esbullington / monadic

A monad transformers library for OCaml, based on transformers and mtl

Monadic

Monadic is a Monad library for OCaml. It implements its monads as Monad Transformers, so you can nest them together for powerful computation expressions.

It focuses on implementation simplicity, DRYness, extensibility, in leveraging the new OCaml syntax sugars (let+, and+, and let*), and in documentation.

Simplicity

The library will not have any dependencies besides dev-dependencies that help on editor support, such as ocaml-language-server.

If it uses unusual module-level or type-level programming, it will be well documented so that client users can use the same sort of tricks on their extensions.

DRYness

As much as possible, the library will try to avoid code repetition.

Extensibility

The library aims at simplicity so that users can implement their own Monadic-compatible monad transformers. For instance, one might want to implement a Lwt-based monad transformer, so that they combine the Option transformer with async-based programming. The library should make that easy, and document the steps necessary to do that. One might even release this extension as a library.

New OCaml syntax sugars

The new OCaml syntax sugars, perhaps inspired by Haskell’s do syntax and F#’s computational expressions, helps making monadic code look a lot prettier. The sugar was the inspiration for this library even existing. ReasonML and BuckleScript already support OCaml 4.08, but ReScript still doesn’t. So the library will not work on ReScript.

Documentation

While this library aims at having simple implementation, the documentation should be extensive. People should be comfortable with using monad transformers in OCaml.

Comparison with ocaml-mtl

Feature-set

For now, MTL (being older) is more feature-complete. On the other hand, its documentation is sub-par, and it hasn’t been updated for a long time. Its implementation details are also quite complex.

Here is a list of monad transformers in each library:

Transformer	Monadic	MTL
Identity	[X]	[X]
Option (called Maybe in MTL)	[X]	[X]
Result (called Error in MTL)	[X]	[X]
Reader	[X]	[X]
State	[X]	[X]
Writer	[X]	[X]
RefState	[X]	[ ]
List	[X]	[X]
ZipList	[X]	[ ]
Array	[X]	[ ]
ZipArray	[X]	[ ]
Seq	[X]	[ ]
ZipSeq	[X]	[ ]
Continuation	[ ]	[X]
Ref	[ ]	[X]
Tree	[ ]	[X]

Some observations:

RefState in Monadic is simply a State monad implemented internally by using a Ref instead of passing a tuple ahead in the context. Sometimes it might be more efficient as a regular State, but you should validate it yourself before deciding for one or the other.

ZipList is an applicative, and doesn’t have a monadic interface. It’s similar to List, but it acts on zips of the two lists, instead of expanding like lists do. Same for ZipArray and ZipSeq, which are similar to Zip, but act on Arrays and Seqs, of course.

Continuation will probably never be implemented in Monadic, given it introduces a lot of complexity on the implementation side of every transformer. I’ll consider it in the future if I can think of a simple implementation.

Ref, from MTL, is a structured State monad where you have a Dictionary where the keys are integers and the values are parameterizable. This seems redundant of a usage of State + lens, and goes against the simplicity of the library.

Tree is also not being implemented, given that it doesn’t have a Stdlib implementation, and it’s better for the user to implement it as an extension to the library, using whatever Tree library they want to use.