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

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
data () => Bool
data () => Int
data () => Char
data () => Ordering
data () => Word
data () => IO a
data () => Ptr a
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 () => Integer
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
class (Num a, Ord a) => Real a
toRational :: Real a => a -> Rational
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
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
data () => Constraint
data () => FunPtr 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
data () => CallStack
type HasCallStack = ?callStack :: CallStack
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)
class () => HasField (x :: k) r a | x r -> a
getField :: HasField x r a => r -> a
type Type = TYPE LiftedRep
print :: Show a => a -> IO ()
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
ord :: Char -> Int
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
(^) :: (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
(++) :: [a] -> [a] -> [a]
seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
asTypeOf :: a -> a -> a
maxInt :: Int
minInt :: Int
until :: (a -> Bool) -> (a -> a) -> a -> a
getStackTrace :: IO (Maybe [Location])
showStackTrace :: IO (Maybe String)
callStack :: HasCallStack => CallStack
prettySrcLoc :: SrcLoc -> String
currentCallStack :: IO [String]
getCallStack :: CallStack -> [([Char], SrcLoc)]
prettyCallStack :: CallStack -> String
withFrozenCallStack :: HasCallStack => (HasCallStack => a) -> a
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
($!) :: (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 :: 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.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
class () => Show a
data () => Bool
data () => Int
data () => Char
data () => Ordering
data () => Word
data () => IO a
data () => Ptr a
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 () => Integer
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
class (Num a, Ord a) => Real a
toRational :: Real a => a -> Rational
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
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
data () => Constraint
data () => FunPtr 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
data () => CallStack
type HasCallStack = ?callStack :: CallStack
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)
class () => HasField (x :: k) r a | x r -> a
getField :: HasField x r a => r -> a
type Type = TYPE LiftedRep
ord :: Char -> Int
($!) :: (a -> b) -> a -> b
infixr 0 $!
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
(^) :: (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
(++) :: [a] -> [a] -> [a]
seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
asTypeOf :: a -> a -> a
maxInt :: Int
minInt :: Int
until :: (a -> Bool) -> (a -> a) -> a -> a
getStackTrace :: IO (Maybe [Location])
showStackTrace :: IO (Maybe String)
callStack :: HasCallStack => CallStack
prettySrcLoc :: SrcLoc -> String
currentCallStack :: IO [String]
getCallStack :: CallStack -> [([Char], SrcLoc)]
prettyCallStack :: CallStack -> String
withFrozenCallStack :: HasCallStack => (HasCallStack => a) -> a
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

-- | 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
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (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
data () => NonEmpty a
(:|) :: a -> [a] -> NonEmpty a
group :: Eq a => [a] -> [[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]
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]]
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
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 <||>

-- | 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
newtype () => Identity a
Identity :: a -> Identity a
[runIdentity] :: Identity a -> a
($>) :: Functor f => f a -> b -> f b
(<$>) :: 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
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
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
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)
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)
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
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
data () => Handler a
Handler :: (e -> IO a) -> Handler a
data () => MaskingState
Unmasked :: MaskingState
MaskedInterruptible :: MaskingState
MaskedUninterruptible :: MaskingState
interruptible :: IO a -> IO a
asyncExceptionToException :: Exception e => e -> SomeException
asyncExceptionFromException :: Exception e => SomeException -> Maybe e
ioError :: IOError -> IO a
catch :: Exception e => IO a -> (e -> IO a) -> IO a
catches :: IO a -> [Handler a] -> IO 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
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
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]
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
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 -> 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 () => 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
class () => NFData a
rnf :: NFData a => a -> ()
deepseq :: NFData a => a -> b -> b
($!!) :: 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
data () => (a :: k) :~: (b :: k)
[Refl] :: forall {k} (a :: k). a :~: a
type family (a :: k) == (b :: k) :: Bool
data () => Void
coerceWith :: Coercion a b -> a -> b
repr :: forall {k} (a :: k) (b :: k). (a :~: b) -> Coercion a b
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
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
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
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
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
data () => Word
data () => Word8
data () => Word16
data () => Word32
data () => Word64
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
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 family 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
type OnDecodeError = OnError Word8 Char
type OnError a b = String -> Maybe a -> Maybe b
data () => UnicodeException
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 :: Text -> Text
fromStrict :: Text -> Text
encodeUtf8 :: Text -> ByteString
decodeUtf8 :: ByteString -> Text
decodeUtf8' :: ByteString -> Either UnicodeException Text
decodeUtf8With :: OnDecodeError -> ByteString -> Text
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
data () => ExitCode
ExitSuccess :: ExitCode
ExitFailure :: Int -> ExitCode
data () => Handle
type FilePath = String
data () => IOMode
ReadMode :: IOMode
WriteMode :: IOMode
AppendMode :: IOMode
ReadWriteMode :: IOMode
getArgs :: IO [String]
exitWith :: ExitCode -> IO a
exitFailure :: IO a
exitSuccess :: IO a
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
data () => MVar a
data () => Chan a
data () => QSem
data () => QSemN
data () => ThreadId
data () => Async a
newtype () => Concurrently a
Concurrently :: IO a -> Concurrently a
[runConcurrently] :: Concurrently a -> IO a
async :: IO a -> IO (Async 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 ()
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 ()
newQSem :: Int -> IO QSem
waitQSem :: QSem -> IO ()
signalQSem :: QSem -> IO ()
newQSemN :: Int -> IO QSemN
waitQSemN :: QSemN -> Int -> IO ()
signalQSemN :: QSemN -> Int -> IO ()
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
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
