Control.Arrow.DeepArrow

"Deep arrows" as an Arrow subclass.

The DeepArrow class

class Arrow ar => DeepArrow ar where

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

    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 `ar` b') -> (a -> b) `ar` (a -> b')

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

dupA :: a `ar` (a, a)

Duplicate.

fstA :: (a, b) `ar` a

Extract first.

sndA :: (a, b) `ar` b

Extract second.

funF :: (c -> a, b) `ar` (c -> (a, b))

Extract function from first element.

funS :: (a, c -> b) `ar` (c -> (a, b))

Extract function from second element.

funR :: (a -> c -> b) `ar` (c -> a -> b)

Extract function from result.

curryA :: ((a, b) -> c) `ar` (a -> b -> c)

Curry arrow.

uncurryA :: (a -> b -> c) `ar` ((a, b) -> c)

Uncurry arrow.

swapA :: (a, b) `ar` (b, a)

Swap elements. Has default.

lAssocA :: (a, (b, c)) `ar` ((a, b), c)

Left-associate. Has default.

rAssocA :: ((a, b), c) `ar` (a, (b, c))

Right-associate. Has default.

Instances

DeepArrow (->)

DeepArrow DArrow

FunDble h => DeepArrow (FunA h)

(DeepArrow ar, DeepArrow ar') => DeepArrow (::*:: ar ar')

Composable function extractors

funFirst :: DeepArrow ar => (a `ar` (d -> a')) -> (a, b) `ar` (d -> (a', b))

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

funSecond :: DeepArrow ar => (b `ar` (d -> b')) -> (a, b) `ar` (d -> (a, b'))

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

funResult :: DeepArrow ar => (b `ar` (d -> b')) -> (a -> b) `ar` (d -> a -> b')

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

Composable input extractors

inpF :: DeepArrow ar => ((a, b) -> c) `ar` (a -> b -> c)

Extract the first component of a pair input.

inpS :: DeepArrow ar => ((a, b) -> c) `ar` (b -> a -> c)

Extract the second component of a pair input.

inpFirst :: DeepArrow ar => ((a -> c) `ar` (d -> a' -> c)) -> ((a, b) -> c) `ar` (d -> (a', b) -> c)

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 ar => ((b -> c) `ar` (d -> b' -> c)) -> ((a, b) -> c) `ar` (d -> (a, b') -> c)

Analogous to inpFirst.

Misc functions

flipA :: DeepArrow ar => (a -> c -> b) `ar` (c -> a -> b)

Flip argument order

unzipA :: DeepArrow ar => (a `ar` (b, c)) -> (a `ar` b, a `ar` c)

Like unzip but for DeepArrow arrows instead of lists.

DeepArrow instance helper

class FunAble h => FunDble h where

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')

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

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

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

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

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

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

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

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

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

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

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

Some utilities

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

Compose wrapped functions