Control.Arrow.DeepArrow

"Deep arrows" as an Arrow subclass.

The DeepArrow class

class Arrow ~> => DeepArrow (~>) 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

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

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

idA :: a ~> a

Identity.

dupA :: a ~> (a, a)

Duplicate.

fstA :: (a, b) ~> a

Extract first.

sndA :: (a, b) ~> b

Extract second.

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

Extract function from first element.

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

Extract function from second element.

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

Extract function from result.

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

Curry arrow.

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

Uncurry arrow.

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

Swap elements. Has default.

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

Left-associate. Has default.

rAssocA :: ((a, b), c) ~> (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 ~> => (a ~> (d -> a')) -> (a, b) ~> (d -> (a', b))

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

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

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)

Extract the first component of a pair input.

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

Extract the second component of a pair input.

inpFirst :: DeepArrow ~> => ((a -> c) ~> (d -> a' -> c)) -> ((a, b) -> c) ~> (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 ~> => ((b -> c) ~> (d -> b' -> c)) -> ((a, b) -> c) ~> (d -> (a, b') -> c)

Analogous to inpFirst.

Misc functions

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

Flip argument order

unzipA :: DeepArrow ~> => (a ~> (b, c)) -> (a ~> b, a ~> 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 ~>, FunArr ~> w) => w (a -> b) -> w (b -> c) -> w (a -> c)

Compose wrapped functions