OCaml相当于javascript'apply'

Question

自从我编写OCaml以来已经有一段时间了,我遇到了这个听起来很简单的问题,但我遇到了解决问题的心理障碍:

编写一个函数,该函数接受一个f带有可变数量参数的函数,该函数返回一个布尔值(即f类型'a -> 'b -> 'c -> ... -> bool)并返回一个g表示否定的函数f(即(f x1 x2 .. xn) == not (g x1 x2 .. xn)对于所有有效参数集).

它的灵感来自以下代码块,它解决了Javascript中的问题:

function negate(func) {
  return function() {
    return !func.apply(null, arguments);
  };
}

(来自http://eloquentjavascript.net/1st_edition/chapter6.html)

但是,我没有看到在OCaml中实现此方法的方法("arguments"关键字或等效项不可用),因为该函数f没有预设数量的参数.我找到了关于处理具有可变数量参数的函数的链接(例如https://blogs.janestreet.com/variable-argument-functions/),但我想知道是否有更简单/更自然的'处理这个具体问题的方法.

Answer 1

我是一名 JavaScript 程序员，我一直认为可变参数是有害的。如果我们在 JavaScript 中没有可变参数函数（只要远离对象arguments），那么 JavaScript 中可在 Hindley Milner 类型系统中输入的每个函数（减去 API 特定函数，如 DOM 函数）都可以轻松转换为奥卡姆。

那么该apply函数在 OCaml 中的等价物是什么？我相信这是正常的函数应用：

let apply f x = f x (* equivalent of apply in JavaScript *)

普通函数应用如何等同于applyJavaScript 中的函数？考虑：

let s f g x = f x (g x) (* the S combinator from the SKI combinator calculus *)

该函数将用 JavaScript 编写，如下所示：

var s = function (f) {
    return function (g) {
        return function (x) {
            return f(x)(g(x));
        };
    };
};

请注意，每个函数定义和函数调用都是以柯里化形式显式编写的。

这是 JavaScript 和 OCaml 之间的区别：

1. 在 OCaml 中，默认情况下所有函数都会被柯里化，并且您必须显式地对它们进行柯里化。
2. 在 JavaScript 中，默认情况下所有函数都是非柯里化的，您必须显式地柯里化它们。

那么，让我们看一下 S 组合器的非柯里化变体。首先，OCaml：

let s (f, g, x) = f (x, g (x)) (* sml convention is to use uncurried functions *)

JavaScript 中的等价物：

var s = function (f, g, x) {
    return f(x, g(x));
};

请注意，OCaml 和 JavaScript 中的正常函数应用是相同的。对于柯里化函数：

let result = s f g x (* equivalent to `((s f) g) x` *)

JavaScript 中的等价物：

var result = s(f)(g)(x);

对于非柯里化函数：

let result = s (f, g, x)

JavaScript 中的等价物：

var result = s(f, g, x);

那么apply功能呢？这与普通的函数应用程序有何等价？

在 OCaml 中，你可以这样做：

let args   = (f, g, x) (* args is a tuple *)

let result = s args    (* normal function application *)

JavaScript 中的等价物是：

var args   = [f, g, x];           // args is an array

var result = s.apply(null, args); // normal function application

正如您所看到的，OCaml 中的元组相当于 JavaScript 中的数组。JavaScript 中的数组用途广泛。它们可以用作列表或元组，具体取决于上下文。

args给定的参数可以apply是任何类似数组的对象，并且它被视为单个元组参数。JavaScript 中的每个函数都可以被视为单个参数函数。JavaScript 中的多参数函数可以被认为是单参数元组参数函数。JavaScript 的函数apply只是普通函数应用的一种特殊形式。

那么这意味着什么呢？考虑：

var negate = function (f) {
    return function () {
        return !f.apply(null, arguments);
    };
};

如果我们认为arguments是内部函数的隐式参数，那么 OCaml 中上述函数的等价物是：

let negate f = fun arguments -> not (f arguments) (* arguments is explicit *)

这可以简化为：

let negate f x = not (f x)

现在，您可能会说这仅适用于单参数函数。事实并非如此。的类型签名negate是：

val negate : ('a -> bool) -> 'a -> bool

因此，它可以适用于任何类型，'a包括元组。这相当于 JavaScript，其中多参数函数只是单参数元组参数函数。

最后，唯一真正的问题是将柯里化函数转换为非柯里化函数，以便您可以使用negate它们。不幸的是，在 OCaml 中没有通用的方法来取消柯里化函数。因此，您需要一系列函数来uncurry柯里化多个参数的函数：

let uncurry2 f (x, y) = f x y

let uncurry3 f (x, y, z) = f x y z

           .
           .
           .
           .

否定这些功能后，您可以将curry它们恢复。然而，就像uncurry没有办法通用curry一个函数一样。因此，您再次需要一系列curry函数：

let curry2 f x y   = f (x, y)

let curry3 f x y z = f (x, y, z)

         .
         .
         .
         .

创建泛型curry或uncurry函数的唯一方法是使用动态类型语言（如 Lisp 或 JavaScript）或依赖类型语言（如 Idris 或 Agda）。OCaml 的类型系统（Hindley Milner 类型系统）限制太多，无法实现此类功能。