Hello community, here is the log from the commit of package ghc-parallel for openSUSE:Factory checked in at 2014-11-26 20:54:53 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-parallel (Old) and /work/SRC/openSUSE:Factory/.ghc-parallel.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-parallel" Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-parallel/ghc-parallel.changes 2014-08-25 11:05:58.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-parallel.new/ghc-parallel.changes 2014-11-26 20:54:59.000000000 +0100 @@ -1,0 +2,12 @@ +Fri Sep 12 06:37:30 UTC 2014 - peter.trommler@ohm-hochschule.de + +- update to 3.2.0.4 +* no changelog +* Haskell Platform 2014.2.0.0 + +------------------------------------------------------------------- +Tue Sep 2 09:38:53 UTC 2014 - peter.trommler@ohm-hochschule.de + +- regenerate spec file + +------------------------------------------------------------------- Old: ---- parallel-3.2.0.3.tar.gz New: ---- parallel-3.2.0.4.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-parallel.spec ++++++ --- /var/tmp/diff_new_pack.C1Lw7z/_old 2014-11-26 20:55:00.000000000 +0100 +++ /var/tmp/diff_new_pack.C1Lw7z/_new 2014-11-26 20:55:00.000000000 +0100 @@ -1,7 +1,7 @@ # # spec file for package ghc-parallel # -# Copyright (c) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany. +# Copyright (c) 2014 SUSE LINUX Products GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -18,42 +18,41 @@ %global pkg_name parallel -%global common_summary Haskell %{pkg_name} library - -%global common_description A %{pkg_name} library for Haskell. - Name: ghc-parallel -Version: 3.2.0.3 +Version: 3.2.0.4 Release: 0 -Summary: %{common_summary} +Summary: Parallel programming library License: BSD-3-Clause Group: System/Libraries -BuildRoot: %{_tmppath}/%{name}-%{version}-build -# BEGIN cabal2spec Url: http://hackage.haskell.org/package/%{pkg_name} Source0: http://hackage.haskell.org/packages/archive/%{pkg_name}/%{version}/%{pkg_name}-%{version}.tar.gz +BuildRoot: %{_tmppath}/%{name}-%{version}-build + BuildRequires: ghc-Cabal-devel +BuildRequires: ghc-rpm-macros +# Begin cabal-rpm deps: BuildRequires: ghc-array-devel BuildRequires: ghc-containers-devel BuildRequires: ghc-deepseq-devel -BuildRequires: ghc-rpm-macros -# END cabal2spec +# End cabal-rpm deps %description -%{common_description} +This package provides a library for parallel programming. + %package devel Summary: Haskell %{pkg_name} library development files -Group: Development/Languages/Other -Requires: ghc-compiler -Requires(post): ghc-compiler -Requires(postun): ghc-compiler +Group: Development/Libraries/Other +Provides: %{name}-static = %{version}-%{release} +Requires: ghc-compiler = %{ghc_version} +Requires(post): ghc-compiler = %{ghc_version} +Requires(postun): ghc-compiler = %{ghc_version} Requires: %{name} = %{version}-%{release} %description devel -%{common_description} -This package contains the development files. +This package provides the Haskell %{pkg_name} library development files. + %prep %setup -q -n %{pkg_name}-%{version} ++++++ parallel-3.2.0.3.tar.gz -> parallel-3.2.0.4.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/parallel-3.2.0.3/Control/Parallel/Strategies.hs new/parallel-3.2.0.4/Control/Parallel/Strategies.hs --- old/parallel-3.2.0.3/Control/Parallel/Strategies.hs 2012-05-16 17:29:33.000000000 +0200 +++ new/parallel-3.2.0.4/Control/Parallel/Strategies.hs 2013-11-05 14:50:46.000000000 +0100 @@ -1,10 +1,10 @@ -{-# LANGUAGE MagicHash, UnboxedTuples #-} +{-# LANGUAGE BangPatterns, CPP, MagicHash, UnboxedTuples #-} ----------------------------------------------------------------------------- -- | -- Module : Control.Parallel.Strategies -- Copyright : (c) The University of Glasgow 2001-2010 -- License : BSD-style (see the file libraries/base/LICENSE) --- +-- -- Maintainer : libraries@haskell.org -- Stability : experimental -- Portability : portable @@ -29,7 +29,7 @@ -- -- * 'Monad' and 'Applicative' instances are provided, for quickly building -- strategies that involve traversing structures in a regular way. --- +-- -- For API history and changes in this release, see "Control.Parallel.Strategies#history". ----------------------------------------------------------------------------- @@ -121,7 +121,7 @@ -- $history -- * Backwards compatibility - + -- | These functions and types are all deprecated, and will be -- removed in a future release. In all cases they have been -- either renamed or replaced with equivalent functionality. @@ -156,7 +156,7 @@ -- Eval monad (isomorphic to Lift monad from MonadLib 3.6.1) -- | 'Eval' is a Monad that makes it easier to define parallel --- strategies. It is a strict identity monad: that is, in +-- strategies. It is a strict identity monad: that is, in -- -- > m >>= f -- @@ -258,7 +258,7 @@ -- | A 'Strategy' is a function that embodies a parallel evaluation strategy. -- The function traverses (parts of) its argument, evaluating subexpressions -- in parallel or in sequence. --- +-- -- A 'Strategy' may do an arbitrary amount of evaluation of its -- argument, but should not return a value different from the one it -- was passed. @@ -269,7 +269,7 @@ -- intention is that the program applies the 'Strategy' to a -- structure, and then uses the returned value, discarding the old -- value. This idiom is expressed by the 'using' function. --- +-- type Strategy a = a -> Eval a -- | Evaluate a value using the given 'Strategy'. @@ -281,11 +281,11 @@ -- | evaluate a value using the given 'Strategy'. This is simply -- 'using' with the arguments reversed. --- +-- withStrategy :: Strategy a -> a -> a withStrategy = flip using --- | Compose two strategies sequentially. +-- | Compose two strategies sequentially. -- This is the analogue to function composition on strategies. -- -- > strat2 `dot` strat1 == strat2 . withStrategy strat1 @@ -411,7 +411,7 @@ -- -------------------------------------------------------------------------- -- Strategy combinators for Traversable data types --- | Evaluate the elements of a traversable data structure +-- | Evaluate the elements of a traversable data structure -- according to the given strategy. evalTraversable :: Traversable t => Strategy a -> Strategy (t a) evalTraversable = traverse @@ -506,7 +506,8 @@ -- The non-compositional 'parListWHNF' might be more efficient than its -- more compositional counterpart; use RULES to do the specialisation. -{-# RULES +{-# NOINLINE [1] parList #-} +{-# RULES "parList/rseq" parList rseq = parListWHNF #-} @@ -518,7 +519,7 @@ -- > parMap strat f = withStrategy (parList strat) . map f -- parMap :: Strategy b -> (a -> b) -> [a] -> [b] -parMap strat f = (`using` parList strat) . map f +parMap strat f = (`using` parList strat) . map f -- -------------------------------------------------------------------------- -- Strategies for lazy lists @@ -542,7 +543,7 @@ -- 'evalBuffer' is not as compositional as the type suggests. In fact, -- it evaluates list elements at least to weak head normal form, -- disregarding a strategy argument 'r0'. --- +-- -- > evalBuffer n r0 == evalBuffer n rseq -- evalBuffer :: Int -> Strategy a -> Strategy [a] @@ -573,7 +574,9 @@ -- Deforest the intermediate list in parBuffer/evalBuffer when it is -- unnecessary: -{-# RULES +{-# NOINLINE [1] evalBuffer #-} +{-# NOINLINE [1] parBuffer #-} +{-# RULES "evalBuffer/rseq" forall n . evalBuffer n rseq = evalBufferWHNF n "parBuffer/rseq" forall n . parBuffer n rseq = parBufferWHNF n #-} @@ -666,34 +669,34 @@ f $|| s = \ x -> let z = x `using` s in z `par` f z -- | Sequential function composition. The result of --- the second function is evaluated using the given strategy, +-- the second function is evaluated using the given strategy, -- and then given to the first function. (.|) :: (b -> c) -> Strategy b -> (a -> b) -> (a -> c) -(.|) f s g = \ x -> let z = g x `using` s in +(.|) f s g = \ x -> let z = g x `using` s in z `pseq` f z -- | Parallel function composition. The result of the second -- function is evaluated using the given strategy, -- in parallel with the application of the first function. (.||) :: (b -> c) -> Strategy b -> (a -> b) -> (a -> c) -(.||) f s g = \ x -> let z = g x `using` s in +(.||) f s g = \ x -> let z = g x `using` s in z `par` f z --- | Sequential inverse function composition, +-- | Sequential inverse function composition, -- for those who read their programs from left to right. --- The result of the first function is evaluated using the +-- The result of the first function is evaluated using the -- given strategy, and then given to the second function. (-|) :: (a -> b) -> Strategy b -> (b -> c) -> (a -> c) -(-|) f s g = \ x -> let z = f x `using` s in +(-|) f s g = \ x -> let z = f x `using` s in z `pseq` g z -- | Parallel inverse function composition, -- for those who read their programs from left to right. --- The result of the first function is evaluated using the --- given strategy, in parallel with the application of the +-- The result of the first function is evaluated using the +-- given strategy, in parallel with the application of the -- second function. (-||) :: (a -> b) -> Strategy b -> (b -> c) -> (a -> c) -(-||) f s g = \ x -> let z = f x `using` s in +(-||) f s g = \ x -> let z = f x `using` s in z `par` g z -- ----------------------------------------------------------------------------- @@ -715,12 +718,12 @@ {-# DEPRECATED (>|) "Use pseq or $| instead" #-} -- | DEPRECATED: Use 'pseq' or '$|' instead -(>|) :: Done -> Done -> Done +(>|) :: Done -> Done -> Done (>|) = Prelude.seq {-# DEPRECATED (>||) "Use par or $|| instead" #-} -- | DEPRECATED: Use 'par' or '$||' instead -(>||) :: Done -> Done -> Done +(>||) :: Done -> Done -> Done (>||) = par {-# DEPRECATED rwhnf "renamed to rseq" #-} @@ -781,7 +784,7 @@ The original Strategies design is described in /Algorithm + Strategy = Parallelism/ <http://www.macs.hw.ac.uk/~dsg/gph/papers/html/Strategies/strategies.html> and the code was written by - Phil Trinder, Hans-Wolfgang Loidl, Kevin Hammond et al. + Phil Trinder, Hans-Wolfgang Loidl, Kevin Hammond et al. Version 2.x @@ -845,7 +848,7 @@ (version 2.3 was not released on Hackage). Version 3 introduced a major overhaul of the API, to match what is -presented in the paper +presented in the paper /Seq no More: Better Strategies for Parallel Haskell/ <http://www.haskell.org/~simonmar/papers/strategies.pdf> @@ -857,14 +860,14 @@ * Changes to the naming scheme: 'rwhnf' renamed to 'rseq', 'seqList' renamed to 'evalList', 'seqPair' renamed to - 'evalTuple2', + 'evalTuple2', The naming scheme is now as follows: * Basic polymorphic strategies (of type @'Strategy' a@) are called @r...@. Examples: 'r0', 'rseq', 'rpar', 'rdeepseq'. - * A strategy combinator for a particular type constructor + * A strategy combinator for a particular type constructor or constructor class @T@ is called @evalT...@, @parT...@ or @seqT...@. * The @seqT...@ combinators (residing in module @@ -888,4 +891,3 @@ 'parBuffer', which are not named after their type constructor (lists) but after their function (rolling buffer of fixed size). -} - diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/parallel-3.2.0.3/Control/Parallel.hs new/parallel-3.2.0.4/Control/Parallel.hs --- old/parallel-3.2.0.3/Control/Parallel.hs 2012-05-16 17:29:33.000000000 +0200 +++ new/parallel-3.2.0.4/Control/Parallel.hs 2013-11-05 14:50:46.000000000 +0100 @@ -1,9 +1,11 @@ +{-# LANGUAGE CPP #-} + ----------------------------------------------------------------------------- -- | -- Module : Control.Parallel -- Copyright : (c) The University of Glasgow 2001 -- License : BSD-style (see the file libraries/base/LICENSE) --- +-- -- Maintainer : libraries@haskell.org -- Stability : stable -- Portability : portable @@ -17,7 +19,7 @@ ) where #ifdef __GLASGOW_HASKELL__ -import qualified GHC.Conc ( par, pseq ) +import qualified GHC.Conc ( par, pseq ) infixr 0 `par`, `pseq` #endif @@ -27,7 +29,7 @@ -- | Indicates that it may be beneficial to evaluate the first -- argument in parallel with the second. Returns the value of the -- second argument. --- +-- -- @a ``par`` b@ is exactly equivalent semantically to @b@. -- -- @par@ is generally used when the value of @a@ is likely to be diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/parallel-3.2.0.3/changelog new/parallel-3.2.0.4/changelog --- old/parallel-3.2.0.3/changelog 1970-01-01 01:00:00.000000000 +0100 +++ new/parallel-3.2.0.4/changelog 2013-11-05 14:50:46.000000000 +0100 @@ -0,0 +1,8 @@ +-*-change-log-*- + +3.2.0.4 Nov 2013 + * Update package description to Cabal 1.10 format + * Add support for GHC 7.8 + * Drop support for GHCs older than GHC 7.0.1 + * Add NOINLINE pragmas to `parBuffer`, `parList`, and `evalBuffer` + to make RULEs more likely to fire diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/parallel-3.2.0.3/parallel.cabal new/parallel-3.2.0.4/parallel.cabal --- old/parallel-3.2.0.3/parallel.cabal 2012-05-16 17:29:33.000000000 +0200 +++ new/parallel-3.2.0.4/parallel.cabal 2013-11-05 14:50:46.000000000 +0100 @@ -1,33 +1,49 @@ -name: parallel -version: 3.2.0.3 -license: BSD3 -license-file: LICENSE -maintainer: libraries@haskell.org -synopsis: Parallel programming library +name: parallel +version: 3.2.0.4 +license: BSD3 +license-file: LICENSE +maintainer: libraries@haskell.org +synopsis: Parallel programming library +category: Control, Parallelism +build-type: Simple +cabal-version: >=1.10 +tested-with: GHC==7.6.3, GHC==7.6.2, GHC==7.6.1, GHC==7.4.2, GHC==7.4.1, GHC==7.2.2, GHC==7.2.1, GHC==7.0.4, GHC==7.0.3, GHC==7.0.2, GHC==7.0.1 description: This package provides a library for parallel programming. -category: Control -build-type: Simple -cabal-version: >=1.6 + +extra-source-files: changelog source-repository head type: git - location: http://darcs.haskell.org/packages/parallel.git/ + location: http://git.haskell.org/packages/parallel.git + +source-repository this + type: git + location: http://git.haskell.org/packages/parallel.git + tag: parallel-3.2.0.4-release -library { - exposed-modules: +library + default-language: Haskell2010 + other-extensions: + BangPatterns + CPP + FlexibleInstances + MagicHash + UnboxedTuples + + exposed-modules: Control.Seq Control.Parallel Control.Parallel.Strategies - extensions: CPP BangPatterns - build-depends: base >= 3 && < 5, - deepseq >= 1.1 && < 1.4, - containers >= 0.1 && < 0.6, - array >= 0.1 && < 0.5 - ghc-options: -Wall - - if impl(ghc >= 6.11) { - -- To improve parallel performance: - ghc-options: -feager-blackholing - } -} + + build-depends: + array >= 0.3 && < 0.6, + base >= 4.3 && < 4.8, + containers >= 0.4 && < 0.6, + deepseq >= 1.1 && < 1.4 + + ghc-options: -Wall + + if impl(ghc >= 6.11) + -- To improve parallel performance: + ghc-options: -feager-blackholing -- To unsubscribe, e-mail: opensuse-commit+unsubscribe@opensuse.org For additional commands, e-mail: opensuse-commit+help@opensuse.org