packages feed

basic-prelude 0.6.1 → 0.6.1.1

raw patch · 3 files changed

+13/−1 lines, 3 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- BasicPrelude: foldMap :: Monoid m => (a -> m) -> t a -> m
+ BasicPrelude: foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
- BasicPrelude: foldl :: (b -> a -> b) -> b -> t a -> b
+ BasicPrelude: foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
- BasicPrelude: foldl' :: (b -> a -> b) -> b -> t a -> b
+ BasicPrelude: foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
- BasicPrelude: foldl1 :: (a -> a -> a) -> t a -> a
+ BasicPrelude: foldl1 :: Foldable t => (a -> a -> a) -> t a -> a
- BasicPrelude: foldr :: (a -> b -> b) -> b -> t a -> b
+ BasicPrelude: foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
- BasicPrelude: foldr' :: (a -> b -> b) -> b -> t a -> b
+ BasicPrelude: foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b
- BasicPrelude: foldr1 :: (a -> a -> a) -> t a -> a
+ BasicPrelude: foldr1 :: Foldable t => (a -> a -> a) -> t a -> a
- BasicPrelude: length :: t a -> Int
+ BasicPrelude: length :: Foldable t => t a -> Int
- BasicPrelude: mapM :: Monad m => (a -> m b) -> t a -> m (t b)
+ BasicPrelude: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
- BasicPrelude: null :: t a -> Bool
+ BasicPrelude: null :: Foldable t => t a -> Bool
- BasicPrelude: sequence :: Monad m => t (m a) -> m (t a)
+ BasicPrelude: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
- BasicPrelude: sequenceA :: Applicative f => t (f a) -> f (t a)
+ BasicPrelude: sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
- BasicPrelude: show :: a -> String
+ BasicPrelude: show :: Show a => a -> String
- BasicPrelude: showList :: [a] -> ShowS
+ BasicPrelude: showList :: Show a => [a] -> ShowS
- BasicPrelude: showsPrec :: Int -> a -> ShowS
+ BasicPrelude: showsPrec :: Show a => Int -> a -> ShowS
- BasicPrelude: traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
+ BasicPrelude: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
- CorePrelude: (*) :: a -> a -> a
+ CorePrelude: (*) :: Num a => a -> a -> a
- CorePrelude: (**) :: a -> a -> a
+ CorePrelude: (**) :: Floating a => a -> a -> a
- CorePrelude: (*>) :: f a -> f b -> f b
+ CorePrelude: (*>) :: Applicative f => f a -> f b -> f b
- CorePrelude: (+) :: a -> a -> a
+ CorePrelude: (+) :: Num a => a -> a -> a
- CorePrelude: (-) :: a -> a -> a
+ CorePrelude: (-) :: Num a => a -> a -> a
- CorePrelude: (/) :: a -> a -> a
+ CorePrelude: (/) :: Fractional a => a -> a -> a
- CorePrelude: (/=) :: a -> a -> Bool
+ CorePrelude: (/=) :: Eq a => a -> a -> Bool
- CorePrelude: (<$) :: a -> f b -> f a
+ CorePrelude: (<$) :: Functor f => a -> f b -> f a
- CorePrelude: (<) :: a -> a -> Bool
+ CorePrelude: (<) :: Ord a => a -> a -> Bool
- CorePrelude: (<*) :: f a -> f b -> f a
+ CorePrelude: (<*) :: Applicative f => f a -> f b -> f a
- CorePrelude: (<*>) :: f (a -> b) -> f a -> f b
+ CorePrelude: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
- CorePrelude: (<=) :: a -> a -> Bool
+ CorePrelude: (<=) :: Ord a => a -> a -> Bool
- CorePrelude: (==) :: a -> a -> Bool
+ CorePrelude: (==) :: Eq a => a -> a -> Bool
- CorePrelude: (>) :: a -> a -> Bool
+ CorePrelude: (>) :: Ord a => a -> a -> Bool
- CorePrelude: (>=) :: a -> a -> Bool
+ CorePrelude: (>=) :: Ord a => a -> a -> Bool
- CorePrelude: (>>) :: m a -> m b -> m b
+ CorePrelude: (>>) :: Monad m => m a -> m b -> m b
- CorePrelude: (>>=) :: m a -> (a -> m b) -> m b
+ CorePrelude: (>>=) :: Monad m => m a -> (a -> m b) -> m b
- CorePrelude: abs :: a -> a
+ CorePrelude: abs :: Num a => a -> a
- CorePrelude: acos :: a -> a
+ CorePrelude: acos :: Floating a => a -> a
- CorePrelude: acosh :: a -> a
+ CorePrelude: acosh :: Floating a => a -> a
- CorePrelude: asin :: a -> a
+ CorePrelude: asin :: Floating a => a -> a
- CorePrelude: asinh :: a -> a
+ CorePrelude: asinh :: Floating a => a -> a
- CorePrelude: atan :: a -> a
+ CorePrelude: atan :: Floating a => a -> a
- CorePrelude: atan2 :: a -> a -> a
+ CorePrelude: atan2 :: RealFloat a => a -> a -> a
- CorePrelude: atanh :: a -> a
+ CorePrelude: atanh :: Floating a => a -> a
- CorePrelude: ceiling :: Integral b => a -> b
+ CorePrelude: ceiling :: (RealFrac a, Integral b) => a -> b
- CorePrelude: compare :: a -> a -> Ordering
+ CorePrelude: compare :: Ord a => a -> a -> Ordering
- CorePrelude: cos :: a -> a
+ CorePrelude: cos :: Floating a => a -> a
- CorePrelude: cosh :: a -> a
+ CorePrelude: cosh :: Floating a => a -> a
- CorePrelude: decodeFloat :: a -> (Integer, Int)
+ CorePrelude: decodeFloat :: RealFloat a => a -> (Integer, Int)
- CorePrelude: displayException :: e -> String
+ CorePrelude: displayException :: Exception e => e -> String
- CorePrelude: div :: a -> a -> a
+ CorePrelude: div :: Integral a => a -> a -> a
- CorePrelude: divMod :: a -> a -> (a, a)
+ CorePrelude: divMod :: Integral a => a -> a -> (a, a)
- CorePrelude: encodeFloat :: Integer -> Int -> a
+ CorePrelude: encodeFloat :: RealFloat a => Integer -> Int -> a
- CorePrelude: enumFrom :: a -> [a]
+ CorePrelude: enumFrom :: Enum a => a -> [a]
- CorePrelude: enumFromThen :: a -> a -> [a]
+ CorePrelude: enumFromThen :: Enum a => a -> a -> [a]
- CorePrelude: enumFromThenTo :: a -> a -> a -> [a]
+ CorePrelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
- CorePrelude: enumFromTo :: a -> a -> [a]
+ CorePrelude: enumFromTo :: Enum a => a -> a -> [a]
- CorePrelude: exp :: a -> a
+ CorePrelude: exp :: Floating a => a -> a
- CorePrelude: exponent :: a -> Int
+ CorePrelude: exponent :: RealFloat a => a -> Int
- CorePrelude: fail :: String -> m a
+ CorePrelude: fail :: Monad m => String -> m a
- CorePrelude: floatDigits :: a -> Int
+ CorePrelude: floatDigits :: RealFloat a => a -> Int
- CorePrelude: floatRadix :: a -> Integer
+ CorePrelude: floatRadix :: RealFloat a => a -> Integer
- CorePrelude: floatRange :: a -> (Int, Int)
+ CorePrelude: floatRange :: RealFloat a => a -> (Int, Int)
- CorePrelude: floor :: Integral b => a -> b
+ CorePrelude: floor :: (RealFrac a, Integral b) => a -> b
- CorePrelude: fmap :: (a -> b) -> f a -> f b
+ CorePrelude: fmap :: Functor f => (a -> b) -> f a -> f b
- CorePrelude: fromEnum :: a -> Int
+ CorePrelude: fromEnum :: Enum a => a -> Int
- CorePrelude: fromException :: SomeException -> Maybe e
+ CorePrelude: fromException :: Exception e => SomeException -> Maybe e
- CorePrelude: fromInteger :: Integer -> a
+ CorePrelude: fromInteger :: Num a => Integer -> a
- CorePrelude: fromRational :: Rational -> a
+ CorePrelude: fromRational :: Fractional a => Rational -> a
- CorePrelude: fromString :: String -> a
+ CorePrelude: fromString :: IsString a => String -> a
- CorePrelude: isDenormalized :: a -> Bool
+ CorePrelude: isDenormalized :: RealFloat a => a -> Bool
- CorePrelude: isIEEE :: a -> Bool
+ CorePrelude: isIEEE :: RealFloat a => a -> Bool
- CorePrelude: isInfinite :: a -> Bool
+ CorePrelude: isInfinite :: RealFloat a => a -> Bool
- CorePrelude: isNaN :: a -> Bool
+ CorePrelude: isNaN :: RealFloat a => a -> Bool
- CorePrelude: isNegativeZero :: a -> Bool
+ CorePrelude: isNegativeZero :: RealFloat a => a -> Bool
- CorePrelude: log :: a -> a
+ CorePrelude: log :: Floating a => a -> a
- CorePrelude: logBase :: a -> a -> a
+ CorePrelude: logBase :: Floating a => a -> a -> a
- CorePrelude: mappend :: a -> a -> a
+ CorePrelude: mappend :: Monoid a => a -> a -> a
- CorePrelude: max :: a -> a -> a
+ CorePrelude: max :: Ord a => a -> a -> a
- CorePrelude: maxBound :: a
+ CorePrelude: maxBound :: Bounded a => a
- CorePrelude: mconcat :: [a] -> a
+ CorePrelude: mconcat :: Monoid a => [a] -> a
- CorePrelude: mempty :: a
+ CorePrelude: mempty :: Monoid a => a
- CorePrelude: min :: a -> a -> a
+ CorePrelude: min :: Ord a => a -> a -> a
- CorePrelude: minBound :: a
+ CorePrelude: minBound :: Bounded a => a
- CorePrelude: mod :: a -> a -> a
+ CorePrelude: mod :: Integral a => a -> a -> a
- CorePrelude: negate :: a -> a
+ CorePrelude: negate :: Num a => a -> a
- CorePrelude: pi :: a
+ CorePrelude: pi :: Floating a => a
- CorePrelude: pred :: a -> a
+ CorePrelude: pred :: Enum a => a -> a
- CorePrelude: properFraction :: Integral b => a -> (b, a)
+ CorePrelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
- CorePrelude: pure :: a -> f a
+ CorePrelude: pure :: Applicative f => a -> f a
- CorePrelude: quot :: a -> a -> a
+ CorePrelude: quot :: Integral a => a -> a -> a
- CorePrelude: quotRem :: a -> a -> (a, a)
+ CorePrelude: quotRem :: Integral a => a -> a -> (a, a)
- CorePrelude: recip :: a -> a
+ CorePrelude: recip :: Fractional a => a -> a
- CorePrelude: rem :: a -> a -> a
+ CorePrelude: rem :: Integral a => a -> a -> a
- CorePrelude: return :: a -> m a
+ CorePrelude: return :: Monad m => a -> m a
- CorePrelude: round :: Integral b => a -> b
+ CorePrelude: round :: (RealFrac a, Integral b) => a -> b
- CorePrelude: scaleFloat :: Int -> a -> a
+ CorePrelude: scaleFloat :: RealFloat a => Int -> a -> a
- CorePrelude: significand :: a -> a
+ CorePrelude: significand :: RealFloat a => a -> a
- CorePrelude: signum :: a -> a
+ CorePrelude: signum :: Num a => a -> a
- CorePrelude: sin :: a -> a
+ CorePrelude: sin :: Floating a => a -> a
- CorePrelude: sinh :: a -> a
+ CorePrelude: sinh :: Floating a => a -> a
- CorePrelude: sqrt :: a -> a
+ CorePrelude: sqrt :: Floating a => a -> a
- CorePrelude: succ :: a -> a
+ CorePrelude: succ :: Enum a => a -> a
- CorePrelude: tan :: a -> a
+ CorePrelude: tan :: Floating a => a -> a
- CorePrelude: tanh :: a -> a
+ CorePrelude: tanh :: Floating a => a -> a
- CorePrelude: terror :: Text -> a
+ CorePrelude: terror :: HasCallStack => Text -> a
- CorePrelude: toEnum :: Int -> a
+ CorePrelude: toEnum :: Enum a => Int -> a
- CorePrelude: toException :: e -> SomeException
+ CorePrelude: toException :: Exception e => e -> SomeException
- CorePrelude: toInteger :: a -> Integer
+ CorePrelude: toInteger :: Integral a => a -> Integer
- CorePrelude: toRational :: a -> Rational
+ CorePrelude: toRational :: Real a => a -> Rational
- CorePrelude: truncate :: Integral b => a -> b
+ CorePrelude: truncate :: (RealFrac a, Integral b) => a -> b

Files

ChangeLog.md view
@@ -1,3 +1,7 @@+## 0.6.1.1++* Add `HasCallStack` for `terror`+ ## 0.6.1  * Generalize `sum` and `product` to `Foldable` [#69](https://github.com/snoyberg/basic-prelude/issues/69)
CorePrelude.hs view
@@ -239,6 +239,10 @@ import Data.Monoid ((<>)) #endif +#if MIN_VERSION_base(4,9,0)+import GHC.Stack (HasCallStack)+#endif+ type LText = Data.Text.Lazy.Text type LByteString = Data.ByteString.Lazy.ByteString type UVector = Data.Vector.Unboxed.Vector@@ -281,5 +285,9 @@ -- | @error@ applied to @Text@ -- -- Since 0.4.1+#if MIN_VERSION_base(4,9,0)+terror :: HasCallStack => Text -> a+#else terror :: Text -> a+#endif terror = Prelude.error . Data.Text.unpack
basic-prelude.cabal view
@@ -1,5 +1,5 @@ name:                basic-prelude-version:             0.6.1+version:             0.6.1.1 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.