From 3ab610ba0ebc995aedd87b64bc0fd4ef6e2cf6e0 Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Mon, 1 May 2017 16:59:25 +0200 Subject: [PATCH] prepapre for 1.2 --- CHANGELOG.adoc | 36 ++++++++++++++++++++++++++++++++++++ _oasis | 2 +- src/core/CCArray.mli | 4 ++-- src/core/CCEqual.mli | 2 +- src/core/CCFloat.mli | 4 ++-- src/core/CCFormat.mli | 14 +++++++------- src/core/CCInt.mli | 14 +++++++------- src/core/CCList.mli | 12 ++++++------ src/core/CCOpt.mli | 12 ++++++------ src/core/CCResult.mli | 6 +++--- src/core/CCString.mli | 12 ++++++------ src/data/CCBV.mli | 16 ++++++++-------- src/unix/CCUnix.mli | 2 +- 13 files changed, 86 insertions(+), 50 deletions(-) diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc index 65cc9a2c..9a36f8c5 100644 --- a/CHANGELOG.adoc +++ b/CHANGELOG.adoc @@ -1,5 +1,41 @@ = Changelog +== 1.2 + +- make many modules extensions of stdlib (close #109) + the modules are: `String List ListLabels Array ArrayLabels Char Random` +- add `CCString.{l,r}trim` (close #121) +- add `CCInt.floor_div` and `CCInt.rem` +- add test and bugfix for `CCBV` +- add `CCList.take_drop_while` (close #120) +- add `CCstring.equal_caseless` (close #112) +- add alias `CCString.split` (close #115) +- add `CCFormat.text` (close #111) +- add `CCFormat.{newline,substring}` +- add `CCList.combine_gen` (close #110) +- add module `CCEqual` +- add `CCResult.fold_ok` (closes #107) +- add `CCFormat.with_color_ksf` for colored printing +- add `CCInt.range{,',by}` for iterating on integer ranges +- add `CCString.Sub.get` +- add `CCResult.add_ctx{,f}` for replacing stack traces +- add `CCString.split_on_char` +- add `CCArray.{fold_map,scan_left}` (close #101) +- add `CCList.scan_left` +- add `CCList.{cartesian_product,map_product_l}` +- add `CCUnix.with_file_lock` for locking whole files +- add `CCFormat.of_chan` +- add `CCFormat.flush` +- Add `{map_lazy, or_, or_lazy, to_result, to_result_lazy, of_result}` to `CCOpt` + +- annotations in `CCEqual`, for optimization +- Add a tail-recursive implementation of `List.combine` +- fix too restrictive type in `CCResult` +- build unix support by default +- bugfix and test for `CCZipper.is_focused` (closes #102) +- use boxes in `CCFormat.Dump` for tuples +- update header, and use more `(==)` in `CCIntMap` + == 1.1 **bugfixes**: diff --git a/_oasis b/_oasis index 19753b57..aaf86b7b 100644 --- a/_oasis +++ b/_oasis @@ -1,6 +1,6 @@ OASISFormat: 0.4 Name: containers -Version: 1.1 +Version: 1.2 Homepage: https://github.com/c-cube/ocaml-containers Authors: Simon Cruanes License: BSD-2-clause diff --git a/src/core/CCArray.mli b/src/core/CCArray.mli index 6676d1ed..e8d5c8e2 100644 --- a/src/core/CCArray.mli +++ b/src/core/CCArray.mli @@ -46,12 +46,12 @@ val fold_while : ('a -> 'b -> 'a * [`Stop | `Continue]) -> 'a -> 'b t -> 'a val fold_map : ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a t -> 'acc * 'b t (** [fold_map f acc a] is a [fold_left]-like function, but it also maps the array to another array. - @since NEXT_RELEASE *) + @since 1.2 *) val scan_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc t (** [scan_left f acc a] returns the array [ [|acc; f acc x0; f (f acc a.(0)) a.(1); …|] ] - @since NEXT_RELEASE *) + @since 1.2 *) val iter : ('a -> unit) -> 'a t -> unit diff --git a/src/core/CCEqual.mli b/src/core/CCEqual.mli index 8c1d4adc..94230bfa 100644 --- a/src/core/CCEqual.mli +++ b/src/core/CCEqual.mli @@ -3,7 +3,7 @@ (** {1 Equality Combinators} *) -(** @since NEXT_RELEASE *) +(** @since 1.2 *) type 'a t = 'a -> 'a -> bool (** Equality function. Must be transitive, symmetric, and reflexive. *) diff --git a/src/core/CCFloat.mli b/src/core/CCFloat.mli index 0e57b997..a0c25034 100644 --- a/src/core/CCFloat.mli +++ b/src/core/CCFloat.mli @@ -79,11 +79,11 @@ val to_string : t -> string val of_string_exn : string -> t (** Alias to {!float_of_string} @raise Failure in case of failure - @since NEXT_RELEASE *) + @since 1.2 *) val of_string : string -> t (** Alias to {!float_of_string}. - @deprecated since NEXT_RELEASE, use {!of_string_exn} instead + @deprecated since 1.2, use {!of_string_exn} instead @raise Failure in case of failure *) val equal_precision : epsilon:t -> t -> t -> bool diff --git a/src/core/CCFormat.mli b/src/core/CCFormat.mli index 847de339..f55662e4 100644 --- a/src/core/CCFormat.mli +++ b/src/core/CCFormat.mli @@ -25,20 +25,20 @@ val float : float printer val newline : unit printer (** Force newline (see {!Format.pp_force_newline}) - @since NEXT_RELEASE *) + @since 1.2 *) val substring : (string * int * int) printer (** Print the substring [(s,i,len)], where [i] is the offset in [s] and [len] the number of bytes in the substring. @raise Invalid_argument if the triple [(s,i,len)] does not describe a proper substring. - @since NEXT_RELEASE *) + @since 1.2 *) val text : string printer (** Print string, but replacing spaces with breaks and newlines with {!newline}. See [pp_print_text] on recent versions of OCaml. - @since NEXT_RELEASE *) + @since 1.2 *) val char : char printer (** @since 0.14 *) val int32 : int32 printer (** @since 0.14 *) @@ -47,7 +47,7 @@ val nativeint : nativeint printer (** @since 0.14 *) val flush : unit printer (** Alias to {!Format.pp_print_flush}. - @since NEXT_RELEASE *) + @since 1.2 *) val string_quoted : string printer (** Similar to {!CCString.print}. @@ -204,7 +204,7 @@ val with_color_ksf : f:(string -> 'b) -> string -> ('a, t, unit, 'b) format4 -> {[ CCFormat.with_color_ksf "red" ~f:failwith "%a" CCFormat.Dump.(list int) [1;2;3];; ]} - @since NEXT_RELEASE *) + @since 1.2 *) (** {2 IO} *) @@ -213,13 +213,13 @@ val to_string : 'a printer -> 'a -> string val of_chan : out_channel -> t (** Alias to {!Format.formatter_of_out_channel} - @since NEXT_RELEASE *) + @since 1.2 *) val with_out_chan : out_channel -> (t -> 'a) -> 'a (** [with_out_chan oc f] turns [oc] into a formatter [fmt], and call [f fmt]. Behaves like [f fmt] from then on, but whether the call to [f] fails or returns, [fmt] is flushed before the call terminates. - @since NEXT_RELEASE *) + @since 1.2 *) val stdout : t val stderr : t diff --git a/src/core/CCInt.mli b/src/core/CCInt.mli index 7c9146ff..30f9dddc 100644 --- a/src/core/CCInt.mli +++ b/src/core/CCInt.mli @@ -26,12 +26,12 @@ val pow : t -> t -> t val floor_div : t -> t -> t (** [floor_div a n] is integer division rounding towards negative infinity. It satisfies [a = m * floor_div a n + rem a n]. - @since NEXT_RELEASE *) + @since 1.2 *) val rem : t -> t -> t (** [rem a n] is the remainder of dividing [a] by [n], with the same sign as [n]. - @since NEXT_RELEASE *) + @since 1.2 *) type 'a printer = Format.formatter -> 'a -> unit type 'a random_gen = Random.State.t -> 'a @@ -67,17 +67,17 @@ val range_by : step:t -> t -> t -> t sequence where the difference between successive elements is [step]. use a negative [step] for a decreasing list. @raise Invalid_argument if [step=0] - @since NEXT_RELEASE *) + @since 1.2 *) val range : t -> t -> t sequence (** [range i j] iterates on integers from [i] to [j] included . It works both for decreasing and increasing ranges - @since NEXT_RELEASE *) + @since 1.2 *) val range' : t -> t -> t sequence (** Same as {!range} but the second bound is excluded. For instance [range' 0 5 = Sequence.of_list [0;1;2;3;4]] - @since NEXT_RELEASE *) + @since 1.2 *) (** {2 Infix Operators} @@ -103,11 +103,11 @@ module Infix : sig val (--) : t -> t -> t sequence (** Alias to {!range} - @since NEXT_RELEASE *) + @since 1.2 *) val (--^) : t -> t -> t sequence (** Alias to {!range'} - @since NEXT_RELEASE *) + @since 1.2 *) end include module type of Infix diff --git a/src/core/CCList.mli b/src/core/CCList.mli index 4a5138d6..686d154c 100644 --- a/src/core/CCList.mli +++ b/src/core/CCList.mli @@ -59,7 +59,7 @@ val fold_map : ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a list -> 'acc * 'b list val scan_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a list -> 'acc list (** [scan_left f acc l] returns the list [[acc; f acc x0; f (f acc x0) x1; …]] where [x0], [x1], etc. are the elements of [l] - @since NEXT_RELEASE *) + @since 1.2 *) val fold_map2 : ('acc -> 'a -> 'b -> 'acc * 'c) -> 'acc -> 'a list -> 'b list -> 'acc * 'c list (** [fold_map2] is to [fold_map] what [List.map2] is to [List.map]. @@ -83,14 +83,14 @@ val init : int -> (int -> 'a) -> 'a t val combine : 'a list -> 'b list -> ('a * 'b) list (** Similar to {!List.combine} but tail-recursive. @raise Invalid_argument if the lists have distinct lengths. - @since NEXT_RELEASE *) + @since 1.2 *) val combine_gen : 'a list -> 'b list -> ('a * 'b) gen (** Lazy version of {!combine}. Unlike {!combine}, it does not fail if the lists have different lengths; instead, the output has as many pairs as the smallest input list. - @since NEXT_RELEASE *) + @since 1.2 *) val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int @@ -119,14 +119,14 @@ val cartesian_product : 'a t t -> 'a t t [[1;3;4;5;6];[2;3;4;5;6]];; ]} invariant: [cartesian_product l = map_product id l]. - @since NEXT_RELEASE *) + @since 1.2 *) val map_product_l : ('a -> 'b list) -> 'a list -> 'b list list (** [map_product_l f l] maps each element of [l] to a list of objects of type ['b] using [f]. We obtain [[l1;l2;…;ln]] where [length l=n] and [li : 'b list]. Then, it returns all the ways of picking exactly one element per [li]. - @since NEXT_RELEASE *) + @since 1.2 *) val diagonal : 'a t -> ('a * 'a) t (** All pairs of distinct positions of the list. [list_diagonal l] will @@ -201,7 +201,7 @@ val drop_while : ('a -> bool) -> 'a t -> 'a t val take_drop_while : ('a -> bool) -> 'a t -> 'a t * 'a t (** [take_drop_while p l = take_while p l, drop_while p l] - @since NEXT_RELEASE *) + @since 1.2 *) val last : int -> 'a t -> 'a t (** [last n l] takes the last [n] elements of [l] (or less if diff --git a/src/core/CCOpt.mli b/src/core/CCOpt.mli index 19c7eead..c5caa5a6 100644 --- a/src/core/CCOpt.mli +++ b/src/core/CCOpt.mli @@ -14,7 +14,7 @@ val map_or : default:'b -> ('a -> 'b) -> 'a t -> 'b val map_lazy : (unit -> 'b) -> ('a -> 'b) -> 'a t -> 'b (** [map_lazy default_fn f o] if [f o] if [o = Some x], [default_fn ()] otherwise - @since NEXT_RELEASE *) + @since 1.2 *) val is_some : _ t -> bool @@ -100,11 +100,11 @@ val (<$>) : ('a -> 'b) -> 'a t -> 'b t val or_ : else_:('a t) -> 'a t -> 'a t (** [or_ ~else_ a] is [a] if [a] is [Some _], [else_] otherwise - @since NEXT_RELEASE *) + @since 1.2 *) val or_lazy : else_:(unit -> 'a t) -> 'a t -> 'a t (** [or_lazy else_ a] is [a] if [a] is [Some _], [else_ ()] otherwise - @since NEXT_RELEASE *) + @since 1.2 *) val (<+>) : 'a t -> 'a t -> 'a t (** [a <+> b] is [a] if [a] is [Some _], [b] otherwise *) @@ -131,13 +131,13 @@ val of_list : 'a list -> 'a t (** Head of list, or [None] *) val to_result : 'e -> 'a t -> ('a, 'e) Result.result -(** @since NEXT_RELEASE *) +(** @since 1.2 *) val to_result_lazy : (unit -> 'e) -> 'a t -> ('a, 'e) Result.result -(** @since NEXT_RELEASE *) +(** @since 1.2 *) val of_result : ('a, _) Result.result -> 'a t -(** @since NEXT_RELEASE *) +(** @since 1.2 *) type 'a sequence = ('a -> unit) -> unit type 'a gen = unit -> 'a option diff --git a/src/core/CCResult.mli b/src/core/CCResult.mli index 9c6a9b49..c0e7b63e 100644 --- a/src/core/CCResult.mli +++ b/src/core/CCResult.mli @@ -46,7 +46,7 @@ val add_ctx : string -> ('a, string) t -> ('a, string) t (** [add_ctx msg] leaves [Ok x] untouched, but transforms [Error s] into [Error s'] where [s'] contains the additional context given by [msg] - @since NEXT_RELEASE *) + @since 1.2 *) val add_ctxf : ('a, Format.formatter, unit, ('b, string) t -> ('b, string) t) format4 -> 'a (** [add_ctxf format_message] is similar to {!add_ctx} but with @@ -54,7 +54,7 @@ val add_ctxf : ('a, Format.formatter, unit, ('b, string) t -> ('b, string) t) fo Example: {[ add_ctxf "message(number %d, foo: %B)" 42 true (Error "error)" ]} - @since NEXT_RELEASE *) + @since 1.2 *) val map : ('a -> 'b) -> ('a, 'err) t -> ('b, 'err) t (** Map on success *) @@ -104,7 +104,7 @@ val fold : ok:('a -> 'b) -> error:('err -> 'b) -> ('a, 'err) t -> 'b val fold_ok : ('a -> 'b -> 'a) -> 'a -> ('b, _) t -> 'a (** [fold_ok f acc r] will compute [f acc x] if [r=Ok x], and return [acc] otherwise, as if the result were a mere option. - @since NEXT_RELEASE *) + @since 1.2 *) val is_ok : ('a, 'err) t -> bool (** Return true if Ok diff --git a/src/core/CCString.mli b/src/core/CCString.mli index 98be782f..83fde8c7 100644 --- a/src/core/CCString.mli +++ b/src/core/CCString.mli @@ -353,11 +353,11 @@ include S with type t := string val ltrim : t -> t (** trim space on the left (see {!String.trim} for more details) - @since NEXT_RELEASE *) + @since 1.2 *) val rtrim : t -> t (** trim space on the right (see {!String.trim} for more details) - @since NEXT_RELEASE *) + @since 1.2 *) (*$= & ~printer:id "abc " (ltrim " abc ") @@ -428,7 +428,7 @@ val lowercase_ascii : string -> string val equal_caseless : string -> string -> bool (** Comparison without respect to {b ascii} lowercase. - @since NEXT_RELEASE *) + @since 1.2 *) (*$T equal_caseless "foo" "FoO" @@ -540,7 +540,7 @@ end val split_on_char : char -> string -> string list (** Split the string along the given char - @since NEXT_RELEASE *) + @since 1.2 *) (*$= & ~printer:Q.Print.(list string) ["a"; "few"; "words"; "from"; "our"; "sponsors"] \ @@ -555,7 +555,7 @@ val split_on_char : char -> string -> string list val split : by:string -> string -> string list (** Alias to {!Split.list_cpy} - @since NEXT_RELEASE *) + @since 1.2 *) (** {2 Utils} *) @@ -635,7 +635,7 @@ module Sub : sig val get : t -> int -> char (** [get s i] gets the [i]-th element, or fails @raise Invalid_argument if the index is not within [0... length -1] - @since NEXT_RELEASE *) + @since 1.2 *) include S with type t := t diff --git a/src/data/CCBV.mli b/src/data/CCBV.mli index 4d0e4bae..247aafee 100644 --- a/src/data/CCBV.mli +++ b/src/data/CCBV.mli @@ -3,7 +3,7 @@ (** {2 Imperative Bitvectors} - {b BREAKING CHANGES} since NEXT_RELEASE: + {b BREAKING CHANGES} since 1.2: size is now stored along with the bitvector. Some functions have a new signature. @@ -30,13 +30,13 @@ val cardinal : t -> int val length : t -> int (** Size of underlying bitvector. This is not related to the underlying implementation. - Changed at NEXT_RELEASE + Changed at 1.2 *) val capacity : t -> int (** The number of bits this bitvector can store without resizing. - @since NEXT_RELEASE *) + @since 1.2 *) val resize : t -> int -> unit (** Resize the BV so that it has the specified length. This can grow or shrink @@ -83,12 +83,12 @@ val of_list : int list -> t val first : t -> int option (** First set bit, or return None. - changed type at NEXT_RELEASE *) + changed type at 1.2 *) val first_exn : t -> int (** First set bit, or @raise Not_found if all bits are 0 - @since NEXT_RELEASE *) + @since 1.2 *) val filter : t -> (int -> bool) -> unit (** [filter bv p] only keeps the true bits of [bv] whose [index] @@ -97,7 +97,7 @@ val filter : t -> (int -> bool) -> unit val negate_self : t -> unit (** [negate_self t] flips all of the bits in [t]. - @since NEXT_RELEASE *) + @since 1.2 *) val negate : t -> t (** [negate t] returns a copy of [t] with all of the bits flipped. *) @@ -121,12 +121,12 @@ val inter : t -> t -> t val diff_into : into:t -> t -> unit (** [diff ~into t] Modify [into] with only the bits set but not in [t]. - @since NEXT_RELEASE *) + @since 1.2 *) val diff : t -> t -> t (** [diff t1 t2] Return those bits found [t1] but not in [t2]. - @since NEXT_RELEASE *) + @since 1.2 *) val select : t -> 'a array -> 'a list (** [select arr bv] selects the elements of [arr] whose index diff --git a/src/unix/CCUnix.mli b/src/unix/CCUnix.mli index 6e6be9a2..3515f0de 100644 --- a/src/unix/CCUnix.mli +++ b/src/unix/CCUnix.mli @@ -168,7 +168,7 @@ val with_file_lock : kind:[`Read|`Write] -> string -> (unit -> 'a) -> 'a re-raised after the file is unlocked. @param kind specifies whether the lock is read-only or read-write. - @since NEXT_RELEASE *) + @since 1.2 *) (** {2 Infix Functions} *)