-- 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.5

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
class Show a
showsPrec :: Show a => Int -> a -> ShowS
show :: Show a => a -> String
showList :: Show a => [a] -> ShowS
print :: Show a => a -> IO ()
data Bool
data Int
data Char
putStr :: String -> IO ()
putStrLn :: String -> IO ()
showFloat :: RealFloat a => a -> ShowS
showSigned :: Real a => (a -> ShowS) -> Int -> a -> ShowS
showSignedFloat :: RealFloat a => (a -> ShowS) -> Int -> a -> ShowS
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
data Ordering
data Word
ord :: Char -> Int
data IO a
data Ptr a
data Integer
subtract :: Num a => a -> 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 Bounded a
minBound :: Bounded a => a
maxBound :: Bounded a => a
boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
class (Num a, Ord a) => Real a
toRational :: Real a => a -> Rational
(%) :: Integral a => a -> a -> Ratio 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
data Ratio a
type Rational = Ratio Integer
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
(^) :: (Num a, Integral b) => a -> b -> a
(^%^) :: Integral a => Rational -> a -> Rational
(^^) :: (Fractional a, Integral b) => a -> b -> a
(^^%^^) :: Integral a => Rational -> a -> Rational
denominator :: Ratio a -> a
divZeroError :: a
even :: Integral a => a -> Bool
fromIntegral :: (Integral a, Num b) => a -> b
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]
numericEnumFromThenTo :: (Ord a, Fractional a) => a -> a -> a -> [a]
numericEnumFromTo :: (Ord a, Fractional a) => a -> a -> [a]
odd :: Integral a => a -> Bool
overflowError :: a
ratioPrec :: Int
ratioPrec1 :: Int
ratioZeroDenominatorError :: a
realToFrac :: (Real a, Fractional b) => a -> b
reduce :: Integral a => a -> a -> Ratio a
underflowError :: a
data Float
F# :: Float# -> Float
data Double
D# :: Double# -> Double
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 (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
type Constraint = CONSTRAINT LiftedRep
data FunPtr a
(++) :: [a] -> [a] -> [a]
seq :: a -> b -> b
asTypeOf :: a -> a -> a
maxInt :: Int
minInt :: Int
until :: (a -> Bool) -> (a -> a) -> a -> a
class a ~R# b => Coercible (a :: k) (b :: k)
data StaticPtr a
class IsLabel (x :: Symbol) a
fromLabel :: IsLabel x a => a
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
getStackTrace :: IO (Maybe [Location])
showStackTrace :: IO (Maybe String)
data CallStack
type HasCallStack = ?callStack :: CallStack
callStack :: HasCallStack => CallStack
prettySrcLoc :: SrcLoc -> String
currentCallStack :: IO [String]
getCallStack :: CallStack -> [([Char], SrcLoc)]
prettyCallStack :: CallStack -> String
withFrozenCallStack :: HasCallStack => (HasCallStack => a) -> a
data Symbol
data SomeSymbol
SomeSymbol :: Proxy n -> SomeSymbol
type Nat = Natural
data SomeNat
SomeNat :: Proxy n -> SomeNat
type family CmpNat (a :: Natural) (b :: Natural) :: Ordering
class KnownSymbol (n :: Symbol)
class KnownNat (n :: Nat)
natVal :: forall (n :: Nat) proxy. KnownNat n => proxy n -> Integer
someNatVal :: Integer -> Maybe SomeNat
symbolVal :: forall (n :: Symbol) proxy. KnownSymbol n => proxy n -> String
someSymbolVal :: String -> SomeSymbol
class HasField (x :: k) r a | x r -> a
getField :: HasField x r a => r -> a
type Type = TYPE LiftedRep
($!) :: (a -> b) -> a -> b
infixr 0 $!

module Protolude.Bifunctor
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
instance Protolude.Bifunctor.Bifunctor GHC.Internal.Data.Functor.Const.Const
instance Protolude.Bifunctor.Bifunctor GHC.Internal.Data.Either.Either
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)

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.Internal.Enum.Bounded Protolude.Conv.Leniency
instance GHC.Internal.Enum.Enum Protolude.Conv.Leniency
instance GHC.Classes.Eq Protolude.Conv.Leniency
instance GHC.Classes.Ord Protolude.Conv.Leniency
instance GHC.Internal.Show.Show Protolude.Conv.Leniency
instance Protolude.Conv.StringConv Data.ByteString.Lazy.Internal.ByteString Data.ByteString.Lazy.Internal.ByteString
instance Protolude.Conv.StringConv Data.ByteString.Lazy.Internal.ByteString Data.ByteString.Internal.Type.ByteString
instance Protolude.Conv.StringConv Data.ByteString.Lazy.Internal.ByteString GHC.Internal.Base.String
instance Protolude.Conv.StringConv Data.ByteString.Lazy.Internal.ByteString Data.Text.Internal.Lazy.Text
instance Protolude.Conv.StringConv Data.ByteString.Lazy.Internal.ByteString Data.Text.Internal.Text
instance Protolude.Conv.StringConv Data.ByteString.Internal.Type.ByteString Data.ByteString.Lazy.Internal.ByteString
instance Protolude.Conv.StringConv Data.ByteString.Internal.Type.ByteString Data.ByteString.Internal.Type.ByteString
instance Protolude.Conv.StringConv Data.ByteString.Internal.Type.ByteString GHC.Internal.Base.String
instance Protolude.Conv.StringConv Data.ByteString.Internal.Type.ByteString Data.Text.Internal.Lazy.Text
instance Protolude.Conv.StringConv Data.ByteString.Internal.Type.ByteString Data.Text.Internal.Text
instance Protolude.Conv.StringConv GHC.Internal.Base.String Data.ByteString.Lazy.Internal.ByteString
instance Protolude.Conv.StringConv GHC.Internal.Base.String Data.ByteString.Internal.Type.ByteString
instance Protolude.Conv.StringConv GHC.Internal.Base.String GHC.Internal.Base.String
instance Protolude.Conv.StringConv GHC.Internal.Base.String Data.Text.Internal.Lazy.Text
instance Protolude.Conv.StringConv GHC.Internal.Base.String Data.Text.Internal.Text
instance Protolude.Conv.StringConv Data.Text.Internal.Lazy.Text Data.ByteString.Internal.Type.ByteString
instance Protolude.Conv.StringConv Data.Text.Internal.Lazy.Text Data.ByteString.Lazy.Internal.ByteString
instance Protolude.Conv.StringConv Data.Text.Internal.Lazy.Text GHC.Internal.Base.String
instance Protolude.Conv.StringConv Data.Text.Internal.Lazy.Text Data.Text.Internal.Lazy.Text
instance Protolude.Conv.StringConv Data.Text.Internal.Lazy.Text Data.Text.Internal.Text
instance Protolude.Conv.StringConv Data.Text.Internal.Text Data.ByteString.Lazy.Internal.ByteString
instance Protolude.Conv.StringConv Data.Text.Internal.Text Data.ByteString.Internal.Type.ByteString
instance Protolude.Conv.StringConv Data.Text.Internal.Text GHC.Internal.Base.String
instance Protolude.Conv.StringConv Data.Text.Internal.Text Data.Text.Internal.Text
instance Protolude.Conv.StringConv Data.Text.Internal.Text Data.Text.Internal.Lazy.Text


-- | 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 Data.ByteString.Internal.Type.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.Lazy.Internal.ByteString Data.ByteString.Lazy.Internal.ByteString
instance Protolude.ConvertText.ConvertText Data.ByteString.Lazy.Internal.ByteString Data.ByteString.Internal.Type.ByteString
instance Protolude.ConvertText.ConvertText GHC.Internal.Base.String GHC.Internal.Base.String
instance Protolude.ConvertText.ConvertText GHC.Internal.Base.String Data.Text.Internal.Lazy.Text
instance Protolude.ConvertText.ConvertText GHC.Internal.Base.String Data.Text.Internal.Text
instance Protolude.ConvertText.ConvertText Data.Text.Internal.Lazy.Text GHC.Internal.Base.String
instance Protolude.ConvertText.ConvertText Data.Text.Internal.Lazy.Text Data.Text.Internal.Lazy.Text
instance Protolude.ConvertText.ConvertText Data.Text.Internal.Lazy.Text Data.Text.Internal.Text
instance Protolude.ConvertText.ConvertText Data.Text.Internal.Text GHC.Internal.Base.String
instance Protolude.ConvertText.ConvertText Data.Text.Internal.Text Data.Text.Internal.Text
instance Protolude.ConvertText.ConvertText Data.Text.Internal.Text Data.Text.Internal.Lazy.Text

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 :: HasCallStack => Text -> a

module Protolude.Exceptions
hush :: Alternative m => Either e a -> m a
note :: MonadError e m => e -> Maybe a -> m a
tryIO :: forall (m :: Type -> Type) a. 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.Internal.Exception.Type.Exception Protolude.Panic.FatalError
instance GHC.Internal.Show.Show Protolude.Panic.FatalError

module Protolude.Partial
head :: HasCallStack => [a] -> a
init :: HasCallStack => [a] -> [a]
tail :: HasCallStack => [a] -> [a]
last :: HasCallStack => [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 :: HasCallStack => [a] -> [a]
maximum :: (Foldable t, Ord a) => t a -> a
minimum :: (Foldable t, Ord a) => t a -> a
(!!) :: HasCallStack => [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.ByteString.Lazy.Internal.ByteString
instance Protolude.Show.Print Data.ByteString.Internal.Type.ByteString
instance Protolude.Show.Print [GHC.Types.Char]
instance Protolude.Show.Print Data.Text.Internal.Lazy.Text
instance Protolude.Show.Print Data.Text.Internal.Text

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
class Show a
data Bool
data Int
data Char
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
data Ordering
data Word
ord :: Char -> Int
data IO a
data Ptr a
($!) :: (a -> b) -> a -> b
infixr 0 $!
data Integer
subtract :: Num a => a -> 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 Bounded a
minBound :: Bounded a => a
maxBound :: Bounded a => a
boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
class (Num a, Ord a) => Real a
toRational :: Real a => a -> Rational
(%) :: Integral a => a -> a -> Ratio 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
data Ratio a
type Rational = Ratio Integer
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
(^) :: (Num a, Integral b) => a -> b -> a
(^%^) :: Integral a => Rational -> a -> Rational
(^^) :: (Fractional a, Integral b) => a -> b -> a
(^^%^^) :: Integral a => Rational -> a -> Rational
denominator :: Ratio a -> a
divZeroError :: a
even :: Integral a => a -> Bool
fromIntegral :: (Integral a, Num b) => a -> b
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]
numericEnumFromThenTo :: (Ord a, Fractional a) => a -> a -> a -> [a]
numericEnumFromTo :: (Ord a, Fractional a) => a -> a -> [a]
odd :: Integral a => a -> Bool
overflowError :: a
ratioPrec :: Int
ratioPrec1 :: Int
ratioZeroDenominatorError :: a
realToFrac :: (Real a, Fractional b) => a -> b
reduce :: Integral a => a -> a -> Ratio a
underflowError :: a
data Float
F# :: Float# -> Float
data Double
D# :: Double# -> Double
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 (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
type Constraint = CONSTRAINT LiftedRep
data FunPtr a
(++) :: [a] -> [a] -> [a]
seq :: a -> b -> b
asTypeOf :: a -> a -> a
maxInt :: Int
minInt :: Int
until :: (a -> Bool) -> (a -> a) -> a -> a
class a ~R# b => Coercible (a :: k) (b :: k)
data StaticPtr a
class IsLabel (x :: Symbol) a
fromLabel :: IsLabel x a => a
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
getStackTrace :: IO (Maybe [Location])
showStackTrace :: IO (Maybe String)
data CallStack
type HasCallStack = ?callStack :: CallStack
callStack :: HasCallStack => CallStack
prettySrcLoc :: SrcLoc -> String
currentCallStack :: IO [String]
getCallStack :: CallStack -> [([Char], SrcLoc)]
prettyCallStack :: CallStack -> String
withFrozenCallStack :: HasCallStack => (HasCallStack => a) -> a
data Symbol
data SomeSymbol
SomeSymbol :: Proxy n -> SomeSymbol
type Nat = Natural
data SomeNat
SomeNat :: Proxy n -> SomeNat
type family CmpNat (a :: Natural) (b :: Natural) :: Ordering
class KnownSymbol (n :: Symbol)
class KnownNat (n :: Nat)
natVal :: forall (n :: Nat) proxy. KnownNat n => proxy n -> Integer
someNatVal :: Integer -> Maybe SomeNat
symbolVal :: forall (n :: Symbol) proxy. KnownSymbol n => proxy n -> String
someSymbolVal :: String -> SomeSymbol
class HasField (x :: k) r a | x r -> a
getField :: HasField x r a => r -> a
type Type = TYPE LiftedRep

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

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

-- | Apply a function n times to a given value
applyN :: Int -> (a -> a) -> a -> a
group :: Eq a => [a] -> [[a]]
data NonEmpty a
(:|) :: a -> [a] -> NonEmpty a
nonEmpty :: [a] -> Maybe (NonEmpty a)
splitAt :: Int -> [a] -> ([a], [a])
break :: (a -> Bool) -> [a] -> ([a], [a])
intercalate :: [a] -> [[a]] -> [a]
isPrefixOf :: Eq a => [a] -> [a] -> Bool
isInfixOf :: Eq a => [a] -> [a] -> Bool
isSuffixOf :: Eq a => [a] -> [a] -> Bool
drop :: Int -> [a] -> [a]
filter :: (a -> Bool) -> [a] -> [a]
reverse :: [a] -> [a]
replicate :: Int -> a -> [a]
take :: Int -> [a] -> [a]
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
sort :: Ord a => [a] -> [a]
intersperse :: a -> [a] -> [a]
transpose :: [[a]] -> [[a]]
subsequences :: [a] -> [[a]]
permutations :: [a] -> [[a]]
scanl :: (b -> a -> b) -> b -> [a] -> [b]
scanl' :: (b -> a -> b) -> b -> [a] -> [b]
scanr :: (a -> b -> b) -> b -> [a] -> [b]
iterate :: (a -> a) -> a -> [a]
repeat :: a -> [a]
cycle :: HasCallStack => [a] -> [a]
unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
takeWhile :: (a -> Bool) -> [a] -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
inits :: [a] -> [[a]]
tails :: [a] -> [[a]]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zip :: [a] -> [b] -> [(a, b)]
unzip :: [(a, b)] -> ([a], [b])
genericLength :: Num i => [a] -> i
genericTake :: Integral i => i -> [a] -> [a]
genericDrop :: Integral i => i -> [a] -> [a]
genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
genericReplicate :: Integral i => i -> a -> [a]
map :: Functor f => (a -> b) -> f a -> f b
uncons :: [a] -> Maybe (a, [a])
unsnoc :: [x] -> Maybe ([x], x)
data Map k a
data Set 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 ()
data Bool
False :: Bool
True :: Bool
(&&) :: Bool -> Bool -> Bool
(||) :: Bool -> Bool -> Bool
not :: Bool -> Bool
otherwise :: Bool

-- | 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
newtype Identity a
Identity :: a -> Identity a
[runIdentity] :: Identity a -> a
data Either a b
Left :: a -> Either a b
Right :: b -> Either a b
either :: (a -> c) -> (b -> c) -> Either a b -> c
lefts :: [Either a b] -> [a]
rights :: [Either a b] -> [b]
partitionEithers :: [Either a b] -> ([a], [b])
isLeft :: Either a b -> Bool
isRight :: Either a b -> Bool
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
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]
newtype Const a (b :: k)
Const :: a -> Const a (b :: k)
[getConst] :: Const a (b :: k) -> a
newtype ZipList a
ZipList :: [a] -> ZipList a
[getZipList] :: ZipList a -> [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
optional :: Alternative f => f a -> f (Maybe a)
guarded :: Alternative f => (a -> Bool) -> a -> f a
guardedA :: (Functor f, Alternative t) => (a -> f Bool) -> a -> f (t a)
interruptible :: IO a -> IO a
class (Typeable e, Show e) => Exception e
toException :: Exception e => e -> SomeException
fromException :: Exception e => SomeException -> Maybe e
displayException :: Exception e => e -> String
data SomeException
SomeException :: e -> SomeException
data IOException
data ArithException
Overflow :: ArithException
Underflow :: ArithException
LossOfPrecision :: ArithException
DivideByZero :: ArithException
Denormal :: ArithException
RatioZeroDenominator :: ArithException
data ArrayException
IndexOutOfBounds :: String -> ArrayException
UndefinedElement :: String -> ArrayException
newtype AssertionFailed
AssertionFailed :: String -> AssertionFailed
data SomeAsyncException
SomeAsyncException :: e -> SomeAsyncException
asyncExceptionToException :: Exception e => e -> SomeException
asyncExceptionFromException :: Exception e => SomeException -> Maybe e
data AsyncException
StackOverflow :: AsyncException
HeapOverflow :: AsyncException
ThreadKilled :: AsyncException
UserInterrupt :: AsyncException
data NonTermination
NonTermination :: NonTermination
data NestedAtomically
NestedAtomically :: NestedAtomically
data BlockedIndefinitelyOnMVar
BlockedIndefinitelyOnMVar :: BlockedIndefinitelyOnMVar
data BlockedIndefinitelyOnSTM
BlockedIndefinitelyOnSTM :: BlockedIndefinitelyOnSTM
data AllocationLimitExceeded
AllocationLimitExceeded :: AllocationLimitExceeded
newtype CompactionFailed
CompactionFailed :: String -> CompactionFailed
data Deadlock
Deadlock :: Deadlock
newtype NoMethodError
NoMethodError :: String -> NoMethodError
newtype PatternMatchFail
PatternMatchFail :: String -> PatternMatchFail
newtype RecConError
RecConError :: String -> RecConError
newtype RecSelError
RecSelError :: String -> RecSelError
newtype RecUpdError
RecUpdError :: String -> RecUpdError
data ErrorCall
ErrorCallWithLocation :: String -> String -> ErrorCall
pattern ErrorCall :: String -> ErrorCall
newtype TypeError
TypeError :: String -> TypeError
ioError :: IOError -> IO a
catch :: Exception e => IO a -> (e -> IO a) -> IO a
catches :: IO a -> [Handler a] -> IO a
data Handler a
Handler :: (e -> IO a) -> Handler a
catchJust :: Exception e => (e -> Maybe b) -> IO a -> (b -> IO a) -> 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
try :: Exception e => IO a -> IO (Either e a)
tryJust :: Exception e => (e -> Maybe b) -> IO a -> IO (Either b a)
evaluate :: a -> IO a
mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> 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
data MaskingState
Unmasked :: MaskingState
MaskedInterruptible :: MaskingState
MaskedUninterruptible :: MaskingState
getMaskingState :: IO MaskingState
allowInterrupt :: IO ()
bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket_ :: IO a -> IO b -> IO c -> IO c
bracketOnError :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
finally :: IO a -> IO b -> IO a
onException :: IO a -> IO b -> IO a

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

-- | Lifted throwTo
throwTo :: (MonadIO m, Exception e) => ThreadId -> e -> m ()
class IsString 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 (Functor t, Foldable t) => Traversable (t :: Type -> Type)
traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
mapAccumL :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
mapAccumR :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
fmapDefault :: Traversable t => (a -> b) -> t a -> t b
foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m
for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
forAccumM :: (Monad m, Traversable t) => s -> t a -> (s -> a -> m (s, b)) -> m (s, t b)
mapAccumM :: (Monad m, Traversable t) => (s -> a -> m (s, b)) -> s -> t a -> m (s, t b)
class Foldable (t :: Type -> 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
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
asum :: (Foldable t, Alternative f) => t (f a) -> f a
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
concat :: Foldable t => t [a] -> [a]
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
and :: Foldable t => t Bool -> Bool
or :: Foldable t => t Bool -> Bool
any :: Foldable t => (a -> Bool) -> t a -> Bool
all :: Foldable t => (a -> Bool) -> t a -> Bool
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
find :: Foldable t => (a -> Bool) -> t a -> Maybe a
class Semigroup a
sconcat :: Semigroup a => NonEmpty a -> a
stimes :: (Semigroup a, Integral b) => b -> a -> a
data WrappedMonoid m
diff :: Semigroup m => m -> Endo m
cycle1 :: Semigroup m => m -> m
stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
stimesIdempotent :: Integral b => b -> a -> a
stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
class Semigroup a => Monoid a
mempty :: Monoid a => a
mappend :: Monoid a => a -> a -> a
mconcat :: Monoid a => [a] -> a
(<>) :: Semigroup a => a -> a -> a
newtype Any
Any :: Bool -> Any
[getAny] :: Any -> Bool
newtype Ap (f :: k -> Type) (a :: k)
Ap :: f a -> Ap (f :: k -> Type) (a :: k)
[getAp] :: Ap (f :: k -> Type) (a :: k) -> f a
newtype First a
First :: Maybe a -> First a
[getFirst] :: First a -> Maybe a
newtype Last a
Last :: Maybe a -> Last a
[getLast] :: Last a -> Maybe a
newtype All
All :: Bool -> All
[getAll] :: All -> Bool
newtype Alt (f :: k -> Type) (a :: k)
Alt :: f a -> Alt (f :: k -> Type) (a :: k)
[getAlt] :: Alt (f :: k -> Type) (a :: k) -> f a
newtype Dual a
Dual :: a -> Dual a
[getDual] :: Dual a -> a
newtype Endo a
Endo :: (a -> a) -> Endo a
[appEndo] :: Endo a -> a -> a
newtype Product a
Product :: a -> Product a
[getProduct] :: Product a -> a
newtype Sum a
Sum :: a -> Sum a
[getSum] :: Sum a -> a
class forall a. () => Functor p a => 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
class Eq a => Hashable a
hashWithSalt :: Hashable a => Int -> a -> Int
hash :: Hashable a => a -> Int
hashUsing :: Hashable b => (a -> b) -> Int -> a -> Int
deepseq :: NFData a => a -> b -> b
class NFData a
rnf :: NFData a => a -> ()
($!!) :: NFData a => (a -> b) -> a -> b
force :: NFData a => a -> a
fst :: (a, b) -> a
snd :: (a, b) -> b
curry :: ((a, b) -> c) -> a -> b -> c
uncurry :: (a -> b -> c) -> (a, b) -> c
swap :: (a, b) -> (b, a)
class Typeable (a :: k)
type TypeRep = SomeTypeRep
typeOf :: Typeable a => a -> TypeRep
cast :: (Typeable a, Typeable b) => a -> Maybe b
gcast :: forall {k} (a :: k) (b :: k) c. (Typeable a, Typeable b) => c a -> Maybe (c b)
typeRep :: forall {k} proxy (a :: k). Typeable a => proxy a -> TypeRep
eqT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => Maybe (a :~: b)
data Proxy (t :: k)
Proxy :: Proxy (t :: k)
data Coercion (a :: k) (b :: k)
[Coercion] :: forall {k} (a :: k) (b :: k). Coercible a b => Coercion a b
coerceWith :: Coercion a b -> a -> b
repr :: forall {k} (a :: k) (b :: k). (a :~: b) -> Coercion a b
data (a :: k) :~: (b :: k)
[Refl] :: forall {k} (a :: k). a :~: a
type family (a :: k) == (b :: k) :: Bool
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
castWith :: (a :~: b) -> a -> b
gcastWith :: forall {k} (a :: k) (b :: k) r. (a :~: b) -> (a ~ b => r) -> r
data Void
absurd :: Void -> a
vacuous :: Functor f => f Void -> f a
class Monad m => MonadFail (m :: Type -> Type)
type State s = StateT s Identity
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 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)
gets :: MonadState s m => (s -> a) -> m a
modify :: MonadState s m => (s -> s) -> m ()
withState :: (s -> s) -> State s a -> State s a
runState :: State s a -> s -> (a, s)
execState :: State s a -> s -> s
evalState :: State s a -> s -> a
execStateT :: Monad m => StateT s m a -> s -> m s
evalStateT :: Monad m => StateT s m a -> s -> m a
type Reader r = ReaderT r Identity
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
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
asks :: MonadReader r m => (r -> a) -> m a
runReader :: Reader r a -> r -> a
type Except e = ExceptT e Identity
throwE :: forall (m :: Type -> Type) e a. Monad m => e -> ExceptT e m a
catchE :: forall (m :: Type -> Type) e a e'. Monad m => ExceptT e m a -> (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
newtype ExceptT e (m :: Type -> Type) a
ExceptT :: m (Either e a) -> ExceptT e (m :: Type -> Type) a
runExcept :: Except e a -> Either e a
runExceptT :: ExceptT e m a -> m (Either e 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
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 => 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
runST :: (forall s. () => ST s a) -> a
fixST :: (a -> ST s a) -> ST s a
data STM a
atomically :: STM a -> IO a
retry :: STM a
orElse :: STM a -> STM a -> STM a
check :: Bool -> STM ()
throwSTM :: Exception e => e -> STM a
catchSTM :: Exception e => STM a -> (e -> STM a) -> STM a
data Int
data Int8
data Int16
data Int32
data Int64
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
bitDefault :: (Bits a, Num a) => Int -> a
testBitDefault :: (Bits a, Num a) => a -> Int -> Bool
popCountDefault :: (Bits a, Num a) => a -> Int
toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
data Word
data Word8
data Word16
data Word32
data Word64
byteSwap16 :: Word16 -> Word16
byteSwap32 :: Word32 -> Word32
byteSwap64 :: Word64 -> Word64
data Complex a
(:+) :: !a -> !a -> Complex a
realPart :: Complex a -> a
imagPart :: Complex a -> a
mkPolar :: Floating a => a -> a -> Complex a
cis :: Floating a => a -> Complex a
polar :: RealFloat a => Complex a -> (a, a)
magnitude :: RealFloat a => Complex a -> a
phase :: RealFloat a => Complex a -> a
conjugate :: Num a => Complex a -> Complex a
data Char
ord :: Char -> Int
chr :: Int -> Char
digitToInt :: Char -> Int
intToDigit :: Int -> Char
toUpper :: Char -> Char
toLower :: Char -> Char
toTitle :: Char -> Char
isAscii :: Char -> Bool
isLetter :: Char -> Bool
isDigit :: Char -> Bool
isHexDigit :: Char -> Bool
isPrint :: Char -> Bool
isAlpha :: Char -> Bool
isAlphaNum :: Char -> Bool
isUpper :: Char -> Bool
isLower :: Char -> Bool
isSpace :: Char -> Bool
isControl :: Char -> Bool
data Maybe a
Nothing :: Maybe a
Just :: a -> Maybe a
maybe :: b -> (a -> b) -> Maybe a -> b
isJust :: Maybe a -> Bool
isNothing :: Maybe a -> Bool
fromMaybe :: a -> Maybe a -> a
listToMaybe :: [a] -> Maybe a
maybeToList :: Maybe a -> [a]
catMaybes :: [Maybe a] -> [a]
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
class Generic a where {
    type Rep a :: Type -> Type;
}
from :: Generic a => a -> Rep a x
to :: Generic a => Rep a x -> a
class Generic1 (f :: k -> Type)
type family Rep a :: Type -> Type
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 U1 (p :: k)
U1 :: U1 (p :: k)
data V1 (p :: k)
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
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
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 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 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 Fixity
Prefix :: Fixity
Infix :: Associativity -> Int -> Fixity
data Associativity
LeftAssociative :: Associativity
RightAssociative :: Associativity
NotAssociative :: Associativity
data Meta
MetaData :: Symbol -> Symbol -> Symbol -> Bool -> Meta
MetaCons :: Symbol -> FixityI -> Bool -> Meta
MetaSel :: Maybe Symbol -> SourceUnpackedness -> SourceStrictness -> DecidedStrictness -> Meta
data FixityI
PrefixI :: FixityI
InfixI :: Associativity -> Nat -> FixityI
data family URec a (p :: k)
data ByteString
type LByteString = ByteString
data Text
lines :: Text -> [Text]
words :: Text -> [Text]
unlines :: [Text] -> Text
unwords :: [Text] -> Text
getLine :: IO Text
getContents :: IO Text
interact :: (Text -> Text) -> IO ()
readFile :: FilePath -> IO Text
writeFile :: FilePath -> Text -> IO ()
appendFile :: FilePath -> Text -> IO ()
toStrict :: LazyText -> StrictText
fromStrict :: StrictText -> LazyText
encodeUtf8 :: Text -> ByteString
decodeUtf8 :: ByteString -> Text
decodeUtf8' :: ByteString -> Either UnicodeException Text
decodeUtf8With :: OnDecodeError -> ByteString -> Text
type OnDecodeError = OnError Word8 Char
type OnError a b = String -> Maybe a -> Maybe b
data UnicodeException
lenientDecode :: OnDecodeError
strictDecode :: OnDecodeError
ignore :: OnError a b
replace :: b -> OnError a b
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
getArgs :: IO [String]
data ExitCode
ExitSuccess :: ExitCode
ExitFailure :: Int -> ExitCode
exitWith :: ExitCode -> IO a
exitFailure :: IO a
exitSuccess :: IO a
data Handle
type FilePath = String
data IOMode
ReadMode :: IOMode
WriteMode :: IOMode
AppendMode :: IOMode
ReadWriteMode :: IOMode
stdin :: Handle
stdout :: Handle
stderr :: Handle
withFile :: FilePath -> IOMode -> (Handle -> IO r) -> IO r
openFile :: FilePath -> IOMode -> IO Handle

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

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
