[Caml-list] Attn: Development Editor, Latest OCaml Weekly News

[Alan Schmitt <alan.schmitt@polytechnique.org>]

[-- Attachment #1: Type: text/plain, Size: 13392 bytes --]

Hello

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

Table of Contents
─────────────────

routes v1.0.0 released
Feather 0.3.0
Release of GopCaml-mode (0.0.3) and GopCaml-mode-Merlin (0.0.4) - Wizardry release
Share my experience about running OCaml on WebAssembly
Old CWN


routes v1.0.0 released
══════════════════════

  Archive:
  <https://discuss.ocaml.org/t/ann-routes-v1-0-0-released/8319/1>


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]

  *Edit*

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


[routes] <https://github.com/anuragsoni/routes/>

[#115] <https://github.com/anuragsoni/routes/pull/115>

[@Chattered] <https://github.com/Chattered>

[#118] <https://github.com/anuragsoni/routes/pull/118>

[#129] <https://github.com/anuragsoni/routes/pull/129>

[@Lupus] <https://github.com/Lupus>

[#121] <https://github.com/anuragsoni/routes/pull/121>

[#123] <https://github.com/anuragsoni/routes/pull/123>

[tests]
<https://github.com/anuragsoni/routes/blob/b9bb8a0f50b7bd9fbd0c79113142ea82830ce2bb/test/routing_test.ml>

[small demo]
<https://github.com/anuragsoni/routes/blob/b9bb8a0f50b7bd9fbd0c79113142ea82830ce2bb/example/no_http.ml>

[here] <https://anuragsoni.github.io/routes/>


Feather 0.3.0
═════════════

  Archive: <https://discuss.ocaml.org/t/ann-feather-0-3-0/8322/1>


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:


[github/tutorial] <https://github.com/charlesetc/feather>

[documentation]
<https://www.charlesetc.com/feather/feather/Feather/index.html>

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
  │ in
  │ 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 ->
  │   'a
  └────

  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].


[Feather.run]
<https://www.charlesetc.com/feather/feather/Feather/index.html#val-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
  │ in
  │ ... 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:


[async wrapper]
<https://www.charlesetc.com/feather/feather_async/Feather_async/index.html>


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

  Archive:
  <https://discuss.ocaml.org/t/ann-release-of-gopcaml-mode-0-0-3-and-gopcaml-mode-merlin-0-0-4-wizardry-release/8333/1>


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:

  <https://aws1.discourse-cdn.com/standard11/uploads/ocaml/original/2X/a/a09586b9db3bf19667b6969c701a40f0791a2a9d.gif>

  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:

  <https://aws1.discourse-cdn.com/standard11/uploads/ocaml/original/2X/9/9f2976b47018e2d892b9cea09da913d07f8c1f00.gif>


[0.0.2 release]
<https://discuss.ocaml.org/t/ann-release-of-gopcaml-mode-0-0-2-unicode-compatibility-update/7425>

[0.0.1 release]
<https://discuss.ocaml.org/t/introducing-gopcaml-mode-structural-ocaml-editing/5310>

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
     └────
     or
     ┌────
     │ 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))
     │ 	auto-mode-alist))
     │       ))
     └────

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


[release post ]
<https://discuss.ocaml.org/t/introducing-gopcaml-mode-structural-ocaml-editing/5310>


Contribute
╌╌╌╌╌╌╌╌╌╌

  • Github: [GitHub - Gopiandcode/gopcaml-mode: [MIRROR] Ultimate Ocaml
    Editing Mode]
  • Gitlab: [Kiran Gopinathan / gopcaml-mode · GitLab ]


[GitHub - Gopiandcode/gopcaml-mode: [MIRROR] Ultimate Ocaml Editing
Mode] <https://github.com/Gopiandcode/gopcaml-mode>

[Kiran Gopinathan / gopcaml-mode · GitLab ]
<https://gitlab.com/gopiandcode/gopcaml-mode>


Share my experience about running OCaml on WebAssembly
══════════════════════════════════════════════════════

  Archive:
  <https://discuss.ocaml.org/t/share-my-experience-about-running-ocaml-on-webassembly/8343/1>


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]


[Run OCaml in the browser by WebAssembly | by Vincent Chan | Aug, 2021 |
Medium]
<https://okcdz.medium.com/run-ocaml-in-the-browser-by-webassembly-31ce464594c6>


Old CWN
═══════

  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].

  [Alan Schmitt]


[send me a message] <mailto:alan.schmitt@polytechnique.org>

[the archive] <https://alan.petitepomme.net/cwn/>

[RSS feed of the archives] <https://alan.petitepomme.net/cwn/cwn.rss>

[online] <http://lists.idyll.org/listinfo/caml-news-weekly/>

[Alan Schmitt] <https://alan.petitepomme.net/>


[-- Attachment #2: Type: text/html, Size: 27625 bytes --]