Ce sont de type lambdas en Scala et quels sont leurs avantages?

Type lambdas sont essentiels un peu de temps lorsque vous travaillez avec plus de kinded types.

Considérons un exemple simple de définir une monade pour le droit de projection Soit[A, B]. La monade typeclass ressemble à ceci:

trait Monad[M[_]] {
  def point[A](a: A): M[A]
  def bind[A, B](m: M[A])(f: A => M[B]): M[B]
}

Maintenant, est un type de constructeur à deux arguments, mais de mettre en œuvre Monade, vous avez besoin de lui donner un constructeur de type d'un argument. La solution pour cela est d'utiliser un type lambda:

class EitherMonad[A] extends Monad[({type λ[α] = Either[A, α]})#λ] {
  def point[B](b: B): Either[A, B]
  def bind[B, C](m: Either[A, B])(f: B => Either[A, C]): Either[A, C]
}

Ceci est un exemple de nourrissage dans le type de système que vous avez au curry le type de, tel que, lorsque vous souhaitez créer une instance de EitherMonad, vous devez spécifier l'un des types, l'autre de cours est fourni au moment de l'appel du point ou de la lier.

Le type lambda truc exploite le fait qu'un bloc vide dans une position crée un anonyme, un type de structure. Nous utilisons ensuite la # syntaxe pour obtenir un type de membre.

Dans certains cas, vous pouvez avoir besoin de plus sophistiqué de type lambdas qui sont une douleur à écrire sur la ligne. Voici un exemple de mon code à partir d'aujourd'hui:

//types X and E are defined in an enclosing scope
private[iteratee] class FG[F[_[_], _], G[_]] {
  type FGA[A] = F[G, A]
  type IterateeM[A] = IterateeT[X, E, FGA, A] 
}

Cette classe existe exclusivement afin que je puisse utiliser un nom comme FG[F, G]#IterateeM pour désigner le type de la IterateeT monade spécialisé pour certains transformateur version d'un deuxième monade qui est spécialisé pour la troisième monade. Lorsque vous commencez à pile, ces sortes de constructions devenu très nécessaire. Je n'ai jamais instancier un FG, bien sûr; il est juste là comme un hack de me laisser exprimer ce que je veux dans le système de type.

De mettre les choses dans leur contexte: Cette réponse a été posté dans un autre thread. Vous êtes le voir ici, car les deux fils ont été fusionnés. La question de l'instruction dans le dit fil a été comme suit:

La façon de résoudre ce type de définition: Pure[({type ?[a]=(R, a)})#?] ?

Quelles sont les raisons de l'utilisation d'une telle construction?

Ciselée vient de scalaz bibliothèque:

trait Pure[P[_]] {
  def pure[A](a: => A): P[A]
}

object Pure {
  import Scalaz._
//...
  implicit def Tuple2Pure[R: Zero]: Pure[({type ?[a]=(R, a)})#?] = new Pure[({type ?[a]=(R, a)})#?] {
  def pure[A](a: => A) = (Ø, a)
  }

//...
}

---

Réponse:

trait Pure[P[_]] {
  def pure[A](a: => A): P[A]
}

Un trait de soulignement dans les cases après P implique que c'est un type constructeur prend un type et retourne un autre type. Exemples de type de constructeurs avec ce genre: List, Option.

Donner List un Int, un type de béton, et il vous donne List[Int], un autre type de béton. Donner List un String et il vous donne List[String]. Etc.

Donc, List, Option peut être considéré comme le type de fonctions d'arité 1. Officiellement nous dire, qu'ils ont une sorte * -> *. L'astérisque indique un type de.

Maintenant Tuple2[_, _] est un constructeur de type avec l'aimable (*, *) -> * c'est à dire vous avez besoin de lui donner deux types d'obtenir un nouveau type.

Depuis leurs signatures ne correspondent pas, vous ne pouvez pas remplacer Tuple2 pour P. Ce que vous devez faire est de appliquer partiellement Tuple2 sur l'un de ses arguments, ce qui va nous donner un constructeur de type avec l'aimable * -> *, et nous pouvons substituer pour P.

Malheureusement Scala n'a pas de syntaxe particulière pour l'application partielle de type constructeurs, et ainsi nous avons du avoir recours à la monstruosité du type lambda. (Ce que vous avez dans votre exemple.) Ils sont appelés parce qu'ils sont analogues aux expressions lambda qui existent au plan de la valeur.

L'exemple suivant qui pourraient vous aider:

//VALUE LEVEL

//foo has signature: (String, String) => String
scala> def foo(x: String, y: String): String = x + " " + y
foo: (x: String, y: String)String

//world wants a parameter of type String => String    
scala> def world(f: String => String): String = f("world")
world: (f: String => String)String

//So we use a lambda expression that partially applies foo on one parameter
//to yield a value of type String => String
scala> world(x => foo("hello", x))
res0: String = hello world


//TYPE LEVEL

//Foo has a kind (*, *) -> *
scala> type Foo[A, B] = Map[A, B]
defined type alias Foo

//World wants a parameter of kind * -> *
scala> type World[M[_]] = M[Int]
defined type alias World

//So we use a lambda lambda that partially applies Foo on one parameter
//to yield a type of kind * -> *
scala> type X[A] = World[({ type M[A] = Foo[String, A] })#M]
defined type alias X

//Test the equality of two types. (If this compiles, it means they're equal.)
scala> implicitly[X[Int] =:= Foo[String, Int]]
res2: =:=[X[Int],Foo[String,Int]] = <function1>

Edit:

Plus de valeur niveau et le type de niveau de parallels.

//VALUE LEVEL

//Instead of a lambda, you can define a named function beforehand...
scala> val g: String => String = x => foo("hello", x)
g: String => String = <function1>

//...and use it.
scala> world(g)
res3: String = hello world

//TYPE LEVEL

//Same applies at type level too.
scala> type G[A] = Foo[String, A]
defined type alias G

scala> implicitly[X =:= Foo[String, Int]]
res5: =:=[X,Foo[String,Int]] = <function1>

scala> type T = World[G]
defined type alias T

scala> implicitly[T =:= Foo[String, Int]]
res6: =:=[T,Foo[String,Int]] = <function1>

Dans le cas où vous avez présenté, le paramètre de type R est locale à la fonction Tuple2Pure et donc vous ne pouvez pas simplement définir type PartialTuple2[A] = Tuple2[R, A], car il n'y a tout simplement pas de place où vous pouvez mettre ce synonyme.

À faire face à de tels cas, j'utilise l'astuce suivante qui rend l'utilisation de type de membres. (J'espère que l'exemple est auto-explicatif.)

scala> type Partial2[F[_, _], A] = {
     |   type Get[B] = F[A, B]
     | }
defined type alias Partial2

scala> implicit def Tuple2Pure[R]: Pure[Partial2[Tuple2, R]#Get] = sys.error("")
Tuple2Pure: [R]=> Pure[[B](R, B)]