Scala: использование неявного преобразования A-> B для опции [A] → Option [B]

Ответ 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).

В стороне:

Вы можете использовать некоторую теорию категорий для обработки множества различных типов "опциональных" вещей.

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
                            ^

Это говорит о том, что отклонение имеет решающее значение и взаимодействует с имплицитами. Я предполагаю, что вы столкнулись с очень редкой, вероятно, трудно исправить ошибку, которой можно избежать с помощью других методов.

Ответ 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!

Ответ 3

Действительно, это очень странная проблема. Я попытался использовать другой тип, чем 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 в Y, прежде чем обернуть его в A.

Теперь, когда мы знаем проблему source, вам нужно подождать, пока гуру типа объяснит почему, это на самом деле проблема... Преобразование по-прежнему действует, вы видите:

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

Ответ 4

Это не работает, потому что спецификация языка 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)

Ответ 5

Я улучшил @jseureth answer и добавил поддержку 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)