base-compat 0.14.1 → 0.15.0
raw patch · 4 files changed
+27/−8 lines, 4 filesdep −unixPVP ok
version bump matches the API change (PVP)
Dependencies removed: unix
API changes (from Hackage documentation)
- Control.Monad.Compat: (<$!>) :: Monad m => (a -> b) -> m a -> m b
- Control.Monad.Compat: (<$) :: Functor f => a -> f b -> f a
- Control.Monad.Compat: (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- Control.Monad.Compat: (=<<) :: Monad m => (a -> m b) -> m a -> m b
- Control.Monad.Compat: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- Control.Monad.Compat: (>>) :: Monad m => m a -> m b -> m b
- Control.Monad.Compat: (>>=) :: Monad m => m a -> (a -> m b) -> m b
- Control.Monad.Compat: ap :: Monad m => m (a -> b) -> m a -> m b
- Control.Monad.Compat: class () => Functor (f :: Type -> Type)
- Control.Monad.Compat: filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
- Control.Monad.Compat: fmap :: Functor f => (a -> b) -> f a -> f b
- Control.Monad.Compat: foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- Control.Monad.Compat: foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
- Control.Monad.Compat: forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- Control.Monad.Compat: forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
- Control.Monad.Compat: forever :: Applicative f => f a -> f b
- Control.Monad.Compat: guard :: Alternative f => Bool -> f ()
- Control.Monad.Compat: infixl 1 >>
- Control.Monad.Compat: infixl 4 <$!>
- Control.Monad.Compat: infixr 1 <=<
- Control.Monad.Compat: join :: Monad m => m (m a) -> m a
- Control.Monad.Compat: liftM :: Monad m => (a1 -> r) -> m a1 -> m r
- Control.Monad.Compat: liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
- Control.Monad.Compat: liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
- Control.Monad.Compat: liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
- Control.Monad.Compat: liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
- Control.Monad.Compat: mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
- Control.Monad.Compat: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
- Control.Monad.Compat: mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- Control.Monad.Compat: mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
- Control.Monad.Compat: msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
- Control.Monad.Compat: replicateM :: Applicative m => Int -> m a -> m [a]
- Control.Monad.Compat: replicateM_ :: Applicative m => Int -> m a -> m ()
- Control.Monad.Compat: return :: Monad m => a -> m a
- Control.Monad.Compat: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
- Control.Monad.Compat: sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- Control.Monad.Compat: unless :: Applicative f => Bool -> f () -> f ()
- Control.Monad.Compat: void :: Functor f => f a -> f ()
- Control.Monad.Compat: when :: Applicative f => Bool -> f () -> f ()
- Control.Monad.Compat: zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- Control.Monad.Compat: zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
- Data.List.Compat: (!?) :: [a] -> Int -> Maybe a
- Data.List.Compat: infixl 9 !?
- Data.List.Compat: unsnoc :: [a] -> Maybe ([a], a)
+ Data.Tuple.Compat.Repl: curry :: ((a, b) -> c) -> a -> b -> c
+ Data.Tuple.Compat.Repl: data Solo a
+ Data.Tuple.Compat.Repl: fst :: (a, b) -> a
+ Data.Tuple.Compat.Repl: getSolo :: Solo a -> a
+ Data.Tuple.Compat.Repl: pattern Solo :: a -> Solo a
+ Data.Tuple.Compat.Repl: snd :: (a, b) -> b
+ Data.Tuple.Compat.Repl: swap :: (a, b) -> (b, a)
+ Data.Tuple.Compat.Repl: uncurry :: (a -> b -> c) -> (a, b) -> c
- Control.Exception.Compat: throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a
+ Control.Exception.Compat: throw :: forall a e. Exception e => e -> a
- Data.Bitraversable.Compat: firstA :: Bitraversable t => Applicative f => (a -> f c) -> t a b -> f (t c b)
+ Data.Bitraversable.Compat: firstA :: (Bitraversable t, Applicative f) => (a -> f c) -> t a b -> f (t c b)
- Data.Bitraversable.Compat: secondA :: Bitraversable t => Applicative f => (b -> f c) -> t a b -> f (t a c)
+ Data.Bitraversable.Compat: secondA :: (Bitraversable t, Applicative f) => (b -> f c) -> t a b -> f (t a c)
- Data.Functor.Compat: class () => Functor (f :: Type -> Type)
+ Data.Functor.Compat: class Functor (f :: Type -> Type)
- Data.Functor.Const.Compat: newtype () => Const a (b :: k)
+ Data.Functor.Const.Compat: newtype Const a (b :: k)
- Data.List.Compat: data () => [] a
+ Data.List.Compat: data [] a
- Data.List.NonEmpty.Compat: data () => NonEmpty a
+ Data.List.NonEmpty.Compat: data NonEmpty a
- Data.List.NonEmpty.Compat: unzip :: Functor f => f (a, b) -> (f a, f b)
+ Data.List.NonEmpty.Compat: unzip :: NonEmpty (a, b) -> (NonEmpty a, NonEmpty b)
- Data.Monoid.Compat: newtype () => All
+ Data.Monoid.Compat: newtype All
- Data.Monoid.Compat: newtype () => Alt (f :: k -> Type) (a :: k)
+ Data.Monoid.Compat: newtype Alt (f :: k -> Type) (a :: k)
- Data.Monoid.Compat: newtype () => Any
+ Data.Monoid.Compat: newtype Any
- Data.Monoid.Compat: newtype () => Ap (f :: k -> Type) (a :: k)
+ Data.Monoid.Compat: newtype Ap (f :: k -> Type) (a :: k)
- Data.Monoid.Compat: newtype () => Dual a
+ Data.Monoid.Compat: newtype Dual a
- Data.Monoid.Compat: newtype () => Endo a
+ Data.Monoid.Compat: newtype Endo a
- Data.Monoid.Compat: newtype () => First a
+ Data.Monoid.Compat: newtype First a
- Data.Monoid.Compat: newtype () => Last a
+ Data.Monoid.Compat: newtype Last a
- Data.Monoid.Compat: newtype () => Product a
+ Data.Monoid.Compat: newtype Product a
- Data.Monoid.Compat: newtype () => Sum a
+ Data.Monoid.Compat: newtype Sum a
- Data.Semigroup.Compat: class () => Semigroup a
+ Data.Semigroup.Compat: class Semigroup a
- Data.Semigroup.Compat: data () => Arg a b
+ Data.Semigroup.Compat: data Arg a b
- Data.Semigroup.Compat: newtype () => All
+ Data.Semigroup.Compat: newtype All
- Data.Semigroup.Compat: newtype () => Any
+ Data.Semigroup.Compat: newtype Any
- Data.Semigroup.Compat: newtype () => Dual a
+ Data.Semigroup.Compat: newtype Dual a
- Data.Semigroup.Compat: newtype () => Endo a
+ Data.Semigroup.Compat: newtype Endo a
- Data.Semigroup.Compat: newtype () => First a
+ Data.Semigroup.Compat: newtype First a
- Data.Semigroup.Compat: newtype () => Last a
+ Data.Semigroup.Compat: newtype Last a
- Data.Semigroup.Compat: newtype () => Max a
+ Data.Semigroup.Compat: newtype Max a
- Data.Semigroup.Compat: newtype () => Min a
+ Data.Semigroup.Compat: newtype Min a
- Data.Semigroup.Compat: newtype () => Product a
+ Data.Semigroup.Compat: newtype Product a
- Data.Semigroup.Compat: newtype () => Sum a
+ Data.Semigroup.Compat: newtype Sum a
- Data.Semigroup.Compat: newtype () => WrappedMonoid m
+ Data.Semigroup.Compat: newtype WrappedMonoid m
- Data.Tuple.Compat: data () => Solo a
+ Data.Tuple.Compat: data Solo a
- Data.Typeable.Compat: decT :: forall a b. (Typeable a, Typeable b) => Either ((a :~: b) -> Void) (a :~: b)
+ Data.Typeable.Compat: decT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => Either ((a :~: b) -> Void) (a :~: b)
- Data.Typeable.Compat: hdecT :: forall a b. (Typeable a, Typeable b) => Either ((a :~~: b) -> Void) (a :~~: b)
+ Data.Typeable.Compat: hdecT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => Either ((a :~~: b) -> Void) (a :~~: b)
- Foreign.ForeignPtr.Safe.Compat: data () => ForeignPtr a
+ Foreign.ForeignPtr.Safe.Compat: data ForeignPtr a
- Prelude.Compat: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
+ Prelude.Compat: ($!) :: (a -> b) -> a -> b
- Prelude.Compat: ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
+ Prelude.Compat: ($) :: (a -> b) -> a -> b
- Prelude.Compat: class () => Bounded a
+ Prelude.Compat: class Bounded a
- Prelude.Compat: class () => Enum a
+ Prelude.Compat: class Enum a
- Prelude.Compat: class () => Eq a
+ Prelude.Compat: class Eq a
- Prelude.Compat: class () => Foldable (t :: Type -> Type)
+ Prelude.Compat: class Foldable (t :: Type -> Type)
- Prelude.Compat: class () => Functor (f :: Type -> Type)
+ Prelude.Compat: class Functor (f :: Type -> Type)
- Prelude.Compat: class () => Num a
+ Prelude.Compat: class Num a
- Prelude.Compat: class () => Read a
+ Prelude.Compat: class Read a
- Prelude.Compat: class () => Semigroup a
+ Prelude.Compat: class Semigroup a
- Prelude.Compat: class () => Show a
+ Prelude.Compat: class Show a
- Prelude.Compat: data () => Bool
+ Prelude.Compat: data Bool
- Prelude.Compat: data () => Char
+ Prelude.Compat: data Char
- Prelude.Compat: data () => Double
+ Prelude.Compat: data Double
- Prelude.Compat: data () => Either a b
+ Prelude.Compat: data Either a b
- Prelude.Compat: data () => Float
+ Prelude.Compat: data Float
- Prelude.Compat: data () => IO a
+ Prelude.Compat: data IO a
- Prelude.Compat: data () => Int
+ Prelude.Compat: data Int
- Prelude.Compat: data () => Integer
+ Prelude.Compat: data Integer
- Prelude.Compat: data () => Maybe a
+ Prelude.Compat: data Maybe a
- Prelude.Compat: data () => Ordering
+ Prelude.Compat: data Ordering
- Prelude.Compat: data () => Word
+ Prelude.Compat: data Word
- Prelude.Compat: error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
+ Prelude.Compat: error :: HasCallStack => [Char] -> a
- Prelude.Compat: errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a
+ Prelude.Compat: errorWithoutStackTrace :: [Char] -> a
- Prelude.Compat: seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
+ Prelude.Compat: seq :: a -> b -> b
- Prelude.Compat: undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
+ Prelude.Compat: undefined :: HasCallStack => a
- Text.Read.Compat: class () => Read a
+ Text.Read.Compat: class Read a
- Text.Read.Compat: data () => Lexeme
+ Text.Read.Compat: data Lexeme
- Type.Reflection.Compat: withTypeable :: forall k (a :: k) (rep :: RuntimeRep) (r :: TYPE rep). TypeRep a -> (Typeable a => r) -> r
+ Type.Reflection.Compat: withTypeable :: forall k (a :: k) r. TypeRep a -> (Typeable a => r) -> r
Files
- CHANGES.markdown +6/−0
- README.markdown +2/−0
- base-compat.cabal +6/−7
- src/Data/List/NonEmpty/Compat.hs +13/−1
CHANGES.markdown view
@@ -1,3 +1,9 @@+## Changes in 0.15.0 [2026.01.10]+ - Sync with `base-4.22`/GHC 9.14+ - Restrict `Data.List.NonEmpty.Compat.unzip` to be of type+ `NonEmpty (a, b) -> (NonEmpty a, NonEmpty b)`, mirroring similar changes+ introducted in `base-4.22`.+ ## Changes in 0.14.1 [2024.12.06] - Sync with `base-4.21`/GHC 9.12 - Backport `compareLength` to `Data.List.Compat` and
README.markdown view
@@ -162,6 +162,7 @@ * `singleton` to `Data.List.Compat` and `Data.List.NonEmpty.Compat` * `inits1` and `tails1` to `Data.List.NonEmpty.Compat` * `permutations`, `permutations1`, and `sortOn` to `Data.List.NonEmpty.Compat`+ * `Data.List.NonEmpty.Compat`'s `unzip` function is restricted to only work over `NonEmpty` lists * `hGetContents'`, `getContents'`, and `readFile'` to `System.IO.Compat` * `readBinP` to `Text.Read.Lex.Compat` * `withTypeable` and `pattern TypeRep` to `Type.Reflection.Compat`@@ -314,6 +315,7 @@ ## Supported versions of GHC/`base` + * `ghc-9.14.*` / `base-4.22.*` * `ghc-9.12.*` / `base-4.21.*` * `ghc-9.10.*` / `base-4.20.*` * `ghc-9.8.*` / `base-4.19.*`
base-compat.cabal view
@@ -1,5 +1,5 @@ name: base-compat-version: 0.14.1+version: 0.15.0 license: MIT license-file: LICENSE copyright: (c) 2012-2018 Simon Hengel,@@ -53,10 +53,11 @@ , GHC == 9.0.2 , GHC == 9.2.8 , GHC == 9.4.8- , GHC == 9.6.6- , GHC == 9.8.2- , GHC == 9.10.1- , GHC == 9.12.1+ , GHC == 9.6.7+ , GHC == 9.8.4+ , GHC == 9.10.3+ , GHC == 9.12.2+ , GHC == 9.14.1 source-repository head type: git@@ -71,8 +72,6 @@ build-depends: base >= 4.9 && < 5, ghc-prim- if !os(windows) && !os(halvm)- build-depends: unix ghc-options: -Wno-duplicate-exports -Wno-trustworthy-safe
src/Data/List/NonEmpty/Compat.hs view
@@ -82,14 +82,20 @@ ) where import Data.List.NonEmpty+#if !(MIN_VERSION_base(4,22,0))+ hiding (unzip)+#endif #if !(MIN_VERSION_base(4,20,0))-import qualified Prelude.Compat as Prelude import Prelude.Compat ((.)) import qualified Data.List.Compat as List #endif +#if !(MIN_VERSION_base(4,22,0))+import qualified Prelude.Compat as Prelude+#endif+ #if !(MIN_VERSION_base(4,21,0)) import Prelude.Compat (Int, Num(..), Ord(..), Ordering(..), otherwise) @@ -275,4 +281,10 @@ (\m -> if m > 0 then LT else EQ) xs n+#endif++#if !(MIN_VERSION_base(4,22,0))+-- | The 'unzip' function is the inverse of the 'zip' function.+unzip :: NonEmpty (a, b) -> (NonEmpty a, NonEmpty b)+unzip xs = (Prelude.fst Prelude.<$> xs, Prelude.snd Prelude.<$> xs) #endif