base-compat-batteries 0.10.5 → 0.11.0
raw patch · 7 files changed
+109/−6 lines, 7 filesdep +type-equalitydep ~base-compatPVP ok
version bump matches the API change (PVP)
Dependencies added: type-equality
Dependency ranges changed: base-compat
API changes (from Hackage documentation)
+ Control.Monad.Compat: (<$!>) :: Monad m => (a -> b) -> m a -> m b
+ 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: class Applicative m => Monad (m :: Type -> Type)
+ Control.Monad.Compat: class Monad m => MonadFail (m :: Type -> Type)
+ Control.Monad.Compat: class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
+ Control.Monad.Compat: fail :: MonadFail m => String -> m a
+ 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: mplus :: MonadPlus m => m a -> m a -> m a
+ Control.Monad.Compat: msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
+ Control.Monad.Compat: mzero :: MonadPlus m => 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.Monoid.Compat: Ap :: f a -> Ap
+ Data.Monoid.Compat: [getAp] :: Ap -> f a
+ Data.Semigroup.Compat: infixr 6 <>
+ Data.Type.Equality.Compat: [HRefl] :: forall k1 k2 (a :: k1) (b :: k2). () => a :~~: a
+ Data.Type.Equality.Compat: [Refl] :: forall k (a :: k) (b :: k). () => a :~: a
+ Data.Type.Equality.Compat: apply :: () => (f :~: g) -> (a :~: b) -> f a :~: g b
+ Data.Type.Equality.Compat: castWith :: () => (a :~: b) -> a -> b
+ Data.Type.Equality.Compat: class a ~# b => (~~) (a :: k0) (b :: k1)
+ Data.Type.Equality.Compat: class TestEquality (f :: k -> Type)
+ Data.Type.Equality.Compat: data (:~:) (a :: k) (b :: k) :: forall k. () => k -> k -> Type
+ Data.Type.Equality.Compat: data (:~~:) (a :: k1) (b :: k2) :: forall k1 k2. () => k1 -> k2 -> Type
+ Data.Type.Equality.Compat: gcastWith :: () => (a :~: b) -> ((a ~ b) -> r) -> r
+ Data.Type.Equality.Compat: infix 4 ==
+ Data.Type.Equality.Compat: inner :: () => (f a :~: g b) -> a :~: b
+ Data.Type.Equality.Compat: outer :: () => (f a :~: g b) -> f :~: g
+ Data.Type.Equality.Compat: sym :: () => (a :~: b) -> b :~: a
+ Data.Type.Equality.Compat: testEquality :: TestEquality f => f a -> f b -> Maybe (a :~: b)
+ Data.Type.Equality.Compat: trans :: () => (a :~: b) -> (b :~: c) -> a :~: c
+ Data.Type.Equality.Compat: type family (==) (a :: k) (b :: k) :: Bool
- Data.Functor.Compat: (<&>) :: Functor f => f a -> a -> b -> f b
+ Data.Functor.Compat: (<&>) :: Functor f => f a -> (a -> b) -> f b
- Data.Functor.Compat: class Functor (f :: * -> *)
+ Data.Functor.Compat: class Functor (f :: Type -> Type)
- Data.Functor.Compat: fmap :: Functor f => a -> b -> f a -> f b
+ Data.Functor.Compat: fmap :: Functor f => (a -> b) -> f a -> f b
- 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: 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: group1 :: Eq a => NonEmpty a -> NonEmpty NonEmpty a
+ Data.List.NonEmpty.Compat: group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a)
- Data.List.NonEmpty.Compat: groupAllWith :: Ord b => a -> b -> [a] -> [NonEmpty a]
+ Data.List.NonEmpty.Compat: groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a]
- Data.List.NonEmpty.Compat: groupAllWith1 :: Ord b => a -> b -> NonEmpty a -> NonEmpty NonEmpty a
+ Data.List.NonEmpty.Compat: groupAllWith1 :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
- Data.List.NonEmpty.Compat: groupBy :: Foldable f => a -> a -> Bool -> f a -> [NonEmpty a]
+ Data.List.NonEmpty.Compat: groupBy :: Foldable f => (a -> a -> Bool) -> f 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: groupWith :: (Foldable f, Eq b) => a -> b -> f a -> [NonEmpty a]
+ Data.List.NonEmpty.Compat: groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a]
- Data.List.NonEmpty.Compat: groupWith1 :: Eq b => a -> b -> NonEmpty a -> NonEmpty NonEmpty a
+ Data.List.NonEmpty.Compat: groupWith1 :: Eq b => (a -> b) -> NonEmpty a -> NonEmpty (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: 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: scanl :: Foldable f => b -> a -> b -> b -> f a -> NonEmpty b
+ Data.List.NonEmpty.Compat: scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b
- 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: scanr :: Foldable f => a -> b -> b -> b -> f a -> NonEmpty b
+ Data.List.NonEmpty.Compat: scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b
- 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: some1 :: Alternative f => f a -> f NonEmpty a
+ Data.List.NonEmpty.Compat: some1 :: Alternative f => f a -> f (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: sortWith :: Ord o => a -> o -> NonEmpty a -> NonEmpty a
+ Data.List.NonEmpty.Compat: sortWith :: Ord o => (a -> o) -> 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: takeWhile :: () => a -> Bool -> NonEmpty a -> [a]
+ Data.List.NonEmpty.Compat: takeWhile :: () => (a -> Bool) -> 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: 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: Endo :: a -> a -> Endo a
+ Data.Monoid.Compat: Endo :: (a -> a) -> Endo a
- Data.Monoid.Compat: newtype Alt (f :: k -> *) (a :: k) :: forall k. () => k -> * -> k -> *
+ Data.Monoid.Compat: newtype Alt (f :: k -> Type) (a :: k) :: forall k. () => k -> Type -> k -> Type
- Data.Semigroup.Compat: Endo :: a -> a -> Endo a
+ Data.Semigroup.Compat: Endo :: (a -> a) -> Endo a
- Data.Semigroup.Compat: option :: () => b -> a -> b -> Option a -> b
+ Data.Semigroup.Compat: option :: () => b -> (a -> b) -> Option a -> b
Files
- CHANGES.markdown +38/−0
- base-compat-batteries.cabal +8/−4
- src/Control/Monad/Compat.hs +4/−2
- src/Data/Type/Equality/Compat.hs +45/−0
- src/Data/Type/Equality/Compat/Repl/Batteries.hs +8/−0
- src/Prelude/Compat.hs +5/−0
- test/SafeHaskellSpec.hs +1/−0
CHANGES.markdown view
@@ -1,3 +1,41 @@+## Changes in 0.11.0 [2019.09.06]+ - Reexport `MonadFail(fail)` from `Prelude.Compat` and `Control.Monad.Compat`.++ Because `Prelude.Compat.fail` now corresponds to the `fail` from `MonadFail`+ instead of `Monad`, some care is required to implement `Monad.fail` on+ pre-8.8 versions of GHC. The following template is recommended:++ ```haskell+ import Prelude.Compat+ import qualified Control.Monad as Monad+ import qualified Control.Monad.Fail as Fail++ data Blah a = ...++ instance Functor Blah where ...+ instance Applicative Blah where ...++ instance Monad.Monad Blah where+ (>>=) = ...+ #if !(MIN_VERSION_base(4,13,0))+ fail = Fail.fail+ #endif++ instance Fail.MonadFail Blah where+ fail = ...+ ```++ This approach is also backwards-compatible with previous releases of+ `base-compat-batteries`.++ - Introduce the `Data.Type.Equality.Compat` module, which+ reexports `Data.Type.Equality` from `base` (if using a sufficiently recent+ version of GHC) or the `type-equality` library (if using an old GHC).++ - This coincides with the `base-compat-0.11.0` release. Refer to the+ [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0110-20190906)+ for more details.+ ## Changes in 0.10.5 [2018.10.18] - This coincides with the `base-compat-0.10.5` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0105-20181018)
base-compat-batteries.cabal view
@@ -1,5 +1,5 @@ name: base-compat-batteries-version: 0.10.5+version: 0.11.0 license: MIT license-file: LICENSE copyright: (c) 2012-2018 Simon Hengel,@@ -44,6 +44,7 @@ , GHC == 8.2.* , GHC == 8.4.* , GHC == 8.6.*+ , GHC == 8.8.* extra-source-files: CHANGES.markdown, README.markdown source-repository head@@ -56,7 +57,7 @@ -Wall build-depends: base >= 4.3 && < 5,- base-compat == 0.10.5+ base-compat == 0.11.0 if !impl(ghc >= 7.8) build-depends: tagged >= 0.8.5 && < 0.9@@ -67,12 +68,13 @@ if !impl(ghc >= 8.0) build-depends: fail >= 4.9.0.0 && < 4.10,- semigroups >= 0.18.4 && < 0.19,+ semigroups >= 0.18.4 && < 0.20, transformers >= 0.2 && < 0.6, transformers-compat >= 0.6 && < 0.7 if !impl(ghc >= 8.2) build-depends:- bifunctors >= 5.5.2 && < 5.6+ bifunctors >= 5.5.2 && < 5.6,+ type-equality >= 1 && < 1.1 if !impl(ghc >= 8.6) build-depends: contravariant >= 1.5 && < 1.6@@ -117,6 +119,7 @@ Data.STRef.Compat Data.String.Compat Data.Type.Coercion.Compat+ Data.Type.Equality.Compat Data.Version.Compat Data.Void.Compat Data.Word.Compat@@ -174,6 +177,7 @@ Data.STRef.Compat.Repl.Batteries Data.String.Compat.Repl.Batteries Data.Type.Coercion.Compat.Repl.Batteries+ Data.Type.Equality.Compat.Repl.Batteries Data.Version.Compat.Repl.Batteries Data.Void.Compat.Repl.Batteries Data.Word.Compat.Repl.Batteries
src/Control/Monad/Compat.hs view
@@ -1,6 +1,8 @@ {-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Monad.Compat ( module Base- ) where+, fail+) where -import "base-compat" Control.Monad.Compat as Base+import "base-compat" Control.Monad.Compat as Base hiding (fail)+import Control.Monad.Fail (fail)
+ src/Data/Type/Equality/Compat.hs view
@@ -0,0 +1,45 @@+{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-}+#if __GLASGOW_HASKELL__ >= 702+{-# LANGUAGE Trustworthy #-}+#endif+#if __GLASGOW_HASKELL__ >= 708+{-# LANGUAGE ExplicitNamespaces #-}+#endif+module Data.Type.Equality.Compat (+ -- * The equality types+ (:~:)(..),+#if __GLASGOW_HASKELL__ >= 800+ type (~~),+#endif+#if __GLASGOW_HASKELL__ >= 800+ (:~~:)(..),+#endif++ -- * Working with equality+ sym, trans, castWith, gcastWith,+#if __GLASGOW_HASKELL__ >= 706+ apply,+#endif+ inner,+#if __GLASGOW_HASKELL__ >= 706+ outer,+#endif++ -- * Inferring equality from other types+ TestEquality(..),++#if __GLASGOW_HASKELL__ >= 708+ -- * Boolean type-level equality+ type (==),+#endif+) where++#if MIN_VERSION_base(4,7,0)+import "base" Data.Type.Equality+#else+import "type-equality" Data.Type.Equality+#endif++#if MIN_VERSION_base(4,9,0) && !MIN_VERSION_base(4,10,0)+import "type-equality" Data.Type.Equality.Hetero+#endif
+ src/Data/Type/Equality/Compat/Repl/Batteries.hs view
@@ -0,0 +1,8 @@+{-# LANGUAGE PackageImports #-}+{-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-}+-- | Reexports "Data.Type.Equality.Compat"+-- from a globally unique namespace.+module Data.Type.Equality.Compat.Repl.Batteries (+ module Data.Type.Equality.Compat+) where+import "this" Data.Type.Equality.Compat
src/Prelude/Compat.hs view
@@ -2,12 +2,17 @@ module Prelude.Compat ( module Base #if !(MIN_VERSION_base(4,9,0))+, Fail.MonadFail(Fail.fail) , Semi.Semigroup((Semi.<>)) #endif ) where import "base-compat" Prelude.Compat as Base+#if !(MIN_VERSION_base(4,9,0))+ hiding (fail)+#endif #if !(MIN_VERSION_base(4,9,0))+import "fail" Control.Monad.Fail as Fail import "semigroups" Data.Semigroup as Semi #endif
test/SafeHaskellSpec.hs view
@@ -39,6 +39,7 @@ import Data.STRef.Compat () import Data.String.Compat () import Data.Type.Coercion.Compat ()+import Data.Type.Equality.Compat () import Data.Version.Compat () import Data.Void.Compat () import Data.Word.Compat ()