“int->”整数->整数”这在 F# 中意味着什么？

Question

我想知道这在 F# 中意味着什么。
“一个接受整数的函数，
它返回一个接受整数并返回整数的函数。”
但我不太明白这一点。
有谁能解释得这么清楚吗？

[更新]：

> let f1 x y = x+y ;;

 val f1 : int -> int -> int

这是什么意思？

Answer 1

F# 类型

让我们从头开始。

F# 使用冒号 (:) 表示法来指示事物的类型。假设您定义了一个 int 类型的值：

let myNumber = 5

F# Interactive 会理解 myNumber 是一个整数，并会通过以下方式告诉您：

myNumber : int

读作

myNumber 的类型为 int

F# 函数类型

到目前为止一切顺利。让我们介绍一些其他东西，函数类型。函数类型就是函数的类型。 F# 使用 -> 来表示函数类型。这个箭头象征着左侧所写的内容被转换为右侧所写的内容。

让我们考虑一个简单的函数，它接受一个参数并将其转换为一个输出。此类函数的示例如下：

isEven : int -> bool

这引入了函数的名称（位于 : 的左侧）及其类型。这行英文可以读作：

isEven 是将 int 转换为 bool 的函数类型。

请注意，为了正确解释所说的内容，您应该在“属于类型”部分之后短暂停顿，然后立即阅读句子的其余部分，不要停顿。

在 F# 中，函数是值

在 F# 中，函数（几乎）并不比普通类型更特殊。它们是可以传递给函数、从函数返回的东西，就像布尔值、整数或字符串一样。

因此，如果您有：

myNumber : int
isEven : int -> bool

您应该考虑 int 和 int ->; bool 作为同一种类的两个实体：类型。这里，myNumber是一个int类型的值，isEven是一个int -> type的值。 bool （这就是我在谈论上面的短暂停顿时想要表达的意思）。

函数应用

包含 -> 的类型的值也称为函数，并且具有特殊的能力：您可以将函数应用于价值。例如，这

isEven myNumber

意味着您正在将名为 isEven 的函数应用于值 myNumber。正如您通过检查 isEven 的类型所期望的，它将返回一个布尔值。如果您正确实现了 isEven，它显然会返回 false。

返回函数类型值的函数

让我们定义一个通用函数来确定一个整数是否是其他整数的倍数。我们可以想象我们的函数的类型将是（括号是为了帮助您理解，它们可能存在也可能不存在，它们有特殊的含义）：

isMultipleOf : int -> (int -> bool)

正如您可以猜到的，这被读作：

isMultipleOf 是 (PAUSE) 类型函数，可将 int 转换为 (PAUSE) 函数，将 int 转换为 布尔。

（这里的（PAUSE）表示大声朗读时的暂停）。

我们稍后将定义这个函数。在此之前，让我们看看如何使用它：

let isEven = isMultipleOf 2

F# 交互式会回答：

isEven : int -> bool

读作

isEven 的类型为 int ->布尔

这里，isEven 的类型为 int ->; bool，因为我们刚刚将值 2 (int) 赋予 isMultipleOf，正如我们已经看到的，它转换了 int code> 转换为 int ->布尔。

我们可以将此函数 isMultipleOf 视为一种函数创建者。

isMultipleOf 的定义

现在让我们定义这个神秘的函数创建函数。

let isMultipleOf n x =
    (x % n) = 0

容易吧？

如果您在 F# Interactive 中输入此内容，它将回答：

isMultipleOf : int -> int -> bool

括号在哪里？

请注意，没有括号。现在这对你来说并不是特别重要。请记住，箭头是右关联的。也就是说，如果有，

a -> b -> c

您应该将其解释为

a -> (b -> c)

“右关联”中的“右”意味着您应该将其解释为最右边的运算符周围有括号。因此：

a -> b -> c -> d

应该解释为

a -> (b -> (c -> d))

isMultipleOf 的用法

因此，正如您所看到的，我们可以使用 isMultipleOf 创建新函数：

let isEven = isMultipleOf 2
let isOdd = not << isEven
let isMultipleOfThree = isMultipleOf 3
let endsWithZero = isMultipleOf 10

F# Interactive 会响应：

isEven : int -> bool
isOdd : int -> bool
isMultipleOfThree : int -> bool
endsWithZero : int -> bool

但您可以以不同的方式使用它。如果您不想（或需要）创建新函数，可以按如下方式使用它：

isMultipleOf 10 150

这将返回 true，因为 150 是 10 的倍数。这与 create 完全相同函数 endsWithZero ，然后将其应用到值 150。

实际上，函数应用是左关联的，这意味着上面的行应该解释为：

(isMultipleOf 10) 150

也就是说，您将最左边的函数应用程序周围的括号。

现在，如果您能理解这一切，那么您的示例（即规范的 CreateAdder）应该很简单！

不久前有人问这个问题它处理完全相同的概念，但在 Javascript 中。在我的回答中，我给出了两个 inf Javascript 规范示例（CreateAdder、CreateMultiplier），它们对于返回函数更加明确。

我希望这有帮助。

Answer 2

典型的例子可能是“加法器创建者”——一个函数，给定一个数字（例如 3），返回另一个函数，该函数接受一个整数并将第一个数字添加到其中。

因此，例如，在伪代码中，

x = CreateAdder(3)
x(5) // returns 8
x(10) // returns 13
CreateAdder(20)(30) // returns 50

我对 F# 不太熟悉，无法在不检查的情况下尝试编写它，但 C# 会是这样的：

public static Func<int, int> CreateAdder(int amountToAdd)
{
    return x => x + amountToAdd;
}

这有帮助吗？

编辑：正如布鲁诺指出的，您在问题中给出的示例正是我给出的 C# 代码示例，因此上面的伪代码将变为：

let x = f1 3
x 5 // Result: 8
x 10 // Result: 13
f1 20 30 // Result: 50

Answer 3

它是一个接受整数并返回整数的函数，它接受整数并返回整数。

这在功能上相当于一个接受两个整数并返回一个整数的函数。这种处理采用多个参数的函数的方式在函数式语言中很常见，并且可以轻松地在值上部分应用函数。

例如，假设有一个 add 函数，它接受两个整数并将它们相加：

let add x y = x + y

您有一个列表，并且想要将 10 添加到每个项目。您可以将 add 函数部分应用于值 10。它将其中一个参数绑定到 10 并保留另一个参数未绑定。

let list = [1;2;3;4]
let listPlusTen = List.map (add 10)

这个技巧使编写函数变得非常容易，并且使它们非常可重用。正如您所看到的，您不需要编写另一个将 10 添加到列表项的函数来将其传递给 map。您刚刚重用了 add 函数。

Answer 4

您通常将其解释为一个接受两个整数并返回一个整数的函数。
您应该阅读柯里化。

Answer 5

一个接受整数的函数，它返回一个接受整数并返回整数的函数

最后一部分：

一个接受整数并返回整数的函数

应该相当简单，C# 示例：

public int Test(int takesAnInteger) { return 0; }

所以我们剩下

一个接受整数的函数，它返回（类似于上面的函数）

再次 C#：

public int Test(int takesAnInteger) { return 0; }
public int Test2(int takesAnInteger) { return 1; }

public Func<int,int> Test(int takesAnInteger) {
    if(takesAnInteger == 0) {
        return Test;
    } else {
        return Test2;
    }
}

Answer 6

您可能想阅读

F# 函数类型：元组和柯里化的乐趣

Answer 7

在 F#（以及许多其他函数式语言）中，有一个称为柯里化函数的概念。这就是你所看到的。本质上，每个函数都接受一个参数并返回一个值。

乍一看这似乎有点令人困惑，因为您可以编写 let add xy = x + y 并且它似乎添加了两个参数。但实际上，原始的 add 函数只接受参数 x。当您应用它时，它会返回一个函数，该函数接受一个参数 (y) 并已填充 x 值。当您随后应用该函数时，它会返回所需的值整数。

这显示在类型签名中。将类型签名中的箭头视为“获取左侧的内容并返回右侧的内容”。在类型 int -> 中整数-> int，这意味着它接受一个 int 类型的参数（一个整数），并返回一个 int -> 类型的函数。 int — 一个接受整数并返回整数的函数。您会注意到，这与上面对柯里化函数如何工作的描述完全匹配。

Answer 8

示例：

let fba = pown ab //fab = a^b

是一个函数，它接受 int（指数）并返回一个将其参数提升为该指数的函数，例如

let sqr = f 2

或

let tothepowerofthird = f 3

所以

sqr 5 = 25

tothepowerof Three 3 = 27

Answer 9

这个概念称为高阶函数，在函数式编程中非常常见。

函数本身只是另一种类型的数据。因此，您可以编写返回其他函数的函数。当然，您仍然可以拥有一个接受 int 作为参数并返回其他内容的函数。将两者结合起来并考虑以下示例（在 python 中）：（

def mult_by(a):
    def _mult_by(x):
        return x*a
    return mult_by

mult_by_3 = mult_by(3)

print mylt_by_3(3)
9

很抱歉使用 python，但我不知道 f#）

Answer 10

这里已经有很多答案，但我想提供另一种看法。有时，用多种不同的方式解释同一件事可以帮助你“理解”它。

我喜欢将函数视为“你给我一些东西，我会给你一些其他东西”

所以一个 Func 表示“你给我一个 int，我给你一个 string”。

我还发现从“以后”的角度思考更容易：“当你给我一个整数时，我会给你一个字符串”。当您看到诸如 myfunc = x =>; 之类的内容时，这一点尤其重要。 y => x + y（“当你给出一个 x 时，你会得到一些东西，当你给出 ay 时会返回 x + y”）。

（顺便说一句，我假设您熟悉 C#）

所以我们可以表达您的 int ->整数-> int 示例为 Func>。

我看待 int -> 的另一种方式整数-> int 是通过提供适当类型的参数来剥离左侧的每个元素。当你不再有 -> 时，你就不再“稍后”了，你就得到了一个值。

---

（只是为了好玩），您可以将一个一次性接受所有参数的函数转换为“渐进式”接受它们的函数（渐进式应用它们的官方术语是“部分应用”），这称为“柯里化”：

static void Main()
{
    //define a simple add function
    Func<int, int, int> add = (a, b) => a + b;

    //curry so we can apply one parameter at a time
    var curried = Curry(add);    

    //'build' an incrementer out of our add function
    var inc = curried(1);         // (var inc = Curry(add)(1) works here too)
    Console.WriteLine(inc(5));    // returns 6
    Console.ReadKey();
}
static Func<T, Func<T, T>> Curry<T>(Func<T, T, T> f)
{
    return a => b => f(a, b);
}

Answer 11

这是我的 2c。默认情况下，F# 函数启用部分应用或柯里化。这意味着当您定义它时：

let adder a b = a + b;;

您正在定义一个函数，该函数接受整数并返回一个接受整数并返回整数的函数或int ->;整数-> int。然后，柯里化允许您部分地应用一个函数来创建另一个函数：

let twoadder = adder 2;;
//val it: int -> int

上面的代码将 a 预定义为 2，这样每当您调用 twoadder 3 时，它都会简单地将 2 添加到参数中。

函数参数用空格分隔的语法相当于以下 lambda 语法：

let adder = fun a -> fun b -> a + b;;

这是一种更易读的方式来确定两个函数实际上是链接的。