scala - Scala 中丢失类型信息和类型类实现

Question

我有以下关系:

trait Bar[I <: Foo] { def doSomething(...) }
object Doer { def apply[I <: Foo](...)(implicit ev: Bar[I]) = ev.doSomething(...) } 

trait Foo

case class A(...) extends Foo
object A { implicit object Something extends Bar[A] }

case class B(...) extends Foo
object B { implicit object SomethingElse extends Bar[B] }

我有以下情况:

val xs: List[Foo] = ...
xs.map(x => Doer(x)) // implicit not found since no implementation for type Foo.

不使用case，因为它将打破为 future 可扩展性而拥有类型类的整个想法。

我需要做什么才能处理这种情况？

Answer 1

从问题中可以看出两个主要困难

1. 隐式由编译器解决。当您有抽象类型但需要具体隐式时，您必须以某种方式将预缓存的类型类实例携带到结果代码中。
2. 子类型化抽象与类型类风格的抽象关系很糟糕。将这些结合起来需要很多妥协和解决方法。

但是想象一下我们有这样的定义

trait Bar[+I] {def doSomething[J >: I](x: J): String}
object Doer {
  def apply[I <: Foo](el: I)(implicit ev: Bar[I]) = ev.doSomething(el)
}

trait Foo

case class A() extends Foo
object A {
  implicit object Something extends Bar[A] {
    def doSomething[X >: A](el: X) = "do A"
}
}

case class B() extends Foo
object B {
  implicit object SomethingElse extends Bar[B] {
     def doSomething[X >: B](el: X) = "do B"
  }
}

我们也许可以创建一些数据类型来保留已解析的隐式:

case class MemoTC[+Value, TC[+_]](value: Value)(implicit tc: TC[Value]) {
  def withTC[Result](action: (Value) ⇒ TC[Value] ⇒ Result): Result =
    action(value)(tc)
} 

现在你可以编写奇怪的代码了

val xs: List[MemoTC[Foo, Bar]] = List(MemoTC(A()), MemoTC(B()))
xs.map(x => x.withTC( x ⇒ implicit bar ⇒ Doer(x) ))

如果您想保持类型类不变，也可以在存在类型的帮助下修改此示例:

trait Bar[I] {def doSomething(x: I): String}
object Doer {
  def apply[I <: Foo](el: I)(implicit ev: Bar[I]) = ev.doSomething(el)
}

trait Foo

case class A() extends Foo
object A {
  implicit object Something extends Bar[A] {
    def doSomething(el: A) = "do A"
  }
}

case class B() extends Foo
object B {
  implicit object SomethingElse extends Bar[B] {
    def doSomething(el: B) = "do B"
  }
}

abstract class MemoTC[Abstract, TC[_]] {
  type Concrete <: Abstract
  val value: Concrete
  val inst: TC[Concrete]

  def withTC[Result](action: (Concrete) ⇒ TC[Concrete] ⇒ Result): Result =
    action(value)(inst)
}

object MemoTC {
  def apply[A, C <: A, TC[_]](v: C)(implicit tc: TC[C]) = new MemoTC[A, TC] {
    type Concrete = C
    val value = v
    val inst = tc
  }
}


val xs: List[MemoTC[Foo, Bar]] = List(MemoTC(A()), MemoTC(B()))
xs.map(x => x.withTC(x ⇒ implicit bar ⇒ Doer(x)))