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


-- | Featureful preludes formed solely from the "base" package
--   
--   A library which aims to reexport all the non-conflicting and most
--   general definitions from the "base" package. This includes APIs for
--   applicatives, arrows, monoids, foldables, traversables, exceptions,
--   generics, ST, MVars and STM.
--   
--   This package will never have any dependencies other than "base".
--   
--   Besides a rich prelude it provides limited ones like
--   <a>BasePrelude.DataTypes</a>, which only exports the data-types
--   defined across the "base" package, and <a>BasePrelude.Operators</a>,
--   which only exports the common operators.
--   
--   <i>Versioning policy</i>
--   
--   The versioning policy of this package deviates from PVP in the sense
--   that its exports in part are transitively determined by the version of
--   "base". Therefore it's recommended for the users of "base-prelude" to
--   specify the bounds of "base" as well.
@package base-prelude
@version 1.6.1


-- | Reexports of most of the definitions from the "base" package, which it
--   is a common practice to import unqualified.
--   
--   For details check out the source.
module BasePrelude
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 Category a => Arrow (a :: Type -> Type -> Type)
arr :: Arrow a => (b -> c) -> a b c
(***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c')
(&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
class () => Category (cat :: k -> k -> Type)
id :: forall (a :: k). Category cat => cat a a
(.) :: forall (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
class (Typeable e, Show e) => Exception e
toException :: Exception e => e -> SomeException
fromException :: Exception e => SomeException -> Maybe e
displayException :: Exception e => e -> String
class Applicative m => Monad (m :: Type -> Type)
(>>=) :: Monad m => m a -> (a -> m b) -> m b
(>>) :: Monad m => m a -> m b -> m b
return :: Monad m => a -> m a
data () => ST s a
class Typeable a => Data a
gfoldl :: Data a => (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. () => g -> c g) -> a -> c a
gunfold :: Data a => (forall b r. Data b => c (b -> r) -> c r) -> (forall r. () => r -> c r) -> Constr -> c a
toConstr :: Data a => a -> Constr
dataTypeOf :: Data a => a -> DataType
dataCast1 :: (Data a, Typeable t) => (forall d. Data d => c (t d)) -> Maybe (c a)
dataCast2 :: (Data a, Typeable t) => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a)
gmapT :: Data a => (forall b. Data b => b -> b) -> a -> a
gmapQl :: Data a => (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
gmapQr :: forall r r'. Data a => (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
gmapQ :: Data a => (forall d. Data d => d -> u) -> a -> [u]
gmapQi :: Data a => Int -> (forall d. Data d => d -> u) -> a -> u
gmapM :: (Data a, Monad m) => (forall d. Data d => d -> m d) -> a -> m a
gmapMp :: (Data a, MonadPlus m) => (forall d. Data d => d -> m d) -> a -> m a
gmapMo :: (Data a, MonadPlus m) => (forall d. Data d => d -> m d) -> a -> m 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 => 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
unsafeShiftL :: Bits a => a -> Int -> a
shiftR :: Bits a => a -> Int -> a
unsafeShiftR :: Bits a => a -> Int -> a
rotateL :: Bits a => a -> Int -> a
rotateR :: Bits a => a -> Int -> a
popCount :: Bits a => a -> Int
data () => Bool
False :: Bool
True :: Bool
data () => Char
data () => Complex a
(:+) :: !a -> !a -> Complex a
data () => Dynamic
[Dynamic] :: forall a. TypeRep a -> a -> Dynamic
data () => Either a b
Left :: a -> Either a b
Right :: b -> Either a b
newtype () => Fixed (a :: k)
MkFixed :: Integer -> Fixed (a :: k)
class () => Foldable (t :: Type -> Type)
fold :: (Foldable t, Monoid m) => t m -> m
foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> 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
foldr1 :: Foldable t => (a -> a -> a) -> t a -> a
foldl1 :: Foldable t => (a -> a -> a) -> 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
sum :: (Foldable t, Num a) => t a -> a
product :: (Foldable t, Num a) => t a -> a
class () => Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b
(<$) :: Functor f => a -> f b -> f a
newtype () => Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1)
Compose :: f (g a) -> Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1)
[getCompose] :: Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) -> f (g a)
class () => Contravariant (f :: Type -> Type)
contramap :: Contravariant f => (a' -> a) -> f a -> f a'
(>$) :: Contravariant f => b -> f b -> f a
newtype () => Identity a
Identity :: a -> Identity a
[runIdentity] :: Identity a -> a
data () => IORef a
data () => Int
class Ord a => Ix a
range :: Ix a => (a, a) -> [a]
index :: Ix a => (a, a) -> a -> Int
inRange :: Ix a => (a, a) -> a -> Bool
rangeSize :: Ix a => (a, a) -> Int
data () => NonEmpty a
(:|) :: a -> [a] -> NonEmpty a
data () => Maybe a
Nothing :: Maybe a
Just :: a -> Maybe a
class Semigroup a => Monoid a
mempty :: Monoid a => a
mappend :: Monoid a => a -> a -> a
mconcat :: Monoid a => [a] -> a
newtype () => First a
First :: a -> First a
[getFirst] :: First a -> a
newtype () => Last a
Last :: a -> Last a
[getLast] :: Last a -> a
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 () => Proxy (t :: k)
Proxy :: Proxy (t :: k)
data () => Ratio a
data () => STRef s a
class () => Semigroup a
(<>) :: Semigroup a => a -> a -> a
sconcat :: Semigroup a => NonEmpty a -> a
stimes :: (Semigroup a, Integral b) => b -> a -> a
type String = [Char]
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)
data () => Unique
data () => Version
Version :: [Int] -> [String] -> Version
[versionBranch] :: Version -> [Int]
[versionTags] :: Version -> [String]
data () => Void
data () => Word
data () => ForeignPtr a
data () => Ptr a
data () => StablePtr a
class () => Storable a
sizeOf :: Storable a => a -> Int
alignment :: Storable a => a -> Int
peekElemOff :: Storable a => Ptr a -> Int -> IO a
pokeElemOff :: Storable a => Ptr a -> Int -> a -> IO ()
peekByteOff :: Storable a => Ptr b -> Int -> IO a
pokeByteOff :: Storable a => Ptr b -> Int -> a -> IO ()
peek :: Storable a => Ptr a -> IO a
poke :: Storable a => Ptr a -> a -> IO ()
class () => IsList l where {
    type family Item l;
}
fromList :: IsList l => [Item l] -> l
fromListN :: IsList l => Int -> [Item l] -> l
toList :: IsList l => l -> [Item l]
class () => Generic a
class () => Generic1 (f :: k -> Type)
data () => Natural
data () => IO a
data () => StableName a
data () => Timeout
data () => ReadP a
type ReadS a = String -> [(a, String)]
data () => ReadPrec a
class () => Read a
readsPrec :: Read a => Int -> ReadS a
readList :: Read a => ReadS [a]
readPrec :: Read a => ReadPrec a
readListPrec :: Read a => ReadPrec [a]
data () => Double
data () => Float
data () => Integer
data () => Int8
data () => Int16
data () => Int32
data () => Int64
data () => Word8
data () => Word16
data () => Word32
data () => Word64
type Rational = Ratio Integer
class () => Eq a
(==) :: Eq a => a -> a -> Bool
(/=) :: Eq a => a -> a -> Bool
class ArrowZero a => ArrowPlus (a :: Type -> Type -> Type)
(<+>) :: ArrowPlus a => a b c -> a b c -> a b c
class Arrow a => ArrowZero (a :: Type -> Type -> Type)
zeroArrow :: ArrowZero a => a b c
newtype () => Const a (b :: k)
Const :: a -> Const a (b :: k)
[getConst] :: Const a (b :: k) -> a
class Applicative f => Alternative (f :: Type -> Type)
empty :: Alternative f => f a
(<|>) :: Alternative f => f a -> f a -> f a
some :: Alternative f => f a -> f [a]
many :: Alternative f => f a -> f [a]
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
mzero :: MonadPlus m => m a
mplus :: MonadPlus m => m a -> m a -> m a
class () => Show a
showsPrec :: Show a => Int -> a -> ShowS
show :: Show a => a -> String
showList :: Show a => [a] -> ShowS
newtype () => WrappedArrow (a :: Type -> Type -> Type) b c
WrapArrow :: a b c -> WrappedArrow (a :: Type -> Type -> Type) b c
[unwrapArrow] :: WrappedArrow (a :: Type -> Type -> Type) b c -> a b c
newtype () => WrappedMonad (m :: Type -> Type) a
WrapMonad :: m a -> WrappedMonad (m :: Type -> Type) a
[unwrapMonad] :: WrappedMonad (m :: Type -> Type) a -> m a
newtype () => ZipList a
ZipList :: [a] -> ZipList a
[getZipList] :: ZipList a -> [a]
type ShowS = String -> String
data () => TyCon
data RealWorld
data () => Ordering
LT :: Ordering
EQ :: Ordering
GT :: Ordering
class a ~# b => (a :: k) ~ (b :: k)
class a ~R# b => Coercible (a :: k) (b :: k)
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
newtype () => Any
Any :: Bool -> Any
[getAny] :: Any -> Bool
class Monad m => MonadFix (m :: Type -> Type)
mfix :: MonadFix m => (a -> m a) -> m a
newtype () => Kleisli (m :: Type -> Type) a b
Kleisli :: (a -> m b) -> Kleisli (m :: Type -> Type) a b
[runKleisli] :: Kleisli (m :: Type -> Type) a b -> a -> m b
newtype () => ArrowMonad (a :: Type -> Type -> Type) b
ArrowMonad :: a () b -> ArrowMonad (a :: Type -> Type -> Type) b
class Arrow a => ArrowApply (a :: Type -> Type -> Type)
app :: ArrowApply a => a (a b c, b) c
class Arrow a => ArrowChoice (a :: Type -> Type -> Type)
left :: ArrowChoice a => a b c -> a (Either b d) (Either c d)
right :: ArrowChoice a => a b c -> a (Either d b) (Either d c)
(+++) :: ArrowChoice a => a b c -> a b' c' -> a (Either b b') (Either c c')
(|||) :: ArrowChoice a => a b d -> a c d -> a (Either b c) d
class Arrow a => ArrowLoop (a :: Type -> Type -> Type)
loop :: ArrowLoop a => a (b, d) (c, d) -> a b c
data () => (a :: k) :~: (b :: k)
[Refl] :: forall {k} (a :: k). a :~: a
data () => (a :: k1) :~~: (b :: k2)
[HRefl] :: forall {k1} (a :: k1). a :~~: a
data () => Chan a
data () => QSem
data () => QSemN
newtype () => STM a
STM :: (State# RealWorld -> (# State# RealWorld, a #)) -> STM a
data () => ThreadId
ThreadId :: ThreadId# -> ThreadId
data () => SomeException
SomeException :: e -> SomeException
data () => MVar a
data () => NestedAtomically
NestedAtomically :: NestedAtomically
newtype () => NoMethodError
NoMethodError :: String -> NoMethodError
data () => NonTermination
NonTermination :: NonTermination
newtype () => PatternMatchFail
PatternMatchFail :: String -> PatternMatchFail
newtype () => RecConError
RecConError :: String -> RecConError
newtype () => RecSelError
RecSelError :: String -> RecSelError
newtype () => RecUpdError
RecUpdError :: String -> RecUpdError
newtype () => TypeError
TypeError :: String -> TypeError
data () => ErrorCall
ErrorCallWithLocation :: String -> String -> ErrorCall
pattern ErrorCall :: String -> ErrorCall
data () => ArithException
Overflow :: ArithException
Underflow :: ArithException
LossOfPrecision :: ArithException
DivideByZero :: ArithException
Denormal :: ArithException
RatioZeroDenominator :: ArithException
data () => MaskingState
Unmasked :: MaskingState
MaskedInterruptible :: MaskingState
MaskedUninterruptible :: MaskingState
data () => Handler a
Handler :: (e -> IO a) -> Handler a
data () => AllocationLimitExceeded
AllocationLimitExceeded :: AllocationLimitExceeded
data () => ArrayException
IndexOutOfBounds :: String -> ArrayException
UndefinedElement :: String -> ArrayException
newtype () => AssertionFailed
AssertionFailed :: String -> AssertionFailed
data () => AsyncException
StackOverflow :: AsyncException
HeapOverflow :: AsyncException
ThreadKilled :: AsyncException
UserInterrupt :: AsyncException
data () => BlockedIndefinitelyOnMVar
BlockedIndefinitelyOnMVar :: BlockedIndefinitelyOnMVar
data () => BlockedIndefinitelyOnSTM
BlockedIndefinitelyOnSTM :: BlockedIndefinitelyOnSTM
newtype () => CompactionFailed
CompactionFailed :: String -> CompactionFailed
data () => Deadlock
Deadlock :: Deadlock
data () => IOException
IOError :: Maybe Handle -> IOErrorType -> String -> String -> Maybe CInt -> Maybe FilePath -> IOException
[ioe_handle] :: IOException -> Maybe Handle
[ioe_type] :: IOException -> IOErrorType
[ioe_location] :: IOException -> String
[ioe_description] :: IOException -> String
[ioe_errno] :: IOException -> Maybe CInt
[ioe_filename] :: IOException -> Maybe FilePath
data () => SomeAsyncException
SomeAsyncException :: e -> SomeAsyncException
class Monad m => MonadFail (m :: Type -> Type)
fail :: MonadFail m => String -> m a
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 () => Down a
Down :: a -> Down a
[getDown] :: Down a -> a
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 () => Product a
Product :: a -> Product a
[getProduct] :: Product a -> a
newtype () => Sum a
Sum :: a -> Sum a
[getSum] :: Sum a -> a
class Monad m => MonadIO (m :: Type -> Type)
liftIO :: MonadIO m => IO a -> m a
class Bits b => FiniteBits b
finiteBitSize :: FiniteBits b => b -> Int
countLeadingZeros :: FiniteBits b => b -> Int
countTrailingZeros :: FiniteBits b => b -> Int
class () => Bounded a
minBound :: Bounded a => a
maxBound :: Bounded a => a
class () => Enum a
succ :: Enum a => a -> a
pred :: Enum a => a -> a
toEnum :: Enum a => Int -> a
fromEnum :: Enum a => a -> Int
enumFrom :: Enum a => a -> [a]
enumFromThen :: Enum a => a -> a -> [a]
enumFromTo :: Enum a => a -> a -> [a]
enumFromThenTo :: Enum a => a -> a -> a -> [a]
newtype () => And a
And :: a -> And a
[getAnd] :: And a -> a
newtype () => Iff a
Iff :: a -> Iff a
[getIff] :: Iff a -> a
newtype () => Ior a
Ior :: a -> Ior a
[getIor] :: Ior a -> a
newtype () => Xor a
Xor :: a -> Xor a
[getXor] :: Xor a -> a
data () => GeneralCategory
UppercaseLetter :: GeneralCategory
LowercaseLetter :: GeneralCategory
TitlecaseLetter :: GeneralCategory
ModifierLetter :: GeneralCategory
OtherLetter :: GeneralCategory
NonSpacingMark :: GeneralCategory
SpacingCombiningMark :: GeneralCategory
EnclosingMark :: GeneralCategory
DecimalNumber :: GeneralCategory
LetterNumber :: GeneralCategory
OtherNumber :: GeneralCategory
ConnectorPunctuation :: GeneralCategory
DashPunctuation :: GeneralCategory
OpenPunctuation :: GeneralCategory
ClosePunctuation :: GeneralCategory
InitialQuote :: GeneralCategory
FinalQuote :: GeneralCategory
OtherPunctuation :: GeneralCategory
MathSymbol :: GeneralCategory
CurrencySymbol :: GeneralCategory
ModifierSymbol :: GeneralCategory
OtherSymbol :: GeneralCategory
Space :: GeneralCategory
LineSeparator :: GeneralCategory
ParagraphSeparator :: GeneralCategory
Control :: GeneralCategory
Format :: GeneralCategory
Surrogate :: GeneralCategory
PrivateUse :: GeneralCategory
NotAssigned :: GeneralCategory
data () => Constr
data () => DataType
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
class Num a => Fractional a
(/) :: Fractional a => a -> a -> a
recip :: Fractional a => a -> a
fromRational :: Fractional a => Rational -> a
data () => DataRep
AlgRep :: [Constr] -> DataRep
IntRep :: DataRep
FloatRep :: DataRep
CharRep :: DataRep
NoRep :: DataRep
type TypeRep = SomeTypeRep
class () => Typeable (a :: k)
class (Real a, Fractional a) => RealFrac a
properFraction :: (RealFrac a, Integral b) => a -> (b, a)
truncate :: (RealFrac a, Integral b) => a -> b
round :: (RealFrac a, Integral b) => a -> b
ceiling :: (RealFrac a, Integral b) => a -> b
floor :: (RealFrac a, Integral b) => a -> b
class (Real a, Enum a) => Integral a
quot :: Integral a => a -> a -> a
rem :: Integral a => a -> a -> a
div :: Integral a => a -> a -> a
mod :: Integral a => a -> a -> a
quotRem :: Integral a => a -> a -> (a, a)
divMod :: Integral a => a -> a -> (a, a)
toInteger :: Integral a => a -> Integer
class (Num a, Ord a) => Real a
toRational :: Real a => a -> Rational
data () => FunPtr a
newtype () => All
All :: Bool -> All
[getAll] :: All -> Bool
newtype () => IntPtr
IntPtr :: Int -> IntPtr
newtype () => WordPtr
WordPtr :: Word -> WordPtr
data () => Fixity
Prefix :: Fixity
Infix :: Fixity
data () => ConstrRep
AlgConstr :: ConIndex -> ConstrRep
IntConstr :: Integer -> ConstrRep
FloatConstr :: Rational -> ConstrRep
CharConstr :: Char -> ConstrRep
type ConIndex = Int
class () => HasResolution (a :: k)
resolution :: HasResolution a => p a -> Integer
type Centi = Fixed E2
type Deci = Fixed E1
data () => E0
data () => E1
data () => E12
data () => E2
data () => E3
data () => E6
data () => E9
type Micro = Fixed E6
type Milli = Fixed E3
type Nano = Fixed E9
type Pico = Fixed E12
type Uni = Fixed E0
newtype () => Max a
Max :: a -> Max a
[getMax] :: Max a -> a
newtype () => Min a
Min :: a -> Min a
[getMin] :: Min a -> a
newtype () => Endo a
Endo :: (a -> a) -> Endo a
[appEndo] :: Endo a -> a -> a
class () => Eq1 (f :: Type -> Type)
liftEq :: Eq1 f => (a -> b -> Bool) -> f a -> f b -> Bool
class () => Eq2 (f :: Type -> Type -> Type)
liftEq2 :: Eq2 f => (a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool
class Eq1 f => Ord1 (f :: Type -> Type)
liftCompare :: Ord1 f => (a -> b -> Ordering) -> f a -> f b -> Ordering
class Eq2 f => Ord2 (f :: Type -> Type -> Type)
liftCompare2 :: Ord2 f => (a -> b -> Ordering) -> (c -> d -> Ordering) -> f a c -> f b d -> Ordering
class () => Read1 (f :: Type -> Type)
liftReadsPrec :: Read1 f => (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a)
liftReadList :: Read1 f => (Int -> ReadS a) -> ReadS [a] -> ReadS [f a]
liftReadPrec :: Read1 f => ReadPrec a -> ReadPrec [a] -> ReadPrec (f a)
liftReadListPrec :: Read1 f => ReadPrec a -> ReadPrec [a] -> ReadPrec [f a]
class () => Read2 (f :: Type -> Type -> Type)
liftReadsPrec2 :: Read2 f => (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (f a b)
liftReadList2 :: Read2 f => (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [f a b]
liftReadPrec2 :: Read2 f => ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (f a b)
liftReadListPrec2 :: Read2 f => ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [f a b]
class () => Show1 (f :: Type -> Type)
liftShowsPrec :: Show1 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS
liftShowList :: Show1 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS
class () => Show2 (f :: Type -> Type -> Type)
liftShowsPrec2 :: Show2 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> f a b -> ShowS
liftShowList2 :: Show2 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [f a b] -> ShowS
newtype () => Op a b
Op :: (b -> a) -> Op a b
[getOp] :: Op a b -> b -> a
newtype () => Comparison a
Comparison :: (a -> a -> Ordering) -> Comparison a
[getComparison] :: Comparison a -> a -> a -> Ordering
newtype () => Equivalence a
Equivalence :: (a -> a -> Bool) -> Equivalence a
[getEquivalence] :: Equivalence a -> a -> a -> Bool
newtype () => Predicate a
Predicate :: (a -> Bool) -> Predicate a
[getPredicate] :: Predicate a -> a -> Bool
data () => KProxy t
KProxy :: KProxy t
data () => Arg a b
Arg :: a -> b -> Arg a b
newtype () => WrappedMonoid m
WrapMonoid :: m -> WrappedMonoid m
[unwrapMonoid] :: WrappedMonoid m -> m
type ArgMax a b = Max Arg a b
type ArgMin a b = Min Arg a b
class () => IsString a
fromString :: IsString a => String -> a
data () => TextEncoding
type FinalizerEnvPtr env a = FunPtr Ptr env -> Ptr a -> IO ()
type FinalizerPtr a = FunPtr Ptr a -> IO ()
type HandlerFun = ForeignPtr Word8 -> IO ()
type Signal = CInt
data () => BlockReason
BlockedOnMVar :: BlockReason
BlockedOnBlackHole :: BlockReason
BlockedOnException :: BlockReason
BlockedOnSTM :: BlockReason
BlockedOnForeignCall :: BlockReason
BlockedOnOther :: BlockReason
data () => PrimMVar
data () => TVar a
TVar :: TVar# RealWorld a -> TVar a
data () => ThreadStatus
ThreadRunning :: ThreadStatus
ThreadFinished :: ThreadStatus
ThreadBlocked :: BlockReason -> ThreadStatus
ThreadDied :: ThreadStatus
type family Item l
type FilePath = String
data () => Handle
data () => ExitCode
ExitSuccess :: ExitCode
ExitFailure :: Int -> ExitCode
data () => IOErrorType
AlreadyExists :: IOErrorType
NoSuchThing :: IOErrorType
ResourceBusy :: IOErrorType
ResourceExhausted :: IOErrorType
EOF :: IOErrorType
IllegalOperation :: IOErrorType
PermissionDenied :: IOErrorType
UserError :: IOErrorType
UnsatisfiedConstraints :: IOErrorType
SystemError :: IOErrorType
ProtocolError :: IOErrorType
OtherError :: IOErrorType
InvalidArgument :: IOErrorType
InappropriateType :: IOErrorType
HardwareFault :: IOErrorType
UnsupportedOperation :: IOErrorType
TimeExpired :: IOErrorType
ResourceVanished :: IOErrorType
Interrupted :: IOErrorType
data () => FixIOException
FixIOException :: FixIOException
type IOError = IOException
class () => IsLabel (x :: Symbol) a
fromLabel :: IsLabel x a => a
class () => HasField (x :: k) r a | x r -> a
getField :: HasField x r a => r -> a
data () => SeekMode
AbsoluteSeek :: SeekMode
RelativeSeek :: SeekMode
SeekFromEnd :: SeekMode
data () => HandlePosn
data () => BufferMode
NoBuffering :: BufferMode
LineBuffering :: BufferMode
BlockBuffering :: Maybe Int -> BufferMode
data () => Newline
LF :: Newline
CRLF :: Newline
data () => NewlineMode
NewlineMode :: Newline -> Newline -> NewlineMode
[inputNL] :: NewlineMode -> Newline
[outputNL] :: NewlineMode -> Newline
data () => IOMode
ReadMode :: IOMode
WriteMode :: IOMode
AppendMode :: IOMode
ReadWriteMode :: IOMode
data () => UnsafeEquality (a :: k) (b :: k)
[UnsafeRefl] :: forall {k} (a :: k). UnsafeEquality a a
group :: Eq a => [a] -> [[a]]
interruptible :: IO a -> IO a
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
fix :: (a -> a) -> a
all :: Foldable t => (a -> Bool) -> t a -> Bool
and :: Foldable t => t Bool -> Bool
any :: Foldable t => (a -> Bool) -> t a -> Bool
concat :: Foldable t => t [a] -> [a]
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
find :: Foldable t => (a -> Bool) -> t a -> Maybe a
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)
maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
or :: Foldable t => t Bool -> Bool
threadWaitRead :: Fd -> IO ()
threadWaitReadSTM :: Fd -> IO (STM (), IO ())
threadWaitWrite :: Fd -> IO ()
threadWaitWriteSTM :: Fd -> IO (STM (), IO ())
withMVar :: MVar a -> (a -> IO b) -> IO b
groupWith :: Ord b => (a -> b) -> [a] -> [[a]]
inline :: a -> a
lazy :: a -> a
sortWith :: Ord b => (a -> b) -> [a] -> [a]
readP_to_S :: ReadP a -> ReadS a
readS_to_P :: ReadS a -> ReadP a
readP_to_Prec :: (Int -> ReadP a) -> ReadPrec a
readPrec_to_P :: ReadPrec a -> Int -> ReadP a
readPrec_to_S :: ReadPrec a -> Int -> ReadS a
readS_to_Prec :: (Int -> ReadS a) -> ReadPrec a
hPrintf :: HPrintfType r => Handle -> String -> r
printf :: PrintfType r => String -> r
readEither :: Read a => String -> Either String a
readMaybe :: Read a => String -> Maybe a
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
(=<<) :: Monad m => (a -> m b) -> m a -> m b
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
(&&) :: Bool -> Bool -> Bool
(||) :: Bool -> Bool -> Bool
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
(&) :: a -> (a -> b) -> b
($>) :: Functor f => f a -> b -> f b
(<$>) :: Functor f => (a -> b) -> f a -> f b
(<&>) :: Functor f => f a -> (a -> b) -> f b
(>$<) :: Contravariant f => (a -> b) -> f b -> f a
(>$$<) :: Contravariant f => f b -> (a -> b) -> f a
($<) :: Contravariant f => f b -> b -> f a
(%) :: Integral a => a -> a -> Ratio a
($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
(^) :: (Num a, Integral b) => a -> b -> a
(^^) :: (Fractional a, Integral b) => a -> b -> a
(>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
asum :: (Foldable t, Alternative f) => t (f a) -> f a
uncurry :: (a -> b -> c) -> (a, b) -> c
ap :: Monad m => m (a -> b) -> m a -> m b
const :: a -> b -> a
liftA :: Applicative f => (a -> b) -> f a -> f b
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
repeat :: a -> [a]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
showParen :: Bool -> ShowS -> ShowS
showString :: String -> ShowS
optional :: Alternative f => f a -> f (Maybe a)
assert :: Bool -> a -> a
otherwise :: Bool
(++) :: [a] -> [a] -> [a]
map :: (a -> b) -> [a] -> [b]
join :: Monad m => m (m a) -> m a
zip :: [a] -> [b] -> [(a, b)]
filter :: (a -> Bool) -> [a] -> [a]
(<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
either :: (a -> c) -> (b -> c) -> Either a b -> c
fst :: (a, b) -> a
snd :: (a, b) -> b
(<<^) :: Arrow a => a c d -> (b -> c) -> a b d
(>>^) :: Arrow a => a b c -> (c -> d) -> a b d
(^<<) :: Arrow a => (c -> d) -> a b c -> a b d
(^>>) :: Arrow a => (b -> c) -> a c d -> a b d
leftApp :: ArrowApply a => a b c -> a (Either b d) (Either c d)
returnA :: Arrow a => a b b
dupChan :: Chan a -> IO (Chan a)
getChanContents :: Chan a -> IO [a]
newChan :: IO (Chan a)
readChan :: Chan a -> IO a
writeChan :: Chan a -> a -> IO ()
writeList2Chan :: Chan a -> [a] -> IO ()
addMVarFinalizer :: MVar a -> IO () -> IO ()
mkWeakMVar :: MVar a -> IO () -> IO (Weak (MVar a))
modifyMVar :: MVar a -> (a -> IO (a, b)) -> IO b
modifyMVarMasked :: MVar a -> (a -> IO (a, b)) -> IO b
modifyMVarMasked_ :: MVar a -> (a -> IO a) -> IO ()
modifyMVar_ :: MVar a -> (a -> IO a) -> IO ()
swapMVar :: MVar a -> a -> IO a
withMVarMasked :: MVar a -> (a -> IO b) -> IO b
newQSem :: Int -> IO QSem
signalQSem :: QSem -> IO ()
waitQSem :: QSem -> IO ()
newQSemN :: Int -> IO QSemN
signalQSemN :: QSemN -> Int -> IO ()
waitQSemN :: QSemN -> Int -> IO ()
bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
try :: Exception e => IO a -> IO (Either e a)
when :: Applicative f => Bool -> f () -> f ()
threadDelay :: Int -> IO ()
childHandler :: SomeException -> IO ()
forkIO :: IO () -> IO ThreadId
forkIOWithUnmask :: ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
forkOn :: Int -> IO () -> IO ThreadId
forkOnWithUnmask :: Int -> ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
getNumCapabilities :: IO Int
killThread :: ThreadId -> IO ()
mkWeakThreadId :: ThreadId -> IO (Weak ThreadId)
myThreadId :: IO ThreadId
setNumCapabilities :: Int -> IO ()
threadCapability :: ThreadId -> IO (Int, Bool)
throwTo :: Exception e => ThreadId -> e -> IO ()
yield :: IO ()
undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
catch :: Exception e => IO a -> (e -> IO a) -> IO a
getMaskingState :: IO MaskingState
mask :: ((forall a. () => IO a -> IO a) -> IO b) -> IO b
throwIO :: Exception e => e -> IO a
uninterruptibleMask_ :: IO a -> IO a
newIORef :: a -> IO (IORef a)
readIORef :: IORef a -> IO a
writeIORef :: IORef a -> a -> IO ()
isEmptyMVar :: MVar a -> IO Bool
newEmptyMVar :: IO (MVar a)
newMVar :: a -> IO (MVar a)
putMVar :: MVar a -> a -> IO ()
readMVar :: MVar a -> IO a
takeMVar :: MVar a -> IO a
tryPutMVar :: MVar a -> a -> IO Bool
tryReadMVar :: MVar a -> IO (Maybe a)
tryTakeMVar :: MVar a -> IO (Maybe a)
deRefStablePtr :: StablePtr a -> IO a
freeStablePtr :: StablePtr a -> IO ()
newStablePtr :: a -> IO (StablePtr a)
rtsSupportsBoundThreads :: Bool
forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
forkOS :: IO () -> IO ThreadId
forkOSWithUnmask :: ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
isCurrentThreadBound :: IO Bool
runInBoundThread :: IO a -> IO a
runInUnboundThread :: IO a -> IO a
bracketOnError :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket_ :: IO a -> IO b -> IO c -> IO c
catchJust :: Exception e => (e -> Maybe b) -> IO a -> (b -> IO a) -> IO a
finally :: IO a -> IO b -> IO a
handle :: Exception e => (e -> IO a) -> IO a -> IO a
handleJust :: Exception e => (e -> Maybe b) -> (b -> IO a) -> IO a -> IO a
mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
onException :: IO a -> IO b -> IO a
tryJust :: Exception e => (e -> Maybe b) -> IO a -> IO (Either b a)
throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a
evaluate :: a -> IO a
mask_ :: IO a -> IO a
uninterruptibleMask :: ((forall a. () => IO a -> IO a) -> IO b) -> IO b
allowInterrupt :: IO ()
catches :: IO a -> [Handler a] -> IO a
asyncExceptionFromException :: Exception e => SomeException -> Maybe e
asyncExceptionToException :: Exception e => e -> SomeException
ioError :: IOError -> IO a
assertError :: (?callStack :: CallStack) => Bool -> a -> a
foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
void :: Functor f => f a -> f ()
flip :: (a -> b -> c) -> b -> a -> c
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
unzip :: [(a, b)] -> ([a], [b])
(<$!>) :: Monad m => (a -> b) -> m a -> m b
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 ()
unless :: Applicative f => Bool -> f () -> f ()
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
forever :: Applicative f => f a -> f b
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
guard :: Alternative f => Bool -> f ()
fixST :: (a -> ST s a) -> ST s a
errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a
head :: HasCallStack => [a] -> a
tail :: HasCallStack => [a] -> [a]
fixIO :: (a -> IO a) -> IO a
print :: Show a => a -> IO ()
stToIO :: ST RealWorld a -> IO a
runST :: (forall s. () => ST s a) -> a
bitDefault :: (Bits a, Num a) => Int -> a
popCountDefault :: (Bits a, Num a) => a -> Int
testBitDefault :: (Bits a, Num a) => a -> Int -> Bool
toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
(!<<.) :: Bits a => a -> Int -> a
(!>>.) :: Bits a => a -> Int -> a
(.<<.) :: Bits a => a -> Int -> a
(.>>.) :: Bits a => a -> Int -> a
(.^.) :: Bits a => a -> a -> a
oneBits :: FiniteBits a => a
bool :: a -> a -> Bool -> a
not :: Bool -> Bool
ord :: Char -> Int
chr :: Int -> Char
lexLitChar :: ReadS String
readLitChar :: ReadS Char
fromIntegral :: (Integral a, Num b) => a -> b
intToDigit :: Int -> Char
showLitChar :: Char -> ShowS
generalCategory :: Char -> GeneralCategory
isAlpha :: Char -> Bool
isAlphaNum :: Char -> Bool
isAscii :: Char -> Bool
isAsciiLower :: Char -> Bool
isAsciiUpper :: Char -> Bool
isControl :: Char -> Bool
isDigit :: Char -> Bool
isHexDigit :: Char -> Bool
isLatin1 :: Char -> Bool
isLower :: Char -> Bool
isOctDigit :: Char -> Bool
isPrint :: Char -> Bool
isPunctuation :: Char -> Bool
isSpace :: Char -> Bool
isSymbol :: Char -> Bool
isUpper :: Char -> Bool
toLower :: Char -> Char
toTitle :: Char -> Char
toUpper :: Char -> Char
digitToInt :: Char -> Int
isLetter :: Char -> Bool
isMark :: Char -> Bool
isNumber :: Char -> Bool
isSeparator :: Char -> Bool
mkConstrTag :: DataType -> String -> Int -> [String] -> Fixity -> Constr
mkDataType :: String -> [Constr] -> DataType
gcast1 :: forall {k1} {k2} c (t :: k2 -> k1) (t' :: k2 -> k1) (a :: k2). (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a))
castPtr :: Ptr a -> Ptr b
realToFrac :: (Real a, Fractional b) => a -> b
cis :: Floating a => a -> Complex a
conjugate :: Num a => Complex a -> Complex a
magnitude :: RealFloat a => Complex a -> a
mkPolar :: Floating a => a -> a -> Complex a
phase :: RealFloat a => Complex a -> a
polar :: RealFloat a => Complex a -> (a, a)
imagPart :: Complex a -> a
realPart :: Complex a -> a
fromJust :: HasCallStack => Maybe a -> a
findIndex :: (a -> Bool) -> [a] -> Maybe Int
cast :: (Typeable a, Typeable b) => a -> Maybe b
eqT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => Maybe (a :~: b)
funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep
gcast :: forall {k} (a :: k) (b :: k) c. (Typeable a, Typeable b) => c a -> Maybe (c b)
gcast2 :: forall {k1} {k2} {k3} c (t :: k2 -> k3 -> k1) (t' :: k2 -> k3 -> k1) (a :: k2) (b :: k3). (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b))
mkFunTy :: TypeRep -> TypeRep -> TypeRep
rnfTypeRep :: TypeRep -> ()
showsTypeRep :: TypeRep -> ShowS
splitTyConApp :: TypeRep -> (TyCon, [TypeRep])
typeOf :: Typeable a => a -> TypeRep
typeOf1 :: Typeable t => t a -> TypeRep
typeOf2 :: Typeable t => t a b -> TypeRep
typeOf3 :: Typeable t => t a b c -> TypeRep
typeOf4 :: Typeable t => t a b c d -> TypeRep
typeOf5 :: Typeable t => t a b c d e -> TypeRep
typeOf6 :: Typeable t => t a b c d e f -> TypeRep
typeOf7 :: Typeable t => t a b c d e f g -> TypeRep
typeRep :: forall {k} proxy (a :: k). Typeable a => proxy a -> TypeRep
typeRepArgs :: TypeRep -> [TypeRep]
typeRepFingerprint :: TypeRep -> Fingerprint
typeRepTyCon :: TypeRep -> TyCon
rnfTyCon :: TyCon -> ()
trLiftedRep :: TypeRep LiftedRep
tyConFingerprint :: TyCon -> Fingerprint
tyConModule :: TyCon -> String
tyConName :: TyCon -> String
tyConPackage :: TyCon -> String
(!!) :: HasCallStack => [a] -> Int -> a
break :: (a -> Bool) -> [a] -> ([a], [a])
dropWhile :: (a -> Bool) -> [a] -> [a]
reads :: Read a => ReadS a
constrFields :: Constr -> [String]
constrFixity :: Constr -> Fixity
constrIndex :: Constr -> ConIndex
constrRep :: Constr -> ConstrRep
constrType :: Constr -> DataType
dataTypeConstrs :: DataType -> [Constr]
dataTypeName :: DataType -> String
dataTypeRep :: DataType -> DataRep
fromConstr :: Data a => Constr -> a
fromConstrB :: Data a => (forall d. Data d => d) -> Constr -> a
fromConstrM :: (Monad m, Data a) => (forall d. Data d => m d) -> Constr -> m a
indexConstr :: DataType -> ConIndex -> Constr
isAlgType :: DataType -> Bool
isNorepType :: DataType -> Bool
maxConstrIndex :: DataType -> ConIndex
mkCharConstr :: DataType -> Char -> Constr
mkCharType :: String -> DataType
mkConstr :: DataType -> String -> [String] -> Fixity -> Constr
mkFloatType :: String -> DataType
mkIntType :: String -> DataType
mkIntegralConstr :: (Integral a, Show a) => DataType -> a -> Constr
mkNoRepType :: String -> DataType
mkRealConstr :: (Real a, Show a) => DataType -> a -> Constr
readConstr :: DataType -> String -> Maybe Constr
repConstr :: DataType -> ConstrRep -> Constr
showConstr :: Constr -> String
tyconModule :: String -> String
tyconUQname :: String -> String
findIndices :: (a -> Bool) -> [a] -> [Int]
dynApp :: Dynamic -> Dynamic -> Dynamic
dynApply :: Dynamic -> Dynamic -> Maybe Dynamic
dynTypeRep :: Dynamic -> SomeTypeRep
fromDyn :: Typeable a => Dynamic -> a -> a
fromDynamic :: Typeable a => Dynamic -> Maybe a
toDyn :: Typeable a => a -> Dynamic
fromLeft :: a -> Either a b -> a
fromRight :: b -> Either a b -> b
isLeft :: Either a b -> Bool
isRight :: Either a b -> Bool
lefts :: [Either a b] -> [a]
partitionEithers :: [Either a b] -> ([a], [b])
rights :: [Either a b] -> [b]
asTypeOf :: a -> a -> a
replicate :: Int -> a -> [a]
showFixed :: forall {k} (a :: k). HasResolution a => Bool -> Fixed a -> String
div' :: (Real a, Integral b) => a -> a -> b
divMod' :: (Real a, Integral b) => a -> a -> (b, a)
mod' :: Real a => a -> a -> a
fromMaybe :: a -> Maybe a -> a
maybe :: b -> (a -> b) -> Maybe a -> b
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
lex :: ReadS String
readParen :: Bool -> ReadS a -> ReadS a
showChar :: Char -> ShowS
showsBinary1 :: (Show1 f, Show1 g, Show a) => String -> Int -> f a -> g a -> ShowS
showsUnary1 :: (Show1 f, Show a) => String -> Int -> f a -> ShowS
showsUnary :: Show a => String -> Int -> a -> ShowS
readsBinary1 :: (Read1 f, Read1 g, Read a) => String -> (f a -> g a -> t) -> String -> ReadS t
readsUnary1 :: (Read1 f, Read a) => String -> (f a -> t) -> String -> ReadS t
readsUnary :: Read a => String -> (a -> t) -> String -> ReadS t
liftReadList2Default :: Read2 f => (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [f a b]
compare1 :: (Ord1 f, Ord a) => f a -> f a -> Ordering
compare2 :: (Ord2 f, Ord a, Ord b) => f a b -> f a b -> Ordering
eq1 :: (Eq1 f, Eq a) => f a -> f a -> Bool
eq2 :: (Eq2 f, Eq a, Eq b) => f a b -> f a b -> Bool
liftReadListDefault :: Read1 f => (Int -> ReadS a) -> ReadS [a] -> ReadS [f a]
liftReadListPrec2Default :: Read2 f => ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [f a b]
liftReadListPrecDefault :: Read1 f => ReadPrec a -> ReadPrec [a] -> ReadPrec [f a]
readBinaryWith :: ReadPrec a -> ReadPrec b -> String -> (a -> b -> t) -> ReadPrec t
readData :: ReadPrec a -> ReadPrec a
readPrec1 :: (Read1 f, Read a) => ReadPrec (f a)
readPrec2 :: (Read2 f, Read a, Read b) => ReadPrec (f a b)
readUnaryWith :: ReadPrec a -> String -> (a -> t) -> ReadPrec t
readsBinaryWith :: (Int -> ReadS a) -> (Int -> ReadS b) -> String -> (a -> b -> t) -> String -> ReadS t
readsData :: (String -> ReadS a) -> Int -> ReadS a
readsPrec1 :: (Read1 f, Read a) => Int -> ReadS (f a)
readsPrec2 :: (Read2 f, Read a, Read b) => Int -> ReadS (f a b)
readsUnaryWith :: (Int -> ReadS a) -> String -> (a -> t) -> String -> ReadS t
showsBinaryWith :: (Int -> a -> ShowS) -> (Int -> b -> ShowS) -> String -> Int -> a -> b -> ShowS
showsPrec1 :: (Show1 f, Show a) => Int -> f a -> ShowS
showsPrec2 :: (Show2 f, Show a, Show b) => Int -> f a b -> ShowS
showsUnaryWith :: (Int -> a -> ShowS) -> String -> Int -> a -> ShowS
comparisonEquivalence :: Comparison a -> Equivalence a
defaultComparison :: Ord a => Comparison a
defaultEquivalence :: Eq a => Equivalence a
phantom :: (Functor f, Contravariant f) => f a -> f b
atomicModifyIORef' :: IORef a -> (a -> (a, b)) -> IO b
atomicModifyIORef :: IORef a -> (a -> (a, b)) -> IO b
atomicWriteIORef :: IORef a -> a -> IO ()
mkWeakIORef :: IORef a -> IO () -> IO (Weak (IORef a))
modifyIORef :: IORef a -> (a -> a) -> IO ()
modifyIORef' :: IORef a -> (a -> a) -> IO ()
(\\) :: Eq a => [a] -> [a] -> [a]
delete :: Eq a => a -> [a] -> [a]
deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
dropWhileEnd :: (a -> Bool) -> [a] -> [a]
elemIndex :: Eq a => a -> [a] -> Maybe Int
elemIndices :: Eq a => a -> [a] -> [Int]
genericDrop :: Integral i => i -> [a] -> [a]
genericIndex :: Integral i => [a] -> i -> a
genericLength :: Num i => [a] -> i
genericReplicate :: Integral i => i -> a -> [a]
genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
genericTake :: Integral i => i -> [a] -> [a]
groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
inits :: [a] -> [[a]]
insert :: Ord a => a -> [a] -> [a]
insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
intercalate :: [a] -> [[a]] -> [a]
intersect :: Eq a => [a] -> [a] -> [a]
intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
intersperse :: a -> [a] -> [a]
isInfixOf :: Eq a => [a] -> [a] -> Bool
isPrefixOf :: Eq a => [a] -> [a] -> Bool
isSuffixOf :: Eq a => [a] -> [a] -> Bool
lines :: String -> [String]
nub :: Eq a => [a] -> [a]
nubBy :: (a -> a -> Bool) -> [a] -> [a]
partition :: (a -> Bool) -> [a] -> ([a], [a])
permutations :: [a] -> [[a]]
singleton :: a -> [a]
sort :: Ord a => [a] -> [a]
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
sortOn :: Ord b => (a -> b) -> [a] -> [a]
stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]
subsequences :: [a] -> [[a]]
tails :: [a] -> [[a]]
transpose :: [[a]] -> [[a]]
unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
union :: Eq a => [a] -> [a] -> [a]
unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
unlines :: [String] -> String
unwords :: [String] -> String
unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])
unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
words :: String -> [String]
zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
isSubsequenceOf :: Eq a => [a] -> [a] -> Bool
cycle :: HasCallStack => [a] -> [a]
drop :: Int -> [a] -> [a]
foldl1' :: HasCallStack => (a -> a -> a) -> [a] -> a
init :: HasCallStack => [a] -> [a]
iterate :: (a -> a) -> a -> [a]
iterate' :: (a -> a) -> a -> [a]
last :: HasCallStack => [a] -> a
lookup :: Eq a => a -> [(a, b)] -> Maybe b
reverse :: [a] -> [a]
scanl :: (b -> a -> b) -> b -> [a] -> [b]
scanl' :: (b -> a -> b) -> b -> [a] -> [b]
scanl1 :: (a -> a -> a) -> [a] -> [a]
scanr :: (a -> b -> b) -> b -> [a] -> [b]
scanr1 :: (a -> a -> a) -> [a] -> [a]
span :: (a -> Bool) -> [a] -> ([a], [a])
splitAt :: Int -> [a] -> ([a], [a])
take :: Int -> [a] -> [a]
takeWhile :: (a -> Bool) -> [a] -> [a]
uncons :: [a] -> Maybe (a, [a])
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
comparing :: Ord a => (b -> a) -> b -> b -> Ordering
error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
cycle1 :: Semigroup m => m -> m
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
catMaybes :: [Maybe a] -> [a]
isJust :: Maybe a -> Bool
isNothing :: Maybe a -> Bool
listToMaybe :: [a] -> Maybe a
maybeToList :: Maybe a -> [a]
stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
clamp :: Ord a => (a, a) -> a -> a
asProxyTypeOf :: a -> proxy a -> a
denominator :: Ratio a -> a
numerator :: Ratio a -> a
approxRational :: RealFrac a => a -> a -> Rational
newSTRef :: a -> ST s (STRef s a)
readSTRef :: STRef s a -> ST s a
writeSTRef :: STRef s a -> a -> ST s ()
modifySTRef :: STRef s a -> (a -> a) -> ST s ()
modifySTRef' :: STRef s a -> (a -> a) -> ST s ()
stimesIdempotent :: Integral b => b -> a -> a
stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
diff :: Semigroup m => m -> Endo m
mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
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)
curry :: ((a, b) -> c) -> a -> b -> c
swap :: (a, b) -> (b, a)
unsafePerformIO :: IO a -> a
hashUnique :: Unique -> Int
newUnique :: IO Unique
read :: Read a => String -> a
makeVersion :: [Int] -> Version
parseVersion :: ReadP Version
showVersion :: Version -> String
absurd :: Void -> a
vacuous :: Functor f => f Void -> f a
bitReverse16 :: Word16 -> Word16
bitReverse32 :: Word32 -> Word32
bitReverse64 :: Word64 -> Word64
bitReverse8 :: Word8 -> Word8
byteSwap16 :: Word16 -> Word16
byteSwap32 :: Word32 -> Word32
byteSwap64 :: Word64 -> Word64
utf8 :: TextEncoding
unsafeDupablePerformIO :: IO a -> a
nullPtr :: Ptr a
putTraceMsg :: String -> IO ()
flushEventLog :: IO ()
traceEvent :: String -> a -> a
traceEventIO :: String -> IO ()
traceIO :: String -> IO ()
traceId :: String -> String
traceM :: Applicative f => String -> f ()
traceMarker :: String -> a -> a
traceMarkerIO :: String -> IO ()
traceShow :: Show a => a -> b -> b
traceShowId :: Show a => a -> a
traceShowM :: (Show a, Applicative f) => a -> f ()
traceStack :: String -> a -> a
trace :: String -> a -> a
mallocForeignPtrArray :: Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray0 :: Storable a => Int -> IO (ForeignPtr a)
newForeignPtr :: FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtrEnv :: FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO (ForeignPtr a)
addForeignPtrFinalizer :: FinalizerPtr a -> ForeignPtr a -> IO ()
addForeignPtrFinalizerEnv :: FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> IO ()
castForeignPtr :: ForeignPtr a -> ForeignPtr b
finalizeForeignPtr :: ForeignPtr a -> IO ()
mallocForeignPtr :: Storable a => IO (ForeignPtr a)
mallocForeignPtrBytes :: Int -> IO (ForeignPtr a)
newForeignPtr_ :: Ptr a -> IO (ForeignPtr a)
plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b
touchForeignPtr :: ForeignPtr a -> IO ()
withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
alignPtr :: Ptr a -> Int -> Ptr a
castFunPtr :: FunPtr a -> FunPtr b
castFunPtrToPtr :: FunPtr a -> Ptr b
castPtrToFunPtr :: Ptr a -> FunPtr b
minusPtr :: Ptr a -> Ptr b -> Int
nullFunPtr :: FunPtr a
plusPtr :: Ptr a -> Int -> Ptr b
freeHaskellFunPtr :: FunPtr a -> IO ()
intPtrToPtr :: IntPtr -> Ptr a
ptrToIntPtr :: Ptr a -> IntPtr
ptrToWordPtr :: Ptr a -> WordPtr
wordPtrToPtr :: WordPtr -> Ptr a
castPtrToStablePtr :: Ptr () -> StablePtr a
castStablePtrToPtr :: StablePtr a -> Ptr ()
closeFdWith :: (Fd -> IO ()) -> Fd -> IO ()
ensureIOManagerIsRunning :: IO ()
ioManagerCapabilitiesChanged :: IO ()
registerDelay :: Int -> IO (TVar Bool)
runHandlers :: ForeignPtr Word8 -> Signal -> IO ()
setHandler :: Signal -> Maybe (HandlerFun, Dynamic) -> IO (Maybe (HandlerFun, Dynamic))
atomically :: STM a -> IO a
catchSTM :: Exception e => STM a -> (e -> STM a) -> STM a
disableAllocationLimit :: IO ()
enableAllocationLimit :: IO ()
getAllocationCounter :: IO Int64
getNumProcessors :: IO Int
getUncaughtExceptionHandler :: IO (SomeException -> IO ())
labelThread :: ThreadId -> String -> IO ()
newStablePtrPrimMVar :: MVar a -> IO (StablePtr PrimMVar)
newTVar :: a -> STM (TVar a)
newTVarIO :: a -> IO (TVar a)
numCapabilities :: Int
numSparks :: IO Int
par :: a -> b -> b
pseq :: a -> b -> b
readTVar :: TVar a -> STM a
readTVarIO :: TVar a -> IO a
reportError :: SomeException -> IO ()
reportHeapOverflow :: IO ()
reportStackOverflow :: IO ()
retry :: STM a
runSparks :: IO ()
setAllocationCounter :: Int64 -> IO ()
setUncaughtExceptionHandler :: (SomeException -> IO ()) -> IO ()
threadStatus :: ThreadId -> IO ThreadStatus
throwSTM :: Exception e => e -> STM a
unsafeIOToSTM :: IO a -> STM a
writeTVar :: TVar a -> a -> STM ()
unsafeCoerce# :: forall (q :: RuntimeRep) (r :: RuntimeRep) (a :: TYPE q) (b :: TYPE r). a -> b
coerce :: forall {k :: RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
shows :: Show a => a -> ShowS
allocationLimitExceeded :: SomeException
blockedIndefinitelyOnMVar :: SomeException
blockedIndefinitelyOnSTM :: SomeException
cannotCompactFunction :: SomeException
cannotCompactMutable :: SomeException
cannotCompactPinned :: SomeException
heapOverflow :: SomeException
ioException :: IOException -> IO a
stackOverflow :: SomeException
unsupportedOperation :: IOError
untangle :: Addr# -> String -> String
userError :: String -> IOError
floatToDigits :: RealFloat a => Integer -> a -> ([Int], Int)
fromRat :: RealFloat a => Rational -> a
showFloat :: RealFloat a => a -> ShowS
lexDigits :: ReadS String
showSigned :: Real a => (a -> ShowS) -> Int -> a -> ShowS
showEFloat :: RealFloat a => Maybe Int -> a -> ShowS
showFFloat :: RealFloat a => Maybe Int -> a -> ShowS
showGFloat :: RealFloat a => Maybe Int -> a -> ShowS
readBin :: (Eq a, Num a) => ReadS a
readDec :: (Eq a, Num a) => ReadS a
readFloat :: RealFrac a => ReadS a
readHex :: (Eq a, Num a) => ReadS a
readInt :: Num a => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
readOct :: (Eq a, Num a) => ReadS a
readSigned :: Real a => ReadS a -> ReadS a
showBin :: Integral a => a -> ShowS
showFFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS
showGFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS
showHFloat :: RealFloat a => a -> ShowS
showHex :: Integral a => a -> ShowS
showInt :: Integral a => a -> ShowS
showIntAtBase :: Integral a => a -> (Int -> Char) -> a -> ShowS
showOct :: Integral a => a -> ShowS
executablePath :: Maybe (IO (Maybe FilePath))
getExecutablePath :: IO FilePath
mkIOError :: IOErrorType -> String -> Maybe Handle -> Maybe FilePath -> IOError
getArgs :: IO [String]
getEnv :: String -> IO String
getEnvironment :: IO [(String, String)]
getProgName :: IO String
lookupEnv :: String -> IO (Maybe String)
setEnv :: String -> String -> IO ()
unsetEnv :: String -> IO ()
withArgs :: [String] -> IO a -> IO a
withProgName :: String -> IO a -> IO a
hPutStrLn :: Handle -> String -> IO ()
stderr :: Handle
die :: String -> IO a
exitFailure :: IO a
exitSuccess :: IO a
exitWith :: ExitCode -> IO a
char8 :: TextEncoding
latin1 :: TextEncoding
mkTextEncoding :: String -> IO TextEncoding
utf16 :: TextEncoding
utf16be :: TextEncoding
utf16le :: TextEncoding
utf32 :: TextEncoding
utf32be :: TextEncoding
utf32le :: TextEncoding
utf8_bom :: TextEncoding
hClose :: Handle -> IO ()
hFileSize :: Handle -> IO Integer
hFlush :: Handle -> IO ()
hGetBuffering :: Handle -> IO BufferMode
hGetEcho :: Handle -> IO Bool
hGetEncoding :: Handle -> IO (Maybe TextEncoding)
hGetPosn :: Handle -> IO HandlePosn
hIsClosed :: Handle -> IO Bool
hIsEOF :: Handle -> IO Bool
hIsOpen :: Handle -> IO Bool
hIsReadable :: Handle -> IO Bool
hIsSeekable :: Handle -> IO Bool
hIsTerminalDevice :: Handle -> IO Bool
hIsWritable :: Handle -> IO Bool
hLookAhead :: Handle -> IO Char
hSeek :: Handle -> SeekMode -> Integer -> IO ()
hSetBinaryMode :: Handle -> Bool -> IO ()
hSetBuffering :: Handle -> BufferMode -> IO ()
hSetEcho :: Handle -> Bool -> IO ()
hSetEncoding :: Handle -> TextEncoding -> IO ()
hSetFileSize :: Handle -> Integer -> IO ()
hSetNewlineMode :: Handle -> NewlineMode -> IO ()
hSetPosn :: HandlePosn -> IO ()
hShow :: Handle -> IO String
hTell :: Handle -> IO Integer
isEOF :: IO Bool
hGetBuf :: Handle -> Ptr a -> Int -> IO Int
hGetBufNonBlocking :: Handle -> Ptr a -> Int -> IO Int
hGetBufSome :: Handle -> Ptr a -> Int -> IO Int
hGetChar :: Handle -> IO Char
hGetContents :: Handle -> IO String
hGetContents' :: Handle -> IO String
hGetLine :: Handle -> IO String
hPutBuf :: Handle -> Ptr a -> Int -> IO ()
hPutBufNonBlocking :: Handle -> Ptr a -> Int -> IO Int
hPutChar :: Handle -> Char -> IO ()
hPutStr :: Handle -> String -> IO ()
hWaitForInput :: Handle -> Int -> IO Bool
nativeNewline :: Newline
nativeNewlineMode :: NewlineMode
noNewlineTranslation :: NewlineMode
universalNewlineMode :: NewlineMode
openBinaryFile :: FilePath -> IOMode -> IO Handle
openFile :: FilePath -> IOMode -> IO Handle
stdin :: Handle
stdout :: Handle
withBinaryFile :: FilePath -> IOMode -> (Handle -> IO r) -> IO r
withFile :: FilePath -> IOMode -> (Handle -> IO r) -> IO r
appendFile :: FilePath -> String -> IO ()
getChar :: IO Char
getContents :: IO String
getContents' :: IO String
getLine :: IO String
hPrint :: Show a => Handle -> a -> IO ()
hReady :: Handle -> IO Bool
interact :: (String -> String) -> IO ()
localeEncoding :: TextEncoding
openBinaryTempFile :: FilePath -> String -> IO (FilePath, Handle)
openBinaryTempFileWithDefaultPermissions :: FilePath -> String -> IO (FilePath, Handle)
openTempFile :: FilePath -> String -> IO (FilePath, Handle)
openTempFileWithDefaultPermissions :: FilePath -> String -> IO (FilePath, Handle)
putChar :: Char -> IO ()
putStr :: String -> IO ()
putStrLn :: String -> IO ()
readFile :: FilePath -> IO String
readFile' :: FilePath -> IO String
readIO :: Read a => String -> IO a
readLn :: Read a => IO a
writeFile :: FilePath -> String -> IO ()
alreadyExistsErrorType :: IOErrorType
alreadyInUseErrorType :: IOErrorType
annotateIOError :: IOError -> String -> Maybe Handle -> Maybe FilePath -> IOError
catchIOError :: IO a -> (IOError -> IO a) -> IO a
doesNotExistErrorType :: IOErrorType
eofErrorType :: IOErrorType
fullErrorType :: IOErrorType
illegalOperationErrorType :: IOErrorType
ioeGetErrorString :: IOError -> String
ioeGetErrorType :: IOError -> IOErrorType
ioeGetFileName :: IOError -> Maybe FilePath
ioeGetHandle :: IOError -> Maybe Handle
ioeGetLocation :: IOError -> String
ioeSetErrorString :: IOError -> String -> IOError
ioeSetErrorType :: IOError -> IOErrorType -> IOError
ioeSetFileName :: IOError -> FilePath -> IOError
ioeSetHandle :: IOError -> Handle -> IOError
ioeSetLocation :: IOError -> String -> IOError
isAlreadyExistsError :: IOError -> Bool
isAlreadyExistsErrorType :: IOErrorType -> Bool
isAlreadyInUseError :: IOError -> Bool
isAlreadyInUseErrorType :: IOErrorType -> Bool
isDoesNotExistError :: IOError -> Bool
isDoesNotExistErrorType :: IOErrorType -> Bool
isEOFError :: IOError -> Bool
isEOFErrorType :: IOErrorType -> Bool
isFullError :: IOError -> Bool
isFullErrorType :: IOErrorType -> Bool
isIllegalOperation :: IOError -> Bool
isIllegalOperationErrorType :: IOErrorType -> Bool
isPermissionError :: IOError -> Bool
isPermissionErrorType :: IOErrorType -> Bool
isResourceVanishedError :: IOError -> Bool
isResourceVanishedErrorType :: IOErrorType -> Bool
isUserError :: IOError -> Bool
isUserErrorType :: IOErrorType -> Bool
modifyIOError :: (IOError -> IOError) -> IO a -> IO a
permissionErrorType :: IOErrorType
resourceVanishedErrorType :: IOErrorType
tryIOError :: IO a -> IO (Either IOError a)
userErrorType :: IOErrorType
unsafeInterleaveIO :: IO a -> IO a
unsafeFixIO :: (a -> IO a) -> IO a
performMajorGC :: IO ()
performGC :: IO ()
performMinorGC :: IO ()
eqStableName :: StableName a -> StableName b -> Bool
hashStableName :: StableName a -> Int
makeStableName :: a -> IO (StableName a)
timeout :: Int -> IO a -> IO (Maybe a)
unsafeCoerce :: a -> b
unsafeCoerceAddr :: forall (a :: TYPE 'AddrRep) (b :: TYPE 'AddrRep). a -> b
unsafeCoerceUnlifted :: forall (a :: UnliftedType) (b :: UnliftedType). a -> b
unsafeEqualityProof :: forall {k} (a :: k) (b :: k). UnsafeEquality a b
until :: (a -> Bool) -> (a -> a) -> a -> a
subtract :: Num a => a -> a -> a
even :: Integral a => a -> Bool
gcd :: Integral a => a -> a -> a
lcm :: Integral a => a -> a -> a
odd :: Integral a => a -> Bool


-- | A module that reexports only the data types defined across various
--   modules of the "base" package.
--   
--   By data types we mean that it is the ones we use to define data
--   structures. It is not abstraction integration wrappers, like
--   <a>First</a>. It is not resource types like <a>Handle</a>.
module BasePrelude.DataTypes
data () => Bool
False :: Bool
True :: Bool
data () => Char
data () => Double
data () => Either a b
Left :: a -> Either a b
Right :: b -> Either a b
data () => Float
data () => Integer
data () => Maybe a
Nothing :: Maybe a
Just :: a -> Maybe a
type String = [Char]
data () => Int
data () => Int8
data () => Int16
data () => Int32
data () => Int64
data () => Word
data () => Word8
data () => Word16
data () => Word32
data () => Word64
data () => Complex a
(:+) :: !a -> !a -> Complex a
type Rational = Ratio Integer
data () => Natural
data () => NonEmpty a
(:|) :: a -> [a] -> NonEmpty a


-- | A collection of common operators provided across various modules of
--   the "base" package.
module BasePrelude.Operators
(*>) :: Applicative f => f a -> f b -> f b
(<*) :: Applicative f => f a -> f b -> f a
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
(<|>) :: Alternative f => f a -> f a -> f a
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
(=<<) :: Monad m => (a -> m b) -> m a -> m b
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
(>>) :: Monad m => m a -> m b -> m b
(>>=) :: Monad m => m a -> (a -> m b) -> m b
(.&.) :: Bits a => a -> a -> a
(.|.) :: Bits a => a -> a -> a
(&&) :: Bool -> Bool -> Bool
(||) :: Bool -> Bool -> Bool
(/=) :: Eq a => a -> a -> Bool
(==) :: Eq a => a -> a -> Bool
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
(&) :: a -> (a -> b) -> b
(.) :: (b -> c) -> (a -> b) -> a -> c
($>) :: Functor f => f a -> b -> f b
(<$) :: Functor f => a -> f b -> f a
(<$>) :: Functor f => (a -> b) -> f a -> f b
(<&>) :: Functor f => f a -> (a -> b) -> f b
(>$) :: Contravariant f => b -> f b -> f a
(>$<) :: Contravariant f => (a -> b) -> f b -> f a
(>$$<) :: Contravariant f => f b -> (a -> b) -> f a
($<) :: Contravariant f => f b -> b -> f a
(<) :: Ord a => a -> a -> Bool
(<=) :: Ord a => a -> a -> Bool
(>) :: Ord a => a -> a -> Bool
(>=) :: Ord a => a -> a -> Bool
(%) :: Integral a => a -> a -> Ratio a
(<>) :: Semigroup a => a -> a -> a
($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
(*) :: Num a => a -> a -> a
(+) :: Num a => a -> a -> a
(-) :: Num a => a -> a -> a
(/) :: Fractional a => a -> a -> a
(^) :: (Num a, Integral b) => a -> b -> a
(^^) :: (Fractional a, Integral b) => a -> b -> a
