Fatal编程技术网
  • ocaml/
  • 此OCaml表达式的参数类型为非'；t定义为AFAIK，为什么另一个表达式有'_a而不是'；A.

此OCaml表达式的参数类型为非'；t定义为AFAIK，为什么另一个表达式有'_a而不是'；A.

ocaml

此OCaml表达式的参数类型为非'；t定义为AFAIK，为什么另一个表达式有'_a而不是'；A.,ocaml,type-inference,Ocaml,Type Inference,我明白了 let apply f x = f x 有类型 ('a -> 'b) -> 'a -> 'b apply是一个函数，它接受函数f和参数x，并返回应用于x的f。因此，如果fx具有类型'b并且x具有类型'a，那么f必须具有类型'a->'b，因此您可以将它们组合起来得到（'a->'b>）-'a->'b。我明白了。通过扩展，let identity f=f具有类型'a->'a，因为它接受类型为'a'的项，并返回类型为'a的相同项，所以它的类型为'a->'a。我明白了 le

我明白了

let apply f x = f x
有类型

('a -> 'b) -> 'a -> 'b

apply
是一个函数，它接受函数
f
和参数
x
，并返回应用于
x
的
f
。因此，如果
fx
具有类型
'b
并且
x
具有类型
'a
，那么
f
必须具有类型
'a->'b
，因此您可以将它们组合起来得到
（'a->'b>）-'a->'b
。我明白了。通过扩展，
let identity f=f
具有类型
'a->'a
，因为它接受类型为
'a'
的项，并返回类型为
'a
的相同项，所以它的类型为
'a->'a
。我明白了

let bf b f = if (f b) then f else (fun x -> b)
是一种

bool -> (bool -> bool) -> bool -> bool

fb
必须为
bool
类型，因此
f
为
'a->bool
，
b
为
'a
类型<类型为
'a->bool
的code>f与
funx->b
的类型相同，即
'c->'a
。所以，
'c='a=bool
，所以
bf
接受
bool
，然后是
f
的类型，即
bool->bool
，并返回
bool->bool
，作为最后一种

bool -> (bool -> bool) -> bool -> bool
我必须找到一种

let t1 = apply bf
与应用bf的类型相同

因此，
apply f
是
'a->'a
如果
f
具有类型
'a
，那么我希望
apply bf
具有
类型（bf）->类型（bf）
，这将是

bool -> (bool -> bool) -> bool -> bool -> bool -> (bool -> bool) -> bool -> bool
显然，
apply bf
属于
bool->（bool->bool）->bool->bool
类型，我不明白为什么会这样

我也不明白
'a
类型和
'u a
类型之间的区别

如果
让应用fx=fx
，则
应用
具有类型
（'a->'b）->'a->'b
，并且
让app2=apply应用
具有类型

('_a -> '_b) -> '_a -> '_b
如果有人能帮助我理解为什么会这样，这样我就不会在没有理解的情况下简单地提交答案而感到迷失，那将不胜感激

我希望apply bf具有type（bf）->type（bf）

这是错误的。首先请注意，应用程序的键入规则是

f   : A -> B
x   : A
-------------
f x : B
在你的例子中，多态性在起作用，但想法是一样的

apply    : ('a -> 'b) -> ('a -> 'b)
bf       :   A -> B
------------------------------------
apply    : (A -> B) -> (A -> B)
bf       :  A -> B
------------------------------------
apply bf :  A -> B
我也不明白“a型”和“a型”之间的区别

符号
“\u a
表示虚拟类型，以及“值限制”的结果，该“值限制”表示只有值表达式可以是多态的。参见

描述的另一种方式是，它表示任意类型，但仅表示一种特定类型。也就是说，它是一个单态变量。这种机制比简单地拒绝违反值限制的代码更灵活。谢谢。另一个函数呢：
让wfx=x（fx）
。我得到
fx
有类型
B
，
x
有类型
A
，因此
f
有类型
A->B
。然而，然后
x
也必须是
B->C
类型，因为它的右侧是
B
，这意味着
A
=
B->C
，所以
f
实际上是
B->C->B
类型<代码>w属于
（（a->b）->a）->（a->b）->b
类型。如果说
a
是更大的东西这一事实很奇怪的话，那么这一点应该是一致的。我不知道如何推导。我发现的另一个例子是
（a->（b->a））->b->a->b
，但这并不好。然后你有
f:a->b
和
x:C->D
，因为它们都是函数。由于
x
是
fx
中
f
的输入，因此
A=C->D
。既然
fx
是
x
的输入，那么
B=C
。所以我们有
f：（C->D）->C
和
x:C->D
。所以
w:（（C->D）->C）->（C->D）->D
。