Skip to content
Snippets Groups Projects
Normal view Permalink
base-exports.stdout-javascript-unknown-ghcjs 919 KiB
Newer Older
Ben Gamari's avatar
testsuite: Add test to catch changes in core libraries
Ben Gamari committed
7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183 7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 
  type (~) :: forall k. k -> k -> Constraint
  class (a ~ b) => (~) a b
    {-# MINIMAL #-}
  type (~~) :: forall k0 k1. k0 -> k1 -> Constraint
  class (a ~~ b) => (~~) a b
    {-# MINIMAL #-}

module GHC.Fingerprint where
  -- Safety: Trustworthy
  type Fingerprint :: *
  data Fingerprint = Fingerprint {-# UNPACK #-}GHC.Word.Word64 {-# UNPACK #-}GHC.Word.Word64
  fingerprint0 :: Fingerprint
  fingerprintData :: GHC.Ptr.Ptr GHC.Word.Word8 -> GHC.Types.Int -> GHC.Types.IO Fingerprint
  fingerprintFingerprints :: [Fingerprint] -> Fingerprint
  fingerprintString :: GHC.Base.String -> Fingerprint
  getFileHash :: GHC.IO.FilePath -> GHC.Types.IO Fingerprint

module GHC.Fingerprint.Type where
  -- Safety: Trustworthy
  type Fingerprint :: *
  data Fingerprint = Fingerprint {-# UNPACK #-}GHC.Word.Word64 {-# UNPACK #-}GHC.Word.Word64

module GHC.Float where
  -- Safety: Trustworthy
  type Double :: *
  data Double = D# Double#
  type Double# :: TYPE GHC.Types.DoubleRep
  data Double#
  type FFFormat :: *
  data FFFormat = FFExponent | FFFixed | FFGeneric
  type Float :: *
  data Float = F# Float#
  type Float# :: TYPE GHC.Types.FloatRep
  data Float#
  type Floating :: * -> Constraint
  class GHC.Real.Fractional a => Floating a where
    pi :: a
    exp :: a -> a
    log :: a -> a
    sqrt :: a -> a
    (**) :: a -> a -> a
    logBase :: a -> a -> a
    sin :: a -> a
    cos :: a -> a
    tan :: a -> a
    asin :: a -> a
    acos :: a -> a
    atan :: a -> a
    sinh :: a -> a
    cosh :: a -> a
    tanh :: a -> a
    asinh :: a -> a
    acosh :: a -> a
    atanh :: a -> a
    log1p :: a -> a
    expm1 :: a -> a
    log1pexp :: a -> a
    log1mexp :: a -> a
    {-# MINIMAL pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh #-}
  type RealFloat :: * -> Constraint
  class (GHC.Real.RealFrac a, Floating a) => RealFloat a where
    floatRadix :: a -> GHC.Num.Integer.Integer
    floatDigits :: a -> GHC.Types.Int
    floatRange :: a -> (GHC.Types.Int, GHC.Types.Int)
    decodeFloat :: a -> (GHC.Num.Integer.Integer, GHC.Types.Int)
    encodeFloat :: GHC.Num.Integer.Integer -> GHC.Types.Int -> a
    exponent :: a -> GHC.Types.Int
    significand :: a -> a
    scaleFloat :: GHC.Types.Int -> a -> a
    isNaN :: a -> GHC.Types.Bool
    isInfinite :: a -> GHC.Types.Bool
    isDenormalized :: a -> GHC.Types.Bool
    isNegativeZero :: a -> GHC.Types.Bool
    isIEEE :: a -> GHC.Types.Bool
    atan2 :: a -> a -> a
    {-# MINIMAL floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE #-}
  acosDouble :: Double -> Double
  acosFloat :: Float -> Float
  acoshDouble :: Double -> Double
  acoshFloat :: Float -> Float
  asinDouble :: Double -> Double
  asinFloat :: Float -> Float
  asinhDouble :: Double -> Double
  asinhFloat :: Float -> Float
  atanDouble :: Double -> Double
  atanFloat :: Float -> Float
  atanhDouble :: Double -> Double
  atanhFloat :: Float -> Float
  castDoubleToWord64 :: Double -> GHC.Word.Word64
  castFloatToWord32 :: Float -> GHC.Word.Word32
  castWord32ToFloat :: GHC.Word.Word32 -> Float
  castWord64ToDouble :: GHC.Word.Word64 -> Double
  ceilingDouble :: forall b. GHC.Real.Integral b => Double -> b
  ceilingFloat :: forall b. GHC.Real.Integral b => Float -> b
  clamp :: GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int
  cosDouble :: Double -> Double
  cosFloat :: Float -> Float
  coshDouble :: Double -> Double
  coshFloat :: Float -> Float
  divideDouble :: Double -> Double -> Double
  divideFloat :: Float -> Float -> Float
  double2Float :: Double -> Float
  double2Int :: Double -> GHC.Types.Int
  eqDouble :: Double -> Double -> GHC.Types.Bool
  eqFloat :: Float -> Float -> GHC.Types.Bool
  expDouble :: Double -> Double
  expFloat :: Float -> Float
  expm1Double :: Double -> Double
  expm1Float :: Float -> Float
  expt :: GHC.Num.Integer.Integer -> GHC.Types.Int -> GHC.Num.Integer.Integer
  expts :: GHC.Arr.Array GHC.Types.Int GHC.Num.Integer.Integer
  expts10 :: GHC.Arr.Array GHC.Types.Int GHC.Num.Integer.Integer
  fabsDouble :: Double -> Double
  fabsFloat :: Float -> Float
  float2Double :: Float -> Double
  float2Int :: Float -> GHC.Types.Int
  floatToDigits :: forall a. RealFloat a => GHC.Num.Integer.Integer -> a -> ([GHC.Types.Int], GHC.Types.Int)
  floorDouble :: forall b. GHC.Real.Integral b => Double -> b
  floorFloat :: forall b. GHC.Real.Integral b => Float -> b
  formatRealFloat :: forall a. RealFloat a => FFFormat -> GHC.Maybe.Maybe GHC.Types.Int -> a -> GHC.Base.String
  formatRealFloatAlt :: forall a. RealFloat a => FFFormat -> GHC.Maybe.Maybe GHC.Types.Int -> GHC.Types.Bool -> a -> GHC.Base.String
  fromRat :: forall a. RealFloat a => GHC.Real.Rational -> a
  fromRat' :: forall a. RealFloat a => GHC.Real.Rational -> a
  fromRat'' :: forall a. RealFloat a => GHC.Types.Int -> GHC.Types.Int -> GHC.Num.Integer.Integer -> GHC.Num.Integer.Integer -> a
  geDouble :: Double -> Double -> GHC.Types.Bool
  geFloat :: Float -> Float -> GHC.Types.Bool
  gtDouble :: Double -> Double -> GHC.Types.Bool
  gtFloat :: Float -> Float -> GHC.Types.Bool
  int2Double :: GHC.Types.Int -> Double
  int2Float :: GHC.Types.Int -> Float
  integerToBinaryFloat' :: forall a. RealFloat a => GHC.Num.Integer.Integer -> a
  integerToDouble# :: GHC.Num.Integer.Integer -> Double#
  integerToFloat# :: GHC.Num.Integer.Integer -> Float#
  isDoubleDenormalized :: Double -> GHC.Types.Int
  isDoubleFinite :: Double -> GHC.Types.Int
  isDoubleInfinite :: Double -> GHC.Types.Int
  isDoubleNaN :: Double -> GHC.Types.Int
  isDoubleNegativeZero :: Double -> GHC.Types.Int
  isFloatDenormalized :: Float -> GHC.Types.Int
  isFloatFinite :: Float -> GHC.Types.Int
  isFloatInfinite :: Float -> GHC.Types.Int
  isFloatNaN :: Float -> GHC.Types.Int
  isFloatNegativeZero :: Float -> GHC.Types.Int
  leDouble :: Double -> Double -> GHC.Types.Bool
  leFloat :: Float -> Float -> GHC.Types.Bool
  log1mexpOrd :: forall a. (GHC.Classes.Ord a, Floating a) => a -> a
  log1pDouble :: Double -> Double
  log1pFloat :: Float -> Float
  logDouble :: Double -> Double
  logFloat :: Float -> Float
  ltDouble :: Double -> Double -> GHC.Types.Bool
  ltFloat :: Float -> Float -> GHC.Types.Bool
  maxExpt :: GHC.Types.Int
  maxExpt10 :: GHC.Types.Int
  minExpt :: GHC.Types.Int
  minusDouble :: Double -> Double -> Double
  minusFloat :: Float -> Float -> Float
  naturalToDouble# :: GHC.Num.Natural.Natural -> Double#
  naturalToFloat# :: GHC.Num.Natural.Natural -> Float#
  negateDouble :: Double -> Double
  negateFloat :: Float -> Float
  plusDouble :: Double -> Double -> Double
  plusFloat :: Float -> Float -> Float
  powerDouble :: Double -> Double -> Double
  powerFloat :: Float -> Float -> Float
  properFractionDouble :: forall b. GHC.Real.Integral b => Double -> (b, Double)
  properFractionFloat :: forall b. GHC.Real.Integral b => Float -> (b, Float)
  rationalToDouble :: GHC.Num.Integer.Integer -> GHC.Num.Integer.Integer -> Double
  rationalToFloat :: GHC.Num.Integer.Integer -> GHC.Num.Integer.Integer -> Float
  roundDouble :: forall b. GHC.Real.Integral b => Double -> b
  roundFloat :: forall b. GHC.Real.Integral b => Float -> b
  roundTo :: GHC.Types.Int -> GHC.Types.Int -> [GHC.Types.Int] -> (GHC.Types.Int, [GHC.Types.Int])
  roundingMode# :: GHC.Num.Integer.Integer -> GHC.Prim.Int# -> GHC.Prim.Int#
  showFloat :: forall a. RealFloat a => a -> GHC.Show.ShowS
  showSignedFloat :: forall a. RealFloat a => (a -> GHC.Show.ShowS) -> GHC.Types.Int -> a -> GHC.Show.ShowS
  sinDouble :: Double -> Double
  sinFloat :: Float -> Float
  sinhDouble :: Double -> Double
  sinhFloat :: Float -> Float
  sqrtDouble :: Double -> Double
  sqrtFloat :: Float -> Float
  stgDoubleToWord64 :: Double# -> GHC.Prim.Word64#
  stgFloatToWord32 :: Float# -> GHC.Prim.Word32#
  stgWord32ToFloat :: GHC.Prim.Word32# -> Float#
  stgWord64ToDouble :: GHC.Prim.Word64# -> Double#
  tanDouble :: Double -> Double
  tanFloat :: Float -> Float
  tanhDouble :: Double -> Double
  tanhFloat :: Float -> Float
  timesDouble :: Double -> Double -> Double
  timesFloat :: Float -> Float -> Float
  truncateDouble :: forall b. GHC.Real.Integral b => Double -> b
  truncateFloat :: forall b. GHC.Real.Integral b => Float -> b
  word2Double :: GHC.Types.Word -> Double
  word2Float :: GHC.Types.Word -> Float

module GHC.Float.ConversionUtils where
  -- Safety: Trustworthy
  elimZerosInt# :: GHC.Prim.Int# -> GHC.Prim.Int# -> (# GHC.Num.Integer.Integer, GHC.Prim.Int# #)
  elimZerosInteger :: GHC.Num.Integer.Integer -> GHC.Prim.Int# -> (# GHC.Num.Integer.Integer, GHC.Prim.Int# #)

module GHC.Float.RealFracMethods where
  -- Safety: Trustworthy
  ceilingDoubleInt :: GHC.Types.Double -> GHC.Types.Int
  ceilingDoubleInteger :: GHC.Types.Double -> GHC.Num.Integer.Integer
  ceilingFloatInt :: GHC.Types.Float -> GHC.Types.Int
  ceilingFloatInteger :: GHC.Types.Float -> GHC.Num.Integer.Integer
  double2Int :: GHC.Types.Double -> GHC.Types.Int
  float2Int :: GHC.Types.Float -> GHC.Types.Int
  floorDoubleInt :: GHC.Types.Double -> GHC.Types.Int
  floorDoubleInteger :: GHC.Types.Double -> GHC.Num.Integer.Integer
  floorFloatInt :: GHC.Types.Float -> GHC.Types.Int
  floorFloatInteger :: GHC.Types.Float -> GHC.Num.Integer.Integer
  int2Double :: GHC.Types.Int -> GHC.Types.Double
  int2Float :: GHC.Types.Int -> GHC.Types.Float
  properFractionDoubleInt :: GHC.Types.Double -> (GHC.Types.Int, GHC.Types.Double)
  properFractionDoubleInteger :: GHC.Types.Double -> (GHC.Num.Integer.Integer, GHC.Types.Double)
  properFractionFloatInt :: GHC.Types.Float -> (GHC.Types.Int, GHC.Types.Float)
  properFractionFloatInteger :: GHC.Types.Float -> (GHC.Num.Integer.Integer, GHC.Types.Float)
  roundDoubleInt :: GHC.Types.Double -> GHC.Types.Int
  roundDoubleInteger :: GHC.Types.Double -> GHC.Num.Integer.Integer
  roundFloatInt :: GHC.Types.Float -> GHC.Types.Int
  roundFloatInteger :: GHC.Types.Float -> GHC.Num.Integer.Integer
  truncateDoubleInteger :: GHC.Types.Double -> GHC.Num.Integer.Integer
  truncateFloatInteger :: GHC.Types.Float -> GHC.Num.Integer.Integer

module GHC.Foreign where
Ben Gamari's avatar
Move `base` to `ghc-internal`  
Ben Gamari committed
7228 
  -- Safety: Safe
Ben Gamari's avatar
testsuite: Add test to catch changes in core libraries
Ben Gamari committed
7229 7230 7231 7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253 7254 7255 7256 7257 7258 7259 7260 7261 7262 7263 7264 7265 7266 7267 7268 7269 7270 7271 7272 7273 7274 7275 7276 7277 7278 7279 7280 7281 7282 7283 7284 7285 
  type CString :: *
  type CString = GHC.Ptr.Ptr Foreign.C.Types.CChar
  type CStringLen :: *
  type CStringLen = (GHC.Ptr.Ptr Foreign.C.Types.CChar, GHC.Types.Int)
  charIsRepresentable :: GHC.IO.Encoding.Types.TextEncoding -> GHC.Types.Char -> GHC.Types.IO GHC.Types.Bool
  newCString :: GHC.IO.Encoding.Types.TextEncoding -> GHC.Base.String -> GHC.Types.IO CString
  newCStringLen :: GHC.IO.Encoding.Types.TextEncoding -> GHC.Base.String -> GHC.Types.IO CStringLen
  newCStringLen0 :: GHC.IO.Encoding.Types.TextEncoding -> GHC.Base.String -> GHC.Types.IO CStringLen
  peekCString :: GHC.IO.Encoding.Types.TextEncoding -> CString -> GHC.Types.IO GHC.Base.String
  peekCStringLen :: GHC.IO.Encoding.Types.TextEncoding -> CStringLen -> GHC.Types.IO GHC.Base.String
  withCString :: forall a. GHC.IO.Encoding.Types.TextEncoding -> GHC.Base.String -> (CString -> GHC.Types.IO a) -> GHC.Types.IO a
  withCStringLen :: forall a. GHC.IO.Encoding.Types.TextEncoding -> GHC.Base.String -> (CStringLen -> GHC.Types.IO a) -> GHC.Types.IO a
  withCStringLen0 :: forall a. GHC.IO.Encoding.Types.TextEncoding -> GHC.Base.String -> (CStringLen -> GHC.Types.IO a) -> GHC.Types.IO a
  withCStringsLen :: forall a. GHC.IO.Encoding.Types.TextEncoding -> [GHC.Base.String] -> (GHC.Types.Int -> GHC.Ptr.Ptr CString -> GHC.Types.IO a) -> GHC.Types.IO a

module GHC.ForeignPtr where
  -- Safety: Unsafe
  type FinalizerEnvPtr :: * -> * -> *
  type FinalizerEnvPtr env a = GHC.Ptr.FunPtr (GHC.Ptr.Ptr env -> GHC.Ptr.Ptr a -> GHC.Types.IO ())
  type FinalizerPtr :: * -> *
  type FinalizerPtr a = GHC.Ptr.FunPtr (GHC.Ptr.Ptr a -> GHC.Types.IO ())
  type Finalizers :: *
  data Finalizers = NoFinalizers | CFinalizers (GHC.Prim.Weak# ()) | HaskellFinalizers [GHC.Types.IO ()]
  type role ForeignPtr phantom
  type ForeignPtr :: * -> *
  data ForeignPtr a = ForeignPtr GHC.Prim.Addr# ForeignPtrContents
  type ForeignPtrContents :: *
  data ForeignPtrContents = PlainForeignPtr ! {-# UNPACK #-}(GHC.IORef.N:IORef[0] <Finalizers>_N)(GHC.IORef.IORef Finalizers) | FinalPtr | MallocPtr (GHC.Prim.MutableByteArray# GHC.Prim.RealWorld) ! {-# UNPACK #-}(GHC.IORef.N:IORef[0] <Finalizers>_N)(GHC.IORef.IORef Finalizers) | PlainPtr (GHC.Prim.MutableByteArray# GHC.Prim.RealWorld)
  addForeignPtrConcFinalizer :: forall a. ForeignPtr a -> GHC.Types.IO () -> GHC.Types.IO ()
  addForeignPtrFinalizer :: forall a. FinalizerPtr a -> ForeignPtr a -> GHC.Types.IO ()
  addForeignPtrFinalizerEnv :: forall env a. FinalizerEnvPtr env a -> GHC.Ptr.Ptr env -> ForeignPtr a -> GHC.Types.IO ()
  castForeignPtr :: forall a b. ForeignPtr a -> ForeignPtr b
  finalizeForeignPtr :: forall a. ForeignPtr a -> GHC.Types.IO ()
  mallocForeignPtr :: forall a. Foreign.Storable.Storable a => GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrAlignedBytes :: forall a. GHC.Types.Int -> GHC.Types.Int -> GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrBytes :: forall a. GHC.Types.Int -> GHC.Types.IO (ForeignPtr a)
  mallocPlainForeignPtr :: forall a. Foreign.Storable.Storable a => GHC.Types.IO (ForeignPtr a)
  mallocPlainForeignPtrAlignedBytes :: forall a. GHC.Types.Int -> GHC.Types.Int -> GHC.Types.IO (ForeignPtr a)
  mallocPlainForeignPtrBytes :: forall a. GHC.Types.Int -> GHC.Types.IO (ForeignPtr a)
  newConcForeignPtr :: forall a. GHC.Ptr.Ptr a -> GHC.Types.IO () -> GHC.Types.IO (ForeignPtr a)
  newForeignPtr_ :: forall a. GHC.Ptr.Ptr a -> GHC.Types.IO (ForeignPtr a)
  plusForeignPtr :: forall a b. ForeignPtr a -> GHC.Types.Int -> ForeignPtr b
  touchForeignPtr :: forall a. ForeignPtr a -> GHC.Types.IO ()
  unsafeForeignPtrToPtr :: forall a. ForeignPtr a -> GHC.Ptr.Ptr a
  unsafeWithForeignPtr :: forall a b. ForeignPtr a -> (GHC.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withForeignPtr :: forall a b. ForeignPtr a -> (GHC.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b

module GHC.GHCi where
  -- Safety: None
  type GHCiSandboxIO :: (* -> *) -> Constraint
  class GHC.Base.Monad m => GHCiSandboxIO m where
    ghciStepIO :: forall a. m a -> GHC.Types.IO a
    {-# MINIMAL ghciStepIO #-}
  type NoIO :: * -> *
  newtype NoIO a = ...

module GHC.GHCi.Helpers where
Ben Gamari's avatar
Move `base` to `ghc-internal`  
Ben Gamari committed
7286 
  -- Safety: Trustworthy
Ben Gamari's avatar
testsuite: Add test to catch changes in core libraries
Ben Gamari committed
7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302 7303 7304 7305 7306 7307 7308 7309 7310 7311 7312 7313 7314 7315 7316 7317 7318 7319 7320 7321 7322 7323 7324 7325 7326 7327 7328 7329 7330 7331 7332 7333 7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344 7345 7346 7347 7348 7349 7350 7351 7352 7353 7354 7355 7356 7357 7358 7359 7360 7361 7362 7363 7364 7365 7366 7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379 7380 7381 7382 7383 7384 7385 7386 7387 7388 7389 7390 7391 7392 7393 7394 7395 7396 7397 7398 7399 7400 7401 7402 7403 7404 7405 7406 7407 7408 7409 7410 7411 7412 7413 7414 7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446 7447 7448 7449 7450 7451 7452 7453 7454 7455 7456 7457 7458 7459 7460 7461 7462 7463 7464 7465 7466 7467 7468 7469 7470 7471 7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516 7517 7518 7519 7520 7521 7522 7523 7524 7525 7526 7527 7528 7529 7530 7531 7532 7533 7534 7535 7536 7537 7538 7539 7540 7541 7542 7543 7544 7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555 7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567 7568 7569 7570 7571 7572 7573 7574 7575 7576 7577 7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588 7589 7590 7591 7592 7593 7594 7595 7596 7597 7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612 7613 7614 7615 7616 7617 7618 7619 7620 7621 7622 7623 7624 7625 7626 7627 7628 7629 7630 7631 7632 7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643 7644 7645 7646 7647 7648 7649 7650 7651 7652 7653 7654 7655 7656 7657 7658 7659 7660 7661 7662 7663 7664 7665 7666 7667 7668 7669 7670 7671 7672 7673 7674 7675 7676 7677 7678 7679 7680 7681 7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695 7696 7697 7698 7699 7700 7701 7702 7703 7704 7705 7706 7707 7708 7709 7710 7711 7712 7713 7714 7715 7716 7717 7718 7719 7720 7721 7722 7723 7724 7725 7726 7727 7728 7729 7730 7731 7732 7733 7734 7735 7736 7737 7738 7739 7740 7741 7742 7743 7744 7745 7746 7747 7748 7749 7750 7751 7752 7753 7754 7755 7756 7757 7758 7759 7760 7761 7762 7763 7764 7765 7766 7767 7768 7769 7770 7771 7772 7773 7774 7775 7776 7777 7778 7779 7780 7781 7782 7783 7784 7785 7786 7787 7788 7789 7790 7791 7792 7793 7794 7795 7796 7797 7798 7799 7800 7801 7802 7803 7804 7805 7806 7807 
  disableBuffering :: GHC.Types.IO ()
  evalWrapper :: forall a. GHC.Base.String -> [GHC.Base.String] -> GHC.Types.IO a -> GHC.Types.IO a
  flushAll :: GHC.Types.IO ()

module GHC.Generics where
  -- Safety: Trustworthy
  type role (:*:) representational representational nominal
  type (:*:) :: forall k. (k -> *) -> (k -> *) -> k -> *
  data (:*:) f g p = (f p) :*: (g p)
  type role (:+:) representational representational nominal
  type (:+:) :: forall k. (k -> *) -> (k -> *) -> k -> *
  data (:+:) f g p = L1 (f p) | R1 (g p)
  type role (:.:) representational nominal nominal
  type (:.:) :: forall k2 k1. (k2 -> *) -> (k1 -> k2) -> k1 -> *
  newtype (:.:) f g p = Comp1 {unComp1 :: f (g p)}
  type Associativity :: *
  data Associativity = LeftAssociative | RightAssociative | NotAssociative
  type C :: *
  data C
  type C1 :: forall {k}. Meta -> (k -> *) -> k -> *
  type C1 = M1 C :: Meta -> (k -> *) -> k -> *
  type Constructor :: forall {k}. k -> Constraint
  class Constructor c where
    conName :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t c f a -> [GHC.Types.Char]
    conFixity :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t c f a -> Fixity
    conIsRecord :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t c f a -> GHC.Types.Bool
    {-# MINIMAL conName #-}
  type D :: *
  data D
  type D1 :: forall {k}. Meta -> (k -> *) -> k -> *
  type D1 = M1 D :: Meta -> (k -> *) -> k -> *
  type Datatype :: forall {k}. k -> Constraint
  class Datatype d where
    datatypeName :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t d f a -> [GHC.Types.Char]
    moduleName :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t d f a -> [GHC.Types.Char]
    packageName :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t d f a -> [GHC.Types.Char]
    isNewtype :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t d f a -> GHC.Types.Bool
    {-# MINIMAL datatypeName, moduleName, packageName #-}
  type DecidedStrictness :: *
  data DecidedStrictness = DecidedLazy | DecidedStrict | DecidedUnpack
  type Fixity :: *
  data Fixity = Prefix | Infix Associativity GHC.Types.Int
  type FixityI :: *
  data FixityI = PrefixI | InfixI Associativity GHC.TypeNats.Nat
  type Generic :: * -> Constraint
  class Generic a where
    type Rep :: * -> * -> *
    type family Rep a
    from :: forall x. a -> Rep a x
    to :: forall x. Rep a x -> a
    {-# MINIMAL from, to #-}
  type Generic1 :: forall k. (k -> *) -> Constraint
  class Generic1 f where
    type Rep1 :: forall k. (k -> *) -> k -> *
    type family Rep1 f
    from1 :: forall (a :: k). f a -> Rep1 f a
    to1 :: forall (a :: k). Rep1 f a -> f a
    {-# MINIMAL from1, to1 #-}
  type Generically :: * -> *
  newtype Generically a = Generically a
  type role Generically1 representational nominal
  type Generically1 :: forall k. (k -> *) -> k -> *
  newtype Generically1 f a where
    Generically1 :: forall {k} (f :: k -> *) (a :: k). f a -> Generically1 f a
  type role K1 phantom representational phantom
  type K1 :: forall k. * -> * -> k -> *
  newtype K1 i c p = K1 {unK1 :: c}
  type role M1 phantom phantom representational nominal
  type M1 :: forall k. * -> Meta -> (k -> *) -> k -> *
  newtype M1 i c f p = M1 {unM1 :: f p}
  type Meta :: *
  data Meta = MetaData GHC.Types.Symbol GHC.Types.Symbol GHC.Types.Symbol GHC.Types.Bool | MetaCons GHC.Types.Symbol FixityI GHC.Types.Bool | MetaSel (GHC.Maybe.Maybe GHC.Types.Symbol) SourceUnpackedness SourceStrictness DecidedStrictness
  type Par1 :: * -> *
  newtype Par1 p = Par1 {unPar1 :: p}
  type R :: *
  data R
  type Rec0 :: forall {k}. * -> k -> *
  type Rec0 = K1 R :: * -> k -> *
  type role Rec1 representational nominal
  type Rec1 :: forall k. (k -> *) -> k -> *
  newtype Rec1 f p = Rec1 {unRec1 :: f p}
  type S :: *
  data S
  type S1 :: forall {k}. Meta -> (k -> *) -> k -> *
  type S1 = M1 S :: Meta -> (k -> *) -> k -> *
  type Selector :: forall {k}. k -> Constraint
  class Selector s where
    selName :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t s f a -> [GHC.Types.Char]
    selSourceUnpackedness :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t s f a -> SourceUnpackedness
    selSourceStrictness :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t s f a -> SourceStrictness
    selDecidedStrictness :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t s f a -> DecidedStrictness
    {-# MINIMAL selName, selSourceUnpackedness, selSourceStrictness, selDecidedStrictness #-}
  type SourceStrictness :: *
  data SourceStrictness = NoSourceStrictness | SourceLazy | SourceStrict
  type SourceUnpackedness :: *
  data SourceUnpackedness = NoSourceUnpackedness | SourceNoUnpack | SourceUnpack
  type role U1 phantom
  type U1 :: forall k. k -> *
  data U1 p = U1
  UAddr :: forall k (p :: k). GHC.Prim.Addr# -> URec (GHC.Ptr.Ptr ()) p
  type UAddr :: forall {k}. k -> *
  type UAddr = URec (GHC.Ptr.Ptr ()) :: k -> *
  UChar :: forall k (p :: k). GHC.Prim.Char# -> URec GHC.Types.Char p
  type UChar :: forall {k}. k -> *
  type UChar = URec GHC.Types.Char :: k -> *
  UDouble :: forall k (p :: k). GHC.Prim.Double# -> URec GHC.Types.Double p
  type UDouble :: forall {k}. k -> *
  type UDouble = URec GHC.Types.Double :: k -> *
  UFloat :: forall k (p :: k). GHC.Prim.Float# -> URec GHC.Types.Float p
  type UFloat :: forall {k}. k -> *
  type UFloat = URec GHC.Types.Float :: k -> *
  UInt :: forall k (p :: k). GHC.Prim.Int# -> URec GHC.Types.Int p
  type UInt :: forall {k}. k -> *
  type UInt = URec GHC.Types.Int :: k -> *
  type URec :: forall k. * -> k -> *
  data family URec a p
  UWord :: forall k (p :: k). GHC.Prim.Word# -> URec GHC.Types.Word p
  type UWord :: forall {k}. k -> *
  type UWord = URec GHC.Types.Word :: k -> *
  type role V1 phantom
  type V1 :: forall k. k -> *
  data V1 p
  prec :: Fixity -> GHC.Types.Int
  uAddr# :: forall k (p :: k). URec (GHC.Ptr.Ptr ()) p -> GHC.Prim.Addr#
  uChar# :: forall k (p :: k). URec GHC.Types.Char p -> GHC.Prim.Char#
  uDouble# :: forall k (p :: k). URec GHC.Types.Double p -> GHC.Prim.Double#
  uFloat# :: forall k (p :: k). URec GHC.Types.Float p -> GHC.Prim.Float#
  uInt# :: forall k (p :: k). URec GHC.Types.Int p -> GHC.Prim.Int#
  uWord# :: forall k (p :: k). URec GHC.Types.Word p -> GHC.Prim.Word#

module GHC.IO where
  -- Safety: Unsafe
  type FilePath :: *
  type FilePath = GHC.Base.String
  type IO :: * -> *
  newtype IO a = IO (GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, a #))
  type MaskingState :: *
  data MaskingState = Unmasked | MaskedInterruptible | MaskedUninterruptible
  bracket :: forall a b c. IO a -> (a -> IO b) -> (a -> IO c) -> IO c
  catch :: forall e a. GHC.Exception.Type.Exception e => IO a -> (e -> IO a) -> IO a
  catchAny :: forall a. IO a -> (forall e. GHC.Exception.Type.Exception e => e -> IO a) -> IO a
  catchException :: forall e a. GHC.Exception.Type.Exception e => IO a -> (e -> IO a) -> IO a
  evaluate :: forall a. a -> IO a
  finally :: forall a b. IO a -> IO b -> IO a
  getMaskingState :: IO MaskingState
  interruptible :: forall a. IO a -> IO a
  ioToST :: forall a. IO a -> GHC.ST.ST GHC.Prim.RealWorld a
  liftIO :: forall a. IO a -> GHC.Prim.State# GHC.Prim.RealWorld -> GHC.ST.STret GHC.Prim.RealWorld a
  mask :: forall b. ((forall a. IO a -> IO a) -> IO b) -> IO b
  mask_ :: forall a. IO a -> IO a
  mkUserError :: [GHC.Types.Char] -> GHC.Exception.Type.SomeException
  mplusIO :: forall a. IO a -> IO a -> IO a
  noDuplicate :: IO ()
  onException :: forall a b. IO a -> IO b -> IO a
  stToIO :: forall a. GHC.ST.ST GHC.Prim.RealWorld a -> IO a
  throwIO :: forall e a. GHC.Exception.Type.Exception e => e -> IO a
  unIO :: forall a. IO a -> GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, a #)
  uninterruptibleMask :: forall b. ((forall a. IO a -> IO a) -> IO b) -> IO b
  uninterruptibleMask_ :: forall a. IO a -> IO a
  unsafeDupableInterleaveIO :: forall a. IO a -> IO a
  unsafeDupablePerformIO :: forall a. IO a -> a
  unsafeIOToST :: forall a s. IO a -> GHC.ST.ST s a
  unsafeInterleaveIO :: forall a. IO a -> IO a
  unsafePerformIO :: forall a. IO a -> a
  unsafeSTToIO :: forall s a. GHC.ST.ST s a -> IO a
  unsafeUnmask :: forall a. IO a -> IO a

module GHC.IO.Buffer where
  -- Safety: Trustworthy
  type role Buffer phantom
  type Buffer :: * -> *
  data Buffer e = Buffer {bufRaw :: {-# UNPACK #-}(RawBuffer e), bufState :: BufferState, bufSize :: {-# UNPACK #-}GHC.Types.Int, bufOffset :: {-# UNPACK #-}GHC.Word.Word64, bufL :: {-# UNPACK #-}GHC.Types.Int, bufR :: {-# UNPACK #-}GHC.Types.Int}
  type BufferState :: *
  data BufferState = ReadBuffer | WriteBuffer
  type CharBufElem :: *
  type CharBufElem = GHC.Types.Char
  type CharBuffer :: *
  type CharBuffer = Buffer GHC.Types.Char
  type RawBuffer :: * -> *
  type RawBuffer e = GHC.ForeignPtr.ForeignPtr e
  type RawCharBuffer :: *
  type RawCharBuffer = RawBuffer CharBufElem
  bufferAdd :: forall e. GHC.Types.Int -> Buffer e -> Buffer e
  bufferAddOffset :: forall e. GHC.Types.Int -> Buffer e -> Buffer e
  bufferAdjustL :: forall e. GHC.Types.Int -> Buffer e -> Buffer e
  bufferAdjustOffset :: forall e. GHC.Word.Word64 -> Buffer e -> Buffer e
  bufferAvailable :: forall e. Buffer e -> GHC.Types.Int
  bufferElems :: forall e. Buffer e -> GHC.Types.Int
  bufferOffset :: forall e. Buffer e -> GHC.Word.Word64
  bufferRemove :: forall e. GHC.Types.Int -> Buffer e -> Buffer e
  charSize :: GHC.Types.Int
  checkBuffer :: forall a. Buffer a -> GHC.Types.IO ()
  emptyBuffer :: forall e. RawBuffer e -> GHC.Types.Int -> BufferState -> Buffer e
  isEmptyBuffer :: forall e. Buffer e -> GHC.Types.Bool
  isFullBuffer :: forall e. Buffer e -> GHC.Types.Bool
  isFullCharBuffer :: forall e. Buffer e -> GHC.Types.Bool
  isWriteBuffer :: forall e. Buffer e -> GHC.Types.Bool
  newBuffer :: forall e. GHC.Types.Int -> GHC.Types.Int -> BufferState -> GHC.Types.IO (Buffer e)
  newByteBuffer :: GHC.Types.Int -> BufferState -> GHC.Types.IO (Buffer GHC.Word.Word8)
  newCharBuffer :: GHC.Types.Int -> BufferState -> GHC.Types.IO CharBuffer
  peekCharBuf :: RawCharBuffer -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Char
  readCharBuf :: RawCharBuffer -> GHC.Types.Int -> GHC.Types.IO (GHC.Types.Char, GHC.Types.Int)
  readCharBufPtr :: GHC.Ptr.Ptr CharBufElem -> GHC.Types.Int -> GHC.Types.IO (GHC.Types.Char, GHC.Types.Int)
  readWord8Buf :: RawBuffer GHC.Word.Word8 -> GHC.Types.Int -> GHC.Types.IO GHC.Word.Word8
  slideContents :: Buffer GHC.Word.Word8 -> GHC.Types.IO (Buffer GHC.Word.Word8)
  summaryBuffer :: forall a. Buffer a -> GHC.Base.String
  withBuffer :: forall e a. Buffer e -> (GHC.Ptr.Ptr e -> GHC.Types.IO a) -> GHC.Types.IO a
  withRawBuffer :: forall e a. RawBuffer e -> (GHC.Ptr.Ptr e -> GHC.Types.IO a) -> GHC.Types.IO a
  writeCharBuf :: RawCharBuffer -> GHC.Types.Int -> GHC.Types.Char -> GHC.Types.IO GHC.Types.Int
  writeCharBufPtr :: GHC.Ptr.Ptr CharBufElem -> GHC.Types.Int -> GHC.Types.Char -> GHC.Types.IO GHC.Types.Int
  writeWord8Buf :: RawBuffer GHC.Word.Word8 -> GHC.Types.Int -> GHC.Word.Word8 -> GHC.Types.IO ()

module GHC.IO.BufferedIO where
  -- Safety: Trustworthy
  type BufferedIO :: * -> Constraint
  class BufferedIO dev where
    newBuffer :: dev -> GHC.IO.Buffer.BufferState -> GHC.Types.IO (GHC.IO.Buffer.Buffer GHC.Word.Word8)
    fillReadBuffer :: dev -> GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.Types.IO (GHC.Types.Int, GHC.IO.Buffer.Buffer GHC.Word.Word8)
    fillReadBuffer0 :: dev -> GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.Types.IO (GHC.Maybe.Maybe GHC.Types.Int, GHC.IO.Buffer.Buffer GHC.Word.Word8)
    emptyWriteBuffer :: dev -> GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.Types.IO (GHC.IO.Buffer.Buffer GHC.Word.Word8)
    flushWriteBuffer :: dev -> GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.Types.IO (GHC.IO.Buffer.Buffer GHC.Word.Word8)
    flushWriteBuffer0 :: dev -> GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.Types.IO (GHC.Types.Int, GHC.IO.Buffer.Buffer GHC.Word.Word8)
    {-# MINIMAL newBuffer, fillReadBuffer, fillReadBuffer0, flushWriteBuffer, flushWriteBuffer0 #-}
  readBuf :: forall dev. GHC.IO.Device.RawIO dev => dev -> GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.Types.IO (GHC.Types.Int, GHC.IO.Buffer.Buffer GHC.Word.Word8)
  readBufNonBlocking :: forall dev. GHC.IO.Device.RawIO dev => dev -> GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.Types.IO (GHC.Maybe.Maybe GHC.Types.Int, GHC.IO.Buffer.Buffer GHC.Word.Word8)
  writeBuf :: forall dev. GHC.IO.Device.RawIO dev => dev -> GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.Types.IO (GHC.IO.Buffer.Buffer GHC.Word.Word8)
  writeBufNonBlocking :: forall dev. GHC.IO.Device.RawIO dev => dev -> GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.Types.IO (GHC.Types.Int, GHC.IO.Buffer.Buffer GHC.Word.Word8)

module GHC.IO.Device where
  -- Safety: Trustworthy
  type IODevice :: * -> Constraint
  class IODevice a where
    ready :: a -> GHC.Types.Bool -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Bool
    close :: a -> GHC.Types.IO ()
    isTerminal :: a -> GHC.Types.IO GHC.Types.Bool
    isSeekable :: a -> GHC.Types.IO GHC.Types.Bool
    seek :: a -> SeekMode -> GHC.Num.Integer.Integer -> GHC.Types.IO GHC.Num.Integer.Integer
    tell :: a -> GHC.Types.IO GHC.Num.Integer.Integer
    getSize :: a -> GHC.Types.IO GHC.Num.Integer.Integer
    setSize :: a -> GHC.Num.Integer.Integer -> GHC.Types.IO ()
    setEcho :: a -> GHC.Types.Bool -> GHC.Types.IO ()
    getEcho :: a -> GHC.Types.IO GHC.Types.Bool
    setRaw :: a -> GHC.Types.Bool -> GHC.Types.IO ()
    devType :: a -> GHC.Types.IO IODeviceType
    dup :: a -> GHC.Types.IO a
    dup2 :: a -> a -> GHC.Types.IO a
    {-# MINIMAL ready, close, devType #-}
  type IODeviceType :: *
  data IODeviceType = Directory | Stream | RegularFile | RawDevice
  type RawIO :: * -> Constraint
  class RawIO a where
    read :: a -> GHC.Ptr.Ptr GHC.Word.Word8 -> GHC.Word.Word64 -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
    readNonBlocking :: a -> GHC.Ptr.Ptr GHC.Word.Word8 -> GHC.Word.Word64 -> GHC.Types.Int -> GHC.Types.IO (GHC.Maybe.Maybe GHC.Types.Int)
    write :: a -> GHC.Ptr.Ptr GHC.Word.Word8 -> GHC.Word.Word64 -> GHC.Types.Int -> GHC.Types.IO ()
    writeNonBlocking :: a -> GHC.Ptr.Ptr GHC.Word.Word8 -> GHC.Word.Word64 -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
    {-# MINIMAL read, readNonBlocking, write, writeNonBlocking #-}
  type SeekMode :: *
  data SeekMode = AbsoluteSeek | RelativeSeek | SeekFromEnd

module GHC.IO.Encoding where
  -- Safety: Trustworthy
  pattern BufferCodec :: forall from to state. GHC.IO.Encoding.Types.CodeBuffer from to -> (GHC.IO.Buffer.Buffer from -> GHC.IO.Buffer.Buffer to -> GHC.Types.IO (GHC.IO.Buffer.Buffer from, GHC.IO.Buffer.Buffer to)) -> GHC.Types.IO () -> GHC.Types.IO state -> (state -> GHC.Types.IO ()) -> BufferCodec from to state
  pattern BufferCodec {encode, recover, close, getState, setState}
  type role BufferCodec phantom phantom representational
  type BufferCodec :: * -> * -> * -> *
  data BufferCodec from to state = BufferCodec# {encode# :: GHC.IO.Encoding.Types.CodeBuffer# from to, recover# :: GHC.IO.Buffer.Buffer from -> GHC.IO.Buffer.Buffer to -> GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, GHC.IO.Buffer.Buffer from, GHC.IO.Buffer.Buffer to #), close# :: GHC.Types.IO (), getState# :: GHC.Types.IO state, setState# :: state -> GHC.Types.IO ()}
  type CodingProgress :: *
  data CodingProgress = InputUnderflow | OutputUnderflow | InvalidSequence
  type TextDecoder :: * -> *
  type TextDecoder state = BufferCodec GHC.Word.Word8 GHC.IO.Buffer.CharBufElem state
  type TextEncoder :: * -> *
  type TextEncoder state = BufferCodec GHC.IO.Buffer.CharBufElem GHC.Word.Word8 state
  type TextEncoding :: *
  data TextEncoding = forall dstate estate. TextEncoding {textEncodingName :: GHC.Base.String, mkTextDecoder :: GHC.Types.IO (TextDecoder dstate), mkTextEncoder :: GHC.Types.IO (TextEncoder estate)}
  argvEncoding :: GHC.Types.IO TextEncoding
  char8 :: TextEncoding
  getFileSystemEncoding :: GHC.Types.IO TextEncoding
  getForeignEncoding :: GHC.Types.IO TextEncoding
  getLocaleEncoding :: GHC.Types.IO TextEncoding
  initLocaleEncoding :: TextEncoding
  latin1 :: TextEncoding
  latin1_decode :: GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.IO.Buffer.CharBuffer -> GHC.Types.IO (GHC.IO.Buffer.Buffer GHC.Word.Word8, GHC.IO.Buffer.CharBuffer)
  latin1_encode :: GHC.IO.Buffer.CharBuffer -> GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.Types.IO (GHC.IO.Buffer.CharBuffer, GHC.IO.Buffer.Buffer GHC.Word.Word8)
  mkTextEncoding :: GHC.Base.String -> GHC.Types.IO TextEncoding
  setFileSystemEncoding :: TextEncoding -> GHC.Types.IO ()
  setForeignEncoding :: TextEncoding -> GHC.Types.IO ()
  setLocaleEncoding :: TextEncoding -> GHC.Types.IO ()
  utf16 :: TextEncoding
  utf16be :: TextEncoding
  utf16le :: TextEncoding
  utf32 :: TextEncoding
  utf32be :: TextEncoding
  utf32le :: TextEncoding
  utf8 :: TextEncoding
  utf8_bom :: TextEncoding

module GHC.IO.Encoding.CodePage where
  -- Safety: Trustworthy

module GHC.IO.Encoding.Failure where
  -- Safety: Trustworthy
  type CodingFailureMode :: *
  data CodingFailureMode = ErrorOnCodingFailure | IgnoreCodingFailure | TransliterateCodingFailure | RoundtripFailure
  codingFailureModeSuffix :: CodingFailureMode -> GHC.Base.String
  isSurrogate :: GHC.Types.Char -> GHC.Types.Bool
  recoverDecode :: CodingFailureMode -> GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.IO.Buffer.Buffer GHC.Types.Char -> GHC.Types.IO (GHC.IO.Buffer.Buffer GHC.Word.Word8, GHC.IO.Buffer.Buffer GHC.Types.Char)
  recoverDecode# :: CodingFailureMode -> GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.IO.Buffer.Buffer GHC.Types.Char -> GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, GHC.IO.Buffer.Buffer GHC.Word.Word8, GHC.IO.Buffer.Buffer GHC.Types.Char #)
  recoverEncode :: CodingFailureMode -> GHC.IO.Buffer.Buffer GHC.Types.Char -> GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.Types.IO (GHC.IO.Buffer.Buffer GHC.Types.Char, GHC.IO.Buffer.Buffer GHC.Word.Word8)
  recoverEncode# :: CodingFailureMode -> GHC.IO.Buffer.Buffer GHC.Types.Char -> GHC.IO.Buffer.Buffer GHC.Word.Word8 -> GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, GHC.IO.Buffer.Buffer GHC.Types.Char, GHC.IO.Buffer.Buffer GHC.Word.Word8 #)

module GHC.IO.Encoding.Iconv where
  -- Safety: Trustworthy
  iconvEncoding :: GHC.Base.String -> GHC.Types.IO (GHC.Maybe.Maybe GHC.IO.Encoding.Types.TextEncoding)
  localeEncodingName :: GHC.Base.String
  mkIconvEncoding :: GHC.IO.Encoding.Failure.CodingFailureMode -> GHC.Base.String -> GHC.Types.IO (GHC.Maybe.Maybe GHC.IO.Encoding.Types.TextEncoding)

module GHC.IO.Encoding.Latin1 where
  -- Safety: Trustworthy
  ascii :: GHC.IO.Encoding.Types.TextEncoding
  ascii_decode :: GHC.IO.Encoding.Types.DecodeBuffer#
  ascii_encode :: GHC.IO.Encoding.Types.EncodeBuffer#
  latin1 :: GHC.IO.Encoding.Types.TextEncoding
  latin1_checked :: GHC.IO.Encoding.Types.TextEncoding
  latin1_checked_encode :: GHC.IO.Encoding.Types.EncodeBuffer#
  latin1_decode :: GHC.IO.Encoding.Types.DecodeBuffer#
  latin1_encode :: GHC.IO.Encoding.Types.EncodeBuffer#
  mkAscii :: GHC.IO.Encoding.Failure.CodingFailureMode -> GHC.IO.Encoding.Types.TextEncoding
  mkLatin1 :: GHC.IO.Encoding.Failure.CodingFailureMode -> GHC.IO.Encoding.Types.TextEncoding
  mkLatin1_checked :: GHC.IO.Encoding.Failure.CodingFailureMode -> GHC.IO.Encoding.Types.TextEncoding

module GHC.IO.Encoding.Types where
  -- Safety: Trustworthy
  pattern BufferCodec :: forall from to state. CodeBuffer from to -> (GHC.IO.Buffer.Buffer from -> GHC.IO.Buffer.Buffer to -> GHC.Types.IO (GHC.IO.Buffer.Buffer from, GHC.IO.Buffer.Buffer to)) -> GHC.Types.IO () -> GHC.Types.IO state -> (state -> GHC.Types.IO ()) -> BufferCodec from to state
  pattern BufferCodec {encode, recover, close, getState, setState}
  type role BufferCodec phantom phantom representational
  type BufferCodec :: * -> * -> * -> *
  data BufferCodec from to state = BufferCodec# {encode# :: GHC.IO.Encoding.Types.CodeBuffer# from to, recover# :: GHC.IO.Buffer.Buffer from -> GHC.IO.Buffer.Buffer to -> GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, GHC.IO.Buffer.Buffer from, GHC.IO.Buffer.Buffer to #), close# :: GHC.Types.IO (), getState# :: GHC.Types.IO state, setState# :: state -> GHC.Types.IO ()}
  type CodeBuffer :: * -> * -> *
  type CodeBuffer from to = GHC.IO.Buffer.Buffer from -> GHC.IO.Buffer.Buffer to -> GHC.Types.IO (CodingProgress, GHC.IO.Buffer.Buffer from, GHC.IO.Buffer.Buffer to)
  type CodingProgress :: *
  data CodingProgress = InputUnderflow | OutputUnderflow | InvalidSequence
  type DecodeBuffer :: *
  type DecodeBuffer = CodeBuffer GHC.Word.Word8 GHC.Types.Char
  type DecodeBuffer# :: *
  type DecodeBuffer# = GHC.IO.Encoding.Types.CodeBuffer# GHC.Word.Word8 GHC.Types.Char
  type DecodingBuffer# :: *
  type DecodingBuffer# = GHC.IO.Encoding.Types.CodingBuffer# GHC.Word.Word8 GHC.Types.Char
  type EncodeBuffer :: *
  type EncodeBuffer = CodeBuffer GHC.Types.Char GHC.Word.Word8
  type EncodeBuffer# :: *
  type EncodeBuffer# = GHC.IO.Encoding.Types.CodeBuffer# GHC.Types.Char GHC.Word.Word8
  type EncodingBuffer# :: *
  type EncodingBuffer# = GHC.IO.Encoding.Types.CodingBuffer# GHC.Types.Char GHC.Word.Word8
  type TextDecoder :: * -> *
  type TextDecoder state = BufferCodec GHC.Word.Word8 GHC.IO.Buffer.CharBufElem state
  type TextEncoder :: * -> *
  type TextEncoder state = BufferCodec GHC.IO.Buffer.CharBufElem GHC.Word.Word8 state
  type TextEncoding :: *
  data TextEncoding = forall dstate estate. TextEncoding {textEncodingName :: GHC.Base.String, mkTextDecoder :: GHC.Types.IO (TextDecoder dstate), mkTextEncoder :: GHC.Types.IO (TextEncoder estate)}

module GHC.IO.Encoding.UTF16 where
  -- Safety: Trustworthy
  mkUTF16 :: GHC.IO.Encoding.Failure.CodingFailureMode -> GHC.IO.Encoding.Types.TextEncoding
  mkUTF16be :: GHC.IO.Encoding.Failure.CodingFailureMode -> GHC.IO.Encoding.Types.TextEncoding
  mkUTF16le :: GHC.IO.Encoding.Failure.CodingFailureMode -> GHC.IO.Encoding.Types.TextEncoding
  utf16 :: GHC.IO.Encoding.Types.TextEncoding
  utf16_decode :: GHC.IORef.IORef (GHC.Maybe.Maybe GHC.IO.Encoding.Types.DecodeBuffer#) -> GHC.IO.Encoding.Types.DecodeBuffer#
  utf16_encode :: GHC.IORef.IORef GHC.Types.Bool -> GHC.IO.Encoding.Types.EncodeBuffer#
  utf16be :: GHC.IO.Encoding.Types.TextEncoding
  utf16be_decode :: GHC.IO.Encoding.Types.DecodeBuffer#
  utf16be_encode :: GHC.IO.Encoding.Types.EncodeBuffer#
  utf16le :: GHC.IO.Encoding.Types.TextEncoding
  utf16le_decode :: GHC.IO.Encoding.Types.DecodeBuffer#
  utf16le_encode :: GHC.IO.Encoding.Types.EncodeBuffer#

module GHC.IO.Encoding.UTF32 where
  -- Safety: Trustworthy
  mkUTF32 :: GHC.IO.Encoding.Failure.CodingFailureMode -> GHC.IO.Encoding.Types.TextEncoding
  mkUTF32be :: GHC.IO.Encoding.Failure.CodingFailureMode -> GHC.IO.Encoding.Types.TextEncoding
  mkUTF32le :: GHC.IO.Encoding.Failure.CodingFailureMode -> GHC.IO.Encoding.Types.TextEncoding
  utf32 :: GHC.IO.Encoding.Types.TextEncoding
  utf32_decode :: GHC.IORef.IORef (GHC.Maybe.Maybe GHC.IO.Encoding.Types.DecodeBuffer#) -> GHC.IO.Encoding.Types.DecodeBuffer#
  utf32_encode :: GHC.IORef.IORef GHC.Types.Bool -> GHC.IO.Encoding.Types.EncodeBuffer#
  utf32be :: GHC.IO.Encoding.Types.TextEncoding
  utf32be_decode :: GHC.IO.Encoding.Types.DecodeBuffer#
  utf32be_encode :: GHC.IO.Encoding.Types.EncodeBuffer#
  utf32le :: GHC.IO.Encoding.Types.TextEncoding
  utf32le_decode :: GHC.IO.Encoding.Types.DecodeBuffer#
  utf32le_encode :: GHC.IO.Encoding.Types.EncodeBuffer#

module GHC.IO.Encoding.UTF8 where
  -- Safety: Trustworthy
  mkUTF8 :: GHC.IO.Encoding.Failure.CodingFailureMode -> GHC.IO.Encoding.Types.TextEncoding
  mkUTF8_bom :: GHC.IO.Encoding.Failure.CodingFailureMode -> GHC.IO.Encoding.Types.TextEncoding
  utf8 :: GHC.IO.Encoding.Types.TextEncoding
  utf8_bom :: GHC.IO.Encoding.Types.TextEncoding

module GHC.IO.Exception where
  -- Safety: Trustworthy
  type AllocationLimitExceeded :: *
  data AllocationLimitExceeded = AllocationLimitExceeded
  type ArrayException :: *
  data ArrayException = IndexOutOfBounds GHC.Base.String | UndefinedElement GHC.Base.String
  type AssertionFailed :: *
  newtype AssertionFailed = AssertionFailed GHC.Base.String
  type AsyncException :: *
  data AsyncException = StackOverflow | HeapOverflow | ThreadKilled | UserInterrupt
  type BlockedIndefinitelyOnMVar :: *
  data BlockedIndefinitelyOnMVar = BlockedIndefinitelyOnMVar
  type BlockedIndefinitelyOnSTM :: *
  data BlockedIndefinitelyOnSTM = BlockedIndefinitelyOnSTM
  type CompactionFailed :: *
  newtype CompactionFailed = CompactionFailed GHC.Base.String
  type Deadlock :: *
  data Deadlock = Deadlock
  type ExitCode :: *
  data ExitCode = ExitSuccess | ExitFailure GHC.Types.Int
  type FixIOException :: *
  data FixIOException = FixIOException
  type IOError :: *
  type IOError = IOException
  type IOErrorType :: *
  data IOErrorType = AlreadyExists | NoSuchThing | ResourceBusy | ResourceExhausted | EOF | IllegalOperation | PermissionDenied | UserError | UnsatisfiedConstraints | SystemError | ProtocolError | OtherError | InvalidArgument | InappropriateType | HardwareFault | UnsupportedOperation | TimeExpired | ResourceVanished | Interrupted
  type IOException :: *
  data IOException = IOError {ioe_handle :: GHC.Maybe.Maybe GHC.IO.Handle.Types.Handle, ioe_type :: IOErrorType, ioe_location :: GHC.Base.String, ioe_description :: GHC.Base.String, ioe_errno :: GHC.Maybe.Maybe Foreign.C.Types.CInt, ioe_filename :: GHC.Maybe.Maybe GHC.IO.FilePath}
  type SomeAsyncException :: *
  data SomeAsyncException = forall e. GHC.Exception.Type.Exception e => SomeAsyncException e
  allocationLimitExceeded :: GHC.Exception.Type.SomeException
  assertError :: forall a. (?callStack::GHC.Stack.Types.CallStack) => GHC.Types.Bool -> a -> a
  asyncExceptionFromException :: forall e. GHC.Exception.Type.Exception e => GHC.Exception.Type.SomeException -> GHC.Maybe.Maybe e
  asyncExceptionToException :: forall e. GHC.Exception.Type.Exception e => e -> GHC.Exception.Type.SomeException
  blockedIndefinitelyOnMVar :: GHC.Exception.Type.SomeException
  blockedIndefinitelyOnSTM :: GHC.Exception.Type.SomeException
  cannotCompactFunction :: GHC.Exception.Type.SomeException
  cannotCompactMutable :: GHC.Exception.Type.SomeException
  cannotCompactPinned :: GHC.Exception.Type.SomeException
  heapOverflow :: GHC.Exception.Type.SomeException
  ioError :: forall a. IOError -> GHC.Types.IO a
  ioException :: forall a. IOException -> GHC.Types.IO a
  stackOverflow :: GHC.Exception.Type.SomeException
  unsupportedOperation :: IOError
  untangle :: GHC.Prim.Addr# -> GHC.Base.String -> GHC.Base.String
  userError :: GHC.Base.String -> IOError

module GHC.IO.FD where
  -- Safety: Trustworthy
  type FD :: *
  data FD = FD {fdFD :: ! {-# UNPACK #-}(Foreign.C.Types.N:CInt[0])Foreign.C.Types.CInt, fdIsNonBlocking :: {-# UNPACK #-}GHC.Types.Int}
  mkFD :: Foreign.C.Types.CInt -> GHC.IO.IOMode.IOMode -> GHC.Maybe.Maybe (GHC.IO.Device.IODeviceType, System.Posix.Types.CDev, System.Posix.Types.CIno) -> GHC.Types.Bool -> GHC.Types.Bool -> GHC.Types.IO (FD, GHC.IO.Device.IODeviceType)
  openFile :: GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> GHC.Types.Bool -> GHC.Types.IO (FD, GHC.IO.Device.IODeviceType)
  openFileWith :: forall r s. GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> GHC.Types.Bool -> (FD -> GHC.IO.Device.IODeviceType -> GHC.Types.IO r) -> ((forall x. GHC.Types.IO x -> GHC.Types.IO x) -> r -> GHC.Types.IO s) -> GHC.Types.IO s
  readRawBufferPtr :: GHC.Base.String -> FD -> GHC.Ptr.Ptr GHC.Word.Word8 -> GHC.Types.Int -> Foreign.C.Types.CSize -> GHC.Types.IO GHC.Types.Int
  readRawBufferPtrNoBlock :: GHC.Base.String -> FD -> GHC.Ptr.Ptr GHC.Word.Word8 -> GHC.Types.Int -> Foreign.C.Types.CSize -> GHC.Types.IO GHC.Types.Int
  release :: FD -> GHC.Types.IO ()
  setNonBlockingMode :: FD -> GHC.Types.Bool -> GHC.Types.IO FD
  stderr :: FD
  stdin :: FD
  stdout :: FD
  writeRawBufferPtr :: GHC.Base.String -> FD -> GHC.Ptr.Ptr GHC.Word.Word8 -> GHC.Types.Int -> Foreign.C.Types.CSize -> GHC.Types.IO Foreign.C.Types.CInt

module GHC.IO.Handle where
  -- Safety: Trustworthy
  type BufferMode :: *
  data BufferMode = NoBuffering | LineBuffering | BlockBuffering (GHC.Maybe.Maybe GHC.Types.Int)
  type Handle :: *
  data Handle = ...
  type HandlePosition :: *
  type HandlePosition = GHC.Num.Integer.Integer
  type HandlePosn :: *
  data HandlePosn = HandlePosn Handle HandlePosition
  type LockMode :: *
  data LockMode = SharedLock | ExclusiveLock
  type Newline :: *
  data Newline = LF | CRLF
  type NewlineMode :: *
  data NewlineMode = NewlineMode {inputNL :: Newline, outputNL :: Newline}
  type SeekMode :: *
  data SeekMode = AbsoluteSeek | RelativeSeek | SeekFromEnd
  hClose :: Handle -> GHC.Types.IO ()
  hClose_help :: GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO (GHC.IO.Handle.Types.Handle__, GHC.Maybe.Maybe GHC.Exception.Type.SomeException)
  hDuplicate :: Handle -> GHC.Types.IO Handle
  hDuplicateTo :: Handle -> Handle -> GHC.Types.IO ()
  hFileSize :: Handle -> GHC.Types.IO GHC.Num.Integer.Integer
  hFlush :: Handle -> GHC.Types.IO ()
  hFlushAll :: Handle -> GHC.Types.IO ()
  hGetBuf :: forall a. Handle -> GHC.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  hGetBufNonBlocking :: forall a. Handle -> GHC.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  hGetBuffering :: Handle -> GHC.Types.IO BufferMode
  hGetChar :: Handle -> GHC.Types.IO GHC.Types.Char
  hGetContents :: Handle -> GHC.Types.IO GHC.Base.String
  hGetContents' :: Handle -> GHC.Types.IO GHC.Base.String
  hGetEcho :: Handle -> GHC.Types.IO GHC.Types.Bool
  hGetEncoding :: Handle -> GHC.Types.IO (GHC.Maybe.Maybe GHC.IO.Encoding.Types.TextEncoding)
  hGetLine :: Handle -> GHC.Types.IO GHC.Base.String
  hGetPosn :: Handle -> GHC.Types.IO HandlePosn
  hIsClosed :: Handle -> GHC.Types.IO GHC.Types.Bool
  hIsEOF :: Handle -> GHC.Types.IO GHC.Types.Bool
  hIsOpen :: Handle -> GHC.Types.IO GHC.Types.Bool
  hIsReadable :: Handle -> GHC.Types.IO GHC.Types.Bool
  hIsSeekable :: Handle -> GHC.Types.IO GHC.Types.Bool
  hIsTerminalDevice :: Handle -> GHC.Types.IO GHC.Types.Bool
  hIsWritable :: Handle -> GHC.Types.IO GHC.Types.Bool
  hLock :: Handle -> LockMode -> GHC.Types.IO ()
  hLookAhead :: Handle -> GHC.Types.IO GHC.Types.Char
  hPutBuf :: forall a. Handle -> GHC.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  hPutBufNonBlocking :: forall a. Handle -> GHC.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  hPutChar :: Handle -> GHC.Types.Char -> GHC.Types.IO ()
  hPutStr :: Handle -> GHC.Base.String -> GHC.Types.IO ()
  hSeek :: Handle -> SeekMode -> GHC.Num.Integer.Integer -> GHC.Types.IO ()
  hSetBinaryMode :: Handle -> GHC.Types.Bool -> GHC.Types.IO ()
  hSetBuffering :: Handle -> BufferMode -> GHC.Types.IO ()
  hSetEcho :: Handle -> GHC.Types.Bool -> GHC.Types.IO ()
  hSetEncoding :: Handle -> GHC.IO.Encoding.Types.TextEncoding -> GHC.Types.IO ()
  hSetFileSize :: Handle -> GHC.Num.Integer.Integer -> GHC.Types.IO ()
  hSetNewlineMode :: Handle -> NewlineMode -> GHC.Types.IO ()
  hSetPosn :: HandlePosn -> GHC.Types.IO ()
  hShow :: Handle -> GHC.Types.IO GHC.Base.String
  hTell :: Handle -> GHC.Types.IO GHC.Num.Integer.Integer
  hTryLock :: Handle -> LockMode -> GHC.Types.IO GHC.Types.Bool
  hWaitForInput :: Handle -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Bool
  isEOF :: GHC.Types.IO GHC.Types.Bool
Ben Gamari's avatar
Move `base` to `ghc-internal`  
Ben Gamari committed
7808 7809 
  mkDuplexHandle :: forall dev. (GHC.IO.Device.RawIO dev, GHC.IO.Device.IODevice dev, GHC.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:Data.Typeable.Internal.Typeable dev) => dev -> GHC.IO.FilePath -> GHC.Maybe.Maybe GHC.IO.Encoding.Types.TextEncoding -> NewlineMode -> GHC.Types.IO Handle
  mkFileHandle :: forall dev. (GHC.IO.Device.RawIO dev, GHC.IO.Device.IODevice dev, GHC.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:Data.Typeable.Internal.Typeable dev) => dev -> GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> GHC.Maybe.Maybe GHC.IO.Encoding.Types.TextEncoding -> NewlineMode -> GHC.Types.IO Handle
Ben Gamari's avatar
testsuite: Add test to catch changes in core libraries
Ben Gamari committed
7810 7811 7812 7813 7814 7815 7816 7817 7818 7819 7820 7821 7822 7823 7824 7825 7826 7827 7828 7829 7830 7831 7832 7833 7834 7835 7836 7837 7838 7839 7840 7841 7842 7843 7844 7845 7846 7847 7848 7849 7850 7851 7852 7853 7854 7855 7856 7857 7858 
  nativeNewline :: Newline
  nativeNewlineMode :: NewlineMode
  noNewlineTranslation :: NewlineMode
  universalNewlineMode :: NewlineMode

module GHC.IO.Handle.FD where
  -- Safety: Trustworthy
  fdToHandle :: System.Posix.Internals.FD -> GHC.Types.IO GHC.IO.Handle.Types.Handle
  fdToHandle' :: Foreign.C.Types.CInt -> GHC.Maybe.Maybe GHC.IO.Device.IODeviceType -> GHC.Types.Bool -> GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> GHC.Types.Bool -> GHC.Types.IO GHC.IO.Handle.Types.Handle
  handleToFd :: GHC.IO.Handle.Types.Handle -> GHC.Types.IO GHC.IO.FD.FD
  mkHandleFromFD :: GHC.IO.FD.FD -> GHC.IO.Device.IODeviceType -> GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> GHC.Types.Bool -> GHC.Maybe.Maybe GHC.IO.Encoding.Types.TextEncoding -> GHC.Types.IO GHC.IO.Handle.Types.Handle
  openBinaryFile :: GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> GHC.Types.IO GHC.IO.Handle.Types.Handle
  openFile :: GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> GHC.Types.IO GHC.IO.Handle.Types.Handle
  openFileBlocking :: GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> GHC.Types.IO GHC.IO.Handle.Types.Handle
  stderr :: GHC.IO.Handle.Types.Handle
  stdin :: GHC.IO.Handle.Types.Handle
  stdout :: GHC.IO.Handle.Types.Handle
  withBinaryFile :: forall r. GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> (GHC.IO.Handle.Types.Handle -> GHC.Types.IO r) -> GHC.Types.IO r
  withFile :: forall r. GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> (GHC.IO.Handle.Types.Handle -> GHC.Types.IO r) -> GHC.Types.IO r
  withFileBlocking :: forall r. GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> (GHC.IO.Handle.Types.Handle -> GHC.Types.IO r) -> GHC.Types.IO r

module GHC.IO.Handle.Internals where
  -- Safety: Trustworthy
  type HandleFinalizer :: *
  type HandleFinalizer = GHC.IO.FilePath -> GHC.MVar.MVar GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  addHandleFinalizer :: GHC.IO.Handle.Types.Handle -> HandleFinalizer -> GHC.Types.IO ()
  augmentIOError :: GHC.IO.Exception.IOException -> GHC.Base.String -> GHC.IO.Handle.Types.Handle -> GHC.IO.Exception.IOException
  closeTextCodecs :: GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  dEFAULT_CHAR_BUFFER_SIZE :: GHC.Types.Int
  debugIO :: GHC.Base.String -> GHC.Types.IO ()
  decodeByteBuf :: GHC.IO.Handle.Types.Handle__ -> GHC.IO.Buffer.CharBuffer -> GHC.Types.IO GHC.IO.Buffer.CharBuffer
  flushBuffer :: GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  flushByteReadBuffer :: GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  flushByteWriteBuffer :: GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  flushCharBuffer :: GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  flushCharReadBuffer :: GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  flushWriteBuffer :: GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  hClose_help :: GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO (GHC.IO.Handle.Types.Handle__, GHC.Maybe.Maybe GHC.Exception.Type.SomeException)
  hClose_impl :: GHC.IO.Handle.Types.Handle -> GHC.Types.IO ()
  hLookAhead_ :: GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO GHC.Types.Char
  handleFinalizer :: GHC.IO.FilePath -> GHC.MVar.MVar GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  initBufferState :: GHC.IO.Handle.Types.HandleType -> GHC.IO.Buffer.BufferState
  ioe_EOF :: forall a. GHC.Types.IO a
  ioe_bufsiz :: forall a. GHC.Types.Int -> GHC.Types.IO a
  ioe_closedHandle :: forall a. GHC.Types.IO a
  ioe_finalizedHandle :: GHC.IO.FilePath -> GHC.IO.Handle.Types.Handle__
  ioe_notReadable :: forall a. GHC.Types.IO a
  ioe_notWritable :: forall a. GHC.Types.IO a
  ioe_semiclosedHandle :: forall a. GHC.Types.IO a
Ben Gamari's avatar
Move `base` to `ghc-internal`  
Ben Gamari committed
7859 7860 7861 7862 7863 
  mkDuplexHandle :: forall dev. (GHC.IO.Device.RawIO dev, GHC.IO.Device.IODevice dev, GHC.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:Data.Typeable.Internal.Typeable dev) => dev -> GHC.IO.FilePath -> GHC.Maybe.Maybe GHC.IO.Encoding.Types.TextEncoding -> GHC.IO.Handle.Types.NewlineMode -> GHC.Types.IO GHC.IO.Handle.Types.Handle
  mkDuplexHandleNoFinalizer :: forall dev. (GHC.IO.Device.RawIO dev, GHC.IO.Device.IODevice dev, GHC.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:Data.Typeable.Internal.Typeable dev) => dev -> GHC.IO.FilePath -> GHC.Maybe.Maybe GHC.IO.Encoding.Types.TextEncoding -> GHC.IO.Handle.Types.NewlineMode -> GHC.Types.IO GHC.IO.Handle.Types.Handle
  mkFileHandle :: forall dev. (GHC.IO.Device.RawIO dev, GHC.IO.Device.IODevice dev, GHC.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:Data.Typeable.Internal.Typeable dev) => dev -> GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> GHC.Maybe.Maybe GHC.IO.Encoding.Types.TextEncoding -> GHC.IO.Handle.Types.NewlineMode -> GHC.Types.IO GHC.IO.Handle.Types.Handle
  mkFileHandleNoFinalizer :: forall dev. (GHC.IO.Device.RawIO dev, GHC.IO.Device.IODevice dev, GHC.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:Data.Typeable.Internal.Typeable dev) => dev -> GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> GHC.Maybe.Maybe GHC.IO.Encoding.Types.TextEncoding -> GHC.IO.Handle.Types.NewlineMode -> GHC.Types.IO GHC.IO.Handle.Types.Handle
  mkHandle :: forall dev. (GHC.IO.Device.RawIO dev, GHC.IO.Device.IODevice dev, GHC.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:Data.Typeable.Internal.Typeable dev) => dev -> GHC.IO.FilePath -> GHC.IO.Handle.Types.HandleType -> GHC.Types.Bool -> GHC.Maybe.Maybe GHC.IO.Encoding.Types.TextEncoding -> GHC.IO.Handle.Types.NewlineMode -> GHC.Maybe.Maybe HandleFinalizer -> GHC.Maybe.Maybe (GHC.MVar.MVar GHC.IO.Handle.Types.Handle__) -> GHC.Types.IO GHC.IO.Handle.Types.Handle
Ben Gamari's avatar
testsuite: Add test to catch changes in core libraries
Ben Gamari committed
7864 7865 7866 7867 7868 7869 7870 7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886 7887 7888 7889 7890 7891 7892 7893 7894 7895 7896 7897 7898 7899 7900 7901 7902 7903 7904 7905 7906 7907 7908 7909 7910 7911 7912 7913 7914 7915 7916 7917 7918 7919 7920 7921 7922 7923 7924 7925 7926 
  openTextEncoding :: forall a. GHC.Maybe.Maybe GHC.IO.Encoding.Types.TextEncoding -> GHC.IO.Handle.Types.HandleType -> (forall es ds. GHC.Maybe.Maybe (GHC.IO.Encoding.Types.TextEncoder es) -> GHC.Maybe.Maybe (GHC.IO.Encoding.Types.TextDecoder ds) -> GHC.Types.IO a) -> GHC.Types.IO a
  readTextDevice :: GHC.IO.Handle.Types.Handle__ -> GHC.IO.Buffer.CharBuffer -> GHC.Types.IO GHC.IO.Buffer.CharBuffer
  readTextDeviceNonBlocking :: GHC.IO.Handle.Types.Handle__ -> GHC.IO.Buffer.CharBuffer -> GHC.Types.IO GHC.IO.Buffer.CharBuffer
  traceIO :: GHC.Base.String -> GHC.Types.IO ()
  wantReadableHandle :: forall a. GHC.Base.String -> GHC.IO.Handle.Types.Handle -> (GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO (GHC.IO.Handle.Types.Handle__, a)) -> GHC.Types.IO a
  wantReadableHandle_ :: forall a. GHC.Base.String -> GHC.IO.Handle.Types.Handle -> (GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO a) -> GHC.Types.IO a
  wantSeekableHandle :: forall a. GHC.Base.String -> GHC.IO.Handle.Types.Handle -> (GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO a) -> GHC.Types.IO a
  wantWritableHandle :: forall a. GHC.Base.String -> GHC.IO.Handle.Types.Handle -> (GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO a) -> GHC.Types.IO a
  withAllHandles__ :: GHC.Base.String -> GHC.IO.Handle.Types.Handle -> (GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO GHC.IO.Handle.Types.Handle__) -> GHC.Types.IO ()
  withHandle :: forall a. GHC.Base.String -> GHC.IO.Handle.Types.Handle -> (GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO (GHC.IO.Handle.Types.Handle__, a)) -> GHC.Types.IO a
  withHandle' :: forall a. GHC.Base.String -> GHC.IO.Handle.Types.Handle -> GHC.MVar.MVar GHC.IO.Handle.Types.Handle__ -> (GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO (GHC.IO.Handle.Types.Handle__, a)) -> GHC.Types.IO a
  withHandle_ :: forall a. GHC.Base.String -> GHC.IO.Handle.Types.Handle -> (GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO a) -> GHC.Types.IO a
  withHandle_' :: forall a. GHC.Base.String -> GHC.IO.Handle.Types.Handle -> GHC.MVar.MVar GHC.IO.Handle.Types.Handle__ -> (GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO a) -> GHC.Types.IO a
  withHandle__' :: GHC.Base.String -> GHC.IO.Handle.Types.Handle -> GHC.MVar.MVar GHC.IO.Handle.Types.Handle__ -> (GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO GHC.IO.Handle.Types.Handle__) -> GHC.Types.IO ()
  writeCharBuffer :: GHC.IO.Handle.Types.Handle__ -> GHC.IO.Buffer.CharBuffer -> GHC.Types.IO ()

module GHC.IO.Handle.Lock where
  -- Safety: None
  type FileLockingNotSupported :: *
  data FileLockingNotSupported = FileLockingNotSupported
  type LockMode :: *
  data LockMode = SharedLock | ExclusiveLock
  hLock :: GHC.IO.Handle.Types.Handle -> LockMode -> GHC.Types.IO ()
  hTryLock :: GHC.IO.Handle.Types.Handle -> LockMode -> GHC.Types.IO GHC.Types.Bool
  hUnlock :: GHC.IO.Handle.Types.Handle -> GHC.Types.IO ()

module GHC.IO.Handle.Text where
  -- Safety: Trustworthy
  commitBuffer' :: GHC.IO.Buffer.RawCharBuffer -> GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Bool -> GHC.Types.Bool -> GHC.IO.Handle.Types.Handle__ -> GHC.Types.IO GHC.IO.Buffer.CharBuffer
  hGetBuf :: forall a. GHC.IO.Handle.Types.Handle -> GHC.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  hGetBufNonBlocking :: forall a. GHC.IO.Handle.Types.Handle -> GHC.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  hGetBufSome :: forall a. GHC.IO.Handle.Types.Handle -> GHC.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  hGetChar :: GHC.IO.Handle.Types.Handle -> GHC.Types.IO GHC.Types.Char
  hGetContents :: GHC.IO.Handle.Types.Handle -> GHC.Types.IO GHC.Base.String
  hGetContents' :: GHC.IO.Handle.Types.Handle -> GHC.Types.IO GHC.Base.String
  hGetLine :: GHC.IO.Handle.Types.Handle -> GHC.Types.IO GHC.Base.String
  hPutBuf :: forall a. GHC.IO.Handle.Types.Handle -> GHC.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  hPutBufNonBlocking :: forall a. GHC.IO.Handle.Types.Handle -> GHC.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  hPutChar :: GHC.IO.Handle.Types.Handle -> GHC.Types.Char -> GHC.Types.IO ()
  hPutStr :: GHC.IO.Handle.Types.Handle -> GHC.Base.String -> GHC.Types.IO ()
  hPutStrLn :: GHC.IO.Handle.Types.Handle -> GHC.Base.String -> GHC.Types.IO ()
  hWaitForInput :: GHC.IO.Handle.Types.Handle -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Bool
  memcpy :: forall a. GHC.Ptr.Ptr a -> GHC.Ptr.Ptr a -> Foreign.C.Types.CSize -> GHC.Types.IO (GHC.Ptr.Ptr ())

module GHC.IO.Handle.Types where
  -- Safety: Trustworthy
  pattern BufferCodec :: forall from to state. GHC.IO.Encoding.Types.CodeBuffer from to -> (GHC.IO.Buffer.Buffer from -> GHC.IO.Buffer.Buffer to -> GHC.Types.IO (GHC.IO.Buffer.Buffer from, GHC.IO.Buffer.Buffer to)) -> GHC.Types.IO () -> GHC.Types.IO state -> (state -> GHC.Types.IO ()) -> BufferCodec from to state
  pattern BufferCodec {encode, recover, close, getState, setState}
  type role BufferCodec phantom phantom representational
  type BufferCodec :: * -> * -> * -> *
  data BufferCodec from to state = BufferCodec# {encode# :: GHC.IO.Encoding.Types.CodeBuffer# from to, recover# :: GHC.IO.Buffer.Buffer from -> GHC.IO.Buffer.Buffer to -> GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, GHC.IO.Buffer.Buffer from, GHC.IO.Buffer.Buffer to #), close# :: GHC.Types.IO (), getState# :: GHC.Types.IO state, setState# :: state -> GHC.Types.IO ()}
  type role BufferList phantom
  type BufferList :: * -> *
  data BufferList e = BufferListNil | BufferListCons (GHC.IO.Buffer.RawBuffer e) (BufferList e)
  type BufferMode :: *
  data BufferMode = NoBuffering | LineBuffering | BlockBuffering (GHC.Maybe.Maybe GHC.Types.Int)
  type Handle :: *
  data Handle = FileHandle GHC.IO.FilePath {-# UNPACK #-}(GHC.MVar.MVar Handle__) | DuplexHandle GHC.IO.FilePath {-# UNPACK #-}(GHC.MVar.MVar Handle__) {-# UNPACK #-}(GHC.MVar.MVar Handle__)
  type HandleType :: *
  data HandleType = ClosedHandle | SemiClosedHandle | ReadHandle | WriteHandle | AppendHandle | ReadWriteHandle
  type Handle__ :: *
  data Handle__
    = forall dev enc_state dec_state.
Ben Gamari's avatar
Move `base` to `ghc-internal`  
Ben Gamari committed
7927 
      (GHC.IO.Device.RawIO dev, GHC.IO.Device.IODevice dev, GHC.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:Data.Typeable.Internal.Typeable dev) =>
Ben Gamari's avatar
testsuite: Add test to catch changes in core libraries
Ben Gamari committed
7928 7929 7930 7931 7932 7933 7934 7935 7936 7937 7938 7939 7940 7941 7942 7943 7944 7945 7946 7947 7948 7949 7950 7951 7952 7953 7954 7955 7956 7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985 7986 7987 7988 7989 7990 7991 7992 7993 7994 7995 7996 7997 7998 7999 8000 
      Handle__ {haDevice :: !dev,
                haType :: HandleType,
                haByteBuffer :: ! {-# UNPACK #-}(GHC.IORef.N:IORef[0] <GHC.IO.Buffer.Buffer GHC.Word.Word8>_N)(GHC.IORef.IORef (GHC.IO.Buffer.Buffer GHC.Word.Word8)),
                haBufferMode :: BufferMode,
                haLastDecode :: ! {-# UNPACK #-}(GHC.IORef.N:IORef[0] <(dec_state, GHC.IO.Buffer.Buffer GHC.Word.Word8)>_N)(GHC.IORef.IORef (dec_state, GHC.IO.Buffer.Buffer GHC.Word.Word8)),
                haCharBuffer :: ! {-# UNPACK #-}(GHC.IORef.N:IORef[0] <GHC.IO.Buffer.Buffer GHC.IO.Buffer.CharBufElem>_N)(GHC.IORef.IORef (GHC.IO.Buffer.Buffer GHC.IO.Buffer.CharBufElem)),
                haBuffers :: ! {-# UNPACK #-}(GHC.IORef.N:IORef[0] <BufferList GHC.IO.Buffer.CharBufElem>_N)(GHC.IORef.IORef (BufferList GHC.IO.Buffer.CharBufElem)),
                haEncoder :: GHC.Maybe.Maybe (GHC.IO.Encoding.Types.TextEncoder enc_state),
                haDecoder :: GHC.Maybe.Maybe (GHC.IO.Encoding.Types.TextDecoder dec_state),
                haCodec :: GHC.Maybe.Maybe GHC.IO.Encoding.Types.TextEncoding,
                haInputNL :: Newline,
                haOutputNL :: Newline,
                haOtherSide :: GHC.Maybe.Maybe (GHC.MVar.MVar Handle__)}
  type Newline :: *
  data Newline = LF | CRLF
  type NewlineMode :: *
  data NewlineMode = NewlineMode {inputNL :: Newline, outputNL :: Newline}
  checkHandleInvariants :: Handle__ -> GHC.Types.IO ()
  isAppendHandleType :: HandleType -> GHC.Types.Bool
  isReadWriteHandleType :: HandleType -> GHC.Types.Bool
  isReadableHandleType :: HandleType -> GHC.Types.Bool
  isWritableHandleType :: HandleType -> GHC.Types.Bool
  nativeNewline :: Newline
  nativeNewlineMode :: NewlineMode
  noNewlineTranslation :: NewlineMode
  showHandle :: GHC.IO.FilePath -> GHC.Base.String -> GHC.Base.String
  universalNewlineMode :: NewlineMode

module GHC.IO.IOMode where
  -- Safety: Trustworthy
  type IOMode :: *
  data IOMode = ReadMode | WriteMode | AppendMode | ReadWriteMode

module GHC.IO.StdHandles where
  -- Safety: Trustworthy
  openBinaryFile :: GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> GHC.Types.IO GHC.IO.Handle.Types.Handle
  openFile :: GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> GHC.Types.IO GHC.IO.Handle.Types.Handle
  openFileBlocking :: GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> GHC.Types.IO GHC.IO.Handle.Types.Handle
  stderr :: GHC.IO.Handle.Types.Handle
  stdin :: GHC.IO.Handle.Types.Handle
  stdout :: GHC.IO.Handle.Types.Handle
  withBinaryFile :: forall r. GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> (GHC.IO.Handle.Types.Handle -> GHC.Types.IO r) -> GHC.Types.IO r
  withFile :: forall r. GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> (GHC.IO.Handle.Types.Handle -> GHC.Types.IO r) -> GHC.Types.IO r
  withFileBlocking :: forall r. GHC.IO.FilePath -> GHC.IO.IOMode.IOMode -> (GHC.IO.Handle.Types.Handle -> GHC.Types.IO r) -> GHC.Types.IO r

module GHC.IO.SubSystem where
  -- Safety: Trustworthy
  (<!>) :: forall a. a -> a -> a
  type IoSubSystem :: *
  data IoSubSystem = IoPOSIX | IoNative
  conditional :: forall a. a -> a -> a
  ioSubSystem :: IoSubSystem
  isWindowsNativeIO :: GHC.Types.Bool
  whenIoSubSystem :: IoSubSystem -> GHC.Types.IO () -> GHC.Types.IO ()
  withIoSubSystem :: forall a. (IoSubSystem -> GHC.Types.IO a) -> GHC.Types.IO a
  withIoSubSystem' :: forall a. (IoSubSystem -> a) -> a

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

module GHC.IOArray where
  -- Safety: Unsafe
  type role IOArray nominal representational
  type IOArray :: * -> * -> *
  newtype IOArray i e = IOArray (GHC.Arr.STArray GHC.Prim.RealWorld i e)
  boundsIOArray :: forall i e. IOArray i e -> (i, i)
  newIOArray :: forall i e. GHC.Ix.Ix i => (i, i) -> e -> GHC.Types.IO (IOArray i e)
  readIOArray :: forall i e. GHC.Ix.Ix i => IOArray i e -> i -> GHC.Types.IO e
Show full blame