base-prelude 1.3 → 1.4
raw patch · 2 files changed
+13/−161 lines, 2 filesdep ~basePVP ok
version bump matches the API change (PVP)
Dependency ranges changed: base
API changes (from Hackage documentation)
+ BasePrelude: (!!) :: () => [a] -> Int -> a
+ BasePrelude: ($!) :: () => (a -> b) -> a -> b
+ BasePrelude: ($) :: () => (a -> b) -> a -> b
+ BasePrelude: (%) :: Integral a => a -> a -> Ratio a
+ BasePrelude: (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
+ BasePrelude: (&&) :: Bool -> Bool -> Bool
+ BasePrelude: (*) :: Num a => a -> a -> a
+ BasePrelude: (**) :: Floating a => a -> a -> a
+ BasePrelude: (***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c')
+ BasePrelude: (*>) :: Applicative f => f a -> f b -> f b
+ BasePrelude: (+) :: Num a => a -> a -> a
+ BasePrelude: (++) :: () => [a] -> [a] -> [a]
+ BasePrelude: (+++) :: ArrowChoice a => a b c -> a b' c' -> a (Either b b') (Either c c')
+ BasePrelude: (-) :: Num a => a -> a -> a
+ BasePrelude: (.&.) :: Bits a => a -> a -> a
+ BasePrelude: (.) :: Category cat => cat b c -> cat a b -> cat a c
+ BasePrelude: (.|.) :: Bits a => a -> a -> a
+ BasePrelude: (/) :: Fractional a => a -> a -> a
+ BasePrelude: (/=) :: Eq a => a -> a -> Bool
+ BasePrelude: (:+) :: !a -> !a -> Complex a
+ BasePrelude: (:|) :: a -> [a] -> NonEmpty a
+ BasePrelude: (<$!>) :: Monad m => (a -> b) -> m a -> m b
+ BasePrelude: (<$) :: Functor f => a -> f b -> f a
+ BasePrelude: (<$>) :: Functor f => (a -> b) -> f a -> f b
+ BasePrelude: (<&>) :: Functor f => f a -> (a -> b) -> f b
+ BasePrelude: (<) :: Ord a => a -> a -> Bool
+ BasePrelude: (<*) :: Applicative f => f a -> f b -> f a
+ BasePrelude: (<**>) :: Applicative f => f a -> f (a -> b) -> f b
+ BasePrelude: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
+ BasePrelude: (<+>) :: ArrowPlus a => a b c -> a b c -> a b c
+ BasePrelude: (<<<) :: Category cat => cat b c -> cat a b -> cat a c
+ BasePrelude: (<<^) :: Arrow a => a c d -> (b -> c) -> a b d
+ BasePrelude: (<=) :: Ord a => a -> a -> Bool
+ BasePrelude: (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
+ BasePrelude: (<>) :: Semigroup a => a -> a -> a
+ BasePrelude: (<|>) :: Alternative f => f a -> f a -> f a
+ BasePrelude: (=<<) :: Monad m => (a -> m b) -> m a -> m b
+ BasePrelude: (==) :: Eq a => a -> a -> Bool
+ BasePrelude: (>) :: Ord a => a -> a -> Bool
+ BasePrelude: (>=) :: Ord a => a -> a -> Bool
+ BasePrelude: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
+ BasePrelude: (>>) :: Monad m => m a -> m b -> m b
+ BasePrelude: (>>=) :: Monad m => m a -> (a -> m b) -> m b
+ BasePrelude: (>>>) :: Category cat => cat a b -> cat b c -> cat a c
+ BasePrelude: (>>^) :: Arrow a => a b c -> (c -> d) -> a b d
+ BasePrelude: (\\) :: Eq a => [a] -> [a] -> [a]
+ BasePrelude: (^) :: (Num a, Integral b) => a -> b -> a
+ BasePrelude: (^<<) :: Arrow a => (c -> d) -> a b c -> a b d
+ BasePrelude: (^>>) :: Arrow a => (b -> c) -> a c d -> a b d
+ BasePrelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ BasePrelude: (||) :: Bool -> Bool -> Bool
+ BasePrelude: (|||) :: ArrowChoice a => a b d -> a c d -> a (Either b c) d
+ BasePrelude: -- structure <tt>l</tt>.
+ BasePrelude: -- | The <a>Item</a> type function returns the type of items of the
+ BasePrelude: AbsoluteSeek :: SeekMode
+ BasePrelude: AlgConstr :: ConIndex -> ConstrRep
+ BasePrelude: AlgRep :: [Constr] -> DataRep
+ BasePrelude: All :: Bool -> All
+ BasePrelude: AllocationLimitExceeded :: AllocationLimitExceeded
+ BasePrelude: AlreadyExists :: IOErrorType
+ BasePrelude: Alt :: f a -> Alt
+ BasePrelude: Any :: Bool -> Any
+ BasePrelude: Ap :: f a -> Ap
+ BasePrelude: AppendMode :: IOMode
+ BasePrelude: Arg :: a -> b -> Arg a b
+ BasePrelude: ArrowMonad :: a () b -> ArrowMonad b
+ BasePrelude: AssertionFailed :: String -> AssertionFailed
+ BasePrelude: BlockBuffering :: Maybe Int -> BufferMode
+ BasePrelude: BlockedIndefinitelyOnMVar :: BlockedIndefinitelyOnMVar
+ BasePrelude: BlockedIndefinitelyOnSTM :: BlockedIndefinitelyOnSTM
+ BasePrelude: BlockedOnBlackHole :: BlockReason
+ BasePrelude: BlockedOnException :: BlockReason
+ BasePrelude: BlockedOnForeignCall :: BlockReason
+ BasePrelude: BlockedOnMVar :: BlockReason
+ BasePrelude: BlockedOnOther :: BlockReason
+ BasePrelude: BlockedOnSTM :: BlockReason
+ BasePrelude: CRLF :: Newline
+ BasePrelude: CharConstr :: Char -> ConstrRep
+ BasePrelude: CharRep :: DataRep
+ BasePrelude: ClosePunctuation :: GeneralCategory
+ BasePrelude: CompactionFailed :: String -> CompactionFailed
+ BasePrelude: Compose :: f (g a) -> Compose
+ BasePrelude: ConnectorPunctuation :: GeneralCategory
+ BasePrelude: Const :: a -> Const a
+ BasePrelude: Control :: GeneralCategory
+ BasePrelude: CurrencySymbol :: GeneralCategory
+ BasePrelude: DashPunctuation :: GeneralCategory
+ BasePrelude: Deadlock :: Deadlock
+ BasePrelude: DecimalNumber :: GeneralCategory
+ BasePrelude: Denormal :: ArithException
+ BasePrelude: DivideByZero :: ArithException
+ BasePrelude: Down :: a -> Down a
+ BasePrelude: Dual :: a -> Dual a
+ BasePrelude: EOF :: IOErrorType
+ BasePrelude: EQ :: Ordering
+ BasePrelude: EnclosingMark :: GeneralCategory
+ BasePrelude: Endo :: (a -> a) -> Endo a
+ BasePrelude: ErrorCallWithLocation :: String -> String -> ErrorCall
+ BasePrelude: ExitFailure :: Int -> ExitCode
+ BasePrelude: ExitSuccess :: ExitCode
+ BasePrelude: False :: Bool
+ BasePrelude: FinalQuote :: GeneralCategory
+ BasePrelude: First :: a -> First a
+ BasePrelude: FixIOException :: FixIOException
+ BasePrelude: FloatConstr :: Rational -> ConstrRep
+ BasePrelude: FloatRep :: DataRep
+ BasePrelude: Format :: GeneralCategory
+ BasePrelude: GT :: Ordering
+ BasePrelude: HardwareFault :: IOErrorType
+ BasePrelude: HeapOverflow :: AsyncException
+ BasePrelude: IOError :: Maybe Handle -> IOErrorType -> String -> String -> Maybe CInt -> Maybe FilePath -> IOException
+ BasePrelude: Identity :: a -> Identity a
+ BasePrelude: IllegalOperation :: IOErrorType
+ BasePrelude: InappropriateType :: IOErrorType
+ BasePrelude: IndexOutOfBounds :: String -> ArrayException
+ BasePrelude: Infix :: Fixity
+ BasePrelude: InitialQuote :: GeneralCategory
+ BasePrelude: IntConstr :: Integer -> ConstrRep
+ BasePrelude: IntPtr :: Int -> IntPtr
+ BasePrelude: IntRep :: DataRep
+ BasePrelude: Interrupted :: IOErrorType
+ BasePrelude: InvalidArgument :: IOErrorType
+ BasePrelude: Just :: a -> Maybe a
+ BasePrelude: KProxy :: KProxy t
+ BasePrelude: Kleisli :: (a -> m b) -> Kleisli a b
+ BasePrelude: LF :: Newline
+ BasePrelude: LT :: Ordering
+ BasePrelude: Last :: a -> Last a
+ BasePrelude: Left :: a -> Either a b
+ BasePrelude: LetterNumber :: GeneralCategory
+ BasePrelude: LineBuffering :: BufferMode
+ BasePrelude: LineSeparator :: GeneralCategory
+ BasePrelude: LossOfPrecision :: ArithException
+ BasePrelude: LowercaseLetter :: GeneralCategory
+ BasePrelude: MaskedInterruptible :: MaskingState
+ BasePrelude: MaskedUninterruptible :: MaskingState
+ BasePrelude: MathSymbol :: GeneralCategory
+ BasePrelude: Max :: a -> Max a
+ BasePrelude: Min :: a -> Min a
+ BasePrelude: MkFixed :: Integer -> Fixed a
+ BasePrelude: ModifierLetter :: GeneralCategory
+ BasePrelude: ModifierSymbol :: GeneralCategory
+ BasePrelude: NestedAtomically :: NestedAtomically
+ BasePrelude: NewlineMode :: Newline -> Newline -> NewlineMode
+ BasePrelude: NoBuffering :: BufferMode
+ BasePrelude: NoMethodError :: String -> NoMethodError
+ BasePrelude: NoRep :: DataRep
+ BasePrelude: NoSuchThing :: IOErrorType
+ BasePrelude: NonSpacingMark :: GeneralCategory
+ BasePrelude: NonTermination :: NonTermination
+ BasePrelude: NotAssigned :: GeneralCategory
+ BasePrelude: Nothing :: Maybe a
+ BasePrelude: OpenPunctuation :: GeneralCategory
+ BasePrelude: Option :: Maybe a -> Option a
+ BasePrelude: OtherError :: IOErrorType
+ BasePrelude: OtherLetter :: GeneralCategory
+ BasePrelude: OtherNumber :: GeneralCategory
+ BasePrelude: OtherPunctuation :: GeneralCategory
+ BasePrelude: OtherSymbol :: GeneralCategory
+ BasePrelude: Overflow :: ArithException
+ BasePrelude: ParagraphSeparator :: GeneralCategory
+ BasePrelude: PatternMatchFail :: String -> PatternMatchFail
+ BasePrelude: PermissionDenied :: IOErrorType
+ BasePrelude: Prefix :: Fixity
+ BasePrelude: PrivateUse :: GeneralCategory
+ BasePrelude: Product :: a -> Product a
+ BasePrelude: ProtocolError :: IOErrorType
+ BasePrelude: Proxy :: Proxy
+ BasePrelude: RatioZeroDenominator :: ArithException
+ BasePrelude: ReadMode :: IOMode
+ BasePrelude: ReadWriteMode :: IOMode
+ BasePrelude: RecConError :: String -> RecConError
+ BasePrelude: RecSelError :: String -> RecSelError
+ BasePrelude: RecUpdError :: String -> RecUpdError
+ BasePrelude: RelativeSeek :: SeekMode
+ BasePrelude: ResourceBusy :: IOErrorType
+ BasePrelude: ResourceExhausted :: IOErrorType
+ BasePrelude: ResourceVanished :: IOErrorType
+ BasePrelude: Right :: b -> Either a b
+ BasePrelude: STM :: (State# RealWorld -> (# State# RealWorld, a #)) -> STM a
+ BasePrelude: SeekFromEnd :: SeekMode
+ BasePrelude: Space :: GeneralCategory
+ BasePrelude: SpacingCombiningMark :: GeneralCategory
+ BasePrelude: StackOverflow :: AsyncException
+ BasePrelude: Sum :: a -> Sum a
+ BasePrelude: Surrogate :: GeneralCategory
+ BasePrelude: SystemError :: IOErrorType
+ BasePrelude: TVar :: TVar# RealWorld a -> TVar a
+ BasePrelude: ThreadBlocked :: BlockReason -> ThreadStatus
+ BasePrelude: ThreadDied :: ThreadStatus
+ BasePrelude: ThreadFinished :: ThreadStatus
+ BasePrelude: ThreadId :: ThreadId# -> ThreadId
+ BasePrelude: ThreadKilled :: AsyncException
+ BasePrelude: ThreadRunning :: ThreadStatus
+ BasePrelude: TimeExpired :: IOErrorType
+ BasePrelude: TitlecaseLetter :: GeneralCategory
+ BasePrelude: True :: Bool
+ BasePrelude: TypeError :: String -> TypeError
+ BasePrelude: UndefinedElement :: String -> ArrayException
+ BasePrelude: Underflow :: ArithException
+ BasePrelude: Unmasked :: MaskingState
+ BasePrelude: UnsatisfiedConstraints :: IOErrorType
+ BasePrelude: UnsupportedOperation :: IOErrorType
+ BasePrelude: UppercaseLetter :: GeneralCategory
+ BasePrelude: UserError :: IOErrorType
+ BasePrelude: UserInterrupt :: AsyncException
+ BasePrelude: Version :: [Int] -> [String] -> Version
+ BasePrelude: WordPtr :: Word -> WordPtr
+ BasePrelude: WrapArrow :: a b c -> WrappedArrow b c
+ BasePrelude: WrapMonad :: m a -> WrappedMonad a
+ BasePrelude: WrapMonoid :: m -> WrappedMonoid m
+ BasePrelude: WriteMode :: IOMode
+ BasePrelude: ZipList :: [a] -> ZipList a
+ BasePrelude: [Dynamic] :: forall a. () => TypeRep a -> a -> Dynamic
+ BasePrelude: [HRefl] :: forall k1 k2 (a :: k1) (b :: k2). () => a :~~: a
+ BasePrelude: [Handler] :: forall a e. Exception e => (e -> IO a) -> Handler a
+ BasePrelude: [Refl] :: forall k (a :: k) (b :: k). () => a :~: a
+ BasePrelude: [SomeAsyncException] :: forall e. Exception e => e -> SomeAsyncException
+ BasePrelude: [SomeException] :: forall e. Exception e => e -> SomeException
+ BasePrelude: [appEndo] :: Endo a -> a -> a
+ BasePrelude: [getAll] :: All -> Bool
+ BasePrelude: [getAlt] :: Alt -> f a
+ BasePrelude: [getAny] :: Any -> Bool
+ BasePrelude: [getAp] :: Ap -> f a
+ BasePrelude: [getCompose] :: Compose -> f (g a)
+ BasePrelude: [getConst] :: Const a -> a
+ BasePrelude: [getDual] :: Dual a -> a
+ BasePrelude: [getFirst] :: First a -> a
+ BasePrelude: [getLast] :: Last a -> a
+ BasePrelude: [getMax] :: Max a -> a
+ BasePrelude: [getMin] :: Min a -> a
+ BasePrelude: [getOption] :: Option a -> Maybe a
+ BasePrelude: [getProduct] :: Product a -> a
+ BasePrelude: [getSum] :: Sum a -> a
+ BasePrelude: [getZipList] :: ZipList a -> [a]
+ BasePrelude: [inputNL] :: NewlineMode -> Newline
+ BasePrelude: [ioe_description] :: IOException -> String
+ BasePrelude: [ioe_errno] :: IOException -> Maybe CInt
+ BasePrelude: [ioe_filename] :: IOException -> Maybe FilePath
+ BasePrelude: [ioe_handle] :: IOException -> Maybe Handle
+ BasePrelude: [ioe_location] :: IOException -> String
+ BasePrelude: [ioe_type] :: IOException -> IOErrorType
+ BasePrelude: [outputNL] :: NewlineMode -> Newline
+ BasePrelude: [runIdentity] :: Identity a -> a
+ BasePrelude: [runKleisli] :: Kleisli a b -> a -> m b
+ BasePrelude: [unwrapArrow] :: WrappedArrow b c -> a b c
+ BasePrelude: [unwrapMonad] :: WrappedMonad a -> m a
+ BasePrelude: [unwrapMonoid] :: WrappedMonoid m -> m
+ BasePrelude: [versionBranch] :: Version -> [Int]
+ BasePrelude: [versionTags] :: Version -> [String]
+ BasePrelude: abs :: Num a => a -> a
+ BasePrelude: absurd :: () => Void -> a
+ BasePrelude: acos :: Floating a => a -> a
+ BasePrelude: acosh :: Floating a => a -> a
+ BasePrelude: addForeignPtrFinalizer :: () => FinalizerPtr a -> ForeignPtr a -> IO ()
+ BasePrelude: addForeignPtrFinalizerEnv :: () => FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> IO ()
+ BasePrelude: addMVarFinalizer :: () => MVar a -> IO () -> IO ()
+ BasePrelude: alignPtr :: () => Ptr a -> Int -> Ptr a
+ BasePrelude: alignment :: Storable a => a -> Int
+ BasePrelude: all :: Foldable t => (a -> Bool) -> t a -> Bool
+ BasePrelude: allocationLimitExceeded :: SomeException
+ BasePrelude: allowInterrupt :: IO ()
+ BasePrelude: alreadyExistsErrorType :: IOErrorType
+ BasePrelude: alreadyInUseErrorType :: IOErrorType
+ BasePrelude: and :: Foldable t => t Bool -> Bool
+ BasePrelude: annotateIOError :: IOError -> String -> Maybe Handle -> Maybe FilePath -> IOError
+ BasePrelude: any :: Foldable t => (a -> Bool) -> t a -> Bool
+ BasePrelude: ap :: Monad m => m (a -> b) -> m a -> m b
+ BasePrelude: app :: ArrowApply a => a (a b c, b) c
+ BasePrelude: appendFile :: FilePath -> String -> IO ()
+ BasePrelude: approxRational :: RealFrac a => a -> a -> Rational
+ BasePrelude: arr :: Arrow a => (b -> c) -> a b c
+ BasePrelude: asProxyTypeOf :: () => a -> proxy a -> a
+ BasePrelude: asTypeOf :: () => a -> a -> a
+ BasePrelude: asin :: Floating a => a -> a
+ BasePrelude: asinh :: Floating a => a -> a
+ BasePrelude: assert :: () => Bool -> a -> a
+ BasePrelude: assertError :: ?callStack :: CallStack => Bool -> a -> a
+ BasePrelude: asum :: (Foldable t, Alternative f) => t (f a) -> f a
+ BasePrelude: asyncExceptionFromException :: Exception e => SomeException -> Maybe e
+ BasePrelude: asyncExceptionToException :: Exception e => e -> SomeException
+ BasePrelude: atan :: Floating a => a -> a
+ BasePrelude: atan2 :: RealFloat a => a -> a -> a
+ BasePrelude: atanh :: Floating a => a -> a
+ BasePrelude: atomicModifyIORef :: () => IORef a -> (a -> (a, b)) -> IO b
+ BasePrelude: atomicModifyIORef' :: () => IORef a -> (a -> (a, b)) -> IO b
+ BasePrelude: atomicWriteIORef :: () => IORef a -> a -> IO ()
+ BasePrelude: atomically :: () => STM a -> IO a
+ BasePrelude: bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
+ BasePrelude: bit :: Bits a => Int -> a
+ BasePrelude: bitDefault :: (Bits a, Num a) => Int -> a
+ BasePrelude: bitSize :: Bits a => a -> Int
+ BasePrelude: bitSizeMaybe :: Bits a => a -> Maybe Int
+ BasePrelude: blockedIndefinitelyOnMVar :: SomeException
+ BasePrelude: blockedIndefinitelyOnSTM :: SomeException
+ BasePrelude: bracket :: () => IO a -> (a -> IO b) -> (a -> IO c) -> IO c
+ BasePrelude: bracketOnError :: () => IO a -> (a -> IO b) -> (a -> IO c) -> IO c
+ BasePrelude: bracket_ :: () => IO a -> IO b -> IO c -> IO c
+ BasePrelude: break :: () => (a -> Bool) -> [a] -> ([a], [a])
+ BasePrelude: byteSwap16 :: Word16 -> Word16
+ BasePrelude: byteSwap32 :: Word32 -> Word32
+ BasePrelude: byteSwap64 :: Word64 -> Word64
+ BasePrelude: cannotCompactFunction :: SomeException
+ BasePrelude: cannotCompactMutable :: SomeException
+ BasePrelude: cannotCompactPinned :: SomeException
+ BasePrelude: cast :: (Typeable a, Typeable b) => a -> Maybe b
+ BasePrelude: castForeignPtr :: () => ForeignPtr a -> ForeignPtr b
+ BasePrelude: castFunPtr :: () => FunPtr a -> FunPtr b
+ BasePrelude: castFunPtrToPtr :: () => FunPtr a -> Ptr b
+ BasePrelude: castPtr :: () => Ptr a -> Ptr b
+ BasePrelude: castPtrToFunPtr :: () => Ptr a -> FunPtr b
+ BasePrelude: castPtrToStablePtr :: () => Ptr () -> StablePtr a
+ BasePrelude: castStablePtrToPtr :: () => StablePtr a -> Ptr ()
+ BasePrelude: catMaybes :: () => [Maybe a] -> [a]
+ BasePrelude: catch :: Exception e => IO a -> (e -> IO a) -> IO a
+ BasePrelude: catchIOError :: () => IO a -> (IOError -> IO a) -> IO a
+ BasePrelude: catchJust :: Exception e => (e -> Maybe b) -> IO a -> (b -> IO a) -> IO a
+ BasePrelude: catchSTM :: Exception e => STM a -> (e -> STM a) -> STM a
+ BasePrelude: catches :: () => IO a -> [Handler a] -> IO a
+ BasePrelude: ceiling :: (RealFrac a, Integral b) => a -> b
+ BasePrelude: char8 :: TextEncoding
+ BasePrelude: childHandler :: SomeException -> IO ()
+ BasePrelude: chr :: Int -> Char
+ BasePrelude: cis :: Floating a => a -> Complex a
+ BasePrelude: class Applicative f => Alternative (f :: Type -> Type)
+ BasePrelude: class Functor f => Applicative (f :: Type -> Type)
+ BasePrelude: class Category a => Arrow (a :: Type -> Type -> Type)
+ BasePrelude: class Arrow a => ArrowApply (a :: Type -> Type -> Type)
+ BasePrelude: class Arrow a => ArrowChoice (a :: Type -> Type -> Type)
+ BasePrelude: class Arrow a => ArrowLoop (a :: Type -> Type -> Type)
+ BasePrelude: class ArrowZero a => ArrowPlus (a :: Type -> Type -> Type)
+ BasePrelude: class Arrow a => ArrowZero (a :: Type -> Type -> Type)
+ BasePrelude: class Bifunctor (p :: Type -> Type -> Type)
+ BasePrelude: class Eq a => Bits a
+ BasePrelude: class Bounded a
+ BasePrelude: class Category (cat :: k -> k -> Type)
+ BasePrelude: class a ~R# b => Coercible (a :: k0) (b :: k0)
+ BasePrelude: class Typeable a => Data a
+ BasePrelude: class Enum a
+ BasePrelude: class Eq a
+ BasePrelude: class Eq1 (f :: Type -> Type)
+ BasePrelude: class Eq2 (f :: Type -> Type -> Type)
+ BasePrelude: class (Typeable e, Show e) => Exception e
+ BasePrelude: class Bits b => FiniteBits b
+ BasePrelude: class Fractional a => Floating a
+ BasePrelude: class Foldable (t :: Type -> Type)
+ BasePrelude: class Num a => Fractional a
+ BasePrelude: class Functor (f :: Type -> Type)
+ BasePrelude: class Generic a
+ BasePrelude: class Generic1 (f :: k -> Type)
+ BasePrelude: class HasResolution a
+ BasePrelude: class (Real a, Enum a) => Integral a
+ BasePrelude: class IsList l where {
+ BasePrelude: class IsString a
+ BasePrelude: class Ord a => Ix a
+ BasePrelude: class Applicative m => Monad (m :: Type -> Type)
+ BasePrelude: class Monad m => MonadFail (m :: Type -> Type)
+ BasePrelude: class Monad m => MonadFix (m :: Type -> Type)
+ BasePrelude: class Monad m => MonadIO (m :: Type -> Type)
+ BasePrelude: class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
+ BasePrelude: class Semigroup a => Monoid a
+ BasePrelude: class Num a
+ BasePrelude: class Eq a => Ord a
+ BasePrelude: class Eq1 f => Ord1 (f :: Type -> Type)
+ BasePrelude: class Eq2 f => Ord2 (f :: Type -> Type -> Type)
+ BasePrelude: class Read a
+ BasePrelude: class Read1 (f :: Type -> Type)
+ BasePrelude: class Read2 (f :: Type -> Type -> Type)
+ BasePrelude: class (Num a, Ord a) => Real a
+ BasePrelude: class (RealFrac a, Floating a) => RealFloat a
+ BasePrelude: class (Real a, Fractional a) => RealFrac a
+ BasePrelude: class Semigroup a
+ BasePrelude: class Show a
+ BasePrelude: class Show1 (f :: Type -> Type)
+ BasePrelude: class Show2 (f :: Type -> Type -> Type)
+ BasePrelude: class Storable a
+ BasePrelude: class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
+ BasePrelude: class Typeable (a :: k)
+ BasePrelude: clearBit :: Bits a => a -> Int -> a
+ BasePrelude: closeFdWith :: (Fd -> IO ()) -> Fd -> IO ()
+ BasePrelude: coerce :: Coercible a b => a -> b
+ BasePrelude: compare :: Ord a => a -> a -> Ordering
+ BasePrelude: compare1 :: (Ord1 f, Ord a) => f a -> f a -> Ordering
+ BasePrelude: compare2 :: (Ord2 f, Ord a, Ord b) => f a b -> f a b -> Ordering
+ BasePrelude: comparing :: Ord a => (b -> a) -> b -> b -> Ordering
+ BasePrelude: complement :: Bits a => a -> a
+ BasePrelude: complementBit :: Bits a => a -> Int -> a
+ BasePrelude: concat :: Foldable t => t [a] -> [a]
+ BasePrelude: concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
+ BasePrelude: conjugate :: Num a => Complex a -> Complex a
+ BasePrelude: const :: () => a -> b -> a
+ BasePrelude: constrFields :: Constr -> [String]
+ BasePrelude: constrFixity :: Constr -> Fixity
+ BasePrelude: constrIndex :: Constr -> ConIndex
+ BasePrelude: constrRep :: Constr -> ConstrRep
+ BasePrelude: constrType :: Constr -> DataType
+ BasePrelude: cos :: Floating a => a -> a
+ BasePrelude: cosh :: Floating a => a -> a
+ BasePrelude: countLeadingZeros :: FiniteBits b => b -> Int
+ BasePrelude: countTrailingZeros :: FiniteBits b => b -> Int
+ BasePrelude: curry :: () => ((a, b) -> c) -> a -> b -> c
+ BasePrelude: cycle :: () => [a] -> [a]
+ BasePrelude: cycle1 :: Semigroup m => m -> m
+ BasePrelude: data AllocationLimitExceeded
+ BasePrelude: data Arg a b
+ BasePrelude: data ArithException
+ BasePrelude: data ArrayException
+ BasePrelude: data AsyncException
+ BasePrelude: data BlockReason
+ BasePrelude: data BlockedIndefinitelyOnMVar
+ BasePrelude: data BlockedIndefinitelyOnSTM
+ BasePrelude: data Bool
+ BasePrelude: data BufferMode
+ BasePrelude: data Chan a
+ BasePrelude: data Char
+ BasePrelude: data Complex a
+ BasePrelude: data Constr
+ BasePrelude: data ConstrRep
+ BasePrelude: data DataRep
+ BasePrelude: data DataType
+ BasePrelude: data Deadlock
+ BasePrelude: data Double
+ BasePrelude: data Dynamic
+ BasePrelude: data E0
+ BasePrelude: data E1
+ BasePrelude: data E12
+ BasePrelude: data E2
+ BasePrelude: data E3
+ BasePrelude: data E6
+ BasePrelude: data E9
+ BasePrelude: data Either a b
+ BasePrelude: data ErrorCall
+ BasePrelude: data ExitCode
+ BasePrelude: data FixIOException
+ BasePrelude: data Fixity
+ BasePrelude: data Float
+ BasePrelude: data ForeignPtr a
+ BasePrelude: data FunPtr a
+ BasePrelude: data GeneralCategory
+ BasePrelude: data Handle
+ BasePrelude: data HandlePosn
+ BasePrelude: data Handler a
+ BasePrelude: data IO a
+ BasePrelude: data IOErrorType
+ BasePrelude: data IOException
+ BasePrelude: data IOMode
+ BasePrelude: data IORef a
+ BasePrelude: data Int
+ BasePrelude: data Int16
+ BasePrelude: data Int32
+ BasePrelude: data Int64
+ BasePrelude: data Int8
+ BasePrelude: data Integer
+ BasePrelude: data KProxy t
+ BasePrelude: data MVar a
+ BasePrelude: data MaskingState
+ BasePrelude: data Maybe a
+ BasePrelude: data Natural
+ BasePrelude: data NestedAtomically
+ BasePrelude: data Newline
+ BasePrelude: data NewlineMode
+ BasePrelude: data NonEmpty a
+ BasePrelude: data NonTermination
+ BasePrelude: data Ordering
+ BasePrelude: data PrimMVar
+ BasePrelude: data Ptr a
+ BasePrelude: data QSem
+ BasePrelude: data QSemN
+ BasePrelude: data Ratio a
+ BasePrelude: data ReadP a
+ BasePrelude: data ReadPrec a
+ BasePrelude: data RealWorld :: Type
+ BasePrelude: data ST s a
+ BasePrelude: data STRef s a
+ BasePrelude: data SeekMode
+ BasePrelude: data SomeAsyncException
+ BasePrelude: data SomeException
+ BasePrelude: data StableName a
+ BasePrelude: data StablePtr a
+ BasePrelude: data TVar a
+ BasePrelude: data TextEncoding
+ BasePrelude: data ThreadId
+ BasePrelude: data ThreadStatus
+ BasePrelude: data TyCon
+ BasePrelude: data Unique
+ BasePrelude: data Version
+ BasePrelude: data Void
+ BasePrelude: data Word
+ BasePrelude: data Word16
+ BasePrelude: data Word32
+ BasePrelude: data Word64
+ BasePrelude: data Word8
+ BasePrelude: data (:~:) (a :: k) (b :: k) :: forall k. () => k -> k -> Type
+ BasePrelude: data (:~~:) (a :: k1) (b :: k2) :: forall k1 k2. () => k1 -> k2 -> Type
+ BasePrelude: dataCast1 :: (Data a, Typeable t) => (forall d. Data d => c (t d)) -> Maybe (c a)
+ BasePrelude: dataCast2 :: (Data a, Typeable t) => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a)
+ BasePrelude: dataTypeConstrs :: DataType -> [Constr]
+ BasePrelude: dataTypeName :: DataType -> String
+ BasePrelude: dataTypeOf :: Data a => a -> DataType
+ BasePrelude: dataTypeRep :: DataType -> DataRep
+ BasePrelude: deRefStablePtr :: () => StablePtr a -> IO a
+ BasePrelude: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ BasePrelude: delete :: Eq a => a -> [a] -> [a]
+ BasePrelude: deleteBy :: () => (a -> a -> Bool) -> a -> [a] -> [a]
+ BasePrelude: deleteFirstsBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]
+ BasePrelude: denominator :: () => Ratio a -> a
+ BasePrelude: die :: () => String -> IO a
+ BasePrelude: diff :: Semigroup m => m -> Endo m
+ BasePrelude: digitToInt :: Char -> Int
+ BasePrelude: disableAllocationLimit :: IO ()
+ BasePrelude: displayException :: Exception e => e -> String
+ BasePrelude: div :: Integral a => a -> a -> a
+ BasePrelude: div' :: (Real a, Integral b) => a -> a -> b
+ BasePrelude: divMod :: Integral a => a -> a -> (a, a)
+ BasePrelude: divMod' :: (Real a, Integral b) => a -> a -> (b, a)
+ BasePrelude: doesNotExistErrorType :: IOErrorType
+ BasePrelude: drop :: () => Int -> [a] -> [a]
+ BasePrelude: dropWhile :: () => (a -> Bool) -> [a] -> [a]
+ BasePrelude: dropWhileEnd :: () => (a -> Bool) -> [a] -> [a]
+ BasePrelude: dupChan :: () => Chan a -> IO (Chan a)
+ BasePrelude: dynApp :: Dynamic -> Dynamic -> Dynamic
+ BasePrelude: dynApply :: Dynamic -> Dynamic -> Maybe Dynamic
+ BasePrelude: dynTypeRep :: Dynamic -> SomeTypeRep
+ BasePrelude: either :: () => (a -> c) -> (b -> c) -> Either a b -> c
+ BasePrelude: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ BasePrelude: elemIndex :: Eq a => a -> [a] -> Maybe Int
+ BasePrelude: elemIndices :: Eq a => a -> [a] -> [Int]
+ BasePrelude: empty :: Alternative f => f a
+ BasePrelude: enableAllocationLimit :: IO ()
+ BasePrelude: encodeFloat :: RealFloat a => Integer -> Int -> a
+ BasePrelude: ensureIOManagerIsRunning :: IO ()
+ BasePrelude: enumFrom :: Enum a => a -> [a]
+ BasePrelude: enumFromThen :: Enum a => a -> a -> [a]
+ BasePrelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ BasePrelude: enumFromTo :: Enum a => a -> a -> [a]
+ BasePrelude: eofErrorType :: IOErrorType
+ BasePrelude: eq1 :: (Eq1 f, Eq a) => f a -> f a -> Bool
+ BasePrelude: eq2 :: (Eq2 f, Eq a, Eq b) => f a b -> f a b -> Bool
+ BasePrelude: eqStableName :: () => StableName a -> StableName b -> Bool
+ BasePrelude: eqT :: (Typeable a, Typeable b) => Maybe (a :~: b)
+ BasePrelude: error :: HasCallStack => [Char] -> a
+ BasePrelude: errorWithoutStackTrace :: () => [Char] -> a
+ BasePrelude: evaluate :: () => a -> IO a
+ BasePrelude: even :: Integral a => a -> Bool
+ BasePrelude: exitFailure :: () => IO a
+ BasePrelude: exitSuccess :: () => IO a
+ BasePrelude: exitWith :: () => ExitCode -> IO a
+ BasePrelude: exp :: Floating a => a -> a
+ BasePrelude: expm1 :: Floating a => a -> a
+ BasePrelude: exponent :: RealFloat a => a -> Int
+ BasePrelude: fail :: MonadFail m => String -> m a
+ BasePrelude: filter :: () => (a -> Bool) -> [a] -> [a]
+ BasePrelude: filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
+ BasePrelude: finalizeForeignPtr :: () => ForeignPtr a -> IO ()
+ BasePrelude: finally :: () => IO a -> IO b -> IO a
+ BasePrelude: find :: Foldable t => (a -> Bool) -> t a -> Maybe a
+ BasePrelude: findIndex :: () => (a -> Bool) -> [a] -> Maybe Int
+ BasePrelude: findIndices :: () => (a -> Bool) -> [a] -> [Int]
+ BasePrelude: finiteBitSize :: FiniteBits b => b -> Int
+ BasePrelude: first :: Bifunctor p => (a -> b) -> p a c -> p b c
+ BasePrelude: fix :: () => (a -> a) -> a
+ BasePrelude: fixIO :: () => (a -> IO a) -> IO a
+ BasePrelude: fixST :: () => (a -> ST s a) -> ST s a
+ BasePrelude: flip :: () => (a -> b -> c) -> b -> a -> c
+ BasePrelude: floatDigits :: RealFloat a => a -> Int
+ BasePrelude: floatRadix :: RealFloat a => a -> Integer
+ BasePrelude: floatRange :: RealFloat a => a -> (Int, Int)
+ BasePrelude: floatToDigits :: RealFloat a => Integer -> a -> ([Int], Int)
+ BasePrelude: floor :: (RealFrac a, Integral b) => a -> b
+ BasePrelude: fmap :: Functor f => (a -> b) -> f a -> f b
+ BasePrelude: fmapDefault :: Traversable t => (a -> b) -> t a -> t b
+ BasePrelude: fold :: (Foldable t, Monoid m) => t m -> m
+ BasePrelude: foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
+ BasePrelude: foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
+ BasePrelude: foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
+ BasePrelude: foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m
+ BasePrelude: foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
+ BasePrelude: foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
+ BasePrelude: foldl1 :: Foldable t => (a -> a -> a) -> t a -> a
+ BasePrelude: foldl1' :: () => (a -> a -> a) -> [a] -> a
+ BasePrelude: foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
+ BasePrelude: foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
+ BasePrelude: foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b
+ BasePrelude: foldr1 :: Foldable t => (a -> a -> a) -> t a -> a
+ BasePrelude: foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
+ BasePrelude: for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
+ BasePrelude: forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
+ BasePrelude: forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
+ BasePrelude: for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
+ BasePrelude: forever :: Applicative f => f a -> f b
+ BasePrelude: forkFinally :: () => IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
+ BasePrelude: forkIO :: IO () -> IO ThreadId
+ BasePrelude: forkIOWithUnmask :: ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
+ BasePrelude: forkOS :: IO () -> IO ThreadId
+ BasePrelude: forkOSWithUnmask :: ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
+ BasePrelude: forkOn :: Int -> IO () -> IO ThreadId
+ BasePrelude: forkOnWithUnmask :: Int -> ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId
+ BasePrelude: freeHaskellFunPtr :: () => FunPtr a -> IO ()
+ BasePrelude: freeStablePtr :: () => StablePtr a -> IO ()
+ BasePrelude: fromConstr :: Data a => Constr -> a
+ BasePrelude: fromConstrB :: Data a => (forall d. Data d => d) -> Constr -> a
+ BasePrelude: fromConstrM :: (Monad m, Data a) => (forall d. Data d => m d) -> Constr -> m a
+ BasePrelude: fromDyn :: Typeable a => Dynamic -> a -> a
+ BasePrelude: fromDynamic :: Typeable a => Dynamic -> Maybe a
+ BasePrelude: fromEnum :: Enum a => a -> Int
+ BasePrelude: fromException :: Exception e => SomeException -> Maybe e
+ BasePrelude: fromInteger :: Num a => Integer -> a
+ BasePrelude: fromIntegral :: (Integral a, Num b) => a -> b
+ BasePrelude: fromJust :: () => Maybe a -> a
+ BasePrelude: fromLeft :: () => a -> Either a b -> a
+ BasePrelude: fromList :: IsList l => [Item l] -> l
+ BasePrelude: fromListN :: IsList l => Int -> [Item l] -> l
+ BasePrelude: fromMaybe :: () => a -> Maybe a -> a
+ BasePrelude: fromRat :: RealFloat a => Rational -> a
+ BasePrelude: fromRational :: Fractional a => Rational -> a
+ BasePrelude: fromRight :: () => b -> Either a b -> b
+ BasePrelude: fromString :: IsString a => String -> a
+ BasePrelude: fst :: () => (a, b) -> a
+ BasePrelude: fullErrorType :: IOErrorType
+ BasePrelude: funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep
+ BasePrelude: gcast :: (Typeable a, Typeable b) => c a -> Maybe (c b)
+ BasePrelude: gcast1 :: (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a))
+ BasePrelude: gcast2 :: (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b))
+ BasePrelude: gcd :: Integral a => a -> a -> a
+ BasePrelude: generalCategory :: Char -> GeneralCategory
+ BasePrelude: genericDrop :: Integral i => i -> [a] -> [a]
+ BasePrelude: genericIndex :: Integral i => [a] -> i -> a
+ BasePrelude: genericLength :: Num i => [a] -> i
+ BasePrelude: genericReplicate :: Integral i => i -> a -> [a]
+ BasePrelude: genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
+ BasePrelude: genericTake :: Integral i => i -> [a] -> [a]
+ BasePrelude: getAllocationCounter :: IO Int64
+ BasePrelude: getArgs :: IO [String]
+ BasePrelude: getChanContents :: () => Chan a -> IO [a]
+ BasePrelude: getChar :: IO Char
+ BasePrelude: getContents :: IO String
+ BasePrelude: getEnv :: String -> IO String
+ BasePrelude: getEnvironment :: IO [(String, String)]
+ BasePrelude: getExecutablePath :: IO FilePath
+ BasePrelude: getLine :: IO String
+ BasePrelude: getMaskingState :: IO MaskingState
+ BasePrelude: getNumCapabilities :: IO Int
+ BasePrelude: getNumProcessors :: IO Int
+ BasePrelude: getProgName :: IO String
+ BasePrelude: getUncaughtExceptionHandler :: IO (SomeException -> IO ())
+ BasePrelude: gfoldl :: Data a => (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. () => g -> c g) -> a -> c a
+ BasePrelude: gmapM :: (Data a, Monad m) => (forall d. Data d => d -> m d) -> a -> m a
+ BasePrelude: gmapMo :: (Data a, MonadPlus m) => (forall d. Data d => d -> m d) -> a -> m a
+ BasePrelude: gmapMp :: (Data a, MonadPlus m) => (forall d. Data d => d -> m d) -> a -> m a
+ BasePrelude: gmapQ :: Data a => (forall d. Data d => d -> u) -> a -> [u]
+ BasePrelude: gmapQi :: Data a => Int -> (forall d. Data d => d -> u) -> a -> u
+ BasePrelude: gmapQl :: Data a => (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
+ BasePrelude: gmapQr :: Data a => (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
+ BasePrelude: gmapT :: Data a => (forall b. Data b => b -> b) -> a -> a
+ BasePrelude: group :: Eq a => [a] -> [[a]]
+ BasePrelude: groupBy :: () => (a -> a -> Bool) -> [a] -> [[a]]
+ BasePrelude: groupWith :: Ord b => (a -> b) -> [a] -> [[a]]
+ BasePrelude: guard :: Alternative f => Bool -> f ()
+ BasePrelude: gunfold :: Data a => (forall b r. Data b => c (b -> r) -> c r) -> (forall r. () => r -> c r) -> Constr -> c a
+ BasePrelude: hClose :: Handle -> IO ()
+ BasePrelude: hFileSize :: Handle -> IO Integer
+ BasePrelude: hFlush :: Handle -> IO ()
+ BasePrelude: hGetBuf :: () => Handle -> Ptr a -> Int -> IO Int
+ BasePrelude: hGetBufNonBlocking :: () => Handle -> Ptr a -> Int -> IO Int
+ BasePrelude: hGetBufSome :: () => Handle -> Ptr a -> Int -> IO Int
+ BasePrelude: hGetBuffering :: Handle -> IO BufferMode
+ BasePrelude: hGetChar :: Handle -> IO Char
+ BasePrelude: hGetContents :: Handle -> IO String
+ BasePrelude: hGetEcho :: Handle -> IO Bool
+ BasePrelude: hGetEncoding :: Handle -> IO (Maybe TextEncoding)
+ BasePrelude: hGetLine :: Handle -> IO String
+ BasePrelude: hGetPosn :: Handle -> IO HandlePosn
+ BasePrelude: hIsClosed :: Handle -> IO Bool
+ BasePrelude: hIsEOF :: Handle -> IO Bool
+ BasePrelude: hIsOpen :: Handle -> IO Bool
+ BasePrelude: hIsReadable :: Handle -> IO Bool
+ BasePrelude: hIsSeekable :: Handle -> IO Bool
+ BasePrelude: hIsTerminalDevice :: Handle -> IO Bool
+ BasePrelude: hIsWritable :: Handle -> IO Bool
+ BasePrelude: hLookAhead :: Handle -> IO Char
+ BasePrelude: hPrint :: Show a => Handle -> a -> IO ()
+ BasePrelude: hPrintf :: HPrintfType r => Handle -> String -> r
+ BasePrelude: hPutBuf :: () => Handle -> Ptr a -> Int -> IO ()
+ BasePrelude: hPutBufNonBlocking :: () => Handle -> Ptr a -> Int -> IO Int
+ BasePrelude: hPutChar :: Handle -> Char -> IO ()
+ BasePrelude: hPutStr :: Handle -> String -> IO ()
+ BasePrelude: hPutStrLn :: Handle -> String -> IO ()
+ BasePrelude: hReady :: Handle -> IO Bool
+ BasePrelude: hSeek :: Handle -> SeekMode -> Integer -> IO ()
+ BasePrelude: hSetBinaryMode :: Handle -> Bool -> IO ()
+ BasePrelude: hSetBuffering :: Handle -> BufferMode -> IO ()
+ BasePrelude: hSetEcho :: Handle -> Bool -> IO ()
+ BasePrelude: hSetEncoding :: Handle -> TextEncoding -> IO ()
+ BasePrelude: hSetFileSize :: Handle -> Integer -> IO ()
+ BasePrelude: hSetNewlineMode :: Handle -> NewlineMode -> IO ()
+ BasePrelude: hSetPosn :: HandlePosn -> IO ()
+ BasePrelude: hShow :: Handle -> IO String
+ BasePrelude: hTell :: Handle -> IO Integer
+ BasePrelude: hWaitForInput :: Handle -> Int -> IO Bool
+ BasePrelude: handle :: Exception e => (e -> IO a) -> IO a -> IO a
+ BasePrelude: handleJust :: Exception e => (e -> Maybe b) -> (b -> IO a) -> IO a -> IO a
+ BasePrelude: hashStableName :: () => StableName a -> Int
+ BasePrelude: hashUnique :: Unique -> Int
+ BasePrelude: head :: () => [a] -> a
+ BasePrelude: heapOverflow :: SomeException
+ BasePrelude: id :: Category cat => cat a a
+ BasePrelude: illegalOperationErrorType :: IOErrorType
+ BasePrelude: imagPart :: () => Complex a -> a
+ BasePrelude: inRange :: Ix a => (a, a) -> a -> Bool
+ BasePrelude: index :: Ix a => (a, a) -> a -> Int
+ BasePrelude: indexConstr :: DataType -> ConIndex -> Constr
+ BasePrelude: infix 4 :~~:
+ BasePrelude: infix 5 \\
+ BasePrelude: infix 6 :+
+ BasePrelude: infixl 0 `on`
+ BasePrelude: infixl 3 <|>
+ BasePrelude: infixl 5 .|.
+ BasePrelude: infixl 6 `xor`
+ BasePrelude: infixl 7 %
+ BasePrelude: infixl 8 `rotateR`
+ BasePrelude: infixl 9 !!
+ BasePrelude: infixr 0 $!
+ BasePrelude: infixr 1 =<<
+ BasePrelude: infixr 2 ||
+ BasePrelude: infixr 3 &&
+ BasePrelude: infixr 5 :|
+ BasePrelude: infixr 6 <>
+ BasePrelude: infixr 8 ^
+ BasePrelude: infixr 9 .
+ BasePrelude: init :: () => [a] -> [a]
+ BasePrelude: inits :: () => [a] -> [[a]]
+ BasePrelude: inline :: () => a -> a
+ BasePrelude: insert :: Ord a => a -> [a] -> [a]
+ BasePrelude: insertBy :: () => (a -> a -> Ordering) -> a -> [a] -> [a]
+ BasePrelude: intPtrToPtr :: () => IntPtr -> Ptr a
+ BasePrelude: intToDigit :: Int -> Char
+ BasePrelude: interact :: (String -> String) -> IO ()
+ BasePrelude: intercalate :: () => [a] -> [[a]] -> [a]
+ BasePrelude: interruptible :: () => IO a -> IO a
+ BasePrelude: intersect :: Eq a => [a] -> [a] -> [a]
+ BasePrelude: intersectBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]
+ BasePrelude: intersperse :: () => a -> [a] -> [a]
+ BasePrelude: ioError :: () => IOError -> IO a
+ BasePrelude: ioException :: () => IOException -> IO a
+ BasePrelude: ioManagerCapabilitiesChanged :: IO ()
+ BasePrelude: ioeGetErrorString :: IOError -> String
+ BasePrelude: ioeGetErrorType :: IOError -> IOErrorType
+ BasePrelude: ioeGetFileName :: IOError -> Maybe FilePath
+ BasePrelude: ioeGetHandle :: IOError -> Maybe Handle
+ BasePrelude: ioeGetLocation :: IOError -> String
+ BasePrelude: ioeSetErrorString :: IOError -> String -> IOError
+ BasePrelude: ioeSetErrorType :: IOError -> IOErrorType -> IOError
+ BasePrelude: ioeSetFileName :: IOError -> FilePath -> IOError
+ BasePrelude: ioeSetHandle :: IOError -> Handle -> IOError
+ BasePrelude: ioeSetLocation :: IOError -> String -> IOError
+ BasePrelude: isAlgType :: DataType -> Bool
+ BasePrelude: isAlpha :: Char -> Bool
+ BasePrelude: isAlphaNum :: Char -> Bool
+ BasePrelude: isAlreadyExistsError :: IOError -> Bool
+ BasePrelude: isAlreadyExistsErrorType :: IOErrorType -> Bool
+ BasePrelude: isAlreadyInUseError :: IOError -> Bool
+ BasePrelude: isAlreadyInUseErrorType :: IOErrorType -> Bool
+ BasePrelude: isAscii :: Char -> Bool
+ BasePrelude: isAsciiLower :: Char -> Bool
+ BasePrelude: isAsciiUpper :: Char -> Bool
+ BasePrelude: isControl :: Char -> Bool
+ BasePrelude: isCurrentThreadBound :: IO Bool
+ BasePrelude: isDenormalized :: RealFloat a => a -> Bool
+ BasePrelude: isDigit :: Char -> Bool
+ BasePrelude: isDoesNotExistError :: IOError -> Bool
+ BasePrelude: isDoesNotExistErrorType :: IOErrorType -> Bool
+ BasePrelude: isEOF :: IO Bool
+ BasePrelude: isEOFError :: IOError -> Bool
+ BasePrelude: isEOFErrorType :: IOErrorType -> Bool
+ BasePrelude: isEmptyMVar :: () => MVar a -> IO Bool
+ BasePrelude: isFullError :: IOError -> Bool
+ BasePrelude: isFullErrorType :: IOErrorType -> Bool
+ BasePrelude: isHexDigit :: Char -> Bool
+ BasePrelude: isIEEE :: RealFloat a => a -> Bool
+ BasePrelude: isIllegalOperation :: IOError -> Bool
+ BasePrelude: isIllegalOperationErrorType :: IOErrorType -> Bool
+ BasePrelude: isInfinite :: RealFloat a => a -> Bool
+ BasePrelude: isInfixOf :: Eq a => [a] -> [a] -> Bool
+ BasePrelude: isJust :: () => Maybe a -> Bool
+ BasePrelude: isLatin1 :: Char -> Bool
+ BasePrelude: isLeft :: () => Either a b -> Bool
+ BasePrelude: isLetter :: Char -> Bool
+ BasePrelude: isLower :: Char -> Bool
+ BasePrelude: isMark :: Char -> Bool
+ BasePrelude: isNaN :: RealFloat a => a -> Bool
+ BasePrelude: isNegativeZero :: RealFloat a => a -> Bool
+ BasePrelude: isNorepType :: DataType -> Bool
+ BasePrelude: isNothing :: () => Maybe a -> Bool
+ BasePrelude: isNumber :: Char -> Bool
+ BasePrelude: isOctDigit :: Char -> Bool
+ BasePrelude: isPermissionError :: IOError -> Bool
+ BasePrelude: isPermissionErrorType :: IOErrorType -> Bool
+ BasePrelude: isPrefixOf :: Eq a => [a] -> [a] -> Bool
+ BasePrelude: isPrint :: Char -> Bool
+ BasePrelude: isPunctuation :: Char -> Bool
+ BasePrelude: isRight :: () => Either a b -> Bool
+ BasePrelude: isSeparator :: Char -> Bool
+ BasePrelude: isSigned :: Bits a => a -> Bool
+ BasePrelude: isSpace :: Char -> Bool
+ BasePrelude: isSuffixOf :: Eq a => [a] -> [a] -> Bool
+ BasePrelude: isSymbol :: Char -> Bool
+ BasePrelude: isUpper :: Char -> Bool
+ BasePrelude: isUserError :: IOError -> Bool
+ BasePrelude: isUserErrorType :: IOErrorType -> Bool
+ BasePrelude: iterate :: () => (a -> a) -> a -> [a]
+ BasePrelude: iterate' :: () => (a -> a) -> a -> [a]
+ BasePrelude: join :: Monad m => m (m a) -> m a
+ BasePrelude: killThread :: ThreadId -> IO ()
+ BasePrelude: labelThread :: ThreadId -> String -> IO ()
+ BasePrelude: last :: () => [a] -> a
+ BasePrelude: latin1 :: TextEncoding
+ BasePrelude: lazy :: () => a -> a
+ BasePrelude: lcm :: Integral a => a -> a -> a
+ BasePrelude: left :: ArrowChoice a => a b c -> a (Either b d) (Either c d)
+ BasePrelude: leftApp :: ArrowApply a => a b c -> a (Either b d) (Either c d)
+ BasePrelude: lefts :: () => [Either a b] -> [a]
+ BasePrelude: length :: Foldable t => t a -> Int
+ BasePrelude: lex :: ReadS String
+ BasePrelude: lexDigits :: ReadS String
+ BasePrelude: lexLitChar :: ReadS String
+ BasePrelude: liftA :: Applicative f => (a -> b) -> f a -> f b
+ BasePrelude: liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
+ BasePrelude: liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
+ BasePrelude: liftCompare :: Ord1 f => (a -> b -> Ordering) -> f a -> f b -> Ordering
+ BasePrelude: liftCompare2 :: Ord2 f => (a -> b -> Ordering) -> (c -> d -> Ordering) -> f a c -> f b d -> Ordering
+ BasePrelude: liftEq :: Eq1 f => (a -> b -> Bool) -> f a -> f b -> Bool
+ BasePrelude: liftEq2 :: Eq2 f => (a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool
+ BasePrelude: liftIO :: MonadIO m => IO a -> m a
+ BasePrelude: liftM :: Monad m => (a1 -> r) -> m a1 -> m r
+ BasePrelude: liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
+ BasePrelude: liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
+ BasePrelude: liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
+ BasePrelude: liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
+ BasePrelude: liftReadList :: Read1 f => (Int -> ReadS a) -> ReadS [a] -> ReadS [f a]
+ BasePrelude: liftReadList2 :: Read2 f => (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [f a b]
+ BasePrelude: liftReadList2Default :: Read2 f => (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [f a b]
+ BasePrelude: liftReadListDefault :: Read1 f => (Int -> ReadS a) -> ReadS [a] -> ReadS [f a]
+ BasePrelude: liftReadListPrec :: Read1 f => ReadPrec a -> ReadPrec [a] -> ReadPrec [f a]
+ BasePrelude: liftReadListPrec2 :: Read2 f => ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [f a b]
+ BasePrelude: liftReadListPrec2Default :: Read2 f => ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [f a b]
+ BasePrelude: liftReadListPrecDefault :: Read1 f => ReadPrec a -> ReadPrec [a] -> ReadPrec [f a]
+ BasePrelude: liftReadPrec :: Read1 f => ReadPrec a -> ReadPrec [a] -> ReadPrec (f a)
+ BasePrelude: liftReadPrec2 :: Read2 f => ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (f a b)
+ BasePrelude: liftReadsPrec :: Read1 f => (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a)
+ BasePrelude: liftReadsPrec2 :: Read2 f => (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (f a b)
+ BasePrelude: liftShowList :: Show1 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS
+ BasePrelude: liftShowList2 :: Show2 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [f a b] -> ShowS
+ BasePrelude: liftShowsPrec :: Show1 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS
+ BasePrelude: liftShowsPrec2 :: Show2 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> f a b -> ShowS
+ BasePrelude: lines :: String -> [String]
+ BasePrelude: listToMaybe :: () => [a] -> Maybe a
+ BasePrelude: localeEncoding :: TextEncoding
+ BasePrelude: log :: Floating a => a -> a
+ BasePrelude: log1mexp :: Floating a => a -> a
+ BasePrelude: log1p :: Floating a => a -> a
+ BasePrelude: log1pexp :: Floating a => a -> a
+ BasePrelude: logBase :: Floating a => a -> a -> a
+ BasePrelude: lookup :: Eq a => a -> [(a, b)] -> Maybe b
+ BasePrelude: lookupEnv :: String -> IO (Maybe String)
+ BasePrelude: loop :: ArrowLoop a => a (b, d) (c, d) -> a b c
+ BasePrelude: magnitude :: RealFloat a => Complex a -> a
+ BasePrelude: makeStableName :: () => a -> IO (StableName a)
+ BasePrelude: makeVersion :: [Int] -> Version
+ BasePrelude: mallocForeignPtr :: Storable a => IO (ForeignPtr a)
+ BasePrelude: mallocForeignPtrArray :: Storable a => Int -> IO (ForeignPtr a)
+ BasePrelude: mallocForeignPtrArray0 :: Storable a => Int -> IO (ForeignPtr a)
+ BasePrelude: mallocForeignPtrBytes :: () => Int -> IO (ForeignPtr a)
+ BasePrelude: many :: Alternative f => f a -> f [a]
+ BasePrelude: map :: () => (a -> b) -> [a] -> [b]
+ BasePrelude: mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
+ BasePrelude: mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
+ BasePrelude: mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
+ BasePrelude: mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
+ BasePrelude: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
+ BasePrelude: mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
+ BasePrelude: mapMaybe :: () => (a -> Maybe b) -> [a] -> [b]
+ BasePrelude: mappend :: Monoid a => a -> a -> a
+ BasePrelude: mask :: () => ((forall a. () => IO a -> IO a) -> IO b) -> IO b
+ BasePrelude: mask_ :: () => IO a -> IO a
+ BasePrelude: max :: Ord a => a -> a -> a
+ BasePrelude: maxBound :: Bounded a => a
+ BasePrelude: maxConstrIndex :: DataType -> ConIndex
+ BasePrelude: maximum :: (Foldable t, Ord a) => t a -> a
+ BasePrelude: maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
+ BasePrelude: maybe :: () => b -> (a -> b) -> Maybe a -> b
+ BasePrelude: maybeToList :: () => Maybe a -> [a]
+ BasePrelude: mconcat :: Monoid a => [a] -> a
+ BasePrelude: mempty :: Monoid a => a
+ BasePrelude: mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
+ BasePrelude: mfix :: MonadFix m => (a -> m a) -> m a
+ BasePrelude: min :: Ord a => a -> a -> a
+ BasePrelude: minBound :: Bounded a => a
+ BasePrelude: minimum :: (Foldable t, Ord a) => t a -> a
+ BasePrelude: minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
+ BasePrelude: minusPtr :: () => Ptr a -> Ptr b -> Int
+ BasePrelude: mkCharConstr :: DataType -> Char -> Constr
+ BasePrelude: mkCharType :: String -> DataType
+ BasePrelude: mkConstr :: DataType -> String -> [String] -> Fixity -> Constr
+ BasePrelude: mkDataType :: String -> [Constr] -> DataType
+ BasePrelude: mkFloatType :: String -> DataType
+ BasePrelude: mkFunTy :: TypeRep -> TypeRep -> TypeRep
+ BasePrelude: mkIOError :: IOErrorType -> String -> Maybe Handle -> Maybe FilePath -> IOError
+ BasePrelude: mkIntType :: String -> DataType
+ BasePrelude: mkIntegralConstr :: (Integral a, Show a) => DataType -> a -> Constr
+ BasePrelude: mkNoRepType :: String -> DataType
+ BasePrelude: mkPolar :: Floating a => a -> a -> Complex a
+ BasePrelude: mkRealConstr :: (Real a, Show a) => DataType -> a -> Constr
+ BasePrelude: mkTextEncoding :: String -> IO TextEncoding
+ BasePrelude: mkWeakIORef :: () => IORef a -> IO () -> IO (Weak (IORef a))
+ BasePrelude: mkWeakMVar :: () => MVar a -> IO () -> IO (Weak (MVar a))
+ BasePrelude: mkWeakThreadId :: ThreadId -> IO (Weak ThreadId)
+ BasePrelude: mod :: Integral a => a -> a -> a
+ BasePrelude: mod' :: Real a => a -> a -> a
+ BasePrelude: modifyIOError :: () => (IOError -> IOError) -> IO a -> IO a
+ BasePrelude: modifyIORef :: () => IORef a -> (a -> a) -> IO ()
+ BasePrelude: modifyIORef' :: () => IORef a -> (a -> a) -> IO ()
+ BasePrelude: modifyMVar :: () => MVar a -> (a -> IO (a, b)) -> IO b
+ BasePrelude: modifyMVarMasked :: () => MVar a -> (a -> IO (a, b)) -> IO b
+ BasePrelude: modifyMVarMasked_ :: () => MVar a -> (a -> IO a) -> IO ()
+ BasePrelude: modifyMVar_ :: () => MVar a -> (a -> IO a) -> IO ()
+ BasePrelude: modifySTRef :: () => STRef s a -> (a -> a) -> ST s ()
+ BasePrelude: modifySTRef' :: () => STRef s a -> (a -> a) -> ST s ()
+ BasePrelude: mplus :: MonadPlus m => m a -> m a -> m a
+ BasePrelude: msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
+ BasePrelude: mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
+ BasePrelude: myThreadId :: IO ThreadId
+ BasePrelude: mzero :: MonadPlus m => m a
+ BasePrelude: nativeNewline :: Newline
+ BasePrelude: nativeNewlineMode :: NewlineMode
+ BasePrelude: negate :: Num a => a -> a
+ BasePrelude: newChan :: () => IO (Chan a)
+ BasePrelude: newEmptyMVar :: () => IO (MVar a)
+ BasePrelude: newForeignPtr :: () => FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
+ BasePrelude: newForeignPtrEnv :: () => FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO (ForeignPtr a)
+ BasePrelude: newForeignPtr_ :: () => Ptr a -> IO (ForeignPtr a)
+ BasePrelude: newIORef :: () => a -> IO (IORef a)
+ BasePrelude: newMVar :: () => a -> IO (MVar a)
+ BasePrelude: newQSem :: Int -> IO QSem
+ BasePrelude: newQSemN :: Int -> IO QSemN
+ BasePrelude: newSTRef :: () => a -> ST s (STRef s a)
+ BasePrelude: newStablePtr :: () => a -> IO (StablePtr a)
+ BasePrelude: newStablePtrPrimMVar :: MVar () -> IO (StablePtr PrimMVar)
+ BasePrelude: newTVar :: () => a -> STM (TVar a)
+ BasePrelude: newTVarIO :: () => a -> IO (TVar a)
+ BasePrelude: newUnique :: IO Unique
+ BasePrelude: newtype All
+ BasePrelude: newtype Any
+ BasePrelude: newtype ArrowMonad (a :: Type -> Type -> Type) b
+ BasePrelude: newtype AssertionFailed
+ BasePrelude: newtype CompactionFailed
+ BasePrelude: newtype Down a
+ BasePrelude: newtype Dual a
+ BasePrelude: newtype Endo a
+ BasePrelude: newtype First a
+ BasePrelude: newtype Fixed a
+ BasePrelude: newtype Identity a
+ BasePrelude: newtype IntPtr
+ BasePrelude: newtype Kleisli (m :: Type -> Type) a b
+ BasePrelude: newtype Last a
+ BasePrelude: newtype Max a
+ BasePrelude: newtype Min a
+ BasePrelude: newtype NoMethodError
+ BasePrelude: newtype Option a
+ BasePrelude: newtype PatternMatchFail
+ BasePrelude: newtype Product a
+ BasePrelude: newtype RecConError
+ BasePrelude: newtype RecSelError
+ BasePrelude: newtype RecUpdError
+ BasePrelude: newtype STM a
+ BasePrelude: newtype Sum a
+ BasePrelude: newtype Const a (b :: k) :: forall k. () => Type -> k -> Type
+ BasePrelude: newtype TypeError
+ BasePrelude: newtype WordPtr
+ BasePrelude: newtype WrappedArrow (a :: Type -> Type -> Type) b c
+ BasePrelude: newtype WrappedMonad (m :: Type -> Type) a
+ BasePrelude: newtype WrappedMonoid m
+ BasePrelude: newtype ZipList a
+ BasePrelude: newtype Alt (f :: k -> Type) (a :: k) :: forall k. () => k -> Type -> k -> Type
+ BasePrelude: noNewlineTranslation :: NewlineMode
+ BasePrelude: not :: Bool -> Bool
+ BasePrelude: notElem :: (Foldable t, Eq a) => a -> t a -> Bool
+ BasePrelude: nub :: Eq a => [a] -> [a]
+ BasePrelude: nubBy :: () => (a -> a -> Bool) -> [a] -> [a]
+ BasePrelude: null :: Foldable t => t a -> Bool
+ BasePrelude: nullFunPtr :: () => FunPtr a
+ BasePrelude: nullPtr :: () => Ptr a
+ BasePrelude: numCapabilities :: Int
+ BasePrelude: numSparks :: IO Int
+ BasePrelude: numerator :: () => Ratio a -> a
+ BasePrelude: odd :: Integral a => a -> Bool
+ BasePrelude: on :: () => (b -> b -> c) -> (a -> b) -> a -> a -> c
+ BasePrelude: onException :: () => IO a -> IO b -> IO a
+ BasePrelude: openBinaryFile :: FilePath -> IOMode -> IO Handle
+ BasePrelude: openBinaryTempFile :: FilePath -> String -> IO (FilePath, Handle)
+ BasePrelude: openBinaryTempFileWithDefaultPermissions :: FilePath -> String -> IO (FilePath, Handle)
+ BasePrelude: openFile :: FilePath -> IOMode -> IO Handle
+ BasePrelude: openTempFile :: FilePath -> String -> IO (FilePath, Handle)
+ BasePrelude: openTempFileWithDefaultPermissions :: FilePath -> String -> IO (FilePath, Handle)
+ BasePrelude: option :: () => b -> (a -> b) -> Option a -> b
+ BasePrelude: optional :: Alternative f => f a -> f (Maybe a)
+ BasePrelude: or :: Foldable t => t Bool -> Bool
+ BasePrelude: orElse :: () => STM a -> STM a -> STM a
+ BasePrelude: ord :: Char -> Int
+ BasePrelude: otherwise :: Bool
+ BasePrelude: par :: () => a -> b -> b
+ BasePrelude: parseVersion :: ReadP Version
+ BasePrelude: partition :: () => (a -> Bool) -> [a] -> ([a], [a])
+ BasePrelude: partitionEithers :: () => [Either a b] -> ([a], [b])
+ BasePrelude: pattern ErrorCall :: () => () => String -> ErrorCall
+ BasePrelude: peek :: Storable a => Ptr a -> IO a
+ BasePrelude: peekByteOff :: Storable a => Ptr b -> Int -> IO a
+ BasePrelude: peekElemOff :: Storable a => Ptr a -> Int -> IO a
+ BasePrelude: performGC :: IO ()
+ BasePrelude: performMajorGC :: IO ()
+ BasePrelude: performMinorGC :: IO ()
+ BasePrelude: permissionErrorType :: IOErrorType
+ BasePrelude: permutations :: () => [a] -> [[a]]
+ BasePrelude: phase :: RealFloat a => Complex a -> a
+ BasePrelude: pi :: Floating a => a
+ BasePrelude: plusForeignPtr :: () => ForeignPtr a -> Int -> ForeignPtr b
+ BasePrelude: plusPtr :: () => Ptr a -> Int -> Ptr b
+ BasePrelude: poke :: Storable a => Ptr a -> a -> IO ()
+ BasePrelude: pokeByteOff :: Storable a => Ptr b -> Int -> a -> IO ()
+ BasePrelude: pokeElemOff :: Storable a => Ptr a -> Int -> a -> IO ()
+ BasePrelude: polar :: RealFloat a => Complex a -> (a, a)
+ BasePrelude: popCount :: Bits a => a -> Int
+ BasePrelude: popCountDefault :: (Bits a, Num a) => a -> Int
+ BasePrelude: pred :: Enum a => a -> a
+ BasePrelude: print :: Show a => a -> IO ()
+ BasePrelude: printf :: PrintfType r => String -> r
+ BasePrelude: product :: (Foldable t, Num a) => t a -> a
+ BasePrelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ BasePrelude: pseq :: () => a -> b -> b
+ BasePrelude: ptrToIntPtr :: () => Ptr a -> IntPtr
+ BasePrelude: ptrToWordPtr :: () => Ptr a -> WordPtr
+ BasePrelude: pure :: Applicative f => a -> f a
+ BasePrelude: putChar :: Char -> IO ()
+ BasePrelude: putMVar :: () => MVar a -> a -> IO ()
+ BasePrelude: putStr :: String -> IO ()
+ BasePrelude: putStrLn :: String -> IO ()
+ BasePrelude: putTraceMsg :: String -> IO ()
+ BasePrelude: quot :: Integral a => a -> a -> a
+ BasePrelude: quotRem :: Integral a => a -> a -> (a, a)
+ BasePrelude: range :: Ix a => (a, a) -> [a]
+ BasePrelude: rangeSize :: Ix a => (a, a) -> Int
+ BasePrelude: read :: Read a => String -> a
+ BasePrelude: readBinaryWith :: () => ReadPrec a -> ReadPrec b -> String -> (a -> b -> t) -> ReadPrec t
+ BasePrelude: readChan :: () => Chan a -> IO a
+ BasePrelude: readConstr :: DataType -> String -> Maybe Constr
+ BasePrelude: readData :: () => ReadPrec a -> ReadPrec a
+ BasePrelude: readDec :: (Eq a, Num a) => ReadS a
+ BasePrelude: readEither :: Read a => String -> Either String a
+ BasePrelude: readFile :: FilePath -> IO String
+ BasePrelude: readFloat :: RealFrac a => ReadS a
+ BasePrelude: readHex :: (Eq a, Num a) => ReadS a
+ BasePrelude: readIO :: Read a => String -> IO a
+ BasePrelude: readIORef :: () => IORef a -> IO a
+ BasePrelude: readInt :: Num a => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
+ BasePrelude: readList :: Read a => ReadS [a]
+ BasePrelude: readListPrec :: Read a => ReadPrec [a]
+ BasePrelude: readLitChar :: ReadS Char
+ BasePrelude: readLn :: Read a => IO a
+ BasePrelude: readMVar :: () => MVar a -> IO a
+ BasePrelude: readMaybe :: Read a => String -> Maybe a
+ BasePrelude: readOct :: (Eq a, Num a) => ReadS a
+ BasePrelude: readP_to_Prec :: () => (Int -> ReadP a) -> ReadPrec a
+ BasePrelude: readP_to_S :: () => ReadP a -> ReadS a
+ BasePrelude: readParen :: () => Bool -> ReadS a -> ReadS a
+ BasePrelude: readPrec :: Read a => ReadPrec a
+ BasePrelude: readPrec1 :: (Read1 f, Read a) => ReadPrec (f a)
+ BasePrelude: readPrec2 :: (Read2 f, Read a, Read b) => ReadPrec (f a b)
+ BasePrelude: readPrec_to_P :: () => ReadPrec a -> Int -> ReadP a
+ BasePrelude: readPrec_to_S :: () => ReadPrec a -> Int -> ReadS a
+ BasePrelude: readSTRef :: () => STRef s a -> ST s a
+ BasePrelude: readS_to_P :: () => ReadS a -> ReadP a
+ BasePrelude: readS_to_Prec :: () => (Int -> ReadS a) -> ReadPrec a
+ BasePrelude: readSigned :: Real a => ReadS a -> ReadS a
+ BasePrelude: readTVar :: () => TVar a -> STM a
+ BasePrelude: readTVarIO :: () => TVar a -> IO a
+ BasePrelude: readUnaryWith :: () => ReadPrec a -> String -> (a -> t) -> ReadPrec t
+ BasePrelude: reads :: Read a => ReadS a
+ BasePrelude: readsBinary1 :: (Read1 f, Read1 g, Read a) => String -> (f a -> g a -> t) -> String -> ReadS t
+ BasePrelude: readsBinaryWith :: () => (Int -> ReadS a) -> (Int -> ReadS b) -> String -> (a -> b -> t) -> String -> ReadS t
+ BasePrelude: readsData :: () => (String -> ReadS a) -> Int -> ReadS a
+ BasePrelude: readsPrec :: Read a => Int -> ReadS a
+ BasePrelude: readsPrec1 :: (Read1 f, Read a) => Int -> ReadS (f a)
+ BasePrelude: readsPrec2 :: (Read2 f, Read a, Read b) => Int -> ReadS (f a b)
+ BasePrelude: readsUnary :: Read a => String -> (a -> t) -> String -> ReadS t
+ BasePrelude: readsUnary1 :: (Read1 f, Read a) => String -> (f a -> t) -> String -> ReadS t
+ BasePrelude: readsUnaryWith :: () => (Int -> ReadS a) -> String -> (a -> t) -> String -> ReadS t
+ BasePrelude: realPart :: () => Complex a -> a
+ BasePrelude: realToFrac :: (Real a, Fractional b) => a -> b
+ BasePrelude: recip :: Fractional a => a -> a
+ BasePrelude: registerDelay :: Int -> IO (TVar Bool)
+ BasePrelude: rem :: Integral a => a -> a -> a
+ BasePrelude: repConstr :: DataType -> ConstrRep -> Constr
+ BasePrelude: repeat :: () => a -> [a]
+ BasePrelude: replicate :: () => Int -> a -> [a]
+ BasePrelude: replicateM :: Applicative m => Int -> m a -> m [a]
+ BasePrelude: replicateM_ :: Applicative m => Int -> m a -> m ()
+ BasePrelude: reportError :: SomeException -> IO ()
+ BasePrelude: reportHeapOverflow :: IO ()
+ BasePrelude: reportStackOverflow :: IO ()
+ BasePrelude: resolution :: HasResolution a => p a -> Integer
+ BasePrelude: retry :: () => STM a
+ BasePrelude: return :: Monad m => a -> m a
+ BasePrelude: returnA :: Arrow a => a b b
+ BasePrelude: reverse :: () => [a] -> [a]
+ BasePrelude: right :: ArrowChoice a => a b c -> a (Either d b) (Either d c)
+ BasePrelude: rights :: () => [Either a b] -> [b]
+ BasePrelude: rnfTyCon :: TyCon -> ()
+ BasePrelude: rnfTypeRep :: TypeRep -> ()
+ BasePrelude: rotate :: Bits a => a -> Int -> a
+ BasePrelude: rotateL :: Bits a => a -> Int -> a
+ BasePrelude: rotateR :: Bits a => a -> Int -> a
+ BasePrelude: round :: (RealFrac a, Integral b) => a -> b
+ BasePrelude: rtsSupportsBoundThreads :: Bool
+ BasePrelude: runHandlers :: ForeignPtr Word8 -> Signal -> IO ()
+ BasePrelude: runInBoundThread :: () => IO a -> IO a
+ BasePrelude: runInUnboundThread :: () => IO a -> IO a
+ BasePrelude: runST :: () => (forall s. () => ST s a) -> a
+ BasePrelude: runSparks :: IO ()
+ BasePrelude: scaleFloat :: RealFloat a => Int -> a -> a
+ BasePrelude: scanl :: () => (b -> a -> b) -> b -> [a] -> [b]
+ BasePrelude: scanl' :: () => (b -> a -> b) -> b -> [a] -> [b]
+ BasePrelude: scanl1 :: () => (a -> a -> a) -> [a] -> [a]
+ BasePrelude: scanr :: () => (a -> b -> b) -> b -> [a] -> [b]
+ BasePrelude: scanr1 :: () => (a -> a -> a) -> [a] -> [a]
+ BasePrelude: sconcat :: Semigroup a => NonEmpty a -> a
+ BasePrelude: second :: Bifunctor p => (b -> c) -> p a b -> p a c
+ BasePrelude: seq :: () => a -> b -> b
+ BasePrelude: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
+ BasePrelude: sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
+ BasePrelude: sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
+ BasePrelude: sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
+ BasePrelude: setAllocationCounter :: Int64 -> IO ()
+ BasePrelude: setBit :: Bits a => a -> Int -> a
+ BasePrelude: setEnv :: String -> String -> IO ()
+ BasePrelude: setHandler :: Signal -> Maybe (HandlerFun, Dynamic) -> IO (Maybe (HandlerFun, Dynamic))
+ BasePrelude: setNumCapabilities :: Int -> IO ()
+ BasePrelude: setUncaughtExceptionHandler :: (SomeException -> IO ()) -> IO ()
+ BasePrelude: shift :: Bits a => a -> Int -> a
+ BasePrelude: shiftL :: Bits a => a -> Int -> a
+ BasePrelude: shiftR :: Bits a => a -> Int -> a
+ BasePrelude: show :: Show a => a -> String
+ BasePrelude: showChar :: Char -> ShowS
+ BasePrelude: showConstr :: Constr -> String
+ BasePrelude: showEFloat :: RealFloat a => Maybe Int -> a -> ShowS
+ BasePrelude: showFFloat :: RealFloat a => Maybe Int -> a -> ShowS
+ BasePrelude: showFFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS
+ BasePrelude: showFixed :: HasResolution a => Bool -> Fixed a -> String
+ BasePrelude: showFloat :: RealFloat a => a -> ShowS
+ BasePrelude: showGFloat :: RealFloat a => Maybe Int -> a -> ShowS
+ BasePrelude: showGFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS
+ BasePrelude: showHFloat :: RealFloat a => a -> ShowS
+ BasePrelude: showHex :: (Integral a, Show a) => a -> ShowS
+ BasePrelude: showInt :: Integral a => a -> ShowS
+ BasePrelude: showIntAtBase :: (Integral a, Show a) => a -> (Int -> Char) -> a -> ShowS
+ BasePrelude: showList :: Show a => [a] -> ShowS
+ BasePrelude: showLitChar :: Char -> ShowS
+ BasePrelude: showOct :: (Integral a, Show a) => a -> ShowS
+ BasePrelude: showParen :: Bool -> ShowS -> ShowS
+ BasePrelude: showSigned :: Real a => (a -> ShowS) -> Int -> a -> ShowS
+ BasePrelude: showString :: String -> ShowS
+ BasePrelude: showVersion :: Version -> String
+ BasePrelude: shows :: Show a => a -> ShowS
+ BasePrelude: showsBinary1 :: (Show1 f, Show1 g, Show a) => String -> Int -> f a -> g a -> ShowS
+ BasePrelude: showsBinaryWith :: () => (Int -> a -> ShowS) -> (Int -> b -> ShowS) -> String -> Int -> a -> b -> ShowS
+ BasePrelude: showsPrec :: Show a => Int -> a -> ShowS
+ BasePrelude: showsPrec1 :: (Show1 f, Show a) => Int -> f a -> ShowS
+ BasePrelude: showsPrec2 :: (Show2 f, Show a, Show b) => Int -> f a b -> ShowS
+ BasePrelude: showsTypeRep :: TypeRep -> ShowS
+ BasePrelude: showsUnary :: Show a => String -> Int -> a -> ShowS
+ BasePrelude: showsUnary1 :: (Show1 f, Show a) => String -> Int -> f a -> ShowS
+ BasePrelude: showsUnaryWith :: () => (Int -> a -> ShowS) -> String -> Int -> a -> ShowS
+ BasePrelude: signalQSem :: QSem -> IO ()
+ BasePrelude: signalQSemN :: QSemN -> Int -> IO ()
+ BasePrelude: significand :: RealFloat a => a -> a
+ BasePrelude: signum :: Num a => a -> a
+ BasePrelude: sin :: Floating a => a -> a
+ BasePrelude: sinh :: Floating a => a -> a
+ BasePrelude: sizeOf :: Storable a => a -> Int
+ BasePrelude: snd :: () => (a, b) -> b
+ BasePrelude: some :: Alternative f => f a -> f [a]
+ BasePrelude: sort :: Ord a => [a] -> [a]
+ BasePrelude: sortBy :: () => (a -> a -> Ordering) -> [a] -> [a]
+ BasePrelude: sortWith :: Ord b => (a -> b) -> [a] -> [a]
+ BasePrelude: span :: () => (a -> Bool) -> [a] -> ([a], [a])
+ BasePrelude: splitAt :: () => Int -> [a] -> ([a], [a])
+ BasePrelude: splitTyConApp :: TypeRep -> (TyCon, [TypeRep])
+ BasePrelude: sqrt :: Floating a => a -> a
+ BasePrelude: stToIO :: () => ST RealWorld a -> IO a
+ BasePrelude: stackOverflow :: SomeException
+ BasePrelude: stderr :: Handle
+ BasePrelude: stdin :: Handle
+ BasePrelude: stdout :: Handle
+ BasePrelude: stimes :: (Semigroup a, Integral b) => b -> a -> a
+ BasePrelude: stimesIdempotent :: Integral b => b -> a -> a
+ BasePrelude: stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
+ BasePrelude: stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
+ BasePrelude: stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]
+ BasePrelude: subsequences :: () => [a] -> [[a]]
+ BasePrelude: subtract :: Num a => a -> a -> a
+ BasePrelude: succ :: Enum a => a -> a
+ BasePrelude: sum :: (Foldable t, Num a) => t a -> a
+ BasePrelude: swap :: () => (a, b) -> (b, a)
+ BasePrelude: swapMVar :: () => MVar a -> a -> IO a
+ BasePrelude: tail :: () => [a] -> [a]
+ BasePrelude: tails :: () => [a] -> [[a]]
+ BasePrelude: take :: () => Int -> [a] -> [a]
+ BasePrelude: takeMVar :: () => MVar a -> IO a
+ BasePrelude: takeWhile :: () => (a -> Bool) -> [a] -> [a]
+ BasePrelude: tan :: Floating a => a -> a
+ BasePrelude: tanh :: Floating a => a -> a
+ BasePrelude: testBit :: Bits a => a -> Int -> Bool
+ BasePrelude: testBitDefault :: (Bits a, Num a) => a -> Int -> Bool
+ BasePrelude: threadCapability :: ThreadId -> IO (Int, Bool)
+ BasePrelude: threadDelay :: Int -> IO ()
+ BasePrelude: threadStatus :: ThreadId -> IO ThreadStatus
+ BasePrelude: threadWaitRead :: Fd -> IO ()
+ BasePrelude: threadWaitReadSTM :: Fd -> IO (STM (), IO ())
+ BasePrelude: threadWaitWrite :: Fd -> IO ()
+ BasePrelude: threadWaitWriteSTM :: Fd -> IO (STM (), IO ())
+ BasePrelude: throw :: Exception e => e -> a
+ BasePrelude: throwIO :: Exception e => e -> IO a
+ BasePrelude: throwSTM :: Exception e => e -> STM a
+ BasePrelude: throwTo :: Exception e => ThreadId -> e -> IO ()
+ BasePrelude: timeout :: () => Int -> IO a -> IO (Maybe a)
+ BasePrelude: toConstr :: Data a => a -> Constr
+ BasePrelude: toDyn :: Typeable a => a -> Dynamic
+ BasePrelude: toEnum :: Enum a => Int -> a
+ BasePrelude: toException :: Exception e => e -> SomeException
+ BasePrelude: toInteger :: Integral a => a -> Integer
+ BasePrelude: toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
+ BasePrelude: toList :: IsList l => l -> [Item l]
+ BasePrelude: toLower :: Char -> Char
+ BasePrelude: toRational :: Real a => a -> Rational
+ BasePrelude: toTitle :: Char -> Char
+ BasePrelude: toUpper :: Char -> Char
+ BasePrelude: touchForeignPtr :: () => ForeignPtr a -> IO ()
+ BasePrelude: trace :: () => String -> a -> a
+ BasePrelude: traceEvent :: () => String -> a -> a
+ BasePrelude: traceEventIO :: String -> IO ()
+ BasePrelude: traceIO :: String -> IO ()
+ BasePrelude: traceId :: String -> String
+ BasePrelude: traceMarker :: () => String -> a -> a
+ BasePrelude: traceMarkerIO :: String -> IO ()
+ BasePrelude: traceShow :: Show a => a -> b -> b
+ BasePrelude: traceStack :: () => String -> a -> a
+ BasePrelude: transpose :: () => [[a]] -> [[a]]
+ BasePrelude: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
+ BasePrelude: traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
+ BasePrelude: truncate :: (RealFrac a, Integral b) => a -> b
+ BasePrelude: try :: Exception e => IO a -> IO (Either e a)
+ BasePrelude: tryIOError :: () => IO a -> IO (Either IOError a)
+ BasePrelude: tryJust :: Exception e => (e -> Maybe b) -> IO a -> IO (Either b a)
+ BasePrelude: tryPutMVar :: () => MVar a -> a -> IO Bool
+ BasePrelude: tryReadMVar :: () => MVar a -> IO (Maybe a)
+ BasePrelude: tryTakeMVar :: () => MVar a -> IO (Maybe a)
+ BasePrelude: tyConFingerprint :: TyCon -> Fingerprint
+ BasePrelude: tyConModule :: TyCon -> String
+ BasePrelude: tyConName :: TyCon -> String
+ BasePrelude: tyConPackage :: TyCon -> String
+ BasePrelude: tyconModule :: String -> String
+ BasePrelude: tyconUQname :: String -> String
+ BasePrelude: type ArgMax a b = Max Arg a b
+ BasePrelude: type ArgMin a b = Min Arg a b
+ BasePrelude: type Centi = Fixed E2
+ BasePrelude: type ConIndex = Int
+ BasePrelude: type Deci = Fixed E1
+ BasePrelude: type FilePath = String
+ BasePrelude: type FinalizerEnvPtr env a = FunPtr Ptr env -> Ptr a -> IO ()
+ BasePrelude: type FinalizerPtr a = FunPtr Ptr a -> IO ()
+ BasePrelude: type HandlerFun = ForeignPtr Word8 -> IO ()
+ BasePrelude: type IOError = IOException
+ BasePrelude: type Micro = Fixed E6
+ BasePrelude: type Milli = Fixed E3
+ BasePrelude: type Nano = Fixed E9
+ BasePrelude: type Pico = Fixed E12
+ BasePrelude: type Rational = Ratio Integer
+ BasePrelude: type ReadS a = String -> [(a, String)]
+ BasePrelude: type ShowS = String -> String
+ BasePrelude: type Signal = CInt
+ BasePrelude: type String = [Char]
+ BasePrelude: type TypeRep = SomeTypeRep
+ BasePrelude: type Uni = Fixed E0
+ BasePrelude: type family Item l :: Type;
+ BasePrelude: typeOf :: Typeable a => a -> TypeRep
+ BasePrelude: typeOf1 :: Typeable t => t a -> TypeRep
+ BasePrelude: typeOf2 :: Typeable t => t a b -> TypeRep
+ BasePrelude: typeOf3 :: Typeable t => t a b c -> TypeRep
+ BasePrelude: typeOf4 :: Typeable t => t a b c d -> TypeRep
+ BasePrelude: typeOf5 :: Typeable t => t a b c d e -> TypeRep
+ BasePrelude: typeOf6 :: Typeable t => t a b c d e f -> TypeRep
+ BasePrelude: typeOf7 :: Typeable t => t a b c d e f g -> TypeRep
+ BasePrelude: typeRep :: Typeable a => proxy a -> TypeRep
+ BasePrelude: typeRepArgs :: TypeRep -> [TypeRep]
+ BasePrelude: typeRepFingerprint :: TypeRep -> Fingerprint
+ BasePrelude: typeRepTyCon :: TypeRep -> TyCon
+ BasePrelude: uncurry :: () => (a -> b -> c) -> (a, b) -> c
+ BasePrelude: undefined :: HasCallStack => a
+ BasePrelude: unfoldr :: () => (b -> Maybe (a, b)) -> b -> [a]
+ BasePrelude: uninterruptibleMask :: () => ((forall a. () => IO a -> IO a) -> IO b) -> IO b
+ BasePrelude: uninterruptibleMask_ :: () => IO a -> IO a
+ BasePrelude: union :: Eq a => [a] -> [a] -> [a]
+ BasePrelude: unionBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]
+ BasePrelude: universalNewlineMode :: NewlineMode
+ BasePrelude: unless :: Applicative f => Bool -> f () -> f ()
+ BasePrelude: unlines :: [String] -> String
+ BasePrelude: unsafeCoerce :: () => a -> b
+ BasePrelude: unsafeDupablePerformIO :: () => IO a -> a
+ BasePrelude: unsafeFixIO :: () => (a -> IO a) -> IO a
+ BasePrelude: unsafeIOToSTM :: () => IO a -> STM a
+ BasePrelude: unsafeInterleaveIO :: () => IO a -> IO a
+ BasePrelude: unsafePerformIO :: () => IO a -> a
+ BasePrelude: unsafeShiftL :: Bits a => a -> Int -> a
+ BasePrelude: unsafeShiftR :: Bits a => a -> Int -> a
+ BasePrelude: unsetEnv :: String -> IO ()
+ BasePrelude: unsupportedOperation :: IOError
+ BasePrelude: untangle :: Addr# -> String -> String
+ BasePrelude: until :: () => (a -> Bool) -> (a -> a) -> a -> a
+ BasePrelude: unwords :: [String] -> String
+ BasePrelude: unzip :: () => [(a, b)] -> ([a], [b])
+ BasePrelude: unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])
+ BasePrelude: unzip4 :: () => [(a, b, c, d)] -> ([a], [b], [c], [d])
+ BasePrelude: unzip5 :: () => [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
+ BasePrelude: unzip6 :: () => [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
+ BasePrelude: unzip7 :: () => [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
+ BasePrelude: userError :: String -> IOError
+ BasePrelude: userErrorType :: IOErrorType
+ BasePrelude: utf16 :: TextEncoding
+ BasePrelude: utf16be :: TextEncoding
+ BasePrelude: utf16le :: TextEncoding
+ BasePrelude: utf32 :: TextEncoding
+ BasePrelude: utf32be :: TextEncoding
+ BasePrelude: utf32le :: TextEncoding
+ BasePrelude: utf8 :: TextEncoding
+ BasePrelude: utf8_bom :: TextEncoding
+ BasePrelude: vacuous :: Functor f => f Void -> f a
+ BasePrelude: void :: Functor f => f a -> f ()
+ BasePrelude: waitQSem :: QSem -> IO ()
+ BasePrelude: waitQSemN :: QSemN -> Int -> IO ()
+ BasePrelude: when :: Applicative f => Bool -> f () -> f ()
+ BasePrelude: withArgs :: () => [String] -> IO a -> IO a
+ BasePrelude: withBinaryFile :: () => FilePath -> IOMode -> (Handle -> IO r) -> IO r
+ BasePrelude: withFile :: () => FilePath -> IOMode -> (Handle -> IO r) -> IO r
+ BasePrelude: withForeignPtr :: () => ForeignPtr a -> (Ptr a -> IO b) -> IO b
+ BasePrelude: withMVar :: () => MVar a -> (a -> IO b) -> IO b
+ BasePrelude: withMVarMasked :: () => MVar a -> (a -> IO b) -> IO b
+ BasePrelude: withProgName :: () => String -> IO a -> IO a
+ BasePrelude: wordPtrToPtr :: () => WordPtr -> Ptr a
+ BasePrelude: words :: String -> [String]
+ BasePrelude: writeChan :: () => Chan a -> a -> IO ()
+ BasePrelude: writeFile :: FilePath -> String -> IO ()
+ BasePrelude: writeIORef :: () => IORef a -> a -> IO ()
+ BasePrelude: writeList2Chan :: () => Chan a -> [a] -> IO ()
+ BasePrelude: writeSTRef :: () => STRef s a -> a -> ST s ()
+ BasePrelude: writeTVar :: () => TVar a -> a -> STM ()
+ BasePrelude: xor :: Bits a => a -> a -> a
+ BasePrelude: yield :: IO ()
+ BasePrelude: zeroArrow :: ArrowZero a => a b c
+ BasePrelude: zeroBits :: Bits a => a
+ BasePrelude: zip :: () => [a] -> [b] -> [(a, b)]
+ BasePrelude: zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]
+ BasePrelude: zip4 :: () => [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
+ BasePrelude: zip5 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
+ BasePrelude: zip6 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
+ BasePrelude: zip7 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
+ BasePrelude: zipWith :: () => (a -> b -> c) -> [a] -> [b] -> [c]
+ BasePrelude: zipWith3 :: () => (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
+ BasePrelude: zipWith4 :: () => (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
+ BasePrelude: zipWith5 :: () => (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
+ BasePrelude: zipWith6 :: () => (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
+ BasePrelude: zipWith7 :: () => (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
+ BasePrelude: zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
+ BasePrelude: zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
+ BasePrelude: }
- BasePrelude: infixl 1 &
+ BasePrelude: infixl 1 <&>
- BasePrelude: infixl 4 $>
+ BasePrelude: infixl 4 <**>
Files
- base-prelude.cabal +2/−2
- library/BasePrelude.hs +11/−159
base-prelude.cabal view
@@ -1,7 +1,7 @@ name: base-prelude version:- 1.3+ 1.4 synopsis: The most complete prelude formed solely from the "base" package description:@@ -56,6 +56,6 @@ exposed-modules: BasePrelude build-depends:- base >= 4.6 && < 5+ base >= 4.9 && < 5 default-language: Haskell2010
library/BasePrelude.hs view
@@ -1,4 +1,3 @@-{-# LANGUAGE CPP #-} -- | -- This module reexports most of the definitions from the \"base\" package, -- which are meant to be imported unqualified.@@ -7,21 +6,6 @@ module BasePrelude ( module Exports,- -- * Reimplementations of functions presented in versions of \"base\" newer than 4.6- -- ** Data.Bool- bool,- -- ** Data.Function- (&),- -- ** Data.Functor- ($>),- -- ** Data.List- isSubsequenceOf,- sortOn,- uncons,- -- ** Debug.Trace- traceShowId,- traceM,- traceShowM, ) where @@ -33,89 +17,61 @@ import Control.Category as Exports import Control.Concurrent as Exports import Control.Exception as Exports-import Control.Monad as Exports hiding (mapM_, sequence_, forM_, msum, mapM, sequence, forM)+import Control.Monad as Exports hiding (mapM_, sequence_, forM_, msum, mapM, sequence, forM, fail)+import Control.Monad.Fail as Exports import Control.Monad.Fix as Exports hiding (fix)-#if MIN_VERSION_base(4,9,0)-import Control.Monad.Fail as Exports (MonadFail)-#endif-#if MIN_VERSION_base(4,9,0) import Control.Monad.IO.Class as Exports-#endif import Control.Monad.ST as Exports-#if MIN_VERSION_base(4,8,0) import Data.Bifunctor as Exports-#endif import Data.Bits as Exports import Data.Bool as Exports import Data.Char as Exports-#if MIN_VERSION_base(4,7,0) import Data.Coerce as Exports-#endif import Data.Complex as Exports import Data.Data as Exports import Data.Dynamic as Exports import Data.Either as Exports import Data.Fixed as Exports-import Data.Foldable as Exports+import Data.Foldable as Exports hiding (toList)+import Data.Function as Exports hiding ((.), id) import Data.Functor as Exports-#if MIN_VERSION_base(4,9,0) import Data.Functor.Classes as Exports-#endif-#if MIN_VERSION_base(4,9,0) import Data.Functor.Compose as Exports-#endif-#if MIN_VERSION_base(4,8,0) import Data.Functor.Identity as Exports-#endif-import Data.Function as Exports hiding ((.), id) import Data.Int as Exports import Data.IORef as Exports import Data.Ix as Exports-import Data.List as Exports hiding (concat, foldr, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, find, maximumBy, minimumBy, mapAccumL, mapAccumR, foldl')-#if MIN_VERSION_base(4,9,0)+import Data.List as Exports hiding (all, and, any, concat, concatMap, elem, find, foldl, foldl', foldl1, foldr, foldr1, mapAccumL, mapAccumR, maximum, maximumBy, minimum, minimumBy, notElem, or, product, sum) import Data.List.NonEmpty as Exports (NonEmpty(..))-#endif import Data.Maybe as Exports-#if MIN_VERSION_base(4,9,0) import Data.Monoid as Exports hiding ((<>), First(..), Last(..))-#else-import Data.Monoid as Exports-#endif import Data.Ord as Exports-#if MIN_VERSION_base(4,7,0) import Data.Proxy as Exports-#endif import Data.Ratio as Exports-#if MIN_VERSION_base(4,9,0) import Data.Semigroup as Exports-#endif import Data.STRef as Exports import Data.String as Exports import Data.Traversable as Exports import Data.Tuple as Exports import Data.Unique as Exports import Data.Version as Exports-#if MIN_VERSION_base(4,8,0) import Data.Void as Exports-#endif import Data.Word as Exports import Debug.Trace as Exports-import Foreign.Storable as Exports-import Foreign.Ptr as Exports import Foreign.ForeignPtr as Exports+import Foreign.Ptr as Exports import Foreign.StablePtr as Exports+import Foreign.Storable as Exports import GHC.Conc as Exports hiding (withMVar, threadWaitWriteSTM, threadWaitWrite, threadWaitReadSTM, threadWaitRead)-import GHC.Exts as Exports (lazy, inline, sortWith, groupWith)-import GHC.Generics as Exports (Generic)+import GHC.Exts as Exports (lazy, inline, sortWith, groupWith, IsList(..))+import GHC.Generics as Exports (Generic, Generic1) import GHC.IO.Exception as Exports import Numeric as Exports-#if MIN_VERSION_base(4,8,0) import Numeric.Natural as Exports-#endif-import Prelude as Exports hiding (concat, foldr, mapM_, sequence_, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, mapM, sequence, id, (.))+import Prelude as Exports hiding (concat, foldr, mapM_, sequence_, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, mapM, sequence, id, (.), fail) import System.Environment as Exports import System.Exit as Exports-import System.IO as Exports (Handle, hClose)+import System.IO as Exports import System.IO.Error as Exports import System.IO.Unsafe as Exports import System.Mem as Exports@@ -126,107 +82,3 @@ import Text.Printf as Exports (printf, hPrintf) import Text.Read as Exports (Read(..), readMaybe, readEither) import Unsafe.Coerce as Exports--------------------------------------- Reimplementations for base-4.7------------------------------------#if !MIN_VERSION_base(4,7,0)---- | Case analysis for the 'Bool' type.--- @bool a b p@ evaluates to @a@ when @p@ is @False@, and evaluates to @b@--- when @p@ is @True@.-bool :: a -> a -> Bool -> a-bool f t b = if b then t else f--{-|-Like 'traceShow' but returns the shown value instead of a third value.--}-traceShowId :: (Show a) => a -> a-traceShowId a = trace (show a) a--{-|-Like 'trace' but returning unit in an arbitrary monad. Allows for convenient-use in do-notation. Note that the application of 'trace' is not an action in the-monad, as 'traceIO' is in the 'IO' monad.--> ... = do-> x <- ...-> traceM $ "x: " ++ show x-> y <- ...-> traceM $ "y: " ++ show y--}-traceM :: (Monad m) => String -> m ()-traceM string = trace string $ return ()--{-|-Like 'traceM', but uses 'show' on the argument to convert it to a 'String'.--> ... = do-> x <- ...-> traceShowM $ x-> y <- ...-> traceShowM $ x + y--}-traceShowM :: (Show a, Monad m) => a -> m ()-traceShowM = traceM . show--infixl 4 $>---- | Flipped version of '<$'.-($>) :: Functor f => f a -> b -> f b-($>) = flip (<$)--#endif-------------------------------------- Reimplementations for base-4.8------------------------------------#if !MIN_VERSION_base(4,8,0)--infixl 1 &---- | '&' is a reverse application operator. This provides notational--- convenience. Its precedence is one higher than that of the forward--- application operator '$', which allows '&' to be nested in '$'.-(&) :: a -> (a -> b) -> b-x & f = f x---- | The 'isSubsequenceOf' function takes two lists and returns 'True' if the--- first list is a subsequence of the second list.------ @'isSubsequenceOf' x y@ is equivalent to @'elem' x ('subsequences' y)@.------ ==== __Examples__------ >>> isSubsequenceOf "GHC" "The Glorious Haskell Compiler"--- True--- >>> isSubsequenceOf ['a','d'..'z'] ['a'..'z']--- True--- >>> isSubsequenceOf [1..10] [10,9..0]--- False-isSubsequenceOf :: (Eq a) => [a] -> [a] -> Bool-isSubsequenceOf [] _ = True-isSubsequenceOf _ [] = False-isSubsequenceOf a@(x:a') (y:b) | x == y = isSubsequenceOf a' b- | otherwise = isSubsequenceOf a b---- | Decompose a list into its head and tail. If the list is empty,--- returns 'Nothing'. If the list is non-empty, returns @'Just' (x, xs)@,--- where @x@ is the head of the list and @xs@ its tail.-uncons :: [a] -> Maybe (a, [a])-uncons [] = Nothing-uncons (x:xs) = Just (x, xs)---- | Sort a list by comparing the results of a key function applied to each--- element. @sortOn f@ is equivalent to @sortBy . comparing f@, but has the--- performance advantage of only evaluating @f@ once for each element in the--- input list. This is called the decorate-sort-undecorate paradigm, or--- Schwartzian transform.-sortOn :: Ord b => (a -> b) -> [a] -> [a]-sortOn f =- map snd . sortBy (comparing fst) . map (\x -> let y = f x in y `seq` (y, x))--#endif