109.44.00

- Implemented `Dequeue.iter` directly, instead of as a specialization
  of `fold`.

  Extended random tests to cover `iter`.
109.45.00

- Changed `Blang.bind` to short-circuit `And`, `Or`, and `If`
  expressions.

  For example if `bind t1 f ` false`, then `bind (and_ t1 t2) `
  false`, and will not evaluate `bind t2 f`.

- Renamed `Dequeue.get` as `get_opt`, and `get_exn` as `get`, to be
  consistent with other containers which don't use the `_exn` suffix
  for subscripting exceptions.
- Removed `Source_code_position.to_sexp_hum`, in favor of
  `sexp_of_t_hum`, which works smoothly with `with sexp`.
- Changed `Flat_queue_unit_tests` to run `Flat_queue.invariant`, which
  was mistakenly not being used.
109.47.00

- Added `Error.to_info` and `of_info`.
- Significantly sped up `Float.iround_*` functions.

  For `iround_down_exn`, the new version appears to use about 25% of the
  CPU time of the old version on non-negative floats.  For negative
  floats it uses around 60% of the CPU time.

  ```
  ┌─────────────────────────┬───────────┬──────────┐
  │ Name                    │ Time (ns) │ % of max │
  ├─────────────────────────┼───────────┼──────────┤
  │ old iround_down_exn pos │     15.02 │    95.23 │
  │ new iround_down_exn pos │      3.75 │    23.75 │
  │ old iround_down_exn neg │     15.78 │   100.00 │
  │ new iround_down_exn neg │      9.80 │    62.10 │
  └─────────────────────────┴───────────┴──────────┘
  ```
- Added `Binary_searchable.Make` functor to core, and used it in `Array` and `Dequeue`.
- Fixed `Bounded_int_table` to match `Invariant.S2`.
- Added to `Pool` support for `10-`, `11-`, and `12-` tuples.
- Added functions to the `Gc` module to get usage information without allocating.

  Added these functions, all of type `unit -> int`:

  ```
  minor_collections
  major_collections
  heap_words
  heap_chunks
  compactions
  top_heap_words
  ```

  They all satisfy:

  ```ocaml
  Gc.f () = (Gc.quick_stat ()).Gc.Stat.f
  ```

  They all avoid the allocation of the stat record, so one can monitor
  the garbage collector without perturbing it.
109.52.00

- Added to `Binary_packing` module functions for packing and unpacking
  signed 64-bit ints in little- and big-endian.
- Changed the `Comparator` interfaces to no longer have `with bin_io`
  or `with sexp`.

  The `Comparator` interfaces are now just about having a comparator.

  Also, renamed `type comparator` as `type comparator_witness`.  And,
  removed `Comparator.S_binable`, since one can use:

  ```ocaml
  type t with bin_io
  include Comparator.S with type t :` t
  ```
- Changed `Comparator.Make` to return a module without a type `t`,
  like other `*able` functors,

   This made it possible to remove the signature constraint when
  `Comparator.Make` is applied.
- Made `Comparable.S_binable` be like `Comparable.S` and not have
  `type t with sexp`.

  The following two functors now fail to type check:

  ```ocaml
  module F1 (M : Comparable.S        ) : sig type t with sexp end ` M
  module F2 (M : Comparable.S_binable) : sig type t with sexp end ` M
  ```

  whereas previously `F1` was rejected and `F2` was accepted.
- Changed the `Monad.Make` functor to require a `val map` argument.

  This was done since we almost always want a specialized `map`, and
  we kept making the mistake of not overriding the generic one in the
  three places needed.

  Added `Monad.map_via_bind`, which one can use to create a standard
  `map` function using `bind` and `return`.
- Removed unnecessary signature constraints on the result of applying
  `Monad.Make`.

  Some time ago, `Monad.Make` changed from returning:

  ```ocaml
  S with type 'a t ` 'a M.t
  ```

  to returning:

  ```ocaml
  S with type 'a t :` 'a M.t
  ```

  so we no longer need to constrain the result of `Monad.Make` at its
  uses to remove `t`.
- Changed `String.exists` and `String.for_all` to iterate by
  increasing index rather than decreasing.
- Added `with compare` to module `Ref`.
- Made `Flags` be `Comparable`, with the order consistent with bitwise
  subset.
- Cleaned up the implementation of `Union_find`.

  Improvemed the code in `union_find.ml`:

  * Removed an assert false.
  * do not reallocate a parent node during compress. This should
    result in more stability for sets memory wise.
  * Added implementation notes.
  * Renamed internal variant constructors.
  * Added unit tests.
- Added `Float.O`, a sub-module intended to be used with local opens.

  The idea is to be able to write expressions like:

  ```ocaml
  Float.O.((3. + 4.) > 6. / 2.)
  ```

  This idiom is expected to be extended to other modules as well.
- Added a `sexp_of_t` converter to `Type_equal.Id`.
- Replaced `Univ.Constr` with `Type_equal.Id`.
- Added `Debug.eprintf`, analogous to `eprint` and `eprints`.
109.53.00

- Added `Float.to_string_round_trippable`, which produces a string
  that loses no precision but (usually) uses as few digits as
  possible.

  This can eliminate noise at the end (e.g. `3.14` not
  `3.1400000000000001243`).

  Benchmarks:

  New sexp:

  ```ocaml
  ┌────────────────────────┬──────────┬─────────┬────────────┐
  │ Name                   │ Time/Run │ mWd/Run │ Percentage │
  ├────────────────────────┼──────────┼─────────┼────────────┤
  │ new Float.sexp_of 3.14 │ 463.28ns │   6.00w │     48.88% │
  │ new Float.sexp_of e    │ 947.71ns │  12.00w │    100.00% │
  └────────────────────────┴──────────┴─────────┴────────────┘
  ```

  Old sexp:

  ```ocaml
  ┌────────────────────────┬──────────┬─────────┬────────────┐
  │ Name                   │ Time/Run │ mWd/Run │ Percentage │
  ├────────────────────────┼──────────┼─────────┼────────────┤
  │ old Float.sexp_of 3.14 │ 841.99ns │ 178.00w │     98.03% │
  │ old Float.sexp_of e    │ 858.94ns │ 178.00w │    100.00% │
  └────────────────────────┴──────────┴─────────┴────────────┘
  ```

  Much of the speedup in the 3.14 case comes from the fact that
  `format_float "%.15g"` is much faster than `sprintf "%.15g"`.  And
  of course the above does not capture any of the benefits of dealing
  with shorter strings down the road.

  Here are some detailed benchmarks of the various bits and pieces of
  what's going on here:

  ```ocaml
  ┌─────────────────────────────────────┬────────────┬─────────┬────────────┐
  │ Name                                │   Time/Run │ mWd/Run │ Percentage │
  ├─────────────────────────────────────┼────────────┼─────────┼────────────┤
  │ format_float '%.15g' 3.14           │   335.96ns │   2.00w │     32.71% │
  │ format_float '%.17g' 3.14           │   394.18ns │   4.00w │     38.38% │
  │ format_float '%.20g' 3.14           │   459.79ns │   4.00w │     44.77% │
  │ format_float '%.40g' 3.14           │   638.06ns │   7.00w │     62.13% │
  │ sprintf '%.15g' 3.14                │   723.71ns │ 165.00w │     70.47% │
  │ sprintf '%.17g' 3.14                │   803.44ns │ 173.00w │     78.23% │
  │ sprintf '%.20g' 3.14                │   920.78ns │ 176.00w │     89.66% │
  │ sprintf '%.40g' 3.14                │   990.09ns │ 187.00w │     96.41% │
  │ format_float '%.15g' e              │   357.59ns │   4.00w │     34.82% │
  │ format_float '%.17g' e              │   372.16ns │   4.00w │     36.24% │
  │ format_float '%.20g' e              │   434.59ns │   4.00w │     42.32% │
  │ format_float '%.40g' e              │   592.78ns │   7.00w │     57.72% │
  │ sprintf '%.15g' e                   │   742.12ns │ 173.00w │     72.26% │
  │ sprintf '%.17g' e                   │   747.92ns │ 173.00w │     72.83% │
  │ sprintf '%.20g' e                   │   836.30ns │ 176.00w │     81.43% │
  │ sprintf '%.40g' e                   │ 1_026.96ns │ 187.00w │    100.00% │
  │ valid_float_lexem 12345678901234567 │    76.29ns │   9.00w │      7.43% │
  │ valid_float_lexem 3.14              │     9.28ns │   5.00w │      0.90% │
  │ float_of_string 3.14                │   130.19ns │   2.00w │     12.68% │
  │ float_of_string 1234567890123456.7  │   184.33ns │   2.00w │     17.95% │
  │ to_string 3.14                      │   316.47ns │   7.00w │     30.82% │
  │ to_string_round_trippable 3.14      │   466.02ns │   9.00w │     45.38% │
  │ to_string e                         │   315.41ns │   7.00w │     30.71% │
  │ to_string_round_trippable e         │   949.12ns │  15.00w │     92.42% │
  └─────────────────────────────────────┴────────────┴─────────┴────────────┘
  ```

- Replaced `Float.min_positive_value` with `min_positive_normal_value`
  and `min_positive_subnormal_value`.
- Added some functions to `Float.O`: `abs`, `of_float`, and
  `Robustly_comparable.S`.
- Small improvements to the `Heap` module.

  Implemented `Heap.iter` directly rather than in terms of `fold`.

  In `heap.ml`, fixed the idiom for using `Container.Make`.
- Added an `Int.O` and other `Int*.O` modules, with arithmetic
  operators, infix comparators, and a few useful arithmetic values.
- Added `Int.( ~- )`, for unary negation.
- Added `Pool.unsafe_free`.
- Added `Percent` module.
32bits fix
fix build on 32bits again
109.55.00

- Added `with typerep` to many `Core` types.
- Changed `Flat_queue` to raise if the queue is mutated during
  iteration.
- Improved `Map.merge` to run in linear time.
fix _tags for oasis 0.4.0
remove the res dependency
109.58.00

- Moved all of the `Gc` module into `Core_kernel`.

  Part of the `Gc` module used to be in `Core` because it used
  threads.  But it doesn't use threads anymore, so can be all in
  `Core_kernel`.
- Made `Stable.Map` and `Set` have `with compare`.
- Added `String.rev`.

  Closes janestreet/core#16

  We will not add `String.rev_inplace`, as we do not want to encourage
  mutation of strings.
- Made `Univ_map.Key` equivalent to `Type_equal.Id`.
- Added `Univ.view`, which exposes `Univ.t` as an existential, `type t
  = T : 'a Id.t * 'a -> t`.

  Exposing the existential makes it possible to, for example, use
  `Univ_map.set` to construct a `Univ_map.t`from a list of `Univ.t`s.

  This representation is currently the same as the underlying
  representation, but to make changes to the underlying representation
  easier, it has been put in a module `Univ.View`.
109.60.00

- Added `Gc.keep_alive`, which ensures its argument is live at the point
  of the call.
- Added `Sexp.With_text` module, which keeps a value and the a sexp it
  was generated from, preserving the original formatting.
110.01.00

- Changed `Queue` from a linked to an array-backed implementation.

  Renamed the previous implementation to `Linked_queue`.

  Renamed `transfer`, which was constant time, as `blit_transfer`,
  which is linear time.

  Removed `partial_iter`.  One can use `with_return`.

  Added `singleton`, `filter`, `get`, `set`.
- For `Error` and `Info`, changed `to_string_hum` to use `sexp_of_t`
  and `Sexp.to_string_hum`, rather than a custom string format.
- Changed the output format of `Validate.errors` to be a sexp.
- Added `Hashtbl.of_alist_or_error` and `Map.of_alist_or_error`.
- Added `String_id.Make` functor, which includes a module name for
  better error messages.
- Exposed `Bucket.size`.
- Changed the default for `Debug.should_print_backtrace` to be `false`
  rather than `true`.

  Usually the backtraces are noise.
- Removed the tuning of gc parameters built in to Core, so that the
  default is now the stock OCaml settings.

  Such tuning doesn't belong in Core, but rather done per application.
  Also, the Core settings had fallen way out of date, and not kept up
  with changes in the OCaml runtime settings.  We have one example
  (lwt on async) where the Core settings significantly slowed down a
  program.
- Added `Exn.raise_without_backtrace`, to raise without building a
  backtrace.

  `raise_without_backtrace` never builds a backtrace, even when
  `Backtrace.am_recording ()`.
- Made `with_return` faster by using `Exn.raise_without_backtrace`.
- Improved `with_return` to detect usage of a `return` after its
  creating `with_return` has returned.
remove the Document section
Merge remote-tracking branch 'upstream/master'