Question

互锁模块有问题：我想引用第一个模块中定义的类型。

module type E = sig
    type event
end

type ev = Ev;;

module EE : E = struct type event = ev end;;

module  type StateType = functor (E : E ) ->  sig
    type event = E.event

    type state_t = {
        mutable event_success : event option;
    }

    val set_event_success : state_t -> event option -> unit
    val create : unit -> state_t     
end

module State   : StateType =  functor (E : E) -> struct   
    type event = E.event

    type  state_t = {  
        mutable event_success : event option;
    }

    let create  ()  = { 
        event_success = None;
    }

    let set_event_success s e = (s.event_success <- e;)
end

module S = State(struct type event = ev end);;

let s = S.create ();;

S.set_event_success s (Some(Ev));;

\- : unit = ()

所以，它有效。

module type  AgentType =  
  functor (S: StateType) -> functor (E : E) ->
sig

  type event = E.event
  type state_t = S.state_t 
end

我收到此错误：

Error: Unbound type constructor S.state_t

我不明白为什么会出现此错误，因为S显然是使用模块StateType设置的。

我的目标是做以下声明：

module Ag = Agent ( State(struct type event = ev end)) (struct type event = ev end)

我该怎么做？

Answer 1

那是因为StateType是仿函数的类型，而不是模块。

您应该将StateType声明为

module type StateType =
sig
  type event

  type state_t = {
    mutable event_success : event option;
  }

  val set_event_success : state_t -> event option -> unit

  val create : unit -> state_t
end

和仿函数State为

module State (E : E)  : (StateType with type event = E.event) =
struct
  type event = E.event

  type  state_t = {  
    mutable event_success : event option;
  }

  let create  ()  = { 
    event_success = None;
  }

  let set_event_success s e = (s.event_success <- e;)
end

如何解决这类问题：

不要编写仿函数类型。而是编写输出模块的签名，并使用with type添加类型方程式。

对于Agent，输出签名将是

module type AgentType =
sig
  type event
  type state_t
end

并且Agent仿函数看起来像

module Agent (S : StateType) (E : E) : (AgentType with type event = E.event and type state_t = S.state_t) = …

未绑定的类型构造函数错误

1 个答案: