Ocaml 中的高阶类型构造函数和函子

Question

可以以下多态函数

let id x = x;;
let compose f g x = f (g x);;
let rec fix f = f (fix f);;     (*laziness aside*)

为类型/类型构造函数或模块/函子编写？我试过了

type 'x id = Id of 'x;;
type 'f 'g 'x compose = Compose of ('f ('g 'x));;
type 'f fix = Fix of ('f (Fix 'f));;

对于类型，但它不起作用。

这是用于类型的 Haskell 版本：

data Id x = Id x
data Compose f g x = Compose (f (g x))
data Fix f = Fix (f (Fix f))

-- examples:
l = Compose [Just 'a'] :: Compose [] Maybe Char

type Natural = Fix Maybe   -- natural numbers are fixpoint of Maybe
n = Fix (Just (Fix (Just (Fix Nothing)))) :: Natural   -- n is 2

-- up to isomorphism composition of identity and f is f:
iso :: Compose Id f x -> f x
iso (Compose (Id a)) = a

Answer 1

Haskell 允许更高种类的类型变量。 ML 方言，包括 Caml，只允许类型变量“*”。翻译成简单的英文，

• 在 Haskell 中，类型变量 g 可以对应于“类型构造函数”，例如 Maybe 或 IO 或列表。因此，如果 g 是 Maybe 并且 x 是 Integer，则您的 Haskell 示例中的 g x 可以（行话：“善意”）。

1234563因此，永远尝试将类型变量应用于另一种类型是正确的。

据我所知，ML 中的这种限制没有深层原因。最可能的解释是历史偶然性。当 Milner 最初提出他关于多态性的想法时，他使用了非常简单的类型变量，只代表种类 * 的单型。 Haskell 的早期版本也是这样做的，然后 Mark Jones 发现推断类型变量的种类实际上非常容易。 Haskell 很快被修改为允许更高种类的类型变量，但 ML 从未赶上。

INRIA 的人员对 ML 进行了许多其他更改，我有点惊讶他们从未进行过此更改。当我在 ML 中编程时，我可能会喜欢拥有更高种类的类型变量。但是它们不存在，而且我不知道有什么方法可以对您正在谈论的示例进行编码，除非使用 functors。

Answer 2

您可以在 OCaml 中做类似的事情，使用模块代替类型，使用函子（高阶模块）代替高阶类型。但它看起来更丑，而且没有类型推断能力，所以你必须手动指定很多东西。

module type Type = sig
  type t
end

module Char = struct
  type t = char
end

module List (X:Type) = struct
  type t = X.t list
end

module Maybe (X:Type) = struct
  type t = X.t option
end

(* In the following, I decided to omit the redundant
   single constructors "Id of ...", "Compose of ...", since
   they don't help in OCaml since we can't use inference *)

module Id (X:Type) = X

module Compose
  (F:functor(Z:Type)->Type)
  (G:functor(Y:Type)->Type)
  (X:Type) = F(G(X))

let l : Compose(List)(Maybe)(Char).t = [Some 'a']

module Example2 (F:functor(Y:Type)->Type) (X:Type) = struct
  (* unlike types, "free" module variables are not allowed,
     so we have to put it inside another functor in order
     to scope F and X *)
  let iso (a:Compose(Id)(F)(X).t) : F(X).t = a
end

Answer 3

嗯...我不是高阶类型的专家，也不是 Haskell 编程专家。 但这对于 F#（即 OCaml）来说似乎没问题，你可以使用这些吗：

type 'x id = Id of 'x;;
type 'f fix = Fix of ('f fix -> 'f);;
type ('f,'g,'x) compose = Compose of ('f ->'g -> 'x);;

最后一个我包装成元组，因为我没有想出更好的...

Answer 4

你可以做到，但你需要做点小把戏：

newtype Fix f = In{out:: f (Fix f)}

您可以在之后定义 Cata：

Cata :: (Functor f) => (f a -> a) -> Fix f -> a
Cata f = f.(fmap (cata f)).out

这将为所有函子定义一个通用的变态，您可以使用它来构建自己的东西。示例：

data ListFix a b = Nil | Cons a b
data List a = Fix (ListFix a)
instance functor (ListFix a) where
fmap f Nil = Nil
fmap f (Cons a lst) = Cons a (f lst)