【讨论】函数自动柯里化符号

[mwc]

使用 * 可以声明一个生成器函数：

function * foo( ) {
   ......
}

是否也能够通过问号来声明函数自动柯里化：

function ? add(a, b, c) {
  return a + b + c
}

然后如下调用：

add(1)(3)(5)
add()(1, 3)(5)
add(1, 3)(5)

调用时，支持问号作为占位符，类似 ramda.js 的 R.__：

add(1, ?, 5)(3)

对象字面量中声明：

let obj = {
  ? add(a, b, c) {
    return a + b + c
  }
}

obj.add(1)(2)(3)

[monkingxue]

函数 curry 的需求是什么呢？或者说什么场景需要使用一个 operator 而不是用 curry() 这种 util 函数呢？

[hax]

add(1, ?, 5) 有一份单独的 partial application 提案，它并不要求是curry（但因为和 pipeline 提案有关联，所以必须一起推进）。

[hax]

自动curry有个问题就是似乎无法和 default param 共存。

比如对于 function ? add(a, b, c = 1) 来说 add(1,2) 返回啥。

[mwc]

@hax

返回 4。

参数如有默认值：

function ? add(a, b, c = 1) {
}

则 a 和 b 两个参数支持 currying，c 只支持值替换。
add(1) 返回偏函数，add(1, 2) 返回 4；通过 add(1, 2, 10) 覆盖 c 的默认值，得到结果 13。

[mwc]

@monkingxue

不是什么迫切的需求，譬如 pipeline 和 partial function 一样，没有倒也无妨，基于函数高阶特性，利用现成类库或手工实现都不算难事。

在增强函数式表达方面，既然提案管道与偏函数都阳光普照了，柯里化何不一起明媚？

[hax]

@mwc 需要注意一点，JS 里 default param 可以出现在任何位置，不一定是最后。

如果是 function ? add(a, b=1, c)， add(1,2)又返回啥呢？也是4吗？（按照你前面的描述，似乎应该是4）

从js现有的default param语义来说，function ? add(a, b=1, c) 其实应该等同于 function ? add(a=undefined, b=1, c=undefined) 。

当然我认为你描述的语义也是有道理的，ruby似乎就是如此。但js现有的default param的设计与此不太一致。

[hax]

提案管道与偏函数都阳光普照了

我个人觉得并没有阳光普照，而是前景不明……

[JasinYip]

按照你前面的描述，似乎应该是4

我理解他的意思似乎应该返回函数

[mwc]

@hax @JasinYip

如果是 function ? add(a, b=1, c)， add(1, 2) 应返回 NaN。
这是与现有的函数语法保持一致的期望结果；
包括与使用函数式库的 curry 的结果也是一致 (ramda)，函数的 length 属性对其 curry 的实现至关重要，然而默认参数会“破坏” length 的真实值，因此 function ? add(a, b=1, c) 函数的 length 为 1， add(1, 2) 的调用已满足 1 个参数（a=1，第二个实参 2 覆盖 b 的默认值 1，c 仍未有值，是以 undefined），使得它执行真实函数体并返回 NaN。

如果不考虑现有语法，理应是返回部分函数，等待接收最后一个参数的值，即 add(1, 2) 的第二个实参只是覆盖 b 的默认值，c 仍可被 curry，从字面来看是还有一个参数没有获得值。

[mwc]

以下是一个初步构思：

CurryFunction

支持柯里化的函数称为 CurryFunction，其 constructor 指向下述的 CurryFunction 函数。

constructor

function CurryFunction( ) {

}

声明式

通过在 function 关键字与函数名之间置入 ? 的语法声明一个支持自动柯里化的函数：

function ? function_name(args) {

}

function_name.prototype = CurryFunction.prototype

支持柯里化函数的特点是参数无需一次给足，在不足的情况下，会再次返回一个新的支持自动柯里化的函数；当参数提供完毕（视乎提供的实参个数总和是否大于或等于函数的length值）：

function ? add(a, b) {
  return a + b
}

const cur = a(1)  // 参数不足，返回 function ? (b) {  }，b 参数等待补充完整
cur(2)   // 补充 b 的值，参数提供完毕，执行函数体，返回 3

• 所有支持柯里化的函数的 prototype 均指向 CurryFunction.prototype
• 不允许同时声明函数为自动柯里化及生成器，以下是非法声明：

function ?* fn( ) {   // => SyntaxError
}

表达式/匿名

(
  function ? (args) {

  }
)

对象成员方法

let obj = {
  ? add(a, b, c) {
    return a + b + c
  },
  mul: function ? (a, b, c) {
    return a * b * c
  }
}

obj.add(1)(2, 3)
obj.mul(2, 4)(6)

• 柯里化成员方法，在未提供完整所需的参数之前，返回接收剩余参数的 CurryFunction，即使只剩一个参数；
• 每次返回的CurryFunction实例内部的 this 须置为一致的 obj；
• 不允许同时声明方法成员为自动柯里化及生成器。

类声明

构造函数允许柯里化

虽然 class 的 constructor 不允许是 GeneratorFunction，但可以是 CurryFunction：

class User {
  ? constructor(userName, age) {   // constructor has been curried.
    // super( ? )     // 调用 super 禁止置入 ? 占位符
  }

  // 私有成员是 CurryFunction
  #_username = function ? ( ) {  }

  // public 成员
  ? getName (username, age) {  }
}

const user38 = new User(?, 38)  // 38 岁的人，存在问号占位符，不立即返回对象，返回函数
const jack = user38('Jack')   // { userName: 'Jack', age: 38 }
const mike = user38('Mike')   // { userName: 'Mike', age: 38 } 

构造函数声明自动柯里化，可以延迟 User 实例的创建。

• super() 必须一次性提供所需参数，其所有参数禁止置入 ? 占位符（关于 ? 占位符参看下述《调用》一章），但基类的 constructor 允许声明为 CurryFunction；
• 基于特殊用途的 get及set函数不允许声明为 CurryFunction。

箭头函数柯里化

有鉴于箭头生成器（Arrow Generator），不支持箭头函数柯里化。
通过使用全局 Curry() 支持转换箭头函数为 CurryFunction（参考下方《全局 Curry》一章）：

Curry((a, b) => a + b)

存在默认参数情况（含非尾部默认参数）及REST参数

function ? add(a, b = 1, c) {

}

• 仅识别首个 default parameter 之前的参数自动柯里化，其后续参数不论是否存在默认值，仅依赖调用时直接补充，否则值为默认值或undefined，不被认为是支持柯里化的参数；
• REST 参数不会被柯里化，溢出的实参仍然支持传递到 REST 参数。

function ? foo(x, y, ...z) {

}

const cur_foo = foo(1)  // x=1, y=?
cur_foo(2, 3, 4)        // x=1, y=2, z=[3, 4]

全局 Curry 函数

转换函数为 CurryFunction

Curry(fn: Function) -> CurryFunction

function Curry(fn) {

}

• 给定参数 fn 类型为 Function，为常规函数（含箭头函数），返回柯里化后的函数；
  • 若 fn 类型为 GeneratorFunction，抛出 TypeError 异常；
  • 若 fn 类型为 CurryFunction，返回 fn；
• 给定参数 fn 非 Function 类型，抛出 TypeError 异常。

function ? add(a, b) {  }

等同于：

function add(a, b) {  }
add = Curry(add)

等同于：

function add(a, b) {  }
add = add(?, ?)   // 参考下文《调用》一章关于问号 (?) 占位符的描述

// sample
function add(a, b) {

}

const addCurrying = Curry(add)

addCurrying(1)(2)	// calling

Function.prototype.isCurry()

判断一个函数是否柯里化函数

function ? add(a, b) {

}

function pow(n, times) {

}

add.isCurry()  // => true
pow.isCurry()  // => false
pow(?, 2).isCurry()  // => true

调用

已使用 ? 声明的函数，例如：

function ? add(a, b) {

}

调用时无需指定 ? 实参占位，语言隐式处理函数柯里化，实参从左至右依次第提供，不足则自动返回CurryFunction接收剩余参数：

function ? add(a, b) {

}

const cur = add(1)   // returns: function ? (b) { }
cur(2)

如需变更实参提供顺序，使用 ? 实参占位符显式指定。

调用参考 partial function，但是建议返回 curry；
在 partial function 提案中，无需 curry 的原因无非是 pipeline 要求每个函数只能一个参数，
即问号占位符（placehold parameter）其实仅需一个，如果使其更具适应性，推而广之，应使其调用后自动 currying：

使用 ? 实参占位符改变参数传递顺序

示例

function ? add(a, b, c, d) {

}

add.isCurry()  // => true

// 提供参数
const cur = add(1, 2)  // 实参不足，返回 CurryFunction
// a=1, b=2, c=?, d=?

const evol = cur(?, 4)  // 改变实参提供的顺序，先提供第4个参数，第3个参数使用 ? 占位符
// a=1, b=2, c=?, d=4

evol(3)
// a=1, b=2, c=3, d=4

实参一旦显式指定 ? 占位符进行调用，调用表达式的规则（参考下一节）将有所改变，但返回的 CurryFunction 仍支持隐式柯里化。

多个占位符示例

function add(a, b, c, d) {
  return a+b+c+d
}

// 多个占位符
const curryAdd = add(10, ?, 20, ?)    // => a=10, b=?, c=20, d=?
// returns: function ? (b, d) { }

const evolutionAdd = curryAdd(?, 25)  // => a=10, b=?, c=20, d=25
// returns: function ? (b) { }

evolutionAdd(15)   // => 10+15+20+25;  return 70

调用表达式规则：

• 类构造函数中调用父类的 super( ) 不支持使用占位符；

• 给定 f()，若 f 参数个数为 0，则立即执行；

• 给定 f(arguments list)，不存在 ? 占位符的情况下，在未提供完整所需的参数之前，返回接收剩余参数的 CurryFunction，即使该函数只声明了一个参数。在对象成员方法中（如 obj），返回的 CurryFunction 其 this 应均为对象（obj）本身，参考《CurryFunction》一章下属《对象成员方法》中的说明；

• 给定 f(?)，f 如有多个参数，仅首个参数柯里化，其余按默认值（若有）或 undefined；

function add(a, b, c) {

}

const curAdd = add(?)  // a=?, b=undefined, c=undefined, returns: function (a) { }

• 给定 f(?, x, ?)，
  • 若 f 少于3个参数，忽略客户调用的第二个 ? 占位符；
  • 若 f 参数个数为 3，返回接收第1个及第3个参数的 CurryFunction；
  • 若 f 多于3个参数，溢出部分的参数按默认值（若有）或赋值 undefined。

// 实参富余的情况
function surpass(a, b) {

}

const curring = surpass(?, 2, ?)  // a=?, b=2, drop the last '?'

// 实参不足的情况
function shortage(a, b, c, d, e) {

}

const cur = shortage(10, ?, 14, ?)  // a=10, b=?, c=14, d=?, e=undefined
// e 将被设置为 undefined
// returns: function ? (b, d) {  }

cur(12)(15)     // 返回的 CurryFunction 仍支持隐式柯里化

[hax]

@mwc 你现在这个已经比较复杂了，比如混合 partial 和 curry。也不是说不行，但复杂的设计需要更强有力的动机和用例，还有正反面因素的对比。此外有很多你的设计决策（比如构造器支持curry而箭头函数不支持）需要解释原因和目的。

我先提一个比较重要的问题，如果我们有Function.curry(f)这样的工具方法，是否就已经够了，而不需要额外的语法。