Hello community, here is the log from the commit of package ghc-ilist for openSUSE:Factory checked in at 2017-08-31 20:56:30 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-ilist (Old) and /work/SRC/openSUSE:Factory/.ghc-ilist.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-ilist" Thu Aug 31 20:56:30 2017 rev:2 rq:513398 version:0.3.1.0 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-ilist/ghc-ilist.changes 2017-04-12 18:07:14.694070606 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-ilist.new/ghc-ilist.changes 2017-08-31 20:56:31.442906060 +0200 @@ -1,0 +2,5 @@ +Thu Jul 27 14:04:45 UTC 2017 - psimons@suse.com + +- Update to version 0.3.1.0. + +------------------------------------------------------------------- Old: ---- ilist-0.2.0.0.tar.gz New: ---- ilist-0.3.1.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-ilist.spec ++++++ --- /var/tmp/diff_new_pack.Hks5hj/_old 2017-08-31 20:56:32.282788054 +0200 +++ /var/tmp/diff_new_pack.Hks5hj/_new 2017-08-31 20:56:32.310784120 +0200 @@ -19,7 +19,7 @@ %global pkg_name ilist %bcond_with tests Name: ghc-%{pkg_name} -Version: 0.2.0.0 +Version: 0.3.1.0 Release: 0 Summary: Optimised list functions for doing index-related things License: BSD-3-Clause @@ -36,7 +36,9 @@ %description Optimised list functions for doing index-related things. They're faster than -common idioms in all cases, and sometimes they fuse better as well. +common idioms in all cases, they avoid +<https://ghc.haskell.org/trac/ghc/ticket/12620 space leaks>, and sometimes they +fuse better as well. %package devel Summary: Haskell %{pkg_name} library development files ++++++ ilist-0.2.0.0.tar.gz -> ilist-0.3.1.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ilist-0.2.0.0/CHANGELOG.md new/ilist-0.3.1.0/CHANGELOG.md --- old/ilist-0.2.0.0/CHANGELOG.md 2016-05-24 23:12:55.000000000 +0200 +++ new/ilist-0.3.1.0/CHANGELOG.md 2017-06-19 23:55:08.000000000 +0200 @@ -1,3 +1,11 @@ +# 0.3.1.0 + +* Added `ireplicateM` and `ireplicateM_`. + +# 0.3.0.0 + +* `ifind` now returns the index alongside with the value (same as in `lens`). + # 0.2.0.0 * `izipWithM` and `izipWithM_` have been generalised from `Monad` to `Applicative` (which mimics what was done in base-4.9). diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ilist-0.2.0.0/bench/Functions.hs new/ilist-0.3.1.0/bench/Functions.hs --- old/ilist-0.2.0.0/bench/Functions.hs 2016-05-24 23:12:55.000000000 +0200 +++ new/ilist-0.3.1.0/bench/Functions.hs 2017-06-19 23:55:08.000000000 +0200 @@ -1,6 +1,7 @@ {-# LANGUAGE MagicHash, -BangPatterns +BangPatterns, +CPP #-} @@ -16,6 +17,7 @@ import Data.List import Data.List.Index import Control.Monad +import qualified Control.Loop as Loop indexed_zip :: [a] -> [(Int, a)] @@ -94,6 +96,20 @@ go (i +# 1#) xs {-# INLINE imapM__rec #-} +#if __GLASGOW_HASKELL__ < 710 +ireplicateM__loop + :: (Monad m, Functor m) => Int -> (Int -> m a) -> m () +#else +ireplicateM__loop + :: Monad m => Int -> (Int -> m a) -> m () +#endif +ireplicateM__loop n f = Loop.numLoop 0 (n-1) (void . f) +{-# INLINE ireplicateM__loop #-} + +ireplicateM__for :: Monad m => Int -> (Int -> m a) -> m () +ireplicateM__for n f = forM_ [0..n-1] f +{-# INLINE ireplicateM__for #-} + iall_zip :: (Int -> a -> Bool) -> [a] -> Bool iall_zip p xs = and (zipWith p [0..] xs) {-# INLINE iall_zip #-} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ilist-0.2.0.0/bench/Main.hs new/ilist-0.3.1.0/bench/Main.hs --- old/ilist-0.2.0.0/bench/Main.hs 2016-05-24 23:12:55.000000000 +0200 +++ new/ilist-0.3.1.0/bench/Main.hs 2017-06-19 23:55:08.000000000 +0200 @@ -106,6 +106,16 @@ bench "lens" $ nf (\n -> flip runState [] $ L.imapM_ (\i x -> modify ((i+x):) >> return (i-x)) [0..n]) 100000, bench "our" $ nf (\n -> flip runState [] $ imapM_ (\i x -> modify ((i+x):) >> return (i-x)) [0..n]) 100000 ] ], + bgroup "ireplicateM_" [ + bgroup "Just" [ + bench "loop" $ nf (\n -> ireplicateM__loop n (\i -> if i<50000 then Just i else Nothing)) 100000, + bench "for" $ nf (\n -> ireplicateM__for n (\i -> if i<50000 then Just i else Nothing)) 100000, + bench "our" $ nf (\n -> ireplicateM_ n (\i -> if i<50000 then Just i else Nothing)) 100000 ], + bgroup "State" [ + bench "loop" $ nf (\n -> flip runState 0 $ ireplicateM__loop n (\i -> modify' (i+))) 100000, + bench "for" $ nf (\n -> flip runState 0 $ ireplicateM__for n (\i -> modify' (i+))) 100000, + bench "our" $ nf (\n -> flip runState 0 $ ireplicateM_ n (\i -> modify' (i+))) 100000 ] ], + bgroup "ifilter" [ bgroup "consume" [ bench "rec" $ nf (\n -> sum $ ifilter_rec (\i x -> rem (i+x) 5000 == 0) [0..n]) 100000, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ilist-0.2.0.0/ilist.cabal new/ilist-0.3.1.0/ilist.cabal --- old/ilist-0.2.0.0/ilist.cabal 2016-05-24 23:12:55.000000000 +0200 +++ new/ilist-0.3.1.0/ilist.cabal 2017-06-19 23:55:08.000000000 +0200 @@ -1,8 +1,8 @@ name: ilist -version: 0.2.0.0 +version: 0.3.1.0 synopsis: Optimised list functions for doing index-related things description: - Optimised list functions for doing index-related things. They're faster than common idioms in all cases, and sometimes they fuse better as well. + Optimised list functions for doing index-related things. They're faster than common idioms in all cases, they avoid <https://ghc.haskell.org/trac/ghc/ticket/12620 space leaks>, and sometimes they fuse better as well. homepage: http://github.com/aelve/ilist bug-reports: http://github.com/aelve/ilist/issues license: BSD3 @@ -49,6 +49,7 @@ , ilist -- imapM_ is broken in 4.13.2 , lens >= 4.13.2.1 + , loop , transformers , vector ghc-options: -O2 -Wall -fno-warn-unused-do-bind diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ilist-0.2.0.0/lib/Data/List/Index.hs new/ilist-0.3.1.0/lib/Data/List/Index.hs --- old/ilist-0.2.0.0/lib/Data/List/Index.hs 2016-05-24 23:12:55.000000000 +0200 +++ new/ilist-0.3.1.0/lib/Data/List/Index.hs 2017-06-19 23:55:08.000000000 +0200 @@ -58,6 +58,7 @@ -- ** Monadic functions iforM, iforM_, itraverse, itraverse_, + ireplicateM, ireplicateM_, ifoldrM, ifoldlM, @@ -342,6 +343,31 @@ ifor_ = flip itraverse_ {-# INLINE ifor_ #-} +{- | +Perform a given action @n@ times. Behaves like @for_ [0..n-1]@, but avoids <https://ghc.haskell.org/trac/ghc/ticket/12620 space leaks>. + +If you want more complicated loops (e.g. counting downwards), consider the <https://hackage.haskell.org/package/loop loop> package. +-} +ireplicateM :: Applicative m => Int -> (Int -> m a) -> m [a] +ireplicateM cnt f = go 0 + where + go !i | i >= cnt = pure [] + | otherwise = (:) <$> f i <*> go (i + 1) +{-# INLINE ireplicateM #-} + +{- | +NB. This function intentionally uses 'Monad' even though 'Applicative' is enough. That's because the @transformers@ package didn't have an optimized definition of ('*>') for 'StateT' prior to 0.5.3.0, so for a common case of 'StateT' this function would be 40 times slower with the 'Applicative' constraint. +-} +ireplicateM_ :: Monad m => Int -> (Int -> m a) -> m () +ireplicateM_ cnt f = if cnt > 0 then go 0 else return () + where + -- this is 30% faster for Maybe than the simpler + -- go i | i == cnt = return () + -- | otherwise = f i >> go (i + 1) + cnt_ = cnt-1 + go !i = if i == cnt_ then f i >> return () else f i >> go (i + 1) +{-# INLINE ireplicateM_ #-} + -- Using unboxed ints here doesn't seem to result in any benefit ifoldr :: (Int -> a -> b -> b) -> b -> [a] -> b ifoldr f z xs = foldr (\x g i -> f i x (g (i+1))) (const z) xs 0 @@ -493,8 +519,13 @@ iselect p i x ~(ts,fs) | p i x = (x:ts,fs) | otherwise = (ts, x:fs) -ifind :: (Int -> a -> Bool) -> [a] -> Maybe a -ifind p = listToMaybe . ifilter p +ifind :: (Int -> a -> Bool) -> [a] -> Maybe (Int, a) +ifind p ls = go 0# ls + where + go i (x:xs) | p (I# i) x = Just (I# i, x) + | otherwise = go (i +# 1#) xs + go _ _ = Nothing +{-# INLINE ifind #-} ifindIndex :: (Int -> a -> Bool) -> [a] -> Maybe Int ifindIndex p = listToMaybe . ifindIndices p diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ilist-0.2.0.0/tests/Main.hs new/ilist-0.3.1.0/tests/Main.hs --- old/ilist-0.2.0.0/tests/Main.hs 2016-05-24 23:12:55.000000000 +0200 +++ new/ilist-0.3.1.0/tests/Main.hs 2017-06-19 23:55:08.000000000 +0200 @@ -136,7 +136,7 @@ specify "basic" $ do let f i x = modify ((i,x):) >> return (i-x) let (resA, stA) = runState (imapM f [1,3..9]) [] - let (resB, stB) = runState (itraverse f [1,3..9]) [] + (resB, stB) = runState (itraverse f [1,3..9]) [] resA `shouldBe` [0-1,1-3,2-5,3-7,4-9] resB `shouldBe` [0-1,1-3,2-5,3-7,4-9] stA `shouldBe` reverse (zip [0..4] [1,3..9]) @@ -154,10 +154,25 @@ specify "basic" $ do let f i x = modify ((i,x):) >> return (i-x) let stA = execState (imapM_ f [1,3..9]) [] - let stB = execState (itraverse_ f [1,3..9]) [] + stB = execState (itraverse_ f [1,3..9]) [] stA `shouldBe` reverse (zip [0..4] [1,3..9]) stB `shouldBe` reverse (zip [0..4] [1,3..9]) + describe "ireplicateM" $ do + describe "State" $ do + specify "basic" $ do + let f i = modify (i:) >> return ((i+1)*2) + let (res, st) = runState (ireplicateM 5 f) [] + res `shouldBe` [2,4..10] + st `shouldBe` reverse [0..4] + + describe "ireplicateM_" $ do + describe "State" $ do + specify "basic" $ do + let f i = modify (i:) >> return ((i+1)*2) + let st = execState (ireplicateM_ 5 f) [] + st `shouldBe` reverse [0..4] + specialFolds :: Spec specialFolds = describe "special folds" $ do describe "iall" $ do @@ -245,11 +260,13 @@ search = describe "search" $ do describe "ifind" $ do specify "found" $ do - ifind (\i x -> i*2==x) [1,3,4,7] `shouldBe` Just 4 + ifind (\i x -> i*2==x) [1,3,4,7] `shouldBe` Just (2, 4) + specify "found twice" $ do + ifind (\i x -> i*2==x) [1,3,4,6] `shouldBe` Just (2, 4) specify "not found" $ do ifind (\i x -> i*2==x) [1,3,5,7] `shouldBe` Nothing specify "empty" $ do - ifind undefined [] `shouldBe` (Nothing :: Maybe Bool) + ifind undefined [] `shouldBe` (Nothing :: Maybe (Int, Bool)) describe "ifindIndex" $ do specify "found" $ do