DeepArrow-0.3.5: Arrows for "deep application"

Portabilityportable
Stabilityexperimental
Maintainerconal@conal.net
Safe HaskellSafe-Infered

Control.Arrow.DeepArrow

Contents

Description

"Deep arrows" as an Arrow subclass.

Synopsis

The DeepArrow class

class Arrow ~> => DeepArrow (~>) whereSource

Arrows for deep application. Most of these methods could be defined using arr, but arr is not definable for some types. If your DeepArrow instance has arr, you might want to use these implementations

    idA      = arr id
    fstA     = arr fst
    dupA     = arr (\ x -> (x,x))
    sndA     = arr snd
    funF     = arr (\ (f,b) -> \ c -> (f c, b))
    funS     = arr (\ (a,f) -> \ c -> (a, f c))
    funR     = arr flip
    curryA   = arr curry
    uncurryA = arr uncurry
    swapA    = arr (\ (a,b) -> (b,a))
    lAssocA  = arr (\ (a,(b,c)) -> ((a,b),c))
    rAssocA  = arr (\ ((a,b),c) -> (a,(b,c)))

If your DeepArrow instance does not have arr, you'll have to come up with other definitions. In any case, I recommend the following definitions, which mirror Arrow defaults while avoiding arr. Be sure also to define arr or pure to yield an error message (rather than ping-ponging infinitely between them via the Arrow default definitions).

    second f = swapA >>> first f >>> swapA
    f &&& g  = dupA  >>> f *** g

In a few cases, there are default methods, as noted below. The defaults do not use arr.

Methods

result :: (b ~> b') -> (a -> b) ~> (a -> b')Source

Direct arrow into a function's result. Analogous to first and second.

idA :: a ~> aSource

Identity.

dupA :: a ~> (a, a)Source

Duplicate.

fstA :: (a, b) ~> aSource

Extract first.

sndA :: (a, b) ~> bSource

Extract second.

funF :: (c -> a, b) ~> (c -> (a, b))Source

Extract function from first element.

funS :: (a, c -> b) ~> (c -> (a, b))Source

Extract function from second element.

funR :: (a -> c -> b) ~> (c -> a -> b)Source

Extract function from result.

curryA :: ((a, b) -> c) ~> (a -> b -> c)Source

Curry arrow.

uncurryA :: (a -> b -> c) ~> ((a, b) -> c)Source

Uncurry arrow.

swapA :: (a, b) ~> (b, a)Source

Swap elements. Has default.

lAssocA :: (a, (b, c)) ~> ((a, b), c)Source

Left-associate. Has default.

rAssocA :: ((a, b), c) ~> (a, (b, c))Source

Right-associate. Has default.

Instances

Composable function extractors

funFirst :: DeepArrow ~> => (a ~> (d -> a')) -> (a, b) ~> (d -> (a', b))Source

Promote a function extractor into one that reaches into the first element of a pair.

funSecond :: DeepArrow ~> => (b ~> (d -> b')) -> (a, b) ~> (d -> (a, b'))Source

Promote a function extractor into one that reaches into the second element of a pair.

funResult :: DeepArrow ~> => (b ~> (d -> b')) -> (a -> b) ~> (d -> a -> b')Source

Promote a function extractor into one that reaches into the result element of a function.

Composable input extractors

inpF :: DeepArrow ~> => ((a, b) -> c) ~> (a -> b -> c)Source

Extract the first component of a pair input.

inpS :: DeepArrow ~> => ((a, b) -> c) ~> (b -> a -> c)Source

Extract the second component of a pair input.

inpFirst :: DeepArrow ~> => ((a -> c) ~> (d -> a' -> c)) -> ((a, b) -> c) ~> (d -> (a', b) -> c)Source

Given a way to extract a d input from an a input, leaving an a' residual input, inpFirst yields a way to extract a d input from an (a,b) input, leaving an (a',b) residual input.

inpSecond :: DeepArrow ~> => ((b -> c) ~> (d -> b' -> c)) -> ((a, b) -> c) ~> (d -> (a, b') -> c)Source

Analogous to inpFirst.

Misc functions

flipA :: DeepArrow ~> => (a -> c -> b) ~> (c -> a -> b)Source

Flip argument order

unzipA :: DeepArrow ~> => (a ~> (b, c)) -> (a ~> b, a ~> c)Source

Like unzip but for DeepArrow arrows instead of lists.

DeepArrow instance helper

class FunAble h => FunDble h whereSource

Support needed for a FunA to be a DeepArrow (as FunAble serves Arrow).

Methods

resultFun :: (h b -> h b') -> h (a -> b) -> h (a -> b')Source

dupAFun :: h a -> h (a, a)Source

fstAFun :: h (a, b) -> h aSource

sndAFun :: h (a, b) -> h bSource

funFFun :: h (c -> a, b) -> h (c -> (a, b))Source

funSFun :: h (a, c -> b) -> h (c -> (a, b))Source

funRFun :: h (a -> c -> b) -> h (c -> a -> b)Source

curryAFun :: h ((a, b) -> c) -> h (a -> b -> c)Source

uncurryAFun :: h (a -> b -> c) -> h ((a, b) -> c)Source

swapAFun :: h (a, b) -> h (b, a)Source

lAssocAFun :: h (a, (b, c)) -> h ((a, b), c)Source

rAssocAFun :: h ((a, b), c) -> h (a, (b, c))Source

Some utilities

(->|) :: (DeepArrow ~>, FunArr ~> w) => w (a -> b) -> w (b -> c) -> w (a -> c)Source

Compose wrapped functions