interlude-l 0.4.0.0 → 0.5.0.0
raw patch · 1 files changed
+5/−5 lines, 1 filesdep ~aesondep ~exceptionsdep ~lensPVP ok
version bump matches the API change (PVP)
Dependency ranges changed: aeson, exceptions, lens, witherable
API changes (from Hackage documentation)
+ Interlude: (#%%=) :: MonadState s m => ALens s s a b -> (a -> (r, b)) -> m r
+ Interlude: (#%%~) :: Functor f => ALens s t a b -> (a -> f b) -> s -> f t
+ Interlude: (#%=) :: MonadState s m => ALens s s a b -> (a -> b) -> m ()
+ Interlude: (#%~) :: () => ALens s t a b -> (a -> b) -> s -> t
+ Interlude: (#) :: () => AReview t b -> b -> t
+ Interlude: (#=) :: MonadState s m => ALens s s a b -> b -> m ()
+ Interlude: (#~) :: () => ALens s t a b -> b -> s -> t
+ Interlude: ($!!) :: NFData a => (a -> b) -> a -> b
+ Interlude: ($!) :: () => (a -> b) -> a -> b
+ Interlude: ($) :: () => (a -> b) -> a -> b
+ Interlude: ($>) :: Functor f => f a -> b -> f b
+ Interlude: (%%=) :: MonadState s m => Over p ((,) r) s s a b -> p a (r, b) -> m r
+ Interlude: (%%@=) :: MonadState s m => Over (Indexed i) ((,) r) s s a b -> (i -> a -> (r, b)) -> m r
+ Interlude: (%%@~) :: () => Over (Indexed i) f s t a b -> (i -> a -> f b) -> s -> f t
+ Interlude: (%%~) :: () => LensLike f s t a b -> (a -> f b) -> s -> f t
+ Interlude: (%) :: Integral a => a -> a -> Ratio a
+ Interlude: (%=) :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()
+ Interlude: (%@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m ()
+ Interlude: (%@~) :: () => AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
+ Interlude: (%~) :: () => ASetter s t a b -> (a -> b) -> s -> t
+ Interlude: (&&) :: Bool -> Bool -> Bool
+ Interlude: (&&=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()
+ Interlude: (&&^) :: Monad m => m Bool -> m Bool -> m Bool
+ Interlude: (&&~) :: () => ASetter s t Bool Bool -> Bool -> s -> t
+ Interlude: (&) :: () => a -> (a -> b) -> b
+ Interlude: (&~) :: () => s -> State s a -> s
+ Interlude: (*) :: Num a => a -> a -> a
+ Interlude: (**) :: Floating a => a -> a -> a
+ Interlude: (**=) :: (MonadState s m, Floating a) => ASetter' s a -> a -> m ()
+ Interlude: (**~) :: Floating a => ASetter s t a a -> a -> s -> t
+ Interlude: (*=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
+ Interlude: (*>) :: Applicative f => f a -> f b -> f b
+ Interlude: (*~) :: Num a => ASetter s t a a -> a -> s -> t
+ Interlude: (+) :: Num a => a -> a -> a
+ Interlude: (++) :: () => [a] -> [a] -> [a]
+ Interlude: (+=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
+ Interlude: (+~) :: Num a => ASetter s t a a -> a -> s -> t
+ Interlude: (-) :: Num a => a -> a -> a
+ Interlude: (-=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
+ Interlude: (-~) :: Num a => ASetter s t a a -> a -> s -> t
+ Interlude: (.&.) :: Bits a => a -> a -> a
+ Interlude: (.) :: () => (b -> c) -> (a -> b) -> a -> c
+ Interlude: (...) :: (Applicative f, Plated c) => LensLike f s t c c -> Over p f c c a b -> Over p f s t a b
+ Interlude: (.=) :: MonadState s m => ASetter s s a b -> b -> m ()
+ Interlude: (.>) :: () => (st -> r) -> (kab -> st) -> kab -> r
+ Interlude: (.@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> b) -> m ()
+ Interlude: (.@~) :: () => AnIndexedSetter i s t a b -> (i -> b) -> s -> t
+ Interlude: (.|.) :: Bits a => a -> a -> a
+ Interlude: (.~) :: () => ASetter s t a b -> b -> s -> t
+ Interlude: (/) :: Fractional a => a -> a -> a
+ Interlude: (//=) :: (MonadState s m, Fractional a) => ASetter' s a -> a -> m ()
+ Interlude: (//~) :: Fractional a => ASetter s t a a -> a -> s -> t
+ Interlude: (/=) :: Eq a => a -> a -> Bool
+ Interlude: (:%) :: !a -> !a -> Ratio a
+ Interlude: (:*:) :: f p -> g p -> (:*:)
+ Interlude: (:+) :: !a -> !a -> Complex a
+ Interlude: (:|) :: a -> [a] -> NonEmpty a
+ Interlude: (<#%=) :: MonadState s m => ALens s s a b -> (a -> b) -> m b
+ Interlude: (<#%~) :: () => ALens s t a b -> (a -> b) -> s -> (b, t)
+ Interlude: (<#=) :: MonadState s m => ALens s s a b -> b -> m b
+ Interlude: (<#~) :: () => ALens s t a b -> b -> s -> (b, t)
+ Interlude: (<$!>) :: Monad m => (a -> b) -> m a -> m b
+ Interlude: (<$) :: Functor f => a -> f b -> f a
+ Interlude: (<$>) :: Functor f => (a -> b) -> f a -> f b
+ Interlude: (<%=) :: MonadState s m => LensLike ((,) b) s s a b -> (a -> b) -> m b
+ Interlude: (<%@=) :: MonadState s m => Over (Indexed i) ((,) b) s s a b -> (i -> a -> b) -> m b
+ Interlude: (<%@~) :: () => Over (Indexed i) ((,) b) s t a b -> (i -> a -> b) -> s -> (b, t)
+ Interlude: (<%~) :: () => LensLike ((,) b) s t a b -> (a -> b) -> s -> (b, t)
+ Interlude: (<&&=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
+ Interlude: (<&&>) :: Applicative a => a Bool -> a Bool -> a Bool
+ Interlude: (<&&~) :: () => LensLike ((,) Bool) s t Bool Bool -> Bool -> s -> (Bool, t)
+ Interlude: (<&>) :: Functor f => f a -> (a -> b) -> f b
+ Interlude: (<) :: Ord a => a -> a -> Bool
+ Interlude: (<*) :: Applicative f => f a -> f b -> f a
+ Interlude: (<**=) :: (MonadState s m, Floating a) => LensLike' ((,) a) s a -> a -> m a
+ Interlude: (<**>) :: Applicative f => f a -> f (a -> b) -> f b
+ Interlude: (<**~) :: Floating a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Interlude: (<*=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Interlude: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
+ Interlude: (<*~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Interlude: (<+=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Interlude: (<+~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Interlude: (<-=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Interlude: (<-~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Interlude: (<.) :: Indexable i p => (Indexed i s t -> r) -> ((a -> b) -> s -> t) -> p a b -> r
+ Interlude: (<.=) :: MonadState s m => ASetter s s a b -> b -> m b
+ Interlude: (<.>) :: Indexable (i, j) p => (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> p a b -> r
+ Interlude: (<.~) :: () => ASetter s t a b -> b -> s -> (b, t)
+ Interlude: (<//=) :: (MonadState s m, Fractional a) => LensLike' ((,) a) s a -> a -> m a
+ Interlude: (<//~) :: Fractional a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Interlude: (<<$>>) :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
+ Interlude: (<<%=) :: (Strong p, MonadState s m) => Over p ((,) a) s s a b -> p a b -> m a
+ Interlude: (<<%@=) :: MonadState s m => Over (Indexed i) ((,) a) s s a b -> (i -> a -> b) -> m a
+ Interlude: (<<%@~) :: () => Over (Indexed i) ((,) a) s t a b -> (i -> a -> b) -> s -> (a, t)
+ Interlude: (<<%~) :: () => LensLike ((,) a) s t a b -> (a -> b) -> s -> (a, t)
+ Interlude: (<<&&=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
+ Interlude: (<<&&~) :: () => LensLike' ((,) Bool) s Bool -> Bool -> s -> (Bool, s)
+ Interlude: (<<**=) :: (MonadState s m, Floating a) => LensLike' ((,) a) s a -> a -> m a
+ Interlude: (<<**~) :: Floating a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Interlude: (<<*=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Interlude: (<<*>>) :: (Applicative f, Applicative g) => f (g (a -> b)) -> f (g a) -> f (g b)
+ Interlude: (<<*~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Interlude: (<<+=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Interlude: (<<+~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Interlude: (<<-=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Interlude: (<<-~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Interlude: (<<.=) :: MonadState s m => LensLike ((,) a) s s a b -> b -> m a
+ Interlude: (<<.~) :: () => LensLike ((,) a) s t a b -> b -> s -> (a, t)
+ Interlude: (<<//=) :: (MonadState s m, Fractional a) => LensLike' ((,) a) s a -> a -> m a
+ Interlude: (<<//~) :: Fractional a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Interlude: (<<<>=) :: (MonadState s m, Monoid r) => LensLike' ((,) r) s r -> r -> m r
+ Interlude: (<<<>~) :: Monoid r => LensLike' ((,) r) s r -> r -> s -> (r, s)
+ Interlude: (<<>=) :: (MonadState s m, Monoid r) => LensLike' ((,) r) s r -> r -> m r
+ Interlude: (<<>~) :: Monoid m => LensLike ((,) m) s t m m -> m -> s -> (m, t)
+ Interlude: (<<?=) :: MonadState s m => LensLike ((,) a) s s a (Maybe b) -> b -> m a
+ Interlude: (<<?~) :: () => LensLike ((,) a) s t a (Maybe b) -> b -> s -> (a, t)
+ Interlude: (<<^=) :: (MonadState s m, Num a, Integral e) => LensLike' ((,) a) s a -> e -> m a
+ Interlude: (<<^^=) :: (MonadState s m, Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> m a
+ Interlude: (<<^^~) :: (Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> s -> (a, s)
+ Interlude: (<<^~) :: (Num a, Integral e) => LensLike' ((,) a) s a -> e -> s -> (a, s)
+ Interlude: (<<||=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
+ Interlude: (<<||~) :: () => LensLike' ((,) Bool) s Bool -> Bool -> s -> (Bool, s)
+ Interlude: (<<~) :: MonadState s m => ALens s s a b -> m b -> m b
+ Interlude: (<=) :: Ord a => a -> a -> Bool
+ Interlude: (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
+ Interlude: (<>) :: Semigroup a => a -> a -> a
+ Interlude: (<>=) :: (MonadState s m, Monoid a) => ASetter' s a -> a -> m ()
+ Interlude: (<>~) :: Monoid a => ASetter s t a a -> a -> s -> t
+ Interlude: (<?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m b
+ Interlude: (<?~) :: () => ASetter s t a (Maybe b) -> b -> s -> (b, t)
+ Interlude: (<^=) :: (MonadState s m, Num a, Integral e) => LensLike' ((,) a) s a -> e -> m a
+ Interlude: (<^^=) :: (MonadState s m, Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> m a
+ Interlude: (<^^~) :: (Fractional a, Integral e) => LensLike ((,) a) s t a a -> e -> s -> (a, t)
+ Interlude: (<^~) :: (Num a, Integral e) => LensLike ((,) a) s t a a -> e -> s -> (a, t)
+ Interlude: (<|) :: Cons s s a a => a -> s -> s
+ Interlude: (<|>) :: Alternative f => f a -> f a -> f a
+ Interlude: (<||=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
+ Interlude: (<||>) :: Applicative a => a Bool -> a Bool -> a Bool
+ Interlude: (<||~) :: () => LensLike ((,) Bool) s t Bool Bool -> Bool -> s -> (Bool, t)
+ Interlude: (<~) :: MonadState s m => ASetter s s a b -> m b -> m ()
+ Interlude: (=<<) :: Monad m => (a -> m b) -> m a -> m b
+ Interlude: (==) :: Eq a => a -> a -> Bool
+ Interlude: (>) :: Ord a => a -> a -> Bool
+ Interlude: (>=) :: Ord a => a -> a -> Bool
+ Interlude: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
+ Interlude: (>>) :: Monad m => m a -> m b -> m b
+ Interlude: (>>=) :: Monad m => m a -> (a -> m b) -> m b
+ Interlude: (?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m ()
+ Interlude: (??) :: Functor f => f (a -> b) -> a -> f b
+ Interlude: (?~) :: () => ASetter s t a (Maybe b) -> b -> s -> t
+ Interlude: (^#) :: () => s -> ALens s t a b -> a
+ Interlude: (^%^) :: Integral a => Rational -> a -> Rational
+ Interlude: (^) :: (Num a, Integral b) => a -> b -> a
+ Interlude: (^.) :: () => s -> Getting a s a -> a
+ Interlude: (^..) :: () => s -> Getting (Endo [a]) s a -> [a]
+ Interlude: (^=) :: (MonadState s m, Num a, Integral e) => ASetter' s a -> e -> m ()
+ Interlude: (^?!) :: HasCallStack => s -> Getting (Endo a) s a -> a
+ Interlude: (^?) :: () => s -> Getting (First a) s a -> Maybe a
+ Interlude: (^@.) :: () => s -> IndexedGetting i (i, a) s a -> (i, a)
+ Interlude: (^@..) :: () => s -> IndexedGetting i (Endo [(i, a)]) s a -> [(i, a)]
+ Interlude: (^@?!) :: HasCallStack => s -> IndexedGetting i (Endo (i, a)) s a -> (i, a)
+ Interlude: (^@?) :: () => s -> IndexedGetting i (Endo (Maybe (i, a))) s a -> Maybe (i, a)
+ Interlude: (^^%^^) :: Integral a => Rational -> a -> Rational
+ Interlude: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Interlude: (^^=) :: (MonadState s m, Fractional a, Integral e) => ASetter' s a -> e -> m ()
+ Interlude: (^^~) :: (Fractional a, Integral e) => ASetter s t a a -> e -> s -> t
+ Interlude: (^~) :: (Num a, Integral e) => ASetter s t a a -> e -> s -> t
+ Interlude: (|>) :: Snoc s s a a => s -> a -> s
+ Interlude: (||) :: Bool -> Bool -> Bool
+ Interlude: (||=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()
+ Interlude: (||^) :: Monad m => m Bool -> m Bool -> m Bool
+ Interlude: (||~) :: () => ASetter s t Bool Bool -> Bool -> s -> t
+ Interlude: -- | Generic representation type
+ Interlude: All :: Bool -> All
+ Interlude: AllocationLimitExceeded :: AllocationLimitExceeded
+ Interlude: Alt :: f a -> Alt
+ Interlude: Any :: Bool -> Any
+ Interlude: Ap :: f a -> Ap
+ Interlude: AppendMode :: IOMode
+ Interlude: AssertionFailed :: String -> AssertionFailed
+ Interlude: BlockedIndefinitelyOnMVar :: BlockedIndefinitelyOnMVar
+ Interlude: BlockedIndefinitelyOnSTM :: BlockedIndefinitelyOnSTM
+ Interlude: ClosePunctuation :: GeneralCategory
+ Interlude: Comp1 :: f (g p) -> (:.:)
+ Interlude: CompactionFailed :: String -> CompactionFailed
+ Interlude: Concurrently :: IO a -> Concurrently a
+ Interlude: ConnectorPunctuation :: GeneralCategory
+ Interlude: Const :: a -> Const a
+ Interlude: Control :: GeneralCategory
+ Interlude: CurrencySymbol :: GeneralCategory
+ Interlude: D# :: Double# -> Double
+ Interlude: DashPunctuation :: GeneralCategory
+ Interlude: Deadlock :: Deadlock
+ Interlude: DecimalNumber :: GeneralCategory
+ Interlude: Denormal :: ArithException
+ Interlude: DivideByZero :: ArithException
+ Interlude: Down :: a -> Down a
+ Interlude: Dual :: a -> Dual a
+ Interlude: EQ :: Ordering
+ Interlude: EnclosingMark :: GeneralCategory
+ Interlude: Endo :: (a -> a) -> Endo a
+ Interlude: ErrorCallWithLocation :: String -> String -> ErrorCall
+ Interlude: ExceptT :: m (Either e a) -> ExceptT e a
+ Interlude: ExitFailure :: Int -> ExitCode
+ Interlude: ExitSuccess :: ExitCode
+ Interlude: F# :: Float# -> Float
+ Interlude: False :: Bool
+ Interlude: FatalError :: Text -> FatalError
+ Interlude: FinalQuote :: GeneralCategory
+ Interlude: First :: Maybe a -> First a
+ Interlude: Format :: GeneralCategory
+ Interlude: GT :: Ordering
+ Interlude: HeapOverflow :: AsyncException
+ Interlude: Identity :: a -> Identity a
+ Interlude: IndexOutOfBounds :: String -> ArrayException
+ Interlude: Infix :: Associativity -> Int -> Fixity
+ Interlude: InfixI :: Associativity -> Nat -> FixityI
+ Interlude: InitialQuote :: GeneralCategory
+ Interlude: Just :: a -> Maybe a
+ Interlude: K1 :: c -> K1 i c
+ Interlude: L1 :: f p -> (:+:)
+ Interlude: LT :: Ordering
+ Interlude: Last :: Maybe a -> Last a
+ Interlude: Left :: a -> Either a b
+ Interlude: LeftAssociative :: Associativity
+ Interlude: Lenient :: Leniency
+ Interlude: LetterNumber :: GeneralCategory
+ Interlude: LineSeparator :: GeneralCategory
+ Interlude: Location :: String -> String -> Maybe SrcLoc -> Location
+ Interlude: LossOfPrecision :: ArithException
+ Interlude: LowercaseLetter :: GeneralCategory
+ Interlude: M1 :: f p -> M1 i
+ Interlude: MaskedInterruptible :: MaskingState
+ Interlude: MaskedUninterruptible :: MaskingState
+ Interlude: MathSymbol :: GeneralCategory
+ Interlude: MetaCons :: Symbol -> FixityI -> Bool -> Meta
+ Interlude: MetaData :: Symbol -> Symbol -> Symbol -> Bool -> Meta
+ Interlude: MetaSel :: Maybe Symbol -> SourceUnpackedness -> SourceStrictness -> DecidedStrictness -> Meta
+ Interlude: MethodName :: Name -> Name -> DefName
+ Interlude: ModifierLetter :: GeneralCategory
+ Interlude: ModifierSymbol :: GeneralCategory
+ Interlude: NestedAtomically :: NestedAtomically
+ Interlude: NoMethodError :: String -> NoMethodError
+ Interlude: NonSpacingMark :: GeneralCategory
+ Interlude: NonTermination :: NonTermination
+ Interlude: NotAssigned :: GeneralCategory
+ Interlude: NotAssociative :: Associativity
+ Interlude: Nothing :: Maybe a
+ Interlude: ObjectWithSingleField :: SumEncoding
+ Interlude: OpenPunctuation :: GeneralCategory
+ Interlude: Option :: Maybe a -> Option a
+ Interlude: OtherLetter :: GeneralCategory
+ Interlude: OtherNumber :: GeneralCategory
+ Interlude: OtherPunctuation :: GeneralCategory
+ Interlude: OtherSymbol :: GeneralCategory
+ Interlude: Overflow :: ArithException
+ Interlude: ParagraphSeparator :: GeneralCategory
+ Interlude: PatternMatchFail :: String -> PatternMatchFail
+ Interlude: Peat :: (forall (f :: Type -> Type). Applicative f => (a -> f (Maybe b)) -> f t) -> Peat a b t
+ Interlude: Prefix :: Fixity
+ Interlude: PrefixI :: FixityI
+ Interlude: PrivateUse :: GeneralCategory
+ Interlude: Product :: a -> Product a
+ Interlude: Proxy :: Proxy
+ Interlude: R1 :: g p -> (:+:)
+ Interlude: RatioZeroDenominator :: ArithException
+ Interlude: ReadMode :: IOMode
+ Interlude: ReadWriteMode :: IOMode
+ Interlude: ReaderT :: (r -> m a) -> ReaderT r
+ Interlude: RecConError :: String -> RecConError
+ Interlude: RecSelError :: String -> RecSelError
+ Interlude: RecUpdError :: String -> RecUpdError
+ Interlude: Right :: b -> Either a b
+ Interlude: RightAssociative :: Associativity
+ Interlude: Space :: GeneralCategory
+ Interlude: SpacingCombiningMark :: GeneralCategory
+ Interlude: SrcLoc :: String -> Int -> Int -> SrcLoc
+ Interlude: StackOverflow :: AsyncException
+ Interlude: StateT :: (s -> m (a, s)) -> StateT s a
+ Interlude: Strict :: Leniency
+ Interlude: Sum :: a -> Sum a
+ Interlude: Surrogate :: GeneralCategory
+ Interlude: TaggedObject :: String -> String -> SumEncoding
+ Interlude: ThreadKilled :: AsyncException
+ Interlude: TitlecaseLetter :: GeneralCategory
+ Interlude: TopName :: Name -> DefName
+ Interlude: True :: Bool
+ Interlude: TwoElemArray :: SumEncoding
+ Interlude: TypeError :: String -> TypeError
+ Interlude: U1 :: U1
+ Interlude: UndefinedElement :: String -> ArrayException
+ Interlude: Underflow :: ArithException
+ Interlude: Unmasked :: MaskingState
+ Interlude: UntaggedValue :: SumEncoding
+ Interlude: UppercaseLetter :: GeneralCategory
+ Interlude: UserInterrupt :: AsyncException
+ Interlude: WriteMode :: IOMode
+ Interlude: ZipList :: [a] -> ZipList a
+ Interlude: [Coercion] :: forall k (a :: k) (b :: k). Coercible a b => Coercion a b
+ Interlude: [Handler] :: forall (m :: Type -> Type) a e. Exception e => (e -> m a) -> Handler m a
+ Interlude: [Refl] :: forall k (a :: k) (b :: k). () => a :~: a
+ Interlude: [SomeAsyncException] :: forall e. Exception e => e -> SomeAsyncException
+ Interlude: [SomeException] :: forall e. Exception e => e -> SomeException
+ Interlude: [SomeNat] :: forall (n :: Nat). KnownNat n => Proxy n -> SomeNat
+ Interlude: [SomeSymbol] :: forall (n :: Symbol). KnownSymbol n => Proxy n -> SomeSymbol
+ Interlude: [appEndo] :: Endo a -> a -> a
+ Interlude: [contentsFieldName] :: SumEncoding -> String
+ Interlude: [fatalErrorMessage] :: FatalError -> Text
+ Interlude: [functionName] :: Location -> String
+ Interlude: [getAll] :: All -> Bool
+ Interlude: [getAlt] :: Alt -> f a
+ Interlude: [getAny] :: Any -> Bool
+ Interlude: [getAp] :: Ap -> f a
+ Interlude: [getConst] :: Const a -> a
+ Interlude: [getDual] :: Dual a -> a
+ Interlude: [getFirst] :: First a -> Maybe a
+ Interlude: [getLast] :: Last a -> Maybe a
+ Interlude: [getOption] :: Option a -> Maybe a
+ Interlude: [getProduct] :: Product a -> a
+ Interlude: [getSum] :: Sum a -> a
+ Interlude: [getZipList] :: ZipList a -> [a]
+ Interlude: [objectName] :: Location -> String
+ Interlude: [runConcurrently] :: Concurrently a -> IO a
+ Interlude: [runIdentity] :: Identity a -> a
+ Interlude: [runPeat] :: Peat a b t -> forall (f :: Type -> Type). Applicative f => (a -> f (Maybe b)) -> f t
+ Interlude: [runReaderT] :: ReaderT r -> r -> m a
+ Interlude: [runStateT] :: StateT s a -> s -> m (a, s)
+ Interlude: [sourceColumn] :: SrcLoc -> Int
+ Interlude: [sourceFile] :: SrcLoc -> String
+ Interlude: [sourceLine] :: SrcLoc -> Int
+ Interlude: [srcLoc] :: Location -> Maybe SrcLoc
+ Interlude: [tagFieldName] :: SumEncoding -> String
+ Interlude: [unComp1] :: (:.:) -> f (g p)
+ Interlude: [unK1] :: K1 i c -> c
+ Interlude: [unM1] :: M1 i -> f p
+ Interlude: abbreviatedFields :: LensRules
+ Interlude: abbreviatedNamer :: FieldNamer
+ Interlude: abs :: Num a => a -> a
+ Interlude: absurd :: () => Void -> a
+ Interlude: acos :: Floating a => a -> a
+ Interlude: acosh :: Floating a => a -> a
+ Interlude: addMVarFinalizer :: () => MVar a -> IO () -> IO ()
+ Interlude: all :: Foldable t => (a -> Bool) -> t a -> Bool
+ Interlude: allowInterrupt :: IO ()
+ Interlude: and :: Foldable t => t Bool -> Bool
+ Interlude: any :: Foldable t => (a -> Bool) -> t a -> Bool
+ Interlude: ap :: Monad m => m (a -> b) -> m a -> m b
+ Interlude: appendFile :: FilePath -> Text -> IO ()
+ Interlude: applyN :: () => Int -> (a -> a) -> a -> a
+ Interlude: asTypeOf :: () => a -> a -> a
+ Interlude: asin :: Floating a => a -> a
+ Interlude: asinh :: Floating a => a -> a
+ Interlude: ask :: MonadReader r m => m r
+ Interlude: asks :: MonadReader r m => (r -> a) -> m a
+ Interlude: asum :: (Foldable t, Alternative f) => t (f a) -> f a
+ Interlude: async :: () => IO a -> IO (Async a)
+ Interlude: asyncBound :: () => IO a -> IO (Async a)
+ Interlude: asyncExceptionFromException :: Exception e => SomeException -> Maybe e
+ Interlude: asyncExceptionToException :: Exception e => e -> SomeException
+ Interlude: asyncOn :: () => Int -> IO a -> IO (Async a)
+ Interlude: atDef :: () => a -> [a] -> Int -> a
+ Interlude: atMay :: () => [a] -> Int -> Maybe a
+ Interlude: atan :: Floating a => a -> a
+ Interlude: atan2 :: RealFloat a => a -> a -> a
+ Interlude: atanh :: Floating a => a -> a
+ Interlude: atomically :: () => STM a -> IO a
+ Interlude: bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
+ Interlude: bit :: Bits a => Int -> a
+ Interlude: bitDefault :: (Bits a, Num a) => Int -> a
+ Interlude: bitSize :: Bits a => a -> Int
+ Interlude: bitSizeMaybe :: Bits a => a -> Maybe Int
+ Interlude: bool :: () => a -> a -> Bool -> a
+ Interlude: boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
+ Interlude: boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
+ Interlude: bracket :: () => IO a -> (a -> IO b) -> (a -> IO c) -> IO c
+ Interlude: bracketOnError :: () => IO a -> (a -> IO b) -> (a -> IO c) -> IO c
+ Interlude: bracket_ :: () => IO a -> IO b -> IO c -> IO c
+ Interlude: break :: () => (a -> Bool) -> [a] -> ([a], [a])
+ Interlude: byteSwap16 :: Word16 -> Word16
+ Interlude: byteSwap32 :: Word32 -> Word32
+ Interlude: byteSwap64 :: Word64 -> Word64
+ Interlude: callStack :: HasCallStack -> CallStack
+ Interlude: camelCaseFields :: LensRules
+ Interlude: camelCaseNamer :: FieldNamer
+ Interlude: cancel :: () => Async a -> IO ()
+ Interlude: cancelWith :: Exception e => Async a -> e -> IO ()
+ Interlude: cast :: (Typeable a, Typeable b) => a -> Maybe b
+ Interlude: castWith :: () => (a :~: b) -> a -> b
+ Interlude: catMaybes :: Filterable f => f (Maybe a) -> f a
+ Interlude: catMaybesOf :: () => FilterLike Identity s t (Maybe a) a -> s -> t
+ Interlude: catch :: (MonadCatch m, Exception e) => m a -> (e -> m a) -> m a
+ Interlude: catchE :: Monad m => ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a
+ Interlude: catchError :: MonadError e m => m a -> (e -> m a) -> m a
+ Interlude: catchIf :: (MonadCatch m, Exception e) => (e -> Bool) -> m a -> (e -> m a) -> m a
+ Interlude: catchJust :: Exception e => (e -> Maybe b) -> IO a -> (b -> IO a) -> IO a
+ Interlude: catchSTM :: Exception e => STM a -> (e -> STM a) -> STM a
+ Interlude: catches :: (Foldable f, MonadCatch m) => m a -> f (Handler m a) -> m a
+ Interlude: ceiling :: (RealFrac a, Integral b) => a -> b
+ Interlude: check :: Bool -> STM ()
+ Interlude: chr :: Int -> Char
+ Interlude: cis :: Floating a => a -> Complex a
+ Interlude: class Applicative f => Alternative (f :: Type -> Type)
+ Interlude: class Functor f => Applicative (f :: Type -> Type)
+ Interlude: class Bifunctor (p :: Type -> Type -> Type)
+ Interlude: class Eq a => Bits a
+ Interlude: class Bounded a
+ Interlude: class a ~R# b => Coercible (a :: k0) (b :: k0)
+ Interlude: class Constructor (c :: k)
+ Interlude: class Datatype (d :: k)
+ Interlude: class Enum a
+ Interlude: class Eq a
+ Interlude: class (Typeable e, Show e) => Exception e
+ Interlude: class Functor f => Filterable (f :: Type -> Type)
+ Interlude: class Bits b => FiniteBits b
+ Interlude: class Fractional a => Floating a
+ Interlude: class Foldable (t :: Type -> Type)
+ Interlude: class Num a => Fractional a
+ Interlude: class FromJSON a
+ Interlude: class Functor (f :: Type -> Type)
+ Interlude: class Generic a where {
+ Interlude: class Generic1 (f :: k -> Type)
+ Interlude: class HasField (x :: k) r a | x r -> a
+ Interlude: class Hashable a
+ Interlude: class (Real a, Enum a) => Integral a
+ Interlude: class IsLabel (x :: Symbol) a
+ Interlude: class IsString a
+ Interlude: class KnownNat (n :: Nat)
+ Interlude: class KnownSymbol (n :: Symbol)
+ Interlude: class Applicative m => Monad (m :: Type -> Type)
+ Interlude: class MonadBase b m => MonadBaseControl (b :: Type -> Type) (m :: Type -> Type) | m -> b
+ Interlude: class MonadThrow m => MonadCatch (m :: Type -> Type)
+ Interlude: class Monad m => MonadError e (m :: Type -> Type) | m -> e
+ Interlude: class Monad m => MonadFix (m :: Type -> Type)
+ Interlude: class Monad m => MonadIO (m :: Type -> Type)
+ Interlude: class MonadRandom m => MonadInterleave (m :: Type -> Type)
+ Interlude: class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
+ Interlude: class Monad m => MonadRandom (m :: Type -> Type)
+ Interlude: class Monad m => MonadReader r (m :: Type -> Type) | m -> r
+ Interlude: class Monad m => MonadSplit g (m :: Type -> Type) | m -> g
+ Interlude: class Monad m => MonadState s (m :: Type -> Type) | m -> s
+ Interlude: class Monad m => MonadThrow (m :: Type -> Type)
+ Interlude: class MonadTrans (t :: Type -> Type -> Type -> Type)
+ Interlude: class MonadTrans t => MonadTransControl (t :: Type -> Type -> Type -> Type)
+ Interlude: class Semigroup a => Monoid a
+ Interlude: class NFData a
+ Interlude: class Num a
+ Interlude: class Eq a => Ord a
+ Interlude: class Print a
+ Interlude: class Random a
+ Interlude: class RandomGen g
+ Interlude: class Read a
+ Interlude: class (Num a, Ord a) => Real a
+ Interlude: class (RealFrac a, Floating a) => RealFloat a
+ Interlude: class (Real a, Fractional a) => RealFrac a
+ Interlude: class Selector (s :: k)
+ Interlude: class Semigroup a
+ Interlude: class Monoid m => Semiring m
+ Interlude: class Show a
+ Interlude: class Storable a
+ Interlude: class StringConv a b
+ Interlude: class ToJSON a
+ Interlude: class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
+ Interlude: class Typeable (a :: k)
+ Interlude: class (Traversable t, Filterable t) => Witherable (t :: Type -> Type)
+ Interlude: classUnderscoreNoPrefixFields :: LensRules
+ Interlude: classUnderscoreNoPrefixNamer :: FieldNamer
+ Interlude: classyRules :: LensRules
+ Interlude: classyRules_ :: LensRules
+ Interlude: clearBit :: Bits a => a -> Int -> a
+ Interlude: cloneFilter :: () => FilterLike (Peat a b) s t a b -> Filter s t a b
+ Interlude: coerce :: Coercible a b => a -> b
+ Interlude: coerceWith :: () => Coercion a b -> a -> b
+ Interlude: compare :: Ord a => a -> a -> Ordering
+ Interlude: comparing :: Ord a => (b -> a) -> b -> b -> Ordering
+ Interlude: complement :: Bits a => a -> a
+ Interlude: complementBit :: Bits a => a -> Int -> a
+ Interlude: conFixity :: Constructor c => t c f a -> Fixity
+ Interlude: conIsRecord :: Constructor c => t c f a -> Bool
+ Interlude: conName :: Constructor c => t c f a -> [Char]
+ Interlude: concat :: Foldable t => t [a] -> [a]
+ Interlude: concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
+ Interlude: concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]
+ Interlude: concurrently :: () => IO a -> IO b -> IO (a, b)
+ Interlude: conjugate :: Num a => Complex a -> Complex a
+ Interlude: const :: () => a -> b -> a
+ Interlude: cos :: Floating a => a -> a
+ Interlude: cosh :: Floating a => a -> a
+ Interlude: countLeadingZeros :: FiniteBits b => b -> Int
+ Interlude: countTrailingZeros :: FiniteBits b => b -> Int
+ Interlude: createClass :: Lens' LensRules Bool
+ Interlude: currentCallStack :: IO [String]
+ Interlude: curry :: () => ((a, b) -> c) -> a -> b -> c
+ Interlude: cycle :: () => [a] -> [a]
+ Interlude: cycle1 :: Semigroup m => m -> m
+ Interlude: data AllocationLimitExceeded
+ Interlude: data ArithException
+ Interlude: data ArrayException
+ Interlude: data Associativity
+ Interlude: data Async a
+ Interlude: data AsyncException
+ Interlude: data BlockedIndefinitelyOnMVar
+ Interlude: data BlockedIndefinitelyOnSTM
+ Interlude: data Bool
+ Interlude: data ByteString
+ Interlude: data CallStack
+ Interlude: data Chan a
+ Interlude: data Char
+ Interlude: data Complex a
+ Interlude: data Constraint
+ Interlude: data Deadlock
+ Interlude: data DefName
+ Interlude: data Double
+ Interlude: data Either a b
+ Interlude: data ErrorCall
+ Interlude: data ExitCode
+ Interlude: data FatalError
+ Interlude: data Fixity
+ Interlude: data FixityI
+ Interlude: data Float
+ Interlude: data FunPtr a
+ Interlude: data GeneralCategory
+ Interlude: data Handle
+ Interlude: data Handler (m :: Type -> Type) a
+ Interlude: data IO a
+ Interlude: data IOException
+ Interlude: data IOMode
+ Interlude: data Int
+ Interlude: data Int16
+ Interlude: data Int32
+ Interlude: data Int64
+ Interlude: data Int8
+ Interlude: data IntMap a
+ Interlude: data IntPtr
+ Interlude: data IntSet
+ Interlude: data Integer
+ Interlude: data Leniency
+ Interlude: data LensRules
+ Interlude: data Location
+ Interlude: data MVar a
+ Interlude: data Map k a
+ Interlude: data MaskingState
+ Interlude: data Maybe a
+ Interlude: data Meta
+ Interlude: data Nat
+ Interlude: data NestedAtomically
+ Interlude: data NonEmpty a
+ Interlude: data NonTermination
+ Interlude: data Options
+ Interlude: data Ordering
+ Interlude: data Ptr a
+ Interlude: data QSem
+ Interlude: data QSemN
+ Interlude: data RandT g (m :: Type -> Type) a
+ Interlude: data Ratio a
+ Interlude: data ST s a
+ Interlude: data STM a
+ Interlude: data Seq a
+ Interlude: data Set a
+ Interlude: data SomeAsyncException
+ Interlude: data SomeException
+ Interlude: data SomeNat
+ Interlude: data SomeSymbol
+ Interlude: data SrcLoc
+ Interlude: data StablePtr a
+ Interlude: data StaticPtr a
+ Interlude: data StdGen
+ Interlude: data SumEncoding
+ Interlude: data Symbol
+ Interlude: data Text
+ Interlude: data ThreadId
+ Interlude: data UnicodeException
+ Interlude: data Void
+ Interlude: data Word
+ Interlude: data Word16
+ Interlude: data Word32
+ Interlude: data Word64
+ Interlude: data Word8
+ Interlude: data WordPtr
+ Interlude: data WrappedMonoid m
+ Interlude: data family URec a (p :: k) :: Type
+ Interlude: data (:~:) (a :: k) (b :: k) :: forall k. () => k -> k -> Type
+ Interlude: datatypeName :: Datatype d => t d f a -> [Char]
+ Interlude: declareClassy :: DecsQ -> DecsQ
+ Interlude: declareClassyFor :: [(String, (String, String))] -> [(String, String)] -> DecsQ -> DecsQ
+ Interlude: declareFields :: DecsQ -> DecsQ
+ Interlude: declareLenses :: DecsQ -> DecsQ
+ Interlude: declareLensesFor :: [(String, String)] -> DecsQ -> DecsQ
+ Interlude: declareLensesWith :: LensRules -> DecsQ -> DecsQ
+ Interlude: declarePrisms :: DecsQ -> DecsQ
+ Interlude: declareWrapped :: DecsQ -> DecsQ
+ Interlude: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ Interlude: decodeUtf8 :: ByteString -> Text
+ Interlude: decodeUtf8' :: ByteString -> Either UnicodeException Text
+ Interlude: decodeUtf8With :: OnDecodeError -> ByteString -> Text
+ Interlude: deepseq :: NFData a => a -> b -> b
+ Interlude: defaultFieldRules :: LensRules
+ Interlude: defaultOptions :: Options
+ Interlude: defaultTaggedObject :: SumEncoding
+ Interlude: denominator :: () => Ratio a -> a
+ Interlude: deriveFromJSON :: Options -> Name -> Q [Dec]
+ Interlude: deriveFromJSON1 :: Options -> Name -> Q [Dec]
+ Interlude: deriveFromJSON2 :: Options -> Name -> Q [Dec]
+ Interlude: deriveJSON :: Options -> Name -> Q [Dec]
+ Interlude: deriveJSON1 :: Options -> Name -> Q [Dec]
+ Interlude: deriveJSON2 :: Options -> Name -> Q [Dec]
+ Interlude: deriveToJSON :: Options -> Name -> Q [Dec]
+ Interlude: deriveToJSON1 :: Options -> Name -> Q [Dec]
+ Interlude: deriveToJSON2 :: Options -> Name -> Q [Dec]
+ Interlude: die :: () => Text -> IO a
+ Interlude: diff :: Semigroup m => m -> Endo m
+ Interlude: digitToInt :: Char -> Int
+ Interlude: displayException :: Exception e => e -> String
+ Interlude: div :: Integral a => a -> a -> a
+ Interlude: divMod :: Integral a => a -> a -> (a, a)
+ Interlude: divZeroError :: () => a
+ Interlude: drop :: () => Int -> [a] -> [a]
+ Interlude: dropWhile :: () => (a -> Bool) -> [a] -> [a]
+ Interlude: dupChan :: () => Chan a -> IO (Chan a)
+ Interlude: either :: () => (a -> c) -> (b -> c) -> Either a b -> c
+ Interlude: eitherA :: Alternative f => f a -> f b -> f (Either a b)
+ Interlude: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Interlude: empty :: Alternative f => f a
+ Interlude: encodeFloat :: RealFloat a => Integer -> Int -> a
+ Interlude: encodeUtf8 :: Text -> ByteString
+ Interlude: enumFrom :: Enum a => a -> [a]
+ Interlude: enumFromThen :: Enum a => a -> a -> [a]
+ Interlude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ Interlude: enumFromTo :: Enum a => a -> a -> [a]
+ Interlude: eqT :: (Typeable a, Typeable b) => Maybe (a :~: b)
+ Interlude: error :: HasCallStack => [Char] -> a
+ Interlude: evalRand :: () => Rand g a -> g -> a
+ Interlude: evalRandIO :: () => Rand StdGen a -> IO a
+ Interlude: evalRandT :: Monad m => RandT g m a -> g -> m a
+ Interlude: evalRandTIO :: MonadIO m => RandT StdGen m a -> m a
+ Interlude: evalState :: () => State s a -> s -> a
+ Interlude: evalStateT :: Monad m => StateT s m a -> s -> m a
+ Interlude: evaluate :: () => a -> IO a
+ Interlude: even :: Integral a => a -> Bool
+ Interlude: execRand :: () => Rand g a -> g -> g
+ Interlude: execRandT :: Monad m => RandT g m a -> g -> m g
+ Interlude: execState :: () => State s a -> s -> s
+ Interlude: execStateT :: Monad m => StateT s m a -> s -> m s
+ Interlude: exitFailure :: () => IO a
+ Interlude: exitSuccess :: () => IO a
+ Interlude: exitWith :: () => ExitCode -> IO a
+ Interlude: exp :: Floating a => a -> a
+ Interlude: expm1 :: Floating a => a -> a
+ Interlude: exponent :: RealFloat a => a -> Int
+ Interlude: fail :: Monad m => String -> m a
+ Interlude: filter :: Filterable f => (a -> Bool) -> f a -> f a
+ Interlude: filterA :: (Witherable t, Applicative f) => (a -> f Bool) -> t a -> f (t a)
+ Interlude: filterAOf :: Functor f => FilterLike' f s a -> (a -> f Bool) -> s -> f s
+ Interlude: filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
+ Interlude: filterOf :: () => FilterLike' Identity s a -> (a -> Bool) -> s -> s
+ Interlude: finally :: () => IO a -> IO b -> IO a
+ Interlude: find :: Foldable t => (a -> Bool) -> t a -> Maybe a
+ Interlude: finiteBitSize :: FiniteBits b => b -> Int
+ Interlude: first :: Bifunctor p => (a -> b) -> p a c -> p b c
+ Interlude: fix :: () => (a -> a) -> a
+ Interlude: fixST :: () => (a -> ST s a) -> ST s a
+ Interlude: flip :: () => (a -> b -> c) -> b -> a -> c
+ Interlude: floatDigits :: RealFloat a => a -> Int
+ Interlude: floatRadix :: RealFloat a => a -> Integer
+ Interlude: floatRange :: RealFloat a => a -> (Int, Int)
+ Interlude: floor :: (RealFrac a, Integral b) => a -> b
+ Interlude: fmap :: Functor f => (a -> b) -> f a -> f b
+ Interlude: fmapDefault :: Traversable t => (a -> b) -> t a -> t b
+ Interlude: fold :: (Foldable t, Monoid m) => t m -> m
+ Interlude: foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
+ Interlude: foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
+ Interlude: foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
+ Interlude: foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m
+ Interlude: foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
+ Interlude: foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
+ Interlude: foldl1May :: () => (a -> a -> a) -> [a] -> Maybe a
+ Interlude: foldl1May' :: () => (a -> a -> a) -> [a] -> Maybe a
+ Interlude: foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
+ Interlude: foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
+ Interlude: foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b
+ Interlude: foldr1May :: () => (a -> a -> a) -> [a] -> Maybe a
+ Interlude: foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
+ Interlude: for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
+ Interlude: forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
+ Interlude: forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
+ Interlude: forMaybe :: (Witherable t, Applicative f) => t a -> (a -> f (Maybe b)) -> f (t b)
+ Interlude: forMaybeOf :: () => FilterLike f s t a b -> s -> (a -> f (Maybe b)) -> f t
+ Interlude: for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
+ Interlude: force :: NFData a => a -> a
+ Interlude: foreach :: Functor f => f a -> (a -> b) -> f b
+ Interlude: forever :: Applicative f => f a -> f b
+ Interlude: forkFinally :: () => IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
+ Interlude: forkIO :: IO () -> IO ThreadId
+ Interlude: forkIOWithUnmask :: ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
+ Interlude: forkOS :: IO () -> IO ThreadId
+ Interlude: forkOSWithUnmask :: ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
+ Interlude: forkOn :: Int -> IO () -> IO ThreadId
+ Interlude: forkOnWithUnmask :: Int -> ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
+ Interlude: from :: Generic a => a -> Rep a x
+ Interlude: fromEnum :: Enum a => a -> Int
+ Interlude: fromException :: Exception e => SomeException -> Maybe e
+ Interlude: fromInteger :: Num a => Integer -> a
+ Interlude: fromIntegral :: (Integral a, Num b) => a -> b
+ Interlude: fromLabel :: IsLabel x a => a
+ Interlude: fromLeft :: () => a -> Either a b -> a
+ Interlude: fromList :: MonadRandom m => [(a, Rational)] -> m a
+ Interlude: fromListMay :: MonadRandom m => [(a, Rational)] -> m (Maybe a)
+ Interlude: fromMaybe :: () => a -> Maybe a -> a
+ Interlude: fromRational :: Fractional a => Rational -> a
+ Interlude: fromRight :: () => b -> Either a b -> b
+ Interlude: fromStrict :: Text -> Text
+ Interlude: fst :: () => (a, b) -> a
+ Interlude: gcastWith :: () => (a :~: b) -> ((a ~ b) -> r) -> r
+ Interlude: gcd :: Integral a => a -> a -> a
+ Interlude: gcdInt' :: Int -> Int -> Int
+ Interlude: gcdWord' :: Word -> Word -> Word
+ Interlude: genRange :: RandomGen g => g -> (Int, Int)
+ Interlude: generalCategory :: Char -> GeneralCategory
+ Interlude: generateLazyPatterns :: Lens' LensRules Bool
+ Interlude: generateSignatures :: Lens' LensRules Bool
+ Interlude: generateUpdateableOptics :: Lens' LensRules Bool
+ Interlude: genericDrop :: Integral i => i -> [a] -> [a]
+ Interlude: genericLength :: Num i => [a] -> i
+ Interlude: genericReplicate :: Integral i => i -> a -> [a]
+ Interlude: genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
+ Interlude: genericTake :: Integral i => i -> [a] -> [a]
+ Interlude: get :: MonadState s m => m s
+ Interlude: getArgs :: IO [String]
+ Interlude: getCallStack :: CallStack -> [([Char], SrcLoc)]
+ Interlude: getChanContents :: () => Chan a -> IO [a]
+ Interlude: getContents :: IO Text
+ Interlude: getField :: HasField x r a => r -> a
+ Interlude: getLine :: IO Text
+ Interlude: getMaskingState :: IO MaskingState
+ Interlude: getNumCapabilities :: IO Int
+ Interlude: getRandom :: (MonadRandom m, Random a) => m a
+ Interlude: getRandomR :: (MonadRandom m, Random a) => (a, a) -> m a
+ Interlude: getRandomRs :: (MonadRandom m, Random a) => (a, a) -> m [a]
+ Interlude: getRandoms :: (MonadRandom m, Random a) => m [a]
+ Interlude: getSplit :: MonadSplit g m => m g
+ Interlude: getStackTrace :: IO (Maybe [Location])
+ Interlude: getStdGen :: IO StdGen
+ Interlude: getStdRandom :: () => (StdGen -> (a, StdGen)) -> IO a
+ Interlude: gets :: MonadState s m => (s -> a) -> m a
+ Interlude: group :: Eq a => [a] -> [[a]]
+ Interlude: groupBy :: () => (a -> a -> Bool) -> [a] -> [[a]]
+ Interlude: guard :: Alternative f => Bool -> f ()
+ Interlude: guardM :: MonadPlus m => m Bool -> m ()
+ Interlude: guarded :: Alternative f => (a -> Bool) -> a -> f a
+ Interlude: guardedA :: (Functor f, Alternative t) => (a -> f Bool) -> a -> f (t a)
+ Interlude: hPutStr :: (Print a, MonadIO m) => Handle -> a -> m ()
+ Interlude: hPutStrLn :: (Print a, MonadIO m) => Handle -> a -> m ()
+ Interlude: handle :: (MonadCatch m, Exception e) => (e -> m a) -> m a -> m a
+ Interlude: handleIf :: (MonadCatch m, Exception e) => (e -> Bool) -> (e -> m a) -> m a -> m a
+ Interlude: handleJust :: Exception e => (e -> Maybe b) -> (b -> IO a) -> IO a -> IO a
+ Interlude: hash :: Hashable a => a -> Int
+ Interlude: hashNub :: (Witherable t, Eq a, Hashable a) => t a -> t a
+ Interlude: hashNubOf :: (Eq a, Hashable a) => FilterLike' (State (HashSet a)) s a -> s -> s
+ Interlude: hashUsing :: Hashable b => (a -> b) -> Int -> a -> Int
+ Interlude: hashWithSalt :: Hashable a => Int -> a -> Int
+ Interlude: head :: Foldable f => f a -> Maybe a
+ Interlude: headDef :: () => a -> [a] -> a
+ Interlude: headMay :: () => [a] -> Maybe a
+ Interlude: hush :: Alternative m => Either e a -> m a
+ Interlude: identity :: () => a -> a
+ Interlude: ifM :: Monad m => m Bool -> m a -> m a -> m a
+ Interlude: ignore :: () => OnError a b
+ Interlude: imagPart :: () => Complex a -> a
+ Interlude: infinity :: Rational
+ Interlude: infix 4 .=
+ Interlude: infix 6 :+
+ Interlude: infixl 0 `on`
+ Interlude: infixl 1 &~
+ Interlude: infixl 3 <|>
+ Interlude: infixl 4 <<$>>
+ Interlude: infixl 5 |>
+ Interlude: infixl 6 `xor`
+ Interlude: infixl 7 %
+ Interlude: infixl 8 ^#
+ Interlude: infixr 0 $!
+ Interlude: infixr 1 <=<
+ Interlude: infixr 2 ||^
+ Interlude: infixr 3 &&^
+ Interlude: infixr 4 %~
+ Interlude: infixr 5 <|
+ Interlude: infixr 6 :*:
+ Interlude: infixr 7 :.:
+ Interlude: infixr 8 #
+ Interlude: infixr 9 <.
+ Interlude: initDef :: () => [a] -> [a] -> [a]
+ Interlude: initMay :: () => [a] -> Maybe [a]
+ Interlude: initSafe :: () => [a] -> [a]
+ Interlude: inits :: () => [a] -> [[a]]
+ Interlude: intToDigit :: Int -> Char
+ Interlude: integralEnumFrom :: (Integral a, Bounded a) => a -> [a]
+ Interlude: integralEnumFromThen :: (Integral a, Bounded a) => a -> a -> [a]
+ Interlude: integralEnumFromThenTo :: Integral a => a -> a -> a -> [a]
+ Interlude: integralEnumFromTo :: Integral a => a -> a -> [a]
+ Interlude: interact :: (Text -> Text) -> IO ()
+ Interlude: intercalate :: () => [a] -> [[a]] -> [a]
+ Interlude: interleave :: MonadInterleave m => m a -> m a
+ Interlude: interruptible :: () => IO a -> IO a
+ Interlude: intersperse :: () => a -> [a] -> [a]
+ Interlude: ioError :: () => IOError -> IO a
+ Interlude: isAlpha :: Char -> Bool
+ Interlude: isAlphaNum :: Char -> Bool
+ Interlude: isAscii :: Char -> Bool
+ Interlude: isAsciiLower :: Char -> Bool
+ Interlude: isAsciiUpper :: Char -> Bool
+ Interlude: isControl :: Char -> Bool
+ Interlude: isCurrentThreadBound :: IO Bool
+ Interlude: isDenormalized :: RealFloat a => a -> Bool
+ Interlude: isDigit :: Char -> Bool
+ Interlude: isEmptyMVar :: () => MVar a -> IO Bool
+ Interlude: isHexDigit :: Char -> Bool
+ Interlude: isIEEE :: RealFloat a => a -> Bool
+ Interlude: isInfinite :: RealFloat a => a -> Bool
+ Interlude: isJust :: () => Maybe a -> Bool
+ Interlude: isLatin1 :: Char -> Bool
+ Interlude: isLeft :: () => Either a b -> Bool
+ Interlude: isLetter :: Char -> Bool
+ Interlude: isLower :: Char -> Bool
+ Interlude: isMark :: Char -> Bool
+ Interlude: isNaN :: RealFloat a => a -> Bool
+ Interlude: isNegativeZero :: RealFloat a => a -> Bool
+ Interlude: isNewtype :: Datatype d => t d f a -> Bool
+ Interlude: isNothing :: () => Maybe a -> Bool
+ Interlude: isNumber :: Char -> Bool
+ Interlude: isOctDigit :: Char -> Bool
+ Interlude: isPrefixOf :: Eq a => [a] -> [a] -> Bool
+ Interlude: isPrint :: Char -> Bool
+ Interlude: isPunctuation :: Char -> Bool
+ Interlude: isRight :: () => Either a b -> Bool
+ Interlude: isSeparator :: Char -> Bool
+ Interlude: isSigned :: Bits a => a -> Bool
+ Interlude: isSpace :: Char -> Bool
+ Interlude: isSymbol :: Char -> Bool
+ Interlude: isUpper :: Char -> Bool
+ Interlude: iterate :: () => (a -> a) -> a -> [a]
+ Interlude: join :: Monad m => m (m a) -> m a
+ Interlude: killThread :: ThreadId -> IO ()
+ Interlude: lastDef :: () => a -> [a] -> a
+ Interlude: lastMay :: () => [a] -> Maybe a
+ Interlude: lcm :: Integral a => a -> a -> a
+ Interlude: leftToMaybe :: () => Either l r -> Maybe l
+ Interlude: lefts :: () => [Either a b] -> [a]
+ Interlude: length :: Foldable t => t a -> Int
+ Interlude: lenientDecode :: OnDecodeError
+ Interlude: lensClass :: Lens' LensRules ClassyNamer
+ Interlude: lensField :: Lens' LensRules FieldNamer
+ Interlude: lensRules :: LensRules
+ Interlude: lensRulesFor :: [(String, String)] -> LensRules
+ Interlude: lexLitChar :: ReadS String
+ Interlude: lift :: (MonadTrans t, Monad m) => m a -> t m a
+ Interlude: liftA :: Applicative f => (a -> b) -> f a -> f b
+ Interlude: liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
+ Interlude: liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
+ Interlude: liftAA2 :: (Applicative f, Applicative g) => (a -> b -> c) -> f (g a) -> f (g b) -> f (g c)
+ Interlude: liftIO :: MonadIO m => IO a -> m a
+ Interlude: liftIO1 :: MonadIO m => (a -> IO b) -> a -> m b
+ Interlude: liftIO2 :: MonadIO m => (a -> b -> IO c) -> a -> b -> m c
+ Interlude: liftM :: Monad m => (a1 -> r) -> m a1 -> m r
+ Interlude: liftM' :: Monad m => (a -> b) -> m a -> m b
+ Interlude: liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
+ Interlude: liftM2' :: Monad m => (a -> b -> c) -> m a -> m b -> m c
+ Interlude: liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
+ Interlude: liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
+ Interlude: liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
+ Interlude: liftRand :: () => (g -> (a, g)) -> Rand g a
+ Interlude: liftRandT :: () => (g -> m (a, g)) -> RandT g m a
+ Interlude: link :: () => Async a -> IO ()
+ Interlude: link2 :: () => Async a -> Async b -> IO ()
+ Interlude: list :: () => [b] -> (a -> b) -> [a] -> [b]
+ Interlude: listToMaybe :: () => [a] -> Maybe a
+ Interlude: local :: MonadReader r m => (r -> r) -> m a -> m a
+ Interlude: log :: Floating a => a -> a
+ Interlude: log1mexp :: Floating a => a -> a
+ Interlude: log1p :: Floating a => a -> a
+ Interlude: log1pexp :: Floating a => a -> a
+ Interlude: logBase :: Floating a => a -> a -> a
+ Interlude: lookingupNamer :: [(String, String)] -> FieldNamer
+ Interlude: magnitude :: RealFloat a => Complex a -> a
+ Interlude: makeClassy :: Name -> DecsQ
+ Interlude: makeClassyFor :: String -> String -> [(String, String)] -> Name -> DecsQ
+ Interlude: makeClassyPrisms :: Name -> DecsQ
+ Interlude: makeClassy_ :: Name -> DecsQ
+ Interlude: makeFields :: Name -> DecsQ
+ Interlude: makeFieldsNoPrefix :: Name -> DecsQ
+ Interlude: makeLenses :: Name -> DecsQ
+ Interlude: makeLensesFor :: [(String, String)] -> Name -> DecsQ
+ Interlude: makeLensesWith :: LensRules -> Name -> DecsQ
+ Interlude: makePrisms :: Name -> DecsQ
+ Interlude: makeWrapped :: Name -> DecsQ
+ Interlude: many :: Alternative f => f a -> f [a]
+ Interlude: map :: Functor f => (a -> b) -> f a -> f b
+ Interlude: mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
+ Interlude: mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
+ Interlude: mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
+ Interlude: mapExcept :: () => (Either e a -> Either e' b) -> Except e a -> Except e' b
+ Interlude: mapExceptT :: () => (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b
+ Interlude: mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
+ Interlude: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
+ Interlude: mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
+ Interlude: mapMaybe :: Filterable f => (a -> Maybe b) -> f a -> f b
+ Interlude: mapMaybeOf :: () => FilterLike Identity s t a b -> (a -> Maybe b) -> s -> t
+ Interlude: mapRand :: () => ((a, g) -> (b, g)) -> Rand g a -> Rand g b
+ Interlude: mapRandT :: () => (m (a, g) -> n (b, g)) -> RandT g m a -> RandT g n b
+ Interlude: mappend :: Monoid a => a -> a -> a
+ Interlude: mappingNamer :: (String -> [String]) -> FieldNamer
+ Interlude: mask :: () => ((forall a. () => IO a -> IO a) -> IO b) -> IO b
+ Interlude: mask_ :: () => IO a -> IO a
+ Interlude: max :: Ord a => a -> a -> a
+ Interlude: maxBound :: Bounded a => a
+ Interlude: maxInt :: Int
+ Interlude: maximum :: (Foldable t, Ord a) => t a -> a
+ Interlude: maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
+ Interlude: maximumDef :: Ord a => a -> [a] -> a
+ Interlude: maximumMay :: Ord a => [a] -> Maybe a
+ Interlude: maybe :: () => b -> (a -> b) -> Maybe a -> b
+ Interlude: maybeEmpty :: Monoid b => (a -> b) -> Maybe a -> b
+ Interlude: maybeToEither :: () => e -> Maybe a -> Either e a
+ Interlude: maybeToLeft :: () => r -> Maybe l -> Either l r
+ Interlude: maybeToList :: () => Maybe a -> [a]
+ Interlude: maybeToRight :: () => l -> Maybe r -> Either l r
+ Interlude: mconcat :: Monoid a => [a] -> a
+ Interlude: mempty :: Monoid a => a
+ Interlude: mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
+ Interlude: mfix :: MonadFix m => (a -> m a) -> m a
+ Interlude: min :: Ord a => a -> a -> a
+ Interlude: minBound :: Bounded a => a
+ Interlude: minInt :: Int
+ Interlude: minimum :: (Foldable t, Ord a) => t a -> a
+ Interlude: minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
+ Interlude: minimumDef :: Ord a => a -> [a] -> a
+ Interlude: minimumMay :: Ord a => [a] -> Maybe a
+ Interlude: mkLiftParseJSON :: Options -> Name -> Q Exp
+ Interlude: mkLiftParseJSON2 :: Options -> Name -> Q Exp
+ Interlude: mkLiftToEncoding :: Options -> Name -> Q Exp
+ Interlude: mkLiftToEncoding2 :: Options -> Name -> Q Exp
+ Interlude: mkLiftToJSON :: Options -> Name -> Q Exp
+ Interlude: mkLiftToJSON2 :: Options -> Name -> Q Exp
+ Interlude: mkParseJSON :: Options -> Name -> Q Exp
+ Interlude: mkPolar :: Floating a => a -> a -> Complex a
+ Interlude: mkStdGen :: Int -> StdGen
+ Interlude: mkToEncoding :: Options -> Name -> Q Exp
+ Interlude: mkToJSON :: Options -> Name -> Q Exp
+ Interlude: mkWeakMVar :: () => MVar a -> IO () -> IO (Weak (MVar a))
+ Interlude: mkWeakThreadId :: ThreadId -> IO (Weak ThreadId)
+ Interlude: mod :: Integral a => a -> a -> a
+ Interlude: modify :: MonadState s m => (s -> s) -> m ()
+ Interlude: modify' :: MonadState s m => (s -> s) -> m ()
+ Interlude: modifyMVar :: () => MVar a -> (a -> IO (a, b)) -> IO b
+ Interlude: modifyMVarMasked :: () => MVar a -> (a -> IO (a, b)) -> IO b
+ Interlude: modifyMVarMasked_ :: () => MVar a -> (a -> IO a) -> IO ()
+ Interlude: modifyMVar_ :: () => MVar a -> (a -> IO a) -> IO ()
+ Interlude: moduleName :: Datatype d => t d f a -> [Char]
+ Interlude: mplus :: MonadPlus m => m a -> m a -> m a
+ Interlude: msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
+ Interlude: mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
+ Interlude: myThreadId :: IO ThreadId
+ Interlude: mzero :: MonadPlus m => m a
+ Interlude: natVal :: KnownNat n => proxy n -> Integer
+ Interlude: negate :: Num a => a -> a
+ Interlude: newChan :: () => IO (Chan a)
+ Interlude: newEmptyMVar :: () => IO (MVar a)
+ Interlude: newMVar :: () => a -> IO (MVar a)
+ Interlude: newQSem :: Int -> IO QSem
+ Interlude: newQSemN :: Int -> IO QSemN
+ Interlude: newStdGen :: IO StdGen
+ Interlude: newtype All
+ Interlude: newtype Any
+ Interlude: newtype AssertionFailed
+ Interlude: newtype CompactionFailed
+ Interlude: newtype Concurrently a
+ Interlude: newtype Down a
+ Interlude: newtype Dual a
+ Interlude: newtype Endo a
+ Interlude: newtype ExceptT e (m :: Type -> Type) a
+ Interlude: newtype First a
+ Interlude: newtype Identity a
+ Interlude: newtype Last a
+ Interlude: newtype NoMethodError
+ Interlude: newtype Option a
+ Interlude: newtype PatternMatchFail
+ Interlude: newtype Peat a b t
+ Interlude: newtype Product a
+ Interlude: newtype RecConError
+ Interlude: newtype RecSelError
+ Interlude: newtype RecUpdError
+ Interlude: newtype StateT s (m :: Type -> Type) a
+ Interlude: newtype Sum a
+ Interlude: newtype ReaderT r (m :: k -> Type) (a :: k) :: forall k. () => Type -> k -> Type -> k -> Type
+ Interlude: newtype TypeError
+ Interlude: newtype ZipList a
+ Interlude: newtype Alt (f :: k -> Type) (a :: k) :: forall k. () => k -> Type -> k -> Type
+ Interlude: newtype (:.:) (f :: k2 -> Type) (g :: k1 -> k2) (p :: k1) :: forall k2 k1. () => k2 -> Type -> k1 -> k2 -> k1 -> Type
+ Interlude: next :: RandomGen g => g -> (Int, g)
+ Interlude: nonEmpty :: () => [a] -> Maybe (NonEmpty a)
+ Interlude: not :: Bool -> Bool
+ Interlude: notANumber :: Rational
+ Interlude: notElem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Interlude: notImplemented :: () => a
+ Interlude: note :: MonadError e m => e -> Maybe a -> m a
+ Interlude: null :: Foldable t => t a -> Bool
+ Interlude: numerator :: () => Ratio a -> a
+ Interlude: numericEnumFrom :: Fractional a => a -> [a]
+ Interlude: numericEnumFromThen :: Fractional a => a -> a -> [a]
+ Interlude: numericEnumFromThenTo :: (Ord a, Fractional a) => a -> a -> a -> [a]
+ Interlude: numericEnumFromTo :: (Ord a, Fractional a) => a -> a -> [a]
+ Interlude: odd :: Integral a => a -> Bool
+ Interlude: on :: () => (b -> b -> c) -> (a -> b) -> a -> a -> c
+ Interlude: onException :: () => IO a -> IO b -> IO a
+ Interlude: one :: Semiring m => m
+ Interlude: openFile :: FilePath -> IOMode -> IO Handle
+ Interlude: option :: () => b -> (a -> b) -> Option a -> b
+ Interlude: optional :: Alternative f => f a -> f (Maybe a)
+ Interlude: or :: Foldable t => t Bool -> Bool
+ Interlude: orAlt :: (Alternative f, Monoid a) => f a -> f a
+ Interlude: orElse :: () => STM a -> STM a -> STM a
+ Interlude: orEmpty :: Alternative f => Bool -> a -> f a
+ Interlude: ord :: Char -> Int
+ Interlude: ordNub :: (Witherable t, Ord a) => t a -> t a
+ Interlude: ordNubOf :: Ord a => FilterLike' (State (Set a)) s a -> s -> s
+ Interlude: otherwise :: Bool
+ Interlude: overflowError :: () => a
+ Interlude: packageName :: Datatype d => t d f a -> [Char]
+ Interlude: panic :: HasCallStack => Text -> a
+ Interlude: partitionEithers :: () => [Either a b] -> ([a], [b])
+ Interlude: pass :: Applicative f => f ()
+ Interlude: permutations :: () => [a] -> [[a]]
+ Interlude: phase :: RealFloat a => Complex a -> a
+ Interlude: pi :: Floating a => a
+ Interlude: polar :: RealFloat a => Complex a -> (a, a)
+ Interlude: poll :: () => Async a -> IO (Maybe (Either SomeException a))
+ Interlude: popCount :: Bits a => a -> Int
+ Interlude: popCountDefault :: (Bits a, Num a) => a -> Int
+ Interlude: pred :: Enum a => a -> a
+ Interlude: prettyCallStack :: CallStack -> String
+ Interlude: prettySrcLoc :: SrcLoc -> String
+ Interlude: print :: (MonadIO m, Show a) => a -> m ()
+ Interlude: product :: (Foldable f, Num a) => f a -> a
+ Interlude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Interlude: pure :: Applicative f => a -> f a
+ Interlude: purer :: (Applicative f, Applicative g) => a -> f (g a)
+ Interlude: put :: MonadState s m => s -> m ()
+ Interlude: putByteString :: MonadIO m => ByteString -> m ()
+ Interlude: putErrLn :: (Print a, MonadIO m) => a -> m ()
+ Interlude: putErrText :: MonadIO m => Text -> m ()
+ Interlude: putLByteString :: MonadIO m => ByteString -> m ()
+ Interlude: putLText :: MonadIO m => Text -> m ()
+ Interlude: putMVar :: () => MVar a -> a -> IO ()
+ Interlude: putStr :: (Print a, MonadIO m) => a -> m ()
+ Interlude: putStrLn :: (Print a, MonadIO m) => a -> m ()
+ Interlude: putText :: MonadIO m => Text -> m ()
+ Interlude: quot :: Integral a => a -> a -> a
+ Interlude: quotRem :: Integral a => a -> a -> (a, a)
+ Interlude: race :: () => IO a -> IO b -> IO (Either a b)
+ Interlude: race_ :: () => IO a -> IO b -> IO ()
+ Interlude: random :: (Random a, RandomGen g) => g -> (a, g)
+ Interlude: randomIO :: Random a => IO a
+ Interlude: randomR :: (Random a, RandomGen g) => (a, a) -> g -> (a, g)
+ Interlude: randomRIO :: Random a => (a, a) -> IO a
+ Interlude: randomRs :: (Random a, RandomGen g) => (a, a) -> g -> [a]
+ Interlude: randoms :: (Random a, RandomGen g) => g -> [a]
+ Interlude: ratioPrec :: Int
+ Interlude: ratioPrec1 :: Int
+ Interlude: ratioZeroDenominatorError :: () => a
+ Interlude: readChan :: () => Chan a -> IO a
+ Interlude: readEither :: Read a => String -> Either String a
+ Interlude: readFile :: FilePath -> IO Text
+ Interlude: readLitChar :: ReadS Char
+ Interlude: readMVar :: () => MVar a -> IO a
+ Interlude: readMaybe :: Read a => String -> Maybe a
+ Interlude: reader :: MonadReader r m => (r -> a) -> m a
+ Interlude: reads :: Read a => ReadS a
+ Interlude: realPart :: () => Complex a -> a
+ Interlude: realToFrac :: (Real a, Fractional b) => a -> b
+ Interlude: recip :: Fractional a => a -> a
+ Interlude: reduce :: Integral a => a -> a -> Ratio a
+ Interlude: rem :: Integral a => a -> a -> a
+ Interlude: repeat :: () => a -> [a]
+ Interlude: replace :: () => b -> OnError a b
+ Interlude: replicate :: () => Int -> a -> [a]
+ Interlude: replicateM :: Applicative m => Int -> m a -> m [a]
+ Interlude: replicateM_ :: Applicative m => Int -> m a -> m ()
+ Interlude: repr :: () => (a :~: b) -> Coercion a b
+ Interlude: retry :: () => STM a
+ Interlude: return :: Monad m => a -> m a
+ Interlude: reverse :: () => [a] -> [a]
+ Interlude: rightToMaybe :: () => Either l r -> Maybe r
+ Interlude: rights :: () => [Either a b] -> [b]
+ Interlude: rnf :: NFData a => a -> ()
+ Interlude: rotate :: Bits a => a -> Int -> a
+ Interlude: rotateL :: Bits a => a -> Int -> a
+ Interlude: rotateR :: Bits a => a -> Int -> a
+ Interlude: round :: (RealFrac a, Integral b) => a -> b
+ Interlude: rtsSupportsBoundThreads :: Bool
+ Interlude: runExcept :: () => Except e a -> Either e a
+ Interlude: runExceptT :: () => ExceptT e m a -> m (Either e a)
+ Interlude: runInBoundThread :: () => IO a -> IO a
+ Interlude: runInUnboundThread :: () => IO a -> IO a
+ Interlude: runRand :: () => Rand g a -> g -> (a, g)
+ Interlude: runRandT :: () => RandT g m a -> g -> m (a, g)
+ Interlude: runReader :: () => Reader r a -> r -> a
+ Interlude: runST :: () => (forall s. () => ST s a) -> a
+ Interlude: runState :: () => State s a -> s -> (a, s)
+ Interlude: scaleFloat :: RealFloat a => Int -> a -> a
+ Interlude: scanl :: () => (b -> a -> b) -> b -> [a] -> [b]
+ Interlude: scanl' :: () => (b -> a -> b) -> b -> [a] -> [b]
+ Interlude: scanr :: () => (a -> b -> b) -> b -> [a] -> [b]
+ Interlude: sconcat :: Semigroup a => NonEmpty a -> a
+ Interlude: second :: Bifunctor p => (b -> c) -> p a b -> p a c
+ Interlude: selDecidedStrictness :: Selector s => t s f a -> DecidedStrictness
+ Interlude: selName :: Selector s => t s f a -> [Char]
+ Interlude: selSourceStrictness :: Selector s => t s f a -> SourceStrictness
+ Interlude: selSourceUnpackedness :: Selector s => t s f a -> SourceUnpackedness
+ Interlude: seq :: () => a -> b -> b
+ Interlude: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
+ Interlude: sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
+ Interlude: sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
+ Interlude: sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
+ Interlude: setBit :: Bits a => a -> Int -> a
+ Interlude: setNumCapabilities :: Int -> IO ()
+ Interlude: setStdGen :: StdGen -> IO ()
+ Interlude: shift :: Bits a => a -> Int -> a
+ Interlude: shiftL :: Bits a => a -> Int -> a
+ Interlude: shiftR :: Bits a => a -> Int -> a
+ Interlude: show :: (Show a, StringConv String b) => a -> b
+ Interlude: showLitChar :: Char -> ShowS
+ Interlude: showStackTrace :: IO (Maybe String)
+ Interlude: signalQSem :: QSem -> IO ()
+ Interlude: signalQSemN :: QSemN -> Int -> IO ()
+ Interlude: significand :: RealFloat a => a -> a
+ Interlude: signum :: Num a => a -> a
+ Interlude: simpleLenses :: Lens' LensRules Bool
+ Interlude: sin :: Floating a => a -> a
+ Interlude: sinh :: Floating a => a -> a
+ Interlude: snd :: () => (a, b) -> b
+ Interlude: some :: Alternative f => f a -> f [a]
+ Interlude: someNatVal :: Integer -> Maybe SomeNat
+ Interlude: someSymbolVal :: String -> SomeSymbol
+ Interlude: sort :: Ord a => [a] -> [a]
+ Interlude: sortBy :: () => (a -> a -> Ordering) -> [a] -> [a]
+ Interlude: sortOn :: Ord o => (a -> o) -> [a] -> [a]
+ Interlude: split :: RandomGen g => g -> (g, g)
+ Interlude: splitAt :: () => Int -> [a] -> ([a], [a])
+ Interlude: sqrt :: Floating a => a -> a
+ Interlude: state :: MonadState s m => (s -> (a, s)) -> m a
+ Interlude: stderr :: Handle
+ Interlude: stdin :: Handle
+ Interlude: stdout :: Handle
+ Interlude: stimes :: (Semigroup a, Integral b) => b -> a -> a
+ Interlude: stimesIdempotent :: Integral b => b -> a -> a
+ Interlude: stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
+ Interlude: stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
+ Interlude: strConv :: StringConv a b => Leniency -> a -> b
+ Interlude: strictDecode :: OnDecodeError
+ Interlude: subsequences :: () => [a] -> [[a]]
+ Interlude: subtract :: Num a => a -> a -> a
+ Interlude: succ :: Enum a => a -> a
+ Interlude: sum :: (Foldable f, Num a) => f a -> a
+ Interlude: swap :: () => (a, b) -> (b, a)
+ Interlude: swapMVar :: () => MVar a -> a -> IO a
+ Interlude: sym :: () => (a :~: b) -> b :~: a
+ Interlude: symbolVal :: KnownSymbol n => proxy n -> String
+ Interlude: tailDef :: () => [a] -> [a] -> [a]
+ Interlude: tailMay :: () => [a] -> Maybe [a]
+ Interlude: tailSafe :: () => [a] -> [a]
+ Interlude: tails :: () => [a] -> [[a]]
+ Interlude: take :: () => Int -> [a] -> [a]
+ Interlude: takeMVar :: () => MVar a -> IO a
+ Interlude: takeWhile :: () => (a -> Bool) -> [a] -> [a]
+ Interlude: tan :: Floating a => a -> a
+ Interlude: tanh :: Floating a => a -> a
+ Interlude: testBit :: Bits a => a -> Int -> Bool
+ Interlude: testBitDefault :: (Bits a, Num a) => a -> Int -> Bool
+ Interlude: threadCapability :: ThreadId -> IO (Int, Bool)
+ Interlude: threadDelay :: Int -> IO ()
+ Interlude: threadWaitRead :: Fd -> IO ()
+ Interlude: threadWaitReadSTM :: Fd -> IO (STM (), IO ())
+ Interlude: threadWaitWrite :: Fd -> IO ()
+ Interlude: threadWaitWriteSTM :: Fd -> IO (STM (), IO ())
+ Interlude: throwE :: Monad m => e -> ExceptT e m a
+ Interlude: throwError :: MonadError e m => e -> m a
+ Interlude: throwIO :: (MonadIO m, Exception e) => e -> m a
+ Interlude: throwM :: (MonadThrow m, Exception e) => e -> m a
+ Interlude: throwSTM :: Exception e => e -> STM a
+ Interlude: throwTo :: (MonadIO m, Exception e) => ThreadId -> e -> m ()
+ Interlude: to :: Generic a => Rep a x -> a
+ Interlude: toEnum :: Enum a => Int -> a
+ Interlude: toException :: Exception e => e -> SomeException
+ Interlude: toInteger :: Integral a => a -> Integer
+ Interlude: toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
+ Interlude: toList :: Foldable t => t a -> [a]
+ Interlude: toLower :: Char -> Char
+ Interlude: toRational :: Real a => a -> Rational
+ Interlude: toS :: StringConv a b => a -> b
+ Interlude: toSL :: StringConv a b => a -> b
+ Interlude: toStrict :: Text -> Text
+ Interlude: toTitle :: Char -> Char
+ Interlude: toUpper :: Char -> Char
+ Interlude: trace :: Print b => b -> a -> a
+ Interlude: traceIO :: Print b => b -> a -> IO a
+ Interlude: traceId :: Text -> Text
+ Interlude: traceM :: Monad m => Text -> m ()
+ Interlude: traceShow :: Show a => a -> b -> b
+ Interlude: traceShowId :: Show a => a -> a
+ Interlude: traceShowM :: (Show a, Monad m) => a -> m ()
+ Interlude: trans :: () => (a :~: b) -> (b :~: c) -> a :~: c
+ Interlude: transpose :: () => [[a]] -> [[a]]
+ Interlude: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
+ Interlude: traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
+ Interlude: truncate :: (RealFrac a, Integral b) => a -> b
+ Interlude: try :: (MonadCatch m, Exception e) => m a -> m (Either e a)
+ Interlude: tryIO :: MonadIO m => IO a -> ExceptT IOException m a
+ Interlude: tryJust :: Exception e => (e -> Maybe b) -> IO a -> IO (Either b a)
+ Interlude: tryPutMVar :: () => MVar a -> a -> IO Bool
+ Interlude: tryReadMVar :: () => MVar a -> IO (Maybe a)
+ Interlude: tryTakeMVar :: () => MVar a -> IO (Maybe a)
+ Interlude: type C1 = (M1 C :: Meta -> k -> Type -> k -> Type)
+ Interlude: type ClassyNamer = Name -> Maybe (Name, Name)
+ Interlude: type D1 = (M1 D :: Meta -> k -> Type -> k -> Type)
+ Interlude: type Except e = ExceptT e Identity
+ Interlude: type FieldNamer = Name -> [Name] -> Name -> [DefName]
+ Interlude: type FilePath = String
+ Interlude: type Filter s t a b = forall (f :: Type -> Type). Applicative f => FilterLike f s t a b
+ Interlude: type Filter' s a = forall (f :: Type -> Type). Applicative f => FilterLike' f s a
+ Interlude: type HasCallStack = ?callStack :: CallStack
+ Interlude: type LByteString = ByteString
+ Interlude: type LText = Text
+ Interlude: type OnDecodeError = OnError Word8 Char
+ Interlude: type OnError a b = String -> Maybe a -> Maybe b
+ Interlude: type Rand g = RandT g Identity
+ Interlude: type Rational = Ratio Integer
+ Interlude: type Reader r = ReaderT r Identity
+ Interlude: type Rec0 = (K1 R :: Type -> k -> Type)
+ Interlude: type S1 = (M1 S :: Meta -> k -> Type -> k -> Type)
+ Interlude: type State s = StateT s Identity
+ Interlude: type Type = Type
+ Interlude: type TypeRep = SomeTypeRep
+ Interlude: type family (==) (a :: k) (b :: k) :: Bool
+ Interlude: typeRep :: Typeable a => proxy a -> TypeRep
+ Interlude: uncons :: () => [a] -> Maybe (a, [a])
+ Interlude: uncurry :: () => (a -> b -> c) -> (a, b) -> c
+ Interlude: undefined :: () => a
+ Interlude: underflowError :: () => a
+ Interlude: underscoreFields :: LensRules
+ Interlude: underscoreNamer :: FieldNamer
+ Interlude: underscoreNoPrefixNamer :: FieldNamer
+ Interlude: unfoldr :: () => (b -> Maybe (a, b)) -> b -> [a]
+ Interlude: uniform :: (Foldable t, MonadRandom m) => t a -> m a
+ Interlude: uniformMay :: (Foldable t, MonadRandom m) => t a -> m (Maybe a)
+ Interlude: uninterruptibleMask :: () => ((forall a. () => IO a -> IO a) -> IO b) -> IO b
+ Interlude: uninterruptibleMask_ :: () => IO a -> IO a
+ Interlude: unless :: Applicative f => Bool -> f () -> f ()
+ Interlude: unlessM :: Monad m => m Bool -> m () -> m ()
+ Interlude: unsnoc :: () => [x] -> Maybe ([x], x)
+ Interlude: until :: () => (a -> Bool) -> (a -> a) -> a -> a
+ Interlude: unzip :: () => [(a, b)] -> ([a], [b])
+ Interlude: vacuous :: Functor f => f Void -> f a
+ Interlude: view :: MonadReader s m => Getting a s a -> m a
+ Interlude: void :: Functor f => f a -> f ()
+ Interlude: waitAny :: () => [Async a] -> IO (Async a, a)
+ Interlude: waitAnyCancel :: () => [Async a] -> IO (Async a, a)
+ Interlude: waitAnyCatch :: () => [Async a] -> IO (Async a, Either SomeException a)
+ Interlude: waitAnyCatchCancel :: () => [Async a] -> IO (Async a, Either SomeException a)
+ Interlude: waitBoth :: () => Async a -> Async b -> IO (a, b)
+ Interlude: waitCatch :: () => Async a -> IO (Either SomeException a)
+ Interlude: waitEither :: () => Async a -> Async b -> IO (Either a b)
+ Interlude: waitEitherCancel :: () => Async a -> Async b -> IO (Either a b)
+ Interlude: waitEitherCatch :: () => Async a -> Async b -> IO (Either (Either SomeException a) (Either SomeException b))
+ Interlude: waitEitherCatchCancel :: () => Async a -> Async b -> IO (Either (Either SomeException a) (Either SomeException b))
+ Interlude: waitEither_ :: () => Async a -> Async b -> IO ()
+ Interlude: waitQSem :: QSem -> IO ()
+ Interlude: waitQSemN :: QSemN -> Int -> IO ()
+ Interlude: weighted :: (Foldable t, MonadRandom m) => t (a, Rational) -> m a
+ Interlude: weightedMay :: (Foldable t, MonadRandom m) => t (a, Rational) -> m (Maybe a)
+ Interlude: when :: Applicative f => Bool -> f () -> f ()
+ Interlude: whenM :: Monad m => m Bool -> m () -> m ()
+ Interlude: withAsync :: () => IO a -> (Async a -> IO b) -> IO b
+ Interlude: withAsyncBound :: () => IO a -> (Async a -> IO b) -> IO b
+ Interlude: withAsyncOn :: () => Int -> IO a -> (Async a -> IO b) -> IO b
+ Interlude: withExcept :: () => (e -> e') -> Except e a -> Except e' a
+ Interlude: withExceptT :: Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a
+ Interlude: withFile :: () => FilePath -> IOMode -> (Handle -> IO r) -> IO r
+ Interlude: withFrozenCallStack :: HasCallStack => (HasCallStack -> a) -> a
+ Interlude: withMVar :: () => MVar a -> (a -> IO b) -> IO b
+ Interlude: withMVarMasked :: () => MVar a -> (a -> IO b) -> IO b
+ Interlude: withRand :: () => (g -> g) -> Rand g a -> Rand g a
+ Interlude: withRandT :: () => (g -> g) -> RandT g m a -> RandT g m a
+ Interlude: withState :: () => (s -> s) -> State s a -> State s a
+ Interlude: wither :: (Witherable t, Applicative f) => (a -> f (Maybe b)) -> t a -> f (t b)
+ Interlude: witherM :: (Witherable t, Monad m) => (a -> m (Maybe b)) -> t a -> m (t b)
+ Interlude: witherOf :: () => FilterLike f s t a b -> (a -> f (Maybe b)) -> s -> f t
+ Interlude: witness :: () => a
+ Interlude: writeChan :: () => Chan a -> a -> IO ()
+ Interlude: writeFile :: FilePath -> Text -> IO ()
+ Interlude: writeList2Chan :: () => Chan a -> [a] -> IO ()
+ Interlude: xor :: Bits a => a -> a -> a
+ Interlude: zero :: Monoid m => m
+ Interlude: zeroBits :: Bits a => a
+ Interlude: zip :: () => [a] -> [b] -> [(a, b)]
+ Interlude: zipWith :: () => (a -> b -> c) -> [a] -> [b] -> [c]
+ Interlude: zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
+ Interlude: zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
+ Interlude: }
Files
- interlude-l.cabal +5/−5
interlude-l.cabal view
@@ -1,5 +1,5 @@ name: interlude-l -version: 0.4.0.0 +version: 0.5.0.0 synopsis: Prelude replacement based on protolude description: Prelude replacement based on protolude license: MIT @@ -18,11 +18,11 @@ build-depends: base >= 4.7 && < 5 , protolude >= 0.2.1 , string-conv == 0.1.* - , exceptions == 0.8.* + , exceptions >= 0.8 && < 0.11 , mtl == 2.2.* - , lens >= 4.14 && < 4.17 - , aeson >= 0.11 && < 1.3 - , witherable == 0.2.* + , lens >= 4.14 && < 4.18 + , aeson >= 0.11 && < 1.5 + , witherable >= 0.2 && < 0.4 , transformers == 0.5.* , mtl == 2.2.* , monad-control