Qu'est-ce qu'un «contexte lié» dans Scala?

L'une des nouvelles fonctionnalités de Scala 2.8 sont les limites de contexte. Qu'est-ce qu'un contexte lié et où est-il utile?

Bien sûr, j'ai cherché en premier (et trouvé par exemple ceci ) mais je n'ai pas trouvé d'informations vraiment claires et détaillées.

Avez-vous trouvé cet article ? Il couvre la nouvelle fonctionnalité liée au contexte, dans le contexte des améliorations des tableaux.

En général, un paramètre de type avec un contexte lié est de la forme [T: Bound]; il est développé en paramètre de type simple Tavec un paramètre implicite de type Bound[T].

Considérons la méthode tabulatequi forme un tableau à partir des résultats de l'application d'une fonction f donnée sur une plage de nombres de 0 jusqu'à une longueur donnée. Jusqu'à Scala 2.7, le tableau pouvait être écrit comme suit:

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

Dans Scala 2.8, cela n'est plus possible, car les informations d'exécution sont nécessaires pour créer la bonne représentation de Array[T]. Il faut fournir ces informations en passant a ClassManifest[T]dans la méthode en tant que paramètre implicite:

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
}

En tant que forme abrégée, un contexte lié peut être utilisé sur le paramètre type à la Tplace, donnant:

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
}

La réponse de Robert couvre les détails techniques des limites de contexte. Je vais vous donner mon interprétation de leur signification.

Dans Scala, un View Bound ( A <% B) capture le concept de «peut être vu comme» (alors qu'une borne supérieure <:capture le concept de «est un»). Un contexte lié ( A : C) dit «a un» sur un type. Vous pouvez lire les exemples sur les manifestes comme " Ta un Manifest". L'exemple auquel vous avez lié about Orderedvs Orderingillustre la différence. Une méthode

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

dit que le paramètre peut être vu comme un Ordered. Comparer avec

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

qui dit que le paramètre a un associé Ordering.

En termes d'utilisation, il a fallu un certain temps pour que les conventions soient établies, mais les limites de contexte sont préférées aux limites de vue (les limites de vue sont maintenant obsolètes ). Une suggestion est qu'un contexte lié est préféré lorsque vous devez transférer une définition implicite d'une portée à une autre sans avoir besoin de s'y référer directement (c'est certainement le cas pour le ClassManifestutilisé pour créer un tableau).

Une autre façon de penser aux limites de vue et aux limites de contexte est que la première transfère les conversions implicites de la portée de l'appelant. Le second transfère les objets implicites de la portée de l'appelant.

(Ceci est une note entre parenthèses. Lisez et comprenez d'abord les autres réponses.)

Les limites de contexte généralisent en fait les limites de vue.

Donc, étant donné ce code exprimé avec un 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

Cela pourrait également être exprimé avec un Contexte Bound, à l'aide d'un alias de type représentant des fonctions de type Fen type 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

Un contexte lié doit être utilisé avec un constructeur de type de type * => *. Cependant, le constructeur de type Function1est du genre (*, *) => *. L'utilisation de l'alias de type applique partiellement le second paramètre de type avec le type String, ce qui donne un constructeur de type du type correct à utiliser en tant que contexte lié.

Il existe une proposition pour vous permettre d'exprimer directement des types partiellement appliqués dans Scala, sans utiliser l'alias de type à l'intérieur d'un trait. Vous pourriez alors écrire:

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

Ceci est une autre note entre parenthèses.

Comme Ben l'a souligné , un contexte lié représente une contrainte "has-a" entre un paramètre de type et une classe de type. En d'autres termes, cela représente une contrainte qu'une valeur implicite d'une classe de type particulière existe.

Lors de l'utilisation d'un contexte lié, il faut souvent faire apparaître cette valeur implicite. Par exemple, étant donné la contrainte T : Ordering, on aura souvent besoin de l'instance de Ordering[T]qui satisfait la contrainte. Comme démontré ici , il est possible d'accéder à la valeur implicite en utilisant la implicitlyméthode ou une méthode légèrement plus utile context:

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

ou

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