-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Please see the README on GitHub at
--   <a>https://github.com/ChrisPenner/proton#readme</a>
@package proton
@version 0.0.2

module Data.Market

-- | The <a>Market</a> profunctor characterizes a <tt>Prism</tt>.
data Market a b s t
Market :: (b -> t) -> (s -> Either t a) -> Market a b s t
instance GHC.Base.Functor (Data.Market.Market a b s)
instance Data.Profunctor.Unsafe.Profunctor (Data.Market.Market a b)
instance Data.Profunctor.Choice.Choice (Data.Market.Market a b)

module Data.Pair
data Pair a
Pair :: a -> a -> Pair a
paired :: Profunctor p => p (Pair a) (Pair b) -> p (a, a) (b, b)
liftPair :: (a -> a -> b) -> Pair a -> b
instance GHC.Base.Functor Data.Pair.Pair
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Pair.Pair a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Pair.Pair a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Pair.Pair a)
instance GHC.Base.Applicative Data.Pair.Pair
instance Data.Distributive.Distributive Data.Pair.Pair
instance Data.Functor.Rep.Representable Data.Pair.Pair

module Data.Profunctor.Absorbent
class Profunctor p => Absorbent m p | p -> m
absorb :: Absorbent m p => p a (m b) -> p a b
instance Data.Profunctor.Absorbent.Absorbent Data.Functor.Identity.Identity (->)
instance GHC.Base.Monad m => Data.Profunctor.Absorbent.Absorbent m (Data.Profunctor.Types.Star m)
instance Data.Profunctor.Absorbent.Absorbent m (Data.Profunctor.Types.Forget (m r))

module Data.Profunctor.Annotated
class (Profunctor p, Profunctor q) => Annotatable e p q | q -> p
coindexed :: Annotatable e p q => p a (e, b) -> q a b
coindexed :: (Annotatable e p q, p ~ q) => p a (e, b) -> q a b
data Annotated e p a b
Annotated :: p a (e, b) -> Annotated e p a b
[runCoindexed] :: Annotated e p a b -> p a (e, b)
instance Data.Profunctor.Unsafe.Profunctor p => Data.Profunctor.Unsafe.Profunctor (Data.Profunctor.Annotated.Annotated e p)
instance Data.Profunctor.Strong.Strong p => Data.Profunctor.Strong.Strong (Data.Profunctor.Annotated.Annotated i p)
instance Data.Profunctor.Unsafe.Profunctor p => Data.Profunctor.Annotated.Annotatable i p (Data.Profunctor.Annotated.Annotated i p)
instance Data.Profunctor.Annotated.Annotatable e (Data.Profunctor.Types.Forget r) (Data.Profunctor.Types.Forget r)
instance Data.Profunctor.Annotated.Annotatable e (->) (->)
instance GHC.Base.Functor f => Data.Profunctor.Annotated.Annotatable e (Data.Profunctor.Types.Star f) (Data.Profunctor.Types.Star f)
instance GHC.Base.Functor f => Data.Profunctor.Annotated.Annotatable e (Data.Profunctor.Types.Costar f) (Data.Profunctor.Types.Costar f)
instance Data.Profunctor.Annotated.Annotatable e Data.Tagged.Tagged Data.Tagged.Tagged

module Data.Profunctor.Arrow
arr :: (Profunctor p, Category p) => (a -> b) -> p a b

-- | Split the input between the two argument profunctors and combine their
--   output.
(***) :: (Category p, Strong p) => p b c -> p b' c' -> p (b, b') (c, c')

-- | Fanout: send the input to both argument arrows and combine their
--   output.
(&&&) :: (Category p, Strong p) => p b c -> p b c' -> p b (c, c')

-- | Precomposition with a pure function.
(^>>) :: (Profunctor p, Category p) => (b -> c) -> p c d -> p b d

-- | Postcomposition with a pure function.
(>>^) :: (Profunctor p, Category p) => p b c -> (c -> d) -> p b d

-- | Precomposition with a pure function (right-to-left variant).
(<<^) :: (Profunctor p, Category p) => p c d -> (b -> c) -> p b d

-- | Postcomposition with a pure function (right-to-left variant).
(^<<) :: (Profunctor p, Category p) => (c -> d) -> p b c -> p b d
(+++) :: (Choice p, Category p) => p b c -> p b' c' -> p (Either b b') (Either c c')
(|||) :: (Choice p, Category p) => p b d -> p c d -> p (Either b c) d
class Profunctor p => ProfunctorZero p
zeroProfunctor :: ProfunctorZero p => p a b
class ProfunctorZero p => ProfunctorPlus p
(<+>) :: ProfunctorPlus p => p a b -> p a b -> p a b
class Profunctor p => ProfunctorApply p
app :: ProfunctorApply p => p (p a b, a) b
instance GHC.Base.Functor f => Data.Profunctor.Arrow.ProfunctorApply (Data.Profunctor.Types.Star f)
instance Data.Profunctor.Arrow.ProfunctorApply (->)
instance GHC.Base.Monad m => Data.Profunctor.Arrow.ProfunctorApply (Control.Arrow.Kleisli m)
instance Data.Profunctor.Arrow.ProfunctorApply (Data.Profunctor.Types.Forget r)
instance (Control.Arrow.Arrow p, Control.Arrow.ArrowApply p) => Data.Profunctor.Arrow.ProfunctorApply (Data.Profunctor.Types.WrappedArrow p)
instance GHC.Base.Alternative g => Data.Profunctor.Arrow.ProfunctorApply (Data.Bifunctor.Joker.Joker g)
instance GHC.Base.Alternative f => Data.Profunctor.Arrow.ProfunctorPlus (Data.Profunctor.Types.Star f)
instance (GHC.Base.Monad m, GHC.Base.Alternative m) => Data.Profunctor.Arrow.ProfunctorPlus (Control.Arrow.Kleisli m)
instance GHC.Base.Monoid r => Data.Profunctor.Arrow.ProfunctorPlus (Data.Profunctor.Types.Forget r)
instance (GHC.Base.Applicative f, Data.Profunctor.Arrow.ProfunctorPlus p) => Data.Profunctor.Arrow.ProfunctorPlus (Data.Profunctor.Cayley.Cayley f p)
instance (GHC.Base.Applicative f, Data.Profunctor.Arrow.ProfunctorPlus p) => Data.Profunctor.Arrow.ProfunctorPlus (Data.Bifunctor.Tannen.Tannen f p)
instance Data.Profunctor.Arrow.ProfunctorPlus p => Data.Profunctor.Arrow.ProfunctorPlus (Data.Profunctor.Strong.Tambara p)
instance Data.Profunctor.Arrow.ProfunctorPlus p => Data.Profunctor.Arrow.ProfunctorPlus (Data.Profunctor.Closed.Closure p)
instance Data.Profunctor.Arrow.ProfunctorPlus p => Data.Profunctor.Arrow.ProfunctorPlus (Data.Profunctor.Choice.TambaraSum p)
instance Data.Profunctor.Arrow.ProfunctorPlus p => Data.Profunctor.Arrow.ProfunctorPlus (Data.Profunctor.Traversing.CofreeTraversing p)
instance Data.Profunctor.Arrow.ProfunctorPlus p => Data.Profunctor.Arrow.ProfunctorPlus (Data.Profunctor.Mapping.CofreeMapping p)
instance GHC.Base.Alternative f => Data.Profunctor.Arrow.ProfunctorPlus (Data.Bifunctor.Joker.Joker f)
instance Control.Arrow.ArrowPlus p => Data.Profunctor.Arrow.ProfunctorPlus (Data.Profunctor.Types.WrappedArrow p)
instance Data.Profunctor.Arrow.ProfunctorPlus p => Data.Profunctor.Arrow.ProfunctorPlus (Data.Profunctor.Ran.Codensity p)
instance (Data.Profunctor.Arrow.ProfunctorPlus p, Data.Profunctor.Arrow.ProfunctorPlus q) => Data.Profunctor.Arrow.ProfunctorPlus (Data.Bifunctor.Product.Product p q)
instance (Data.Profunctor.Unsafe.Profunctor p, Data.Profunctor.Arrow.ProfunctorPlus q) => Data.Profunctor.Arrow.ProfunctorPlus (Data.Profunctor.Composition.Rift p q)
instance (Data.Profunctor.Arrow.ProfunctorPlus p, GHC.Base.Functor f, GHC.Base.Functor g) => Data.Profunctor.Arrow.ProfunctorPlus (Data.Bifunctor.Biff.Biff p f g)
instance GHC.Base.Alternative f => Data.Profunctor.Arrow.ProfunctorZero (Data.Profunctor.Types.Star f)
instance (GHC.Base.Monad m, GHC.Base.Alternative m) => Data.Profunctor.Arrow.ProfunctorZero (Control.Arrow.Kleisli m)
instance GHC.Base.Monoid r => Data.Profunctor.Arrow.ProfunctorZero (Data.Profunctor.Types.Forget r)
instance (GHC.Base.Applicative f, Data.Profunctor.Arrow.ProfunctorZero p) => Data.Profunctor.Arrow.ProfunctorZero (Data.Profunctor.Cayley.Cayley f p)
instance (GHC.Base.Applicative f, Data.Profunctor.Arrow.ProfunctorZero p) => Data.Profunctor.Arrow.ProfunctorZero (Data.Bifunctor.Tannen.Tannen f p)
instance Data.Profunctor.Arrow.ProfunctorZero p => Data.Profunctor.Arrow.ProfunctorZero (Data.Profunctor.Strong.Tambara p)
instance Data.Profunctor.Arrow.ProfunctorZero p => Data.Profunctor.Arrow.ProfunctorZero (Data.Profunctor.Closed.Closure p)
instance Data.Profunctor.Arrow.ProfunctorZero p => Data.Profunctor.Arrow.ProfunctorZero (Data.Profunctor.Choice.TambaraSum p)
instance Data.Profunctor.Arrow.ProfunctorZero p => Data.Profunctor.Arrow.ProfunctorZero (Data.Profunctor.Traversing.CofreeTraversing p)
instance Data.Profunctor.Arrow.ProfunctorZero p => Data.Profunctor.Arrow.ProfunctorZero (Data.Profunctor.Mapping.CofreeMapping p)
instance Data.Profunctor.Arrow.ProfunctorZero p => Data.Profunctor.Arrow.ProfunctorZero (Data.Profunctor.Yoneda.Yoneda p)
instance GHC.Base.Alternative f => Data.Profunctor.Arrow.ProfunctorZero (Data.Bifunctor.Joker.Joker f)
instance Control.Arrow.ArrowZero p => Data.Profunctor.Arrow.ProfunctorZero (Data.Profunctor.Types.WrappedArrow p)
instance Data.Profunctor.Arrow.ProfunctorZero p => Data.Profunctor.Arrow.ProfunctorZero (Data.Profunctor.Ran.Codensity p)
instance (Data.Profunctor.Arrow.ProfunctorZero p, Data.Profunctor.Arrow.ProfunctorZero q) => Data.Profunctor.Arrow.ProfunctorZero (Data.Bifunctor.Product.Product p q)
instance (Data.Profunctor.Unsafe.Profunctor p, Data.Profunctor.Arrow.ProfunctorZero q) => Data.Profunctor.Arrow.ProfunctorZero (Data.Profunctor.Composition.Rift p q)
instance (Data.Profunctor.Arrow.ProfunctorZero p, GHC.Base.Functor f, GHC.Base.Functor g) => Data.Profunctor.Arrow.ProfunctorZero (Data.Bifunctor.Biff.Biff p f g)

module Control.Arrow.Profunctor
newtype WrappedProfunctor p a b
WrappedProfunctor :: p a b -> WrappedProfunctor p a b
[unwrapProfunctor] :: WrappedProfunctor p a b -> p a b
instance Control.Category.Category p => Control.Category.Category (Control.Arrow.Profunctor.WrappedProfunctor p)
instance (Data.Profunctor.Unsafe.Profunctor p, Control.Category.Category p, Data.Profunctor.Strong.Strong p) => Control.Arrow.Arrow (Control.Arrow.Profunctor.WrappedProfunctor p)
instance (Data.Profunctor.Arrow.ProfunctorZero p, Control.Category.Category p, Data.Profunctor.Strong.Strong p) => Control.Arrow.ArrowZero (Control.Arrow.Profunctor.WrappedProfunctor p)
instance (Data.Profunctor.Arrow.ProfunctorPlus p, Control.Category.Category p, Data.Profunctor.Strong.Strong p) => Control.Arrow.ArrowPlus (Control.Arrow.Profunctor.WrappedProfunctor p)
instance (Data.Profunctor.Choice.Choice p, Control.Category.Category p, Data.Profunctor.Strong.Strong p) => Control.Arrow.ArrowChoice (Control.Arrow.Profunctor.WrappedProfunctor p)
instance (Control.Category.Category p, Data.Profunctor.Strong.Strong p, Data.Profunctor.Arrow.ProfunctorApply p) => Control.Arrow.ArrowApply (Control.Arrow.Profunctor.WrappedProfunctor p)
instance (Control.Category.Category p, Data.Profunctor.Strong.Strong p, Data.Profunctor.Strong.Costrong p) => Control.Arrow.ArrowLoop (Control.Arrow.Profunctor.WrappedProfunctor p)

module Data.Profunctor.Coindexed
class (Profunctor p, Profunctor q) => Coindexable e p q | q -> p
coindexed :: Coindexable e p q => p a (Either e b) -> q a b
coindexed :: (Coindexable e p q, e ~ Void, p ~ q) => p a (Either e b) -> q a b
data Coindexed e p a b
Coindexed :: p a (Either e b) -> Coindexed e p a b
[runCoindexed] :: Coindexed e p a b -> p a (Either e b)
instance Data.Profunctor.Unsafe.Profunctor p => Data.Profunctor.Unsafe.Profunctor (Data.Profunctor.Coindexed.Coindexed e p)
instance Data.Profunctor.Choice.Choice p => Data.Profunctor.Choice.Choice (Data.Profunctor.Coindexed.Coindexed i p)
instance Data.Profunctor.Unsafe.Profunctor p => Data.Profunctor.Coindexed.Coindexable i p (Data.Profunctor.Coindexed.Coindexed i p)
instance Data.Profunctor.Coindexed.Coindexable e (Data.Profunctor.Types.Forget r) (Data.Profunctor.Types.Forget r)
instance Data.Profunctor.Coindexed.Coindexable Data.Void.Void (->) (->)
instance GHC.Base.Functor f => Data.Profunctor.Coindexed.Coindexable Data.Void.Void (Data.Profunctor.Types.Star f) (Data.Profunctor.Types.Star f)
instance (GHC.Base.Alternative f, GHC.Base.Monad f) => Data.Profunctor.Coindexed.Coindexable e (Data.Profunctor.Types.Star f) (Data.Profunctor.Types.Star f)
instance GHC.Base.Functor f => Data.Profunctor.Coindexed.Coindexable Data.Void.Void (Data.Profunctor.Types.Costar f) (Data.Profunctor.Types.Costar f)
instance Data.Profunctor.Coindexed.Coindexable Data.Void.Void Data.Tagged.Tagged Data.Tagged.Tagged

module Data.Profunctor.Cont
helper :: (a -> Bool) -> [a] -> ContT r f (Maybe a)
helper' :: (Monad m, Monoid r) => (a -> Bool) -> [a] -> ContT r m a
helper'' :: (Monad m, Monoid r) => (r -> Bool) -> [r] -> ContT r m r
stopWhen :: (Representable p, Rep p ~ f) => p (Maybe Int) r -> p [Int] r
stopWhen' :: (Monoid r, Monad m, Representable p, Rep p ~ m) => p Int r -> p [Int] r
stopWhen'' :: (Monad m, Representable p, Rep p ~ m) => p [a] [a] -> p [[a]] [a]
withCapture :: (Representable p, Rep p ~ f) => (s -> ContT r f a) -> p a r -> p s r
tester :: [[Int]] -> IO [Int]

module Data.Profunctor.Depending
class Traversing p => Depending p
depend :: Depending p => (forall f. Monad f => (a -> f b) -> s -> f t) -> p a b -> p s t
instance GHC.Base.Monad f => Data.Profunctor.Depending.Depending (Data.Profunctor.Types.Star f)

module Data.Profunctor.Distributing
distribute' :: (Closed p, Representable g) => p a b -> p (g a) (g b)

module Data.Profunctor.Expanding
class Profunctor p => Expanding p
expand :: (Expanding p, Comonad w) => p (w a) b -> p a (w b)

module Data.Profunctor.Expansive
class Expansive p
expand :: (Expansive p, Foldable f) => p a b -> p (f a) b
instance GHC.Base.Alternative f => Data.Profunctor.Expansive.Expansive (Data.Profunctor.Types.Star f)
instance GHC.Base.Monoid r => Data.Profunctor.Expansive.Expansive (Data.Profunctor.Types.Forget r)
instance Data.Profunctor.Expansive.Expansive Data.Tagged.Tagged
instance (GHC.Base.Functor f, Data.Profunctor.Expansive.Expansive p) => Data.Profunctor.Expansive.Expansive (Data.Profunctor.Cayley.Cayley f p)

module Data.Profunctor.Extraction
class Profunctor p => Extraction p
extractions :: (Extraction p, Comonad w) => p (w a) b -> p (w a) (w b)
act :: (Star f a b -> Star f s t) -> (a -> f b) -> s -> f t
t :: NonEmpty a -> Pair (Maybe a)
u :: NonEmpty Int -> Pair Int
home :: Int -> Store Int Int -> Either Int Int
looper :: NonEmpty Int -> Either [Int] Int
coiterate :: forall w a b. (Traversable w, Comonad w) => (w a -> Either b a) -> w a -> w b
instance Data.Profunctor.Extraction.Extraction (Data.Profunctor.Types.Forget r)
instance Data.Profunctor.Extraction.Extraction (->)
instance Data.Distributive.Distributive f => Data.Profunctor.Extraction.Extraction (Data.Profunctor.Types.Star f)

module Data.Profunctor.Extras
join' :: (Sieve p f, Strong p) => p a (p a b) -> p a (f b)
join'' :: (Representable p, Strong p, Monad (Rep p)) => p a (p a b) -> p a b
absorb :: (Representable p, m ~ Rep p, Monad m) => p a (m b) -> p a b
newtype Dub p f a b
Dub :: p (f a) (f b) -> Dub p f a b
instance (Data.Profunctor.Unsafe.Profunctor p, GHC.Base.Functor f) => Data.Profunctor.Unsafe.Profunctor (Data.Profunctor.Extras.Dub p f)

module Data.Profunctor.Fold

module Data.Profunctor.FoldM
data FoldM m a b
FoldM :: (x -> a -> m x) -> m x -> (x -> m b) -> FoldM m a b
instance GHC.Base.Functor m => Data.Profunctor.Unsafe.Profunctor (Data.Profunctor.FoldM.FoldM m)

module Data.Profunctor.Indexed
class (Profunctor p, Profunctor q) => Indexable i p q | p -> q
indexed :: Indexable i p q => p a b -> q (i, a) b
indexed :: (Indexable i p q, p ~ q) => p a b -> q (i, a) b
data Indexed i p a b
Indexed :: p (i, a) b -> Indexed i p a b
newtype UnIndexed i p a b
UnIndexed :: p a b -> UnIndexed i p a b
instance Data.Profunctor.Strong.Costrong p => Data.Profunctor.Strong.Costrong (Data.Profunctor.Indexed.UnIndexed i p)
instance Data.Profunctor.Choice.Cochoice p => Data.Profunctor.Choice.Cochoice (Data.Profunctor.Indexed.UnIndexed i p)
instance Data.Profunctor.Traversing.Traversing p => Data.Profunctor.Traversing.Traversing (Data.Profunctor.Indexed.UnIndexed i p)
instance Data.Profunctor.Choice.Choice p => Data.Profunctor.Choice.Choice (Data.Profunctor.Indexed.UnIndexed i p)
instance Data.Profunctor.Strong.Strong p => Data.Profunctor.Strong.Strong (Data.Profunctor.Indexed.UnIndexed i p)
instance Data.Profunctor.Closed.Closed p => Data.Profunctor.Closed.Closed (Data.Profunctor.Indexed.UnIndexed i p)
instance Data.Profunctor.Unsafe.Profunctor p => Data.Profunctor.Unsafe.Profunctor (Data.Profunctor.Indexed.UnIndexed i p)
instance Data.Profunctor.Unsafe.Profunctor p => Data.Profunctor.Indexed.Indexable i (Data.Profunctor.Indexed.UnIndexed i p) p
instance Data.Profunctor.Unsafe.Profunctor p => Data.Profunctor.Unsafe.Profunctor (Data.Profunctor.Indexed.Indexed i p)
instance Data.Profunctor.Strong.Strong p => Data.Profunctor.Strong.Strong (Data.Profunctor.Indexed.Indexed i p)
instance Data.Profunctor.Unsafe.Profunctor p => Data.Profunctor.Indexed.Indexable i (Data.Profunctor.Indexed.Indexed i p) p
instance Data.Profunctor.Indexed.Indexable i (Data.Profunctor.Types.Forget r) (Data.Profunctor.Types.Forget r)
instance GHC.Base.Functor f => Data.Profunctor.Indexed.Indexable i (Data.Profunctor.Types.Star f) (Data.Profunctor.Types.Star f)
instance GHC.Base.Functor f => Data.Profunctor.Indexed.Indexable i (Data.Profunctor.Types.Costar f) (Data.Profunctor.Types.Costar f)
instance Data.Profunctor.Indexed.Indexable i (->) (->)
instance Data.Profunctor.Indexed.Indexable i Data.Tagged.Tagged Data.Tagged.Tagged

module Data.Profunctor.Joinable
class Profunctor p => Joinable p m | p -> m
join' :: Joinable p m => p a (m b) -> p a b
instance GHC.Base.Monad m => Data.Profunctor.Joinable.Joinable (Data.Profunctor.Types.Star m) m
instance GHC.Base.Monad m => Data.Profunctor.Joinable.Joinable (Data.Profunctor.Types.Forget (m r)) m

module Data.Profunctor.MStrong
class Profunctor p => MStrong p
mfirst' :: (MStrong p, Monoid m) => p a b -> p (a, m) (b, m)
msecond' :: (MStrong p, Monoid m) => p a b -> p (m, a) (m, b)
instance Data.Profunctor.MStrong.MStrong (Data.Profunctor.Types.Forget r)
instance Data.Profunctor.MStrong.MStrong (->)
instance GHC.Base.Functor f => Data.Profunctor.MStrong.MStrong (Data.Profunctor.Types.Star f)
instance Data.Profunctor.MStrong.MStrong Data.Tagged.Tagged
instance Data.Traversable.Traversable f => Data.Profunctor.MStrong.MStrong (Data.Profunctor.Types.Costar f)

module Data.Profunctor.DoubleStar
data DoubleStar f g a b
DoubleStar :: (f a -> g b) -> DoubleStar f g a b
instance (GHC.Base.Functor f, GHC.Base.Functor g) => Data.Profunctor.Unsafe.Profunctor (Data.Profunctor.DoubleStar.DoubleStar f g)
instance (Data.Traversable.Traversable f, Data.Distributive.Distributive g) => Data.Profunctor.MStrong.MStrong (Data.Profunctor.DoubleStar.DoubleStar f g)
instance (Data.Traversable.Traversable f, Data.Distributive.Distributive g) => Data.Profunctor.Choice.Choice (Data.Profunctor.DoubleStar.DoubleStar f g)

module Data.Profunctor.Phantom
class Profunctor p => Phantom p
phantom :: Phantom p => p a x -> p a y
instance Data.Profunctor.Phantom.Phantom (Data.Profunctor.Types.Forget r)
instance (GHC.Base.Functor f, Data.Functor.Contravariant.Contravariant f) => Data.Profunctor.Phantom.Phantom (Data.Profunctor.Types.Star f)
instance (GHC.Base.Functor f, Data.Profunctor.Phantom.Phantom p) => Data.Profunctor.Phantom.Phantom (Data.Profunctor.Cayley.Cayley f p)

module Data.Profunctor.Reflector
class MStrong p => Reflector p
reflected :: (Reflector p, Applicative f) => p a b -> p (f a) (f b)
instance Data.Profunctor.Reflector.Reflector (->)
instance Data.Traversable.Traversable f => Data.Profunctor.Reflector.Reflector (Data.Profunctor.Types.Costar f)
instance Data.Profunctor.Reflector.Reflector Data.Tagged.Tagged
instance Data.Distributive.Distributive f => Data.Profunctor.Reflector.Reflector (Data.Profunctor.Types.Star f)

module Data.Profunctor.Remember
newtype Remember r a b
Remember :: (r -> b) -> Remember r a b
instance GHC.Base.Functor (Data.Profunctor.Remember.Remember r a)
instance Data.Profunctor.Unsafe.Profunctor (Data.Profunctor.Remember.Remember r)
instance Data.Profunctor.Choice.Choice (Data.Profunctor.Remember.Remember r)
instance Data.Profunctor.Closed.Closed (Data.Profunctor.Remember.Remember r)
instance Data.Profunctor.Strong.Costrong (Data.Profunctor.Remember.Remember r)

module Data.Profunctor.Withering
class (Traversing p) => Withering p
cull :: Withering p => (forall f. Alternative f => (a -> f b) -> s -> f t) -> p a b -> p s t
newtype AltConst a b
AltConst :: Maybe a -> AltConst a b
instance GHC.Base.Functor (Data.Profunctor.Withering.AltConst a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Profunctor.Withering.AltConst a b)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Profunctor.Withering.AltConst a b)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Profunctor.Withering.AltConst a b)
instance GHC.Base.Monoid m => Data.Profunctor.Withering.Withering (Data.Profunctor.Types.Forget m)
instance GHC.Base.Monoid a => GHC.Base.Applicative (Data.Profunctor.Withering.AltConst a)
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Data.Profunctor.Withering.AltConst a x)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Data.Profunctor.Withering.AltConst a x)
instance GHC.Base.Monoid m => GHC.Base.Alternative (Data.Profunctor.Withering.AltConst m)
instance GHC.Base.Alternative f => Data.Profunctor.Withering.Withering (Data.Profunctor.Types.Star f)

module Examples.Alt

module Examples.Coalgebraic

module Proton.Internal.Orphans
instance Control.Comonad.Comonad f => Data.Profunctor.Strong.Strong (Data.Profunctor.Types.Costar f)

module Proton.Kaleidoscope
class MStrong p => Reflector p
reflected :: (Reflector p, Applicative f) => p a b -> p (f a) (f b)
type Kaleidoscope s t a b = forall p. Reflector p => p a b -> p s t
type Kaleidoscope' s a = Kaleidoscope s s a a
pointWise :: Kaleidoscope [a] [b] a b

module Proton.Lens
type Lens s t a b = forall p. Strong p => p a b -> p s t
type Lens' s a = Lens s s a a
lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
_1 :: Lens (a, x) (b, x) a b
_2 :: Lens (x, a) (x, b) a b

module Proton.Achromatic
achrom :: forall s t a b. (s -> Maybe (b -> t)) -> (s -> a) -> (b -> t) -> Lens s t a b

module Proton.Miso
data Miso m a b s t
Miso :: (s -> m a) -> (b -> m t) -> Miso m a b s t
instance GHC.Base.Functor m => Data.Profunctor.Unsafe.Profunctor (Proton.Miso.Miso m a b)

module Proton.Prisms
type Prism s t a b = forall p. Choice p => p a b -> p s t
type Prism' s a = Prism s s a a
prism :: (b -> t) -> (s -> Either t a) -> Prism s t a b
prism' :: (b -> s) -> (s -> Maybe a) -> Prism s s a b
_Just :: Prism (Maybe a) (Maybe b) a b
_Nothing :: Prism' (Maybe a) ()
_Left :: Prism (Either a b) (Either a' b) a a'
_Right :: Prism (Either a b) (Either a b') b b'
_Show :: (Read a, Show a) => Prism' String a
withPrism :: forall s t a b r. Prism s t a b -> ((b -> t) -> (s -> Either t a) -> r) -> r
matching :: Prism s t a b -> s -> Either t a

module Proton.Setter
type Setter s t a b = (a -> b) -> (s -> t)
type Setter' s a = Setter s s a a
set :: Setter s t a b -> s -> b -> t
over :: Setter s t a b -> (a -> b) -> s -> t
sets :: (forall p. Profunctor p => p a b -> p s t) -> Setter s t a b
setter :: (s -> a) -> (b -> t) -> Setter s t a b
mapped :: Functor f => Setter (f a) (f b) a b
(%~) :: Setter s t a b -> (a -> b) -> s -> t
infixr 4 %~
(.~) :: Setter s t a b -> b -> s -> t
infixr 4 .~

module Proton.Types
type Optic p s t a b = p a b -> p s t
type Optic' p s a = Optic p s s a a
type Optical p q s t a b = p a b -> q s t
type Optical' p q s a = Optical p q s s a a
type IndexedOptic i q s t a b = forall p. Indexable i p q => Optical p q s t a b
type IndexedOptic' i p s a = IndexedOptic i p s s a a
type CoindexedOptic e p s t a b = Optical p (Coindexed e p) s t a b
type CoindexedOptic' e p s a = CoindexedOptic e p s s a a

module Proton.Telescope
cat :: Expansive p => Optic p [a] b a b

module Proton.Par
parrallelising :: Joinable p Concurrently => p a (IO b) -> p a b

module Proton.Loop
type Loop s t a b = forall p. Cochoice p => p a b -> p s t
type Loop' s a = Loop s s a a
data CoPrism a b s t
CoPrism :: (s -> a) -> (b -> Either a t) -> CoPrism a b s t
loop :: forall p s t a b. Cochoice p => (s -> a) -> (b -> Either a t) -> Optic p s t a b
iterM :: forall s t a. Optic (Star ((,) [a])) s t a a -> (a -> Either a a) -> s -> ([a], t)
tester :: Int -> Either Int Int
instance Data.Profunctor.Unsafe.Profunctor (Proton.Loop.CoPrism a b)
instance Data.Profunctor.Choice.Cochoice (Proton.Loop.CoPrism a b)

module Proton.Indexed
indexing :: Indexable i p q => (s -> i) -> p s t -> q s t
itraversed :: Traversing p => IndexedOptic Int p [a] [b] a b
itoListOf :: IndexedOptic i (Forget [(i, a)]) s t a b -> s -> [(i, a)]
iover :: IndexedOptic i (->) s t a b -> (i -> a -> b) -> s -> t
iset :: IndexedOptic i (->) s t a b -> (i -> b) -> s -> t

module Proton.Grate
type Grate s t a b = forall p. Closed p => (p a b) -> (p s t)
type Grate' s a = Grate s s a a
newtype Zipping a b
Zipping :: (a -> a -> b) -> Zipping a b
grate :: (((s -> a) -> b) -> t) -> Grate s t a b
distributed :: (Closed p, Representable g) => p a b -> p (g a) (g b)
both :: Grate (a, a) (b, b) a b
zipWithOf :: forall s t a b. Optic (Costar Pair) s t a b -> (a -> a -> b) -> s -> s -> t
zipFWithOf :: forall f s t a b. Optic (Costar f) s t a b -> (f a -> b) -> f s -> t

module Proton.PreGrate
alignMaybeWithDefault :: a -> Grate (Maybe a) (Maybe b) a b
aligner :: (s -> k -> a) -> ((k -> b) -> t) -> Grate s t a b
alignMap :: Ord k => Set k -> Grate (Map k a) (Map k b) (Maybe a) (Maybe b)
alignMapWithDefault :: Ord k => Set k -> a -> Grate (Map k a) (Map k b) a b
alignList :: Int -> Grate [a] [b] (Maybe a) (Maybe b)
alignListWithDefault :: Int -> a -> Grate [a] [b] a b
alignMapMonoid :: (Monoid a, Ord k) => Set k -> Grate (Map k a) (Map k b) a b
alignListMonoid :: Monoid a => Int -> Grate [a] [b] a b
x :: Map Int [String]
y :: Map Int [String]
l :: Grate (Map Int [String]) (Map Int [b]) String b
l' :: Grate (Map Int [String]) (Map Int [b]) (Maybe String) (Maybe b)
newtype Intersection a
Intersection :: Set a -> Intersection a
fullAlignMap :: (Ord k, MStrong p, Closed p) => p a b -> p (Map k a) (Map k b)
fullAlignList :: (MStrong p, Closed p) => p a b -> p [a] [b]
tester :: Map Int [String]
zipBy :: forall f p s t a b m. (Representable f, MStrong p, Closed p, Monoid m) => (s -> (f a, m)) -> (f b -> m -> t) -> p a b -> p s t
instance GHC.Classes.Ord a => GHC.Base.Semigroup (Proton.PreGrate.Intersection a)

module Proton.Getter
type Getter s t a b = forall p. Phantom p => p a b -> p s t
to :: Profunctor p => (s -> a) -> Optic p s b a b
to' :: (s -> a) -> Getter s t a b
to'' :: (s -> a) -> Optic (Forget r) s t a b
view :: Optic (Forget a) s t a b -> s -> a
views :: Optic (Forget a) s t a b -> (a -> a') -> s -> a'
like :: a -> Getter s t a b
(^.) :: s -> Optic (Forget a) s t a b -> a
infixl 8 ^.

module Proton.Review
type Review s t a b = forall p. (Profunctor p, Bifunctor p) => p a b -> p s t
retagged :: forall p a b s. (Profunctor p, Bifunctor p) => p a b -> p s b
review :: (Tagged a b -> Tagged s t) -> b -> t
(#) :: (Tagged a b -> Tagged s t) -> b -> t
infixr 8 #
reviews :: (Tagged a b -> Tagged s t) -> (t -> t') -> b -> t'
re :: (Tagged a b -> Tagged s t) -> Getter b a t s
unto :: forall (s :: *) t (a :: *) b. (b -> t) -> Tagged a b -> Tagged s t
un :: Getter s t a b -> Tagged t s -> Tagged b a

module Proton.Iso
type Iso s t a b = forall p. Profunctor p => p a b -> p s t
type Iso' s a = Iso s s a a
iso :: (s -> a) -> (b -> t) -> Iso s t a b
from :: Iso s t a b -> Iso b a t s
withIso :: Iso s t a b -> ((s -> a) -> (b -> t) -> r) -> r
under :: Iso s t a b -> (t -> s) -> b -> a
mapping :: (Functor f, Functor g) => Iso s t a b -> Iso (f s) (g t) (f a) (g b)
involuted :: (a -> a) -> Iso' a a
data Exchange a b s t
Exchange :: (s -> a) -> (b -> t) -> Exchange a b s t
instance GHC.Base.Functor (Proton.Iso.Exchange a b s)
instance Data.Profunctor.Unsafe.Profunctor (Proton.Iso.Exchange a b)

module Proton.Glass
type Glass s t a b = forall p. (Strong p, Closed p) => Optic p s t a b
type Glass' s a = Glass s s a a
type Glassed p = (Strong p, Closed p)
glassed :: (Strong p, Closed p) => p a b -> p (s, u -> a) (s, u -> b)
glass :: forall p s t a b. Glassed p => (((s -> a) -> b) -> s -> t) -> p a b -> p s t
glassList :: forall a b. Glass [a] [b] a b
extendOf :: Comonad w => Optic (Costar w) s t a b -> (w a -> b) -> w s -> w t
traversed' :: forall f a b. Traversable f => Glass (f a) (f b) a b

module Proton.Fold
type Fold s t a b = forall p. (Traversing p, Phantom p) => p a b -> p s t
folding :: (Foldable f, Phantom p, Traversing p) => (s -> f a) -> p a b -> p s t
folded :: (Traversing p, Foldable f, Phantom p) => p a b -> p (f a) t
foldOf :: Monoid a => Fold s t a b -> s -> a
foldMapOf :: Monoid m => Optic (Forget m) s t a b -> (a -> m) -> s -> m
toListOf :: Optic (Forget [a]) s t a b -> s -> [a]
preview :: Optic (Forget (First a)) s t a b -> s -> Maybe a
(^?) :: s -> Optic (Forget (First a)) s t a b -> Maybe a
(^..) :: s -> Optic (Forget [a]) s t a b -> [a]
(<+>) :: Semigroup r => Optic (Forget r) s t a b -> Optic (Forget r) s t' a b' -> Optic (Forget r) s t a b

module Proton.Traversal
type Traversal s t a b = forall p. (Traversing p) => p a b -> p s t
type Traversal' s a = forall p. Traversing p => p a a -> p s s
traversed :: Traversable f => Traversal (f a) (f b) a b
filtered :: (a -> Bool) -> Traversal' a a
traverseOf :: Optic (Star f) s t a b -> (a -> f b) -> s -> f t
(%%~) :: Optic (Star f) s t a b -> (a -> f b) -> s -> f t
infixr 4 %%~
beside :: forall s t a b s' t' p r. (Representable p, Bitraversable r, Applicative (Rep p)) => Optic p s t a b -> Optic p s' t' a b -> Optic p (r s s') (r t t') a b
unsafePartsOf :: forall s t a b. (forall p. Traversing p => p a b -> p s t) -> Lens s t [a] [b]
partsOf :: forall s a. (forall p. Traversing p => p a a -> p s s) -> Lens' s [a]
taking :: forall q s a. Traversing q => Int -> (forall p. Traversing p => p a a -> p s s) -> Optic' q s a
dropping :: forall s a. Int -> Traversal' s a -> Traversal' s a

module Proton.Grid
type Grid s t a b = forall p. (Traversing p, Closed p) => Optic p s t a b
type Grid' s a = Grid s s a a

module Proton.Plated

module Proton.Feedback
type Feedback s t a b = forall p. Costrong p => p a b -> p s t
type Feedback' s a = Feedback s s a a
feedback :: forall p s t a b. Costrong p => ((s, b) -> a) -> (b -> (t, b)) -> Optic p s t a b
fib :: Feedback Int [Int] [Int] [Int]

module Proton.Diffraction
diffract :: Distributive f => Optic (Star f) s t a b -> (a -> f b) -> s -> f t

module Proton.Coindexed
vView :: CoindexedOptic e (Forget (Either e a)) s t a b -> s -> Either e a
vPrism :: (Coindexable e p q, Choice p, Choice q) => (t -> e) -> Prism s t a b -> Optical p q s t a b
_Just' :: (Choice p, Choice q, Coindexable String p q) => Optical p q (Maybe a) (Maybe b) a b
coindexing :: forall e p s t a b. Profunctor p => Optic (Coindexed e p) s t a b -> Optic p s (Either e t) a b
vOver :: Optic (Coindexed e (->)) s t a b -> (a -> b) -> s -> Either e t
vFirst :: forall p a. Traversing p => p a a -> Coindexed String p [a] [a]

module Proton.Coalgebraic
type Coalgebraic s t a b = forall p. MChoice p => Optic p s t a b
type Coalgebraic' s a = Coalgebraic s s a a
swapEither :: Either a b -> Either b a
class Profunctor p => MChoice p
mleft' :: MChoice p => p a b -> p (Either a m) (Either b m)
mright' :: MChoice p => p a b -> p (Either m a) (Either m b)
coprism :: (b -> t) -> (s -> Either t a) -> Coalgebraic s t a b
coalgPrism :: Prism s t a b -> Coalgebraic s t a b
_Just' :: Coalgebraic (Maybe a) (Maybe b) a b
_Right' :: Coalgebraic (Either e a) (Either e b) a b
instance Proton.Coalgebraic.MChoice (->)
instance GHC.Base.Applicative f => Proton.Coalgebraic.MChoice (Data.Profunctor.Types.Star f)
instance GHC.Base.Monoid r => Proton.Coalgebraic.MChoice (Data.Profunctor.Types.Forget r)
instance Data.Traversable.Traversable f => Proton.Coalgebraic.MChoice (Data.Profunctor.Types.Costar f)

module Proton.Annotated
vView :: CoindexedOptic e (Forget (Either e a)) s t a b -> s -> Either e a
coindexing :: forall e p s t a b. Profunctor p => Optic (Coindexed e p) s t a b -> Optic p s (Either e t) a b
vOver :: Optic (Coindexed e (->)) s t a b -> (a -> b) -> s -> Either e t
vFirst :: forall p a. Traversing p => p a a -> Coindexed String p [a] [a]

module Proton.Algebraic
class Profunctor p => MStrong p
mfirst' :: (MStrong p, Monoid m) => p a b -> p (a, m) (b, m)
msecond' :: (MStrong p, Monoid m) => p a b -> p (m, a) (m, b)
type AlgebraicLens s t a b = forall p. MStrong p => p a b -> p s t
type AlgebraicLens' s a = AlgebraicLens s s a a
algebraic :: forall m p s t a b. (Monoid m, MStrong p) => (s -> m) -> (s -> a) -> (m -> b -> t) -> Optic p s t a b
listLens :: MStrong p => (s -> a) -> ([s] -> b -> t) -> Optic p s t a b
altLens :: (Alternative f, MStrong p) => (s -> a) -> (f s -> b -> t) -> Optic p s t a b
(>-) :: Optic (Costar f) s t a b -> (f a -> b) -> f s -> t
infixr 4 >-
(?.) :: Optic (Costar f) s t a b -> b -> f s -> t
infixr 4 ?.

module Proton

-- | <a>&amp;</a> is a reverse application operator. This provides
--   notational convenience. Its precedence is one higher than that of the
--   forward application operator <a>$</a>, which allows <a>&amp;</a> to be
--   nested in <a>$</a>.
--   
--   <pre>
--   &gt;&gt;&gt; 5 &amp; (+1) &amp; show
--   "6"
--   </pre>
(&) :: a -> (a -> b) -> b
infixl 1 &
class Profunctor p => Extraction p
extractions :: (Extraction p, Comonad w) => p (w a) b -> p (w a) (w b)
act :: (Star f a b -> Star f s t) -> (a -> f b) -> s -> f t
t :: NonEmpty a -> Pair (Maybe a)
u :: NonEmpty Int -> Pair Int
home :: Int -> Store Int Int -> Either Int Int
looper :: NonEmpty Int -> Either [Int] Int
coiterate :: forall w a b. (Traversable w, Comonad w) => (w a -> Either b a) -> w a -> w b
class Profunctor p => MStrong p
mfirst' :: (MStrong p, Monoid m) => p a b -> p (a, m) (b, m)
msecond' :: (MStrong p, Monoid m) => p a b -> p (m, a) (m, b)
class MStrong p => Reflector p
reflected :: (Reflector p, Applicative f) => p a b -> p (f a) (f b)
type Kaleidoscope' s a = Kaleidoscope s s a a
type Kaleidoscope s t a b = forall p. Reflector p => p a b -> p s t
pointWise :: Kaleidoscope [a] [b] a b
type Lens' s a = Lens s s a a
type Lens s t a b = forall p. Strong p => p a b -> p s t
lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
_1 :: Lens (a, x) (b, x) a b
_2 :: Lens (x, a) (x, b) a b
achrom :: forall s t a b. (s -> Maybe (b -> t)) -> (s -> a) -> (b -> t) -> Lens s t a b
type Prism' s a = Prism s s a a
type Prism s t a b = forall p. Choice p => p a b -> p s t
prism :: (b -> t) -> (s -> Either t a) -> Prism s t a b
prism' :: (b -> s) -> (s -> Maybe a) -> Prism s s a b
_Just :: Prism (Maybe a) (Maybe b) a b
_Nothing :: Prism' (Maybe a) ()
_Left :: Prism (Either a b) (Either a' b) a a'
_Right :: Prism (Either a b) (Either a b') b b'
_Show :: (Read a, Show a) => Prism' String a
withPrism :: forall s t a b r. Prism s t a b -> ((b -> t) -> (s -> Either t a) -> r) -> r
matching :: Prism s t a b -> s -> Either t a
type Setter' s a = Setter s s a a
type Setter s t a b = (a -> b) -> (s -> t)
set :: Setter s t a b -> s -> b -> t
over :: Setter s t a b -> (a -> b) -> s -> t
sets :: (forall p. Profunctor p => p a b -> p s t) -> Setter s t a b
setter :: (s -> a) -> (b -> t) -> Setter s t a b
mapped :: Functor f => Setter (f a) (f b) a b
(%~) :: Setter s t a b -> (a -> b) -> s -> t
infixr 4 %~
(.~) :: Setter s t a b -> b -> s -> t
infixr 4 .~
type CoindexedOptic' e p s a = CoindexedOptic e p s s a a
type CoindexedOptic e p s t a b = Optical p (Coindexed e p) s t a b
type IndexedOptic' i p s a = IndexedOptic i p s s a a
type IndexedOptic i q s t a b = forall p. Indexable i p q => Optical p q s t a b
type Optical' p q s a = Optical p q s s a a
type Optical p q s t a b = p a b -> q s t
type Optic' p s a = Optic p s s a a
type Optic p s t a b = p a b -> p s t
cat :: Expansive p => Optic p [a] b a b
data CoPrism a b s t
CoPrism :: (s -> a) -> (b -> Either a t) -> CoPrism a b s t
type Loop' s a = Loop s s a a
type Loop s t a b = forall p. Cochoice p => p a b -> p s t
loop :: forall p s t a b. Cochoice p => (s -> a) -> (b -> Either a t) -> Optic p s t a b
iterM :: forall s t a. Optic (Star ((,) [a])) s t a a -> (a -> Either a a) -> s -> ([a], t)
tester :: Int -> Either Int Int
indexing :: Indexable i p q => (s -> i) -> p s t -> q s t
itraversed :: Traversing p => IndexedOptic Int p [a] [b] a b
itoListOf :: IndexedOptic i (Forget [(i, a)]) s t a b -> s -> [(i, a)]
iover :: IndexedOptic i (->) s t a b -> (i -> a -> b) -> s -> t
iset :: IndexedOptic i (->) s t a b -> (i -> b) -> s -> t
newtype Zipping a b
Zipping :: (a -> a -> b) -> Zipping a b
type Grate' s a = Grate s s a a
type Grate s t a b = forall p. Closed p => (p a b) -> (p s t)
grate :: (((s -> a) -> b) -> t) -> Grate s t a b
distributed :: (Closed p, Representable g) => p a b -> p (g a) (g b)
both :: Grate (a, a) (b, b) a b
zipWithOf :: forall s t a b. Optic (Costar Pair) s t a b -> (a -> a -> b) -> s -> s -> t
zipFWithOf :: forall f s t a b. Optic (Costar f) s t a b -> (f a -> b) -> f s -> t
type Getter s t a b = forall p. Phantom p => p a b -> p s t
to :: Profunctor p => (s -> a) -> Optic p s b a b
to' :: (s -> a) -> Getter s t a b
to'' :: (s -> a) -> Optic (Forget r) s t a b
view :: Optic (Forget a) s t a b -> s -> a
views :: Optic (Forget a) s t a b -> (a -> a') -> s -> a'
like :: a -> Getter s t a b
(^.) :: s -> Optic (Forget a) s t a b -> a
infixl 8 ^.
type Review s t a b = forall p. (Profunctor p, Bifunctor p) => p a b -> p s t
retagged :: forall p a b s. (Profunctor p, Bifunctor p) => p a b -> p s b
review :: (Tagged a b -> Tagged s t) -> b -> t
(#) :: (Tagged a b -> Tagged s t) -> b -> t
infixr 8 #
reviews :: (Tagged a b -> Tagged s t) -> (t -> t') -> b -> t'
re :: (Tagged a b -> Tagged s t) -> Getter b a t s
unto :: forall (s :: *) t (a :: *) b. (b -> t) -> Tagged a b -> Tagged s t
un :: Getter s t a b -> Tagged t s -> Tagged b a
data Exchange a b s t
Exchange :: (s -> a) -> (b -> t) -> Exchange a b s t
type Iso' s a = Iso s s a a
type Iso s t a b = forall p. Profunctor p => p a b -> p s t
iso :: (s -> a) -> (b -> t) -> Iso s t a b
from :: Iso s t a b -> Iso b a t s
withIso :: Iso s t a b -> ((s -> a) -> (b -> t) -> r) -> r
under :: Iso s t a b -> (t -> s) -> b -> a
mapping :: (Functor f, Functor g) => Iso s t a b -> Iso (f s) (g t) (f a) (g b)
involuted :: (a -> a) -> Iso' a a
type Glassed p = (Strong p, Closed p)
type Glass' s a = Glass s s a a
type Glass s t a b = forall p. (Strong p, Closed p) => Optic p s t a b
glassed :: (Strong p, Closed p) => p a b -> p (s, u -> a) (s, u -> b)
glass :: forall p s t a b. Glassed p => (((s -> a) -> b) -> s -> t) -> p a b -> p s t
glassList :: forall a b. Glass [a] [b] a b
extendOf :: Comonad w => Optic (Costar w) s t a b -> (w a -> b) -> w s -> w t
traversed' :: forall f a b. Traversable f => Glass (f a) (f b) a b
type Fold s t a b = forall p. (Traversing p, Phantom p) => p a b -> p s t
folding :: (Foldable f, Phantom p, Traversing p) => (s -> f a) -> p a b -> p s t
folded :: (Traversing p, Foldable f, Phantom p) => p a b -> p (f a) t
foldOf :: Monoid a => Fold s t a b -> s -> a
foldMapOf :: Monoid m => Optic (Forget m) s t a b -> (a -> m) -> s -> m
toListOf :: Optic (Forget [a]) s t a b -> s -> [a]
preview :: Optic (Forget (First a)) s t a b -> s -> Maybe a
(^?) :: s -> Optic (Forget (First a)) s t a b -> Maybe a
(^..) :: s -> Optic (Forget [a]) s t a b -> [a]
(<+>) :: Semigroup r => Optic (Forget r) s t a b -> Optic (Forget r) s t' a b' -> Optic (Forget r) s t a b
type Traversal' s a = forall p. Traversing p => p a a -> p s s
type Traversal s t a b = forall p. (Traversing p) => p a b -> p s t
traversed :: Traversable f => Traversal (f a) (f b) a b
filtered :: (a -> Bool) -> Traversal' a a
traverseOf :: Optic (Star f) s t a b -> (a -> f b) -> s -> f t
(%%~) :: Optic (Star f) s t a b -> (a -> f b) -> s -> f t
infixr 4 %%~
beside :: forall s t a b s' t' p r. (Representable p, Bitraversable r, Applicative (Rep p)) => Optic p s t a b -> Optic p s' t' a b -> Optic p (r s s') (r t t') a b
unsafePartsOf :: forall s t a b. (forall p. Traversing p => p a b -> p s t) -> Lens s t [a] [b]
partsOf :: forall s a. (forall p. Traversing p => p a a -> p s s) -> Lens' s [a]
taking :: forall q s a. Traversing q => Int -> (forall p. Traversing p => p a a -> p s s) -> Optic' q s a
dropping :: forall s a. Int -> Traversal' s a -> Traversal' s a
type Grid' s a = Grid s s a a
type Grid s t a b = forall p. (Traversing p, Closed p) => Optic p s t a b
type Feedback' s a = Feedback s s a a
type Feedback s t a b = forall p. Costrong p => p a b -> p s t
feedback :: forall p s t a b. Costrong p => ((s, b) -> a) -> (b -> (t, b)) -> Optic p s t a b
fib :: Feedback Int [Int] [Int] [Int]
diffract :: Distributive f => Optic (Star f) s t a b -> (a -> f b) -> s -> f t
class Profunctor p => MChoice p
mleft' :: MChoice p => p a b -> p (Either a m) (Either b m)
mright' :: MChoice p => p a b -> p (Either m a) (Either m b)
type Coalgebraic' s a = Coalgebraic s s a a
type Coalgebraic s t a b = forall p. MChoice p => Optic p s t a b
swapEither :: Either a b -> Either b a
coprism :: (b -> t) -> (s -> Either t a) -> Coalgebraic s t a b
coalgPrism :: Prism s t a b -> Coalgebraic s t a b
_Just' :: Coalgebraic (Maybe a) (Maybe b) a b
_Right' :: Coalgebraic (Either e a) (Either e b) a b
type AlgebraicLens' s a = AlgebraicLens s s a a
type AlgebraicLens s t a b = forall p. MStrong p => p a b -> p s t
algebraic :: forall m p s t a b. (Monoid m, MStrong p) => (s -> m) -> (s -> a) -> (m -> b -> t) -> Optic p s t a b
listLens :: MStrong p => (s -> a) -> ([s] -> b -> t) -> Optic p s t a b
altLens :: (Alternative f, MStrong p) => (s -> a) -> (f s -> b -> t) -> Optic p s t a b
(?.) :: Optic (Costar f) s t a b -> b -> f s -> t
infixr 4 ?.
(>-) :: Optic (Costar f) s t a b -> (f a -> b) -> f s -> t
infixr 4 >-

module Examples.Scrap
data Species
Setosa :: Species
Versicolor :: Species
Virginica :: Species
data Measurements
Measurements :: V4 Float -> Measurements
[getMeasurements] :: Measurements -> V4 Float
data Flower
Flower :: Species -> Measurements -> Flower
[species] :: Flower -> Species
[measurements] :: Flower -> Measurements
measurementDistance :: Measurements -> Measurements -> Float
classify :: Foldable f => f Flower -> Measurements -> Flower
aggregate :: Kaleidoscope' Measurements Float
measureNearest :: AlgebraicLens' Flower Measurements
flower1 :: Flower
flower2 :: Flower
flowers :: [Flower]
mean :: [Float] -> Float
aggOnIndex :: (s -> a) -> AlgebraicLens s b a b
test :: IO ()
instance GHC.Show.Show Examples.Scrap.Flower
instance GHC.Show.Show Examples.Scrap.Measurements
instance GHC.Show.Show Examples.Scrap.Species

module Examples.Loop
thing :: Loop' Int Int
collatz :: Int -> [Int]
factorial :: Int -> Product Int
accum :: forall p next state. (Monoid state, Strong p, Cochoice p) => (next -> Maybe (next, state)) -> Optic p next state next next
while :: (Monoid state, Strong p, Cochoice p) => (t -> Bool) -> (t -> state) -> Optic p t state t t

module Examples.Layers
imgLayers :: [[Int]]
forward :: Profunctor p => (s -> a) -> Optic p s t a t
back :: Profunctor p => (x -> t) -> Optic p s t s x
lookup'er :: Eq a => AlgebraicLens (a, b) (a, Maybe b) a a

module Examples.Glass

module Examples.Flowers
data Species
Setosa :: Species
Versicolor :: Species
Virginica :: Species
data Measurements
Measurements :: [Float] -> Measurements
[getMeasurements] :: Measurements -> [Float]
data Flower
Flower :: Species -> Measurements -> Flower
[flowerSpecies] :: Flower -> Species
[flowerMeasurements] :: Flower -> Measurements
measurementDistance :: Measurements -> Measurements -> Float
aggregate :: Kaleidoscope' Measurements Float
classify :: [Flower] -> Measurements -> Maybe Flower
measurements :: AlgebraicLens Flower (Maybe Flower) Measurements Measurements
versicolor :: Flower
setosa :: Flower
flowers :: [Flower]
mean :: Fractional a => [a] -> a
(>--) :: [s] -> Optic (Costar []) s t a a -> t
infixr 4 >--
aggregateWith :: Functor f => (f Float -> Float) -> Optic (Costar []) Measurements Measurements Float Float
avgMeasurement :: Foldable f => f Measurements -> Measurements
applyWeight :: Float -> Measurements -> Measurements
partitioned :: forall f a. Ord a => AlgebraicLens a ([a], [a]) a a
onFirst :: Eq a => AlgebraicLens (a, b) (Maybe b) a a
selectingOn :: (s -> a) -> AlgebraicLens s (Maybe s) a (Maybe Int)
indexOf :: Eq s => AlgebraicLens s (Maybe Int) s s
test :: IO ()
allMeasurements :: [[Float]]
measurementMap :: Map String (ZipList Float)
instance GHC.Show.Show Examples.Flowers.Flower
instance GHC.Show.Show Examples.Flowers.Measurements
instance GHC.Show.Show Examples.Flowers.Species

module Examples.Diffract
split :: [a] -> Pair [a]
splitter :: (a, a) -> Pair a
example :: IO ()

module Examples.Algebraic
pad :: AlgebraicLens String [String] String Int
padLength :: AlgebraicLens String [String] Int Int

module Proton.Wither
type Wither s t a b = forall p. Withering p => Optic p s t a b
type Wither' s a = Wither s s a a
guarding :: Alternative f => (a -> Bool) -> a -> f a
guarded :: forall a b. (a -> Bool) -> Wither a b a b
filterOf :: Optic (Star Maybe) s t a a -> (a -> Bool) -> s -> Maybe t
witherPrism :: forall p s t a b. Withering p => Prism s t a b -> Optic p s t a b