Scala中的lambdas类型是什么？它们的优点是什么？

有时我偶然发现了一种半神秘的符号

def f[T](..) = new T[({type l[A]=SomeType[A,..]})#l] {..} 

在Scala的博客文章中，它给出了一个“我们使用了lambda类型的技巧”handwave

---

虽然我对此有一些直觉（我们获得了一个匿名类型参数

A

，而不必用它污染定义？），但我没有找到明确的来源来描述什么是类型lambda技巧，以及它的好处是什么。它只是语法上的甜点，还是打开了一些新的维度？

类型lambda在处理高级类型时相当重要

考虑一个简单的例子，为[a，B]的右投影定义一个单子。monad类型类如下所示：

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

现在，两者都是两个参数的类型构造函数，但是要实现Monad，需要给它一个参数的类型构造函数。解决方案是使用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]
}

这是一个在类型系统中使用curry的示例-您已经使用了其中一种类型，因此当您想要创建EitherMonad的实例时，您必须指定其中一种类型；另一个当然是在调用点或绑定时提供的

类型lambda技巧利用类型位置中的空块创建匿名结构类型这一事实。然后，我们使用#语法获取类型成员

在某些情况下，您可能需要更复杂的lambda类型，这是内联编写的难题。下面是我今天的代码示例：

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

---

这个类以独占方式存在，因此我可以使用FG[F，G]#IterateeM这样的名称来表示专门化为第二个单子的某个转换器版本的IterateeT monad的类型，该版本专门化为第三个单子。当您开始堆叠时，这些类型的构造变得非常必要。当然，我从不实例化FG；它只是一个黑客，让我在类型系统中表达我想要的内容。

其好处与匿名函数所赋予的好处完全相同

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

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

使用Scalaz 7的示例用法。我们希望使用一个

函子

，它可以将一个函数映射到

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提供了一些隐式转换，可以将类型参数推断为

Functor

，因此我们通常避免编写这些函数。前一行可以重写为：

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

如果您使用IntelliJ，则可以启用设置、代码样式、Scala、折叠、键入Lambdas。然后，这将呈现更美味的：

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

---

Scala的未来版本可能会直接支持这种语法。

将事情放到上下文中：这个答案最初发布在另一个线程中。您在这里看到它是因为两个线程已合并。上述帖子中的问题陈述如下：

如何解析此类型定义：Pure[（{type？[a]=（R，a）}）#？]

使用这种结构的原因是什么

Snipped来自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)
  }

//...
}

---

回答：

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

p

后面的框中的一条下划线表示它是一个类型构造函数，接受一种类型并返回另一种类型。具有这种类型的类型构造函数的示例：

列表

，

选项

给

List

一个

Int

，一个具体类型，它给你另一个具体类型

List[Int]

。给

List

一个

String

，它会给你

List[String]

。等等

因此，

列表

，

选项

可以被认为是arity 1的类型级函数。正式地说，他们有一种

*->*

。星号表示一种类型

现在，

Tuple2[\uu，\u]

是一个类型构造函数，其种类为

（*，*）->*

，也就是说，您需要给它两种类型才能得到一个新类型

由于它们的签名不匹配，因此不能用

p

替换

Tuple2

。您需要做的是在它的一个参数上部分应用

Tuple2

，这将为我们提供一个具有kind

*->*

的类型构造函数，我们可以将其替换为

P

不幸的是，Scala对于类型构造函数的部分应用没有特殊的语法，因此我们不得不求助于称为类型lambdas的怪物。它们之所以被称为lambda，是因为它们类似于存在于值级别的lambda表达式

以下示例可能会有所帮助：

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

---

键入World[M[\u]]=M[Int]

导致无论我们在

X[A]

中放入

什么，我猜
隐式地[X[A]=:=Foo[String，Int]]
总是正确的。
最后一个片段看起来真不错。IntelliJ scala插件确实很棒！谢谢上一个示例中可能缺少lambda。另外，为什么元组函子选择转换最后一个值？这是惯例/实际默认值吗？我正在为Nika运行夜间睡眠，我没有描述的想法选项。有趣的是，这里有一个“Applied Type Lambda can can simplified”（应用类型Lambda可以简化）的检查。它被移动到设置->编辑器->代码折叠。@追溯，我在REPL:`:11:error:值映射不是（Int，Int）（1，2）的成员。map（a=>a+1）中尝试时出错^`值得注意的是，尽管一些新类型的黑客（例如TypeCompose库）有办法解决这个问题。我很想看到您为
EitherMonad
类定义
bind
方法。：-）除此之外，如果我可以在这里给Adriaan介绍一下，在这个例子中，您没有使用更高级的类型。您在
FG
，但不在
EitherMonad
。相反，您使用的是类型构造函数，它的种类是
*=>*
。这种是1阶，不是“更高”。我认为那种
*
是1阶，但在任何情况下Monad都有
（*=>*）=>*
。另外，您会注意到，我指定了“
的右投影”[
// 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>

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