Arrows and computation Ross Paterson

Many programs and libraries involve components that are ‘function-like’, in that they take inputs and produce outputs, but are not simple functions from inputs to outputs. This chapter explores the features of such ‘notions of computation’, defining a common interface, called ‘arrows’. This allows all these notions of computation to share infrastructure, such as libraries, proofs or language support. Arrows also provide a useful discipline for structuring many programs, and allow one to program at a greater level of generality. Monads, discussed in Chapter 11 of IFPH, serve a similar purpose, but arrows are more general. In particular, they include notions of computation with static components, independent of the input, as well as computations that consume multiple inputs. We also consider some useful subclasses of arrows, one of which turns out to be equivalent to monads. The others bring choice and feedback to the arrow world.

With this machinery, we can give a common structure to programs based on different notions of computation. The generality of arrows tends to force one into a point-free style, which is useful for proving general properties. However it is not to everyone’s taste, and can be awkward for programming specific instances. The solution is a point-wise notation for arrows, which is automatically translated to the functional language Haskell. Each notion of computation thus defines a special sublanguage of Haskell.

1 Notions of computation

We shall explore what we mean by a notion of computation using four varied examples. As a point of comparison, we shall consider how the following operator on functions may be generalized to the various types of ‘function-like’ components.

add  :: (β → Int) → (β → Int) → (β → Int)
add f g b = f b + g b

State transformers: Applications that involve the threading of a state through a function might have types described by

type State σ ι o = (σ, ι) → (σ, o)

A generalization of add to state transformers is

addST  :: State σ β Int → State σ β Int → State σ β Int

addST f g (s, b)

= let

(s′, x) = f (s, b)
(s′′, y) = g (s′, b)
in (s′′, x + y)

which we can picture as below:

[figure: .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; β; f; +; σ; σ; Int; g; Int; Int; σ]

But for the dotted line, this is the same as add. The difference is that the state σ is threaded first through f and then through g to produce the resulting state. This is not the only choice: we could have defined addST to thread the state through g and then through f .

Nondeterminism: Many search algorithms may be described as functions that return a list of possible answers (with the empty list indicating failure):

type NonDet ι o = ι → [o]

The generalization of add is to add each combination:

addND  :: NonDet β Int → NonDet β Int → NonDet β Int
addND f g b = [x + y | x ← f b, y ← g b]

The effect under lazy evaluation is similar to backtracking. To compute the head of the list, the function gets the first elements from f and g. To compute the next element, it gets the next element from g if any, or otherwise the next element from f and the first from g, and so on. As with state transformers, another version is available: we could have gone through all the results of f first.

More sophisticated variations on this idea are discussed in Chapter ??.

Map transformers: A data parallel algorithm transforms a family of input values, one for each place in a set σ, into a family of output values at the same places:

type MapTrans σ ι o = (σ → ι) → (σ → o)

Another interpretation takes σ as representing time, so that a function σ → α is a time-varying value, or behaviour, and the component is a behaviour transformer.

The generalization of add to map transformers adds the functions pointwise:

addMT :: MapTrans σ β Int → MapTrans σ β Int → MapTrans σ β Int addMT f g m s = f m s + g m s If σ represents place, this corresponds to evaluating f and g at each place and summing each pair of results. If σ represents time, this operator adds the values of two behaviours at each point in time.

Simple automata: One way to model synchronous circuits is to use simple automata, which map an input to an output and a new version of themselves:

newtype Auto ι o = A (ι → (o, Auto ι o))

The generalization of add to automata runs the two automata in parallel, summing each pair of results:

addAuto  :: Auto β Int → Auto β Int → Auto β Int
addAuto (A f ) (A g) = A (λ b → let (x, f′) = f b (y, g′) = g b in (x + y, addAuto f′ g′))

1.1 Categories and functors

In each of the above examples, and many more like them, there is a type A ⇝ B of computations taking inputs of type A and producing outputs of type B. It is natural to ask what else these examples have in common. We shall define an interface that is sufficiently general to encompass our examples (and many others), but also powerful enough to program general combinators like add.

It seems reasonable to expect that we can compose two computations by connecting the output of the first to the input of the second, and that composition is associative with an identity (a ‘do-nothing’ computation). This is the standard notion of a category, with types as objects and computations as arrows (or morphisms). We can represent this in Haskell with the class

class Category α where

\begin{aligned}idA & :: & α β β \\ (≫) & :: & α β γ → α γ δ → α β δ \end{aligned}

Haskell does not permit infix type constructors like ⇝, so the arrow type constructor α is placed before its two type arguments.

In a category, these operations are required to satisfy the axioms

identity  idA ≫ f = f ≫ idA = f
associativity (f ≫ g) ≫ h = f ≫ (g ≫ h)

Pure functions constitute a category:

instance Category (→) where

idA  = id
f ≫ g = g · f

A category is a very general concept, and it is perhaps no surprise that all of our examples induce categories, as do many other things. However this interface is much too general (or offers too little) for programming purposes. Firstly, we shall also require a combinator to embed ordinary functions as ‘pure’ computations:

pure :: (β → γ) → α β γ

satisfying the following axioms:

functor-identity  pure id = idA
functor-composition pure (g · f ) = pure f ≫ pure g

Normally functional programmers use only functors, like map, from the category of functions to itself, but pure is a functor from the category of pure functions to the new category.

Using pure, we can lift functions like + to computations, but this is still not enough to implement a generalization of add. So far, the results of a computation must be fed to the immediately following computation; we have no way to save intermediate results. We need a means to apply a computation to part of the input, while preserving the rest. In the category of functions, this is done using the product functor:^{1}

(×)  :: (α → α′) → (β → β′) → (α, β) → (α′, β′)
(f × g)˜ (a, b) = (f a, g b)

The operator × is a functor in two arguments, so that we have

(f · g) × (h · k) = (f × h) · (g × k)

This does not generalize directly to other notions of computation. For example, in state transformer computations the order of g and h cannot be changed without changing the effect of the computation. However, it suffices to assume a one-sided product, which we shall call first. Hence instead of Category, we use the following class:

class Arrow α where

pure :: (β → γ) → α β γ
(≫) :: α β γ → α γ δ → α β δ
first :: α β γ → α (β, δ) (γ, δ)

There is no need to assume idA, because it is uniquely defined by the functoridentity law for pure:

idA :: Arrow α ⇒ α β β
idA = pure id

We need not assume a mirror image of first, as it may be defined as

1The tilde marks an irrefutable pattern in Haskell. It is used in this and some later definitions to make the matching of pairs non-strict.

Ross Paterson 5

second :: Arrow α ⇒ α β γ → α (δ, β) (δ, γ)
second f = pure swap ≫ first f ≫ pure swap
where swap ˜ (x, y) = (y, x)

We assume that first satisfies the following axioms:

extension  first (pure f ) = pure (f × id)
functor  first (f ≫ g) = first f ≫ first g
exchange  first f ≫ pure (id × g) = pure (id × g) ≫ first f
unit  first f ≫ pure fst = pure fst ≫ f
association first (first f ) ≫ pure assoc = pure assoc ≫ first f

where assoc rearranges pairs:

assoc  :: ((α, β), γ) → (α, (β, γ))
assoc ˜ (˜ (a, b), c) = (a, (b, c))

Ordinary functions are an instance of the Arrow class:

instance Arrow (→) where

pure f = f
f ≫ g = g · f
first f = f × id

Our other examples are also instances, though in some cases we must alter the definitions slightly, because Haskell does not permit type synonyms as instances:

newtype State σ ι o  = ST ((σ, ι) → (σ, o))
newtype NonDet ι o  = ND (ι → [o])
newtype MapTrans σ ι o = MT ((σ → ι) → (σ → o))

Now we can define an instance for the State type. A pure state transformer leaves the state untouched, while first routes the state through f :

instance Arrow (State σ) where

pure f  = ST (id × f )
ST f ≫ ST g = ST (g · f )
first (ST f ) = ST (assoc · (f × id) · unassoc)

where unassoc is the inverse of assoc:

unassoc  :: (α, (β, γ)) → ((α, β), γ)
unassoc ˜ (a,˜ (b, c)) = ((a, b), c)

A pure non-deterministic computation is a single-valued, or deterministic, computation, while composition encapsulates backtracking:

instance Arrow NonDet where

pure f  = ND (λ b → [f b])
ND f ≫ ND g = ND (λ b → [d | c ← f b, d ← g c])
first (ND f )  = ND (λ (b, d) → [(c, d) | c ← f b])

A pure map transformer applies a function to each result of the map, while first applies a transformer to only part of a map:

instance Arrow (MapTrans σ) where

pure f  = MT (f ·)
MT f ≫ MT g = MT (g · f )
first (MT f )  = MT (zipMap · (f × id) · unzipMap)

where zipMap and its inverse unzipMap convert between pairs of maps and maps yielding pairs:

zipMap  :: (σ → α, σ → β) → (σ → (α, β))
zipMap h s = (fst h s, snd h s)
unzipMap :: (σ → (α, β)) → (σ → α, σ → β)
unzipMap h = (fst · h, snd · h)

The instance for automata is a bit more complicated:

instance Arrow Auto where

pure f  = A (λ b → (f b, pure f ))
A f ≫ A g = A (λ b → let (c, f′) = f b (d, g′) = g c in (d, f′ ≫ g′))

first (A f ) = A (λ (b, d) → let (c, f′) = f b in ((c, d), first f′))

Remember that an automaton maps an input to an output and a new version of itself to be used on the next input. In the case of a pure automaton, the new version is the same as the old one: the automaton is stateless, with each output a function of the corresponding input. A pair of automata are composed by running them side by side, with each output of the first used as an input to the second.

Now we can write some general combinators for arrows. For example, we can define something that looks like a product:

(∗∗∗) :: Arrow α ⇒ α β γ → α β′ γ′ → α (β, β′) (γ, γ′)
f ∗∗∗ g = first f ≫ second g

Note that we have arbitrarily chosen an order for the computations f and g. For many arrows (e.g. state transformers), the other order has a different meaning. As a consequence, ∗∗∗ is not in general a functor.

A convenient variant duplicates the input first:

(&&&) :: Arrow α ⇒ α β γ → α β γ′ → α β (γ, γ′)
f &&& g = pure dup ≫ (f ∗∗∗ g)

where dup b = (b, b)

A general combinator corresponding to add is:

addA :: Arrow α ⇒ α β Int → α β Int → α β Int
addA f g = f &&& g ≫ pure (uncurry (+))

Each of the versions of add defined above may be obtained by specializing addA with the appropriate arrow type.

Exercise 1 Write Arrow instances for the following types:

newtype Reader σ ι o = R ((σ, ι) → o)
newtype Writer ι o = W (ι → (String, o))

In the latter case, any monoid could be used in place of String. □

Exercise 2 The following is almost an arrow type:

newtype ListMap ι o = LM ([ι] → [o])

What goes wrong? □

Exercise 3 Define the following as an arrow type:

data Stream α  = Cons α (Stream α)
newtype StreamMap ι o = SM (Stream ι → Stream o)

This enables us to mimic dataflow languages, in which an infinite list represents all the values of a variable, or Kahn networks, in which a list represents all the values that pass through a channel. □

Exercise 4 Show that the following is a functor:

(⋉) :: Arrow α ⇒ α β γ → (β′ → γ′) → α (β, β′) (γ, γ′)
f ⋉ g = first f ≫ (id × g)

□

2 Special cases

We consider here a number of interfaces that are less general than arrows, but which nevertheless offer useful additional facilities when available.

2.1 Arrows and monads

The Arrow combinators operate on computations, rather than the values that pass through them. They are point-free, in contrast to normal functional programming, where we use named values (variables) bound by λ or let. We could name inputs to arrows in the same way if the arrow type α satisfied

currying α (β, γ) δ ≅ β → α γ δ

(This is an example of what category theorists call an adjunction.) There is a obvious function from the left side to the right:

curryA :: Arrow α ⇒ α (β, γ) δ → β → α γ δ
curryA f b = mkPair b ≫ f
mkPair :: Arrow α ⇒ β → α γ (β, γ)
mkPair b = pure (λ c → (b, c))

But does curryA have an inverse? Such an inverse would map id :: α γ δ → α γ δ to a combinator

class Arrow α ⇒ ArrowApply α where

app :: α (α γ δ, γ) δ

Indeed, it can be shown that a natural currying isomorphism exists if and only if such an arrow app exists and satisfies the axioms:

composition pure ((≫ h) × id) ≫ app = app ≫ h
reduction  pure (mkPair × id) ≫ app = pure id
extensionality  mkPair f ≫ app = f

Pure functions are a trivial instance of this class:

instance ArrowApply (→) where

app˜ (f , c) = f c

Of the other arrows we have considered, State and NonDet are instances, but MapTrans and Auto are not. Indeed, the currying isomorphism implies

α β δ ≅ α (β, ()) δ ≅ β → α () δ

and any such arrow may be factored as β → M δ, where M is a monad. Conversely any monad gives rise to an arrow of this form, called its Kleisli arrow, which satisfies the currying isomorphism. Thus the ArrowApply class is merely a less convenient version of the Monad class. It describes computations that always take a single input. However, arrows also include computations that consume multiple input values (like MapTrans and Auto), as well as computations that are partially static, i.e. independent of the input. We shall see examples of both kinds in Section 4.

Exercise 5 Verify the ArrowApply axioms for pure functions. □

Exercise 6 The following instance has the correct type: instance ArrowApply Auto where

app = pure (λ (A f , x) → fst (f x))

Show that the extensionality axiom fails for this definition. □

2.2 Conditionals

In many situations we wish to perform different computations for different inputs. This would be trivial if we could refer to the input directly, as with monadic computations (or, equivalently, ArrowApply). Although this is not available for arrows in general, more arrows admit conditional computation than currying. We begin with a Haskell sum type:

data Either α β = Left α | Right β

Just as with the product type, there is a corresponding functor:

(⊕)  :: (α → α′) → (β → β′) → Either α β → Either α′ β′
(f ⊕ g) (Left a) = Left (f a)
(f ⊕ g) (Right b) = Right (g b)

By analogy with products, we postulate a one-sided sum functor on arrows:

class Arrow α ⇒ ArrowChoice α where

left :: α β γ → α (Either β δ) (Either γ δ)

As with products, the mirror image may be defined:

right :: ArrowChoice α ⇒ α β γ → α (Either δ β) (Either δ γ)
right f = pure mirror ≫ left f ≫ pure mirror

where

mirror (Left x) = Right x
mirror (Right y) = Left y

The axioms for left mirror those for first:

extension  left (pure f ) = pure (f ⊕ id)
functor  left (f ≫ g) = left f ≫ left g
exchange  left f ≫ pure (id ⊕ g) = pure (id ⊕ g) ≫ left f
unit  pure Left ≫ left f = f ≫ pure Left
association left (left f ) ≫ pure assocsum = pure assocsum ≫ left f

for the function

assocsum  :: Either (Either α β) γ → Either α (Either β γ)
assocsum (Left (Left a)) = Left a
assocsum (Left (Right b)) = Right (Left b)
assocsum (Right c)  = Right (Right c)

In the world of pure functions, sums and products are related by the function

distr  :: (Either α β, γ) → Either (α, γ) (β, γ)
distr (Left a, c) = Left (a, c)
distr (Right b, c) = Right (b, c)

We also postulate an additional axiom for arrows:

distribution first (left f ) ≫ pure distr = pure distr ≫ left (first f )

We can define derived combinators corresponding to those for products:

(<+>)

::

ArrowChoice α ⇒

α β γ → α β′ γ′ → α (Either β β′) (Either γ γ′)

f <+> g = left f ≫ right g
(|||)  :: ArrowChoice α ⇒ α β δ → α γ δ → α (Either β γ) δ
f ||| g = f <+> g ≫ pure untag

where

untag (Left x) = x
untag (Right y) = y

Naturally pure functions are an instance of ArrowChoice:

instance ArrowChoice (→) where

left f = f ⊕ id

Indeed any instance of ArrowApply, including State and NonDet, is also an instance of ArrowChoice. More interestingly, simple automata allow choice, even though they do not permit application:

instance ArrowChoice Auto where

left (A f ) = A lf

where

lf (Left b) = let (c, f′) = f b in (Left c, left f′)
lf (Right d) = (Right d, left (A f ))

Only inputs marked Left are run through the automaton, while others are copied to the output.

There is no ArrowChoice instance for map transformers.

Exercise 7 Define ArrowChoice instances for NonDet, State and the StreamMap type from Exercise 3. □

Exercise 8 Show that the equation

(f ||| g) ≫ h = (f ≫ h) ||| (g ≫ h)

fails for the Auto and StreamMap arrows. □

Exercise 9 Given the following definition, which adds string-valued exceptions to an arrow:

newtype Except α β γ = E (α β (Either String γ))

Define the following instance

instance ArrowChoice α ⇒ Arrow (Except α)

□

Exercise 10 Prove the functor axiom for first in the arrow defined in the previous exercise. This requires the distributivity axiom. □

2.3 Feedback

Since arrows are Haskell values, they may be recursively defined in the usual way. Sometimes we want a different form of recursion, where values input to an arrow are defined in terms of its outputs, as in the following diagram:

[figure: γ; β; f; δ]

For ordinary functions, we can define a function category theorists call a trace:

trace :: ((β, δ) → (γ, δ)) → β → γ
trace f b = let (c, d) = f (b, d) in c

Here the second component of the output of f is fed back as the second component of its input. Some arrows permit a generalization of trace, characterized by the class

class Arrow α ⇒ ArrowLoop α where

loop :: α (β, δ) (γ, δ) → α β γ

The intention is that while the value is fed back, any effect of the computation occurs once only, and this is reflected by the axioms of loop:

extension  loop (pure f ) = pure (trace f )
left tightening  loop (first h ≫ f ) = h ≫ loop f
right tightening  loop (f ≫ first h) = loop f ≫ h
sliding  loop (f ≫ pure (id × k)) = loop (pure (id × k) ≫ f )
vanishing  loop (loop f ) =

loop (pure unassoc ≫ f ≫ pure assoc)

superposing  second (loop f ) =

loop (pure assoc ≫ second f ≫ pure unassoc)

For example, a computation that is independent of the feedback value may be moved out of the loop, as in the ‘tightening’ axioms.

As we have already seen, ordinary functions support such an operator:

instance ArrowLoop (→) where

loop = trace

In the case of state transformers, we want a function that transforms the state once, while feeding back part of the output:

[figure: .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; f; σ; σ; β; γ; δ]

We can implement this directly, with a little manipulation of the pairs:

instance ArrowLoop (State σ) where

loop (ST f ) = ST (trace (unassoc · f · assoc))

This definition is almost an inside-out version of the definition of first for state transformers. The instance for map transformers is similar:

instance ArrowLoop (MapTrans σ) where

loop (MT f ) = MT (trace (unzipMap · f · zipMap))

The instance for automata is more subtle. At each stage, part of the output is fed back to the input:

instance ArrowLoop Auto where

loop (A f ) = A (λ b → let (˜ (c, d), f′) = f (b, d) in (c, loop f′))

However there is no loop operator for non-deterministic functions, unless we are prepared to relax our axioms.

Exercise 11 Define an ArrowLoop instance for the StreamMap type from Exercise 3. □

Exercise 12 Prove that loop (first f ) = f . □

3 Arrow notation

Arrows present a usefully general interface to computation, but we have seen that they force a point-free style. This may be convenient for general definitions and

Minor rephrasing to im- proofs, but it can be cumbersome for specific programming. For example, suppose prove pagebreaks we have the following operations for the state transformer arrow:

fetch :: State σ () σ
fetch = ST (λ (s, ()) → (s, s))
store :: State σ σ ()
store = ST (λ (s, s′) → (s′, ()))

The following arrow uses an integer state to generate a fresh number:

genSym :: State Int () Int
genSym = fetch ≫ pure incr ≫ first store ≫ pure snd
where incr n = (n + 1, n)

Note that we must explicitly describe the plumbing, duplicating the n, passing the new value to store and then discarding its result.

To facilitate programming with arrows, we extend the Haskell syntax with a new sort of expression, the proc expression for defining arrows. Here is a version of genSym in the new notation:

genSym :: State Int () Int
genSym = proc () → do
n ← fetch −≺ ()
store −≺ n + 1
idA −≺ n

The right-hand side is a proc expression, a variation on a lambda expression that defines an arrow. In this case the input has the form (). The next line passes a value () through the arrow fetch, naming the result n. (The −≺ symbol is meant to signify an arrow tail.) The value n + 1 is then sent to store. Finally n is sent to the identity arrow idA to produce the output of the whole arrow.

The new expressions are defined by the grammar of Figure 1. A command occurs as the body of a proc binding, and elsewhere. It returns a value, but may also have some effect. The simplest sort of command is built using the arrow tail −≺ which acts as a sort of application of an arrow to an input expression. The above example includes sub-commands fetch −≺ () and store −≺ n + 1 that are of this form. The do command consists of a series of statements, which may define variables or simply execute commands for effect, followed by a final command, in the above example idA −≺ n.

These new forms are given meaning by translation to ordinary Haskell, using the rules of Figure 2. Note in particular the two translations for arrow application (−≺). The first is syntactically restricted, but is valid for any arrow. In the special case where f is idA, we have

proc p → do idA −≺ e = pure (λ p → e)

The second possibility has no such syntactic restriction, but because its translation uses app, the arrow in the type of the arrow expression must be an instance of the

exp = …
| proc pat → cmd
cmd = exp −≺ exp
| do { stmt; …; stmt; cmd }
stmt = pat ← cmd
| cmd
| rec { stmt; …; stmt }

Figure 1: Grammar for arrow expressions

proc p → f −≺ a ≜ \{ \begin{matrix}pure (λp → a) ≫ f & if FV (p) ∩ FV (f ) = ∅ \\ pure (λp → (f , a)) ≫ app & otherwise \end{matrix}

proc p → do { c } ≜ proc p → c

proc p → do { p′ ← c; B } ≜ ((proc p → c) &&& idA) ≫ proc (p′, p) → do { B }

proc p → do { c; B } ≜ proc p → do { ← c; B }

proc p → do { rec { A }; B} ≜ idA &&& loop (proc (p, p_{A}) → do { A; idA −≺ (p_{B}, p_{A}) }) ≫ proc (p, p_{B}) → do { B }

Figure 2: Translation rules for arrow expressions

ArrowApply class. Thus neither form is more general than the other, and both are useful.

The third rule deals with binding of new variables. As the translation makes clear, a copy of the original input (described by p) must be routed around the command c for use in the rest of the do command, which also has access to the output of c, bound by p′. The next rule is the special case where we wish to discard the output of a command, as with store in the genSym example.

The last rule, dealing with recursion, is more involved. The right side may be visualized as follows:

[figure: reset; DELAY 0; IF; CONST 0; +1; next; output]

Figure 3: A resettable counter circuit

[figure: p; B; pB; p; p; A; idA −≺ (p_{B}, p_{A}); pA]

Here pA is a pattern containing all the variables that are both defined and used in A, while the pattern pB contains the variables defined in A that are used in B. Note that if recursion is used, the arrow involved must be an instance of ArrowLoop.

Exercise 13 Use the rules of Figure 2 to translate the above definition of genSym into ordinary Haskell, and use the axioms to simplify the result. Compare your answer with the point-free version. □

Exercise 14 Prove that when both translations of proc p → f −≺ a are possible, they are equal. □

Exercise 15 Suppose the syntax is extended with a new form of command

if exp then cmd else cmd

Suggest a translation for the new form, assuming the arrow concerned belongs to ArrowChoice. A case command could be defined similarly. □

4 Examples

4.1 Synchronous circuits

A synchronous circuit receives an input and produces an output on each tick of some global clock. The output for a given tick may depend on the input for that tick, as well as previous inputs. Consider the simple circuit of Figure 3 (taken from [13]). This circuit represents a resettable counter, taking a Boolean input and producing an integer output, which will be the number of clock ticks since the input was last True. To achieve this, the output is incremented and fed back, delayed by one clock cycle. The first output of the delay component is its argument, here 0; its second output is its first input, and so on.

We propose to treat circuits as arrows. It suffices to consider circuits with a single input and output, because multiple inputs may be treated as input of a tuple, and similarly for output.

• The pure operation defines circuits where each output is a pure function of the corresponding input (e.g. if and +1 in the above circuit).

• Composition connects the output of the first circuit to the input of the second.

• The first operation channels part of the input to a subcircuit, with the rest copied directly to the output.

As with any arrow instance, we shall require additional operations. We define circuits as arrows that support cycles and a delay arrow:

class ArrowLoop α ⇒ ArrowCircuit α where

delay :: β → α β β

The argument supplies the initial output; subsequent outputs are copied from the input of the previous tick. A circuit built with loop will not work unless it includes a delay somewhere on its second input before using it, as in the example above. One could enforce this by combining the two in a single construct, but the present formulation is better suited to algebraic manipulation.

Here is the resettable counter circuit in arrow notation:

counter :: ArrowCircuit α ⇒ α Bool Int
counter = proc reset → do

rec output ← idA −≺ if reset then 0 else next

next ← delay 0 −≺ output + 1 idA −≺ output

This corresponds rather directly to the graphical presentation of Figure 3. The variables denote the values passing through wires on a particular clock tick.

Several implementations of the ArrowCircuit class are possible, allowing many different interpretations of circuit descriptions. For example, we already have an ArrowLoop instance for simple automata, so we need only implement delay:

instance ArrowCircuit Auto where

delay b = A (λ b′ → (b, delay b′))

To simulate a circuit, we feed it a list of inputs, extracting a list of the same number of outputs:

runAuto  :: Auto β γ → [β] → [γ]
runAuto (A f ) [ ]  = [ ]
runAuto (A f ) (b : bs) = let (c, f′) = f b in (c : runAuto f′ bs)

However many other other arrows satisfy the ArrowCircuit interface, permitting a range of interpretations of a single circuit description. An interpretation could add probes that show intermediate values, or calculate static properties of a circuit, such as a wiring description.

Exercise 16 Define an ArrowCircuit instance for the StreamMap type from Exercise 3. □

4.2 Homogeneous functions

Many parallel algorithms and circuit designs operate on collections of 2^{n} elements, with behaviour defined by induction on n. We can model these collections in Haskell using the following type:

data BalTree α = Zero α | Succ (BalTree (Pair α))
type Pair α = (α, α)

Here are some example elements:

tree0 = Zero 1
tree1 = Succ (Zero (1, 2))
tree2 = Succ (Succ (Zero ((1, 2), (3, 4))))
tree3 = Succ (Succ (Succ (Zero (((1, 2), (3, 4)), ((5, 6), (7, 8))))))

The elements of this type have a string of constructors expressing a depth n as a Peano numeral, enclosing a nested pair tree of 2^{n} elements. However few algorithms can be expressed in terms of the balanced tree type. Typically one wants to split a tree into two subtrees, do some processing on the subtrees and combine the results. But the type system cannot discover that the two results are of the same depth (and thus combinable).

The solution is to define a type we call homogeneous functions, namely families of functions mapping trees of size 2^{n} to trees of the same size 2^{n}:

data Hom α β = (α → β) :&: Hom (Pair α) (Pair β)

Elements of this type have the form

f_{0} :&: f_{1} :&: f_{2} :&: …

where f_{n} :: Pair^{n} α → Pair^{n} β.

The following function applies a homogeneous function to a perfectly balanced tree, yielding another perfectly balanced tree of the same depth:

apply  :: Hom α β → BalTree α → BalTree β
apply (f :&: fs) (Zero x) = Zero (f x)
apply (f :&: fs) (Succ t) = Succ (apply fs t)

Having defined apply, we can program with the Hom type and forget about BalTree. Firstly, Hom is an arrow: instance Arrow Hom where

pure f  = f :&: pure (f × f )
(f :&: fs) ≫ (g :&: gs) = (g · f ) :&: (fs ≫ gs)
first (f :&: fs)  =

(f × id) :&: (pure transpose ≫ first fs ≫ pure transpose)

transpose  :: ((α, β), (γ, δ)) → ((α, γ), (β, δ))
transpose ((a, b), (c, d)) = ((a, c), (b, d))

The function pure maps a function over the leaves of the tree. The composition ≫ composes sequences of functions pairwise. The ∗∗∗ operator unriffles a tree of pairs (α, β) into a tree of αs and a tree of βs, applies the appropriate function to each tree and riffles the results.

When describing algorithms, one often provides a pure function for the base case (trees of one element) and an expression for trees of pairs, usually invoking the same algorithm on smaller trees.

Parallel Prefix: This operation (also called scan) maps the sequence

x_{1}, x_{2}, x_{3}, …, x_{2^{n}}

to the sequence

x_{1}, x_{1} + x_{2}, x_{1} + x_{2} + x_{3}, …, x_{1} + x_{2} + ⋯ + x_{2^{n}}

(All this generalizes easily from + to any associative operation.)

If there is only one element (i.e. the tree has zero depth) then obviously the scan should be the identity function. Otherwise, we need to deal with a tree of pairs, so the general scan operation will have the form

scan :: Num β ⇒ Hom β β
scan = id :&: proc (x, y) → ⟨something using scan on smaller trees⟩

An efficient scheme, devised by Ladner and Fischer [12], is first to sum the elements pairwise:

x_{1} + x_{2}, x_{3} + x_{4}, x_{5} + x_{6}, …

and then to compute the scan of this list (which is half the length of the original), yielding

x_{1} + x_{2}, x_{1} + x_{2} + x_{3} + x_{4}, x_{1} + x_{2} + x_{3} + x_{4} + x_{5} + x_{6}, …

This list is half of the desired answer; the other elements are

x_{1}, x_{1} + x_{2} + x_{3}, x_{1} + x_{2} + x_{3} + x_{4} + x_{5}, …

which can be obtained by shifting our partial answer one place to the right and adding x_{1}, x_{3}, x_{5}, . . .. We can express this idea directly in our notation:

scan :: Num β ⇒ Hom β β
scan = id :&: proc (o, e) → do
e′ ← scan −≺ o + e
el ← rsh 0 −≺ e′
idA −≺ (el + o, e′)

The auxiliary arrow rsh b shifts each element in the tree one place to the right, placing b in the now-vacant leftmost position, and discarding the old rightmost element. This could be supplied as a primitive, but it is also possible to code it directly:

rsh :: β → Hom β β
rsh v = const v :&: proc (o, e) → do
o′ ← rsh v −≺ e
idA −≺ (o′, o)

Butterfly Circuits: In many divide-and-conquer schemes, one recursive call processes the odd-numbered elements and the other the even ones [9]: deleted second ‘pro-

cesses’ to avoid bad linebreak

butterfly :: (Pair β → Pair β) → Hom β β
butterfly f = id :&: proc (o, e) → do

o′ ← butterfly f −≺ o e′ ← butterfly f −≺ e idA −≺ f (o′, e′)

The recursive calls operate on halves of the original tree, so the recursion is welldefined. (The Fast Fourier Transform has a similar structure. See also Chapter ?? for another view.) Here are some examples of butterflies:

rev  :: Hom β β
rev  = butterfly swap
unriffle :: Hom (Pair β) (Pair β)
unriffle = butterfly transpose

Batcher’s ingenious sorter for bitonic sequences [1] is another example of a butterfly circuit:

bisort :: Ord β ⇒ Hom β β
bisort = butterfly cmp
where cmp (x, y) = (min x y, max x y)

Exercise 17 Use the functions defined in this section to define an arrow

sort :: Ord β ⇒ Hom β β

using a merge based on Batcher’s bitonic sorter, combined with rev. □

4.3 Combining arrows

We have seen that each arrow type embodies a notion of computation. Sometimes we want to combine two such notions, e.g. dataflow with state. The trick is to generalize one of the arrows to an arrow transformer, and then apply it to the other one. For example, state transformers were defined using functions, but we can generalize to any arrow:

newtype StateT σ α ι o = ST (α (σ, ι) (σ, o))

Now we can define a new arrow for each arrow α, as follows:

instance Arrow α ⇒ Arrow (StateT σ α) where

pure f  = ST (proc (s, b) → idA −≺ (s, f b))
ST f ≫ ST g = ST (f ≫ g)
first (ST f ) = ST (proc (s, (b, d)) → do
(s′, c) ← f −≺ (s, b)
idA −≺ (s′, (c, d)))

The arrow notation is useful here, especially in the definition of first. Now State may be defined as a special case:

type State σ = StateT σ (→)

The transformer StateT could be also applied to Auto, yielding an automaton that also transforms a state on each iteration.

Arrows can also model static data, which is independent of the input. For example, the following arrow transformer augments an arrow with an integer count:

data Count α ι o = Count Int (α ι o)

The arrow combinators of the base arrow lift directly to the new arrow:

instance Arrow α ⇒ Arrow (Count α) where

pure f  = Count 0 (pure f )
Count n1 f 1 ≫ Count n2 f 2 = Count (n1 + n2) (f 1 ≫ f 2)
first (Count n f )  = Count n (first f )

Other arrow combinators lift similarly:

instance ArrowChoice α ⇒ ArrowChoice (Count α) where

left (Count n f ) = Count n (left f )

This is a very simple example, but the ability to handle such static information enables arrows to express many efficient algorithms. An example is parser combinators that compute properties of the grammar, independent of the input being parsed [17].

Exercise 18 Rewrite the definition of StateT without arrow notation. □

Exercise 19 Given the following definition,

newtype AutoFunctor α ι o = A (α ι (o, AutoFunctor α ι o))

write the following instance, using arrow notation (or not):

instance Arrow α ⇒ Arrow (AutoFunctor α)

□

5 Chapter notes

Arrows were invented as a programming abstraction by John Hughes [8], to deal with libraries that did not fit the monad model. Unknown to Hughes, workers in denotational semantics had also defined generalizations of monads, based on premonoidal categories [16]. A special case of these structures, later called a Freydcategory, turns out to be identical to Hughes’s definition.

Hughes also introduced the ArrowApply and ArrowChoice classes, though the distribution axiom is new here. The ArrowLoop class [15] generalizes traces, defined by Joyal, Street and Verity [11], and the recursive monads of Erkök and Launchbury [7]. A more primitive and powerful version of the arrow notation sketched here may also be found in [15]. More information about arrows, including a preprocessor implementation this notation, may be found on the web page

http://www.haskell.org/arrows/.

The embedded language FRP [6], used to model reactive situations such as robotics and graphical interfaces, has recently been reformulated in terms of arrows [5]. Map transformers are used as the abstract semantics, though implementations use variants of stream maps or automata.

Several dataflow languages have been used to model circuits [2, 4, 18]. The microarchitecture design language Hawk [13] abstracts over the type of values that may pass through wires. Low-level descriptions deal with bits (Bool), but any Haskell type may be used, allowing Hawk to scale to much more abstract descriptions, and also allowing the same circuit description to be simulated or symbolically executed. Related ideas are discussed in Chapter ??. There, circuits are functions, but in another version of the hardware description language Lava [3], circuits have the form Value → Monad Value′ where both value and monad types are parameters described by Haskell classes. By selecting appropriate instances, a single description may be simulated, symbolically executed or presented in a variety of styles.

Formalisms related to our homogeneous functions include Ruby [10], used in circuit design, and Misra’s powerlists [14].

Hughes [8] also introduced arrow transformers, including the state arrow transformer.

References

[1] K. Batcher. Sorting networks and their applications. In AFIPS Spring Joint Conference, pages 307–314, 1968.

[2] G. Berry and G. Gonthier. The Esterel synchronous programming language: Design, semantics, implementation. Science of Computer Programming, 19(2):87–152, 1992.

[3] P. Bjesse, K. Claessen, M. Sheeran, and S. Singh. Lava: Hardware design in Haskell. In International Conference on Functional Programming. ACM, 1998.

[4] P. Caspi, D. Pilaud, N. Halbwachs, and J. Plaice. LUSTRE: A declarative language for programming synchronous systems. In 14th ACM Symposium on Principles of Programming Languages, pages 178–188, Munich, 1987.

[5] A. Courtney and C. Elliott. Genuinely functional user interfaces. In Haskell Workshop, pages 41–69, 2001.

[6] C. Elliott and P. Hudak. Functional reactive programming. In International Conference on Functional Programming, pages 163–173, 1997.

[7] L. Erkök and J. Launchbury. Recursive monadic bindings. In International Conference on Functional Programming, pages 174–185, 2000.

[8] J. Hughes. Generalising monads to arrows. Science of Computer Programming, 37:67–111, May 2000.

[9] G. Jones and M. Sheeran. Collecting butterflies. Technical Monograph PRG-91, Oxford University Computing Laboratory, Programming Research Group, Feb. 1991.

[10] G. Jones and M. Sheeran. Designing arithmetic circuits by refinement in Ruby. In R. Bird, C. Morgan, and J. Woodcock, editors, Mathematics of Program Construction, volume 669 of Lecture Notes in Computer Science, pages 208–232. Springer, 1993.

[11] A. Joyal, R. Street, and D. Verity. Traced monoidal categories. Mathematical Proceedings of the Cambridge Philosophical Society, 119(3):447–468, 1996.

[12] R. Ladner and M. Fischer. Parallel prefix computation. J. ACM, 27:831–838, 1980.

[13] J. Launchbury, J. Lewis, and B. Cook. On embedding a microarchitecture design language within Haskell. In International Conference on Functional Programming. ACM, 1999.

[14] J. Misra. Powerlist: A structure for parallel recursion. ACM Trans. Prog. Lang. Syst., 16(6):1737–1767, Nov. 1994.

[15] R. Paterson. A new notation for arrows. In International Conference on Functional Programming, pages 229–240. ACM Press, Sept. 2001.

[16] J. Power and E. Robinson. Premonoidal categories and notions of computation. Mathematical Structures in Computer Science, 7(5):453–468, Oct. 1997.

[17] S. D. Swierstra and L. Duponcheel. Deterministic, error-correcting combinator parsers. In J. Launchbury, E. Meijer, and T. Sheard, editors, Advanced Functional Programming, volume 1129 of Lecture Notes in Computer Science, pages 184–207. Springer, 1996.

[18] W. Wadge and E. Ashcroft. Lucid, the Dataflow Programming Language. Academic Press, 1985.