Generics.Pointless.Combinators

Pointless Haskell: point-free programming with recursion patterns as hylomorphisms

This module defines many standard combinators used for point-free programming.

Terminal object

_L :: a

The bottom value for any type. It is many times used just for type annotations.

data One

The final object. The only possible value of type One is _L.

Instances

Eq One

Show One

Typeable One

Observable One

Points

bang :: a -> One

Creates a point to the terminal object.

pnt :: a -> One -> a

Converts elements into points.

Products

(/\) :: (a -> b) -> (a -> c) -> a -> (b, c)

The infix split combinator.

(><) :: (a -> b) -> (c -> d) -> (a, c) -> (b, d)

Sums

inl :: a -> Either a b

Injects a value to the left of a sum.

inr :: b -> Either a b

Injects a value to the right of a sum.

(\/) :: (b -> a) -> (c -> a) -> Either b c -> a

The infix either combinator.

(-|-) :: (a -> b) -> (c -> d) -> Either a c -> Either b d

The infix sum combinator.

(<>) :: (a -> b) -> (c -> d) -> Either a c -> Either b d

Alias for the infix sum combinator.

Exponentials

app :: (a -> b, a) -> b

The application combinator.

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

The left exponentiation combinator.

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

The right exponentiation combinator.

(!) :: a -> b -> a

The infix combinator for a constant point.

Guards

grd :: (a -> Bool) -> a -> Either a a

Guard combinator that operates on Haskell booleans.

(?) :: (a -> Bool) -> a -> Either a a

Infix guarc combinator that simulates the postfix syntax.

Point-free definitions of uncurried versions of the basic combinators

split :: (a -> b, a -> c) -> a -> (b, c)

The uncurried split combinator.

eithr :: (a -> c, b -> c) -> Either a b -> c

The uncurried either combinator.

comp :: (b -> c, a -> b) -> a -> c

The uncurried composition combinator.

orf :: (a -> Bool, a -> Bool) -> a -> Bool

Binary or of boolean functions.

andf :: (a -> Bool, a -> Bool) -> a -> Bool

Binary and of boolean functions.

or :: (Bool, Bool) -> Bool

Binary or point-free combinator.

and :: (Bool, Bool) -> Bool

Binary and point-free combinator.

eq :: Eq a => (a, a) -> Bool

Binary equality point-free combinator.

neq :: Eq a => (a, a) -> Bool

Binary inequality point-free combinator.

Point-free isomorphic combinators

swap :: (a, b) -> (b, a)

Swap the elements of a product.

coswap :: Either a b -> Either b a

Swap the elements of a sum.

distl :: (Either a b, c) -> Either (a, c) (b, c)

Distribute products over the left of sums.

undistl :: Either (a, c) (b, c) -> (Either a b, c)

Distribute sums over the left of products.

distr :: (c, Either a b) -> Either (c, a) (c, b)

Distribute products over the right of sums.

undistr :: Either (c, a) (c, b) -> (c, Either a b)

Distribute sums over the right of products.

assocl :: (a, (b, c)) -> ((a, b), c)

Associate nested products to the left.

assocr :: ((a, b), c) -> (a, (b, c))

Associates nested products to the right.

coassocl :: Either a (Either b c) -> Either (Either a b) c

Associates nested sums to the left.

coassocr :: Either (Either a b) c -> Either a (Either b c)

Associates nested sums to the right.