I'm happy to announce the 111.21.00 release of the Core suite.

The following packages were upgraded:

- async_extended
- async_extra
- async_ssl
- async_unix
- core
- core_kernel
- custom_printf
- jenga
- ocaml_plugin
- patdiff
- patience_diff

Files and documentation for this release are available on our website and
all packages are in opam:

  https://ocaml.janestreet.com/ocaml-core/111.21.00/individual
  https://ocaml.janestreet.com/ocaml-core/111.21.00/doc

Here is the list of changes for this version:

## async_extra

- Added `Sexp_hum` `Log.Output.format`, which is useful for making logs
  more human readable.
- Added `with compare` to `Rpc.Implementation.Description`.

## async_ssl

- Upgraded to use new ctypes and its new stub generation methods.

## async_unix

- Added `Process.wait_stdout` and `wait_stdout_lines`, which are like
  `run` and `run_lines`, but take a `Process.t`.

## core

- Fixed an issue where `Time.Zone.init` would not properly traverse the
  directory containing timezone information.
- Added `Time.With_utc_sexp`, which has stable serialization of `Time.t`
  that is byte-for-byte equal across timezones.
- Made `Uuid` stable.
- Made `Piecewise_linear` stable.

## core_kernel

- Removed our custom C stub for closing channels, reverting to the one
  in the OCaml runtime.

    A long time ago we found that the OCaml runtime did not release the
    lock before calling `close` on the fd underlying a channel.  On some
    filesystems (e.g. smb, nfs) this could cause a runtime hang.  We
    filed a bug with INRIA and wrote our own `close` function which
    `In_channel` calls to this day.  The bug has long been fixed, and
    our function is probably buggy, so this reverts us to the runtime's
    `close`.

- Added `Float.{of,to}_int64_preserve_order`, which implement the
  order-preserving zero-preserving bijection between non-NaN floats and
  99.95% of `Int64`'s.

    Used the new function to improve `one_ulp`, which is now exposed:

        (** The next or previous representable float.  ULP stands for "unit
of least precision",
            and is the spacing between floating point numbers.  Both
[one_ulp `Up infinity] and
            [one_ulp `Down neg_infinity] return a nan. *)
        val one_ulp : [`Up | `Down] -> t -> t

- Changed `Map.symmetric_diff` to return a `Sequence.t`
  instead of a `list`.
- Added `Sequence.filter_map`.
- Improved `Stable_unit_test.Make_sexp_deserialization_test`'s error
  message so that it includes the expected sexp.

## custom_printf

- Fixed a bug in which custom-printf syntax was incompatible with
  labeled arguments.

    For example, the preprocessor used to raise an exception on this code:

        let f ~labeled_arg:() fmt = ksprintf (fun _ -> ()) fmt in
        f !"hello" ~labeled_arg:()

## jenga

- Introduced jenga API v3, a small cleanup of v2 which has been planned
  for a while.

## ocaml_plugin

- Fixed a bug in `ocaml_embed_compiler` on 32-bit machines.

    `ocaml_embed_compiler` tries to read the full contents of the file as
    a string, but the string might be too big on 32bits:

    https://github.com/ocaml/opam-repository/pull/2062#issuecomment-43045491

## patdiff

- Added `Patdiff_core.iter_ansi`.

        (** Iter along the lines of the diff and the breaks between hunks.
Offers more flexibility
            regarding what the caller wants to do with the lines *)
        val iter_ansi
          :  f_hunk_break:((int*int) -> (int*int) -> unit)
          -> f_line:(string -> unit)
          -> string Patience_diff.Hunk.t list
          -> unit

## patience_diff

- Added plain differ `Plain_diff` and use it in some cases for
  improved results.
- Move modules under `Patience_diff_lib.Std`.

---

We hope you find it useful!

-- Ben Millwood, on behalf of the Core team.