profunctor-optics-0.0.0.4: An optics library compatible with the typeclasses in 'profunctors'.

Safe HaskellNone
LanguageHaskell2010

Data.Profunctor.Optic.Prism

Contents

Synopsis

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 Prism' s a = Prism s s a a Source #

type Cxprism k s t a b = forall p. Choice p => CoindexedOptic p k s t a b Source #

type Cxprism' k s a = Cxprism k s s a a 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:

See Property.

prism' :: (s -> Maybe a) -> (a -> s) -> Prism' s a Source #

Obtain a Prism' from a reviewer and a matcher function that produces a Maybe.

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

kright :: (e -> k -> e + b) -> Cxprism k (e + a) (e + b) a b Source #

Coindexed prism into the Right constructor of Either.

>>> kset (catchFoo "Caught foo") id $ Left "fooError"
Right "Caught foo"
>>> kset (catchFoo "Caught foo") id $ Left "barError"
Left "barError"

just :: Prism (Maybe a) (Maybe b) a b Source #

Focus on the Just constructor of Maybe.

>>> Just 1 :| [Just 2, Just 3] & just //~ sum
Just 6
>>> Nothing :| [Just 2, Just 3] & just //~ sum
Just 5

kjust :: (k -> Maybe b) -> Cxprism k (Maybe a) (Maybe b) a b Source #

Coindexed prism into the Just constructor of Maybe.

>>> Just "foo" & catchOn 1 ##~ (\k msg -> show k ++ ": " ++ msg)
Just "0: foo"
>>> Nothing & catchOn 1 ##~ (\k msg -> show k ++ ": " ++ msg)
Nothing
>>> Nothing & catchOn 0 ##~ (\k msg -> show k ++ ": " ++ msg)
Just "caught"

nothing :: Prism (Maybe a) (Maybe b) () () Source #

Focus on the Nothing constructor of Maybe.

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.

nearly :: a -> (a -> Bool) -> Prism' a () Source #

Create a Prism from a value and a predicate.

>>> nearly [] null #^ ()
[]
>>> [1,2,3,4] ^? nearly [] null
Nothing
nearly [] null :: Prism' [a] ()

Caution: In order for the generated optic to be well-defined, you must ensure that f x holds iff x ≡ a.

nthbit :: Bits s => Int -> Prism' s () Source #

Focus on the truth value of the nth bit in a bit array.

sync :: Exception e => Prism' e e Source #

Focus on whether an exception is synchronous.

async :: Exception e => Prism' e e Source #

Focus on whether an exception is asynchronous.

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 #

Use a Prism to construct a PastroSum.

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.

Minimal complete definition

left' | right'

Methods

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 Leftlmap 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 Rightlmap 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
Instances
Monad m => Choice (Kleisli m) 
Instance details

Defined in Data.Profunctor.Choice

Methods

left' :: Kleisli m a b -> Kleisli m (Either a c) (Either b c) #

right' :: Kleisli m a b -> Kleisli m (Either c a) (Either c b) #

Choice (PastroSum p) 
Instance details

Defined in Data.Profunctor.Choice

Methods

left' :: PastroSum p a b -> PastroSum p (Either a c) (Either b c) #

right' :: PastroSum p a b -> PastroSum p (Either c a) (Either c b) #

Choice p => Choice (Coyoneda p) 
Instance details

Defined in Data.Profunctor.Yoneda

Methods

left' :: Coyoneda p a b -> Coyoneda p (Either a c) (Either b c) #

right' :: Coyoneda p a b -> Coyoneda p (Either c a) (Either c b) #

Choice p => Choice (Yoneda p) 
Instance details

Defined in Data.Profunctor.Yoneda

Methods

left' :: Yoneda p a b -> Yoneda p (Either a c) (Either b c) #

right' :: Yoneda p a b -> Yoneda p (Either c a) (Either c b) #

Profunctor p => Choice (TambaraSum p) 
Instance details

Defined in Data.Profunctor.Choice

Methods

left' :: TambaraSum p a b -> TambaraSum p (Either a c) (Either b c) #

right' :: TambaraSum p a b -> TambaraSum p (Either c a) (Either c b) #

Choice p => Choice (Tambara p) 
Instance details

Defined in Data.Profunctor.Choice

Methods

left' :: Tambara p a b -> Tambara p (Either a c) (Either b c) #

right' :: Tambara p a b -> Tambara p (Either c a) (Either c b) #

Applicative f => Choice (Star f) 
Instance details

Defined in Data.Profunctor.Choice

Methods

left' :: Star f a b -> Star f (Either a c) (Either b c) #

right' :: Star f a b -> Star f (Either c a) (Either c b) #

Coapplicative f => Choice (Costar f) Source # 
Instance details

Defined in Data.Profunctor.Optic.Types

Methods

left' :: Costar f a b -> Costar f (Either a c) (Either b c) #

right' :: Costar f a b -> Costar f (Either c a) (Either c b) #

ArrowChoice p => Choice (WrappedArrow p) 
Instance details

Defined in Data.Profunctor.Choice

Methods

left' :: WrappedArrow p a b -> WrappedArrow p (Either a c) (Either b c) #

right' :: WrappedArrow p a b -> WrappedArrow p (Either c a) (Either c b) #

Monoid r => Choice (Forget r) 
Instance details

Defined in Data.Profunctor.Choice

Methods

left' :: Forget r a b -> Forget r (Either a c) (Either b c) #

right' :: Forget r a b -> Forget r (Either c a) (Either c b) #

Choice (Tagged :: Type -> Type -> Type) 
Instance details

Defined in Data.Profunctor.Choice

Methods

left' :: Tagged a b -> Tagged (Either a c) (Either b c) #

right' :: Tagged a b -> Tagged (Either c a) (Either c b) #

Choice (Conjoin j) Source # 
Instance details

Defined in Data.Profunctor.Optic.Index

Methods

left' :: Conjoin j a b -> Conjoin j (Either a c) (Either b c) #

right' :: Conjoin j a b -> Conjoin j (Either c a) (Either c b) #

Choice (OptionRep r) Source # 
Instance details

Defined in Data.Profunctor.Optic.Carrier

Methods

left' :: OptionRep r a b -> OptionRep r (Either a c) (Either b c) #

right' :: OptionRep r a b -> OptionRep r (Either c a) (Either c b) #

Choice ((->) :: Type -> Type -> Type) 
Instance details

Defined in Data.Profunctor.Choice

Methods

left' :: (a -> b) -> Either a c -> Either b c #

right' :: (a -> b) -> Either c a -> Either c b #

Comonad w => Choice (Cokleisli w)

extract approximates costrength

Instance details

Defined in Data.Profunctor.Choice

Methods

left' :: Cokleisli w a b -> Cokleisli w (Either a c) (Either b c) #

right' :: Cokleisli w a b -> Cokleisli w (Either c a) (Either c b) #

Choice (GrismRep a b) Source # 
Instance details

Defined in Data.Profunctor.Optic.Carrier

Methods

left' :: GrismRep a b a0 b0 -> GrismRep a b (Either a0 c) (Either b0 c) #

right' :: GrismRep a b a0 b0 -> GrismRep a b (Either c a0) (Either c b0) #

Choice (AffineRep a b) Source # 
Instance details

Defined in Data.Profunctor.Optic.Carrier

Methods

left' :: AffineRep a b a0 b0 -> AffineRep a b (Either a0 c) (Either b0 c) #

right' :: AffineRep a b a0 b0 -> AffineRep a b (Either c a0) (Either c b0) #

Choice (PrismRep a b) Source # 
Instance details

Defined in Data.Profunctor.Optic.Carrier

Methods

left' :: PrismRep a b a0 b0 -> PrismRep a b (Either a0 c) (Either b0 c) #

right' :: PrismRep a b a0 b0 -> PrismRep a b (Either c a0) (Either c b0) #

Functor f => Choice (Joker f :: Type -> Type -> Type) 
Instance details

Defined in Data.Profunctor.Choice

Methods

left' :: Joker f a b -> Joker f (Either a c) (Either b c) #

right' :: Joker f a b -> Joker f (Either c a) (Either c b) #

Cochoice p => Choice (Re p s t) Source # 
Instance details

Defined in Data.Profunctor.Optic.Types

Methods

left' :: Re p s t a b -> Re p s t (Either a c) (Either b c) #

right' :: Re p s t a b -> Re p s t (Either c a) (Either c b) #

(Choice p, Choice q) => Choice (Sum p q) 
Instance details

Defined in Data.Profunctor.Choice

Methods

left' :: Sum p q a b -> Sum p q (Either a c) (Either b c) #

right' :: Sum p q a b -> Sum p q (Either c a) (Either c b) #

(Choice p, Choice q) => Choice (Product p q) 
Instance details

Defined in Data.Profunctor.Choice

Methods

left' :: Product p q a b -> Product p q (Either a c) (Either b c) #

right' :: Product p q a b -> Product p q (Either c a) (Either c b) #

(Functor f, Choice p) => Choice (Tannen f p) 
Instance details

Defined in Data.Profunctor.Choice

Methods

left' :: Tannen f p a b -> Tannen f p (Either a c) (Either b c) #

right' :: Tannen f p a b -> Tannen f p (Either c a) (Either c b) #