如何在 Scala 的类型类中使用依赖类型？

Question

我想为几个不同的C -s 定义一对类型（A 中的B 和B）。例如，A=String 和 B=View 代表 C=View1（在隐式对象 DepInstanceView1 中定义）。然后我想在类型类定义中使用这些类型级别的依赖关系。

如何定义一个类型类实例（此处为 ServerSideFun[View1]），它具有具有依赖输入和返回类型（此处定义为 DepInstanceView1）的函数？

换句话说，我想有一个来自C -> (A,B) 的类型级函数（这里在DepInstanceView1 中定义了一个这样的类型级映射）并在类型类声明中使用这个类型级函数（这里@ 987654336@) 及其实例（此处为View1Conv）。

有人可以建议一种方法吗？

或者如何修改下面的代码来编码这样的类型级别，类型类中f（正如trait ServerSideFun[C]所暗示的那样）的类型依赖约束？

我这样做的尝试以编译器错误告终：

source_file.scala:47: error: type mismatch;
 found   : Int(42)
 required: B
    def f[A, B] (a:A)(implicit aux:Dep.Aux[View1,A,B]):B = 42
                                                           ^
one error found

代码示例：

下面的代码可以在这里在线执行：http://rextester.com/GYWW78561

object Rextester extends App {
    println("Hello, World!3")
 }

trait Dep[C]{
  type A
  type B
}

trait View1
trait View2


object Dep{

  type Aux[C0, A0, B0]=  Dep[C0] {type A=A0; type B= B0}

  implicit object DepInstanceView1  extends  Dep[View1] {
    type A=String
    type B=Int
  } 
}

trait ServerSideFun[C]
{
   def f[A,B] (a:A)(implicit aux:Dep.Aux[C,A,B]):B
}

object ServerSideFun {
  implicit object View1Conv extends ServerSideFun[View1]{
    def f[A, B] (a:A)(implicit aux:Dep.Aux[View1,A,B]):B = 42
  }
}

编辑：

我更新了代码以澄清意图：http://rextester.com/YVBV30174

这是：

1) 定义几个View-s：

• trait View1
• trait View2

2) 为每个View-s 定义一个单独的类型级映射View -> (A,B)，例如：

• View1-> (String,Int) in DepInstanceView1
• View2-> (String,String) 在DepInstanceView2

3) 可以有多个不同的类型类ServerSideFun 实现，例如：

• object ServerSideFun中的一个
• object ServerSideFunAlternativeImplementation 中的另一个。

本质上：

• 类型类ServerSideFun[C] 的所有 实例应遵循object Dep 中定义的类型级别映射View -> (A,B)。
• 因此，对于给定的View，函数f 的每个定义（实现）都必须采用A 类型的输入参数并返回B 类型的结果。

代码如下：

object Rextester extends App {
    println("Hello, World!3")
 }

trait Dep[C]{
  type A
  type B
}

trait View1
trait View2


object Dep{

  type Aux[C0, A0, B0]=  Dep[C0] {type A=A0; type B= B0}

  implicit object DepInstanceView1  extends  Dep[View1] {
    type A=String
    type B=Int
  } 

  implicit object DepInstanceView2  extends  Dep[View2] {
    type A=String
    type B=String
  } 
}

trait ServerSideFun[C]
{
   def f[A,B] (a:A)(implicit aux:Dep.Aux[C,A,B]):B
}


object ServerSideFun {
  implicit object View1Conv extends ServerSideFun[View1]{
    def f[A, B] (a:A)(implicit aux:Dep.Aux[View1,A,B]):B = 42
  }

  implicit object View2Conv extends ServerSideFun[View2]{
    def f[A, B] (a:A)(implicit aux:Dep.Aux[View2,A,B]):B = "42"
  }
}



object ServerSideFunAlternativeImplementation {
  implicit object View1Conv extends ServerSideFun[View1]{
    def f[A, B] (a:A)(implicit aux:Dep.Aux[View1,A,B]):B = 43
  }

  implicit object View2Conv extends ServerSideFun[View2]{
    def f[A, B] (a:A)(implicit aux:Dep.Aux[View2,A,B]):B = "43"
  }

}

Answer 1

如果ServerSideFun[C] 应该包含针对某些类型A 和B 的函数f: A => B 的实现，那么ServerSideFun[C] 显然必须知道A 和B 是什么类型，否则它将不得不从来自特征ServerSideFun[C] 之外的一些片段组成函数f。但是我们可以将type A 和type B 包含在ServerSideFun[C] 中，然后完全删除Dep[C]：

trait View1
trait View2

trait ServerSideFun[C]{
  type A
  type B
  def f(a: A): B
}

object ServerSideFun {
  implicit object View1Conv extends ServerSideFun[View1] {
    type A = String
    type B = Int
    def f(a: String): Int = 42
  }
}

如果需要，可以重新引入Dep[C]，然后将Dep[C]扩展为ServerSideFun[C]：

trait Dep[C]{
  type A
  type B
}

trait View1
trait View2

object Dep {
  trait DepInstanceView1 extends Dep[View1] {
    type A = String
    type B = Int
  } 
}

trait ServerSideFun[C] extends Dep[C] {
  def f(a: A): B
}

object ServerSideFun {
  implicit object View1Conv 
    extends ServerSideFun[View1] 
    with Dep.DepInstanceView1 {

    def f(a: String): Int = 42
  }
}

如果f 不是完全通用函数的“自然组合”，那么在某些时候你将不得不在A 和B 已知的上下文中写下f 的主体。在正文中写下具体的42，但同时从外部将完全未指定的A 和B 带入Dep.Aux[View1,A,B] 是行不通的。