什么是“上下文绑定”？在斯卡拉？

Question

Scala 2.8 的新功能之一是上下文边界。什么是上下文绑定以及它在哪里有用？

当然，我首先搜索（并发现例如 this），但我找不到任何真正清晰详细的信息。

Answer 1

罗伯特的回答涵盖了上下文边界的技术细节。我将向您解释它们的含义。

在 Scala 中，视图边界 (A <% B) 捕获“可以被视为”的概念（而上限 <: 捕获“是”的概念一个'）。上下文绑定 (A : C) 表示关于类型的“有一个”。您可以将有关清单的示例阅读为“T has a Manifest”。您链接到的有关 Ordered 与 Ordering 的示例说明了其中的差异。方法

def example[T <% Ordered[T]](param: T)

表示该参数可以被视为Ordered。与

def example[T : Ordering](param: T)

它进行比较，表明该参数具有关联的Ordering。

在使用方面，建立约定需要一段时间，但上下文边界优于视图边界（视图边界现已弃用）。一个建议是，当您需要将隐式定义从一个作用域传输到另一个作用域而不需要直接引用它时，首选上下文绑定（对于用于创建数组的 ClassManifest 来说肯定是这种情况） ）。

考虑视图边界和上下文边界的另一种方式是，第一种方式从调用者的作用域传输隐式转换。第二个从调用者的范围传输隐式对象。

Answer 2

您找到这篇文章了吗？它涵盖了数组改进上下文中的新上下文绑定功能。

一般来说，具有上下文绑定的类型参数的形式为[T: Bound]；它被扩展为普通类型参数 T 以及类型 Bound[T] 的隐式参数。

考虑一下 tabulate 方法，它根据应用的结果形成一个数组
给定函数 f，作用于从 0 到给定长度的数字范围。到 Scala 2.7，表格可以是
编写如下：

def tabulate[T](len: Int, f: Int => T) = {
    val xs = new Array[T](len)
    for (i <- 0 until len) xs(i) = f(i)
    xs
}

在 Scala 2.8 中，这不再可能，因为需要运行时信息来创建 Array[T] 的正确表示。需要通过将 ClassManifest[T] 作为隐式参数传递到方法中来提供此信息：

def tabulate[T](len: Int, f: Int => T)(implicit m: ClassManifest[T]) = {
    val xs = new Array[T](len)
    for (i <- 0 until len) xs(i) = f(i)
    xs
}

作为一种简写形式，可以在类型参数上使用上下文绑定相反，使用 T 给出：

def tabulate[T: ClassManifest](len: Int, f: Int => T) = {
    val xs = new Array[T](len)
    for (i <- 0 until len) xs(i) = f(i)
    xs
}

Answer 3

（这是一个括号注释。首先阅读并理解其他答案。）

上下文边界实际上概括了视图边界。

因此，给定用 View Bound 表达的代码：

scala> implicit def int2str(i: Int): String = i.toString
int2str: (i: Int)String

scala> def f1[T <% String](t: T) = 0
f1: [T](t: T)(implicit evidence$1: (T) => String)Int

这也可以用 Context Bound 表达，并借助表示从类型 F 到类型 T 的函数的类型别名。

scala> trait To[T] { type From[F] = F => T }           
defined trait To

scala> def f2[T : To[String]#From](t: T) = 0       
f2: [T](t: T)(implicit evidence$1: (T) => java.lang.String)Int

scala> f2(1)
res1: Int = 0

上下文绑定必须与 * => 类型的类型构造函数一起使用。 *。然而，类型构造函数 Function1 的类型是 (*, *) =>; *。类型别名的使用部分应用了 String 类型的第二个类型参数，生成正确类型的类型构造函数以用作上下文绑定。

有一项提议允许您直接在 Scala 中表达部分应用的类型，而无需在特征中使用类型别名。然后你可以写：

def f3[T : [X](X => String)](t: T) = 0 

Answer 4

这是另一个括号注释。

如 Ben 指出，上下文绑定表示类型参数和类型类之间的“has-a”约束。换句话说，它表示存在特定类型类的隐式值的约束。

当使用上下文绑定时，人们通常需要显示该隐式值。例如，给定约束 T : Ordering，人们通常需要满足该约束的 Ordering[T] 实例。 如此处所示，可以使用implicitly 方法或稍微有用的context 方法来访问隐式值：

def **[T : Numeric](xs: Iterable[T], ys: Iterable[T]) = 
   xs zip ys map { t => implicitly[Numeric[T]].times(t._1, t._2) }

或者

def **[T : Numeric](xs: Iterable[T], ys: Iterable[T]) =
   xs zip ys map { t => context[T]().times(t._1, t._2) }