OCaml：签名中的类型约束

Question

在我的代码中，我有一个提供基本读/写操作的数据库访问上下文，称为CouchDB.ctx。然后我的应用程序中的各种模块使用附加功能扩展该类，例如Async.ctx。

我正在实现一个 Cache 模块，它包裹在一个 Source 模块周围。 Cache 模块函数采用上下文参数并操作数据库。然后将一些调用连同上下文一起转发到Source 模块。

我需要按照以下方式定义一个仿函数：

module CouchDB = struct
  class ctx = object
    method get : string -> string option monad 
    method put : string -> string -> unit monad
  end
end

module AsyncDB = struct
  class ctx = object
    inherit CouchDB.ctx
    method delay : 'a. float -> (ctx -> 'a monad) -> 'a monad 
  end
end

module type SOURCE = sig
  class ctx = #CouchDB.ctx (* <-- incorrect *)
  type source
  val get : source -> ctx -> string monad
end

module Cache = functor(S:SOURCE) -> struct
  class ctx = S.ctx
  type source = S.source
  let get source ctx = 
    bind (ctx # get source) (function 
     | Some cache -> return cache
     | None -> 
       bind (S.get source ctx) 
         (fun data -> bind (ctx # put source data) 
                        (fun () -> return data)) 
end

module SomeSource = struct
  class ctx = AsyncDB.ctx
  type source = string
  let get s ctx = 
    ctx # async 300 (some_long_computation s)
end

module SomeCache = Cache(SomeSource)

问题是我无法表达Source 模块使用的上下文应该是CouchDB.ctx 的子类型这一事实。以上代码返回错误：

A type variable is unbound in this type declaration.
In type #CouchDB.ctx as 'a the variable 'a is unbound

如何表达这种类型约束？

Answer 1

[已过时...

你能得到的最接近的是将签名定义为：

module type SOURCE = sig
  type 'a ctx = 'a constraint 'a = #CouchDB.ctx
  type source
  val get : source -> 'a ctx -> string 
end

当然，你也可以这样写：

module type SOURCE = sig
  type source
  val get : source -> #CouchDB.ctx -> string 
end

编辑：请注意，OCaml 对对象使用 structural 类型。这意味着即使您想要，您也无法获得比上述更多的限制。它甚至不将get 的参数限制为CouchDB.ctx 或派生类的实例——任何具有（至少）相同方法的对象都是兼容的。即使你写了

  val get : source -> CouchDB.ctx -> string 

您可以传递具有相同方法的 任何 对象。 CouchDB.ctx 类型只是一个特定结构对象类型的缩写，它恰好匹配同名类生成的对象。它不限于那些。只是为了确定：这被认为是一项功能。

======]

编辑 2：通过扩展示例，我现在看到了您想要什么以及为什么。不幸的是，这在 OCaml 中是不可能的。您将需要 部分抽象 类型。也就是说，你需要能够写

module type SOURCE = sig
  type ctx < CouchDB.ctx
  ...
end

这在 OCaml 中不可用。但是，如果您愿意在签名中提供明确的向上转换，则可以接近：

module type SOURCE = sig
  type ctx
  val up : ctx -> CouchDB.ctx
  type source = string
  val get : source -> ctx -> string monad
end

然后，在Cache 中，您必须将出现的ctx#get 替换为(S.up ctx)#get，ctx#put 也是如此。

module Cache = functor (S:SOURCE) -> struct
  type ctx = S.ctx
  type source = S.source
  let get source ctx = 
     bind ((S.up ctx)#get source) ...
end

module SomeSource = struct
  type ctx = AsyncDB.ctx
  let up ctx = (ctx : ctx :> CouchDB.ctx)
  type source = string
  let get s ctx = ...
end

module SomeCache = Cache (SomeSource)

请注意，我还在签名SOURCE 中使type source = string 透明。没有它，我无法看到 ctx#get source 如何在 Cache 函子中进行类型检查。

Answer 2

除非我误解了你的目标，否则这应该可以解决问题：

module type SOURCE = sig
  class ctx : CouchDB.ctx
  type source
  val get : source -> ctx -> string
end

class ctx : CouchDB.ctx 是一个class-specification。 OCaml 文档将它们描述为

这是类定义签名中的对应物。如果类规范具有相同的类型参数并且它们的类型匹配，则类规范与类定义匹配。

还有这个

module type SOURCE = sig
  class type ctx = CouchDB.ctx
  type source
  val get : source -> ctx -> string
end

这是微妙的不同。前者需要模块中的真实类定义，后者接受类定义或类类型定义（即类类型别名）。