functional-programming - 在 OCaml 中实现 Okasaki 的自举堆，为什么不编译？

Question

(可以在 https://gist.github.com/4044467 找到一个最小的非编译示例，请参阅下面的更多背景信息。)

我正在尝试实现冈崎的纯功能数据结构第 10 章中介绍的引导堆。以下是我的非编译代码的简化版本。

我们要实现一个具有以下签名的堆:

module type ORDERED =
sig
  type t
  val compare : t -> t -> int
end

module type HEAP =
sig
  module Elem : ORDERED

  type heap

  val empty : heap
  val insert : Elem.t -> heap -> heap
  val find_min : heap -> Elem.t
  val delete_min : heap -> heap
end

我们说一个数据结构是 自举当它的实现依赖于同一种数据结构的另一个实现时。所以我们有一个这样的堆(实际的实现并不重要):

module SomeHeap (Element : ORDERED) : (HEAP with module Elem = Element) =
struct
  module Elem = Element

  type heap

  let empty = failwith "skipped"
  let insert = failwith "skipped"
  let find_min = failwith "skipped"
  let delete_min = failwith "skipped"
end 

然后，我们将要实现的引导堆，它可以依赖于任何堆实现，应该具有以下签名:

module BootstrappedHeap
  (MakeH : functor (Element : ORDERED) -> HEAP with module Elem = Element)
  (Element : ORDERED) : (HEAP with module Elem = Element)

所以我们可以这样使用它:

module StringHeap = BootstrappedHeap(SomeHeap)(String)

根据 Okasaki 的说法，BootstrappedHeap 的实现是这样的:

module BootstrappedHeap
  (MakeH : functor (Element : ORDERED) -> HEAP with module Elem = Element)
  (Element : ORDERED) : (HEAP with module Elem = Element) =
struct
  module Elem = Element

  module rec BootstrappedElem :
  sig
    type t =
      | E
      | H of Elem.t * PrimH.heap
    val compare : t -> t -> int
  end =
  struct
    type t =
      | E
      | H of Elem.t * PrimH.heap
    let compare t1 t2 = match t1, t2 with
      | H (x, _), H (y, _) -> Elem.compare x y
      | _ -> failwith "unreachable"
  end
  and PrimH : (HEAP with module Elem = BootstrappedElem) =
    MakeH(BootstrappedElem)

  type heap

  let empty = failwith "not implemented"
  let insert = failwith "not implemented"
  let find_min = failwith "not implemented"
  let delete_min = failwith "not implemented"
end

但这不是编译!错误信息是:

File "ordered.ml", line 52, characters 15-55:
Error: In this `with' constraint, the new definition of Elem
       does not match its original definition in the constrained signature:
       Modules do not match:
         sig type t = BootstrappedElem.t end
       is not included in
         ORDERED
       The field `compare' is required but not provided

第52行是行

and PrimH : (HEAP with module Elem = BootstrappedElem) =

我认为 BootstrappedElem确实实现了 ORDERED因为它同时具有 t和 compare ，但我看不出为什么编译器找不到 compare功能。

将 BootstrappedElem 的签名更改为

module rec BootstrappedElem : ORDERED

将使其编译，但这将隐藏类型构造函数 E和 T在 BootstrappedElem使后面的部分无法实现。

完整的非编译代码可以在 https://raw.github.com/gist/4044281/0ce0336c40b277e59cece43dbadb9b94ce6efdaf/ordered.ml 下载。

Answer 1

我相信这可能是类型检查器中的一个错误。我已将您的代码简化为以下示例:

module type ORDERED =
sig
  type t
  val compare : t -> t -> int
end


module type CARRY = sig
  module M : ORDERED
end

(* works *)
module HigherOrderFunctor
  (Make : functor (X : ORDERED) -> (CARRY with module M = X))
= struct
  module rec Base
    : (ORDERED with type t = string)
    = String
  and Other
    : (CARRY with module M = Base)
    = Make(Base)
end

(* does not work *)
module HigherOrderFunctor
  (Make : functor (X : ORDERED) -> (CARRY with module M = X))
= struct
  module rec Base
    : sig
      (* 'compare' seems dropped from this signature *)
      type t = string
      val compare : t -> t -> int
    end
    = String
  and Other
    : (CARRY with module M = (Base : sig type t = string val compare : t -> t -> int end))
    = Make(Base)
end

我不明白为什么第一个代码有效而第二个(似乎等效)无效。我建议您稍等一下，看看专家是否有解释(安德烈亚斯？)，然后考虑发送 a bug report .

在这种情况下，一种解决方案是首先绑定(bind)似乎处理不当的签名:

(* works again *)
module HigherOrderFunctor
  (Make : functor (X : ORDERED) -> (CARRY with module M = X))
= struct
  (* bind the problematic signature first *)
  module type S = sig
    type t = string
    val compare : t -> t -> int
  end

  module rec Base : S = String
  and Other : (CARRY with module M = Base) = Make(Base)
end

但是，这在您的设置中是不可能的，因为 BootstrappedElem 的签名与 BootstrappedHeap 相互递归.

一种解决方法是避免明显微妙的 with module ...构造并用简单的类型相等替换它 with type Elem.t = ... :

module BootstrappedHeap
  (MakeH : functor (Element : ORDERED) -> HEAP with module Elem = Element)
  (Element : ORDERED) : (HEAP with module Elem = Element) =
struct
  module Elem = Element

  module rec BootstrappedElem :
  sig
    type t =
      | E
      | H of Elem.t * PrimH.heap
    val compare : t -> t -> int
  end =
  struct
    type t =
      | E
      | H of Elem.t * PrimH.heap
    let compare t1 t2 = match t1, t2 with
      | H (x, _), H (y, _) -> Elem.compare x y
      | _ -> failwith "unreachable"
  end
  and PrimH : (HEAP with type Elem.t = BootstrappedElem.t) =
    MakeH(BootstrappedElem)

  type heap

  let empty = failwith "not implemented"
  let insert = failwith "not implemented"
  let find_min = failwith "not implemented"
  let delete_min = failwith "not implemented"
end

您还可以避免相互递归并同时定义 BootstrappedElem和 BootstrappedHeap在一个递归结中，通过定义 BootstrappedElem递归内 BootstrappedHeap .

module BootstrappedHeap
  (MakeH : functor (Element : ORDERED) -> HEAP with module Elem = Element)
  (Element : ORDERED) : (HEAP with module Elem = Element) =
struct
  module rec BootstrappedHeap : sig
    module Elem : sig
      type t = E | H of Element.t * BootstrappedHeap.heap
      val compare : t -> t -> int
    end        
    include (HEAP with module Elem := Elem)
  end = struct
    module Elem = struct
      type t = E | H of Element.t * BootstrappedHeap.heap
      let compare t1 t2 = match t1, t2 with
        | H (x, _), H (y, _) -> Element.compare x y
        | _ -> failwith "unreachable"
    end
    include (MakeH(Elem) : HEAP with module Elem := Elem)
  end

  module Elem = Element

  type heap

  let empty = failwith "not implemented"
  let insert = failwith "not implemented"
  let find_min = failwith "not implemented"
  let delete_min = failwith "not implemented"
end

这种风格自然对应于您嵌入 Elem 的决定。在 HEAP签名和使用 with module ...为细化。另一种解决方案是定义 HEAP作为返回签名的仿函数，用作 HEAP(Elem).S ，我想可以选择不同的递归样式。并不是说这样会更好:我认为“抽象模块”样式更方便。