base-exports.stdout-javascript-unknown-ghcjs

    {-# MINIMAL pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh #-}
  type Foldable :: (* -> *) -> Constraint
  class Foldable t where
    ...
    foldMap :: forall m a. Monoid m => (a -> m) -> t a -> m
    ...
    foldr :: forall a b. (a -> b -> b) -> b -> t a -> b
    ...
    foldl :: forall b a. (b -> a -> b) -> b -> t a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> t a -> b
    foldr1 :: forall a. (a -> a -> a) -> t a -> a
    foldl1 :: forall a. (a -> a -> a) -> t a -> a
    ...
    null :: forall a. t a -> Bool
    length :: forall a. t a -> Int
    elem :: forall a. Eq a => a -> t a -> Bool
    maximum :: forall a. Ord a => t a -> a
    minimum :: forall a. Ord a => t a -> a
    sum :: forall a. Num a => t a -> a
    product :: forall a. Num a => t a -> a
    {-# MINIMAL foldMap | foldr #-}
  type Fractional :: * -> Constraint
  class Num a => Fractional a where
    (/) :: a -> a -> a
    recip :: a -> a
    fromRational :: Rational -> a
    {-# MINIMAL fromRational, (recip | (/)) #-}
  type Functor :: (* -> *) -> Constraint
  class Functor f where
    fmap :: forall a b. (a -> b) -> f a -> f b
    (<$) :: forall a b. a -> f b -> f a
    {-# MINIMAL fmap #-}
  type IO :: * -> *
  newtype IO a = ...
  type IOError :: *
  type IOError = GHC.Internal.IO.Exception.IOException
  type Int :: *
  data Int = ...
  type Integer :: *
  data Integer = ...
  type Integral :: * -> Constraint
  class (Real a, Enum a) => Integral a where
    quot :: a -> a -> a
    rem :: a -> a -> a
    div :: a -> a -> a
    mod :: a -> a -> a
    quotRem :: a -> a -> (a, a)
    divMod :: a -> a -> (a, a)
    toInteger :: a -> Integer
    {-# MINIMAL quotRem, toInteger #-}
  type Maybe :: * -> *
  data Maybe a = Nothing | Just a
  type Monad :: (* -> *) -> Constraint
  class Applicative m => Monad m where
    (>>=) :: forall a b. m a -> (a -> m b) -> m b
    (>>) :: forall a b. m a -> m b -> m b
    return :: forall a. a -> m a
    {-# MINIMAL (>>=) #-}
  type MonadFail :: (* -> *) -> Constraint
  class Monad m => MonadFail m where
    fail :: forall a. String -> m a
    {-# MINIMAL fail #-}
  type Monoid :: * -> Constraint
  class Semigroup a => Monoid a where
    mempty :: a
    mappend :: a -> a -> a
    mconcat :: [a] -> a
    {-# MINIMAL mempty | mconcat #-}
  type Num :: * -> Constraint
  class Num a where
    (+) :: a -> a -> a
    (-) :: a -> a -> a
    (*) :: a -> a -> a
    negate :: a -> a
    abs :: a -> a
    signum :: a -> a
    fromInteger :: Integer -> a
    {-# MINIMAL (+), (*), abs, signum, fromInteger, (negate | (-)) #-}
  type Ord :: * -> Constraint
  class Eq a => Ord a where
    compare :: a -> a -> Ordering
    (<) :: a -> a -> Bool
    (<=) :: a -> a -> Bool
    (>) :: a -> a -> Bool
    (>=) :: a -> a -> Bool
    max :: a -> a -> a
    min :: a -> a -> a
    {-# MINIMAL compare | (<=) #-}
  type Ordering :: *
  data Ordering = LT | EQ | GT
  type Rational :: *
  type Rational = GHC.Internal.Real.Ratio Integer
  type Read :: * -> Constraint
  class Read a where
    readsPrec :: Int -> ReadS a
    readList :: ReadS [a]
    ...
    {-# MINIMAL readsPrec | GHC.Internal.Read.readPrec #-}
  type ReadS :: * -> *
  type ReadS a = String -> [(a, String)]
  type Real :: * -> Constraint
  class (Num a, Ord a) => Real a where
    toRational :: a -> Rational
    {-# MINIMAL toRational #-}
  type RealFloat :: * -> Constraint
  class (RealFrac a, Floating a) => RealFloat a where
    floatRadix :: a -> Integer
    floatDigits :: a -> Int
    floatRange :: a -> (Int, Int)
    decodeFloat :: a -> (Integer, Int)
    encodeFloat :: Integer -> Int -> a
    exponent :: a -> Int
    significand :: a -> a
    scaleFloat :: Int -> a -> a
    isNaN :: a -> Bool
    isInfinite :: a -> Bool
    isDenormalized :: a -> Bool
    isNegativeZero :: a -> Bool
    isIEEE :: a -> Bool
    atan2 :: a -> a -> a
    {-# MINIMAL floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE #-}
  type RealFrac :: * -> Constraint
  class (Real a, Fractional a) => RealFrac a where
    properFraction :: forall b. Integral b => a -> (b, a)
    truncate :: forall b. Integral b => a -> b
    round :: forall b. Integral b => a -> b
    ceiling :: forall b. Integral b => a -> b
    floor :: forall b. Integral b => a -> b
    {-# MINIMAL properFraction #-}
  type Semigroup :: * -> Constraint
  class Semigroup a where
    (<>) :: a -> a -> a
    ...
    {-# MINIMAL (<>) | GHC.Internal.Base.sconcat #-}
  type Show :: * -> Constraint
  class Show a where
    showsPrec :: Int -> a -> ShowS
    show :: a -> String
    showList :: [a] -> ShowS
    {-# MINIMAL showsPrec | show #-}
  type ShowS :: *
  type ShowS = String -> String
  type String :: *
  type String = [Char]
  type Traversable :: (* -> *) -> Constraint
  class (Functor t, Foldable t) => Traversable t where
    traverse :: forall (f :: * -> *) a b. Applicative f => (a -> f b) -> t a -> f (t b)
    sequenceA :: forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a)
    mapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> t a -> m (t b)
    sequence :: forall (m :: * -> *) a. Monad m => t (m a) -> m (t a)
    {-# MINIMAL traverse | sequenceA #-}
  type Word :: *
  data Word = ...
  (^) :: forall a b. (Num a, Integral b) => a -> b -> a
  (^^) :: forall a b. (Fractional a, Integral b) => a -> b -> a
  all :: forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
  and :: forall (t :: * -> *). Foldable t => t Bool -> Bool
  any :: forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
  appendFile :: FilePath -> String -> IO ()
  asTypeOf :: forall a. a -> a -> a
  break :: forall a. (a -> Bool) -> [a] -> ([a], [a])
  concat :: forall (t :: * -> *) a. Foldable t => t [a] -> [a]
  concatMap :: forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
  const :: forall a b. a -> b -> a
  curry :: forall a b c. ((a, b) -> c) -> a -> b -> c
  cycle :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  drop :: forall a. Int -> [a] -> [a]
  dropWhile :: forall a. (a -> Bool) -> [a] -> [a]
  either :: forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
  error :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r). GHC.Internal.Stack.Types.HasCallStack => [Char] -> a
  errorWithoutStackTrace :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r). [Char] -> a
  even :: forall a. Integral a => a -> Bool
  filter :: forall a. (a -> Bool) -> [a] -> [a]
  flip :: forall a b c. (a -> b -> c) -> b -> a -> c
  fromIntegral :: forall a b. (Integral a, Num b) => a -> b
  fst :: forall a b. (a, b) -> a
  gcd :: forall a. Integral a => a -> a -> a
  getChar :: IO Char
  getContents :: IO String
  getLine :: IO String
  head :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> a
  id :: forall a. a -> a
  init :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  interact :: (String -> String) -> IO ()
  ioError :: forall a. IOError -> IO a
  iterate :: forall a. (a -> a) -> a -> [a]
  last :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> a
  lcm :: forall a. Integral a => a -> a -> a
  lex :: ReadS String
  lines :: String -> [String]
  lookup :: forall a b. Eq a => a -> [(a, b)] -> Maybe b
  map :: forall a b. (a -> b) -> [a] -> [b]
  mapM_ :: forall (t :: * -> *) (m :: * -> *) a b. (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
  maybe :: forall b a. b -> (a -> b) -> Maybe a -> b
  not :: Bool -> Bool
  notElem :: forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
  odd :: forall a. Integral a => a -> Bool
  or :: forall (t :: * -> *). Foldable t => t Bool -> Bool
  otherwise :: Bool
  print :: forall a. Show a => a -> IO ()
  putChar :: Char -> IO ()
  putStr :: String -> IO ()
  putStrLn :: String -> IO ()
  read :: forall a. Read a => String -> a
  readFile :: FilePath -> IO String
  readIO :: forall a. Read a => String -> IO a
  readLn :: forall a. Read a => IO a
  readParen :: forall a. Bool -> ReadS a -> ReadS a
  reads :: forall a. Read a => ReadS a
  realToFrac :: forall a b. (Real a, Fractional b) => a -> b
  repeat :: forall a. a -> [a]
  replicate :: forall a. Int -> a -> [a]
  reverse :: forall a. [a] -> [a]
  scanl :: forall b a. (b -> a -> b) -> b -> [a] -> [b]
  scanl1 :: forall a. (a -> a -> a) -> [a] -> [a]
  scanr :: forall a b. (a -> b -> b) -> b -> [a] -> [b]
  scanr1 :: forall a. (a -> a -> a) -> [a] -> [a]
  seq :: forall {r :: GHC.Types.RuntimeRep} a (b :: TYPE r). a -> b -> b
  sequence_ :: forall (t :: * -> *) (m :: * -> *) a. (Foldable t, Monad m) => t (m a) -> m ()
  showChar :: Char -> ShowS
  showParen :: Bool -> ShowS -> ShowS
  showString :: String -> ShowS
  shows :: forall a. Show a => a -> ShowS
  snd :: forall a b. (a, b) -> b
  span :: forall a. (a -> Bool) -> [a] -> ([a], [a])
  splitAt :: forall a. Int -> [a] -> ([a], [a])
  subtract :: forall a. Num a => a -> a -> a
  tail :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  take :: forall a. Int -> [a] -> [a]
  takeWhile :: forall a. (a -> Bool) -> [a] -> [a]
  uncurry :: forall a b c. (a -> b -> c) -> (a, b) -> c
  undefined :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r). GHC.Internal.Stack.Types.HasCallStack => a
  unlines :: [String] -> String
  until :: forall a. (a -> Bool) -> (a -> a) -> a -> a
  unwords :: [String] -> String
  unzip :: forall a b. [(a, b)] -> ([a], [b])
  unzip3 :: forall a b c. [(a, b, c)] -> ([a], [b], [c])
  userError :: String -> IOError
  words :: String -> [String]
  writeFile :: FilePath -> String -> IO ()
  zip :: forall a b. [a] -> [b] -> [(a, b)]
  zip3 :: forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
  zipWith :: forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
  zipWith3 :: forall a b c d. (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
  (||) :: Bool -> Bool -> Bool
  type (~) :: forall k. k -> k -> Constraint
  class (a ~ b) => (~) a b
    {-# MINIMAL #-}

module System.CPUTime where
  -- Safety: Trustworthy
  cpuTimePrecision :: GHC.Num.Integer.Integer
  getCPUTime :: GHC.Types.IO GHC.Num.Integer.Integer

module System.Console.GetOpt where
  -- Safety: Safe
  type ArgDescr :: * -> *
  data ArgDescr a = NoArg a | ReqArg (GHC.Internal.Base.String -> a) GHC.Internal.Base.String | OptArg (GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> a) GHC.Internal.Base.String
  type ArgOrder :: * -> *
  data ArgOrder a = RequireOrder | Permute | ReturnInOrder (GHC.Internal.Base.String -> a)
  type OptDescr :: * -> *
  data OptDescr a = Option [GHC.Types.Char] [GHC.Internal.Base.String] (ArgDescr a) GHC.Internal.Base.String
  getOpt :: forall a. ArgOrder a -> [OptDescr a] -> [GHC.Internal.Base.String] -> ([a], [GHC.Internal.Base.String], [GHC.Internal.Base.String])
  getOpt' :: forall a. ArgOrder a -> [OptDescr a] -> [GHC.Internal.Base.String] -> ([a], [GHC.Internal.Base.String], [GHC.Internal.Base.String], [GHC.Internal.Base.String])
  usageInfo :: forall a. GHC.Internal.Base.String -> [OptDescr a] -> GHC.Internal.Base.String

module System.Environment where
  -- Safety: Safe
  executablePath :: GHC.Internal.Maybe.Maybe (GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Internal.IO.FilePath))
  getArgs :: GHC.Types.IO [GHC.Internal.Base.String]
  getEnv :: GHC.Internal.Base.String -> GHC.Types.IO GHC.Internal.Base.String
  getEnvironment :: GHC.Types.IO [(GHC.Internal.Base.String, GHC.Internal.Base.String)]
  getExecutablePath :: GHC.Types.IO GHC.Internal.IO.FilePath
  getProgName :: GHC.Types.IO GHC.Internal.Base.String
  lookupEnv :: GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Internal.Base.String)
  setEnv :: GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Types.IO ()
  unsetEnv :: GHC.Internal.Base.String -> GHC.Types.IO ()
  withArgs :: forall a. [GHC.Internal.Base.String] -> GHC.Types.IO a -> GHC.Types.IO a
  withProgName :: forall a. GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO a

module System.Environment.Blank where
  -- Safety: Safe
  getArgs :: GHC.Types.IO [GHC.Internal.Base.String]
  getEnv :: GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Internal.Base.String)
  getEnvDefault :: GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Types.IO GHC.Internal.Base.String
  getEnvironment :: GHC.Types.IO [(GHC.Internal.Base.String, GHC.Internal.Base.String)]
  getExecutablePath :: GHC.Types.IO GHC.Internal.IO.FilePath
  getProgName :: GHC.Types.IO GHC.Internal.Base.String
  setEnv :: GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Types.Bool -> GHC.Types.IO ()
  unsetEnv :: GHC.Internal.Base.String -> GHC.Types.IO ()
  withArgs :: forall a. [GHC.Internal.Base.String] -> GHC.Types.IO a -> GHC.Types.IO a
  withProgName :: forall a. GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO a

module System.Exit where
  -- Safety: Safe
  type ExitCode :: *
  data ExitCode = ExitSuccess | ExitFailure GHC.Types.Int
  die :: forall a. GHC.Internal.Base.String -> GHC.Types.IO a
  exitFailure :: forall a. GHC.Types.IO a
  exitSuccess :: forall a. GHC.Types.IO a
  exitWith :: forall a. ExitCode -> GHC.Types.IO a

module System.IO where
  -- Safety: Safe
  type BufferMode :: *
  data BufferMode = NoBuffering | LineBuffering | BlockBuffering (GHC.Internal.Maybe.Maybe GHC.Types.Int)
  type FilePath :: *
  type FilePath = GHC.Internal.Base.String
  type Handle :: *
  data Handle = ...
  type HandlePosn :: *
  data HandlePosn = ...
  type IO :: * -> *
  newtype IO a = ...
  type IOMode :: *
  data IOMode = ReadMode | WriteMode | AppendMode | ReadWriteMode
  type Newline :: *
  data Newline = LF | CRLF
  type NewlineMode :: *
  data NewlineMode = NewlineMode {inputNL :: Newline, outputNL :: Newline}
  type SeekMode :: *
  data SeekMode = AbsoluteSeek | RelativeSeek | SeekFromEnd
  type TextEncoding :: *
  data TextEncoding = ...
  appendFile :: FilePath -> GHC.Internal.Base.String -> IO ()
  char8 :: TextEncoding
  fixIO :: forall a. (a -> IO a) -> IO a
  getChar :: IO GHC.Types.Char
  getContents :: IO GHC.Internal.Base.String
  getContents' :: IO GHC.Internal.Base.String
  getLine :: IO GHC.Internal.Base.String
  hClose :: Handle -> IO ()
  hFileSize :: Handle -> IO GHC.Num.Integer.Integer
  hFlush :: Handle -> IO ()
  hGetBuf :: forall a. Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> IO GHC.Types.Int
  hGetBufNonBlocking :: forall a. Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> IO GHC.Types.Int
  hGetBufSome :: forall a. Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> IO GHC.Types.Int
  hGetBuffering :: Handle -> IO BufferMode
  hGetChar :: Handle -> IO GHC.Types.Char
  hGetContents :: Handle -> IO GHC.Internal.Base.String
  hGetContents' :: Handle -> IO GHC.Internal.Base.String
  hGetEcho :: Handle -> IO GHC.Types.Bool
  hGetEncoding :: Handle -> IO (GHC.Internal.Maybe.Maybe TextEncoding)
  hGetLine :: Handle -> IO GHC.Internal.Base.String
  hGetPosn :: Handle -> IO HandlePosn
  hIsClosed :: Handle -> IO GHC.Types.Bool
  hIsEOF :: Handle -> IO GHC.Types.Bool
  hIsOpen :: Handle -> IO GHC.Types.Bool
  hIsReadable :: Handle -> IO GHC.Types.Bool
  hIsSeekable :: Handle -> IO GHC.Types.Bool
  hIsTerminalDevice :: Handle -> IO GHC.Types.Bool
  hIsWritable :: Handle -> IO GHC.Types.Bool
  hLookAhead :: Handle -> IO GHC.Types.Char
  hPrint :: forall a. GHC.Internal.Show.Show a => Handle -> a -> IO ()
  hPutBuf :: forall a. Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> IO ()
  hPutBufNonBlocking :: forall a. Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> IO GHC.Types.Int
  hPutChar :: Handle -> GHC.Types.Char -> IO ()
  hPutStr :: Handle -> GHC.Internal.Base.String -> IO ()
  hPutStrLn :: Handle -> GHC.Internal.Base.String -> IO ()
  hReady :: Handle -> IO GHC.Types.Bool
  hSeek :: Handle -> SeekMode -> GHC.Num.Integer.Integer -> IO ()
  hSetBinaryMode :: Handle -> GHC.Types.Bool -> IO ()
  hSetBuffering :: Handle -> BufferMode -> IO ()
  hSetEcho :: Handle -> GHC.Types.Bool -> IO ()
  hSetEncoding :: Handle -> TextEncoding -> IO ()
  hSetFileSize :: Handle -> GHC.Num.Integer.Integer -> IO ()
  hSetNewlineMode :: Handle -> NewlineMode -> IO ()
  hSetPosn :: HandlePosn -> IO ()
  hShow :: Handle -> IO GHC.Internal.Base.String
  hTell :: Handle -> IO GHC.Num.Integer.Integer
  hWaitForInput :: Handle -> GHC.Types.Int -> IO GHC.Types.Bool
  interact :: (GHC.Internal.Base.String -> GHC.Internal.Base.String) -> IO ()
  isEOF :: IO GHC.Types.Bool
  latin1 :: TextEncoding
  localeEncoding :: TextEncoding
  mkTextEncoding :: GHC.Internal.Base.String -> IO TextEncoding
  nativeNewline :: Newline
  nativeNewlineMode :: NewlineMode
  noNewlineTranslation :: NewlineMode
  openBinaryFile :: FilePath -> IOMode -> IO Handle
  openBinaryTempFile :: FilePath -> GHC.Internal.Base.String -> IO (FilePath, Handle)
  openBinaryTempFileWithDefaultPermissions :: FilePath -> GHC.Internal.Base.String -> IO (FilePath, Handle)
  openFile :: FilePath -> IOMode -> IO Handle
  openTempFile :: FilePath -> GHC.Internal.Base.String -> IO (FilePath, Handle)
  openTempFileWithDefaultPermissions :: FilePath -> GHC.Internal.Base.String -> IO (FilePath, Handle)
  print :: forall a. GHC.Internal.Show.Show a => a -> IO ()
  putChar :: GHC.Types.Char -> IO ()
  putStr :: GHC.Internal.Base.String -> IO ()
  putStrLn :: GHC.Internal.Base.String -> IO ()
  readFile :: FilePath -> IO GHC.Internal.Base.String
  readFile' :: FilePath -> IO GHC.Internal.Base.String
  readIO :: forall a. GHC.Internal.Read.Read a => GHC.Internal.Base.String -> IO a
  readLn :: forall a. GHC.Internal.Read.Read a => IO a
  stderr :: Handle
  stdin :: Handle
  stdout :: Handle
  universalNewlineMode :: NewlineMode
  utf16 :: TextEncoding
  utf16be :: TextEncoding
  utf16le :: TextEncoding
  utf32 :: TextEncoding
  utf32be :: TextEncoding
  utf32le :: TextEncoding
  utf8 :: TextEncoding
  utf8_bom :: TextEncoding
  withBinaryFile :: forall r. FilePath -> IOMode -> (Handle -> IO r) -> IO r
  withFile :: forall r. FilePath -> IOMode -> (Handle -> IO r) -> IO r
  writeFile :: FilePath -> GHC.Internal.Base.String -> IO ()

module System.IO.Error where
  -- Safety: Safe
  type IOError :: *
  type IOError = GHC.Internal.IO.Exception.IOException
  type IOErrorType :: *
  data IOErrorType = ...
  alreadyExistsErrorType :: IOErrorType
  alreadyInUseErrorType :: IOErrorType
  annotateIOError :: IOError -> GHC.Internal.Base.String -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.FilePath -> IOError
  catchIOError :: forall a. GHC.Types.IO a -> (IOError -> GHC.Types.IO a) -> GHC.Types.IO a
  doesNotExistErrorType :: IOErrorType
  eofErrorType :: IOErrorType
  fullErrorType :: IOErrorType
  illegalOperationErrorType :: IOErrorType
  ioError :: forall a. IOError -> GHC.Types.IO a
  ioeGetErrorString :: IOError -> GHC.Internal.Base.String
  ioeGetErrorType :: IOError -> IOErrorType
  ioeGetFileName :: IOError -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.FilePath
  ioeGetHandle :: IOError -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Handle.Types.Handle
  ioeGetLocation :: IOError -> GHC.Internal.Base.String
  ioeSetErrorString :: IOError -> GHC.Internal.Base.String -> IOError
  ioeSetErrorType :: IOError -> IOErrorType -> IOError
  ioeSetFileName :: IOError -> GHC.Internal.IO.FilePath -> IOError
  ioeSetHandle :: IOError -> GHC.Internal.IO.Handle.Types.Handle -> IOError
  ioeSetLocation :: IOError -> GHC.Internal.Base.String -> IOError
  isAlreadyExistsError :: IOError -> GHC.Types.Bool
  isAlreadyExistsErrorType :: IOErrorType -> GHC.Types.Bool
  isAlreadyInUseError :: IOError -> GHC.Types.Bool
  isAlreadyInUseErrorType :: IOErrorType -> GHC.Types.Bool
  isDoesNotExistError :: IOError -> GHC.Types.Bool
  isDoesNotExistErrorType :: IOErrorType -> GHC.Types.Bool
  isEOFError :: IOError -> GHC.Types.Bool
  isEOFErrorType :: IOErrorType -> GHC.Types.Bool
  isFullError :: IOError -> GHC.Types.Bool
  isFullErrorType :: IOErrorType -> GHC.Types.Bool
  isIllegalOperation :: IOError -> GHC.Types.Bool
  isIllegalOperationErrorType :: IOErrorType -> GHC.Types.Bool
  isPermissionError :: IOError -> GHC.Types.Bool
  isPermissionErrorType :: IOErrorType -> GHC.Types.Bool
  isResourceVanishedError :: IOError -> GHC.Types.Bool
  isResourceVanishedErrorType :: IOErrorType -> GHC.Types.Bool
  isUserError :: IOError -> GHC.Types.Bool
  isUserErrorType :: IOErrorType -> GHC.Types.Bool
  mkIOError :: IOErrorType -> GHC.Internal.Base.String -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.FilePath -> IOError
  modifyIOError :: forall a. (IOError -> IOError) -> GHC.Types.IO a -> GHC.Types.IO a
  permissionErrorType :: IOErrorType
  resourceVanishedErrorType :: IOErrorType
  tryIOError :: forall a. GHC.Types.IO a -> GHC.Types.IO (GHC.Internal.Data.Either.Either IOError a)
  userError :: GHC.Internal.Base.String -> IOError
  userErrorType :: IOErrorType

module System.IO.Unsafe where
  -- Safety: Unsafe
  unsafeDupablePerformIO :: forall a. GHC.Types.IO a -> a
  unsafeFixIO :: forall a. (a -> GHC.Types.IO a) -> GHC.Types.IO a
  unsafeInterleaveIO :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  unsafePerformIO :: forall a. GHC.Types.IO a -> a

module System.Info where
  -- Safety: Safe
  arch :: GHC.Internal.Base.String
  compilerName :: GHC.Internal.Base.String
  compilerVersion :: GHC.Internal.Data.Version.Version
  fullCompilerVersion :: GHC.Internal.Data.Version.Version
  os :: GHC.Internal.Base.String

module System.Mem where
  -- Safety: Safe
  disableAllocationLimit :: GHC.Types.IO ()
  enableAllocationLimit :: GHC.Types.IO ()
  getAllocationCounter :: GHC.Types.IO GHC.Internal.Int.Int64
  performBlockingMajorGC :: GHC.Types.IO ()
  performGC :: GHC.Types.IO ()
  performMajorGC :: GHC.Types.IO ()
  performMinorGC :: GHC.Types.IO ()
  setAllocationCounter :: GHC.Internal.Int.Int64 -> GHC.Types.IO ()

module System.Mem.StableName where
  -- Safety: Safe
  type role StableName phantom
  type StableName :: * -> *
  data StableName a = ...
  eqStableName :: forall a b. StableName a -> StableName b -> GHC.Types.Bool
  hashStableName :: forall a. StableName a -> GHC.Types.Int
  makeStableName :: forall a. a -> GHC.Types.IO (StableName a)

module System.Mem.Weak where
  -- Safety: Trustworthy
  type Weak :: * -> *
  data Weak v = ...
  addFinalizer :: forall key. key -> GHC.Types.IO () -> GHC.Types.IO ()
  deRefWeak :: forall v. Weak v -> GHC.Types.IO (GHC.Internal.Maybe.Maybe v)
  finalize :: forall v. Weak v -> GHC.Types.IO ()
  getFinalizerExceptionHandler :: GHC.Types.IO (GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ())
  mkWeak :: forall k v. k -> v -> GHC.Internal.Maybe.Maybe (GHC.Types.IO ()) -> GHC.Types.IO (Weak v)
  mkWeakPair :: forall k v. k -> v -> GHC.Internal.Maybe.Maybe (GHC.Types.IO ()) -> GHC.Types.IO (Weak (k, v))
  mkWeakPtr :: forall k. k -> GHC.Internal.Maybe.Maybe (GHC.Types.IO ()) -> GHC.Types.IO (Weak k)
  printToHandleFinalizerExceptionHandler :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ()
  setFinalizerExceptionHandler :: (GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ()) -> GHC.Types.IO ()

module System.Posix.Internals where
  -- Safety: Safe
  type CFLock :: *
  data CFLock
  type CFilePath :: *
  type CFilePath = GHC.Internal.Foreign.C.String.Encoding.CString
  type CGroup :: *
  data CGroup
  type CLconv :: *
  data CLconv
  type CPasswd :: *
  data CPasswd
  type CSigaction :: *
  data CSigaction
  type CSigset :: *
  data CSigset
  type CStat :: *
  data CStat
  type CTermios :: *
  data CTermios
  type CTm :: *
  data CTm
  type CTms :: *
  data CTms
  type CUtimbuf :: *
  data CUtimbuf
  type CUtsname :: *
  data CUtsname
  type FD :: *
  type FD = GHC.Internal.Foreign.C.Types.CInt
  c_access :: GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_chmod :: GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_close :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_creat :: GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_dup :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_dup2 :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_fcntl_lock :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr CFLock -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_fcntl_read :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_fcntl_write :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Foreign.C.Types.CLong -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_fstat :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_ftruncate :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.System.Posix.Types.FileOffset -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_getpid :: GHC.Types.IO GHC.Internal.System.Posix.Types.CPid
  c_interruptible_open :: CFilePath -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_interruptible_open_ :: CFilePath -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_isatty :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_lflag :: GHC.Internal.Ptr.Ptr CTermios -> GHC.Types.IO GHC.Internal.System.Posix.Types.CTcflag
  c_link :: GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_lseek :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.System.Posix.Types.COff -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.System.Posix.Types.COff
  c_mkfifo :: GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_open :: CFilePath -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_pipe :: GHC.Internal.Ptr.Ptr GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_read :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Internal.Foreign.C.Types.CSize -> GHC.Types.IO GHC.Internal.System.Posix.Types.CSsize
  c_s_isblk :: GHC.Internal.System.Posix.Types.CMode -> GHC.Internal.Foreign.C.Types.CInt
  c_s_ischr :: GHC.Internal.System.Posix.Types.CMode -> GHC.Internal.Foreign.C.Types.CInt
  c_s_isdir :: GHC.Internal.System.Posix.Types.CMode -> GHC.Internal.Foreign.C.Types.CInt
  c_s_isfifo :: GHC.Internal.System.Posix.Types.CMode -> GHC.Internal.Foreign.C.Types.CInt
  c_s_isreg :: GHC.Internal.System.Posix.Types.CMode -> GHC.Internal.Foreign.C.Types.CInt
  c_s_issock :: GHC.Internal.System.Posix.Types.CMode -> GHC.Internal.Foreign.C.Types.CInt
  c_safe_open :: CFilePath -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_safe_open_ :: CFilePath -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_safe_read :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Internal.Foreign.C.Types.CSize -> GHC.Types.IO GHC.Internal.System.Posix.Types.CSsize
  c_safe_write :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Internal.Foreign.C.Types.CSize -> GHC.Types.IO GHC.Internal.System.Posix.Types.CSsize
  c_sigaddset :: GHC.Internal.Ptr.Ptr CSigset -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_sigemptyset :: GHC.Internal.Ptr.Ptr CSigset -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_sigprocmask :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr CSigset -> GHC.Internal.Ptr.Ptr CSigset -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_stat :: CFilePath -> GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_tcgetattr :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr CTermios -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_tcsetattr :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr CTermios -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_umask :: GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.System.Posix.Types.CMode
  c_unlink :: GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_utime :: GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Internal.Ptr.Ptr CUtimbuf -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_waitpid :: GHC.Internal.System.Posix.Types.CPid -> GHC.Internal.Ptr.Ptr GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.System.Posix.Types.CPid
  c_write :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Internal.Foreign.C.Types.CSize -> GHC.Types.IO GHC.Internal.System.Posix.Types.CSsize
  checkForInteriorNuls :: GHC.Internal.IO.FilePath -> GHC.Internal.Foreign.C.String.Encoding.CStringLen -> GHC.Types.IO ()
  const_echo :: GHC.Internal.Foreign.C.Types.CInt
  const_f_getfl :: GHC.Internal.Foreign.C.Types.CInt
  const_f_setfd :: GHC.Internal.Foreign.C.Types.CInt
  const_f_setfl :: GHC.Internal.Foreign.C.Types.CInt
  const_fd_cloexec :: GHC.Internal.Foreign.C.Types.CLong
  const_icanon :: GHC.Internal.Foreign.C.Types.CInt
  const_sig_block :: GHC.Internal.Foreign.C.Types.CInt
  const_sig_setmask :: GHC.Internal.Foreign.C.Types.CInt
  const_sigttou :: GHC.Internal.Foreign.C.Types.CInt
  const_tcsanow :: GHC.Internal.Foreign.C.Types.CInt
  const_vmin :: GHC.Internal.Foreign.C.Types.CInt
  const_vtime :: GHC.Internal.Foreign.C.Types.CInt
  dEFAULT_BUFFER_SIZE :: GHC.Types.Int
  fdFileSize :: FD -> GHC.Types.IO GHC.Num.Integer.Integer
  fdGetMode :: FD -> GHC.Types.IO GHC.Internal.IO.IOMode.IOMode
  fdStat :: FD -> GHC.Types.IO (GHC.Internal.IO.Device.IODeviceType, GHC.Internal.System.Posix.Types.CDev, GHC.Internal.System.Posix.Types.CIno)
  fdType :: FD -> GHC.Types.IO GHC.Internal.IO.Device.IODeviceType
  fileType :: GHC.Internal.IO.FilePath -> GHC.Types.IO GHC.Internal.IO.Device.IODeviceType
  getEcho :: FD -> GHC.Types.IO GHC.Types.Bool
  get_saved_termios :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO (GHC.Internal.Ptr.Ptr CTermios)
  hostIsThreaded :: GHC.Types.Bool
  ioe_unknownfiletype :: GHC.Internal.IO.Exception.IOException
  lstat :: CFilePath -> GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  newFilePath :: GHC.Internal.IO.FilePath -> GHC.Types.IO GHC.Internal.Foreign.C.String.Encoding.CString
  o_APPEND :: GHC.Internal.Foreign.C.Types.CInt
  o_BINARY :: GHC.Internal.Foreign.C.Types.CInt
  o_CREAT :: GHC.Internal.Foreign.C.Types.CInt
  o_EXCL :: GHC.Internal.Foreign.C.Types.CInt
  o_NOCTTY :: GHC.Internal.Foreign.C.Types.CInt
  o_NONBLOCK :: GHC.Internal.Foreign.C.Types.CInt
  o_RDONLY :: GHC.Internal.Foreign.C.Types.CInt
  o_RDWR :: GHC.Internal.Foreign.C.Types.CInt
  o_TRUNC :: GHC.Internal.Foreign.C.Types.CInt
  o_WRONLY :: GHC.Internal.Foreign.C.Types.CInt
  peekFilePath :: GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Types.IO GHC.Internal.IO.FilePath
  peekFilePathLen :: GHC.Internal.Foreign.C.String.Encoding.CStringLen -> GHC.Types.IO GHC.Internal.IO.FilePath
  poke_c_lflag :: GHC.Internal.Ptr.Ptr CTermios -> GHC.Internal.System.Posix.Types.CTcflag -> GHC.Types.IO ()
  ptr_c_cc :: GHC.Internal.Ptr.Ptr CTermios -> GHC.Types.IO (GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8)
  puts :: GHC.Internal.Base.String -> GHC.Types.IO ()
  rtsIsThreaded_ :: GHC.Types.Int
  sEEK_CUR :: GHC.Internal.Foreign.C.Types.CInt
  sEEK_END :: GHC.Internal.Foreign.C.Types.CInt
  sEEK_SET :: GHC.Internal.Foreign.C.Types.CInt
  s_isblk :: GHC.Internal.System.Posix.Types.CMode -> GHC.Types.Bool
  s_ischr :: GHC.Internal.System.Posix.Types.CMode -> GHC.Types.Bool
  s_isdir :: GHC.Internal.System.Posix.Types.CMode -> GHC.Types.Bool
  s_isfifo :: GHC.Internal.System.Posix.Types.CMode -> GHC.Types.Bool
  s_isreg :: GHC.Internal.System.Posix.Types.CMode -> GHC.Types.Bool
  s_issock :: GHC.Internal.System.Posix.Types.CMode -> GHC.Types.Bool
  setCloseOnExec :: FD -> GHC.Types.IO ()
  setCooked :: FD -> GHC.Types.Bool -> GHC.Types.IO ()
  setEcho :: FD -> GHC.Types.Bool -> GHC.Types.IO ()
  setNonBlockingFD :: FD -> GHC.Types.Bool -> GHC.Types.IO ()
  set_saved_termios :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr CTermios -> GHC.Types.IO ()
  sizeof_sigset_t :: GHC.Types.Int
  sizeof_stat :: GHC.Types.Int
  sizeof_termios :: GHC.Types.Int
  st_dev :: GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.System.Posix.Types.CDev
  st_ino :: GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.System.Posix.Types.CIno
  st_mode :: GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.System.Posix.Types.CMode
  st_mtime :: GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CTime
  st_size :: GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.Int.Int64
  statGetType :: GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.IO.Device.IODeviceType
  tcSetAttr :: forall a. FD -> (GHC.Internal.Ptr.Ptr CTermios -> GHC.Types.IO a) -> GHC.Types.IO a
  throwInternalNulError :: forall a. GHC.Internal.IO.FilePath -> GHC.Types.IO a
  withFilePath :: forall a. GHC.Internal.IO.FilePath -> (GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Types.IO a) -> GHC.Types.IO a

module System.Posix.Types where

-- ignored


module System.Timeout where
  -- Safety: Safe
  type Timeout :: *
  newtype Timeout = ...
  timeout :: forall a. GHC.Types.Int -> GHC.Types.IO a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe a)

module Text.ParserCombinators.ReadP where
  -- Safety: Safe
  (+++) :: forall a. ReadP a -> ReadP a -> ReadP a
  (<++) :: forall a. ReadP a -> ReadP a -> ReadP a
  type ReadP :: * -> *
  newtype ReadP a = ...
  type ReadS :: * -> *
  type ReadS a = GHC.Internal.Base.String -> [(a, GHC.Internal.Base.String)]
  between :: forall open close a. ReadP open -> ReadP close -> ReadP a -> ReadP a
  chainl :: forall a. ReadP a -> ReadP (a -> a -> a) -> a -> ReadP a
  chainl1 :: forall a. ReadP a -> ReadP (a -> a -> a) -> ReadP a
  chainr :: forall a. ReadP a -> ReadP (a -> a -> a) -> a -> ReadP a
  chainr1 :: forall a. ReadP a -> ReadP (a -> a -> a) -> ReadP a
  char :: GHC.Types.Char -> ReadP GHC.Types.Char
  choice :: forall a. [ReadP a] -> ReadP a
  count :: forall a. GHC.Types.Int -> ReadP a -> ReadP [a]
  endBy :: forall a sep. ReadP a -> ReadP sep -> ReadP [a]
  endBy1 :: forall a sep. ReadP a -> ReadP sep -> ReadP [a]
  eof :: ReadP ()
  gather :: forall a. ReadP a -> ReadP (GHC.Internal.Base.String, a)
  get :: ReadP GHC.Types.Char
  look :: ReadP GHC.Internal.Base.String
  many :: forall a. ReadP a -> ReadP [a]
  many1 :: forall a. ReadP a -> ReadP [a]
  manyTill :: forall a end. ReadP a -> ReadP end -> ReadP [a]
  munch :: (GHC.Types.Char -> GHC.Types.Bool) -> ReadP GHC.Internal.Base.String
  munch1 :: (GHC.Types.Char -> GHC.Types.Bool) -> ReadP GHC.Internal.Base.String
  option :: forall a. a -> ReadP a -> ReadP a
  optional :: forall a. ReadP a -> ReadP ()
  pfail :: forall a. ReadP a
  readP_to_S :: forall a. ReadP a -> ReadS a
  readS_to_P :: forall a. ReadS a -> ReadP a
  satisfy :: (GHC.Types.Char -> GHC.Types.Bool) -> ReadP GHC.Types.Char
  sepBy :: forall a sep. ReadP a -> ReadP sep -> ReadP [a]
  sepBy1 :: forall a sep. ReadP a -> ReadP sep -> ReadP [a]
  skipMany :: forall a. ReadP a -> ReadP ()
  skipMany1 :: forall a. ReadP a -> ReadP ()
  skipSpaces :: ReadP ()
  string :: GHC.Internal.Base.String -> ReadP GHC.Internal.Base.String

module Text.ParserCombinators.ReadPrec where
  -- Safety: Safe
  (+++) :: forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
  (<++) :: forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
  type Prec :: *
  type Prec = GHC.Types.Int
  type ReadPrec :: * -> *
  newtype ReadPrec a = ...
  choice :: forall a. [ReadPrec a] -> ReadPrec a
  get :: ReadPrec GHC.Types.Char
  lift :: forall a. GHC.Internal.Text.ParserCombinators.ReadP.ReadP a -> ReadPrec a
  look :: ReadPrec GHC.Internal.Base.String
  minPrec :: Prec
  pfail :: forall a. ReadPrec a
  prec :: forall a. Prec -> ReadPrec a -> ReadPrec a
  readP_to_Prec :: forall a. (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadP a) -> ReadPrec a
  readPrec_to_P :: forall a. ReadPrec a -> GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadP a
  readPrec_to_S :: forall a. ReadPrec a -> GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readS_to_Prec :: forall a. (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a) -> ReadPrec a
  reset :: forall a. ReadPrec a -> ReadPrec a
  step :: forall a. ReadPrec a -> ReadPrec a

module Text.Printf where
  -- Safety: Safe
  type FieldFormat :: *
  data FieldFormat = FieldFormat {fmtWidth :: GHC.Internal.Maybe.Maybe GHC.Types.Int, fmtPrecision :: GHC.Internal.Maybe.Maybe GHC.Types.Int, fmtAdjust :: GHC.Internal.Maybe.Maybe FormatAdjustment, fmtSign :: GHC.Internal.Maybe.Maybe FormatSign, fmtAlternate :: GHC.Types.Bool, fmtModifiers :: GHC.Internal.Base.String, fmtChar :: GHC.Types.Char}
  type FieldFormatter :: *
  type FieldFormatter = FieldFormat -> GHC.Internal.Show.ShowS
  type FormatAdjustment :: *
  data FormatAdjustment = LeftAdjust | ZeroPad
  type FormatParse :: *
  data FormatParse = FormatParse {fpModifiers :: GHC.Internal.Base.String, fpChar :: GHC.Types.Char, fpRest :: GHC.Internal.Base.String}
  type FormatSign :: *
  data FormatSign = SignPlus | SignSpace
  type HPrintfType :: * -> Constraint
  class HPrintfType t where
    ...
    {-# MINIMAL Text.Printf.hspr #-}
  type IsChar :: * -> Constraint
  class IsChar c where
    toChar :: c -> GHC.Types.Char
    fromChar :: GHC.Types.Char -> c
    {-# MINIMAL toChar, fromChar #-}
  type ModifierParser :: *
  type ModifierParser = GHC.Internal.Base.String -> FormatParse
  type PrintfArg :: * -> Constraint
  class PrintfArg a where
    formatArg :: a -> FieldFormatter
    parseFormat :: a -> ModifierParser
    {-# MINIMAL formatArg #-}
  type PrintfType :: * -> Constraint
  class PrintfType t where
    ...
    {-# MINIMAL Text.Printf.spr #-}
  errorBadArgument :: forall a. a
  errorBadFormat :: forall a. GHC.Types.Char -> a
  errorMissingArgument :: forall a. a
  errorShortFormat :: forall a. a
  formatChar :: GHC.Types.Char -> FieldFormatter
  formatInt :: forall a. (GHC.Internal.Real.Integral a, GHC.Internal.Enum.Bounded a) => a -> FieldFormatter
  formatInteger :: GHC.Num.Integer.Integer -> FieldFormatter
  formatRealFloat :: forall a. GHC.Internal.Float.RealFloat a => a -> FieldFormatter
  formatString :: forall a. IsChar a => [a] -> FieldFormatter
  hPrintf :: forall r. HPrintfType r => GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Base.String -> r
  perror :: forall a. GHC.Internal.Base.String -> a
  printf :: forall r. PrintfType r => GHC.Internal.Base.String -> r
  vFmt :: GHC.Types.Char -> FieldFormat -> FieldFormat

module Text.Read where
  -- Safety: Safe
  (+++) :: forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
  (<++) :: forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
  type Lexeme :: *
  data Lexeme = Char GHC.Types.Char | String GHC.Internal.Base.String | Punc GHC.Internal.Base.String | Ident GHC.Internal.Base.String | Symbol GHC.Internal.Base.String | Number GHC.Internal.Text.Read.Lex.Number | EOF
  type Prec :: *
  type Prec = GHC.Types.Int
  type Read :: * -> Constraint
  class Read a where
    readsPrec :: GHC.Types.Int -> ReadS a
    readList :: ReadS [a]
    readPrec :: ReadPrec a
    readListPrec :: ReadPrec [a]
    {-# MINIMAL readsPrec | readPrec #-}
  type ReadPrec :: * -> *
  newtype ReadPrec a = ...
  type ReadS :: * -> *
  type ReadS a = GHC.Internal.Base.String -> [(a, GHC.Internal.Base.String)]
  choice :: forall a. [ReadPrec a] -> ReadPrec a
  get :: ReadPrec GHC.Types.Char
  lex :: ReadS GHC.Internal.Base.String
  lexP :: ReadPrec Lexeme
  lift :: forall a. GHC.Internal.Text.ParserCombinators.ReadP.ReadP a -> ReadPrec a
  look :: ReadPrec GHC.Internal.Base.String
  minPrec :: Prec
  parens :: forall a. ReadPrec a -> ReadPrec a
  pfail :: forall a. ReadPrec a
  prec :: forall a. Prec -> ReadPrec a -> ReadPrec a
  read :: forall a. Read a => GHC.Internal.Base.String -> a
  readEither :: forall a. Read a => GHC.Internal.Base.String -> GHC.Internal.Data.Either.Either GHC.Internal.Base.String a
  readListDefault :: forall a. Read a => ReadS [a]
  readListPrecDefault :: forall a. Read a => ReadPrec [a]
  readMaybe :: forall a. Read a => GHC.Internal.Base.String -> GHC.Internal.Maybe.Maybe a
  readP_to_Prec :: forall a. (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadP a) -> ReadPrec a
  readParen :: forall a. GHC.Types.Bool -> ReadS a -> ReadS a
  readPrec_to_P :: forall a. ReadPrec a -> GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadP a
  readPrec_to_S :: forall a. ReadPrec a -> GHC.Types.Int -> ReadS a
  readS_to_Prec :: forall a. (GHC.Types.Int -> ReadS a) -> ReadPrec a
  reads :: forall a. Read a => ReadS a
  reset :: forall a. ReadPrec a -> ReadPrec a
  step :: forall a. ReadPrec a -> ReadPrec a

module Text.Read.Lex where
  -- Safety: Safe
  type Lexeme :: *
  data Lexeme = Char GHC.Types.Char | String GHC.Internal.Base.String | Punc GHC.Internal.Base.String | Ident GHC.Internal.Base.String | Symbol GHC.Internal.Base.String | Number Number | EOF
  type Number :: *
  data Number = ...
  expect :: Lexeme -> GHC.Internal.Text.ParserCombinators.ReadP.ReadP ()
  hsLex :: GHC.Internal.Text.ParserCombinators.ReadP.ReadP GHC.Internal.Base.String
  isSymbolChar :: GHC.Types.Char -> GHC.Types.Bool
  lex :: GHC.Internal.Text.ParserCombinators.ReadP.ReadP Lexeme
  lexChar :: GHC.Internal.Text.ParserCombinators.ReadP.ReadP GHC.Types.Char
  numberToFixed :: GHC.Num.Integer.Integer -> Number -> GHC.Internal.Maybe.Maybe (GHC.Num.Integer.Integer, GHC.Num.Integer.Integer)
  numberToInteger :: Number -> GHC.Internal.Maybe.Maybe GHC.Num.Integer.Integer
  numberToRangedRational :: (GHC.Types.Int, GHC.Types.Int) -> Number -> GHC.Internal.Maybe.Maybe GHC.Internal.Real.Rational
  numberToRational :: Number -> GHC.Internal.Real.Rational
  readBinP :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadP a
  readDecP :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadP a
  readHexP :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadP a
  readIntP :: forall a. GHC.Internal.Num.Num a => a -> (GHC.Types.Char -> GHC.Types.Bool) -> (GHC.Types.Char -> GHC.Types.Int) -> GHC.Internal.Text.ParserCombinators.ReadP.ReadP a
  readOctP :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadP a

module Text.Show where
  -- Safety: Safe
  type Show :: * -> Constraint
  class Show a where
    showsPrec :: GHC.Types.Int -> a -> ShowS
    show :: a -> GHC.Internal.Base.String
    showList :: [a] -> ShowS
    {-# MINIMAL showsPrec | show #-}
  type ShowS :: *
  type ShowS = GHC.Internal.Base.String -> GHC.Internal.Base.String
  showChar :: GHC.Types.Char -> ShowS
  showListWith :: forall a. (a -> ShowS) -> [a] -> ShowS
  showParen :: GHC.Types.Bool -> ShowS -> ShowS
  showString :: GHC.Internal.Base.String -> ShowS
  shows :: forall a. Show a => a -> ShowS

module Text.Show.Functions where
  -- Safety: Safe

module Type.Reflection where
  -- Safety: Safe
  type role (:~:) nominal nominal
  type (:~:) :: forall {k}. k -> k -> *
  data (:~:) a b where
    Refl :: forall {k} (a :: k). (:~:) a a
  type role (:~~:) nominal nominal
  type (:~~:) :: forall k1 k2. k1 -> k2 -> *
  data (:~~:) a b where
    HRefl :: forall {k1} (a :: k1). (:~~:) a a
  pattern App :: forall k2 (t :: k2). () => forall k1 (a :: k1 -> k2) (b :: k1). (t ~ a b) => TypeRep a -> TypeRep b -> TypeRep t
  pattern Con :: forall k (a :: k). () => ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.NotApplication a => TyCon -> TypeRep a
  pattern Con' :: forall k (a :: k). () => ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.NotApplication a => TyCon -> [SomeTypeRep] -> TypeRep a
  pattern Fun :: forall k (fun :: k). () => forall (r1 :: GHC.Types.RuntimeRep) (r2 :: GHC.Types.RuntimeRep) (arg :: TYPE r1) (res :: TYPE r2). (k ~ *, fun ~~ (arg -> res)) => TypeRep arg -> TypeRep res -> TypeRep fun
  type Module :: *
  data Module = ...
  type SomeTypeRep :: *
  data SomeTypeRep where
    SomeTypeRep :: forall k (a :: k). !(TypeRep a) -> SomeTypeRep
  type TyCon :: *
  data TyCon = ...
  pattern TypeRep :: forall {k} (a :: k). () => Typeable a => TypeRep a
  type role TypeRep nominal
  type TypeRep :: forall k. k -> *
  data TypeRep a where
    ...
  type Typeable :: forall k. k -> Constraint
  class Typeable a where
    ...
    {-# MINIMAL ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.typeRep# #-}
  decTypeRep :: forall k1 k2 (a :: k1) (b :: k2). TypeRep a -> TypeRep b -> GHC.Internal.Data.Either.Either ((a :~~: b) -> GHC.Internal.Base.Void) (a :~~: b)
  eqTypeRep :: forall k1 k2 (a :: k1) (b :: k2). TypeRep a -> TypeRep b -> GHC.Internal.Maybe.Maybe (a :~~: b)
  moduleName :: Module -> GHC.Internal.Base.String
  modulePackage :: Module -> GHC.Internal.Base.String
  rnfModule :: Module -> ()
  rnfSomeTypeRep :: SomeTypeRep -> ()
  rnfTyCon :: TyCon -> ()
  rnfTypeRep :: forall {k} (a :: k). TypeRep a -> ()
  someTypeRep :: forall {k} (proxy :: k -> *) (a :: k). Typeable a => proxy a -> SomeTypeRep
  someTypeRepTyCon :: SomeTypeRep -> TyCon
  splitApps :: forall {k} (a :: k). TypeRep a -> (TyCon, [SomeTypeRep])
  tyConModule :: TyCon -> GHC.Internal.Base.String
  tyConName :: TyCon -> GHC.Internal.Base.String
  tyConPackage :: TyCon -> GHC.Internal.Base.String
  typeOf :: forall a. 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) (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). TypeRep a -> (Typeable a => r) -> r

module Type.Reflection.Unsafe where
  -- Safety: None
  type KindRep :: *
  data KindRep = KindRepTyConApp TyCon [KindRep] | KindRepVar {-# UNPACK #-}GHC.Types.KindBndr | KindRepApp KindRep KindRep | KindRepFun KindRep KindRep | KindRepTYPE !GHC.Types.RuntimeRep | KindRepTypeLitS TypeLitSort GHC.Prim.Addr# | KindRepTypeLitD TypeLitSort [GHC.Types.Char]
  pattern KindRepTypeLit :: TypeLitSort -> GHC.Internal.Base.String -> KindRep
  type TyCon :: *
  data TyCon = ...
  type TypeLitSort :: *
  data TypeLitSort = TypeLitSymbol | TypeLitNat | TypeLitChar
  type role TypeRep nominal
  type TypeRep :: forall k. k -> *
  data TypeRep a where
    ...
  mkTrApp :: forall k1 k2 (a :: k1 -> k2) (b :: k1). TypeRep a -> TypeRep b -> TypeRep (a b)
  mkTrCon :: forall k (a :: k). TyCon -> [ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.SomeTypeRep] -> TypeRep a
  mkTyCon :: GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Types.Int -> KindRep -> TyCon
  someTypeRepFingerprint :: ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.SomeTypeRep -> GHC.Internal.Fingerprint.Type.Fingerprint
  tyConFingerprint :: TyCon -> GHC.Internal.Fingerprint.Type.Fingerprint
  tyConKindArgs :: TyCon -> GHC.Types.Int
  tyConKindRep :: TyCon -> KindRep
  typeRepFingerprint :: forall {k} (a :: k). TypeRep a -> GHC.Internal.Fingerprint.Type.Fingerprint

module Unsafe.Coerce where
  -- Safety: None
  type role UnsafeEquality nominal nominal
  type UnsafeEquality :: forall {k}. k -> k -> *
  data UnsafeEquality a b where
    UnsafeRefl :: forall {k} (a :: k). UnsafeEquality a a
  unsafeCoerce :: forall a b. a -> b
  unsafeCoerce# :: forall (q :: GHC.Types.RuntimeRep) (r :: GHC.Types.RuntimeRep) (a :: TYPE q) (b :: TYPE r). a -> b
  unsafeCoerceAddr :: forall (a :: TYPE GHC.Types.AddrRep) (b :: TYPE GHC.Types.AddrRep). a -> b
  unsafeCoerceUnlifted :: forall (a :: GHC.Types.UnliftedType) (b :: GHC.Types.UnliftedType). a -> b
  unsafeEqualityProof :: forall {k} (a :: k) (b :: k). UnsafeEquality a b


-- Instances:
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Ord.Down -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Semigroup.Internal.Dual -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Monoid.First -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Monoid.Last -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip [] -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Maybe.Maybe -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Base.NonEmpty -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Generics.Par1 -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Semigroup.Internal.Product -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip Solo -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Semigroup.Internal.Sum -- Defined in ‘Control.Monad.Zip’
instance Control.Monad.Zip.MonadZip Data.Complex.Complex -- Defined in ‘Data.Complex’
instance [safe] Data.Bifoldable.Bifoldable GHC.Internal.Data.Either.Either -- Defined in ‘Data.Bifoldable’
instance [safe] Data.Bifoldable.Bifoldable (,) -- Defined in ‘Data.Bifoldable’
instance [safe] forall x. Data.Bifoldable.Bifoldable ((,,) x) -- Defined in ‘Data.Bifoldable’
instance [safe] forall x y. Data.Bifoldable.Bifoldable ((,,,) x y) -- Defined in ‘Data.Bifoldable’
instance [safe] forall x y z. Data.Bifoldable.Bifoldable ((,,,,) x y z) -- Defined in ‘Data.Bifoldable’
instance [safe] forall x y z w. Data.Bifoldable.Bifoldable ((,,,,,) x y z w) -- Defined in ‘Data.Bifoldable’
instance [safe] forall x y z w v. Data.Bifoldable.Bifoldable ((,,,,,,) x y z w v) -- Defined in ‘Data.Bifoldable’
instance Data.Bifoldable.Bifoldable Data.Semigroup.Arg -- Defined in ‘Data.Semigroup’
instance [safe] Data.Bifoldable1.Bifoldable1 Data.Semigroup.Arg -- Defined in ‘Data.Bifoldable1’
instance [safe] Data.Bifoldable1.Bifoldable1 GHC.Internal.Data.Either.Either -- Defined in ‘Data.Bifoldable1’
instance [safe] Data.Bifoldable1.Bifoldable1 (,) -- Defined in ‘Data.Bifoldable1’
instance [safe] forall x. Data.Bifoldable1.Bifoldable1 ((,,) x) -- Defined in ‘Data.Bifoldable1’
instance [safe] forall x y. Data.Bifoldable1.Bifoldable1 ((,,,) x y) -- Defined in ‘Data.Bifoldable1’
instance [safe] forall x y z. Data.Bifoldable1.Bifoldable1 ((,,,,) x y z) -- Defined in ‘Data.Bifoldable1’
instance [safe] Data.Bifunctor.Bifunctor GHC.Internal.Data.Either.Either -- Defined in ‘Data.Bifunctor’
instance [safe] Data.Bifunctor.Bifunctor (,) -- Defined in ‘Data.Bifunctor’
instance [safe] forall x1. Data.Bifunctor.Bifunctor ((,,) x1) -- Defined in ‘Data.Bifunctor’
instance [safe] forall x1 x2. Data.Bifunctor.Bifunctor ((,,,) x1 x2) -- Defined in ‘Data.Bifunctor’
instance [safe] forall x1 x2 x3. Data.Bifunctor.Bifunctor ((,,,,) x1 x2 x3) -- Defined in ‘Data.Bifunctor’
instance [safe] forall x1 x2 x3 x4. Data.Bifunctor.Bifunctor ((,,,,,) x1 x2 x3 x4) -- Defined in ‘Data.Bifunctor’
instance [safe] forall x1 x2 x3 x4 x5. Data.Bifunctor.Bifunctor ((,,,,,,) x1 x2 x3 x4 x5) -- Defined in ‘Data.Bifunctor’
instance Data.Bifunctor.Bifunctor Data.Semigroup.Arg -- Defined in ‘Data.Semigroup’
instance Data.Bitraversable.Bitraversable GHC.Internal.Data.Either.Either -- Defined in ‘Data.Bitraversable’
instance Data.Bitraversable.Bitraversable (,) -- Defined in ‘Data.Bitraversable’
instance forall x. Data.Bitraversable.Bitraversable ((,,) x) -- Defined in ‘Data.Bitraversable’
instance forall x y. Data.Bitraversable.Bitraversable ((,,,) x y) -- Defined in ‘Data.Bitraversable’
instance forall x y z. Data.Bitraversable.Bitraversable ((,,,,) x y z) -- Defined in ‘Data.Bitraversable’
instance forall x y z w. Data.Bitraversable.Bitraversable ((,,,,,) x y z w) -- Defined in ‘Data.Bitraversable’
instance forall x y z w v. Data.Bitraversable.Bitraversable ((,,,,,,) x y z w v) -- Defined in ‘Data.Bitraversable’
instance Data.Bitraversable.Bitraversable Data.Semigroup.Arg -- Defined in ‘Data.Semigroup’
instance forall (n :: GHC.Internal.TypeNats.Nat). GHC.Internal.TypeNats.KnownNat n => Data.Fixed.HasResolution n -- Defined in ‘Data.Fixed’
instance Data.Foldable1.Foldable1 Data.Complex.Complex -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 GHC.Internal.Data.Ord.Down -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 GHC.Internal.Data.Semigroup.Internal.Dual -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 Data.Semigroup.First -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 Data.Semigroup.Last -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 Data.Semigroup.Max -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 Data.Semigroup.Min -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 GHC.Internal.Base.NonEmpty -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 GHC.Internal.Generics.Par1 -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 GHC.Internal.Data.Semigroup.Internal.Product -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 Solo -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 GHC.Internal.Data.Semigroup.Internal.Sum -- Defined in ‘Data.Foldable1’
instance forall a. Data.Foldable1.Foldable1 ((,) a) -- Defined in ‘Data.Foldable1’
instance [safe] Data.Functor.Classes.Eq1 Data.Complex.Complex -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Eq1 GHC.Internal.Data.Ord.Down -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a. GHC.Classes.Eq a => Data.Functor.Classes.Eq1 (GHC.Internal.Data.Either.Either a) -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Eq1 GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘Data.Functor.Classes’