Question

我正在为Scala开发servant-server端口。我们的想法是使用类型类分辨率来归纳地构建可以处理请求的函数。我遇到了一些我无法弄清楚的奇怪的推理问题。

object Servant {                                                                     

  class :>[Path, A]                                                                  

  trait HasServer[A] {                                                               
    type ServerT                                                                     

    def route(a: ServerT): String                                                    
  }                                                                                  

  implicit val unitServer = new HasServer[Unit] {                                    
    type ServerT = String                                                            

    def route(str: ServerT): String = str                                            
  }                                                                                  

  implicit def subServer[A, Sub](implicit sub: HasServer[Sub]) = new HasServer[A :> Sub] {
    type ServerT = A => sub.ServerT                                                  

    def route(handler: ServerT): String = "handler"                                  
  } 

}

有了上述内容，以下内容无法编译：

val foo = implicitly[HasServer[Int :> Unit]]
implicitly[=:=[Int => String, foo.ServerT]]

错误是：

servant.scala:33: error: 
Cannot prove that Int => String =:= Main.$anon.Servant.foo.ServerT.

但是，如果我通过以下方式直接实例HasServer[Int :> Unit]，将编译：

  val foo = new HasServer[Int :> Unit] {                                             
    type ServerT = Int => unitServer.ServerT                                         

    def route(handler: ServerT): String = handler(10)                                
  }

如何编译？谢谢！

Answer 1

问题在于implicitly ...

的定义

def implicitly[T](implicit e: T) = e

implicitly[T]只会给你一个输入T的值，绝不会更精确。在上面的例子中，HasServer[Int :> Unit]至关重要地使成员类型ServerT不受约束。

这通常通过定义每种类型的伴随对象apply方法来保留所需的细化，例如，

object HasServer {
  def apply[T](implicit hs: HasServer[T]):
    HasServer[T] { type ServerT = hs.ServerT } = hs
}

这里的结果类型有点笨拙，所以将它与＆＃34; Aux＆＃34;相结合也很常见。图案，

object HasServer {
  type Aux[T, S] = HasServer[T] { type ServerT = S }
  def apply[T](implicit hs: HasServer[T]): Aux[T, hs.ServerT] = hs
}

在任何情况下都可能派上用场。

我们可以看到它对REPL的推断类型的区别，

scala> implicitly[HasServer[Int :> Unit]]
res0: Servant.HasServer[Servant.:>[Int,Unit]] = ...

scala> HasServer[Int :> Unit]
res1: Servant.HasServer[Servant.:>[Int,Unit]]{type ServerT = Int => String} = ...

此细化将被推断为val定义的类型，因此现在您将获得所需的结果，

scala> val foo = HasServer[Int :> Unit]
foo: Servant.HasServer[Servant.:>[Int,Unit]]{type ServerT = Int => String} = ...

scala> implicitly[=:=[Int => String, foo.ServerT]]
res2: =:=[Int => String,foo.ServerT] = <function1>

有许多方法可以改进implicitly的定义以避免此问题。以下是最直接的参考类型，

def implicitly[T <: AnyRef](implicit t: T): t.type = t

如果literal types已启用，我们可以删除<: AnyRef边界并为所有类型定义

def implicitly[T](implicit t: T): t.type = t

shapeless提供了一个the[T]运算符，它通过宏运行与后者类似。

Scalac无法推断出归纳建立的路径依赖型

1 个答案: