From 3ccabcd7b0f0b0c91e9297c7f9700bc7ffe3c004 Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Fri, 16 May 2014 22:26:59 +0200 Subject: [PATCH] more modules in containers Core; moved KMP to sublibrary containers_string --- .ocamlinit | 5 +- _oasis | 11 +- core/CCFun.ml | 39 ++++++ core/CCFun.mli | 42 ++++++ core/CCList.ml | 213 +++++++++++++++++++++++++++++++ core/CCList.mli | 96 ++++++++++++++ core/CCOpt.ml | 94 ++++++++++++++ core/CCOpt.mli | 66 ++++++++++ core/CCPair.ml | 56 ++++++++ core/CCPair.mli | 53 ++++++++ core/CCPrint.ml | 2 +- core/CCPrint.mli | 1 - core/CCKMP.ml => string/KMP.ml | 0 core/CCKMP.mli => string/KMP.mli | 0 14 files changed, 672 insertions(+), 6 deletions(-) create mode 100644 core/CCFun.ml create mode 100644 core/CCFun.mli create mode 100644 core/CCList.ml create mode 100644 core/CCList.mli create mode 100644 core/CCOpt.ml create mode 100644 core/CCOpt.mli create mode 100644 core/CCPair.ml create mode 100644 core/CCPair.mli rename core/CCKMP.ml => string/KMP.ml (100%) rename core/CCKMP.mli => string/KMP.mli (100%) diff --git a/.ocamlinit b/.ocamlinit index 0f6abac0..f2acb85d 100644 --- a/.ocamlinit +++ b/.ocamlinit @@ -1,12 +1,13 @@ #use "topfind";; #thread -#directory "_build/";; +#directory "_build/core";; +#directory "_build/misc";; #directory "_build/tests/";; #load "containers.cma";; +#load "containers_misc.cma";; #require "threads";; #load "containers_thread.cma";; open Containers;; -open Sequence.Infix;; #install_printer Bencode.pretty;; #install_printer HGraph.Default.fmt;; #require "CamlGI";; diff --git a/_oasis b/_oasis index 53e94cf9..255b7395 100644 --- a/_oasis +++ b/_oasis @@ -39,10 +39,17 @@ Flag "bench" Library "containers" Path: core Modules: CCVector, CCDeque, CCGen, CCSequence, CCFQueue, CCMultiMap, - CCMultiSet, CCBV, CCKMP, CCPrint, CCPersistentHashtbl, - CCLeftistheap + CCMultiSet, CCBV, CCPrint, CCPersistentHashtbl, + CCLeftistheap, CCList, CCOpt, CCPair, CCFun FindlibName: containers +Library "containers_string" + Path: string + Pack: true + Modules: KMP + FindlibName: string + FindlibParent: containers + Library "containers_misc" Path: misc Pack: true diff --git a/core/CCFun.ml b/core/CCFun.ml new file mode 100644 index 00000000..ba6173d5 --- /dev/null +++ b/core/CCFun.ml @@ -0,0 +1,39 @@ + +(* +copyright (c) 2013-2014, simon cruanes +all rights reserved. + +redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. redistributions in binary +form must reproduce the above copyright notice, this list of conditions and the +following disclaimer in the documentation and/or other materials provided with +the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*) + +(** {1 Basic Functions} *) + +let (|>) x f = f x + +let compose f g x = g (f x) + +let (%>) = compose + +let (%) f g x = f (g x) + +let lexicographic f1 f2 x y = + let c = f1 x y in + if c <> 0 then c else f2 x y diff --git a/core/CCFun.mli b/core/CCFun.mli new file mode 100644 index 00000000..aa0010e1 --- /dev/null +++ b/core/CCFun.mli @@ -0,0 +1,42 @@ + +(* +copyright (c) 2013-2014, simon cruanes +all rights reserved. + +redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. redistributions in binary +form must reproduce the above copyright notice, this list of conditions and the +following disclaimer in the documentation and/or other materials provided with +the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*) + +(** {1 Basic Functions} *) + +val (|>) : 'a -> ('a -> 'b) -> 'b +(** Pipeline (naive implementation) *) + +val compose : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c +(** Composition *) + +val (%>) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c +(** Alias to [compose] *) + +val (%) : ('b -> 'c) -> ('a -> 'b) -> 'a -> 'c +(** Mathematical composition *) + +val lexicographic : ('a -> 'a -> int) -> ('a -> 'a -> int) -> 'a -> 'a -> int +(** Lexicographic combination of comparison functions *) diff --git a/core/CCList.ml b/core/CCList.ml new file mode 100644 index 00000000..0caed9c5 --- /dev/null +++ b/core/CCList.ml @@ -0,0 +1,213 @@ + +(* +copyright (c) 2013-2014, simon cruanes +all rights reserved. + +redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. redistributions in binary +form must reproduce the above copyright notice, this list of conditions and the +following disclaimer in the documentation and/or other materials provided with +the distribution. + +this software is provided by the copyright holders and contributors "as is" and +any express or implied warranties, including, but not limited to, the implied +warranties of merchantability and fitness for a particular purpose are +disclaimed. in no event shall the copyright holder or contributors be liable +for any direct, indirect, incidental, special, exemplary, or consequential +damages (including, but not limited to, procurement of substitute goods or +services; loss of use, data, or profits; or business interruption) however +caused and on any theory of liability, whether in contract, strict liability, +or tort (including negligence or otherwise) arising in any way out of the use +of this software, even if advised of the possibility of such damage. +*) + +(** {1 complements to list} *) + +type 'a t = 'a list + +(* max depth for direct recursion *) +let _direct_depth = 500 + +let map f l = + let rec direct f i l = match l with + | [] -> [] + | _ when i=0 -> safe f l + | x::l' -> + let y = f x in + y :: direct f (i-1) l' + and safe f l = + List.rev (List.rev_map f l) + in + direct f _direct_depth l + +(*$Q + (Q.list Q.small_int) (fun l -> \ + let f x = x+1 in \ + List.rev (List.rev_map f l) = map f l) +*) + +let append l1 l2 = + let rec direct i l1 l2 = match l1 with + | [] -> l2 + | _ when i=0 -> safe l1 l2 + | x::l1' -> x :: direct (i-1) l1' l2 + and safe l1 l2 = + List.rev_append (List.rev l1) l2 + in + direct _direct_depth l1 l2 + +let (@) = append + +let rec compare f l1 l2 = match l1, l2 with + | [], [] -> 0 + | _, [] -> 1 + | [], _ -> -1 + | x1::l1', x2::l2' -> + let c = f x1 x2 in + if c <> 0 then c else compare f l1' l2' + +let rec equal f l1 l2 = match l1, l2 with + | [], [] -> true + | [], _ | _, [] -> false + | x1::l1', x2::l2' -> f x1 x2 && equal f l1' l2' + +(* difference list *) +type 'a dlist = 'a list -> 'a list + +(* append difference lists *) +let _d_append f1 f2 = + fun l -> f1 (f2 l) + +let flat_map f l = + let rec aux prefix f l = match l with + | [] -> prefix [] + | x::l' -> + let sublist = append (f x) in + let prefix = _d_append prefix sublist in + aux prefix f l' + in + aux (fun l->l) f l + +(*$T + flat_map (fun x -> [x+1; x*2]) [10;100] = [11;20;101;200] +*) + +let flatten l = flat_map (fun l -> l) l + +let product f l1 l2 = + flat_map (fun x -> map (fun y -> f x y) l2) l1 + +let return x = [x] + +let (>>=) l f = flat_map f l + +let (<$>) = map + +let (<*>) funs l = product (fun f x -> f x) funs l + +(*$T + List.sort Pervasives.compare ([(( * )2); ((+)1)] <*> [10;100]) \ + = [11; 20; 101; 200] +*) + +let range i j = + let rec up i j acc = + if i=j then i::acc else up i (j-1) (j::acc) + and down i j acc = + if i=j then i::acc else down i (j+1) (j::acc) + in + if i<=j then up i j [] else down i j [] + +(*$T + range 0 5 = [0;1;2;3;4;5] + range 0 0 = [0] + range 5 2 = [5;4;3;2] +*) + +let (--) = range + +(*$T + append (range 0 100) (range 101 1000) = range 0 1000 + append (range 1000 500) (range 499 0) = range 1000 0 +*) + +let take n l = + let rec direct i n l = match l with + | [] -> [] + | _ when i=0 -> safe n [] l + | x::l' -> x :: direct (i-1) (n-1) l' + and safe n acc l = match l with + | [] -> List.rev acc + | _ when n=0 -> List.rev acc + | x::l' -> safe (n-1) (x::acc) l' + in + direct _direct_depth n l + +let rec drop n l = match l with + | [] -> [] + | _ when n=0 -> l + | _::l' -> drop (n-1) l' + +let split n l = take n l, drop n l + +(*$Q + (Q.pair (Q.list Q.small_int) Q.int) (fun (l,i) -> \ + let i = abs i in \ + let l1, l2 = split i l in \ + l1 @ l2 = l ) +*) + +let last n l = + let len = List.length l in + if len < n then l else drop (len-n) l + +(** {2 Conversions} *) + +type 'a sequence = ('a -> unit) -> unit +type 'a gen = unit -> 'a option +type 'a printer = Buffer.t -> 'a -> unit + +let to_seq l k = List.iter k l +let of_seq seq = + let l = ref [] in + seq (fun x -> l := x :: !l); + List.rev !l + +let to_gen l = + let l = ref l in + fun () -> + match !l with + | [] -> None + | x::l' -> + l := l'; Some x + +let of_gen g = + let rec direct i g = + if i = 0 then safe [] g + else match g () with + | None -> [] + | Some x -> x :: direct (i-1) g + and safe acc g = match g () with + | None -> List.rev acc + | Some x -> safe (x::acc) g + in + direct _direct_depth g + +(** {2 IO} *) + +let pp ?(start="[") ?(stop="]") ?(sep=", ") pp_item buf l = + let rec print l = match l with + | x::((y::xs) as l) -> + pp_item buf x; + Buffer.add_string buf sep; + print l + | x::[] -> pp_item buf x + | [] -> () + in Buffer.add_string buf start; print l; Buffer.add_string buf stop + +(*$T + CCPrint.to_string (pp CCPrint.int) [1;2;3] = "[1, 2, 3]" + *) diff --git a/core/CCList.mli b/core/CCList.mli new file mode 100644 index 00000000..8ffb2089 --- /dev/null +++ b/core/CCList.mli @@ -0,0 +1,96 @@ + +(* +copyright (c) 2013-2014, simon cruanes +all rights reserved. + +redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. redistributions in binary +form must reproduce the above copyright notice, this list of conditions and the +following disclaimer in the documentation and/or other materials provided with +the distribution. + +this software is provided by the copyright holders and contributors "as is" and +any express or implied warranties, including, but not limited to, the implied +warranties of merchantability and fitness for a particular purpose are +disclaimed. in no event shall the copyright holder or contributors be liable +for any direct, indirect, incidental, special, exemplary, or consequential +damages (including, but not limited to, procurement of substitute goods or +services; loss of use, data, or profits; or business interruption) however +caused and on any theory of liability, whether in contract, strict liability, +or tort (including negligence or otherwise) arising in any way out of the use +of this software, even if advised of the possibility of such damage. +*) + +(** {1 complements to list} *) + +type 'a t = 'a list + +val map : ('a -> 'b) -> 'a t -> 'b t +(** Safe version of map *) + +val append : 'a t -> 'a t -> 'a t +(** Safe version of append *) + +val (@) : '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 flat_map : ('a -> 'b t) -> 'a t -> 'b t +(** map and flatten at the same time (safe). Evaluation order is not guaranteed. *) + +val flatten : 'a t t -> 'a t +(** Safe flatten *) + +val product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t +(** cartesian product of the two lists, with the given combinator *) + +val (<*>) : ('a -> 'b) t -> 'a t -> 'b t + +val (<$>) : ('a -> 'b) -> 'a t -> 'b t + +val return : 'a -> 'a t + +val (>>=) : 'a t -> ('a -> 'b t) -> 'b t + +val range : int -> int -> int t +(** [range i j] iterates on integers from [i] to [j] included. It works + both for decreasing and increasing ranges *) + +val (--) : int -> int -> int t +(** Infix alias for [range] *) + +val take : int -> 'a t -> 'a t +(** take the [n] first elements, drop the rest *) + +val drop : int -> 'a t -> 'a t +(** drop the [n] first elements, keep the rest *) + +val split : int -> 'a t -> 'a t * 'a t +(** [split n l] returns [l1, l2] such that [l1 @ l2 = l] and + [length l1 = min (length l) n] *) + +val last : int -> 'a t -> 'a t +(** [last n l] takes the last [n] elements of [l] (or less if + [l] doesn't have that many elements *) + +(** {2 Conversions} *) + +type 'a sequence = ('a -> unit) -> unit +type 'a gen = unit -> 'a option +type 'a printer = Buffer.t -> 'a -> unit + +val to_seq : 'a t -> 'a sequence +val of_seq : 'a sequence -> 'a t + +val to_gen : 'a t -> 'a gen +val of_gen : 'a gen -> 'a t + +(** {2 IO} *) + +val pp : ?start:string -> ?stop:string -> ?sep:string -> + 'a printer -> 'a t printer diff --git a/core/CCOpt.ml b/core/CCOpt.ml new file mode 100644 index 00000000..7a979b62 --- /dev/null +++ b/core/CCOpt.ml @@ -0,0 +1,94 @@ + +(* +copyright (c) 2013-2014, simon cruanes +all rights reserved. + +redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. redistributions in binary +form must reproduce the above copyright notice, this list of conditions and the +following disclaimer in the documentation and/or other materials provided with +the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*) + +(** {1 Options} *) + +type 'a t = 'a option + +let map f = function + | None -> None + | Some x -> Some (f x) + +let maybe f d = function + | None -> d + | Some x -> f x + +let is_some = function + | None -> false + | Some _ -> true + +let compare f o1 o2 = match o1, o2 with + | None, None -> 0 + | Some _, None -> 1 + | None, Some _ -> -1 + | Some x, Some y -> f x y + +let equal f o1 o2 = match o1, o2 with + | None, None -> true + | Some _, None + | None, Some _ -> false + | Some x, Some y -> f x y + +let return x = Some x + +let (>>=) o f = match o with + | None -> None + | Some x -> f x + +let (<*>) f x = match f, x with + | None, _ + | _, None -> None + | Some f, Some x -> Some (f x) + +let (<$>) = map + +let map2 f o1 o2 = match o1, o2 with + | None, _ + | _, None -> None + | Some x, Some y -> Some (f x y) + +let to_list o = match o with + | None -> [] + | Some x -> [x] + +type 'a sequence = ('a -> unit) -> unit +type 'a gen = unit -> 'a option +type 'a printer = Buffer.t -> 'a -> unit + +let to_gen o = + match o with + | None -> (fun () -> None) + | Some _ -> + let first = ref true in + fun () -> if !first then (first:=false; o) else None + +let to_seq o k = match o with + | None -> () + | Some x -> k x + +let pp ppx buf o = match o with + | None -> Buffer.add_string buf "None" + | Some x -> Buffer.add_string buf "Some "; ppx buf x diff --git a/core/CCOpt.mli b/core/CCOpt.mli new file mode 100644 index 00000000..16d96f3b --- /dev/null +++ b/core/CCOpt.mli @@ -0,0 +1,66 @@ + +(* +copyright (c) 2013-2014, simon cruanes +all rights reserved. + +redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. redistributions in binary +form must reproduce the above copyright notice, this list of conditions and the +following disclaimer in the documentation and/or other materials provided with +the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*) + +(** {1 Options} *) + +type 'a t = 'a option + +val map : ('a -> 'b) -> 'a t -> 'b t + +val maybe : ('a -> 'b) -> 'b -> 'a t -> 'b +(** [maybe f x o] is [x] if [o] is [None], otherwise it's [f y] if [o = Some y] *) + +val is_some : _ t -> bool + +val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int + +val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool + +val return : 'a -> 'a t +(** Monadic return *) + +val (>>=) : 'a t -> ('a -> 'b t) -> 'b t +(** Monadic bind *) + +val (<*>) : ('a -> 'b) t -> 'a t -> 'b t + +val (<$>) : ('a -> 'b) -> 'a t -> 'b t + +val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t + +(** {2 Conversion and IO} *) + +val to_list : 'a t -> 'a list + +type 'a sequence = ('a -> unit) -> unit +type 'a gen = unit -> 'a option +type 'a printer = Buffer.t -> 'a -> unit + +val to_gen : 'a t -> 'a gen +val to_seq : 'a t -> 'a sequence + +val pp : 'a printer -> 'a t printer + diff --git a/core/CCPair.ml b/core/CCPair.ml new file mode 100644 index 00000000..ec00f2cd --- /dev/null +++ b/core/CCPair.ml @@ -0,0 +1,56 @@ + +(* +copyright (c) 2013-2014, simon cruanes +all rights reserved. + +redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. redistributions in binary +form must reproduce the above copyright notice, this list of conditions and the +following disclaimer in the documentation and/or other materials provided with +the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*) + +(** {1 Tuple Functions} *) + +type ('a,'b) t = ('a * 'b) + +let map1 f (x,y) = f x,y + +let map2 f (x,y) = x,f y + +let map f g (x,y) = f x, g y + +let map_same f (x,y) = f x, f y + +let swap (x,y) = y, x + +let (<<<) = map1 + +let (>>>) = map2 + +let ( *** ) = map + +let equal f g (x1,y1) (x2,y2) = f x1 x2 && g y1 y2 + +let compare f g (x1,y1) (x2,y2) = + let c = f x1 x2 in + if c <> 0 then c else g y1 y2 + +type 'a printer = Buffer.t -> 'a -> unit + +let pp pp_x pp_y buf (x,y) = + Printf.bprintf buf "(%a, %a)" pp_x x pp_y y diff --git a/core/CCPair.mli b/core/CCPair.mli new file mode 100644 index 00000000..4c76413f --- /dev/null +++ b/core/CCPair.mli @@ -0,0 +1,53 @@ + +(* +copyright (c) 2013-2014, simon cruanes +all rights reserved. + +redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. redistributions in binary +form must reproduce the above copyright notice, this list of conditions and the +following disclaimer in the documentation and/or other materials provided with +the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*) + +(** {1 Tuple Functions} *) + +type ('a,'b) t = ('a * 'b) + +val map1 : ('a -> 'b) -> ('a * 'c) -> ('b * 'c) + +val map2 : ('a -> 'b) -> ('c * 'a) -> ('c * 'b) + +val map : ('a -> 'c) -> ('b -> 'd) -> ('a * 'b) -> ('c * 'd) + +val map_same : ('a -> 'b) -> ('a*'a) -> ('b*'b) + +val swap : ('a * 'b) -> ('b * 'a) + +val (<<<) : ('a -> 'b) -> ('a * 'c) -> ('b * 'c) + +val (>>>) : ('a -> 'b) -> ('c * 'a) -> ('c * 'b) + +val ( *** ) : ('a -> 'c) -> ('b -> 'd) -> ('a * 'b) -> ('c * 'd) + +val equal : ('a -> 'a -> bool) -> ('b -> 'b -> bool) -> ('a * 'b) -> ('a * 'b) -> bool + +val compare : ('a -> 'a -> int) -> ('b -> 'b -> int) -> ('a * 'b) -> ('a * 'b) -> int + +type 'a printer = Buffer.t -> 'a -> unit + +val pp : 'a printer -> 'b printer -> ('a*'b) printer diff --git a/core/CCPrint.ml b/core/CCPrint.ml index 892acf55..e7648fce 100644 --- a/core/CCPrint.ml +++ b/core/CCPrint.ml @@ -34,7 +34,7 @@ but a simple way to print complicated values without writing a lot of code. type 'a sequence = ('a -> unit) -> unit type 'a t = Buffer.t -> 'a -> unit - (** A printer for the type ['a] *) +(** A printer for the type ['a] *) (** {2 Combinators} *) diff --git a/core/CCPrint.mli b/core/CCPrint.mli index 960fad0a..e3e1109d 100644 --- a/core/CCPrint.mli +++ b/core/CCPrint.mli @@ -58,7 +58,6 @@ val quad : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t val map : ('a -> 'b) -> 'b t -> 'a t - (** {2 IO} *) val output : out_channel -> 'a t -> 'a -> unit diff --git a/core/CCKMP.ml b/string/KMP.ml similarity index 100% rename from core/CCKMP.ml rename to string/KMP.ml diff --git a/core/CCKMP.mli b/string/KMP.mli similarity index 100% rename from core/CCKMP.mli rename to string/KMP.mli