1

我很沮丧，因为我不知道如何处理我的类型安全代码和使用多态性和继承的外部 API 之间的边界。

我的流程如下。我收到 Class1 的条目值，我用它从外部服务中检索 Class2 的项目。然后我需要对两者进行子类型化以获得它们的运行时类型并解析隐式。但是，由于类型擦除，这是不可能的。

trait Typeclass1[A, B] {
  def hash(a: A, b: B): String
}

trait Typeclass2[A, B] {
  def hash(a: A, b: B): B
}

trait Entity

trait MyEntity1

trait MyEntity2

object db {
  def load(any:Any):Entity = new Entity{}
}


class MyClass[T](t: T, a: String) {

  def apply(timeout: Long): T = {
    val loadFromDB = db.load(t)
    loadFromDB match {
      case myEntity1: MyEntity1 => applyTypeSafe(myEntity1)
      case myEntity2: MyEntity2 => applyTypeSafe(myEntity2)
    }
  }


  def applyTypeSafe[C](c: C)(implicit typeClass1: Typeclass1[C, T], typeclass2: Typeclass2[C, T]): (String, T) = {
    typeClass1.hash(c, t) -> typeclass2.hash(c, t)
  }
}

我想知道开发这个前沿层的正确模式是什么。我可能需要为我的类型类提供一个类型构造函数，以便在 MyClass 的构造函数中提供......或者完全重新思考我的设计？

4

1 回答 1

0

如果在MyEntity和的范围内添加隐式定义，则不会出现编译问题MyEntity2。例如，下面的代码编译正常：

trait Typeclass1[A, B] { def hash(a: A, b: B): String }
trait Typeclass2[A, B] { def hash(a: A, b: B): B }

trait Entity
trait MyEntity1 extends Entity
trait MyEntity2 extends Entity

object db { def load(any:Any):Entity = new Entity {} }

implicit def MyEntity1HasTypeclass1[T] = new Typeclass1[MyEntity1, T] {
  def hash(a: MyEntity1, t: T) = a.toString
}
implicit def MyEntity1HasTypeclass2[T] = new Typeclass2[MyEntity1, T] {
  def hash(a: MyEntity1, t: T) =t
}

class MyClass[T](t: T, a: String) {
  def apply(timeout: Long): (String, T) = {
    db.load(t) match {
      case myEntity1: MyEntity1 => applyTypeSafe(myEntity1)
    }
  }
  def applyTypeSafe[C](c: C)(implicit typeClass1: Typeclass1[C, T], 
                                      typeclass2: Typeclass2[C, T]): (String, T) = {
    typeClass1.hash(c, t) -> typeclass2.hash(c, t)
  }
}
于 2013-06-08T09:00:28.947 回答