Eff Directly in OCaml

Abstract

The language Eff is an OCaml-like language serving as a prototype implementation of the theory of algebraic effects, intended for experimentation with algebraic effects on a large scale.We present the embedding of Eff into OCaml, using the library of delimited continuations or the multicore OCaml branch. We demonstrate the correctness of the embedding denotationally, relying on the tagless-final-style interpreter-based denotational semantics, including the novel, direct denotational semantics of multi-prompt delimited control. The embedding is systematic, lightweight, performant and supports even higher-order, 'dynamic' effects with their polymorphism. OCaml thus may be regarded as another implementation of Eff, broadening the scope and appeal of that language. 1 https://github.com/atnos-org/eff, https://github.com/m50d/paperdoll, among others 2 https://www.humblespark.com/blog/extensible-effects-in-node-part-1 3 http://purescript.org 4 http://www.eff-lang.org/ 5 While writing this paper we have implemented delimited control in yet another way, in pure OCaml: see Core delimcc in §3.2. Although developed for the formalization of the Eff translation, it may be used in real programs -provided the code is written in a particular stylized way as shown in §3.2. In contrast, the original delimcc and Multicore OCaml can be used with the existing OCaml code as it is. Hence they let Eff be embedded rather than compiled into OCaml. 24Eff Directly in OCaml detail in §3.1.4). We also demonstrate the novel denotational semantics of multi-prompt delimited control that does not rely on continuation-passing-style (and is, hence, direct).The structure of the paper is as follows. First we informally introduce Eff on a simple example. §2.2 then demonstrates our translation to OCaml using the delimcc library, putting Eff and the corresponding OCaml code side-by-side. §2.3 shows how the embedding works in multicore OCaml with its 'native effects'. §3 gives the formal, denotational treatment, reminding the denotational semantics of Eff; describing the novel direct denotational semantics of multi-prompt delimited control; then presenting the translation precisely; and arguing that it is meaning-preserving. We describe the translation of the dynamic effects into OCaml in §4. The empirical §5 evaluates the performance of our implementation of Eff comparing it with the Eff's own optimizing compiler. Related work is reviewed in §6. We then conclude and summarize the research program inspired by our Eff embedding.The source code of all our examples and benchmarks is available at http://okmij.org/ftp/ continuations/Eff/. Eff in Itself and OCamlWe illustrate the Eff embedding on the running example, juxtaposing the Eff code with the corresponding OCaml. We thus demonstrate both the simplicity of the translation and the way to do Eff-like effects in idiomatic OCaml. A taste of EffAn effect in Eff has to be declared first 6 : type α nondet = effect operation fail : unit → empty operation choose : (α * α) → α end Our running effect is thus famili...

Effect handlers for the masses

“…Existing implementations of libraries and languages for (algebraic) effect handlers are either translations to a high level language or involve a custom runtime implementation. High level implementations translate effect handlers into delimited continuations [Brachthäuser and Schuster 2017;Kammar et al 2013;Kiselyov and Sivaramakrishnan 2016], free monads [Kiselyov and Ishii 2015] or perform a source to source CPS translation into another high-level language Leijen 2017c]. Other implementations require a custom runtime that supports stack manipulation [Bauer and Pretnar 2015;Dolan et al 2017] or setjump / longjump [Leijen 2017a].…”

“…We implement the effect handler library on top of multi-prompt delimited continuations as defined in interface DelimitedControl . While the implementation of effect handlers in terms of multi-prompt delimited continuations is not novel [Kiselyov and Sivaramakrishnan 2016], choosing Java as the target language is and poses new challenges like integrating effect handlers with mutable state and designing an API that only uses interfaces and generics for typing. However, it also opens new opportunities like using subtyping and inheritance for handler reuse.…”

“…All code in the rest of this paper is subject to the CPS bytecode transformation and all methods annotated with throws Effects will be instrumented. As we will see in subsection 3.3, the effect handler library can be implemented as a very thin layer on top of multi-prompt delimited continuations [Brachthäuser and Schuster 2017;Kiselyov and Sivaramakrishnan 2016]. Our implementation of multi-prompt delimited continuations closely follows Dyvbig et al [2007], but translated to Java and to our setting of bytecode instrumentation.…”

“…Another approach is to instantiate the continuation only when it is needed. Typically, to signal that the continuation needs to be captured, the effectful function can use a special exception [Loitsch 2007;Pettyjohn et al 2005;Sekiguchi et al 2001], sum types [Kiselyov and Sivaramakrishnan 2016] or global flags (JavaFlow, Coroutines).…”

“…They are either built into the language, like in Eff [Bauer and Pretnar 2015], Koka [Leijen 2014], Frank and Links , or implemented as a libraries for Haskell [Kammar et al 2013;Kiselyov et al 2013;Wu and Schrijvers 2015] or Idris [Brady 2013]. Recently, object-oriented and imperative languages also started to adopt effect handlers, both as a built-in language construct for OCAML [Dolan et al 2017]), as well as as libraries for OCAML [Kammar et al 2013;Kiselyov and Sivaramakrishnan 2016], C [Leijen 2017a] and Scala [Brachthäuser and Schuster 2017].…”