OCaml Weekly News

Previous Week Up Next Week


Here is the latest OCaml Weekly News, for the week of August 17 to 24, 2021.

Table of Contents

routes v1.0.0 released

Anurag Soni announced

I'd like to announce release of version 1.0.0 of routes. The PR to opam repository has been merged, and the new release should be available via opam once the package cache refreshes.

Routes provides a DSL for bi-directional URI dispatch. It allows writing route definitions that can be used for both matching, and printing URI paths.

Changes since the last opam release:

  • Support for merging two routers by adding a union operation (#115, @Chattered)
  • Support for wildcard parameters (#118, #129, @Lupus) -> Compile time checks ensure that wildcard parameters can only be defined at the end of a route
  • Support map operation for path parameter definitions, and support defining path prefixes that can be pre-prended to other routes (#121, @Chattered)
  • Addition of a ksprintf style function for routes. (#123, @Chattered)

Examples of how to use the library are available in the tests and in a small demo

Documentation can be found here


1.0.0 is available via opam now - http://opam.ocaml.org/packages/routes/routes.1.0.0/

Feather 0.3.0

Charles announced

I'm happy to announce Feather 0.3.0! Feather is a minimal library for bash-like scripting and process execution. (github/tutorial, documentation) This release adds two major features:

1. A new interface for collecting the exit status, stdout, and stderr of a Feather command.

For example, you can easily print a process's stderr if it exits non-zero:

open Feather;;
let stderr, status =
  process "ls" [ "/tmp/does-not-exist" ] |> collect stderr_and_status
if status <> 0 then failwith ("ls failed with stderr:\n" ^ stderr)

where the types are

val process : string -> string list -> cmd

type 'a what_to_collect
val stderr_and_status : (string * int) what_to_collect

val collect :
  ?cwd:string ->
  ?env:(string * string) ->
  'a what_to_collect ->
  cmd ->

as you can imagine, we expose several of these what_to_collect's. Here's the full set:

val stdout : string what_to_collect
val stderr : string what_to_collect
val status : int what_to_collect

val stdout_and_stderr : (string * string) what_to_collect
val stdout_and_status : (string * int) what_to_collect
val stderr_and_status : (string * int) what_to_collect

type everything = { stdout : string; stderr : string; status : int }
val everything : everything what_to_collect

We considered different design approaches here. I think what we landed on keeps the call site readable and the types of the interface simple.

It should be noted: the simplest way to run a command without collecting anything is to use Feather.run.

2. The ability to wait on background processes and collect their output.

Starting with Feather 0.1.0, you were able to start processes in the background, but the only way to wait for them to complete was to use Feather's async wrapper. For those wanting an async-less, direct-style interface, we now expose new methods to do this properly:

type 'a background_process

val run_in_background :
  ?⁠cwd:string ->
  ?⁠env:(string * string) Base.list ->
  cmd ->
  unit background_process

val collect_in_background :
  ?cwd:string ->
  ?env:(string * string) list ->
  'a what_to_collect ->
  cmd ->
  'a background_process

val wait : 'a background_process -> 'a
val wait_all : unit -> unit

where an example use might be

let server_process =
   process "my-server.exe" [] |> collect_in_background stdout_and_status
... do other things ...
match Feather.wait server_process with
| (stdout, 0) -> ...
| (_, 1) -> ...

Thanks again to @Firobe and @tmarti2 for their contributions to this release! I think we've made a lot of progress here and I'm excited to see where things go :slight_smile:

Release of GopCaml-mode (0.0.3) and GopCaml-mode-Merlin (0.0.4) - Wizardry release

Kiran Gopinathan announced

I'm pleased to announce the latest version of GopCaml-mode (0.0.3), and the new release of GopCaml-mode-Merlin (0.0.4).

GopCaml-mode-Merlin is a brand new! variant of GopCaml-mode that uses the Merlin parser rather than the OCaml compiler-libs one, and thus has some level of robustness to invalid syntax:


If that's piqued your interest, I'd recommend checking out the release posts for the previous versions for more details on what GopCaml can do, and how to get it: 0.0.2 release, 0.0.1 release

The Merlin parser seems to assign text-regions for syntactic constructs slightly more liberally than the standard OCaml parser, so the overlays can feel a bit weird if you're used to the normal GopCaml overlays, but the benefit is that all your favorite structural movement/transformation operations work even when you're dealing with ill-formed programs, allowing for a more fluid editing experience:


Detailed Changelog

  • new! [for GopCaml-mode-Merlin] Robustness to ill-formated syntax
    • Vendored a copy of Merlin to reuse its parser and thereby gain it's robustness to invalid syntax.
  • new! Added support for customisable verbosity
    • Customise the Emacs variable `gopcaml-messaging-level` to change the level of messages that are output by GopCaml. Set it to `'none` to disable messages entirely.
  • new! Fixed bug when starting zipper mode at the start of a file.
    • Zipper mode selects the immediately prior byte position to avoid inconsistencies when the cursor is just on the edge of an expression, but when the cursor is at position 1, this causes an error as 0 is not a valid point.
  • new! Special casing of shebangs
    • Added support for handling shebangs at the start of a buffer.
    • Implemented as part of a larger library for preprocessing buffertext before running the parser on it - could be extended to support additional preprocessing in the future.
    • Another possible direction for extension is to use an Emacs callback to modify the text, although this may not be ideal, as the parsing has to be as fast as possible.

Get Gopcaml-mode

Its as easy as 1, 2, 3!

  1. Install from opam (either `gopcaml-mode` xor `gopcaml-mode-merlin`):

    opam install gopcaml-mode


    opam install gopcaml-mode-merlin
  2. Compile your emacs with support for dynamic modules
  3. Load gopcaml-mode in your init.el:

    (let ((opam-share (ignore-errors (car (process-lines "opam" "var" "share")))))
        (when (and opam-share (file-directory-p opam-share))
          ;; Register Gopcaml mode
          (add-to-list 'load-path (expand-file-name "emacs/site-lisp" opam-share))
            (autoload 'gopcaml-mode "gopcaml-mode" nil t nil)
            (autoload 'tuareg-mode "tuareg" nil t nil)
            (autoload 'merlin-mode "merlin" "Merlin mode" t)
          ;; Automatically start it in OCaml buffers
          (setq auto-mode-alist
          (append '(("\\.ml[ily]?$" . gopcaml-mode)
              ("\\.topml$" . gopcaml-mode))

See the release post for version 0.0.1 for detailed instructions on how you can install it.

Share my experience about running OCaml on WebAssembly

Vincent Chan announced

In the last two weeks, I was working on migrating OCaml to WebAssembly. I wrote an article to share my experience.

Run OCaml in the browser by WebAssembly | by Vincent Chan | Aug, 2021 | Medium


If you happen to miss a CWN, you can send me a message and I'll mail it to you, or go take a look at the archive or the RSS feed of the archives.

If you also wish to receive it every week by mail, you may subscribe online.