¿Qué son las lambdas tipo en Scala y cuáles son sus beneficios?

Los beneficios son exactamente los mismos que los conferidos por funciones anónimas.

def inc(a: Int) = a + 1; List(1, 2, 3).map(inc)

List(1, 2, 3).map(a => a + 1)

Un ejemplo de uso, con Scalaz 7. Queremos usar un Functor que pueda mapear una función sobre el segundo elemento en un Tuple2.

type IntTuple[+A]=(Int, A)
Functor[IntTuple].map((1, 2))(a => a + 1)) // (1, 3)

Functor[({type l[a] = (Int, a)})#l].map((1, 2))(a => a + 1)) // (1, 3)

Scalaz proporciona algunas conversiones implícitas que pueden inferir el argumento type a Functor, por lo que a menudo evitamos escribirlas por completo. La línea anterior se puede reescribir como:

(1, 2).map(a => a + 1) // (1, 3)

Si utiliza IntelliJ, puede habilitar Ajustes, Estilo de código, Scala, Plegado, Escribe Lambdas. Esto entonces oculta las partes crufty de la sintaxis, y presenta la más apetecible:

Functor[[a]=(Int, a)].map((1, 2))(a => a + 1)) // (1, 3)

Una futura versión de Scala podría soportar directamente dicha sintaxis.

Para poner las cosas en contexto: Esta respuesta se publicó originalmente en otro hilo. Lo estás viendo aquí porque los dos hilos se han fusionado. La declaración de la pregunta en dicho hilo fue la siguiente:

Cómo resolver esta definición de tipo: Pure [({type ?[a]=(R, a)})#?] ?

¿Cuáles son las razones para utilizar tal construcción?

Snipped viene de la biblioteca scalaz:

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)
  }

//...
}

Respuesta:

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

El un subrayado en los cuadros después de P implica que es un constructor de tipo toma un tipo y devuelve otro tipo. Ejemplos de constructores de tipo con este tipo: List, Option.

Da List un Int, un tipo concreto, y te da List[Int], otro tipo concreto. Da List a String y te da List[String]. Sucesivamente.

So, List, Option se puede considerar que son funciones de nivel de tipo de arity 1. Formalmente decimos, tienen un tipo * -> *. El asterisco indica una tipo.

Ahora Tuple2[_, _] es un constructor de tipo con tipo (*, *) -> * es decir, necesita darle dos tipos para obtener un nuevo tipo.

Dado que sus firmas no coinciden, no se puede sustituir Tuple2 por P. Lo que necesita hacer es aplicar parcialmente Tuple2 en uno de sus argumentos, que nos dará un constructor de tipo con tipo * -> *, y podemos sustituirlo por P.

Desafortunadamente Scala no tiene una sintaxis especial para la aplicación parcial de constructores de tipos, por lo que hay que recurrir a la monstruosidad llamada tipo lambdas. (Lo que tienes en tu ejemplo. Se les llama así porque son análogas a las expresiones lambda que existen a nivel de valor.

El siguiente ejemplo podría ayudar:

// 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>

Editar:

Más paralelos de nivel de valor y nivel de tipo.

// 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>

En el caso que ha presentado, el parámetro type R es local para la función Tuple2Pure y, por lo tanto, no puede definir simplemente type PartialTuple2[A] = Tuple2[R, A], porque simplemente no hay lugar donde puedes poner ese sinónimo.

Para lidiar con tal caso, utilizo el siguiente truco que hace uso de miembros de tipo. (Esperemos que el ejemplo se explique por sí mismo.)

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)]

type World[M[_]] = M[Int] causas que todo lo que ponemos en A en X[A] el implicitly[X[A] =:= Foo[String,Int]] siempre es cierto, supongo.