Скала:Выполнение неявного преобразования A-> B для параметра [A] -> Option[B]
-
27-10-2019 - |
Вопрос
Я пытаюсь написать функцию, которая повторно использует неявные преобразования, которые у меня есть для объекта A -> Объекта B, когда они обернуты в Option общим способом, чтобы преобразования Option [A] -> Option [B] также работали.
То, что я придумал, это:
implicit def fromOptionToOption[A, B](from: Option[A])(implicit conversion: (A) => B): Option[B] = from.map(conversion(_))
Это работает, когда я присваиваю некоторому (..) значению, но не когда я присваиваю параметру 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)
Решение
Вот подсказка:
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)
Выглядит как законно странный ошибка. Я бы открыл меньший тестовый пример и открыл проблему (или искал один в Джире).
Как в сторону:
Вы можете использовать некоторую теорию категорий, чтобы справиться с множеством различных типов вещей «опцион».
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
^
Это говорит вам это дисперсия имеет решающее значение и взаимодействует с последствиями. Я предполагаю, что вы столкнулись с очень редкой, вероятно, трудно исправить ошибку, которую можно избежать, используя другие методы.
Другие советы
Вы можете не знать об этом, но для этого есть флаг: -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
!
Это не работает, потому что спецификация языка Scala определяет представление следующим образом:
Неявные параметры и методы также могут определить неявные конверсии, вызванные Просмотры. Анкет Вид из типа С печатать Т определяется неявным значением, которое имеет тип функции 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)
Действительно, это очень странная проблема. Я попытался использовать другой тип, чем 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
.
Теперь, когда мы знаем проблему источник, вам нужно ждать, пока он объяснит гуру типа Почему Это на самом деле проблема ... конверсия все еще действительна, вы видите:
askForY(movea(f)) // succeeds, even with A[+B]
Я улучшился @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)