OCaml Weekly News

Hi everyone! Last year, we made a series of blogposts describing our plans to introduce Rust-like type system features to OCaml (see here). Now, we are sharing updates on everything we've done since last year for ICFP 2024. Please read our blogpost and check out our compiler extensions at our GitHub!

I have been venturing to learn a new language and I landed on OCaml after hearing a few interesting talks from Jane Street. I just made public a toy autograd engine in OCaml with an Apple Accelerate backend if anyone is interested:

https://github.com/jewelltaylor/camlgrad

I would really appreciate any feedback in terms of the OCaml code that I wrote so that I can improve. If anyone is willing to quickly take a look it would mean a lot :slight_smile:

It is my pleasure to announce a new release of cppo (v1.7.0) with two new features.

• The new syntax #def ... #enddef allows a macro definition to span several lines, without backslashes. This syntax allows macro definitions to be nested.

  #def repeat_until(action,condition)
    action;
    while not (condition) do
      action
    done
  #enddef
  

• A parameterized macro can take a parameterized macro as a parameter: this is a higher-order macro.

  #define TWICE(e)          (e + e)
  #define APPLY(F : [.], e) (let x = (e) in F(x))
  let forty_two =
    APPLY(TWICE,1+2+3+4+5+6)
  

For more details, please see the documentation.

Today, a quick head's up about our contributions to this year's International Conference on Functional Programming which is unraveling right now in Milan!

This year, our team presents two topics:

• "Snapshottable Stores": A generic and efficient data structure for the implementation of backtracking algorithms, used particularly in automatic theorem provers and type checkers. This implementation in OCaml will soon be available on opam.
• A presentation on opam, detailing the contents of the latest major release 2.2, which was released in July, as well as how the opam team operates.

Be sure to checkout the event, there are plenty of great presentations and video replays!

Until next time, which will be sooner than later with another one of our Flambda2 Snippets,

Kind regards, The OCamlPro Team

As promised in our previous post about OCamlPro's contributions to this year's International Conference of Functional Programming, we back again with a new entry in our Flambda2 Snippet blog series!

Flambda2 Ep. 3: Speculative Inlining covers inlining in general as well as how our compiler handles it. We go in detail about how Speculative Inlining allows more significant optimisations to take place.

This blog entry is key for a smooth read of our next article which will cover Upwards and Downwards Traversals in Flambda2.

Happy to say that it's already quite far down the release pipeline!

https://www.gridbugs.org/frustrating-interactions-with-the-ocaml-ecosystem-while-developing-a-synthesizer-library/

Last year I made a synthesizer library in OCaml and had some struggles using Dune and Opam, and also ran into several issues with libraries. I wrote a blog post about all the problems I encountered.

I hope you had a nice summer! Mine took an unexpected turn when, roughly at the same time, I wrote my first cmdliner subcommand and heard about climate for the first time. My experience with OCaml CLI so far had been centered around core.command.

When I read climate's terminology section and how it defines Terms, Arguments, and Parameters, something clicked. Seeing how climate's API managed to make positional and named arguments fit so nicely together, I thought: "Wow, for the first time, it seems I'll be able to write a CLI spec on a whiteboard without referring to some code I never seem to get right (I am looking at you, core.command's anonymous arguments)."

I got quite excited and thought: "Can I switch to climate today?" But reality checked: it's not on opam yet, still under construction, I'm not sure what the community will do, etc.

Implementing my own engine for an API resembling climate felt like a wasted effort, knowing about the work happening in climate. Still, having a 'a Param.t, 'a Arg.t, and 'a Command.t type that I would get to know and love felt too good to pass up.

I stared at the climate types for a while, and filled with happy thoughts about a bright CLI future, it occurred to me: can I use an API like climate but compile it down to existing libraries such as cmdliner or core.command? (and climate too!). I wrote down the following types:

Hi everyone, I'd like to announce the first release of zarr, an Ocaml implementation of the Zarr version 3 storage format specification for chunked & compressed multi-dimensional arrays, designed for use in parallel computing.

There'a new release of Brr, an ISC licenced toolkit for programming browsers with the js_of_ocaml compiler.

This release has some changes to support work being done for wasm_of_ocaml; thanks to @vouillon for his patches. There are also other small fixes and additions, consult the release notes for the details and thanks to all the contributors.

A big thanks to my donators for supporting my work. I welcome the (not so[^1]) new donator Tarides.

Home page, Docs and manuals or odig doc brr

Install: opam install brr (PR)

Best,

Daniel

[^1]: Tarides has been generously donating for my work from the onset but used to do it via the Mirage organisation.

We're delighted to announce a major new version of Ocsigen Server! This version 6.0.0 focuses on the use of Ocsigen Server as a library, without any configuration file, which is now much easier and brings the exact same features as the executable.

Example of use:

To add a Web server to your OCaml program, serving static files from directory `static`:

let _ = Ocsigen_server.start 
          [ Ocsigen_server.host [Staticmod.run ~dir:"static" ()]]

Install:

opam install ocsigenserver

Example of Dune file for this program:

(executable
 (public_name myproject)
 (name main)
 (libraries
  main
  ocsigenserver
  ocsigenserver.ext.staticmod))

Compile with:

dune build

Ocsigen Server can of course still be used as an executable taking its configuration from a file. This allows for non OCaml developers to use it and make their own configurations. It also makes it possible to distribute a binary version of your Web applications.

Ocsigen Server is build in modular and extensible way. The default opam packages comes with several extensions. In the example above, we are using Staticmod for serving static files. Other extensions makes it possible for example to configure redirections, to control the access to some sub-directory, to use a reverse proxy, to rewrite the request, compress the output etc.

The programming interface follows exactly the structure of the configuration file: instructions are tried in order until one generates a result, then some other instructions can be used to change the result (like compressing it or adding some headers).

Here is a more complex example of configuration:

let _ =
  Ocsigen_server.start
    ~ports:[`All, 8080]
    ~command_pipe:"local/var/run/mysite-cmd"
    ~logdir:"local/var/log/mysite"
    ~datadir:"local/var/data/mysite"
    ~default_charset:(Some "utf-8")
    [ Ocsigen_server.host
        ~regexp:"mydomain.com"
        [ Ocsigen_server.site ["subsite"]
            [ Accesscontrol.(
                if_
                  (and_
                     [ ip "122.122.122.122"
                     ; header ~name:"user-agent" ~regexp:".*FooBar.*"
                     ; method_ `POST ])
                  [forbidden] [])
            ; Authbasic.run ~realm:"myrealm"
                ~auth:(fun _u p -> Lwt.return (p = "toto"))
                ()
            ; Staticmod.run ~dir:"local/var/www/otherdir" () ]
        ; Ocsigen_server.site ["othersubsite"]
            [ Revproxy.run
                ~redirection:
                  (Revproxy.create_redirection ~full_url:false ~regexp:"(.*)"
                     ~keephost:true "http://localhost:8888/\\1")
                () ]
        ; Redirectmod.run
            ~redirection:
              (Redirectmod.create_redirection ~full_url:false ~regexp:"old(.*)"
                 "new\\1")
            ()
        ; Staticmod.run ~dir:"local/var/www/staticdir" ()
        ; Cors.run ~max_age:86400 ~credentials:true ~methods:[`POST; `GET; `HEAD]
            ~exposed_headers:
              [ "x-eliom-application"
              ; "x-eliom-location"
              ; "x-eliom-set-process-cookies"
              ; "x-eliom-set-cookie-substitutes" ]
            ()
        ; Deflatemod.run
            ~mode:
              (`Only
                [ `Type (Some "text", Some "html")
                ; `Type (Some "text", Some "javascript")
                ; `Type (Some "text", Some "css")
                ; `Type (Some "application", Some "javascript")
                ; `Type (Some "application", Some "x-javascript")
                ; `Type (Some "application", Some "xhtml+xml")
                ; `Type (Some "image", Some "svg+xml")
                ; `Type (Some "application", Some "x-eliom") ])
            () ] ]

In this example, the server defines one virtual host for domain mydomain.com. It will first check whether it is a request for directory subsite/, and if yes, will reject the request with 403 Forbidden if it is a POST request coming from user-agent FooBar at IP 122.122.122.122. If not, it will ask for a password before serving files from directory local/var/www/otherdir. Then we define another subsite othersubsite for which the requests will be transfered to another Web server running locally on port 8888, then rewrite the answer location header accordingly. Then, if the page is still not generated, the server will send a redirection if URLs starts with "old". Otherwise, it will try to serve files from directory local/var/www/staticdir. If the page has still not been found, a 404 Not found will be sent, otherwise, some CORS headers will be added, and the result will be compressed before being sent.

Compile this example with the following dune file:

(executable
 (public_name myserver)
 (name main)
 (libraries
  ocsigenserver
  ocsigenserver.ext.staticmod
  ocsigenserver.ext.authbasic
  ocsigenserver.ext.extendconfiguration
  ocsigenserver.ext.outputfilter
  ocsigenserver.ext.cors
  ocsigenserver.ext.accesscontrol
  ocsigenserver.ext.deflatemod
  ocsigenserver.ext.redirectmod
  ocsigenserver.ext.revproxy
 ))

Eliom and Ocsigen Start have also been updated for being used without configuration file and will be released very soon.

[ANN] dream-html & pure-html 3.6.1, 3.6.2

A double announcement:

3.6.1: when in XML rendering mode, correctly render empty-value attributes as having an empty string value. Thanks to @jonsterling !

3.6.2: automatically switch to XML rendering mode when rendering SVG and MathML tags inside HTML rendering mode.

Here are links from many OCaml blogs aggregated at the ocaml.org blog.

• Outreachy May 2024 Demo
• Frama-Clang v0.0.16 for Frama-C 29.0 Copper
• Easy Debugging for OCaml With LLDB
• Getting Specific: Announcing the Gospel and Ortac Projects
• Upcoming OCaml Events (Sep 2024 and onwards)