OCaml：签名中的类型约束(OCaml : type constraints in signatures)

 在我的代码中，我有一个数据库访问上下文 ，它提供了基本的读/写操作，称为CouchDB.ctx 。 然后，我的应用程序中的各个模块将使用其他功能扩展该类，如Async.ctx 。 
 
 我正在实现一个环绕Source模块的Cache模块。 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的子类型的CouchDB.ctx 。 上面的代码返回错误： 
 
A type variable is unbound in this type declaration.
In type #CouchDB.ctx as 'a the variable 'a is unbound
 
 我如何表达这种类型约束？ 

In my code, I have a database access context that provides elementary read/write operations, called CouchDB.ctx. Various modules in my application then extend that class with additional functionality, such as Async.ctx. 
 
I am implementing a Cache module which is wrapped around a Source module. The Cache module functions take a context argument and manipulate the database. Some calls are then forwarded to the Source module along with the context. 
 
I need to define a functor along the lines of this: 
 
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)
 
The problem is that I cannot express the fact that the context used by the Source module should be a subtype of CouchDB.ctx. The above code returns the error: 
 
A type variable is unbound in this type declaration.
In type #CouchDB.ctx as 'a the variable 'a is unbound
 
How do I express this type constraint ?

原文：https://stackoverflow.com/questions/10588382