Scala: Обеспечение работы неявного преобразования A-> B для Option [A] -> Option [B]

Я пытаюсь написать функцию, которая повторно использует неявные преобразования, которые у меня есть для Объект A -> Объект B, когда они заключены в Option обычным способом, так что преобразования Option [A] -> Option [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)