OCaml Weekly News

• Changed Base, Core_kernel, and Core functions to raise Not_found_s instead of Not_found. Hashtbl.find_exn and Map.find_exn now include the key in their error message.
• Changed Core and Core_kernel to export int comparison rather than polymorphic comparison.
• Removed the "robust" float comparison operators (>., =., …) from the default namespace.
• Replaced sexp_* types (sexp_list, sexp_option, sexp_opaque, …) with preprocessor attributes ([@sexp.list], [@sexp.option], [@sexp.opaque], …).
• Changed let%map syntax from let%map.Foo.Let_syntax to let%map.Foo.
• Added to match%optional support for specifying a path, so you can write match%optional.Foo foo_option rather than let open Foo.Optional_syntax in match%optional foo_option.
• Improved Base.Backtrace so that it enables recording of backtraces in more situations, specifically when OCAMLRUNPARAM is defined but doesn't mention the backtrace flag, b.
• Added javascript support for Zarith, Bigint, Bignum, and Bigdecimal.
• Changed Hashtbl.create's default size from 128 to 0.
• Changed Core_kernel.Command so that all commands accept double dash flags: --help, --version, and --build-info.

• async_udp (https://github.com/janestreet/async_udp): UDP support for Async.
• async_websocket (https://github.com/janestreet/async_websocket): A library that implements the websocket protocol on top of Async.
• bonsai (https://github.com/janestreet/bonsai): A library for building dynamic webapps, using Js_of_ocaml.
• postgres_async (https://github.com/janestreet/postgres_async): OCaml/async implementation of the postgres protocol (i.e., does not use C-bindings to libpq).
• ppx_cold (https://github.com/janestreet/ppx_cold): Expands [@cold] into [@inline never][@specialise never][@local never].
• ppx_pattern_bind (https://github.com/janestreet/ppx_pattern_bind): A ppx for writing fast incremental bind nodes in a pattern match.
• ppx_python (https://github.com/janestreet/ppx_python): [@@deriving] plugin to generate Python conversion functions.
• ppx_yojson_conv (https://github.com/janestreet/ppx_yojson_conv): [@@deriving] plugin to generate Yojson conversion functions.
• ppx_yojson_conv_lib (https://github.com/janestreet/ppx_yojson_conv_lib): Runtime lib for ppx_yojson_conv.
• pythonlib (https://github.com/janestreet/pythonlib): A library to help writing wrappers around OCaml code for python.
• sexp_select (https://github.com/janestreet/sexp_select): A library to use CSS-style selectors to traverse sexp trees.
• timezone (https://github.com/janestreet/timezone): Time-zone handling.
• toplevel_backend (https://github.com/janestreet/toplevel_backend): Shared backend for setting up toplevels.
• zarith_stubs_js (https://github.com/janestreet/zarith_stubs_js): Javascript stubs for the Zarith library.

Async_kernel:

• Deprecated monadic ignore functions in favor of ignore_m.

Base:

• Deleted Array.replace and replace_all functions, which have been deprecated since before the last public release.
• Deprecated Result.ok_unit; use Ok ().
• Removed the Monad and Applicative interfaces' all_ignore function; it was previously deprecated and replaced by all_unit.
• Removed List.dedup, which has been deprecated since 2017-04.
• Removed String mutation functions, which have been deprecated in favor of Bytes since 2017-10.
• Deprecated Array.truncate, Obj_array.unsafe_truncate, and Uniform_array.unsafe_truncate.
• Deprecated Sys.argv, which has been superseded by get_argv, which is a function, reflecting the fact that argv can change (as of OCaml 4.09).

Core_kernel:

• Removed Core_kernel.Std, which had been deprecated for a year.
• Deprecated type Command.Spec.param in favor of Command.Param.t.
• Removed Hashtbl functions that had been deprecated for years.
• Removed Float.to_string_round_trippable, which has been deprecated in favor of to_string since 2017-04.
• Deprecated Fqueue functions where one should use Fdeque instead: bot, bot_exn, and enqueue_top.
• Deleted Bus.unsubscribes, which will be obviated by a performance improvement to Bus.unsubscribe.

Timing_wheel:

• Removed the alarm_upper_bound function, which has been deprecated for 6 months, and superseded by max_allowed_alarm_time.

Core_kernel:

• Moved Bounded_int_table to a standalone library.
• Moved the Pool and Tuple_type modules to a standalone library, Tuple_pool.

Async_unix:

• Moved Unix.Fd.replace into a Private submodule.

Please visit https://discuss.ocaml.org/t/ann-v0-13-release-of-jane-street-packages/4735

Programs that heavily use match often see a shift to the right due to nested indentation.

match foo with
| Foo -> ...
| Bar x ->
  match bar x with
  | FooBar -> ...
  | Blah y ->
    match f y with
    | Some z ->
      ...

Another problem with this style is that it suffers from the "dangling bar" issue: if you try to add a new case for one of the exterior match, it is parsed as belonging to the innermost match. People have been recommending (rightly) to use begin match .. end for all nested match constructs to avoid this issue.

match foo with
| Foo -> ...
| Bar x ->
  begin match bar x with
  | FooBar -> ...
  | Blah y ->
    begin match f y with
    | None -> ...
    | Some z ->
      ...
    end
  (* now this is safe *)
  | FooBlah -> ...
  end

But still the unpleasant shift to the right remains.

We should in general use begin match .. end for nested matches. But the "cascading tail case" proposal is to not do it for the last case of the pattern-matching, and instead de-indent (dedent) this last case – tail case.

match foo with
| Foo -> ...
| Bar x ->
match bar x with
| FooBar -> ...
| Blah y ->
match f y with
| None -> ...
| Some z ->
...

Note that with this indentation style, the "dangling match" problem is also avoided: unlike with the original, non end-protected program, the indentation makes it immediately obvious that any further case will be attached to the innermost match, and not any of the exterior ones.

A program using this "cascading tail" approach should always use begin match .. end for nested matches, except for a nested match returned within the last branch of an outer match, which can (optionally) be dedented instead.

The choice to dedent the last case corresponds to encouraging a sequential reading of the program, where the other cases are "auxiliary cases" checked first and dispatched quickly, and the last case is the "main part" where the "rest" of the logic of the program lies. This pattern is typical of nested pattern-matching on the option or result type for example:

match foo x with
| Error err ->
  fail_foo_error err
| Ok y ->
match bar y with
| Error err ->
  fail_bar_error err
| Ok () ->
...

Remark: it is not always the case that the Error constructor is the auxiliary case, and the Ok constructor is the main case; sometimes we implement fallback logic like "if foo work then we are good, but otherwise we have to do this and that", and the error case is the most salient (and longer) part of the program logic. I would recommend being mindful, when you write code, of whether there is a most convincing way to "sequentialize" it (distinguish auxiliary and main/tail case), and avoid using cascading tails when there is no clear sequentialization choice.

Remark: some cases of tail cascades can be linearized by using a good definition of "bind" and a monadic style. This tends to be very limited however: it fixes one of the constructors to always be the "tail" constructor (always Some, always Ok), and it only works when the handling of the other constructors is very homogeneous (typically: return directly). In real code, many situations occur where the monadic style doesn't fit the problem, but tail cascade does help writing a readable program.

While I have never seen cascading tail cases in real-world OCaml code before (I'm happy to be given pointers; I think that the idea is not new, but I'm not aware of previous attempts to give it a catchy name and spread the cascade love), this is in fact a new (to me) instance of a common technique that is used for other OCaml constructs:

if foo x then ...
else if bar x then ...
else ... (* this `tail else` was dedented *)

let x = foo in
let y = bar in (* this `tail let` was dedented *)
...            (* and the rest as well *)

bind foo @@ fun x ->
bind bar @@ fun y -> (* this "tail function body" was dedented *)
...                  (* and the rest as well *)

I would call "tail cascade" (or maybe: "cascading tail") the idea of dedenting the "rest" of an OCaml expression (compared to a strict tree-nesting-based approach) when it morally describes the "rest" of the expression. I use the name "tail" because those expressions are almost always in tail-position in the sense of tail-calls.

This general approach legitimizes some styles that I have seen, and sometimes used, in the wild, while at the same time considering that I may have been doing something improper, for example:

if foo then blah else
... (* dedented *)


Fun.protect
  ~finally:(...)
@@ fun () ->
... (* dedented *)


try simple_approach with exn ->
... (* dedented *)


1 +
2 + (* dedented *)
... (* dedented *)

Remark: after a then or else, many people share the reasonable view that any expression containing imperative constructs (foo; bar) should be enclosed in a begin .. end block to avoid surprising-precedence issue. Just as for nested match, this recommendation should be lifted for "tail else" constructs.

Remark: The last example is a case where the dedented expressions are not in tail-position from a runtime-evaluation point of view. I am not sure as whether the two notions should be made to coincide more strongly, but in any case I'm not fond of the style in this particular example, I prefer to move the infix operator to the beginning of the next line instead, following a different style and justification.

The possibility this "cascading tail" style today crucially relies on the nesting properties of open-ended syntactic constructs, notably let (commonly cascaded), and now match and if ... else. Proposals to transition to a syntax where match and else are forced to take a closing marker are incompatible with the cascading style. I have not made my mind on whether this should be considered a blocker for those proposals, but at least it shows that having the open-ended form available has value for certain programs.