One-Shot Algebraic Effects as Coroutines

Kawahara, Shinnosuke; Kameyama, Yutaka

doi:10.1007/978-3-030-57761-2_8

Cited by 7 publications

(6 citation statements)

References 17 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The usage of coroutines in our TLS library resembles the pattern of algebraic effects with handlers in that a value a coroutine yields requests some action to be performed, and the response sent back to the coroutine is the result of that action. However, the (handwritten) code encoding these requests as coroutines is substantially different from outputs of the generic translation of effect-handler code into coroutines presented by Kawahara and Kameyama [2020]. In particular, we seem to have somehow avoided having to introduce a continuation-carrying Rehandle effect wrapper when yielding unhandled effects further out from an effect handler.…”

Section: Coroutines Continuations and Algebraic Effectsmentioning

confidence: 94%

“…First-class coroutines correspond closely to one-shot continuations (call1cc and similarly restricted algebraic effects [Kawahara and Kameyama 2020;Moura and Ierusalimschy 2009]). Further, coroutines whose state can be duplicated correspond to general continuations (callcc) [Prokopec and Liu 2018] and presumably general algebraic effects.…”

Section: Coroutines Continuations and Algebraic Effectsmentioning

confidence: 98%

See 1 more Smart Citation

Certifying derivation of state machines from coroutines

Ikebuchi

Erbsen

Chlipala

2022

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

One of the biggest implementation challenges in security-critical network protocols is nested state machines. In practice today, state machines are either implemented manually at a low level, risking bugs easily missed in audits; or are written using higher-level abstractions like threads, depending on runtime systems that may sacrifice performance or compatibility with the ABIs of important platforms (e.g., resource-constrained IoT systems). We present a compiler-based technique allowing the best of both worlds, coding protocols in a natural high-level form, using freer monads to represent nested coroutines , which are then compiled automatically to lower-level code with explicit state. In fact, our compiler is implemented as a tactic in the Coq proof assistant, structuring compilation as search for an equivalence proof for source and target programs. As such, it is straightforwardly (and soundly) extensible with new hints, for instance regarding new data structures that may be used for efficient lookup of coroutines. As a case study, we implemented a core of TLS sufficient for use with popular Web browsers, and our experiments show that the extracted Haskell code achieves reasonable performance.

show abstract

Section: Coroutines Continuations and Algebraic Effectsmentioning

confidence: 94%

Section: Coroutines Continuations and Algebraic Effectsmentioning

confidence: 98%

Certifying derivation of state machines from coroutines

Ikebuchi

Erbsen

Chlipala

2022

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…Multicore OCaml stacks do not neatly fit the description of one of these implementation strategies -they are best described as using the resize strategy from Farvardin et al for each of the fibers, which are linked to represent the current stack and the captured continuations. Kawahara et al [30] implement one-shot effect handlers using coroutines as a macro-expressible translation, and present an embedding in Lua and Ruby. Lua provides asymmetric coroutines [16] where each coroutine uses its own stack similar to how each handled computation runs in its own fiber in Multicore OCaml.…”

Section: Related Workmentioning

confidence: 99%

Retrofitting effect handlers onto OCaml

Sivaramakrishnan

Dolan²,

White³

et al. 2021

Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

Effect handlers have been gathering momentum as a mechanism for modular programming with user-defined effects. Effect handlers allow for non-local control flow mechanisms such as generators, async/await, lightweight threads and coroutines to be composably expressed. We present a design and evaluate a full-fledged efficient implementation of effect handlers for OCaml, an industrial-strength multi-paradigm programming language. Our implementation strives to maintain the backwards compatibility and performance profile of existing OCaml code. Retrofitting effect handlers onto OCaml is challenging since OCaml does not currently have any nonlocal control flow mechanisms other than exceptions. Our implementation of effect handlers for OCaml: (i) imposes a mean 1% overhead on a comprehensive macro benchmark suite that does not use effect handlers; (ii) remains compatible with program analysis tools that inspect the stack; and (iii) is efficient for new code that makes use of effect handlers. CCS Concepts: • Software and its engineering → Runtime environments; Concurrent programming structures; Control structures; Parallel programming languages; Concurrent programming languages.

show abstract

“…λ-abstractions and operations are both treated as effects, which might make the definition of the C operator, which permutes λ with operations, more intuitive. 47 λ eff also has a well-developed metatheory, developed in [23]: it is both confluent (due to its reduction relation being deterministic) and terminating (thanks to its effect type system).…”

Section: • λ Effmentioning

confidence: 99%

“…The problem of the specification and verification of programs with algebraic effects has seen a lot of progress recently [36,37,38,39,40,41,42]. Other interesting developments include the introduction of dependent types [43], a generalization from monads to applicative functors and arrows [44], new mechanisms for abstracting effects [45] and novel implementation techniques [46,47]. Algebraic effects and effect handlers provide a modular abstraction for effectful programming.…”

mentioning

confidence: 99%