Question

是否可以将上下文边界语法快捷方式与更高的kinded-types一起使用？

trait One { def test[W   : ClassManifest]: Unit } // first-order ok
trait Two { def test[W[_]: ClassManifest]: Unit } // not possible??
trait Six { def test[W[_]](implicit m: ClassManifest[W[_]]): Unit } // hmm...

Answer 1

是的，但是，你的上下文绑定类型必须具有更高的kinded类型参数（ClassManifest不会）。

scala> trait HKTypeClass[CC[_]]
defined trait HKTypeClass

scala> implicit def listHKTC = new HKTypeClass[List] {}
listHKTC: java.lang.Object with HKTypeClass[List]

scala> def frob[CC[_] : HKTypeClass] = implicitly[HKTypeClass[CC]]
frob: [CC[_]](implicit evidence$1: HKTypeClass[CC])HKTypeClass[CC]

scala> frob[List]
res0: HKTypeClass[List] = $anon$1@13e02ed

<强>更新

可以使用类型别名来允许更高级别的类型参数受一阶上下文绑定类型的限制。我们使用类型别名作为类型级函数来从一阶类型中创建一个更高级的类型。对于ClassManifest，它可以像这样，

scala> type HKClassManifest[CC[_]] = ClassManifest[CC[_]]
defined type alias HKClassManifest

scala> def frob[CC[_] : HKClassManifest] = implicitly[HKClassManifest[CC]]         
test: [CC[_]](implicit evidence$1: HKClassManifest[CC])HKClassManifest[CC]

scala> frob[List]                                                       
res1: HKClassManifest[List] = scala.collection.immutable.List[Any]

请注意，在类型别名CC [_]的右侧是一阶类型...这里的下划线是通配符。因此，它可以用作ClassManifest的类型参数。

<强>更新

为了完整性，我应该注意，可以使用类型lambda

来内联类型别名

scala> def frob[CC[_] : ({ type λ[X[_]] = ClassManifest[X[_]] })#λ] = implicitly[ClassManifest[CC[_]]]     
frob: [CC[_]](implicit evidence$1: scala.reflect.ClassManifest[CC[_]])scala.reflect.ClassManifest[CC[_]]

scala> frob[List]
res0: scala.reflect.ClassManifest[List[_]] = scala.collection.immutable.List[Any]

Answer 2

请注意，implicitly[ClassManifest[List[_]]]是implicitly[ClassManifest[List[T] forSome {type T}]]的缩写。

这就是它工作的原因：ClassManifest期望一个正确的类型参数，List[T] forSome {type T}是一个正确的类型，但List是一个类型构造函数。（请参阅What is a higher kinded type in Scala?了解“适当”等的定义。）

要使ClassManifest[List[String]]和ClassManifest[List]都有效，我们需要以某种方式重载ClassManifest版本，这些版本采用不同类型的类型参数，例如：

class ClassManifest[T] // proper type
class ClassManifest[T[_]] // type constructor with one type parameter
class ClassManifest[T[_, _]] // type constructor with two type parameters
// ... ad nauseam

（在学术笔记中，“正确”的方法是允许抽象的类型：

    class ClassManifest[T : K][K]

    implicitly[ClassManifest[String]] // --> compiler infers ClassManifest[String][*]
    implicitly[ClassManifest[List]] // --> compiler infers ClassManifest[List][* -> *]

）

具有更高kinded类型的上下文边界快捷方式

2 个答案: