Question

问题

我遇到的一个问题是将两个模块的类型和值带入一个新的组合模块。我举个例子。目前我有以下两种类型签名

module type Ordered =
 sig
  type t (* the type of elements which have an order *)
  val eq : t * t -> bool
  val lt : t * t -> bool
  val leq : t * t -> bool
 end

module type Stack =
 sig
  exception Empty 
  type 'a t (* the type of polymorphic stacks *)

  val empty  : 'a t
  val isEmpty : 'a t -> bool

  val cons  : 'a * 'a t -> 'a t
  val head  : 'a t -> 'a
  val tail  : 'a t -> 'a t
 end

我想创建一个“有序基本元素的堆栈”模块，即

module type OrderedStack =
 sig 
  exception Empty

  type elem (* the type of the elements in the stack *)
  val eq : elem * elem -> bool
  val lt : elem * elem -> bool
  val leq : elem * elem -> bool

  type t (* the type of monomorphic stacks *)
  val empty  : t
  val isEmpty : t -> bool
  val cons  : elem * t -> t
  val head  : t -> elem
  val tail  : t -> t
 end

到此为止，一切都很好，整洁。但现在，我想编写一个带有Ordered模块和Stack模块并生成OrderedStack模块的仿函数。像

这样的东西

module My_functor (Elem : Ordered) (St : Stack): OrderedStack  = 
 struct
  exception Empty

   type elem = Elem.t
  let eq = Elem.eq
  let lt = Elem.lt
  let leq = Elem.leq

  type t = elem St.t
  let empty = St.empty
  let isEmpty = St.isEmpty
  let cons = St.cons
  let head = St.head
  let tail = St.tail
 end

这正是我想要的，也是正确的。但它看起来像是对键盘的极大浪费。

我的问题

是否有更紧凑的方式来编写上面的My_functor？

我发现但无法投入工作

我已经看到了include指令，我可以在其中编写类似的内容：

module my_functor (Elem : Ordered) (St : Stack): OrderedStack  = 
 struct
  include Elem
  include St
 end

但是这有一个问题，对于我上面特定的两个模块，Ordered和Stack都有相同的type t（尽管它们在每个模块中都有不同的含义）。我不想更改Ordered和Stacks的原始定义，因为它们已经在代码的许多部分中使用，但如果您找到原始的两个模块的替代配方，使其工作，没关系。

我也看到with operator可能与此相关，但我无法弄清楚如何使用它来产生预期的效果。我面临的问题是两个模块t和'a t的类型Ordered和Stacks并且实际上已连接。

有什么想法吗？

Answer 1

OrderedStack重用Ordered定义，类型略有不同（elem而不是t）。这是一种冗余的原因。

您可以直接重用OrderedStack来使用此Ordered签名：

module type OrderedStack = sig
    module Elem : Ordered

    type t
    val empty       : t
    val isEmpty     : t -> bool
    val cons        : Elem.t * t -> t
    val head        : t -> Elem.t
    val tail        : t -> t
end

另一个冗余来源是您从参数类型'a Stack.t移动到单形OrderedStack.t。这两种类型不能相提并论，它们根本不具有可比性，因此必须在这里进行翻译。

请注意，您可以将从（多态）Stack到OrderedStack的移动分解为一个中间堆栈，（单态）MonoStack：

module type MonoStack = sig
  type elem
  type t
  val empty       : t
  val isEmpty     : t -> bool
  val cons        : elem * t -> t
  val head        : t -> elem
  val tail        : t -> t
end

module type OrderedStack = sig
  module Elem : Ordered
  module Stack : MonoStack with type elem = Elem.t
end

修改

如果您不喜欢使用子模块的额外间接，这会增加一些语法负担，则可以包含模块而不是链接到它们。但正如你所注意到的那样，这个问题就是名称冲突。从OCaml 3.12开始，我们的工具集中有一个新的构造，它允许重命名签名的类型组件以避免冲突。

module type OrderedStack = sig type elem include Ordered with type t := elem include MonoStack with type elem := elem end

第二次修改

好的，我提出了以下解决方案来引导Stack / MonoStack桥。但坦率地说，这是一个黑客，我认为这不是一个好主意。

module type PolyOrderedStack = sig module Elem : Ordered type t type 'a const = t module Stack : Stack with type 'a t = 'a const end (* 3.12 only *) module type PolyOrderedStack = sig type elem include Ordered with type t := elem type t type 'a const = t include Stack with type 'a t := 'a const end

OCaml模块：将来自不同模块的（互连）类型引入新模块

问题

我的问题

我发现但无法投入工作

1 个答案: