-- 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.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
group :: Eq a => [a] -> [[a]]
interruptible :: IO a -> IO a
class forall a. () => Functor p a => Bifunctor (p :: Type -> Type -> Type)
bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
first :: Bifunctor p => (a -> b) -> p a c -> p b c
second :: Bifunctor p => (b -> c) -> p a b -> p a c
class Monad m => MonadFail (m :: Type -> Type)
fail :: MonadFail m => String -> m 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 ()
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)
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
class IsList l where {
    type Item l;
}
fromList :: IsList l => [Item l] -> l
fromListN :: IsList l => Int -> [Item l] -> l
toList :: IsList l => l -> [Item l]
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
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
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 (Typeable e, Show e) => Exception e
toException :: Exception e => e -> SomeException
fromException :: Exception e => SomeException -> Maybe e
displayException :: Exception e => e -> String
backtraceDesired :: Exception e => e -> Bool
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 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 Num a
(+) :: Num a => a -> a -> a
(-) :: Num a => a -> a -> a
(*) :: Num a => a -> a -> a
negate :: Num a => a -> a
abs :: Num a => a -> a
signum :: Num a => a -> a
fromInteger :: Num a => Integer -> a
class Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b
(<$) :: Functor f => a -> f b -> f a
unzip :: [(a, b)] -> ([a], [b])
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 [] 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
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 Semigroup a
(<>) :: Semigroup a => a -> a -> a
sconcat :: Semigroup a => NonEmpty a -> a
stimes :: (Semigroup a, Integral b) => b -> 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
type String = [Char]
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 ()
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]
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)]
readP_to_S :: ReadP a -> ReadS a
readS_to_P :: ReadS a -> ReadP a
data ReadPrec 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
class Read a
readsPrec :: Read a => Int -> ReadS a
readList :: Read a => ReadS [a]
readPrec :: Read a => ReadPrec a
readListPrec :: Read a => ReadPrec [a]
readEither :: Read a => String -> Either String a
readMaybe :: Read a => String -> Maybe 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
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
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]
(<=<) :: 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
class Eq a
(==) :: Eq a => a -> a -> Bool
(/=) :: Eq a => a -> a -> Bool
($) :: (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
($!) :: (a -> b) -> a -> b
class Num a => Fractional a
(/) :: Fractional a => a -> a -> a
recip :: Fractional a => a -> a
fromRational :: Fractional a => Rational -> a
(^) :: (Num a, Integral b) => a -> b -> a
(^^) :: (Fractional a, Integral b) => a -> b -> a
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
optional :: Alternative f => f a -> f (Maybe 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
asum :: (Foldable t, Alternative f) => t (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]
class Arrow a => ArrowZero (a :: Type -> Type -> Type)
zeroArrow :: ArrowZero a => a b c
class ArrowZero a => ArrowPlus (a :: Type -> Type -> Type)
(<+>) :: ArrowPlus a => a b c -> a b c -> a b c
uncurry :: (a -> b -> c) -> (a, b) -> c
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
mzero :: MonadPlus m => m a
mplus :: MonadPlus m => m a -> m a -> m a
const :: a -> b -> a
ap :: Monad m => m (a -> b) -> m a -> m b
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
data Constr
data DataType
data DataRep
AlgRep :: [Constr] -> DataRep
IntRep :: DataRep
FloatRep :: DataRep
CharRep :: DataRep
NoRep :: DataRep
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
data TyCon
data RealWorld
data Solo a
MkSolo :: a -> Solo a
pattern Solo :: a -> Solo a
data Ordering
LT :: Ordering
EQ :: Ordering
GT :: Ordering
class a ~# b => (a :: k) ~ (b :: k)
class a ~R# b => Coercible (a :: k) (b :: k)
assert :: Bool -> a -> a
otherwise :: Bool
(++) :: [a] -> [a] -> [a]
map :: (a -> b) -> [a] -> [b]
join :: Monad m => m (m a) -> m a
class Arrow a => ArrowLoop (a :: Type -> Type -> Type)
loop :: ArrowLoop a => a (b, d) (c, d) -> a 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 => ArrowApply (a :: Type -> Type -> Type)
app :: ArrowApply a => a (a b c, b) c
type TypeRep = SomeTypeRep
class Typeable (a :: k)
newtype Any
Any :: Bool -> Any
[getAny] :: Any -> Bool
(<<^) :: 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
(<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
(>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
newtype ArrowMonad (a :: Type -> Type -> Type) b
ArrowMonad :: a () b -> ArrowMonad (a :: Type -> Type -> Type) b
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
data Chan a
dupChan :: Chan a -> IO (Chan a)
getChanContents :: Chan a -> IO [a]
newChan :: IO (Chan a)
readChan :: Chan a -> IO a
writeChan :: Chan a -> a -> IO ()
writeList2Chan :: Chan a -> [a] -> IO ()
data QSem
newQSem :: Int -> IO QSem
signalQSem :: QSem -> IO ()
waitQSem :: QSem -> IO ()
data QSemN
newQSemN :: Int -> IO QSemN
signalQSemN :: QSemN -> Int -> IO ()
waitQSemN :: QSemN -> Int -> IO ()
forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
forkOS :: IO () -> IO ThreadId
forkOSWithUnmask :: ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
isCurrentThreadBound :: IO Bool
rtsSupportsBoundThreads :: Bool
runInBoundThread :: IO a -> IO a
runInUnboundThread :: IO a -> IO a
threadDelay :: Int -> IO ()
forkIO :: IO () -> IO ThreadId
forkIOWithUnmask :: ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
forkOn :: Int -> IO () -> IO ThreadId
forkOnWithUnmask :: Int -> ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
getNumCapabilities :: IO Int
killThread :: ThreadId -> IO ()
mkWeakThreadId :: ThreadId -> IO (Weak ThreadId)
myThreadId :: IO ThreadId
setNumCapabilities :: Int -> IO ()
threadCapability :: ThreadId -> IO (Int, Bool)
throwTo :: Exception e => ThreadId -> e -> IO ()
yield :: 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
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)
data ThreadId
ThreadId :: ThreadId# -> ThreadId
data MVar a
data SomeException
SomeException :: e -> SomeException
newtype STM a
STM :: (State# RealWorld -> (# State# RealWorld, a #)) -> STM a
allowInterrupt :: IO ()
catches :: IO a -> [Handler a] -> IO a
bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracketOnError :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket_ :: IO a -> IO b -> IO c -> IO c
catchJust :: Exception e => (e -> Maybe b) -> IO a -> (b -> IO a) -> IO a
finally :: IO a -> IO b -> IO a
handle :: Exception e => (e -> IO a) -> IO a -> IO a
handleJust :: Exception e => (e -> Maybe b) -> (b -> IO a) -> IO a -> IO a
mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
onException :: IO a -> IO b -> IO a
try :: Exception e => IO a -> IO (Either e a)
tryJust :: Exception e => (e -> Maybe b) -> IO a -> IO (Either b a)
throw :: forall a e. (HasCallStack, Exception e) => e -> a
addExceptionContext :: ExceptionAnnotation a => a -> SomeException -> SomeException
someExceptionContext :: SomeException -> ExceptionContext
annotateIO :: ExceptionAnnotation e => e -> IO a -> IO a
catch :: Exception e => IO a -> (e -> IO a) -> IO a
evaluate :: a -> IO a
getMaskingState :: IO MaskingState
mask :: ((forall a. () => IO a -> IO a) -> IO b) -> IO b
mask_ :: IO a -> IO a
throwIO :: (HasCallStack, Exception e) => e -> IO a
uninterruptibleMask :: ((forall a. () => IO a -> IO a) -> IO b) -> IO b
uninterruptibleMask_ :: IO a -> IO a
asyncExceptionFromException :: Exception e => SomeException -> Maybe e
asyncExceptionToException :: Exception e => e -> SomeException
ioError :: IOError -> IO a
data Handler a
Handler :: (e -> IO a) -> Handler a
data NestedAtomically
NestedAtomically :: NestedAtomically
newtype NoMethodError
NoMethodError :: String -> NoMethodError
data NonTermination
NonTermination :: NonTermination
newtype PatternMatchFail
PatternMatchFail :: String -> PatternMatchFail
newtype RecConError
RecConError :: String -> RecConError
newtype RecSelError
RecSelError :: String -> RecSelError
newtype RecUpdError
RecUpdError :: String -> RecUpdError
newtype TypeError
TypeError :: String -> TypeError
data ErrorCall
ErrorCallWithLocation :: String -> String -> ErrorCall
pattern ErrorCall :: String -> ErrorCall
data ArithException
Overflow :: ArithException
Underflow :: ArithException
LossOfPrecision :: ArithException
DivideByZero :: ArithException
Denormal :: ArithException
RatioZeroDenominator :: ArithException
data ExceptionWithContext a
ExceptionWithContext :: ExceptionContext -> a -> ExceptionWithContext a
data MaskingState
Unmasked :: MaskingState
MaskedInterruptible :: MaskingState
MaskedUninterruptible :: MaskingState
data AllocationLimitExceeded
AllocationLimitExceeded :: AllocationLimitExceeded
data ArrayException
IndexOutOfBounds :: String -> ArrayException
UndefinedElement :: String -> ArrayException
newtype AssertionFailed
AssertionFailed :: String -> AssertionFailed
data AsyncException
StackOverflow :: AsyncException
HeapOverflow :: AsyncException
ThreadKilled :: AsyncException
UserInterrupt :: AsyncException
data BlockedIndefinitelyOnMVar
BlockedIndefinitelyOnMVar :: BlockedIndefinitelyOnMVar
data BlockedIndefinitelyOnSTM
BlockedIndefinitelyOnSTM :: BlockedIndefinitelyOnSTM
newtype CompactionFailed
CompactionFailed :: String -> CompactionFailed
data Deadlock
Deadlock :: Deadlock
data 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
assertError :: (?callStack :: CallStack) => Bool -> a -> a
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
when :: Applicative f => Bool -> f () -> f ()
(<$!>) :: Monad m => (a -> b) -> m a -> m b
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
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 ()
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
replicateM :: Applicative m => Int -> m a -> m [a]
replicateM_ :: Applicative m => Int -> m a -> m ()
unless :: Applicative f => Bool -> f () -> f ()
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
void :: Functor f => f a -> f ()
guard :: Alternative f => Bool -> f ()
class Monad m => MonadFix (m :: Type -> Type)
mfix :: MonadFix m => (a -> m a) -> m a
class Monad m => MonadIO (m :: Type -> Type)
liftIO :: MonadIO m => IO a -> m a
fixST :: (a -> ST s a) -> ST s a
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
class Bits b => FiniteBits b
finiteBitSize :: FiniteBits b => b -> Int
countLeadingZeros :: FiniteBits b => b -> Int
countTrailingZeros :: FiniteBits b => b -> Int
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
bool :: a -> a -> Bool -> a
not :: Bool -> Bool
digitToInt :: Char -> Int
isLetter :: Char -> Bool
isMark :: Char -> Bool
isNumber :: Char -> Bool
isSeparator :: Char -> Bool
ord :: Char -> Int
chr :: Int -> Char
lexLitChar :: ReadS String
readLitChar :: ReadS Char
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
isLowerCase :: Char -> Bool
isOctDigit :: Char -> Bool
isPrint :: Char -> Bool
isPunctuation :: Char -> Bool
isSpace :: Char -> Bool
isSymbol :: Char -> Bool
isUpper :: Char -> Bool
isUpperCase :: Char -> Bool
toLower :: Char -> Char
toTitle :: Char -> Char
toUpper :: Char -> Char
class Show a
showsPrec :: Show a => Int -> a -> ShowS
show :: Show a => a -> String
showList :: Show a => [a] -> ShowS
magnitude :: RealFloat a => Complex a -> a
phase :: RealFloat a => Complex a -> a
cis :: Floating a => a -> Complex a
conjugate :: Num a => Complex a -> Complex a
mkPolar :: Floating a => a -> a -> Complex a
polar :: RealFloat a => Complex a -> (a, a)
imagPart :: Complex a -> a
realPart :: Complex a -> a
data (a :: k1) :~~: (b :: k2)
[HRefl] :: forall {k1} (a :: k1). a :~~: a
class Fractional a => Floating a
pi :: Floating a => a
exp :: Floating a => a -> a
log :: Floating a => a -> a
sqrt :: Floating a => a -> a
(**) :: Floating a => a -> a -> a
logBase :: Floating a => a -> a -> a
sin :: Floating a => a -> a
cos :: Floating a => a -> a
tan :: Floating a => a -> a
asin :: Floating a => a -> a
acos :: Floating a => a -> a
atan :: Floating a => a -> a
sinh :: Floating a => a -> a
cosh :: Floating a => a -> a
tanh :: Floating a => a -> a
asinh :: Floating a => a -> a
acosh :: Floating a => a -> a
atanh :: Floating a => a -> a
log1p :: Floating a => a -> a
expm1 :: Floating a => a -> a
log1pexp :: Floating a => a -> a
log1mexp :: Floating a => a -> a
class (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
newtype Product a
Product :: a -> Product a
[getProduct] :: Product a -> a
newtype Sum a
Sum :: a -> Sum a
[getSum] :: Sum a -> a
type ShowS = String -> String
realToFrac :: (Real a, Fractional b) => a -> b
fromIntegral :: (Integral a, Num b) => a -> b
class (Num a, Ord a) => Real a
toRational :: Real a => a -> Rational
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 (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 FunPtr 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
mkConstrTag :: DataType -> String -> Int -> [String] -> Fixity -> Constr
mkDataType :: String -> [Constr] -> DataType
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
cast :: (Typeable a, Typeable b) => a -> Maybe b
decT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => Either ((a :~: b) -> Void) (a :~: 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)
gcast1 :: forall {k1} {k2} c (t :: k2 -> k1) (t' :: k2 -> k1) (a :: k2). (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a))
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))
hdecT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => Either ((a :~~: b) -> Void) (a :~~: b)
heqT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => Maybe (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
type ConIndex = Int
data ConstrRep
AlgConstr :: ConIndex -> ConstrRep
IntConstr :: Integer -> ConstrRep
FloatConstr :: Rational -> ConstrRep
CharConstr :: Char -> ConstrRep
data Fixity
Prefix :: Fixity
Infix :: Fixity
data (a :: k) :~: (b :: k)
[Refl] :: forall {k} (a :: k). a :~: a
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
either :: (a -> c) -> (b -> c) -> Either a b -> c
fromLeft :: a -> Either a b -> a
fromRight :: b -> Either a b -> b
isLeft :: Either a b -> Bool
isRight :: Either a b -> Bool
lefts :: [Either a b] -> [a]
partitionEithers :: [Either a b] -> ([a], [b])
rights :: [Either a b] -> [b]
class HasResolution (a :: k)
resolution :: HasResolution a => p a -> Integer
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
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
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
foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m 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 ()
sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
flip :: (a -> b -> c) -> b -> a -> c
applyWhen :: Bool -> (a -> a) -> a -> a
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
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
class forall a. Eq a => Eq1 f a => Eq2 (f :: Type -> Type -> Type)
liftEq2 :: Eq2 f => (a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool
class (Eq2 f, forall a. Ord a => Ord1 f a) => Ord2 (f :: Type -> Type -> Type)
liftCompare2 :: Ord2 f => (a -> b -> Ordering) -> (c -> d -> Ordering) -> f a c -> f b d -> Ordering
class forall a. Read a => Read f a => 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 forall a. Read a => Read1 f a => 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 forall a. Show a => Show1 f a => 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
class forall a. Eq a => Eq f a => Eq1 (f :: Type -> Type)
liftEq :: Eq1 f => (a -> b -> Bool) -> f a -> f b -> Bool
class (Eq1 f, forall a. Ord a => Ord f a) => Ord1 (f :: Type -> Type)
liftCompare :: Ord1 f => (a -> b -> Ordering) -> f a -> f b -> Ordering
class forall a. Show a => Show f a => 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
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
newtype Down a
Down :: a -> Down a
[getDown] :: Down a -> a
readParen :: Bool -> ReadS a -> ReadS a
newtype All
All :: Bool -> All
[getAll] :: All -> Bool
zip :: [a] -> [b] -> [(a, b)]
filter :: (a -> Bool) -> [a] -> [a]
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
comparisonEquivalence :: Comparison a -> Equivalence a
defaultComparison :: Ord a => Comparison a
defaultEquivalence :: Eq a => Equivalence a
phantom :: (Functor f, Contravariant f) => f a -> f b
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
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 ()
atomicModifyIORef' :: IORef a -> (a -> (a, b)) -> IO b
newIORef :: a -> IO (IORef a)
readIORef :: IORef a -> IO a
writeIORef :: IORef a -> a -> IO ()
isSubsequenceOf :: Eq a => [a] -> [a] -> Bool
(\\) :: 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]
findIndex :: (a -> Bool) -> [a] -> Maybe Int
findIndices :: (a -> Bool) -> [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]
(!!) :: HasCallStack => [a] -> Int -> a
(!?) :: [a] -> Int -> Maybe a
break :: (a -> Bool) -> [a] -> ([a], [a])
cycle :: HasCallStack => [a] -> [a]
drop :: Int -> [a] -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
foldl1' :: HasCallStack => (a -> a -> a) -> [a] -> a
head :: HasCallStack => [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
repeat :: a -> [a]
replicate :: Int -> a -> [a]
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])
tail :: HasCallStack => [a] -> [a]
take :: Int -> [a] -> [a]
takeWhile :: (a -> Bool) -> [a] -> [a]
uncons :: [a] -> Maybe (a, [a])
unsnoc :: [a] -> Maybe ([a], a)
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
comparing :: Ord a => (b -> a) -> b -> b -> Ordering
cycle1 :: Semigroup m => m -> m
fst :: (a, b) -> a
snd :: (a, b) -> b
catMaybes :: [Maybe a] -> [a]
fromJust :: HasCallStack => Maybe a -> a
fromMaybe :: a -> Maybe a -> a
isJust :: Maybe a -> Bool
isNothing :: Maybe a -> Bool
listToMaybe :: [a] -> Maybe a
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
maybe :: b -> (a -> b) -> Maybe a -> b
maybeToList :: Maybe a -> [a]
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 Dual a
Dual :: a -> Dual a
[getDual] :: Dual a -> a
newtype Endo a
Endo :: (a -> a) -> Endo a
[appEndo] :: Endo a -> a -> a
clamp :: Ord a => (a, a) -> a -> a
asProxyTypeOf :: a -> proxy a -> a
data KProxy t
KProxy :: KProxy t
approxRational :: RealFrac a => a -> a -> Rational
denominator :: Ratio a -> a
numerator :: Ratio a -> a
modifySTRef :: STRef s a -> (a -> a) -> ST s ()
modifySTRef' :: STRef s a -> (a -> a) -> ST s ()
newSTRef :: a -> ST s (STRef s a)
readSTRef :: STRef s a -> ST s a
writeSTRef :: STRef s a -> a -> ST s ()
data Arg a b
Arg :: a -> b -> Arg a b
newtype Max a
Max :: a -> Max a
[getMax] :: Max a -> a
newtype Min a
Min :: a -> Min a
[getMin] :: Min a -> a
newtype WrappedMonoid m
WrapMonoid :: m -> WrappedMonoid m
[unwrapMonoid] :: WrappedMonoid m -> m
diff :: Semigroup m => m -> Endo m
mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
stimesIdempotent :: Integral b => b -> a -> a
stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
type ArgMax a b = Max Arg a b
type ArgMin a b = Min Arg a b
fmapDefault :: Traversable t => (a -> b) -> t a -> t b
foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m
for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
forAccumM :: (Monad m, Traversable t) => s -> t a -> (s -> a -> m (s, b)) -> m (s, t b)
mapAccumM :: (Monad m, Traversable t) => (s -> a -> m (s, b)) -> s -> t a -> m (s, t b)
curry :: ((a, b) -> c) -> a -> b -> c
swap :: (a, b) -> (b, a)
getSolo :: Solo a -> a
hashUnique :: Unique -> Int
newUnique :: IO Unique
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
flushEventLog :: IO ()
putTraceMsg :: String -> IO ()
traceEvent :: String -> a -> a
traceEventIO :: String -> IO ()
traceEventWith :: (a -> String) -> a -> a
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 ()
traceShowWith :: Show b => (a -> b) -> a -> a
traceStack :: String -> a -> a
traceWith :: (a -> 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
type FinalizerEnvPtr env a = FunPtr Ptr env -> Ptr a -> IO ()
type FinalizerPtr a = FunPtr Ptr a -> IO ()
freeHaskellFunPtr :: FunPtr a -> IO ()
intPtrToPtr :: IntPtr -> Ptr a
ptrToIntPtr :: Ptr a -> IntPtr
ptrToWordPtr :: Ptr a -> WordPtr
wordPtrToPtr :: WordPtr -> Ptr a
alignPtr :: Ptr a -> Int -> Ptr a
castFunPtr :: FunPtr a -> FunPtr b
castFunPtrToPtr :: FunPtr a -> Ptr b
castPtr :: Ptr a -> Ptr b
castPtrToFunPtr :: Ptr a -> FunPtr b
minusPtr :: Ptr a -> Ptr b -> Int
nullFunPtr :: FunPtr a
nullPtr :: Ptr a
plusPtr :: Ptr a -> Int -> Ptr b
newtype IntPtr
IntPtr :: Int -> IntPtr
newtype WordPtr
WordPtr :: Word -> WordPtr
castPtrToStablePtr :: Ptr () -> StablePtr a
castStablePtrToPtr :: StablePtr a -> Ptr ()
deRefStablePtr :: StablePtr a -> IO a
freeStablePtr :: StablePtr a -> IO ()
newStablePtr :: a -> IO (StablePtr a)
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
childHandler :: SomeException -> IO ()
disableAllocationLimit :: IO ()
enableAllocationLimit :: IO ()
getAllocationCounter :: IO Int64
getNumProcessors :: IO Int
getUncaughtExceptionHandler :: IO (SomeException -> IO ())
labelThread :: ThreadId -> String -> IO ()
listThreads :: IO [ThreadId]
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 ()
newStablePtrPrimMVar :: MVar a -> IO (StablePtr PrimMVar)
type HandlerFun = ForeignPtr Word8 -> IO ()
type Signal = CInt
data BlockReason
BlockedOnMVar :: BlockReason
BlockedOnBlackHole :: BlockReason
BlockedOnException :: BlockReason
BlockedOnSTM :: BlockReason
BlockedOnForeignCall :: BlockReason
BlockedOnOther :: BlockReason
data TVar a
TVar :: TVar# RealWorld a -> TVar a
data ThreadStatus
ThreadRunning :: ThreadStatus
ThreadFinished :: ThreadStatus
ThreadBlocked :: BlockReason -> ThreadStatus
ThreadDied :: ThreadStatus
data PrimMVar
type family Item l
unsafeCoerce# :: a -> b
coerce :: Coercible a b => a -> b
seq :: a -> b -> b
class IsString a
fromString :: IsString a => String -> a
allocationLimitExceeded :: SomeException
blockedIndefinitelyOnMVar :: SomeException
blockedIndefinitelyOnSTM :: SomeException
cannotCompactFunction :: SomeException
cannotCompactMutable :: SomeException
cannotCompactPinned :: SomeException
heapOverflow :: SomeException
ioException :: HasCallStack => IOException -> IO a
stackOverflow :: SomeException
unsupportedOperation :: IOError
untangle :: Addr# -> String -> String
userError :: String -> IOError
data ExitCode
ExitSuccess :: ExitCode
ExitFailure :: Int -> ExitCode
data FixIOException
FixIOException :: FixIOException
type IOError = IOException
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
class IsLabel (x :: Symbol) a
fromLabel :: IsLabel x a => a
floatToDigits :: RealFloat a => Integer -> a -> ([Int], Int)
fromRat :: RealFloat a => Rational -> a
showFloat :: RealFloat a => 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
showEFloat :: RealFloat a => Maybe Int -> a -> ShowS
showFFloat :: RealFloat a => Maybe Int -> a -> ShowS
showFFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS
showGFloat :: 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
lexDigits :: ReadS String
showSigned :: Real a => (a -> ShowS) -> Int -> a -> ShowS
minusNaturalMaybe :: Natural -> Natural -> Maybe Natural
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
executablePath :: Maybe (IO (Maybe FilePath))
getExecutablePath :: IO FilePath
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 :: 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 ()
hPutStrLn :: 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
stderr :: 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 ()
fixIO :: (a -> IO a) -> IO a
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 ()
type FilePath = String
data SeekMode
AbsoluteSeek :: SeekMode
RelativeSeek :: SeekMode
SeekFromEnd :: SeekMode
data TextEncoding
data HandlePosn
data BufferMode
NoBuffering :: BufferMode
LineBuffering :: BufferMode
BlockBuffering :: Maybe Int -> BufferMode
data Handle
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
print :: Show a => a -> 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
mkIOError :: IOErrorType -> String -> Maybe Handle -> Maybe FilePath -> IOError
modifyIOError :: (IOError -> IOError) -> IO a -> IO a
permissionErrorType :: IOErrorType
resourceVanishedErrorType :: IOErrorType
tryIOError :: IO a -> IO (Either IOError a)
userErrorType :: IOErrorType
unsafeFixIO :: (a -> IO a) -> IO a
unsafeDupablePerformIO :: IO a -> a
unsafeInterleaveIO :: IO a -> IO a
unsafePerformIO :: IO a -> a
performBlockingMajorGC :: IO ()
performGC :: IO ()
performMajorGC :: 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)
lex :: ReadS String
read :: Read a => String -> a
reads :: Read a => ReadS a
unsafeCoerce :: a -> b
unsafeCoerceAddr :: forall (a :: TYPE 'AddrRep) (b :: TYPE 'AddrRep). a -> b
unsafeCoerceUnlifted :: forall (a :: UnliftedType) (b :: UnliftedType). a -> b
data UnsafeEquality (a :: k) (b :: k)
[UnsafeRefl] :: forall {k} (a :: k). UnsafeEquality a a
unsafeEqualityProof :: forall {k} (a :: k) (b :: k). UnsafeEquality a b
asTypeOf :: a -> a -> a
until :: (a -> Bool) -> (a -> a) -> a -> a
error :: HasCallStack => [Char] -> a
errorWithoutStackTrace :: [Char] -> a
undefined :: HasCallStack => 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
showChar :: Char -> ShowS
showParen :: Bool -> ShowS -> ShowS
showString :: String -> ShowS
shows :: Show a => a -> ShowS
class HasField (x :: k) r a | x r -> a
getField :: HasField x r a => r -> a


-- | 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
($) :: (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
($!) :: (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
