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


-- | A small prelude.
--   
--   A sensible set of defaults for writing custom Preludes.
@package protolude
@version 0.3.2

module Protolude.Applicative
orAlt :: (Alternative f, Monoid a) => f a -> f a
orEmpty :: Alternative f => Bool -> a -> f a
eitherA :: Alternative f => f a -> f b -> f (Either a b)
purer :: (Applicative f, Applicative g) => a -> f (g a)
liftAA2 :: (Applicative f, Applicative g) => (a -> b -> c) -> f (g a) -> f (g b) -> f (g c)
(<<*>>) :: (Applicative f, Applicative g) => f (g (a -> b)) -> f (g a) -> f (g b)
infixl 4 <<*>>

module Protolude.Base
(++) :: [a] -> [a] -> [a]
seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
print :: Show a => a -> IO ()
fromIntegral :: (Integral a, Num b) => a -> b
realToFrac :: (Real a, Fractional b) => a -> b
class Bounded a
minBound :: Bounded a => a
maxBound :: Bounded a => a
class Enum a
succ :: Enum a => a -> a
pred :: Enum a => a -> a
toEnum :: Enum a => Int -> a
fromEnum :: Enum a => a -> Int
enumFrom :: Enum a => a -> [a]
enumFromThen :: Enum a => a -> a -> [a]
enumFromTo :: Enum a => a -> a -> [a]
enumFromThenTo :: Enum a => a -> a -> a -> [a]
class Fractional a => Floating a
pi :: Floating a => a
exp :: Floating a => a -> a
log :: Floating a => a -> a
sqrt :: Floating a => a -> a
(**) :: Floating a => a -> a -> a
logBase :: Floating a => a -> a -> a
sin :: Floating a => a -> a
cos :: Floating a => a -> a
tan :: Floating a => a -> a
asin :: Floating a => a -> a
acos :: Floating a => a -> a
atan :: Floating a => a -> a
sinh :: Floating a => a -> a
cosh :: Floating a => a -> a
tanh :: Floating a => a -> a
asinh :: Floating a => a -> a
acosh :: Floating a => a -> a
atanh :: Floating a => a -> a
log1p :: Floating a => a -> a
expm1 :: Floating a => a -> a
log1pexp :: Floating a => a -> a
log1mexp :: Floating a => a -> a
class Num a => Fractional a
(/) :: Fractional a => a -> a -> a
recip :: Fractional a => a -> a
fromRational :: Fractional a => Rational -> a
class (Real a, Enum a) => Integral a
quot :: Integral a => a -> a -> a
rem :: Integral a => a -> a -> a
div :: Integral a => a -> a -> a
mod :: Integral a => a -> a -> a
quotRem :: Integral a => a -> a -> (a, a)
divMod :: Integral a => a -> a -> (a, a)
toInteger :: Integral a => a -> Integer
class Num a
(+) :: Num a => a -> a -> a
(-) :: Num a => a -> a -> a
(*) :: Num a => a -> a -> a
negate :: Num a => a -> a
abs :: Num a => a -> a
signum :: Num a => a -> a
fromInteger :: Num a => Integer -> a
class (Num a, Ord a) => Real a
toRational :: Real a => a -> Rational
class (RealFrac a, Floating a) => RealFloat a
floatRadix :: RealFloat a => a -> Integer
floatDigits :: RealFloat a => a -> Int
floatRange :: RealFloat a => a -> (Int, Int)
decodeFloat :: RealFloat a => a -> (Integer, Int)
encodeFloat :: RealFloat a => Integer -> Int -> a
exponent :: RealFloat a => a -> Int
significand :: RealFloat a => a -> a
scaleFloat :: RealFloat a => Int -> a -> a
isNaN :: RealFloat a => a -> Bool
isInfinite :: RealFloat a => a -> Bool
isDenormalized :: RealFloat a => a -> Bool
isNegativeZero :: RealFloat a => a -> Bool
isIEEE :: RealFloat a => a -> Bool
atan2 :: RealFloat a => a -> a -> a
class (Real a, Fractional a) => RealFrac a
properFraction :: (RealFrac a, Integral b) => a -> (b, a)
truncate :: (RealFrac a, Integral b) => a -> b
round :: (RealFrac a, Integral b) => a -> b
ceiling :: (RealFrac a, Integral b) => a -> b
floor :: (RealFrac a, Integral b) => a -> b
class Show a
showsPrec :: Show a => Int -> a -> ShowS
show :: Show a => a -> String
showList :: Show a => [a] -> ShowS
class KnownNat (n :: Nat)
class KnownSymbol (n :: Symbol)
class HasField (x :: k) r a | x r -> a
getField :: HasField x r a => r -> a
data Bool
data Char
data Double
D# :: Double# -> Double
data Float
F# :: Float# -> Float
data Int
data Integer
data Ordering
data Ratio a
type Rational = Ratio Integer
data IO a
data Word
data Ptr a
data FunPtr a
type Type = TYPE LiftedRep
data Constraint
class a ~R# b => Coercible (a :: k) (b :: k)
data StaticPtr a
data CallStack
data Symbol
type family CmpNat (a :: Natural) (b :: Natural) :: Ordering
showFloat :: RealFloat a => a -> ShowS
showSignedFloat :: RealFloat a => (a -> ShowS) -> Int -> a -> ShowS
(^) :: (Num a, Integral b) => a -> b -> a
divZeroError :: a
even :: Integral a => a -> Bool
overflowError :: a
numericEnumFromThenTo :: (Ord a, Fractional a) => a -> a -> a -> [a]
asTypeOf :: a -> a -> a
maxInt :: Int
minInt :: Int
ord :: Char -> Int
until :: (a -> Bool) -> (a -> a) -> a -> a
subtract :: Num a => a -> a -> a
boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
(%) :: Integral a => a -> a -> Ratio a
(^%^) :: Integral a => Rational -> a -> Rational
(^^) :: (Fractional a, Integral b) => a -> b -> a
(^^%^^) :: Integral a => Rational -> a -> Rational
denominator :: Ratio a -> a
gcd :: Integral a => a -> a -> a
infinity :: Rational
integralEnumFrom :: (Integral a, Bounded a) => a -> [a]
integralEnumFromThen :: (Integral a, Bounded a) => a -> a -> [a]
integralEnumFromThenTo :: Integral a => a -> a -> a -> [a]
integralEnumFromTo :: Integral a => a -> a -> [a]
lcm :: Integral a => a -> a -> a
notANumber :: Rational
numerator :: Ratio a -> a
numericEnumFrom :: Fractional a => a -> [a]
numericEnumFromThen :: Fractional a => a -> a -> [a]
numericEnumFromTo :: (Ord a, Fractional a) => a -> a -> [a]
odd :: Integral a => a -> Bool
ratioPrec :: Int
ratioPrec1 :: Int
ratioZeroDenominatorError :: a
reduce :: Integral a => a -> a -> Ratio a
showSigned :: Real a => (a -> ShowS) -> Int -> a -> ShowS
underflowError :: a
getCallStack :: CallStack -> [([Char], SrcLoc)]
currentCallStack :: IO [String]
putStr :: String -> IO ()
putStrLn :: String -> IO ()
class IsLabel (x :: Symbol) a
fromLabel :: IsLabel x a => a
getStackTrace :: IO (Maybe [Location])
showStackTrace :: IO (Maybe String)
data Location
Location :: String -> String -> Maybe SrcLoc -> Location
[objectName] :: Location -> String
[functionName] :: Location -> String
[srcLoc] :: Location -> Maybe SrcLoc
data SrcLoc
SrcLoc :: String -> Int -> Int -> SrcLoc
prettyCallStack :: CallStack -> String
prettySrcLoc :: SrcLoc -> String
callStack :: HasCallStack => CallStack
withFrozenCallStack :: HasCallStack => (HasCallStack => a) -> a
type HasCallStack = ?callStack :: CallStack
natVal :: forall (n :: Nat) proxy. KnownNat n => proxy n -> Integer
someNatVal :: Integer -> Maybe SomeNat
someSymbolVal :: String -> SomeSymbol
symbolVal :: forall (n :: Symbol) proxy. KnownSymbol n => proxy n -> String
data SomeSymbol
SomeSymbol :: Proxy n -> SomeSymbol
type Nat = Natural
data SomeNat
SomeNat :: Proxy n -> SomeNat
($!) :: (a -> b) -> a -> b
infixr 0 $!

module Protolude.Bifunctor
class Bifunctor p
bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
first :: Bifunctor p => (a -> b) -> p a c -> p b c
second :: Bifunctor p => (b -> c) -> p a b -> p a c
instance Protolude.Bifunctor.Bifunctor (,)
instance Protolude.Bifunctor.Bifunctor ((,,) x1)
instance Protolude.Bifunctor.Bifunctor ((,,,) x1 x2)
instance Protolude.Bifunctor.Bifunctor ((,,,,) x1 x2 x3)
instance Protolude.Bifunctor.Bifunctor ((,,,,,) x1 x2 x3 x4)
instance Protolude.Bifunctor.Bifunctor ((,,,,,,) x1 x2 x3 x4 x5)
instance Protolude.Bifunctor.Bifunctor Data.Either.Either
instance Protolude.Bifunctor.Bifunctor Data.Functor.Const.Const

module Protolude.Bool
whenM :: Monad m => m Bool -> m () -> m ()
unlessM :: Monad m => m Bool -> m () -> m ()
ifM :: Monad m => m Bool -> m a -> m a -> m a
guardM :: MonadPlus m => m Bool -> m ()
bool :: a -> a -> Bool -> a

-- | The <a>&amp;&amp;</a> operator lifted to a monad. If the first
--   argument evaluates to <a>False</a> the second argument will not be
--   evaluated.
(&&^) :: Monad m => m Bool -> m Bool -> m Bool
infixr 3 &&^

-- | The <a>||</a> operator lifted to a monad. If the first argument
--   evaluates to <a>True</a> the second argument will not be evaluated.
(||^) :: Monad m => m Bool -> m Bool -> m Bool
infixr 2 ||^

-- | <a>&amp;&amp;</a> lifted to an Applicative. Unlike <a>&amp;&amp;^</a>
--   the operator is <b>not</b> short-circuiting.
(<&&>) :: Applicative a => a Bool -> a Bool -> a Bool
infixr 3 <&&>

-- | <a>||</a> lifted to an Applicative. Unlike <a>||^</a> the operator is
--   <b>not</b> short-circuiting.
(<||>) :: Applicative a => a Bool -> a Bool -> a Bool
infixr 2 <||>

module Protolude.CallStack
type HasCallStack = ?callStack :: CallStack


-- | An alternative to <a>ConvertText</a> that includes partial
--   conversions. Not re-exported by <tt>Protolude</tt>.
module Protolude.Conv
class StringConv a b
strConv :: StringConv a b => Leniency -> a -> b
toS :: StringConv a b => a -> b
toSL :: StringConv a b => a -> b
data Leniency
Lenient :: Leniency
Strict :: Leniency
instance GHC.Enum.Bounded Protolude.Conv.Leniency
instance GHC.Enum.Enum Protolude.Conv.Leniency
instance GHC.Classes.Ord Protolude.Conv.Leniency
instance GHC.Show.Show Protolude.Conv.Leniency
instance GHC.Classes.Eq Protolude.Conv.Leniency
instance Protolude.Conv.StringConv GHC.Base.String GHC.Base.String
instance Protolude.Conv.StringConv GHC.Base.String Data.ByteString.Internal.Type.ByteString
instance Protolude.Conv.StringConv GHC.Base.String Data.ByteString.Lazy.Internal.ByteString
instance Protolude.Conv.StringConv GHC.Base.String Data.Text.Internal.Text
instance Protolude.Conv.StringConv GHC.Base.String Data.Text.Internal.Lazy.Text
instance Protolude.Conv.StringConv Data.ByteString.Internal.Type.ByteString GHC.Base.String
instance Protolude.Conv.StringConv Data.ByteString.Internal.Type.ByteString Data.ByteString.Internal.Type.ByteString
instance Protolude.Conv.StringConv Data.ByteString.Internal.Type.ByteString Data.ByteString.Lazy.Internal.ByteString
instance Protolude.Conv.StringConv Data.ByteString.Internal.Type.ByteString Data.Text.Internal.Text
instance Protolude.Conv.StringConv Data.ByteString.Internal.Type.ByteString Data.Text.Internal.Lazy.Text
instance Protolude.Conv.StringConv Data.ByteString.Lazy.Internal.ByteString GHC.Base.String
instance Protolude.Conv.StringConv Data.ByteString.Lazy.Internal.ByteString Data.ByteString.Internal.Type.ByteString
instance Protolude.Conv.StringConv Data.ByteString.Lazy.Internal.ByteString Data.ByteString.Lazy.Internal.ByteString
instance Protolude.Conv.StringConv Data.ByteString.Lazy.Internal.ByteString Data.Text.Internal.Text
instance Protolude.Conv.StringConv Data.ByteString.Lazy.Internal.ByteString Data.Text.Internal.Lazy.Text
instance Protolude.Conv.StringConv Data.Text.Internal.Text GHC.Base.String
instance Protolude.Conv.StringConv Data.Text.Internal.Text Data.ByteString.Internal.Type.ByteString
instance Protolude.Conv.StringConv Data.Text.Internal.Text Data.ByteString.Lazy.Internal.ByteString
instance Protolude.Conv.StringConv Data.Text.Internal.Text Data.Text.Internal.Lazy.Text
instance Protolude.Conv.StringConv Data.Text.Internal.Text Data.Text.Internal.Text
instance Protolude.Conv.StringConv Data.Text.Internal.Lazy.Text GHC.Base.String
instance Protolude.Conv.StringConv Data.Text.Internal.Lazy.Text Data.Text.Internal.Text
instance Protolude.Conv.StringConv Data.Text.Internal.Lazy.Text Data.Text.Internal.Lazy.Text
instance Protolude.Conv.StringConv Data.Text.Internal.Lazy.Text Data.ByteString.Lazy.Internal.ByteString
instance Protolude.Conv.StringConv Data.Text.Internal.Lazy.Text Data.ByteString.Internal.Type.ByteString


-- | Non-partial text conversion typeclass and functions. For an
--   alternative with partial conversions import <a>Conv</a>.
module Protolude.ConvertText

-- | Convert from one Unicode textual type to another. Not for
--   serialization/deserialization, so doesn't have instances for
--   bytestrings.
class ConvertText a b
toS :: ConvertText a b => a -> b
toUtf8 :: ConvertText a Text => a -> ByteString
toUtf8Lazy :: ConvertText a Text => a -> ByteString
instance Protolude.ConvertText.ConvertText GHC.Base.String GHC.Base.String
instance Protolude.ConvertText.ConvertText GHC.Base.String Data.Text.Internal.Text
instance Protolude.ConvertText.ConvertText GHC.Base.String Data.Text.Internal.Lazy.Text
instance Protolude.ConvertText.ConvertText Data.Text.Internal.Text GHC.Base.String
instance Protolude.ConvertText.ConvertText Data.Text.Internal.Text Data.Text.Internal.Lazy.Text
instance Protolude.ConvertText.ConvertText Data.Text.Internal.Text Data.Text.Internal.Text
instance Protolude.ConvertText.ConvertText Data.Text.Internal.Lazy.Text GHC.Base.String
instance Protolude.ConvertText.ConvertText Data.Text.Internal.Lazy.Text Data.Text.Internal.Text
instance Protolude.ConvertText.ConvertText Data.Text.Internal.Lazy.Text Data.Text.Internal.Lazy.Text
instance Protolude.ConvertText.ConvertText Data.ByteString.Lazy.Internal.ByteString Data.ByteString.Internal.Type.ByteString
instance Protolude.ConvertText.ConvertText Data.ByteString.Lazy.Internal.ByteString Data.ByteString.Lazy.Internal.ByteString
instance Protolude.ConvertText.ConvertText Data.ByteString.Internal.Type.ByteString Data.ByteString.Internal.Type.ByteString
instance Protolude.ConvertText.ConvertText Data.ByteString.Internal.Type.ByteString Data.ByteString.Lazy.Internal.ByteString

module Protolude.Either
maybeToLeft :: r -> Maybe l -> Either l r
maybeToRight :: l -> Maybe r -> Either l r
leftToMaybe :: Either l r -> Maybe l
rightToMaybe :: Either l r -> Maybe r
maybeEmpty :: Monoid b => (a -> b) -> Maybe a -> b
maybeToEither :: e -> Maybe a -> Either e a
fromLeft :: a -> Either a b -> a
fromRight :: b -> Either a b -> b

module Protolude.Error

-- | <i>Warning: <a>error</a> remains in code</i>
error :: forall (r :: RuntimeRep). forall (a :: TYPE r). HasCallStack => Text -> a

module Protolude.Exceptions
hush :: Alternative m => Either e a -> m a
note :: MonadError e m => e -> Maybe a -> m a
tryIO :: MonadIO m => IO a -> ExceptT IOException m a

module Protolude.Functor
class Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b
($>) :: Functor f => f a -> b -> f b
(<$) :: Functor f => a -> f b -> f a
(<$>) :: Functor f => (a -> b) -> f a -> f b
(<<$>>) :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
infixl 4 <<$>>
(<&>) :: Functor f => f a -> (a -> b) -> f b
void :: Functor f => f a -> f ()
foreach :: Functor f => f a -> (a -> b) -> f b

module Protolude.List
head :: Foldable f => f a -> Maybe a
ordNub :: Ord a => [a] -> [a]
sortOn :: Ord o => (a -> o) -> [a] -> [a]
list :: [b] -> (a -> b) -> [a] -> [b]
product :: (Foldable f, Num a) => f a -> a
sum :: (Foldable f, Num a) => f a -> a
groupBy :: (a -> a -> Bool) -> [a] -> [[a]]

module Protolude.Monad
class Applicative m => Monad (m :: Type -> Type)
(>>=) :: Monad m => m a -> (a -> m b) -> m b
return :: Monad m => a -> m a
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
mzero :: MonadPlus m => m a
mplus :: MonadPlus m => m a -> m a -> m a
(=<<) :: Monad m => (a -> m b) -> m a -> m b
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
(>>) :: Monad m => m a -> m b -> m b
forever :: Applicative f => f a -> f b
join :: Monad m => m (m a) -> m a
mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
replicateM :: Applicative m => Int -> m a -> m [a]
replicateM_ :: Applicative m => Int -> m a -> m ()
concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]
guard :: Alternative f => Bool -> f ()
when :: Applicative f => Bool -> f () -> f ()
unless :: Applicative f => Bool -> f () -> f ()
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
liftM' :: Monad m => (a -> b) -> m a -> m b
liftM2' :: Monad m => (a -> b -> c) -> m a -> m b -> m c
ap :: Monad m => m (a -> b) -> m a -> m b
(<$!>) :: Monad m => (a -> b) -> m a -> m b

module Protolude.Panic

-- | Uncatchable exceptions thrown and never caught.
newtype FatalError
FatalError :: Text -> FatalError
[fatalErrorMessage] :: FatalError -> Text
panic :: HasCallStack => Text -> a
instance GHC.Show.Show Protolude.Panic.FatalError
instance GHC.Exception.Type.Exception Protolude.Panic.FatalError

module Protolude.Partial
head :: [a] -> a
init :: [a] -> [a]
tail :: [a] -> [a]
last :: [a] -> a
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b
foldr1 :: Foldable t => (a -> a -> a) -> t a -> a
foldl1 :: Foldable t => (a -> a -> a) -> t a -> a
cycle :: [a] -> [a]
maximum :: (Foldable t, Ord a) => t a -> a
minimum :: (Foldable t, Ord a) => t a -> a
(!!) :: [a] -> Int -> a
sum :: (Foldable t, Num a) => t a -> a
product :: (Foldable t, Num a) => t a -> a
fromJust :: HasCallStack => Maybe a -> a
read :: Read a => String -> a

module Protolude.Safe
headMay :: [a] -> Maybe a
headDef :: a -> [a] -> a
initMay :: [a] -> Maybe [a]
initDef :: [a] -> [a] -> [a]
initSafe :: [a] -> [a]
tailMay :: [a] -> Maybe [a]
tailDef :: [a] -> [a] -> [a]
tailSafe :: [a] -> [a]
lastDef :: a -> [a] -> a
lastMay :: [a] -> Maybe a
foldr1May :: (a -> a -> a) -> [a] -> Maybe a
foldl1May :: (a -> a -> a) -> [a] -> Maybe a
foldl1May' :: (a -> a -> a) -> [a] -> Maybe a
maximumMay :: Ord a => [a] -> Maybe a
minimumMay :: Ord a => [a] -> Maybe a
maximumDef :: Ord a => a -> [a] -> a
minimumDef :: Ord a => a -> [a] -> a
atMay :: [a] -> Int -> Maybe a
atDef :: a -> [a] -> Int -> a

module Protolude.Semiring
class Monoid m => Semiring m
one :: Semiring m => m
(<.>) :: Semiring m => m -> m -> m

-- | Alias for <a>mempty</a>
zero :: Monoid m => m

module Protolude.Show
class Print a
hPutStr :: (Print a, MonadIO m) => Handle -> a -> m ()
putStr :: (Print a, MonadIO m) => a -> m ()
hPutStrLn :: (Print a, MonadIO m) => Handle -> a -> m ()
putStrLn :: (Print a, MonadIO m) => a -> m ()
putErrLn :: (Print a, MonadIO m) => a -> m ()
putText :: MonadIO m => Text -> m ()
putErrText :: MonadIO m => Text -> m ()
putLText :: MonadIO m => Text -> m ()
putByteString :: MonadIO m => ByteString -> m ()
putLByteString :: MonadIO m => ByteString -> m ()
instance Protolude.Show.Print Data.Text.Internal.Text
instance Protolude.Show.Print Data.Text.Internal.Lazy.Text
instance Protolude.Show.Print Data.ByteString.Internal.Type.ByteString
instance Protolude.Show.Print Data.ByteString.Lazy.Internal.ByteString
instance Protolude.Show.Print [GHC.Types.Char]

module Protolude.Debug

-- | <i>Warning: <a>undefined</a> remains in code</i>
undefined :: a

-- | <i>Warning: <a>trace</a> remains in code</i>
trace :: Print b => b -> a -> a

-- | <i>Warning: <a>traceM</a> remains in code</i>
traceM :: Monad m => Text -> m ()

-- | <i>Warning: <a>traceId</a> remains in code</i>
traceId :: Text -> Text

-- | <i>Warning: <a>traceIO</a> remains in code</i>
traceIO :: Print b => b -> a -> IO a

-- | <i>Warning: <a>traceShow</a> remains in code</i>
traceShow :: Show a => a -> b -> b

-- | <i>Warning: <a>traceShowId</a> remains in code</i>
traceShowId :: Show a => a -> a

-- | <i>Warning: <a>traceShowM</a> remains in code</i>
traceShowM :: (Show a, Monad m) => a -> m ()

-- | <i>Warning: <a>notImplemented</a> remains in code</i>
notImplemented :: a
witness :: a

module Protolude
(++) :: [a] -> [a] -> [a]
seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
fromIntegral :: (Integral a, Num b) => a -> b
realToFrac :: (Real a, Fractional b) => a -> b
class Bounded a
minBound :: Bounded a => a
maxBound :: Bounded a => a
class Enum a
succ :: Enum a => a -> a
pred :: Enum a => a -> a
toEnum :: Enum a => Int -> a
fromEnum :: Enum a => a -> Int
enumFrom :: Enum a => a -> [a]
enumFromThen :: Enum a => a -> a -> [a]
enumFromTo :: Enum a => a -> a -> [a]
enumFromThenTo :: Enum a => a -> a -> a -> [a]
class Fractional a => Floating a
pi :: Floating a => a
exp :: Floating a => a -> a
log :: Floating a => a -> a
sqrt :: Floating a => a -> a
(**) :: Floating a => a -> a -> a
logBase :: Floating a => a -> a -> a
sin :: Floating a => a -> a
cos :: Floating a => a -> a
tan :: Floating a => a -> a
asin :: Floating a => a -> a
acos :: Floating a => a -> a
atan :: Floating a => a -> a
sinh :: Floating a => a -> a
cosh :: Floating a => a -> a
tanh :: Floating a => a -> a
asinh :: Floating a => a -> a
acosh :: Floating a => a -> a
atanh :: Floating a => a -> a
log1p :: Floating a => a -> a
expm1 :: Floating a => a -> a
log1pexp :: Floating a => a -> a
log1mexp :: Floating a => a -> a
class Num a => Fractional a
(/) :: Fractional a => a -> a -> a
recip :: Fractional a => a -> a
fromRational :: Fractional a => Rational -> a
class (Real a, Enum a) => Integral a
quot :: Integral a => a -> a -> a
rem :: Integral a => a -> a -> a
div :: Integral a => a -> a -> a
mod :: Integral a => a -> a -> a
quotRem :: Integral a => a -> a -> (a, a)
divMod :: Integral a => a -> a -> (a, a)
toInteger :: Integral a => a -> Integer
class Num a
(+) :: Num a => a -> a -> a
(-) :: Num a => a -> a -> a
(*) :: Num a => a -> a -> a
negate :: Num a => a -> a
abs :: Num a => a -> a
signum :: Num a => a -> a
fromInteger :: Num a => Integer -> a
class (Num a, Ord a) => Real a
toRational :: Real a => a -> Rational
class (RealFrac a, Floating a) => RealFloat a
floatRadix :: RealFloat a => a -> Integer
floatDigits :: RealFloat a => a -> Int
floatRange :: RealFloat a => a -> (Int, Int)
decodeFloat :: RealFloat a => a -> (Integer, Int)
encodeFloat :: RealFloat a => Integer -> Int -> a
exponent :: RealFloat a => a -> Int
significand :: RealFloat a => a -> a
scaleFloat :: RealFloat a => Int -> a -> a
isNaN :: RealFloat a => a -> Bool
isInfinite :: RealFloat a => a -> Bool
isDenormalized :: RealFloat a => a -> Bool
isNegativeZero :: RealFloat a => a -> Bool
isIEEE :: RealFloat a => a -> Bool
atan2 :: RealFloat a => a -> a -> a
class (Real a, Fractional a) => RealFrac a
properFraction :: (RealFrac a, Integral b) => a -> (b, a)
truncate :: (RealFrac a, Integral b) => a -> b
round :: (RealFrac a, Integral b) => a -> b
ceiling :: (RealFrac a, Integral b) => a -> b
floor :: (RealFrac a, Integral b) => a -> b
class Show a
class KnownNat (n :: Nat)
class KnownSymbol (n :: Symbol)
class HasField (x :: k) r a | x r -> a
getField :: HasField x r a => r -> a
data Bool
data Char
data Double
D# :: Double# -> Double
data Float
F# :: Float# -> Float
data Int
data Integer
data Ordering
data Ratio a
type Rational = Ratio Integer
data IO a
data Word
data Ptr a
data FunPtr a
type Type = TYPE LiftedRep
data Constraint
class a ~R# b => Coercible (a :: k) (b :: k)
data StaticPtr a
data CallStack
data Symbol
type family CmpNat (a :: Natural) (b :: Natural) :: Ordering
(^) :: (Num a, Integral b) => a -> b -> a
divZeroError :: a
even :: Integral a => a -> Bool
overflowError :: a
numericEnumFromThenTo :: (Ord a, Fractional a) => a -> a -> a -> [a]
asTypeOf :: a -> a -> a
maxInt :: Int
minInt :: Int
ord :: Char -> Int
until :: (a -> Bool) -> (a -> a) -> a -> a
subtract :: Num a => a -> a -> a
boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
(%) :: Integral a => a -> a -> Ratio a
(^%^) :: Integral a => Rational -> a -> Rational
(^^) :: (Fractional a, Integral b) => a -> b -> a
(^^%^^) :: Integral a => Rational -> a -> Rational
denominator :: Ratio a -> a
gcd :: Integral a => a -> a -> a
infinity :: Rational
integralEnumFrom :: (Integral a, Bounded a) => a -> [a]
integralEnumFromThen :: (Integral a, Bounded a) => a -> a -> [a]
integralEnumFromThenTo :: Integral a => a -> a -> a -> [a]
integralEnumFromTo :: Integral a => a -> a -> [a]
lcm :: Integral a => a -> a -> a
notANumber :: Rational
numerator :: Ratio a -> a
numericEnumFrom :: Fractional a => a -> [a]
numericEnumFromThen :: Fractional a => a -> a -> [a]
numericEnumFromTo :: (Ord a, Fractional a) => a -> a -> [a]
odd :: Integral a => a -> Bool
ratioPrec :: Int
ratioPrec1 :: Int
ratioZeroDenominatorError :: a
reduce :: Integral a => a -> a -> Ratio a
underflowError :: a
getCallStack :: CallStack -> [([Char], SrcLoc)]
currentCallStack :: IO [String]
class IsLabel (x :: Symbol) a
fromLabel :: IsLabel x a => a
getStackTrace :: IO (Maybe [Location])
showStackTrace :: IO (Maybe String)
data Location
Location :: String -> String -> Maybe SrcLoc -> Location
[objectName] :: Location -> String
[functionName] :: Location -> String
[srcLoc] :: Location -> Maybe SrcLoc
data SrcLoc
SrcLoc :: String -> Int -> Int -> SrcLoc
prettyCallStack :: CallStack -> String
prettySrcLoc :: SrcLoc -> String
callStack :: HasCallStack => CallStack
withFrozenCallStack :: HasCallStack => (HasCallStack => a) -> a
type HasCallStack = ?callStack :: CallStack
natVal :: forall (n :: Nat) proxy. KnownNat n => proxy n -> Integer
someNatVal :: Integer -> Maybe SomeNat
someSymbolVal :: String -> SomeSymbol
symbolVal :: forall (n :: Symbol) proxy. KnownSymbol n => proxy n -> String
data SomeSymbol
SomeSymbol :: Proxy n -> SomeSymbol
type Nat = Natural
data SomeNat
SomeNat :: Proxy n -> SomeNat
($!) :: (a -> b) -> a -> b
infixr 0 $!

-- | The identity function, returns the give value unchanged.
identity :: a -> a

-- | Do nothing returning unit inside applicative.
pass :: Applicative f => f ()
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
const :: a -> b -> a
(&) :: a -> (a -> b) -> b
fix :: (a -> a) -> a
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
(.) :: (b -> c) -> (a -> b) -> a -> c
flip :: (a -> b -> c) -> b -> a -> c

-- | Apply a function n times to a given value
applyN :: Int -> (a -> a) -> a -> a
filter :: (a -> Bool) -> [a] -> [a]
zip :: [a] -> [b] -> [(a, b)]
data NonEmpty a
(:|) :: a -> [a] -> NonEmpty a
repeat :: a -> [a]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
takeWhile :: (a -> Bool) -> [a] -> [a]
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
transpose :: [[a]] -> [[a]]
genericDrop :: Integral i => i -> [a] -> [a]
genericLength :: Num i => [a] -> i
genericReplicate :: Integral i => i -> a -> [a]
genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
genericTake :: Integral i => i -> [a] -> [a]
group :: Eq a => [a] -> [[a]]
groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
inits :: [a] -> [[a]]
intercalate :: [a] -> [[a]] -> [a]
intersperse :: a -> [a] -> [a]
isInfixOf :: Eq a => [a] -> [a] -> Bool
isPrefixOf :: Eq a => [a] -> [a] -> Bool
isSuffixOf :: Eq a => [a] -> [a] -> Bool
permutations :: [a] -> [[a]]
sort :: Ord a => [a] -> [a]
subsequences :: [a] -> [[a]]
tails :: [a] -> [[a]]
unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
break :: (a -> Bool) -> [a] -> ([a], [a])
cycle :: [a] -> [a]
drop :: Int -> [a] -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
iterate :: (a -> a) -> a -> [a]
replicate :: Int -> a -> [a]
reverse :: [a] -> [a]
scanl :: (b -> a -> b) -> b -> [a] -> [b]
scanl' :: (b -> a -> b) -> b -> [a] -> [b]
scanr :: (a -> b -> b) -> b -> [a] -> [b]
splitAt :: Int -> [a] -> ([a], [a])
take :: Int -> [a] -> [a]
unzip :: [(a, b)] -> ([a], [b])
head :: Foldable f => f a -> Maybe a
sortOn :: Ord o => (a -> o) -> [a] -> [a]
ordNub :: Ord a => [a] -> [a]
list :: [b] -> (a -> b) -> [a] -> [b]
product :: (Foldable f, Num a) => f a -> a
sum :: (Foldable f, Num a) => f a -> a
nonEmpty :: [a] -> Maybe (NonEmpty a)
map :: Functor f => (a -> b) -> f a -> f b
uncons :: [a] -> Maybe (a, [a])
unsnoc :: [x] -> Maybe ([x], x)
data Set a
data Map k a
data Seq a
data IntMap a
data IntSet
show :: (Show a, StringConv String b) => a -> b

-- | The print function outputs a value of any printable type to the
--   standard output device. Printable types are those that are instances
--   of class Show; print converts values to strings for output using the
--   show operation and adds a newline.
print :: (MonadIO m, Show a) => a -> m ()
otherwise :: Bool
data Bool
False :: Bool
True :: Bool
(&&) :: Bool -> Bool -> Bool
not :: Bool -> Bool
(||) :: Bool -> Bool -> Bool
bool :: a -> a -> Bool -> a
whenM :: Monad m => m Bool -> m () -> m ()
unlessM :: Monad m => m Bool -> m () -> m ()
ifM :: Monad m => m Bool -> m a -> m a -> m a
guardM :: MonadPlus m => m Bool -> m ()

-- | The <a>||</a> operator lifted to a monad. If the first argument
--   evaluates to <a>True</a> the second argument will not be evaluated.
(||^) :: Monad m => m Bool -> m Bool -> m Bool
infixr 2 ||^

-- | <a>||</a> lifted to an Applicative. Unlike <a>||^</a> the operator is
--   <b>not</b> short-circuiting.
(<||>) :: Applicative a => a Bool -> a Bool -> a Bool
infixr 2 <||>

-- | The <a>&amp;&amp;</a> operator lifted to a monad. If the first
--   argument evaluates to <a>False</a> the second argument will not be
--   evaluated.
(&&^) :: Monad m => m Bool -> m Bool -> m Bool
infixr 3 &&^

-- | <a>&amp;&amp;</a> lifted to an Applicative. Unlike <a>&amp;&amp;^</a>
--   the operator is <b>not</b> short-circuiting.
(<&&>) :: Applicative a => a Bool -> a Bool -> a Bool
infixr 3 <&&>

-- | Lift an <a>IO</a> operation with 1 argument into another monad
liftIO1 :: MonadIO m => (a -> IO b) -> a -> m b

-- | Lift an <a>IO</a> operation with 2 arguments into another monad
liftIO2 :: MonadIO m => (a -> b -> IO c) -> a -> b -> m c
class Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b
(<$) :: Functor f => a -> f b -> f a
(<$>) :: Functor f => (a -> b) -> f a -> f b
($>) :: Functor f => f a -> b -> f b
(<&>) :: Functor f => f a -> (a -> b) -> f b
void :: Functor f => f a -> f ()
newtype Identity a
Identity :: a -> Identity a
[runIdentity] :: Identity a -> a
(<<$>>) :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
infixl 4 <<$>>
foreach :: Functor f => f a -> (a -> b) -> f b
data Either a b
Left :: a -> Either a b
Right :: b -> Either a b
either :: (a -> c) -> (b -> c) -> Either a b -> c
fromLeft :: a -> Either a b -> a
fromRight :: b -> Either a b -> b
isLeft :: Either a b -> Bool
isRight :: Either a b -> Bool
lefts :: [Either a b] -> [a]
partitionEithers :: [Either a b] -> ([a], [b])
rights :: [Either a b] -> [b]
leftToMaybe :: Either l r -> Maybe l
rightToMaybe :: Either l r -> Maybe r
maybeToRight :: l -> Maybe r -> Either l r
maybeToLeft :: r -> Maybe l -> Either l r
maybeEmpty :: Monoid b => (a -> b) -> Maybe a -> b
maybeToEither :: e -> Maybe a -> Either e a
class Functor f => Applicative (f :: Type -> Type)
pure :: Applicative f => a -> f a
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
(*>) :: Applicative f => f a -> f b -> f b
(<*) :: Applicative f => f a -> f b -> f a
optional :: Alternative f => f a -> f (Maybe a)
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
liftA :: Applicative f => (a -> b) -> f a -> f b
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
newtype ZipList a
ZipList :: [a] -> ZipList a
[getZipList] :: ZipList a -> [a]
newtype Const a (b :: k)
Const :: a -> Const a (b :: k)
[getConst] :: Const a (b :: k) -> a
class Applicative f => Alternative (f :: Type -> Type)
empty :: Alternative f => f a
(<|>) :: Alternative f => f a -> f a -> f a
some :: Alternative f => f a -> f [a]
many :: Alternative f => f a -> f [a]
orAlt :: (Alternative f, Monoid a) => f a -> f a
orEmpty :: Alternative f => Bool -> a -> f a
eitherA :: Alternative f => f a -> f b -> f (Either a b)
purer :: (Applicative f, Applicative g) => a -> f (g a)
liftAA2 :: (Applicative f, Applicative g) => (a -> b -> c) -> f (g a) -> f (g b) -> f (g c)
(<<*>>) :: (Applicative f, Applicative g) => f (g (a -> b)) -> f (g a) -> f (g b)
infixl 4 <<*>>
guarded :: Alternative f => (a -> Bool) -> a -> f a
guardedA :: (Functor f, Alternative t) => (a -> f Bool) -> a -> f (t a)
data SomeException
SomeException :: e -> SomeException
ioError :: IOError -> IO a
data IOException
data ErrorCall
ErrorCallWithLocation :: String -> String -> ErrorCall
pattern ErrorCall :: String -> ErrorCall
data ArithException
Overflow :: ArithException
Underflow :: ArithException
LossOfPrecision :: ArithException
DivideByZero :: ArithException
Denormal :: ArithException
RatioZeroDenominator :: ArithException
class (Typeable e, Show e) => Exception e
toException :: Exception e => e -> SomeException
fromException :: Exception e => SomeException -> Maybe e
displayException :: Exception e => e -> String
allowInterrupt :: IO ()
catches :: IO a -> [Handler a] -> IO a
bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracketOnError :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket_ :: IO a -> IO b -> IO c -> IO c
catchJust :: Exception e => (e -> Maybe b) -> IO a -> (b -> IO a) -> IO a
finally :: IO a -> IO b -> IO a
handle :: Exception e => (e -> IO a) -> IO a -> IO a
handleJust :: Exception e => (e -> Maybe b) -> (b -> IO a) -> IO a -> IO a
mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
onException :: IO a -> IO b -> IO a
try :: Exception e => IO a -> IO (Either e a)
tryJust :: Exception e => (e -> Maybe b) -> IO a -> IO (Either b a)
catch :: Exception e => IO a -> (e -> IO a) -> IO a
evaluate :: a -> IO a
getMaskingState :: IO MaskingState
interruptible :: IO a -> IO a
mask :: ((forall a. () => IO a -> IO a) -> IO b) -> IO b
mask_ :: IO a -> IO a
uninterruptibleMask :: ((forall a. () => IO a -> IO a) -> IO b) -> IO b
uninterruptibleMask_ :: IO a -> IO a
asyncExceptionFromException :: Exception e => SomeException -> Maybe e
asyncExceptionToException :: Exception e => e -> SomeException
data Handler a
Handler :: (e -> IO a) -> Handler a
data NestedAtomically
NestedAtomically :: NestedAtomically
newtype NoMethodError
NoMethodError :: String -> NoMethodError
data NonTermination
NonTermination :: NonTermination
newtype PatternMatchFail
PatternMatchFail :: String -> PatternMatchFail
newtype RecConError
RecConError :: String -> RecConError
newtype RecSelError
RecSelError :: String -> RecSelError
newtype RecUpdError
RecUpdError :: String -> RecUpdError
newtype TypeError
TypeError :: String -> TypeError
data MaskingState
Unmasked :: MaskingState
MaskedInterruptible :: MaskingState
MaskedUninterruptible :: MaskingState
data AllocationLimitExceeded
AllocationLimitExceeded :: AllocationLimitExceeded
data ArrayException
IndexOutOfBounds :: String -> ArrayException
UndefinedElement :: String -> ArrayException
newtype AssertionFailed
AssertionFailed :: String -> AssertionFailed
data AsyncException
StackOverflow :: AsyncException
HeapOverflow :: AsyncException
ThreadKilled :: AsyncException
UserInterrupt :: AsyncException
data BlockedIndefinitelyOnMVar
BlockedIndefinitelyOnMVar :: BlockedIndefinitelyOnMVar
data BlockedIndefinitelyOnSTM
BlockedIndefinitelyOnSTM :: BlockedIndefinitelyOnSTM
newtype CompactionFailed
CompactionFailed :: String -> CompactionFailed
data Deadlock
Deadlock :: Deadlock
data SomeAsyncException
SomeAsyncException :: e -> SomeAsyncException
hush :: Alternative m => Either e a -> m a
note :: MonadError e m => e -> Maybe a -> m a
tryIO :: MonadIO m => IO a -> ExceptT IOException m a

-- | Lifted throwIO
throwIO :: (MonadIO m, Exception e) => e -> m a

-- | Lifted throwTo
throwTo :: (MonadIO m, Exception e) => ThreadId -> e -> m ()
class IsString a
headMay :: [a] -> Maybe a
headDef :: a -> [a] -> a
initMay :: [a] -> Maybe [a]
initDef :: [a] -> [a] -> [a]
initSafe :: [a] -> [a]
tailMay :: [a] -> Maybe [a]
tailDef :: [a] -> [a] -> [a]
tailSafe :: [a] -> [a]
lastMay :: [a] -> Maybe a
lastDef :: a -> [a] -> a
minimumMay :: Ord a => [a] -> Maybe a
maximumMay :: Ord a => [a] -> Maybe a
minimumDef :: Ord a => a -> [a] -> a
maximumDef :: Ord a => a -> [a] -> a
foldr1May :: (a -> a -> a) -> [a] -> Maybe a
foldl1May :: (a -> a -> a) -> [a] -> Maybe a
foldl1May' :: (a -> a -> a) -> [a] -> Maybe a
atMay :: [a] -> Int -> Maybe a
atDef :: a -> [a] -> Int -> a
class Eq a
(==) :: Eq a => a -> a -> Bool
(/=) :: Eq a => a -> a -> Bool
class Eq a => Ord a
compare :: Ord a => a -> a -> Ordering
(<) :: Ord a => a -> a -> Bool
(<=) :: Ord a => a -> a -> Bool
(>) :: Ord a => a -> a -> Bool
(>=) :: Ord a => a -> a -> Bool
max :: Ord a => a -> a -> a
min :: Ord a => a -> a -> a
data Ordering
LT :: Ordering
EQ :: Ordering
GT :: Ordering
newtype Down a
Down :: a -> Down a
comparing :: Ord a => (b -> a) -> b -> b -> Ordering
class Foldable (t :: TYPE LiftedRep -> Type)
fold :: (Foldable t, Monoid m) => t m -> m
foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
toList :: Foldable t => t a -> [a]
null :: Foldable t => t a -> Bool
length :: Foldable t => t a -> Int
elem :: (Foldable t, Eq a) => a -> t a -> Bool
maximum :: (Foldable t, Ord a) => t a -> a
minimum :: (Foldable t, Ord a) => t a -> a
asum :: (Foldable t, Alternative f) => t (f a) -> f a
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
all :: Foldable t => (a -> Bool) -> t a -> Bool
and :: Foldable t => t Bool -> Bool
any :: Foldable t => (a -> Bool) -> t a -> Bool
concat :: Foldable t => t [a] -> [a]
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
find :: Foldable t => (a -> Bool) -> t a -> Maybe a
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
or :: Foldable t => t Bool -> Bool
sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
class Semigroup a
sconcat :: Semigroup a => NonEmpty a -> a
stimes :: (Semigroup a, Integral b) => b -> a -> a
stimesIdempotent :: Integral b => b -> a -> a
stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
cycle1 :: Semigroup m => m -> m
diff :: Semigroup m => m -> Endo m
mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
data WrappedMonoid m
class Bifunctor (p :: Type -> Type -> Type)
bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
first :: Bifunctor p => (a -> b) -> p a c -> p b c
second :: Bifunctor p => (b -> c) -> p a b -> p a c
hashUsing :: Hashable b => (a -> b) -> Int -> a -> Int
class Eq a => Hashable a
hashWithSalt :: Hashable a => Int -> a -> Int
hash :: Hashable a => a -> Int
class NFData a
rnf :: NFData a => a -> ()
($!!) :: NFData a => (a -> b) -> a -> b
deepseq :: NFData a => a -> b -> b
force :: NFData a => a -> a
fst :: (a, b) -> a
snd :: (a, b) -> b
uncurry :: (a -> b -> c) -> (a, b) -> c
curry :: ((a, b) -> c) -> a -> b -> c
swap :: (a, b) -> (b, a)
class Typeable (a :: k)
cast :: (Typeable a, Typeable b) => a -> Maybe b
eqT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => Maybe (a :~: b)
gcast :: forall {k} (a :: k) (b :: k) c. (Typeable a, Typeable b) => c a -> Maybe (c b)
typeOf :: Typeable a => a -> TypeRep
typeRep :: forall {k} proxy (a :: k). Typeable a => proxy a -> TypeRep
type TypeRep = SomeTypeRep
data Proxy (t :: k)
Proxy :: Proxy (t :: k)
data (a :: k) :~: (b :: k)
[Refl] :: forall {k} (a :: k). a :~: a
castWith :: (a :~: b) -> a -> b
gcastWith :: forall {k} (a :: k) (b :: k) r. (a :~: b) -> (a ~ b => r) -> r
sym :: forall {k} (a :: k) (b :: k). (a :~: b) -> b :~: a
trans :: forall {k} (a :: k) (b :: k) (c :: k). (a :~: b) -> (b :~: c) -> a :~: c
type family (a :: k) == (b :: k) :: Bool
data Void
absurd :: Void -> a
coerceWith :: Coercion a b -> a -> b
repr :: forall {k} (a :: k) (b :: k). (a :~: b) -> Coercion a b
data Coercion (a :: k) (b :: k)
[Coercion] :: forall {k} (a :: k) (b :: k). Coercible a b => Coercion a b
vacuous :: Functor f => f Void -> f a
class Monad m => MonadFail (m :: Type -> Type)
newtype StateT s (m :: Type -> Type) a
StateT :: (s -> m (a, s)) -> StateT s (m :: Type -> Type) a
[runStateT] :: StateT s (m :: Type -> Type) a -> s -> m (a, s)
evalState :: State s a -> s -> a
evalStateT :: Monad m => StateT s m a -> s -> m a
execState :: State s a -> s -> s
execStateT :: Monad m => StateT s m a -> s -> m s
runState :: State s a -> s -> (a, s)
withState :: (s -> s) -> State s a -> State s a
type State s = StateT s Identity
gets :: MonadState s m => (s -> a) -> m a
modify :: MonadState s m => (s -> s) -> m ()
class Monad m => MonadState s (m :: Type -> Type) | m -> s
get :: MonadState s m => m s
put :: MonadState s m => s -> m ()
state :: MonadState s m => (s -> (a, s)) -> m a
newtype ReaderT r (m :: Type -> Type) a
ReaderT :: (r -> m a) -> ReaderT r (m :: Type -> Type) a
[runReaderT] :: ReaderT r (m :: Type -> Type) a -> r -> m a
runReader :: Reader r a -> r -> a
type Reader r = ReaderT r Identity
asks :: MonadReader r m => (r -> a) -> m a
class Monad m => MonadReader r (m :: Type -> Type) | m -> r
ask :: MonadReader r m => m r
local :: MonadReader r m => (r -> r) -> m a -> m a
reader :: MonadReader r m => (r -> a) -> m a
mapExcept :: (Either e a -> Either e' b) -> Except e a -> Except e' b
mapExceptT :: (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b
runExcept :: Except e a -> Either e a
runExceptT :: ExceptT e m a -> m (Either e a)
withExcept :: (e -> e') -> Except e a -> Except e' a
withExceptT :: forall (m :: Type -> Type) e e' a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a
class Monad m => MonadError e (m :: Type -> Type) | m -> e
throwError :: MonadError e m => e -> m a
catchError :: MonadError e m => m a -> (e -> m a) -> m a
type Except e = ExceptT e Identity
newtype ExceptT e (m :: Type -> Type) a
ExceptT :: m (Either e a) -> ExceptT e (m :: Type -> Type) a
catchE :: forall (m :: Type -> Type) e a e'. Monad m => ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a
throwE :: forall (m :: Type -> Type) e a. Monad m => e -> ExceptT e m a
class Monad m => MonadIO (m :: Type -> Type)
liftIO :: MonadIO m => IO a -> m a
lift :: (MonadTrans t, Monad m) => m a -> t m a
data ST s a
fixST :: (a -> ST s a) -> ST s a
runST :: (forall s. () => ST s a) -> a
atomically :: STM a -> IO a
catchSTM :: Exception e => STM a -> (e -> STM a) -> STM a
orElse :: STM a -> STM a -> STM a
retry :: STM a
throwSTM :: Exception e => e -> STM a
check :: Bool -> STM ()
data STM a
data Int
data Int8
data Int16
data Int32
data Int64
data Word
data Word8
data Word16
data Word32
data Word64
class Eq a => Bits a
(.&.) :: Bits a => a -> a -> a
(.|.) :: Bits a => a -> a -> a
xor :: Bits a => a -> a -> a
complement :: Bits a => a -> a
shift :: Bits a => a -> Int -> a
rotate :: Bits a => a -> Int -> a
zeroBits :: Bits a => a
bit :: Bits a => Int -> a
setBit :: Bits a => a -> Int -> a
clearBit :: Bits a => a -> Int -> a
complementBit :: Bits a => a -> Int -> a
testBit :: Bits a => a -> Int -> Bool
bitSizeMaybe :: Bits a => a -> Maybe Int
bitSize :: Bits a => a -> Int
isSigned :: Bits a => a -> Bool
shiftL :: Bits a => a -> Int -> a
shiftR :: Bits a => a -> Int -> a
rotateL :: Bits a => a -> Int -> a
rotateR :: Bits a => a -> Int -> a
popCount :: Bits a => a -> Int
class Bits b => FiniteBits b
finiteBitSize :: FiniteBits b => b -> Int
countLeadingZeros :: FiniteBits b => b -> Int
countTrailingZeros :: FiniteBits b => b -> Int
byteSwap16 :: Word16 -> Word16
byteSwap32 :: Word32 -> Word32
byteSwap64 :: Word64 -> Word64
bitDefault :: (Bits a, Num a) => Int -> a
popCountDefault :: (Bits a, Num a) => a -> Int
testBitDefault :: (Bits a, Num a) => a -> Int -> Bool
toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
cis :: Floating a => a -> Complex a
conjugate :: Num a => Complex a -> Complex a
imagPart :: Complex a -> a
magnitude :: RealFloat a => Complex a -> a
mkPolar :: Floating a => a -> a -> Complex a
phase :: RealFloat a => Complex a -> a
polar :: RealFloat a => Complex a -> (a, a)
realPart :: Complex a -> a
data Complex a
(:+) :: !a -> !a -> Complex a
data Char
ord :: Char -> Int
chr :: Int -> Char
intToDigit :: Int -> Char
isSpace :: Char -> Bool
isDigit :: Char -> Bool
digitToInt :: Char -> Int
isLetter :: Char -> Bool
isAlpha :: Char -> Bool
isAlphaNum :: Char -> Bool
isAscii :: Char -> Bool
isControl :: Char -> Bool
isHexDigit :: Char -> Bool
isLower :: Char -> Bool
isPrint :: Char -> Bool
isUpper :: Char -> Bool
toLower :: Char -> Char
toTitle :: Char -> Char
toUpper :: Char -> Char
data Maybe a
Nothing :: Maybe a
Just :: a -> Maybe a
catMaybes :: [Maybe a] -> [a]
fromMaybe :: a -> Maybe a -> a
isJust :: Maybe a -> Bool
isNothing :: Maybe a -> Bool
listToMaybe :: [a] -> Maybe a
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
maybe :: b -> (a -> b) -> Maybe a -> b
maybeToList :: Maybe a -> [a]
class Generic a where {
    type family Rep a :: Type -> Type;
}
from :: Generic a => a -> Rep a x
to :: Generic a => Rep a x -> a
class Generic1 (f :: k -> Type)
class Datatype (d :: k)
datatypeName :: forall k1 t (f :: k1 -> Type) (a :: k1). Datatype d => t d f a -> [Char]
moduleName :: forall k1 t (f :: k1 -> Type) (a :: k1). Datatype d => t d f a -> [Char]
packageName :: forall k1 t (f :: k1 -> Type) (a :: k1). Datatype d => t d f a -> [Char]
isNewtype :: forall k1 t (f :: k1 -> Type) (a :: k1). Datatype d => t d f a -> Bool
class Constructor (c :: k)
conName :: forall k1 t (f :: k1 -> Type) (a :: k1). Constructor c => t c f a -> [Char]
conFixity :: forall k1 t (f :: k1 -> Type) (a :: k1). Constructor c => t c f a -> Fixity
conIsRecord :: forall k1 t (f :: k1 -> Type) (a :: k1). Constructor c => t c f a -> Bool
class Selector (s :: k)
selName :: forall k1 t (f :: k1 -> Type) (a :: k1). Selector s => t s f a -> [Char]
selSourceUnpackedness :: forall k1 t (f :: k1 -> Type) (a :: k1). Selector s => t s f a -> SourceUnpackedness
selSourceStrictness :: forall k1 t (f :: k1 -> Type) (a :: k1). Selector s => t s f a -> SourceStrictness
selDecidedStrictness :: forall k1 t (f :: k1 -> Type) (a :: k1). Selector s => t s f a -> DecidedStrictness
data V1 (p :: k)
data U1 (p :: k)
U1 :: U1 (p :: k)
newtype K1 i c (p :: k)
K1 :: c -> K1 i c (p :: k)
[unK1] :: K1 i c (p :: k) -> c
newtype M1 i (c :: Meta) (f :: k -> Type) (p :: k)
M1 :: f p -> M1 i (c :: Meta) (f :: k -> Type) (p :: k)
[unM1] :: M1 i (c :: Meta) (f :: k -> Type) (p :: k) -> f p
data ( (f :: k -> Type) :+: (g :: k -> Type) ) (p :: k)
L1 :: f p -> (:+:) (f :: k -> Type) (g :: k -> Type) (p :: k)
R1 :: g p -> (:+:) (f :: k -> Type) (g :: k -> Type) (p :: k)
data ( (f :: k -> Type) :*: (g :: k -> Type) ) (p :: k)
(:*:) :: f p -> g p -> (:*:) (f :: k -> Type) (g :: k -> Type) (p :: k)
newtype ( (f :: k2 -> Type) :.: (g :: k1 -> k2) ) (p :: k1)
Comp1 :: f (g p) -> (:.:) (f :: k2 -> Type) (g :: k1 -> k2) (p :: k1)
[unComp1] :: (:.:) (f :: k2 -> Type) (g :: k1 -> k2) (p :: k1) -> f (g p)
type Rec0 = K1 R :: Type -> k -> Type
type D1 = M1 D :: Meta -> k -> Type -> k -> Type
type C1 = M1 C :: Meta -> k -> Type -> k -> Type
type S1 = M1 S :: Meta -> k -> Type -> k -> Type
type family Rep a :: Type -> Type
data family URec a (p :: k)
data Meta
MetaData :: Symbol -> Symbol -> Symbol -> Bool -> Meta
MetaCons :: Symbol -> FixityI -> Bool -> Meta
MetaSel :: Maybe Symbol -> SourceUnpackedness -> SourceStrictness -> DecidedStrictness -> Meta
data Associativity
LeftAssociative :: Associativity
RightAssociative :: Associativity
NotAssociative :: Associativity
data Fixity
Prefix :: Fixity
Infix :: Associativity -> Int -> Fixity
data FixityI
PrefixI :: FixityI
InfixI :: Associativity -> Nat -> FixityI
data ByteString
type LByteString = ByteString
lines :: Text -> [Text]
unlines :: [Text] -> Text
unwords :: [Text] -> Text
words :: Text -> [Text]
data Text
data UnicodeException
strictDecode :: OnDecodeError
decodeUtf8 :: ByteString -> Text
decodeUtf8' :: ByteString -> Either UnicodeException Text
decodeUtf8With :: OnDecodeError -> ByteString -> Text
encodeUtf8 :: Text -> ByteString
type OnDecodeError = OnError Word8 Char
ignore :: OnError a b
lenientDecode :: OnDecodeError
replace :: b -> OnError a b
type OnError a b = String -> Maybe a -> Maybe b
fromStrict :: Text -> Text
toStrict :: Text -> Text
appendFile :: FilePath -> Text -> IO ()
getContents :: IO Text
getLine :: IO Text
interact :: (Text -> Text) -> IO ()
readFile :: FilePath -> IO Text
writeFile :: FilePath -> Text -> IO ()
type LText = Text
class Read a
reads :: Read a => ReadS a

-- | Parse a string using the <a>Read</a> instance. Succeeds if there is
--   exactly one valid result.
--   
--   <pre>
--   &gt;&gt;&gt; readMaybe ("123" :: Text) :: Maybe Int
--   Just 123
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; readMaybe ("hello" :: Text) :: Maybe Int
--   Nothing
--   </pre>
readMaybe :: (Read b, StringConv a String) => a -> Maybe b

-- | Parse a string using the <a>Read</a> instance. Succeeds if there is
--   exactly one valid result. A <a>Left</a> value indicates a parse error.
--   
--   <pre>
--   &gt;&gt;&gt; readEither "123" :: Either Text Int
--   Right 123
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; readEither "hello" :: Either Text Int
--   Left "Prelude.read: no parse"
--   </pre>
readEither :: (Read a, StringConv String e, StringConv e String) => e -> Either e a
openFile :: FilePath -> IOMode -> IO Handle
stderr :: Handle
stdin :: Handle
stdout :: Handle
withFile :: FilePath -> IOMode -> (Handle -> IO r) -> IO r
type FilePath = String
data Handle
data IOMode
ReadMode :: IOMode
WriteMode :: IOMode
AppendMode :: IOMode
ReadWriteMode :: IOMode
data ExitCode
ExitSuccess :: ExitCode
ExitFailure :: Int -> ExitCode
getArgs :: IO [String]
exitFailure :: IO a
exitSuccess :: IO a
exitWith :: ExitCode -> IO a

-- | Terminate main process with failure
die :: Text -> IO a
data MVar a
data ThreadId
addMVarFinalizer :: MVar a -> IO () -> IO ()
mkWeakMVar :: MVar a -> IO () -> IO (Weak (MVar a))
modifyMVar :: MVar a -> (a -> IO (a, b)) -> IO b
modifyMVarMasked :: MVar a -> (a -> IO (a, b)) -> IO b
modifyMVarMasked_ :: MVar a -> (a -> IO a) -> IO ()
modifyMVar_ :: MVar a -> (a -> IO a) -> IO ()
swapMVar :: MVar a -> a -> IO a
withMVar :: MVar a -> (a -> IO b) -> IO b
withMVarMasked :: MVar a -> (a -> IO b) -> IO b
isEmptyMVar :: MVar a -> IO Bool
newEmptyMVar :: IO (MVar a)
newMVar :: a -> IO (MVar a)
putMVar :: MVar a -> a -> IO ()
readMVar :: MVar a -> IO a
takeMVar :: MVar a -> IO a
tryPutMVar :: MVar a -> a -> IO Bool
tryReadMVar :: MVar a -> IO (Maybe a)
tryTakeMVar :: MVar a -> IO (Maybe a)
dupChan :: Chan a -> IO (Chan a)
getChanContents :: Chan a -> IO [a]
newChan :: IO (Chan a)
readChan :: Chan a -> IO a
writeChan :: Chan a -> a -> IO ()
writeList2Chan :: Chan a -> [a] -> IO ()
data Chan a
newQSem :: Int -> IO QSem
signalQSem :: QSem -> IO ()
waitQSem :: QSem -> IO ()
data QSem
newQSemN :: Int -> IO QSemN
signalQSemN :: QSemN -> Int -> IO ()
waitQSemN :: QSemN -> Int -> IO ()
data QSemN
forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
forkOS :: IO () -> IO ThreadId
forkOSWithUnmask :: ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
isCurrentThreadBound :: IO Bool
rtsSupportsBoundThreads :: Bool
runInBoundThread :: IO a -> IO a
runInUnboundThread :: IO a -> IO a
threadWaitRead :: Fd -> IO ()
threadWaitReadSTM :: Fd -> IO (STM (), IO ())
threadWaitWrite :: Fd -> IO ()
threadWaitWriteSTM :: Fd -> IO (STM (), IO ())
threadDelay :: Int -> IO ()
forkIO :: IO () -> IO ThreadId
forkIOWithUnmask :: ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
forkOn :: Int -> IO () -> IO ThreadId
forkOnWithUnmask :: Int -> ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
getNumCapabilities :: IO Int
killThread :: ThreadId -> IO ()
mkWeakThreadId :: ThreadId -> IO (Weak ThreadId)
myThreadId :: IO ThreadId
setNumCapabilities :: Int -> IO ()
threadCapability :: ThreadId -> IO (Int, Bool)
yield :: IO ()
async :: IO a -> IO (Async a)
asyncBound :: IO a -> IO (Async a)
asyncOn :: Int -> IO a -> IO (Async a)
cancel :: Async a -> IO ()
cancelWith :: Exception e => Async a -> e -> IO ()
concurrently :: IO a -> IO b -> IO (a, b)
link :: Async a -> IO ()
link2 :: Async a -> Async b -> IO ()
poll :: Async a -> IO (Maybe (Either SomeException a))
race :: IO a -> IO b -> IO (Either a b)
race_ :: IO a -> IO b -> IO ()
wait :: Async a -> IO a
waitAny :: [Async a] -> IO (Async a, a)
waitAnyCancel :: [Async a] -> IO (Async a, a)
waitAnyCatch :: [Async a] -> IO (Async a, Either SomeException a)
waitAnyCatchCancel :: [Async a] -> IO (Async a, Either SomeException a)
waitBoth :: Async a -> Async b -> IO (a, b)
waitCatch :: Async a -> IO (Either SomeException a)
waitEither :: Async a -> Async b -> IO (Either a b)
waitEitherCancel :: Async a -> Async b -> IO (Either a b)
waitEitherCatch :: Async a -> Async b -> IO (Either (Either SomeException a) (Either SomeException b))
waitEitherCatchCancel :: Async a -> Async b -> IO (Either (Either SomeException a) (Either SomeException b))
waitEither_ :: Async a -> Async b -> IO ()
withAsync :: IO a -> (Async a -> IO b) -> IO b
withAsyncBound :: IO a -> (Async a -> IO b) -> IO b
withAsyncOn :: Int -> IO a -> (Async a -> IO b) -> IO b
data Async a
newtype Concurrently a
Concurrently :: IO a -> Concurrently a
[runConcurrently] :: Concurrently a -> IO a
data StablePtr a
class Storable a
data IntPtr
data WordPtr

module Protolude.Unsafe
unsafeHead :: HasCallStack => [a] -> a
unsafeTail :: HasCallStack => [a] -> [a]
unsafeInit :: HasCallStack => [a] -> [a]
unsafeLast :: HasCallStack => [a] -> a
unsafeFromJust :: HasCallStack => Maybe a -> a
unsafeIndex :: HasCallStack => [a] -> Int -> a
unsafeThrow :: Exception e => e -> a
unsafeRead :: (HasCallStack, Read a) => [Char] -> a
