Question

我是OCaml的新手，并试图了解仿函数。到目前为止，我有以下内容：

utop # module type Foo = sig
  type t = {
      foo : int;
      bar : int;
  }
  val create : int -> int -> t
  val get : t -> int
end;;

utop # module FooImpl = struct
  type t = {
      foo : int;
      bar : int;
  }
  let create x y = {
      foo = x;
      bar = y;
  }
  let get w = w.foo
end;;

现在我将尝试定义我的仿函数，它将对Foo类型的模块进行操作并替换get函数。

utop # module Functor (F : Foo) : Foo with type t := F.t = struct
  let create = F.create
  let get w = w.bar
end;;
Error: Unbound record field bar

它不知道记录的类型。我会尝试定义它：

utop # module Functor (F : Foo) : Foo with type t := F.t = struct
  type t = {
      foo : int;
      bar : int;
  }
  let create = F.create
  let get w = w.bar
end;;
Error: Signature mismatch:                                                                                                                ...                                                                                                                                Values do not match:
     val get : t -> int
   is not included in
     val get : F.t -> int

因此，OCaml不知道t和F.t实际上是同一类型。所以我会试着说：

utop # module Functor (F : Foo) : Foo with type t := F.t = struct
  type t = F.t
  let create = F.create
  let get w = w.bar
end;;
Error: Unbound record field bar

我做错了什么？

Answer 1

字段名称属于定义它们的模块的范围。例如，如果您在模块Foo

中定义记录

module Foo = struct
  type t = { bar : int; baz : int; quz : int }
end

然后，为了访问模块Foo之外的这些字段，您需要使用完全限定的名称，例如

let bar_of_foo x = x.Foo.bar

在模式匹配中，字段名称也可以限定，这允许按如下方式编写上述函数：

let bar_of_foo {Foo.bar} = bar

您只需要限定一个名称，因此当您需要一次访问多个字段时，此语法很有用：

let sum_of_foo {Foo.bar; baz; quz} = bar + baz + quz

最后，您可以open模块将记录名称带到当前范围。您可以使用本地开放语法Foo.(expr)来本地化开放的影响：

 let bar_of_foo x = Foo.(x.bar)

在您的示例字段中，模块F中定义了作为仿函数Functor的参数的字段。因此，您需要使用上述方法之一来访问它的字段，例如，

module Functor (F : Foo) : Foo with type t := F.t = struct
 open F
 let create = F.create
 let get w = w.bar
end

Answer 2

如果我像这样定义get，那么您首次尝试定义Functor是有用的：

let get w = w.F.bar

这是我的全部会议：

# module type Foo = sig (... ELIDED...) end;;
module type Foo =
  sig
    type t = { foo : int; bar : int; }
    val create : int -> int -> t
    val get : t -> int
  end
# module FooImpl = struct (...ELIDED...) end;;
module FooImpl :
  sig
    type t = { foo : int; bar : int; }
    val create : int -> int -> t 
    val get : t -> int
  end
# module Functor (F: Foo) : Foo with type t := F.t = struct 
    let create = F.create 
    let get w = w.F.bar 
end;;
module Functor :
  functor (F : Foo) ->
    sig val create : int -> int -> F.t val get : F.t -> int end
# module F2 = Functor(FooImpl);;
module F2 :
  sig val create : int -> int -> FooImpl.t val get : FooImpl.t -> int end
# let c1 = FooImpl.create 8 9;;
val c1 : FooImpl.t = {FooImpl.foo = 8; bar = 9}
# FooImpl.get c1;;
- : int = 8
# let c2 = F2.create 8 9;;
val c2 : FooImpl.t = {FooImpl.foo = 8; bar = 9}
# F2.get c2;;
- : int = 9

Functors - 导入类型

2 个答案: