base-prelude 1.4 → 1.5
raw patch · 6 files changed
+172/−62 lines, 6 filesdep ~basesetup-changedPVP ok
version bump matches the API change (PVP)
Dependency ranges changed: base
API changes (from Hackage documentation)
- BasePrelude: Option :: Maybe a -> Option a
- BasePrelude: [Handler] :: forall a e. Exception e => (e -> IO a) -> Handler a
- BasePrelude: [SomeAsyncException] :: forall e. Exception e => e -> SomeAsyncException
- BasePrelude: [SomeException] :: forall e. Exception e => e -> SomeException
- BasePrelude: [getOption] :: Option a -> Maybe a
- BasePrelude: data (:~:) (a :: k) (b :: k) :: forall k. () => k -> k -> Type
- BasePrelude: data (:~~:) (a :: k1) (b :: k2) :: forall k1 k2. () => k1 -> k2 -> Type
- BasePrelude: newtype Option a
- BasePrelude: newtype Const a (b :: k) :: forall k. () => Type -> k -> Type
- BasePrelude: newtype Alt (f :: k -> Type) (a :: k) :: forall k. () => k -> Type -> k -> Type
- BasePrelude: pattern ErrorCall :: () => () => String -> ErrorCall
+ BasePrelude: Handler :: (e -> IO a) -> Handler a
+ BasePrelude: SomeAsyncException :: e -> SomeAsyncException
+ BasePrelude: SomeException :: e -> SomeException
+ BasePrelude: [getDown] :: Down a -> a
+ BasePrelude: bitReverse16 :: Word16 -> Word16
+ BasePrelude: bitReverse32 :: Word32 -> Word32
+ BasePrelude: bitReverse64 :: Word64 -> Word64
+ BasePrelude: bitReverse8 :: Word8 -> Word8
+ BasePrelude: data (a :: k1) :~~: (b :: k2)
+ BasePrelude: data Proxy (t :: k)
+ BasePrelude: data Timeout
+ BasePrelude: foldMap' :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
+ BasePrelude: getOption :: Option a -> Maybe a
+ BasePrelude: isResourceVanishedError :: IOError -> Bool
+ BasePrelude: isResourceVanishedErrorType :: IOErrorType -> Bool
+ BasePrelude: newtype Alt (f :: k -> Type) (a :: k)
+ BasePrelude: newtype Ap (f :: k -> Type) (a :: k)
+ BasePrelude: newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1)
+ BasePrelude: newtype Const a (b :: k)
+ BasePrelude: pattern ErrorCall :: String -> ErrorCall
+ BasePrelude: resourceVanishedErrorType :: IOErrorType
+ BasePrelude.DataTypes: (:|) :: a -> [a] -> NonEmpty a
+ BasePrelude.DataTypes: False :: Bool
+ BasePrelude.DataTypes: Just :: a -> Maybe a
+ BasePrelude.DataTypes: Left :: a -> Either a b
+ BasePrelude.DataTypes: Nothing :: Maybe a
+ BasePrelude.DataTypes: Right :: b -> Either a b
+ BasePrelude.DataTypes: True :: Bool
+ BasePrelude.DataTypes: data Bool
+ BasePrelude.DataTypes: data Char
+ BasePrelude.DataTypes: data Double
+ BasePrelude.DataTypes: data Either a b
+ BasePrelude.DataTypes: data Float
+ BasePrelude.DataTypes: data Int
+ BasePrelude.DataTypes: data Int16
+ BasePrelude.DataTypes: data Int32
+ BasePrelude.DataTypes: data Int64
+ BasePrelude.DataTypes: data Int8
+ BasePrelude.DataTypes: data Integer
+ BasePrelude.DataTypes: data Maybe a
+ BasePrelude.DataTypes: data Natural
+ BasePrelude.DataTypes: data NonEmpty a
+ BasePrelude.DataTypes: data Word
+ BasePrelude.DataTypes: data Word16
+ BasePrelude.DataTypes: data Word32
+ BasePrelude.DataTypes: data Word64
+ BasePrelude.DataTypes: data Word8
+ BasePrelude.DataTypes: infixr 5 :|
+ BasePrelude.DataTypes: type Rational = Ratio Integer
+ BasePrelude.DataTypes: type String = [Char]
+ BasePrelude.Operators: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
+ BasePrelude.Operators: ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
+ BasePrelude.Operators: ($>) :: Functor f => f a -> b -> f b
+ BasePrelude.Operators: (%) :: Integral a => a -> a -> Ratio a
+ BasePrelude.Operators: (&&) :: Bool -> Bool -> Bool
+ BasePrelude.Operators: (&) :: a -> (a -> b) -> b
+ BasePrelude.Operators: (*) :: Num a => a -> a -> a
+ BasePrelude.Operators: (*>) :: Applicative f => f a -> f b -> f b
+ BasePrelude.Operators: (+) :: Num a => a -> a -> a
+ BasePrelude.Operators: (-) :: Num a => a -> a -> a
+ BasePrelude.Operators: (.&.) :: Bits a => a -> a -> a
+ BasePrelude.Operators: (.) :: (b -> c) -> (a -> b) -> a -> c
+ BasePrelude.Operators: (.|.) :: Bits a => a -> a -> a
+ BasePrelude.Operators: (/) :: Fractional a => a -> a -> a
+ BasePrelude.Operators: (/=) :: Eq a => a -> a -> Bool
+ BasePrelude.Operators: (<$) :: Functor f => a -> f b -> f a
+ BasePrelude.Operators: (<$>) :: Functor f => (a -> b) -> f a -> f b
+ BasePrelude.Operators: (<&>) :: Functor f => f a -> (a -> b) -> f b
+ BasePrelude.Operators: (<) :: Ord a => a -> a -> Bool
+ BasePrelude.Operators: (<*) :: Applicative f => f a -> f b -> f a
+ BasePrelude.Operators: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
+ BasePrelude.Operators: (<=) :: Ord a => a -> a -> Bool
+ BasePrelude.Operators: (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
+ BasePrelude.Operators: (<>) :: Semigroup a => a -> a -> a
+ BasePrelude.Operators: (<|>) :: Alternative f => f a -> f a -> f a
+ BasePrelude.Operators: (=<<) :: Monad m => (a -> m b) -> m a -> m b
+ BasePrelude.Operators: (==) :: Eq a => a -> a -> Bool
+ BasePrelude.Operators: (>) :: Ord a => a -> a -> Bool
+ BasePrelude.Operators: (>=) :: Ord a => a -> a -> Bool
+ BasePrelude.Operators: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
+ BasePrelude.Operators: (>>) :: Monad m => m a -> m b -> m b
+ BasePrelude.Operators: (>>=) :: Monad m => m a -> (a -> m b) -> m b
+ BasePrelude.Operators: (^) :: (Num a, Integral b) => a -> b -> a
+ BasePrelude.Operators: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ BasePrelude.Operators: (||) :: Bool -> Bool -> Bool
+ BasePrelude.Operators: infix 4 >=
+ BasePrelude.Operators: infixl 1 <&>
+ BasePrelude.Operators: infixl 3 <|>
+ BasePrelude.Operators: infixl 4 <$>
+ BasePrelude.Operators: infixl 5 .|.
+ BasePrelude.Operators: infixl 6 -
+ BasePrelude.Operators: infixl 7 /
+ BasePrelude.Operators: infixr 0 $!
+ BasePrelude.Operators: infixr 1 >=>
+ BasePrelude.Operators: infixr 2 ||
+ BasePrelude.Operators: infixr 3 &&
+ BasePrelude.Operators: infixr 6 <>
+ BasePrelude.Operators: infixr 8 ^^
+ BasePrelude.Operators: infixr 9 .
- BasePrelude: (!!) :: () => [a] -> Int -> a
+ BasePrelude: (!!) :: [a] -> Int -> a
- BasePrelude: ($!) :: () => (a -> b) -> a -> b
+ BasePrelude: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- BasePrelude: ($) :: () => (a -> b) -> a -> b
+ BasePrelude: ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- BasePrelude: (&) :: () => a -> (a -> b) -> b
+ BasePrelude: (&) :: a -> (a -> b) -> b
- BasePrelude: (++) :: () => [a] -> [a] -> [a]
+ BasePrelude: (++) :: [a] -> [a] -> [a]
- BasePrelude: (.) :: Category cat => cat b c -> cat a b -> cat a c
+ BasePrelude: (.) :: forall (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
- BasePrelude: (<<<) :: Category cat => cat b c -> cat a b -> cat a c
+ BasePrelude: (<<<) :: forall k cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
- BasePrelude: (>>>) :: Category cat => cat a b -> cat b c -> cat a c
+ BasePrelude: (>>>) :: forall k cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
- BasePrelude: Alt :: f a -> Alt
+ BasePrelude: Alt :: f a -> Alt (f :: k -> Type) (a :: k)
- BasePrelude: Ap :: f a -> Ap
+ BasePrelude: Ap :: f a -> Ap (f :: k -> Type) (a :: k)
- BasePrelude: ArrowMonad :: a () b -> ArrowMonad b
+ BasePrelude: ArrowMonad :: a () b -> ArrowMonad (a :: Type -> Type -> Type) b
- BasePrelude: Compose :: f (g a) -> Compose
+ BasePrelude: Compose :: f (g a) -> Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1)
- BasePrelude: Const :: a -> Const a
+ BasePrelude: Const :: a -> Const a (b :: k)
- BasePrelude: Kleisli :: (a -> m b) -> Kleisli a b
+ BasePrelude: Kleisli :: (a -> m b) -> Kleisli (m :: Type -> Type) a b
- BasePrelude: MkFixed :: Integer -> Fixed a
+ BasePrelude: MkFixed :: Integer -> Fixed (a :: k)
- BasePrelude: Proxy :: Proxy
+ BasePrelude: Proxy :: Proxy (t :: k)
- BasePrelude: WrapArrow :: a b c -> WrappedArrow b c
+ BasePrelude: WrapArrow :: a b c -> WrappedArrow (a :: Type -> Type -> Type) b c
- BasePrelude: WrapMonad :: m a -> WrappedMonad a
+ BasePrelude: WrapMonad :: m a -> WrappedMonad (m :: Type -> Type) a
- BasePrelude: [Dynamic] :: forall a. () => TypeRep a -> a -> Dynamic
+ BasePrelude: [Dynamic] :: forall a. TypeRep a -> a -> Dynamic
- BasePrelude: [HRefl] :: forall k1 k2 (a :: k1) (b :: k2). () => a :~~: a
+ BasePrelude: [HRefl] :: forall k1 (a :: k1). a :~~: a
- BasePrelude: [Refl] :: forall k (a :: k) (b :: k). () => a :~: a
+ BasePrelude: [Refl] :: forall k (a :: k). a :~: a
- BasePrelude: [getAlt] :: Alt -> f a
+ BasePrelude: [getAlt] :: Alt (f :: k -> Type) (a :: k) -> f a
- BasePrelude: [getAp] :: Ap -> f a
+ BasePrelude: [getAp] :: Ap (f :: k -> Type) (a :: k) -> f a
- BasePrelude: [getCompose] :: Compose -> f (g a)
+ BasePrelude: [getCompose] :: Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) -> f (g a)
- BasePrelude: [getConst] :: Const a -> a
+ BasePrelude: [getConst] :: Const a (b :: k) -> a
- BasePrelude: [runKleisli] :: Kleisli a b -> a -> m b
+ BasePrelude: [runKleisli] :: Kleisli (m :: Type -> Type) a b -> a -> m b
- BasePrelude: [unwrapArrow] :: WrappedArrow b c -> a b c
+ BasePrelude: [unwrapArrow] :: WrappedArrow (a :: Type -> Type -> Type) b c -> a b c
- BasePrelude: [unwrapMonad] :: WrappedMonad a -> m a
+ BasePrelude: [unwrapMonad] :: WrappedMonad (m :: Type -> Type) a -> m a
- BasePrelude: absurd :: () => Void -> a
+ BasePrelude: absurd :: Void -> a
- BasePrelude: addForeignPtrFinalizer :: () => FinalizerPtr a -> ForeignPtr a -> IO ()
+ BasePrelude: addForeignPtrFinalizer :: FinalizerPtr a -> ForeignPtr a -> IO ()
- BasePrelude: addForeignPtrFinalizerEnv :: () => FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> IO ()
+ BasePrelude: addForeignPtrFinalizerEnv :: FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> IO ()
- BasePrelude: addMVarFinalizer :: () => MVar a -> IO () -> IO ()
+ BasePrelude: addMVarFinalizer :: MVar a -> IO () -> IO ()
- BasePrelude: alignPtr :: () => Ptr a -> Int -> Ptr a
+ BasePrelude: alignPtr :: Ptr a -> Int -> Ptr a
- BasePrelude: asProxyTypeOf :: () => a -> proxy a -> a
+ BasePrelude: asProxyTypeOf :: a -> proxy a -> a
- BasePrelude: asTypeOf :: () => a -> a -> a
+ BasePrelude: asTypeOf :: a -> a -> a
- BasePrelude: assert :: () => Bool -> a -> a
+ BasePrelude: assert :: Bool -> a -> a
- BasePrelude: assertError :: ?callStack :: CallStack => Bool -> a -> a
+ BasePrelude: assertError :: (?callStack :: CallStack) => Bool -> a -> a
- BasePrelude: atomicModifyIORef :: () => IORef a -> (a -> (a, b)) -> IO b
+ BasePrelude: atomicModifyIORef :: IORef a -> (a -> (a, b)) -> IO b
- 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: atomicWriteIORef :: IORef a -> a -> IO ()
- BasePrelude: atomically :: () => STM a -> IO a
+ BasePrelude: atomically :: STM a -> IO a
- BasePrelude: bool :: () => a -> a -> Bool -> a
+ BasePrelude: bool :: a -> a -> Bool -> a
- BasePrelude: bracket :: () => IO a -> (a -> IO b) -> (a -> IO c) -> IO c
+ 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: bracketOnError :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
- BasePrelude: bracket_ :: () => IO a -> IO b -> IO c -> IO c
+ BasePrelude: bracket_ :: IO a -> IO b -> IO c -> IO c
- BasePrelude: break :: () => (a -> Bool) -> [a] -> ([a], [a])
+ BasePrelude: break :: (a -> Bool) -> [a] -> ([a], [a])
- BasePrelude: castForeignPtr :: () => ForeignPtr a -> ForeignPtr b
+ BasePrelude: castForeignPtr :: ForeignPtr a -> ForeignPtr b
- BasePrelude: castFunPtr :: () => FunPtr a -> FunPtr b
+ BasePrelude: castFunPtr :: FunPtr a -> FunPtr b
- BasePrelude: castFunPtrToPtr :: () => FunPtr a -> Ptr b
+ BasePrelude: castFunPtrToPtr :: FunPtr a -> Ptr b
- BasePrelude: castPtr :: () => Ptr a -> Ptr b
+ BasePrelude: castPtr :: Ptr a -> Ptr b
- BasePrelude: castPtrToFunPtr :: () => Ptr a -> FunPtr b
+ BasePrelude: castPtrToFunPtr :: Ptr a -> FunPtr b
- BasePrelude: castPtrToStablePtr :: () => Ptr () -> StablePtr a
+ BasePrelude: castPtrToStablePtr :: Ptr () -> StablePtr a
- BasePrelude: castStablePtrToPtr :: () => StablePtr a -> Ptr ()
+ BasePrelude: castStablePtrToPtr :: StablePtr a -> Ptr ()
- BasePrelude: catMaybes :: () => [Maybe a] -> [a]
+ BasePrelude: catMaybes :: [Maybe a] -> [a]
- BasePrelude: catchIOError :: () => IO a -> (IOError -> IO a) -> IO a
+ BasePrelude: catchIOError :: IO a -> (IOError -> IO a) -> IO a
- BasePrelude: catches :: () => IO a -> [Handler a] -> IO a
+ BasePrelude: catches :: IO a -> [Handler a] -> IO a
- BasePrelude: class a ~R# b => Coercible (a :: k0) (b :: k0)
+ BasePrelude: class a ~R# b => Coercible (a :: k) (b :: k)
- BasePrelude: class HasResolution a
+ BasePrelude: class HasResolution (a :: k)
- BasePrelude: coerce :: Coercible a b => a -> b
+ BasePrelude: coerce :: forall (k :: RuntimeRep) (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
- BasePrelude: const :: () => a -> b -> a
+ BasePrelude: const :: a -> b -> a
- BasePrelude: curry :: () => ((a, b) -> c) -> a -> b -> c
+ BasePrelude: curry :: ((a, b) -> c) -> a -> b -> c
- BasePrelude: cycle :: () => [a] -> [a]
+ BasePrelude: cycle :: [a] -> [a]
- BasePrelude: data RealWorld :: Type
+ BasePrelude: data RealWorld
- BasePrelude: deRefStablePtr :: () => StablePtr a -> IO a
+ BasePrelude: deRefStablePtr :: StablePtr a -> IO a
- BasePrelude: deleteBy :: () => (a -> a -> Bool) -> a -> [a] -> [a]
+ BasePrelude: deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
- BasePrelude: deleteFirstsBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]
+ BasePrelude: deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- BasePrelude: denominator :: () => Ratio a -> a
+ BasePrelude: denominator :: Ratio a -> a
- BasePrelude: die :: () => String -> IO a
+ BasePrelude: die :: String -> IO a
- BasePrelude: drop :: () => Int -> [a] -> [a]
+ BasePrelude: drop :: Int -> [a] -> [a]
- BasePrelude: dropWhile :: () => (a -> Bool) -> [a] -> [a]
+ BasePrelude: dropWhile :: (a -> Bool) -> [a] -> [a]
- BasePrelude: dropWhileEnd :: () => (a -> Bool) -> [a] -> [a]
+ BasePrelude: dropWhileEnd :: (a -> Bool) -> [a] -> [a]
- BasePrelude: dupChan :: () => Chan a -> IO (Chan a)
+ BasePrelude: dupChan :: Chan a -> IO (Chan a)
- BasePrelude: either :: () => (a -> c) -> (b -> c) -> Either a b -> c
+ BasePrelude: either :: (a -> c) -> (b -> c) -> Either a b -> c
- BasePrelude: eqStableName :: () => StableName a -> StableName b -> Bool
+ BasePrelude: eqStableName :: StableName a -> StableName b -> Bool
- BasePrelude: eqT :: (Typeable a, Typeable b) => Maybe (a :~: b)
+ BasePrelude: eqT :: forall k (a :: k) (b :: k). (Typeable a, Typeable b) => Maybe (a :~: b)
- BasePrelude: error :: HasCallStack => [Char] -> a
+ BasePrelude: error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
- BasePrelude: errorWithoutStackTrace :: () => [Char] -> a
+ BasePrelude: errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a
- BasePrelude: evaluate :: () => a -> IO a
+ BasePrelude: evaluate :: a -> IO a
- BasePrelude: exitFailure :: () => IO a
+ BasePrelude: exitFailure :: IO a
- BasePrelude: exitSuccess :: () => IO a
+ BasePrelude: exitSuccess :: IO a
- BasePrelude: exitWith :: () => ExitCode -> IO a
+ BasePrelude: exitWith :: ExitCode -> IO a
- BasePrelude: filter :: () => (a -> Bool) -> [a] -> [a]
+ BasePrelude: filter :: (a -> Bool) -> [a] -> [a]
- BasePrelude: finalizeForeignPtr :: () => ForeignPtr a -> IO ()
+ BasePrelude: finalizeForeignPtr :: ForeignPtr a -> IO ()
- BasePrelude: finally :: () => IO a -> IO b -> IO a
+ BasePrelude: finally :: IO a -> IO b -> IO a
- BasePrelude: findIndex :: () => (a -> Bool) -> [a] -> Maybe Int
+ BasePrelude: findIndex :: (a -> Bool) -> [a] -> Maybe Int
- BasePrelude: findIndices :: () => (a -> Bool) -> [a] -> [Int]
+ BasePrelude: findIndices :: (a -> Bool) -> [a] -> [Int]
- BasePrelude: fix :: () => (a -> a) -> a
+ BasePrelude: fix :: (a -> a) -> a
- BasePrelude: fixIO :: () => (a -> IO a) -> IO a
+ BasePrelude: fixIO :: (a -> IO a) -> IO a
- BasePrelude: fixST :: () => (a -> ST s a) -> ST s a
+ BasePrelude: fixST :: (a -> ST s a) -> ST s a
- BasePrelude: flip :: () => (a -> b -> c) -> b -> a -> c
+ BasePrelude: flip :: (a -> b -> c) -> b -> a -> c
- BasePrelude: foldl1' :: () => (a -> a -> a) -> [a] -> a
+ BasePrelude: foldl1' :: (a -> a -> a) -> [a] -> a
- BasePrelude: forkFinally :: () => IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
+ BasePrelude: forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
- BasePrelude: freeHaskellFunPtr :: () => FunPtr a -> IO ()
+ BasePrelude: freeHaskellFunPtr :: FunPtr a -> IO ()
- BasePrelude: freeStablePtr :: () => StablePtr a -> IO ()
+ BasePrelude: freeStablePtr :: StablePtr a -> IO ()
- BasePrelude: fromJust :: () => Maybe a -> a
+ BasePrelude: fromJust :: HasCallStack => Maybe a -> a
- BasePrelude: fromLeft :: () => a -> Either a b -> a
+ BasePrelude: fromLeft :: a -> Either a b -> a
- BasePrelude: fromMaybe :: () => a -> Maybe a -> a
+ BasePrelude: fromMaybe :: a -> Maybe a -> a
- BasePrelude: fromRight :: () => b -> Either a b -> b
+ BasePrelude: fromRight :: b -> Either a b -> b
- BasePrelude: fst :: () => (a, b) -> a
+ BasePrelude: fst :: (a, b) -> a
- BasePrelude: gcast :: (Typeable a, Typeable b) => c a -> Maybe (c b)
+ BasePrelude: gcast :: forall k (a :: k) (b :: k) c. (Typeable a, Typeable b) => c a -> Maybe (c b)
- BasePrelude: gcast1 :: (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a))
+ BasePrelude: gcast1 :: forall k1 k2 c (t :: k2 -> k1) (t' :: k2 -> k1) (a :: k2). (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: gcast2 :: forall k1 k2 k3 c (t :: k2 -> k3 -> k1) (t' :: k2 -> k3 -> k1) (a :: k2) (b :: k3). (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b))
- BasePrelude: getChanContents :: () => Chan a -> IO [a]
+ BasePrelude: getChanContents :: Chan a -> IO [a]
- BasePrelude: gmapQr :: Data a => (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
+ BasePrelude: gmapQr :: forall r r'. Data a => (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
- BasePrelude: groupBy :: () => (a -> a -> Bool) -> [a] -> [[a]]
+ BasePrelude: groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
- BasePrelude: hGetBuf :: () => Handle -> Ptr a -> Int -> IO Int
+ BasePrelude: hGetBuf :: Handle -> Ptr a -> Int -> IO Int
- BasePrelude: hGetBufNonBlocking :: () => Handle -> Ptr a -> Int -> IO Int
+ BasePrelude: hGetBufNonBlocking :: Handle -> Ptr a -> Int -> IO Int
- BasePrelude: hGetBufSome :: () => Handle -> Ptr a -> Int -> IO Int
+ BasePrelude: hGetBufSome :: Handle -> Ptr a -> Int -> IO Int
- BasePrelude: hPutBuf :: () => Handle -> Ptr a -> Int -> IO ()
+ BasePrelude: hPutBuf :: Handle -> Ptr a -> Int -> IO ()
- BasePrelude: hPutBufNonBlocking :: () => Handle -> Ptr a -> Int -> IO Int
+ BasePrelude: hPutBufNonBlocking :: Handle -> Ptr a -> Int -> IO Int
- BasePrelude: hashStableName :: () => StableName a -> Int
+ BasePrelude: hashStableName :: StableName a -> Int
- BasePrelude: head :: () => [a] -> a
+ BasePrelude: head :: [a] -> a
- BasePrelude: id :: Category cat => cat a a
+ BasePrelude: id :: forall (a :: k). Category cat => cat a a
- BasePrelude: imagPart :: () => Complex a -> a
+ BasePrelude: imagPart :: Complex a -> a
- BasePrelude: infixl 8 `rotateR`
+ BasePrelude: infixl 8 `shift`
- BasePrelude: init :: () => [a] -> [a]
+ BasePrelude: init :: [a] -> [a]
- BasePrelude: inits :: () => [a] -> [[a]]
+ BasePrelude: inits :: [a] -> [[a]]
- BasePrelude: inline :: () => a -> a
+ BasePrelude: inline :: a -> a
- BasePrelude: insertBy :: () => (a -> a -> Ordering) -> a -> [a] -> [a]
+ BasePrelude: insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
- BasePrelude: intPtrToPtr :: () => IntPtr -> Ptr a
+ BasePrelude: intPtrToPtr :: IntPtr -> Ptr a
- BasePrelude: intercalate :: () => [a] -> [[a]] -> [a]
+ BasePrelude: intercalate :: [a] -> [[a]] -> [a]
- BasePrelude: interruptible :: () => IO a -> IO a
+ BasePrelude: interruptible :: IO a -> IO a
- BasePrelude: intersectBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]
+ BasePrelude: intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- BasePrelude: intersperse :: () => a -> [a] -> [a]
+ BasePrelude: intersperse :: a -> [a] -> [a]
- BasePrelude: ioError :: () => IOError -> IO a
+ BasePrelude: ioError :: IOError -> IO a
- BasePrelude: ioException :: () => IOException -> IO a
+ BasePrelude: ioException :: IOException -> IO a
- BasePrelude: isEmptyMVar :: () => MVar a -> IO Bool
+ BasePrelude: isEmptyMVar :: MVar a -> IO Bool
- BasePrelude: isJust :: () => Maybe a -> Bool
+ BasePrelude: isJust :: Maybe a -> Bool
- BasePrelude: isLeft :: () => Either a b -> Bool
+ BasePrelude: isLeft :: Either a b -> Bool
- BasePrelude: isNothing :: () => Maybe a -> Bool
+ BasePrelude: isNothing :: Maybe a -> Bool
- BasePrelude: isRight :: () => Either a b -> Bool
+ BasePrelude: isRight :: Either a b -> Bool
- BasePrelude: iterate :: () => (a -> a) -> a -> [a]
+ BasePrelude: iterate :: (a -> a) -> a -> [a]
- BasePrelude: iterate' :: () => (a -> a) -> a -> [a]
+ BasePrelude: iterate' :: (a -> a) -> a -> [a]
- BasePrelude: last :: () => [a] -> a
+ BasePrelude: last :: [a] -> a
- BasePrelude: lazy :: () => a -> a
+ BasePrelude: lazy :: a -> a
- BasePrelude: lefts :: () => [Either a b] -> [a]
+ BasePrelude: lefts :: [Either a b] -> [a]
- BasePrelude: listToMaybe :: () => [a] -> Maybe a
+ BasePrelude: listToMaybe :: [a] -> Maybe a
- BasePrelude: makeStableName :: () => a -> IO (StableName a)
+ BasePrelude: makeStableName :: a -> IO (StableName a)
- BasePrelude: mallocForeignPtrBytes :: () => Int -> IO (ForeignPtr a)
+ BasePrelude: mallocForeignPtrBytes :: Int -> IO (ForeignPtr a)
- BasePrelude: map :: () => (a -> b) -> [a] -> [b]
+ BasePrelude: map :: (a -> b) -> [a] -> [b]
- BasePrelude: mapMaybe :: () => (a -> Maybe b) -> [a] -> [b]
+ BasePrelude: mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- BasePrelude: mask :: () => ((forall a. () => IO a -> IO a) -> IO b) -> IO b
+ BasePrelude: mask :: ((forall a. () => IO a -> IO a) -> IO b) -> IO b
- BasePrelude: mask_ :: () => IO a -> IO a
+ BasePrelude: mask_ :: IO a -> IO a
- BasePrelude: maybe :: () => b -> (a -> b) -> Maybe a -> b
+ BasePrelude: maybe :: b -> (a -> b) -> Maybe a -> b
- BasePrelude: maybeToList :: () => Maybe a -> [a]
+ BasePrelude: maybeToList :: Maybe a -> [a]
- BasePrelude: minusPtr :: () => Ptr a -> Ptr b -> Int
+ BasePrelude: minusPtr :: Ptr a -> Ptr b -> Int
- BasePrelude: mkWeakIORef :: () => IORef a -> IO () -> IO (Weak (IORef a))
+ BasePrelude: mkWeakIORef :: IORef a -> IO () -> IO (Weak (IORef a))
- BasePrelude: mkWeakMVar :: () => MVar a -> IO () -> IO (Weak (MVar a))
+ BasePrelude: mkWeakMVar :: MVar a -> IO () -> IO (Weak (MVar a))
- BasePrelude: modifyIOError :: () => (IOError -> IOError) -> IO a -> IO a
+ BasePrelude: modifyIOError :: (IOError -> IOError) -> IO a -> IO a
- BasePrelude: modifyIORef :: () => IORef a -> (a -> a) -> IO ()
+ BasePrelude: modifyIORef :: IORef a -> (a -> a) -> IO ()
- 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: 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, b)) -> IO b
- BasePrelude: modifyMVarMasked_ :: () => MVar a -> (a -> IO a) -> IO ()
+ BasePrelude: modifyMVarMasked_ :: MVar a -> (a -> IO a) -> IO ()
- BasePrelude: modifyMVar_ :: () => 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: modifySTRef' :: () => STRef s a -> (a -> a) -> ST s ()
+ BasePrelude: modifySTRef' :: STRef s a -> (a -> a) -> ST s ()
- BasePrelude: newChan :: () => IO (Chan a)
+ BasePrelude: newChan :: IO (Chan a)
- BasePrelude: newEmptyMVar :: () => IO (MVar a)
+ BasePrelude: newEmptyMVar :: IO (MVar a)
- BasePrelude: newForeignPtr :: () => FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
+ BasePrelude: newForeignPtr :: FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
- BasePrelude: newForeignPtrEnv :: () => FinalizerEnvPtr env a -> Ptr env -> 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: newForeignPtr_ :: Ptr a -> IO (ForeignPtr a)
- BasePrelude: newIORef :: () => a -> IO (IORef a)
+ BasePrelude: newIORef :: a -> IO (IORef a)
- BasePrelude: newMVar :: () => a -> IO (MVar a)
+ BasePrelude: newMVar :: a -> IO (MVar a)
- BasePrelude: newSTRef :: () => a -> ST s (STRef s a)
+ BasePrelude: newSTRef :: a -> ST s (STRef s a)
- BasePrelude: newStablePtr :: () => a -> IO (StablePtr a)
+ BasePrelude: newStablePtr :: a -> IO (StablePtr a)
- BasePrelude: newTVar :: () => a -> STM (TVar a)
+ BasePrelude: newTVar :: a -> STM (TVar a)
- BasePrelude: newTVarIO :: () => a -> IO (TVar a)
+ BasePrelude: newTVarIO :: a -> IO (TVar a)
- BasePrelude: newtype Fixed a
+ BasePrelude: newtype Fixed (a :: k)
- BasePrelude: nubBy :: () => (a -> a -> Bool) -> [a] -> [a]
+ BasePrelude: nubBy :: (a -> a -> Bool) -> [a] -> [a]
- BasePrelude: nullFunPtr :: () => FunPtr a
+ BasePrelude: nullFunPtr :: FunPtr a
- BasePrelude: nullPtr :: () => Ptr a
+ BasePrelude: nullPtr :: Ptr a
- BasePrelude: numerator :: () => Ratio a -> a
+ BasePrelude: numerator :: Ratio a -> a
- BasePrelude: on :: () => (b -> b -> c) -> (a -> b) -> a -> a -> c
+ BasePrelude: on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- BasePrelude: onException :: () => IO a -> IO b -> IO a
+ BasePrelude: onException :: IO a -> IO b -> IO a
- BasePrelude: option :: () => b -> (a -> b) -> Option a -> b
+ BasePrelude: option :: b -> (a -> b) -> Option a -> b
- BasePrelude: orElse :: () => STM a -> STM a -> STM a
+ BasePrelude: orElse :: STM a -> STM a -> STM a
- BasePrelude: par :: () => a -> b -> b
+ BasePrelude: par :: a -> b -> b
- BasePrelude: partition :: () => (a -> Bool) -> [a] -> ([a], [a])
+ BasePrelude: partition :: (a -> Bool) -> [a] -> ([a], [a])
- BasePrelude: partitionEithers :: () => [Either a b] -> ([a], [b])
+ BasePrelude: partitionEithers :: [Either a b] -> ([a], [b])
- BasePrelude: permutations :: () => [a] -> [[a]]
+ BasePrelude: permutations :: [a] -> [[a]]
- BasePrelude: plusForeignPtr :: () => ForeignPtr a -> Int -> ForeignPtr b
+ BasePrelude: plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b
- BasePrelude: plusPtr :: () => Ptr a -> Int -> Ptr b
+ BasePrelude: plusPtr :: Ptr a -> Int -> Ptr b
- BasePrelude: pseq :: () => a -> b -> b
+ BasePrelude: pseq :: a -> b -> b
- BasePrelude: ptrToIntPtr :: () => Ptr a -> IntPtr
+ BasePrelude: ptrToIntPtr :: Ptr a -> IntPtr
- BasePrelude: ptrToWordPtr :: () => Ptr a -> WordPtr
+ BasePrelude: ptrToWordPtr :: Ptr a -> WordPtr
- BasePrelude: putMVar :: () => MVar a -> a -> IO ()
+ BasePrelude: putMVar :: MVar a -> a -> IO ()
- BasePrelude: readBinaryWith :: () => ReadPrec a -> ReadPrec b -> String -> (a -> b -> t) -> ReadPrec t
+ BasePrelude: readBinaryWith :: ReadPrec a -> ReadPrec b -> String -> (a -> b -> t) -> ReadPrec t
- BasePrelude: readChan :: () => Chan a -> IO a
+ BasePrelude: readChan :: Chan a -> IO a
- BasePrelude: readData :: () => ReadPrec a -> ReadPrec a
+ BasePrelude: readData :: ReadPrec a -> ReadPrec a
- BasePrelude: readIORef :: () => IORef a -> IO a
+ BasePrelude: readIORef :: IORef a -> IO a
- BasePrelude: readMVar :: () => MVar a -> IO a
+ BasePrelude: readMVar :: MVar a -> IO a
- BasePrelude: readP_to_Prec :: () => (Int -> ReadP a) -> ReadPrec a
+ BasePrelude: readP_to_Prec :: (Int -> ReadP a) -> ReadPrec a
- BasePrelude: readP_to_S :: () => ReadP a -> ReadS a
+ BasePrelude: readP_to_S :: ReadP a -> ReadS a
- BasePrelude: readParen :: () => Bool -> ReadS a -> ReadS a
+ BasePrelude: readParen :: Bool -> ReadS a -> ReadS a
- BasePrelude: readPrec_to_P :: () => ReadPrec a -> Int -> ReadP a
+ BasePrelude: readPrec_to_P :: ReadPrec a -> Int -> ReadP a
- BasePrelude: readPrec_to_S :: () => ReadPrec a -> Int -> ReadS a
+ BasePrelude: readPrec_to_S :: ReadPrec a -> Int -> ReadS a
- BasePrelude: readSTRef :: () => STRef s a -> ST s a
+ BasePrelude: readSTRef :: STRef s a -> ST s a
- BasePrelude: readS_to_P :: () => ReadS a -> ReadP a
+ BasePrelude: readS_to_P :: ReadS a -> ReadP a
- BasePrelude: readS_to_Prec :: () => (Int -> ReadS a) -> ReadPrec a
+ BasePrelude: readS_to_Prec :: (Int -> ReadS a) -> ReadPrec a
- BasePrelude: readTVar :: () => TVar a -> STM a
+ BasePrelude: readTVar :: TVar a -> STM a
- BasePrelude: readTVarIO :: () => TVar a -> IO a
+ BasePrelude: readTVarIO :: TVar a -> IO a
- BasePrelude: readUnaryWith :: () => ReadPrec a -> String -> (a -> t) -> ReadPrec t
+ BasePrelude: readUnaryWith :: ReadPrec a -> String -> (a -> t) -> ReadPrec t
- BasePrelude: readsBinaryWith :: () => (Int -> ReadS a) -> (Int -> ReadS b) -> String -> (a -> b -> 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: readsData :: (String -> ReadS a) -> Int -> ReadS a
- BasePrelude: readsUnaryWith :: () => (Int -> ReadS a) -> String -> (a -> t) -> String -> ReadS t
+ BasePrelude: readsUnaryWith :: (Int -> ReadS a) -> String -> (a -> t) -> String -> ReadS t
- BasePrelude: realPart :: () => Complex a -> a
+ BasePrelude: realPart :: Complex a -> a
- BasePrelude: repeat :: () => a -> [a]
+ BasePrelude: repeat :: a -> [a]
- BasePrelude: replicate :: () => Int -> a -> [a]
+ BasePrelude: replicate :: Int -> a -> [a]
- BasePrelude: retry :: () => STM a
+ BasePrelude: retry :: STM a
- BasePrelude: reverse :: () => [a] -> [a]
+ BasePrelude: reverse :: [a] -> [a]
- BasePrelude: rights :: () => [Either a b] -> [b]
+ BasePrelude: rights :: [Either a b] -> [b]
- BasePrelude: runInBoundThread :: () => IO a -> IO a
+ BasePrelude: runInBoundThread :: IO a -> IO a
- BasePrelude: runInUnboundThread :: () => IO a -> IO a
+ BasePrelude: runInUnboundThread :: IO a -> IO a
- BasePrelude: runST :: () => (forall s. () => ST s a) -> a
+ BasePrelude: runST :: (forall s. () => ST s a) -> a
- BasePrelude: scanl :: () => (b -> a -> b) -> b -> [a] -> [b]
+ BasePrelude: scanl :: (b -> a -> b) -> b -> [a] -> [b]
- BasePrelude: scanl' :: () => (b -> a -> b) -> b -> [a] -> [b]
+ BasePrelude: scanl' :: (b -> a -> b) -> b -> [a] -> [b]
- BasePrelude: scanl1 :: () => (a -> a -> a) -> [a] -> [a]
+ BasePrelude: scanl1 :: (a -> a -> a) -> [a] -> [a]
- BasePrelude: scanr :: () => (a -> b -> b) -> b -> [a] -> [b]
+ BasePrelude: scanr :: (a -> b -> b) -> b -> [a] -> [b]
- BasePrelude: scanr1 :: () => (a -> a -> a) -> [a] -> [a]
+ BasePrelude: scanr1 :: (a -> a -> a) -> [a] -> [a]
- BasePrelude: seq :: () => a -> b -> b
+ BasePrelude: seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b
- BasePrelude: showFixed :: HasResolution a => Bool -> Fixed a -> String
+ BasePrelude: showFixed :: forall k (a :: k). HasResolution a => Bool -> Fixed a -> String
- BasePrelude: showsBinaryWith :: () => (Int -> a -> ShowS) -> (Int -> b -> ShowS) -> String -> Int -> a -> b -> ShowS
+ BasePrelude: showsBinaryWith :: (Int -> a -> ShowS) -> (Int -> b -> ShowS) -> String -> Int -> a -> b -> ShowS
- BasePrelude: showsUnaryWith :: () => (Int -> a -> ShowS) -> String -> Int -> a -> ShowS
+ BasePrelude: showsUnaryWith :: (Int -> a -> ShowS) -> String -> Int -> a -> ShowS
- BasePrelude: snd :: () => (a, b) -> b
+ BasePrelude: snd :: (a, b) -> b
- BasePrelude: sortBy :: () => (a -> a -> Ordering) -> [a] -> [a]
+ BasePrelude: sortBy :: (a -> a -> Ordering) -> [a] -> [a]
- BasePrelude: span :: () => (a -> Bool) -> [a] -> ([a], [a])
+ BasePrelude: span :: (a -> Bool) -> [a] -> ([a], [a])
- BasePrelude: splitAt :: () => Int -> [a] -> ([a], [a])
+ BasePrelude: splitAt :: Int -> [a] -> ([a], [a])
- BasePrelude: stToIO :: () => ST RealWorld a -> IO a
+ BasePrelude: stToIO :: ST RealWorld a -> IO a
- BasePrelude: subsequences :: () => [a] -> [[a]]
+ BasePrelude: subsequences :: [a] -> [[a]]
- BasePrelude: swap :: () => (a, b) -> (b, a)
+ BasePrelude: swap :: (a, b) -> (b, a)
- BasePrelude: swapMVar :: () => MVar a -> a -> IO a
+ BasePrelude: swapMVar :: MVar a -> a -> IO a
- BasePrelude: tail :: () => [a] -> [a]
+ BasePrelude: tail :: [a] -> [a]
- BasePrelude: tails :: () => [a] -> [[a]]
+ BasePrelude: tails :: [a] -> [[a]]
- BasePrelude: take :: () => Int -> [a] -> [a]
+ BasePrelude: take :: Int -> [a] -> [a]
- BasePrelude: takeMVar :: () => MVar a -> IO a
+ BasePrelude: takeMVar :: MVar a -> IO a
- BasePrelude: takeWhile :: () => (a -> Bool) -> [a] -> [a]
+ BasePrelude: takeWhile :: (a -> Bool) -> [a] -> [a]
- BasePrelude: throw :: Exception e => e -> a
+ BasePrelude: throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a
- BasePrelude: timeout :: () => Int -> IO a -> IO (Maybe a)
+ BasePrelude: timeout :: Int -> IO a -> IO (Maybe a)
- BasePrelude: touchForeignPtr :: () => ForeignPtr a -> IO ()
+ BasePrelude: touchForeignPtr :: ForeignPtr a -> IO ()
- BasePrelude: trace :: () => String -> a -> a
+ BasePrelude: trace :: String -> a -> a
- BasePrelude: traceEvent :: () => String -> a -> a
+ BasePrelude: traceEvent :: String -> a -> a
- BasePrelude: traceMarker :: () => String -> a -> a
+ BasePrelude: traceMarker :: String -> a -> a
- BasePrelude: traceStack :: () => String -> a -> a
+ BasePrelude: traceStack :: String -> a -> a
- BasePrelude: transpose :: () => [[a]] -> [[a]]
+ BasePrelude: transpose :: [[a]] -> [[a]]
- BasePrelude: tryIOError :: () => IO a -> IO (Either IOError a)
+ BasePrelude: tryIOError :: IO a -> IO (Either IOError a)
- BasePrelude: tryPutMVar :: () => MVar a -> a -> IO Bool
+ BasePrelude: tryPutMVar :: MVar a -> a -> IO Bool
- BasePrelude: tryReadMVar :: () => MVar a -> IO (Maybe a)
+ BasePrelude: tryReadMVar :: MVar a -> IO (Maybe a)
- BasePrelude: tryTakeMVar :: () => MVar a -> IO (Maybe a)
+ BasePrelude: tryTakeMVar :: MVar a -> IO (Maybe a)
- BasePrelude: type family Item l :: Type;
+ BasePrelude: type family Item l
- BasePrelude: typeRep :: Typeable a => proxy a -> TypeRep
+ BasePrelude: typeRep :: forall k proxy (a :: k). Typeable a => proxy a -> TypeRep
- BasePrelude: uncons :: () => [a] -> Maybe (a, [a])
+ BasePrelude: uncons :: [a] -> Maybe (a, [a])
- BasePrelude: uncurry :: () => (a -> b -> c) -> (a, b) -> c
+ BasePrelude: uncurry :: (a -> b -> c) -> (a, b) -> c
- BasePrelude: undefined :: HasCallStack => a
+ BasePrelude: undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
- BasePrelude: unfoldr :: () => (b -> Maybe (a, b)) -> b -> [a]
+ BasePrelude: unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
- BasePrelude: uninterruptibleMask :: () => ((forall a. () => IO a -> IO a) -> IO b) -> IO b
+ BasePrelude: uninterruptibleMask :: ((forall a. () => IO a -> IO a) -> IO b) -> IO b
- BasePrelude: uninterruptibleMask_ :: () => IO a -> IO a
+ BasePrelude: uninterruptibleMask_ :: IO a -> IO a
- BasePrelude: unionBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]
+ BasePrelude: unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- BasePrelude: unsafeCoerce :: () => a -> b
+ BasePrelude: unsafeCoerce :: a -> b
- BasePrelude: unsafeDupablePerformIO :: () => IO a -> a
+ BasePrelude: unsafeDupablePerformIO :: IO a -> a
- BasePrelude: unsafeFixIO :: () => (a -> IO a) -> IO a
+ BasePrelude: unsafeFixIO :: (a -> IO a) -> IO a
- BasePrelude: unsafeIOToSTM :: () => IO a -> STM a
+ BasePrelude: unsafeIOToSTM :: IO a -> STM a
- BasePrelude: unsafeInterleaveIO :: () => IO a -> IO a
+ BasePrelude: unsafeInterleaveIO :: IO a -> IO a
- BasePrelude: unsafePerformIO :: () => IO a -> a
+ BasePrelude: unsafePerformIO :: IO a -> a
- BasePrelude: until :: () => (a -> Bool) -> (a -> a) -> a -> a
+ BasePrelude: until :: (a -> Bool) -> (a -> a) -> a -> a
- BasePrelude: unzip :: () => [(a, b)] -> ([a], [b])
+ BasePrelude: unzip :: [(a, b)] -> ([a], [b])
- BasePrelude: unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])
+ BasePrelude: unzip3 :: [(a, b, c)] -> ([a], [b], [c])
- BasePrelude: unzip4 :: () => [(a, b, c, d)] -> ([a], [b], [c], [d])
+ BasePrelude: unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])
- BasePrelude: unzip5 :: () => [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
+ 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: 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: unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
- BasePrelude: withArgs :: () => [String] -> IO a -> IO a
+ BasePrelude: withArgs :: [String] -> IO a -> IO a
- BasePrelude: withBinaryFile :: () => FilePath -> IOMode -> (Handle -> IO r) -> IO r
+ BasePrelude: withBinaryFile :: FilePath -> IOMode -> (Handle -> IO r) -> IO r
- BasePrelude: withFile :: () => 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: withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
- BasePrelude: withMVar :: () => MVar a -> (a -> IO b) -> IO b
+ BasePrelude: withMVar :: MVar a -> (a -> IO b) -> IO b
- BasePrelude: withMVarMasked :: () => MVar a -> (a -> IO b) -> IO b
+ BasePrelude: withMVarMasked :: MVar a -> (a -> IO b) -> IO b
- BasePrelude: withProgName :: () => String -> IO a -> IO a
+ BasePrelude: withProgName :: String -> IO a -> IO a
- BasePrelude: wordPtrToPtr :: () => WordPtr -> Ptr a
+ BasePrelude: wordPtrToPtr :: WordPtr -> Ptr a
- BasePrelude: writeChan :: () => Chan a -> a -> IO ()
+ BasePrelude: writeChan :: Chan a -> a -> IO ()
- BasePrelude: writeIORef :: () => IORef a -> a -> IO ()
+ BasePrelude: writeIORef :: IORef a -> a -> IO ()
- BasePrelude: writeList2Chan :: () => Chan a -> [a] -> IO ()
+ BasePrelude: writeList2Chan :: Chan a -> [a] -> IO ()
- BasePrelude: writeSTRef :: () => STRef s a -> a -> ST s ()
+ BasePrelude: writeSTRef :: STRef s a -> a -> ST s ()
- BasePrelude: writeTVar :: () => TVar a -> a -> STM ()
+ BasePrelude: writeTVar :: TVar a -> a -> STM ()
- BasePrelude: zip :: () => [a] -> [b] -> [(a, b)]
+ BasePrelude: zip :: [a] -> [b] -> [(a, b)]
- BasePrelude: zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]
+ BasePrelude: zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- BasePrelude: zip4 :: () => [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
+ BasePrelude: zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
- BasePrelude: zip5 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
+ 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: 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: zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
- BasePrelude: zipWith :: () => (a -> b -> c) -> [a] -> [b] -> [c]
+ BasePrelude: zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- BasePrelude: zipWith3 :: () => (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
+ BasePrelude: zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
- BasePrelude: zipWith4 :: () => (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
+ 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: 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: 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: zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
Files
- CHANGELOG.md +11/−0
- Setup.hs +0/−2
- base-prelude.cabal +22/−40
- library/BasePrelude.hs +16/−20
- library/BasePrelude/DataTypes.hs +51/−0
- library/BasePrelude/Operators.hs +72/−0
CHANGELOG.md view
@@ -1,3 +1,14 @@+# 1.5++* Exclude Data.Semigroup.Option+* Restrict to min GHC 8.4+* Add focused preludes for data types and operators++# 1.4++* Restrict to min GHC 8.0 and give preference to MonadFail+* Add IsList, Generic1 and export all of System.IO+ # 1.3 * Give preference to Semigroup definitions over Monoid
− Setup.hs
@@ -1,2 +0,0 @@-import Distribution.Simple-main = defaultMain
base-prelude.cabal view
@@ -1,9 +1,8 @@-name:- base-prelude-version:- 1.4-synopsis:- The most complete prelude formed solely from the "base" package+cabal-version: 3.0++name: base-prelude+version: 1.5+synopsis: The most complete prelude formed solely from the "base" package description: A library which aims to reexport all the non-conflicting and most general definitions from the \"base\" package.@@ -18,44 +17,27 @@ that its exports in part are transitively determined by the version of \"base\". Therefore it's recommended for the users of \"base-prelude\" to specify the bounds of \"base\" as well.-category:- Prelude-homepage:- https://github.com/nikita-volkov/base-prelude -bug-reports:- https://github.com/nikita-volkov/base-prelude/issues -author:- Nikita Volkov <nikita.y.volkov@mail.ru>-maintainer:- Nikita Volkov <nikita.y.volkov@mail.ru>-copyright:- (c) 2014, Nikita Volkov-license:- MIT-license-file:- LICENSE-build-type:- Simple-extra-source-files:- CHANGELOG.md-cabal-version:- >=1.10-+category: Prelude+homepage: https://github.com/nikita-volkov/base-prelude+bug-reports: https://github.com/nikita-volkov/base-prelude/issues+author: Nikita Volkov <nikita.y.volkov@mail.ru>+maintainer: Nikita Volkov <nikita.y.volkov@mail.ru>+copyright: (c) 2014, Nikita Volkov+license: MIT+license-file: LICENSE+build-type: Simple+extra-source-files: CHANGELOG.md source-repository head- type:- git- location:- git://github.com/nikita-volkov/base-prelude.git-+ type: git+ location: git://github.com/nikita-volkov/base-prelude.git library- hs-source-dirs:- library- other-modules:+ hs-source-dirs: library+ default-language: Haskell2010 exposed-modules: BasePrelude+ BasePrelude.DataTypes+ BasePrelude.Operators build-depends:- base >= 4.9 && < 5- default-language:- Haskell2010+ base >=4.11 && <5
library/BasePrelude.hs view
@@ -1,23 +1,19 @@ -- |--- This module reexports most of the definitions from the \"base\" package,--- which are meant to be imported unqualified.+-- Reexports of most of the definitions from the \"base\" package,+-- which it is a common practice to import unqualified. -- -- For details check out the source. module BasePrelude-(- module Exports,-)+ ( module Exports,+ ) where --- Reexports--------------------------- import Control.Applicative as Exports import Control.Arrow as Exports hiding (first, second) 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, fail)+import Control.Monad as Exports hiding (fail, forM, forM_, mapM, mapM_, msum, sequence, sequence_) import Control.Monad.Fail as Exports import Control.Monad.Fix as Exports hiding (fix) import Control.Monad.IO.Class as Exports@@ -33,23 +29,23 @@ import Data.Either as Exports import Data.Fixed as Exports import Data.Foldable as Exports hiding (toList)-import Data.Function as Exports hiding ((.), id)+import Data.Function as Exports hiding (id, (.)) import Data.Functor as Exports import Data.Functor.Classes as Exports import Data.Functor.Compose as Exports import Data.Functor.Identity as Exports-import Data.Int as Exports import Data.IORef as Exports+import Data.Int as Exports import Data.Ix as Exports 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(..))+import Data.List.NonEmpty as Exports (NonEmpty (..)) import Data.Maybe as Exports-import Data.Monoid as Exports hiding ((<>), First(..), Last(..))+import Data.Monoid as Exports hiding (First (..), Last (..), (<>)) import Data.Ord as Exports import Data.Proxy as Exports import Data.Ratio as Exports-import Data.Semigroup as Exports import Data.STRef as Exports+import Data.Semigroup as Exports hiding (Option) import Data.String as Exports import Data.Traversable as Exports import Data.Tuple as Exports@@ -62,13 +58,12 @@ 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, IsList(..))+import GHC.Conc as Exports hiding (threadWaitRead, threadWaitReadSTM, threadWaitWrite, threadWaitWriteSTM, withMVar)+import GHC.Exts as Exports (IsList (..), groupWith, inline, lazy, sortWith) import GHC.Generics as Exports (Generic, Generic1) import GHC.IO.Exception as Exports import Numeric as Exports import Numeric.Natural as Exports-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@@ -78,7 +73,8 @@ import System.Mem.StableName as Exports import System.Timeout as Exports import Text.ParserCombinators.ReadP as Exports (ReadP, ReadS, readP_to_S, readS_to_P)-import Text.ParserCombinators.ReadPrec as Exports (ReadPrec, readPrec_to_P, readP_to_Prec, readPrec_to_S, readS_to_Prec)-import Text.Printf as Exports (printf, hPrintf)-import Text.Read as Exports (Read(..), readMaybe, readEither)+import Text.ParserCombinators.ReadPrec as Exports (ReadPrec, readP_to_Prec, readPrec_to_P, readPrec_to_S, readS_to_Prec)+import Text.Printf as Exports (hPrintf, printf)+import Text.Read as Exports (Read (..), readEither, readMaybe) import Unsafe.Coerce as Exports+import Prelude as Exports hiding (all, and, any, concat, concatMap, elem, fail, foldl, foldl1, foldr, foldr1, id, mapM, mapM_, maximum, minimum, notElem, or, product, sequence, sequence_, sum, (.))
+ library/BasePrelude/DataTypes.hs view
@@ -0,0 +1,51 @@+-- |+-- A module that reexports only the data types+-- defined across various modules of the \"base\" package.+--+-- By data types we mean that it is the ones we use+-- to define data structures.+-- It is not abstraction integration wrappers,+-- like 'Data.Semigroup.First'.+-- It is not resource types like 'System.IO.Handle'.+module BasePrelude.DataTypes+ ( -- * From "Prelude"+ Prelude.Bool (..),+ Prelude.Char,+ Prelude.Double,+ Prelude.Either (..),+ Prelude.Float,+ Prelude.Integer,+ Prelude.Maybe (..),+ Prelude.String,++ -- * From "Data.Int"+ Data.Int.Int,+ Data.Int.Int16,+ Data.Int.Int32,+ Data.Int.Int64,+ Data.Int.Int8,++ -- * From "Data.Word"+ Data.Word.Word,+ Data.Word.Word16,+ Data.Word.Word32,+ Data.Word.Word64,+ Data.Word.Word8,++ -- * From "Data.Ratio"+ Data.Ratio.Rational,++ -- * From "Numeric.Natural"+ Numeric.Natural.Natural,++ -- * From "Data.List.NonEmpty"+ Data.List.NonEmpty.NonEmpty (..),+ )+where++import qualified Data.Int+import qualified Data.List.NonEmpty+import qualified Data.Ratio+import qualified Data.Word+import qualified Numeric.Natural+import qualified Prelude
+ library/BasePrelude/Operators.hs view
@@ -0,0 +1,72 @@+-- |+-- A collection of common operators provided across+-- various modules of the \"base\" package.+module BasePrelude.Operators+ ( -- * From "Control.Applicative"+ (Control.Applicative.*>),+ (Control.Applicative.<*),+ (Control.Applicative.<*>),+ (Control.Applicative.<|>),++ -- * From "Control.Monad"+ (Control.Monad.<=<),+ (Control.Monad.=<<),+ (Control.Monad.>=>),+ (Control.Monad.>>),+ (Control.Monad.>>=),++ -- * From "Data.Bits"+ (Data.Bits..&.),+ (Data.Bits..|.),++ -- * From "Data.Bool"+ (Data.Bool.&&),+ (Data.Bool.||),+ (Data.Eq./=),+ (Data.Eq.==),++ -- * From "Data.Function"+ (Data.Function.$),+ (Data.Function.&),+ (Data.Function..),++ -- * From "Data.Functor"+ (Data.Functor.$>),+ (Data.Functor.<$),+ (Data.Functor.<$>),+ (Data.Functor.<&>),++ -- * From "Data.Ord"+ (Data.Ord.<),+ (Data.Ord.<=),+ (Data.Ord.>),+ (Data.Ord.>=),++ -- * From "Data.Ratio"+ (Data.Ratio.%),++ -- * From "Data.Semigroup"+ (Data.Semigroup.<>),++ -- * From "Prelude"+ (Prelude.$!),+ (Prelude.*),+ (Prelude.+),+ (Prelude.-),+ (Prelude./),+ (Prelude.^),+ (Prelude.^^),+ )+where++import qualified Control.Applicative+import qualified Control.Monad+import qualified Data.Bits+import qualified Data.Bool+import qualified Data.Eq+import qualified Data.Function+import qualified Data.Functor+import qualified Data.Ord+import qualified Data.Ratio+import qualified Data.Semigroup+import qualified Prelude