Question

首先是代码：

module Boolean = struct
  exception SizeMismatch
  type boolean = T | F | Vec of boolean array 

  let to_bool v = match v with 
    T -> true
  | F -> false 
  | _ -> raise SizeMismatch
end

module Logic = struct
  type 'a var_t = { name: string; mutable value: 'a }
  type 'a bexp  = Const of 'a
  |             Var of 'a var_t

  let eval exp = match exp with
    Const x -> x
  | Var x   -> x.value

  let make_var s v = { name = s; value = v }
  let set v n = v.value <- n
  let get_var_name v = v.name
  let get_var_val  v = v.value
end

module type EXP =
  sig
    type  'a var_t
    type  'a bexp
    val eval_exp     : 'a bexp -> bool
    val get_var_name : 'a var_t -> string
    val get_var_val  : 'a var_t -> 'a
  end

module LogicExp = 
  struct
    include Logic
    let eval_exp exp = Boolean.to_bool (Logic.eval exp)
  end

module FSM ( Exp : EXP ) = 
  struct
    let print_var v = Printf.printf "%s = %d\n" (Exp.get_var_name v)
    (Exp.get_var_val v)

  end

module MyFSM = FSM(LogicExp) 

let myvar = Logic.make_var "foo" 1;;

MyFSM.print_var myvar ;;

当我编译它时，我收到以下错误：

File "test.ml", line 57, characters 19-27:
Error: Signature mismatch:
   Modules do not match:
     sig
       type 'a var_t =
         'a Logic.var_t = {
         name : string;
         mutable value : 'a;
       }
       type 'a bexp = 'a Logic.bexp = Const of 'a | Var of 'a var_t
       val eval : 'a bexp -> 'a
       val make_var : string -> 'a -> 'a var_t
       val set : 'a var_t -> 'a -> unit
       val get_var_name : 'a var_t -> string
       val get_var_val : 'a var_t -> 'a
       val eval_exp : Boolean.boolean Logic.bexp -> bool
     end
   is not included in
     EXP
   Values do not match:
     val eval_exp : Boolean.boolean Logic.bexp -> bool
   is not included in
     val eval_exp : 'a bexp -> bool

我不明白更具体的类型如何不包含在更一般的类型中？

Answer 1

错误信息实际上非常准确：

Values do not match:
  val eval_exp : Boolean.boolean Logic.bexp -> bool
is not included in
  val eval_exp : 'a bexp -> bool

MyFSM仿函数需要一个模块参数，该参数除其他外应包含类型为eval_exp的函数'a bexp -> bool。这意味着，对于选项'a bexp，给定'a类型的值，该函数应生成类型bool的值。但是，您提供的模块包含的功能仅对 'a的一个特定选项执行此操作，即'a类型为{{1}的那个来自模块boolean。

最快的解决方法是将您的签名Boolean定义为

EXP

以便module type EXP = sig type b (* added *) type 'a var_t type 'a bexp val eval_exp : b bexp -> bool (* changed *) val get_var_name : 'a var_t -> string val get_var_val : 'a var_t -> 'a end现在对固定类型eval_exp上的布尔表达式进行操作，然后将b定义为

LogicExp

以便将module LogicExp = struct type b = Boolean.boolean (* added *) include Logic let eval_exp exp = Boolean.to_bool (Logic.eval exp) end修复为b。

实现这些更改将使您的代码编译。

现在，让我们看看你的问题“更具体的类型如何不包含在更一般的类型中？”。这假设Boolean.boolean确实比'a bexp -> bool更通用，但实际上并非如此。如果boolean bexp -> bool比A -> B更通用，而C -> D比C更通用，则函数类型A被认为比函数类型B更通用}：

D

请注意前提中A <: C D <: B -------------------- C -> D <: A -> B和C的“翻转”。我们说函数空间构造函数A在其参数位置是逆变（与其结果位置中的协变相对）。

直观地说，如果类型包含更多值，则类型比另一类更通用。要查看函数空间构造函数在其参数位置中是逆变的原因，请考虑某些类型... -> ...和f的{{1}}类型的函数A -> C。现在，考虑一个A类型，它比C更加通用，也就是说，B中的所有值都在A中，但A包含一些不在B中的值。因此，至少有一个值B，我们可以为其分配类型A，但不能键入b。它的类型告诉我们B知道如何操作类型A的值。但是，如果我们（{错误！）从f A得出结论，那么我们可以使用A <: B，就好像它有类型A -> C <: B -> C一样，因此我们可以将值f作为参数传递给B -> C。但b不属于f类，b只知道如何对A类型的值进行操作！

显然，f在论证位置的协方差是行不通的。要查看逆向确实有效，请考虑相同的类型A，... -> ...和A，现在还要考虑B类型的函数C。也就是说，g知道如何对B -> C类型的所有值进行操作。函数空间构造函数在其参数位置的逆变性使我们得出结论：g也可以安全地分配类型B。我们知道g中的所有值都在A -> C中，而A知道如何处理所有B这不会造成任何问题，我们可以安全地传递{ {1}}至g。

Functor编译问题：签名不匹配：模块不匹配

1 个答案: