高阶代理滥用

Question

Javascript声称是一种函数式语言，但感觉上肯定不是。它缺少让函数式语言变得整洁的大多数东西，其中之一就是点自由风格。幸运的是，我们在ES6中得到了箭头函数和代理，所以我自己用代理实现了无点风格：

let pfree = ctx => f => new Proxy (f, {
  has: (t, p) => p in t || p in ctx
, get: (t, p) => {
    let k = p in t? t[p]: ctx[p];

    if (k instanceof Function) return (
      function fetch (_k) {
        return pfree (ctx) ( x => ( q => q instanceof Function
                                       ? fetch (q)
                                       : t (q)
                                  ) ( _k(x) )
                           )
      })(k);

    return k;
  }
});

相当令人头疼，但它做了这项工作-在nodejs中，你可以这样使用它：

let p = pfree (global) (x => x)

with (p) {
  add  = x => y => x + y
  succ = add (1)
  five = succ . add (2) . succ (1)
}

console.log(five) // 5

当你创建更高阶的函数时，问题就出现了：

with (p) {
  flip  = f => x => y => f (y) (x)
  Const = a => b => a
  dot   = f => a => b => f(a(b))
  ap    = f => g => x => f (x) (g (x))

  zero  = flip (Const)
  succ  = ap (dot) 

  num   = n => n (x => x + 1) (0) // The number n is represented by running a function n times over some input

  console.log ( num ( succ ( succ ( succ (zero) )))) // 3
  console.log ( num . succ . succ . succ (zero) )    // [Function]
}

我真的不明白为什么..

想法？

Answer 1

问题很简单：

succ . add(2)

与无法区分

(succ . add) (2)

使用JavaScript属性访问的规则，但您希望它们做不同的事情。

解决方案是不可能的(我敢说)，但您可以通过引入自定义分组运算符来解决问题：

group(succ . add) (2)

您还应该在分配给p的属性时调用它。您应该能够完成以下工作：

addFour = succ . add (2) . succ
five = group(succ . add (2) . succ) (1)
fiveAgain = addFour (1)

console.log ( group(num . succ . succ . succ) (zero) )    // 3