由函子构建的两个模块之间的类型关系

Question

我定义了几个签名和模块，如下：

module type MATRIX =
sig
  type 'a t
  val init: 'a -> 'a t
end

module type MMM =
sig
  type 'a t
end

module type AMATRIX =
sig
  include MATRIX
  module Mmm : MMM
  module Matrix: MATRIX
  val mmm_of_amatrix: 'a t -> int -> int -> 'a Mmm.t
end

module type AREAMMM =
sig
  type t
  module Mmm: MMM
  val make: int Mmm.t -> t
end

module MatrixArray: MATRIX =
struct
  type 'a t = 'a array array
  let init (e: 'a) : 'a t = failwith "to do"
end

module MmmArray: MMM =
struct
  type 'a t = 'a array array
end

和两个函子：

module AMatrixFun: functor (Mmm: MMM) -> functor (Matrix: MATRIX) -> AMATRIX
  with
    module Mmm = Mmm
  and
    module Matrix = Matrix =
      functor (Mmm: MMM) -> functor (Matrix: MATRIX) ->
    struct
      include MatrixArray
      module Mmm = Mmm
      module Matrix = Matrix
      let mmm_of_amatrix (m: 'a t) (nr_i: int) (nc_i: int) : 'a Mmm.t = failwith "to do"
    end

module AreaMmmFun : functor (Mmm: MMM) -> AREAMMM
  with module Mmm = Mmm =
    functor (Mmm: MMM) ->
  struct
    type t
    module Mmm = Mmm
    let make (x: int Mmm.t) : t = failwith "to do"
  end

以及带有一些模块的应用函子：

module AMatrix  = AMatrixFun(MmmArray)(MatrixArray)
module AreaMmm  = AreaMmmFun(MmmArray)

let a = AMatrix.mmm_of_amatrix (AMatrix.init 5) 0 0
let b = AreaMmm.make a

编译在这段代码上运行良好。但是，如果我将最后一部分更改为

module AMatrix : AMATRIX = AMatrixFun(MmmArray)(MatrixArray)
module AreaMmm : AREAMMM = AreaMmmFun(MmmArray)

let a = AMatrix.mmm_of_amatrix (AMatrix.init 5) 0 0
let b = AreaMmm.make a

编译在最后一行停止，并给出：

File "lib/tools.ml", line 69, characters 21-22:
Error: This expression has type int AMatrix.Mmm.t
       but an expression was expected of type int AreaMmm.Mmm.t

我真的想将 : AMATRIX 添加到 AMatrix 和 : AREAMMM 到 AreaMmm，因为这确保我这两个模块受到这两个签名的约束。有人可以帮忙吗？

Answer 1

我仍然不知道你想要实现什么，但如果你的目标是在模块之间实现某种继承（正如你在之前的一些线程标题中所说），你可能需要使用递归模块。

例如，您首先定义模块层次结构：这里 S 是初始模块签名，可以通过 S1 和 S2 扩展：

module type S = sig
  type 'a t
end

module type S1 = sig
  include S
  val f: 'a -> 'a t
end

module type S2 = sig
  include S
  val g: 'a t -> 'a
end

然后，您创建具体的实现，它准确定义了 'a t，并实现了 S1 和 S2 所需的所有函数：

module Concrete = struct
  type 'a t = 'a array
  let f a = [| a |] (* fill with the right contents *)
  let g a = a.(0)   (* fill with the right contents *)
end

然后，您将类型 'a t 抽象出来通过使用正确的签名来限制实施。您在这里需要递归模块（请注意 rec 关键字）：

module rec I : S = Concrete
and I2 : S2 with type 'a t = 'a I.t = Concrete
and I1 : S1 with type 'a t = 'a I.t = Concrete

您可以测试您的结果：

let a = I2.g (I1.f 0)

它按预期返回 0。

Answer 2

您的应用程序需要知道AMatrix.Mmm.t与AreaMmm.Mmm.t相同，因为否则您将无法在另一个模块提供的函数中使用一个模块创建的值。

正如我之前所解释的，如果您断言 module AMatrix : AMATRIX ，那么您将丢弃 AMATRIX< 中未包含的有关 AMatrix 内容的任何其他信息/代码>。特别是，由于 AMATRIX 没有提及 AMatrix.Mmm.t 与 AreaMmm.Mmm.t 相同，因此该信息会丢失并且该代码无法编译。

你应该断言的是：

module AMatrix : AMATRIX 
  with module Mmm = MmmArray 
   and module Matrix = MatrixArray