69 lines
2.7 KiB
OCaml
69 lines
2.7 KiB
OCaml
(***********************************************************************)
|
|
(* *)
|
|
(* Objective Caml *)
|
|
(* *)
|
|
(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)
|
|
(* *)
|
|
(* Copyright 1996 Institut National de Recherche en Informatique et *)
|
|
(* en Automatique. All rights reserved. This file is distributed *)
|
|
(* under the terms of the GNU Library General Public License. *)
|
|
(* *)
|
|
(***********************************************************************)
|
|
|
|
(* $Id$ *)
|
|
|
|
(** Sets over ordered types.
|
|
|
|
This module implements the set data structure, given a total ordering
|
|
function over the set elements. All operations over sets
|
|
are purely applicative (no side-effects).
|
|
The implementation uses balanced binary trees, and is therefore
|
|
reasonably efficient: insertion and membership take time
|
|
logarithmic in the size of the set, for instance.
|
|
*)
|
|
|
|
module type OrderedType = sig type t val compare : t -> t -> int end
|
|
(** The input signature of the functor {!Set.Make}.
|
|
[t] is the type of the set elements.
|
|
[compare] is a total ordering function over the set elements.
|
|
This is a two-argument function [f] such that
|
|
[f e1 e2] is zero if the elements [e1] and [e2] are equal,
|
|
[f e1 e2] is strictly negative if [e1] is smaller than [e2],
|
|
and [f e1 e2] is strictly positive if [e1] is greater than [e2].
|
|
Example: a suitable ordering function is
|
|
the generic structural comparison function {!Pervasives.compare}. *)
|
|
|
|
|
|
module type S =
|
|
sig
|
|
type elt
|
|
type t
|
|
val empty : t
|
|
val is_empty : t -> bool
|
|
val mem : elt -> t -> bool
|
|
val add : elt -> t -> t
|
|
val singleton : elt -> t
|
|
val remove : elt -> t -> t
|
|
val union : t -> t -> t
|
|
val inter : t -> t -> t
|
|
val diff : t -> t -> t
|
|
val compare : t -> t -> int
|
|
val equal : t -> t -> bool
|
|
val subset : t -> t -> bool
|
|
val iter : (elt -> unit) -> t -> unit
|
|
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
|
|
val for_all : (elt -> bool) -> t -> bool
|
|
val exists : (elt -> bool) -> t -> bool
|
|
val filter : (elt -> bool) -> t -> t
|
|
val partition : (elt -> bool) -> t -> t * t
|
|
val cardinal : t -> int
|
|
val elements : t -> elt list
|
|
val min_elt : t -> elt
|
|
val max_elt : t -> elt
|
|
val choose : t -> elt
|
|
end
|
|
|
|
module Make (Ord : OrderedType) : S with type elt = Ord.t
|
|
(** Functor building an implementation of the set structure
|
|
given a totally ordered type. *)
|