basic-prelude 0.1.0.0 → 0.2.0.0
raw patch · 3 files changed
+327/−152 lines, 3 filesPVP ok
version bump matches the API change (PVP)
API changes (from Hackage documentation)
- BasicPrelude: ($) :: (a -> b) -> a -> b
- BasicPrelude: (&&&) :: Arrow a => forall b c c'. a b c -> a b c' -> a b (c, c')
- BasicPrelude: (&&) :: Bool -> Bool -> Bool
- BasicPrelude: (*) :: Num a => a -> a -> a
- BasicPrelude: (**) :: Floating a => a -> a -> a
- BasicPrelude: (***) :: Arrow a => forall b c b' c'. a b c -> a b' c' -> a (b, b') (c, c')
- BasicPrelude: (*>) :: Applicative f => f a -> f b -> f b
- BasicPrelude: (+) :: Num a => a -> a -> a
- BasicPrelude: (++) :: Monoid w => w -> w -> w
- BasicPrelude: (-) :: Num a => a -> a -> a
- BasicPrelude: (.) :: Category cat => forall b c a. cat b c -> cat a b -> cat a c
- BasicPrelude: (/) :: Fractional a => a -> a -> a
- BasicPrelude: (/=) :: Eq a => a -> a -> Bool
- BasicPrelude: (<$) :: Functor f => a -> f b -> f a
- BasicPrelude: (<$>) :: Functor f => (a -> b) -> f a -> f b
- BasicPrelude: (<) :: Ord a => a -> a -> Bool
- BasicPrelude: (<*) :: Applicative f => f a -> f b -> f a
- BasicPrelude: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
- BasicPrelude: (<.>) :: FilePath -> Text -> FilePath
- BasicPrelude: (</>) :: FilePath -> FilePath -> FilePath
- BasicPrelude: (<=) :: Ord a => a -> a -> Bool
- BasicPrelude: (=<<) :: Monad m => (a -> m b) -> m a -> m b
- BasicPrelude: (==) :: Eq a => a -> a -> Bool
- BasicPrelude: (>) :: Ord a => a -> a -> Bool
- BasicPrelude: (>=) :: Ord a => a -> a -> Bool
- BasicPrelude: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- BasicPrelude: (>>) :: Monad m => m a -> m b -> m b
- BasicPrelude: (>>=) :: Monad m => m a -> (a -> m b) -> m b
- BasicPrelude: (^) :: (Num a, Integral b) => a -> b -> a
- BasicPrelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
- BasicPrelude: (||) :: Bool -> Bool -> Bool
- BasicPrelude: EQ :: Ordering
- BasicPrelude: False :: Bool
- BasicPrelude: GT :: Ordering
- BasicPrelude: Just :: a -> Maybe a
- BasicPrelude: LT :: Ordering
- BasicPrelude: Left :: a -> Either a b
- BasicPrelude: Nothing :: Maybe a
- BasicPrelude: Right :: b -> Either a b
- BasicPrelude: True :: Bool
- BasicPrelude: abs :: Num a => a -> a
- BasicPrelude: acos :: Floating a => a -> a
- BasicPrelude: acosh :: Floating a => a -> a
- BasicPrelude: asin :: Floating a => a -> a
- BasicPrelude: asinh :: Floating a => a -> a
- BasicPrelude: atan :: Floating a => a -> a
- BasicPrelude: atan2 :: RealFloat a => a -> a -> a
- BasicPrelude: atanh :: Floating a => a -> a
- BasicPrelude: basename :: FilePath -> FilePath
- BasicPrelude: catMaybes :: [Maybe a] -> [a]
- BasicPrelude: ceiling :: (RealFrac a, Integral b) => a -> b
- BasicPrelude: class Functor f => Applicative (f :: * -> *)
- BasicPrelude: class Enum a
- BasicPrelude: class Eq a
- BasicPrelude: class (Typeable e, Show e) => Exception e
- BasicPrelude: class Fractional a => Floating a
- BasicPrelude: class Num a => Fractional a
- BasicPrelude: class Functor (f :: * -> *)
- BasicPrelude: class Hashable a
- BasicPrelude: class (Real a, Enum a) => Integral a
- BasicPrelude: class Monad (m :: * -> *)
- BasicPrelude: class Monad m => MonadIO (m :: * -> *)
- BasicPrelude: class Monoid a
- BasicPrelude: class Num a
- BasicPrelude: class Eq a => Ord a
- BasicPrelude: class (Num a, Ord a) => Real a
- BasicPrelude: class (RealFrac a, Floating a) => RealFloat a
- BasicPrelude: class (Real a, Fractional a) => RealFrac a
- BasicPrelude: class Show a
- BasicPrelude: compare :: Ord a => a -> a -> Ordering
- BasicPrelude: concat :: Monoid w => [w] -> w
- BasicPrelude: const :: a -> b -> a
- BasicPrelude: cos :: Floating a => a -> a
- BasicPrelude: cosh :: Floating a => a -> a
- BasicPrelude: data Bool :: *
- BasicPrelude: data ByteString :: *
- BasicPrelude: data Char :: *
- BasicPrelude: data Double :: *
- BasicPrelude: data Either a b :: * -> * -> *
- BasicPrelude: data FilePath :: *
- BasicPrelude: data Float :: *
- BasicPrelude: data HashMap k v :: * -> * -> *
- BasicPrelude: data HashSet a :: * -> *
- BasicPrelude: data IO a :: * -> *
- BasicPrelude: data Int :: *
- BasicPrelude: data Int64 :: *
- BasicPrelude: data Integer :: *
- BasicPrelude: data Map k a :: * -> * -> *
- BasicPrelude: data Maybe a :: * -> *
- BasicPrelude: data Ordering :: *
- BasicPrelude: data Set a :: * -> *
- BasicPrelude: data SomeException :: *
- BasicPrelude: data Text :: *
- BasicPrelude: data Vector a :: * -> *
- BasicPrelude: data Word :: *
- BasicPrelude: data Word64 :: *
- BasicPrelude: data Word8 :: *
- BasicPrelude: decodeFloat :: RealFloat a => a -> (Integer, Int)
- BasicPrelude: div :: Integral a => a -> a -> a
- BasicPrelude: divMod :: Integral a => a -> a -> (a, a)
- BasicPrelude: either :: (a -> c) -> (b -> c) -> Either a b -> c
- BasicPrelude: elem :: Eq a => a -> [a] -> Bool
- BasicPrelude: encodeFloat :: RealFloat a => Integer -> Int -> a
- BasicPrelude: enumFrom :: Enum a => a -> [a]
- BasicPrelude: enumFromThen :: Enum a => a -> a -> [a]
- BasicPrelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
- BasicPrelude: enumFromTo :: Enum a => a -> a -> [a]
- BasicPrelude: error :: [Char] -> a
- BasicPrelude: even :: Integral a => a -> Bool
- BasicPrelude: exp :: Floating a => a -> a
- BasicPrelude: exponent :: RealFloat a => a -> Int
- BasicPrelude: fail :: Monad m => String -> m a
- BasicPrelude: filename :: FilePath -> FilePath
- BasicPrelude: first :: Arrow a => forall b c d. a b c -> a (b, d) (c, d)
- BasicPrelude: flip :: (a -> b -> c) -> b -> a -> c
- BasicPrelude: floatDigits :: RealFloat a => a -> Int
- BasicPrelude: floatRadix :: RealFloat a => a -> Integer
- BasicPrelude: floatRange :: RealFloat a => a -> (Int, Int)
- BasicPrelude: floor :: (RealFrac a, Integral b) => a -> b
- BasicPrelude: fmap :: Functor f => (a -> b) -> f a -> f b
- BasicPrelude: fromEnum :: Enum a => a -> Int
- BasicPrelude: fromException :: Exception e => SomeException -> Maybe e
- BasicPrelude: fromInteger :: Num a => Integer -> a
- BasicPrelude: fromIntegral :: (Integral a, Num b) => a -> b
- BasicPrelude: fromMaybe :: a -> Maybe a -> a
- BasicPrelude: fromRational :: Fractional a => Rational -> a
- BasicPrelude: fst :: (a, b) -> a
- BasicPrelude: hasExtension :: FilePath -> Text -> Bool
- BasicPrelude: id :: Category cat => forall a. cat a a
- BasicPrelude: isDenormalized :: RealFloat a => a -> Bool
- BasicPrelude: isIEEE :: RealFloat a => a -> Bool
- BasicPrelude: isInfinite :: RealFloat a => a -> Bool
- BasicPrelude: isNaN :: RealFloat a => a -> Bool
- BasicPrelude: isNegativeZero :: RealFloat a => a -> Bool
- BasicPrelude: lift :: MonadTrans t => forall (m :: * -> *) a. Monad m => m a -> t m a
- BasicPrelude: liftIO :: MonadIO m => forall a. IO a -> m a
- BasicPrelude: log :: Floating a => a -> a
- BasicPrelude: logBase :: Floating a => a -> a -> a
- BasicPrelude: mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- BasicPrelude: mappend :: Monoid a => a -> a -> a
- BasicPrelude: max :: Ord a => a -> a -> a
- BasicPrelude: maybe :: b -> (a -> b) -> Maybe a -> b
- BasicPrelude: mconcat :: Monoid a => [a] -> a
- BasicPrelude: mempty :: Monoid a => a
- BasicPrelude: min :: Ord a => a -> a -> a
- BasicPrelude: mod :: Integral a => a -> a -> a
- BasicPrelude: negate :: Num a => a -> a
- BasicPrelude: not :: Bool -> Bool
- BasicPrelude: odd :: Integral a => a -> Bool
- BasicPrelude: or :: [Bool] -> Bool
- BasicPrelude: otherwise :: Bool
- BasicPrelude: partitionEithers :: [Either a b] -> ([a], [b])
- BasicPrelude: pi :: Floating a => a
- BasicPrelude: pred :: Enum a => a -> a
- BasicPrelude: print :: Show a => a -> IO ()
- BasicPrelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
- BasicPrelude: pure :: Applicative f => a -> f a
- BasicPrelude: putStrLn :: Text -> IO ()
- BasicPrelude: quot :: Integral a => a -> a -> a
- BasicPrelude: quotRem :: Integral a => a -> a -> (a, a)
- BasicPrelude: realToFrac :: (Real a, Fractional b) => a -> b
- BasicPrelude: recip :: Fractional a => a -> a
- BasicPrelude: rem :: Integral a => a -> a -> a
- BasicPrelude: return :: Monad m => a -> m a
- BasicPrelude: round :: (RealFrac a, Integral b) => a -> b
- BasicPrelude: scaleFloat :: RealFloat a => Int -> a -> a
- BasicPrelude: second :: Arrow a => forall b c d. a b c -> a (d, b) (d, c)
- BasicPrelude: significand :: RealFloat a => a -> a
- BasicPrelude: signum :: Num a => a -> a
- BasicPrelude: sin :: Floating a => a -> a
- BasicPrelude: sinh :: Floating a => a -> a
- BasicPrelude: snd :: (a, b) -> b
- BasicPrelude: sqrt :: Floating a => a -> a
- BasicPrelude: subtract :: Num a => a -> a -> a
- BasicPrelude: succ :: Enum a => a -> a
- BasicPrelude: tan :: Floating a => a -> a
- BasicPrelude: tanh :: Floating a => a -> a
- BasicPrelude: throwIO :: Exception e => e -> IO a
- BasicPrelude: toEnum :: Enum a => Int -> a
- BasicPrelude: toException :: Exception e => e -> SomeException
- BasicPrelude: toInteger :: Integral a => a -> Integer
- BasicPrelude: toRational :: Real a => a -> Rational
- BasicPrelude: truncate :: (RealFrac a, Integral b) => a -> b
- BasicPrelude: type LByteString = ByteString
- BasicPrelude: type LText = Text
- BasicPrelude: type Rational = Ratio Integer
- BasicPrelude: uncurry :: (a -> b -> c) -> (a, b) -> c
- BasicPrelude: unzip :: [(a, b)] -> ([a], [b])
- BasicPrelude: zip :: [a] -> [b] -> [(a, b)]
- BasicPrelude: zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+ BasicPrelude: appendFile :: FilePath -> Text -> IO ()
+ BasicPrelude: getContents :: IO LText
+ BasicPrelude: getLine :: IO Text
+ BasicPrelude: map :: Functor f => (a -> b) -> f a -> f b
+ BasicPrelude: product :: Num a => [a] -> a
+ BasicPrelude: putStr :: Text -> IO ()
+ BasicPrelude: read :: Read a => Text -> a
+ BasicPrelude: readFile :: FilePath -> IO Text
+ BasicPrelude: readIO :: Read a => Text -> IO a
+ BasicPrelude: show :: Show a => a -> Text
+ BasicPrelude: sum :: Num a => [a] -> a
+ BasicPrelude: writeFile :: FilePath -> Text -> IO ()
+ CorePrelude: ($!) :: (a -> b) -> a -> b
+ CorePrelude: ($) :: (a -> b) -> a -> b
+ CorePrelude: (&&&) :: Arrow a => forall b c c'. a b c -> a b c' -> a b (c, c')
+ CorePrelude: (&&) :: Bool -> Bool -> Bool
+ CorePrelude: (*) :: Num a => a -> a -> a
+ CorePrelude: (**) :: Floating a => a -> a -> a
+ CorePrelude: (***) :: Arrow a => forall b c b' c'. a b c -> a b' c' -> a (b, b') (c, c')
+ CorePrelude: (*>) :: Applicative f => f a -> f b -> f b
+ CorePrelude: (+) :: Num a => a -> a -> a
+ CorePrelude: (++) :: Monoid w => w -> w -> w
+ CorePrelude: (-) :: Num a => a -> a -> a
+ CorePrelude: (.) :: Category cat => forall b c a. cat b c -> cat a b -> cat a c
+ CorePrelude: (/) :: Fractional a => a -> a -> a
+ CorePrelude: (/=) :: Eq a => a -> a -> Bool
+ CorePrelude: (<$) :: Functor f => a -> f b -> f a
+ CorePrelude: (<$>) :: Functor f => (a -> b) -> f a -> f b
+ CorePrelude: (<) :: Ord a => a -> a -> Bool
+ CorePrelude: (<*) :: Applicative f => f a -> f b -> f a
+ CorePrelude: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
+ CorePrelude: (<.>) :: FilePath -> Text -> FilePath
+ CorePrelude: (</>) :: FilePath -> FilePath -> FilePath
+ CorePrelude: (<=) :: Ord a => a -> a -> Bool
+ CorePrelude: (=<<) :: Monad m => (a -> m b) -> m a -> m b
+ CorePrelude: (==) :: Eq a => a -> a -> Bool
+ CorePrelude: (>) :: Ord a => a -> a -> Bool
+ CorePrelude: (>=) :: Ord a => a -> a -> Bool
+ CorePrelude: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
+ CorePrelude: (>>) :: Monad m => m a -> m b -> m b
+ CorePrelude: (>>=) :: Monad m => m a -> (a -> m b) -> m b
+ CorePrelude: (^) :: (Num a, Integral b) => a -> b -> a
+ CorePrelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ CorePrelude: (||) :: Bool -> Bool -> Bool
+ CorePrelude: EQ :: Ordering
+ CorePrelude: False :: Bool
+ CorePrelude: GT :: Ordering
+ CorePrelude: Just :: a -> Maybe a
+ CorePrelude: LT :: Ordering
+ CorePrelude: Left :: a -> Either a b
+ CorePrelude: Nothing :: Maybe a
+ CorePrelude: Right :: b -> Either a b
+ CorePrelude: True :: Bool
+ CorePrelude: abs :: Num a => a -> a
+ CorePrelude: acos :: Floating a => a -> a
+ CorePrelude: acosh :: Floating a => a -> a
+ CorePrelude: asTypeOf :: a -> a -> a
+ CorePrelude: asin :: Floating a => a -> a
+ CorePrelude: asinh :: Floating a => a -> a
+ CorePrelude: atan :: Floating a => a -> a
+ CorePrelude: atan2 :: RealFloat a => a -> a -> a
+ CorePrelude: atanh :: Floating a => a -> a
+ CorePrelude: basename :: FilePath -> FilePath
+ CorePrelude: catMaybes :: [Maybe a] -> [a]
+ CorePrelude: ceiling :: (RealFrac a, Integral b) => a -> b
+ CorePrelude: class Functor f => Applicative (f :: * -> *)
+ CorePrelude: class Enum a
+ CorePrelude: class Eq a
+ CorePrelude: class (Typeable e, Show e) => Exception e
+ CorePrelude: class Fractional a => Floating a
+ CorePrelude: class Num a => Fractional a
+ CorePrelude: class Functor (f :: * -> *)
+ CorePrelude: class Hashable a
+ CorePrelude: class (Real a, Enum a) => Integral a
+ CorePrelude: class Monad (m :: * -> *)
+ CorePrelude: class Monad m => MonadIO (m :: * -> *)
+ CorePrelude: class Monoid a
+ CorePrelude: class Num a
+ CorePrelude: class Eq a => Ord a
+ CorePrelude: class (Num a, Ord a) => Real a
+ CorePrelude: class (RealFrac a, Floating a) => RealFloat a
+ CorePrelude: class (Real a, Fractional a) => RealFrac a
+ CorePrelude: class Show a
+ CorePrelude: class (Vector Vector a, MVector MVector a) => Unbox a
+ CorePrelude: compare :: Ord a => a -> a -> Ordering
+ CorePrelude: comparing :: Ord a => (b -> a) -> b -> b -> Ordering
+ CorePrelude: concat :: Monoid w => [w] -> w
+ CorePrelude: const :: a -> b -> a
+ CorePrelude: cos :: Floating a => a -> a
+ CorePrelude: cosh :: Floating a => a -> a
+ CorePrelude: curry :: ((a, b) -> c) -> a -> b -> c
+ CorePrelude: data Bool :: *
+ CorePrelude: data ByteString :: *
+ CorePrelude: data Char :: *
+ CorePrelude: data Double :: *
+ CorePrelude: data Either a b :: * -> * -> *
+ CorePrelude: data FilePath :: *
+ CorePrelude: data Float :: *
+ CorePrelude: data HashMap k v :: * -> * -> *
+ CorePrelude: data HashSet a :: * -> *
+ CorePrelude: data IO a :: * -> *
+ CorePrelude: data Int :: *
+ CorePrelude: data Int32 :: *
+ CorePrelude: data Int64 :: *
+ CorePrelude: data Integer :: *
+ CorePrelude: data Map k a :: * -> * -> *
+ CorePrelude: data Maybe a :: * -> *
+ CorePrelude: data Ordering :: *
+ CorePrelude: data Set a :: * -> *
+ CorePrelude: data SomeException :: *
+ CorePrelude: data Text :: *
+ CorePrelude: data Vector a :: * -> *
+ CorePrelude: data Word :: *
+ CorePrelude: data Word32 :: *
+ CorePrelude: data Word64 :: *
+ CorePrelude: data Word8 :: *
+ CorePrelude: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ CorePrelude: div :: Integral a => a -> a -> a
+ CorePrelude: divMod :: Integral a => a -> a -> (a, a)
+ CorePrelude: either :: (a -> c) -> (b -> c) -> Either a b -> c
+ CorePrelude: elem :: Eq a => a -> [a] -> Bool
+ CorePrelude: empty :: Monoid w => w
+ CorePrelude: encodeFloat :: RealFloat a => Integer -> Int -> a
+ CorePrelude: enumFrom :: Enum a => a -> [a]
+ CorePrelude: enumFromThen :: Enum a => a -> a -> [a]
+ CorePrelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ CorePrelude: enumFromTo :: Enum a => a -> a -> [a]
+ CorePrelude: equating :: Eq a => (b -> a) -> b -> b -> Bool
+ CorePrelude: error :: [Char] -> a
+ CorePrelude: even :: Integral a => a -> Bool
+ CorePrelude: exp :: Floating a => a -> a
+ CorePrelude: exponent :: RealFloat a => a -> Int
+ CorePrelude: fail :: Monad m => String -> m a
+ CorePrelude: filename :: FilePath -> FilePath
+ CorePrelude: first :: Arrow a => forall b c d. a b c -> a (b, d) (c, d)
+ CorePrelude: flip :: (a -> b -> c) -> b -> a -> c
+ CorePrelude: floatDigits :: RealFloat a => a -> Int
+ CorePrelude: floatRadix :: RealFloat a => a -> Integer
+ CorePrelude: floatRange :: RealFloat a => a -> (Int, Int)
+ CorePrelude: floor :: (RealFrac a, Integral b) => a -> b
+ CorePrelude: fmap :: Functor f => (a -> b) -> f a -> f b
+ CorePrelude: fromEnum :: Enum a => a -> Int
+ CorePrelude: fromException :: Exception e => SomeException -> Maybe e
+ CorePrelude: fromInteger :: Num a => Integer -> a
+ CorePrelude: fromIntegral :: (Integral a, Num b) => a -> b
+ CorePrelude: fromMaybe :: a -> Maybe a -> a
+ CorePrelude: fromRational :: Fractional a => Rational -> a
+ CorePrelude: fst :: (a, b) -> a
+ CorePrelude: hasExtension :: FilePath -> Text -> Bool
+ CorePrelude: id :: Category cat => forall a. cat a a
+ CorePrelude: isDenormalized :: RealFloat a => a -> Bool
+ CorePrelude: isIEEE :: RealFloat a => a -> Bool
+ CorePrelude: isInfinite :: RealFloat a => a -> Bool
+ CorePrelude: isNaN :: RealFloat a => a -> Bool
+ CorePrelude: isNegativeZero :: RealFloat a => a -> Bool
+ CorePrelude: lift :: MonadTrans t => forall (m :: * -> *) a. Monad m => m a -> t m a
+ CorePrelude: liftIO :: MonadIO m => forall a. IO a -> m a
+ CorePrelude: log :: Floating a => a -> a
+ CorePrelude: logBase :: Floating a => a -> a -> a
+ CorePrelude: mapMaybe :: (a -> Maybe b) -> [a] -> [b]
+ CorePrelude: mappend :: Monoid a => a -> a -> a
+ CorePrelude: max :: Ord a => a -> a -> a
+ CorePrelude: maybe :: b -> (a -> b) -> Maybe a -> b
+ CorePrelude: mconcat :: Monoid a => [a] -> a
+ CorePrelude: mempty :: Monoid a => a
+ CorePrelude: min :: Ord a => a -> a -> a
+ CorePrelude: mod :: Integral a => a -> a -> a
+ CorePrelude: negate :: Num a => a -> a
+ CorePrelude: not :: Bool -> Bool
+ CorePrelude: odd :: Integral a => a -> Bool
+ CorePrelude: on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
+ CorePrelude: or :: [Bool] -> Bool
+ CorePrelude: otherwise :: Bool
+ CorePrelude: partitionEithers :: [Either a b] -> ([a], [b])
+ CorePrelude: pi :: Floating a => a
+ CorePrelude: pred :: Enum a => a -> a
+ CorePrelude: print :: Show a => a -> IO ()
+ CorePrelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ CorePrelude: pure :: Applicative f => a -> f a
+ CorePrelude: putStrLn :: Text -> IO ()
+ CorePrelude: quot :: Integral a => a -> a -> a
+ CorePrelude: quotRem :: Integral a => a -> a -> (a, a)
+ CorePrelude: realToFrac :: (Real a, Fractional b) => a -> b
+ CorePrelude: recip :: Fractional a => a -> a
+ CorePrelude: rem :: Integral a => a -> a -> a
+ CorePrelude: return :: Monad m => a -> m a
+ CorePrelude: round :: (RealFrac a, Integral b) => a -> b
+ CorePrelude: scaleFloat :: RealFloat a => Int -> a -> a
+ CorePrelude: second :: Arrow a => forall b c d. a b c -> a (d, b) (d, c)
+ CorePrelude: seq :: a -> b -> b
+ CorePrelude: significand :: RealFloat a => a -> a
+ CorePrelude: signum :: Num a => a -> a
+ CorePrelude: sin :: Floating a => a -> a
+ CorePrelude: sinh :: Floating a => a -> a
+ CorePrelude: snd :: (a, b) -> b
+ CorePrelude: sqrt :: Floating a => a -> a
+ CorePrelude: subtract :: Num a => a -> a -> a
+ CorePrelude: succ :: Enum a => a -> a
+ CorePrelude: swap :: (a, b) -> (b, a)
+ CorePrelude: tan :: Floating a => a -> a
+ CorePrelude: tanh :: Floating a => a -> a
+ CorePrelude: throwIO :: Exception e => e -> IO a
+ CorePrelude: toEnum :: Enum a => Int -> a
+ CorePrelude: toException :: Exception e => e -> SomeException
+ CorePrelude: toInteger :: Integral a => a -> Integer
+ CorePrelude: toRational :: Real a => a -> Rational
+ CorePrelude: truncate :: (RealFrac a, Integral b) => a -> b
+ CorePrelude: type LByteString = ByteString
+ CorePrelude: type LText = Text
+ CorePrelude: type Rational = Ratio Integer
+ CorePrelude: type UVector = Vector
+ CorePrelude: uncurry :: (a -> b -> c) -> (a, b) -> c
+ CorePrelude: undefined :: a
+ CorePrelude: until :: (a -> Bool) -> (a -> a) -> a -> a
+ CorePrelude: unzip :: [(a, b)] -> ([a], [b])
+ CorePrelude: zip :: [a] -> [b] -> [(a, b)]
+ CorePrelude: zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
Files
- BasicPrelude.hs +121/−149
- CorePrelude.hs +191/−0
- basic-prelude.cabal +15/−3
BasicPrelude.hs view
@@ -1,163 +1,135 @@ {-# LANGUAGE NoImplicitPrelude #-}+ module BasicPrelude- ( -- * Standard- -- ** Operators- (Prelude.$)- , (Prelude.&&)- , (Prelude.||)- , (Control.Category..)- -- ** Functions- , Prelude.not- , Prelude.otherwise- , Prelude.fst- , Prelude.snd- , Control.Category.id- , Prelude.maybe- , Prelude.either- , Prelude.flip- , Prelude.const- , Prelude.error- , Prelude.zip- , Prelude.unzip- , Prelude.zipWith- , Prelude.or- , Data.Text.IO.putStrLn- , Prelude.elem- , Prelude.odd- , Prelude.even- , Prelude.uncurry- -- ** Type classes- , Prelude.Ord (..)- , Prelude.Eq (..)- , Prelude.Enum (..)- , Prelude.Show- , Prelude.Functor (..)- , Prelude.Monad (..)- , (Control.Monad.=<<)- -- ** Numeric type classes- , Prelude.Num (..)- , Prelude.Real (..)- , Prelude.Integral (..)- , Prelude.Fractional (..)- , Prelude.Floating (..)- , Prelude.RealFrac (..)- , Prelude.RealFloat(..)- -- ** Data types- , Prelude.Maybe (..)- , Prelude.Ordering (..)- , Prelude.Bool (..)- , Prelude.Char- , Prelude.IO- , Prelude.Either (..)- -- * Re-exports- -- ** Packed reps- , ByteString- , LByteString- , Text- , LText- -- ** Containers- , Map- , HashMap- , Set- , HashSet- , Vector- , Hashable- -- ** Numbers- , Word- , Word8- , Word64- , Prelude.Int- , Int64- , Prelude.Integer- , Prelude.Rational- , Prelude.Float- , Prelude.Double- -- ** Numeric functions- , (Prelude.^)- , (Prelude.^^)- , Prelude.subtract- , Prelude.fromIntegral- , Prelude.realToFrac- -- ** Monoids- , Monoid (..)- , concat- , (++)- -- ** Arrow- , Control.Arrow.first- , Control.Arrow.second- , (Control.Arrow.***)- , (Control.Arrow.&&&)- -- ** Maybe- , Data.Maybe.mapMaybe- , Data.Maybe.catMaybes- , Data.Maybe.fromMaybe- -- ** Either- , Data.Either.partitionEithers- -- ** Applicative- , Control.Applicative.Applicative (..)- , (Control.Applicative.<$>)- -- ** Monad- , (Control.Monad.>=>)- -- ** Transformers- , Control.Monad.Trans.Class.lift- , Control.Monad.IO.Class.MonadIO- , Control.Monad.IO.Class.liftIO- -- ** Exceptions- , Control.Exception.Exception (..)- , Control.Exception.SomeException- , Control.Exception.throwIO- -- ** Files- , F.FilePath- , (F.</>)- , (F.<.>)- , F.hasExtension- , F.basename- , F.filename- -- ** Print- , Prelude.print- ) where+ ( module CorePrelude+ , module Data.List+ , module Prelude+ , module Data.Text+ , module Data.Text.Lazy.IO+ , module Control.Monad+ , map+ , show+ , read+ , sum+ , product+ , putStr+ , getLine+ , getContents+ , readFile+ , writeFile+ , appendFile+ , readIO+ ) where -import qualified Prelude-import Prelude (Char, (.))+import qualified Data.Text as T+import qualified Data.Text.IO as T+import qualified Data.Text.Lazy.IO as TL+import qualified Prelude as P+import qualified Filesystem.Path.CurrentOS as F -import Data.Hashable (Hashable)+import CorePrelude -import Data.Monoid (Monoid (..))-import qualified Control.Arrow-import qualified Control.Applicative-import qualified Control.Category-import qualified Control.Monad-import qualified Control.Exception+import Data.List hiding+ ( -- already in CorePrelude+ (++)+ , concat+ + -- prefer Text versions instead+ , lines+ , words+ , unlines+ , unwords+ , intercalate+ + -- prefer map = fmap instead+ , map+ + -- prefer strict versions+ , sum+ , product+ ) -import qualified Filesystem.Path.CurrentOS as F+import Prelude+ ( Bounded (..)+ , gcd+ , lcm+ , seq+ , ($!)+ , curry+ , until+ , asTypeOf+ , undefined+ , String+ , ReadS+ , ShowS+ , Read (..)+ , Show (showsPrec, showList)+ , reads+ , shows+ , showChar+ , showString+ , showParen+ , readParen+ , lex+ , IOError+ , ioError+ , userError+ , putChar+ , getChar+ , readLn+ ) -import Data.Word (Word8, Word64, Word)-import Data.Int (Int64)+import Data.Text+ ( lines+ , words+ , unlines+ , unwords+ , intercalate+ ) -import qualified Data.Text.IO+import Data.Text.Lazy.IO+ ( interact+ ) -import qualified Data.Maybe-import qualified Data.Either+-- Import *all of the things* from Control.Monad,+-- specifically, the list-based things that+-- CorePrelude doesn't export+import Control.Monad -import qualified Control.Monad.Trans.Class-import qualified Control.Monad.IO.Class -import Data.ByteString (ByteString)-import qualified Data.ByteString.Lazy-import Data.Text (Text)-import qualified Data.Text.Lazy-import Data.Vector (Vector)-import Data.Map (Map)-import Data.Set (Set)-import Data.HashMap.Strict (HashMap)-import Data.HashSet (HashSet)+map :: (Functor f) => (a -> b) -> f a -> f b+map = fmap -type LText = Data.Text.Lazy.Text-type LByteString = Data.ByteString.Lazy.ByteString+show :: Show a => a -> Text+show = T.pack . P.show -concat :: Monoid w => [w] -> w-concat = mconcat+read :: Read a => Text -> a+read = P.read . T.unpack -infixr 5 ++-(++) :: Monoid w => w -> w -> w-(++) = mappend+sum :: Num a => [a] -> a+sum = foldl' (+) 0++product :: Num a => [a] -> a+product = foldl' (*) 1++putStr :: Text -> IO ()+putStr = T.putStr++getLine :: IO Text+getLine = T.getLine++getContents :: IO LText+getContents = TL.getContents++readFile :: FilePath -> IO Text+readFile = T.readFile . F.encodeString++writeFile :: FilePath -> Text -> IO ()+writeFile = T.writeFile . F.encodeString++appendFile :: FilePath -> Text -> IO ()+appendFile = T.appendFile . F.encodeString++readIO :: Read a => Text -> IO a+readIO = P.readIO . T.unpack+
+ CorePrelude.hs view
@@ -0,0 +1,191 @@+{-# LANGUAGE NoImplicitPrelude #-}+module CorePrelude+ ( -- * Standard+ -- ** Operators+ (Prelude.$)+ , (Prelude.$!)+ , (Prelude.&&)+ , (Prelude.||)+ , (Control.Category..)+ -- ** Functions+ , Prelude.not+ , Prelude.otherwise+ , Prelude.fst+ , Prelude.snd+ , Control.Category.id+ , Prelude.maybe+ , Prelude.either+ , Prelude.flip+ , Prelude.const+ , Prelude.error+ , Prelude.zip+ , Prelude.unzip+ , Prelude.zipWith+ , Prelude.or+ , Data.Text.IO.putStrLn+ , Prelude.elem+ , Prelude.odd+ , Prelude.even+ , Prelude.uncurry+ , Prelude.curry+ , Data.Tuple.swap+ , Prelude.until+ , Prelude.asTypeOf+ , Prelude.undefined+ , Prelude.seq+ -- ** Type classes+ , Prelude.Ord (..)+ , Prelude.Eq (..)+ , Prelude.Enum (..)+ , Prelude.Show+ , Prelude.Functor (..)+ , Prelude.Monad (..)+ , (Control.Monad.=<<)+ -- ** Numeric type classes+ , Prelude.Num (..)+ , Prelude.Real (..)+ , Prelude.Integral (..)+ , Prelude.Fractional (..)+ , Prelude.Floating (..)+ , Prelude.RealFrac (..)+ , Prelude.RealFloat(..)+ -- ** Data types+ , Prelude.Maybe (..)+ , Prelude.Ordering (..)+ , Prelude.Bool (..)+ , Prelude.Char+ , Prelude.IO+ , Prelude.Either (..)+ -- * Re-exports+ -- ** Packed reps+ , ByteString+ , LByteString+ , Text+ , LText+ -- ** Containers+ , Map+ , HashMap+ , Set+ , HashSet+ , Vector+ , UVector+ , Unbox+ , Hashable+ -- ** Numbers+ , Word+ , Word8+ , Word32+ , Word64+ , Prelude.Int+ , Int32+ , Int64+ , Prelude.Integer+ , Prelude.Rational+ , Prelude.Float+ , Prelude.Double+ -- ** Numeric functions+ , (Prelude.^)+ , (Prelude.^^)+ , Prelude.subtract+ , Prelude.fromIntegral+ , Prelude.realToFrac+ -- ** Monoids+ , Monoid (..)+ , empty+ , concat+ , (++)+ -- ** Arrow+ , Control.Arrow.first+ , Control.Arrow.second+ , (Control.Arrow.***)+ , (Control.Arrow.&&&)+ -- ** Maybe+ , Data.Maybe.mapMaybe+ , Data.Maybe.catMaybes+ , Data.Maybe.fromMaybe+ -- ** Either+ , Data.Either.partitionEithers+ -- ** Ord+ , Data.Function.on+ , Data.Ord.comparing+ , equating+ -- ** Applicative+ , Control.Applicative.Applicative (..)+ , (Control.Applicative.<$>)+ -- ** Monad+ , (Control.Monad.>=>)+ -- ** Transformers+ , Control.Monad.Trans.Class.lift+ , Control.Monad.IO.Class.MonadIO+ , Control.Monad.IO.Class.liftIO+ -- ** Exceptions+ , Control.Exception.Exception (..)+ , Control.Exception.SomeException+ , Control.Exception.throwIO+ -- ** Files+ , F.FilePath+ , (F.</>)+ , (F.<.>)+ , F.hasExtension+ , F.basename+ , F.filename+ -- ** Print+ , Prelude.print+ ) where++import qualified Prelude+import Prelude (Char, (.), Eq, Bool)++import Data.Hashable (Hashable)+import Data.Vector.Unboxed (Unbox)++import Data.Monoid (Monoid (..))+import qualified Control.Arrow+import qualified Control.Applicative+import qualified Control.Category+import qualified Control.Monad+import qualified Control.Exception++import qualified Filesystem.Path.CurrentOS as F++import Data.Word (Word8, Word32, Word64, Word)+import Data.Int (Int32, Int64)++import qualified Data.Text.IO++import qualified Data.Maybe+import qualified Data.Either+import qualified Data.Ord+import qualified Data.Function+import qualified Data.Tuple++import qualified Control.Monad.Trans.Class+import qualified Control.Monad.IO.Class++import Data.ByteString (ByteString)+import qualified Data.ByteString.Lazy+import Data.Text (Text)+import qualified Data.Text.Lazy+import Data.Vector (Vector)+import qualified Data.Vector.Unboxed+import Data.Map (Map)+import Data.Set (Set)+import Data.HashMap.Strict (HashMap)+import Data.HashSet (HashSet)++type LText = Data.Text.Lazy.Text+type LByteString = Data.ByteString.Lazy.ByteString+type UVector = Data.Vector.Unboxed.Vector++empty :: Monoid w => w+empty = mempty++concat :: Monoid w => [w] -> w+concat = mconcat++infixr 5 +++(++) :: Monoid w => w -> w -> w+(++) = mappend++equating :: Eq a => (b -> a) -> b -> b -> Bool+equating = Data.Function.on (Prelude.==)
basic-prelude.cabal view
@@ -1,6 +1,18 @@ name: basic-prelude-version: 0.1.0.0-synopsis: An enhanced core prelude, meant for building up more complete preludes on top of.+version: 0.2.0.0+synopsis: An enhanced core prelude; a common foundation for alternate preludes.+description:+ The premise of @basic-prelude@ is that there are a lot of very commonly desired features missing from the standard @Prelude@, such as commonly used operators (@\<$\>@ and @>=>@, for instance) and imports for common datatypes (e.g., @ByteString@ and @Vector@). At the same time, there are lots of other components which are more debatable, such as providing polymorphic versions of common functions.+ .+ So @basic-prelude@ is intended to give a common foundation for a number of alternate preludes. The package provides two modules: @CorePrelude@ provides the common ground for other preludes to build on top of, while @BasicPrelude@ exports @CorePrelude@ together with commonly used list functions to provide a drop-in replacement for the standard @Prelude@.+ .+ Users wishing to have an improved @Prelude@ can use @BasicPrelude@. Developers wishing to create a new prelude should use @CorePrelude@.+ .+ Release history:+ .+ [0.2] Renamed @BasicPrelude@ to @CorePrelude@ and added a new @BasicPrelude@ module provided a full-featured @Prelude@ alternative. Also added a number of new exports.+ .+ [0.1] Initial version, code taken from @classy-prelude@ with a few minor tweaks. homepage: https://github.com/snoyberg/basic-prelude license: MIT@@ -13,7 +25,7 @@ cabal-version: >=1.8 library- exposed-modules: BasicPrelude+ exposed-modules: BasicPrelude, CorePrelude build-depends: base >= 4 && < 5 , hashable , bytestring