OCaml 相当于 javascript 'apply'

Question

自从我编写 OCaml 代码以来已经有一段时间了，我遇到了这个听起来很简单但我无法解决的问题：

编写一个函数，该函数接受函数 f，参数数量可变，returns 一个布尔值（即 f 的类型为 'a -> 'b -> 'c -> ... -> bool）和 returns 一个函数 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/）的链接，但我想知道是否有更简单/更多 'natural' 的方法来处理这个特定问题。

Answer 1

ocaml中的A function takes several arguments实际上是一个函数接受一个参数和return另一个函数。这是咖喱。

你想做的事情可以用非柯里化函数实现，即只接受一个参数（可能是一个元组）的函数：

例如，您需要 f : (a * b * c) -> bool 而不是 f : a -> b -> c -> bool。但是你必须"manually"转换你的函数。

您可以像 let uncurry f (x,y) = f x y 那样对函数进行右移，但这只是解决了问题，因为您必须对任意数量的参数执行此操作。

也许您可以否定将参数列表作为参数的函数。我的意思是我不知道你要做什么的具体细节。

Answer 2

这并不难，但是您必须手动编写（并且在调用站点，select）每个元数的明确定义，因为 OCaml 缺乏必要的机制来抽象不同的相似定义参数。

请注意，这是 OCaml 代码中已经存在的模式：请参阅 List.map(2)、List.iter(2) 等

定义可能如下所示：

let negate f = (fun a -> not (f a))
let negate2 f = (fun a b -> not (f a b))
let negate3 f = (fun a b c -> not (f a b c))
(* etc *)

请注意，允许这种多态性的类型系统是可以想象的：事实上，Typed Racket 可能能够表达这种定义。

Answer 3

我是一名 JavaScript 程序员，我一直坚持 variadic arguments are harmful。如果我们在 JavaScript 中没有可变参数函数（只要远离 arguments 对象），那么 JavaScript 中的每个函数都可以在 Hindley Milner 类型系统中输入（减去 API 特定函数，如 DOM 函数）可以很容易地转换为 OCaml 中的等效函数。

那么 apply 函数的 OCaml 等价物是什么？我相信这是正常的功能应用程序：

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

正常的函数应用如何等同于JavaScript中的apply函数？考虑：

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的区别：

在 OCaml 中，默认情况下所有函数都是柯里化的，您必须显式取消它们。
在 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 中的数组用途广泛。它们可以用作列表或元组，具体取决于上下文。

apply 的 args 参数可以是任何类似数组的对象，它被视为单个元组参数。 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 类型系统）限制太多，不允许这样的函数。

OCaml 相当于 javascript 'apply'

OCaml equivalent of javascript 'apply'

javascript

functional-programming

ocaml

variadic-functions