# Future of OCaml

Some interesting news/developments coming up in OCaml’s future:

## Medium-Term Plans

### Flambda 2.0

Flambda is the framework that currently optionally optimizes OCaml code. Work is ongoing to create the next version at OCamlPro. See this post and this development branch.

### Multicore OCaml

Currently, OCaml has a global runtime lock,
with support for green threads (concurrency) via `lwt`

and `Async`

.
The plan is to allow OCaml to run in parallel threads (which are termed `domains`

),
while also allowing for native green thread support via algebraic effects.

- Multicore: what’s coming in 2021 presentation
- Monthly updates
- Paper on retrofitting a parallel GC into OCaml
- The multicore OCaml github repo and its wiki.
- The multicore roadmap.
- ICFP Presentation on advanced lock-free programming in multicore OCaml
- Discuss post on recent past and future of integrating multicore
- Update on status of multicore
- Adjusting the stdlib for multicore

### Typed Algebraic Effects

Part of the plan for multicore OCaml is to include non-monadic green threading into the runtime. In order to allow for this, algebraic effects are being added to the language. These are similar to exceptions but with a bookmark to the current position of the execution (aka continutation) added to each “exception” (aka effect) thrown, so one has the option to continue execution after handling the effect.

Initially, this was going to exist outside of the type system. However, this introduces many issues, and we’d much rather have it be typed and handled by the type system. Extending OCaml’s type system with algebraic effects would make it similar to Haskell’s, but without requiring monads for effects.

See the tutorial above for an introduction to (untyped) algebraic effects. Work on typed effects is ongoing here.

- A great explanation of algebraic effects can be found here.
- Presentation on effects in OCaml 21
- Presentation on algebraic effects at ICFP
- Presentation on typed effects in OCaml
- Complete bibilography of literature on effects

## Long-Term Plans

### Modular Implicits

A type-based dispatch similar to Haskell’s typeclasses.

See a video demonstration here. As this paper clarifies, creating typeclasses in OCaml is difficult due to its adherence to type abstraction. Put simply, you can have functors or type classes, but not both, and OCaml already has functors. While the community eagerly awaits this solution, its implementation unfortunately appears to be years away.

To see how complicated the solution is, see this response. You can follow some of the work that is taking place here and here.