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

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

module Control.Concurrent.Compat
forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
forkOSWithUnmask :: ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId

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

module Control.Concurrent.MVar.Compat
withMVarMasked :: MVar a -> (a -> IO b) -> IO b

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

module Control.Exception.Compat
throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a

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

module Control.Monad.Compat
guard :: Alternative f => Bool -> f ()
join :: Monad m => m (m a) -> m 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 Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b
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)
(=<<) :: Monad m => (a -> m b) -> m a -> m b
ap :: Monad m => m (a -> b) -> m a -> m b
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 ()
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
mzero :: MonadPlus m => m a
mplus :: MonadPlus m => m a -> m a -> m a
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
(<$!>) :: 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
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 ()
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
void :: Functor f => f a -> f ()
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
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 Control.Monad.Compat from a globally unique
--   namespace.
module Control.Monad.Compat.Repl

module Control.Monad.Fail.Compat

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

module Control.Monad.IO.Class.Compat

-- | Reexports Control.Monad.IO.Class.Compat 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 Control.Monad.ST.Lazy.Unsafe.Compat 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 Control.Monad.ST.Unsafe.Compat from a globally unique
--   namespace.
module Control.Monad.ST.Unsafe.Compat.Repl

module Data.Bifoldable.Compat

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

module Data.Bifunctor.Compat

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

module Data.Bitraversable.Compat

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

module Data.Bits.Compat
bitDefault :: (Bits a, Num a) => Int -> a
testBitDefault :: (Bits a, Num a) => a -> Int -> Bool
popCountDefault :: (Bits a, Num a) => a -> Int
toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b

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

module Data.Bool.Compat
bool :: a -> a -> Bool -> a

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

module Data.Complex.Compat

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

module Data.Either.Compat
isLeft :: Either a b -> Bool
isRight :: Either a b -> Bool
fromLeft :: a -> Either a b -> a
fromRight :: b -> Either a b -> b

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

module Data.Foldable.Compat

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

module Data.Function.Compat
(&) :: a -> (a -> b) -> b

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

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

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

module Data.Functor.Compose.Compat

-- | Reexports Data.Functor.Compose.Compat 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 Data.Functor.Const.Compat from a globally unique
--   namespace.
module Data.Functor.Const.Compat.Repl

module Data.Functor.Contravariant.Compat

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

module Data.Functor.Identity.Compat

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

module Data.Functor.Product.Compat

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

module Data.Functor.Sum.Compat

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

module Data.IORef.Compat
modifyIORef' :: IORef a -> (a -> a) -> IO ()
atomicModifyIORef' :: IORef a -> (a -> (a, b)) -> IO b
atomicWriteIORef :: IORef a -> a -> IO ()

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

module Data.List.Compat

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

-- | This backports the modern Data.Semigroup interface back to
--   base-4.9/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
head :: NonEmpty a -> a
tail :: NonEmpty a -> [a]
last :: NonEmpty a -> a
init :: NonEmpty a -> [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
reverse :: NonEmpty a -> NonEmpty a
inits :: Foldable f => f a -> NonEmpty [a]
tails :: Foldable f => f 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)
isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool
nub :: Eq a => NonEmpty a -> NonEmpty a
nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a
(!!) :: 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 :: [a] -> NonEmpty a
toList :: NonEmpty a -> [a]
nonEmpty :: [a] -> Maybe (NonEmpty a)
xor :: NonEmpty Bool -> Bool

-- | Reexports Data.List.NonEmpty.Compat 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 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 Ap (f :: k -> Type) (a :: k)
Ap :: f a -> Ap (f :: k -> Type) (a :: k)
[getAp] :: Ap (f :: k -> Type) (a :: k) -> f a
newtype Dual a
Dual :: a -> Dual a
[getDual] :: Dual a -> a
newtype 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 Product a
Product :: a -> Product a
[getProduct] :: Product a -> a
newtype Sum a
Sum :: a -> Sum a
[getSum] :: Sum a -> a
newtype Any
Any :: Bool -> Any
[getAny] :: Any -> Bool
newtype Endo a
Endo :: (a -> a) -> Endo a
[appEndo] :: Endo a -> a -> a
newtype All
All :: Bool -> All
[getAll] :: All -> Bool
(<>) :: Semigroup a => a -> a -> a

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

module Data.Proxy.Compat
asProxyTypeOf :: a -> proxy a -> a

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

module Data.Ratio.Compat

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

module Data.STRef.Compat
modifySTRef' :: STRef s a -> (a -> a) -> ST s ()

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

-- | This backports the modern Data.Semigroup interface back to
--   base-4.9/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
newtype Option a
Option :: Maybe a -> Option a
[getOption] :: Option a -> Maybe a
option :: b -> (a -> b) -> Option a -> b
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 Data.Semigroup.Compat from a globally unique
--   namespace.
module Data.Semigroup.Compat.Repl

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

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

module Data.Type.Coercion.Compat
gcoerceWith :: forall k (a :: k) (b :: k) r. Coercion a b -> (Coercible a b => r) -> r

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

module Data.Type.Equality.Compat

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

module Data.Version.Compat
makeVersion :: [Int] -> Version

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

module Data.Void.Compat

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

module Data.Word.Compat
byteSwap16 :: Word16 -> Word16
byteSwap32 :: Word32 -> Word32
byteSwap64 :: Word64 -> Word64

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

module Debug.Trace.Compat
traceId :: String -> String
traceShowId :: Show a => a -> a
traceM :: Applicative f => String -> f ()
traceShowM :: (Show a, Applicative f) => a -> f ()

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

module Foreign.ForeignPtr.Compat
plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b

-- | Reexports Foreign.ForeignPtr.Compat 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 Foreign.ForeignPtr.Safe.Compat from a globally unique
--   namespace.
module Foreign.ForeignPtr.Safe.Compat.Repl

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

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

module Foreign.Marshal.Alloc.Compat
calloc :: Storable a => IO (Ptr a)
callocBytes :: Int -> IO (Ptr a)

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

module Foreign.Marshal.Array.Compat
callocArray :: Storable a => Int -> IO (Ptr a)
callocArray0 :: Storable a => Int -> IO (Ptr a)

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

module Foreign.Marshal.Safe.Compat

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

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

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

module Foreign.Marshal.Utils.Compat
fillBytes :: Ptr a -> Word8 -> Int -> IO ()

module Foreign.Marshal.Compat

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

module Foreign.Compat

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

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

module Numeric.Compat
showFFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS
showGFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS
showHFloat :: RealFloat a => a -> ShowS

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

module Numeric.Natural.Compat

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

module Prelude.Compat

-- | Reexports Prelude.Compat 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 System.Environment.Compat from a globally unique
--   namespace.
module System.Environment.Compat.Repl

module System.Exit.Compat
die :: String -> IO a

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

module System.IO.Error.Compat

-- | An error indicating that the operation failed because the resource
--   vanished. See resourceVanishedErrorType.
--   
--   Since 4.14.0.0
isResourceVanishedError :: IOError -> Bool

-- | I/O error where the operation failed because the resource vanished.
--   This happens when, for example, attempting to write to a closed socket
--   or attempting to write to a named pipe that was deleted.
--   
--   Since 4.14.0.0
resourceVanishedErrorType :: IOErrorType

-- | I/O error where the operation failed because the resource vanished.
--   See resourceVanishedErrorType.
--   
--   Since 4.14.0.0
isResourceVanishedErrorType :: IOErrorType -> Bool

-- | Reexports System.IO.Error.Compat 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

-- | Reexports System.IO.Unsafe.Compat 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
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 Text.Read.Compat from a globally unique namespace.
module Text.Read.Compat.Repl

module Type.Reflection.Compat
withTypeable :: forall k (a :: k) (rep :: RuntimeRep) (r :: TYPE rep). TypeRep a -> (Typeable a => r) -> r

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