使用模块签名时出现未绑定的构造函数错误

Question

module type Cont_map = sig
  type t
  type key
  type value = key (* values are the same type as keys *)
  val empty : t

  val lookup : key -> t -> value option

  val insert : key -> value -> t -> t

  val remove : key -> t -> t * value option

  val lub_key : key -> t -> key option

  val glb_key : key -> t -> key option

  val interpolated_lookup : key -> t -> value option

end

module Cont_map (Key : Interp with type t = float) : Cont_map = struct 
  type t = 
    | Leaf 
    | Branch of Key.t * Key.t * t * t

  type key = Key.t
  type value = key

  let empty = Leaf

  let rec lookup k dmap = 
    match dmap with
    | Leaf -> None
    | Branch (kk, vv, l, r) -> if k < kk then lookup k l else if k > kk then lookup k r else Some(vv)

  let rec insert kk vv dmap = 
    match dmap with
    | Leaf -> Branch (kk, vv, Leaf, Leaf)
    | Branch (k, v, l, r) -> 
      if kk < k then Branch (k, v, insert kk vv l, r)
      else if kk = k then Branch (k, vv, l, r)
      else Branch (k, v, l, insert kk vv r)

  let remove kk dmap = 
    let rec max_key (d: t) = 
      match d with
      | Leaf -> None
      | Branch (key, value, _, right) -> 
        match right with
        | Leaf -> Some(key, value)
        | Branch (_, _, _, _) -> max_key(right)
    in
    let rec remove_internal kk map =
      match map with
      | Leaf -> remove_internal kk map
      | Branch (k, v, l, r) -> 
        if kk < k then Branch (k, v, remove_internal kk l, r)
        else if kk = k then 
          match max_key(l) with
          | Some(key, value) -> Branch (key, value, remove_internal key l, r)
          | None -> r
        else Branch (k, v, l, remove_internal kk r)
    in
    match lookup kk dmap with
    | None -> (dmap, None)
    | Some(v) -> (remove_internal kk dmap, Some(v))
    
  let rec lub_key kk map = 
    let rec max_key (d: t) = 
      match d with
      | Leaf -> None
      | Branch (key, _, _, right) -> 
        match right with
        | Leaf -> Some(key)
        | Branch (_, _, _, _) -> max_key(right)
    in
    match map with
    | Leaf -> None
    | Branch (k, _, l, r) -> if kk < k then
      match max_key(l) with
      | None -> Some(k)
      | Some(kkk) -> if kkk < kk then Some(k) else lub_key kk l 
  else if kk = k then Some(k) else lub_key kk r

  let rec glb_key kk map =
    let rec min_key (d: t) = 
      match d with
      | Leaf -> None
      | Branch (key, _, left, _) -> 
        match left with
        | Leaf -> Some(key)
        | Branch (_, _, _, _) -> min_key(left)
    in
    match map with
    | Leaf -> None
    | Branch (k, _, l, r) -> if kk < k then glb_key kk l else if kk = k then Some(k)
    else match min_key(r) with
    | None -> Some(k)
    | Some(kkk) -> if kkk <= kk then glb_key kk r else Some(k)

  let interpolated_lookup kk map = 
    match lub_key kk map with
    | None -> None
    | Some(rk) -> match glb_key kk map with
                  | None -> None
                  | Some(lk) -> match lookup lk map, lookup rk map with
                                | Some(lv), Some(rv) -> Some(Key.interpolate (lk, lv) (rk, rv) kk)
                                | _ -> failwith "Can't reach here"

end

module Float_cont_map = Cont_map (Float_interp)

以上是我在一个名为 abstraction.ml 的文件中的代码

open Core;;
open OUnit2;;

module M = Abstraction.Cont_map(Abstraction.Float_interp);;

let empty = M.empty

let d1 = M.(Branch (1.0, 1.0, Leaf, Branch (2.0, 2.0, Leaf, Branch (3.0, 3.0, Leaf, Branch (4.0, 4.0, Leaf, Leaf)))))

这是我的名为 tests.ml 的测试文件

(test
 (name tests)
 (libraries 
  core
  ounit2
  abstraction
 ))

这是我在测试目录中的沙丘文件。

但是，它称之为“未绑定构造函数分支”。在下面的代码中，我写道：

let test_lookup _ = 
  assert_equal None @@ (M.lookup 1. empty);
  assert_equal (Some(1.0)) @@ (M.lookup 1. d1)

它没有说 M.lookup 未绑定值，但它说预期的 M.value 类型但获得浮动。

Answer 1

与函数类似，例如 empty，构造函数，例如 Leaf 也是签名的一部分。因此，当您使用缺少构造函数的签名来约束您的模块类型时，您实际上是对模块的用户隐藏了它。

您应该将它们公开，例如，

module type Cont_map = sig
  type key
  type t = 
   | Leaf 
   | Branch of key * key * t * t

但这会破坏模块的抽象，因为您不希望用户直接创建容器。所以正确的方法是使用模块的公共接口来创建容器，即使用empty 和insert。

您还可以使用inline_tests 并在您的模块内部测试容器模块的实现，您可以在其中访问您的构造函数。