3

我有这种 OO 情况，我试图在 Ocaml 中实现：两个类X1和X2，都是子类型X（X1 <: X和X2 <: X），我想编写一个动态返回一个的函数，X它可以是 anX1或 an X2。

但是我听说避免使用 Ocaml 中的类并改用模块通常很好，所以我试图像这样表示我的问题（过于简化但仍然很重要）：两个模块X1和X2，我希望我的函数在返回一个X1.t或一个X2.t。

module type X = sig
  type choice
  type t
  (* some methods we don't care about in this instance, like
     val modifySomething : t -> t *)
end

module Xbase = struct
  type choice = Smth | SmthElse
end

module X1 = (
struct
  include Xbase
  type t = { foo : int; bar : int }
end : X)

module X2 = (
struct
  include Xbase
  type t = { foo : int; star : int }
end : X)

module XStatic =
struct
  (* construct either an X1.t or X2.t from the string *)
  let read : string -> 'a =
    function
    | "X1" -> { X1.foo = 0, bar = 0 }
    | "X2" -> { X2.foo = 1, star = 1 }
end

但这Error: Unbound record field label X1.foo在read功能中失败了。我尝试了不同的排列方式，例如使用let open X1 in { foo = 0, ... }但无济于事。

我的方法是从根本上错误的（即我应该使用类，因为这对模块来说是不可能/不切实际的）还是我只是错过了一些微不足道的东西？

编辑：澄清了我要解决的问题并重命名module X为module XBase以区别于module type X.

4

3 回答 3

6

最简单的方法是使用 sum 类型（免责声明：我没有尝试编译代码）：

module X1 = struct
  type t = { foo : int; bar : string }
  let modify_foo = ...
end
module X2 = struct
  type t = { foo : int; star : bool }
  let modify_foo = ...
end
type x1_or_x2 =
  | Left of X1.t
  | Right of X2.t

let read = function
  | "X1" -> Left { X1.foo = 1; bar = "bar" }
  | "X2" -> Right { X2.foo = 1; star = true }

let modify_foo = function
  | Left x1 -> Left (X1.modify_foo x1)
  | Right x2 -> Right (X2.modify_foo x2)

如果您想利用这一事实X1.t并X2.t共享一些共同的结构，您可以分解类型。这个想法是它们分别与产品类型同构common_part * specific_to_x1和common_part * specific_to_x2。因此x1_or_x2类型是(common * specific_to_x1) + (common * specific_to_x2)，相当于common * (specific_to_x1 + specific_to_x2)。

type common = { foo : int }
let modify_foo_common : common -> common = ...

type specific_x1 = { bar : string }
type specific_x2 = { star : bool }

type x1_or_x2 = common * specific_x1_or_x2
and specific_x1_or_x2 =
  | Left of X1.t
  | Right of X2.t

let read = function
  | "X1" -> { foo = 1 }, Left { bar = "bar" }
  | "X2" -> { foo = 1 }, Right { star = true }

let modify_foo (common, specific) = (modify_foo_common common, specific)

这样，作用于公共部分的定义不会重复，而是可以声明一次。

PS：另请参阅这个非常相关的问题，您可能对此感兴趣并且有一个很好的答案（镜头！）：Ptival：静态“扩展”一个记录式数据类型而没有间接麻烦

于 2012-12-10T14:06:01.207 回答
1

一旦您将模块强制转换为模块类型X1，您就失去了在这些模块之外如何构建内部类型的信息。其余的代码（即除模块内容之外的所有内容）将无法知道是由什么组成的：这些类型对于其他所有内容都变得抽象，但它们各自的模块除外。X2XX1.tX2.t

您的问题的 OOP 方法可能是创建默认构造函数，并在需要时调用它们。在您的情况下，这意味着在模块中定义默认值，在接口（模块类型）中添加声明，以便外部代码仍然可以创建这些类型的值。

module type X = sig
    type t
    val default : unit -> t
    (* etc. *)
end;;

module X1 : X = struct
    include XBase     
    type t = {foo : int; bar : int}
    (* here I can change fields adlib *)
    let default () = {foo = 0; bar = 1}
   (* ... *)
end;;
(* here I don't have access to X1.t fields anymore *)

请注意，如果您的类型不包含可变字段或引用，您可以将default其作为简单的值t，而不是函数，但也许您希望保留在其他模块中拥有此类字段的可能性。

这里的要点是，您需要保持您的类型公开或为您的抽象类型提供构造和操作值的方法（我想后者已经在您的代码中在某种程度上实现了）。

如果您不更改或无法更改模块类型X，那么您也许可以在上层强制签名，使用 mli 文件对包含X1and的模块以外的其他模块进行强制转换X2（也就是说，如果您的代码遵循这样的设计）。

另一种方法是添加有关t何时进行强制的类型信息。例如，这里有一个明确类型的X1声明choice（假设它已经存在于 中X）：

module X1 : X with type choice = XBase.choice =
struct
   (* body of the X1 module *)
end;;
(* now I can access X1.choice constants from here, if XBase.choice is visible too *)

您可以对其 type 执行类似的操作t，然后从外部代码访问其内容。从设计的角度来看，如果您已经在模块中提供了操作符来操作 type 的值，那么这显然不是处理问题的最佳方式t。

于 2012-12-10T15:21:50.113 回答
1

该错误Unbound record field label X1.foo是由于X1andX2具有模块签名Xbase，它只有类型choice（而不是类型t）。即语法隐藏了不属于签名: X的所有值和类型。X1Xbase

但是即使你纠正了这个错误，也会出现更重要的东西：函数的返回类型是read什么？不能同时是X1.t和X2.t。

于 2012-12-10T10:05:34.463 回答