eio

Nice work! Did you ever open any open source any of it? Looking at your OCaml wishlist from back in 2017, some stuff has improved and some is on its way: - Support for read-only BigArrays (or sections) : we're starting to switch to just using bytes/string in OCaml 5+ now, since the larger allocations go into malloc'ed pools and do not relocate, so they can be used as part of an FFI (without the Bigarray C value overhead) - More support for floating-point numbers (exceptions, representation exploration): OxCaml has some of this now! https://oxcaml.org/documentation/miscellaneous-extensions/sm... - Syntax for extended BigArray indexing: now supported in OCaml https://ocaml.org/manual/5.4/indexops.html#ss:multiindexing - LaCaml remains too low-level (non-functional) and unreadable: still remains the case, but OxCaml's got initial support fo

Oh, interesting thanks! That would be like what's described here? https://docs.flatpak.org/en/latest/sandbox-permissions.html Looking at Leonard's post from my earlier comment, I was really appreciating the ability to do this sort of restriction _within_ a single application. I know that the code I am writing is not doing anything malicious, but I'm still at the mercy of whatever dependent libraries I'm calling. (Think file parsers, for examples of code that often goes sideways.) His Eio effects library for OCaml supports Capsicum, which I could see as being awesome for any sort of multi-user server process in particular. https://github.com/ocaml-multicore/eio?tab=readme-ov-file#de...

> Also, didn't OCaml have weak support for concurrency? Has that changed recently? OCaml has had Lwt for concurrent IO for long enough that it is now being deprecated in favor of Eio[1]: https://github.com/ocsigen/lwt [1] https://github.com/ocaml-multicore/eio

the actual project (Readme has some code samples): https://github.com/ocaml-multicore/eio

For 5.0+ you might want to look at https://github.com/ocaml-multicore/eio for how effects can make async much more pleasant

> like at Eio Look at Eio here: https://github.com/ocaml-multicore/eio

> This is realllly unidiomatic in real world Haskell. Whether idiomatic or not does not matter. It proves my point: IO won't save you, and even very mundane effects are not part of the game… Idris is the "better Haskell" sure, but the effect tracking is still part of the uncanny valley (still IO monad based). Koka is a toy, and Frank mostly "only a paper" (even there is some code out there). The "Frank concept" is to some degree implemented in the Unison language, though: https://www.unison-lang.org/learn/fundamentals/abilities/ Having a notion of co-effects (or however you please to call them) is imho actually much more important than talking about effects (as effects are in fact neither values nor types—something that all the IO kludges get wrong). I think the first practicable approach in the mainstream about this topic will be what ge

It's used by Eio in OCaml for the Linux backend: https://github.com/ocaml-multicore/eio.

Here's an example using OCaml 5 to run multiple fibers concurrently (look - no monads!): https://github.com/ocaml-multicore/eio#fibers

Effects are included in OCaml 5, but considered experimental. This doesn't stop us from building libraries that take advantage of them internally, in order to provide really nice external interfaces. The best developed one is "eio", which uses effects (and io_uring on Linux) internally in order to provide a really high performance, direct-style IO library for OCaml. You can walk through some of the code here: https://github.com/ocaml-multicore/eio#getting-started Also a video talk about our experiences with using effects for writing parsers, from the OCaml Workshop last year. https://watch.ocaml.org/videos/watch/74ece0a8-380f-4e2a-bef5...

Its a good time to try it. The tooling has come a long way and OCaml has an excellent build system [1] (dune is probably the best build tool I've used and I miss it whenever I use other programming languages), excellent editor tooling for vscode [2], emacs and neovim. OCaml 5.0 will bring multicore support [3] and an effect system that will cover a lot of interesting use-cases. As an example with OCaml 5 it'll be feasible to have concurrency libraries that still let you write in direct-style [4] [5]. I don't intend to say that OCaml will fit every use-case, but there is a lot going for it even in its current form before multicore support lands. If you want a language that compiles fast (it does compile really fast, at-part with Go if not better), has excellent performance characteristics, and has a good story for concurrency, you should g

work has already begin on a direct-style IO library that internally uses effects. See: - https://github.com/ocaml-multicore/eio#readme for more information on the Eio library - https://watch.ocaml.org/videos/watch/74ece0a8-380f-4e2a-bef5... is a short talk on experiences using effects with some nice motivating examples Note that Eio is more than just a direct replacement for Lwt and Async. We couldn't resist using some of the experiences also gained from the MirageOS (mirage.io) unikernel framework in EIO. This means that the backends are highly optimised to use the best syscalls available in the OS (e.g. io_uring by default in Linux). If you write your applications to use Eio natively, then performance is very high so far. The ergonomics of programming in it also compare favourably to using monadic concurrency.

Work has already started: https://github.com/ocaml-multicore/eio There's also now https://github.com/talex5/lwt_eio, which allows you to run existing Lwt code alongside code using effects, to aid with porting.

> Maybe for the next trendy language we could think about the Object-capability model before it's too late. https://en.wikipedia.org/wiki/Object-capability_model There is an object-capability model in the upcoming OCaml 5.0, however it's only in the Eio library, that deals with IO https://github.com/ocaml-multicore/eio#design-note-object-ca.... There's also Emily, a subset of OCaml based on POLA (Principle of Least Authority) https://www.hpl.hp.com/techreports/2006/HPL-2006-116.pdf. I'm unaware of any plain to extend OCaml in that direction though.

Instead of Stdlib.Queue you can use Eio.Stream, which is thread-safe (and will take care of waking sleeping threads when data becomes available). The README shows an example of a pool of workers pulling jobs from an Eio.Stream: https://github.com/ocaml-multicore/eio#example-a-worker-pool We're still exploring what APIs to provide for this kind of thing, and in particular how to unify domainslib and eio.