Fusion for Free

Abstract

Algebraic effect handlers are a recently popular approach for modelling side-effects that separates the syntax and semantics of effectful operations. The shape of syntax is captured by functors, and free monads over these functors denote syntax trees. The semantics is captured by algebras, and effect handlers pass these over the syntax trees to interpret them into a semantic domain. This approach is inherently modular: different functors can be composed to make trees with richer structure. Such trees are interpreted by applying several handlers in sequence, each removing the syntactic constructs it recognizes. Unfortunately, the construction and traversal of intermediate trees is painfully inefficient and has hindered the adoption of the handler approach. This paper explains how a sequence of handlers can be fused into one, so that multiple tree traversals can be reduced to a single one and no intermediate trees need to be allocated. At the heart of this optimization is keeping the notion of a free monad abstract, thus enabling a change of representation that opens up the possibility of fusion. We demonstrate how the ensuing code can be inlined at compile time to produce efficient handlers.

Syntax and Semantics for Operations with Scopes

“…Another issue is to establish a relationship between syntax with scopes and frameworks like the second-order algebraic theories introduced by Fiore and Mahmoud [9]. As for the practical aspects, it is an interesting task to fully work out an implementation with more advanced features, such as fusion [28], either in Haskell or a language with native support for handlers, like Eff [4].…”

Folding over Neural Networks

“…One of these is performance, in particular, establishing to what extent we trade off computational efficiency in order to achieve generality in our approach. It is hoped that some of this can be offset by the performance gains of "fusion properties" [22] which the setting of structured recursion may give rise to; further insight would be needed as to the necessary circumstance for our implementation to exploit this. A second direction is to explore the many useful universal properties that recursion schemes enjoy, such as having unique solutions and being well-formed [13]; these may offer a means for equationally reasoning about the construction and evaluation of neural networks.…”

Modular effects in Haskell through effect polymorphism and explicit dictionary applications: a new approach and the μVeriFast verifier as a case study

“…A problem with this approach is that instantiating effects in several steps leads to several encodings and decodings of the free monad, and ultimately suboptimal performance, although people have worked to fix this [39]. Our approach does not require changing the representation of effectful code just for instantiating effect interfaces and as such, avoids this source of suboptimal performance.…”