Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package ghc-vector for openSUSE:Factory checked in at 2023-10-15 19:28:08 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-vector (Old) and /work/SRC/openSUSE:Factory/.ghc-vector.new.20540 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-vector" Sun Oct 15 19:28:08 2023 rev:35 rq:1117835 version:0.13.1.0 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-vector/ghc-vector.changes 2023-08-18 19:29:28.683436297 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-vector.new.20540/ghc-vector.changes 2023-10-15 19:30:16.614812199 +0200 @@ -1,0 +2,20 @@ +Sat Oct 7 13:35:28 UTC 2023 - Peter Simons <[email protected]> + +- Update vector to version 0.13.1.0. + # Changes in version 0.13.1.0 + + * Specialized variants of `findIndexR` are reexported for all vector + types. [#469](https://github.com/haskell/vector/pull/469) + * `UnboxViaPrim` could be used for deriving `Unbox` instances (`V_UnboxViaPrim` + constructor is exported) [#450](https://github.com/haskell/vector/pull/450) + * Fields of `Data.Vector.Fusion.Bundle.Size` are now strict + [#456](https://github.com/haskell/vector/pull/456) + * Compatibility with future GHC 9.10 release + [#462](https://github.com/haskell/vector/pull/462) + * Test suite no longer fails when built with QuickCheck-2.14 + [#461](https://github.com/haskell/vector/pull/461) + * Doctests now work with current versions of GHC + [#465](https://github.com/haskell/vector/pull/466) + * Various documentation improvements + +------------------------------------------------------------------- Old: ---- vector-0.13.0.0.tar.gz vector.cabal New: ---- vector-0.13.1.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-vector.spec ++++++ --- /var/tmp/diff_new_pack.TDtlHq/_old 2023-10-15 19:30:17.138831076 +0200 +++ /var/tmp/diff_new_pack.TDtlHq/_new 2023-10-15 19:30:17.138831076 +0200 @@ -20,13 +20,12 @@ %global pkgver %{pkg_name}-%{version} %bcond_with tests Name: ghc-%{pkg_name} -Version: 0.13.0.0 +Version: 0.13.1.0 Release: 0 Summary: Efficient Arrays License: BSD-3-Clause URL: https://hackage.haskell.org/package/%{pkg_name} Source0: https://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{version}.tar.gz -Source1: https://hackage.haskell.org/package/%{pkg_name}-%{version}/revision/5.cabal#/%{pkg_name}.cabal BuildRequires: ghc-Cabal-devel BuildRequires: ghc-base-devel BuildRequires: ghc-base-prof @@ -114,7 +113,6 @@ %prep %autosetup -n %{pkg_name}-%{version} -cp -p %{SOURCE1} %{pkg_name}.cabal %build %ghc_lib_build ++++++ vector-0.13.0.0.tar.gz -> vector-0.13.1.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/changelog.md new/vector-0.13.1.0/changelog.md --- old/vector-0.13.0.0/changelog.md 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/changelog.md 2001-09-09 03:46:40.000000000 +0200 @@ -1,3 +1,20 @@ +# Changes in version 0.13.1.0 + + * Specialized variants of `findIndexR` are reexported for all vector + types. [#469](https://github.com/haskell/vector/pull/469) + * `UnboxViaPrim` could be used for deriving `Unbox` instances (`V_UnboxViaPrim` + constructor is exported) [#450](https://github.com/haskell/vector/pull/450) + * Fields of `Data.Vector.Fusion.Bundle.Size` are now strict + [#456](https://github.com/haskell/vector/pull/456) + * Compatibility with future GHC 9.10 release + [#462](https://github.com/haskell/vector/pull/462) + * Test suite no longer fails when built with QuickCheck-2.14 + [#461](https://github.com/haskell/vector/pull/461) + * Doctests now work with current versions of GHC + [#465](https://github.com/haskell/vector/pull/466) + * Various documentation improvements + + # Changes in version 0.13.0.0 * `mkType` from `Data.Vector.Generic` is deprecated in favor of diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Fusion/Bundle/Monadic.hs new/vector-0.13.1.0/src/Data/Vector/Fusion/Bundle/Monadic.hs --- old/vector-0.13.0.0/src/Data/Vector/Fusion/Bundle/Monadic.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Fusion/Bundle/Monadic.hs 2001-09-09 03:46:40.000000000 +0200 @@ -100,18 +100,10 @@ import Data.Char ( ord ) import GHC.Base ( unsafeChr ) import Control.Monad ( liftM ) -import Prelude hiding ( length, null, - replicate, (++), - head, last, (!!), - init, tail, take, drop, - map, mapM, mapM_, concatMap, - zipWith, zipWith3, zip, zip3, - filter, takeWhile, dropWhile, - elem, notElem, - foldl, foldl1, foldr, foldr1, - and, or, - scanl, scanl1, - enumFromTo, enumFromThenTo ) +import Prelude + ( Eq, Ord, Num, Enum, Functor, Monad, Bool(..), Ordering, Char, Int, Word, Integer, Float, Double, Maybe(..), Either(..), Integral, RealFrac + , return, fmap, otherwise, id, const, seq, max, maxBound, fromIntegral, truncate + , (+), (-), (<), (<=), (>), (>=), (==), (/=), (&&), (.), ($), (<$), (/) ) import Data.Int ( Int8, Int16, Int32 ) import Data.Word ( Word8, Word16, Word32, Word64 ) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Fusion/Bundle/Size.hs new/vector-0.13.1.0/src/Data/Vector/Fusion/Bundle/Size.hs --- old/vector-0.13.0.0/src/Data/Vector/Fusion/Bundle/Size.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Fusion/Bundle/Size.hs 2001-09-09 03:46:40.000000000 +0200 @@ -20,9 +20,9 @@ import Data.Vector.Fusion.Util ( delay_inline ) -- | Size hint -data Size = Exact Int -- ^ Exact size - | Max Int -- ^ Upper bound on the size - | Unknown -- ^ Unknown size +data Size = Exact {-# UNPACK #-} !Int -- ^ Exact size + | Max {-# UNPACK #-} !Int -- ^ Upper bound on the size + | Unknown -- ^ Unknown size deriving( Eq, Show ) instance Num Size where diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Fusion/Bundle.hs new/vector-0.13.1.0/src/Data/Vector/Fusion/Bundle.hs --- old/vector-0.13.0.0/src/Data/Vector/Fusion/Bundle.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Fusion/Bundle.hs 2001-09-09 03:46:40.000000000 +0200 @@ -89,19 +89,10 @@ import qualified Data.Vector.Fusion.Bundle.Monadic as M import qualified Data.Vector.Fusion.Stream.Monadic as S -import Prelude hiding ( length, null, - replicate, (++), - head, last, (!!), - init, tail, take, drop, - map, concatMap, - zipWith, zipWith3, zip, zip3, - filter, takeWhile, dropWhile, - elem, notElem, - foldl, foldl1, foldr, foldr1, - and, or, - scanl, scanl1, - enumFromTo, enumFromThenTo, - mapM, mapM_ ) +import Prelude + ( Eq, Ord, Num, Enum, Monad, Bool, Ordering, Int, Maybe + , compare, return, seq + , (==), (.) ) import Data.Functor.Classes (Eq1 (..), Ord1 (..)) import GHC.Base ( build ) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Generic/Mutable.hs new/vector-0.13.1.0/src/Data/Vector/Generic/Mutable.hs --- old/vector-0.13.0.0/src/Data/Vector/Generic/Mutable.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Generic/Mutable.hs 2001-09-09 03:46:40.000000000 +0200 @@ -90,8 +90,10 @@ import Control.Monad.Primitive ( PrimMonad(..), RealWorld, stToPrim ) -import Prelude hiding ( length, null, replicate, reverse, map, read, - take, drop, splitAt, init, tail, mapM_, foldr, foldl ) +import Prelude + ( Ord, Monad, Bool(..), Int, Maybe(..), Either(..) + , return, otherwise, flip, const, seq, min, max, not, pure + , (>>=), (+), (-), (<), (<=), (>=), (==), (/=), (.), ($), (=<<), (>>), (<$>) ) #include "vector.h" @@ -505,14 +507,7 @@ -- @since 0.12.3.0 generateM :: (PrimMonad m, MVector v a) => Int -> (Int -> m a) -> m (v (PrimState m) a) {-# INLINE generateM #-} -generateM n f - | n <= 0 = new 0 - | otherwise = do - vec <- new n - let loop i | i >= n = return vec - | otherwise = do unsafeWrite vec i =<< f i - loop (i + 1) - loop 0 +generateM n f = munstream (MBundle.generateM n f) -- | Create a copy of a mutable vector. clone :: (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a) @@ -1248,3 +1243,6 @@ l' = if kval' < cur then i else l loop kval' k' l' cur (i+1) dim = length v + +-- $setup +-- >>> import Prelude ((*)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Generic/New.hs new/vector-0.13.1.0/src/Data/Vector/Generic/New.hs --- old/vector-0.13.0.0/src/Data/Vector/Generic/New.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Generic/New.hs 2001-09-09 03:46:40.000000000 +0200 @@ -18,10 +18,13 @@ -- module Data.Vector.Generic.New ( + -- * Array recycling primitives New(..), create, run, runPrim, apply, modify, modifyWithBundle, unstream, transform, unstreamR, transformR, slice, init, tail, take, drop, unsafeSlice, unsafeInit, unsafeTail + -- * References + -- $references ) where import qualified Data.Vector.Generic.Mutable as MVector @@ -36,12 +39,22 @@ import Control.Monad.Primitive import Control.Monad.ST ( ST ) import Control.Monad ( liftM ) -import Prelude hiding ( init, tail, take, drop, reverse, map, filter ) +import Prelude + ( Monad, Int + , return, seq + , (.), (=<<) ) -- Data.Vector.Internal.Check is unused #define NOT_VECTOR_MODULE #include "vector.h" +-- | This data type is a wrapper around a monadic action which produces +-- a mutable vector. It's used by a number of rewrite rules in order to +-- facilitate the reuse of buffers allocated for vectors. See "Recycle +-- your arrays!" for a detailed explanation. +-- +-- Note that this data type must be declared as @data@ and not @newtype@ +-- since it's used for rewrite rules and rules won't fire with @newtype@. data New v a = New (forall s. ST s (Mutable v s a)) create :: (forall s. ST s (Mutable v s a)) -> New v a @@ -180,3 +193,9 @@ unsafeTail (unstream s) = unstream (Bundle.tail s) #-} +-- $references +-- +-- * Leshchinskiy, Roman. "Recycle your arrays!". Practical Aspects of +-- Declarative Languages: 11th International Symposium, PADL 2009, +-- Savannah, GA, USA, January 19-20, 2009. Proceedings 11. Springer +-- Berlin Heidelberg, 2009. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Generic.hs new/vector-0.13.1.0/src/Data/Vector/Generic.hs --- old/vector-0.13.0.0/src/Data/Vector/Generic.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Generic.hs 2001-09-09 03:46:40.000000000 +0200 @@ -196,20 +196,10 @@ import Control.Monad.ST ( ST, runST ) import Control.Monad.Primitive -import Prelude hiding ( length, null, - replicate, (++), concat, - head, last, - init, tail, take, drop, splitAt, reverse, - map, concat, concatMap, - zipWith, zipWith3, zip, zip3, unzip, unzip3, - filter, takeWhile, dropWhile, span, break, - elem, notElem, - foldl, foldl1, foldr, foldr1, foldMap, - all, any, and, or, sum, product, maximum, minimum, - scanl, scanl1, scanr, scanr1, - enumFromTo, enumFromThenTo, - mapM, mapM_, sequence, sequence_, - showsPrec ) +import Prelude + ( Eq, Ord, Num, Enum, Monoid, Monad, Read, Show, Bool, Ordering(..), Int, Maybe(..), Either, IO, ShowS, ReadS, String + , compare, mempty, mappend, return, fmap, otherwise, id, flip, seq, error, undefined, uncurry, shows, fst, snd, min, max, not + , (>>=), (+), (-), (*), (<), (==), (.), ($), (=<<), (>>), (<$>) ) import qualified Text.Read as Read import qualified Data.List.NonEmpty as NonEmpty @@ -1025,13 +1015,16 @@ -- Safe destructive updates -- ------------------------ --- | Apply a destructive operation to a vector. The operation will be +-- | Apply a destructive operation to a vector. The operation may be -- performed in place if it is safe to do so and will modify a copy of the --- vector otherwise. +-- vector otherwise (see 'Data.Vector.Generic.New.New' for details). -- --- @ --- modify (\\v -> 'M.write' v 0 \'x\') ('replicate' 3 \'a\') = \<\'x\',\'a\',\'a\'\> --- @ +-- ==== __Examples__ +-- +-- >>> import qualified Data.Vector as V +-- >>> import qualified Data.Vector.Mutable as MV +-- >>> V.modify (\v -> MV.write v 0 'x') $ V.replicate 4 'a' +-- "xaaa" modify :: Vector v a => (forall s. Mutable v s a -> ST s ()) -> v a -> v a {-# INLINE modify #-} modify p = new . New.modify p . clone @@ -1627,6 +1620,8 @@ -- | /O(n)/ Yield 'Just' the index of the /last/ element matching the predicate -- or 'Nothing' if no such element exists. -- +-- Does not fuse. +-- -- @since 0.12.2.0 findIndexR :: Vector v a => (a -> Bool) -> v a -> Maybe Int {-# INLINE findIndexR #-} @@ -2664,3 +2659,4 @@ -- $setup -- >>> :set -XFlexibleContexts -- >>> :set -Wno-type-defaults +-- >>> import Prelude (Bool(True, False), even) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Internal/Check.hs new/vector-0.13.1.0/src/Data/Vector/Internal/Check.hs --- old/vector-0.13.0.0/src/Data/Vector/Internal/Check.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Internal/Check.hs 2001-09-09 03:46:40.000000000 +0200 @@ -27,7 +27,10 @@ ) where import GHC.Exts (Int(..), Int#) -import Prelude hiding( error, (&&), (||), not ) +import Prelude + ( Eq, Bool(..), Word, String + , otherwise, fromIntegral, show, unlines + , (-), (<), (<=), (>=), ($), (++) ) import qualified Prelude as P import GHC.Stack (HasCallStack) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Mutable.hs new/vector-0.13.1.0/src/Data/Vector/Mutable.hs --- old/vector-0.13.0.0/src/Data/Vector/Mutable.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Mutable.hs 2001-09-09 03:46:40.000000000 +0200 @@ -76,8 +76,10 @@ import Data.Primitive.Array import Control.Monad.Primitive -import Prelude hiding ( length, null, replicate, reverse, read, - take, drop, splitAt, init, tail, foldr, foldl, mapM_ ) +import Prelude + ( Ord, Monad, Bool, Ordering(..), Int, Maybe + , compare, return, otherwise, error + , (>>=), (+), (-), (*), (<), (>), (>=), (&&), (||), ($), (>>) ) import Data.Typeable ( Typeable ) @@ -742,3 +744,6 @@ toMutableArray :: PrimMonad m => MVector (PrimState m) a -> m (MutableArray (PrimState m) a) {-# INLINE toMutableArray #-} toMutableArray (MVector offset size marr) = cloneMutableArray marr offset size + +-- $setup +-- >>> import Prelude (Integer) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Primitive/Mutable.hs new/vector-0.13.1.0/src/Data/Vector/Primitive/Mutable.hs --- old/vector-0.13.0.0/src/Data/Vector/Primitive/Mutable.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Primitive/Mutable.hs 2001-09-09 03:46:40.000000000 +0200 @@ -82,8 +82,10 @@ #endif ) -import Prelude hiding ( length, null, replicate, reverse, map, read, - take, drop, splitAt, init, tail, foldr, foldl, mapM_ ) +import Prelude + ( Ord, Bool, Int, Maybe + , otherwise, error, undefined, div, show, maxBound + , (+), (*), (<), (>), (>=), (==), (&&), (||), ($), (++) ) import Data.Typeable ( Typeable ) import Data.Coerce diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Primitive.hs new/vector-0.13.1.0/src/Data/Vector/Primitive.hs --- old/vector-0.13.0.0/src/Data/Vector/Primitive.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Primitive.hs 2001-09-09 03:46:40.000000000 +0200 @@ -110,7 +110,7 @@ partition, unstablePartition, partitionWith, span, break, groupBy, group, -- ** Searching - elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices, + elem, notElem, find, findIndex, findIndexR, findIndices, elemIndex, elemIndices, -- * Folding foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1', @@ -175,19 +175,10 @@ import Control.Monad.ST ( ST ) import Control.Monad.Primitive -import Prelude hiding ( length, null, - replicate, (++), concat, - head, last, - init, tail, take, drop, splitAt, reverse, - map, concatMap, - zipWith, zipWith3, zip, zip3, unzip, unzip3, - filter, takeWhile, dropWhile, span, break, - elem, notElem, - foldl, foldl1, foldr, foldr1, foldMap, - all, any, sum, product, minimum, maximum, - scanl, scanl1, scanr, scanr1, - enumFromTo, enumFromThenTo, - mapM, mapM_ ) +import Prelude + ( Eq, Ord, Num, Enum, Monoid, Traversable, Monad, Read, Show, Bool, Ordering(..), Int, Maybe, Either + , compare, mempty, mappend, mconcat, showsPrec, return, otherwise, seq, error, undefined + , (+), (*), (<), (<=), (>), (>=), (==), (/=), ($!) ) import Data.Typeable ( Typeable ) import Data.Data ( Data(..) ) @@ -862,13 +853,16 @@ -- Safe destructive updates -- ------------------------ --- | Apply a destructive operation to a vector. The operation will be +-- | Apply a destructive operation to a vector. The operation may be -- performed in place if it is safe to do so and will modify a copy of the --- vector otherwise. +-- vector otherwise (see 'Data.Vector.Generic.New.New' for details). -- --- @ --- modify (\\v -> write v 0 \'x\') ('replicate' 3 \'a\') = \<\'x\',\'a\',\'a\'\> --- @ +-- ==== __Examples__ +-- +-- >>> import qualified Data.Vector.Primitive as VP +-- >>> import qualified Data.Vector.Primitive.Mutable as MVP +-- >>> VP.modify (\v -> MVP.write v 0 'x') $ VP.replicate 4 'a' +-- "xaaa" modify :: Prim a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a {-# INLINE modify #-} modify p = G.modify p @@ -1239,6 +1233,14 @@ {-# INLINE findIndex #-} findIndex = G.findIndex +-- | /O(n)/ Yield 'Just' the index of the /last/ element matching the predicate +-- or 'Nothing' if no such element exists. +-- +-- Does not fuse. +findIndexR :: Prim a => (a -> Bool) -> Vector a -> Maybe Int +{-# INLINE findIndexR #-} +findIndexR = G.findIndexR + -- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending -- order. findIndices :: Prim a => (a -> Bool) -> Vector a -> Vector Int @@ -1890,3 +1892,6 @@ copy :: (Prim a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m () {-# INLINE copy #-} copy = G.copy + +-- $setup +-- >>> import Prelude (($), min, even, max, succ) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Storable/Mutable.hs new/vector-0.13.1.0/src/Data/Vector/Storable/Mutable.hs --- old/vector-0.13.0.0/src/Data/Vector/Storable/Mutable.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Storable/Mutable.hs 2001-09-09 03:46:40.000000000 +0200 @@ -100,8 +100,10 @@ import GHC.Word (Word8, Word16, Word32, Word64) import GHC.Ptr (Ptr(..)) -import Prelude hiding ( length, null, replicate, reverse, map, read, - take, drop, splitAt, init, tail, foldr, foldl, mapM_ ) +import Prelude + ( Ord, Bool, Maybe, IO + , return, otherwise, error, undefined, max, div, quot, maxBound, show + , (-), (*), (<), (>), (>=), (==), (&&), (||), (.), ($), (++) ) import Data.Typeable ( Typeable ) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Storable.hs new/vector-0.13.1.0/src/Data/Vector/Storable.hs --- old/vector-0.13.0.0/src/Data/Vector/Storable.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Storable.hs 2001-09-09 03:46:40.000000000 +0200 @@ -107,7 +107,7 @@ partition, unstablePartition, partitionWith, span, break, groupBy, group, -- ** Searching - elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices, + elem, notElem, find, findIndex, findIndexR, findIndices, elemIndex, elemIndices, -- * Folding foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1', @@ -183,19 +183,10 @@ import Control.Monad.ST ( ST ) import Control.Monad.Primitive -import Prelude hiding ( length, null, - replicate, (++), concat, - head, last, - init, tail, take, drop, splitAt, reverse, - map, concatMap, - zipWith, zipWith3, zip, zip3, unzip, unzip3, - filter, takeWhile, dropWhile, span, break, - elem, notElem, - foldl, foldl1, foldr, foldr1, foldMap, - all, any, and, or, sum, product, minimum, maximum, - scanl, scanl1, scanr, scanr1, - enumFromTo, enumFromThenTo, - mapM, mapM_ ) +import Prelude + ( Eq, Ord, Num, Enum, Monoid, Traversable, Monad, Read, Show, Bool, Ordering(..), Int, Maybe, Either, IO + , compare, mempty, mappend, mconcat, showsPrec, return, seq, undefined, div + , (*), (<), (<=), (>), (>=), (==), (/=), (&&), (.), ($) ) import Data.Typeable ( Typeable ) import Data.Data ( Data(..) ) @@ -873,13 +864,16 @@ -- Safe destructive updates -- ------------------------ --- | Apply a destructive operation to a vector. The operation will be +-- | Apply a destructive operation to a vector. The operation may be -- performed in place if it is safe to do so and will modify a copy of the --- vector otherwise. +-- vector otherwise (see 'Data.Vector.Generic.New.New' for details). -- --- @ --- modify (\\v -> write v 0 \'x\') ('replicate' 3 \'a\') = \<\'x\',\'a\',\'a\'\> --- @ +-- ==== __Examples__ +-- +-- >>> import qualified Data.Vector.Storable as VS +-- >>> import qualified Data.Vector.Storable.Mutable as MVS +-- >>> VS.modify (\v -> MVS.write v 0 'x') $ VS.replicate 4 'a' +-- "xaaa" modify :: Storable a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a {-# INLINE modify #-} modify p = G.modify p @@ -1038,7 +1032,8 @@ -- | Checks whether two values are the same vector: they have same length -- and share the same buffer. -- --- >>> let xs = fromList [0/0::Double] in isSameVector xs xs +-- >>> import qualified Data.Vector.Storable as VS +-- >>> let xs = VS.fromList [0/0::Double] in VS.isSameVector xs xs -- True isSameVector :: (Storable a) => Vector a -> Vector a -> Bool {-# INLINE isSameVector #-} @@ -1260,6 +1255,14 @@ {-# INLINE findIndex #-} findIndex = G.findIndex +-- | /O(n)/ Yield 'Just' the index of the /last/ element matching the predicate +-- or 'Nothing' if no such element exists. +-- +-- Does not fuse. +findIndexR :: Storable a => (a -> Bool) -> Vector a -> Maybe Int +{-# INLINE findIndexR #-} +findIndexR = G.findIndexR + -- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending -- order. findIndices :: Storable a => (a -> Bool) -> Vector a -> Vector Int @@ -1993,3 +1996,6 @@ unsafeWith :: Storable a => Vector a -> (Ptr a -> IO b) -> IO b {-# INLINE unsafeWith #-} unsafeWith (Vector _ fp) = withForeignPtr fp + +-- $setup +-- >>> import Prelude (Bool(..), Double, ($), (+), (/), succ, even, min, max) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Unboxed/Base.hs new/vector-0.13.1.0/src/Data/Vector/Unboxed/Base.hs --- old/vector-0.13.0.0/src/Data/Vector/Unboxed/Base.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Unboxed/Base.hs 2001-09-09 03:46:40.000000000 +0200 @@ -184,36 +184,36 @@ -- >>> -- Needed to derive Prim -- >>> :set -XGeneralizedNewtypeDeriving -XDataKinds -XUnboxedTuples -XPolyKinds -- >>> --- >>> import qualified Data.Vector.Unboxed as U --- >>> import qualified Data.Vector.Primitive as P --- >>> import qualified Data.Vector.Generic as G --- >>> import qualified Data.Vector.Generic.Mutable as M --- >>> --- >>> newtype Foo = Foo Int deriving P.Prim --- >>> --- >>> newtype instance U.MVector s Foo = MV_Int (P.MVector s Foo) --- >>> newtype instance U.Vector Foo = V_Int (P.Vector Foo) --- >>> deriving via (U.UnboxViaPrim Foo) instance M.MVector MVector Foo --- >>> deriving via (U.UnboxViaPrim Foo) instance G.Vector Vector Foo --- >>> instance Unbox Foo +-- >>> import qualified Data.Vector.Generic as VG +-- >>> import qualified Data.Vector.Generic.Mutable as VGM +-- >>> import qualified Data.Vector.Primitive as VP +-- >>> import qualified Data.Vector.Unboxed as VU +-- >>> +-- >>> newtype Foo = Foo Int deriving VP.Prim +-- >>> +-- >>> newtype instance VU.MVector s Foo = MV_Int (VP.MVector s Foo) +-- >>> newtype instance VU.Vector Foo = V_Int (VP.Vector Foo) +-- >>> deriving via (VU.UnboxViaPrim Foo) instance VGM.MVector VU.MVector Foo +-- >>> deriving via (VU.UnboxViaPrim Foo) instance VG.Vector VU.Vector Foo +-- >>> instance VU.Unbox Foo -- -- Second example is essentially same but with a twist. Instead of -- using @Prim@ instance of data type, we use underlying instance of @Int@: -- -- >>> :set -XTypeFamilies -XStandaloneDeriving -XDerivingVia -XMultiParamTypeClasses -- >>> --- >>> import qualified Data.Vector.Unboxed as U --- >>> import qualified Data.Vector.Primitive as P --- >>> import qualified Data.Vector.Generic as G --- >>> import qualified Data.Vector.Generic.Mutable as M +-- >>> import qualified Data.Vector.Generic as VG +-- >>> import qualified Data.Vector.Generic.Mutable as VGM +-- >>> import qualified Data.Vector.Primitive as VP +-- >>> import qualified Data.Vector.Unboxed as VU -- >>> -- >>> newtype Foo = Foo Int -- >>> --- >>> newtype instance U.MVector s Foo = MV_Int (P.MVector s Int) --- >>> newtype instance U.Vector Foo = V_Int (P.Vector Int) --- >>> deriving via (U.UnboxViaPrim Int) instance M.MVector MVector Foo --- >>> deriving via (U.UnboxViaPrim Int) instance G.Vector Vector Foo --- >>> instance Unbox Foo +-- >>> newtype instance VU.MVector s Foo = MV_Int (VP.MVector s Int) +-- >>> newtype instance VU.Vector Foo = V_Int (VP.Vector Int) +-- >>> deriving via (VU.UnboxViaPrim Int) instance VGM.MVector VU.MVector Foo +-- >>> deriving via (VU.UnboxViaPrim Int) instance VG.Vector VU.Vector Foo +-- >>> instance VU.Unbox Foo -- -- @since 0.13.0.0 newtype UnboxViaPrim a = UnboxViaPrim a @@ -304,6 +304,7 @@ -- >>> :set -XTypeFamilies -XStandaloneDeriving -XDerivingVia -- >>> :set -XMultiParamTypeClasses -XTypeOperators -XFlexibleInstances -- >>> import qualified Data.Vector.Unboxed as VU +-- >>> import qualified Data.Vector.Unboxed.Mutable as MVU -- >>> import qualified Data.Vector.Generic as VG -- >>> import qualified Data.Vector.Generic.Mutable as VGM -- >>> :{ @@ -316,8 +317,8 @@ -- {-# INLINE fromURepr #-} -- newtype instance VU.MVector s (Foo a) = MV_Foo (VU.MVector s (Int, a)) -- newtype instance VU.Vector (Foo a) = V_Foo (VU.Vector (Int, a)) --- deriving via (Foo a `VU.As` (Int, a)) instance VU.Unbox a => VGM.MVector MVector (Foo a) --- deriving via (Foo a `VU.As` (Int, a)) instance VU.Unbox a => VG.Vector Vector (Foo a) +-- deriving via (Foo a `VU.As` (Int, a)) instance VU.Unbox a => VGM.MVector MVU.MVector (Foo a) +-- deriving via (Foo a `VU.As` (Int, a)) instance VU.Unbox a => VG.Vector VU.Vector (Foo a) -- instance VU.Unbox a => VU.Unbox (Foo a) -- :} -- @@ -325,8 +326,8 @@ -- It's also possible to use generic-based instance for 'IsoUnbox' -- which should work for all product types. -- --- >>> :set -XTypeFamilies -XStandaloneDeriving -XDerivingVia -XDeriveGeneric --- >>> :set -XMultiParamTypeClasses -XTypeOperators -XFlexibleInstances +-- >>> :set -XMultiParamTypeClasses -XTypeOperators -XFlexibleInstances -XDeriveGeneric +-- >>> :set -XDerivingVia -- >>> import qualified Data.Vector.Unboxed as VU -- >>> import qualified Data.Vector.Generic as VG -- >>> import qualified Data.Vector.Generic.Mutable as VGM diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Unboxed/Mutable.hs new/vector-0.13.1.0/src/Data/Vector/Unboxed/Mutable.hs --- old/vector-0.13.0.0/src/Data/Vector/Unboxed/Mutable.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Unboxed/Mutable.hs 2001-09-09 03:46:40.000000000 +0200 @@ -70,9 +70,7 @@ import Data.Vector.Fusion.Util ( delayed_min ) import Control.Monad.Primitive -import Prelude hiding ( length, null, replicate, reverse, map, read, - take, drop, splitAt, init, tail, - zip, zip3, unzip, unzip3, foldr, foldl, mapM_ ) +import Prelude ( Ord, Bool, Int, Maybe ) -- don't import an unused Data.Vector.Internal.Check #define NOT_VECTOR_MODULE @@ -601,3 +599,6 @@ #define DEFINE_MUTABLE #include "unbox-tuple-instances" + +-- $setup +-- >>> import Prelude (Char, (*), ($)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector/Unboxed.hs new/vector-0.13.1.0/src/Data/Vector/Unboxed.hs --- old/vector-0.13.0.0/src/Data/Vector/Unboxed.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector/Unboxed.hs 2001-09-09 03:46:40.000000000 +0200 @@ -46,21 +46,21 @@ -- -- >>> :set -XTypeFamilies -XStandaloneDeriving -XMultiParamTypeClasses -XGeneralizedNewtypeDeriving -- >>> --- >>> import qualified Data.Vector.Unboxed as U --- >>> import qualified Data.Vector.Generic as G --- >>> import qualified Data.Vector.Generic.Mutable as M +-- >>> import qualified Data.Vector.Generic as VG +-- >>> import qualified Data.Vector.Generic.Mutable as VGM +-- >>> import qualified Data.Vector.Unboxed as VU -- >>> -- >>> newtype Foo = Foo Int -- >>> --- >>> newtype instance U.MVector s Foo = MV_Int (U.MVector s Int) --- >>> newtype instance U.Vector Foo = V_Int (U.Vector Int) --- >>> deriving instance M.MVector MVector Foo --- >>> deriving instance G.Vector Vector Foo --- >>> instance Unbox Foo +-- >>> newtype instance VU.MVector s Foo = MV_Int (VU.MVector s Int) +-- >>> newtype instance VU.Vector Foo = V_Int (VU.Vector Int) +-- >>> deriving instance VGM.MVector VU.MVector Foo +-- >>> deriving instance VG.Vector VU.Vector Foo +-- >>> instance VU.Unbox Foo module Data.Vector.Unboxed ( -- * Unboxed vectors - Vector(V_UnboxAs), MVector(..), Unbox, + Vector(V_UnboxAs, V_UnboxViaPrim), MVector(..), Unbox, -- * Accessors @@ -152,7 +152,7 @@ partition, unstablePartition, partitionWith, span, break, groupBy, group, -- ** Searching - elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices, + elem, notElem, find, findIndex, findIndexR, findIndices, elemIndex, elemIndices, -- * Folding foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1', @@ -209,19 +209,10 @@ import Control.Monad.ST ( ST ) import Control.Monad.Primitive -import Prelude hiding ( length, null, - replicate, (++), concat, - head, last, - init, tail, take, drop, splitAt, reverse, - map, concatMap, - zipWith, zipWith3, zip, zip3, unzip, unzip3, - filter, takeWhile, dropWhile, span, break, - elem, notElem, - foldl, foldl1, foldr, foldr1, foldMap, - all, any, and, or, sum, product, minimum, maximum, - scanl, scanl1, scanr, scanr1, - enumFromTo, enumFromThenTo, - mapM, mapM_ ) +import Prelude + ( Eq, Ord, Num, Enum, Monoid, Traversable, Monad, Read, Show, Bool, Ordering(..), Int, Maybe, Either + , compare, mempty, mappend, mconcat, showsPrec + , (<), (<=), (>), (>=), (==), (/=) ) import Text.Read ( Read(..), readListPrecDefault ) import Data.Semigroup ( Semigroup(..) ) @@ -880,13 +871,16 @@ -- Safe destructive updates -- ------------------------ --- | Apply a destructive operation to a vector. The operation will be +-- | Apply a destructive operation to a vector. The operation may be -- performed in place if it is safe to do so and will modify a copy of the --- vector otherwise. +-- vector otherwise (see 'Data.Vector.Generic.New.New' for details). -- --- @ --- modify (\\v -> write v 0 \'x\') ('replicate' 3 \'a\') = \<\'x\',\'a\',\'a\'\> --- @ +-- ==== __Examples__ +-- +-- >>> import qualified Data.Vector.Unboxed as VU +-- >>> import qualified Data.Vector.Unboxed.Mutable as MVU +-- >>> VU.modify (\v -> MVU.write v 0 'x') $ VU.replicate 4 'a' +-- "xaaa" modify :: Unbox a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a {-# INLINE modify #-} modify p = G.modify p @@ -1250,6 +1244,14 @@ {-# INLINE findIndex #-} findIndex = G.findIndex +-- | /O(n)/ Yield 'Just' the index of the /last/ element matching the predicate +-- or 'Nothing' if no such element exists. +-- +-- Does not fuse. +findIndexR :: Unbox a => (a -> Bool) -> Vector a -> Maybe Int +{-# INLINE findIndexR #-} +findIndexR = G.findIndexR + -- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending -- order. findIndices :: Unbox a => (a -> Bool) -> Vector a -> Vector Int @@ -1970,3 +1972,6 @@ #define DEFINE_IMMUTABLE #include "unbox-tuple-instances" + +-- $setup +-- >>> import Prelude (Bool(True, False), ($), (+), min, max, even, fst, pred, succ, undefined) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/src/Data/Vector.hs new/vector-0.13.1.0/src/Data/Vector.hs --- old/vector-0.13.0.0/src/Data/Vector.hs 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/src/Data/Vector.hs 2001-09-09 03:46:40.000000000 +0200 @@ -125,7 +125,7 @@ partition, unstablePartition, partitionWith, span, break, groupBy, group, -- ** Searching - elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices, + elem, notElem, find, findIndex, findIndexR, findIndices, elemIndex, elemIndices, -- * Folding foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1', @@ -187,6 +187,9 @@ ) import Control.Monad ( MonadPlus(..), liftM, ap ) +#if !MIN_VERSION_base(4,13,0) +import Control.Monad (fail) +#endif import Control.Monad.ST ( ST, runST ) import Control.Monad.Primitive import qualified Control.Monad.Fail as Fail @@ -194,19 +197,10 @@ import Control.Monad.Zip import Data.Function ( fix ) -import Prelude hiding ( length, null, - replicate, (++), concat, - head, last, - init, tail, take, drop, splitAt, reverse, - map, concatMap, - zipWith, zipWith3, zip, zip3, unzip, unzip3, - filter, takeWhile, dropWhile, span, break, - elem, notElem, - foldl, foldl1, foldr, foldr1, foldMap, - all, any, and, or, sum, product, minimum, maximum, - scanl, scanl1, scanr, scanr1, - enumFromTo, enumFromThenTo, - mapM, mapM_, sequence, sequence_ ) +import Prelude + ( Eq, Ord, Num, Enum, Monoid, Functor, Monad, Show, Bool, Ordering(..), Int, Maybe, Either + , compare, mempty, mappend, mconcat, return, showsPrec, fmap, otherwise, id, flip, const + , (>>=), (+), (-), (<), (<=), (>), (>=), (==), (/=), (&&), (.), ($) ) import Data.Functor.Classes (Eq1 (..), Ord1 (..), Read1 (..), Show1 (..)) import Data.Typeable ( Typeable ) @@ -1065,13 +1059,16 @@ -- Safe destructive updates -- ------------------------ --- | Apply a destructive operation to a vector. The operation will be +-- | Apply a destructive operation to a vector. The operation may be -- performed in place if it is safe to do so and will modify a copy of the --- vector otherwise. +-- vector otherwise (see 'Data.Vector.Generic.New.New' for details). -- --- @ --- modify (\\v -> write v 0 \'x\') ('replicate' 3 \'a\') = \<\'x\',\'a\',\'a\'\> --- @ +-- ==== __Examples__ +-- +-- >>> import qualified Data.Vector as V +-- >>> import qualified Data.Vector.Mutable as MV +-- >>> V.modify (\v -> MV.write v 0 'x') $ V.replicate 4 'a' +-- "xaaa" modify :: (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a {-# INLINE modify #-} modify p = G.modify p @@ -1480,6 +1477,14 @@ {-# INLINE findIndex #-} findIndex = G.findIndex +-- | /O(n)/ Yield 'Just' the index of the /last/ element matching the predicate +-- or 'Nothing' if no such element exists. +-- +-- Does not fuse. +findIndexR :: (a -> Bool) -> Vector a -> Maybe Int +{-# INLINE findIndexR #-} +findIndexR = G.findIndexR + -- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending -- order. findIndices :: (a -> Bool) -> Vector a -> Vector Int @@ -2247,3 +2252,4 @@ -- $setup -- >>> :set -Wno-type-defaults +-- >>> import Prelude (Char, String, Bool(True, False), min, max, fst, even, undefined) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/tests/Tests/Bundle.hs new/vector-0.13.1.0/tests/Tests/Bundle.hs --- old/vector-0.13.0.0/tests/Tests/Bundle.hs 2022-06-19 14:51:08.000000000 +0200 +++ new/vector-0.13.1.0/tests/Tests/Bundle.hs 2001-09-09 03:46:40.000000000 +0200 @@ -1,4 +1,5 @@ {-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE TypeOperators #-} module Tests.Bundle ( tests ) where import Boilerplater diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/tests/Tests/Vector/Property.hs new/vector-0.13.1.0/tests/Tests/Vector/Property.hs --- old/vector-0.13.0.0/tests/Tests/Vector/Property.hs 2022-06-19 14:51:08.000000000 +0200 +++ new/vector-0.13.1.0/tests/Tests/Vector/Property.hs 2001-09-09 03:46:40.000000000 +0200 @@ -1,4 +1,5 @@ {-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE TypeOperators #-} module Tests.Vector.Property ( CommonContext , VanillaContext @@ -31,6 +32,7 @@ import Control.Monad.ST import qualified Data.Traversable as T (Traversable(..)) import Data.Orphans () +import Data.Maybe import Data.Foldable (foldrM) import qualified Data.Vector.Generic as V import qualified Data.Vector.Generic.Mutable as MV diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/tests/Utilities.hs new/vector-0.13.1.0/tests/Utilities.hs --- old/vector-0.13.0.0/tests/Utilities.hs 2022-06-19 14:51:08.000000000 +0200 +++ new/vector-0.13.1.0/tests/Utilities.hs 2001-09-09 03:46:40.000000000 +0200 @@ -1,10 +1,13 @@ +{-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} +{-# LANGUAGE TypeOperators #-} module Utilities where import Test.QuickCheck import Data.Foldable +import Data.Bifunctor import qualified Data.Vector as DV import qualified Data.Vector.Generic as DVG import qualified Data.Vector.Primitive as DVP @@ -14,7 +17,6 @@ import Control.Monad (foldM, foldM_, zipWithM, zipWithM_) import Control.Monad.Trans.Writer -import Data.Function (on) import Data.Functor.Identity import Data.List ( sortBy ) import Data.Maybe (catMaybes) @@ -67,67 +69,61 @@ unmodel :: Model a -> a type EqTest a + type instance EqTest a = Property equal :: a -> a -> EqTest a + default equal :: (Eq a, EqTest a ~ Property) => a -> a -> EqTest a + equal x y = property (x == y) + instance (Eq a, TestData a) => TestData (S.Bundle v a) where type Model (S.Bundle v a) = [Model a] model = map model . S.toList unmodel = S.fromList . map unmodel - type EqTest (S.Bundle v a) = Property - equal x y = property (x == y) - instance (Eq a, TestData a) => TestData (DV.Vector a) where type Model (DV.Vector a) = [Model a] model = map model . DV.toList unmodel = DV.fromList . map unmodel - type EqTest (DV.Vector a) = Property - equal x y = property (x == y) - instance (Eq a, DVP.Prim a, TestData a) => TestData (DVP.Vector a) where type Model (DVP.Vector a) = [Model a] model = map model . DVP.toList unmodel = DVP.fromList . map unmodel - type EqTest (DVP.Vector a) = Property - equal x y = property (x == y) - instance (Eq a, DVS.Storable a, TestData a) => TestData (DVS.Vector a) where type Model (DVS.Vector a) = [Model a] model = map model . DVS.toList unmodel = DVS.fromList . map unmodel - type EqTest (DVS.Vector a) = Property - equal x y = property (x == y) - instance (Eq a, DVU.Unbox a, TestData a) => TestData (DVU.Vector a) where type Model (DVU.Vector a) = [Model a] model = map model . DVU.toList unmodel = DVU.fromList . map unmodel - type EqTest (DVU.Vector a) = Property - equal x y = property (x == y) - #define id_TestData(ty) \ instance TestData ty where { \ type Model ty = ty; \ model = id; \ - unmodel = id; \ - \ - type EqTest ty = Property; \ - equal x y = property (x == y) } + unmodel = id } \ id_TestData(()) id_TestData(Bool) id_TestData(Int) -id_TestData(Float) -id_TestData(Double) id_TestData(Ordering) -bimapEither :: (a -> b) -> (c -> d) -> Either a c -> Either b d -bimapEither f _ (Left a) = Left (f a) -bimapEither _ g (Right c) = Right (g c) +instance TestData Float where + type Model Float = Float + model = id + unmodel = id + + equal x y = property (x == y || (isNaN x && isNaN y)) + +instance TestData Double where + type Model Double = Double + model = id + unmodel = id + + equal x y = property (x == y || (isNaN x && isNaN y)) -- Functorish models -- All of these need UndecidableInstances although they are actually well founded. Oh well. @@ -136,57 +132,36 @@ model = fmap model unmodel = fmap unmodel - type EqTest (Maybe a) = Property - equal x y = property (x == y) - instance (Eq a, TestData a, Eq b, TestData b) => TestData (Either a b) where type Model (Either a b) = Either (Model a) (Model b) - model = bimapEither model model - unmodel = bimapEither unmodel unmodel - - type EqTest (Either a b) = Property - equal x y = property (x == y) + model = bimap model model + unmodel = bimap unmodel unmodel instance (Eq a, TestData a) => TestData [a] where type Model [a] = [Model a] model = fmap model unmodel = fmap unmodel - type EqTest [a] = Property - equal x y = property (x == y) - instance (Eq a, TestData a) => TestData (Identity a) where type Model (Identity a) = Identity (Model a) model = fmap model unmodel = fmap unmodel - type EqTest (Identity a) = Property - equal = (property .) . on (==) runIdentity - instance (Eq a, TestData a, Eq b, TestData b, Monoid a) => TestData (Writer a b) where type Model (Writer a b) = Writer (Model a) (Model b) model = mapWriter model unmodel = mapWriter unmodel - type EqTest (Writer a b) = Property - equal = (property .) . on (==) runWriter - instance (Eq a, Eq b, TestData a, TestData b) => TestData (a,b) where type Model (a,b) = (Model a, Model b) model (a,b) = (model a, model b) unmodel (a,b) = (unmodel a, unmodel b) - type EqTest (a,b) = Property - equal x y = property (x == y) - instance (Eq a, Eq b, Eq c, TestData a, TestData b, TestData c) => TestData (a,b,c) where type Model (a,b,c) = (Model a, Model b, Model c) model (a,b,c) = (model a, model b, model c) unmodel (a,b,c) = (unmodel a, unmodel b, unmodel c) - type EqTest (a,b,c) = Property - equal x y = property (x == y) - instance (Arbitrary a, Show a, TestData a, TestData b) => TestData (a -> b) where type Model (a -> b) = Model a -> Model b model f = model . f . unmodel @@ -312,9 +287,6 @@ ifilter :: (Int -> a -> Bool) -> [a] -> [a] ifilter f = map snd . withIndexFirst filter f -mapMaybe :: (a -> Maybe b) -> [a] -> [b] -mapMaybe f = catMaybes . map f - imapMaybe :: (Int -> a -> Maybe b) -> [a] -> [b] imapMaybe f = catMaybes . withIndexFirst map f diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/tests/doctests.hs new/vector-0.13.1.0/tests/doctests.hs --- old/vector-0.13.0.0/tests/doctests.hs 2022-06-19 14:51:08.000000000 +0200 +++ new/vector-0.13.1.0/tests/doctests.hs 2001-09-09 03:46:40.000000000 +0200 @@ -1,4 +1,38 @@ import Test.DocTest (doctest) +-- Doctests are weirdly fragile. For example running tests for module +-- A (D.V.Unboxed.Base) could cause tests in unrelated woudle B +-- (D.V.Storable) to start failing with weird errors. +-- +-- In order to avoid this one would want to run doctests with +-- per-module granularity but this cause another sort of problems! +-- When we load only single module and use import doctests then some +-- data types may come from built library and some from ghci session. +-- +-- This could be remedied by running doctests for groups of modules. +-- This _is_ convoluted setup but doctests now works for GHC9.4 main :: IO () -main = doctest [ "-Iinclude" , "-Iinternal" , "-XHaskell2010" , "src/Data" ] +main = mapM_ run modGroups + where + run mods = do + mapM_ putStrLn mods + doctest $ ["-Iinclude", "-Iinternal", "-XHaskell2010"] ++ mods + -- + modGroups = + [ [ "src/Data/Vector/Storable/Mutable.hs" + , "src/Data/Vector/Storable.hs" + ] + , [ "src/Data/Vector.hs" + , "src/Data/Vector/Mutable.hs" + ] + , [ "src/Data/Vector/Generic.hs" + , "src/Data/Vector/Generic/Mutable.hs" + ] + , [ "src/Data/Vector/Primitive.hs" + , "src/Data/Vector/Primitive/Mutable.hs" + ] + , [ "src/Data/Vector/Unboxed.hs" + , "src/Data/Vector/Unboxed/Mutable.hs" + , "src/Data/Vector/Unboxed/Base.hs" + ] + ] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vector-0.13.0.0/vector.cabal new/vector-0.13.1.0/vector.cabal --- old/vector-0.13.0.0/vector.cabal 2022-06-19 21:21:10.000000000 +0200 +++ new/vector-0.13.1.0/vector.cabal 2001-09-09 03:46:40.000000000 +0200 @@ -1,10 +1,13 @@ Name: vector -Version: 0.13.0.0 +Version: 0.13.1.0 -- don't forget to update the changelog file! License: BSD3 License-File: LICENSE Author: Roman Leshchinskiy <[email protected]> Maintainer: Haskell Libraries Team <[email protected]> + Alexey Kuleshevich <[email protected]>, + Aleksey Khudyakov <[email protected]>, + Andrew Lelechenko <[email protected]> Copyright: (c) Roman Leshchinskiy 2008-2012, Alexey Kuleshevich 2020-2022, Aleksey Khudyakov 2020-2022, @@ -45,8 +48,11 @@ GHC == 8.6.5, GHC == 8.8.4, GHC == 8.10.7, - GHC == 9.0.1, - GHC == 9.2.3 + GHC == 9.0.2, + GHC == 9.2.8, + GHC == 9.4.6, + GHC == 9.6.2 + Cabal-Version: >= 1.10 Build-Type: Simple @@ -139,9 +145,9 @@ Install-Includes: vector.h - Build-Depends: base >= 4.9 && < 4.17 - , primitive >= 0.6.4.0 && < 0.8 - , deepseq >= 1.1 && < 1.5 + Build-Depends: base >= 4.9 && < 4.20 + , primitive >= 0.6.4.0 && < 0.10 + , deepseq >= 1.1 && < 1.6 , vector-stream >= 0.1 && < 0.2 Ghc-Options: -O2 -Wall @@ -272,8 +278,8 @@ buildable: True build-depends: base -any - , doctest >=0.15 && <0.21 - , primitive >= 0.6.4.0 && < 0.8 + , doctest >=0.15 && <0.23 + , primitive >= 0.6.4.0 && < 0.10 , vector -any test-suite vector-inspection @@ -288,7 +294,7 @@ Inspect.DerivingVia.OtherFoo build-depends: base -any - , primitive >= 0.6.4.0 && < 0.8 + , primitive >= 0.6.4.0 && < 0.10 , vector -any , tasty , tasty-inspection-testing >= 0.1
