1,510 research outputs found
Programming with Algebraic Effects and Handlers
Eff is a programming language based on the algebraic approach to
computational effects, in which effects are viewed as algebraic operations and
effect handlers as homomorphisms from free algebras. Eff supports first-class
effects and handlers through which we may easily define new computational
effects, seamlessly combine existing ones, and handle them in novel ways. We
give a denotational semantics of eff and discuss a prototype implementation
based on it. Through examples we demonstrate how the standard effects are
treated in eff, and how eff supports programming techniques that use various
forms of delimited continuations, such as backtracking, breadth-first search,
selection functionals, cooperative multi-threading, and others
No value restriction is needed for algebraic effects and handlers
We present a straightforward, sound Hindley-Milner polymorphic type system
for algebraic effects and handlers in a call-by-value calculus, which allows
type variable generalisation of arbitrary computations, not just values. This
result is surprising. On the one hand, the soundness of unrestricted
call-by-value Hindley-Milner polymorphism is known to fail in the presence of
computational effects such as reference cells and continuations. On the other
hand, many programming examples can be recast to use effect handlers instead of
these effects. Analysing the expressive power of effect handlers with respect
to state effects, we claim handlers cannot express reference cells, and show
they can simulate dynamically scoped state
A Calculus for Scoped Effects & Handlers
Algebraic effects & handlers have become a standard approach for side-effects
in functional programming. Their modular composition with other effects and
clean separation of syntax and semantics make them attractive to a wide
audience. However, not all effects can be classified as algebraic; some need a
more sophisticated handling. In particular, effects that have or create a
delimited scope need special care, as their continuation consists of two
parts-in and out of the scope-and their modular composition introduces
additional complexity. These effects are called scoped and have gained
attention by their growing applicability and adoption in popular libraries.
While calculi have been designed with algebraic effects & handlers built in to
facilitate their use, a calculus that supports scoped effects & handlers in a
similar manner does not yet exist. This work fills this gap: we present
, a calculus with native support for both algebraic and
scoped effects & handlers. It addresses the need for polymorphic handlers and
explicit clauses for forwarding unknown scoped operations to other handlers.
Our calculus is based on Eff, an existing calculus for algebraic effects,
extended with Koka-style row polymorphism, and consists of a formal grammar,
operational semantics, a (type-safe) type-and-effect system and type inference.
We demonstrate on a range of examples
Concurrent system programming with effect handlers
© Springer International Publishing AG, part of Springer Nature 2018. Algebraic effects and their handlers have been steadily gaining attention as a programming language feature for composably expressing user-defined computational effects. While several prototype implementations of languages incorporating algebraic effects exist, Multicore OCaml incorporates effect handlers as the primary means of expressing concurrency in the language. In this paper, we make the observation that effect handlers can elegantly express particularly difficult programs that combine system programming and concurrency without compromising performance. Our experimental results on a highly concurrent and scalable web server demonstrate that effect handlers perform on par with highly optimised monadic concurrency libraries, while retaining the simplicity of direct-style code
Effects and Effect Handlers for Programmable Inference
Inference algorithms for probabilistic programming are complex imperative
programs with many moving parts. Efficient inference often requires customising
an algorithm to a particular probabilistic model or problem, sometimes called
inference programming. Most inference frameworks are implemented in languages
that lack a disciplined approach to side effects, which can result in
monolithic implementations where the structure of the algorithms is obscured
and inference programming is hard. Functional programming with typed effects
offers a more structured and modular foundation for programmable inference,
with monad transformers being the primary structuring mechanism explored to
date.
This paper presents an alternative approach to programmable inference, based
on algebraic effects, building on recent work that used algebraic effects to
represent probabilistic models. Using effect signatures to specify the key
operations of the algorithms, and effect handlers to modularly interpret those
operations for specific variants, we develop three abstract algorithms, or
inference patterns, representing three important classes of inference:
Metropolis-Hastings, particle filtering, and guided optimisation. We show how
our approach reveals the algorithms' high-level structure, and makes it easy to
tailor and recombine their parts into new variants. We implement the three
inference patterns as a Haskell library, and discuss the pros and cons of
algebraic effects vis-a-vis monad transformers as a structuring mechanism for
modular imperative algorithm design. It should be possible to reimplement our
library in any typed functional language able to emulate effects and effect
handlers
The modern landscape of managing effects for the working programmer
The management of side effects is a crucial aspect of modern programming, especially in concurrent and distributed systems. This thesis analyses different approaches for managing side effects in programming languages, specifically focusing on unrestricted side effects, monads, and algebraic effects and handlers. Unrestricted side effects, used in mainstream imperative programming languages, can make programs difficult to reason about. Monads offer a solution to this problem by describing side effects in a composable and referentially transparent way but many find them cumbersome to use. Algebraic effects and handlers can address some of the shortcomings of monads by providing a way to model effects in more modular and flexible way. The thesis discusses the advantages and disadvantages of each of these approaches and compares them based on factors such as expressiveness, safety, and constraints they place on how programs must be implemented. The thesis focuses on ZIO, a Scala library for concurrent and asynchronous programming, which revolves around a ZIO monad with three type parameters. With those three parameters ZIO can encode the majority of practically useful effects in a single monad. ZIO takes inspiration from algebraic effects, combining them with monadic effects. The library provides a range of features, such as declarative concurrency, error handling, and resource management. The thesis presents examples of using ZIO to manage side effects in practical scenarios, highlighting its strengths over other approaches. The applicability of ZIO is evaluated by implementing a server side application using ZIO, and analyzing observations from the development process
A Complete Normal-Form Bisimilarity for Algebraic Effects and Handlers
We present a complete coinductive syntactic theory for an untyped calculus of algebraic operations and handlers, a relatively recent concept that augments a programming language with unprecedented flexibility to define, combine and interpret computational effects. Our theory takes the form of a normal-form bisimilarity and its soundness w.r.t. contextual equivalence hinges on using so-called context variables to test evaluation contexts comprising normal forms other than values. The theory is formulated in purely syntactic elementary terms and its completeness demonstrates the discriminating power of handlers. It crucially takes advantage of the clean separation of effect handling code from effect raising construct, a distinctive feature of algebraic effects, not present in other closely related control structures such as delimited-control operators
- …