在这种情况下我需要函子吗？

Question

我在以下代码中使用 Bitstring 模块：

let build_data_32 v wid =
  let num = wid / 32 in
  let v' = Int32.of_int(v) in
  let rec aux lst vv w = match w with
    0 -> lst
  | _ -> (BITSTRING { vv : 32 } ) :: ( aux lst (Int32.succ vv) (w-1)) in
  Bitstring.concat ( aux [] v' num ) ;;

请注意，当您有 BITSTRING { vv : 32 } vv 预计为 Int32 值。我想概括这个函数以处理不同宽度的位串；即，我想创建一个 build_data_n 函数，其中将使用 BITSTRING { vv : n } 构造位串。

然而，这里的问题是，如果 n 小于 32，那么上面使用的 succ 函数将只是 int 类型的 succ。如果大于 32，则为 Int64.succ 与上面 let v' = Int32.of_int(v) in 行中的问题相同 - 对于小于 32 的值，则为： let v' = v in ，而对于大于 32 的值，则为： let v' = Int64.of_int(v) in

在这种情况下，函子会可以派上用场来推广此功能，如果是这样，我将如何设置它？ （如果有其他不需要函子的方法来做到这一点，那也很高兴知道）

Answer 1

有几种可用的方法。一种是使用函子，类似于以下内容：

(* The signature a module needs to match for use below *)
module type S = sig
  type t
  val succ : t -> t
  val of_int : int -> t
end

(* The functor *)
module Make(M : S) = struct
  (* You could "open M" here if you wanted to save some typing *)
  let build_data v =
    M.succ (M.of_int v)
end

(* Making modules with the functor *)
module Implementation32 = Make(Int32)
module Implementation64 = Make(Int64)

let foo32 = Implementation32.build_data 12
let foo64 = Implementation64.build_data 12

另一种是将数据类型包装在记录中：

(* A record to hold the relevant functions *)
type 'a wrapper_t = { x : 'a; succ : 'a -> 'a }

(* Use values of type 'a wrapper_t in *)
let build_data v =
  v.succ v.x

(* Helper function to create 'a wrapper_t values *)
let make_int32_wrapper x = { x = Int32.of_int x; succ = Int32.succ }
let make_int64_wrapper x = { x = Int64.of_int x; succ = Int64.succ }

(* Do something with a wrapped int32 *)
let foo32 = build_data (make_int32_wrapper 12)
let foo64 = build_data (make_int64_wrapper 12)

最后，如果您使用 OCaml 3.12.0 或更高版本，则可以使用第一类模块：

(* You can use the module type S from the first example here *)

let build_data (type s) m x =
  let module M = (val m : S with type t = s) in
  M.succ x

let int32_s = (module Int32 : S with type t = Int32.t)
let int64_s = (module Int64 : S with type t = Int64.t)

let foo32 = build_data int32_s 12l
let foo64 = build_data int64_s 12L

这些方法中的每一种都可以混合搭配。您还可以将值包装在变体类型或对象中以获得类似的结果。

Answer 2

对于BITSTRING { vv : n }，即使用运行时指定的字段长度，vv 的类型不能依赖于n，因为它不是编译时常量不再存在，因此 vv 被强制为 int64。