
Control.Arrow.DeepArrow  Portability  portable  Stability  experimental  Maintainer  conal@conal.net 





Description 
"Deep arrows" as an Arrow subclass.


Synopsis 

class Arrow ~> => DeepArrow (~>) where  result :: (b ~> b') > (a > b) ~> (a > b')  idA :: a ~> a  dupA :: a ~> (a, a)  fstA :: (a, b) ~> a  sndA :: (a, b) ~> b  funF :: (c > a, b) ~> (c > (a, b))  funS :: (a, c > b) ~> (c > (a, b))  funR :: (a > c > b) ~> (c > a > b)  curryA :: ((a, b) > c) ~> (a > b > c)  uncurryA :: (a > b > c) ~> ((a, b) > c)  swapA :: (a, b) ~> (b, a)  lAssocA :: (a, (b, c)) ~> ((a, b), c)  rAssocA :: ((a, b), c) ~> (a, (b, c)) 
  funFirst :: DeepArrow ~> => (a ~> (d > a')) > (a, b) ~> (d > (a', b))   funSecond :: DeepArrow ~> => (b ~> (d > b')) > (a, b) ~> (d > (a, b'))   funResult :: DeepArrow ~> => (b ~> (d > b')) > (a > b) ~> (d > a > b')   inpF :: DeepArrow ~> => ((a, b) > c) ~> (a > b > c)   inpS :: DeepArrow ~> => ((a, b) > c) ~> (b > a > c)   inpFirst :: DeepArrow ~> => ((a > c) ~> (d > a' > c)) > ((a, b) > c) ~> (d > (a', b) > c)   inpSecond :: DeepArrow ~> => ((b > c) ~> (d > b' > c)) > ((a, b) > c) ~> (d > (a, b') > c)   flipA :: DeepArrow ~> => (a > c > b) ~> (c > a > b)   unzipA :: DeepArrow ~> => (a ~> (b, c)) > (a ~> b, a ~> c)   class FunAble h => FunDble h where  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)) 
  (>) :: (DeepArrow ~>, FunArr ~> w) => w (a > b) > w (b > c) > w (a > c) 



The DeepArrow class



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
pingponging 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.
   Identity.
   Duplicate.
   Extract first.
   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 
 Leftassociate. Has default.
  rAssocA :: ((a, b), c) ~> (a, (b, c))  Source 
 Rightassociate. 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



Extract the first component of a pair input.



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



Flip argument order



Like unzip but for DeepArrow arrows instead of lists.


DeepArrow instance helper



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 a  Source 
  sndAFun :: h (a, b) > h b  Source 
  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



Compose wrapped functions


Produced by Haddock version 2.3.0 