Scala - 具有泛型类型的函数映射

Question

如何创建字符串映射到具有泛型类型的函数？例如，我希望能够在编译时创建地图：

var unaryFunctionMap: Map[String, Any => Any] = Map[String, Any => Any]()

然后我想添加可以接受String、Int、Double 等类型组合的函数。可能以如下方式：

unaryFunctionMap += ("Abs" -> Functions.add)
unaryFunctionMap += ("Neg" -> Functions.neg)
unaryFunctionMap += ("Rev" -> Functions.rev)

我在 Functions 类中实现实际功能的地方：

def abs[T: Numeric](value: T)(implicit n: Numeric[T]): T = {
  n.abs(value)
} 

def neg[T: Numeric](value: T)(implicit n: Numeric[T]): T = {
  n.negate(value)
}

def rev(string: String): String = {
  string.reverse
}

所以，abs 和 neg 都允许 Numeric 类型，而 rev 只允许 Strings。当我使用地图时，我希望能够在必要时指定类型。像这样的：

(unaryFunctionMap.get("abs").get)[Int](-45)

或者，如果这不可能，

(unaryFunctionMap.get("abs").get)(Int, -45)

如何修改我的代码以实现此功能？

Answer 1

将函数存储为Any => Any 的问题在于，函数的参数类型是逆变的，但返回类型是协变的，因此Int => Int 不是Any => Any 的子类型。你可以使用存在类型来解决这个问题，但这仍然不会给你类型安全。

作为一种解决方案，您可能希望使用Map[Type, Map[String, _ => _]] 并确保放入映射的每个条目仅使用相应类型的函数。

以下是一个草图，而不是一个明确的解决方案；我对类型标签的了解不足以保证性能的正确性或原因（这需要反射才能工作）。

import scala.reflect.runtime.universe._

class UnaryFunctionMap {
  private var internal: Map[Type, Map[String, _ => _]] = Map.empty

  def +=[A : TypeTag] (key: String, function: A => A): Unit ={
    val a: Map[String, _ => _] = internal.getOrElse(typeOf[A], Map.empty)
    // Because of the TypeTag A we make sure that only functions A => A are put into the map where Type == typeOf[A]
    internal += typeOf[A] -> (a + (key -> function))
  }

  def get[A: TypeTag](key: String): Option[A => A] = internal.get(typeOf[A]).flatMap(_.get(key).map(_.asInstanceOf[A => A])) 
}

由于方法 get 中的显式转换，这可能是不安全的，因此我们需要确保正确填充 internal。

示例用法：

object UnaryFunctionMap {
  def main(args: Array[String]) {
    val neg: Int => Int = i => -i
    val rev: String => String = s => s.reverse

    val map = new UnaryFunctionMap
    map += ("neg", neg)
    map += ("rev", rev)

    println(map.get[Int]("neg").map(_.apply(-45)))            // Some(45)
    println(map.get[String]("neg").map(_.apply("reverto")))   // None
    println(map.get[Int]("rev").map(_.apply(-45)))            // None
    println(map.get[String]("rev").map(_.apply("reverto")))   // Some(otrever)
  }
}

请注意，对于任意类型的A，我假设函数是A => A。如果您希望函数为任意A 和B 的A => B，则需要将第二种类型添加到地图并相应地更新这两种方法。

Answer 2

听起来你想要的是类型类。特别是对于数字，您实际上不需要自定义类型类，因为 Scala 已经提供了它们。如果您不想在所有类型之间共享行为，您只需进行扩充即可。

object Test {
    // In this case you can probably even specialize to avoid unboxing.
    implicit class NumericOps[T : Numeric](val obj: T) extends AnyVal {
      def whatever(x: T): T = obj.add(x) // for instance
    }

}

那么对于所有数字，您都可以免费获得增强：

import Test._
5.whatever(6)// = 11

只需对字符串重复相同的模式，这是我的库模式的正常皮条客。如果您想对一堆不相关的类型实现相同的操作，请查看类型类。