类型化 FP：元组参数和可柯里化参数

Question

在静态类型函数编程语言中，例如 Standard ML、F#、OCaml 和 Haskell，编写函数时通常将参数彼此分开，并通过空格与函数名称分开：

let add a b =
    a + b

此处的类型为“int -> ; (int -> int)”，即一个函数接受一个 int 并返回一个函数，该函数轮流接受一个 int 并且最终返回一个 int。 因此柯里化成为可能。

还可以定义一个以元组作为参数的类似函数：

let add(a, b) =
    a + b

在这种情况下，类型变为“(int * int) -> int”。

从语言设计的角度来看，有什么理由不能简单地识别类型代数中的这两种类型模式吗？ 换句话说，“(a * b) -> c”减少为“a -> (b -> c)”，允许同样轻松地柯里化两个变体。

我认为当设计我提到的四种语言时，一定会出现这个问题。 那么有人知道为什么这四种语言选择不“统一”这两种类型模式的任何原因或研究吗？

Answer 1

我认为今天的共识是通过柯里化（a -> b -> c 形式）来处理多个参数，并在您真正想要以下值时保留元组元组类型（在列表等中）。 自标准 ML 以来的所有静态类型函数语言都遵守这一共识，标准 ML（纯粹作为惯例）对采用多个参数的函数使用元组。

为什么会这样呢？ 标准机器学习是这些语言中最古老的，当人们第一次编写机器学习编译器时，并不知道如何有效地处理柯里化参数。 （问题的根源在于，任何柯里化函数都可能被您尚未见过的其他代码部分应用，并且您必须使用以下命令来编译它考虑到这种可能性。）自从设计了标准机器学习以来，编译器已经得到了改进，您可以在 西蒙·马洛和西蒙·佩顿·琼斯的优秀论文。

LISP 是其中最古老的函数式语言，它的具体语法对柯里化和部分应用极其不友好。 哼。

Answer 2

不将柯里化和非柯里化函数类型混为一谈的至少一个原因是，当元组用作返回值（这些类型化语言中返回多个值的一种便捷方式）时，会非常混乱。 在合并类型系统中，函数如何保持良好的可组合性？ 会 a -> (a * a) 也转换为 a -> 一个-> 一个？ 如果是这样，则为 (a * a) -> a 和 a -> (a * a) 相同类型？ 如果没有，你会如何编写 a ->; (a * a) 与 (a * a) -> 一个？

您针对构图问题提出了一个有趣的解决方案。 然而，我觉得它并不令人满意，因为它与部分应用程序不能很好地配合，而这确实是柯里化函数的一个关键便利之处。 让我尝试用 Haskell 来说明这个问题：

apply f a b = f a b
vecSum (a1,a2) (b1,b2) = (a1+b1,a2+b2)

现在，也许你的解决方案可以理解 map (vecSum (1,1)) [(0,1)]，但是等效的 map 又如何呢？ （应用 vecSum (1,1)）[(0,1)]？ 事情变得复杂了！ 您最完整的解包是否意味着 (1,1) 是用 apply 的 a & 解包的？ b 参数？ 这不是意图……无论如何，推理变得复杂。

简而言之，我认为很难将柯里化函数和非柯里化函数混为一谈，同时（1）保留旧系统下有效的代码语义以及（2）为合并系统提供合理的直觉和算法。 不过，这是一个有趣的问题。

Answer 3

可能是因为将元组作为单独的类型很有用，并且将不同的类型分开也很好？

至少在 Haskell 中，从一种形式转换为另一种形式是相当容易的：

Prelude> let add1 a b = a+b
Prelude> let add2 (a,b) = a+b
Prelude> :t (uncurry add1)
(uncurry add1) :: (Num a) => (a, a) -> a
Prelude> :t (curry add2)
(curry add2) :: (Num a) => a -> a -> a

所以 uncurry add1 与 add2 相同，而 curry add2 是与add1相同。 我想类似的事情在其他语言中也是可能的。 自动柯里化元组上定义的每个函数会有什么更大的好处？ （因为这似乎就是你想问的。）

Answer 4

扩展 namin 好的答案下的评论：

因此假设一个函数的类型为 'a -> ('a * 'a)：

let gimme_tuple(a : int) =
    (a*2, a*3)

然后假设一个函数的类型为 ('a * 'a) -> 'b：

let add(a : int, b) =
    a + b

那么据我所知，组合（假设我建议的合并）不会造成任何问题：

let foo = add(gimme_tuple(5))
// foo gets value 5*2 + 5*3 = 25

但是您可以设想一个多态函数来代替 add 在最后一个代码片段中，例如一个小函数，它只接受一个 2 元组并生成两个元素的列表：

let gimme_list(a, b) =
    [a, b]

这将具有类型 ('a * 'a) -> （'列表）。 现在的构图会有问题。 考虑：

let bar = gimme_list(gimme_tuple(5))

bar 现在的值是 [10, 15] : int list 或者 bar 是 (int 类型的函数* int) ->; ((int * int) list)，最终会返回一个列表，其头为元组 (10, 15)？ 为了实现这一点，我在对 namin 的回答的评论中提出，在类型系统中需要一条附加规则，即实际参数与形式参数的绑定是“尽可能完整的”，即系统应该尝试非部分绑定如果无法实现完整绑定，则首先且仅尝试部分绑定。 在我们的示例中，这意味着我们获得值 [10, 15]，因为在这种情况下可以进行完整绑定。

这种“尽可能”的概念本身就毫无意义吗？ 我不知道，但我无法立即看出原因。

当然，一个问题是，如果您想要最后一个代码片段的第二种解释，那么您需要跳过一个额外的环（通常是匿名函数）才能获得它。

Answer 5

这些语言中的元组不只是用作函数参数。 它们是表示结构化数据的一种非常方便的方式，例如，2D 点 (int * int)、列表元素 ('a * 'a list) 或树节点（'a * '一棵树 * '一棵树）。 还要记住，结构只是元组的语法糖。 即，

type info = 
  { name : string;
    age : int;
    address : string; }

是处理 (string * int * string) 元组的便捷方法。

没有根本理由需要编程语言中的元组（您可以在 lambda 演算中构建元组，就像构建布尔值和整数一样 — 实际上是使用柯里化*），但它们很方便且有用。

* 例如，

tuple a b = λf.f a b
fst x     = x (λa.λb.a)
snd x     = x (λa.λb.b)
curry f   = λa.λb.f (λg.g a b)
uncurry f = λx.x f