packages feed

lens-utils 1.4.5 → 1.4.6

raw patch · 1 files changed

+14/−13 lines, 1 filesdep ~basenew-uploaderPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: base

API changes (from Hackage documentation)

+ Control.Lens.Utils: (#%%=) :: MonadState s m => ALens s s a b -> (a -> (r, b)) -> m r
+ Control.Lens.Utils: (#%%~) :: Functor f => ALens s t a b -> (a -> f b) -> s -> f t
+ Control.Lens.Utils: (#%=) :: MonadState s m => ALens s s a b -> (a -> b) -> m ()
+ Control.Lens.Utils: (#%~) :: () => ALens s t a b -> (a -> b) -> s -> t
+ Control.Lens.Utils: (#) :: () => AReview t b -> b -> t
+ Control.Lens.Utils: (#=) :: MonadState s m => ALens s s a b -> b -> m ()
+ Control.Lens.Utils: (#~) :: () => ALens s t a b -> b -> s -> t
+ Control.Lens.Utils: (%%=) :: MonadState s m => Over p ((,) r) s s a b -> p a (r, b) -> m r
+ Control.Lens.Utils: (%%@=) :: MonadState s m => Over (Indexed i) ((,) r) s s a b -> (i -> a -> (r, b)) -> m r
+ Control.Lens.Utils: (%%@~) :: () => Over (Indexed i) f s t a b -> (i -> a -> f b) -> s -> f t
+ Control.Lens.Utils: (%%~) :: () => LensLike f s t a b -> (a -> f b) -> s -> f t
+ Control.Lens.Utils: (%=) :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()
+ Control.Lens.Utils: (%@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m ()
+ Control.Lens.Utils: (%@~) :: () => AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
+ Control.Lens.Utils: (%~) :: () => ASetter s t a b -> (a -> b) -> s -> t
+ Control.Lens.Utils: (&&=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()
+ Control.Lens.Utils: (&&~) :: () => ASetter s t Bool Bool -> Bool -> s -> t
+ Control.Lens.Utils: (&) :: () => a -> (a -> b) -> b
+ Control.Lens.Utils: (&~) :: () => s -> State s a -> s
+ Control.Lens.Utils: (**=) :: (MonadState s m, Floating a) => ASetter' s a -> a -> m ()
+ Control.Lens.Utils: (**~) :: Floating a => ASetter s t a a -> a -> s -> t
+ Control.Lens.Utils: (*=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
+ Control.Lens.Utils: (*~) :: Num a => ASetter s t a a -> a -> s -> t
+ Control.Lens.Utils: (+=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
+ Control.Lens.Utils: (+~) :: Num a => ASetter s t a a -> a -> s -> t
+ Control.Lens.Utils: (-=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
+ Control.Lens.Utils: (-~) :: Num a => ASetter s t a a -> a -> s -> t
+ Control.Lens.Utils: (...) :: (Applicative f, Plated c) => LensLike f s t c c -> Over p f c c a b -> Over p f s t a b
+ Control.Lens.Utils: (.=) :: MonadState s m => ASetter s s a b -> b -> m ()
+ Control.Lens.Utils: (.>) :: () => (st -> r) -> (kab -> st) -> kab -> r
+ Control.Lens.Utils: (.@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> b) -> m ()
+ Control.Lens.Utils: (.@~) :: () => AnIndexedSetter i s t a b -> (i -> b) -> s -> t
+ Control.Lens.Utils: (.~) :: () => ASetter s t a b -> b -> s -> t
+ Control.Lens.Utils: (//=) :: (MonadState s m, Fractional a) => ASetter' s a -> a -> m ()
+ Control.Lens.Utils: (//~) :: Fractional a => ASetter s t a a -> a -> s -> t
+ Control.Lens.Utils: (<#%=) :: MonadState s m => ALens s s a b -> (a -> b) -> m b
+ Control.Lens.Utils: (<#%~) :: () => ALens s t a b -> (a -> b) -> s -> (b, t)
+ Control.Lens.Utils: (<#=) :: MonadState s m => ALens s s a b -> b -> m b
+ Control.Lens.Utils: (<#~) :: () => ALens s t a b -> b -> s -> (b, t)
+ Control.Lens.Utils: (<%=) :: MonadState s m => LensLike ((,) b) s s a b -> (a -> b) -> m b
+ Control.Lens.Utils: (<%@=) :: MonadState s m => Over (Indexed i) ((,) b) s s a b -> (i -> a -> b) -> m b
+ Control.Lens.Utils: (<%@~) :: () => Over (Indexed i) ((,) b) s t a b -> (i -> a -> b) -> s -> (b, t)
+ Control.Lens.Utils: (<%~) :: () => LensLike ((,) b) s t a b -> (a -> b) -> s -> (b, t)
+ Control.Lens.Utils: (<&&=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
+ Control.Lens.Utils: (<&&~) :: () => LensLike ((,) Bool) s t Bool Bool -> Bool -> s -> (Bool, t)
+ Control.Lens.Utils: (<&>) :: Functor f => f a -> (a -> b) -> f b
+ Control.Lens.Utils: (<**=) :: (MonadState s m, Floating a) => LensLike' ((,) a) s a -> a -> m a
+ Control.Lens.Utils: (<**~) :: Floating a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Control.Lens.Utils: (<*=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Control.Lens.Utils: (<*~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Control.Lens.Utils: (<+=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Control.Lens.Utils: (<+~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Control.Lens.Utils: (<-=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Control.Lens.Utils: (<-~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Control.Lens.Utils: (<.) :: Indexable i p => (Indexed i s t -> r) -> ((a -> b) -> s -> t) -> p a b -> r
+ Control.Lens.Utils: (<.=) :: MonadState s m => ASetter s s a b -> b -> m b
+ Control.Lens.Utils: (<.>) :: Indexable (i, j) p => (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> p a b -> r
+ Control.Lens.Utils: (<.~) :: () => ASetter s t a b -> b -> s -> (b, t)
+ Control.Lens.Utils: (<//=) :: (MonadState s m, Fractional a) => LensLike' ((,) a) s a -> a -> m a
+ Control.Lens.Utils: (<//~) :: Fractional a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Control.Lens.Utils: (<<%=) :: (Strong p, MonadState s m) => Over p ((,) a) s s a b -> p a b -> m a
+ Control.Lens.Utils: (<<%@=) :: MonadState s m => Over (Indexed i) ((,) a) s s a b -> (i -> a -> b) -> m a
+ Control.Lens.Utils: (<<%@~) :: () => Over (Indexed i) ((,) a) s t a b -> (i -> a -> b) -> s -> (a, t)
+ Control.Lens.Utils: (<<%~) :: () => LensLike ((,) a) s t a b -> (a -> b) -> s -> (a, t)
+ Control.Lens.Utils: (<<&&=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
+ Control.Lens.Utils: (<<&&~) :: () => LensLike' ((,) Bool) s Bool -> Bool -> s -> (Bool, s)
+ Control.Lens.Utils: (<<**=) :: (MonadState s m, Floating a) => LensLike' ((,) a) s a -> a -> m a
+ Control.Lens.Utils: (<<**~) :: Floating a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Control.Lens.Utils: (<<*=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Control.Lens.Utils: (<<*~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Control.Lens.Utils: (<<+=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Control.Lens.Utils: (<<+~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Control.Lens.Utils: (<<-=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Control.Lens.Utils: (<<-~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Control.Lens.Utils: (<<.=) :: MonadState s m => LensLike ((,) a) s s a b -> b -> m a
+ Control.Lens.Utils: (<<.~) :: () => LensLike ((,) a) s t a b -> b -> s -> (a, t)
+ Control.Lens.Utils: (<<//=) :: (MonadState s m, Fractional a) => LensLike' ((,) a) s a -> a -> m a
+ Control.Lens.Utils: (<<//~) :: Fractional a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Control.Lens.Utils: (<<<>=) :: (MonadState s m, Monoid r) => LensLike' ((,) r) s r -> r -> m r
+ Control.Lens.Utils: (<<<>~) :: Monoid r => LensLike' ((,) r) s r -> r -> s -> (r, s)
+ Control.Lens.Utils: (<<>=) :: (MonadState s m, Monoid r) => LensLike' ((,) r) s r -> r -> m r
+ Control.Lens.Utils: (<<>~) :: Monoid m => LensLike ((,) m) s t m m -> m -> s -> (m, t)
+ Control.Lens.Utils: (<<?=) :: MonadState s m => LensLike ((,) a) s s a (Maybe b) -> b -> m a
+ Control.Lens.Utils: (<<?~) :: () => LensLike ((,) a) s t a (Maybe b) -> b -> s -> (a, t)
+ Control.Lens.Utils: (<<^=) :: (MonadState s m, Num a, Integral e) => LensLike' ((,) a) s a -> e -> m a
+ Control.Lens.Utils: (<<^^=) :: (MonadState s m, Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> m a
+ Control.Lens.Utils: (<<^^~) :: (Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> s -> (a, s)
+ Control.Lens.Utils: (<<^~) :: (Num a, Integral e) => LensLike' ((,) a) s a -> e -> s -> (a, s)
+ Control.Lens.Utils: (<<||=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
+ Control.Lens.Utils: (<<||~) :: () => LensLike' ((,) Bool) s Bool -> Bool -> s -> (Bool, s)
+ Control.Lens.Utils: (<<~) :: MonadState s m => ALens s s a b -> m b -> m b
+ Control.Lens.Utils: (<>=) :: (MonadState s m, Monoid a) => ASetter' s a -> a -> m ()
+ Control.Lens.Utils: (<>~) :: Monoid a => ASetter s t a a -> a -> s -> t
+ Control.Lens.Utils: (<?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m b
+ Control.Lens.Utils: (<?~) :: () => ASetter s t a (Maybe b) -> b -> s -> (b, t)
+ Control.Lens.Utils: (<^=) :: (MonadState s m, Num a, Integral e) => LensLike' ((,) a) s a -> e -> m a
+ Control.Lens.Utils: (<^^=) :: (MonadState s m, Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> m a
+ Control.Lens.Utils: (<^^~) :: (Fractional a, Integral e) => LensLike ((,) a) s t a a -> e -> s -> (a, t)
+ Control.Lens.Utils: (<^~) :: (Num a, Integral e) => LensLike ((,) a) s t a a -> e -> s -> (a, t)
+ Control.Lens.Utils: (<|) :: Cons s s a a => a -> s -> s
+ Control.Lens.Utils: (<||=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
+ Control.Lens.Utils: (<||~) :: () => LensLike ((,) Bool) s t Bool Bool -> Bool -> s -> (Bool, t)
+ Control.Lens.Utils: (<~) :: MonadState s m => ASetter s s a b -> m b -> m ()
+ Control.Lens.Utils: (>$) :: Contravariant f => b -> f b -> f a
+ Control.Lens.Utils: (?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m ()
+ Control.Lens.Utils: (??) :: Functor f => f (a -> b) -> a -> f b
+ Control.Lens.Utils: (?~) :: () => ASetter s t a (Maybe b) -> b -> s -> t
+ Control.Lens.Utils: (^#) :: () => s -> ALens s t a b -> a
+ Control.Lens.Utils: (^.) :: () => s -> Getting a s a -> a
+ Control.Lens.Utils: (^..) :: () => s -> Getting (Endo [a]) s a -> [a]
+ Control.Lens.Utils: (^=) :: (MonadState s m, Num a, Integral e) => ASetter' s a -> e -> m ()
+ Control.Lens.Utils: (^?!) :: HasCallStack => s -> Getting (Endo a) s a -> a
+ Control.Lens.Utils: (^?) :: () => s -> Getting (First a) s a -> Maybe a
+ Control.Lens.Utils: (^@.) :: () => s -> IndexedGetting i (i, a) s a -> (i, a)
+ Control.Lens.Utils: (^@..) :: () => s -> IndexedGetting i (Endo [(i, a)]) s a -> [(i, a)]
+ Control.Lens.Utils: (^@?!) :: HasCallStack => s -> IndexedGetting i (Endo (i, a)) s a -> (i, a)
+ Control.Lens.Utils: (^@?) :: () => s -> IndexedGetting i (Endo (Maybe (i, a))) s a -> Maybe (i, a)
+ Control.Lens.Utils: (^^=) :: (MonadState s m, Fractional a, Integral e) => ASetter' s a -> e -> m ()
+ Control.Lens.Utils: (^^~) :: (Fractional a, Integral e) => ASetter s t a a -> e -> s -> t
+ Control.Lens.Utils: (^~) :: (Num a, Integral e) => ASetter s t a a -> e -> s -> t
+ Control.Lens.Utils: (|>) :: Snoc s s a a => s -> a -> s
+ Control.Lens.Utils: (||=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()
+ Control.Lens.Utils: (||~) :: () => ASetter s t Bool Bool -> Bool -> s -> t
+ Control.Lens.Utils: Bazaar :: (forall (f :: Type -> Type). Applicative f => p a (f b) -> f t) -> Bazaar a b t
+ Control.Lens.Utils: Bazaar1 :: (forall (f :: Type -> Type). Apply f => p a (f b) -> f t) -> Bazaar1 a b t
+ Control.Lens.Utils: Const :: a -> Const a
+ Control.Lens.Utils: Context :: (b -> t) -> a -> Context a b t
+ Control.Lens.Utils: Fold :: Fold s a -> ReifiedFold s a
+ Control.Lens.Utils: Getter :: Getter s a -> ReifiedGetter s a
+ Control.Lens.Utils: Identity :: a -> Identity a
+ Control.Lens.Utils: Indexed :: (i -> a -> b) -> Indexed i a b
+ Control.Lens.Utils: IndexedFold :: IndexedFold i s a -> ReifiedIndexedFold i s a
+ Control.Lens.Utils: IndexedGetter :: IndexedGetter i s a -> ReifiedIndexedGetter i s a
+ Control.Lens.Utils: IndexedLens :: IndexedLens i s t a b -> ReifiedIndexedLens i s t a b
+ Control.Lens.Utils: IndexedSetter :: IndexedSetter i s t a b -> ReifiedIndexedSetter i s t a b
+ Control.Lens.Utils: IndexedTraversal :: IndexedTraversal i s t a b -> ReifiedIndexedTraversal i s t a b
+ Control.Lens.Utils: Iso :: Iso s t a b -> ReifiedIso s t a b
+ Control.Lens.Utils: Lens :: Lens s t a b -> ReifiedLens s t a b
+ Control.Lens.Utils: MethodName :: Name -> Name -> DefName
+ Control.Lens.Utils: Prism :: Prism s t a b -> ReifiedPrism s t a b
+ Control.Lens.Utils: Setter :: Setter s t a b -> ReifiedSetter s t a b
+ Control.Lens.Utils: TopName :: Name -> DefName
+ Control.Lens.Utils: Traversal :: Traversal s t a b -> ReifiedTraversal s t a b
+ Control.Lens.Utils: [Identical] :: forall k k1 (a :: k) (b :: k1) (s :: k) (t :: k1). () => Identical a b a b
+ Control.Lens.Utils: [getConst] :: Const a -> a
+ Control.Lens.Utils: [runBazaar1] :: Bazaar1 a b t -> forall (f :: Type -> Type). Apply f => p a (f b) -> f t
+ Control.Lens.Utils: [runBazaar] :: Bazaar a b t -> forall (f :: Type -> Type). Applicative f => p a (f b) -> f t
+ Control.Lens.Utils: [runFold] :: ReifiedFold s a -> Fold s a
+ Control.Lens.Utils: [runGetter] :: ReifiedGetter s a -> Getter s a
+ Control.Lens.Utils: [runIdentity] :: Identity a -> a
+ Control.Lens.Utils: [runIndexedFold] :: ReifiedIndexedFold i s a -> IndexedFold i s a
+ Control.Lens.Utils: [runIndexedGetter] :: ReifiedIndexedGetter i s a -> IndexedGetter i s a
+ Control.Lens.Utils: [runIndexedLens] :: ReifiedIndexedLens i s t a b -> IndexedLens i s t a b
+ Control.Lens.Utils: [runIndexedSetter] :: ReifiedIndexedSetter i s t a b -> IndexedSetter i s t a b
+ Control.Lens.Utils: [runIndexedTraversal] :: ReifiedIndexedTraversal i s t a b -> IndexedTraversal i s t a b
+ Control.Lens.Utils: [runIndexed] :: Indexed i a b -> i -> a -> b
+ Control.Lens.Utils: [runIso] :: ReifiedIso s t a b -> Iso s t a b
+ Control.Lens.Utils: [runLens] :: ReifiedLens s t a b -> Lens s t a b
+ Control.Lens.Utils: [runPrism] :: ReifiedPrism s t a b -> Prism s t a b
+ Control.Lens.Utils: [runSetter] :: ReifiedSetter s t a b -> Setter s t a b
+ Control.Lens.Utils: [runTraversal] :: ReifiedTraversal s t a b -> Traversal s t a b
+ Control.Lens.Utils: _1 :: Field1 s t a b => Lens s t a b
+ Control.Lens.Utils: _1' :: Field1 s t a b => Lens s t a b
+ Control.Lens.Utils: _10 :: Field10 s t a b => Lens s t a b
+ Control.Lens.Utils: _10' :: Field10 s t a b => Lens s t a b
+ Control.Lens.Utils: _11 :: Field11 s t a b => Lens s t a b
+ Control.Lens.Utils: _11' :: Field11 s t a b => Lens s t a b
+ Control.Lens.Utils: _12 :: Field12 s t a b => Lens s t a b
+ Control.Lens.Utils: _12' :: Field12 s t a b => Lens s t a b
+ Control.Lens.Utils: _13 :: Field13 s t a b => Lens s t a b
+ Control.Lens.Utils: _13' :: Field13 s t a b => Lens s t a b
+ Control.Lens.Utils: _14 :: Field14 s t a b => Lens s t a b
+ Control.Lens.Utils: _14' :: Field14 s t a b => Lens s t a b
+ Control.Lens.Utils: _15 :: Field15 s t a b => Lens s t a b
+ Control.Lens.Utils: _15' :: Field15 s t a b => Lens s t a b
+ Control.Lens.Utils: _16 :: Field16 s t a b => Lens s t a b
+ Control.Lens.Utils: _16' :: Field16 s t a b => Lens s t a b
+ Control.Lens.Utils: _17 :: Field17 s t a b => Lens s t a b
+ Control.Lens.Utils: _17' :: Field17 s t a b => Lens s t a b
+ Control.Lens.Utils: _18 :: Field18 s t a b => Lens s t a b
+ Control.Lens.Utils: _18' :: Field18 s t a b => Lens s t a b
+ Control.Lens.Utils: _19 :: Field19 s t a b => Lens s t a b
+ Control.Lens.Utils: _19' :: Field19 s t a b => Lens s t a b
+ Control.Lens.Utils: _2 :: Field2 s t a b => Lens s t a b
+ Control.Lens.Utils: _2' :: Field2 s t a b => Lens s t a b
+ Control.Lens.Utils: _3 :: Field3 s t a b => Lens s t a b
+ Control.Lens.Utils: _3' :: Field3 s t a b => Lens s t a b
+ Control.Lens.Utils: _4 :: Field4 s t a b => Lens s t a b
+ Control.Lens.Utils: _4' :: Field4 s t a b => Lens s t a b
+ Control.Lens.Utils: _5 :: Field5 s t a b => Lens s t a b
+ Control.Lens.Utils: _5' :: Field5 s t a b => Lens s t a b
+ Control.Lens.Utils: _6 :: Field6 s t a b => Lens s t a b
+ Control.Lens.Utils: _6' :: Field6 s t a b => Lens s t a b
+ Control.Lens.Utils: _7 :: Field7 s t a b => Lens s t a b
+ Control.Lens.Utils: _7' :: Field7 s t a b => Lens s t a b
+ Control.Lens.Utils: _8 :: Field8 s t a b => Lens s t a b
+ Control.Lens.Utils: _8' :: Field8 s t a b => Lens s t a b
+ Control.Lens.Utils: _9 :: Field9 s t a b => Lens s t a b
+ Control.Lens.Utils: _9' :: Field9 s t a b => Lens s t a b
+ Control.Lens.Utils: _Cons :: Cons s t a b => Prism s t (a, s) (b, t)
+ Control.Lens.Utils: _Empty :: AsEmpty a => Prism' a ()
+ Control.Lens.Utils: _GWrapped' :: (Generic s, D1 d (C1 c (S1 s' (Rec0 a))) ~ Rep s, Unwrapped s ~ GUnwrapped (Rep s)) => Iso' s (Unwrapped s)
+ Control.Lens.Utils: _Just :: () => Prism (Maybe a) (Maybe b) a b
+ Control.Lens.Utils: _Left :: () => Prism (Either a c) (Either b c) a b
+ Control.Lens.Utils: _Nothing :: () => Prism' (Maybe a) ()
+ Control.Lens.Utils: _Right :: () => Prism (Either c a) (Either c b) a b
+ Control.Lens.Utils: _Show :: (Read a, Show a) => Prism' String a
+ Control.Lens.Utils: _Snoc :: Snoc s t a b => Prism s t (s, a) (t, b)
+ Control.Lens.Utils: _Unwrapped :: Rewrapping s t => Iso (Unwrapped t) (Unwrapped s) t s
+ Control.Lens.Utils: _Unwrapped' :: Wrapped s => Iso' (Unwrapped s) s
+ Control.Lens.Utils: _Unwrapping :: Rewrapping s t => (Unwrapped s -> s) -> Iso (Unwrapped t) (Unwrapped s) t s
+ Control.Lens.Utils: _Unwrapping' :: Wrapped s => (Unwrapped s -> s) -> Iso' (Unwrapped s) s
+ Control.Lens.Utils: _Void :: () => Prism s s a Void
+ Control.Lens.Utils: _Wrapped :: Rewrapping s t => Iso s t (Unwrapped s) (Unwrapped t)
+ Control.Lens.Utils: _Wrapped' :: Wrapped s => Iso' s (Unwrapped s)
+ Control.Lens.Utils: _Wrapping :: Rewrapping s t => (Unwrapped s -> s) -> Iso s t (Unwrapped s) (Unwrapped t)
+ Control.Lens.Utils: _Wrapping' :: Wrapped s => (Unwrapped s -> s) -> Iso' s (Unwrapped s)
+ Control.Lens.Utils: _head :: Cons s s a a => Traversal' s a
+ Control.Lens.Utils: _init :: Snoc s s a a => Traversal' s s
+ Control.Lens.Utils: _last :: Snoc s s a a => Traversal' s a
+ Control.Lens.Utils: _tail :: Cons s s a a => Traversal' s s
+ Control.Lens.Utils: _unwrap :: (MonadReader s m, Rewrapped s s) => m (Unwrapped s)
+ Control.Lens.Utils: _wrap :: (MonadReader (Unwrapped t) m, Rewrapped t t) => m t
+ Control.Lens.Utils: abbreviatedFields :: LensRules
+ Control.Lens.Utils: abbreviatedNamer :: FieldNamer
+ Control.Lens.Utils: ala :: (Functor f, Rewrapping s t) => (Unwrapped s -> s) -> ((Unwrapped t -> t) -> f s) -> f (Unwrapped s)
+ Control.Lens.Utils: alaf :: (Functor f, Functor g, Rewrapping s t) => (Unwrapped s -> s) -> (f t -> g s) -> f (Unwrapped t) -> g (Unwrapped s)
+ Control.Lens.Utils: allOf :: () => Getting All s a -> (a -> Bool) -> s -> Bool
+ Control.Lens.Utils: alongside :: () => LensLike (AlongsideLeft f b') s t a b -> LensLike (AlongsideRight f t) s' t' a' b' -> LensLike f (s, s') (t, t') (a, a') (b, b')
+ Control.Lens.Utils: andOf :: () => Getting All s Bool -> s -> Bool
+ Control.Lens.Utils: anon :: () => a -> (a -> Bool) -> Iso' (Maybe a) a
+ Control.Lens.Utils: anyOf :: () => Getting Any s a -> (a -> Bool) -> s -> Bool
+ Control.Lens.Utils: argument :: Profunctor p => Setter (p b r) (p a r) a b
+ Control.Lens.Utils: asIndex :: (Indexable i p, Contravariant f, Functor f) => p i (f i) -> Indexed i s (f s)
+ Control.Lens.Utils: aside :: () => APrism s t a b -> Prism (e, s) (e, t) (e, a) (e, b)
+ Control.Lens.Utils: assign :: MonadState s m => ASetter s s a b -> b -> m ()
+ Control.Lens.Utils: assignA :: Arrow p => ASetter s t a b -> p s b -> p s t
+ Control.Lens.Utils: asumOf :: Alternative f => Getting (Endo (f a)) s (f a) -> s -> f a
+ Control.Lens.Utils: at :: At m => Index m -> Lens' m (Maybe (IxValue m))
+ Control.Lens.Utils: at' :: (Functor f, Ord p) => p -> (Maybe a -> f (Maybe a)) -> Maybe (Map p a) -> f (Maybe (Map p a))
+ Control.Lens.Utils: au :: Functor f => AnIso s t a b -> ((b -> t) -> f s) -> f a
+ Control.Lens.Utils: auf :: () => Optic (Costar f) g s t a b -> (f a -> g b) -> f s -> g t
+ Control.Lens.Utils: backwards :: (Profunctor p, Profunctor q) => Optical p q (Backwards f) s t a b -> Optical p q f s t a b
+ Control.Lens.Utils: below :: Traversable f => APrism' s a -> Prism' (f s) (f a)
+ Control.Lens.Utils: beside :: (Representable q, Applicative (Rep q), Applicative f, Bitraversable r) => Optical p q f s t a b -> Optical p q f s' t' a b -> Optical p q f (r s s') (r t t') a b
+ Control.Lens.Utils: bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
+ Control.Lens.Utils: bimapping :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> AnIso s' t' a' b' -> Iso (f s s') (g t t') (f a a') (g b b')
+ Control.Lens.Utils: both :: Bitraversable r => Traversal (r a a) (r b b) a b
+ Control.Lens.Utils: both1 :: Bitraversable1 r => Traversal1 (r a a) (r b b) a b
+ Control.Lens.Utils: camelCaseFields :: LensRules
+ Control.Lens.Utils: camelCaseNamer :: FieldNamer
+ Control.Lens.Utils: censoring :: MonadWriter w m => Setter w w u v -> (u -> v) -> m a -> m a
+ Control.Lens.Utils: children :: Plated a => a -> [a]
+ Control.Lens.Utils: choosing :: Functor f => LensLike f s t a b -> LensLike f s' t' a b -> LensLike f (Either s s') (Either t t') a b
+ Control.Lens.Utils: chosen :: () => IndexPreservingLens (Either a a) (Either b b) a b
+ Control.Lens.Utils: class AsEmpty a
+ Control.Lens.Utils: class Ixed m => At m
+ Control.Lens.Utils: class Bifunctor (p :: Type -> Type -> Type)
+ Control.Lens.Utils: class Profunctor p => Choice (p :: Type -> Type -> Type)
+ Control.Lens.Utils: class (Choice p, Corepresentable p, Comonad Corep p, Traversable Corep p, Strong p, Representable p, Monad Rep p, MonadFix Rep p, Distributive Rep p, Costrong p, ArrowLoop p, ArrowApply p, ArrowChoice p, Closed p) => Conjoined (p :: Type -> Type -> Type)
+ Control.Lens.Utils: class Cons s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Contains m
+ Control.Lens.Utils: class Contravariant (f :: Type -> Type)
+ Control.Lens.Utils: class Each s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field1 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field10 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field11 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field12 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field13 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field14 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field15 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field16 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field17 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field18 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field19 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field2 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field3 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field4 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field5 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field6 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field7 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field8 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Field9 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Foldable f => FoldableWithIndex i (f :: Type -> Type) | f -> i
+ Control.Lens.Utils: class Functor f => FunctorWithIndex i (f :: Type -> Type) | f -> i
+ Control.Lens.Utils: class GPlated a (g :: Type -> Type)
+ Control.Lens.Utils: class Conjoined p => Indexable i (p :: Type -> Type -> Type)
+ Control.Lens.Utils: class Ixed m
+ Control.Lens.Utils: class (Magnified m ~ Magnified n, MonadReader b m, MonadReader a n) => Magnify (m :: Type -> Type) (n :: Type -> Type) b a | m -> b, n -> a, m a -> n, n b -> m
+ Control.Lens.Utils: class Plated a
+ Control.Lens.Utils: class Profunctor (p :: Type -> Type -> Type)
+ Control.Lens.Utils: class Reversing t
+ Control.Lens.Utils: class (Profunctor p, Bifunctor p) => Reviewable (p :: Type -> Type -> Type)
+ Control.Lens.Utils: class Wrapped s => Rewrapped s t
+ Control.Lens.Utils: class (Rewrapped s t, Rewrapped t s) => Rewrapping s t
+ Control.Lens.Utils: class (Applicative f, Distributive f, Traversable f) => Settable (f :: Type -> Type)
+ Control.Lens.Utils: class Snoc s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Control.Lens.Utils: class Strict lazy strict | lazy -> strict, strict -> lazy
+ Control.Lens.Utils: class Bifunctor p => Swapped (p :: Type -> Type -> Type)
+ Control.Lens.Utils: class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
+ Control.Lens.Utils: class (Foldable1 t, Traversable t) => Traversable1 (t :: Type -> Type)
+ Control.Lens.Utils: class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t) => TraversableWithIndex i (t :: Type -> Type) | t -> i
+ Control.Lens.Utils: class Ord k => TraverseMax k (m :: Type -> Type) | m -> k
+ Control.Lens.Utils: class Ord k => TraverseMin k (m :: Type -> Type) | m -> k
+ Control.Lens.Utils: class Wrapped s where {
+ Control.Lens.Utils: class (MonadState s m, MonadState t n) => Zoom (m :: Type -> Type) (n :: Type -> Type) s t | m -> s, n -> t, m t -> n, n s -> m
+ Control.Lens.Utils: classUnderscoreNoPrefixFields :: LensRules
+ Control.Lens.Utils: classUnderscoreNoPrefixNamer :: FieldNamer
+ Control.Lens.Utils: classyRules :: LensRules
+ Control.Lens.Utils: classyRules_ :: LensRules
+ Control.Lens.Utils: cloneIndexPreservingLens :: () => ALens s t a b -> IndexPreservingLens s t a b
+ Control.Lens.Utils: cloneIndexPreservingSetter :: () => ASetter s t a b -> IndexPreservingSetter s t a b
+ Control.Lens.Utils: cloneIndexPreservingTraversal :: () => ATraversal s t a b -> IndexPreservingTraversal s t a b
+ Control.Lens.Utils: cloneIndexPreservingTraversal1 :: () => ATraversal1 s t a b -> IndexPreservingTraversal1 s t a b
+ Control.Lens.Utils: cloneIndexedLens :: () => AnIndexedLens i s t a b -> IndexedLens i s t a b
+ Control.Lens.Utils: cloneIndexedSetter :: () => AnIndexedSetter i s t a b -> IndexedSetter i s t a b
+ Control.Lens.Utils: cloneIndexedTraversal :: () => AnIndexedTraversal i s t a b -> IndexedTraversal i s t a b
+ Control.Lens.Utils: cloneIndexedTraversal1 :: () => AnIndexedTraversal1 i s t a b -> IndexedTraversal1 i s t a b
+ Control.Lens.Utils: cloneIso :: () => AnIso s t a b -> Iso s t a b
+ Control.Lens.Utils: cloneLens :: () => ALens s t a b -> Lens s t a b
+ Control.Lens.Utils: clonePrism :: () => APrism s t a b -> Prism s t a b
+ Control.Lens.Utils: cloneSetter :: () => ASetter s t a b -> Setter s t a b
+ Control.Lens.Utils: cloneTraversal :: () => ATraversal s t a b -> Traversal s t a b
+ Control.Lens.Utils: cloneTraversal1 :: () => ATraversal1 s t a b -> Traversal1 s t a b
+ Control.Lens.Utils: coerced :: (Coercible s a, Coercible t b) => Iso s t a b
+ Control.Lens.Utils: composOpFold :: Plated a => b -> (b -> b -> b) -> (a -> b) -> a -> b
+ Control.Lens.Utils: concatMapOf :: () => Getting [r] s a -> (a -> [r]) -> s -> [r]
+ Control.Lens.Utils: concatOf :: () => Getting [r] s [r] -> s -> [r]
+ Control.Lens.Utils: confusing :: Applicative f => LensLike (Curried (Yoneda f) (Yoneda f)) s t a b -> LensLike f s t a b
+ Control.Lens.Utils: conjoined :: Conjoined p => ((p ~ ((->) :: Type -> Type -> Type)) -> q (a -> b) r) -> q (p a b) r -> q (p a b) r
+ Control.Lens.Utils: cons :: Cons s s a a => a -> s -> s
+ Control.Lens.Utils: contains :: Contains m => Index m -> Lens' m Bool
+ Control.Lens.Utils: contexts :: Plated a => a -> [Context a a a]
+ Control.Lens.Utils: contextsOf :: () => ATraversal' a a -> a -> [Context a a a]
+ Control.Lens.Utils: contextsOn :: Plated a => ATraversal s t a a -> s -> [Context a a t]
+ Control.Lens.Utils: contextsOnOf :: () => ATraversal s t a a -> ATraversal' a a -> s -> [Context a a t]
+ Control.Lens.Utils: contramap :: Contravariant f => (a -> b) -> f b -> f a
+ Control.Lens.Utils: contramapped :: Contravariant f => Setter (f b) (f a) a b
+ Control.Lens.Utils: contramapping :: Contravariant f => AnIso s t a b -> Iso (f a) (f b) (f s) (f t)
+ Control.Lens.Utils: cosmos :: Plated a => Fold a a
+ Control.Lens.Utils: cosmosOf :: (Applicative f, Contravariant f) => LensLike' f a a -> LensLike' f a a
+ Control.Lens.Utils: cosmosOn :: (Applicative f, Contravariant f, Plated a) => LensLike' f s a -> LensLike' f s a
+ Control.Lens.Utils: cosmosOnOf :: (Applicative f, Contravariant f) => LensLike' f s a -> LensLike' f a a -> LensLike' f s a
+ Control.Lens.Utils: createClass :: Lens' LensRules Bool
+ Control.Lens.Utils: curried :: () => Iso ((a, b) -> c) ((d, e) -> f) (a -> b -> c) (d -> e -> f)
+ Control.Lens.Utils: cycled :: Apply f => LensLike f s t a b -> LensLike f s t a b
+ Control.Lens.Utils: data Context a b t
+ Control.Lens.Utils: data DefName
+ Control.Lens.Utils: data Leftmost a
+ Control.Lens.Utils: data LensRules
+ Control.Lens.Utils: data Level i a
+ Control.Lens.Utils: data Magma i t b a
+ Control.Lens.Utils: data Rightmost a
+ Control.Lens.Utils: data Sequenced a (m :: Type -> Type)
+ Control.Lens.Utils: data Traversed a (f :: Type -> Type)
+ Control.Lens.Utils: data Identical (a :: k) (b :: k1) (s :: k) (t :: k1) :: forall k k1. () => k -> k1 -> k -> k1 -> Type
+ Control.Lens.Utils: declareClassy :: DecsQ -> DecsQ
+ Control.Lens.Utils: declareClassyFor :: [(String, (String, String))] -> [(String, String)] -> DecsQ -> DecsQ
+ Control.Lens.Utils: declareFields :: DecsQ -> DecsQ
+ Control.Lens.Utils: declareLenses :: DecsQ -> DecsQ
+ Control.Lens.Utils: declareLensesFor :: [(String, String)] -> DecsQ -> DecsQ
+ Control.Lens.Utils: declareLensesWith :: LensRules -> DecsQ -> DecsQ
+ Control.Lens.Utils: declarePrisms :: DecsQ -> DecsQ
+ Control.Lens.Utils: declareWrapped :: DecsQ -> DecsQ
+ Control.Lens.Utils: deep :: (Conjoined p, Applicative f, Plated s) => Traversing p f s s a b -> Over p f s s a b
+ Control.Lens.Utils: deepOf :: (Conjoined p, Applicative f) => LensLike f s t s t -> Traversing p f s t a b -> Over p f s t a b
+ Control.Lens.Utils: defaultFieldRules :: LensRules
+ Control.Lens.Utils: devoid :: () => Over p f Void Void a b
+ Control.Lens.Utils: dimap :: Profunctor p => (a -> b) -> (c -> d) -> p b c -> p a d
+ Control.Lens.Utils: dimapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> AnIso s' t' a' b' -> Iso (p a s') (q b t') (p s a') (q t b')
+ Control.Lens.Utils: distrib :: (Conjoined p, Functor f) => p a b -> p (f a) (f b)
+ Control.Lens.Utils: dropping :: (Conjoined p, Applicative f) => Int -> Over p (Indexing f) s t a a -> Over p f s t a a
+ Control.Lens.Utils: droppingWhile :: (Conjoined p, Profunctor q, Applicative f) => (a -> Bool) -> Optical p q (Compose (State Bool) f) s t a a -> Optical p q f s t a a
+ Control.Lens.Utils: each :: Each s t a b => Traversal s t a b
+ Control.Lens.Utils: elemIndexOf :: Eq a => IndexedGetting i (First i) s a -> a -> s -> Maybe i
+ Control.Lens.Utils: elemIndicesOf :: Eq a => IndexedGetting i (Endo [i]) s a -> a -> s -> [i]
+ Control.Lens.Utils: elemOf :: Eq a => Getting Any s a -> a -> s -> Bool
+ Control.Lens.Utils: element :: Traversable t => Int -> IndexedTraversal' Int (t a) a
+ Control.Lens.Utils: elementOf :: Applicative f => LensLike (Indexing f) s t a a -> Int -> IndexedLensLike Int f s t a a
+ Control.Lens.Utils: elements :: Traversable t => (Int -> Bool) -> IndexedTraversal' Int (t a) a
+ Control.Lens.Utils: elementsOf :: Applicative f => LensLike (Indexing f) s t a a -> (Int -> Bool) -> IndexedLensLike Int f s t a a
+ Control.Lens.Utils: emptyMap :: Prism' (Map k a) ()
+ Control.Lens.Utils: enum :: Enum a => Iso' Int a
+ Control.Lens.Utils: failing :: (Conjoined p, Applicative f) => Traversing p f s t a b -> Over p f s t a b -> Over p f s t a b
+ Control.Lens.Utils: failover :: Alternative m => LensLike ((,) Any) s t a b -> (a -> b) -> s -> m t
+ Control.Lens.Utils: filtered :: (Choice p, Applicative f) => (a -> Bool) -> Optic' p f a a
+ Control.Lens.Utils: findIndexOf :: () => IndexedGetting i (First i) s a -> (a -> Bool) -> s -> Maybe i
+ Control.Lens.Utils: findIndicesOf :: () => IndexedGetting i (Endo [i]) s a -> (a -> Bool) -> s -> [i]
+ Control.Lens.Utils: findMOf :: Monad m => Getting (Endo (m (Maybe a))) s a -> (a -> m Bool) -> s -> m (Maybe a)
+ Control.Lens.Utils: findOf :: () => Getting (Endo (Maybe a)) s a -> (a -> Bool) -> s -> Maybe a
+ Control.Lens.Utils: first1Of :: () => Getting (First a) s a -> s -> a
+ Control.Lens.Utils: firstOf :: () => Getting (Leftmost a) s a -> s -> Maybe a
+ Control.Lens.Utils: firsting :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> Iso (f s x) (g t y) (f a x) (g b y)
+ Control.Lens.Utils: flipped :: () => Iso (a -> b -> c) (a' -> b' -> c') (b -> a -> c) (b' -> a' -> c')
+ Control.Lens.Utils: foldBy :: Foldable t => (a -> a -> a) -> a -> t a -> a
+ Control.Lens.Utils: foldByOf :: () => Fold s a -> (a -> a -> a) -> a -> s -> a
+ Control.Lens.Utils: foldMapBy :: Foldable t => (r -> r -> r) -> r -> (a -> r) -> t a -> r
+ Control.Lens.Utils: foldMapByOf :: () => Fold s a -> (r -> r -> r) -> r -> (a -> r) -> s -> r
+ Control.Lens.Utils: foldMapOf :: () => Getting r s a -> (a -> r) -> s -> r
+ Control.Lens.Utils: foldOf :: () => Getting a s a -> s -> a
+ Control.Lens.Utils: folded :: Foldable f => IndexedFold Int (f a) a
+ Control.Lens.Utils: folded64 :: Foldable f => IndexedFold Int64 (f a) a
+ Control.Lens.Utils: folding :: Foldable f => (s -> f a) -> Fold s a
+ Control.Lens.Utils: foldl1Of :: HasCallStack => Getting (Dual (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
+ Control.Lens.Utils: foldl1Of' :: HasCallStack => Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
+ Control.Lens.Utils: foldlMOf :: Monad m => Getting (Endo (r -> m r)) s a -> (r -> a -> m r) -> r -> s -> m r
+ Control.Lens.Utils: foldlOf :: () => Getting (Dual (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
+ Control.Lens.Utils: foldlOf' :: () => Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
+ Control.Lens.Utils: foldr1Of :: HasCallStack => Getting (Endo (Maybe a)) s a -> (a -> a -> a) -> s -> a
+ Control.Lens.Utils: foldr1Of' :: HasCallStack => Getting (Dual (Endo (Endo (Maybe a)))) s a -> (a -> a -> a) -> s -> a
+ Control.Lens.Utils: foldrMOf :: Monad m => Getting (Dual (Endo (r -> m r))) s a -> (a -> r -> m r) -> r -> s -> m r
+ Control.Lens.Utils: foldrOf :: () => Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
+ Control.Lens.Utils: foldrOf' :: () => Getting (Dual (Endo (Endo r))) s a -> (a -> r -> r) -> r -> s -> r
+ Control.Lens.Utils: foldring :: (Contravariant f, Applicative f) => ((a -> f a -> f a) -> f a -> s -> f a) -> LensLike f s t a b
+ Control.Lens.Utils: for1Of_ :: Functor f => Getting (TraversedF r f) s a -> s -> (a -> f r) -> f ()
+ Control.Lens.Utils: forMOf :: () => LensLike (WrappedMonad m) s t a b -> s -> (a -> m b) -> m t
+ Control.Lens.Utils: forMOf_ :: Monad m => Getting (Sequenced r m) s a -> s -> (a -> m r) -> m ()
+ Control.Lens.Utils: forOf :: () => LensLike f s t a b -> s -> (a -> f b) -> f t
+ Control.Lens.Utils: forOf_ :: Functor f => Getting (Traversed r f) s a -> s -> (a -> f r) -> f ()
+ Control.Lens.Utils: from :: () => AnIso s t a b -> Iso b a t s
+ Control.Lens.Utils: fromEq :: () => AnEquality s t a b -> Equality b a t s
+ Control.Lens.Utils: fusing :: Functor f => LensLike (Yoneda f) s t a b -> LensLike f s t a b
+ Control.Lens.Utils: generateLazyPatterns :: Lens' LensRules Bool
+ Control.Lens.Utils: generateSignatures :: Lens' LensRules Bool
+ Control.Lens.Utils: generateUpdateableOptics :: Lens' LensRules Bool
+ Control.Lens.Utils: getting :: (Profunctor p, Profunctor q, Functor f, Contravariant f) => Optical p q f s t a b -> Optical' p q f s a
+ Control.Lens.Utils: gplate :: (Generic a, GPlated a (Rep a)) => Traversal' a a
+ Control.Lens.Utils: has :: () => Getting Any s a -> s -> Bool
+ Control.Lens.Utils: hasn't :: () => Getting All s a -> s -> Bool
+ Control.Lens.Utils: holes :: Plated a => a -> [Pretext ((->) :: Type -> Type -> Type) a a a]
+ Control.Lens.Utils: holesOf :: Conjoined p => Over p (Bazaar p a a) s t a a -> s -> [Pretext p a a t]
+ Control.Lens.Utils: holesOn :: Conjoined p => Over p (Bazaar p a a) s t a a -> s -> [Pretext p a a t]
+ Control.Lens.Utils: holesOnOf :: Conjoined p => LensLike (Bazaar p r r) s t a b -> Over p (Bazaar p r r) a b r r -> s -> [Pretext p r r t]
+ Control.Lens.Utils: iall :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
+ Control.Lens.Utils: iallOf :: () => IndexedGetting i All s a -> (i -> a -> Bool) -> s -> Bool
+ Control.Lens.Utils: iany :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
+ Control.Lens.Utils: ianyOf :: () => IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
+ Control.Lens.Utils: iat :: At m => Index m -> IndexedLens' (Index m) m (Maybe (IxValue m))
+ Control.Lens.Utils: icensoring :: MonadWriter w m => IndexedSetter i w w u v -> (i -> u -> v) -> m a -> m a
+ Control.Lens.Utils: icompose :: Indexable p c => (i -> j -> p) -> (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> c a b -> r
+ Control.Lens.Utils: iconcatMap :: FoldableWithIndex i f => (i -> a -> [b]) -> f a -> [b]
+ Control.Lens.Utils: iconcatMapOf :: () => IndexedGetting i [r] s a -> (i -> a -> [r]) -> s -> [r]
+ Control.Lens.Utils: icontains :: Contains m => Index m -> IndexedLens' (Index m) m Bool
+ Control.Lens.Utils: idroppingWhile :: (Indexable i p, Profunctor q, Applicative f) => (i -> a -> Bool) -> Optical (Indexed i) q (Compose (State Bool) f) s t a a -> Optical p q f s t a a
+ Control.Lens.Utils: ifailover :: Alternative m => Over (Indexed i) ((,) Any) s t a b -> (i -> a -> b) -> s -> m t
+ Control.Lens.Utils: ifiltered :: (Indexable i p, Applicative f) => (i -> a -> Bool) -> Optical' p (Indexed i) f a a
+ Control.Lens.Utils: ifind :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Maybe (i, a)
+ Control.Lens.Utils: ifindMOf :: Monad m => IndexedGetting i (Endo (m (Maybe a))) s a -> (i -> a -> m Bool) -> s -> m (Maybe a)
+ Control.Lens.Utils: ifindOf :: () => IndexedGetting i (Endo (Maybe a)) s a -> (i -> a -> Bool) -> s -> Maybe a
+ Control.Lens.Utils: ifoldMap :: (FoldableWithIndex i f, Monoid m) => (i -> a -> m) -> f a -> m
+ Control.Lens.Utils: ifoldMapBy :: FoldableWithIndex i t => (r -> r -> r) -> r -> (i -> a -> r) -> t a -> r
+ Control.Lens.Utils: ifoldMapByOf :: () => IndexedFold i t a -> (r -> r -> r) -> r -> (i -> a -> r) -> t -> r
+ Control.Lens.Utils: ifoldMapOf :: () => IndexedGetting i m s a -> (i -> a -> m) -> s -> m
+ Control.Lens.Utils: ifolded :: FoldableWithIndex i f => IndexedFold i (f a) a
+ Control.Lens.Utils: ifolding :: (Foldable f, Indexable i p, Contravariant g, Applicative g) => (s -> f (i, a)) -> Over p g s t a b
+ Control.Lens.Utils: ifoldl :: FoldableWithIndex i f => (i -> b -> a -> b) -> b -> f a -> b
+ Control.Lens.Utils: ifoldl' :: FoldableWithIndex i f => (i -> b -> a -> b) -> b -> f a -> b
+ Control.Lens.Utils: ifoldlM :: (FoldableWithIndex i f, Monad m) => (i -> b -> a -> m b) -> b -> f a -> m b
+ Control.Lens.Utils: ifoldlMOf :: Monad m => IndexedGetting i (Endo (r -> m r)) s a -> (i -> r -> a -> m r) -> r -> s -> m r
+ Control.Lens.Utils: ifoldlOf :: () => IndexedGetting i (Dual (Endo r)) s a -> (i -> r -> a -> r) -> r -> s -> r
+ Control.Lens.Utils: ifoldlOf' :: () => IndexedGetting i (Endo (r -> r)) s a -> (i -> r -> a -> r) -> r -> s -> r
+ Control.Lens.Utils: ifoldr :: FoldableWithIndex i f => (i -> a -> b -> b) -> b -> f a -> b
+ Control.Lens.Utils: ifoldr' :: FoldableWithIndex i f => (i -> a -> b -> b) -> b -> f a -> b
+ Control.Lens.Utils: ifoldrM :: (FoldableWithIndex i f, Monad m) => (i -> a -> b -> m b) -> b -> f a -> m b
+ Control.Lens.Utils: ifoldrMOf :: Monad m => IndexedGetting i (Dual (Endo (r -> m r))) s a -> (i -> a -> r -> m r) -> r -> s -> m r
+ Control.Lens.Utils: ifoldrOf :: () => IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
+ Control.Lens.Utils: ifoldrOf' :: () => IndexedGetting i (Dual (Endo (r -> r))) s a -> (i -> a -> r -> r) -> r -> s -> r
+ Control.Lens.Utils: ifoldring :: (Indexable i p, Contravariant f, Applicative f) => ((i -> a -> f a -> f a) -> f a -> s -> f a) -> Over p f s t a b
+ Control.Lens.Utils: ifor :: (TraversableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f (t b)
+ Control.Lens.Utils: iforM :: (TraversableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m (t b)
+ Control.Lens.Utils: iforMOf :: () => (Indexed i a (WrappedMonad m b) -> s -> WrappedMonad m t) -> s -> (i -> a -> m b) -> m t
+ Control.Lens.Utils: iforMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> s -> (i -> a -> m r) -> m ()
+ Control.Lens.Utils: iforM_ :: (FoldableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m ()
+ Control.Lens.Utils: iforOf :: () => (Indexed i a (f b) -> s -> f t) -> s -> (i -> a -> f b) -> f t
+ Control.Lens.Utils: iforOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> s -> (i -> a -> f r) -> f ()
+ Control.Lens.Utils: ifor_ :: (FoldableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f ()
+ Control.Lens.Utils: ignored :: Applicative f => pafb -> s -> f s
+ Control.Lens.Utils: iix :: Ixed m => Index m -> IndexedTraversal' (Index m) m (IxValue m)
+ Control.Lens.Utils: ilens :: () => (s -> (i, a)) -> (s -> b -> t) -> IndexedLens i s t a b
+ Control.Lens.Utils: ilevels :: Applicative f => Traversing (Indexed i) f s t a b -> IndexedLensLike Int f s t (Level i a) (Level j b)
+ Control.Lens.Utils: ilike :: (Indexable i p, Contravariant f, Functor f) => i -> a -> Over' p f s a
+ Control.Lens.Utils: ilistening :: MonadWriter w m => IndexedGetting i (i, u) w u -> m a -> m (a, (i, u))
+ Control.Lens.Utils: ilistenings :: MonadWriter w m => IndexedGetting i v w u -> (i -> u -> v) -> m a -> m (a, v)
+ Control.Lens.Utils: iloci :: () => IndexedTraversal i (Bazaar (Indexed i) a c s) (Bazaar (Indexed i) b c s) a b
+ Control.Lens.Utils: imagma :: () => Over (Indexed i) (Molten i a b) s t a b -> Iso s t' (Magma i t b a) (Magma j t' c c)
+ Control.Lens.Utils: imap :: FunctorWithIndex i f => (i -> a -> b) -> f a -> f b
+ Control.Lens.Utils: imapAccumL :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)
+ Control.Lens.Utils: imapAccumLOf :: () => Over (Indexed i) (State acc) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
+ Control.Lens.Utils: imapAccumR :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)
+ Control.Lens.Utils: imapAccumROf :: () => Over (Indexed i) (Backwards (State acc)) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
+ Control.Lens.Utils: imapM :: (TraversableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m (t b)
+ Control.Lens.Utils: imapMOf :: () => Over (Indexed i) (WrappedMonad m) s t a b -> (i -> a -> m b) -> s -> m t
+ Control.Lens.Utils: imapMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> (i -> a -> m r) -> s -> m ()
+ Control.Lens.Utils: imapM_ :: (FoldableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m ()
+ Control.Lens.Utils: imapOf :: () => AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
+ Control.Lens.Utils: imapped :: FunctorWithIndex i f => IndexedSetter i (f a) (f b) a b
+ Control.Lens.Utils: imodifying :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m ()
+ Control.Lens.Utils: index :: (Indexable i p, Eq i, Applicative f) => i -> Optical' p (Indexed i) f a a
+ Control.Lens.Utils: indexed :: Indexable i p => p a b -> i -> a -> b
+ Control.Lens.Utils: indexing :: Indexable Int p => ((a -> Indexing f b) -> s -> Indexing f t) -> p a (f b) -> s -> f t
+ Control.Lens.Utils: indexing64 :: Indexable Int64 p => ((a -> Indexing64 f b) -> s -> Indexing64 f t) -> p a (f b) -> s -> f t
+ Control.Lens.Utils: indices :: (Indexable i p, Applicative f) => (i -> Bool) -> Optical' p (Indexed i) f a a
+ Control.Lens.Utils: infix 4 .=
+ Control.Lens.Utils: infixl 1 &~
+ Control.Lens.Utils: infixl 4 >$
+ Control.Lens.Utils: infixl 5 `failing`
+ Control.Lens.Utils: infixl 8 ^#
+ Control.Lens.Utils: infixr 2 <~
+ Control.Lens.Utils: infixr 4 %~
+ Control.Lens.Utils: infixr 5 :<
+ Control.Lens.Utils: infixr 8 #
+ Control.Lens.Utils: infixr 9 <.
+ Control.Lens.Utils: inone :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
+ Control.Lens.Utils: inoneOf :: () => IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
+ Control.Lens.Utils: inside :: Corepresentable p => ALens s t a b -> Lens (p e s) (p e t) (p e a) (p e b)
+ Control.Lens.Utils: involuted :: () => (a -> a) -> Iso' a a
+ Control.Lens.Utils: iover :: () => AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
+ Control.Lens.Utils: ipartsOf :: (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a a -> Over p f s t [a] [a]
+ Control.Lens.Utils: ipartsOf' :: (Indexable [i] p, Functor f) => Over (Indexed i) (Bazaar' (Indexed i) a) s t a a -> Over p f s t [a] [a]
+ Control.Lens.Utils: ipassing :: MonadWriter w m => IndexedSetter i w w u v -> m (a, i -> u -> v) -> m a
+ Control.Lens.Utils: iplens :: () => (s -> a) -> (s -> b -> t) -> IndexPreservingLens s t a b
+ Control.Lens.Utils: ipre :: () => IndexedGetting i (First (i, a)) s a -> IndexPreservingGetter s (Maybe (i, a))
+ Control.Lens.Utils: ipreuse :: MonadState s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
+ Control.Lens.Utils: ipreuses :: MonadState s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
+ Control.Lens.Utils: ipreview :: MonadReader s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
+ Control.Lens.Utils: ipreviews :: MonadReader s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
+ Control.Lens.Utils: iset :: () => AnIndexedSetter i s t a b -> (i -> b) -> s -> t
+ Control.Lens.Utils: isets :: () => ((i -> a -> b) -> s -> t) -> IndexedSetter i s t a b
+ Control.Lens.Utils: isn't :: () => APrism s t a b -> s -> Bool
+ Control.Lens.Utils: iso :: () => (s -> a) -> (b -> t) -> Iso s t a b
+ Control.Lens.Utils: itakingWhile :: (Indexable i p, Profunctor q, Contravariant f, Applicative f) => (i -> a -> Bool) -> Optical' (Indexed i) q (Const (Endo (f s)) :: Type -> Type) s a -> Optical' p q f s a
+ Control.Lens.Utils: iterated :: Apply f => (a -> a) -> LensLike' f a a
+ Control.Lens.Utils: ito :: (Indexable i p, Contravariant f) => (s -> (i, a)) -> Over' p f s a
+ Control.Lens.Utils: itoList :: FoldableWithIndex i f => f a -> [(i, a)]
+ Control.Lens.Utils: itoListOf :: () => IndexedGetting i (Endo [(i, a)]) s a -> s -> [(i, a)]
+ Control.Lens.Utils: itraverse :: (TraversableWithIndex i t, Applicative f) => (i -> a -> f b) -> t a -> f (t b)
+ Control.Lens.Utils: itraverseBy :: TraversableWithIndex i t => (forall x. () => x -> f x) -> (forall x y. () => f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> t a -> f (t b)
+ Control.Lens.Utils: itraverseByOf :: () => IndexedTraversal i s t a b -> (forall x. () => x -> f x) -> (forall x y. () => f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> s -> f t
+ Control.Lens.Utils: itraverseOf :: () => (Indexed i a (f b) -> s -> f t) -> (i -> a -> f b) -> s -> f t
+ Control.Lens.Utils: itraverseOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> (i -> a -> f r) -> s -> f ()
+ Control.Lens.Utils: itraverse_ :: (FoldableWithIndex i t, Applicative f) => (i -> a -> f b) -> t a -> f ()
+ Control.Lens.Utils: itraversed :: TraversableWithIndex i t => IndexedTraversal i (t a) (t b) a b
+ Control.Lens.Utils: iunsafePartsOf :: (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a b -> Over p f s t [a] [b]
+ Control.Lens.Utils: iunsafePartsOf' :: () => Over (Indexed i) (Bazaar (Indexed i) a b) s t a b -> IndexedLens [i] s t [a] [b]
+ Control.Lens.Utils: iuse :: MonadState s m => IndexedGetting i (i, a) s a -> m (i, a)
+ Control.Lens.Utils: iuses :: MonadState s m => IndexedGetting i r s a -> (i -> a -> r) -> m r
+ Control.Lens.Utils: iview :: MonadReader s m => IndexedGetting i (i, a) s a -> m (i, a)
+ Control.Lens.Utils: iviews :: MonadReader s m => IndexedGetting i r s a -> (i -> a -> r) -> m r
+ Control.Lens.Utils: ix :: Ixed m => Index m -> Traversal' m (IxValue m)
+ Control.Lens.Utils: ixAt :: At m => Index m -> Traversal' m (IxValue m)
+ Control.Lens.Utils: last1Of :: () => Getting (Last a) s a -> s -> a
+ Control.Lens.Utils: lastOf :: () => Getting (Rightmost a) s a -> s -> Maybe a
+ Control.Lens.Utils: lazy :: Strict lazy strict => Iso' strict lazy
+ Control.Lens.Utils: left' :: Choice p => p a b -> p (Either a c) (Either b c)
+ Control.Lens.Utils: lengthOf :: () => Getting (Endo (Endo Int)) s a -> s -> Int
+ Control.Lens.Utils: lens :: () => (s -> a) -> (s -> b -> t) -> Lens s t a b
+ Control.Lens.Utils: lensClass :: Lens' LensRules ClassyNamer
+ Control.Lens.Utils: lensField :: Lens' LensRules FieldNamer
+ Control.Lens.Utils: lensRules :: LensRules
+ Control.Lens.Utils: lensRulesFor :: [(String, String)] -> LensRules
+ Control.Lens.Utils: levels :: Applicative f => Traversing ((->) :: Type -> Type -> Type) f s t a b -> IndexedLensLike Int f s t (Level () a) (Level () b)
+ Control.Lens.Utils: lifted :: Monad m => Setter (m a) (m b) a b
+ Control.Lens.Utils: like :: (Profunctor p, Contravariant f, Functor f) => a -> Optic' p f s a
+ Control.Lens.Utils: lined :: Applicative f => IndexedLensLike' Int f String String
+ Control.Lens.Utils: listening :: MonadWriter w m => Getting u w u -> m a -> m (a, u)
+ Control.Lens.Utils: listenings :: MonadWriter w m => Getting v w u -> (u -> v) -> m a -> m (a, v)
+ Control.Lens.Utils: lmap :: Profunctor p => (a -> b) -> p b c -> p a c
+ Control.Lens.Utils: lmapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> Iso (p a x) (q b y) (p s x) (q t y)
+ Control.Lens.Utils: loci :: () => Traversal (Bazaar ((->) :: Type -> Type -> Type) a c s) (Bazaar ((->) :: Type -> Type -> Type) b c s) a b
+ Control.Lens.Utils: locus :: IndexedComonadStore p => Lens (p a c s) (p b c s) a b
+ Control.Lens.Utils: lookingupNamer :: [(String, String)] -> FieldNamer
+ Control.Lens.Utils: lookupOf :: Eq k => Getting (Endo (Maybe v)) s (k, v) -> k -> s -> Maybe v
+ Control.Lens.Utils: magma :: () => LensLike (Mafic a b) s t a b -> Iso s u (Magma Int t b a) (Magma j u c c)
+ Control.Lens.Utils: magnify :: Magnify m n b a => LensLike' (Magnified m c) a b -> m c -> n c
+ Control.Lens.Utils: makeClassy :: Name -> DecsQ
+ Control.Lens.Utils: makeClassy' :: Name -> DecsQ
+ Control.Lens.Utils: makeClassyFor :: String -> String -> [(String, String)] -> Name -> DecsQ
+ Control.Lens.Utils: makeClassyPrisms :: Name -> DecsQ
+ Control.Lens.Utils: makeClassy_ :: Name -> DecsQ
+ Control.Lens.Utils: makeFields :: Name -> DecsQ
+ Control.Lens.Utils: makeFieldsNoPrefix :: Name -> DecsQ
+ Control.Lens.Utils: makeLenses :: Name -> DecsQ
+ Control.Lens.Utils: makeLenses' :: Name -> DecsQ
+ Control.Lens.Utils: makeLensesFor :: [(String, String)] -> Name -> DecsQ
+ Control.Lens.Utils: makeLensesWith :: LensRules -> Name -> DecsQ
+ Control.Lens.Utils: makePrisms :: Name -> DecsQ
+ Control.Lens.Utils: makeWrapped :: Name -> DecsQ
+ Control.Lens.Utils: mapAccumLOf :: () => LensLike (State acc) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
+ Control.Lens.Utils: mapAccumROf :: () => LensLike (Backwards (State acc)) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
+ Control.Lens.Utils: mapEq :: () => AnEquality s t a b -> f s -> f a
+ Control.Lens.Utils: mapMOf :: () => LensLike (WrappedMonad m) s t a b -> (a -> m b) -> s -> m t
+ Control.Lens.Utils: mapMOf_ :: Monad m => Getting (Sequenced r m) s a -> (a -> m r) -> s -> m ()
+ Control.Lens.Utils: mapOf :: () => ASetter s t a b -> (a -> b) -> s -> t
+ Control.Lens.Utils: mapped :: Functor f => Setter (f a) (f b) a b
+ Control.Lens.Utils: mapping :: (Functor f, Functor g) => AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
+ Control.Lens.Utils: mappingNamer :: (String -> [String]) -> FieldNamer
+ Control.Lens.Utils: matching :: () => APrism s t a b -> s -> Either t a
+ Control.Lens.Utils: maximum1Of :: Ord a => Getting (Max a) s a -> s -> a
+ Control.Lens.Utils: maximumByOf :: () => Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a
+ Control.Lens.Utils: maximumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
+ Control.Lens.Utils: minimum1Of :: Ord a => Getting (Min a) s a -> s -> a
+ Control.Lens.Utils: minimumByOf :: () => Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a
+ Control.Lens.Utils: minimumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
+ Control.Lens.Utils: modifying :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()
+ Control.Lens.Utils: msumOf :: MonadPlus m => Getting (Endo (m a)) s (m a) -> s -> m a
+ Control.Lens.Utils: nearly :: () => a -> (a -> Bool) -> Prism' a ()
+ Control.Lens.Utils: nestedAt :: (NestedAtCtx a, Mempty (IxValue a)) => NonEmpty (Index a) -> Lens' a (Maybe (IxValue a))
+ Control.Lens.Utils: nestedAt' :: (NestedAtCtx a, Mempty (IxValue a)) => NonEmpty (Index a) -> Lens' a (IxValue a)
+ Control.Lens.Utils: nestedDefAt :: NestedAtCtx a => IxValue a -> NonEmpty (Index a) -> Lens' a (Maybe (IxValue a))
+ Control.Lens.Utils: nestedIx :: NestedIxedCtx a => NonEmpty (Index a) -> Traversal' a (IxValue a)
+ Control.Lens.Utils: newtype Bazaar (p :: Type -> Type -> Type) a b t
+ Control.Lens.Utils: newtype Bazaar1 (p :: Type -> Type -> Type) a b t
+ Control.Lens.Utils: newtype Identity a
+ Control.Lens.Utils: newtype Indexed i a b
+ Control.Lens.Utils: newtype ReifiedFold s a
+ Control.Lens.Utils: newtype ReifiedGetter s a
+ Control.Lens.Utils: newtype ReifiedIndexedFold i s a
+ Control.Lens.Utils: newtype ReifiedIndexedGetter i s a
+ Control.Lens.Utils: newtype ReifiedIndexedLens i s t a b
+ Control.Lens.Utils: newtype ReifiedIndexedSetter i s t a b
+ Control.Lens.Utils: newtype ReifiedIndexedTraversal i s t a b
+ Control.Lens.Utils: newtype ReifiedIso s t a b
+ Control.Lens.Utils: newtype ReifiedLens s t a b
+ Control.Lens.Utils: newtype ReifiedPrism s t a b
+ Control.Lens.Utils: newtype ReifiedSetter s t a b
+ Control.Lens.Utils: newtype ReifiedTraversal s t a b
+ Control.Lens.Utils: newtype Const a (b :: k) :: forall k. () => Type -> k -> Type
+ Control.Lens.Utils: non :: Eq a => a -> Iso' (Maybe a) a
+ Control.Lens.Utils: non' :: () => APrism' a () -> Iso' (Maybe a) a
+ Control.Lens.Utils: none :: Foldable f => (a -> Bool) -> f a -> Bool
+ Control.Lens.Utils: noneOf :: () => Getting Any s a -> (a -> Bool) -> s -> Bool
+ Control.Lens.Utils: notElemOf :: Eq a => Getting All s a -> a -> s -> Bool
+ Control.Lens.Utils: notNullOf :: () => Getting Any s a -> s -> Bool
+ Control.Lens.Utils: nullOf :: () => Getting All s a -> s -> Bool
+ Control.Lens.Utils: only :: Eq a => a -> Prism' a ()
+ Control.Lens.Utils: op :: Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
+ Control.Lens.Utils: orOf :: () => Getting Any s Bool -> s -> Bool
+ Control.Lens.Utils: outside :: Representable p => APrism s t a b -> Lens (p t r) (p s r) (p b r) (p a r)
+ Control.Lens.Utils: over :: () => ASetter s t a b -> (a -> b) -> s -> t
+ Control.Lens.Utils: overA :: Arrow ar => LensLike (Context a b) s t a b -> ar a b -> ar s t
+ Control.Lens.Utils: para :: Plated a => (a -> [r] -> r) -> a -> r
+ Control.Lens.Utils: paraOf :: () => Getting (Endo [a]) a a -> (a -> [r] -> r) -> a -> r
+ Control.Lens.Utils: parts :: Plated a => Lens' a [a]
+ Control.Lens.Utils: partsOf :: Functor f => Traversing ((->) :: Type -> Type -> Type) f s t a a -> LensLike f s t [a] [a]
+ Control.Lens.Utils: partsOf' :: () => ATraversal s t a a -> Lens s t [a] [a]
+ Control.Lens.Utils: passing :: MonadWriter w m => Setter w w u v -> m (a, u -> v) -> m a
+ Control.Lens.Utils: plate :: Plated a => Traversal' a a
+ Control.Lens.Utils: pre :: () => Getting (First a) s a -> IndexPreservingGetter s (Maybe a)
+ Control.Lens.Utils: preuse :: MonadState s m => Getting (First a) s a -> m (Maybe a)
+ Control.Lens.Utils: preuses :: MonadState s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
+ Control.Lens.Utils: preview :: MonadReader s m => Getting (First a) s a -> m (Maybe a)
+ Control.Lens.Utils: previews :: MonadReader s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
+ Control.Lens.Utils: prism :: () => (b -> t) -> (s -> Either t a) -> Prism s t a b
+ Control.Lens.Utils: prism' :: () => (b -> s) -> (s -> Maybe a) -> Prism s s a b
+ Control.Lens.Utils: productOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a
+ Control.Lens.Utils: re :: () => AReview t b -> Getter b t
+ Control.Lens.Utils: reindexed :: Indexable j p => (i -> j) -> (Indexed i a b -> r) -> p a b -> r
+ Control.Lens.Utils: repeated :: Apply f => LensLike' f a a
+ Control.Lens.Utils: replicated :: () => Int -> Fold a a
+ Control.Lens.Utils: retagged :: (Profunctor p, Bifunctor p) => p a b -> p s b
+ Control.Lens.Utils: reuse :: MonadState b m => AReview t b -> m t
+ Control.Lens.Utils: reuses :: MonadState b m => AReview t b -> (t -> r) -> m r
+ Control.Lens.Utils: reversed :: Reversing a => Iso' a a
+ Control.Lens.Utils: reversing :: Reversing t => t -> t
+ Control.Lens.Utils: review :: MonadReader b m => AReview t b -> m t
+ Control.Lens.Utils: reviews :: MonadReader b m => AReview t b -> (t -> r) -> m r
+ Control.Lens.Utils: rewrap :: (Rewrapped s t, Rewrapped t s, Unwrapped t ~# Unwrapped s) => s -> t
+ Control.Lens.Utils: rewrite :: Plated a => (a -> Maybe a) -> a -> a
+ Control.Lens.Utils: rewriteM :: (Monad m, Plated a) => (a -> m (Maybe a)) -> a -> m a
+ Control.Lens.Utils: rewriteMOf :: Monad m => LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> a -> m b
+ Control.Lens.Utils: rewriteMOn :: (Monad m, Plated a) => LensLike (WrappedMonad m) s t a a -> (a -> m (Maybe a)) -> s -> m t
+ Control.Lens.Utils: rewriteMOnOf :: Monad m => LensLike (WrappedMonad m) s t a b -> LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> s -> m t
+ Control.Lens.Utils: rewriteOf :: () => ASetter a b a b -> (b -> Maybe a) -> a -> b
+ Control.Lens.Utils: rewriteOn :: Plated a => ASetter s t a a -> (a -> Maybe a) -> s -> t
+ Control.Lens.Utils: rewriteOnOf :: () => ASetter s t a b -> ASetter a b a b -> (b -> Maybe a) -> s -> t
+ Control.Lens.Utils: right' :: Choice p => p a b -> p (Either c a) (Either c b)
+ Control.Lens.Utils: rmap :: Profunctor p => (b -> c) -> p a b -> p a c
+ Control.Lens.Utils: rmapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> Iso (p x s) (q y t) (p x a) (q y b)
+ Control.Lens.Utils: runEq :: () => AnEquality s t a b -> Identical s t a b
+ Control.Lens.Utils: sans :: At m => Index m -> m -> m
+ Control.Lens.Utils: scanl1Of :: () => LensLike (State (Maybe a)) s t a a -> (a -> a -> a) -> s -> t
+ Control.Lens.Utils: scanr1Of :: () => LensLike (Backwards (State (Maybe a))) s t a a -> (a -> a -> a) -> s -> t
+ Control.Lens.Utils: scribe :: (MonadWriter t m, Monoid s) => ASetter s t a b -> b -> m ()
+ Control.Lens.Utils: seconding :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> Iso (f x s) (g y t) (f x a) (g y b)
+ Control.Lens.Utils: selfIndex :: Indexable a p => p a fb -> a -> fb
+ Control.Lens.Utils: sequence1Of_ :: Functor f => Getting (TraversedF a f) s (f a) -> s -> f ()
+ Control.Lens.Utils: sequenceAOf :: () => LensLike f s t (f b) b -> s -> f t
+ Control.Lens.Utils: sequenceAOf_ :: Functor f => Getting (Traversed a f) s (f a) -> s -> f ()
+ Control.Lens.Utils: sequenceBy :: Traversable t => (forall x. () => x -> f x) -> (forall x y. () => f (x -> y) -> f x -> f y) -> t (f a) -> f (t a)
+ Control.Lens.Utils: sequenceByOf :: () => Traversal s t (f b) b -> (forall x. () => x -> f x) -> (forall x y. () => f (x -> y) -> f x -> f y) -> s -> f t
+ Control.Lens.Utils: sequenceOf :: () => LensLike (WrappedMonad m) s t (m b) b -> s -> m t
+ Control.Lens.Utils: sequenceOf_ :: Monad m => Getting (Sequenced a m) s (m a) -> s -> m ()
+ Control.Lens.Utils: set :: () => ASetter s t a b -> b -> s -> t
+ Control.Lens.Utils: set' :: () => ASetter' s a -> a -> s -> s
+ Control.Lens.Utils: sets :: (Profunctor p, Profunctor q, Settable f) => (p a b -> q s t) -> Optical p q f s t a b
+ Control.Lens.Utils: setting :: () => ((a -> b) -> s -> t) -> IndexPreservingSetter s t a b
+ Control.Lens.Utils: simple :: () => Equality' a a
+ Control.Lens.Utils: simpleLenses :: Lens' LensRules Bool
+ Control.Lens.Utils: simply :: () => (Optic' p f s a -> r) -> Optic' p f s a -> r
+ Control.Lens.Utils: singular :: (HasCallStack, Conjoined p, Functor f) => Traversing p f s t a a -> Over p f s t a a
+ Control.Lens.Utils: snoc :: Snoc s s a a => s -> a -> s
+ Control.Lens.Utils: storing :: () => ALens s t a b -> b -> s -> t
+ Control.Lens.Utils: strict :: Strict lazy strict => Iso' lazy strict
+ Control.Lens.Utils: subMapAt :: (Functor f, Ord p) => p -> (Maybe a -> f (Maybe a)) -> Maybe (Map p a) -> f (Maybe (Map p a))
+ Control.Lens.Utils: substEq :: () => AnEquality s t a b -> ((s ~ a) -> (t ~ b) -> r) -> r
+ Control.Lens.Utils: sumOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a
+ Control.Lens.Utils: swapped :: Swapped p => Iso (p a b) (p c d) (p b a) (p d c)
+ Control.Lens.Utils: taking :: (Conjoined p, Applicative f) => Int -> Traversing p f s t a a -> Over p f s t a a
+ Control.Lens.Utils: takingWhile :: (Conjoined p, Applicative f) => (a -> Bool) -> Over p (TakingWhile p f a a) s t a a -> Over p f s t a a
+ Control.Lens.Utils: to :: (Profunctor p, Contravariant f) => (s -> a) -> Optic' p f s a
+ Control.Lens.Utils: toListOf :: () => Getting (Endo [a]) s a -> s -> [a]
+ Control.Lens.Utils: toNonEmptyOf :: () => Getting (NonEmptyDList a) s a -> s -> NonEmpty a
+ Control.Lens.Utils: transform :: Plated a => (a -> a) -> a -> a
+ Control.Lens.Utils: transformM :: (Monad m, Plated a) => (a -> m a) -> a -> m a
+ Control.Lens.Utils: transformMOf :: Monad m => LensLike (WrappedMonad m) a b a b -> (b -> m b) -> a -> m b
+ Control.Lens.Utils: transformMOn :: (Monad m, Plated a) => LensLike (WrappedMonad m) s t a a -> (a -> m a) -> s -> m t
+ Control.Lens.Utils: transformMOnOf :: Monad m => LensLike (WrappedMonad m) s t a b -> LensLike (WrappedMonad m) a b a b -> (b -> m b) -> s -> m t
+ Control.Lens.Utils: transformOf :: () => ASetter a b a b -> (b -> b) -> a -> b
+ Control.Lens.Utils: transformOn :: Plated a => ASetter s t a a -> (a -> a) -> s -> t
+ Control.Lens.Utils: transformOnOf :: () => ASetter s t a b -> ASetter a b a b -> (b -> b) -> s -> t
+ Control.Lens.Utils: transposeOf :: () => LensLike ZipList s t [a] a -> s -> [t]
+ Control.Lens.Utils: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
+ Control.Lens.Utils: traverse1 :: (Traversable1 t, Apply f) => (a -> f b) -> t a -> f (t b)
+ Control.Lens.Utils: traverse1Of_ :: Functor f => Getting (TraversedF r f) s a -> (a -> f r) -> s -> f ()
+ Control.Lens.Utils: traverseBy :: Traversable t => (forall x. () => x -> f x) -> (forall x y. () => f (x -> y) -> f x -> f y) -> (a -> f b) -> t a -> f (t b)
+ Control.Lens.Utils: traverseByOf :: () => Traversal s t a b -> (forall x. () => x -> f x) -> (forall x y. () => f (x -> y) -> f x -> f y) -> (a -> f b) -> s -> f t
+ Control.Lens.Utils: traverseMax :: TraverseMax k m => IndexedTraversal' k (m v) v
+ Control.Lens.Utils: traverseMin :: TraverseMin k m => IndexedTraversal' k (m v) v
+ Control.Lens.Utils: traverseOf :: () => LensLike f s t a b -> (a -> f b) -> s -> f t
+ Control.Lens.Utils: traverseOf_ :: Functor f => Getting (Traversed r f) s a -> (a -> f r) -> s -> f ()
+ Control.Lens.Utils: traversed :: Traversable f => IndexedTraversal Int (f a) (f b) a b
+ Control.Lens.Utils: traversed1 :: Traversable1 f => IndexedTraversal1 Int (f a) (f b) a b
+ Control.Lens.Utils: traversed64 :: Traversable f => IndexedTraversal Int64 (f a) (f b) a b
+ Control.Lens.Utils: type ALens s t a b = LensLike Pretext ((->) :: Type -> Type -> Type) a b s t a b
+ Control.Lens.Utils: type ALens' s a = ALens s s a a
+ Control.Lens.Utils: type APrism s t a b = Market a b a Identity b -> Market a b s Identity t
+ Control.Lens.Utils: type APrism' s a = APrism s s a a
+ Control.Lens.Utils: type AReview t b = Optic' (Tagged :: Type -> Type -> Type) Identity t b
+ Control.Lens.Utils: type ASetter s t a b = a -> Identity b -> s -> Identity t
+ Control.Lens.Utils: type ASetter' s a = ASetter s s a a
+ Control.Lens.Utils: type ATraversal s t a b = LensLike Bazaar ((->) :: Type -> Type -> Type) a b s t a b
+ Control.Lens.Utils: type ATraversal' s a = ATraversal s s a a
+ Control.Lens.Utils: type ATraversal1 s t a b = LensLike Bazaar1 ((->) :: Type -> Type -> Type) a b s t a b
+ Control.Lens.Utils: type ATraversal1' s a = ATraversal1 s s a a
+ Control.Lens.Utils: type Accessing (p :: Type -> Type -> Type) m s a = p a Const m a -> s -> Const m s
+ Control.Lens.Utils: type AnEquality (s :: k1) (t :: k2) (a :: k1) (b :: k2) = Identical a Proxy b a Proxy b -> Identical a Proxy b s Proxy t
+ Control.Lens.Utils: type AnEquality' (s :: k2) (a :: k2) = AnEquality s s a a
+ Control.Lens.Utils: type AnIndexedLens i s t a b = Optical Indexed i ((->) :: Type -> Type -> Type) Pretext Indexed i a b s t a b
+ Control.Lens.Utils: type AnIndexedLens' i s a = AnIndexedLens i s s a a
+ Control.Lens.Utils: type AnIndexedSetter i s t a b = Indexed i a Identity b -> s -> Identity t
+ Control.Lens.Utils: type AnIndexedSetter' i s a = AnIndexedSetter i s s a a
+ Control.Lens.Utils: type AnIndexedTraversal i s t a b = Over Indexed i Bazaar Indexed i a b s t a b
+ Control.Lens.Utils: type AnIndexedTraversal' i s a = AnIndexedTraversal i s s a a
+ Control.Lens.Utils: type AnIndexedTraversal1 i s t a b = Over Indexed i Bazaar1 Indexed i a b s t a b
+ Control.Lens.Utils: type AnIndexedTraversal1' i s a = AnIndexedTraversal1 i s s a a
+ Control.Lens.Utils: type AnIso s t a b = Exchange a b a Identity b -> Exchange a b s Identity t
+ Control.Lens.Utils: type AnIso' s a = AnIso s s a a
+ Control.Lens.Utils: type As (a :: k2) = Equality' a a
+ Control.Lens.Utils: type Bazaar' (p :: Type -> Type -> Type) a = Bazaar p a a
+ Control.Lens.Utils: type Bazaar1' (p :: Type -> Type -> Type) a = Bazaar1 p a a
+ Control.Lens.Utils: type ClassyNamer = Name -> Maybe (Name, Name)
+ Control.Lens.Utils: type Context' a = Context a a
+ Control.Lens.Utils: type Equality' (s :: k2) (a :: k2) = Equality s s a a
+ Control.Lens.Utils: type FieldNamer = Name -> [Name] -> Name -> [DefName]
+ Control.Lens.Utils: type Getting r s a = a -> Const r a -> s -> Const r s
+ Control.Lens.Utils: type IndexPreservingLens' s a = IndexPreservingLens s s a a
+ Control.Lens.Utils: type IndexPreservingSetter' s a = IndexPreservingSetter s s a a
+ Control.Lens.Utils: type IndexPreservingTraversal' s a = IndexPreservingTraversal s s a a
+ Control.Lens.Utils: type IndexPreservingTraversal1' s a = IndexPreservingTraversal1 s s a a
+ Control.Lens.Utils: type IndexedGetting i m s a = Indexed i a Const m a -> s -> Const m s
+ Control.Lens.Utils: type IndexedLens' i s a = IndexedLens i s s a a
+ Control.Lens.Utils: type IndexedLensLike' i (f :: Type -> Type) s a = IndexedLensLike i f s s a a
+ Control.Lens.Utils: type IndexedSetter' i s a = IndexedSetter i s s a a
+ Control.Lens.Utils: type IndexedTraversal' i s a = IndexedTraversal i s s a a
+ Control.Lens.Utils: type IndexedTraversal1' i s a = IndexedTraversal1 i s s a a
+ Control.Lens.Utils: type Iso' s a = Iso s s a a
+ Control.Lens.Utils: type Lens' s a = Lens s s a a
+ Control.Lens.Utils: type LensLike (f :: k -> Type) s (t :: k) a (b :: k) = a -> f b -> s -> f t
+ Control.Lens.Utils: type LensLike' (f :: Type -> Type) s a = LensLike f s s a a
+ Control.Lens.Utils: type NestedAtCtx a = (NestedCtx a, At a, At (IxValue a))
+ Control.Lens.Utils: type NestedCtx a = (Index a ~ Index (IxValue a), IxValue a ~ IxValue (IxValue a))
+ Control.Lens.Utils: type NestedIxedCtx a = (NestedCtx a, Ixed a, Ixed (IxValue a))
+ Control.Lens.Utils: type Optic (p :: k1 -> k -> Type) (f :: k2 -> k) (s :: k1) (t :: k2) (a :: k1) (b :: k2) = p a f b -> p s f t
+ Control.Lens.Utils: type Optic' (p :: k1 -> k -> Type) (f :: k1 -> k) (s :: k1) (a :: k1) = Optic p f s s a a
+ Control.Lens.Utils: type Optical (p :: k2 -> k -> Type) (q :: k1 -> k -> Type) (f :: k3 -> k) (s :: k1) (t :: k3) (a :: k2) (b :: k3) = p a f b -> q s f t
+ Control.Lens.Utils: type Optical' (p :: k1 -> k -> Type) (q :: k1 -> k -> Type) (f :: k1 -> k) (s :: k1) (a :: k1) = Optical p q f s s a a
+ Control.Lens.Utils: type Over (p :: k -> Type -> Type) (f :: k1 -> Type) s (t :: k1) (a :: k) (b :: k1) = p a f b -> s -> f t
+ Control.Lens.Utils: type Over' (p :: Type -> Type -> Type) (f :: Type -> Type) s a = Over p f s s a a
+ Control.Lens.Utils: type Prism' s a = Prism s s a a
+ Control.Lens.Utils: type ReifiedIndexedLens' i s a = ReifiedIndexedLens i s s a a
+ Control.Lens.Utils: type ReifiedIndexedSetter' i s a = ReifiedIndexedSetter i s s a a
+ Control.Lens.Utils: type ReifiedIndexedTraversal' i s a = ReifiedIndexedTraversal i s s a a
+ Control.Lens.Utils: type ReifiedIso' s a = ReifiedIso s s a a
+ Control.Lens.Utils: type ReifiedLens' s a = ReifiedLens s s a a
+ Control.Lens.Utils: type ReifiedPrism' s a = ReifiedPrism s s a a
+ Control.Lens.Utils: type ReifiedSetter' s a = ReifiedSetter s s a a
+ Control.Lens.Utils: type ReifiedTraversal' s a = ReifiedTraversal s s a a
+ Control.Lens.Utils: type Setter' s a = Setter s s a a
+ Control.Lens.Utils: type Setting (p :: Type -> Type -> Type) s t a b = p a Identity b -> s -> Identity t
+ Control.Lens.Utils: type Setting' (p :: Type -> Type -> Type) s a = Setting p s s a a
+ Control.Lens.Utils: type Simple (f :: k -> k -> k1 -> k1 -> k2) (s :: k) (a :: k1) = f s s a a
+ Control.Lens.Utils: type Traversal' s a = Traversal s s a a
+ Control.Lens.Utils: type Traversal1' s a = Traversal1 s s a a
+ Control.Lens.Utils: type Traversing (p :: Type -> Type -> Type) (f :: Type -> Type) s t a b = Over p BazaarT p f a b s t a b
+ Control.Lens.Utils: type Traversing' (p :: Type -> Type -> Type) (f :: Type -> Type) s a = Traversing p f s s a a
+ Control.Lens.Utils: type Traversing1 (p :: Type -> Type -> Type) (f :: Type -> Type) s t a b = Over p BazaarT1 p f a b s t a b
+ Control.Lens.Utils: type Traversing1' (p :: Type -> Type -> Type) (f :: Type -> Type) s a = Traversing1 p f s s a a
+ Control.Lens.Utils: type Fold1 s a = forall (f :: Type -> Type). (Contravariant f, Apply f) => a -> f a -> s -> f s
+ Control.Lens.Utils: type family Unwrapped s :: Type;
+ Control.Lens.Utils: type IndexedLensLike i (f :: k -> Type) s (t :: k) a (b :: k) = forall (p :: Type -> Type -> Type). Indexable i p => p a f b -> s -> f t
+ Control.Lens.Utils: un :: (Profunctor p, Bifunctor p, Functor f) => Getting a s a -> Optic' p f a s
+ Control.Lens.Utils: uncons :: Cons s s a a => s -> Maybe (a, s)
+ Control.Lens.Utils: uncurried :: () => Iso (a -> b -> c) (d -> e -> f) ((a, b) -> c) ((d, e) -> f)
+ Control.Lens.Utils: under :: () => AnIso s t a b -> (t -> s) -> b -> a
+ Control.Lens.Utils: underscoreFields :: LensRules
+ Control.Lens.Utils: underscoreNamer :: FieldNamer
+ Control.Lens.Utils: underscoreNoPrefixNamer :: FieldNamer
+ Control.Lens.Utils: unfolded :: () => (b -> Maybe (a, b)) -> Fold b a
+ Control.Lens.Utils: united :: () => Lens' a ()
+ Control.Lens.Utils: universe :: Plated a => a -> [a]
+ Control.Lens.Utils: universeOf :: () => Getting [a] a a -> a -> [a]
+ Control.Lens.Utils: universeOn :: Plated a => Getting [a] s a -> s -> [a]
+ Control.Lens.Utils: universeOnOf :: () => Getting [a] s a -> Getting [a] a a -> s -> [a]
+ Control.Lens.Utils: unsafeLensedMapAt :: (Ord k, Default v) => k -> Lens' v a -> Lens' (Map k v) (Maybe a)
+ Control.Lens.Utils: unsafePartsOf :: Functor f => Traversing ((->) :: Type -> Type -> Type) f s t a b -> LensLike f s t [a] [b]
+ Control.Lens.Utils: unsafePartsOf' :: () => ATraversal s t a b -> Lens s t [a] [b]
+ Control.Lens.Utils: unsafeSingular :: (HasCallStack, Conjoined p, Functor f) => Traversing p f s t a b -> Over p f s t a b
+ Control.Lens.Utils: unsnoc :: Snoc s s a a => s -> Maybe (s, a)
+ Control.Lens.Utils: unto :: (Profunctor p, Bifunctor p, Functor f) => (b -> t) -> Optic p f s t a b
+ Control.Lens.Utils: unwrap :: forall a. Coercible a (Unwrapped a) => a -> Unwrapped a
+ Control.Lens.Utils: unwrap' :: (MonadReader s m, Wrapped s) => m (Unwrapped s)
+ Control.Lens.Utils: unwrapped :: (Rewrapped s t, Rewrapped t s, Profunctor p, Functor f) => p t (f s) -> p (Unwrapped t) (f (Unwrapped s))
+ Control.Lens.Utils: unwrapped' :: (Wrapped s, Profunctor p, Functor f) => p s (f s) -> p (Unwrapped s) (f (Unwrapped s))
+ Control.Lens.Utils: unwrapping :: (Rewrapped s t, Rewrapped t s, Profunctor p, Functor f) => (Unwrapped s -> s) -> p t (f s) -> p (Unwrapped t) (f (Unwrapped s))
+ Control.Lens.Utils: unwrapping' :: (Wrapped s, Profunctor p, Functor f) => (Unwrapped s -> s) -> p s (f s) -> p (Unwrapped s) (f (Unwrapped s))
+ Control.Lens.Utils: use :: MonadState s m => Getting a s a -> m a
+ Control.Lens.Utils: uses :: MonadState s m => LensLike' (Const r :: Type -> Type) s a -> (a -> r) -> m r
+ Control.Lens.Utils: view :: MonadReader s m => Getting a s a -> m a
+ Control.Lens.Utils: views :: MonadReader s m => LensLike' (Const r :: Type -> Type) s a -> (a -> r) -> m r
+ Control.Lens.Utils: withIndex :: (Indexable i p, Functor f) => p (i, s) (f (j, t)) -> Indexed i s (f t)
+ Control.Lens.Utils: withIso :: () => AnIso s t a b -> ((s -> a) -> (b -> t) -> r) -> r
+ Control.Lens.Utils: withPrism :: () => APrism s t a b -> ((b -> t) -> (s -> Either t a) -> r) -> r
+ Control.Lens.Utils: without :: () => APrism s t a b -> APrism u v c d -> Prism (Either s u) (Either t v) (Either a c) (Either b d)
+ Control.Lens.Utils: worded :: Applicative f => IndexedLensLike' Int f String String
+ Control.Lens.Utils: wrap :: forall a. Coercible (Unwrapped a) a => Unwrapped a -> a
+ Control.Lens.Utils: wrap' :: (MonadReader (Unwrapped s) m, Wrapped s) => m s
+ Control.Lens.Utils: wrapped :: (Rewrapped s t, Rewrapped t s, Profunctor p, Functor f) => p (Unwrapped s) (f (Unwrapped t)) -> p s (f t)
+ Control.Lens.Utils: wrapped' :: (Wrapped s, Profunctor p, Functor f) => p (Unwrapped s) (f (Unwrapped s)) -> p s (f s)
+ Control.Lens.Utils: wrappedM' :: (Functor f, Wrapped b, Wrapped s) => (Unwrapped s -> f (Unwrapped b)) -> s -> f b
+ Control.Lens.Utils: wrapping :: (Rewrapped s t, Rewrapped t s, Profunctor p, Functor f) => (Unwrapped s -> s) -> p (Unwrapped s) (f (Unwrapped t)) -> p s (f t)
+ Control.Lens.Utils: wrapping' :: (Wrapped s, Profunctor p, Functor f) => (Unwrapped s -> s) -> p (Unwrapped s) (f (Unwrapped s)) -> p s (f s)
+ Control.Lens.Utils: zoom :: Zoom m n s t => LensLike' (Zoomed m c) t s -> m c -> n c
+ Control.Lens.Utils: }
- Control.Lens.Utils.Nested: at' :: (Functor f, Ord p) => p -> (Maybe a -> f Maybe a) -> Maybe Map p a -> f Maybe Map p a
+ Control.Lens.Utils.Nested: at' :: (Functor f, Ord p) => p -> (Maybe a -> f (Maybe a)) -> Maybe (Map p a) -> f (Maybe (Map p a))
- Control.Lens.Utils.Nested: subMapAt :: (Ord p, Functor f) => p -> (Maybe a -> f Maybe a) -> Maybe Map p a -> f Maybe Map p a
+ Control.Lens.Utils.Nested: subMapAt :: (Functor f, Ord p) => p -> (Maybe a -> f (Maybe a)) -> Maybe (Map p a) -> f (Maybe (Map p a))
- Control.Lens.Utils.Wrapped: _unwrap :: (Rewrapped s s, MonadReader s m) => m Unwrapped s
+ Control.Lens.Utils.Wrapped: _unwrap :: (MonadReader s m, Rewrapped s s) => m (Unwrapped s)
- Control.Lens.Utils.Wrapped: _wrap :: (Rewrapped t t, MonadReader Unwrapped t m) => m t
+ Control.Lens.Utils.Wrapped: _wrap :: (MonadReader (Unwrapped t) m, Rewrapped t t) => m t
- Control.Lens.Utils.Wrapped: rewrap :: ((~#) * * Unwrapped t Unwrapped s, Rewrapped t s, Rewrapped s t) => s -> t
+ Control.Lens.Utils.Wrapped: rewrap :: (Rewrapped s t, Rewrapped t s, Unwrapped t ~# Unwrapped s) => s -> t
- Control.Lens.Utils.Wrapped: unwrap' :: (Wrapped s, MonadReader s m) => m Unwrapped s
+ Control.Lens.Utils.Wrapped: unwrap' :: (MonadReader s m, Wrapped s) => m (Unwrapped s)
- Control.Lens.Utils.Wrapped: unwrapped :: (Functor f, Profunctor p, Rewrapped t s, Rewrapped s t) => p t f s -> p Unwrapped t f Unwrapped s
+ Control.Lens.Utils.Wrapped: unwrapped :: (Rewrapped s t, Rewrapped t s, Profunctor p, Functor f) => p t (f s) -> p (Unwrapped t) (f (Unwrapped s))
- Control.Lens.Utils.Wrapped: unwrapped' :: (Functor f, Profunctor p, Wrapped s) => p s f s -> p Unwrapped s f Unwrapped s
+ Control.Lens.Utils.Wrapped: unwrapped' :: (Wrapped s, Profunctor p, Functor f) => p s (f s) -> p (Unwrapped s) (f (Unwrapped s))
- Control.Lens.Utils.Wrapped: unwrapping :: (Functor f, Profunctor p, Rewrapped t s1, Rewrapped s1 t) => (Unwrapped s2 -> s2) -> p t f s1 -> p Unwrapped t f Unwrapped s1
+ Control.Lens.Utils.Wrapped: unwrapping :: (Rewrapped s t, Rewrapped t s, Profunctor p, Functor f) => (Unwrapped s -> s) -> p t (f s) -> p (Unwrapped t) (f (Unwrapped s))
- Control.Lens.Utils.Wrapped: unwrapping' :: (Functor f, Profunctor p, Wrapped s1) => (Unwrapped s2 -> s2) -> p s1 f s1 -> p Unwrapped s1 f Unwrapped s1
+ Control.Lens.Utils.Wrapped: unwrapping' :: (Wrapped s, Profunctor p, Functor f) => (Unwrapped s -> s) -> p s (f s) -> p (Unwrapped s) (f (Unwrapped s))
- Control.Lens.Utils.Wrapped: wrap' :: (Wrapped s, MonadReader Unwrapped s m) => m s
+ Control.Lens.Utils.Wrapped: wrap' :: (MonadReader (Unwrapped s) m, Wrapped s) => m s
- Control.Lens.Utils.Wrapped: wrapped :: (Functor f, Profunctor p, Rewrapped t s, Rewrapped s t) => p Unwrapped s f Unwrapped t -> p s f t
+ Control.Lens.Utils.Wrapped: wrapped :: (Rewrapped s t, Rewrapped t s, Profunctor p, Functor f) => p (Unwrapped s) (f (Unwrapped t)) -> p s (f t)
- Control.Lens.Utils.Wrapped: wrapped' :: (Functor f, Profunctor p, Wrapped s) => p Unwrapped s f Unwrapped s -> p s f s
+ Control.Lens.Utils.Wrapped: wrapped' :: (Wrapped s, Profunctor p, Functor f) => p (Unwrapped s) (f (Unwrapped s)) -> p s (f s)
- Control.Lens.Utils.Wrapped: wrappedM' :: (Functor f, Wrapped b, Wrapped s) => (Unwrapped s -> f Unwrapped b) -> s -> f b
+ Control.Lens.Utils.Wrapped: wrappedM' :: (Functor f, Wrapped b, Wrapped s) => (Unwrapped s -> f (Unwrapped b)) -> s -> f b
- Control.Lens.Utils.Wrapped: wrapping :: (Functor f, Profunctor p, Rewrapped t s1, Rewrapped s1 t) => (Unwrapped s2 -> s2) -> p Unwrapped s1 f Unwrapped t -> p s1 f t
+ Control.Lens.Utils.Wrapped: wrapping :: (Rewrapped s t, Rewrapped t s, Profunctor p, Functor f) => (Unwrapped s -> s) -> p (Unwrapped s) (f (Unwrapped t)) -> p s (f t)
- Control.Lens.Utils.Wrapped: wrapping' :: (Functor f, Profunctor p, Wrapped s1) => (Unwrapped s2 -> s2) -> p Unwrapped s1 f Unwrapped s1 -> p s1 f s1
+ Control.Lens.Utils.Wrapped: wrapping' :: (Wrapped s, Profunctor p, Functor f) => (Unwrapped s -> s) -> p (Unwrapped s) (f (Unwrapped s)) -> p s (f s)

Files

lens-utils.cabal view
@@ -1,11 +1,13 @@--- This file has been generated from package.yaml by hpack version 0.20.0.+cabal-version: 1.12++-- This file has been generated from package.yaml by hpack version 0.31.1. -- -- see: https://github.com/sol/hpack ----- hash: 0602790545b326901e59379955c4541dcab52e82ef782aa8e1cedf784e484c18+-- hash: 5c82c194878b4484c5ed563855433504a4ba35efabe3bf46d0a64136883b60e4  name:           lens-utils-version:        1.4.5+version:        1.4.6 synopsis:       Collection of missing lens utilities. category:       Data stability:      experimental@@ -17,28 +19,27 @@ license:        Apache-2.0 license-file:   LICENSE build-type:     Simple-cabal-version:  >= 1.10  library+  exposed-modules:+      Control.Lens.Aeson+      Control.Lens.Utils+      Control.Lens.Utils.Nested+      Control.Lens.Utils.TH+      Control.Lens.Utils.Wrapped+  other-modules:+      Paths_lens_utils   hs-source-dirs:       src   default-extensions: AllowAmbiguousTypes ApplicativeDo BangPatterns BinaryLiterals ConstraintKinds DataKinds DefaultSignatures DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable DoAndIfThenElse DuplicateRecordFields EmptyDataDecls FlexibleContexts FlexibleInstances FunctionalDependencies GeneralizedNewtypeDeriving InstanceSigs LambdaCase LiberalTypeSynonyms MonadComprehensions MultiWayIf NamedWildCards NegativeLiterals NumDecimals OverloadedLabels PackageImports PatternSynonyms QuasiQuotes RankNTypes RecursiveDo RelaxedPolyRec ScopedTypeVariables StandaloneDeriving TemplateHaskell TupleSections TypeApplications TypeFamilies TypeFamilyDependencies TypeOperators UnicodeSyntax ViewPatterns   ghc-options: -Wall -O2   build-depends:       aeson-    , base >=4.10 && <4.12+    , base >=4.9 && <4.13     , containers     , data-default     , lens     , monoid     , split     , template-haskell-  exposed-modules:-      Control.Lens.Aeson-      Control.Lens.Utils-      Control.Lens.Utils.Nested-      Control.Lens.Utils.TH-      Control.Lens.Utils.Wrapped-  other-modules:-      Paths_lens_utils   default-language: Haskell2010