We first implemented joinads as an extension for F# and wrote a preliminary report about the work, which appeared in PADL 2011. More recently, joinads have been added to Haskell and refined slightly to make the algebraic structure simple and better defined. The extended paper appeared in Haskell Symposium 2011.

There are numerous differences between the two versions - the original version
didn't require *joinad* to be a *monad* and had a more complex operation corresponding
to *choice* and *aliasing*. The revised version simplifies the set of operations
and provides better formal background. The implementation on this page is mostly
based on the newer (Haskell) version.

Additionally, the page below also contains information about PADL 2014 paper that discusses F# computation expressions in a broader perspective and uses an extension (implemented in the editor here) for writing applicative functors.

Tomas Petricek and Don Syme

*Proceedings of PADL 2014*

The abstract of the paper:

Many computations can be structured using abstract computation types such as monoids, monad transformers or applicative functors. Functional programmers use those abstractions directly while main-stream languages often integrate concrete instances as language features - e.g. generators in Python or asynchronous computations in C# 5.0. The question is, is there a sweet spot between convenient, hardwired language features, and an inconvenient but flexible libraries?

F#

computation expressionsanswer this question in the affirmative. Unlike the`do`

notation in Haskell, computation expressions are not tied to a single kind of abstraction. They support a wide range of computations, depending on what operations are available. They also provide greater syntactic flexibility leading to a more intuitive syntax, without resorting to full macro-based meta-programming.We show that computation expressions can structure well-known computations including monoidal list comprehensions, monadic parsers, applicative formlets and asynchronous sequences based on the list monad transformer. We also present typing rules for computation expressions that are capable of capturing all these applications.

The paper can be downloaded from the author's academic page.

Tomas Petricek, Alan Mycroft and Don Syme

*Proceedings of Haskell Symposium 2011*

The abstract of the paper:

Sequencing of effectful computations can be neatly captured using monads and elegantly written using

`do`

notation. In practice such monads often allow additional ways of composing computations, which have to be written explicitly using combinators.We identify joinads, an abstract notion of computation that is stronger than monads and captures many such ad-hoc extensions. In particular, joinads are monads with three additional operations: one of type

`m a -> m b -> m (a, b)`

captures various forms of parallel composition, one of type`m a -> m a -> m a`

that is inspired by choice and one of type`m a -> m (m a)`

that captures aliasing of computations. Algebraically, the first two operations form a near-semiring with commutative multiplication.We introduce

`docase`

notation that can be viewed as a monadic version of`case`

. Joinad laws make it possible to prove various syntactic equivalences of programs written using`docase`

that are analogous to equivalences about`case`

. Examples of joinads that benefit from the notation include speculative parallelism, waiting for a combination of user interface events, but also encoding of validation rules using the intersection of parsers.

The paper can be downloaded from the author's academic page.

Tomas Petricek

*Proceedings of MSFP 2012*

Monads have become a powerful tool for structuring effectful computations in functional programming, because they make the order of effects explicit. When translating pure code to a monadic version, we need to specify evaluation order explicitly. This requires us to choose between

call-by-valueorcall-by-namestyle. The two translations give programs with different semantics, structure and also different types.In this paper, we translate pure code to monadic using an additional operation

`malias`

that abstracts out the evaluation strategy. The`malias`

operation is based oncomputational comonads; we use a categorical framework to specify the laws that are required to hold about the operation.We show two implementations of

`malias`

for any monad that givecall-by-valueandcall-by-namesemantics. Although we do not givecall-by-needsemantics for any monad, we show how to turn any monad into an extended monad withcall-by-needsemantics, which partly answers a standing open question. Moreover, using our unified translation, it is possible to change the evaluation strategy of functional code translated to the monadic form without changing its structure or types.

The paper can be downloaded from the author's academic page.

Tomas Petricek

*The Monad.Reader, Issue 18 (Unreviewed article)*

Monad comprehensions have an interesting history. They were the first syntactic extension for programming with monads. They were implemented in Haskell, but later replaced with plain list comprehensions and monadic

`do`

notation. Now, monad comprehensions are back in Haskell, more powerful than ever before!Redesigned monad comprehensions generalize the syntax for working with lists. Quite interestingly, they also generalize syntax for zipping, grouping and ordering of lists. This article shows how to use some of the new expressive power when working with well-known monads. You'll learn what "parallel composition" means for parsers, a poor man's concurrency monad and an evaluation order monad.

The article can be downloaded from the author's academic page.

for reactive, parallel and concurrent programming

Tomas Petricek and Don Syme

*Proceedings of PADL 2011*

The abstract of the paper:

Modern challenges led to a design of a wide range of programming models for reactive, parallel and concurrent programming, but these are often difficult to encode in general purpose languages. We present an abstract type of computations called

joinadstogether with a syntactic language extension that aims to make it easier to use joinads in modern functional languages.Our extension generalizes pattern matching to work on abstract computations. It keeps a familiar syntax and semantics of pattern matching making it easy to reason about code, even in a non-standard programming model. We demonstrate our extension using three important programming models – a reactive model based on events; a concurrent model based on join calculus and a parallel model using futures. All three models are implemented as libraries that benefit from our syntactic extension. This makes them easier to use and also opens space for exploring new useful programming models.

The paper can be downloaded from the author's academic page.