有人可以解释一下这个 OCaml 程序中使用的类型语法吗？

以下类型取自这个问题 https://stackoverflow.com/q/50586942/633183

(* contains an error, later fixed by the OP *)
type _ task =
| Success : 'a -> 'a task
| Fail : 'a -> 'a task
| Binding : (('a task -> unit) -> unit) -> 'a task
| AndThen : ('a -> 'b task) * 'a task -> 'b task
| OnError : ('a -> 'b task) * 'a task -> 'b task

type _ stack =
| NoStack : 'a stack
| AndThenStack : ('a -> 'b task) * 'b stack -> 'a stack
| OnErrorStack : ('a -> 'b task) * 'b stack -> 'a stack

type 'a process = 
{ root: 'a task 
; stack: 'a stack 
}

我对 OCaml 比较陌生，但我从未见过:语法与之前一样使用。例如，我见过这样定义的多态类型，使用of syntax

type 'a expr =
    | Base  of 'a
    | Const of bool
    | And   of 'a expr list
    | Or    of 'a expr list
    | Not   of 'a expr

在最初的问题中，我不清楚这些变体是如何构造的，因为看起来每个变体都不接受参数。以这个简化的例子为例

type 'a stack =
  | Foo : int stack
  | Bar : string stack
;;
type 'a stack = Foo : int stack | Bar : string stack

尝试制作一个int stack using Foo

Foo 5;;
Error: The constructor Foo expects 0 argument(s),
       but is applied here to 1 argument(s)

然而，无需争论

Foo;;
- : int stack = Foo

好的，但是在哪里int？如何存储这种类型的数据？

在下面的OP程序中，他/她“正常”匹配类型，例如Success value -> ... or Fail value -> ...。同样，如果变体构造函数不接受参数，如何构造该值？

let rec loop : 'a. 'a process -> unit = fun proc ->
match proc.root with
| Success value -> 
    let rec step = function
    | NoStack -> ()
    | AndThenStack (callback, rest) -> loop {proc with root = callback value; stack = rest }
    | OnErrorStack (_callback, rest) -> step rest  <-- ERROR HERE
    in
    step proc.stack
| Fail value -> 
    let rec step = function
    | NoStack -> ()
    | AndThenStack (_callback, rest) -> step rest
    | OnErrorStack (callback, rest) -> loop {proc with root = callback value; stack = rest }
    in
    step proc.stack
| Binding callback -> callback (fun task -> loop {proc with root = task} )
| AndThen (callback, task) -> loop {root = task; stack = AndThenStack (callback, proc.stack)}
| OnError (callback, task) -> loop {root = task; stack = OnErrorStack (callback, proc.stack)}

有人可以帮助我填补我的知识空白吗？

这些类型是广义代数数据类型。也称为GADTs http://caml.inria.fr/pub/docs/manual-ocaml/extn.html#sec251。 GADT 使得细化构造函数和类型之间的关系成为可能。

在您的示例中，GADT 被用作引入存在量化类型的一种方式：删除不相关的构造函数，可以编写

type 'a task =
| Done of 'a
| AndThen : ('a -> 'b task) * 'a task -> 'b task

Here, AndThen是一个带有两个参数的构造函数：类型的回调'a -> 'b task and a 'a task并返回一个类型的任务'b task。这个定义的一个显着特征是类型变量'a只出现在构造函数的参数中。一个自然的问题是我是否有价值AndThen(f,t): 'a task，什么类型f?

答案是，类型f部分未知，我只知道有一种类型ty使得两者f: ty -> 'a task and t: ty。但此时所有信息都超出了单纯存在的范围ty已丢失。由于这个原因，类型ty称为存在量化类型。

但在这里，这个小信息仍然足以有意义地操纵这样的值。我可以定义一个函数步骤

let rec step: type a. a task -> a task = function
| Done _ as x -> x
| AndThen(f,Done x) -> f x
| AndThen(f, t) -> AndThen(f, step t)

尝试应用该功能f在构造函数中AndThen如果可能的话， 使用构造函数之外的信息AndThen始终存储兼容的回调和任务对。

例如

let x: int task = Done 0
let f: int -> float task =  fun x -> Done (float_of_int (x + 1))
let y: float task = AndThen(f,x)
;; step y = Done 1.