base-compat 0.11.2 → 0.12.0
raw patch · 7 files changed
+78/−22 lines, 7 filesdep ~basePVP ok
version bump matches the API change (PVP)
Dependency ranges changed: base
API changes (from Hackage documentation)
- Data.Functor.Const.Compat: newtype Const a (b :: k) :: forall k. () => Type -> k -> Type
- Data.Monoid.Compat: newtype Alt (f :: k -> Type) (a :: k) :: forall k. () => k -> Type -> k -> Type
- Data.Semigroup.Compat: Option :: Maybe a -> Option a
- Data.Semigroup.Compat: [getOption] :: Option a -> Maybe a
- Data.Semigroup.Compat: newtype Option a
- Data.Semigroup.Compat: option :: () => b -> (a -> b) -> Option a -> b
- Prelude.Compat: (!!) :: () => [a] -> Int -> a
- Prelude.Compat: ($!) :: () => (a -> b) -> a -> b
- Prelude.Compat: ($) :: () => (a -> b) -> a -> b
- Prelude.Compat: (&&) :: Bool -> Bool -> Bool
- Prelude.Compat: (*) :: Num a => a -> a -> a
- Prelude.Compat: (**) :: Floating a => a -> a -> a
- Prelude.Compat: (*>) :: Applicative f => f a -> f b -> f b
- Prelude.Compat: (+) :: Num a => a -> a -> a
- Prelude.Compat: (++) :: () => [a] -> [a] -> [a]
- Prelude.Compat: (-) :: Num a => a -> a -> a
- Prelude.Compat: (.) :: () => (b -> c) -> (a -> b) -> a -> c
- Prelude.Compat: (/) :: Fractional a => a -> a -> a
- Prelude.Compat: (/=) :: Eq a => a -> a -> Bool
- Prelude.Compat: (<$) :: Functor f => a -> f b -> f a
- Prelude.Compat: (<$>) :: Functor f => (a -> b) -> f a -> f b
- Prelude.Compat: (<) :: Ord a => a -> a -> Bool
- Prelude.Compat: (<*) :: Applicative f => f a -> f b -> f a
- Prelude.Compat: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
- Prelude.Compat: (<=) :: Ord a => a -> a -> Bool
- Prelude.Compat: (<>) :: Semigroup a => a -> a -> a
- Prelude.Compat: (=<<) :: Monad m => (a -> m b) -> m a -> m b
- Prelude.Compat: (==) :: Eq a => a -> a -> Bool
- Prelude.Compat: (>) :: Ord a => a -> a -> Bool
- Prelude.Compat: (>=) :: Ord a => a -> a -> Bool
- Prelude.Compat: (>>) :: Monad m => m a -> m b -> m b
- Prelude.Compat: (>>=) :: Monad m => m a -> (a -> m b) -> m b
- Prelude.Compat: (^) :: (Num a, Integral b) => a -> b -> a
- Prelude.Compat: (^^) :: (Fractional a, Integral b) => a -> b -> a
- Prelude.Compat: (||) :: Bool -> Bool -> Bool
- Prelude.Compat: EQ :: Ordering
- Prelude.Compat: False :: Bool
- Prelude.Compat: GT :: Ordering
- Prelude.Compat: Just :: a -> Maybe a
- Prelude.Compat: LT :: Ordering
- Prelude.Compat: Left :: a -> Either a b
- Prelude.Compat: Nothing :: Maybe a
- Prelude.Compat: Right :: b -> Either a b
- Prelude.Compat: True :: Bool
- Prelude.Compat: abs :: Num a => a -> a
- Prelude.Compat: acos :: Floating a => a -> a
- Prelude.Compat: acosh :: Floating a => a -> a
- Prelude.Compat: all :: Foldable t => (a -> Bool) -> t a -> Bool
- Prelude.Compat: and :: Foldable t => t Bool -> Bool
- Prelude.Compat: any :: Foldable t => (a -> Bool) -> t a -> Bool
- Prelude.Compat: appendFile :: FilePath -> String -> IO ()
- Prelude.Compat: asTypeOf :: () => a -> a -> a
- Prelude.Compat: asin :: Floating a => a -> a
- Prelude.Compat: asinh :: Floating a => a -> a
- Prelude.Compat: atan :: Floating a => a -> a
- Prelude.Compat: atan2 :: RealFloat a => a -> a -> a
- Prelude.Compat: atanh :: Floating a => a -> a
- Prelude.Compat: break :: () => (a -> Bool) -> [a] -> ([a], [a])
- Prelude.Compat: ceiling :: (RealFrac a, Integral b) => a -> b
- Prelude.Compat: class Functor f => Applicative (f :: Type -> Type)
- Prelude.Compat: class Bounded a
- Prelude.Compat: class Enum a
- Prelude.Compat: class Eq a
- Prelude.Compat: class Fractional a => Floating a
- Prelude.Compat: class Foldable (t :: Type -> Type)
- Prelude.Compat: class Num a => Fractional a
- Prelude.Compat: class Functor (f :: Type -> Type)
- Prelude.Compat: class (Real a, Enum a) => Integral a
- Prelude.Compat: class Applicative m => Monad (m :: Type -> Type)
- Prelude.Compat: class Monad m => MonadFail (m :: Type -> Type)
- Prelude.Compat: class Semigroup a => Monoid a
- Prelude.Compat: class Num a
- Prelude.Compat: class Eq a => Ord a
- Prelude.Compat: class Read a
- Prelude.Compat: class (Num a, Ord a) => Real a
- Prelude.Compat: class (RealFrac a, Floating a) => RealFloat a
- Prelude.Compat: class (Real a, Fractional a) => RealFrac a
- Prelude.Compat: class Semigroup a
- Prelude.Compat: class Show a
- Prelude.Compat: class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
- Prelude.Compat: compare :: Ord a => a -> a -> Ordering
- Prelude.Compat: concat :: Foldable t => t [a] -> [a]
- Prelude.Compat: concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
- Prelude.Compat: const :: () => a -> b -> a
- Prelude.Compat: cos :: Floating a => a -> a
- Prelude.Compat: cosh :: Floating a => a -> a
- Prelude.Compat: curry :: () => ((a, b) -> c) -> a -> b -> c
- Prelude.Compat: cycle :: () => [a] -> [a]
- Prelude.Compat: data Bool
- Prelude.Compat: data Char
- Prelude.Compat: data Double
- Prelude.Compat: data Either a b
- Prelude.Compat: data Float
- Prelude.Compat: data IO a
- Prelude.Compat: data Int
- Prelude.Compat: data Integer
- Prelude.Compat: data Maybe a
- Prelude.Compat: data Ordering
- Prelude.Compat: data Word
- Prelude.Compat: decodeFloat :: RealFloat a => a -> (Integer, Int)
- Prelude.Compat: div :: Integral a => a -> a -> a
- Prelude.Compat: divMod :: Integral a => a -> a -> (a, a)
- Prelude.Compat: drop :: () => Int -> [a] -> [a]
- Prelude.Compat: dropWhile :: () => (a -> Bool) -> [a] -> [a]
- Prelude.Compat: either :: () => (a -> c) -> (b -> c) -> Either a b -> c
- Prelude.Compat: elem :: (Foldable t, Eq a) => a -> t a -> Bool
- Prelude.Compat: encodeFloat :: RealFloat a => Integer -> Int -> a
- Prelude.Compat: enumFrom :: Enum a => a -> [a]
- Prelude.Compat: enumFromThen :: Enum a => a -> a -> [a]
- Prelude.Compat: enumFromThenTo :: Enum a => a -> a -> a -> [a]
- Prelude.Compat: enumFromTo :: Enum a => a -> a -> [a]
- Prelude.Compat: error :: HasCallStack => [Char] -> a
- Prelude.Compat: errorWithoutStackTrace :: () => [Char] -> a
- Prelude.Compat: even :: Integral a => a -> Bool
- Prelude.Compat: exp :: Floating a => a -> a
- Prelude.Compat: exponent :: RealFloat a => a -> Int
- Prelude.Compat: fail :: MonadFail m => String -> m a
- Prelude.Compat: filter :: () => (a -> Bool) -> [a] -> [a]
- Prelude.Compat: flip :: () => (a -> b -> c) -> b -> a -> c
- Prelude.Compat: floatDigits :: RealFloat a => a -> Int
- Prelude.Compat: floatRadix :: RealFloat a => a -> Integer
- Prelude.Compat: floatRange :: RealFloat a => a -> (Int, Int)
- Prelude.Compat: floor :: (RealFrac a, Integral b) => a -> b
- Prelude.Compat: fmap :: Functor f => (a -> b) -> f a -> f b
- Prelude.Compat: foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
- Prelude.Compat: foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
- Prelude.Compat: foldl1 :: Foldable t => (a -> a -> a) -> t a -> a
- Prelude.Compat: foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
- Prelude.Compat: foldr1 :: Foldable t => (a -> a -> a) -> t a -> a
- Prelude.Compat: fromEnum :: Enum a => a -> Int
- Prelude.Compat: fromInteger :: Num a => Integer -> a
- Prelude.Compat: fromIntegral :: (Integral a, Num b) => a -> b
- Prelude.Compat: fromRational :: Fractional a => Rational -> a
- Prelude.Compat: fst :: () => (a, b) -> a
- Prelude.Compat: gcd :: Integral a => a -> a -> a
- Prelude.Compat: getChar :: IO Char
- Prelude.Compat: getContents :: IO String
- Prelude.Compat: getLine :: IO String
- Prelude.Compat: head :: () => [a] -> a
- Prelude.Compat: id :: () => a -> a
- Prelude.Compat: infix 4 `notElem`
- Prelude.Compat: infixl 1 >>
- Prelude.Compat: infixl 4 <$>
- Prelude.Compat: infixl 6 -
- Prelude.Compat: infixl 7 *
- Prelude.Compat: infixl 9 !!
- Prelude.Compat: infixr 0 $!
- Prelude.Compat: infixr 1 =<<
- Prelude.Compat: infixr 2 ||
- Prelude.Compat: infixr 3 &&
- Prelude.Compat: infixr 5 ++
- Prelude.Compat: infixr 6 <>
- Prelude.Compat: infixr 8 ^
- Prelude.Compat: infixr 9 .
- Prelude.Compat: init :: () => [a] -> [a]
- Prelude.Compat: interact :: (String -> String) -> IO ()
- Prelude.Compat: ioError :: () => IOError -> IO a
- Prelude.Compat: isDenormalized :: RealFloat a => a -> Bool
- Prelude.Compat: isIEEE :: RealFloat a => a -> Bool
- Prelude.Compat: isInfinite :: RealFloat a => a -> Bool
- Prelude.Compat: isNaN :: RealFloat a => a -> Bool
- Prelude.Compat: isNegativeZero :: RealFloat a => a -> Bool
- Prelude.Compat: iterate :: () => (a -> a) -> a -> [a]
- Prelude.Compat: last :: () => [a] -> a
- Prelude.Compat: lcm :: Integral a => a -> a -> a
- Prelude.Compat: length :: Foldable t => t a -> Int
- Prelude.Compat: lex :: ReadS String
- Prelude.Compat: lines :: String -> [String]
- Prelude.Compat: log :: Floating a => a -> a
- Prelude.Compat: logBase :: Floating a => a -> a -> a
- Prelude.Compat: lookup :: Eq a => a -> [(a, b)] -> Maybe b
- Prelude.Compat: map :: () => (a -> b) -> [a] -> [b]
- Prelude.Compat: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
- Prelude.Compat: mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- Prelude.Compat: mappend :: Monoid a => a -> a -> a
- Prelude.Compat: max :: Ord a => a -> a -> a
- Prelude.Compat: maxBound :: Bounded a => a
- Prelude.Compat: maximum :: (Foldable t, Ord a) => t a -> a
- Prelude.Compat: maybe :: () => b -> (a -> b) -> Maybe a -> b
- Prelude.Compat: mconcat :: Monoid a => [a] -> a
- Prelude.Compat: mempty :: Monoid a => a
- Prelude.Compat: min :: Ord a => a -> a -> a
- Prelude.Compat: minBound :: Bounded a => a
- Prelude.Compat: minimum :: (Foldable t, Ord a) => t a -> a
- Prelude.Compat: mod :: Integral a => a -> a -> a
- Prelude.Compat: negate :: Num a => a -> a
- Prelude.Compat: not :: Bool -> Bool
- Prelude.Compat: notElem :: (Foldable t, Eq a) => a -> t a -> Bool
- Prelude.Compat: null :: Foldable t => t a -> Bool
- Prelude.Compat: odd :: Integral a => a -> Bool
- Prelude.Compat: or :: Foldable t => t Bool -> Bool
- Prelude.Compat: otherwise :: Bool
- Prelude.Compat: pi :: Floating a => a
- Prelude.Compat: pred :: Enum a => a -> a
- Prelude.Compat: print :: Show a => a -> IO ()
- Prelude.Compat: product :: (Foldable t, Num a) => t a -> a
- Prelude.Compat: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
- Prelude.Compat: pure :: Applicative f => a -> f a
- Prelude.Compat: putChar :: Char -> IO ()
- Prelude.Compat: putStr :: String -> IO ()
- Prelude.Compat: putStrLn :: String -> IO ()
- Prelude.Compat: quot :: Integral a => a -> a -> a
- Prelude.Compat: quotRem :: Integral a => a -> a -> (a, a)
- Prelude.Compat: read :: Read a => String -> a
- Prelude.Compat: readFile :: FilePath -> IO String
- Prelude.Compat: readIO :: Read a => String -> IO a
- Prelude.Compat: readList :: Read a => ReadS [a]
- Prelude.Compat: readLn :: Read a => IO a
- Prelude.Compat: readParen :: () => Bool -> ReadS a -> ReadS a
- Prelude.Compat: reads :: Read a => ReadS a
- Prelude.Compat: readsPrec :: Read a => Int -> ReadS a
- Prelude.Compat: realToFrac :: (Real a, Fractional b) => a -> b
- Prelude.Compat: recip :: Fractional a => a -> a
- Prelude.Compat: rem :: Integral a => a -> a -> a
- Prelude.Compat: repeat :: () => a -> [a]
- Prelude.Compat: replicate :: () => Int -> a -> [a]
- Prelude.Compat: return :: Monad m => a -> m a
- Prelude.Compat: reverse :: () => [a] -> [a]
- Prelude.Compat: round :: (RealFrac a, Integral b) => a -> b
- Prelude.Compat: scaleFloat :: RealFloat a => Int -> a -> a
- Prelude.Compat: scanl :: () => (b -> a -> b) -> b -> [a] -> [b]
- Prelude.Compat: scanl1 :: () => (a -> a -> a) -> [a] -> [a]
- Prelude.Compat: scanr :: () => (a -> b -> b) -> b -> [a] -> [b]
- Prelude.Compat: scanr1 :: () => (a -> a -> a) -> [a] -> [a]
- Prelude.Compat: seq :: () => a -> b -> b
- Prelude.Compat: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
- Prelude.Compat: sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
- Prelude.Compat: sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- Prelude.Compat: show :: Show a => a -> String
- Prelude.Compat: showChar :: Char -> ShowS
- Prelude.Compat: showList :: Show a => [a] -> ShowS
- Prelude.Compat: showParen :: Bool -> ShowS -> ShowS
- Prelude.Compat: showString :: String -> ShowS
- Prelude.Compat: shows :: Show a => a -> ShowS
- Prelude.Compat: showsPrec :: Show a => Int -> a -> ShowS
- Prelude.Compat: significand :: RealFloat a => a -> a
- Prelude.Compat: signum :: Num a => a -> a
- Prelude.Compat: sin :: Floating a => a -> a
- Prelude.Compat: sinh :: Floating a => a -> a
- Prelude.Compat: snd :: () => (a, b) -> b
- Prelude.Compat: span :: () => (a -> Bool) -> [a] -> ([a], [a])
- Prelude.Compat: splitAt :: () => Int -> [a] -> ([a], [a])
- Prelude.Compat: sqrt :: Floating a => a -> a
- Prelude.Compat: subtract :: Num a => a -> a -> a
- Prelude.Compat: succ :: Enum a => a -> a
- Prelude.Compat: sum :: (Foldable t, Num a) => t a -> a
- Prelude.Compat: tail :: () => [a] -> [a]
- Prelude.Compat: take :: () => Int -> [a] -> [a]
- Prelude.Compat: takeWhile :: () => (a -> Bool) -> [a] -> [a]
- Prelude.Compat: tan :: Floating a => a -> a
- Prelude.Compat: tanh :: Floating a => a -> a
- Prelude.Compat: toEnum :: Enum a => Int -> a
- Prelude.Compat: toInteger :: Integral a => a -> Integer
- Prelude.Compat: toRational :: Real a => a -> Rational
- Prelude.Compat: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
- Prelude.Compat: truncate :: (RealFrac a, Integral b) => a -> b
- Prelude.Compat: type FilePath = String
- Prelude.Compat: type IOError = IOException
- Prelude.Compat: type Rational = Ratio Integer
- Prelude.Compat: type ReadS a = String -> [(a, String)]
- Prelude.Compat: type ShowS = String -> String
- Prelude.Compat: type String = [Char]
- Prelude.Compat: uncurry :: () => (a -> b -> c) -> (a, b) -> c
- Prelude.Compat: undefined :: HasCallStack => a
- Prelude.Compat: unlines :: [String] -> String
- Prelude.Compat: until :: () => (a -> Bool) -> (a -> a) -> a -> a
- Prelude.Compat: unwords :: [String] -> String
- Prelude.Compat: unzip :: () => [(a, b)] -> ([a], [b])
- Prelude.Compat: unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])
- Prelude.Compat: userError :: String -> IOError
- Prelude.Compat: words :: String -> [String]
- Prelude.Compat: writeFile :: FilePath -> String -> IO ()
- Prelude.Compat: zip :: () => [a] -> [b] -> [(a, b)]
- Prelude.Compat: zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]
- Prelude.Compat: zipWith :: () => (a -> b -> c) -> [a] -> [b] -> [c]
- Prelude.Compat: zipWith3 :: () => (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
+ Control.Monad.Compat: (<$) :: Functor f => a -> f b -> f a
+ Data.Functor.Const.Compat: newtype Const a (b :: k)
+ Data.Monoid.Compat: newtype Alt (f :: k -> Type) (a :: k)
+ Data.Monoid.Compat: newtype Ap (f :: k -> Type) (a :: k)
+ Numeric.Compat: readBin :: (Eq a, Num a) => ReadS a
+ Numeric.Compat: showBin :: (Integral a, Show a) => a -> ShowS
+ Text.Read.Lex.Compat: readBinP :: (Eq a, Num a) => ReadP a
- Control.Concurrent.Compat: forkFinally :: () => IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
+ Control.Concurrent.Compat: forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
- Control.Concurrent.MVar.Compat: withMVarMasked :: () => MVar a -> (a -> IO b) -> IO b
+ Control.Concurrent.MVar.Compat: withMVarMasked :: MVar a -> (a -> IO b) -> IO b
- Control.Exception.Compat: throw :: Exception e => e -> a
+ Control.Exception.Compat: throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a
- Control.Monad.ST.Lazy.Unsafe.Compat: unsafeIOToST :: () => IO a -> ST s a
+ Control.Monad.ST.Lazy.Unsafe.Compat: unsafeIOToST :: IO a -> ST s a
- Control.Monad.ST.Lazy.Unsafe.Compat: unsafeInterleaveST :: () => ST s a -> ST s a
+ Control.Monad.ST.Lazy.Unsafe.Compat: unsafeInterleaveST :: ST s a -> ST s a
- Control.Monad.ST.Unsafe.Compat: unsafeIOToST :: () => IO a -> ST s a
+ Control.Monad.ST.Unsafe.Compat: unsafeIOToST :: IO a -> ST s a
- Control.Monad.ST.Unsafe.Compat: unsafeInterleaveST :: () => ST s a -> ST s a
+ Control.Monad.ST.Unsafe.Compat: unsafeInterleaveST :: ST s a -> ST s a
- Control.Monad.ST.Unsafe.Compat: unsafeSTToIO :: () => ST s a -> IO a
+ Control.Monad.ST.Unsafe.Compat: unsafeSTToIO :: ST s a -> IO a
- Data.Bool.Compat: bool :: () => a -> a -> Bool -> a
+ Data.Bool.Compat: bool :: a -> a -> Bool -> a
- Data.Either.Compat: fromLeft :: () => a -> Either a b -> a
+ Data.Either.Compat: fromLeft :: a -> Either a b -> a
- Data.Either.Compat: fromRight :: () => b -> Either a b -> b
+ Data.Either.Compat: fromRight :: b -> Either a b -> b
- Data.Either.Compat: isLeft :: () => Either a b -> Bool
+ Data.Either.Compat: isLeft :: Either a b -> Bool
- Data.Either.Compat: isRight :: () => Either a b -> Bool
+ Data.Either.Compat: isRight :: Either a b -> Bool
- Data.Function.Compat: (&) :: () => a -> (a -> b) -> b
+ Data.Function.Compat: (&) :: a -> (a -> b) -> b
- Data.Functor.Const.Compat: Const :: a -> Const a
+ Data.Functor.Const.Compat: Const :: a -> Const a (b :: k)
- Data.Functor.Const.Compat: [getConst] :: Const a -> a
+ Data.Functor.Const.Compat: [getConst] :: Const a (b :: k) -> a
- Data.IORef.Compat: atomicModifyIORef' :: () => IORef a -> (a -> (a, b)) -> IO b
+ Data.IORef.Compat: atomicModifyIORef' :: IORef a -> (a -> (a, b)) -> IO b
- Data.IORef.Compat: atomicWriteIORef :: () => IORef a -> a -> IO ()
+ Data.IORef.Compat: atomicWriteIORef :: IORef a -> a -> IO ()
- Data.IORef.Compat: modifyIORef' :: () => IORef a -> (a -> a) -> IO ()
+ Data.IORef.Compat: modifyIORef' :: IORef a -> (a -> a) -> IO ()
- Data.List.NonEmpty.Compat: (!!) :: () => NonEmpty a -> Int -> a
+ Data.List.NonEmpty.Compat: (!!) :: NonEmpty a -> Int -> a
- Data.List.NonEmpty.Compat: (<|) :: () => a -> NonEmpty a -> NonEmpty a
+ Data.List.NonEmpty.Compat: (<|) :: a -> NonEmpty a -> NonEmpty a
- Data.List.NonEmpty.Compat: break :: () => (a -> Bool) -> NonEmpty a -> ([a], [a])
+ Data.List.NonEmpty.Compat: break :: (a -> Bool) -> NonEmpty a -> ([a], [a])
- Data.List.NonEmpty.Compat: cons :: () => a -> NonEmpty a -> NonEmpty a
+ Data.List.NonEmpty.Compat: cons :: a -> NonEmpty a -> NonEmpty a
- Data.List.NonEmpty.Compat: cycle :: () => NonEmpty a -> NonEmpty a
+ Data.List.NonEmpty.Compat: cycle :: NonEmpty a -> NonEmpty a
- Data.List.NonEmpty.Compat: drop :: () => Int -> NonEmpty a -> [a]
+ Data.List.NonEmpty.Compat: drop :: Int -> NonEmpty a -> [a]
- Data.List.NonEmpty.Compat: dropWhile :: () => (a -> Bool) -> NonEmpty a -> [a]
+ Data.List.NonEmpty.Compat: dropWhile :: (a -> Bool) -> NonEmpty a -> [a]
- Data.List.NonEmpty.Compat: filter :: () => (a -> Bool) -> NonEmpty a -> [a]
+ Data.List.NonEmpty.Compat: filter :: (a -> Bool) -> NonEmpty a -> [a]
- Data.List.NonEmpty.Compat: fromList :: () => [a] -> NonEmpty a
+ Data.List.NonEmpty.Compat: fromList :: [a] -> NonEmpty a
- Data.List.NonEmpty.Compat: groupBy1 :: () => (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)
+ Data.List.NonEmpty.Compat: groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)
- Data.List.NonEmpty.Compat: head :: () => NonEmpty a -> a
+ Data.List.NonEmpty.Compat: head :: NonEmpty a -> a
- Data.List.NonEmpty.Compat: init :: () => NonEmpty a -> [a]
+ Data.List.NonEmpty.Compat: init :: NonEmpty a -> [a]
- Data.List.NonEmpty.Compat: intersperse :: () => a -> NonEmpty a -> NonEmpty a
+ Data.List.NonEmpty.Compat: intersperse :: a -> NonEmpty a -> NonEmpty a
- Data.List.NonEmpty.Compat: iterate :: () => (a -> a) -> a -> NonEmpty a
+ Data.List.NonEmpty.Compat: iterate :: (a -> a) -> a -> NonEmpty a
- Data.List.NonEmpty.Compat: last :: () => NonEmpty a -> a
+ Data.List.NonEmpty.Compat: last :: NonEmpty a -> a
- Data.List.NonEmpty.Compat: length :: () => NonEmpty a -> Int
+ Data.List.NonEmpty.Compat: length :: NonEmpty a -> Int
- Data.List.NonEmpty.Compat: map :: () => (a -> b) -> NonEmpty a -> NonEmpty b
+ Data.List.NonEmpty.Compat: map :: (a -> b) -> NonEmpty a -> NonEmpty b
- Data.List.NonEmpty.Compat: nonEmpty :: () => [a] -> Maybe (NonEmpty a)
+ Data.List.NonEmpty.Compat: nonEmpty :: [a] -> Maybe (NonEmpty a)
- Data.List.NonEmpty.Compat: nubBy :: () => (a -> a -> Bool) -> NonEmpty a -> NonEmpty a
+ Data.List.NonEmpty.Compat: nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a
- Data.List.NonEmpty.Compat: partition :: () => (a -> Bool) -> NonEmpty a -> ([a], [a])
+ Data.List.NonEmpty.Compat: partition :: (a -> Bool) -> NonEmpty a -> ([a], [a])
- Data.List.NonEmpty.Compat: repeat :: () => a -> NonEmpty a
+ Data.List.NonEmpty.Compat: repeat :: a -> NonEmpty a
- Data.List.NonEmpty.Compat: reverse :: () => NonEmpty a -> NonEmpty a
+ Data.List.NonEmpty.Compat: reverse :: NonEmpty a -> NonEmpty a
- Data.List.NonEmpty.Compat: scanl1 :: () => (a -> a -> a) -> NonEmpty a -> NonEmpty a
+ Data.List.NonEmpty.Compat: scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
- Data.List.NonEmpty.Compat: scanr1 :: () => (a -> a -> a) -> NonEmpty a -> NonEmpty a
+ Data.List.NonEmpty.Compat: scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
- Data.List.NonEmpty.Compat: sortBy :: () => (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
+ Data.List.NonEmpty.Compat: sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
- Data.List.NonEmpty.Compat: span :: () => (a -> Bool) -> NonEmpty a -> ([a], [a])
+ Data.List.NonEmpty.Compat: span :: (a -> Bool) -> NonEmpty a -> ([a], [a])
- Data.List.NonEmpty.Compat: splitAt :: () => Int -> NonEmpty a -> ([a], [a])
+ Data.List.NonEmpty.Compat: splitAt :: Int -> NonEmpty a -> ([a], [a])
- Data.List.NonEmpty.Compat: tail :: () => NonEmpty a -> [a]
+ Data.List.NonEmpty.Compat: tail :: NonEmpty a -> [a]
- Data.List.NonEmpty.Compat: take :: () => Int -> NonEmpty a -> [a]
+ Data.List.NonEmpty.Compat: take :: Int -> NonEmpty a -> [a]
- Data.List.NonEmpty.Compat: takeWhile :: () => (a -> Bool) -> NonEmpty a -> [a]
+ Data.List.NonEmpty.Compat: takeWhile :: (a -> Bool) -> NonEmpty a -> [a]
- Data.List.NonEmpty.Compat: toList :: () => NonEmpty a -> [a]
+ Data.List.NonEmpty.Compat: toList :: NonEmpty a -> [a]
- Data.List.NonEmpty.Compat: transpose :: () => NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
+ Data.List.NonEmpty.Compat: transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
- Data.List.NonEmpty.Compat: uncons :: () => NonEmpty a -> (a, Maybe (NonEmpty a))
+ Data.List.NonEmpty.Compat: uncons :: NonEmpty a -> (a, Maybe (NonEmpty a))
- Data.List.NonEmpty.Compat: unfold :: () => (a -> (b, Maybe a)) -> a -> NonEmpty b
+ Data.List.NonEmpty.Compat: unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b
- Data.List.NonEmpty.Compat: unfoldr :: () => (a -> (b, Maybe a)) -> a -> NonEmpty b
+ Data.List.NonEmpty.Compat: unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b
- Data.List.NonEmpty.Compat: zip :: () => NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
+ Data.List.NonEmpty.Compat: zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
- Data.List.NonEmpty.Compat: zipWith :: () => (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
+ Data.List.NonEmpty.Compat: zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
- Data.Monoid.Compat: Alt :: f a -> Alt
+ Data.Monoid.Compat: Alt :: f a -> Alt (f :: k -> Type) (a :: k)
- Data.Monoid.Compat: Ap :: f a -> Ap
+ Data.Monoid.Compat: Ap :: f a -> Ap (f :: k -> Type) (a :: k)
- Data.Monoid.Compat: [getAlt] :: Alt -> f a
+ Data.Monoid.Compat: [getAlt] :: Alt (f :: k -> Type) (a :: k) -> f a
- Data.Monoid.Compat: [getAp] :: Ap -> f a
+ Data.Monoid.Compat: [getAp] :: Ap (f :: k -> Type) (a :: k) -> f a
- Data.Proxy.Compat: asProxyTypeOf :: () => a -> proxy a -> a
+ Data.Proxy.Compat: asProxyTypeOf :: a -> proxy a -> a
- Data.STRef.Compat: modifySTRef' :: () => STRef s a -> (a -> a) -> ST s ()
+ Data.STRef.Compat: modifySTRef' :: STRef s a -> (a -> a) -> ST s ()
- Data.Type.Coercion.Compat: gcoerceWith :: () => Coercion a b -> (Coercible a b -> r) -> r
+ Data.Type.Coercion.Compat: gcoerceWith :: forall k (a :: k) (b :: k) r. Coercion a b -> (Coercible a b => r) -> r
- Foreign.ForeignPtr.Compat: plusForeignPtr :: () => ForeignPtr a -> Int -> ForeignPtr b
+ Foreign.ForeignPtr.Compat: plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b
- Foreign.ForeignPtr.Safe.Compat: addForeignPtrFinalizer :: () => FinalizerPtr a -> ForeignPtr a -> IO ()
+ Foreign.ForeignPtr.Safe.Compat: addForeignPtrFinalizer :: FinalizerPtr a -> ForeignPtr a -> IO ()
- Foreign.ForeignPtr.Safe.Compat: addForeignPtrFinalizerEnv :: () => FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> IO ()
+ Foreign.ForeignPtr.Safe.Compat: addForeignPtrFinalizerEnv :: FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> IO ()
- Foreign.ForeignPtr.Safe.Compat: castForeignPtr :: () => ForeignPtr a -> ForeignPtr b
+ Foreign.ForeignPtr.Safe.Compat: castForeignPtr :: ForeignPtr a -> ForeignPtr b
- Foreign.ForeignPtr.Safe.Compat: finalizeForeignPtr :: () => ForeignPtr a -> IO ()
+ Foreign.ForeignPtr.Safe.Compat: finalizeForeignPtr :: ForeignPtr a -> IO ()
- Foreign.ForeignPtr.Safe.Compat: mallocForeignPtrBytes :: () => Int -> IO (ForeignPtr a)
+ Foreign.ForeignPtr.Safe.Compat: mallocForeignPtrBytes :: Int -> IO (ForeignPtr a)
- Foreign.ForeignPtr.Safe.Compat: newForeignPtr :: () => FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
+ Foreign.ForeignPtr.Safe.Compat: newForeignPtr :: FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
- Foreign.ForeignPtr.Safe.Compat: newForeignPtrEnv :: () => FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO (ForeignPtr a)
+ Foreign.ForeignPtr.Safe.Compat: newForeignPtrEnv :: FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO (ForeignPtr a)
- Foreign.ForeignPtr.Safe.Compat: newForeignPtr_ :: () => Ptr a -> IO (ForeignPtr a)
+ Foreign.ForeignPtr.Safe.Compat: newForeignPtr_ :: Ptr a -> IO (ForeignPtr a)
- Foreign.ForeignPtr.Safe.Compat: touchForeignPtr :: () => ForeignPtr a -> IO ()
+ Foreign.ForeignPtr.Safe.Compat: touchForeignPtr :: ForeignPtr a -> IO ()
- Foreign.ForeignPtr.Safe.Compat: withForeignPtr :: () => ForeignPtr a -> (Ptr a -> IO b) -> IO b
+ Foreign.ForeignPtr.Safe.Compat: withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
- Foreign.ForeignPtr.Unsafe.Compat: unsafeForeignPtrToPtr :: () => ForeignPtr a -> Ptr a
+ Foreign.ForeignPtr.Unsafe.Compat: unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr a
- Foreign.Marshal.Alloc.Compat: callocBytes :: () => Int -> IO (Ptr a)
+ Foreign.Marshal.Alloc.Compat: callocBytes :: Int -> IO (Ptr a)
- Foreign.Marshal.Unsafe.Compat: unsafeLocalState :: () => IO a -> a
+ Foreign.Marshal.Unsafe.Compat: unsafeLocalState :: IO a -> a
- Foreign.Marshal.Utils.Compat: fillBytes :: () => Ptr a -> Word8 -> Int -> IO ()
+ Foreign.Marshal.Utils.Compat: fillBytes :: Ptr a -> Word8 -> Int -> IO ()
- System.Environment.Compat: withArgs :: () => [String] -> IO a -> IO a
+ System.Environment.Compat: withArgs :: [String] -> IO a -> IO a
- System.Environment.Compat: withProgName :: () => String -> IO a -> IO a
+ System.Environment.Compat: withProgName :: String -> IO a -> IO a
- System.Exit.Compat: die :: () => String -> IO a
+ System.Exit.Compat: die :: String -> IO a
- System.IO.Unsafe.Compat: unsafeDupablePerformIO :: () => IO a -> a
+ System.IO.Unsafe.Compat: unsafeDupablePerformIO :: IO a -> a
- System.IO.Unsafe.Compat: unsafeFixIO :: () => (a -> IO a) -> IO a
+ System.IO.Unsafe.Compat: unsafeFixIO :: (a -> IO a) -> IO a
- Text.Read.Compat: parens :: () => ReadPrec a -> ReadPrec a
+ Text.Read.Compat: parens :: ReadPrec a -> ReadPrec a
- Text.Read.Compat: readParen :: () => Bool -> ReadS a -> ReadS a
+ Text.Read.Compat: readParen :: Bool -> ReadS a -> ReadS a
- Type.Reflection.Compat: withTypeable :: () => TypeRep a -> (Typeable a -> r) -> r
+ Type.Reflection.Compat: withTypeable :: forall k (a :: k) (rep :: RuntimeRep) (r :: TYPE rep). TypeRep a -> (Typeable a => r) -> r
Files
- CHANGES.markdown +10/−2
- README.markdown +4/−2
- base-compat.cabal +3/−13
- src/Data/Semigroup/Compat.hs +0/−3
- src/Numeric/Compat.hs +19/−2
- src/Text/Read/Lex/Compat.hs +34/−0
- src/Text/Read/Lex/Compat/Repl.hs +8/−0
CHANGES.markdown view
@@ -1,7 +1,15 @@+## Changes in 0.12.0 [2021.08.29]+ - Sync with `base-4.16`/GHC 9.2+ - `Data.Semigroup.Compat{.Repl}` no longer re-exports the `Option` data type+ or the `option` function, as both have been removed in `base-4.16`.+ - Backport `readBin` and `showBin` to `Numeric.Compat`+ - Backport `readBinP` to `Text.Read.Lex.Compat`+ ## Changes in 0.11.2 [2020.09.30] - Sync with `base-4.15`/GHC 9.0- - Backport `singleton` to `Data.List` and `Data.List.NonEmpty`- - Backport `hGetContents'`, `getContents'`, and `readFile'` added to `System.IO`+ - Backport `singleton` to `Data.List.Compat` and `Data.List.NonEmpty.Compat`+ - Backport `hGetContents'`, `getContents'`, and `readFile'` added to+ `System.IO.Compat` ## Changes in 0.11.1 [2020.01.27] - Sync with `base-4.14`/GHC 8.10
README.markdown view
@@ -145,7 +145,7 @@ * `callocArray` and `callocArray0` functions to `Foreign.Marshal.Array.Compat` * `fillBytes` to `Foreign.Marshal.Utils.Compat` * Added `Data.List.Compat.scanl'`- * `showFFloatAlt` and `showGFloatAlt` to `Numeric.Compat`+ * `showFFloatAlt`, `showGFloatAlt`, `readBin`, and `showBin` to `Numeric.Compat` * `lookupEnv`, `setEnv` and `unsetEnv` to `System.Environment.Compat` * `unsafeFixIO` and `unsafeDupablePerformIO` to `System.IO.Unsafe.IO` * `RuntimeRep`-polymorphic `($!)` to `Prelude.Compat`@@ -153,7 +153,8 @@ * `isResourceVanishedError`, `resourceVanishedErrorType`, and `isResourceVanishedErrorType` to `System.IO.Error.Compat` * `singleton` to `Data.List.Compat` and `Data.List.NonEmpty.Compat`- * `hGetContents'`, `getContents'`, and `readFile'` to `System.IO`+ * `hGetContents'`, `getContents'`, and `readFile'` to `System.IO.Compat`+ * `readBinP` to `Text.Read.Lex.Compat` ## What is not covered @@ -306,6 +307,7 @@ ## Supported versions of GHC/`base` + * `ghc-9.2.*` / `base-4.16.*` * `ghc-9.0.*` / `base-4.15.*` * `ghc-8.10.*` / `base-4.14.*` * `ghc-8.8.*` / `base-4.13.*`
base-compat.cabal view
@@ -1,5 +1,5 @@ name: base-compat-version: 0.11.2+version: 0.12.0 license: MIT license-file: LICENSE copyright: (c) 2012-2018 Simon Hengel,@@ -43,18 +43,6 @@ module with the suffix @.Repl@, which are distinct from anything in @base-compat-batteries@, to allow for easier use in GHCi.-tested-with: GHC == 7.0.4- , GHC == 7.2.2- , GHC == 7.4.2- , GHC == 7.6.3- , GHC == 7.8.4- , GHC == 7.10.3- , GHC == 8.0.2- , GHC == 8.2.2- , GHC == 8.4.4- , GHC == 8.6.5- , GHC == 8.8.3- , GHC == 8.10.1 extra-source-files: CHANGES.markdown, README.markdown source-repository head@@ -138,6 +126,7 @@ System.IO.Error.Compat System.IO.Unsafe.Compat Text.Read.Compat+ Text.Read.Lex.Compat Type.Reflection.Compat Control.Concurrent.Compat.Repl@@ -198,4 +187,5 @@ System.IO.Error.Compat.Repl System.IO.Unsafe.Compat.Repl Text.Read.Compat.Repl+ Text.Read.Lex.Compat.Repl Type.Reflection.Compat.Repl
src/Data/Semigroup/Compat.hs view
@@ -21,9 +21,6 @@ , Any(..) , Sum(..) , Product(..)- -- * A better monoid for Maybe- , Option(..)- , option -- * Difference lists of a semigroup , diff , cycle1
src/Numeric/Compat.hs view
@@ -1,20 +1,24 @@ {-# LANGUAGE CPP, NoImplicitPrelude #-} module Numeric.Compat ( module Base+, showBin , showFFloatAlt , showGFloatAlt , showHFloat+, readBin ) where import Numeric as Base #if !(MIN_VERSION_base(4,7,0))-import Data.Char (intToDigit) import GHC.Float #endif -#if !(MIN_VERSION_base(4,11,0))+#if !(MIN_VERSION_base(4,16,0))+import Data.Char (intToDigit) import Prelude+import Text.ParserCombinators.ReadP (readP_to_S)+import qualified Text.Read.Lex.Compat as L #endif #if !(MIN_VERSION_base(4,7,0))@@ -150,4 +154,17 @@ allZ xs = case xs of x : more -> x == 0 && allZ more [] -> True+#endif++#if !(MIN_VERSION_base(4,16,0))+-- | Read an unsigned number in binary notation.+--+-- >>> readBin "10011"+-- [(19,"")]+readBin :: (Eq a, Num a) => ReadS a+readBin = readP_to_S L.readBinP++-- | Show /non-negative/ 'Integral' numbers in base 2.+showBin :: (Integral a, Show a) => a -> ShowS+showBin = showIntAtBase 2 intToDigit #endif
+ src/Text/Read/Lex/Compat.hs view
@@ -0,0 +1,34 @@+{-# LANGUAGE CPP, NoImplicitPrelude #-}+#if __GLASGOW_HASKELL__ >= 702+{-# LANGUAGE Trustworthy #-}+#endif+module Text.Read.Lex.Compat (+ module Base+, readBinP+) where++import Text.Read.Lex as Base++#if !(MIN_VERSION_base(4,16,0))+import Data.Char (ord)+import Prelude+import Text.ParserCombinators.ReadP (ReadP)+#endif++#if !(MIN_VERSION_base(4,16,0))+readBinP :: (Eq a, Num a) => ReadP a+readBinP = readIntP'2+{-# SPECIALISE readBinP :: ReadP Integer #-}++readIntP'2 :: (Eq a, Num a) => ReadP a+readIntP'2 = readIntP 2 isDigit valDigit+ where+ isDigit c = maybe False (const True) (valDig2 c)+ valDigit c = maybe 0 id (valDig2 c)+{-# SPECIALISE readIntP'2 :: ReadP Integer #-}++valDig2 :: Char -> Maybe Int+valDig2 c+ | '0' <= c && c <= '1' = Just (ord c - ord '0')+ | otherwise = Nothing+#endif
+ src/Text/Read/Lex/Compat/Repl.hs view
@@ -0,0 +1,8 @@+{-# LANGUAGE PackageImports #-}+{-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-}+-- | Reexports "Text.Read.Lex.Compat"+-- from a globally unique namespace.+module Text.Read.Lex.Compat.Repl (+ module Text.Read.Lex.Compat+) where+import "this" Text.Read.Lex.Compat