OCaml 如何利用 dune 来构建项目

1.dune 创建项目命令

dune init project my_proj
cd my_proj
opam switch create . 4.14.1 --deps-only --with-test -y
eval $(opam env)
dune build
# 更新项目依赖库后，需要执行一下命令
opam install . --deps-only --with-test -y

2.项目整体结构

hw                             #项目根目录
├── _build                     #项目编译产出结果
│   ├── default
│   │   ├── META.hw
│   │   ├── bin
│   │   ├── hw.dune-package
│   │   ├── hw.install
│   │   ├── hw.opam
│   │   ├── lib
│   │   └── test
│   ├── install
│   │   └── default
│   └── log                   #编译日志
├── bin                       #项目主代码目录
│   ├── dune                  #dune主代码编译配置
│   ├── main.ml               #项目主代码
├── dune-project              #dune项目编译配置
├── hw.opam                   #自动生成的依赖配置
├── lib                       #自定义库代码目录
│   ├── dune                  #dune配置
│   ├── map.ml                #实现文件
│   └── map.mli               #接口文件
└── test                      #测试目录
    ├── dune
    └── hw.ml

3.OCaml 接口与实现分离的写法

外部只能访问接口文件，具体实现无需关心。接口文件以 mli 后缀结尾，实现文件以 ml 后缀结尾。这里以 Map 数据结构的实现来讲解：

3.1 定义接口

(* Map.mli *)

module type OrderedType =
  sig
    type t
    val compare: t -> t -> int
  end

module type S =
  sig
    type key
    type !+'a t
    val empty: 'a t
    val is_empty: 'a t -> bool
    val mem:  key -> 'a t -> bool
    val add: key -> 'a -> 'a t -> 'a t
    val update: key -> ('a option -> 'a option) -> 'a t -> 'a t
    val singleton: key -> 'a -> 'a t
    val remove: key -> 'a t -> 'a t
    val merge:
          (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
    val union: (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
    val compare: ('a -> 'a -> int) -> 'a t -> 'a t -> int
    val equal: ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
    val iter: (key -> 'a -> unit) -> 'a t -> unit
    val fold: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
    val for_all: (key -> 'a -> bool) -> 'a t -> bool
    val exists: (key -> 'a -> bool) -> 'a t -> bool
    val filter: (key -> 'a -> bool) -> 'a t -> 'a t
    val filter_map: (key -> 'a -> 'b option) -> 'a t -> 'b t
    val partition: (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
    val cardinal: 'a t -> int
    val bindings: 'a t -> (key * 'a) list
    val min_binding: 'a t -> (key * 'a)
    val min_binding_opt: 'a t -> (key * 'a) option
    val max_binding: 'a t -> (key * 'a)
    val max_binding_opt: 'a t -> (key * 'a) option
    val choose: 'a t -> (key * 'a)
    val choose_opt: 'a t -> (key * 'a) option
    val split: key -> 'a t -> 'a t * 'a option * 'a t
    val find: key -> 'a t -> 'a
    val find_opt: key -> 'a t -> 'a option
    val find_first: (key -> bool) -> 'a t -> key * 'a
    val find_first_opt: (key -> bool) -> 'a t -> (key * 'a) option
    val find_last: (key -> bool) -> 'a t -> key * 'a
    val find_last_opt: (key -> bool) -> 'a t -> (key * 'a) option
    val map: ('a -> 'b) -> 'a t -> 'b t
    val mapi: (key -> 'a -> 'b) -> 'a t -> 'b t
    val to_seq : 'a t -> (key * 'a) Seq.t
    val to_rev_seq : 'a t -> (key * 'a) Seq.t
    val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
    val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
    val of_seq : (key * 'a) Seq.t -> 'a t
  end

  module Make (Ord : OrderedType) : S with type key = Ord.t

接口文件中要放入外界可以访问的资源，例如函数声明，类型定义，常量定义，module type，module factors 等，factor 可以实现范型。

• OrderedType:map 数据结构 key 的类型

• S:接口

• Make:map 数据结构的 constructor

3.2 调用

(* 同级目录调用 *)
module MyUsers = Map.Make(String)

(* main文件中调用 *)
module MyUsers = Lib.Map.Make(String)

let m = MyUsers.empty

let n = MyUsers.add "fred" "sugarplums" m

3.3 实现

(* Map.ml *)
module type OrderedType =
  sig
    type t
    val compare: t -> t -> int
  end

module type S = sig ... end

module Make(Ord : OrderedType) = struct
  type key = ord.t
  type 'a t = Empty
      | Node of {l:'a t; v:key; d:'a; r:'a t; h:int}
  end

如果你的 module 要让外界处理 None，那么类型系统就需要定义为 option，方便外界处理。