Question

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

我的流程如下。我收到类Class1的入口值，我用它从外部服务检索Class 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的构造函数...或者可能完全重新考虑我的设计？

Answer 1

如果在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)
  }
}

如何处理类型类和继承使用之间的边界

1 个答案: