Safe Haskell	None
Language	Haskell2010

Data.Profunctor.Optic.Combinator

Contents

Operations on (->) profunctors
Operations on arbitrary profunctors
Operations on (co)-strong profunctors
Operations on (co)-representable profunctors
Arrow-style combinators
Divisible-style combinators

Synopsis

type (+) = Either
(&) :: a -> (a -> b) -> b
rgt :: (a -> b) -> (a + b) -> b
rgt' :: (Void + b) -> b
lft :: (b -> a) -> (a + b) -> a
lft' :: (a + Void) -> a
swap :: (a, b) -> (b, a)
eswap :: (a1 + a2) -> a2 + a1
fork :: a -> (a, a)
join :: (a + a) -> a
eval :: (a, a -> b) -> b
apply :: (b -> a, b) -> a
branch :: (a -> Bool) -> b -> c -> a -> b + c
branch' :: (a -> Bool) -> a -> a + a
assocl :: (a, (b, c)) -> ((a, b), c)
assocr :: ((a, b), c) -> (a, (b, c))
assocl' :: (a, b + c) -> (a, b) + c
assocr' :: (a + b, c) -> a + (b, c)
eassocl :: (a + (b + c)) -> (a + b) + c
eassocr :: ((a + b) + c) -> a + (b + c)
forget1 :: ((c, a) -> (c, b)) -> a -> b
forget2 :: ((a, c) -> (b, c)) -> a -> b
forgetl :: ((c + a) -> c + b) -> a -> b
forgetr :: ((a + c) -> b + c) -> a -> b
constl :: Profunctor p => b -> p b c -> p a c
constr :: Profunctor p => c -> p a b -> p a c
shiftl :: Profunctor p => p (a + b) c -> p b (c + d)
shiftr :: Profunctor p => p b (c, d) -> p (a, b) c
coercel :: Profunctor p => CoerceL p => p a b -> p c b
coercer :: Profunctor p => CoerceR p => p a b -> p a c
strong :: Strong p => ((a, b) -> c) -> p a b -> p a c
costrong :: Costrong p => ((a, b) -> c) -> p c a -> p b a
choice :: Choice p => (c -> a + b) -> p b a -> p c a
cochoice :: Cochoice p => (c -> a + b) -> p a c -> p a b
pull :: Strong p => p a b -> p a (a, b)
peval :: Strong p => p a (a -> b) -> p a b
pushl :: Closed p => Traversing1 p => p a c -> p b c -> p a (b -> c)
pushr :: Closed p => Traversing1 p => p (a, b) c -> p a b -> p a c
star :: Applicative f => Star f a a
costar :: Coapplicative f => Costar f a a
unstar :: Coapplicative f => Star f a b -> a -> b
uncostar :: Applicative f => Costar f a b -> a -> b
sieve' :: Sieve p f => p d c -> Star f d c
cosieve' :: Cosieve p f => p a b -> Costar f a b
tabulate' :: Representable p => Star (Rep p) a b -> p a b
cotabulate' :: Corepresentable p => Costar (Corep p) a b -> p a b
repn :: Representable p => ((a -> Rep p b) -> s -> Rep p t) -> p a b -> p s t
corepn :: Corepresentable p => ((Corep p a -> b) -> Corep p s -> t) -> p a b -> p s t
pure' :: Traversing p => (a -> b) -> p a b
copure' :: Cotraversing p => (a -> b) -> p a b
pappend :: Traversing1 p => p a b -> p a b -> p a b
liftR2 :: Traversing1 p => (b -> c -> d) -> p a b -> p a c -> p a d
(<<*>>) :: Traversing1 p => p a (b -> c) -> p a b -> p a c
(****) :: Traversing1 p => p a1 b1 -> p a2 b2 -> p (a1, a2) (b1, b2)
(++++) :: Cotraversing1 p => p a1 b1 -> p a2 b2 -> p (a1 + a2) (b1 + b2)
(&&&&) :: Traversing1 p => p a b1 -> p a b2 -> p a (b1, b2)
(||||) :: Cotraversing1 p => p a1 b -> p a2 b -> p (a1 + a2) b
divide :: Traversing1 p => (a -> (a1, a2)) -> p a1 b -> p a2 b -> p a b
divide' :: Traversing1 p => p a1 b -> p a2 b -> p (a1, a2) b
codivide :: Cotraversing1 p => ((b1 + b2) -> b) -> p a b1 -> p a b2 -> p a b
codivide' :: Cotraversing1 p => p a b1 -> p a b2 -> p a (b1 + b2)
choose :: Cotraversing1 p => (a -> a1 + a2) -> p a1 b -> p a2 b -> p a b
choose' :: Cotraversing1 p => p a1 b -> p a2 b -> p (a1 + a2) b
cochoose :: Traversing1 p => ((b1, b2) -> b) -> p a b1 -> p a b2 -> p a b
cochoose' :: Traversing1 p => p a b1 -> p a b2 -> p a (b1, b2)

Documentation

type (+) = Either #

(&) :: a -> (a -> b) -> b infixl 1 #

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

>>> 5 & (+1) & show
"6"

Since: base-4.8.0.0

Operations on (->) profunctors

rgt :: (a -> b) -> (a + b) -> b #

rgt' :: (Void + b) -> b #

lft :: (b -> a) -> (a + b) -> a #

lft' :: (a + Void) -> a #

swap :: (a, b) -> (b, a) #

Swap the components of a pair.

eswap :: (a1 + a2) -> a2 + a1 #

fork :: a -> (a, a) #

join :: (a + a) -> a #

eval :: (a, a -> b) -> b #

apply :: (b -> a, b) -> a #

branch :: (a -> Bool) -> b -> c -> a -> b + c Source #

branch' :: (a -> Bool) -> a -> a + a Source #

assocl :: (a, (b, c)) -> ((a, b), c) Source #

assocr :: ((a, b), c) -> (a, (b, c)) Source #

assocl' :: (a, b + c) -> (a, b) + c Source #

assocr' :: (a + b, c) -> a + (b, c) Source #

eassocl :: (a + (b + c)) -> (a + b) + c Source #

eassocr :: ((a + b) + c) -> a + (b + c) Source #

forget1 :: ((c, a) -> (c, b)) -> a -> b Source #

forget2 :: ((a, c) -> (b, c)) -> a -> b Source #

forgetl :: ((c + a) -> c + b) -> a -> b Source #

forgetr :: ((a + c) -> b + c) -> a -> b Source #

Operations on arbitrary profunctors

constl :: Profunctor p => b -> p b c -> p a c Source #

constr :: Profunctor p => c -> p a b -> p a c Source #

shiftl :: Profunctor p => p (a + b) c -> p b (c + d) Source #

shiftr :: Profunctor p => p b (c, d) -> p (a, b) c Source #

coercel :: Profunctor p => CoerceL p => p a b -> p c b Source #

coercer :: Profunctor p => CoerceR p => p a b -> p a c Source #

Operations on (co)-strong profunctors

strong :: Strong p => ((a, b) -> c) -> p a b -> p a c Source #

costrong :: Costrong p => ((a, b) -> c) -> p c a -> p b a Source #

choice :: Choice p => (c -> a + b) -> p b a -> p c a Source #

cochoice :: Cochoice p => (c -> a + b) -> p a c -> p a b Source #

pull :: Strong p => p a b -> p a (a, b) Source #

peval :: Strong p => p a (a -> b) -> p a b Source #

pushl :: Closed p => Traversing1 p => p a c -> p b c -> p a (b -> c) Source #

pushr :: Closed p => Traversing1 p => p (a, b) c -> p a b -> p a c Source #

Operations on (co)-representable profunctors

star :: Applicative f => Star f a a Source #

costar :: Coapplicative f => Costar f a a Source #

unstar :: Coapplicative f => Star f a b -> a -> b Source #

uncostar :: Applicative f => Costar f a b -> a -> b Source #

sieve' :: Sieve p f => p d c -> Star f d c Source #

cosieve' :: Cosieve p f => p a b -> Costar f a b Source #

tabulate' :: Representable p => Star (Rep p) a b -> p a b Source #

cotabulate' :: Corepresentable p => Costar (Corep p) a b -> p a b Source #

repn :: Representable p => ((a -> Rep p b) -> s -> Rep p t) -> p a b -> p s t Source #

corepn :: Corepresentable p => ((Corep p a -> b) -> Corep p s -> t) -> p a b -> p s t Source #

pure' :: Traversing p => (a -> b) -> p a b Source #

copure' :: Cotraversing p => (a -> b) -> p a b Source #

pappend :: Traversing1 p => p a b -> p a b -> p a b Source #

liftR2 :: Traversing1 p => (b -> c -> d) -> p a b -> p a c -> p a d Source #

Arrow-style combinators

(<<*>>) :: Traversing1 p => p a (b -> c) -> p a b -> p a c infixl 4 Source #

Profunctor version of <*>.

(****) :: Traversing1 p => p a1 b1 -> p a2 b2 -> p (a1, a2) (b1, b2) infixr 3 Source #

Profunctor version of ***.

(++++) :: Cotraversing1 p => p a1 b1 -> p a2 b2 -> p (a1 + a2) (b1 + b2) infixr 2 Source #

Profunctor version of +++.

(&&&&) :: Traversing1 p => p a b1 -> p a b2 -> p a (b1, b2) infixr 3 Source #

Profunctor version of &&&.

(||||) :: Cotraversing1 p => p a1 b -> p a2 b -> p (a1 + a2) b infixr 2 Source #

Profunctor version of |||.

Divisible-style combinators

divide :: Traversing1 p => (a -> (a1, a2)) -> p a1 b -> p a2 b -> p a b Source #

Profunctor version of divide.

divide' :: Traversing1 p => p a1 b -> p a2 b -> p (a1, a2) b Source #

codivide :: Cotraversing1 p => ((b1 + b2) -> b) -> p a b1 -> p a b2 -> p a b Source #

codivide' :: Cotraversing1 p => p a b1 -> p a b2 -> p a (b1 + b2) Source #

choose :: Cotraversing1 p => (a -> a1 + a2) -> p a1 b -> p a2 b -> p a b Source #

Profunctor version of choose.

choose' :: Cotraversing1 p => p a1 b -> p a2 b -> p (a1 + a2) b Source #

cochoose :: Traversing1 p => ((b1, b2) -> b) -> p a b1 -> p a b2 -> p a b Source #

cochoose' :: Traversing1 p => p a b1 -> p a b2 -> p a (b1, b2) Source #