1

我正在学习函数式编程，遵循Paul Chiusano 和 Rúnar Bjarnason 所著的 Scala 中的函数式编程一书。我特别关注第 3 章，在那里我正在为一个代表单链表的类实现一些伴随函数，这是作者提供的。

package fpinscala.datastructures

sealed trait List[+A]
case object Nil extends List[Nothing]
case class Cons[+A](head: A, tail: List[A]) extends List[A]

object List {
    def sum(ints: List[Int]): Int = ints match {
    case Nil => 0
    case Cons(x,xs) => x + sum(xs)
    }

    def product(ds: List[Double]): Double = ds match {
    case Nil => 1.0
    case Cons(0.0, _) => 0.0
    case Cons(x,xs) => x * product(xs)
    }

    def apply[A](as: A*): List[A] =
    if (as.isEmpty) Nil
    else Cons(as.head, apply(as.tail: _*))

    def tail[A](ls: List[A]): List[A] = ls match {
    case Nil => Nil
    case Cons(x,xs) => xs
    }
... (more functions)
}

我正在实现的函数在对象列表中，是伴随函数。

在实现 dropWhile 时，其方法签名为：

def dropWhile[A](l: List[A])(f: A => Boolean): List[A]

我遇到了一些关于部分函数应用的问题：

在书中，作者说谓词 f 是在一个单独的参数组中传递的，以帮助 scala 编译器进行类型推断，因为如果我们这样做，Scala 可以根据它所知道的确定 f 的类型而无需任何注释关于 List 的类型，让函数使用起来更方便。

所以，如果我们在同一个参数组中传递 f，scala 会强制调用变成这样：val total = List.dropWhile(example, (x:Int) => 6%x==0 )我们明确定义 x 的类型，我们会“失去”部分函数应用的可能性，对吗？

但是，为什么偏函数应用在这种情况下有用呢？只允许类型推断？在不应用谓词 f 的情况下“部分应用”像 dropWhile 这样的函数是否有意义？因为在我看来，如果我们不应用 f...

那么......为什么部分函数应用程序有用？这是它总是如何完成的，还是它只是 Scala 特有的东西？我知道 Haskell 有一种叫做“完全推理”的东西，但我不知道它的确切含义......

提前致谢

4

1 回答 1

3

里面有几个问题，所以我会尝试分别回答。

关于类型推断，是的，分离参数列表有助于编译推断f.

这是因为 Scala 具有线性局部类型推断（从左到右）并且它使用第一个参数列表来推断A（从 的类型l）。然后它可以使用这些信息来推断f.

举个例子

dropWhile(List(1, 2, 3))(x => x < 3)

编译器将执行以下步骤：

  • 第一个参数列表

    • A是未知的。
    • List[A]预计_
    • aList[Int]提供（这是由 中元素的类型推断的List）
    • =>A是一个Int

  • 第二个参数列表

    • 我们知道A = Int
    • Int => Boolean所以我们期待一个函数f

如果不将两个参数列表分开，编译器就无法“停止”并A在类型检查之前决定类型f。f在决定类型时将成为“对话”的一部分，A因此您需要对其进行注释。

这是 Haskell 可以做得更好的事情，因为它使用了不同的类型系统（Hindley-Milner），它也可以使用从应用函数的上下文中获得的信息。这就是为什么它也被称为“完整”或“通用”的原因。

为什么 Scala 没有 Hindley-Milner 类型系统？长话短说，因为 Scala 还支持子类型，而子类型很难与如此强大的类型系统共存。更多关于这个主题：

关于部分应用，“为什么有用”这个问题肯定太宽泛，无法在这里回答。但是，在特定dropWhile情况下，假设您有一个代表不同“丢弃”条件的函数列表。使用部分应用的功能，您可以：

val list = List(1, 2, 3)
val conditions: List[Int => Boolean] = List(_ < 1, _ < 2, _ < 3)
conditions.map(dropWhile(list)) // List(List(1, 2, 3), List(2, 3), List(3))

显然，使用非柯里化函数（即单个参数列表），您可以使用

val list = List(1, 2, 3)
val conditions: List[Int => Boolean] = List(_ < 1, _ < 2, _ < 3)
conditions.map(cond => dropWhile(list, cond))

但是柯里化在组合函数时允许更大的灵活性。

更多关于这个主题：

于 2016-08-22T08:33:33.800 回答