Scala：使隐式转换 A->B 适用于 Option[A] ->选项[B]

Question

我正在尝试编写一个函数，该函数重新使用对象 A -> 的隐式转换。对象 B 当它们以通用方式包装在 Option 中时，使得 Option[A] ->选项[B] 转换也有效。

我想出的是：

implicit def fromOptionToOption[A, B](from: Option[A])(implicit conversion: (A) => B): Option[B] = from.map(conversion(_))

当我将 Some(..) 分配给一个值时，这有效，但当我分配 Option val 时，这不起作用；请参阅以下控制台输出：

scala> trait T
defined trait T

scala> case class Foo(i: Int) extends T
defined class Foo

scala> case class Bar(i: Int) extends T
defined class Bar

scala> implicit def fromFooToBar(f: Foo):Bar = Bar(f.i)
fromFooToBar: (f: Foo)Bar

scala> implicit def fromBarToFoo(b: Bar):Foo = Foo(b.i)
fromBarToFoo: (b: Bar)Foo

scala> implicit def fromOptionToOption[A, B](from: Option[A])(implicit conversion: (A) => B): Option[B] = from.map(conversion(_))
fromOptionToOption: [A, B](from: Option[A])(implicit conversion: (A) => B)Option[B]

scala> val foo: Option[Foo] = Some(Bar(1))
foo: Option[Foo] = Some(Foo(1))
// THIS WORKS as expected

scala> val fooOpt = Some(Foo(4))
fooOpt: Some[Foo] = Some(Foo(4))

scala> val barOpt2: Option[Bar] = fooOpt
<console>:16: error: type mismatch;
 found   : Some[Foo]
 required: Option[Bar]
       val barOpt2: Option[Bar] = fooOpt
                                  ^
//THIS FAILS.

我并没有真正看到第一次和第二次转换之间的区别。不知何故，它不会调用后者的隐式转换。我想这与类型系统有关，但我还不知道是怎么回事。有什么想法吗？ -阿尔伯特 （我使用的是 scala 2.9.1）

Answer 1

这是线索：

scala> val fooOpt: Option[Bar] = Option(Foo(1))
fooOpt: Option[Bar] = Some(Bar(1))

还有另一个：

scala> implicit def foobar(x: String): Int = augmentString(x).toInt
foobar: (x: String)Int

scala> val y: Option[String] = Option(1)
y: Option[String] = Some(1)

scala> val y: Option[Int] = Option("1")
y: Option[Int] = Some(1)

看起来像是一个合法的奇怪错误。我会弹出一个较小的测试用例并打开一个问题（或在 JIRA 中搜索一个问题）。

顺便说一句：

您可以使用一些范畴论来处理许多不同类型的“Option-ish”事物。

package object fun {
  trait Functor[Container[_]] {
    def fmap[A,B](x: Container[A], f: A => B): Container[B]
  }
  object Functor {
     implicit object optionFunctor extends Functor[Option] {
       override def fmap[A,B](x: Option[A], f: A => B): Option[B] = x map f
     }
     // Note: With some CanBuildFrom magic, we can support Traversables here.
  }
  implicit def liftConversion[F[_], A, B](x: F[A])(implicit f: A => B, functor: Functor[F]): F[B] = 
    functor.fmap(x,f)

}

这有点更高级，因为您将某些类别理论 FP 映射到问题上，但它是根据需要将隐式对话提升到容器中的更通用的解决方案。请注意它们如何通过使用一种隐式对话方法进行链接，该方法采用更有限的隐式参数。

另外，这应该使示例正常工作：

scala> val tmp = Option(Foo(1))
tmp: Option[Foo] = Some(Foo(1))

scala> val y: Option[Bar] = tmp
y: Option[Bar] = Some(Bar(1))

并使您对 Some 的使用更加危险：

scala> val tmp = Some(Foo(1))
tmp: Some[Foo] = Some(Foo(1))

scala> val y: Option[Bar] = tmp
<console>:25: error: could not find implicit value for parameter functor: fun.Functor[Some]
       val y: Option[Bar] = tmp
                            ^

这告诉您方差至关重要，并且与隐式交互。我的猜测是，您遇到了一个非常罕见的、可能难以修复的错误，可以使用其他技术来避免。

Answer 2

您可能没有意识到这一点，但有一个标志：-Xlog-implicits。这就是它所说的：

scala> val barOpt2: Option[Bar] = fooOpt
fromOptionToOption is not a valid implicit value for Some[Foo] => Option[Bar] because:
incompatible: (from: Option[Foo])(implicit conversion: Foo => B)Option[B] does not match expected type Some[Foo] => Option[Bar]
<console>:16: error: type mismatch;
 found   : Some[Foo]
 required: Option[Bar]
       val barOpt2: Option[Bar] = fooOpt
                                  ^

就这样——它不知道 B 必须是什么类型。 0__ 提到这个问题不会发生在不变集合上，这是有道理的。在不变集合中，B 必须完全是 Bar，而对于协变集合，它可以是 Bar 的任何子类型。

那么，为什么 val foo: Option[Foo] = Some(Bar(1)) 有效呢？好吧，也有一个标志...-Ytyper-debug。然而，鉴于极其冗长，不适合弱者。

无论如何，我摇摇晃晃地通过，比较了两种情况下发生的情况，答案相当简单......在这种情况下转换的不是 Option，而是 Bar！请记住，您声明了 Bar => 的隐式转换； Foo，因此它在将结果传递给 Some 之前应用该转换！

Answer 3

它不起作用，因为 Scala 语言规范定义视图如下：

隐式参数和方法还可以定义称为视图的隐式转换。从类型 S 到类型 T 的视图由具有函数类型 S=>T 或 (= >S)=>T 或通过可转换为该类型的值的方法。

fromOptionToOption 不符合这三个类别，因为它采用隐式参数。 编译器似乎找不到目标和源都具有泛型类型的转换器。

定义从 Option[Foo] 到 Option[Bar] 的视图按预期工作。

trait T
case class Foo(i: Int) extends T
case class Bar(i: Int) extends T

object Main {
  implicit def fromFooToBar(f: Foo):Bar = Bar(f.i)
  implicit def fromBarToFoo(b: Bar):Foo = Foo(b.i)
  // implicit def fromOptionToOption[A, B](from: Option[A])(implicit conversion: (A) => B): Option[B] =
  //  from.map(conversion(_))
  implicit def fromOptionFooToOptionBar(o: Option[Foo]): Option[Bar] = o map { foo => foo } 

  def test(): Option[Bar] = {
    val fooOpt = Some(Foo(4))
    val barOpt2: Option[Bar] = fooOpt

    barOpt2
  }
}

println(Main.test)

运行此命令会打印出：

$ scala so.scala
Some(Bar(4))

然而，一切并没有丢失。它不像一般的 Option 到 Option 那么好，但是我们可以做任何可以变成 Bar 到 Option[Bar 的事情] 通过视图绑定。

trait T
case class Foo(i: Int) extends T
case class Bar(i: Int) extends T

object Main {
  implicit def fromFooToBar(f: Foo):Bar = Bar(f.i)
  implicit def fromBarToFoo(b: Bar):Foo = Foo(b.i)
  implicit def fromOptionToOptionBar[A <% Bar](from: Option[A]): Option[Bar] =
    from map { foo => foo }

  def test(): Option[Bar] = {
    val fooOpt = Some(Foo(4))
    val barOpt2: Option[Bar] = fooOpt

    barOpt2
  }
}

println(Main.test)

这是另一种解决方法，可用于一般 Option 到 Option，但需要额外的 .convert 调用：

trait T
case class Foo(i: Int) extends T
case class Bar(i: Int) extends T

case class Converter[A](x: Option[A]) {
  def convert[B](implicit ev: Function1[A, B]): Option[B] = x map { a: A => ev(a) }
}

object Main {
  implicit def optionToConverter[A](x: Option[A]) = Converter(x)
  implicit def fooToBar(x: Foo) = Bar(x.i)

  def test(): Option[Bar] = {
    val fooOpt = Some(Foo(4))
    val barOpt: Option[Bar] = fooOpt.convert
    barOpt
  }
}

println(Main.test)

Answer 4

确实这是一个非常奇怪的问题。我尝试使用 Option 之外的其他类型，结果发现问题在于 Option 在其类型参数中是协变的。这适用于所有情况：

case class A[B](value: B)  // invariant in B

case class X()
case class Y()

implicit def xtoy(x: X): Y = Y()
implicit def ytox(x: Y): X = X()
implicit def movea[U, V](from: A[U])(implicit view: U => V): A[V] =  A[V](from.value)

def test(a: A[Y]) = "ok"
test(A(X()))   // (1)
val f = A(X())
test(f)        // (2)

但是如果我将 A 定义为

case class A[+B](value: B)  // covariant in B

情况 (2) 失败。情况 (1) 总是成功，因为 Scala 在将 X 包装在 A 中之前已经将其转换为 Y。

现在我们知道了问题的来源，你需要等待类型大师来解释为什么这实际上是一个问题......转换仍然有效，你看：

askForY(movea(f))  // succeeds, even with A[+B]

Answer 5

我改进了 @jseureth 答案 并添加了对 Traversable 的支持：

trait Mappable[A, B, C[_]] {
  def apply(f: A => B): C[B]
}

package object app {

  implicit class OptionMappable[A, B, C[X] <: Option[X]](option: C[A]) extends Mappable[A, B, Option] {
    override def apply(f: A => B): Option[B] = option.map(f)
  }

  implicit class TraversableMappable[A, B, C[X] <: Traversable[X]](traversable: C[A])
    (implicit cbf: CanBuildFrom[C[A], B, C[B]]) extends Mappable[A, B, C] {
    override def apply(f: A => B): C[B] = {
      val builder = cbf(traversable)
      builder.sizeHint(traversable)
      builder ++= traversable.map(f)
      builder.result()
    }
  }

  implicit def liftConversion[C[_], A, B](x: C[A])
    (implicit f: A => B, m: C[A] => Mappable[A, B, C]): C[B] = m(x)(f)

}

现在您可以隐式转换选项和可遍历对象：

implicit def f(i: Int): String = s"$i"

val a: Option[String] = Some(1)
val b: Seq[String] = Seq(1, 2, 3)