25 research outputs found
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
Scoped effects as parameterized algebraic theories
Notions of computation can be modelled by monads. Algebraic effects offer a characterization of monads in terms of algebraic
operations and equational axioms, where operations are basic programming features, such as reading or updating the state, and axioms specify
observably equivalent expressions. However, many useful programming
features depend on additional mechanisms such as delimited scopes or
dynamically allocated resources. Such mechanisms can be supported via
extensions to algebraic effects including scoped effects and parameterized algebraic theories. We present a fresh perspective on scoped effects
by translation into a variation of parameterized algebraic theories. The
translation enables a new approach to equational reasoning for scoped
effects and gives rise to an alternative characterization of monads in
terms of generators and equations involving both scoped and algebraic
operations. We demonstrate the power of our fresh perspective by way of
equational characterizations of several known models of scoped effects
Types and Semantics for Extensible Data Types (Extended Version)
Developing and maintaining software commonly requires (1) adding new data
type constructors to existing applications, but also (2) adding new functions
that work on existing data. Most programming languages have native support for
defining data types and functions in a way that supports either (1) or (2), but
not both. This lack of native support makes it difficult to use and extend
libraries. A theoretically well-studied solution is to define data types and
functions using initial algebra semantics. While it is possible to encode this
solution in existing programming languages, such encodings add syntactic and
interpretive overhead, and commonly fail to take advantage of the map and fold
fusion laws of initial algebras which compilers could exploit to generate more
efficient code. A solution to these is to provide native support for initial
algebra semantics. In this paper, we develop such a solution and present a type
discipline and core calculus for a language with native support for initial
algebra semantics.Comment: Extended version (28 pages) of the eponymous paper to appear in the
conference proceedings of APLAS 202
Modular Denotational Semantics for Effects with Guarded Interaction Trees
We present guarded interaction trees -- a structure and a fully formalized
framework for representing higher-order computations with higher-order effects
in Coq, inspired by domain theory and the recently proposed interaction trees.
We also present an accompanying separation logic for reasoning about guarded
interaction trees. To demonstrate that guarded interaction trees provide a
convenient domain for interpreting higher-order languages with effects, we
define an interpretation of a PCF-like language with effects and show that this
interpretation is sound and computationally adequate; we prove the latter using
a logical relation defined using the separation logic. Guarded interaction
trees also allow us to combine different effects and reason about them
modularly. To illustrate this point, we give a modular proof of type soundness
of cross-language interactions for safe interoperability of different
higher-order languages with different effects. All results in the paper are
formalized in Coq using the Iris logic over guarded type theory.Comment: 30 pages; accepted for POPL2
Executable component-based semantics
The potential benefits of formal semantics are well known. However, a substantial amount of work is required to produce a complete and accurate formal semantics for a major language; and when the language evolves, large-scale revision of the semantics may be needed to reflect the changes. The investment of effort needed to produce an initial definition, and subsequently to revise it, has discouraged language developers from using formal semantics. Consequently, many major programming languages (and most domain-specific languages) do not yet have formal semantic definitions.To improve the practicality of formal semantic definitions, the PLanCompS project has developed a component-based approach. In this approach, the semantics of a language is defined by translating its constructs (compositionally) to combinations of so-called fundamental constructs, or ‘funcons’. Each funcon is defined using a modular variant of Structural Operational Semantics, and forms a language-independent component that can be reused in definitions of different languages. A substantial library of funcons has been developed and tested in several case studies. Crucially, the definition of each funcon is fixed, and does not need changing when new funcons are added to the library.For specifying component-based semantics, we have designed and implemented a meta-language called CBS. It includes specification of abstract syntax, of its translation to funcons, and of the funcons themselves. Development of CBS specifications is supported by an integrated development environment. The accuracy of a language definition can be tested by executing the specified translation on programs written in the defined language, and then executing the resulting funcon terms using an interpreter generated from the CBS definitions of the funcons. This paper gives an introduction to CBS, illustrates its use, and presents the various tools involved in our implementation of CBS
Modular Probabilistic Models via Algebraic Effects
Probabilistic programming languages (PPLs) allow programmers to construct
statistical models and then simulate data or perform inference over them. Many
PPLs restrict models to a particular instance of simulation or inference,
limiting their reusability. In other PPLs, models are not readily composable.
Using Haskell as the host language, we present an embedded domain specific
language based on algebraic effects, where probabilistic models are modular,
first-class, and reusable for both simulation and inference. We also
demonstrate how simulation and inference can be expressed naturally as
composable program transformations using algebraic effect handlers
Handling polymorphic algebraic effects
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 polymorphism---we
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 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.Comment: Added the errata for the ESOP'19 paper (page 28
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
Doo bee doo bee doo
We explore the design and implementation of Frank, a strict functional programming language with a bidirectional effect type system designed from the ground up around a novel variant of Plotkin and Pretnar's effect handler abstraction. Effect handlers provide an abstraction for modular effectful programming: a handler acts as an interpreter for a collection of commands whose interfaces are statically tracked by the type system. However, Frank eliminates the need for an additional effect handling construct by generalising the basic mechanism of functional abstraction itself. A function is but the special case of a Frank operator that interprets no commands. Moreover, Frank's operators can be multihandlers which simultaneously interpret commands from several sources at once, without disturbing the direct style of functional programming with values. Effect typing in Frank employs a novel form of effect polymorphism which avoids mentioning effect variables in source code. This is achieved by propagating an ambient ability inwards, rather than accumulating unions of potential effects outwards. With the ambient ability describing the effects that are available at a certain point in the code, it can become necessary to reconfigure access to the ambient ability. A primary goal is to be able to encapsulate internal effects, eliminating a phenomenon we call effect pollution. Moreover, it is sometimes desirable to rewire the effect flow between effectful library components. We propose adaptors as a means for supporting both effect encapsulation and more general rewiring. Programming with effects and handlers is in its infancy. We contribute an exploration of future possibilities, particularly in combination with other forms of rich type systems
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