preamble 0.0.61 → 0.0.62
raw patch · 3 files changed
+11/−22 lines, 3 filesdep ~MonadRandomdep ~lensdep ~monad-loggerPVP ok
version bump matches the API change (PVP)
Dependency ranges changed: MonadRandom, lens, monad-logger, network, resourcet, safe, text, unordered-containers
API changes (from Hackage documentation)
+ Preamble: (!!) :: () => [a] -> Int -> a
+ Preamble: (#%%=) :: MonadState s m => ALens s s a b -> a -> (r, b) -> m r
+ Preamble: (#%%~) :: Functor f => ALens s t a b -> a -> f b -> s -> f t
+ Preamble: (#%=) :: MonadState s m => ALens s s a b -> a -> b -> m ()
+ Preamble: (#%~) :: () => ALens s t a b -> a -> b -> s -> t
+ Preamble: (#) :: () => AReview t b -> b -> t
+ Preamble: (#=) :: MonadState s m => ALens s s a b -> b -> m ()
+ Preamble: (#~) :: () => ALens s t a b -> b -> s -> t
+ Preamble: ($!) :: () => a -> b -> a -> b
+ Preamble: ($) :: () => a -> b -> a -> b
+ Preamble: (%%=) :: MonadState s m => Over p (,) r s s a b -> p a (r, b) -> m r
+ Preamble: (%%@=) :: MonadState s m => Over Indexed i (,) r s s a b -> i -> a -> (r, b) -> m r
+ Preamble: (%%@~) :: () => Over Indexed i f s t a b -> i -> a -> f b -> s -> f t
+ Preamble: (%%~) :: () => LensLike f s t a b -> a -> f b -> s -> f t
+ Preamble: (%=) :: MonadState s m => ASetter s s a b -> a -> b -> m ()
+ Preamble: (%@=) :: MonadState s m => AnIndexedSetter i s s a b -> i -> a -> b -> m ()
+ Preamble: (%@~) :: () => AnIndexedSetter i s t a b -> i -> a -> b -> s -> t
+ Preamble: (%~) :: () => ASetter s t a b -> a -> b -> s -> t
+ Preamble: (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
+ Preamble: (&&) :: Bool -> Bool -> Bool
+ Preamble: (&&=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()
+ Preamble: (&&~) :: () => ASetter s t Bool Bool -> Bool -> s -> t
+ Preamble: (&) :: () => a -> a -> b -> b
+ Preamble: (&~) :: () => s -> State s a -> s
+ Preamble: (*) :: Num a => a -> a -> a
+ Preamble: (**) :: Floating a => a -> a -> a
+ Preamble: (***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c')
+ Preamble: (**=) :: (MonadState s m, Floating a) => ASetter' s a -> a -> m ()
+ Preamble: (**~) :: Floating a => ASetter s t a a -> a -> s -> t
+ Preamble: (*=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
+ Preamble: (*>) :: Applicative f => f a -> f b -> f b
+ Preamble: (*~) :: Num a => ASetter s t a a -> a -> s -> t
+ Preamble: (+) :: Num a => a -> a -> a
+ Preamble: (++) :: Monoid w => w -> w -> w
+ Preamble: (+=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
+ Preamble: (+~) :: Num a => ASetter s t a a -> a -> s -> t
+ Preamble: (-) :: Num a => a -> a -> a
+ Preamble: (-.-) :: (IsString s, Monoid s) => s -> s -> s
+ Preamble: (-/-) :: (IsString s, Monoid s) => s -> s -> s
+ Preamble: (-:-) :: (IsString s, Monoid s) => s -> s -> s
+ Preamble: (-=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
+ Preamble: (-|-) :: (IsString s, Monoid s) => s -> s -> s
+ Preamble: (-~) :: Num a => ASetter s t a a -> a -> s -> t
+ Preamble: (.) :: Category cat => cat b c -> cat a b -> cat a c
+ Preamble: (...) :: (Applicative f, Plated c) => LensLike f s t c c -> Over p f c c a b -> Over p f s t a b
+ Preamble: (.=) :: (KeyValue kv, ToJSON v) => Text -> v -> kv
+ Preamble: (.>) :: () => st -> r -> kab -> st -> kab -> r
+ Preamble: (.@=) :: MonadState s m => AnIndexedSetter i s s a b -> i -> b -> m ()
+ Preamble: (.@~) :: () => AnIndexedSetter i s t a b -> i -> b -> s -> t
+ Preamble: (.~) :: () => ASetter s t a b -> b -> s -> t
+ Preamble: (/) :: Fractional a => a -> a -> a
+ Preamble: (//=) :: (MonadState s m, Fractional a) => ASetter' s a -> a -> m ()
+ Preamble: (//~) :: Fractional a => ASetter s t a a -> a -> s -> t
+ Preamble: (/=) :: Eq a => a -> a -> Bool
+ Preamble: (<#%=) :: MonadState s m => ALens s s a b -> a -> b -> m b
+ Preamble: (<#%~) :: () => ALens s t a b -> a -> b -> s -> (b, t)
+ Preamble: (<#=) :: MonadState s m => ALens s s a b -> b -> m b
+ Preamble: (<#~) :: () => ALens s t a b -> b -> s -> (b, t)
+ Preamble: (<$!>) :: Monad m => a -> b -> m a -> m b
+ Preamble: (<$) :: Functor f => a -> f b -> f a
+ Preamble: (<$>) :: Functor f => a -> b -> f a -> f b
+ Preamble: (<%=) :: MonadState s m => LensLike (,) b s s a b -> a -> b -> m b
+ Preamble: (<%@=) :: MonadState s m => Over Indexed i (,) b s s a b -> i -> a -> b -> m b
+ Preamble: (<%@~) :: () => Over Indexed i (,) b s t a b -> i -> a -> b -> s -> (b, t)
+ Preamble: (<%~) :: () => LensLike (,) b s t a b -> a -> b -> s -> (b, t)
+ Preamble: (<&&=) :: MonadState s m => LensLike' (,) Bool s Bool -> Bool -> m Bool
+ Preamble: (<&&~) :: () => LensLike (,) Bool s t Bool Bool -> Bool -> s -> (Bool, t)
+ Preamble: (<&>) :: Functor f => f a -> a -> b -> f b
+ Preamble: (<) :: Ord a => a -> a -> Bool
+ Preamble: (<*) :: Applicative f => f a -> f b -> f a
+ Preamble: (<**=) :: (MonadState s m, Floating a) => LensLike' (,) a s a -> a -> m a
+ Preamble: (<**~) :: Floating a => LensLike (,) a s t a a -> a -> s -> (a, t)
+ Preamble: (<*=) :: (MonadState s m, Num a) => LensLike' (,) a s a -> a -> m a
+ Preamble: (<*>) :: Applicative f => f a -> b -> f a -> f b
+ Preamble: (<*~) :: Num a => LensLike (,) a s t a a -> a -> s -> (a, t)
+ Preamble: (<+=) :: (MonadState s m, Num a) => LensLike' (,) a s a -> a -> m a
+ Preamble: (<+~) :: Num a => LensLike (,) a s t a a -> a -> s -> (a, t)
+ Preamble: (<-=) :: (MonadState s m, Num a) => LensLike' (,) a s a -> a -> m a
+ Preamble: (<-~) :: Num a => LensLike (,) a s t a a -> a -> s -> (a, t)
+ Preamble: (<.) :: Indexable i p => Indexed i s t -> r -> a -> b -> s -> t -> p a b -> r
+ Preamble: (<.=) :: MonadState s m => ASetter s s a b -> b -> m b
+ Preamble: (<.>) :: FilePath -> String -> FilePath
+ Preamble: (<.~) :: () => ASetter s t a b -> b -> s -> (b, t)
+ Preamble: (<//=) :: (MonadState s m, Fractional a) => LensLike' (,) a s a -> a -> m a
+ Preamble: (<//~) :: Fractional a => LensLike (,) a s t a a -> a -> s -> (a, t)
+ Preamble: (</>) :: FilePath -> FilePath -> FilePath
+ Preamble: (<<%=) :: (Strong p, MonadState s m) => Over p (,) a s s a b -> p a b -> m a
+ Preamble: (<<%@=) :: MonadState s m => Over Indexed i (,) a s s a b -> i -> a -> b -> m a
+ Preamble: (<<%@~) :: () => Over Indexed i (,) a s t a b -> i -> a -> b -> s -> (a, t)
+ Preamble: (<<%~) :: () => LensLike (,) a s t a b -> a -> b -> s -> (a, t)
+ Preamble: (<<&&=) :: MonadState s m => LensLike' (,) Bool s Bool -> Bool -> m Bool
+ Preamble: (<<&&~) :: () => LensLike' (,) Bool s Bool -> Bool -> s -> (Bool, s)
+ Preamble: (<<**=) :: (MonadState s m, Floating a) => LensLike' (,) a s a -> a -> m a
+ Preamble: (<<**~) :: Floating a => LensLike' (,) a s a -> a -> s -> (a, s)
+ Preamble: (<<*=) :: (MonadState s m, Num a) => LensLike' (,) a s a -> a -> m a
+ Preamble: (<<*~) :: Num a => LensLike' (,) a s a -> a -> s -> (a, s)
+ Preamble: (<<+=) :: (MonadState s m, Num a) => LensLike' (,) a s a -> a -> m a
+ Preamble: (<<+~) :: Num a => LensLike' (,) a s a -> a -> s -> (a, s)
+ Preamble: (<<-=) :: (MonadState s m, Num a) => LensLike' (,) a s a -> a -> m a
+ Preamble: (<<-~) :: Num a => LensLike' (,) a s a -> a -> s -> (a, s)
+ Preamble: (<<.=) :: MonadState s m => LensLike (,) a s s a b -> b -> m a
+ Preamble: (<<.~) :: () => LensLike (,) a s t a b -> b -> s -> (a, t)
+ Preamble: (<<//=) :: (MonadState s m, Fractional a) => LensLike' (,) a s a -> a -> m a
+ Preamble: (<<//~) :: Fractional a => LensLike' (,) a s a -> a -> s -> (a, s)
+ Preamble: (<<<>=) :: (MonadState s m, Monoid r) => LensLike' (,) r s r -> r -> m r
+ Preamble: (<<<>~) :: Monoid r => LensLike' (,) r s r -> r -> s -> (r, s)
+ Preamble: (<<>=) :: (MonadState s m, Monoid r) => LensLike' (,) r s r -> r -> m r
+ Preamble: (<<>~) :: Monoid m => LensLike (,) m s t m m -> m -> s -> (m, t)
+ Preamble: (<<?=) :: MonadState s m => LensLike (,) a s s a Maybe b -> b -> m a
+ Preamble: (<<?~) :: () => LensLike (,) a s t a Maybe b -> b -> s -> (a, t)
+ Preamble: (<<^=) :: (MonadState s m, Num a, Integral e) => LensLike' (,) a s a -> e -> m a
+ Preamble: (<<^^=) :: (MonadState s m, Fractional a, Integral e) => LensLike' (,) a s a -> e -> m a
+ Preamble: (<<^^~) :: (Fractional a, Integral e) => LensLike' (,) a s a -> e -> s -> (a, s)
+ Preamble: (<<^~) :: (Num a, Integral e) => LensLike' (,) a s a -> e -> s -> (a, s)
+ Preamble: (<<||=) :: MonadState s m => LensLike' (,) Bool s Bool -> Bool -> m Bool
+ Preamble: (<<||~) :: () => LensLike' (,) Bool s Bool -> Bool -> s -> (Bool, s)
+ Preamble: (<<~) :: MonadState s m => ALens s s a b -> m b -> m b
+ Preamble: (<=) :: Ord a => a -> a -> Bool
+ Preamble: (<=<) :: Monad m => b -> m c -> a -> m b -> a -> m c
+ Preamble: (<>) :: Semigroup a => a -> a -> a
+ Preamble: (<>=) :: (MonadState s m, Monoid a) => ASetter' s a -> a -> m ()
+ Preamble: (<>~) :: Monoid a => ASetter s t a a -> a -> s -> t
+ Preamble: (<?=) :: MonadState s m => ASetter s s a Maybe b -> b -> m b
+ Preamble: (<?~) :: () => ASetter s t a Maybe b -> b -> s -> (b, t)
+ Preamble: (<^=) :: (MonadState s m, Num a, Integral e) => LensLike' (,) a s a -> e -> m a
+ Preamble: (<^^=) :: (MonadState s m, Fractional a, Integral e) => LensLike' (,) a s a -> e -> m a
+ Preamble: (<^^~) :: (Fractional a, Integral e) => LensLike (,) a s t a a -> e -> s -> (a, t)
+ Preamble: (<^~) :: (Num a, Integral e) => LensLike (,) a s t a a -> e -> s -> (a, t)
+ Preamble: (<|) :: Cons s s a a => a -> s -> s
+ Preamble: (<|>) :: Alternative f => f a -> f a -> f a
+ Preamble: (<||=) :: MonadState s m => LensLike' (,) Bool s Bool -> Bool -> m Bool
+ Preamble: (<||~) :: () => LensLike (,) Bool s t Bool Bool -> Bool -> s -> (Bool, t)
+ Preamble: (<~) :: MonadState s m => ASetter s s a b -> m b -> m ()
+ Preamble: (=.) :: a -> b -> (a, b)
+ Preamble: (=<<) :: Monad m => a -> m b -> m a -> m b
+ Preamble: (==) :: Eq a => a -> a -> Bool
+ Preamble: (>$) :: Contravariant f => b -> f b -> f a
+ Preamble: (>) :: Ord a => a -> a -> Bool
+ Preamble: (>=) :: Ord a => a -> a -> Bool
+ Preamble: (>=>) :: Monad m => a -> m b -> b -> m c -> a -> m c
+ Preamble: (>>) :: Monad m => m a -> m b -> m b
+ Preamble: (>>=) :: Monad m => m a -> a -> m b -> m b
+ Preamble: (?=) :: MonadState s m => ASetter s s a Maybe b -> b -> m ()
+ Preamble: (??) :: Functor f => f a -> b -> a -> f b
+ Preamble: (?~) :: () => ASetter s t a Maybe b -> b -> s -> t
+ Preamble: (\\) :: Eq a => [a] -> [a] -> [a]
+ Preamble: (^#) :: () => s -> ALens s t a b -> a
+ Preamble: (^) :: (Num a, Integral b) => a -> b -> a
+ Preamble: (^.) :: () => s -> Getting a s a -> a
+ Preamble: (^..) :: () => s -> Getting Endo [a] s a -> [a]
+ Preamble: (^=) :: (MonadState s m, Num a, Integral e) => ASetter' s a -> e -> m ()
+ Preamble: (^?!) :: HasCallStack => s -> Getting Endo a s a -> a
+ Preamble: (^?) :: () => s -> Getting First a s a -> Maybe a
+ Preamble: (^@.) :: () => s -> IndexedGetting i (i, a) s a -> (i, a)
+ Preamble: (^@..) :: () => s -> IndexedGetting i Endo [(i, a)] s a -> [(i, a)]
+ Preamble: (^@?!) :: HasCallStack => s -> IndexedGetting i Endo (i, a) s a -> (i, a)
+ Preamble: (^@?) :: () => s -> IndexedGetting i Endo Maybe (i, a) s a -> Maybe (i, a)
+ Preamble: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Preamble: (^^=) :: (MonadState s m, Fractional a, Integral e) => ASetter' s a -> e -> m ()
+ Preamble: (^^~) :: (Fractional a, Integral e) => ASetter s t a a -> e -> s -> t
+ Preamble: (^~) :: (Num a, Integral e) => ASetter s t a a -> e -> s -> t
+ Preamble: (|>) :: Snoc s s a a => s -> a -> s
+ Preamble: (||) :: Bool -> Bool -> Bool
+ Preamble: (||=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()
+ Preamble: (||~) :: () => ASetter s t Bool Bool -> Bool -> s -> t
+ Preamble: AllocationLimitExceeded :: AllocationLimitExceeded
+ Preamble: AssertionFailed :: String -> AssertionFailed
+ Preamble: Bazaar :: forall (f :: * -> *). Applicative f => p a f b -> f t -> Bazaar a b t
+ Preamble: Bazaar1 :: forall (f :: * -> *). Apply f => p a f b -> f t -> Bazaar1 a b t
+ Preamble: BlockedIndefinitelyOnMVar :: BlockedIndefinitelyOnMVar
+ Preamble: BlockedIndefinitelyOnSTM :: BlockedIndefinitelyOnSTM
+ Preamble: CompactionFailed :: String -> CompactionFailed
+ Preamble: Const :: a -> Const a
+ Preamble: Context :: b -> t -> a -> Context a b t
+ Preamble: Ctx :: Pairs -> Logger -> Ctx
+ Preamble: Deadlock :: Deadlock
+ Preamble: Denormal :: ArithException
+ Preamble: DivideByZero :: ArithException
+ Preamble: Down :: a -> Down a
+ Preamble: EQ :: Ordering
+ Preamble: ErrorCallWithLocation :: String -> String -> ErrorCall
+ Preamble: False :: Bool
+ Preamble: Fold :: Fold s a -> ReifiedFold s a
+ Preamble: GT :: Ordering
+ Preamble: Getter :: Getter s a -> ReifiedGetter s a
+ Preamble: HeapOverflow :: AsyncException
+ Preamble: Identity :: a -> Identity a
+ Preamble: IndexOutOfBounds :: String -> ArrayException
+ Preamble: Indexed :: i -> a -> b -> Indexed i a b
+ Preamble: IndexedFold :: IndexedFold i s a -> ReifiedIndexedFold i s a
+ Preamble: IndexedGetter :: IndexedGetter i s a -> ReifiedIndexedGetter i s a
+ Preamble: IndexedLens :: IndexedLens i s t a b -> ReifiedIndexedLens i s t a b
+ Preamble: IndexedSetter :: IndexedSetter i s t a b -> ReifiedIndexedSetter i s t a b
+ Preamble: IndexedTraversal :: IndexedTraversal i s t a b -> ReifiedIndexedTraversal i s t a b
+ Preamble: Iso :: Iso s t a b -> ReifiedIso s t a b
+ Preamble: Just :: a -> Maybe a
+ Preamble: LT :: Ordering
+ Preamble: Left :: a -> Either a b
+ Preamble: Lens :: Lens s t a b -> ReifiedLens s t a b
+ Preamble: LossOfPrecision :: ArithException
+ Preamble: MaskedInterruptible :: MaskingState
+ Preamble: MaskedUninterruptible :: MaskingState
+ Preamble: MethodName :: Name -> Name -> DefName
+ Preamble: NestedAtomically :: NestedAtomically
+ Preamble: NoMethodError :: String -> NoMethodError
+ Preamble: NonTermination :: NonTermination
+ Preamble: Nothing :: Maybe a
+ Preamble: Overflow :: ArithException
+ Preamble: PatternMatchFail :: String -> PatternMatchFail
+ Preamble: Prism :: Prism s t a b -> ReifiedPrism s t a b
+ Preamble: RatioZeroDenominator :: ArithException
+ Preamble: RecConError :: String -> RecConError
+ Preamble: RecSelError :: String -> RecSelError
+ Preamble: RecUpdError :: String -> RecUpdError
+ Preamble: Right :: b -> Either a b
+ Preamble: Setter :: Setter s t a b -> ReifiedSetter s t a b
+ Preamble: StackOverflow :: AsyncException
+ Preamble: StatsCtx :: Ctx -> Tags -> Stat -> Text -> StatsCtx
+ Preamble: ThreadKilled :: AsyncException
+ Preamble: TopName :: Name -> DefName
+ Preamble: TransT :: LoggingT (ReaderT c m) a -> TransT c m a
+ Preamble: Traversal :: Traversal s t a b -> ReifiedTraversal s t a b
+ Preamble: True :: Bool
+ Preamble: TypeError :: String -> TypeError
+ Preamble: UndefinedElement :: String -> ArrayException
+ Preamble: Underflow :: ArithException
+ Preamble: Unmasked :: MaskingState
+ Preamble: UserInterrupt :: AsyncException
+ Preamble: [Handler] :: Handler m a
+ Preamble: [Identical] :: Identical a b a b
+ Preamble: [SomeAsyncException] :: SomeAsyncException
+ Preamble: [SomeException] :: SomeException
+ Preamble: [_cLogger] :: Ctx -> Logger
+ Preamble: [_cPreamble] :: Ctx -> Pairs
+ Preamble: [_scCtx] :: StatsCtx -> Ctx
+ Preamble: [_scLabels] :: StatsCtx -> Tags
+ Preamble: [_scPrefix] :: StatsCtx -> Text
+ Preamble: [_scStat] :: StatsCtx -> Stat
+ Preamble: [getConst] :: Const a -> a
+ Preamble: [runBazaar1] :: Bazaar1 a b t -> forall (f :: * -> *). Apply f => p a f b -> f t
+ Preamble: [runBazaar] :: Bazaar a b t -> forall (f :: * -> *). Applicative f => p a f b -> f t
+ Preamble: [runFold] :: ReifiedFold s a -> Fold s a
+ Preamble: [runGetter] :: ReifiedGetter s a -> Getter s a
+ Preamble: [runIdentity] :: Identity a -> a
+ Preamble: [runIndexedFold] :: ReifiedIndexedFold i s a -> IndexedFold i s a
+ Preamble: [runIndexedGetter] :: ReifiedIndexedGetter i s a -> IndexedGetter i s a
+ Preamble: [runIndexedLens] :: ReifiedIndexedLens i s t a b -> IndexedLens i s t a b
+ Preamble: [runIndexedSetter] :: ReifiedIndexedSetter i s t a b -> IndexedSetter i s t a b
+ Preamble: [runIndexedTraversal] :: ReifiedIndexedTraversal i s t a b -> IndexedTraversal i s t a b
+ Preamble: [runIndexed] :: Indexed i a b -> i -> a -> b
+ Preamble: [runIso] :: ReifiedIso s t a b -> Iso s t a b
+ Preamble: [runLens] :: ReifiedLens s t a b -> Lens s t a b
+ Preamble: [runPrism] :: ReifiedPrism s t a b -> Prism s t a b
+ Preamble: [runSetter] :: ReifiedSetter s t a b -> Setter s t a b
+ Preamble: [runTraversal] :: ReifiedTraversal s t a b -> Traversal s t a b
+ Preamble: [unTransT] :: TransT c m a -> LoggingT (ReaderT c m) a
+ Preamble: _1 :: Field1 s t a b => Lens s t a b
+ Preamble: _1' :: Field1 s t a b => Lens s t a b
+ Preamble: _10 :: Field10 s t a b => Lens s t a b
+ Preamble: _10' :: Field10 s t a b => Lens s t a b
+ Preamble: _11 :: Field11 s t a b => Lens s t a b
+ Preamble: _11' :: Field11 s t a b => Lens s t a b
+ Preamble: _12 :: Field12 s t a b => Lens s t a b
+ Preamble: _12' :: Field12 s t a b => Lens s t a b
+ Preamble: _13 :: Field13 s t a b => Lens s t a b
+ Preamble: _13' :: Field13 s t a b => Lens s t a b
+ Preamble: _14 :: Field14 s t a b => Lens s t a b
+ Preamble: _14' :: Field14 s t a b => Lens s t a b
+ Preamble: _15 :: Field15 s t a b => Lens s t a b
+ Preamble: _15' :: Field15 s t a b => Lens s t a b
+ Preamble: _16 :: Field16 s t a b => Lens s t a b
+ Preamble: _16' :: Field16 s t a b => Lens s t a b
+ Preamble: _17 :: Field17 s t a b => Lens s t a b
+ Preamble: _17' :: Field17 s t a b => Lens s t a b
+ Preamble: _18 :: Field18 s t a b => Lens s t a b
+ Preamble: _18' :: Field18 s t a b => Lens s t a b
+ Preamble: _19 :: Field19 s t a b => Lens s t a b
+ Preamble: _19' :: Field19 s t a b => Lens s t a b
+ Preamble: _2 :: Field2 s t a b => Lens s t a b
+ Preamble: _2' :: Field2 s t a b => Lens s t a b
+ Preamble: _3 :: Field3 s t a b => Lens s t a b
+ Preamble: _3' :: Field3 s t a b => Lens s t a b
+ Preamble: _4 :: Field4 s t a b => Lens s t a b
+ Preamble: _4' :: Field4 s t a b => Lens s t a b
+ Preamble: _5 :: Field5 s t a b => Lens s t a b
+ Preamble: _5' :: Field5 s t a b => Lens s t a b
+ Preamble: _6 :: Field6 s t a b => Lens s t a b
+ Preamble: _6' :: Field6 s t a b => Lens s t a b
+ Preamble: _7 :: Field7 s t a b => Lens s t a b
+ Preamble: _7' :: Field7 s t a b => Lens s t a b
+ Preamble: _8 :: Field8 s t a b => Lens s t a b
+ Preamble: _8' :: Field8 s t a b => Lens s t a b
+ Preamble: _9 :: Field9 s t a b => Lens s t a b
+ Preamble: _9' :: Field9 s t a b => Lens s t a b
+ Preamble: _Cons :: Cons s t a b => Prism s t (a, s) (b, t)
+ Preamble: _Empty :: AsEmpty a => Prism' a ()
+ Preamble: _GWrapped' :: (Generic s, D1 d C1 c S1 s' Rec0 a ~ Rep s, Unwrapped s ~ GUnwrapped Rep s) => Iso' s Unwrapped s
+ Preamble: _Just :: (Choice p, Applicative f) => p a f b -> p Maybe a f Maybe b
+ Preamble: _Left :: (Choice p, Applicative f) => p a f b -> p Either a c f Either b c
+ Preamble: _Nothing :: (Choice p, Applicative f) => p () f () -> p Maybe a f Maybe a
+ Preamble: _Right :: (Choice p, Applicative f) => p a f b -> p Either c a f Either c b
+ Preamble: _Show :: (Read a, Show a) => Prism' String a
+ Preamble: _Snoc :: Snoc s t a b => Prism s t (s, a) (t, b)
+ Preamble: _Unwrapped :: Rewrapping s t => Iso Unwrapped t Unwrapped s t s
+ Preamble: _Unwrapped' :: Wrapped s => Iso' Unwrapped s s
+ Preamble: _Unwrapping :: Rewrapping s t => Unwrapped s -> s -> Iso Unwrapped t Unwrapped s t s
+ Preamble: _Unwrapping' :: Wrapped s => Unwrapped s -> s -> Iso' Unwrapped s s
+ Preamble: _Void :: (Choice p, Applicative f) => p a f Void -> p s f s
+ Preamble: _Wrapped :: Rewrapping s t => Iso s t Unwrapped s Unwrapped t
+ Preamble: _Wrapped' :: Wrapped s => Iso' s Unwrapped s
+ Preamble: _Wrapping :: Rewrapping s t => Unwrapped s -> s -> Iso s t Unwrapped s Unwrapped t
+ Preamble: _Wrapping' :: Wrapped s => Unwrapped s -> s -> Iso' s Unwrapped s
+ Preamble: _head :: Cons s s a a => Traversal' s a
+ Preamble: _init :: Snoc s s a a => Traversal' s s
+ Preamble: _last :: Snoc s s a a => Traversal' s a
+ Preamble: _tail :: Cons s s a a => Traversal' s s
+ Preamble: abbreviatedFields :: LensRules
+ Preamble: abbreviatedNamer :: FieldNamer
+ Preamble: abs :: Num a => a -> a
+ Preamble: acos :: Floating a => a -> a
+ Preamble: acosh :: Floating a => a -> a
+ Preamble: ala :: (Functor f, Rewrapping s t) => Unwrapped s -> s -> Unwrapped t -> t -> f s -> f Unwrapped s
+ Preamble: alaf :: (Functor f, Functor g, Rewrapping s t) => Unwrapped s -> s -> f t -> g s -> f Unwrapped t -> g Unwrapped s
+ Preamble: all :: Foldable t => a -> Bool -> t a -> Bool
+ Preamble: allOf :: () => Getting All s a -> a -> Bool -> s -> Bool
+ Preamble: allowInterrupt :: MonadBase IO m => m ()
+ Preamble: 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')
+ Preamble: alreadyExistsErrorType :: IOErrorType
+ Preamble: alreadyInUseErrorType :: IOErrorType
+ Preamble: and :: Foldable t => t Bool -> Bool
+ Preamble: andOf :: () => Getting All s Bool -> s -> Bool
+ Preamble: annotateIOError :: IOError -> String -> Maybe Handle -> Maybe FilePath -> IOError
+ Preamble: anon :: () => a -> a -> Bool -> Iso' Maybe a a
+ Preamble: any :: Foldable t => a -> Bool -> t a -> Bool
+ Preamble: anyOf :: () => Getting Any s a -> a -> Bool -> s -> Bool
+ Preamble: ap :: Monad m => m a -> b -> m a -> m b
+ Preamble: appendFile :: MonadIO m => FilePath -> Text -> m ()
+ Preamble: argument :: Profunctor p => Setter p b r p a r a b
+ Preamble: asIndex :: (Indexable i p, Contravariant f, Functor f) => p i f i -> Indexed i s f s
+ Preamble: asTypeOf :: () => a -> a -> a
+ Preamble: aside :: () => APrism s t a b -> Prism (e, s) (e, t) (e, a) (e, b)
+ Preamble: asin :: Floating a => a -> a
+ Preamble: asinh :: Floating a => a -> a
+ Preamble: assert :: () => Bool -> a -> a
+ Preamble: assign :: MonadState s m => ASetter s s a b -> b -> m ()
+ Preamble: assignA :: Arrow p => ASetter s t a b -> p s b -> p s t
+ Preamble: asum :: (Foldable t, Alternative f) => t f a -> f a
+ Preamble: asumOf :: Alternative f => Getting Endo f a s f a -> s -> f a
+ Preamble: asyncExceptionFromException :: Exception e => SomeException -> Maybe e
+ Preamble: asyncExceptionToException :: Exception e => e -> SomeException
+ Preamble: at :: At m => Index m -> Lens' m Maybe IxValue m
+ Preamble: atan :: Floating a => a -> a
+ Preamble: atan2 :: RealFloat a => a -> a -> a
+ Preamble: atanh :: Floating a => a -> a
+ Preamble: au :: Functor f => AnIso s t a b -> b -> t -> f s -> f a
+ Preamble: auf :: () => Optic Costar f g s t a b -> f a -> g b -> f s -> g t
+ Preamble: backwards :: (Profunctor p, Profunctor q) => Optical p q Backwards f s t a b -> Optical p q f s t a b
+ Preamble: below :: Traversable f => APrism' s a -> Prism' f s f a
+ Preamble: 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
+ Preamble: bimap :: Bifunctor p => a -> b -> c -> d -> p a c -> p b d
+ Preamble: 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'
+ Preamble: bool :: () => a -> a -> Bool -> a
+ Preamble: boolThrowIO :: MonadIO m => String -> Bool -> m ()
+ Preamble: both :: Bitraversable r => Traversal r a a r b b a b
+ Preamble: both1 :: Bitraversable1 r => Traversal1 r a a r b b a b
+ Preamble: bracket :: MonadBaseControl IO m => m a -> a -> m b -> a -> m c -> m c
+ Preamble: bracketOnError :: MonadBaseControl IO m => m a -> a -> m b -> a -> m c -> m c
+ Preamble: bracket_ :: MonadBaseControl IO m => m a -> m b -> m c -> m c
+ Preamble: break :: () => a -> Bool -> [a] -> ([a], [a])
+ Preamble: cLogger :: HasCtx c_aq6s => Lens' c_aq6s Logger
+ Preamble: cPreamble :: HasCtx c_aq6s => Lens' c_aq6s Pairs
+ Preamble: camelCaseFields :: LensRules
+ Preamble: camelCaseNamer :: FieldNamer
+ Preamble: camelOptions :: Options
+ Preamble: catMaybes :: () => [Maybe a] -> [a]
+ Preamble: catch :: (MonadBaseControl IO m, Exception e) => m a -> e -> m a -> m a
+ Preamble: catchIOError :: () => IO a -> IOError -> IO a -> IO a
+ Preamble: catchJust :: (MonadBaseControl IO m, Exception e) => e -> Maybe b -> m a -> b -> m a -> m a
+ Preamble: catches :: MonadBaseControl IO m => m a -> [Handler m a] -> m a
+ Preamble: ceiling :: (RealFrac a, Integral b) => a -> b
+ Preamble: censoring :: MonadWriter w m => Setter w w u v -> u -> v -> m a -> m a
+ Preamble: children :: Plated a => a -> [a]
+ Preamble: 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
+ Preamble: chosen :: (Conjoined p, Functor f) => p a f b -> p Either a a f Either b b
+ Preamble: class Functor f => Applicative (f :: * -> *)
+ Preamble: class AsEmpty a
+ Preamble: class Ixed m => At m
+ Preamble: class Bifunctor (p :: * -> * -> *)
+ Preamble: class Bounded a
+ Preamble: class Profunctor p => Choice (p :: * -> * -> *)
+ Preamble: 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 :: * -> * -> *)
+ Preamble: class Cons s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Contains m
+ Preamble: class Contravariant (f :: * -> *)
+ Preamble: class Each s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Enum a
+ Preamble: class Eq a
+ Preamble: class (Typeable e, Show e) => Exception e
+ Preamble: class Field1 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field10 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field11 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field12 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field13 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field14 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field15 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field16 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field17 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field18 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field19 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field2 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field3 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field4 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field5 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field6 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field7 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field8 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Field9 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Fractional a => Floating a
+ Preamble: class Foldable (t :: * -> *)
+ Preamble: class Foldable f => FoldableWithIndex i (f :: * -> *) | f -> i
+ Preamble: class Num a => Fractional a
+ Preamble: class Functor (f :: * -> *)
+ Preamble: class Functor f => FunctorWithIndex i (f :: * -> *) | f -> i
+ Preamble: class GPlated a (g :: * -> *)
+ Preamble: class HasCtx c_aq6s
+ Preamble: class HasCtx c_ar0X => HasStatsCtx c_ar0X
+ Preamble: class Hashable a
+ Preamble: class Conjoined p => Indexable i (p :: * -> * -> *)
+ Preamble: class (Real a, Enum a) => Integral a
+ Preamble: class IsString a
+ Preamble: class Ixed m
+ Preamble: class (Magnified m ~ Magnified n, MonadReader b m, MonadReader a n) => Magnify (m :: * -> *) (n :: * -> *) b a | m -> b, n -> a, m a -> n, n b -> m
+ Preamble: class Applicative m => Monad (m :: * -> *)
+ Preamble: class MonadBase b m => MonadBaseControl (b :: * -> *) (m :: * -> *) | m -> b
+ Preamble: class Monad m => MonadIO (m :: * -> *)
+ Preamble: class (Alternative m, Monad m) => MonadPlus (m :: * -> *)
+ Preamble: class Monad m => MonadReader r (m :: * -> *) | m -> r
+ Preamble: class MonadIO m => MonadResource (m :: * -> *)
+ Preamble: class Semigroup a => Monoid a
+ Preamble: class Num a
+ Preamble: class Eq a => Ord a
+ Preamble: class Plated a
+ Preamble: class Profunctor (p :: * -> * -> *)
+ Preamble: class Read a
+ Preamble: class (Num a, Ord a) => Real a
+ Preamble: class (RealFrac a, Floating a) => RealFloat a
+ Preamble: class (Real a, Fractional a) => RealFrac a
+ Preamble: class Reversing t
+ Preamble: class (Profunctor p, Bifunctor p) => Reviewable (p :: * -> * -> *)
+ Preamble: class Wrapped s => Rewrapped s t
+ Preamble: class (Rewrapped s t, Rewrapped t s) => Rewrapping s t
+ Preamble: class (Applicative f, Distributive f, Traversable f) => Settable (f :: * -> *)
+ Preamble: class Show a
+ Preamble: class Snoc s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Preamble: class Storable a
+ Preamble: class Strict lazy strict | lazy -> strict, strict -> lazy
+ Preamble: class Bifunctor p => Swapped (p :: * -> * -> *)
+ Preamble: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ Preamble: class (Foldable1 t, Traversable t) => Traversable1 (t :: * -> *)
+ Preamble: class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t) => TraversableWithIndex i (t :: * -> *) | t -> i
+ Preamble: class Ord k => TraverseMax k (m :: * -> *) | m -> k
+ Preamble: class Ord k => TraverseMin k (m :: * -> *) | m -> k
+ Preamble: class Typeable (a :: k)
+ Preamble: class (Vector Vector a, MVector MVector a) => Unbox a
+ Preamble: class Wrapped s where {
+ Preamble: class (MonadState s m, MonadState t n) => Zoom (m :: * -> *) (n :: * -> *) s t | m -> s, n -> t, m t -> n, n s -> m
+ Preamble: classUnderscoreNoPrefixFields :: LensRules
+ Preamble: classUnderscoreNoPrefixNamer :: FieldNamer
+ Preamble: classyRules :: LensRules
+ Preamble: classyRules_ :: LensRules
+ Preamble: cloneIndexPreservingLens :: () => ALens s t a b -> IndexPreservingLens s t a b
+ Preamble: cloneIndexPreservingSetter :: () => ASetter s t a b -> IndexPreservingSetter s t a b
+ Preamble: cloneIndexPreservingTraversal :: () => ATraversal s t a b -> IndexPreservingTraversal s t a b
+ Preamble: cloneIndexPreservingTraversal1 :: () => ATraversal1 s t a b -> IndexPreservingTraversal1 s t a b
+ Preamble: cloneIndexedLens :: () => AnIndexedLens i s t a b -> IndexedLens i s t a b
+ Preamble: cloneIndexedSetter :: () => AnIndexedSetter i s t a b -> IndexedSetter i s t a b
+ Preamble: cloneIndexedTraversal :: () => AnIndexedTraversal i s t a b -> IndexedTraversal i s t a b
+ Preamble: cloneIndexedTraversal1 :: () => AnIndexedTraversal1 i s t a b -> IndexedTraversal1 i s t a b
+ Preamble: cloneIso :: () => AnIso s t a b -> Iso s t a b
+ Preamble: cloneLens :: () => ALens s t a b -> Lens s t a b
+ Preamble: clonePrism :: () => APrism s t a b -> Prism s t a b
+ Preamble: cloneSetter :: () => ASetter s t a b -> Setter s t a b
+ Preamble: cloneTraversal :: () => ATraversal s t a b -> Traversal s t a b
+ Preamble: cloneTraversal1 :: () => ATraversal1 s t a b -> Traversal1 s t a b
+ Preamble: coerced :: (Coercible s a, Coercible t b) => Iso s t a b
+ Preamble: compare :: Ord a => a -> a -> Ordering
+ Preamble: comparing :: Ord a => b -> a -> b -> b -> Ordering
+ Preamble: composOpFold :: Plated a => b -> b -> b -> b -> a -> b -> a -> b
+ Preamble: concat :: Monoid w => [w] -> w
+ Preamble: concatMap :: Foldable t => a -> [b] -> t a -> [b]
+ Preamble: concatMapOf :: () => Getting [r] s a -> a -> [r] -> s -> [r]
+ Preamble: concatOf :: () => Getting [r] s [r] -> s -> [r]
+ Preamble: confusing :: Applicative f => LensLike Curried Yoneda f Yoneda f s t a b -> LensLike f s t a b
+ Preamble: conjoined :: Conjoined p => p ~ ((->) :: * -> * -> *) -> q a -> b r -> q p a b r -> q p a b r
+ Preamble: cons :: Cons s s a a => a -> s -> s
+ Preamble: const :: () => a -> b -> a
+ Preamble: contains :: Contains m => Index m -> Lens' m Bool
+ Preamble: contexts :: Plated a => a -> [Context a a a]
+ Preamble: contextsOf :: () => ATraversal' a a -> a -> [Context a a a]
+ Preamble: contextsOn :: Plated a => ATraversal s t a a -> s -> [Context a a t]
+ Preamble: contextsOnOf :: () => ATraversal s t a a -> ATraversal' a a -> s -> [Context a a t]
+ Preamble: contramap :: Contravariant f => a -> b -> f b -> f a
+ Preamble: contramapped :: Contravariant f => Setter f b f a a b
+ Preamble: contramapping :: Contravariant f => AnIso s t a b -> Iso f a f b f s f t
+ Preamble: cos :: Floating a => a -> a
+ Preamble: cosh :: Floating a => a -> a
+ Preamble: cosmos :: Plated a => Fold a a
+ Preamble: cosmosOf :: (Applicative f, Contravariant f) => LensLike' f a a -> LensLike' f a a
+ Preamble: cosmosOn :: (Applicative f, Contravariant f, Plated a) => LensLike' f s a -> LensLike' f s a
+ Preamble: cosmosOnOf :: (Applicative f, Contravariant f) => LensLike' f s a -> LensLike' f a a -> LensLike' f s a
+ Preamble: createClass :: Lens' LensRules Bool
+ Preamble: ctx :: HasCtx c_aq6s => Lens' c_aq6s Ctx
+ Preamble: curried :: (Profunctor p, Functor f) => p a -> b -> c f d -> e -> f -> p (a, b) -> c f (d, e) -> f
+ Preamble: curry :: () => (a, b) -> c -> a -> b -> c
+ Preamble: cycle :: () => [a] -> [a]
+ Preamble: cycled :: Apply f => LensLike f s t a b -> LensLike f s t a b
+ Preamble: data AllocationLimitExceeded
+ Preamble: data ArithException
+ Preamble: data ArrayException
+ Preamble: data AsyncException
+ Preamble: data BlockedIndefinitelyOnMVar
+ Preamble: data BlockedIndefinitelyOnSTM
+ Preamble: data Bool
+ Preamble: data ByteString
+ Preamble: data Char
+ Preamble: data Context a b t
+ Preamble: data Ctx
+ Preamble: data Deadlock
+ Preamble: data DefName
+ Preamble: data Double
+ Preamble: data Either a b
+ Preamble: data ErrorCall
+ Preamble: data Float
+ Preamble: data Handler (m :: * -> *) a
+ Preamble: data HashMap k v
+ Preamble: data HashSet a
+ Preamble: data IO a
+ Preamble: data IOErrorType
+ Preamble: data IOException
+ Preamble: data Int
+ Preamble: data Int32
+ Preamble: data Int64
+ Preamble: data IntMap a
+ Preamble: data IntSet
+ Preamble: data Integer
+ Preamble: data Leftmost a
+ Preamble: data LensRules
+ Preamble: data Level i a
+ Preamble: data Magma i t b a
+ Preamble: data Map k a
+ Preamble: data MaskingState
+ Preamble: data Maybe a
+ Preamble: data NestedAtomically
+ Preamble: data NonTermination
+ Preamble: data Ordering
+ Preamble: data Rightmost a
+ Preamble: data Seq a
+ Preamble: data Sequenced a (m :: * -> *)
+ Preamble: data Set a
+ Preamble: data SomeAsyncException
+ Preamble: data SomeException
+ Preamble: data StatsCtx
+ Preamble: data Text
+ Preamble: data Traversed a (f :: * -> *)
+ Preamble: data Vector a
+ Preamble: data Word
+ Preamble: data Word32
+ Preamble: data Word64
+ Preamble: data Word8
+ Preamble: data Identical (a :: k) (b :: k1) (s :: k) (t :: k1) :: forall k k1. () => k -> k1 -> k -> k1 -> *
+ Preamble: declareClassy :: DecsQ -> DecsQ
+ Preamble: declareClassyFor :: [(String, (String, String))] -> [(String, String)] -> DecsQ -> DecsQ
+ Preamble: declareFields :: DecsQ -> DecsQ
+ Preamble: declareLenses :: DecsQ -> DecsQ
+ Preamble: declareLensesFor :: [(String, String)] -> DecsQ -> DecsQ
+ Preamble: declareLensesWith :: LensRules -> DecsQ -> DecsQ
+ Preamble: declarePrisms :: DecsQ -> DecsQ
+ Preamble: declareWrapped :: DecsQ -> DecsQ
+ Preamble: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ Preamble: decodeUtf8 :: ByteString -> Text
+ Preamble: deep :: (Conjoined p, Applicative f, Plated s) => Traversing p f s s a b -> Over p f s s a b
+ Preamble: 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
+ Preamble: defaultFieldRules :: LensRules
+ Preamble: delete :: Eq a => a -> [a] -> [a]
+ Preamble: deleteBy :: () => a -> a -> Bool -> a -> [a] -> [a]
+ Preamble: deleteFirstsBy :: () => a -> a -> Bool -> [a] -> [a] -> [a]
+ Preamble: devoid :: () => Over p f Void Void a b
+ Preamble: dimap :: Profunctor p => a -> b -> c -> d -> p b c -> p a d
+ Preamble: 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'
+ Preamble: displayException :: Exception e => e -> String
+ Preamble: distrib :: (Conjoined p, Functor f) => p a b -> p f a f b
+ Preamble: div :: Integral a => a -> a -> a
+ Preamble: divMod :: Integral a => a -> a -> (a, a)
+ Preamble: doesNotExistErrorType :: IOErrorType
+ Preamble: drop :: () => Int -> [a] -> [a]
+ Preamble: dropWhile :: () => a -> Bool -> [a] -> [a]
+ Preamble: dropWhileEnd :: () => a -> Bool -> [a] -> [a]
+ Preamble: dropping :: (Conjoined p, Applicative f) => Int -> Over p Indexing f s t a a -> Over p f s t a a
+ Preamble: 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
+ Preamble: each :: Each s t a b => Traversal s t a b
+ Preamble: either :: () => a -> c -> b -> c -> Either a b -> c
+ Preamble: either' :: Either a b -> (a -> c) -> (b -> c) -> c
+ Preamble: eitherResult :: Result a -> Either String a
+ Preamble: eitherThrowIO :: (MonadIO m, Exception e) => Either e a -> m a
+ Preamble: eitherThrowIO' :: MonadIO m => Either String a -> m a
+ Preamble: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Preamble: elemIndex :: Eq a => a -> [a] -> Maybe Int
+ Preamble: elemIndexOf :: Eq a => IndexedGetting i First i s a -> a -> s -> Maybe i
+ Preamble: elemIndices :: Eq a => a -> [a] -> [Int]
+ Preamble: elemIndicesOf :: Eq a => IndexedGetting i Endo [i] s a -> a -> s -> [i]
+ Preamble: elemOf :: Eq a => Getting Any s a -> a -> s -> Bool
+ Preamble: element :: Traversable t => Int -> IndexedTraversal' Int t a a
+ Preamble: elementOf :: Applicative f => LensLike Indexing f s t a a -> Int -> IndexedLensLike Int f s t a a
+ Preamble: elements :: Traversable t => Int -> Bool -> IndexedTraversal' Int t a a
+ Preamble: elementsOf :: Applicative f => LensLike Indexing f s t a a -> Int -> Bool -> IndexedLensLike Int f s t a a
+ Preamble: empty :: Monoid w => w
+ Preamble: encodeFloat :: RealFloat a => Integer -> Int -> a
+ Preamble: encodeUtf8 :: Text -> ByteString
+ Preamble: enum :: Enum a => Iso' Int a
+ Preamble: enumFrom :: Enum a => a -> [a]
+ Preamble: enumFromThen :: Enum a => a -> a -> [a]
+ Preamble: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ Preamble: enumFromTo :: Enum a => a -> a -> [a]
+ Preamble: eofErrorType :: IOErrorType
+ Preamble: equating :: Eq a => b -> a -> b -> b -> Bool
+ Preamble: error :: HasCallStack => [Char] -> a
+ Preamble: evaluate :: MonadBase IO m => a -> m a
+ Preamble: even :: Integral a => a -> Bool
+ Preamble: exp :: Floating a => a -> a
+ Preamble: exponent :: RealFloat a => a -> Int
+ Preamble: fail :: Monad m => String -> m a
+ Preamble: 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
+ Preamble: failover :: Alternative m => LensLike (,) Any s t a b -> a -> b -> s -> m t
+ Preamble: filter :: () => a -> Bool -> [a] -> [a]
+ Preamble: filterM :: Applicative m => a -> m Bool -> [a] -> m [a]
+ Preamble: filtered :: (Choice p, Applicative f) => a -> Bool -> Optic' p f a a
+ Preamble: finally :: MonadBaseControl IO m => m a -> m b -> m a
+ Preamble: find :: Foldable t => a -> Bool -> t a -> Maybe a
+ Preamble: findIndex :: () => a -> Bool -> [a] -> Maybe Int
+ Preamble: findIndexOf :: () => IndexedGetting i First i s a -> a -> Bool -> s -> Maybe i
+ Preamble: findIndices :: () => a -> Bool -> [a] -> [Int]
+ Preamble: findIndicesOf :: () => IndexedGetting i Endo [i] s a -> a -> Bool -> s -> [i]
+ Preamble: findMOf :: Monad m => Getting Endo m Maybe a s a -> a -> m Bool -> s -> m Maybe a
+ Preamble: findOf :: () => Getting Endo Maybe a s a -> a -> Bool -> s -> Maybe a
+ Preamble: first :: Arrow a => a b c -> a (b, d) (c, d)
+ Preamble: first1Of :: () => Getting First a s a -> s -> a
+ Preamble: firstOf :: () => Getting Leftmost a s a -> s -> Maybe a
+ Preamble: firsting :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> Iso f s x g t y f a x g b y
+ Preamble: flip :: () => a -> b -> c -> b -> a -> c
+ Preamble: flipped :: (Profunctor p, Functor f) => p b -> a -> c f b' -> a' -> c' -> p a -> b -> c f a' -> b' -> c'
+ Preamble: floatDigits :: RealFloat a => a -> Int
+ Preamble: floatRadix :: RealFloat a => a -> Integer
+ Preamble: floatRange :: RealFloat a => a -> (Int, Int)
+ Preamble: floor :: (RealFrac a, Integral b) => a -> b
+ Preamble: fmap :: Functor f => a -> b -> f a -> f b
+ Preamble: foldBy :: Foldable t => a -> a -> a -> a -> t a -> a
+ Preamble: foldByOf :: () => Fold s a -> a -> a -> a -> a -> s -> a
+ Preamble: foldM :: (Foldable t, Monad m) => b -> a -> m b -> b -> t a -> m b
+ Preamble: foldM_ :: (Foldable t, Monad m) => b -> a -> m b -> b -> t a -> m ()
+ Preamble: foldMap :: (Foldable t, Monoid m) => a -> m -> t a -> m
+ Preamble: foldMapBy :: Foldable t => r -> r -> r -> r -> a -> r -> t a -> r
+ Preamble: foldMapByOf :: () => Fold s a -> r -> r -> r -> r -> a -> r -> s -> r
+ Preamble: foldMapOf :: () => Getting r s a -> a -> r -> s -> r
+ Preamble: foldOf :: () => Getting a s a -> s -> a
+ Preamble: folded :: Foldable f => IndexedFold Int f a a
+ Preamble: folded64 :: Foldable f => IndexedFold Int64 f a a
+ Preamble: folding :: Foldable f => s -> f a -> Fold s a
+ Preamble: foldl :: Foldable t => b -> a -> b -> b -> t a -> b
+ Preamble: foldl' :: Foldable t => b -> a -> b -> b -> t a -> b
+ Preamble: foldl1 :: Foldable t => a -> a -> a -> t a -> a
+ Preamble: foldl1' :: () => a -> a -> a -> [a] -> a
+ Preamble: foldl1Of :: HasCallStack => Getting Dual Endo Maybe a s a -> a -> a -> a -> s -> a
+ Preamble: foldl1Of' :: HasCallStack => Getting Endo Endo Maybe a s a -> a -> a -> a -> s -> a
+ Preamble: foldlMOf :: Monad m => Getting Endo r -> m r s a -> r -> a -> m r -> r -> s -> m r
+ Preamble: foldlOf :: () => Getting Dual Endo r s a -> r -> a -> r -> r -> s -> r
+ Preamble: foldlOf' :: () => Getting Endo Endo r s a -> r -> a -> r -> r -> s -> r
+ Preamble: foldr :: Foldable t => a -> b -> b -> b -> t a -> b
+ Preamble: foldr' :: Foldable t => a -> b -> b -> b -> t a -> b
+ Preamble: foldr1 :: Foldable t => a -> a -> a -> t a -> a
+ Preamble: foldr1Of :: HasCallStack => Getting Endo Maybe a s a -> a -> a -> a -> s -> a
+ Preamble: foldr1Of' :: HasCallStack => Getting Dual Endo Endo Maybe a s a -> a -> a -> a -> s -> a
+ Preamble: foldrMOf :: Monad m => Getting Dual Endo r -> m r s a -> a -> r -> m r -> r -> s -> m r
+ Preamble: foldrOf :: () => Getting Endo r s a -> a -> r -> r -> r -> s -> r
+ Preamble: foldrOf' :: () => Getting Dual Endo Endo r s a -> a -> r -> r -> r -> s -> r
+ Preamble: foldring :: (Contravariant f, Applicative f) => a -> f a -> f a -> f a -> s -> f a -> LensLike f s t a b
+ Preamble: for :: (Traversable t, Applicative f) => t a -> a -> f b -> f t b
+ Preamble: for1Of_ :: Functor f => Getting TraversedF r f s a -> s -> a -> f r -> f ()
+ Preamble: forM :: (Traversable t, Monad m) => t a -> a -> m b -> m t b
+ Preamble: forMOf :: () => LensLike WrappedMonad m s t a b -> s -> a -> m b -> m t
+ Preamble: forMOf_ :: Monad m => Getting Sequenced r m s a -> s -> a -> m r -> m ()
+ Preamble: forM_ :: (Foldable t, Monad m) => t a -> a -> m b -> m ()
+ Preamble: forOf :: () => LensLike f s t a b -> s -> a -> f b -> f t
+ Preamble: forOf_ :: Functor f => Getting Traversed r f s a -> s -> a -> f r -> f ()
+ Preamble: for_ :: (Foldable t, Applicative f) => t a -> a -> f b -> f ()
+ Preamble: forever :: Applicative f => f a -> f b
+ Preamble: fpFromText :: Text -> FilePath
+ Preamble: fpToString :: FilePath -> String
+ Preamble: fpToText :: FilePath -> Text
+ Preamble: from :: () => AnIso s t a b -> Iso b a t s
+ Preamble: fromEnum :: Enum a => a -> Int
+ Preamble: fromEq :: () => AnEquality s t a b -> Equality b a t s
+ Preamble: fromException :: Exception e => SomeException -> Maybe e
+ Preamble: fromInteger :: Num a => Integer -> a
+ Preamble: fromIntegral :: (Integral a, Num b) => a -> b
+ Preamble: fromMaybe :: () => a -> Maybe a -> a
+ Preamble: fromRational :: Fractional a => Rational -> a
+ Preamble: fromShow :: (Show a, IsString b) => a -> b
+ Preamble: fromString :: IsString a => String -> a
+ Preamble: fst :: () => (a, b) -> a
+ Preamble: fullErrorType :: IOErrorType
+ Preamble: fusing :: Functor f => LensLike Yoneda f s t a b -> LensLike f s t a b
+ Preamble: gcd :: Integral a => a -> a -> a
+ Preamble: generateLazyPatterns :: Lens' LensRules Bool
+ Preamble: generateSignatures :: Lens' LensRules Bool
+ Preamble: generateUpdateableOptics :: Lens' LensRules Bool
+ Preamble: genericDrop :: Integral i => i -> [a] -> [a]
+ Preamble: genericIndex :: Integral i => [a] -> i -> a
+ Preamble: genericLength :: Num i => [a] -> i
+ Preamble: genericReplicate :: Integral i => i -> a -> [a]
+ Preamble: genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
+ Preamble: genericTake :: Integral i => i -> [a] -> [a]
+ Preamble: getArgs :: MonadIO m => m [Text]
+ Preamble: getChar :: MonadIO m => m Char
+ Preamble: getContents :: MonadIO m => m LText
+ Preamble: getLine :: MonadIO m => m Text
+ Preamble: getMaskingState :: MonadBase IO m => m MaskingState
+ Preamble: getting :: (Profunctor p, Profunctor q, Functor f, Contravariant f) => Optical p q f s t a b -> Optical' p q f s a
+ Preamble: gplate :: (Generic a, GPlated a Rep a) => Traversal' a a
+ Preamble: group :: Eq a => [a] -> [[a]]
+ Preamble: groupBy :: () => a -> a -> Bool -> [a] -> [[a]]
+ Preamble: guard :: Alternative f => Bool -> f ()
+ Preamble: handle :: (MonadBaseControl IO m, Exception e) => e -> m a -> m a -> m a
+ Preamble: handleJust :: (MonadBaseControl IO m, Exception e) => e -> Maybe b -> b -> m a -> m a -> m a
+ Preamble: has :: () => Getting Any s a -> s -> Bool
+ Preamble: hash :: Hashable a => a -> Int
+ Preamble: hashWithSalt :: Hashable a => Int -> a -> Int
+ Preamble: hasn't :: () => Getting All s a -> s -> Bool
+ Preamble: head :: () => [a] -> a
+ Preamble: headMay :: () => [a] -> Maybe a
+ Preamble: holes :: Plated a => a -> [Pretext ((->) :: * -> * -> *) a a a]
+ Preamble: holesOf :: Conjoined p => Over p Bazaar p a a s t a a -> s -> [Pretext p a a t]
+ Preamble: holesOn :: Conjoined p => Over p Bazaar p a a s t a a -> s -> [Pretext p a a t]
+ Preamble: 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]
+ Preamble: iall :: FoldableWithIndex i f => i -> a -> Bool -> f a -> Bool
+ Preamble: iallOf :: () => IndexedGetting i All s a -> i -> a -> Bool -> s -> Bool
+ Preamble: iany :: FoldableWithIndex i f => i -> a -> Bool -> f a -> Bool
+ Preamble: ianyOf :: () => IndexedGetting i Any s a -> i -> a -> Bool -> s -> Bool
+ Preamble: iat :: At m => Index m -> IndexedLens' Index m m Maybe IxValue m
+ Preamble: icensoring :: MonadWriter w m => IndexedSetter i w w u v -> i -> u -> v -> m a -> m a
+ Preamble: icompose :: Indexable p c => i -> j -> p -> Indexed i s t -> r -> Indexed j a b -> s -> t -> c a b -> r
+ Preamble: iconcatMap :: FoldableWithIndex i f => i -> a -> [b] -> f a -> [b]
+ Preamble: iconcatMapOf :: () => IndexedGetting i [r] s a -> i -> a -> [r] -> s -> [r]
+ Preamble: icontains :: Contains m => Index m -> IndexedLens' Index m m Bool
+ Preamble: id :: Category cat => cat a a
+ Preamble: 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
+ Preamble: ifailover :: Alternative m => Over Indexed i (,) Any s t a b -> i -> a -> b -> s -> m t
+ Preamble: ifiltered :: (Indexable i p, Applicative f) => i -> a -> Bool -> Optical' p Indexed i f a a
+ Preamble: ifind :: FoldableWithIndex i f => i -> a -> Bool -> f a -> Maybe (i, a)
+ Preamble: ifindMOf :: Monad m => IndexedGetting i Endo m Maybe a s a -> i -> a -> m Bool -> s -> m Maybe a
+ Preamble: ifindOf :: () => IndexedGetting i Endo Maybe a s a -> i -> a -> Bool -> s -> Maybe a
+ Preamble: ifoldMap :: (FoldableWithIndex i f, Monoid m) => i -> a -> m -> f a -> m
+ Preamble: ifoldMapBy :: FoldableWithIndex i t => r -> r -> r -> r -> i -> a -> r -> t a -> r
+ Preamble: ifoldMapByOf :: () => IndexedFold i t a -> r -> r -> r -> r -> i -> a -> r -> t -> r
+ Preamble: ifoldMapOf :: () => IndexedGetting i m s a -> i -> a -> m -> s -> m
+ Preamble: ifolded :: (FoldableWithIndex i f, Indexable i p, Contravariant f, Applicative f) => p a f a -> f a -> f f a
+ Preamble: ifolding :: (Foldable f, Indexable i p, Contravariant g, Applicative g) => s -> f (i, a) -> Over p g s t a b
+ Preamble: ifoldl :: FoldableWithIndex i f => i -> b -> a -> b -> b -> f a -> b
+ Preamble: ifoldl' :: FoldableWithIndex i f => i -> b -> a -> b -> b -> f a -> b
+ Preamble: ifoldlM :: (FoldableWithIndex i f, Monad m) => i -> b -> a -> m b -> b -> f a -> m b
+ Preamble: ifoldlMOf :: Monad m => IndexedGetting i Endo r -> m r s a -> i -> r -> a -> m r -> r -> s -> m r
+ Preamble: ifoldlOf :: () => IndexedGetting i Dual Endo r s a -> i -> r -> a -> r -> r -> s -> r
+ Preamble: ifoldlOf' :: () => IndexedGetting i Endo r -> r s a -> i -> r -> a -> r -> r -> s -> r
+ Preamble: ifoldr :: FoldableWithIndex i f => i -> a -> b -> b -> b -> f a -> b
+ Preamble: ifoldr' :: FoldableWithIndex i f => i -> a -> b -> b -> b -> f a -> b
+ Preamble: ifoldrM :: (FoldableWithIndex i f, Monad m) => i -> a -> b -> m b -> b -> f a -> m b
+ Preamble: ifoldrMOf :: Monad m => IndexedGetting i Dual Endo r -> m r s a -> i -> a -> r -> m r -> r -> s -> m r
+ Preamble: ifoldrOf :: () => IndexedGetting i Endo r s a -> i -> a -> r -> r -> r -> s -> r
+ Preamble: ifoldrOf' :: () => IndexedGetting i Dual Endo r -> r s a -> i -> a -> r -> r -> r -> s -> r
+ Preamble: 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
+ Preamble: ifor :: (TraversableWithIndex i t, Applicative f) => t a -> i -> a -> f b -> f t b
+ Preamble: iforM :: (TraversableWithIndex i t, Monad m) => t a -> i -> a -> m b -> m t b
+ Preamble: iforMOf :: () => Indexed i a WrappedMonad m b -> s -> WrappedMonad m t -> s -> i -> a -> m b -> m t
+ Preamble: iforMOf_ :: Monad m => IndexedGetting i Sequenced r m s a -> s -> i -> a -> m r -> m ()
+ Preamble: iforM_ :: (FoldableWithIndex i t, Monad m) => t a -> i -> a -> m b -> m ()
+ Preamble: iforOf :: () => Indexed i a f b -> s -> f t -> s -> i -> a -> f b -> f t
+ Preamble: iforOf_ :: Functor f => IndexedGetting i Traversed r f s a -> s -> i -> a -> f r -> f ()
+ Preamble: ifor_ :: (FoldableWithIndex i t, Applicative f) => t a -> i -> a -> f b -> f ()
+ Preamble: ignored :: Applicative f => pafb -> s -> f s
+ Preamble: iix :: Ixed m => Index m -> IndexedTraversal' Index m m IxValue m
+ Preamble: ilens :: () => s -> (i, a) -> s -> b -> t -> IndexedLens i s t a b
+ Preamble: ilevels :: Applicative f => Traversing Indexed i f s t a b -> IndexedLensLike Int f s t Level i a Level j b
+ Preamble: ilike :: (Indexable i p, Contravariant f, Functor f) => i -> a -> Over' p f s a
+ Preamble: ilistening :: MonadWriter w m => IndexedGetting i (i, u) w u -> m a -> m (a, (i, u))
+ Preamble: ilistenings :: MonadWriter w m => IndexedGetting i v w u -> i -> u -> v -> m a -> m (a, v)
+ Preamble: illegalOperationErrorType :: IOErrorType
+ Preamble: iloci :: (Indexable i p, Applicative f) => p a f b -> Bazaar Indexed i a c s -> f Bazaar Indexed i b c s
+ Preamble: 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
+ Preamble: imap :: FunctorWithIndex i f => i -> a -> b -> f a -> f b
+ Preamble: imapAccumL :: TraversableWithIndex i t => i -> s -> a -> (s, b) -> s -> t a -> (s, t b)
+ Preamble: imapAccumLOf :: () => Over Indexed i State acc s t a b -> i -> acc -> a -> (acc, b) -> acc -> s -> (acc, t)
+ Preamble: imapAccumR :: TraversableWithIndex i t => i -> s -> a -> (s, b) -> s -> t a -> (s, t b)
+ Preamble: imapAccumROf :: () => Over Indexed i Backwards State acc s t a b -> i -> acc -> a -> (acc, b) -> acc -> s -> (acc, t)
+ Preamble: imapM :: (TraversableWithIndex i t, Monad m) => i -> a -> m b -> t a -> m t b
+ Preamble: imapMOf :: () => Over Indexed i WrappedMonad m s t a b -> i -> a -> m b -> s -> m t
+ Preamble: imapMOf_ :: Monad m => IndexedGetting i Sequenced r m s a -> i -> a -> m r -> s -> m ()
+ Preamble: imapM_ :: (FoldableWithIndex i t, Monad m) => i -> a -> m b -> t a -> m ()
+ Preamble: imapOf :: () => AnIndexedSetter i s t a b -> i -> a -> b -> s -> t
+ Preamble: imapped :: (FunctorWithIndex i f, Indexable i p, Settable f) => p a f b -> f a -> f f b
+ Preamble: imodifying :: MonadState s m => AnIndexedSetter i s s a b -> i -> a -> b -> m ()
+ Preamble: index :: (Indexable i p, Eq i, Applicative f) => i -> Optical' p Indexed i f a a
+ Preamble: indexed :: Indexable i p => p a b -> i -> a -> b
+ Preamble: indexing :: Indexable Int p => a -> Indexing f b -> s -> Indexing f t -> p a f b -> s -> f t
+ Preamble: indexing64 :: Indexable Int64 p => a -> Indexing64 f b -> s -> Indexing64 f t -> p a f b -> s -> f t
+ Preamble: indices :: (Indexable i p, Applicative f) => i -> Bool -> Optical' p Indexed i f a a
+ Preamble: infix 4 %=
+ Preamble: infix 5 \\
+ Preamble: infixl 0 `on`
+ Preamble: infixl 1 &~
+ Preamble: infixl 3 <|>
+ Preamble: infixl 4 <$>
+ Preamble: infixl 5 `failing`
+ Preamble: infixl 8 ^#
+ Preamble: infixl 9 !!
+ Preamble: infixr 0 $!
+ Preamble: infixr 1 <=<
+ Preamble: infixr 2 <~
+ Preamble: infixr 3 &&
+ Preamble: infixr 4 %~
+ Preamble: infixr 5 :<
+ Preamble: infixr 6 <>
+ Preamble: infixr 7 <.>
+ Preamble: infixr 8 #
+ Preamble: infixr 9 <.
+ Preamble: init :: () => [a] -> [a]
+ Preamble: initMay :: () => [a] -> Maybe [a]
+ Preamble: inits :: () => [a] -> [[a]]
+ Preamble: inone :: FoldableWithIndex i f => i -> a -> Bool -> f a -> Bool
+ Preamble: inoneOf :: () => IndexedGetting i Any s a -> i -> a -> Bool -> s -> Bool
+ Preamble: insert :: Ord a => a -> [a] -> [a]
+ Preamble: insertBy :: () => a -> a -> Ordering -> a -> [a] -> [a]
+ Preamble: inside :: Corepresentable p => ALens s t a b -> Lens p e s p e t p e a p e b
+ Preamble: interact :: MonadIO m => LText -> LText -> m ()
+ Preamble: intercalate :: Monoid w => w -> [w] -> w
+ Preamble: interruptible :: () => IO a -> IO a
+ Preamble: intersect :: Eq a => [a] -> [a] -> [a]
+ Preamble: intersectBy :: () => a -> a -> Bool -> [a] -> [a] -> [a]
+ Preamble: intersperse :: () => a -> [a] -> [a]
+ Preamble: involuted :: () => a -> a -> Iso' a a
+ Preamble: ioError :: () => IOError -> IO a
+ Preamble: ioeGetErrorString :: IOError -> String
+ Preamble: ioeGetErrorType :: IOError -> IOErrorType
+ Preamble: ioeGetFileName :: IOError -> Maybe FilePath
+ Preamble: ioeGetHandle :: IOError -> Maybe Handle
+ Preamble: ioeGetLocation :: IOError -> String
+ Preamble: ioeSetErrorString :: IOError -> String -> IOError
+ Preamble: ioeSetErrorType :: IOError -> IOErrorType -> IOError
+ Preamble: ioeSetFileName :: IOError -> FilePath -> IOError
+ Preamble: ioeSetHandle :: IOError -> Handle -> IOError
+ Preamble: ioeSetLocation :: IOError -> String -> IOError
+ Preamble: iover :: () => AnIndexedSetter i s t a b -> i -> a -> b -> s -> t
+ Preamble: ipartsOf :: (Indexable [i] p, Functor f) => Traversing Indexed i f s t a a -> Over p f s t [a] [a]
+ Preamble: ipartsOf' :: (Indexable [i] p, Functor f) => Over Indexed i Bazaar' Indexed i a s t a a -> Over p f s t [a] [a]
+ Preamble: ipassing :: MonadWriter w m => IndexedSetter i w w u v -> m (a, i -> u -> v) -> m a
+ Preamble: iplens :: () => s -> a -> s -> b -> t -> IndexPreservingLens s t a b
+ Preamble: ipre :: () => IndexedGetting i First (i, a) s a -> IndexPreservingGetter s Maybe (i, a)
+ Preamble: ipreuse :: MonadState s m => IndexedGetting i First (i, a) s a -> m Maybe (i, a)
+ Preamble: ipreuses :: MonadState s m => IndexedGetting i First r s a -> i -> a -> r -> m Maybe r
+ Preamble: ipreview :: MonadReader s m => IndexedGetting i First (i, a) s a -> m Maybe (i, a)
+ Preamble: ipreviews :: MonadReader s m => IndexedGetting i First r s a -> i -> a -> r -> m Maybe r
+ Preamble: isAlreadyExistsError :: IOError -> Bool
+ Preamble: isAlreadyExistsErrorType :: IOErrorType -> Bool
+ Preamble: isAlreadyInUseError :: IOError -> Bool
+ Preamble: isAlreadyInUseErrorType :: IOErrorType -> Bool
+ Preamble: isDenormalized :: RealFloat a => a -> Bool
+ Preamble: isDoesNotExistError :: IOError -> Bool
+ Preamble: isDoesNotExistErrorType :: IOErrorType -> Bool
+ Preamble: isEOFError :: IOError -> Bool
+ Preamble: isEOFErrorType :: IOErrorType -> Bool
+ Preamble: isFullError :: IOError -> Bool
+ Preamble: isFullErrorType :: IOErrorType -> Bool
+ Preamble: isIEEE :: RealFloat a => a -> Bool
+ Preamble: isIllegalOperation :: IOError -> Bool
+ Preamble: isIllegalOperationErrorType :: IOErrorType -> Bool
+ Preamble: isInfinite :: RealFloat a => a -> Bool
+ Preamble: isInfixOf :: Eq a => [a] -> [a] -> Bool
+ Preamble: isJust :: () => Maybe a -> Bool
+ Preamble: isNaN :: RealFloat a => a -> Bool
+ Preamble: isNegativeZero :: RealFloat a => a -> Bool
+ Preamble: isNothing :: () => Maybe a -> Bool
+ Preamble: isPermissionError :: IOError -> Bool
+ Preamble: isPermissionErrorType :: IOErrorType -> Bool
+ Preamble: isPrefixOf :: Eq a => [a] -> [a] -> Bool
+ Preamble: isSubsequenceOf :: Eq a => [a] -> [a] -> Bool
+ Preamble: isSuffixOf :: Eq a => [a] -> [a] -> Bool
+ Preamble: isUserError :: IOError -> Bool
+ Preamble: isUserErrorType :: IOErrorType -> Bool
+ Preamble: iset :: () => AnIndexedSetter i s t a b -> i -> b -> s -> t
+ Preamble: isets :: () => i -> a -> b -> s -> t -> IndexedSetter i s t a b
+ Preamble: isn't :: () => APrism s t a b -> s -> Bool
+ Preamble: iso :: () => s -> a -> b -> t -> Iso s t a b
+ Preamble: itakingWhile :: (Indexable i p, Profunctor q, Contravariant f, Applicative f) => i -> a -> Bool -> Optical' Indexed i q (Const Endo f s :: * -> *) s a -> Optical' p q f s a
+ Preamble: iterate :: () => a -> a -> a -> [a]
+ Preamble: iterate' :: () => a -> a -> a -> [a]
+ Preamble: iterated :: Apply f => a -> a -> LensLike' f a a
+ Preamble: ito :: (Indexable i p, Contravariant f) => s -> (i, a) -> Over' p f s a
+ Preamble: itoList :: FoldableWithIndex i f => f a -> [(i, a)]
+ Preamble: itoListOf :: () => IndexedGetting i Endo [(i, a)] s a -> s -> [(i, a)]
+ Preamble: itraverse :: (TraversableWithIndex i t, Applicative f) => i -> a -> f b -> t a -> f t b
+ Preamble: 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
+ Preamble: 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
+ Preamble: itraverseOf :: () => Indexed i a f b -> s -> f t -> i -> a -> f b -> s -> f t
+ Preamble: itraverseOf_ :: Functor f => IndexedGetting i Traversed r f s a -> i -> a -> f r -> s -> f ()
+ Preamble: itraverse_ :: (FoldableWithIndex i t, Applicative f) => i -> a -> f b -> t a -> f ()
+ Preamble: itraversed :: (TraversableWithIndex i t, Indexable i p, Applicative f) => p a f b -> t a -> f t b
+ Preamble: iunsafePartsOf :: (Indexable [i] p, Functor f) => Traversing Indexed i f s t a b -> Over p f s t [a] [b]
+ Preamble: iunsafePartsOf' :: () => Over Indexed i Bazaar Indexed i a b s t a b -> IndexedLens [i] s t [a] [b]
+ Preamble: iuse :: MonadState s m => IndexedGetting i (i, a) s a -> m (i, a)
+ Preamble: iuses :: MonadState s m => IndexedGetting i r s a -> i -> a -> r -> m r
+ Preamble: iview :: MonadReader s m => IndexedGetting i (i, a) s a -> m (i, a)
+ Preamble: iviews :: MonadReader s m => IndexedGetting i r s a -> i -> a -> r -> m r
+ Preamble: ix :: Ixed m => Index m -> Traversal' m IxValue m
+ Preamble: ixAt :: At m => Index m -> Traversal' m IxValue m
+ Preamble: join :: Monad m => m m a -> m a
+ Preamble: labStatsCtx :: MonadStatsCtx c m => Tags -> TransT StatsCtx m a -> m a
+ Preamble: last :: () => [a] -> a
+ Preamble: last1Of :: () => Getting Last a s a -> s -> a
+ Preamble: lastOf :: () => Getting Rightmost a s a -> s -> Maybe a
+ Preamble: lazy :: Strict lazy strict => Iso' strict lazy
+ Preamble: lcm :: Integral a => a -> a -> a
+ Preamble: left' :: Choice p => p a b -> p Either a c Either b c
+ Preamble: lefts :: () => [Either a b] -> [a]
+ Preamble: length :: Foldable t => t a -> Int
+ Preamble: lengthOf :: () => Getting Endo Endo Int s a -> s -> Int
+ Preamble: lens :: () => s -> a -> s -> b -> t -> Lens s t a b
+ Preamble: lensClass :: Lens' LensRules ClassyNamer
+ Preamble: lensField :: Lens' LensRules FieldNamer
+ Preamble: lensRules :: LensRules
+ Preamble: lensRulesFor :: [(String, String)] -> LensRules
+ Preamble: levels :: Applicative f => Traversing ((->) :: * -> * -> *) f s t a b -> IndexedLensLike Int f s t Level () a Level () b
+ Preamble: lex :: ReadS String
+ Preamble: lift :: (MonadTrans t, Monad m) => m a -> t m a
+ Preamble: liftA2 :: Applicative f => a -> b -> c -> f a -> f b -> f c
+ Preamble: liftIO :: MonadIO m => IO a -> m a
+ Preamble: liftM :: Monad m => a1 -> r -> m a1 -> m r
+ Preamble: liftM2 :: Monad m => a1 -> a2 -> r -> m a1 -> m a2 -> m r
+ Preamble: liftM3 :: Monad m => a1 -> a2 -> a3 -> r -> m a1 -> m a2 -> m a3 -> m r
+ Preamble: liftM4 :: Monad m => a1 -> a2 -> a3 -> a4 -> r -> m a1 -> m a2 -> m a3 -> m a4 -> m r
+ Preamble: liftM5 :: Monad m => a1 -> a2 -> a3 -> a4 -> a5 -> r -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
+ Preamble: lifted :: Monad m => Setter m a m b a b
+ Preamble: like :: (Profunctor p, Contravariant f, Functor f) => a -> Optic' p f s a
+ Preamble: lined :: Applicative f => IndexedLensLike' Int f String String
+ Preamble: lines :: Text -> [Text]
+ Preamble: listToMaybe :: () => [a] -> Maybe a
+ Preamble: listening :: MonadWriter w m => Getting u w u -> m a -> m (a, u)
+ Preamble: listenings :: MonadWriter w m => Getting v w u -> u -> v -> m a -> m (a, v)
+ Preamble: lmap :: Profunctor p => a -> b -> p b c -> p a c
+ Preamble: lmapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> Iso p a x q b y p s x q t y
+ Preamble: loci :: Applicative f => a -> f b -> Bazaar ((->) :: * -> * -> *) a c s -> f Bazaar ((->) :: * -> * -> *) b c s
+ Preamble: locus :: IndexedComonadStore p => Lens p a c s p b c s a b
+ Preamble: log :: Floating a => a -> a
+ Preamble: logBase :: Floating a => a -> a -> a
+ Preamble: lookingupNamer :: [(String, String)] -> FieldNamer
+ Preamble: lookup :: Eq a => a -> [(a, b)] -> Maybe b
+ Preamble: lookupOf :: Eq k => Getting Endo Maybe v s (k, v) -> k -> s -> Maybe v
+ Preamble: ltextToString :: LText -> String
+ Preamble: magma :: () => LensLike Mafic a b s t a b -> Iso s u Magma Int t b a Magma j u c c
+ Preamble: magnify :: Magnify m n b a => LensLike' Magnified m c a b -> m c -> n c
+ Preamble: makeClassy :: Name -> DecsQ
+ Preamble: makeClassyConstraints :: Name -> [Name] -> DecsQ
+ Preamble: makeClassyFor :: String -> String -> [(String, String)] -> Name -> DecsQ
+ Preamble: makeClassyPrisms :: Name -> DecsQ
+ Preamble: makeClassy_ :: Name -> DecsQ
+ Preamble: makeFields :: Name -> DecsQ
+ Preamble: makeFieldsNoPrefix :: Name -> DecsQ
+ Preamble: makeLenses :: Name -> DecsQ
+ Preamble: makeLensesFor :: [(String, String)] -> Name -> DecsQ
+ Preamble: makeLensesWith :: LensRules -> Name -> DecsQ
+ Preamble: makePrisms :: Name -> DecsQ
+ Preamble: makeWrapped :: Name -> DecsQ
+ Preamble: map :: Functor f => a -> b -> f a -> f b
+ Preamble: mapAccumL :: Traversable t => a -> b -> (a, c) -> a -> t b -> (a, t c)
+ Preamble: mapAccumLOf :: () => LensLike State acc s t a b -> acc -> a -> (acc, b) -> acc -> s -> (acc, t)
+ Preamble: mapAccumR :: Traversable t => a -> b -> (a, c) -> a -> t b -> (a, t c)
+ Preamble: mapAccumROf :: () => LensLike Backwards State acc s t a b -> acc -> a -> (acc, b) -> acc -> s -> (acc, t)
+ Preamble: mapAndUnzipM :: Applicative m => a -> m (b, c) -> [a] -> m ([b], [c])
+ Preamble: mapEq :: () => AnEquality s t a b -> f s -> f a
+ Preamble: mapException :: (Exception e1, Exception e2) => e1 -> e2 -> a -> a
+ Preamble: mapM :: (Traversable t, Monad m) => a -> m b -> t a -> m t b
+ Preamble: mapMOf :: () => LensLike WrappedMonad m s t a b -> a -> m b -> s -> m t
+ Preamble: mapMOf_ :: Monad m => Getting Sequenced r m s a -> a -> m r -> s -> m ()
+ Preamble: mapM_ :: (Foldable t, Monad m) => a -> m b -> t a -> m ()
+ Preamble: mapMaybe :: () => a -> Maybe b -> [a] -> [b]
+ Preamble: mapOf :: () => ASetter s t a b -> a -> b -> s -> t
+ Preamble: mapped :: Functor f => Setter f a f b a b
+ Preamble: mappend :: Monoid a => a -> a -> a
+ Preamble: mapping :: (Functor f, Functor g) => AnIso s t a b -> Iso f s g t f a g b
+ Preamble: mappingNamer :: String -> [String] -> FieldNamer
+ Preamble: mask :: MonadBaseControl IO m => forall a. () => m a -> m a -> m b -> m b
+ Preamble: mask_ :: MonadBaseControl IO m => m a -> m a
+ Preamble: matching :: () => APrism s t a b -> s -> Either t a
+ Preamble: max :: Ord a => a -> a -> a
+ Preamble: maxBound :: Bounded a => a
+ Preamble: maximum :: (Foldable t, Ord a) => t a -> a
+ Preamble: maximum1Of :: Ord a => Getting Max a s a -> s -> a
+ Preamble: maximumBy :: Foldable t => a -> a -> Ordering -> t a -> a
+ Preamble: maximumByOf :: () => Getting Endo Endo Maybe a s a -> a -> a -> Ordering -> s -> Maybe a
+ Preamble: maximumOf :: Ord a => Getting Endo Endo Maybe a s a -> s -> Maybe a
+ Preamble: maybe :: () => b -> a -> b -> Maybe a -> b
+ Preamble: maybe' :: Maybe a -> b -> (a -> b) -> b
+ Preamble: maybeResult :: Result a -> Maybe a
+ Preamble: maybeThrowIO :: (MonadIO m, Exception e) => e -> Maybe a -> m a
+ Preamble: maybeThrowIO' :: MonadIO m => String -> Maybe a -> m a
+ Preamble: maybeToList :: () => Maybe a -> [a]
+ Preamble: maybe_ :: Applicative f => Maybe a -> (a -> f ()) -> f ()
+ Preamble: mconcat :: Monoid a => [a] -> a
+ Preamble: mempty :: Monoid a => a
+ Preamble: mfilter :: MonadPlus m => a -> Bool -> m a -> m a
+ Preamble: min :: Ord a => a -> a -> a
+ Preamble: minBound :: Bounded a => a
+ Preamble: minimum :: (Foldable t, Ord a) => t a -> a
+ Preamble: minimum1Of :: Ord a => Getting Min a s a -> s -> a
+ Preamble: minimumBy :: Foldable t => a -> a -> Ordering -> t a -> a
+ Preamble: minimumByOf :: () => Getting Endo Endo Maybe a s a -> a -> a -> Ordering -> s -> Maybe a
+ Preamble: minimumOf :: Ord a => Getting Endo Endo Maybe a s a -> s -> Maybe a
+ Preamble: mkIOError :: IOErrorType -> String -> Maybe Handle -> Maybe FilePath -> IOError
+ Preamble: mod :: Integral a => a -> a -> a
+ Preamble: modifyIOError :: () => IOError -> IOError -> IO a -> IO a
+ Preamble: modifying :: MonadState s m => ASetter s s a b -> a -> b -> m ()
+ Preamble: mplus :: MonadPlus m => m a -> m a -> m a
+ Preamble: msum :: (Foldable t, MonadPlus m) => t m a -> m a
+ Preamble: msumOf :: MonadPlus m => Getting Endo m a s m a -> s -> m a
+ Preamble: mzero :: MonadPlus m => m a
+ Preamble: nearly :: () => a -> a -> Bool -> Prism' a ()
+ Preamble: negate :: Num a => a -> a
+ Preamble: newStderrLogger :: MonadIO m => LogLevel -> m Logger
+ Preamble: newStdoutLogger :: MonadIO m => LogLevel -> m Logger
+ Preamble: newtype Const a (b :: k) :: forall k. () => * -> k -> *
+ Preamble: newtype AssertionFailed
+ Preamble: newtype Bazaar (p :: * -> * -> *) a b t
+ Preamble: newtype Bazaar1 (p :: * -> * -> *) a b t
+ Preamble: newtype CompactionFailed
+ Preamble: newtype Down a
+ Preamble: newtype Identity a
+ Preamble: newtype Indexed i a b
+ Preamble: newtype NoMethodError
+ Preamble: newtype PatternMatchFail
+ Preamble: newtype RecConError
+ Preamble: newtype RecSelError
+ Preamble: newtype RecUpdError
+ Preamble: newtype ReifiedFold s a
+ Preamble: newtype ReifiedGetter s a
+ Preamble: newtype ReifiedIndexedFold i s a
+ Preamble: newtype ReifiedIndexedGetter i s a
+ Preamble: newtype ReifiedIndexedLens i s t a b
+ Preamble: newtype ReifiedIndexedSetter i s t a b
+ Preamble: newtype ReifiedIndexedTraversal i s t a b
+ Preamble: newtype ReifiedIso s t a b
+ Preamble: newtype ReifiedLens s t a b
+ Preamble: newtype ReifiedPrism s t a b
+ Preamble: newtype ReifiedSetter s t a b
+ Preamble: newtype ReifiedTraversal s t a b
+ Preamble: newtype TransT c m a
+ Preamble: newtype TypeError
+ Preamble: non :: Eq a => a -> Iso' Maybe a a
+ Preamble: non' :: () => APrism' a () -> Iso' Maybe a a
+ Preamble: none :: Foldable f => a -> Bool -> f a -> Bool
+ Preamble: noneOf :: () => Getting Any s a -> a -> Bool -> s -> Bool
+ Preamble: not :: Bool -> Bool
+ Preamble: notElem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Preamble: notElemOf :: Eq a => Getting All s a -> a -> s -> Bool
+ Preamble: notNullOf :: () => Getting Any s a -> s -> Bool
+ Preamble: nub :: Eq a => [a] -> [a]
+ Preamble: nubBy :: () => a -> a -> Bool -> [a] -> [a]
+ Preamble: null :: Foldable t => t a -> Bool
+ Preamble: nullLogger :: Logger
+ Preamble: nullOf :: () => Getting All s a -> s -> Bool
+ Preamble: odd :: Integral a => a -> Bool
+ Preamble: on :: () => b -> b -> c -> a -> b -> a -> a -> c
+ Preamble: onException :: MonadBaseControl IO m => m a -> m b -> m a
+ Preamble: only :: Eq a => a -> Prism' a ()
+ Preamble: op :: Wrapped s => Unwrapped s -> s -> s -> Unwrapped s
+ Preamble: or :: Foldable t => t Bool -> Bool
+ Preamble: orOf :: () => Getting Any s Bool -> s -> Bool
+ Preamble: otherwise :: Bool
+ Preamble: outside :: Representable p => APrism s t a b -> Lens p t r p s r p b r p a r
+ Preamble: over :: () => ASetter s t a b -> a -> b -> s -> t
+ Preamble: overA :: Arrow ar => LensLike Context a b s t a b -> ar a b -> ar s t
+ Preamble: para :: Plated a => a -> [r] -> r -> a -> r
+ Preamble: paraOf :: () => Getting Endo [a] a a -> a -> [r] -> r -> a -> r
+ Preamble: partition :: () => a -> Bool -> [a] -> ([a], [a])
+ Preamble: partitionEithers :: () => [Either a b] -> ([a], [b])
+ Preamble: parts :: Plated a => Lens' a [a]
+ Preamble: partsOf :: Functor f => Traversing ((->) :: * -> * -> *) f s t a a -> LensLike f s t [a] [a]
+ Preamble: partsOf' :: () => ATraversal s t a a -> Lens s t [a] [a]
+ Preamble: passing :: MonadWriter w m => Setter w w u v -> m (a, u -> v) -> m a
+ Preamble: permissionErrorType :: IOErrorType
+ Preamble: permutations :: () => [a] -> [[a]]
+ Preamble: pi :: Floating a => a
+ Preamble: plate :: Plated a => Traversal' a a
+ Preamble: pre :: () => Getting First a s a -> IndexPreservingGetter s Maybe a
+ Preamble: preCtx :: MonadCtx c m => Pairs -> TransT Ctx m a -> m a
+ Preamble: preStatsCtx :: MonadStatsCtx c m => Pairs -> TransT StatsCtx m a -> m a
+ Preamble: pred :: Enum a => a -> a
+ Preamble: preuse :: MonadState s m => Getting First a s a -> m Maybe a
+ Preamble: preuses :: MonadState s m => Getting First r s a -> a -> r -> m Maybe r
+ Preamble: preview :: MonadReader s m => Getting First a s a -> m Maybe a
+ Preamble: previews :: MonadReader s m => Getting First r s a -> a -> r -> m Maybe r
+ Preamble: print :: (MonadIO m, Show a) => a -> m ()
+ Preamble: prism :: () => b -> t -> s -> Either t a -> Prism s t a b
+ Preamble: prism' :: () => b -> s -> s -> Maybe a -> Prism s s a b
+ Preamble: product :: (Foldable f, Num a) => f a -> a
+ Preamble: productOf :: Num a => Getting Endo Endo a s a -> s -> a
+ Preamble: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Preamble: pure :: Applicative f => a -> f a
+ Preamble: putChar :: MonadIO m => Char -> m ()
+ Preamble: putStr :: MonadIO m => Text -> m ()
+ Preamble: putStrLn :: MonadIO m => Text -> m ()
+ Preamble: quot :: Integral a => a -> a -> a
+ Preamble: quotRem :: Integral a => a -> a -> (a, a)
+ Preamble: re :: () => AReview t b -> Getter b t
+ Preamble: read :: Read a => Text -> a
+ Preamble: readFile :: MonadIO m => FilePath -> m Text
+ Preamble: readIO :: (MonadIO m, Read a) => Text -> m a
+ Preamble: readList :: Read a => ReadS [a]
+ Preamble: readLn :: (MonadIO m, Read a) => m a
+ Preamble: readMay :: Read a => Text -> Maybe a
+ Preamble: readParen :: () => Bool -> ReadS a -> ReadS a
+ Preamble: reads :: Read a => ReadS a
+ Preamble: readsPrec :: Read a => Int -> ReadS a
+ Preamble: realToFrac :: (Real a, Fractional b) => a -> b
+ Preamble: recip :: Fractional a => a -> a
+ Preamble: reindexed :: Indexable j p => i -> j -> Indexed i a b -> r -> p a b -> r
+ Preamble: rem :: Integral a => a -> a -> a
+ Preamble: repeat :: () => a -> [a]
+ Preamble: repeated :: Apply f => LensLike' f a a
+ Preamble: replicate :: () => Int -> a -> [a]
+ Preamble: replicateM :: Applicative m => Int -> m a -> m [a]
+ Preamble: replicateM_ :: Applicative m => Int -> m a -> m ()
+ Preamble: replicated :: () => Int -> Fold a a
+ Preamble: retagged :: (Profunctor p, Bifunctor p) => p a b -> p s b
+ Preamble: return :: Monad m => a -> m a
+ Preamble: reuse :: MonadState b m => AReview t b -> m t
+ Preamble: reuses :: MonadState b m => AReview t b -> t -> r -> m r
+ Preamble: reverse :: () => [a] -> [a]
+ Preamble: reversed :: Reversing a => Iso' a a
+ Preamble: reversing :: Reversing t => t -> t
+ Preamble: review :: MonadReader b m => AReview t b -> m t
+ Preamble: reviews :: MonadReader b m => AReview t b -> t -> r -> m r
+ Preamble: rewrite :: Plated a => a -> Maybe a -> a -> a
+ Preamble: rewriteM :: (Monad m, Plated a) => a -> m Maybe a -> a -> m a
+ Preamble: rewriteMOf :: Monad m => LensLike WrappedMonad m a b a b -> b -> m Maybe a -> a -> m b
+ Preamble: rewriteMOn :: (Monad m, Plated a) => LensLike WrappedMonad m s t a a -> a -> m Maybe a -> s -> m t
+ Preamble: rewriteMOnOf :: Monad m => LensLike WrappedMonad m s t a b -> LensLike WrappedMonad m a b a b -> b -> m Maybe a -> s -> m t
+ Preamble: rewriteOf :: () => ASetter a b a b -> b -> Maybe a -> a -> b
+ Preamble: rewriteOn :: Plated a => ASetter s t a a -> a -> Maybe a -> s -> t
+ Preamble: rewriteOnOf :: () => ASetter s t a b -> ASetter a b a b -> b -> Maybe a -> s -> t
+ Preamble: right' :: Choice p => p a b -> p Either c a Either c b
+ Preamble: rights :: () => [Either a b] -> [b]
+ Preamble: rmap :: Profunctor p => b -> c -> p a b -> p a c
+ Preamble: rmapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> Iso p x s q y t p x a q y b
+ Preamble: round :: (RealFrac a, Integral b) => a -> b
+ Preamble: runCtx :: MonadIO m => TransT Ctx m a -> m a
+ Preamble: runEq :: () => AnEquality s t a b -> Identical s t a b
+ Preamble: runResourceT :: MonadUnliftIO m => ResourceT m a -> m a
+ Preamble: runStatsCtx :: MonadCtx c m => TransT StatsCtx m a -> m a
+ Preamble: runTransT :: HasCtx c => c -> TransT c m a -> m a
+ Preamble: sans :: At m => Index m -> m -> m
+ Preamble: scCtx :: HasStatsCtx c_ar0X => Lens' c_ar0X Ctx
+ Preamble: scLabels :: HasStatsCtx c_ar0X => Lens' c_ar0X Tags
+ Preamble: scPrefix :: HasStatsCtx c_ar0X => Lens' c_ar0X Text
+ Preamble: scStat :: HasStatsCtx c_ar0X => Lens' c_ar0X Stat
+ Preamble: scaleFloat :: RealFloat a => Int -> a -> a
+ Preamble: scanl :: () => b -> a -> b -> b -> [a] -> [b]
+ Preamble: scanl' :: () => b -> a -> b -> b -> [a] -> [b]
+ Preamble: scanl1 :: () => a -> a -> a -> [a] -> [a]
+ Preamble: scanl1Of :: () => LensLike State Maybe a s t a a -> a -> a -> a -> s -> t
+ Preamble: scanr :: () => a -> b -> b -> b -> [a] -> [b]
+ Preamble: scanr1 :: () => a -> a -> a -> [a] -> [a]
+ Preamble: scanr1Of :: () => LensLike Backwards State Maybe a s t a a -> a -> a -> a -> s -> t
+ Preamble: scribe :: (MonadWriter t m, Monoid s) => ASetter s t a b -> b -> m ()
+ Preamble: second :: Arrow a => a b c -> a (d, b) (d, c)
+ Preamble: seconding :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> Iso f x s g y t f x a g y b
+ Preamble: selfIndex :: Indexable a p => p a fb -> a -> fb
+ Preamble: seq :: () => a -> b -> b
+ Preamble: sequence :: (Traversable t, Monad m) => t m a -> m t a
+ Preamble: sequence1Of_ :: Functor f => Getting TraversedF a f s f a -> s -> f ()
+ Preamble: sequenceA :: (Traversable t, Applicative f) => t f a -> f t a
+ Preamble: sequenceAOf :: () => LensLike f s t f b b -> s -> f t
+ Preamble: sequenceAOf_ :: Functor f => Getting Traversed a f s f a -> s -> f ()
+ Preamble: sequenceA_ :: (Foldable t, Applicative f) => t f a -> f ()
+ Preamble: sequenceBy :: Traversable t => forall x. () => x -> f x -> forall x y. () => f x -> y -> f x -> f y -> t f a -> f t a
+ Preamble: 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
+ Preamble: sequenceOf :: () => LensLike WrappedMonad m s t m b b -> s -> m t
+ Preamble: sequenceOf_ :: Monad m => Getting Sequenced a m s m a -> s -> m ()
+ Preamble: sequence_ :: (Foldable t, Monad m) => t m a -> m ()
+ Preamble: set :: () => ASetter s t a b -> b -> s -> t
+ Preamble: set' :: () => ASetter' s a -> a -> s -> s
+ Preamble: sets :: (Profunctor p, Profunctor q, Settable f) => p a b -> q s t -> Optical p q f s t a b
+ Preamble: setting :: () => a -> b -> s -> t -> IndexPreservingSetter s t a b
+ Preamble: show :: Show a => a -> String
+ Preamble: showChar :: Char -> ShowS
+ Preamble: showList :: Show a => [a] -> ShowS
+ Preamble: showParen :: Bool -> ShowS -> ShowS
+ Preamble: showString :: String -> ShowS
+ Preamble: shows :: Show a => a -> ShowS
+ Preamble: showsPrec :: Show a => Int -> a -> ShowS
+ Preamble: significand :: RealFloat a => a -> a
+ Preamble: signum :: Num a => a -> a
+ Preamble: simple :: () => p a f a -> p a f a
+ Preamble: simpleLenses :: Lens' LensRules Bool
+ Preamble: simply :: () => Optic' p f s a -> r -> Optic' p f s a -> r
+ Preamble: sin :: Floating a => a -> a
+ Preamble: singular :: (HasCallStack, Conjoined p, Functor f) => Traversing p f s t a a -> Over p f s t a a
+ Preamble: sinh :: Floating a => a -> a
+ Preamble: snakeOptions :: Options
+ Preamble: snd :: () => (a, b) -> b
+ Preamble: snoc :: Snoc s s a a => s -> a -> s
+ Preamble: sort :: Ord a => [a] -> [a]
+ Preamble: sortBy :: () => a -> a -> Ordering -> [a] -> [a]
+ Preamble: sortOn :: Ord b => a -> b -> [a] -> [a]
+ Preamble: span :: () => a -> Bool -> [a] -> ([a], [a])
+ Preamble: spinalOptions :: Options
+ Preamble: splitAt :: () => Int -> [a] -> ([a], [a])
+ Preamble: sqrt :: Floating a => a -> a
+ Preamble: statsCount :: (MonadStatsCtx c m, Show a) => Text -> a -> Tags -> m ()
+ Preamble: statsCtx :: HasStatsCtx c_ar0X => Lens' c_ar0X StatsCtx
+ Preamble: statsDecrement :: MonadStatsCtx c m => Text -> Tags -> m ()
+ Preamble: statsGauge :: (MonadStatsCtx c m, Show a) => Text -> a -> Tags -> m ()
+ Preamble: statsHistogram :: (MonadStatsCtx c m, Show a) => Text -> a -> Tags -> m ()
+ Preamble: statsIncrement :: MonadStatsCtx c m => Text -> Tags -> m ()
+ Preamble: statsSet :: (MonadStatsCtx c m, Show a) => Text -> a -> Tags -> m ()
+ Preamble: statsTimer :: (MonadStatsCtx c m, Show a) => Text -> a -> Tags -> m ()
+ Preamble: storing :: () => ALens s t a b -> b -> s -> t
+ Preamble: strict :: Strict lazy strict => Iso' lazy strict
+ Preamble: stringShow :: Show a => a -> String
+ Preamble: stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]
+ Preamble: subsequences :: () => [a] -> [[a]]
+ Preamble: substEq :: () => AnEquality s t a b -> s ~ a -> t ~ b -> r -> r
+ Preamble: subtract :: Num a => a -> a -> a
+ Preamble: succ :: Enum a => a -> a
+ Preamble: sum :: (Foldable f, Num a) => f a -> a
+ Preamble: sumOf :: Num a => Getting Endo Endo a s a -> s -> a
+ Preamble: swap :: () => (a, b) -> (b, a)
+ Preamble: swapped :: (Swapped p, Profunctor p, Functor f) => p p b a f p d c -> p p a b f p c d
+ Preamble: tail :: () => [a] -> [a]
+ Preamble: tailMay :: () => [a] -> Maybe [a]
+ Preamble: tails :: () => [a] -> [[a]]
+ Preamble: take :: () => Int -> [a] -> [a]
+ Preamble: takeWhile :: () => a -> Bool -> [a] -> [a]
+ Preamble: taking :: (Conjoined p, Applicative f) => Int -> Traversing p f s t a a -> Over p f s t a a
+ Preamble: 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
+ Preamble: tan :: Floating a => a -> a
+ Preamble: tanh :: Floating a => a -> a
+ Preamble: terror :: HasCallStack => Text -> a
+ Preamble: textFromString :: String -> Text
+ Preamble: textShow :: Show a => a -> Text
+ Preamble: textToString :: Text -> String
+ Preamble: throw :: Exception e => e -> a
+ Preamble: throwIO :: (MonadBase IO m, Exception e) => e -> m a
+ Preamble: throwTo :: (MonadBase IO m, Exception e) => ThreadId -> e -> m ()
+ Preamble: to :: (Profunctor p, Contravariant f) => s -> a -> Optic' p f s a
+ Preamble: toEnum :: Enum a => Int -> a
+ Preamble: toException :: Exception e => e -> SomeException
+ Preamble: toInteger :: Integral a => a -> Integer
+ Preamble: toListOf :: () => Getting Endo [a] s a -> s -> [a]
+ Preamble: toNonEmptyOf :: () => Getting NonEmptyDList a s a -> s -> NonEmpty a
+ Preamble: toRational :: Real a => a -> Rational
+ Preamble: traceDebug :: MonadCtx c m => Text -> Pairs -> m ()
+ Preamble: traceError :: MonadCtx c m => Text -> Pairs -> m ()
+ Preamble: traceInfo :: MonadCtx c m => Text -> Pairs -> m ()
+ Preamble: traceWarn :: MonadCtx c m => Text -> Pairs -> m ()
+ Preamble: transform :: Plated a => a -> a -> a -> a
+ Preamble: transformM :: (Monad m, Plated a) => a -> m a -> a -> m a
+ Preamble: transformMOf :: Monad m => LensLike WrappedMonad m a b a b -> b -> m b -> a -> m b
+ Preamble: transformMOn :: (Monad m, Plated a) => LensLike WrappedMonad m s t a a -> a -> m a -> s -> m t
+ Preamble: transformMOnOf :: Monad m => LensLike WrappedMonad m s t a b -> LensLike WrappedMonad m a b a b -> b -> m b -> s -> m t
+ Preamble: transformOf :: () => ASetter a b a b -> b -> b -> a -> b
+ Preamble: transformOn :: Plated a => ASetter s t a a -> a -> a -> s -> t
+ Preamble: transformOnOf :: () => ASetter s t a b -> ASetter a b a b -> b -> b -> s -> t
+ Preamble: transpose :: () => [[a]] -> [[a]]
+ Preamble: transposeOf :: () => LensLike ZipList s t [a] a -> s -> [t]
+ Preamble: traverse :: (Traversable t, Applicative f) => a -> f b -> t a -> f t b
+ Preamble: traverse1 :: (Traversable1 t, Apply f) => a -> f b -> t a -> f t b
+ Preamble: traverse1Of_ :: Functor f => Getting TraversedF r f s a -> a -> f r -> s -> f ()
+ Preamble: 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
+ Preamble: 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
+ Preamble: traverseMax :: (TraverseMax k m, Indexable k p, Applicative f) => p v f v -> m v -> f m v
+ Preamble: traverseMin :: (TraverseMin k m, Indexable k p, Applicative f) => p v f v -> m v -> f m v
+ Preamble: traverseOf :: () => LensLike f s t a b -> a -> f b -> s -> f t
+ Preamble: traverseOf_ :: Functor f => Getting Traversed r f s a -> a -> f r -> s -> f ()
+ Preamble: traverse_ :: (Foldable t, Applicative f) => a -> f b -> t a -> f ()
+ Preamble: traversed :: Traversable f => IndexedTraversal Int f a f b a b
+ Preamble: traversed1 :: Traversable1 f => IndexedTraversal1 Int f a f b a b
+ Preamble: traversed64 :: Traversable f => IndexedTraversal Int64 f a f b a b
+ Preamble: truncate :: (RealFrac a, Integral b) => a -> b
+ Preamble: try :: (MonadBaseControl IO m, Exception e) => m a -> m Either e a
+ Preamble: tryIOError :: () => IO a -> IO Either IOError a
+ Preamble: tryJust :: (MonadBaseControl IO m, Exception e) => e -> Maybe b -> m a -> m Either b a
+ Preamble: tshow :: Show a => a -> Text
+ Preamble: type ALens s t a b = LensLike Pretext ((->) :: * -> * -> *) a b s t a b
+ Preamble: type ALens' s a = ALens s s a a
+ Preamble: type APrism s t a b = Market a b a Identity b -> Market a b s Identity t
+ Preamble: type APrism' s a = APrism s s a a
+ Preamble: type AReview t b = Optic' (Tagged :: * -> * -> *) Identity t b
+ Preamble: type ASetter s t a b = a -> Identity b -> s -> Identity t
+ Preamble: type ASetter' s a = ASetter s s a a
+ Preamble: type ATraversal s t a b = LensLike Bazaar ((->) :: * -> * -> *) a b s t a b
+ Preamble: type ATraversal' s a = ATraversal s s a a
+ Preamble: type ATraversal1 s t a b = LensLike Bazaar1 ((->) :: * -> * -> *) a b s t a b
+ Preamble: type ATraversal1' s a = ATraversal1 s s a a
+ Preamble: type Accessing (p :: * -> * -> *) m s a = p a Const m a -> s -> Const m s
+ Preamble: type AnEquality (s :: k1) (t :: k2) (a :: k1) (b :: k2) = Identical a Proxy b a Proxy b -> Identical a Proxy b s Proxy t
+ Preamble: type AnEquality' (s :: k2) (a :: k2) = AnEquality s s a a
+ Preamble: type AnIndexedLens i s t a b = Optical Indexed i ((->) :: * -> * -> *) Pretext Indexed i a b s t a b
+ Preamble: type AnIndexedLens' i s a = AnIndexedLens i s s a a
+ Preamble: type AnIndexedSetter i s t a b = Indexed i a Identity b -> s -> Identity t
+ Preamble: type AnIndexedSetter' i s a = AnIndexedSetter i s s a a
+ Preamble: type AnIndexedTraversal i s t a b = Over Indexed i Bazaar Indexed i a b s t a b
+ Preamble: type AnIndexedTraversal' i s a = AnIndexedTraversal i s s a a
+ Preamble: type AnIndexedTraversal1 i s t a b = Over Indexed i Bazaar1 Indexed i a b s t a b
+ Preamble: type AnIndexedTraversal1' i s a = AnIndexedTraversal1 i s s a a
+ Preamble: type AnIso s t a b = Exchange a b a Identity b -> Exchange a b s Identity t
+ Preamble: type AnIso' s a = AnIso s s a a
+ Preamble: type As (a :: k2) = Equality' a a
+ Preamble: type Bazaar' (p :: * -> * -> *) a = Bazaar p a a
+ Preamble: type Bazaar1' (p :: * -> * -> *) a = Bazaar1 p a a
+ Preamble: type ClassyNamer = Name -> Maybe (Name, Name)
+ Preamble: type Context' a = Context a a
+ Preamble: type Equality' (s :: k2) (a :: k2) = Equality s s a a
+ Preamble: type FieldNamer = Name -> [Name] -> Name -> [DefName]
+ Preamble: type FilePath = String
+ Preamble: type Getting r s a = a -> Const r a -> s -> Const r s
+ Preamble: type IOError = IOException
+ Preamble: type IndexPreservingLens' s a = IndexPreservingLens s s a a
+ Preamble: type IndexPreservingSetter' s a = IndexPreservingSetter s s a a
+ Preamble: type IndexPreservingTraversal' s a = IndexPreservingTraversal s s a a
+ Preamble: type IndexPreservingTraversal1' s a = IndexPreservingTraversal1 s s a a
+ Preamble: type IndexedGetting i m s a = Indexed i a Const m a -> s -> Const m s
+ Preamble: type IndexedLens' i s a = IndexedLens i s s a a
+ Preamble: type IndexedLensLike' i (f :: * -> *) s a = IndexedLensLike i f s s a a
+ Preamble: type IndexedSetter' i s a = IndexedSetter i s s a a
+ Preamble: type IndexedTraversal' i s a = IndexedTraversal i s s a a
+ Preamble: type IndexedTraversal1' i s a = IndexedTraversal1 i s s a a
+ Preamble: type Iso' s a = Iso s s a a
+ Preamble: type LByteString = ByteString
+ Preamble: type LText = Text
+ Preamble: type Lens' s a = Lens s s a a
+ Preamble: type LensLike (f :: k -> *) s (t :: k) a (b :: k) = a -> f b -> s -> f t
+ Preamble: type LensLike' (f :: * -> *) s a = LensLike f s s a a
+ Preamble: type Logger = Loc -> LogSource -> LogLevel -> LogStr -> IO ()
+ Preamble: type MonadCtx c m = (MonadIO m, MonadReader c m, MonadLogger m, MonadMask m, MonadCatch m, MonadThrow m, HasCtx c)
+ Preamble: type MonadStatsCtx c m = (MonadCtx c m, HasStatsCtx c)
+ Preamble: type Optic (p :: k1 -> k -> *) (f :: k2 -> k) (s :: k1) (t :: k2) (a :: k1) (b :: k2) = p a f b -> p s f t
+ Preamble: type Optic' (p :: k1 -> k -> *) (f :: k1 -> k) (s :: k1) (a :: k1) = Optic p f s s a a
+ Preamble: type Optical (p :: k2 -> k -> *) (q :: k1 -> k -> *) (f :: k3 -> k) (s :: k1) (t :: k3) (a :: k2) (b :: k3) = p a f b -> q s f t
+ Preamble: type Optical' (p :: k1 -> k -> *) (q :: k1 -> k -> *) (f :: k1 -> k) (s :: k1) (a :: k1) = Optical p q f s s a a
+ Preamble: type Over (p :: k -> * -> *) (f :: k1 -> *) s (t :: k1) (a :: k) (b :: k1) = p a f b -> s -> f t
+ Preamble: type Over' (p :: * -> * -> *) (f :: * -> *) s a = Over p f s s a a
+ Preamble: type Pairs = [(Text, Value)]
+ Preamble: type Prism' s a = Prism s s a a
+ Preamble: type Rational = Ratio Integer
+ Preamble: type ReadS a = String -> [(a, String)]
+ Preamble: type ReifiedIndexedLens' i s a = ReifiedIndexedLens i s s a a
+ Preamble: type ReifiedIndexedSetter' i s a = ReifiedIndexedSetter i s s a a
+ Preamble: type ReifiedIndexedTraversal' i s a = ReifiedIndexedTraversal i s s a a
+ Preamble: type ReifiedIso' s a = ReifiedIso s s a a
+ Preamble: type ReifiedLens' s a = ReifiedLens s s a a
+ Preamble: type ReifiedPrism' s a = ReifiedPrism s s a a
+ Preamble: type ReifiedSetter' s a = ReifiedSetter s s a a
+ Preamble: type ReifiedTraversal' s a = ReifiedTraversal s s a a
+ Preamble: type SVector = Vector
+ Preamble: type Setter' s a = Setter s s a a
+ Preamble: type Setting (p :: * -> * -> *) s t a b = p a Identity b -> s -> Identity t
+ Preamble: type Setting' (p :: * -> * -> *) s a = Setting p s s a a
+ Preamble: type ShowS = String -> String
+ Preamble: type Simple (f :: k -> k -> k1 -> k1 -> k2) (s :: k) (a :: k1) = f s s a a
+ Preamble: type Stat = ByteString -> IO ()
+ Preamble: type String = [Char]
+ Preamble: type Tags = [(Text, Text)]
+ Preamble: type Traversal' s a = Traversal s s a a
+ Preamble: type Traversal1' s a = Traversal1 s s a a
+ Preamble: type Traversing (p :: * -> * -> *) (f :: * -> *) s t a b = Over p BazaarT p f a b s t a b
+ Preamble: type Traversing' (p :: * -> * -> *) (f :: * -> *) s a = Traversing p f s s a a
+ Preamble: type Traversing1 (p :: * -> * -> *) (f :: * -> *) s t a b = Over p BazaarT1 p f a b s t a b
+ Preamble: type Traversing1' (p :: * -> * -> *) (f :: * -> *) s a = Traversing1 p f s s a a
+ Preamble: type UVector = Vector
+ Preamble: type Fold1 s a = forall (f :: * -> *). (Contravariant f, Apply f) => a -> f a -> s -> f s
+ Preamble: type family Unwrapped s :: *;
+ Preamble: type IndexedLensLike i (f :: k -> *) s (t :: k) a (b :: k) = forall (p :: * -> * -> *). Indexable i p => p a f b -> s -> f t
+ Preamble: un :: (Profunctor p, Bifunctor p, Functor f) => Getting a s a -> Optic' p f a s
+ Preamble: uncons :: () => [a] -> Maybe (a, [a])
+ Preamble: uncurried :: (Profunctor p, Functor f) => p (a, b) -> c f (d, e) -> f -> p a -> b -> c f d -> e -> f
+ Preamble: uncurry :: () => a -> b -> c -> (a, b) -> c
+ Preamble: undefined :: HasCallStack => a
+ Preamble: under :: () => AnIso s t a b -> t -> s -> b -> a
+ Preamble: underscoreFields :: LensRules
+ Preamble: underscoreNamer :: FieldNamer
+ Preamble: underscoreNoPrefixNamer :: FieldNamer
+ Preamble: unfolded :: () => b -> Maybe (a, b) -> Fold b a
+ Preamble: unfoldr :: () => b -> Maybe (a, b) -> b -> [a]
+ Preamble: uninterruptibleMask :: MonadBaseControl IO m => forall a. () => m a -> m a -> m b -> m b
+ Preamble: uninterruptibleMask_ :: MonadBaseControl IO m => m a -> m a
+ Preamble: union :: Eq a => [a] -> [a] -> [a]
+ Preamble: unionBy :: () => a -> a -> Bool -> [a] -> [a] -> [a]
+ Preamble: united :: Functor f => () -> f () -> a -> f a
+ Preamble: universe :: Plated a => a -> [a]
+ Preamble: universeOf :: () => Getting [a] a a -> a -> [a]
+ Preamble: universeOn :: Plated a => Getting [a] s a -> s -> [a]
+ Preamble: universeOnOf :: () => Getting [a] s a -> Getting [a] a a -> s -> [a]
+ Preamble: unless :: Applicative f => Bool -> f () -> f ()
+ Preamble: unlines :: [Text] -> Text
+ Preamble: unsafePartsOf :: Functor f => Traversing ((->) :: * -> * -> *) f s t a b -> LensLike f s t [a] [b]
+ Preamble: unsafePartsOf' :: () => ATraversal s t a b -> Lens s t [a] [b]
+ Preamble: unsafeSingular :: (HasCallStack, Conjoined p, Functor f) => Traversing p f s t a b -> Over p f s t a b
+ Preamble: unsnoc :: Snoc s s a a => s -> Maybe (s, a)
+ Preamble: until :: () => a -> Bool -> a -> a -> a -> a
+ Preamble: unto :: (Profunctor p, Bifunctor p, Functor f) => b -> t -> Optic p f s t a b
+ Preamble: unwords :: [Text] -> Text
+ Preamble: unzip :: () => [(a, b)] -> ([a], [b])
+ Preamble: unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])
+ Preamble: unzip4 :: () => [(a, b, c, d)] -> ([a], [b], [c], [d])
+ Preamble: unzip5 :: () => [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
+ Preamble: unzip6 :: () => [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
+ Preamble: unzip7 :: () => [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
+ Preamble: use :: MonadState s m => Getting a s a -> m a
+ Preamble: userError :: String -> IOError
+ Preamble: userErrorType :: IOErrorType
+ Preamble: uses :: MonadState s m => LensLike' (Const r :: * -> *) s a -> a -> r -> m r
+ Preamble: view :: MonadReader s m => Getting a s a -> m a
+ Preamble: views :: MonadReader s m => LensLike' (Const r :: * -> *) s a -> a -> r -> m r
+ Preamble: void :: Functor f => f a -> f ()
+ Preamble: when :: Applicative f => Bool -> f () -> f ()
+ Preamble: withIndex :: (Indexable i p, Functor f) => p (i, s) f (j, t) -> Indexed i s f t
+ Preamble: withIso :: () => AnIso s t a b -> s -> a -> b -> t -> r -> r
+ Preamble: withPrism :: () => APrism s t a b -> b -> t -> s -> Either t a -> r -> r
+ Preamble: without :: () => APrism s t a b -> APrism u v c d -> Prism Either s u Either t v Either a c Either b d
+ Preamble: worded :: Applicative f => IndexedLensLike' Int f String String
+ Preamble: words :: Text -> [Text]
+ Preamble: writeFile :: MonadIO m => FilePath -> Text -> m ()
+ Preamble: zip :: () => [a] -> [b] -> [(a, b)]
+ Preamble: zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]
+ Preamble: zip4 :: () => [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
+ Preamble: zip5 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
+ Preamble: zip6 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
+ Preamble: zip7 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
+ Preamble: zipWith :: () => a -> b -> c -> [a] -> [b] -> [c]
+ Preamble: zipWith3 :: () => a -> b -> c -> d -> [a] -> [b] -> [c] -> [d]
+ Preamble: zipWith4 :: () => a -> b -> c -> d -> e -> [a] -> [b] -> [c] -> [d] -> [e]
+ Preamble: zipWith5 :: () => a -> b -> c -> d -> e -> f -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
+ Preamble: zipWith6 :: () => a -> b -> c -> d -> e -> f -> g -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
+ Preamble: zipWith7 :: () => a -> b -> c -> d -> e -> f -> g -> h -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
+ Preamble: zipWithM :: Applicative m => a -> b -> m c -> [a] -> [b] -> m [c]
+ Preamble: zipWithM_ :: Applicative m => a -> b -> m c -> [a] -> [b] -> m ()
+ Preamble: zoom :: Zoom m n s t => LensLike' Zoomed m c t s -> m c -> n c
+ Preamble: }
Files
- preamble.cabal +9/−9
- src/Preamble/Types/Alias.hs +0/−12
- src/Preamble/Types/Ctx.hs +2/−1
preamble.cabal view
@@ -1,6 +1,6 @@ cabal-version: >=1.22 name: preamble-version: 0.0.61+version: 0.0.62 license: MIT license-file: LICENSE copyright: Copyright (C) 2016 Swift Navigation, Inc.@@ -36,24 +36,24 @@ default-language: Haskell2010 ghc-options: -Wall build-depends:- MonadRandom >=0.5.1,+ MonadRandom >=0.5.1.1, aeson >=1.2.4.0, base >=4.8 && <5, basic-prelude >=0.7.0, exceptions >=0.8.3, fast-logger >=2.4.11,- lens >=4.15.4,+ lens >=4.16.1, lifted-base >=0.2.3.12, monad-control >=1.0.2.3,- monad-logger >=0.3.28.2,+ monad-logger >=0.3.28.5, mtl >=2.2.2,- network >=2.6.3.4,- resourcet >=1.1.11,- safe >=0.3.15,+ network >=2.6.3.6,+ resourcet >=1.2.1,+ safe >=0.3.17, template-haskell >=2.12.0.0,- text >=1.2.2.2,+ text >=1.2.3.0, text-manipulate >=0.2.0.1, time >=1.8.0.2, transformers-base >=0.4.4,- unordered-containers >=0.2.8.0,+ unordered-containers >=0.2.9.0, uuid >=1.3.13
src/Preamble/Types/Alias.hs view
@@ -8,10 +8,7 @@ ( module Preamble.Types.Alias ) where -import Control.Monad.Catch import Control.Monad.Logger-import Control.Monad.Random-import Control.Monad.Trans.Control import Data.Aeson import Preamble.Prelude @@ -30,12 +27,3 @@ -- | Stat -- type Stat = ByteString -> IO ()---- | MonadControl----type MonadControl m =- ( MonadBaseControl IO m- , MonadIO m- , MonadMask m- , MonadRandom m- )
src/Preamble/Types/Ctx.hs view
@@ -30,9 +30,10 @@ $(makeClassy ''Ctx) type MonadCtx c m =- ( MonadControl m+ ( MonadIO m , MonadReader c m , MonadLogger m+ , MonadMask m , MonadCatch m , MonadThrow m , HasCtx c