packages feed

kioku-api 0.13.0.0 → 0.14.0.0

raw patch · 2 files changed

+8/−2 lines, 2 filesdep ~kioku-apiPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: kioku-api

API changes (from Hackage documentation)

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

Files

CHANGELOG.md view
@@ -1,5 +1,11 @@ # Changelog +## 0.14.0.0 — 2026-11-21++### Changed++- Align the package and its test dependency at Kioku 0.14.0.0.+ ## 0.13.0.0 — 2026-11-08  ### Changed
kioku-api.cabal view
@@ -1,6 +1,6 @@ cabal-version: 3.0 name: kioku-api-version: 0.13.0.0+version: 0.14.0.0 synopsis: Reusable agent memory wire types description:   Wire contract for kioku: custom prelude, TypeID identifiers, memory@@ -87,7 +87,7 @@     base >=4.21 && <5,     bytestring >=0.11 && <0.13,     containers >=0.6 && <0.8,-    kioku-api ^>=0.13.0.0,+    kioku-api ^>=0.14.0.0,     tasty >=1.5 && <1.6,     tasty-hunit >=0.10 && <0.11,     text >=2.1 && <2.2,