Data.Invertible.Prelude

The bidirectional "Prelude", which re-exports various bijections similar to functions from Prelude. Most "un"-functions are left out for obvious reasons.

Documentation

(<->) :: BiArrow a => (b -> c) -> (c -> b) -> a b c

Take two functions and lift them into a bidirectional arrow. The intention is that these functions are each other's inverse.

type (<->) = Bijection (->) infix 2

Specialization of Bijection to function arrows. Represents both a function, f, and its (presumed) inverse, g, represented as f :<->: g.

enum :: Enum a => Int <-> a

Convert between an Int and an Enum with toEnum and fromEnum.

const :: a -> () <-> a

Convert between '()' and a constant (not a true bijection).

flip :: (a -> b -> c) <-> (b -> a -> c)

flip the order of the first two arguments of a function.

id :: a <-> a

Identity bijection.

(.) :: (b <-> c) -> (a <-> b) -> a <-> c infixr 9

Bijection composition

not :: Bool <-> Bool

Boolean not.

fst :: (a, ()) <-> a

Extract the fst component of a pair.

snd :: ((), a) <-> a

Extract the snd component of a pair.

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

Convert between an uncurried function and a curryed function.

cons :: Maybe (a, [a]) <-> [a]

Convert between Just (head, tail) and the non-empty list head:tail.

uncons :: [a] <-> Maybe (a, [a])

Convert between the non-empty list head:tail and Just (head, tail). (invert cons)

bifmap :: Functor f => (a <-> b) -> f a <-> f b

Lift both sides of an bijection over a functor using fmap. We name this bifmap in deference to the more useful fmap.

class Functor f where

An invariant version of Functor, equivalent to Invariant.

Methods

fmap :: (a <-> b) -> f a -> f b

Instances

Functor Endo

Functor BiEndo

(Semigroupoid * a, Arrow a) => Functor (Bijection a b)

(<$>) :: Functor f => (a <-> b) -> f a -> f b infixl 4

An infix synnonym for fmap.

map :: (a <-> b) -> [a] <-> [b]

Apply a bijection over a list using map.

reverse :: [a] <-> [a]

reverse the order of a (finite) list.

zip :: ([a], [b]) <-> [(a, b)]

zip two lists together.

zip3 :: ([a], [b], [c]) <-> [(a, b, c)]

zip3 three lists together.

zipWith :: ((a, b) <-> c) -> ([a], [b]) <-> [c]

zipWith two lists together using a bijection.

lines :: String <-> [String]

Split a string into lines.

words :: String <-> [String]

Split a string into words.