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


-- | Provides functions available in later versions of <tt>base</tt> to a
--   wider range of compilers, without requiring you to use CPP pragmas in
--   your code. See the <a>README</a> for what is covered. Also see the
--   <a>changelog</a> for recent changes.
--   
--   Note that <tt>base-compat</tt> does not add any orphan instances.
--   There is a separate package, <tt><a>base-orphans</a></tt>, for that.
--   
--   In addition, <tt>base-compat</tt> does not backport any data types or
--   type classes. See <tt><a>this section of the README</a></tt> for more
--   info.
--   
--   <tt>base-compat</tt> is designed to have zero dependencies. For a
--   version of <tt>base-compat</tt> that depends on compatibility
--   libraries for a wider support window, see the
--   <tt><a>base-compat-batteries</a></tt> package. Most of the modules in
--   this library have the same names as in <tt>base-compat-batteries</tt>
--   to make it easier to switch between the two. There also exist versions
--   of each module with the suffix <tt>.Repl</tt>, which are distinct from
--   anything in <tt>base-compat-batteries</tt>, to allow for easier use in
--   GHCi.
@package base-compat
@version 0.14.1

module Control.Concurrent.Compat
forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
threadWaitRead :: Fd -> IO ()
threadWaitReadSTM :: Fd -> IO (STM (), IO ())
threadWaitWrite :: Fd -> IO ()
threadWaitWriteSTM :: Fd -> IO (STM (), IO ())
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 ()
newQSem :: Int -> IO QSem
signalQSem :: QSem -> IO ()
waitQSem :: QSem -> IO ()
newQSemN :: Int -> IO QSemN
signalQSemN :: QSemN -> Int -> IO ()
waitQSemN :: QSemN -> Int -> IO ()
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
withMVar :: MVar a -> (a -> IO b) -> IO b
withMVarMasked :: MVar a -> (a -> IO b) -> IO b
isEmptyMVar :: MVar a -> IO Bool
newEmptyMVar :: IO (MVar a)
newMVar :: a -> IO (MVar a)
putMVar :: MVar a -> a -> IO ()
readMVar :: MVar a -> IO a
takeMVar :: MVar a -> IO a
tryPutMVar :: MVar a -> a -> IO Bool
tryReadMVar :: MVar a -> IO (Maybe a)
tryTakeMVar :: MVar a -> IO (Maybe a)
data Chan a
data QSem
data QSemN
data ThreadId
data MVar a
forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
forkOSWithUnmask :: ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId


-- | Reexports <a>Control.Concurrent.Compat</a> from a globally unique
--   namespace.
module Control.Concurrent.Compat.Repl

module Control.Concurrent.MVar.Compat
addMVarFinalizer :: MVar a -> IO () -> IO ()
mkWeakMVar :: MVar a -> IO () -> IO (Weak (MVar a))
modifyMVar :: MVar a -> (a -> IO (a, b)) -> IO b
modifyMVarMasked :: MVar a -> (a -> IO (a, b)) -> IO b
modifyMVarMasked_ :: MVar a -> (a -> IO a) -> IO ()
modifyMVar_ :: MVar a -> (a -> IO a) -> IO ()
swapMVar :: MVar a -> a -> IO a
withMVar :: MVar a -> (a -> IO b) -> IO b
withMVarMasked :: MVar a -> (a -> IO b) -> IO b
isEmptyMVar :: MVar a -> IO Bool
newEmptyMVar :: IO (MVar a)
newMVar :: a -> IO (MVar a)
putMVar :: MVar a -> a -> IO ()
readMVar :: MVar a -> IO a
takeMVar :: MVar a -> IO a
tryPutMVar :: MVar a -> a -> IO Bool
tryReadMVar :: MVar a -> IO (Maybe a)
tryTakeMVar :: MVar a -> IO (Maybe a)
data MVar a
withMVarMasked :: MVar a -> (a -> IO b) -> IO b


-- | Reexports <a>Control.Concurrent.MVar.Compat</a> from a globally unique
--   namespace.
module Control.Concurrent.MVar.Compat.Repl

module Control.Exception.Compat
assert :: Bool -> a -> a
throwTo :: Exception e => ThreadId -> e -> IO ()
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)
tryWithContext :: Exception e => IO a -> IO (Either (ExceptionWithContext e) 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
catchNoPropagate :: Exception e => IO a -> (ExceptionWithContext e -> IO a) -> IO a
evaluate :: a -> IO a
getMaskingState :: IO MaskingState
interruptible :: IO a -> IO a
mask :: ((forall a. () => IO a -> IO a) -> IO b) -> IO b
mask_ :: IO a -> IO a
rethrowIO :: Exception e => ExceptionWithContext e -> 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 :: HasCallStack => 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
ErrorCall :: String -> ErrorCall
pattern ErrorCallWithLocation :: String -> String -> ErrorCall
data ArithException
Overflow :: ArithException
Underflow :: ArithException
LossOfPrecision :: ArithException
DivideByZero :: ArithException
Denormal :: ArithException
RatioZeroDenominator :: ArithException
class (Typeable e, Show e) => Exception e
toException :: Exception e => e -> SomeException
fromException :: Exception e => SomeException -> Maybe e
displayException :: Exception e => e -> String
backtraceDesired :: Exception e => e -> Bool
data ExceptionWithContext a
ExceptionWithContext :: ExceptionContext -> a -> ExceptionWithContext a
newtype NoBacktrace e
NoBacktrace :: e -> NoBacktrace e
data SomeException
SomeException :: e -> SomeException
data WhileHandling
WhileHandling :: SomeException -> WhileHandling
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
data SomeAsyncException
SomeAsyncException :: e -> SomeAsyncException
throw :: forall a e. (HasCallStack, Exception e) => e -> a


-- | Reexports <a>Control.Exception.Compat</a> from a globally unique
--   namespace.
module Control.Exception.Compat.Repl

module Control.Monad.Compat
(=<<) :: Monad m => (a -> m b) -> m a -> m b
ap :: Monad m => m (a -> b) -> m a -> m b
join :: Monad m => m (m a) -> m a
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
when :: Applicative f => Bool -> f () -> f ()
(<$!>) :: Monad m => (a -> b) -> m a -> m b
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
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
guard :: Alternative f => Bool -> f ()
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 ()
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 ()
void :: Functor f => f a -> f ()
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
class Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b
(<$) :: Functor f => a -> f b -> f a
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
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
mzero :: MonadPlus m => m a
mplus :: MonadPlus m => m a -> m a -> m a
class Monad m => MonadFail (m :: Type -> Type)
fail :: MonadFail m => String -> m 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)
class Applicative m => Monad (m :: Type -> Type)
class Monad m => MonadFail (m :: Type -> Type)
fail :: MonadFail m => String -> m a
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
mzero :: MonadPlus m => m a
mplus :: MonadPlus m => m a -> m a -> m a


-- | Reexports <a>Control.Monad.Compat</a> from a globally unique
--   namespace.
module Control.Monad.Compat.Repl

module Control.Monad.Fail.Compat
class Monad m => MonadFail (m :: Type -> Type)
fail :: MonadFail m => String -> m a


-- | Reexports <a>Control.Monad.Fail.Compat</a> from a globally unique
--   namespace.
module Control.Monad.Fail.Compat.Repl

module Control.Monad.IO.Class.Compat
class Monad m => MonadIO (m :: Type -> Type)
liftIO :: MonadIO m => IO a -> m a


-- | Reexports <a>Control.Monad.IO.Class.Compat</a> from a globally unique
--   namespace.
module Control.Monad.IO.Class.Compat.Repl

module Control.Monad.ST.Lazy.Unsafe.Compat
unsafeInterleaveST :: ST s a -> ST s a
unsafeIOToST :: IO a -> ST s a


-- | Reexports <a>Control.Monad.ST.Lazy.Unsafe.Compat</a> from a globally
--   unique namespace.
module Control.Monad.ST.Lazy.Unsafe.Compat.Repl

module Control.Monad.ST.Unsafe.Compat
unsafeInterleaveST :: ST s a -> ST s a
unsafeIOToST :: IO a -> ST s a
unsafeSTToIO :: ST s a -> IO a


-- | Reexports <a>Control.Monad.ST.Unsafe.Compat</a> from a globally unique
--   namespace.
module Control.Monad.ST.Unsafe.Compat.Repl

module Data.Bifoldable.Compat
biList :: Bifoldable t => t a a -> [a]
biall :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool
biand :: Bifoldable t => t Bool Bool -> Bool
biany :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool
biasum :: (Bifoldable t, Alternative f) => t (f a) (f a) -> f a
biconcat :: Bifoldable t => t [a] [a] -> [a]
biconcatMap :: Bifoldable t => (a -> [c]) -> (b -> [c]) -> t a b -> [c]
bielem :: (Bifoldable t, Eq a) => a -> t a a -> Bool
bifind :: Bifoldable t => (a -> Bool) -> t a a -> Maybe a
bifoldl' :: Bifoldable t => (a -> b -> a) -> (a -> c -> a) -> a -> t b c -> a
bifoldl1 :: Bifoldable t => (a -> a -> a) -> t a a -> a
bifoldlM :: (Bifoldable t, Monad m) => (a -> b -> m a) -> (a -> c -> m a) -> a -> t b c -> m a
bifoldr' :: Bifoldable t => (a -> c -> c) -> (b -> c -> c) -> c -> t a b -> c
bifoldr1 :: Bifoldable t => (a -> a -> a) -> t a a -> a
bifoldrM :: (Bifoldable t, Monad m) => (a -> c -> m c) -> (b -> c -> m c) -> c -> t a b -> m c
biforM_ :: (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f ()
bifor_ :: (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f ()
bilength :: Bifoldable t => t a b -> Int
bimapM_ :: (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()
bimaximum :: (Bifoldable t, Ord a) => t a a -> a
bimaximumBy :: Bifoldable t => (a -> a -> Ordering) -> t a a -> a
biminimum :: (Bifoldable t, Ord a) => t a a -> a
biminimumBy :: Bifoldable t => (a -> a -> Ordering) -> t a a -> a
bimsum :: (Bifoldable t, Alternative f) => t (f a) (f a) -> f a
binotElem :: (Bifoldable t, Eq a) => a -> t a a -> Bool
binull :: Bifoldable t => t a b -> Bool
bior :: Bifoldable t => t Bool Bool -> Bool
biproduct :: (Bifoldable t, Num a) => t a a -> a
bisequenceA_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()
bisequence_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()
bisum :: (Bifoldable t, Num a) => t a a -> a
bitraverse_ :: (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()
class Bifoldable (p :: Type -> Type -> Type)
bifold :: (Bifoldable p, Monoid m) => p m m -> m
bifoldMap :: (Bifoldable p, Monoid m) => (a -> m) -> (b -> m) -> p a b -> m
bifoldr :: Bifoldable p => (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
bifoldl :: Bifoldable p => (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c


-- | Reexports <a>Data.Bifoldable.Compat</a> from a globally unique
--   namespace.
module Data.Bifoldable.Compat.Repl

module Data.Bifoldable1.Compat
class Bifoldable t => Bifoldable1 (t :: Type -> Type -> Type)
bifold1 :: (Bifoldable1 t, Semigroup m) => t m m -> m
bifoldMap1 :: (Bifoldable1 t, Semigroup m) => (a -> m) -> (b -> m) -> t a b -> m


-- | Reexports <a>Data.Bifoldable1.Compat</a> from a globally unique
--   namespace.
module Data.Bifoldable1.Compat.Repl

module Data.Bifunctor.Compat
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


-- | Reexports <a>Data.Bifunctor.Compat</a> from a globally unique
--   namespace.
module Data.Bifunctor.Compat.Repl

module Data.Bitraversable.Compat
bifoldMapDefault :: (Bitraversable t, Monoid m) => (a -> m) -> (b -> m) -> t a b -> m
bifor :: (Bitraversable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d)
biforM :: (Bitraversable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d)
bimapAccumL :: Bitraversable t => (a -> b -> (a, c)) -> (a -> d -> (a, e)) -> a -> t b d -> (a, t c e)
bimapAccumR :: Bitraversable t => (a -> b -> (a, c)) -> (a -> d -> (a, e)) -> a -> t b d -> (a, t c e)
bimapDefault :: Bitraversable t => (a -> b) -> (c -> d) -> t a c -> t b d
bimapM :: (Bitraversable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
bisequence :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b)
bisequenceA :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b)
firstA :: (Bitraversable t, Applicative f) => (a -> f c) -> t a b -> f (t c b)
secondA :: (Bitraversable t, Applicative f) => (b -> f c) -> t a b -> f (t a c)
class (Bifunctor t, Bifoldable t) => Bitraversable (t :: Type -> Type -> Type)
bitraverse :: (Bitraversable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
firstA :: (Bitraversable t, Applicative f) => (a -> f c) -> t a b -> f (t c b)
secondA :: (Bitraversable t, Applicative f) => (b -> f c) -> t a b -> f (t a c)


-- | Reexports <a>Data.Bitraversable.Compat</a> from a globally unique
--   namespace.
module Data.Bitraversable.Compat.Repl

module Data.Bits.Compat
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 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
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
bitDefault :: (Bits a, Num a) => Int -> a
testBitDefault :: (Bits a, Num a) => a -> Int -> Bool
popCountDefault :: (Bits a, Num a) => a -> Int
(.^.) :: Bits a => a -> a -> a
(.>>.) :: Bits a => a -> Int -> a
(.<<.) :: Bits a => a -> Int -> a
(!>>.) :: Bits a => a -> Int -> a
(!<<.) :: Bits a => a -> Int -> a
toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
oneBits :: FiniteBits a => a


-- | Reexports <a>Data.Bits.Compat</a> from a globally unique namespace.
module Data.Bits.Compat.Repl

module Data.Bool.Compat
otherwise :: Bool
bool :: a -> a -> Bool -> a
(&&) :: Bool -> Bool -> Bool
not :: Bool -> Bool
(||) :: Bool -> Bool -> Bool
data Bool
False :: Bool
True :: Bool
bool :: a -> a -> Bool -> a


-- | Reexports <a>Data.Bool.Compat</a> from a globally unique namespace.
module Data.Bool.Compat.Repl

module Data.Complex.Compat
cis :: Floating a => a -> Complex a
conjugate :: Num a => Complex a -> Complex a
imagPart :: Complex a -> a
magnitude :: RealFloat a => Complex a -> a
mkPolar :: Floating a => a -> a -> Complex a
phase :: RealFloat a => Complex a -> a
polar :: RealFloat a => Complex a -> (a, a)
realPart :: Complex a -> a
data Complex a
(:+) :: !a -> !a -> Complex a


-- | Reexports <a>Data.Complex.Compat</a> from a globally unique namespace.
module Data.Complex.Compat.Repl

module Data.Either.Compat
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]
data Either a b
Left :: a -> Either a b
Right :: b -> Either a b
isLeft :: Either a b -> Bool
isRight :: Either a b -> Bool
fromLeft :: a -> Either a b -> a
fromRight :: b -> Either a b -> b


-- | Reexports <a>Data.Either.Compat</a> from a globally unique namespace.
module Data.Either.Compat.Repl

module Data.Foldable.Compat
all :: Foldable t => (a -> Bool) -> t a -> Bool
and :: Foldable t => t Bool -> Bool
any :: Foldable t => (a -> Bool) -> t a -> Bool
asum :: (Foldable t, Alternative f) => t (f a) -> f a
concat :: Foldable t => t [a] -> [a]
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
find :: Foldable t => (a -> Bool) -> t a -> Maybe 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
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
or :: Foldable t => t Bool -> Bool
sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
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
toList :: Foldable t => t a -> [a]
null :: Foldable t => t a -> Bool
length :: Foldable t => t a -> Int
elem :: (Foldable t, Eq a) => a -> t a -> Bool
maximum :: (Foldable t, Ord a) => t a -> a
minimum :: (Foldable t, Ord a) => t a -> a
sum :: (Foldable t, Num a) => t a -> a
product :: (Foldable t, Num a) => t a -> a


-- | Reexports <a>Data.Foldable.Compat</a> from a globally unique
--   namespace.
module Data.Foldable.Compat.Repl

module Data.Foldable1.Compat
foldl1 :: Foldable1 t => (a -> a -> a) -> t a -> a
foldl1' :: Foldable1 t => (a -> a -> a) -> t a -> a
foldlM1 :: (Foldable1 t, Monad m) => (a -> a -> m a) -> t a -> m a
foldlMapM1 :: (Foldable1 t, Monad m) => (a -> m b) -> (b -> a -> m b) -> t a -> m b
foldr1 :: Foldable1 t => (a -> a -> a) -> t a -> a
foldr1' :: Foldable1 t => (a -> a -> a) -> t a -> a
foldrM1 :: (Foldable1 t, Monad m) => (a -> a -> m a) -> t a -> m a
foldrMapM1 :: (Foldable1 t, Monad m) => (a -> m b) -> (a -> b -> m b) -> t a -> m b
intercalate1 :: (Foldable1 t, Semigroup m) => m -> t m -> m
maximumBy :: Foldable1 t => (a -> a -> Ordering) -> t a -> a
minimumBy :: Foldable1 t => (a -> a -> Ordering) -> t a -> a
class Foldable t => Foldable1 (t :: Type -> Type)
fold1 :: (Foldable1 t, Semigroup m) => t m -> m
foldMap1 :: (Foldable1 t, Semigroup m) => (a -> m) -> t a -> m
foldMap1' :: (Foldable1 t, Semigroup m) => (a -> m) -> t a -> m
toNonEmpty :: Foldable1 t => t a -> NonEmpty a
maximum :: (Foldable1 t, Ord a) => t a -> a
minimum :: (Foldable1 t, Ord a) => t a -> a
head :: Foldable1 t => t a -> a
last :: Foldable1 t => t a -> a
foldrMap1 :: Foldable1 t => (a -> b) -> (a -> b -> b) -> t a -> b
foldlMap1' :: Foldable1 t => (a -> b) -> (b -> a -> b) -> t a -> b
foldlMap1 :: Foldable1 t => (a -> b) -> (b -> a -> b) -> t a -> b
foldrMap1' :: Foldable1 t => (a -> b) -> (a -> b -> b) -> t a -> b


-- | Reexports <a>Data.Foldable1.Compat</a> from a globally unique
--   namespace.
module Data.Foldable1.Compat.Repl

module Data.Function.Compat
($) :: (a -> b) -> a -> b
(.) :: (b -> c) -> (a -> b) -> a -> c
const :: a -> b -> a
flip :: (a -> b -> c) -> b -> a -> c
id :: a -> a
(&) :: a -> (a -> b) -> b
applyWhen :: Bool -> (a -> a) -> a -> a
fix :: (a -> a) -> a
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
(&) :: a -> (a -> b) -> b
applyWhen :: Bool -> (a -> a) -> a -> a


-- | Reexports <a>Data.Function.Compat</a> from a globally unique
--   namespace.
module Data.Function.Compat.Repl

module Data.Functor.Compat
($>) :: Functor f => f a -> b -> f b
(<$>) :: Functor f => (a -> b) -> f a -> f b
(<&>) :: Functor f => f a -> (a -> b) -> f b
unzip :: Functor f => f (a, b) -> (f a, f b)
void :: Functor f => f a -> f ()
class Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b
(<$) :: Functor f => a -> f b -> f a
class Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b
(<$) :: Functor f => a -> f b -> f a
($>) :: Functor f => f a -> b -> f b
void :: Functor f => f a -> f ()
(<&>) :: Functor f => f a -> (a -> b) -> f b
unzip :: Functor f => f (a, b) -> (f a, f b)


-- | Reexports <a>Data.Functor.Compat</a> from a globally unique namespace.
module Data.Functor.Compat.Repl

module Data.Functor.Compose.Compat
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)


-- | Reexports <a>Data.Functor.Compose.Compat</a> from a globally unique
--   namespace.
module Data.Functor.Compose.Compat.Repl

module Data.Functor.Const.Compat
newtype Const a (b :: k)
Const :: a -> Const a (b :: k)
[getConst] :: Const a (b :: k) -> a


-- | Reexports <a>Data.Functor.Const.Compat</a> from a globally unique
--   namespace.
module Data.Functor.Const.Compat.Repl

module Data.Functor.Contravariant.Compat
($<) :: Contravariant f => f b -> b -> f a
(>$$<) :: Contravariant f => f b -> (a -> b) -> f a
(>$<) :: Contravariant f => (a -> b) -> f b -> f a
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 Comparison a
Comparison :: (a -> a -> Ordering) -> Comparison a
[getComparison] :: Comparison a -> a -> a -> Ordering
class Contravariant (f :: Type -> Type)
contramap :: Contravariant f => (a' -> a) -> f a -> f a'
(>$) :: Contravariant f => b -> f b -> f a
newtype Equivalence a
Equivalence :: (a -> a -> Bool) -> Equivalence a
[getEquivalence] :: Equivalence a -> a -> a -> Bool
newtype Op a b
Op :: (b -> a) -> Op a b
[getOp] :: Op a b -> b -> a
newtype Predicate a
Predicate :: (a -> Bool) -> Predicate a
[getPredicate] :: Predicate a -> a -> Bool


-- | Reexports <a>Data.Functor.Contravariant.Compat</a> from a globally
--   unique namespace.
module Data.Functor.Contravariant.Compat.Repl

module Data.Functor.Identity.Compat
newtype Identity a
Identity :: a -> Identity a
[runIdentity] :: Identity a -> a


-- | Reexports <a>Data.Functor.Identity.Compat</a> from a globally unique
--   namespace.
module Data.Functor.Identity.Compat.Repl

module Data.Functor.Product.Compat
data Product (f :: k -> Type) (g :: k -> Type) (a :: k)
Pair :: f a -> g a -> Product (f :: k -> Type) (g :: k -> Type) (a :: k)


-- | Reexports <a>Data.Functor.Product.Compat</a> from a globally unique
--   namespace.
module Data.Functor.Product.Compat.Repl

module Data.Functor.Sum.Compat
data Sum (f :: k -> Type) (g :: k -> Type) (a :: k)
InL :: f a -> Sum (f :: k -> Type) (g :: k -> Type) (a :: k)
InR :: g a -> Sum (f :: k -> Type) (g :: k -> Type) (a :: k)


-- | Reexports <a>Data.Functor.Sum.Compat</a> from a globally unique
--   namespace.
module Data.Functor.Sum.Compat.Repl

module Data.IORef.Compat
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 ()
data IORef a
modifyIORef' :: IORef a -> (a -> a) -> IO ()
atomicModifyIORef' :: IORef a -> (a -> (a, b)) -> IO b
atomicWriteIORef :: IORef a -> a -> IO ()


-- | Reexports <a>Data.IORef.Compat</a> from a globally unique namespace.
module Data.IORef.Compat.Repl

module Data.List.Compat
compareLength :: [a] -> Int -> Ordering
inits1 :: [a] -> [NonEmpty a]
tails1 :: [a] -> [NonEmpty a]
(++) :: [a] -> [a] -> [a]
map :: (a -> b) -> [a] -> [b]
all :: Foldable t => (a -> Bool) -> t a -> Bool
and :: Foldable t => t Bool -> Bool
any :: Foldable t => (a -> Bool) -> t a -> Bool
concat :: Foldable t => t [a] -> [a]
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
find :: Foldable t => (a -> Bool) -> t a -> Maybe a
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
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]
group :: Eq a => [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]
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)
(!!) :: 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]
filter :: (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)
unzip :: [(a, b)] -> ([a], [b])
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
zip :: [a] -> [b] -> [(a, b)]
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
elem :: (Foldable t, Eq a) => a -> t a -> Bool
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
foldl1 :: Foldable t => (a -> a -> a) -> t a -> a
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
foldr1 :: Foldable t => (a -> a -> a) -> t a -> a
length :: Foldable t => t a -> Int
maximum :: (Foldable t, Ord a) => t a -> a
minimum :: (Foldable t, Ord a) => t a -> a
null :: Foldable t => t a -> Bool
product :: (Foldable t, Num a) => t a -> a
sum :: (Foldable t, Num a) => t a -> a
data [] a


-- | Reexports <a>Data.List.Compat</a> from a globally unique namespace.
module Data.List.Compat.Repl


-- | This backports the modern <a>Data.Semigroup</a> interface back to
--   <tt>base-4.9</tt>/GHC 8.0.
module Data.List.NonEmpty.Compat
data NonEmpty a
(:|) :: a -> [a] -> NonEmpty a
map :: (a -> b) -> NonEmpty a -> NonEmpty b
intersperse :: a -> NonEmpty a -> NonEmpty a
scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b
scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b
scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a
length :: NonEmpty a -> Int
compareLength :: NonEmpty a -> Int -> Ordering
head :: NonEmpty a -> a
tail :: NonEmpty a -> [a]
last :: NonEmpty a -> a
init :: NonEmpty a -> [a]
singleton :: a -> NonEmpty a
(<|) :: a -> NonEmpty a -> NonEmpty a
cons :: a -> NonEmpty a -> NonEmpty a
uncons :: NonEmpty a -> (a, Maybe (NonEmpty a))
unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b
sort :: Ord a => NonEmpty a -> NonEmpty a
sortOn :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty a
reverse :: NonEmpty a -> NonEmpty a
inits :: Foldable f => f a -> NonEmpty [a]
inits1 :: NonEmpty a -> NonEmpty (NonEmpty a)
tails :: Foldable f => f a -> NonEmpty [a]
tails1 :: NonEmpty a -> NonEmpty (NonEmpty a)
append :: NonEmpty a -> NonEmpty a -> NonEmpty a
appendList :: NonEmpty a -> [a] -> NonEmpty a
prependList :: [a] -> NonEmpty a -> NonEmpty a
iterate :: (a -> a) -> a -> NonEmpty a
repeat :: a -> NonEmpty a
cycle :: NonEmpty a -> NonEmpty a
unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b
insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a
some1 :: Alternative f => f a -> f (NonEmpty a)
take :: Int -> NonEmpty a -> [a]
drop :: Int -> NonEmpty a -> [a]
splitAt :: Int -> NonEmpty a -> ([a], [a])
takeWhile :: (a -> Bool) -> NonEmpty a -> [a]
dropWhile :: (a -> Bool) -> NonEmpty a -> [a]
span :: (a -> Bool) -> NonEmpty a -> ([a], [a])
break :: (a -> Bool) -> NonEmpty a -> ([a], [a])
filter :: (a -> Bool) -> NonEmpty a -> [a]
partition :: (a -> Bool) -> NonEmpty a -> ([a], [a])
group :: (Foldable f, Eq a) => f a -> [NonEmpty a]
groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a]
groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a]
groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a]
group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a)
groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)
groupWith1 :: Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
groupAllWith1 :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
permutations :: [a] -> NonEmpty [a]
permutations1 :: NonEmpty a -> NonEmpty (NonEmpty a)
isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool
nub :: Eq a => NonEmpty a -> NonEmpty a
nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a
(!!) :: HasCallStack => NonEmpty a -> Int -> a
zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
unzip :: Functor f => f (a, b) -> (f a, f b)
fromList :: HasCallStack => [a] -> NonEmpty a
toList :: NonEmpty a -> [a]
nonEmpty :: [a] -> Maybe (NonEmpty a)
xor :: NonEmpty Bool -> Bool


-- | Reexports <a>Data.List.NonEmpty.Compat</a> from a globally unique
--   namespace.
module Data.List.NonEmpty.Compat.Repl

module Data.Monoid.Compat
class Semigroup a => Monoid a
mempty :: Monoid a => a
mappend :: Monoid a => a -> a -> a
mconcat :: Monoid a => [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 First a
First :: Maybe a -> First a
[getFirst] :: First a -> Maybe a
newtype Last a
Last :: Maybe a -> Last a
[getLast] :: Last a -> Maybe a
newtype All
All :: Bool -> All
[getAll] :: All -> Bool
newtype Alt (f :: k -> Type) (a :: k)
Alt :: f a -> Alt (f :: k -> Type) (a :: k)
[getAlt] :: Alt (f :: k -> Type) (a :: k) -> f a
newtype Any
Any :: Bool -> Any
[getAny] :: Any -> Bool
newtype Dual a
Dual :: a -> Dual a
[getDual] :: Dual a -> a
newtype Endo a
Endo :: (a -> a) -> Endo a
[appEndo] :: Endo a -> a -> a
newtype Product a
Product :: a -> Product a
[getProduct] :: Product a -> a
newtype Sum a
Sum :: a -> Sum a
[getSum] :: Sum a -> a
(<>) :: Semigroup a => a -> a -> a


-- | Reexports <a>Data.Monoid.Compat</a> from a globally unique namespace.
module Data.Monoid.Compat.Repl

module Data.Proxy.Compat
asProxyTypeOf :: a -> proxy a -> a
data KProxy t
KProxy :: KProxy t
data Proxy (t :: k)
Proxy :: Proxy (t :: k)
asProxyTypeOf :: a -> proxy a -> a


-- | Reexports <a>Data.Proxy.Compat</a> from a globally unique namespace.
module Data.Proxy.Compat.Repl

module Data.Ratio.Compat
approxRational :: RealFrac a => a -> a -> Rational
(%) :: Integral a => a -> a -> Ratio a
denominator :: Ratio a -> a
numerator :: Ratio a -> a
data Ratio a
type Rational = Ratio Integer


-- | Reexports <a>Data.Ratio.Compat</a> from a globally unique namespace.
module Data.Ratio.Compat.Repl

module Data.STRef.Compat
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 STRef s a
modifySTRef' :: STRef s a -> (a -> a) -> ST s ()


-- | Reexports <a>Data.STRef.Compat</a> from a globally unique namespace.
module Data.STRef.Compat.Repl


-- | This backports the modern <a>Data.Semigroup</a> interface back to
--   <tt>base-4.9</tt>/GHC 8.0.
module Data.Semigroup.Compat
class Semigroup a
(<>) :: Semigroup a => a -> a -> a
sconcat :: Semigroup a => NonEmpty a -> a
stimes :: (Semigroup a, Integral b) => b -> a -> a
stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
stimesIdempotent :: Integral b => b -> a -> a
stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
newtype Min a
Min :: a -> Min a
[getMin] :: Min a -> a
newtype Max a
Max :: a -> Max a
[getMax] :: Max a -> a
newtype First a
First :: a -> First a
[getFirst] :: First a -> a
newtype Last a
Last :: a -> Last a
[getLast] :: Last a -> a
newtype WrappedMonoid m
WrapMonoid :: m -> WrappedMonoid m
[unwrapMonoid] :: WrappedMonoid m -> m
newtype Dual a
Dual :: a -> Dual a
[getDual] :: Dual a -> a
newtype Endo a
Endo :: (a -> a) -> Endo a
[appEndo] :: Endo a -> a -> a
newtype All
All :: Bool -> All
[getAll] :: All -> Bool
newtype Any
Any :: Bool -> Any
[getAny] :: Any -> Bool
newtype Sum a
Sum :: a -> Sum a
[getSum] :: Sum a -> a
newtype Product a
Product :: a -> Product a
[getProduct] :: Product a -> a
diff :: Semigroup m => m -> Endo m
cycle1 :: Semigroup m => m -> m
data Arg a b
Arg :: a -> b -> Arg a b
type ArgMin a b = Min Arg a b
type ArgMax a b = Max Arg a b


-- | Reexports <a>Data.Semigroup.Compat</a> from a globally unique
--   namespace.
module Data.Semigroup.Compat.Repl

module Data.String.Compat
lines :: String -> [String]
unlines :: [String] -> String
unwords :: [String] -> String
words :: String -> [String]
class IsString a
fromString :: IsString a => String -> a
type String = [Char]
type String = [Char]
lines :: String -> [String]
words :: String -> [String]
unlines :: [String] -> String
unwords :: [String] -> String


-- | Reexports <a>Data.String.Compat</a> from a globally unique namespace.
module Data.String.Compat.Repl

module Data.Traversable.Compat
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)
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
mapAccumL :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
mapAccumM :: (Monad m, Traversable t) => (s -> a -> m (s, b)) -> s -> t a -> m (s, t b)
mapAccumR :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
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)
mapAccumM :: (Monad m, Traversable t) => (s -> a -> m (s, b)) -> s -> t a -> m (s, t b)
forAccumM :: (Monad m, Traversable t) => s -> t a -> (s -> a -> m (s, b)) -> m (s, t b)


-- | Reexports <a>Data.Traversable.Compat</a> from a globally unique
--   namespace.
module Data.Traversable.Compat.Repl


-- | Note that we only re-export <tt>MkSolo</tt> when building with
--   <tt>ghc-prim-0.10.0</tt> (bundled with GHC 9.6) or later. If you want
--   to backport <tt>MkSolo</tt> to older versions of GHC, import
--   <tt>Data.Tuple.Compat</tt> from <tt>base-compat-batteries</tt>
--   instead.
module Data.Tuple.Compat
fst :: (a, b) -> a
snd :: (a, b) -> b
curry :: ((a, b) -> c) -> a -> b -> c
uncurry :: (a -> b -> c) -> (a, b) -> c
swap :: (a, b) -> (b, a)
data Solo a
MkSolo :: a -> Solo a
pattern Solo :: a -> Solo a
getSolo :: Solo a -> a


-- | Reexports <a>Data.Tuple.Compat</a> from a globally unique namespace.
module Data.Tuple.Compat.Repl
curry :: ((a, b) -> c) -> a -> b -> c
fst :: (a, b) -> a
snd :: (a, b) -> b
swap :: (a, b) -> (b, a)
uncurry :: (a -> b -> c) -> (a, b) -> c
getSolo :: Solo a -> a
data Solo a
pattern Solo :: a -> Solo a

module Data.Type.Coercion.Compat
coerceWith :: Coercion a b -> a -> b
gcoerceWith :: forall {k} (a :: k) (b :: k) r. Coercion a b -> (Coercible a b => r) -> r
repr :: forall {k} (a :: k) (b :: k). (a :~: b) -> Coercion a b
sym :: forall {k} (a :: k) (b :: k). Coercion a b -> Coercion b a
trans :: forall {k} (a :: k) (b :: k) (c :: k). Coercion a b -> Coercion b c -> Coercion a c
data Coercion (a :: k) (b :: k)
[Coercion] :: forall {k} (a :: k) (b :: k). Coercible a b => Coercion a b
class TestCoercion (f :: k -> Type)
testCoercion :: forall (a :: k) (b :: k). TestCoercion f => f a -> f b -> Maybe (Coercion a b)
gcoerceWith :: forall {k} (a :: k) (b :: k) r. Coercion a b -> (Coercible a b => r) -> r


-- | Reexports <a>Data.Type.Coercion.Compat</a> from a globally unique
--   namespace.
module Data.Type.Coercion.Compat.Repl

module Data.Type.Equality.Compat
apply :: forall {k1} {k2} (f :: k1 -> k2) (g :: k1 -> k2) (a :: k1) (b :: k1). (f :~: g) -> (a :~: b) -> f a :~: g b
castWith :: (a :~: b) -> a -> b
gcastWith :: forall {k} (a :: k) (b :: k) r. (a :~: b) -> (a ~ b => r) -> r
inner :: forall {k1} {k2} (f :: k1 -> k2) (a :: k1) (g :: k1 -> k2) (b :: k1). (f a :~: g b) -> a :~: b
outer :: forall {k1} {k2} (f :: k1 -> k2) (a :: k1) (g :: k1 -> k2) (b :: k1). (f a :~: g b) -> f :~: g
sym :: forall {k} (a :: k) (b :: k). (a :~: b) -> b :~: a
trans :: forall {k} (a :: k) (b :: k) (c :: k). (a :~: b) -> (b :~: c) -> a :~: c
data (a :: k) :~: (b :: k)
[Refl] :: forall {k} (a :: k). a :~: a
data (a :: k1) :~~: (b :: k2)
[HRefl] :: forall {k1} (a :: k1). a :~~: a
type family (a :: k) == (b :: k) :: Bool
class TestEquality (f :: k -> Type)
testEquality :: forall (a :: k) (b :: k). TestEquality f => f a -> f b -> Maybe (a :~: b)
class a ~# b => (a :: k) ~ (b :: k)
class a ~# b => (a :: k0) ~~ (b :: k1)


-- | Reexports <a>Data.Type.Equality.Compat</a> from a globally unique
--   namespace.
module Data.Type.Equality.Compat.Repl

module Data.Typeable.Compat
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
data Proxy (t :: k)
Proxy :: Proxy (t :: k)
data (a :: k) :~: (b :: k)
[Refl] :: forall {k} (a :: k). a :~: a
data (a :: k1) :~~: (b :: k2)
[HRefl] :: forall {k1} (a :: k1). a :~~: a
type TypeRep = SomeTypeRep
class Typeable (a :: k)
data TyCon
heqT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => Maybe (a :~~: b)
decT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => Either ((a :~: b) -> Void) (a :~: b)
hdecT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => Either ((a :~~: b) -> Void) (a :~~: b)


-- | Reexports <a>Data.Typeable.Compat</a> from a globally unique
--   namespace.
module Data.Typeable.Compat.Repl

module Data.Version.Compat
makeVersion :: [Int] -> Version
parseVersion :: ReadP Version
showVersion :: Version -> String
data Version
Version :: [Int] -> [String] -> Version
[versionBranch] :: Version -> [Int]
[versionTags] :: Version -> [String]
makeVersion :: [Int] -> Version


-- | Reexports <a>Data.Version.Compat</a> from a globally unique namespace.
module Data.Version.Compat.Repl

module Data.Void.Compat
absurd :: Void -> a
vacuous :: Functor f => f Void -> f a
data Void


-- | Reexports <a>Data.Void.Compat</a> from a globally unique namespace.
module Data.Void.Compat.Repl

module Data.Word.Compat
bitReverse16 :: Word16 -> Word16
bitReverse32 :: Word32 -> Word32
bitReverse64 :: Word64 -> Word64
bitReverse8 :: Word8 -> Word8
byteSwap16 :: Word16 -> Word16
byteSwap32 :: Word32 -> Word32
byteSwap64 :: Word64 -> Word64
data Word16
data Word32
data Word64
data Word8
data Word
byteSwap16 :: Word16 -> Word16
byteSwap32 :: Word32 -> Word32
byteSwap64 :: Word64 -> Word64


-- | Reexports <a>Data.Word.Compat</a> from a globally unique namespace.
module Data.Word.Compat.Repl

module Debug.Trace.Compat
flushEventLog :: IO ()
putTraceMsg :: String -> IO ()
trace :: String -> a -> a
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
traceId :: String -> String
traceShowId :: Show a => a -> a
traceM :: Applicative f => String -> f ()
traceShowM :: (Show a, Applicative f) => a -> f ()
traceWith :: (a -> String) -> a -> a
traceShowWith :: Show b => (a -> b) -> a -> a
traceEventWith :: (a -> String) -> a -> a


-- | Reexports <a>Debug.Trace.Compat</a> from a globally unique namespace.
module Debug.Trace.Compat.Repl

module Foreign.ForeignPtr.Compat
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 ()
data ForeignPtr a
plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b


-- | Reexports <a>Foreign.ForeignPtr.Compat</a> from a globally unique
--   namespace.
module Foreign.ForeignPtr.Compat.Repl

module Foreign.ForeignPtr.Safe.Compat
data ForeignPtr a
type FinalizerPtr a = FunPtr Ptr a -> IO ()
type FinalizerEnvPtr env a = FunPtr Ptr env -> Ptr a -> IO ()
newForeignPtr :: FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr_ :: Ptr a -> IO (ForeignPtr a)
addForeignPtrFinalizer :: FinalizerPtr a -> ForeignPtr a -> IO ()
newForeignPtrEnv :: FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO (ForeignPtr a)
addForeignPtrFinalizerEnv :: FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> IO ()
withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
finalizeForeignPtr :: ForeignPtr a -> IO ()
touchForeignPtr :: ForeignPtr a -> IO ()
castForeignPtr :: ForeignPtr a -> ForeignPtr b
mallocForeignPtr :: Storable a => IO (ForeignPtr a)
mallocForeignPtrBytes :: Int -> IO (ForeignPtr a)
mallocForeignPtrArray :: Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray0 :: Storable a => Int -> IO (ForeignPtr a)


-- | Reexports <a>Foreign.ForeignPtr.Safe.Compat</a> from a globally unique
--   namespace.
module Foreign.ForeignPtr.Safe.Compat.Repl

module Foreign.ForeignPtr.Unsafe.Compat
unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr a


-- | Reexports <a>Foreign.ForeignPtr.Unsafe.Compat</a> from a globally
--   unique namespace.
module Foreign.ForeignPtr.Unsafe.Compat.Repl

module Foreign.Marshal.Alloc.Compat
alloca :: Storable a => (Ptr a -> IO b) -> IO b
allocaBytes :: Int -> (Ptr a -> IO b) -> IO b
allocaBytesAligned :: Int -> Int -> (Ptr a -> IO b) -> IO b
calloc :: Storable a => IO (Ptr a)
callocBytes :: Int -> IO (Ptr a)
finalizerFree :: FinalizerPtr a
free :: Ptr a -> IO ()
malloc :: Storable a => IO (Ptr a)
mallocBytes :: Int -> IO (Ptr a)
realloc :: forall a b. Storable b => Ptr a -> IO (Ptr b)
reallocBytes :: Ptr a -> Int -> IO (Ptr a)
calloc :: Storable a => IO (Ptr a)
callocBytes :: Int -> IO (Ptr a)


-- | Reexports <a>Foreign.Marshal.Alloc.Compat</a> from a globally unique
--   namespace.
module Foreign.Marshal.Alloc.Compat.Repl

module Foreign.Marshal.Array.Compat
advancePtr :: Storable a => Ptr a -> Int -> Ptr a
allocaArray :: Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray0 :: Storable a => Int -> (Ptr a -> IO b) -> IO b
callocArray :: Storable a => Int -> IO (Ptr a)
callocArray0 :: Storable a => Int -> IO (Ptr a)
copyArray :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
lengthArray0 :: (Storable a, Eq a) => a -> Ptr a -> IO Int
mallocArray :: Storable a => Int -> IO (Ptr a)
mallocArray0 :: Storable a => Int -> IO (Ptr a)
moveArray :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
newArray :: Storable a => [a] -> IO (Ptr a)
newArray0 :: Storable a => a -> [a] -> IO (Ptr a)
peekArray :: Storable a => Int -> Ptr a -> IO [a]
peekArray0 :: (Storable a, Eq a) => a -> Ptr a -> IO [a]
pokeArray :: Storable a => Ptr a -> [a] -> IO ()
pokeArray0 :: Storable a => a -> Ptr a -> [a] -> IO ()
reallocArray :: Storable a => Ptr a -> Int -> IO (Ptr a)
reallocArray0 :: Storable a => Ptr a -> Int -> IO (Ptr a)
withArray :: Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray0 :: Storable a => a -> [a] -> (Ptr a -> IO b) -> IO b
withArrayLen :: Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b
withArrayLen0 :: Storable a => a -> [a] -> (Int -> Ptr a -> IO b) -> IO b
callocArray :: Storable a => Int -> IO (Ptr a)
callocArray0 :: Storable a => Int -> IO (Ptr a)


-- | Reexports <a>Foreign.Marshal.Array.Compat</a> from a globally unique
--   namespace.
module Foreign.Marshal.Array.Compat.Repl

module Foreign.Marshal.Safe.Compat
alloca :: Storable a => (Ptr a -> IO b) -> IO b
allocaBytes :: Int -> (Ptr a -> IO b) -> IO b
allocaBytesAligned :: Int -> Int -> (Ptr a -> IO b) -> IO b
calloc :: Storable a => IO (Ptr a)
callocBytes :: Int -> IO (Ptr a)
finalizerFree :: FinalizerPtr a
free :: Ptr a -> IO ()
malloc :: Storable a => IO (Ptr a)
mallocBytes :: Int -> IO (Ptr a)
realloc :: forall a b. Storable b => Ptr a -> IO (Ptr b)
reallocBytes :: Ptr a -> Int -> IO (Ptr a)
advancePtr :: Storable a => Ptr a -> Int -> Ptr a
allocaArray :: Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray0 :: Storable a => Int -> (Ptr a -> IO b) -> IO b
callocArray :: Storable a => Int -> IO (Ptr a)
callocArray0 :: Storable a => Int -> IO (Ptr a)
copyArray :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
lengthArray0 :: (Storable a, Eq a) => a -> Ptr a -> IO Int
mallocArray :: Storable a => Int -> IO (Ptr a)
mallocArray0 :: Storable a => Int -> IO (Ptr a)
moveArray :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
newArray :: Storable a => [a] -> IO (Ptr a)
newArray0 :: Storable a => a -> [a] -> IO (Ptr a)
peekArray :: Storable a => Int -> Ptr a -> IO [a]
peekArray0 :: (Storable a, Eq a) => a -> Ptr a -> IO [a]
pokeArray :: Storable a => Ptr a -> [a] -> IO ()
pokeArray0 :: Storable a => a -> Ptr a -> [a] -> IO ()
reallocArray :: Storable a => Ptr a -> Int -> IO (Ptr a)
reallocArray0 :: Storable a => Ptr a -> Int -> IO (Ptr a)
withArray :: Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray0 :: Storable a => a -> [a] -> (Ptr a -> IO b) -> IO b
withArrayLen :: Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b
withArrayLen0 :: Storable a => a -> [a] -> (Int -> Ptr a -> IO b) -> IO b
throwIf :: (a -> Bool) -> (a -> String) -> IO a -> IO a
throwIfNeg :: (Ord a, Num a) => (a -> String) -> IO a -> IO a
throwIfNeg_ :: (Ord a, Num a) => (a -> String) -> IO a -> IO ()
throwIfNull :: String -> IO (Ptr a) -> IO (Ptr a)
throwIf_ :: (a -> Bool) -> (a -> String) -> IO a -> IO ()
void :: IO a -> IO ()
freePool :: Pool -> IO ()
newPool :: IO Pool
pooledMalloc :: Storable a => Pool -> IO (Ptr a)
pooledMallocArray :: Storable a => Pool -> Int -> IO (Ptr a)
pooledMallocArray0 :: Storable a => Pool -> Int -> IO (Ptr a)
pooledMallocBytes :: Pool -> Int -> IO (Ptr a)
pooledNew :: Storable a => Pool -> a -> IO (Ptr a)
pooledNewArray :: Storable a => Pool -> [a] -> IO (Ptr a)
pooledNewArray0 :: Storable a => Pool -> a -> [a] -> IO (Ptr a)
pooledRealloc :: Storable a => Pool -> Ptr a -> IO (Ptr a)
pooledReallocArray :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a)
pooledReallocArray0 :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a)
pooledReallocBytes :: Pool -> Ptr a -> Int -> IO (Ptr a)
withPool :: (Pool -> IO b) -> IO b
data Pool
copyBytes :: Ptr a -> Ptr a -> Int -> IO ()
fillBytes :: Ptr a -> Word8 -> Int -> IO ()
fromBool :: Num a => Bool -> a
maybeNew :: (a -> IO (Ptr b)) -> Maybe a -> IO (Ptr b)
maybePeek :: (Ptr a -> IO b) -> Ptr a -> IO (Maybe b)
maybeWith :: (a -> (Ptr b -> IO c) -> IO c) -> Maybe a -> (Ptr b -> IO c) -> IO c
moveBytes :: Ptr a -> Ptr a -> Int -> IO ()
new :: Storable a => a -> IO (Ptr a)
toBool :: (Eq a, Num a) => a -> Bool
with :: Storable a => a -> (Ptr a -> IO b) -> IO b
withMany :: (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res


-- | Reexports <a>Foreign.Marshal.Safe.Compat</a> from a globally unique
--   namespace.
module Foreign.Marshal.Safe.Compat.Repl

module Foreign.Marshal.Unsafe.Compat
unsafeLocalState :: IO a -> a


-- | Reexports <a>Foreign.Marshal.Unsafe.Compat</a> from a globally unique
--   namespace.
module Foreign.Marshal.Unsafe.Compat.Repl

module Foreign.Marshal.Utils.Compat
copyBytes :: Ptr a -> Ptr a -> Int -> IO ()
fillBytes :: Ptr a -> Word8 -> Int -> IO ()
fromBool :: Num a => Bool -> a
maybeNew :: (a -> IO (Ptr b)) -> Maybe a -> IO (Ptr b)
maybePeek :: (Ptr a -> IO b) -> Ptr a -> IO (Maybe b)
maybeWith :: (a -> (Ptr b -> IO c) -> IO c) -> Maybe a -> (Ptr b -> IO c) -> IO c
moveBytes :: Ptr a -> Ptr a -> Int -> IO ()
new :: Storable a => a -> IO (Ptr a)
toBool :: (Eq a, Num a) => a -> Bool
with :: Storable a => a -> (Ptr a -> IO b) -> IO b
withMany :: (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res
fillBytes :: Ptr a -> Word8 -> Int -> IO ()

module Foreign.Marshal.Compat
alloca :: Storable a => (Ptr a -> IO b) -> IO b
allocaBytes :: Int -> (Ptr a -> IO b) -> IO b
allocaBytesAligned :: Int -> Int -> (Ptr a -> IO b) -> IO b
calloc :: Storable a => IO (Ptr a)
callocBytes :: Int -> IO (Ptr a)
finalizerFree :: FinalizerPtr a
free :: Ptr a -> IO ()
malloc :: Storable a => IO (Ptr a)
mallocBytes :: Int -> IO (Ptr a)
realloc :: forall a b. Storable b => Ptr a -> IO (Ptr b)
reallocBytes :: Ptr a -> Int -> IO (Ptr a)
advancePtr :: Storable a => Ptr a -> Int -> Ptr a
allocaArray :: Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray0 :: Storable a => Int -> (Ptr a -> IO b) -> IO b
callocArray :: Storable a => Int -> IO (Ptr a)
callocArray0 :: Storable a => Int -> IO (Ptr a)
copyArray :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
lengthArray0 :: (Storable a, Eq a) => a -> Ptr a -> IO Int
mallocArray :: Storable a => Int -> IO (Ptr a)
mallocArray0 :: Storable a => Int -> IO (Ptr a)
moveArray :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
newArray :: Storable a => [a] -> IO (Ptr a)
newArray0 :: Storable a => a -> [a] -> IO (Ptr a)
peekArray :: Storable a => Int -> Ptr a -> IO [a]
peekArray0 :: (Storable a, Eq a) => a -> Ptr a -> IO [a]
pokeArray :: Storable a => Ptr a -> [a] -> IO ()
pokeArray0 :: Storable a => a -> Ptr a -> [a] -> IO ()
reallocArray :: Storable a => Ptr a -> Int -> IO (Ptr a)
reallocArray0 :: Storable a => Ptr a -> Int -> IO (Ptr a)
withArray :: Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray0 :: Storable a => a -> [a] -> (Ptr a -> IO b) -> IO b
withArrayLen :: Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b
withArrayLen0 :: Storable a => a -> [a] -> (Int -> Ptr a -> IO b) -> IO b
throwIf :: (a -> Bool) -> (a -> String) -> IO a -> IO a
throwIfNeg :: (Ord a, Num a) => (a -> String) -> IO a -> IO a
throwIfNeg_ :: (Ord a, Num a) => (a -> String) -> IO a -> IO ()
throwIfNull :: String -> IO (Ptr a) -> IO (Ptr a)
throwIf_ :: (a -> Bool) -> (a -> String) -> IO a -> IO ()
void :: IO a -> IO ()
freePool :: Pool -> IO ()
newPool :: IO Pool
pooledMalloc :: Storable a => Pool -> IO (Ptr a)
pooledMallocArray :: Storable a => Pool -> Int -> IO (Ptr a)
pooledMallocArray0 :: Storable a => Pool -> Int -> IO (Ptr a)
pooledMallocBytes :: Pool -> Int -> IO (Ptr a)
pooledNew :: Storable a => Pool -> a -> IO (Ptr a)
pooledNewArray :: Storable a => Pool -> [a] -> IO (Ptr a)
pooledNewArray0 :: Storable a => Pool -> a -> [a] -> IO (Ptr a)
pooledRealloc :: Storable a => Pool -> Ptr a -> IO (Ptr a)
pooledReallocArray :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a)
pooledReallocArray0 :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a)
pooledReallocBytes :: Pool -> Ptr a -> Int -> IO (Ptr a)
withPool :: (Pool -> IO b) -> IO b
copyBytes :: Ptr a -> Ptr a -> Int -> IO ()
fillBytes :: Ptr a -> Word8 -> Int -> IO ()
fromBool :: Num a => Bool -> a
maybeNew :: (a -> IO (Ptr b)) -> Maybe a -> IO (Ptr b)
maybePeek :: (Ptr a -> IO b) -> Ptr a -> IO (Maybe b)
maybeWith :: (a -> (Ptr b -> IO c) -> IO c) -> Maybe a -> (Ptr b -> IO c) -> IO c
moveBytes :: Ptr a -> Ptr a -> Int -> IO ()
new :: Storable a => a -> IO (Ptr a)
toBool :: (Eq a, Num a) => a -> Bool
with :: Storable a => a -> (Ptr a -> IO b) -> IO b
withMany :: (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res
data Pool


-- | Reexports <a>Foreign.Marshal.Compat</a> from a globally unique
--   namespace.
module Foreign.Marshal.Compat.Repl

module Foreign.Compat
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
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)
alloca :: Storable a => (Ptr a -> IO b) -> IO b
allocaBytes :: Int -> (Ptr a -> IO b) -> IO b
allocaBytesAligned :: Int -> Int -> (Ptr a -> IO b) -> IO b
calloc :: Storable a => IO (Ptr a)
callocBytes :: Int -> IO (Ptr a)
finalizerFree :: FinalizerPtr a
free :: Ptr a -> IO ()
malloc :: Storable a => IO (Ptr a)
mallocBytes :: Int -> IO (Ptr a)
realloc :: forall a b. Storable b => Ptr a -> IO (Ptr b)
reallocBytes :: Ptr a -> Int -> IO (Ptr a)
advancePtr :: Storable a => Ptr a -> Int -> Ptr a
allocaArray :: Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray0 :: Storable a => Int -> (Ptr a -> IO b) -> IO b
callocArray :: Storable a => Int -> IO (Ptr a)
callocArray0 :: Storable a => Int -> IO (Ptr a)
copyArray :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
lengthArray0 :: (Storable a, Eq a) => a -> Ptr a -> IO Int
mallocArray :: Storable a => Int -> IO (Ptr a)
mallocArray0 :: Storable a => Int -> IO (Ptr a)
moveArray :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
newArray :: Storable a => [a] -> IO (Ptr a)
newArray0 :: Storable a => a -> [a] -> IO (Ptr a)
peekArray :: Storable a => Int -> Ptr a -> IO [a]
peekArray0 :: (Storable a, Eq a) => a -> Ptr a -> IO [a]
pokeArray :: Storable a => Ptr a -> [a] -> IO ()
pokeArray0 :: Storable a => a -> Ptr a -> [a] -> IO ()
reallocArray :: Storable a => Ptr a -> Int -> IO (Ptr a)
reallocArray0 :: Storable a => Ptr a -> Int -> IO (Ptr a)
withArray :: Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray0 :: Storable a => a -> [a] -> (Ptr a -> IO b) -> IO b
withArrayLen :: Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b
withArrayLen0 :: Storable a => a -> [a] -> (Int -> Ptr a -> IO b) -> IO b
throwIf :: (a -> Bool) -> (a -> String) -> IO a -> IO a
throwIfNeg :: (Ord a, Num a) => (a -> String) -> IO a -> IO a
throwIfNeg_ :: (Ord a, Num a) => (a -> String) -> IO a -> IO ()
throwIfNull :: String -> IO (Ptr a) -> IO (Ptr a)
throwIf_ :: (a -> Bool) -> (a -> String) -> IO a -> IO ()
void :: IO a -> IO ()
freePool :: Pool -> IO ()
newPool :: IO Pool
pooledMalloc :: Storable a => Pool -> IO (Ptr a)
pooledMallocArray :: Storable a => Pool -> Int -> IO (Ptr a)
pooledMallocArray0 :: Storable a => Pool -> Int -> IO (Ptr a)
pooledMallocBytes :: Pool -> Int -> IO (Ptr a)
pooledNew :: Storable a => Pool -> a -> IO (Ptr a)
pooledNewArray :: Storable a => Pool -> [a] -> IO (Ptr a)
pooledNewArray0 :: Storable a => Pool -> a -> [a] -> IO (Ptr a)
pooledRealloc :: Storable a => Pool -> Ptr a -> IO (Ptr a)
pooledReallocArray :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a)
pooledReallocArray0 :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a)
pooledReallocBytes :: Pool -> Ptr a -> Int -> IO (Ptr a)
withPool :: (Pool -> IO b) -> IO b
copyBytes :: Ptr a -> Ptr a -> Int -> IO ()
fillBytes :: Ptr a -> Word8 -> Int -> IO ()
fromBool :: Num a => Bool -> a
maybeNew :: (a -> IO (Ptr b)) -> Maybe a -> IO (Ptr b)
maybePeek :: (Ptr a -> IO b) -> Ptr a -> IO (Maybe b)
maybeWith :: (a -> (Ptr b -> IO c) -> IO c) -> Maybe a -> (Ptr b -> IO c) -> IO c
moveBytes :: Ptr a -> Ptr a -> Int -> IO ()
new :: Storable a => a -> IO (Ptr a)
toBool :: (Eq a, Num a) => a -> Bool
with :: Storable a => a -> (Ptr a -> IO b) -> IO b
withMany :: (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res
freeHaskellFunPtr :: FunPtr a -> IO ()
intPtrToPtr :: IntPtr -> Ptr a
ptrToIntPtr :: Ptr a -> IntPtr
ptrToWordPtr :: Ptr a -> WordPtr
wordPtrToPtr :: WordPtr -> Ptr 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
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
castPtrToStablePtr :: Ptr () -> StablePtr a
castStablePtrToPtr :: StablePtr a -> Ptr ()
deRefStablePtr :: StablePtr a -> IO a
freeStablePtr :: StablePtr a -> IO ()
newStablePtr :: a -> IO (StablePtr a)
bitReverse16 :: Word16 -> Word16
bitReverse32 :: Word32 -> Word32
bitReverse64 :: Word64 -> Word64
bitReverse8 :: Word8 -> Word8
byteSwap16 :: Word16 -> Word16
byteSwap32 :: Word32 -> Word32
byteSwap64 :: Word64 -> Word64
class Eq a => Bits a
(.&.) :: Bits a => a -> a -> a
(.|.) :: Bits a => a -> a -> a
xor :: Bits a => a -> a -> a
complement :: Bits a => a -> a
shift :: Bits a => a -> Int -> a
rotate :: Bits a => a -> Int -> a
zeroBits :: Bits a => a
bit :: Bits a => Int -> a
setBit :: Bits a => a -> Int -> a
clearBit :: Bits a => a -> Int -> a
complementBit :: Bits a => a -> Int -> a
testBit :: Bits a => a -> Int -> Bool
bitSizeMaybe :: Bits a => a -> Maybe Int
bitSize :: Bits a => a -> Int
isSigned :: Bits a => a -> Bool
shiftL :: Bits a => a -> Int -> a
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
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
data Pool
newtype IntPtr
IntPtr :: Int -> IntPtr
newtype WordPtr
WordPtr :: Word -> WordPtr
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 ()
type FinalizerEnvPtr env a = FunPtr Ptr env -> Ptr a -> IO ()
type FinalizerPtr a = FunPtr Ptr a -> IO ()
data ForeignPtr a
data Int16
data Int32
data Int64
data Int8
data FunPtr a
data Ptr a
data StablePtr a
data Word16
data Word32
data Word64
data Word8
data Int
data Word


-- | Reexports <a>Foreign.Compat</a> from a globally unique namespace.
module Foreign.Compat.Repl


-- | Reexports <a>Foreign.Marshal.Utils.Compat</a> from a globally unique
--   namespace.
module Foreign.Marshal.Utils.Compat.Repl

module Numeric.Compat
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
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
showBin :: Integral a => a -> ShowS
showFFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS
showGFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS
showHFloat :: RealFloat a => a -> ShowS
readBin :: (Eq a, Num a) => ReadS a


-- | Reexports <a>Numeric.Compat</a> from a globally unique namespace.
module Numeric.Compat.Repl

module Numeric.Natural.Compat
minusNaturalMaybe :: Natural -> Natural -> Maybe Natural
data Natural
minusNaturalMaybe :: Natural -> Natural -> Maybe Natural


-- | Reexports <a>Numeric.Natural.Compat</a> from a globally unique
--   namespace.
module Numeric.Natural.Compat.Repl

module Prelude.Compat
($) :: (a -> b) -> a -> b
($!) :: (a -> b) -> a -> b
(++) :: [a] -> [a] -> [a]
(.) :: (b -> c) -> (a -> b) -> a -> c
(=<<) :: Monad m => (a -> m b) -> m a -> m b
asTypeOf :: a -> a -> a
const :: a -> b -> a
flip :: (a -> b -> c) -> b -> a -> c
id :: a -> a
map :: (a -> b) -> [a] -> [b]
otherwise :: Bool
until :: (a -> Bool) -> (a -> a) -> a -> a
either :: (a -> c) -> (b -> c) -> Either a b -> c
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]
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
or :: Foldable t => t Bool -> Bool
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
(<$>) :: Functor f => (a -> b) -> f a -> f b
maybe :: b -> (a -> b) -> Maybe a -> b
lines :: String -> [String]
unlines :: [String] -> String
unwords :: [String] -> String
words :: String -> [String]
curry :: ((a, b) -> c) -> a -> b -> c
fst :: (a, b) -> a
snd :: (a, b) -> b
uncurry :: (a -> b -> c) -> (a, b) -> c
error :: HasCallStack => [Char] -> a
errorWithoutStackTrace :: [Char] -> a
undefined :: HasCallStack => a
ioError :: HasCallStack => IOError -> IO a
userError :: String -> IOError
(!!) :: HasCallStack => [a] -> Int -> a
break :: (a -> Bool) -> [a] -> ([a], [a])
cycle :: HasCallStack => [a] -> [a]
drop :: Int -> [a] -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
filter :: (a -> Bool) -> [a] -> [a]
head :: HasCallStack => [a] -> a
init :: HasCallStack => [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]
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]
unzip :: [(a, b)] -> ([a], [b])
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
zip :: [a] -> [b] -> [(a, b)]
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
subtract :: Num a => a -> a -> a
lex :: ReadS String
readParen :: Bool -> ReadS a -> ReadS a
(^) :: (Num a, Integral b) => a -> b -> a
(^^) :: (Fractional a, Integral b) => a -> b -> a
even :: Integral a => a -> Bool
fromIntegral :: (Integral a, Num b) => a -> b
gcd :: Integral a => a -> a -> a
lcm :: Integral a => a -> a -> a
odd :: Integral a => a -> Bool
realToFrac :: (Real a, Fractional b) => a -> b
showChar :: Char -> ShowS
showParen :: Bool -> ShowS -> ShowS
showString :: String -> ShowS
shows :: Show a => a -> ShowS
appendFile :: FilePath -> String -> IO ()
getChar :: IO Char
getContents :: IO String
getLine :: IO String
interact :: (String -> String) -> IO ()
print :: Show a => a -> IO ()
putChar :: Char -> IO ()
putStr :: String -> IO ()
putStrLn :: String -> IO ()
readFile :: FilePath -> IO String
readIO :: Read a => String -> IO a
readLn :: Read a => IO a
writeFile :: FilePath -> String -> IO ()
read :: Read a => String -> a
reads :: Read a => ReadS a
(&&) :: Bool -> Bool -> Bool
not :: Bool -> Bool
(||) :: Bool -> Bool -> Bool
seq :: a -> b -> b
class Functor f => Applicative (f :: Type -> Type)
pure :: Applicative f => a -> f a
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
(*>) :: Applicative f => f a -> f b -> f b
(<*) :: Applicative f => f a -> f b -> f a
class Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b
(<$) :: Functor f => a -> f b -> f a
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
class Semigroup a => Monoid a
mempty :: Monoid a => a
mappend :: Monoid a => a -> a -> a
mconcat :: Monoid a => [a] -> a
class Semigroup a
(<>) :: Semigroup a => a -> a -> a
class Monad m => MonadFail (m :: Type -> Type)
fail :: MonadFail m => String -> m a
data Either a b
Left :: a -> Either a b
Right :: b -> Either a b
class Foldable (t :: Type -> Type)
foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
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 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)
class Bounded a
minBound :: Bounded a => a
maxBound :: Bounded a => a
class Enum a
succ :: Enum a => a -> a
pred :: Enum a => a -> a
toEnum :: Enum a => Int -> a
fromEnum :: Enum a => a -> Int
enumFrom :: Enum a => a -> [a]
enumFromThen :: Enum a => a -> a -> [a]
enumFromTo :: Enum a => a -> a -> [a]
enumFromThenTo :: Enum a => a -> a -> a -> [a]
class Fractional a => Floating a
pi :: Floating a => a
exp :: Floating a => a -> a
log :: Floating a => a -> a
sqrt :: Floating a => a -> a
(**) :: Floating a => a -> a -> a
logBase :: Floating a => a -> a -> a
sin :: Floating a => a -> a
cos :: Floating a => a -> a
tan :: Floating a => a -> a
asin :: Floating a => a -> a
acos :: Floating a => a -> a
atan :: Floating a => a -> a
sinh :: Floating a => a -> a
cosh :: Floating a => a -> a
tanh :: Floating a => a -> a
asinh :: Floating a => a -> a
acosh :: Floating a => a -> a
atanh :: Floating a => a -> a
class (RealFrac a, Floating a) => RealFloat a
floatRadix :: RealFloat a => a -> Integer
floatDigits :: RealFloat a => a -> Int
floatRange :: RealFloat a => a -> (Int, Int)
decodeFloat :: RealFloat a => a -> (Integer, Int)
encodeFloat :: RealFloat a => Integer -> Int -> a
exponent :: RealFloat a => a -> Int
significand :: RealFloat a => a -> a
scaleFloat :: RealFloat a => Int -> a -> a
isNaN :: RealFloat a => a -> Bool
isInfinite :: RealFloat a => a -> Bool
isDenormalized :: RealFloat a => a -> Bool
isNegativeZero :: RealFloat a => a -> Bool
isIEEE :: RealFloat a => a -> Bool
atan2 :: RealFloat a => a -> a -> a
type FilePath = String
type IOError = IOException
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 Read a
readsPrec :: Read a => Int -> ReadS a
readList :: Read a => ReadS [a]
class Num a => Fractional a
(/) :: Fractional a => a -> a -> a
recip :: Fractional a => a -> a
fromRational :: Fractional a => Rational -> a
class (Real a, Enum a) => Integral a
quot :: Integral a => a -> a -> a
rem :: Integral a => a -> a -> a
div :: Integral a => a -> a -> a
mod :: Integral a => a -> a -> a
quotRem :: Integral a => a -> a -> (a, a)
divMod :: Integral a => a -> a -> (a, a)
toInteger :: Integral a => a -> Integer
type Rational = Ratio Integer
class (Num a, Ord a) => Real a
toRational :: Real a => a -> Rational
class (Real a, Fractional a) => RealFrac a
properFraction :: (RealFrac a, Integral b) => a -> (b, a)
truncate :: (RealFrac a, Integral b) => a -> b
round :: (RealFrac a, Integral b) => a -> b
ceiling :: (RealFrac a, Integral b) => a -> b
floor :: (RealFrac a, Integral b) => a -> b
class Show a
showsPrec :: Show a => Int -> a -> ShowS
show :: Show a => a -> String
showList :: Show a => [a] -> ShowS
type ShowS = String -> String
type ReadS a = String -> [(a, String)]
class Eq a
(==) :: Eq a => a -> a -> Bool
(/=) :: Eq a => a -> a -> Bool
class Eq a => Ord a
compare :: Ord a => a -> a -> Ordering
(<) :: Ord a => a -> a -> Bool
(<=) :: Ord a => a -> a -> Bool
(>) :: Ord a => a -> a -> Bool
(>=) :: Ord a => a -> a -> Bool
max :: Ord a => a -> a -> a
min :: Ord a => a -> a -> a
data IO a
data Ordering
LT :: Ordering
EQ :: Ordering
GT :: Ordering
data Integer
type String = [Char]
data Maybe a
Nothing :: Maybe a
Just :: a -> Maybe a
data Bool
False :: Bool
True :: Bool
data Char
data Double
data Float
data Int
data Word
class a ~# b => (a :: k) ~ (b :: k)


-- | Reexports <a>Prelude.Compat</a> from a globally unique namespace.
module Prelude.Compat.Repl


-- | Miscellaneous information about the system environment.
module System.Environment.Compat
getArgs :: IO [String]
getProgName :: IO String
getEnv :: String -> 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
getEnvironment :: IO [(String, String)]


-- | Reexports <a>System.Environment.Compat</a> from a globally unique
--   namespace.
module System.Environment.Compat.Repl

module System.Exit.Compat
die :: String -> IO a
exitFailure :: IO a
exitSuccess :: IO a
exitWith :: ExitCode -> IO a
data ExitCode
ExitSuccess :: ExitCode
ExitFailure :: Int -> ExitCode
die :: String -> IO a


-- | Reexports <a>System.Exit.Compat</a> from a globally unique namespace.
module System.Exit.Compat.Repl

module System.IO.Compat
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)
print :: Show a => a -> IO ()
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
data IO a
getContents' :: IO String
hGetContents' :: Handle -> IO String
readFile' :: FilePath -> IO String


-- | Reexports <a>System.IO.Compat</a> from a globally unique namespace.
module System.IO.Compat.Repl

module System.IO.Error.Compat
ioError :: HasCallStack => IOError -> IO a
userError :: String -> IOError
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
type IOError = IOException
data IOErrorType
isResourceVanishedError :: IOError -> Bool
resourceVanishedErrorType :: IOErrorType
isResourceVanishedErrorType :: IOErrorType -> Bool


-- | Reexports <a>System.IO.Error.Compat</a> from a globally unique
--   namespace.
module System.IO.Error.Compat.Repl

module System.IO.Unsafe.Compat
unsafeFixIO :: (a -> IO a) -> IO a
unsafeDupablePerformIO :: IO a -> a
unsafeInterleaveIO :: IO a -> IO a
unsafePerformIO :: IO a -> a
unsafeFixIO :: (a -> IO a) -> IO a
unsafeDupablePerformIO :: IO a -> a


-- | Reexports <a>System.IO.Unsafe.Compat</a> from a globally unique
--   namespace.
module System.IO.Unsafe.Compat.Repl

module Text.Read.Compat
class Read a
readsPrec :: Read a => Int -> ReadS a
readList :: Read a => ReadS [a]
readPrec :: Read a => ReadPrec a
readListPrec :: Read a => ReadPrec [a]
type ReadS a = String -> [(a, String)]
reads :: Read a => ReadS a
read :: Read a => String -> a
readParen :: Bool -> ReadS a -> ReadS a
lex :: ReadS String
(+++) :: ReadPrec a -> ReadPrec a -> ReadPrec a
(<++) :: ReadPrec a -> ReadPrec a -> ReadPrec a
choice :: [ReadPrec a] -> ReadPrec a
get :: ReadPrec Char
lift :: ReadP a -> ReadPrec a
look :: ReadPrec String
minPrec :: Prec
pfail :: ReadPrec a
prec :: Prec -> ReadPrec a -> 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
reset :: ReadPrec a -> ReadPrec a
step :: ReadPrec a -> ReadPrec a
type Prec = Int
data ReadPrec a
data Lexeme
Char :: Char -> Lexeme
String :: String -> Lexeme
Punc :: String -> Lexeme
Ident :: String -> Lexeme
Symbol :: String -> Lexeme
Number :: Number -> Lexeme
EOF :: Lexeme
lexP :: ReadPrec Lexeme
parens :: ReadPrec a -> ReadPrec a
readListDefault :: Read a => ReadS [a]
readListPrecDefault :: Read a => ReadPrec [a]
readEither :: Read a => String -> Either String a
readMaybe :: Read a => String -> Maybe a


-- | Reexports <a>Text.Read.Compat</a> from a globally unique namespace.
module Text.Read.Compat.Repl

module Text.Read.Lex.Compat
expect :: Lexeme -> ReadP ()
hsLex :: ReadP String
isSymbolChar :: Char -> Bool
lex :: ReadP Lexeme
lexChar :: ReadP Char
numberToFixed :: Integer -> Number -> Maybe (Integer, Integer)
numberToInteger :: Number -> Maybe Integer
numberToRangedRational :: (Int, Int) -> Number -> Maybe Rational
numberToRational :: Number -> Rational
readBinP :: (Eq a, Num a) => ReadP a
readDecP :: (Eq a, Num a) => ReadP a
readHexP :: (Eq a, Num a) => ReadP a
readIntP :: Num a => a -> (Char -> Bool) -> (Char -> Int) -> ReadP a
readOctP :: (Eq a, Num a) => ReadP a
data Lexeme
Char :: Char -> Lexeme
String :: String -> Lexeme
Punc :: String -> Lexeme
Ident :: String -> Lexeme
Symbol :: String -> Lexeme
Number :: Number -> Lexeme
EOF :: Lexeme
data Number
readBinP :: (Eq a, Num a) => ReadP a


-- | Reexports <a>Text.Read.Lex.Compat</a> from a globally unique
--   namespace.
module Text.Read.Lex.Compat.Repl

module Type.Reflection.Compat
pattern App :: forall k2 t k1 a b. () => t ~ a b => TypeRep a -> TypeRep b -> TypeRep t
pattern Con :: () => NotApplication a => TyCon -> TypeRep a
pattern Con' :: () => NotApplication a => TyCon -> [SomeTypeRep] -> TypeRep a
pattern Fun :: forall k fun (r1 :: RuntimeRep) (r2 :: RuntimeRep) arg res. () => (k ~ Type, fun ~~ (arg -> res)) => TypeRep arg -> TypeRep res -> TypeRep fun
pattern TypeRep :: () => Typeable a => TypeRep a
decTypeRep :: forall k1 k2 (a :: k1) (b :: k2). TypeRep a -> TypeRep b -> Either ((a :~~: b) -> Void) (a :~~: b)
eqTypeRep :: forall k1 k2 (a :: k1) (b :: k2). TypeRep a -> TypeRep b -> Maybe (a :~~: b)
moduleName :: Module -> String
modulePackage :: Module -> String
rnfModule :: Module -> ()
rnfSomeTypeRep :: SomeTypeRep -> ()
rnfTyCon :: TyCon -> ()
rnfTypeRep :: forall {k} (a :: k). TypeRep a -> ()
someTypeRep :: forall {k} proxy (a :: k). Typeable a => proxy a -> SomeTypeRep
someTypeRepTyCon :: SomeTypeRep -> TyCon
splitApps :: forall {k} (a :: k). TypeRep a -> (TyCon, [SomeTypeRep])
tyConModule :: TyCon -> String
tyConName :: TyCon -> String
tyConPackage :: TyCon -> String
typeOf :: Typeable a => a -> TypeRep a
typeRep :: forall {k} (a :: k). Typeable a => TypeRep a
typeRepKind :: forall k (a :: k). TypeRep a -> TypeRep k
typeRepTyCon :: forall {k} (a :: k). TypeRep a -> TyCon
withTypeable :: forall k (a :: k) r. TypeRep a -> (Typeable a => r) -> r
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 SomeTypeRep
[SomeTypeRep] :: forall k (a :: k). !TypeRep a -> SomeTypeRep
data TypeRep (a :: k)
class Typeable (a :: k)
data Module
data TyCon
withTypeable :: forall k (a :: k) r. TypeRep a -> (Typeable a => r) -> r
pattern TypeRep :: () => Typeable a => TypeRep a
decTypeRep :: forall k1 k2 (a :: k1) (b :: k2). TypeRep a -> TypeRep b -> Either ((a :~~: b) -> Void) (a :~~: b)


-- | Reexports <a>Type.Reflection.Compat</a> from a globally unique
--   namespace.
module Type.Reflection.Compat.Repl
