Data.Aviary

Plainly named combinators

Sometimes permuted to be generally useful...

Note the fixity of (#) and (##) is not yet fixed. Some experience needs to be gathered as to whether the precendence levels are appropriate.

The real stuff

(#) :: a -> (a -> b) -> b

T combinator - thrush

Reverse application - the T combinator. Found in Peter Thiemann's WASH and the paper 'Client-Side Web Scripting in Haskell' - Erik Meijer, Daan Leijen & James Hook.

(##) :: (a -> b) -> (b -> c) -> a -> c

Q Combinator - the queer bitd.

Reverse composition - found in Peter Thiemann's WASH. You might perfer to use (<<<) from Control.Categoty.

subst :: (a -> b -> c) -> (a -> b) -> a -> c

S combinator - subst. Familiar as Applicative's (<*>) operator, which itself is fmap:

f (b -> c) -> f b -> f c where f = ((->) a)

bigphi :: (b -> c -> d) -> (a -> b) -> (a -> c) -> a -> d

The big Phi, or Turner's S' combinator. Known to Haskell programmers as liftA2 and liftM2 for the Applicative and Monad instances of (->).

 (a1 -> a2 -> r) -> m a1 -> m a2 -> m r where m = ((->) a)

Taste suggests you may prefer liftA2 especially as bigphi is not a great name (calling it s' would take a very useful variable name).

appro :: (c -> d -> e) -> (a -> c) -> (b -> d) -> a -> b -> e

A variant of the D2 or dovekie combinator - the argument order has been changed to be more satisfying for Haskellers:

 (appro comb f g) x y

 (f x) `comb` (g y)

on from Data.Function is similar but less general, where the two intermediate results are formed by applying the same function to the supplied arguments:

 on = (appro comb f f)

dup :: (a -> a -> b) -> a -> b

dup - duplicator aka the W combinator aka Warbler.

 dup f x = f x x

Specs

oo :: (c -> d) -> (a -> b -> c) -> a -> b -> d

Compose an arity 1 function with an arity 2 function. B1 - blackbird

ooo :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e

Compose an arity 1 function with an arity 3 function. B2 - bunting

oooo :: (e -> f) -> (a -> b -> c -> d -> e) -> a -> b -> c -> d -> f

Compose an arity 1 function with an arity 4 function.

Combiners

combfi :: (c -> b -> d) -> (a -> c) -> a -> b -> d

Combiners - similar to the cardinal' combinator.

Mnemonically - comb(ine) after applying f to x and a single identity: y.

 combfi comb f x y = comb (f x) y

Equivalently:

 combfi comb f = appro comb f id

But combfi is a useful introduction to the (somewhat manic, but sometimes useful) higher arity versions.

combfii :: (d -> b -> c -> e) -> (a -> d) -> a -> b -> c -> e

Extrapolation of combfi with another identity.

Mnemonically - comb(ine) after applying f to x and two identities: y and z.

 combfii comb f x y z = comb (f x) y z

combfiii :: (e -> b -> c -> d -> f) -> (a -> e) -> a -> b -> c -> d -> f

Extrapolation of combfii with a further identity.

Mnemonically - comb(ine) after applying f to s and three identities: t and u and v.

 combfii comb f s t u v = comb (f s) t u v