base-exports.stdout-javascript-unknown-ghcjs

module Control.Applicative where
  -- Safety: Trustworthy
  (<$) :: forall (f :: * -> *) a b. GHC.Internal.Base.Functor f => a -> f b -> f a
  (<$>) :: forall (f :: * -> *) a b. GHC.Internal.Base.Functor f => (a -> b) -> f a -> f b
  (<**>) :: forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
  type Alternative :: (* -> *) -> Constraint
  class Applicative f => Alternative f where
    empty :: forall a. f a
    (<|>) :: forall a. f a -> f a -> f a
    some :: forall a. f a -> f [a]
    many :: forall a. f a -> f [a]
    {-# MINIMAL empty, (<|>) #-}
  type Applicative :: (* -> *) -> Constraint
  class GHC.Internal.Base.Functor f => Applicative f where
    pure :: forall a. a -> f a
    (<*>) :: forall a b. f (a -> b) -> f a -> f b
    liftA2 :: forall a b c. (a -> b -> c) -> f a -> f b -> f c
    (*>) :: forall a b. f a -> f b -> f b
    (<*) :: forall a b. f a -> f b -> f a
    {-# MINIMAL pure, ((<*>) | liftA2) #-}
  type role Const representational phantom
  type Const :: forall {k}. * -> k -> *
  newtype Const a b = Const {getConst :: a}
  type role WrappedArrow representational nominal nominal
  type WrappedArrow :: (* -> * -> *) -> * -> * -> *
  newtype WrappedArrow a b c = WrapArrow {unwrapArrow :: a b c}
  type role WrappedMonad representational nominal
  type WrappedMonad :: (* -> *) -> * -> *
  newtype WrappedMonad m a = WrapMonad {unwrapMonad :: m a}
  type ZipList :: * -> *
  newtype ZipList a = ZipList {getZipList :: [a]}
  asum :: forall (t :: * -> *) (f :: * -> *) a. (GHC.Internal.Data.Foldable.Foldable t, Alternative f) => t (f a) -> f a
  liftA :: forall (f :: * -> *) a b. Applicative f => (a -> b) -> f a -> f b
  liftA3 :: forall (f :: * -> *) a b c d. Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
  optional :: forall (f :: * -> *) a. Alternative f => f a -> f (GHC.Internal.Maybe.Maybe a)

module Control.Arrow where
  -- Safety: Safe
  (<<<) :: forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k). GHC.Internal.Control.Category.Category cat => cat b c -> cat a b -> cat a c
  (<<^) :: forall (a :: * -> * -> *) c d b. Arrow a => a c d -> (b -> c) -> a b d
  (>>>) :: forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). GHC.Internal.Control.Category.Category cat => cat a b -> cat b c -> cat a c
  (>>^) :: forall (a :: * -> * -> *) b c d. Arrow a => a b c -> (c -> d) -> a b d
  type Arrow :: (* -> * -> *) -> Constraint
  class GHC.Internal.Control.Category.Category a => Arrow a where
    arr :: forall b c. (b -> c) -> a b c
    first :: forall b c d. a b c -> a (b, d) (c, d)
    second :: forall b c d. a b c -> a (d, b) (d, c)
    (***) :: forall b c b' c'. a b c -> a b' c' -> a (b, b') (c, c')
    (&&&) :: forall b c c'. a b c -> a b c' -> a b (c, c')
    {-# MINIMAL arr, (first | (***)) #-}
  type ArrowApply :: (* -> * -> *) -> Constraint
  class Arrow a => ArrowApply a where
    app :: forall b c. a (a b c, b) c
    {-# MINIMAL app #-}
  type ArrowChoice :: (* -> * -> *) -> Constraint
  class Arrow a => ArrowChoice a where
    left :: forall b c d. a b c -> a (GHC.Internal.Data.Either.Either b d) (GHC.Internal.Data.Either.Either c d)
    right :: forall b c d. a b c -> a (GHC.Internal.Data.Either.Either d b) (GHC.Internal.Data.Either.Either d c)
    (+++) :: forall b c b' c'. a b c -> a b' c' -> a (GHC.Internal.Data.Either.Either b b') (GHC.Internal.Data.Either.Either c c')
    (|||) :: forall b d c. a b d -> a c d -> a (GHC.Internal.Data.Either.Either b c) d
    {-# MINIMAL (left | (+++)) #-}
  type ArrowLoop :: (* -> * -> *) -> Constraint
  class Arrow a => ArrowLoop a where
    loop :: forall b d c. a (b, d) (c, d) -> a b c
    {-# MINIMAL loop #-}
  type role ArrowMonad representational nominal
  type ArrowMonad :: (* -> * -> *) -> * -> *
  newtype ArrowMonad a b = ArrowMonad (a () b)
  type ArrowPlus :: (* -> * -> *) -> Constraint
  class ArrowZero a => ArrowPlus a where
    (<+>) :: forall b c. a b c -> a b c -> a b c
    {-# MINIMAL (<+>) #-}
  type ArrowZero :: (* -> * -> *) -> Constraint
  class Arrow a => ArrowZero a where
    zeroArrow :: forall b c. a b c
    {-# MINIMAL zeroArrow #-}
  type role Kleisli representational representational nominal
  type Kleisli :: (* -> *) -> * -> * -> *
  newtype Kleisli m a b = Kleisli {runKleisli :: a -> m b}
  (^<<) :: forall (a :: * -> * -> *) c d b. Arrow a => (c -> d) -> a b c -> a b d
  (^>>) :: forall (a :: * -> * -> *) b c d. Arrow a => (b -> c) -> a c d -> a b d
  leftApp :: forall (a :: * -> * -> *) b c d. ArrowApply a => a b c -> a (GHC.Internal.Data.Either.Either b d) (GHC.Internal.Data.Either.Either c d)
  returnA :: forall (a :: * -> * -> *) b. Arrow a => a b b

module Control.Category where
  -- Safety: Safe
  (<<<) :: forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
  (>>>) :: forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
  type Category :: forall {k}. (k -> k -> *) -> Constraint
  class Category cat where
    id :: forall (a :: k). cat a a
    (.) :: forall (b :: k) (c :: k) (a :: k). cat b c -> cat a b -> cat a c
    {-# MINIMAL id, (.) #-}

module Control.Concurrent where
  -- Safety: Trustworthy
  type Chan :: * -> *
  data Chan a = ...
  type MVar :: * -> *
  data MVar a = ...
  type QSem :: *
  newtype QSem = ...
  type QSemN :: *
  data QSemN = ...
  type ThreadId :: *
  data ThreadId = ...
  addMVarFinalizer :: forall a. MVar a -> GHC.Types.IO () -> GHC.Types.IO ()
  dupChan :: forall a. Chan a -> GHC.Types.IO (Chan a)
  forkFinally :: forall a. GHC.Types.IO a -> (GHC.Internal.Data.Either.Either GHC.Internal.Exception.Type.SomeException a -> GHC.Types.IO ()) -> GHC.Types.IO ThreadId
  forkIO :: GHC.Types.IO () -> GHC.Types.IO ThreadId
  forkIOWithUnmask :: ((forall a. GHC.Types.IO a -> GHC.Types.IO a) -> GHC.Types.IO ()) -> GHC.Types.IO ThreadId
  forkOS :: GHC.Types.IO () -> GHC.Types.IO ThreadId
  forkOSWithUnmask :: ((forall a. GHC.Types.IO a -> GHC.Types.IO a) -> GHC.Types.IO ()) -> GHC.Types.IO ThreadId
  forkOn :: GHC.Types.Int -> GHC.Types.IO () -> GHC.Types.IO ThreadId
  forkOnWithUnmask :: GHC.Types.Int -> ((forall a. GHC.Types.IO a -> GHC.Types.IO a) -> GHC.Types.IO ()) -> GHC.Types.IO ThreadId
  getChanContents :: forall a. Chan a -> GHC.Types.IO [a]
  getNumCapabilities :: GHC.Types.IO GHC.Types.Int
  isCurrentThreadBound :: GHC.Types.IO GHC.Types.Bool
  isEmptyMVar :: forall a. MVar a -> GHC.Types.IO GHC.Types.Bool
  killThread :: ThreadId -> GHC.Types.IO ()
  mkWeakMVar :: forall a. MVar a -> GHC.Types.IO () -> GHC.Types.IO (GHC.Internal.Weak.Weak (MVar a))
  mkWeakThreadId :: ThreadId -> GHC.Types.IO (GHC.Internal.Weak.Weak ThreadId)
  modifyMVar :: forall a b. MVar a -> (a -> GHC.Types.IO (a, b)) -> GHC.Types.IO b
  modifyMVarMasked :: forall a b. MVar a -> (a -> GHC.Types.IO (a, b)) -> GHC.Types.IO b
  modifyMVarMasked_ :: forall a. MVar a -> (a -> GHC.Types.IO a) -> GHC.Types.IO ()
  modifyMVar_ :: forall a. MVar a -> (a -> GHC.Types.IO a) -> GHC.Types.IO ()
  myThreadId :: GHC.Types.IO ThreadId
  newChan :: forall a. GHC.Types.IO (Chan a)
  newEmptyMVar :: forall a. GHC.Types.IO (MVar a)
  newMVar :: forall a. a -> GHC.Types.IO (MVar a)
  newQSem :: GHC.Types.Int -> GHC.Types.IO QSem
  newQSemN :: GHC.Types.Int -> GHC.Types.IO QSemN
  putMVar :: forall a. MVar a -> a -> GHC.Types.IO ()
  readChan :: forall a. Chan a -> GHC.Types.IO a
  readMVar :: forall a. MVar a -> GHC.Types.IO a
  rtsSupportsBoundThreads :: GHC.Types.Bool
  runInBoundThread :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  runInUnboundThread :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  setNumCapabilities :: GHC.Types.Int -> GHC.Types.IO ()
  signalQSem :: QSem -> GHC.Types.IO ()
  signalQSemN :: QSemN -> GHC.Types.Int -> GHC.Types.IO ()
  swapMVar :: forall a. MVar a -> a -> GHC.Types.IO a
  takeMVar :: forall a. MVar a -> GHC.Types.IO a
  threadCapability :: ThreadId -> GHC.Types.IO (GHC.Types.Int, GHC.Types.Bool)
  threadDelay :: GHC.Types.Int -> GHC.Types.IO ()
  threadWaitRead :: GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO ()
  threadWaitReadSTM :: GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO (GHC.Internal.Conc.Sync.STM (), GHC.Types.IO ())
  threadWaitWrite :: GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO ()
  threadWaitWriteSTM :: GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO (GHC.Internal.Conc.Sync.STM (), GHC.Types.IO ())
  throwTo :: forall e. GHC.Internal.Exception.Type.Exception e => ThreadId -> e -> GHC.Types.IO ()
  tryPutMVar :: forall a. MVar a -> a -> GHC.Types.IO GHC.Types.Bool
  tryReadMVar :: forall a. MVar a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe a)
  tryTakeMVar :: forall a. MVar a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe a)
  waitQSem :: QSem -> GHC.Types.IO ()
  waitQSemN :: QSemN -> GHC.Types.Int -> GHC.Types.IO ()
  withMVar :: forall a b. MVar a -> (a -> GHC.Types.IO b) -> GHC.Types.IO b
  withMVarMasked :: forall a b. MVar a -> (a -> GHC.Types.IO b) -> GHC.Types.IO b
  writeChan :: forall a. Chan a -> a -> GHC.Types.IO ()
  writeList2Chan :: forall a. Chan a -> [a] -> GHC.Types.IO ()
  yield :: GHC.Types.IO ()

module Control.Concurrent.Chan where
  -- Safety: Trustworthy
  type Chan :: * -> *
  data Chan a = ...
  dupChan :: forall a. Chan a -> GHC.Types.IO (Chan a)
  getChanContents :: forall a. Chan a -> GHC.Types.IO [a]
  newChan :: forall a. GHC.Types.IO (Chan a)
  readChan :: forall a. Chan a -> GHC.Types.IO a
  writeChan :: forall a. Chan a -> a -> GHC.Types.IO ()
  writeList2Chan :: forall a. Chan a -> [a] -> GHC.Types.IO ()

module Control.Concurrent.MVar where
  -- Safety: Safe
  type MVar :: * -> *
  data MVar a = ...
  addMVarFinalizer :: forall a. MVar a -> GHC.Types.IO () -> GHC.Types.IO ()
  isEmptyMVar :: forall a. MVar a -> GHC.Types.IO GHC.Types.Bool
  mkWeakMVar :: forall a. MVar a -> GHC.Types.IO () -> GHC.Types.IO (GHC.Internal.Weak.Weak (MVar a))
  modifyMVar :: forall a b. MVar a -> (a -> GHC.Types.IO (a, b)) -> GHC.Types.IO b
  modifyMVarMasked :: forall a b. MVar a -> (a -> GHC.Types.IO (a, b)) -> GHC.Types.IO b
  modifyMVarMasked_ :: forall a. MVar a -> (a -> GHC.Types.IO a) -> GHC.Types.IO ()
  modifyMVar_ :: forall a. MVar a -> (a -> GHC.Types.IO a) -> GHC.Types.IO ()
  newEmptyMVar :: forall a. GHC.Types.IO (MVar a)
  newMVar :: forall a. a -> GHC.Types.IO (MVar a)
  putMVar :: forall a. MVar a -> a -> GHC.Types.IO ()
  readMVar :: forall a. MVar a -> GHC.Types.IO a
  swapMVar :: forall a. MVar a -> a -> GHC.Types.IO a
  takeMVar :: forall a. MVar a -> GHC.Types.IO a
  tryPutMVar :: forall a. MVar a -> a -> GHC.Types.IO GHC.Types.Bool
  tryReadMVar :: forall a. MVar a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe a)
  tryTakeMVar :: forall a. MVar a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe a)
  withMVar :: forall a b. MVar a -> (a -> GHC.Types.IO b) -> GHC.Types.IO b
  withMVarMasked :: forall a b. MVar a -> (a -> GHC.Types.IO b) -> GHC.Types.IO b

module Control.Concurrent.QSem where
  -- Safety: Safe
  type QSem :: *
  newtype QSem = ...
  newQSem :: GHC.Types.Int -> GHC.Types.IO QSem
  signalQSem :: QSem -> GHC.Types.IO ()
  waitQSem :: QSem -> GHC.Types.IO ()

module Control.Concurrent.QSemN where
  -- Safety: Trustworthy
  type QSemN :: *
  data QSemN = ...
  newQSemN :: GHC.Types.Int -> GHC.Types.IO QSemN
  signalQSemN :: QSemN -> GHC.Types.Int -> GHC.Types.IO ()
  waitQSemN :: QSemN -> GHC.Types.Int -> GHC.Types.IO ()

module Control.Exception where
  -- Safety: Trustworthy
  type AllocationLimitExceeded :: *
  data AllocationLimitExceeded = AllocationLimitExceeded
  type ArithException :: *
  data ArithException = Overflow | Underflow | LossOfPrecision | DivideByZero | Denormal | RatioZeroDenominator
  type ArrayException :: *
  data ArrayException = IndexOutOfBounds GHC.Internal.Base.String | UndefinedElement GHC.Internal.Base.String
  type AssertionFailed :: *
  newtype AssertionFailed = AssertionFailed GHC.Internal.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.Internal.Base.String
  type Deadlock :: *
  data Deadlock = Deadlock
  pattern ErrorCall :: GHC.Internal.Base.String -> ErrorCall
  type ErrorCall :: *
  data ErrorCall = ErrorCallWithLocation GHC.Internal.Base.String GHC.Internal.Base.String
  type Exception :: * -> Constraint
  class (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable e, GHC.Internal.Show.Show e) => Exception e where
    toException :: e -> SomeException
    fromException :: SomeException -> GHC.Internal.Maybe.Maybe e
    displayException :: e -> GHC.Internal.Base.String
    backtraceDesired :: e -> GHC.Types.Bool
    {-# MINIMAL #-}
  type ExceptionWithContext :: * -> *
  data ExceptionWithContext a = ExceptionWithContext GHC.Internal.Exception.Context.ExceptionContext a
  type Handler :: * -> *
  data Handler a = forall e. Exception e => Handler (e -> GHC.Types.IO a)
  type IOException :: *
  data IOException = ...
  type MaskingState :: *
  data MaskingState = Unmasked | MaskedInterruptible | MaskedUninterruptible
  type NestedAtomically :: *
  data NestedAtomically = NestedAtomically
  type NoMethodError :: *
  newtype NoMethodError = NoMethodError GHC.Internal.Base.String
  type NonTermination :: *
  data NonTermination = NonTermination
  type PatternMatchFail :: *
  newtype PatternMatchFail = PatternMatchFail GHC.Internal.Base.String
  type RecConError :: *
  newtype RecConError = RecConError GHC.Internal.Base.String
  type RecSelError :: *
  newtype RecSelError = RecSelError GHC.Internal.Base.String
  type RecUpdError :: *
  newtype RecUpdError = RecUpdError GHC.Internal.Base.String
  type SomeAsyncException :: *
  data SomeAsyncException = forall e. Exception e => SomeAsyncException e
  type SomeException :: *
  data SomeException = forall e. (Exception e, GHC.Internal.Exception.Type.HasExceptionContext) => SomeException e
  type TypeError :: *
  newtype TypeError = TypeError GHC.Internal.Base.String
  addExceptionContext :: forall a. GHC.Internal.Exception.Context.ExceptionAnnotation a => a -> SomeException -> SomeException
  allowInterrupt :: GHC.Types.IO ()
  annotateIO :: forall e a. GHC.Internal.Exception.Context.ExceptionAnnotation e => e -> GHC.Types.IO a -> GHC.Types.IO a
  assert :: forall a. GHC.Types.Bool -> a -> a
  asyncExceptionFromException :: forall e. Exception e => SomeException -> GHC.Internal.Maybe.Maybe e
  asyncExceptionToException :: forall e. Exception e => e -> SomeException
  bracket :: forall a b c. GHC.Types.IO a -> (a -> GHC.Types.IO b) -> (a -> GHC.Types.IO c) -> GHC.Types.IO c
  bracketOnError :: forall a b c. GHC.Types.IO a -> (a -> GHC.Types.IO b) -> (a -> GHC.Types.IO c) -> GHC.Types.IO c
  bracket_ :: forall a b c. GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO c -> GHC.Types.IO c
  catch :: forall e a. Exception e => GHC.Types.IO a -> (e -> GHC.Types.IO a) -> GHC.Types.IO a
  catchJust :: forall e b a. Exception e => (e -> GHC.Internal.Maybe.Maybe b) -> GHC.Types.IO a -> (b -> GHC.Types.IO a) -> GHC.Types.IO a
  catches :: forall a. GHC.Types.IO a -> [Handler a] -> GHC.Types.IO a
  evaluate :: forall a. a -> GHC.Types.IO a
  finally :: forall a b. GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO a
  getMaskingState :: GHC.Types.IO MaskingState
  handle :: forall e a. Exception e => (e -> GHC.Types.IO a) -> GHC.Types.IO a -> GHC.Types.IO a
  handleJust :: forall e b a. Exception e => (e -> GHC.Internal.Maybe.Maybe b) -> (b -> GHC.Types.IO a) -> GHC.Types.IO a -> GHC.Types.IO a
  interruptible :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  ioError :: forall a. GHC.Internal.IO.Exception.IOError -> GHC.Types.IO a
  mapException :: forall e1 e2 a. (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
  mask :: forall b. ((forall a. GHC.Types.IO a -> GHC.Types.IO a) -> GHC.Types.IO b) -> GHC.Types.IO b
  mask_ :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  onException :: forall a b. GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO a
  someExceptionContext :: SomeException -> GHC.Internal.Exception.Context.ExceptionContext
  throw :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r) e. (GHC.Internal.Stack.Types.HasCallStack, Exception e) => e -> a
  throwIO :: forall e a. (GHC.Internal.Stack.Types.HasCallStack, Exception e) => e -> GHC.Types.IO a
  throwTo :: forall e. Exception e => GHC.Internal.Conc.Sync.ThreadId -> e -> GHC.Types.IO ()
  try :: forall e a. Exception e => GHC.Types.IO a -> GHC.Types.IO (GHC.Internal.Data.Either.Either e a)
  tryJust :: forall e b a. Exception e => (e -> GHC.Internal.Maybe.Maybe b) -> GHC.Types.IO a -> GHC.Types.IO (GHC.Internal.Data.Either.Either b a)
  uninterruptibleMask :: forall b. ((forall a. GHC.Types.IO a -> GHC.Types.IO a) -> GHC.Types.IO b) -> GHC.Types.IO b
  uninterruptibleMask_ :: forall a. GHC.Types.IO a -> GHC.Types.IO a

module Control.Exception.Annotation where
  -- Safety: None
  type ExceptionAnnotation :: * -> Constraint
  class ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a => ExceptionAnnotation a where
    displayExceptionAnnotation :: a -> GHC.Internal.Base.String
    default displayExceptionAnnotation :: GHC.Internal.Show.Show a => a -> GHC.Internal.Base.String
    {-# MINIMAL #-}
  type SomeExceptionAnnotation :: *
  data SomeExceptionAnnotation = forall a. ExceptionAnnotation a => SomeExceptionAnnotation a

module Control.Exception.Backtrace where
  -- Safety: None
  type BacktraceMechanism :: *
  data BacktraceMechanism = CostCentreBacktrace | HasCallStackBacktrace | ExecutionBacktrace | IPEBacktrace
  type Backtraces :: *
  data Backtraces = ...
  collectBacktraces :: (?callStack::GHC.Internal.Stack.Types.CallStack) => GHC.Types.IO Backtraces
  displayBacktraces :: Backtraces -> GHC.Internal.Base.String
  getBacktraceMechanismState :: BacktraceMechanism -> GHC.Types.IO GHC.Types.Bool
  setBacktraceMechanismState :: BacktraceMechanism -> GHC.Types.Bool -> GHC.Types.IO ()

module Control.Exception.Base where
  -- Safety: Safe
  type AllocationLimitExceeded :: *
  data AllocationLimitExceeded = AllocationLimitExceeded
  type ArithException :: *
  data ArithException = Overflow | Underflow | LossOfPrecision | DivideByZero | Denormal | RatioZeroDenominator
  type ArrayException :: *
  data ArrayException = IndexOutOfBounds GHC.Internal.Base.String | UndefinedElement GHC.Internal.Base.String
  type AssertionFailed :: *
  newtype AssertionFailed = AssertionFailed GHC.Internal.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.Internal.Base.String
  type Deadlock :: *
  data Deadlock = Deadlock
  pattern ErrorCall :: GHC.Internal.Base.String -> ErrorCall
  type ErrorCall :: *
  data ErrorCall = ErrorCallWithLocation GHC.Internal.Base.String GHC.Internal.Base.String
  type Exception :: * -> Constraint
  class (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable e, GHC.Internal.Show.Show e) => Exception e where
    toException :: e -> SomeException
    fromException :: SomeException -> GHC.Internal.Maybe.Maybe e
    displayException :: e -> GHC.Internal.Base.String
    backtraceDesired :: e -> GHC.Types.Bool
    {-# MINIMAL #-}
  type FixIOException :: *
  data FixIOException = FixIOException
  type IOException :: *
  data IOException = ...
  type MaskingState :: *
  data MaskingState = Unmasked | MaskedInterruptible | MaskedUninterruptible
  type NestedAtomically :: *
  data NestedAtomically = NestedAtomically
  type NoMatchingContinuationPrompt :: *
  data NoMatchingContinuationPrompt = NoMatchingContinuationPrompt
  type NoMethodError :: *
  newtype NoMethodError = NoMethodError GHC.Internal.Base.String
  type NonTermination :: *
  data NonTermination = NonTermination
  type PatternMatchFail :: *
  newtype PatternMatchFail = PatternMatchFail GHC.Internal.Base.String
  type RecConError :: *
  newtype RecConError = RecConError GHC.Internal.Base.String
  type RecSelError :: *
  newtype RecSelError = RecSelError GHC.Internal.Base.String
  type RecUpdError :: *
  newtype RecUpdError = RecUpdError GHC.Internal.Base.String
  type SomeAsyncException :: *
  data SomeAsyncException = forall e. Exception e => SomeAsyncException e
  type SomeException :: *
  data SomeException = forall e. (Exception e, GHC.Internal.Exception.Type.HasExceptionContext) => SomeException e
  type TypeError :: *
  newtype TypeError = TypeError GHC.Internal.Base.String
  assert :: forall a. GHC.Types.Bool -> a -> a
  asyncExceptionFromException :: forall e. Exception e => SomeException -> GHC.Internal.Maybe.Maybe e
  asyncExceptionToException :: forall e. Exception e => e -> SomeException
  bracket :: forall a b c. GHC.Types.IO a -> (a -> GHC.Types.IO b) -> (a -> GHC.Types.IO c) -> GHC.Types.IO c
  bracketOnError :: forall a b c. GHC.Types.IO a -> (a -> GHC.Types.IO b) -> (a -> GHC.Types.IO c) -> GHC.Types.IO c
  bracket_ :: forall a b c. GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO c -> GHC.Types.IO c
  catch :: forall e a. Exception e => GHC.Types.IO a -> (e -> GHC.Types.IO a) -> GHC.Types.IO a
  catchJust :: forall e b a. Exception e => (e -> GHC.Internal.Maybe.Maybe b) -> GHC.Types.IO a -> (b -> GHC.Types.IO a) -> GHC.Types.IO a
  evaluate :: forall a. a -> GHC.Types.IO a
  finally :: forall a b. GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO a
  getMaskingState :: GHC.Types.IO MaskingState
  handle :: forall e a. Exception e => (e -> GHC.Types.IO a) -> GHC.Types.IO a -> GHC.Types.IO a
  handleJust :: forall e b a. Exception e => (e -> GHC.Internal.Maybe.Maybe b) -> (b -> GHC.Types.IO a) -> GHC.Types.IO a -> GHC.Types.IO a
  impossibleConstraintError :: forall (q :: GHC.Types.RuntimeRep) (a :: GHC.Prim.CONSTRAINT q). GHC.Prim.Addr# -=> a
  impossibleError :: forall (q :: GHC.Types.RuntimeRep) (a :: TYPE q). GHC.Prim.Addr# -> a
  ioError :: forall a. GHC.Internal.IO.Exception.IOError -> GHC.Types.IO a
  mapException :: forall e1 e2 a. (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
  mask :: forall b. ((forall a. GHC.Types.IO a -> GHC.Types.IO a) -> GHC.Types.IO b) -> GHC.Types.IO b
  mask_ :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  nestedAtomically :: SomeException
  noMatchingContinuationPrompt :: SomeException
  noMethodBindingError :: forall (q :: GHC.Types.RuntimeRep) (a :: TYPE q). GHC.Prim.Addr# -> a
  nonExhaustiveGuardsError :: forall (q :: GHC.Types.RuntimeRep) (a :: TYPE q). GHC.Prim.Addr# -> a
  nonTermination :: SomeException
  onException :: forall a b. GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO a
  patError :: forall (q :: GHC.Types.RuntimeRep) (a :: TYPE q). GHC.Prim.Addr# -> a
  recConError :: forall (q :: GHC.Types.RuntimeRep) (a :: TYPE q). GHC.Prim.Addr# -> a
  recSelError :: forall (q :: GHC.Types.RuntimeRep) (a :: TYPE q). GHC.Prim.Addr# -> a
  throw :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r) e. (GHC.Internal.Stack.Types.HasCallStack, Exception e) => e -> a
  throwIO :: forall e a. (GHC.Internal.Stack.Types.HasCallStack, Exception e) => e -> GHC.Types.IO a
  throwTo :: forall e. Exception e => GHC.Internal.Conc.Sync.ThreadId -> e -> GHC.Types.IO ()
  try :: forall e a. Exception e => GHC.Types.IO a -> GHC.Types.IO (GHC.Internal.Data.Either.Either e a)
  tryJust :: forall e b a. Exception e => (e -> GHC.Internal.Maybe.Maybe b) -> GHC.Types.IO a -> GHC.Types.IO (GHC.Internal.Data.Either.Either b a)
  typeError :: forall (q :: GHC.Types.RuntimeRep) (a :: TYPE q). GHC.Prim.Addr# -> a
  uninterruptibleMask :: forall b. ((forall a. GHC.Types.IO a -> GHC.Types.IO a) -> GHC.Types.IO b) -> GHC.Types.IO b
  uninterruptibleMask_ :: forall a. GHC.Types.IO a -> GHC.Types.IO a

module Control.Exception.Context where
  -- Safety: None
  type ExceptionContext :: *
  data ExceptionContext = ExceptionContext [GHC.Internal.Exception.Context.SomeExceptionAnnotation]
  addExceptionAnnotation :: forall a. GHC.Internal.Exception.Context.ExceptionAnnotation a => a -> ExceptionContext -> ExceptionContext
  displayExceptionContext :: ExceptionContext -> GHC.Internal.Base.String
  emptyExceptionContext :: ExceptionContext
  getAllExceptionAnnotations :: ExceptionContext -> [GHC.Internal.Exception.Context.SomeExceptionAnnotation]
  getExceptionAnnotations :: forall a. GHC.Internal.Exception.Context.ExceptionAnnotation a => ExceptionContext -> [a]

module Control.Monad where
  -- Safety: Safe
  (<$!>) :: forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
  (<=<) :: forall (m :: * -> *) b c a. Monad m => (b -> m c) -> (a -> m b) -> a -> m c
  (=<<) :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
  (>=>) :: forall (m :: * -> *) a b c. Monad m => (a -> m b) -> (b -> m c) -> a -> m c
  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 Monad :: (* -> *) -> Constraint
  class GHC.Internal.Base.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. GHC.Internal.Base.String -> m a
    {-# MINIMAL fail #-}
  type MonadPlus :: (* -> *) -> Constraint
  class (GHC.Internal.Base.Alternative m, Monad m) => MonadPlus m where
    mzero :: forall a. m a
    mplus :: forall a. m a -> m a -> m a
    {-# MINIMAL #-}
  ap :: forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
  filterM :: forall (m :: * -> *) a. GHC.Internal.Base.Applicative m => (a -> m GHC.Types.Bool) -> [a] -> m [a]
  foldM :: forall (t :: * -> *) (m :: * -> *) b a. (GHC.Internal.Data.Foldable.Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
  foldM_ :: forall (t :: * -> *) (m :: * -> *) b a. (GHC.Internal.Data.Foldable.Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
  forM :: forall (t :: * -> *) (m :: * -> *) a b. (GHC.Internal.Data.Traversable.Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
  forM_ :: forall (t :: * -> *) (m :: * -> *) a b. (GHC.Internal.Data.Foldable.Foldable t, Monad m) => t a -> (a -> m b) -> m ()
  forever :: forall (f :: * -> *) a b. GHC.Internal.Base.Applicative f => f a -> f b
  guard :: forall (f :: * -> *). GHC.Internal.Base.Alternative f => GHC.Types.Bool -> f ()
  join :: forall (m :: * -> *) a. Monad m => m (m a) -> m a
  liftM :: forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
  liftM2 :: forall (m :: * -> *) a1 a2 r. Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
  liftM3 :: forall (m :: * -> *) a1 a2 a3 r. Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
  liftM4 :: forall (m :: * -> *) a1 a2 a3 a4 r. Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
  liftM5 :: forall (m :: * -> *) a1 a2 a3 a4 a5 r. Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
  mapAndUnzipM :: forall (m :: * -> *) a b c. GHC.Internal.Base.Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
  mapM :: forall (t :: * -> *) (m :: * -> *) a b. (GHC.Internal.Data.Traversable.Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
  mapM_ :: forall (t :: * -> *) (m :: * -> *) a b. (GHC.Internal.Data.Foldable.Foldable t, Monad m) => (a -> m b) -> t a -> m ()
  mfilter :: forall (m :: * -> *) a. MonadPlus m => (a -> GHC.Types.Bool) -> m a -> m a
  msum :: forall (t :: * -> *) (m :: * -> *) a. (GHC.Internal.Data.Foldable.Foldable t, MonadPlus m) => t (m a) -> m a
  replicateM :: forall (m :: * -> *) a. GHC.Internal.Base.Applicative m => GHC.Types.Int -> m a -> m [a]
  replicateM_ :: forall (m :: * -> *) a. GHC.Internal.Base.Applicative m => GHC.Types.Int -> m a -> m ()
  sequence :: forall (t :: * -> *) (m :: * -> *) a. (GHC.Internal.Data.Traversable.Traversable t, Monad m) => t (m a) -> m (t a)
  sequence_ :: forall (t :: * -> *) (m :: * -> *) a. (GHC.Internal.Data.Foldable.Foldable t, Monad m) => t (m a) -> m ()
  unless :: forall (f :: * -> *). GHC.Internal.Base.Applicative f => GHC.Types.Bool -> f () -> f ()
  void :: forall (f :: * -> *) a. Functor f => f a -> f ()
  when :: forall (f :: * -> *). GHC.Internal.Base.Applicative f => GHC.Types.Bool -> f () -> f ()
  zipWithM :: forall (m :: * -> *) a b c. GHC.Internal.Base.Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
  zipWithM_ :: forall (m :: * -> *) a b c. GHC.Internal.Base.Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()

module Control.Monad.Fail where
  -- Safety: Safe
  type MonadFail :: (* -> *) -> Constraint
  class GHC.Internal.Base.Monad m => MonadFail m where
    fail :: forall a. GHC.Internal.Base.String -> m a
    {-# MINIMAL fail #-}

module Control.Monad.Fix where
  -- Safety: Safe
  type MonadFix :: (* -> *) -> Constraint
  class GHC.Internal.Base.Monad m => MonadFix m where
    mfix :: forall a. (a -> m a) -> m a
    {-# MINIMAL mfix #-}
  fix :: forall a. (a -> a) -> a

module Control.Monad.IO.Class where
  -- Safety: Trustworthy
  type MonadIO :: (* -> *) -> Constraint
  class GHC.Internal.Base.Monad m => MonadIO m where
    liftIO :: forall a. GHC.Types.IO a -> m a
    {-# MINIMAL liftIO #-}

module Control.Monad.Instances where
  -- Safety: Trustworthy
  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 Monad :: (* -> *) -> Constraint
  class GHC.Internal.Base.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 (>>=) #-}

module Control.Monad.ST where
  -- Safety: Safe
  type RealWorld :: *
  data RealWorld
  type role ST nominal representational
  type ST :: * -> * -> *
  newtype ST s a = ...
  fixST :: forall a s. (a -> ST s a) -> ST s a
  runST :: forall a. (forall s. ST s a) -> a
  stToIO :: forall a. ST RealWorld a -> GHC.Types.IO a

module Control.Monad.ST.Lazy where
  -- Safety: Safe
  type RealWorld :: *
  data RealWorld
  type role ST nominal representational
  type ST :: * -> * -> *
  newtype ST s a = ...
  fixST :: forall a s. (a -> ST s a) -> ST s a
  lazyToStrictST :: forall s a. ST s a -> GHC.Internal.ST.ST s a
  runST :: forall a. (forall s. ST s a) -> a
  stToIO :: forall a. ST RealWorld a -> GHC.Types.IO a
  strictToLazyST :: forall s a. GHC.Internal.ST.ST s a -> ST s a

module Control.Monad.ST.Lazy.Safe where
  -- Safety: Trustworthy
  type RealWorld :: *
  data RealWorld
  type role ST nominal representational
  type ST :: * -> * -> *
  newtype ST s a = ...
  fixST :: forall a s. (a -> ST s a) -> ST s a
  lazyToStrictST :: forall s a. ST s a -> GHC.Internal.ST.ST s a
  runST :: forall a. (forall s. ST s a) -> a
  stToIO :: forall a. ST RealWorld a -> GHC.Types.IO a
  strictToLazyST :: forall s a. GHC.Internal.ST.ST s a -> ST s a

module Control.Monad.ST.Lazy.Unsafe where
  -- Safety: Unsafe
  unsafeIOToST :: forall a s. GHC.Types.IO a -> GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s a
  unsafeInterleaveST :: forall s a. GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s a -> GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s a

module Control.Monad.ST.Safe where
  -- Safety: Trustworthy
  type RealWorld :: *
  data RealWorld
  type role ST nominal representational
  type ST :: * -> * -> *
  newtype ST s a = ...
  fixST :: forall a s. (a -> ST s a) -> ST s a
  runST :: forall a. (forall s. ST s a) -> a
  stToIO :: forall a. ST RealWorld a -> GHC.Types.IO a

module Control.Monad.ST.Strict where
  -- Safety: Safe
  type RealWorld :: *
  data RealWorld
  type role ST nominal representational
  type ST :: * -> * -> *
  newtype ST s a = ...
  fixST :: forall a s. (a -> ST s a) -> ST s a
  runST :: forall a. (forall s. ST s a) -> a
  stToIO :: forall a. ST RealWorld a -> GHC.Types.IO a

module Control.Monad.ST.Unsafe where
  -- Safety: Unsafe
  unsafeDupableInterleaveST :: forall s a. GHC.Internal.ST.ST s a -> GHC.Internal.ST.ST s a
  unsafeIOToST :: forall a s. GHC.Types.IO a -> GHC.Internal.ST.ST s a
  unsafeInterleaveST :: forall s a. GHC.Internal.ST.ST s a -> GHC.Internal.ST.ST s a
  unsafeSTToIO :: forall s a. GHC.Internal.ST.ST s a -> GHC.Types.IO a

module Control.Monad.Zip where
  -- Safety: Safe
  type MonadZip :: (* -> *) -> Constraint
  class GHC.Internal.Base.Monad m => MonadZip m where
    mzip :: forall a b. m a -> m b -> m (a, b)
    mzipWith :: forall a b c. (a -> b -> c) -> m a -> m b -> m c
    munzip :: forall a b. m (a, b) -> (m a, m b)
    {-# MINIMAL mzip | mzipWith #-}

module Data.Array.Byte where
  -- Safety: Trustworthy
  type ByteArray :: *
  data ByteArray = ByteArray GHC.Prim.ByteArray#
  type role MutableByteArray nominal
  type MutableByteArray :: * -> *
  data MutableByteArray s = MutableByteArray (GHC.Prim.MutableByteArray# s)

module Data.Bifoldable where
  -- Safety: Safe
  type Bifoldable :: (* -> * -> *) -> Constraint
  class Bifoldable p where
    bifold :: forall m. GHC.Internal.Base.Monoid m => p m m -> m
    bifoldMap :: forall m a b. GHC.Internal.Base.Monoid m => (a -> m) -> (b -> m) -> p a b -> m
    bifoldr :: forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldl :: forall c a b. (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c
    {-# MINIMAL bifoldr | bifoldMap #-}
  biList :: forall (t :: * -> * -> *) a. Bifoldable t => t a a -> [a]
  biall :: forall (t :: * -> * -> *) a b. Bifoldable t => (a -> GHC.Types.Bool) -> (b -> GHC.Types.Bool) -> t a b -> GHC.Types.Bool
  biand :: forall (t :: * -> * -> *). Bifoldable t => t GHC.Types.Bool GHC.Types.Bool -> GHC.Types.Bool
  biany :: forall (t :: * -> * -> *) a b. Bifoldable t => (a -> GHC.Types.Bool) -> (b -> GHC.Types.Bool) -> t a b -> GHC.Types.Bool
  biasum :: forall (t :: * -> * -> *) (f :: * -> *) a. (Bifoldable t, GHC.Internal.Base.Alternative f) => t (f a) (f a) -> f a
  biconcat :: forall (t :: * -> * -> *) a. Bifoldable t => t [a] [a] -> [a]
  biconcatMap :: forall (t :: * -> * -> *) a c b. Bifoldable t => (a -> [c]) -> (b -> [c]) -> t a b -> [c]
  bielem :: forall (t :: * -> * -> *) a. (Bifoldable t, GHC.Classes.Eq a) => a -> t a a -> GHC.Types.Bool
  bifind :: forall (t :: * -> * -> *) a. Bifoldable t => (a -> GHC.Types.Bool) -> t a a -> GHC.Internal.Maybe.Maybe a
  bifoldl' :: forall (t :: * -> * -> *) a b c. Bifoldable t => (a -> b -> a) -> (a -> c -> a) -> a -> t b c -> a
  bifoldl1 :: forall (t :: * -> * -> *) a. Bifoldable t => (a -> a -> a) -> t a a -> a
  bifoldlM :: forall (t :: * -> * -> *) (m :: * -> *) a b c. (Bifoldable t, GHC.Internal.Base.Monad m) => (a -> b -> m a) -> (a -> c -> m a) -> a -> t b c -> m a
  bifoldr' :: forall (t :: * -> * -> *) a c b. Bifoldable t => (a -> c -> c) -> (b -> c -> c) -> c -> t a b -> c
  bifoldr1 :: forall (t :: * -> * -> *) a. Bifoldable t => (a -> a -> a) -> t a a -> a
  bifoldrM :: forall (t :: * -> * -> *) (m :: * -> *) a c b. (Bifoldable t, GHC.Internal.Base.Monad m) => (a -> c -> m c) -> (b -> c -> m c) -> c -> t a b -> m c
  biforM_ :: forall (t :: * -> * -> *) (f :: * -> *) a b c d. (Bifoldable t, GHC.Internal.Base.Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f ()
  bifor_ :: forall (t :: * -> * -> *) (f :: * -> *) a b c d. (Bifoldable t, GHC.Internal.Base.Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f ()
  bilength :: forall (t :: * -> * -> *) a b. Bifoldable t => t a b -> GHC.Types.Int
  bimapM_ :: forall (t :: * -> * -> *) (f :: * -> *) a c b d. (Bifoldable t, GHC.Internal.Base.Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()
  bimaximum :: forall (t :: * -> * -> *) a. (Bifoldable t, GHC.Classes.Ord a) => t a a -> a
  bimaximumBy :: forall (t :: * -> * -> *) a. Bifoldable t => (a -> a -> GHC.Types.Ordering) -> t a a -> a
  biminimum :: forall (t :: * -> * -> *) a. (Bifoldable t, GHC.Classes.Ord a) => t a a -> a
  biminimumBy :: forall (t :: * -> * -> *) a. Bifoldable t => (a -> a -> GHC.Types.Ordering) -> t a a -> a
  bimsum :: forall (t :: * -> * -> *) (f :: * -> *) a. (Bifoldable t, GHC.Internal.Base.Alternative f) => t (f a) (f a) -> f a
  binotElem :: forall (t :: * -> * -> *) a. (Bifoldable t, GHC.Classes.Eq a) => a -> t a a -> GHC.Types.Bool
  binull :: forall (t :: * -> * -> *) a b. Bifoldable t => t a b -> GHC.Types.Bool
  bior :: forall (t :: * -> * -> *). Bifoldable t => t GHC.Types.Bool GHC.Types.Bool -> GHC.Types.Bool
  biproduct :: forall (t :: * -> * -> *) a. (Bifoldable t, GHC.Internal.Num.Num a) => t a a -> a
  bisequenceA_ :: forall (t :: * -> * -> *) (f :: * -> *) a b. (Bifoldable t, GHC.Internal.Base.Applicative f) => t (f a) (f b) -> f ()
  bisequence_ :: forall (t :: * -> * -> *) (f :: * -> *) a b. (Bifoldable t, GHC.Internal.Base.Applicative f) => t (f a) (f b) -> f ()
  bisum :: forall (t :: * -> * -> *) a. (Bifoldable t, GHC.Internal.Num.Num a) => t a a -> a
  bitraverse_ :: forall (t :: * -> * -> *) (f :: * -> *) a c b d. (Bifoldable t, GHC.Internal.Base.Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()

module Data.Bifoldable1 where
  -- Safety: Safe
  type Bifoldable1 :: (* -> * -> *) -> Constraint
  class Data.Bifoldable.Bifoldable t => Bifoldable1 t where
    bifold1 :: forall m. GHC.Internal.Base.Semigroup m => t m m -> m
    bifoldMap1 :: forall m a b. GHC.Internal.Base.Semigroup m => (a -> m) -> (b -> m) -> t a b -> m
    {-# MINIMAL bifoldMap1 #-}

module Data.Bifunctor where
  -- Safety: Safe
  type Bifunctor :: (* -> * -> *) -> Constraint
  class (forall a. GHC.Internal.Base.Functor (p a)) => Bifunctor p where
    bimap :: forall a b c d. (a -> b) -> (c -> d) -> p a c -> p b d
    first :: forall a b c. (a -> b) -> p a c -> p b c
    second :: forall b c a. (b -> c) -> p a b -> p a c
    {-# MINIMAL bimap | first, second #-}

module Data.Bitraversable where
  -- Safety: Trustworthy
  type Bitraversable :: (* -> * -> *) -> Constraint
  class (Data.Bifunctor.Bifunctor t, Data.Bifoldable.Bifoldable t) => Bitraversable t where
    bitraverse :: forall (f :: * -> *) a c b d. GHC.Internal.Base.Applicative f => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    {-# MINIMAL bitraverse #-}
  bifoldMapDefault :: forall (t :: * -> * -> *) m a b. (Bitraversable t, GHC.Internal.Base.Monoid m) => (a -> m) -> (b -> m) -> t a b -> m
  bifor :: forall (t :: * -> * -> *) (f :: * -> *) a b c d. (Bitraversable t, GHC.Internal.Base.Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d)
  biforM :: forall (t :: * -> * -> *) (f :: * -> *) a b c d. (Bitraversable t, GHC.Internal.Base.Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d)
  bimapAccumL :: forall (t :: * -> * -> *) a b c d e. Bitraversable t => (a -> b -> (a, c)) -> (a -> d -> (a, e)) -> a -> t b d -> (a, t c e)
  bimapAccumR :: forall (t :: * -> * -> *) a b c d e. Bitraversable t => (a -> b -> (a, c)) -> (a -> d -> (a, e)) -> a -> t b d -> (a, t c e)
  bimapDefault :: forall (t :: * -> * -> *) a b c d. Bitraversable t => (a -> b) -> (c -> d) -> t a c -> t b d
  bimapM :: forall (t :: * -> * -> *) (f :: * -> *) a c b d. (Bitraversable t, GHC.Internal.Base.Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
  bisequence :: forall (t :: * -> * -> *) (f :: * -> *) a b. (Bitraversable t, GHC.Internal.Base.Applicative f) => t (f a) (f b) -> f (t a b)
  bisequenceA :: forall (t :: * -> * -> *) (f :: * -> *) a b. (Bitraversable t, GHC.Internal.Base.Applicative f) => t (f a) (f b) -> f (t a b)
  firstA :: forall (t :: * -> * -> *) (f :: * -> *) a c b. (Bitraversable t, GHC.Internal.Base.Applicative f) => (a -> f c) -> t a b -> f (t c b)
  secondA :: forall (t :: * -> * -> *) (f :: * -> *) b c a. (Bitraversable t, GHC.Internal.Base.Applicative f) => (b -> f c) -> t a b -> f (t a c)

module Data.Bits where
  -- Safety: Safe
  (!<<.) :: forall a. Bits a => a -> GHC.Types.Int -> a
  (!>>.) :: forall a. Bits a => a -> GHC.Types.Int -> a
  (.<<.) :: forall a. Bits a => a -> GHC.Types.Int -> a
  (.>>.) :: forall a. Bits a => a -> GHC.Types.Int -> a
  (.^.) :: forall a. Bits a => a -> a -> a
  type And :: * -> *
  newtype And a = And {getAnd :: a}
  type Bits :: * -> Constraint
  class GHC.Classes.Eq a => Bits a where
    (.&.) :: a -> a -> a
    (.|.) :: a -> a -> a
    xor :: a -> a -> a
    complement :: a -> a
    shift :: a -> GHC.Types.Int -> a
    rotate :: a -> GHC.Types.Int -> a
    zeroBits :: a
    bit :: GHC.Types.Int -> a
    setBit :: a -> GHC.Types.Int -> a
    clearBit :: a -> GHC.Types.Int -> a
    complementBit :: a -> GHC.Types.Int -> a
    testBit :: a -> GHC.Types.Int -> GHC.Types.Bool
    bitSizeMaybe :: a -> GHC.Internal.Maybe.Maybe GHC.Types.Int
    bitSize :: a -> GHC.Types.Int
    isSigned :: a -> GHC.Types.Bool
    shiftL :: a -> GHC.Types.Int -> a
    unsafeShiftL :: a -> GHC.Types.Int -> a
    shiftR :: a -> GHC.Types.Int -> a
    unsafeShiftR :: a -> GHC.Types.Int -> a
    rotateL :: a -> GHC.Types.Int -> a
    rotateR :: a -> GHC.Types.Int -> a
    popCount :: a -> GHC.Types.Int
    {-# MINIMAL (.&.), (.|.), xor, complement, (shift | (shiftL, shiftR)), (rotate | (rotateL, rotateR)), bitSize, bitSizeMaybe, isSigned, testBit, bit, popCount #-}
  type FiniteBits :: * -> Constraint
  class Bits b => FiniteBits b where
    finiteBitSize :: b -> GHC.Types.Int
    countLeadingZeros :: b -> GHC.Types.Int
    countTrailingZeros :: b -> GHC.Types.Int
    {-# MINIMAL finiteBitSize #-}
  type Iff :: * -> *
  newtype Iff a = Iff {getIff :: a}
  type Ior :: * -> *
  newtype Ior a = Ior {getIor :: a}
  type Xor :: * -> *
  newtype Xor a = Xor {getXor :: a}
  bitDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => GHC.Types.Int -> a
  oneBits :: forall a. FiniteBits a => a
  popCountDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => a -> GHC.Types.Int
  testBitDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => a -> GHC.Types.Int -> GHC.Types.Bool
  toIntegralSized :: forall a b. (GHC.Internal.Real.Integral a, GHC.Internal.Real.Integral b, Bits a, Bits b) => a -> GHC.Internal.Maybe.Maybe b

module Data.Bool where
  -- Safety: Safe
  (&&) :: Bool -> Bool -> Bool
  type Bool :: *
  data Bool = False | True
  bool :: forall a. a -> a -> Bool -> a
  not :: Bool -> Bool
  otherwise :: Bool
  (||) :: Bool -> Bool -> Bool

module Data.Char where
  -- Safety: Trustworthy
  type Char :: *
  data Char = ...
  type GeneralCategory :: *
  data GeneralCategory = UppercaseLetter | LowercaseLetter | TitlecaseLetter | ModifierLetter | OtherLetter | NonSpacingMark | SpacingCombiningMark | EnclosingMark | DecimalNumber | LetterNumber | OtherNumber | ConnectorPunctuation | DashPunctuation | OpenPunctuation | ClosePunctuation | InitialQuote | FinalQuote | OtherPunctuation | MathSymbol | CurrencySymbol | ModifierSymbol | OtherSymbol | Space | LineSeparator | ParagraphSeparator | Control | Format | Surrogate | PrivateUse | NotAssigned
  chr :: GHC.Types.Int -> Char
  digitToInt :: Char -> GHC.Types.Int
  generalCategory :: Char -> GeneralCategory
  intToDigit :: GHC.Types.Int -> Char
  isAlpha :: Char -> GHC.Types.Bool
  isAlphaNum :: Char -> GHC.Types.Bool
  isAscii :: Char -> GHC.Types.Bool
  isAsciiLower :: Char -> GHC.Types.Bool
  isAsciiUpper :: Char -> GHC.Types.Bool
  isControl :: Char -> GHC.Types.Bool
  isDigit :: Char -> GHC.Types.Bool
  isHexDigit :: Char -> GHC.Types.Bool
  isLatin1 :: Char -> GHC.Types.Bool
  isLetter :: Char -> GHC.Types.Bool
  isLower :: Char -> GHC.Types.Bool
  isLowerCase :: Char -> GHC.Types.Bool
  isMark :: Char -> GHC.Types.Bool
  isNumber :: Char -> GHC.Types.Bool
  isOctDigit :: Char -> GHC.Types.Bool
  isPrint :: Char -> GHC.Types.Bool
  isPunctuation :: Char -> GHC.Types.Bool
  isSeparator :: Char -> GHC.Types.Bool
  isSpace :: Char -> GHC.Types.Bool
  isSymbol :: Char -> GHC.Types.Bool
  isUpper :: Char -> GHC.Types.Bool
  isUpperCase :: Char -> GHC.Types.Bool
  lexLitChar :: GHC.Internal.Text.ParserCombinators.ReadP.ReadS GHC.Internal.Base.String
  ord :: Char -> GHC.Types.Int
  readLitChar :: GHC.Internal.Text.ParserCombinators.ReadP.ReadS Char
  showLitChar :: Char -> GHC.Internal.Show.ShowS
  toLower :: Char -> Char
  toTitle :: Char -> Char
  toUpper :: Char -> Char

module Data.Coerce where
  -- Safety: None
  type role Coercible representational representational
  type Coercible :: forall k. k -> k -> Constraint
  class Coercible a b => Coercible a b
    {-# MINIMAL #-}
  coerce :: forall {k :: GHC.Types.RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b

module Data.Complex where
  -- Safety: Trustworthy
  type Complex :: * -> *
  data Complex a = !a :+ !a
  cis :: forall a. GHC.Internal.Float.Floating a => a -> Complex a
  conjugate :: forall a. GHC.Internal.Num.Num a => Complex a -> Complex a
  imagPart :: forall a. Complex a -> a
  magnitude :: forall a. GHC.Internal.Float.RealFloat a => Complex a -> a
  mkPolar :: forall a. GHC.Internal.Float.Floating a => a -> a -> Complex a
  phase :: forall a. GHC.Internal.Float.RealFloat a => Complex a -> a
  polar :: forall a. GHC.Internal.Float.RealFloat a => Complex a -> (a, a)
  realPart :: forall a. Complex a -> a

module Data.Data 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
  type ConIndex :: *
  type ConIndex = GHC.Types.Int
  type Constr :: *
  data Constr = ...
  type ConstrRep :: *
  data ConstrRep = AlgConstr ConIndex | IntConstr GHC.Num.Integer.Integer | FloatConstr GHC.Internal.Real.Rational | CharConstr GHC.Types.Char
  type Data :: * -> Constraint
  class Typeable a => Data a where
    gfoldl :: forall (c :: * -> *). (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> a -> c a
    gunfold :: forall (c :: * -> *). (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c a
    toConstr :: a -> Constr
    dataTypeOf :: a -> DataType
    dataCast1 :: forall (t :: * -> *) (c :: * -> *). Typeable t => (forall d. Data d => c (t d)) -> GHC.Internal.Maybe.Maybe (c a)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *). Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> GHC.Internal.Maybe.Maybe (c a)
    gmapT :: (forall b. Data b => b -> b) -> a -> a
    gmapQl :: forall r r'. (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
    gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
    gmapQ :: forall u. (forall d. Data d => d -> u) -> a -> [u]
    gmapQi :: forall u. GHC.Types.Int -> (forall d. Data d => d -> u) -> a -> u
    gmapM :: forall (m :: * -> *). GHC.Internal.Base.Monad m => (forall d. Data d => d -> m d) -> a -> m a
    gmapMp :: forall (m :: * -> *). GHC.Internal.Base.MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
    gmapMo :: forall (m :: * -> *). GHC.Internal.Base.MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
    {-# MINIMAL gunfold, toConstr, dataTypeOf #-}
  type DataRep :: *
  data DataRep = AlgRep [Constr] | IntRep | FloatRep | CharRep | NoRep
  type DataType :: *
  data DataType = ...
  type Fixity :: *
  data Fixity = Prefix | Infix
  type role Proxy phantom
  type Proxy :: forall {k}. k -> *
  data Proxy t = Proxy
  type TyCon :: *
  data TyCon = ...
  type TypeRep :: *
  type TypeRep = ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.SomeTypeRep
  type Typeable :: forall k. k -> Constraint
  class Typeable a where
    ...
    {-# MINIMAL ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.typeRep# #-}
  cast :: forall a b. (Typeable a, Typeable b) => a -> GHC.Internal.Maybe.Maybe b
  constrFields :: Constr -> [GHC.Internal.Base.String]
  constrFixity :: Constr -> Fixity
  constrIndex :: Constr -> ConIndex
  constrRep :: Constr -> ConstrRep
  constrType :: Constr -> DataType
  dataTypeConstrs :: DataType -> [Constr]
  dataTypeName :: DataType -> GHC.Internal.Base.String
  dataTypeRep :: DataType -> DataRep
  decT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => GHC.Internal.Data.Either.Either ((a :~: b) -> GHC.Internal.Base.Void) (a :~: b)
  eqT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => GHC.Internal.Maybe.Maybe (a :~: b)
  fromConstr :: forall a. Data a => Constr -> a
  fromConstrB :: forall a. Data a => (forall d. Data d => d) -> Constr -> a
  fromConstrM :: forall (m :: * -> *) a. (GHC.Internal.Base.Monad m, Data a) => (forall d. Data d => m d) -> Constr -> m a
  funResultTy :: TypeRep -> TypeRep -> GHC.Internal.Maybe.Maybe TypeRep
  gcast :: forall {k} (a :: k) (b :: k) (c :: k -> *). (Typeable a, Typeable b) => c a -> GHC.Internal.Maybe.Maybe (c b)
  gcast1 :: forall {k1} {k2} (c :: k1 -> *) (t :: k2 -> k1) (t' :: k2 -> k1) (a :: k2). (Typeable t, Typeable t') => c (t a) -> GHC.Internal.Maybe.Maybe (c (t' a))
  gcast2 :: forall {k1} {k2} {k3} (c :: k1 -> *) (t :: k2 -> k3 -> k1) (t' :: k2 -> k3 -> k1) (a :: k2) (b :: k3). (Typeable t, Typeable t') => c (t a b) -> GHC.Internal.Maybe.Maybe (c (t' a b))
  hdecT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => GHC.Internal.Data.Either.Either ((a :~~: b) -> GHC.Internal.Base.Void) (a :~~: b)
  heqT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => GHC.Internal.Maybe.Maybe (a :~~: b)
  indexConstr :: DataType -> ConIndex -> Constr
  isAlgType :: DataType -> GHC.Types.Bool
  isNorepType :: DataType -> GHC.Types.Bool
  maxConstrIndex :: DataType -> ConIndex
  mkCharConstr :: DataType -> GHC.Types.Char -> Constr
  mkCharType :: GHC.Internal.Base.String -> DataType
  mkConstr :: DataType -> GHC.Internal.Base.String -> [GHC.Internal.Base.String] -> Fixity -> Constr
  mkConstrTag :: DataType -> GHC.Internal.Base.String -> GHC.Types.Int -> [GHC.Internal.Base.String] -> Fixity -> Constr
  mkDataType :: GHC.Internal.Base.String -> [Constr] -> DataType
  mkFloatType :: GHC.Internal.Base.String -> DataType
  mkFunTy :: TypeRep -> TypeRep -> TypeRep
  mkIntType :: GHC.Internal.Base.String -> DataType
  mkIntegralConstr :: forall a. (GHC.Internal.Real.Integral a, GHC.Internal.Show.Show a) => DataType -> a -> Constr
  mkNoRepType :: GHC.Internal.Base.String -> DataType
  mkRealConstr :: forall a. (GHC.Internal.Real.Real a, GHC.Internal.Show.Show a) => DataType -> a -> Constr
  readConstr :: DataType -> GHC.Internal.Base.String -> GHC.Internal.Maybe.Maybe Constr
  repConstr :: DataType -> ConstrRep -> Constr
  rnfTyCon :: TyCon -> ()
  rnfTypeRep :: TypeRep -> ()
  showConstr :: Constr -> GHC.Internal.Base.String
  showsTypeRep :: TypeRep -> GHC.Internal.Show.ShowS
  splitTyConApp :: TypeRep -> (TyCon, [TypeRep])
  trLiftedRep :: ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.TypeRep GHC.Types.LiftedRep
  tyConFingerprint :: TyCon -> GHC.Internal.Fingerprint.Type.Fingerprint
  tyConModule :: TyCon -> GHC.Internal.Base.String
  tyConName :: TyCon -> GHC.Internal.Base.String
  tyConPackage :: TyCon -> GHC.Internal.Base.String
  tyconModule :: GHC.Internal.Base.String -> GHC.Internal.Base.String
  tyconUQname :: GHC.Internal.Base.String -> GHC.Internal.Base.String
  typeOf :: forall a. Typeable a => a -> TypeRep
  typeOf1 :: forall (t :: * -> *) a. Typeable t => t a -> TypeRep
  typeOf2 :: forall (t :: * -> * -> *) a b. Typeable t => t a b -> TypeRep
  typeOf3 :: forall (t :: * -> * -> * -> *) a b c. Typeable t => t a b c -> TypeRep
  typeOf4 :: forall (t :: * -> * -> * -> * -> *) a b c d. Typeable t => t a b c d -> TypeRep
  typeOf5 :: forall (t :: * -> * -> * -> * -> * -> *) a b c d e. Typeable t => t a b c d e -> TypeRep
  typeOf6 :: forall (t :: * -> * -> * -> * -> * -> * -> *) a b c d e f. Typeable t => t a b c d e f -> TypeRep
  typeOf7 :: forall (t :: * -> * -> * -> * -> * -> * -> * -> *) a b c d e f g. Typeable t => t a b c d e f g -> TypeRep
  typeRep :: forall {k} (proxy :: k -> *) (a :: k). Typeable a => proxy a -> TypeRep
  typeRepArgs :: TypeRep -> [TypeRep]
  typeRepFingerprint :: TypeRep -> GHC.Internal.Fingerprint.Type.Fingerprint
  typeRepTyCon :: TypeRep -> TyCon

module Data.Dynamic where
  -- Safety: Safe
  type Dynamic :: *
  data Dynamic where
    Dynamic :: forall a. ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.TypeRep a -> a -> Dynamic
  type Typeable :: forall k. k -> Constraint
  class Typeable a where
    ...
    {-# MINIMAL ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.typeRep# #-}
  dynApp :: Dynamic -> Dynamic -> Dynamic
  dynApply :: Dynamic -> Dynamic -> GHC.Internal.Maybe.Maybe Dynamic
  dynTypeRep :: Dynamic -> ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.SomeTypeRep
  fromDyn :: forall a. Typeable a => Dynamic -> a -> a
  fromDynamic :: forall a. Typeable a => Dynamic -> GHC.Internal.Maybe.Maybe a
  toDyn :: forall a. Typeable a => a -> Dynamic

module Data.Either where
  -- Safety: Safe
  type Either :: * -> * -> *
  data Either a b = Left a | Right b
  either :: forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
  fromLeft :: forall a b. a -> Either a b -> a
  fromRight :: forall b a. b -> Either a b -> b
  isLeft :: forall a b. Either a b -> GHC.Types.Bool
  isRight :: forall a b. Either a b -> GHC.Types.Bool
  lefts :: forall a b. [Either a b] -> [a]
  partitionEithers :: forall a b. [Either a b] -> ([a], [b])
  rights :: forall a b. [Either a b] -> [b]

module Data.Enum where
  -- Safety: Safe
  type Bounded :: * -> Constraint
  class Bounded a where
    minBound :: a
    maxBound :: a
    {-# MINIMAL minBound, maxBound #-}
  type Enum :: * -> Constraint
  class Enum a where
    succ :: a -> a
    pred :: a -> a
    toEnum :: GHC.Types.Int -> a
    fromEnum :: a -> GHC.Types.Int
    enumFrom :: a -> [a]
    enumFromThen :: a -> a -> [a]
    enumFromTo :: a -> a -> [a]
    enumFromThenTo :: a -> a -> a -> [a]
    {-# MINIMAL toEnum, fromEnum #-}

module Data.Eq where
  -- Safety: Safe
  type Eq :: * -> Constraint
  class Eq a where
    (==) :: a -> a -> GHC.Types.Bool
    (/=) :: a -> a -> GHC.Types.Bool
    {-# MINIMAL (==) | (/=) #-}

module Data.Fixed where
  -- Safety: Trustworthy
  type Centi :: *
  type Centi = Fixed E2
  type Deci :: *
  type Deci = Fixed E1
  type E0 :: *
  data E0
  type E1 :: *
  data E1
  type E12 :: *
  data E12
  type E2 :: *
  data E2
  type E3 :: *
  data E3
  type E6 :: *
  data E6
  type E9 :: *
  data E9
  type role Fixed phantom
  type Fixed :: forall k. k -> *
  newtype Fixed a = MkFixed GHC.Num.Integer.Integer
  type HasResolution :: forall k. k -> Constraint
  class HasResolution a where