base-compat-batteries 0.11.2 → 0.12.0
raw patch · 7 files changed
+49/−17 lines, 7 filesdep ~base-compatdep ~transformers-compatPVP ok
version bump matches the API change (PVP)
Dependency ranges changed: base-compat, transformers-compat
API changes (from Hackage documentation)
- 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
- 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
+ Control.Monad.Compat: (<$) :: Functor f => a -> f b -> f a
+ Data.Monoid.Compat: newtype Alt (f :: k -> Type) (a :: k)
+ Data.Monoid.Compat: newtype Ap (f :: k -> Type) (a :: k)
+ Data.Type.Equality.Compat: data (a :: k1) :~~: (b :: k2)
- 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: singleton :: () => a -> NonEmpty a
+ Data.List.NonEmpty.Compat: singleton :: 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.Type.Equality.Compat: [HRefl] :: forall k1 k2 (a :: k1) (b :: k2). () => a :~~: a
+ Data.Type.Equality.Compat: [HRefl] :: forall k1 (a :: k1). a :~~: a
- Data.Type.Equality.Compat: [Refl] :: forall k (a :: k) (b :: k). () => a :~: a
+ Data.Type.Equality.Compat: [Refl] :: forall k (a :: k). a :~: a
- Data.Type.Equality.Compat: apply :: () => (f :~: g) -> (a :~: b) -> f a :~: g b
+ Data.Type.Equality.Compat: apply :: forall k1 k2 (f :: k1 -> k2) (g :: k1 -> k2) (a :: k1) (b :: k1). (f :~: g) -> (a :~: b) -> f a :~: g b
- Data.Type.Equality.Compat: castWith :: () => (a :~: b) -> a -> 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 a ~# b => (a :: k0) ~~ (b :: k1)
- Data.Type.Equality.Compat: gcastWith :: () => (a :~: b) -> ((a ~ b) -> r) -> r
+ Data.Type.Equality.Compat: gcastWith :: forall k (a :: k) (b :: k) r. (a :~: b) -> (a ~ b => r) -> r
- Data.Type.Equality.Compat: inner :: () => (f a :~: g b) -> a :~: b
+ Data.Type.Equality.Compat: inner :: forall k1 k2 (f :: k1 -> k2) (a :: k1) (g :: k1 -> k2) (b :: k1). (f a :~: g b) -> a :~: b
- Data.Type.Equality.Compat: outer :: () => (f a :~: g b) -> f :~: g
+ Data.Type.Equality.Compat: outer :: forall k1 k2 (f :: k1 -> k2) (a :: k1) (g :: k1 -> k2) (b :: k1). (f a :~: g b) -> f :~: g
- Data.Type.Equality.Compat: sym :: () => (a :~: b) -> b :~: a
+ Data.Type.Equality.Compat: sym :: forall k (a :: k) (b :: k). (a :~: b) -> b :~: a
- Data.Type.Equality.Compat: testEquality :: TestEquality f => f a -> f b -> Maybe (a :~: b)
+ Data.Type.Equality.Compat: testEquality :: forall (a :: k) (b :: k). TestEquality f => f a -> f b -> Maybe (a :~: b)
- Data.Type.Equality.Compat: trans :: () => (a :~: b) -> (b :~: c) -> a :~: c
+ Data.Type.Equality.Compat: trans :: forall k (a :: k) (b :: k) (c :: k). (a :~: b) -> (b :~: c) -> a :~: c
- Data.Type.Equality.Compat: type family (==) (a :: k) (b :: k) :: Bool
+ Data.Type.Equality.Compat: type family (a :: k) == (b :: k) :: Bool
- Data.Void.Compat: absurd :: () => Void -> a
+ Data.Void.Compat: absurd :: Void -> a
Files
- CHANGES.markdown +9/−0
- base-compat-batteries.cabal +4/−14
- src/Data/Semigroup/Compat.hs +0/−3
- src/Text/Read/Lex/Compat.hs +6/−0
- src/Text/Read/Lex/Compat/Repl/Batteries.hs +8/−0
- test/Numeric/CompatSpec.hs +21/−0
- test/SafeHaskellSpec.hs +1/−0
CHANGES.markdown view
@@ -1,3 +1,12 @@+## Changes in 0.12.0 [2021.08.29]+ - `Data.Semigroup.Compat{.Repl.Batteries}` no longer re-exports the `Option`+ data type or the `option` function, as both have been removed in+ `base-4.16`.++ - This coincides with the `base-compat-0.12.0` release. Refer to the+ [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0120-20210829)+ for more details.+ ## Changes in 0.11.2 [2020.09.30] - This coincides with the `base-compat-0.11.2` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0112-20200930)
base-compat-batteries.cabal view
@@ -1,5 +1,5 @@ name: base-compat-batteries-version: 0.11.2+version: 0.12.0 license: MIT license-file: LICENSE copyright: (c) 2012-2018 Simon Hengel,@@ -34,18 +34,6 @@ @<https://github.com/haskell-compat/base-compat/blob/master/base-compat/README.markdown#dependencies here>@ for a more comprehensive list of differences between @base-compat@ and @base-compat-batteries@.-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@@ -60,7 +48,7 @@ Haskell2010 build-depends: base >= 4.3 && < 5,- base-compat == 0.11.2+ base-compat == 0.12.0 if !impl(ghc >= 7.8) build-depends: tagged >= 0.8.5 && < 0.9@@ -148,6 +136,7 @@ System.IO.Error.Compat System.IO.Unsafe.Compat Text.Read.Compat+ Text.Read.Lex.Compat Type.Reflection.Compat Control.Concurrent.Compat.Repl.Batteries@@ -208,6 +197,7 @@ System.IO.Error.Compat.Repl.Batteries System.IO.Unsafe.Compat.Repl.Batteries Text.Read.Compat.Repl.Batteries+ Text.Read.Lex.Compat.Repl.Batteries Type.Reflection.Compat.Repl.Batteries test-suite spec type:
src/Data/Semigroup/Compat.hs view
@@ -18,9 +18,6 @@ , Any(..) , Sum(..) , Product(..)- -- * A better monoid for Maybe- , Option(..)- , option -- * Difference lists of a semigroup , diff , cycle1
+ src/Text/Read/Lex/Compat.hs view
@@ -0,0 +1,6 @@+{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-}+module Text.Read.Lex.Compat (+ module Base+) where++import "base-compat" Text.Read.Lex.Compat as Base
+ src/Text/Read/Lex/Compat/Repl/Batteries.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.Batteries (+ module Text.Read.Lex.Compat+) where+import "this" Text.Read.Lex.Compat
test/Numeric/CompatSpec.hs view
@@ -22,3 +22,24 @@ showGFloatAlt Nothing (1234567890 :: Double) "" `shouldBe` "1.23456789e9" it "shows a RealFloat value, using scientific notation and specifying the number of decimal places" $ showGFloatAlt (Just 4) (1234567890 :: Double) "" `shouldBe` "1.2346e9"+ describe "readBin" $ do+ it "parses an entirely binary Integer" $+ readBinInteger "00000111" `shouldBe` [(7, "")]+ it "does not parse a non-binary Integer" $+ readBinInteger "-24" `shouldBe` []+ it "parses the binary prefix of an Integer" $+ readBinInteger "1011784372843778438743" `shouldBe` [(11,"784372843778438743")]+ describe "showBin" $ do+ it "shows small Ints in base 2" $+ map (\ x -> showBinInt x "") [1..32] `shouldBe`+ [ "1","10","11","100","101","110","111","1000","1001","1010","1011","1100","1101","1110","1111"+ , "10000","10001","10010","10011","10100","10101","10110","10111","11000"+ , "11001","11010","11011","11100","11101","11110","11111","100000" ]+ it "shows a large Int in base 2" $+ showBinInt 241324784 "" `shouldBe` "1110011000100101001011110000"+ where+ readBinInteger :: ReadS Integer+ readBinInteger = readBin++ showBinInt :: Int -> ShowS+ showBinInt = showBin
test/SafeHaskellSpec.hs view
@@ -59,6 +59,7 @@ import System.IO.Compat () import System.IO.Error.Compat () import Text.Read.Compat ()+import Text.Read.Lex.Compat () import Type.Reflection.Compat () main :: IO ()