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 Cxprism k s t a b = forall p. Choice p => CoindexedOptic p k s t a b
- type Cxprism' k s a = Cxprism k s s a a
- prism :: (s -> t + a) -> (b -> t) -> Prism s t a b
- prism' :: (s -> Maybe a) -> (a -> s) -> Prism' s a
- kprism :: (s -> (k -> t) + a) -> (b -> t) -> Cxprism k s t a b
- handling :: (s -> c + a) -> ((c + b) -> t) -> Prism s t a b
- clonePrism :: APrism s t a b -> Prism s t a b
- kright :: (e -> k -> e + b) -> Cxprism k (e + a) (e + b) a b
- just :: Prism (Maybe a) (Maybe b) a b
- kjust :: (k -> Maybe b) -> Cxprism k (Maybe a) (Maybe b) a b
- nothing :: Prism (Maybe a) (Maybe b) () ()
- compared :: Eq a => Prd a => a -> Prism' a Ordering
- 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 ()
- sync :: Exception e => Prism' e e
- async :: Exception e => Prism' e e
- exception :: Exception e => Prism' SomeException e
- asyncException :: Exception e => Prism' SomeException e
- 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 #
Prisms access one piece of a sum.
\( \mathsf{Prism}\;S\;A = \exists D, S \cong D + A \)
type Cxprism k s t a b = forall p. Choice p => CoindexedOptic p k s t a b Source #
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
.
kprism :: (s -> (k -> t) + a) -> (b -> t) -> Cxprism k s t a b Source #
Obtain a Cxprism'
from a reviewer and a matcher function that returns either a match or a failure handler.
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
Optics
compared :: Eq a => Prd a => a -> Prism' a Ordering Source #
Focus on comparability to a given element of a partial order.
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.
exception :: Exception e => Prism' SomeException e Source #
Focus on whether a given exception has occurred.
asyncException :: Exception e => Prism' SomeException e Source #
Focus on whether a given asynchronous exception has occurred.
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