Safe Haskell | None |
---|---|
Language | Haskell2010 |
Synopsis
- type Prism s t a b = forall p. Choice p => Optic p s t a b
- type Prism' s a = Prism s s a a
- type Coprism s t a b = forall p. Cochoice p => Optic p s t a b
- type Coprism' t b = Coprism t t b b
- prism :: (s -> t + a) -> (b -> t) -> Prism s t a b
- prism' :: (s -> Maybe a) -> (a -> s) -> Prism' s a
- handling :: (s -> c + a) -> ((c + b) -> t) -> Prism s t a b
- clonePrism :: APrism s t a b -> Prism s t a b
- coprism :: (s -> a) -> (b -> a + t) -> Coprism s t a b
- coprism' :: (s -> a) -> (a -> Maybe s) -> Coprism' s a
- rehandling :: ((c + s) -> a) -> (b -> c + t) -> Coprism s t a b
- cloneCoprism :: ACoprism s t a b -> Coprism s t a b
- just :: Prism (Maybe a) (Maybe b) a b
- cojust :: Coprism a b (Maybe a) (Maybe b)
- nothing :: Prism (Maybe a) (Maybe b) () ()
- prefixed :: Eq a => [a] -> Prism' [a] [a]
- only :: Eq a => a -> Prism' a ()
- nearly :: a -> (a -> Bool) -> Prism' a ()
- nthbit :: Bits s => Int -> Prism' s ()
- withPrism :: APrism s t a b -> ((s -> t + a) -> (b -> t) -> r) -> r
- aside :: APrism s t a b -> Prism (e, s) (e, t) (e, a) (e, b)
- without :: APrism s t a b -> APrism u v c d -> Prism (s + u) (t + v) (a + c) (b + d)
- below :: Traversable f => APrism' s a -> Prism' (f s) (f a)
- toPastroSum :: APrism s t a b -> p a b -> PastroSum p s t
- toTambaraSum :: Choice p => APrism s t a b -> p a b -> TambaraSum p s t
- class Profunctor p => Choice (p :: Type -> Type -> Type) where
Prism & Cxprism
type Prism s t a b = forall p. Choice p => Optic p s t a b Source #
\( \mathsf{Prism}\;S\;A = \exists D, S \cong D + A \)
type Coprism s t a b = forall p. Cochoice p => Optic p s t a b Source #
\( \mathsf{Prism}\;S\;A = \exists D, S + D \cong A \)
prism :: (s -> t + a) -> (b -> t) -> Prism s t a b Source #
Obtain a Prism
from a constructor and a matcher function.
Caution: In order for the generated optic to be well-defined, you must ensure that the input functions satisfy the following properties:
sta (bt b) ≡ Right b
(id ||| bt) (sta s) ≡ s
left sta (sta s) ≡ left Left (sta s)
More generally, a profunctor optic must be monoidal as a natural transformation:
o id ≡ id
o (
Procompose
p q) ≡Procompose
(o p) (o q)
See Property
.
handling :: (s -> c + a) -> ((c + b) -> t) -> Prism s t a b Source #
Obtain a Prism
from its free tensor representation.
Useful for constructing prisms from try and handle functions.
clonePrism :: APrism s t a b -> Prism s t a b Source #
TODO: Document
coprism :: (s -> a) -> (b -> a + t) -> Coprism s t a b Source #
Obtain a Cochoice
optic from a constructor and a matcher function.
coprism f g ≡ f g -> re (prism f g)
Caution: In order for the generated optic to be well-defined, you must ensure that the input functions satisfy the following properties:
bat (bt b) ≡ Right b
(id ||| bt) (bat b) ≡ b
left bat (bat b) ≡ left Left (bat b)
A Coprism
is a View
, so you can specialise types to obtain:
view :: Coprism'
s a -> s -> a
rehandling :: ((c + s) -> a) -> (b -> c + t) -> Coprism s t a b Source #
Obtain a Coprism
from its free tensor representation.
cloneCoprism :: ACoprism s t a b -> Coprism s t a b Source #
TODO: Document
Optics
prefixed :: Eq a => [a] -> Prism' [a] [a] Source #
Focus on the remainder of a list with a given prefix.
only :: Eq a => a -> Prism' a () Source #
Focus not just on a case, but a specific value of that case.
nthbit :: Bits s => Int -> Prism' s () Source #
Focus on the truth value of the nth bit in a bit array.
Primitive operators
withPrism :: APrism s t a b -> ((s -> t + a) -> (b -> t) -> r) -> r Source #
Extract the two functions that characterize a Prism
.
Operators
aside :: APrism s t a b -> Prism (e, s) (e, t) (e, a) (e, b) Source #
Use a Prism
to lift part of a structure.
without :: APrism s t a b -> APrism u v c d -> Prism (s + u) (t + v) (a + c) (b + d) Source #
Given a pair of prisms, project sums.
below :: Traversable f => APrism' s a -> Prism' (f s) (f a) Source #
Lift a Prism
through a Traversable
functor.
Returns a Prism
that matches only if each element matches the original Prism
.
>>>
[Left 1, Right "foo", Left 4, Right "woot"] ^.. below right'
[]>>>
[Right "hail hydra!", Right "foo", Right "blah", Right "woot"] ^.. below right'
[["hail hydra!","foo","blah","woot"]]
toPastroSum :: APrism s t a b -> p a b -> PastroSum p s t Source #
toTambaraSum :: Choice p => APrism s t a b -> p a b -> TambaraSum p s t Source #
Use a Prism
to construct a TambaraSum
.
Classes
class Profunctor p => Choice (p :: Type -> Type -> Type) where #
The generalization of Costar
of Functor
that is strong with respect
to Either
.
Note: This is also a notion of strength, except with regards to another monoidal structure that we can choose to equip Hask with: the cocartesian coproduct.
left' :: p a b -> p (Either a c) (Either b c) #
Laws:
left'
≡dimap
swapE swapE.
right'
where swapE ::Either
a b ->Either
b a swapE =either
Right
Left
rmap
Left
≡lmap
Left
.
left'
lmap
(right
f).
left'
≡rmap
(right
f).
left'
left'
.
left'
≡dimap
assocE unassocE.
left'
where assocE ::Either
(Either
a b) c ->Either
a (Either
b c) assocE (Left
(Left
a)) =Left
a assocE (Left
(Right
b)) =Right
(Left
b) assocE (Right
c) =Right
(Right
c) unassocE ::Either
a (Either
b c) ->Either
(Either
a b) c unassocE (Left
a) =Left
(Left
a) unassocE (Right
(Left
b)) =Left
(Right
b) unassocE (Right
(Right
c)) =Right
c
right' :: p a b -> p (Either c a) (Either c b) #
Laws:
right'
≡dimap
swapE swapE.
left'
where swapE ::Either
a b ->Either
b a swapE =either
Right
Left
rmap
Right
≡lmap
Right
.
right'
lmap
(left
f).
right'
≡rmap
(left
f).
right'
right'
.
right'
≡dimap
unassocE assocE.
right'
where assocE ::Either
(Either
a b) c ->Either
a (Either
b c) assocE (Left
(Left
a)) =Left
a assocE (Left
(Right
b)) =Right
(Left
b) assocE (Right
c) =Right
(Right
c) unassocE ::Either
a (Either
b c) ->Either
(Either
a b) c unassocE (Left
a) =Left
(Left
a) unassocE (Right
(Left
b)) =Left
(Right
b) unassocE (Right
(Right
c)) =Right
c