Freer monads, more extensible effects

Kiselyov, Oleg; Ishii, Hiromi

doi:10.1145/2804302.2804319

Cited by 61 publications

(33 citation statements)

References 25 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…One sees the close analogy with ordinary exceptions: multiple exceptions are usually implemented as a single exception whose payload is an (extensible) union data type. We also notice that extensible-effects in Haskell [22] are based on the very same idea, implemented with no typing compromises.…”

Section: Variablesmentioning

confidence: 99%

“…The translation pattern should be easy to see: each data type variant has exactly two arguments, the latter is the continuation. The attentive reader quickly recognizes the freer monad [22].…”

Section: Eff In Ocamlmentioning

confidence: 99%

“…Such a refinement was first used in [19] to prove that all variations of the 'shift' operator (shift itself, shift0, control, control0) are equally expressible, in the untyped setting. That approach has later led to extensible effects [23,22]. Embedding Eff in OCaml may be seen as porting of extensible-effects to OCaml, with delimited control operators instead of continuation-passing style, and the 'out-of-band' emulation of answer-type polymorphism.…”

Section: Related Workmentioning

confidence: 99%

“…Algebraic effects [33,32] are becoming a more and more popular approach for expressing and composing computational effects. There are implementations of algebraic effects in Haskell [18,22], Idris [4], OCaml [10,18], Koka [27], Scala 1 , Javascript 2 , PureScript 3 , and other languages. The most direct embodiment of algebraic effect theory is the language Eff 4 "built to test the mathematical ideas of algebraic effects in practice".…”

Section: Introductionmentioning

confidence: 99%

See 3 more Smart Citations

Eff Directly in OCaml

Kiselyov

Sivaramakrishnan

2018

Electron. Proc. Theor. Comput. Sci.

Self Cite

View full text Add to dashboard Cite

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...

show abstract

Section: Variablesmentioning

confidence: 99%

Section: Eff In Ocamlmentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Eff Directly in OCaml

Kiselyov

Sivaramakrishnan

2018

Electron. Proc. Theor. Comput. Sci.

Self Cite

View full text Add to dashboard Cite

show abstract

“…This present paper comes as the result of decade-long long experience with the tagless-final style of DSL embedding [24] and the re-discovering 3 and polishing of extensible effects ( [26,25]). It was prompted however by the following message, posted on the Caml-list by Christoph Höger in March 2017: 4 "Assume a simple OCaml program with two primitives that can cause side-effects:…”

Section: Motivationmentioning

confidence: 99%

Effects Without Monads: Non-determinism – Back to the Meta Language

Kiselyov

2019

Electron. Proc. Theor. Comput. Sci.

Self Cite

View full text Add to dashboard Cite

We reflect on programming with complicated effects, recalling an undeservingly forgotten alternative to monadic programming and checking to see how well it can actually work in modern functional languages.We adopt and argue the position of factoring an effectful program into a first-order effectful DSL with a rich, higher-order 'macro' system. Not all programs can be thus factored. Although the approach is not general-purpose, it does admit interesting programs. The effectful DSL is likewise rather problem-specific and lacks general-purpose monadic composition, or even functions. On the upside, it expresses the problem elegantly, is simple to implement and reason about, and lends itself to non-standard interpretations such as code generation (compilation) and abstract interpretation. A specialized DSL is liable to be frequently extended; the experience with the tagless-final style of DSL embedding shown that the DSL evolution can be made painless, with the maximum code reuse.We illustrate the argument on a simple but representative example of a rather complicated effect -non-determinism, including committed choice. Unexpectedly, it turns out we can write interesting non-deterministic programs in an ML-like language just as naturally and elegantly as in the functional-logic language Curry -and not only run them but also statically analyze, optimize and compile. The richness of the Meta Language does, in reality, compensate for the simplicity of the effectful DSL.The key idea goes back to the origins of ML as the Meta Language for the Edinburgh LCF theorem prover. Instead of using ML to build theorems, we now build (DSL) programs.

show abstract

Handling Polymorphic Algebraic Effects

Sekiyama

Igarashi

2019

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Algebraic effects and handlers are a powerful abstraction mechanism to represent and implement control effects. In this work, we study their extension with parametric polymorphism that allows abstracting not only expressions but also effects and handlers. Although polymorphism makes it possible to reuse and reason about effect implementations more effectively, it has long been known that a naive combination of polymorphic effects and let-polymorphism breaks type safety. Although type safety can often be gained by restricting let-bound expressions-e.g., by adopting value restriction or weak polymorphismwe propose a complementary approach that restricts handlers instead of let-bound expressions. Our key observation is that, informally speaking, a handler is safe if resumptions from the handler do not interfere with each other. To formalize our idea, we define a call-by-value lambda calculus λ let eff that supports let-polymorphism and polymorphic algebraic effects and handlers, design a type system that rejects interfering handlers, and prove type safety of our calculus.

show abstract

Freer monads, more extensible effects

Cited by 61 publications

References 25 publications

Eff Directly in OCaml

Eff Directly in OCaml

Effects Without Monads: Non-determinism – Back to the Meta Language

Handling Polymorphic Algebraic Effects

Contact Info

Product

Resources

About