F#简单签名

我发现了类似的东西，但不完全是我要找的

为什么

let map x f = f x

返回

val map : 'a -> ('a -> 'b) -> 'b

 val merge : f:('a -> 'b -> 'b) -> xs:'a list -> a:'b -> 'b

及

返回

val map : 'a -> ('a -> 'b) -> 'b

 val merge : f:('a -> 'b -> 'b) -> xs:'a list -> a:'b -> 'b

及

返回

val merge2: f:('a -> 'b -> 'a) -> a:'a -> _arg1:'b list -> 'a

---

谢谢你的澄清。

好的，我给你看第一个，然后你可以检查其他的

请注意您是如何执行的

fx

这意味着

f

是一个函数（对于某些

'a

和

'b

而言，它始终具有签名

'a->'b

）

现在，

x

是

f

的参数，它必须与我在这里命名为

'a

的

f

的输入具有相同的类型

现在，

fx

的结果当然是类型

'b

现在把它们放在一起：

• map

  接受两个参数：

  • x:'a

  • 和

    f:'a->'b

• 并且具有结果类型

  'b

• 所以它有签名

  map:'a->（'a->'b）->

  b`

---

对于你的观点，这里有同样的论点

首先查看匹配的第一个案例：

• 它匹配一个空列表，因此

  xs

  可能是某种类型的列表

  'a

  ：

  xs:'a list

• 它返回的

  a

  具有某种未知类型

  'b

  ，这也是匹配的结果，因此

  合并
  本身！

现在转到第二行：

由于

xs

具有类型

'a列表

现在您必须具有

• y:'a

• ys:'列表

因此，您将a

'a

和a

'b

插入

f

，并将其结果返回到

匹配
和
合并
（正如我们所看到的，其返回类型为
'b
）

您现在看到，
f
必须具有类型
f:'a->'b->'b
，如果您组装了
merge


旁注
还记得我是如何声称每个函数对某些类型都有签名的吗？现在我写的是像这样的东西

如果您将最后一个读作
'a->（'b->'b）
，这确实是一致的，当然这正是我们所说的：如果您可以只返回函数，就不需要具有多个参数的函数，只要您不深入研究生成的IL，就应该考虑F#正是这样做的；）


我认为你会自己处理最后一个问题——试试看，如果你有问题，请编辑你的问题，指出你的问题，我们会提供帮助；）
 好的，我给你看第一个，然后你可以检查其他的

请注意您是如何执行的
fx
这意味着
f
是一个函数（对于某些
'a
和
'b
而言，它始终具有签名
'a->'b
）

现在，
x
是
f
的参数，它必须与我在这里命名为
'a
的
f
的输入具有相同的类型

现在，
fx
的结果当然是类型
'b

现在把它们放在一起：


map
接受两个参数：

x:'a
和
f:'a->'b

并且具有结果类型
'b
所以它有签名
map:'a->（'a->'b）->
b`


对于你的观点，这里有同样的论点

首先查看匹配的第一个案例
：


它匹配一个空列表，因此
xs
可能是某种类型的列表
'a
：
xs:'a list
它返回的
a
具有某种未知类型
'b
，这也是匹配的结果，因此
合并
本身！


现在转到第二行：

由于
xs
具有类型
'a列表
现在您必须具有


y:'a
ys:'列表

因此，您将a
'a
和a
'b
插入
f
，并将其结果返回到
匹配
和
合并
（正如我们所看到的，其返回类型为
'b
）

您现在看到，
f
必须具有类型
f:'a->'b->'b
，如果您组装了
merge


旁注
还记得我是如何声称每个函数对某些类型都有签名的吗？现在我写的是像这样的东西

如果您将最后一个读作
'a->（'b->'b）
，这确实是一致的，当然这正是我们所说的：如果您可以只返回函数，就不需要具有多个参数的函数，只要您不深入研究生成的IL，就应该考虑F#正是这样做的；）


我认为你会自己处理最后一个问题——试试看，如果你有问题，请编辑你的问题，指出你的问题，我们会提供帮助；）
 多谢各位。这仍然有点让人困惑，但你已经说得很清楚了。谢谢。这仍然有点让人困惑，但你已经说得很清楚了。
let rec merge f xs a =
      match xs with
      | []    -> a
      | y::ys -> f y (merge f ys a);;