Question

基本上，我想要做的是编写重载版本的＆＃34; map＆＃34;对于自定义类，每个版本的映射仅根据传递给它的函数类型而不同。

这就是我想做的事情：

object Test {
  case class Foo(name: String, value: Int)

  implicit class FooUtils(f: Foo) {
    def string() = s"${f.name}: ${f.value}"

    def map(func: Int => Int) = Foo(f.name, func(f.value))
    def map(func: String => String) = Foo(func(f.name), f.value)
  }


  def main(args: Array[String])
  {
    def square(n: Int): Int = n * n
    def rev(s: String): String = s.reverse

    val f = Foo("Test", 3)
    println(f.string)

    val g = f.map(rev)
    val h = g.map(square)
    println(h.string)

  }
}

当然，由于类型擦除，这不会起作用。任何一个版本的地图都可以单独使用，它们的名称可以不同，一切正常。但是，用户只需根据传递给它的函数类型调用正确的map函数，这一点非常重要。

在我寻找如何解决这个问题的过程中，我想到了TypeTags。以下是我提出的代码，我认为它接近正确，但当然不是很有效：

import scala.reflect.runtime.universe._

object Test {
  case class Foo(name: String, value: Int)

  implicit class FooUtils(f: Foo) {
    def string() = s"${f.name}: ${f.value}"

    def map[A: TypeTag](func: A => A) =
      typeOf[A] match {
        case i if i =:= typeOf[Int => Int] => f.mapI(func)
        case s if s =:= typeOf[String => String] => f.mapS(func)
      }                                        
    def mapI(func: Int => Int) = Foo(f.name, func(f.value))
    def mapS(func: String => String) = Foo(func(f.name), f.value)
  }


  def main(args: Array[String])
  {
    def square(n: Int): Int = n * n
    def rev(s: String): String = s.reverse

    val f = Foo("Test", 3)
    println(f.string)

    val g = f.map(rev)
    val h = g.map(square)
    println(h.string)

  }
}

当我尝试运行此代码时，出现以下错误：

[error] /src/main/scala/Test.scala:10: type mismatch;
[error]  found   : A => A
[error]  required: Int => Int
[error]         case i if i =:= typeOf[Int => Int] => f.mapI(func)
[error]                                                      ^
[error] /src/main/scala/Test.scala:11: type mismatch;
[error]  found   : A => A
[error]  required: String => String
[error]         case s if s =:= typeOf[String => String] => f.mapS(func)

func的类型A =＆gt;确实如此。 A，那么如何告诉编译器我在运行时匹配正确的类型？

非常感谢。

Answer 1

在map的定义中，类型A表示函数的参数和结果。 func的类型为A => A。然后你基本上检查一下，例如typeOf[A] =:= typeOf[Int => Int]。这意味着func将为(Int => Int) => (Int => Int)，这是错误的。

使用TypeTag修复此问题的方法之一如下：

def map[T, F : TypeTag](func: F)(implicit ev: F <:< (T => T)) = {
  func match {
    case func0: (Int => Int) @unchecked if typeOf[F] <:< typeOf[Int => Int] => f.mapI(func0)
    case func0: (String => String) @unchecked if typeOf[F] <:< typeOf[String => String] => f.mapS(func0)
  }
}

您必须使用下划线调用它：f.map(rev _)。它可能会引发匹配错误。

有可能改进此代码，但我建议做一些更好的事情。克服重载方法参数上类型擦除的最简单方法是使用DummyImplicit。只需在一些方法中添加一个或多个隐式DummyImplicit参数：

implicit class FooUtils(f: Foo) {
  def string() = s"${f.name}: ${f.value}"

  def map(func: Int => Int)(implicit dummy: DummyImplicit) = Foo(f.name, func(f.value))
  def map(func: String => String) = Foo(func(f.name), f.value)
}

克服方法参数类型擦除的更通用方法是使用the magnet pattern。这是一个有效的例子：

sealed trait MapperMagnet {
  def map(foo: Foo): Foo
}
object MapperMagnet {
  implicit def forValue(func: Int => Int): MapperMagnet = new MapperMagnet {
    override def map(foo: Foo): Foo = Foo(foo.name, func(foo.value))
  }
  implicit def forName(func: String => String): MapperMagnet = new MapperMagnet {
    override def map(foo: Foo): Foo = Foo(func(foo.name), foo.value)
  }
}

implicit class FooUtils(f: Foo) {
  def string = s"${f.name}: ${f.value}"

  // Might be simply `def map(func: MapperMagnet) = func.map(f)`
  // but then it would require those pesky underscores `f.map(rev _)`
  def map[T](func: T => T)(implicit magnet: (T => T) => MapperMagnet): Foo = 
    magnet(func).map(f)
}

这是有效的，因为当您调用map时，隐式magnet在编译时使用完整类型信息解析，因此不会发生擦除，也不需要运行时类型检查。

我认为磁铁版本更干净，作为奖励它不使用任何运行时反射调用，你可以在参数中调用map而不用下划线：f.map(rev)，它也可以' t抛出运行时匹配错误。

<强>更新

现在我想到了，这里的磁铁并不比完整的类型类更简单，但它可能会更好地显示出意图。虽然这是一个鲜明的模式而不是类型类。无论如何，这是使用类型类模式完整性的相同示例：

sealed trait FooMapper[F] {
  def map(foo: Foo, func: F): Foo
}
object FooMapper {
  implicit object ValueMapper extends FooMapper[Int => Int] {
    def map(foo: Foo, func: Int => Int) = Foo(foo.name, func(foo.value))
  }
  implicit object NameMapper extends FooMapper[String => String] {
    def map(foo: Foo, func: String => String) = Foo(func(foo.name), foo.value)
  }
}

implicit class FooUtils(f: Foo) {
  def string = s"${f.name}: ${f.value}"

  def map[T](func: T => T)(implicit mapper: FooMapper[T => T]): Foo =
    mapper.map(f, func)
}

克服高阶函数函数变量的Scala类型擦除

1 个答案: