Map

Map模块

Map创建一种映射关系。比方说，我们需要关联一组用户及其对应的密码，这里存在从用户到密码的 映射关系，可以通过Map模块通过函数式的方式相当迅速地来处理。在下面的例子中我将创建一个从 字符串到字符串的映射，当然这只是例子，映射的类型是很随意的。

创建一个Map是很容易的：

# module MyUsers = Map.Make(String);;
module MyUsers :
  sig
    type key = String.t
    type 'a t = 'a Map.Make(String).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

我们现在已经创建了一个新的模块，叫做 MyUsers。现在我们要往里面加入数据，但是首先，我们先 新建一个空的映射：

# let m = MyUsers.empty;;
val m : 'a MyUsers.t = <abstr>

然后再往里面加数据:

# let m = MyUsers.add "fred" "sugarplums" m;;
val m : string MyUsers.t = <abstr>

m是一个全新的映射，因此前一个m已经被隐藏掉。这个m比前一个多了用户 "fred" 和他的密码 "sugarplums"。有一点很值得指出的是，当我们加入字符串 "sugarplums" 的时候，我们已经固定了映射的目标类型。这也就是说，我们的模块MyUsers成为了一个只能从字符串到字符串 的映射。如果我们想插入一个整数作为键还是值，都必须创建一个新的映射。

让我们加入更多的数据。

# let m = MyUsers.add "tom" "ilovelucy" m;;
val m : string MyUsers.t = <abstr>
# let m = MyUsers.add "mark" "ocamlrules" m;;
val m : string MyUsers.t = <abstr>
# let m = MyUsers.add "pete" "linux" m;;
val m : string MyUsers.t = <abstr>

但是我们也得看得到里面的数据啊？一个函数足以完成这个任务：

# let print_user key password =
    print_string(key ^ " " ^ password ^ "\n");;
val print_user : string -> string -> unit = <fun>

通过传入两个字符串到该函数，就能在屏幕很好地打印出键和密码，并且换行。然后我们得把这个函数 应用到映射的每对键值对上：

# MyUsers.iter print_user m;;
fred sugarplums
mark ocamlrules
pete linux
tom ilovelucy
- : unit = ()

当然，有时候我们只想找到(find)某个用户的密码：

# MyUsers.find "fred" m;;
- : string = "sugarplums"

这个调用会很迅速地返回Fred的密码: "sugarplums"。