January 2016 - openSUSE Commits - openSUSE Mailing Lists

commit ghc-cgi for openSUSE:Factory
by root＠hilbert.suse.de 28 Jan '16

28 Jan '16

Hello community, here is the log from the commit of package ghc-cgi for openSUSE:Factory checked in at 2016-01-28 17:23:40 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-cgi (Old) and /work/SRC/openSUSE:Factory/.ghc-cgi.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-cgi" Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-cgi/ghc-cgi.changes 2015-08-25 10:08:45.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-cgi.new/ghc-cgi.changes 2016-01-28 17:24:34.000000000 +0100 @@ -1,0 +2,6 @@ +Fri Jan 22 08:00:11 UTC 2016 - mimi.vx(a)gmail.com + +- update to 3001.2.2.3 +* CGI.hs haddock: Use web.archive.org link for CGI specification + +------------------------------------------------------------------- Old: ---- cgi-3001.2.2.2.tar.gz New: ---- cgi-3001.2.2.3.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-cgi.spec ++++++ --- /var/tmp/diff_new_pack.4kBb5C/_old 2016-01-28 17:24:35.000000000 +0100 +++ /var/tmp/diff_new_pack.4kBb5C/_new 2016-01-28 17:24:35.000000000 +0100 @@ -18,7 +18,7 @@ %global pkg_name cgi Name: ghc-cgi -Version: 3001.2.2.2 +Version: 3001.2.2.3 Release: 0 Summary: A library for writing CGI programs Group: System/Libraries ++++++ cgi-3001.2.2.2.tar.gz -> cgi-3001.2.2.3.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cgi-3001.2.2.2/Network/CGI.hs new/cgi-3001.2.2.3/Network/CGI.hs --- old/cgi-3001.2.2.2/Network/CGI.hs 2015-04-07 00:45:15.000000000 +0200 +++ new/cgi-3001.2.2.3/Network/CGI.hs 2016-01-20 08:43:22.000000000 +0100 @@ -13,7 +13,7 @@ -- Portability : non-portable (uses Control.Monad.State) -- -- Simple Library for writing CGI programs. --- See <http://hoohoo.ncsa.uiuc.edu/cgi/interface.html> for the +-- See <https://web.archive.org/web/20100109233524/http://hoohoo.ncsa.illinois.edu/…> for the -- CGI specification. -- -- This version of the library is for systems with version 2.0 or greater diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cgi-3001.2.2.2/cgi.cabal new/cgi-3001.2.2.3/cgi.cabal --- old/cgi-3001.2.2.2/cgi.cabal 2015-04-07 00:45:15.000000000 +0200 +++ new/cgi-3001.2.2.3/cgi.cabal 2016-01-20 08:43:22.000000000 +0100 @@ -1,5 +1,5 @@ Name: cgi -Version: 3001.2.2.2 +Version: 3001.2.2.3 Copyright: Bjorn Bringert, John Chee, Andy Gill, Anders Kaseorg, Ian Lynagh, Erik Meijer, Sven Panne, Jeremy Shaw Category: Network diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cgi-3001.2.2.2/changelog new/cgi-3001.2.2.3/changelog --- old/cgi-3001.2.2.2/changelog 2015-04-07 00:45:15.000000000 +0200 +++ new/cgi-3001.2.2.3/changelog 2016-01-20 08:43:22.000000000 +0100 @@ -1,3 +1,13 @@ +3001.2.2.3 + +### Changed +* CGI.hs haddock: Use web.archive.org link for CGI specification + +3001.2.2.2 + +### Changed +* Added support for building with mtl < 2.2.1 via flags + 3001.2.2.1 ### Changed

1 0

commit ghc-cereal for openSUSE:Factory
by root＠hilbert.suse.de 28 Jan '16

28 Jan '16

Hello community, here is the log from the commit of package ghc-cereal for openSUSE:Factory checked in at 2016-01-28 17:23:39 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-cereal (Old) and /work/SRC/openSUSE:Factory/.ghc-cereal.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-cereal" Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-cereal/ghc-cereal.changes 2015-05-21 08:36:46.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-cereal.new/ghc-cereal.changes 2016-01-28 17:24:33.000000000 +0100 @@ -1,0 +2,11 @@ +Tue Jan 26 08:30:51 UTC 2016 - mimi.vx(a)gmail.com + +- update to 0.5.1.0 +* Switch to using the builder provided by the ByteString package +* Change the encoding of Float and Double with the Serialize class to use the + Data.Serialize.IEEE754 module +* Add support for encoding and decoding ShortByteString +* New and improved test suite thanks to Kei Hibino +* Fix two bugs involving the lookAhead combinator and partial chunks. + +------------------------------------------------------------------- Old: ---- cereal-0.4.1.1.tar.gz New: ---- cereal-0.5.1.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-cereal.spec ++++++ --- /var/tmp/diff_new_pack.OwosoL/_old 2016-01-28 17:24:34.000000000 +0100 +++ /var/tmp/diff_new_pack.OwosoL/_new 2016-01-28 17:24:34.000000000 +0100 @@ -21,7 +21,7 @@ %global debug_package %{nil} Name: ghc-cereal -Version: 0.4.1.1 +Version: 0.5.1.0 Release: 0 Summary: A binary serialization library License: BSD-3-Clause ++++++ cereal-0.4.1.1.tar.gz -> cereal-0.5.1.0.tar.gz ++++++ ++++ 3518 lines of diff (skipped)

1 0

commit cabal-install for openSUSE:Factory
by root＠hilbert.suse.de 28 Jan '16

28 Jan '16

Hello community, here is the log from the commit of package cabal-install for openSUSE:Factory checked in at 2016-01-28 17:23:37 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/cabal-install (Old) and /work/SRC/openSUSE:Factory/.cabal-install.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "cabal-install" Changes: -------- --- /work/SRC/openSUSE:Factory/cabal-install/cabal-install.changes 2016-01-05 21:54:59.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.cabal-install.new/cabal-install.changes 2016-01-28 17:24:32.000000000 +0100 @@ -1,0 +2,5 @@ +Sun Jan 24 10:19:03 UTC 2016 - mimi.vx(a)gmail.com + +- relax HTTP dep + +------------------------------------------------------------------- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ cabal-install.spec ++++++ --- /var/tmp/diff_new_pack.0WThy0/_old 2016-01-28 17:24:33.000000000 +0100 +++ /var/tmp/diff_new_pack.0WThy0/_new 2016-01-28 17:24:33.000000000 +0100 @@ -56,6 +56,7 @@ %prep %setup -q +cabal-tweak-dep-ver HTTP "< 4000.3" "< 4000.4" %build %ghc_bin_build

1 0

commit ghc-cabal-helper for openSUSE:Factory
by root＠hilbert.suse.de 28 Jan '16

28 Jan '16

Hello community, here is the log from the commit of package ghc-cabal-helper for openSUSE:Factory checked in at 2016-01-28 17:23:36 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-cabal-helper (Old) and /work/SRC/openSUSE:Factory/.ghc-cabal-helper.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-cabal-helper" Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-cabal-helper/ghc-cabal-helper.changes 2016-01-22 01:08:43.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.ghc-cabal-helper.new/ghc-cabal-helper.changes 2016-01-28 17:24:31.000000000 +0100 @@ -1,0 +2,5 @@ +Fri Jan 22 07:55:32 UTC 2016 - mimi.vx(a)gmail.com + +- update to 0.6.3.1 + +------------------------------------------------------------------- Old: ---- cabal-helper-0.6.3.0.tar.gz New: ---- cabal-helper-0.6.3.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-cabal-helper.spec ++++++ --- /var/tmp/diff_new_pack.BjaXtF/_old 2016-01-28 17:24:32.000000000 +0100 +++ /var/tmp/diff_new_pack.BjaXtF/_new 2016-01-28 17:24:32.000000000 +0100 @@ -19,7 +19,7 @@ %global pkg_name cabal-helper %bcond_with tests Name: ghc-cabal-helper -Version: 0.6.3.0 +Version: 0.6.3.1 Release: 0 Summary: Simple interface to some of Cabal's configuration state used by ghc-mod License: AGPL-3.0+ ++++++ cabal-helper-0.6.3.0.tar.gz -> cabal-helper-0.6.3.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cabal-helper-0.6.3.0/CabalHelper/Compile.hs new/cabal-helper-0.6.3.1/CabalHelper/Compile.hs --- old/cabal-helper-0.6.3.0/CabalHelper/Compile.hs 2015-11-25 23:10:09.000000000 +0100 +++ new/cabal-helper-0.6.3.1/CabalHelper/Compile.hs 2016-01-14 19:19:13.000000000 +0100 @@ -97,7 +97,8 @@ compileSandbox :: FilePath -> MaybeT IO (Either ExitCode FilePath) compileSandbox chdir = do sandbox <- MaybeT $ getSandboxPkgDb projdir (display buildPlatform) =<< ghcVersion opts - ver <- MaybeT $ find (== cabalVer) <$> listCabalVersions' opts (Just sandbox) + ver <- MaybeT $ logSomeError opts "compileSandbox" $ + find (== cabalVer) <$> listCabalVersions' opts (Just sandbox) vLog opts $ logMsg ++ "sandbox package-db" liftIO $ compileWithPkg chdir (Just sandbox) ver diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cabal-helper-0.6.3.0/CabalHelper/GuessGhc.hs new/cabal-helper-0.6.3.1/CabalHelper/GuessGhc.hs --- old/cabal-helper-0.6.3.0/CabalHelper/GuessGhc.hs 2015-04-27 21:16:53.000000000 +0200 +++ new/cabal-helper-0.6.3.1/CabalHelper/GuessGhc.hs 2016-01-17 21:29:42.000000000 +0100 @@ -49,11 +49,11 @@ path = ghcPath dir = takeDirectory path versionSuffix = takeVersionSuffix (dropExeExtension path) - guessNormal = dir </> toolname <.> exeExtension + guessNormal = dir </> toolname <.> exeExtension' guessGhcVersioned = dir </> (toolname ++ "-ghc" ++ versionSuffix) - <.> exeExtension + <.> exeExtension' guessVersioned = dir </> (toolname ++ versionSuffix) - <.> exeExtension + <.> exeExtension' guesses | null versionSuffix = [guessNormal] | otherwise = [guessGhcVersioned, guessVersioned, @@ -70,7 +70,7 @@ dropExeExtension :: FilePath -> FilePath dropExeExtension filepath = case splitExtension filepath of - (filepath', extension) | extension == exeExtension -> filepath' + (filepath', extension) | extension == exeExtension' -> filepath' | otherwise -> filepath -- | @takeWhileEndLE p@ is equivalent to @reverse . takeWhile p . reverse@, but @@ -81,3 +81,6 @@ go x (rest, done) | not done && p x = (x:rest, False) | otherwise = (rest, True) + +exeExtension' :: FilePath +exeExtension' = Distribution.Simple.BuildPaths.exeExtension diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cabal-helper-0.6.3.0/CabalHelper/Log.hs new/cabal-helper-0.6.3.1/CabalHelper/Log.hs --- old/cabal-helper-0.6.3.0/CabalHelper/Log.hs 2015-08-21 06:28:15.000000000 +0200 +++ new/cabal-helper-0.6.3.1/CabalHelper/Log.hs 2016-01-14 19:19:13.000000000 +0100 @@ -2,6 +2,7 @@ import Control.Monad import Control.Monad.IO.Class +import Control.Exception as E import Data.String import System.IO import Prelude @@ -12,3 +13,9 @@ vLog Options { verbose = True } msg = liftIO $ hPutStrLn stderr msg vLog _ _ = return () + +logSomeError :: Options -> String -> IO (Maybe a) -> IO (Maybe a) +logSomeError opts label a = do + a `E.catch` \se@(SomeException _) -> do + vLog opts $ label ++ ": " ++ show se + return Nothing diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cabal-helper-0.6.3.0/Distribution/Helper.hs new/cabal-helper-0.6.3.1/Distribution/Helper.hs --- old/cabal-helper-0.6.3.0/Distribution/Helper.hs 2016-01-10 22:00:45.000000000 +0100 +++ new/cabal-helper-0.6.3.1/Distribution/Helper.hs 2016-01-17 21:26:39.000000000 +0100 @@ -416,7 +416,7 @@ findLibexecExe "cabal-helper-wrapper" = do libexecdir <- getLibexecDir let exeName = "cabal-helper-wrapper" - exe = libexecdir </> exeName <.> exeExtension + exe = libexecdir </> exeName <.> exeExtension' exists <- doesFileExist exe @@ -476,3 +476,6 @@ lookupEnv' :: String -> IO (Maybe String) lookupEnv' k = lookup k <$> getEnvironment + +exeExtension' :: FilePath +exeExtension' = Distribution.Simple.BuildPaths.exeExtension diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cabal-helper-0.6.3.0/Setup.hs new/cabal-helper-0.6.3.1/Setup.hs --- old/cabal-helper-0.6.3.0/Setup.hs 2015-04-27 21:16:53.000000000 +0200 +++ new/cabal-helper-0.6.3.1/Setup.hs 2016-01-14 19:17:15.000000000 +0100 @@ -6,6 +6,7 @@ import Distribution.Simple.Register import Distribution.Simple.InstallDirs as ID import Distribution.Simple.LocalBuildInfo +import Distribution.Simple.Program import Distribution.PackageDescription import Control.Applicative @@ -17,7 +18,8 @@ main :: IO () main = defaultMainWithHooks $ simpleUserHooks { instHook = inst, - copyHook = copy + copyHook = copy, + hookedPrograms = [ simpleProgram "cabal" ] } -- mostly copypasta from 'defaultInstallHook' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cabal-helper-0.6.3.0/cabal-helper.cabal new/cabal-helper-0.6.3.1/cabal-helper.cabal --- old/cabal-helper-0.6.3.0/cabal-helper.cabal 2016-01-10 22:00:59.000000000 +0100 +++ new/cabal-helper-0.6.3.1/cabal-helper.cabal 2016-01-18 20:53:46.000000000 +0100 @@ -1,5 +1,5 @@ name: cabal-helper -version: 0.6.3.0 +version: 0.6.3.1 synopsis: Simple interface to some of Cabal's configuration state used by ghc-mod description: @cabal-helper@ provides a library which wraps the internal use of @@ -87,8 +87,17 @@ Default-Language: Haskell2010 Type: exitcode-stdio-1.0 Main-Is: Spec.hs + Other-Modules: CabalHelper.Common + CabalHelper.Compile + CabalHelper.Data + CabalHelper.Log + CabalHelper.Sandbox + CabalHelper.Types + Distribution.Helper + Paths_cabal_helper Hs-Source-Dirs: tests, . GHC-Options: -Wall + Build-Tools: cabal Build-Depends: base >= 4.5 && < 5 , cabal-helper , extra diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cabal-helper-0.6.3.0/tests/Spec.hs new/cabal-helper-0.6.3.1/tests/Spec.hs --- old/cabal-helper-0.6.3.0/tests/Spec.hs 2016-01-10 22:00:45.000000000 +0100 +++ new/cabal-helper-0.6.3.1/tests/Spec.hs 2016-01-17 22:21:02.000000000 +0100 @@ -55,6 +55,10 @@ "1.22.2.0" , "1.22.3.0" , "1.22.4.0" + , "1.22.5.0" + , "1.22.6.0" + ]), + ("8.0", [ ]) ]

1 0

commit ghc-bifunctors for openSUSE:Factory
by root＠hilbert.suse.de 28 Jan '16

28 Jan '16

Hello community, here is the log from the commit of package ghc-bifunctors for openSUSE:Factory checked in at 2016-01-28 17:23:35 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-bifunctors (Old) and /work/SRC/openSUSE:Factory/.ghc-bifunctors.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-bifunctors" Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-bifunctors/ghc-bifunctors.changes 2016-01-08 15:23:11.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.ghc-bifunctors.new/ghc-bifunctors.changes 2016-01-28 17:24:31.000000000 +0100 @@ -1,0 +2,9 @@ +Wed Jan 20 08:55:42 UTC 2016 - mimi.vx(a)gmail.com + +- update to 5.2 +* dded several Arrow-like instances for Tannen so we can use it as the Cayley + construction if needed. +* Added Data.Bifunctor.Sum +* Added BifunctorFunctor, BifunctorMonad and BifunctorComonad. + +------------------------------------------------------------------- Old: ---- bifunctors-5.1.tar.gz New: ---- bifunctors-5.2.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-bifunctors.spec ++++++ --- /var/tmp/diff_new_pack.KK2FzZ/_old 2016-01-28 17:24:31.000000000 +0100 +++ /var/tmp/diff_new_pack.KK2FzZ/_new 2016-01-28 17:24:31.000000000 +0100 @@ -19,7 +19,7 @@ %global pkg_name bifunctors Name: ghc-bifunctors -Version: 5.1 +Version: 5.2 Release: 0 Summary: Bifunctors License: BSD-2-Clause @@ -32,6 +32,8 @@ BuildRequires: ghc-Cabal-devel BuildRequires: ghc-rpm-macros # Begin cabal-rpm deps: +BuildRequires: ghc-comonad-devel +BuildRequires: ghc-containers-devel BuildRequires: ghc-semigroups-devel BuildRequires: ghc-tagged-devel BuildRequires: ghc-template-haskell-devel ++++++ bifunctors-5.1.tar.gz -> bifunctors-5.2.tar.gz ++++++ ++++ 1684 lines of diff (skipped)

1 0

commit ghc-base-compat for openSUSE:Factory
by root＠hilbert.suse.de 28 Jan '16

28 Jan '16

Hello community, here is the log from the commit of package ghc-base-compat for openSUSE:Factory checked in at 2016-01-28 17:23:32 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-base-compat (Old) and /work/SRC/openSUSE:Factory/.ghc-base-compat.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-base-compat" Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-base-compat/ghc-base-compat.changes 2015-12-24 12:16:19.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.ghc-base-compat.new/ghc-base-compat.changes 2016-01-28 17:24:29.000000000 +0100 @@ -1,0 +2,22 @@ +Wed Jan 20 08:43:57 UTC 2016 - mimi.vx(a)gmail.com + +- update to 0.9.0 +* Sync with base-4.9/GHC 8.0 +* Weakened RealFloat constraints on realPart, imagPart, conjugate, mkPolar, and cis + in Data.Complex.Compat +* Backport Foreign.ForeignPtr.Safe and Foreign.Marshal.Safe +* Generalize filterM, forever, mapAndUnzipM, zipWithM, zipWithM_, replicateM, + and replicateM_ in Control.Monad from Monad to Applicative +* Backport .Unsafe.Compat modules (for Control.Monad.ST, Control.Monad.ST.Lazy, + Foreign.ForeignPtr, and Foreign.Marshal) +* Backport forkFinally and forkOSWithUnmask to Control.Concurrent.Compat +* Backport Data.Functor.Const +* Backport modifyIORef', atomicModifyIORef' and atomicWriteIORef to Data.IORef.Compat +* Data.Ratio.{denominator,numerator} have no Integral constraint anymore +* Backport modifySTRef' to Data.STRef.Compat +* Export String, lines, words, unlines, and unwords to Data.String.Compat +* Generalize Debug.Trace.{traceM, traceShowM} from Monad to Applicative +* Backport errorWithoutStackTrace to Prelude.Compat +* Backport unsafeFixIO and unsafeDupablePerformIO to System.IO.Unsafe.Compat + +------------------------------------------------------------------- Old: ---- base-compat-0.8.2.tar.gz New: ---- base-compat-0.9.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-base-compat.spec ++++++ --- /var/tmp/diff_new_pack.uAgpB6/_old 2016-01-28 17:24:29.000000000 +0100 +++ /var/tmp/diff_new_pack.uAgpB6/_new 2016-01-28 17:24:29.000000000 +0100 @@ -20,7 +20,7 @@ %bcond_with tests Name: ghc-base-compat -Version: 0.8.2 +Version: 0.9.0 Release: 0 Summary: A compatibility layer for base Group: System/Libraries ++++++ base-compat-0.8.2.tar.gz -> base-compat-0.9.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/CHANGES.markdown new/base-compat-0.9.0/CHANGES.markdown --- old/base-compat-0.8.2/CHANGES.markdown 2015-05-13 08:36:37.000000000 +0200 +++ new/base-compat-0.9.0/CHANGES.markdown 2016-01-15 03:45:49.000000000 +0100 @@ -1,3 +1,26 @@ +## Changes in 0.9.0 + - Sync with `base-4.9`/GHC 8.0 + - Weakened `RealFloat` constraints on `realPart`, `imagPart`, `conjugate`, + `mkPolar`, and `cis` in `Data.Complex.Compat` + - Backport `Foreign.ForeignPtr.Safe` and `Foreign.Marshal.Safe` + - Generalize `filterM`, `forever`, `mapAndUnzipM`, `zipWithM`, `zipWithM_`, + `replicateM`, and `replicateM_` in `Control.Monad` from `Monad` to + `Applicative` + - Backport `.Unsafe.Compat` modules (for `Control.Monad.ST`, + `Control.Monad.ST.Lazy`, `Foreign.ForeignPtr`, and `Foreign.Marshal`) + - Backport `forkFinally` and `forkOSWithUnmask` to `Control.Concurrent.Compat` + - Backport `Data.Functor.Const` + - Backport `modifyIORef'`, `atomicModifyIORef'` and `atomicWriteIORef` to + `Data.IORef.Compat` + - `Data.Ratio.{denominator,numerator}` have no `Integral` constraint anymore + - Backport `modifySTRef'` to `Data.STRef.Compat` + - Export `String`, `lines`, `words`, `unlines`, and `unwords` to + `Data.String.Compat` + - Generalize `Debug.Trace.{traceM, traceShowM}` from `Monad` to `Applicative` + - Backport `errorWithoutStackTrace` to `Prelude.Compat` + - Backport `unsafeFixIO` and `unsafeDupablePerformIO` to + `System.IO.Unsafe.Compat` + ## Changes in 0.8.2 - Backport `bitDefault`, `testBitDefault`, and `popCountDefault` in `Data.Bits.Compat` to all versions of `base` diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/LICENSE new/base-compat-0.9.0/LICENSE --- old/base-compat-0.8.2/LICENSE 2015-05-13 08:36:37.000000000 +0200 +++ new/base-compat-0.9.0/LICENSE 2016-01-15 03:45:49.000000000 +0100 @@ -1,4 +1,4 @@ -Copyright (c) 2012-2015 Simon Hengel <sol(a)typeful.net> and Ryan Scott <ryan.gl.scott(a)ku.edu> +Copyright (c) 2012-2015 Simon Hengel <sol(a)typeful.net> and Ryan Scott <ryan.gl.scott(a)gmail.com> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/README.markdown new/base-compat-0.9.0/README.markdown --- old/base-compat-0.8.2/README.markdown 2015-05-13 08:36:37.000000000 +0200 +++ new/base-compat-0.9.0/README.markdown 2016-01-15 03:45:49.000000000 +0100 @@ -1,4 +1,20 @@ -# A compatibility layer for `base` [![Hackage version](https://img.shields.io/hackage/v/base-compat.svg?style=flat)](http… [![Build Status](https://img.shields.io/travis/haskell-compat/base-compat.svg?style=… +# A compatibility layer for `base` +[![Hackage](https://img.shields.io/hackage/v/base-compat.svg)][Hackage: base-compat] +[![Hackage Dependencies](https://img.shields.io/hackage-deps/v/base-compat.svg)](http:… +[![Haskell Programming Language](https://img.shields.io/badge/language-Haskell-blue.svg)][Haskell.org] +[![BSD3 License](http://img.shields.io/badge/license-MIT-brightgreen.svg)][tl;dr Legal: MIT] +[![Build](https://img.shields.io/travis/haskell-compat/base-compat.svg)](https://travis-ci.org/haskell-compat/base-compat) + +[Hackage: base-compat]: + http://hackage.haskell.org/package/base-compat + "base-compat package on Hackage" +[Haskell.org]: + http://www.haskell.org + "The Haskell Programming Language" +[tl;dr Legal: MIT]: + https://tldrlegal.com/license/mit-license + "MIT License" + ## Scope The scope of `base-compat` is to provide functions available in later versions @@ -12,13 +28,19 @@ package [`base-orphans`](https://github.com/haskell-compat/base-orphans) for that. +In addition, `base-compat` only backports functions. In particular, we +purposefully do not backport data types or type classes introduced in newer +versions of `base`. For more info, see the +[Data types and type classes](#data-types-and-type-classes) +section. + ## Basic usage In your cabal file, you should have something like this: ``` build-depends: base >= 4.3 - , base-compat >= 0.8.0 + , base-compat >= 0.9.0 ``` Then, lets say you want to use the `isRight` function introduced with @@ -83,7 +105,7 @@ ### For compatibility with the latest released version of `base` * `Prelude.Compat` incorporates the AMP/Foldable/Traversable changes and - exposes the same interface as `Prelude` from `base-4.8.0.0` + exposes the same interface as `Prelude` from `base-4.9.0.0` * `System.IO.Error.catch` is not re-exported from `Prelude.Compat` for older versions of `base` * `Text.Read.Compat.readMaybe` @@ -93,13 +115,19 @@ * Added `toIntegralSized` to `Data.Bits.Compat` (if using `base-4.7`) * Added `bool` function to `Data.Bool.Compat` * Added `isLeft` and `isRight` to `Data.Either.Compat` + * Added `forkFinally` to `Control.Concurrent.Compat` * Added `withMVarMasked` function to `Control.Concurrent.MVar.Compat` * Added `(<$!>)` function to `Control.Monad.Compat` + * Weakened `RealFloat` constraints on `realPart`, `imagPart`, `conjugate`, `mkPolar`, + and `cis` in `Data.Complex.Compat` * Added `($>)` and `void` functions to `Data.Functor.Compat` * `(&)` function to `Data.Function.Compat` * `($>)` and `void` functions to `Data.Functor.Compat` + * `modifyIORef'`, `atomicModifyIORef'` and `atomicWriteIORef` to `Data.IORef.Compat` * `dropWhileEnd`, `isSubsequenceOf`, `sortOn`, and `uncons` functions to `Data.List.Compat` * Correct versions of `nub`, `nubBy`, `union`, and `unionBy` to `Data.List.Compat` + * `modifySTRef'` to `Data.STRef.Compat` + * `String`, `lines`, `words`, `unlines`, and `unwords` to `Data.String.Compat` * `makeVersion` function to `Data.Version.Compat` * `traceId`, `traceShowId`, `traceM`, and `traceShowM` functions to `Debug.Trace.Compat` * `byteSwap16`, `byteSwap32`, and `byteSwap64` to `Data.Word.Compat` @@ -109,9 +137,114 @@ * Added `Data.List.Compat.scanl'` * `showFFloatAlt` and `showGFloatAlt` to `Numeric.Compat` * `lookupEnv`, `setEnv` and `unsetEnv` to `System.Environment.Compat` + * `unsafeFixIO` and `unsafeDupablePerformIO` to `System.IO.Unsafe.IO` + +## What is not covered + +### Data types and type classes +`base-compat` purposefully does not export any data types or type classes that +were introduced in more recent versions of `base`. The main reasoning for this +policy is that it is not some data types and type classes have had their APIs +change in different versions of `base`, which makes having a consistent +compatibility API for them practically impossible. + +As an example, consider the `FiniteBits` type class. It was introduced in +[`base-4.7.0.0`](http://hackage.haskell.org/package/base-4.7.0.0/docs/Data-Bits.html#t:FiniteBits) +with the following API: + +```haskell +class Bits b => FiniteBits b where + finiteBitSize :: b -> Int +``` -## Supported versions of GHC/base +However, in [`base-4.8.0.0`](http://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Bits.html#t:FiniteBits), +`FiniteBits` gained additional functions: + +```haskell +class Bits b => FiniteBits b where + finiteBitSize :: b -> Int + countLeadingZeros :: b -> Int + countTrailingZeros :: b -> Int +``` + +This raises the question: how can `FiniteBits` be backported consistently +across all versions of `base`? One approach is to backport the API exposed in +`base-4.8.0.0` on versions prior to `4.7.0.0`. The problem with this is that +`countLeadingZeros` and `countTrailingZeros` are not exposed in `base-4.7.0.0`, +so instances of `FiniteBits` would have to be declared like this: + +```haskell +instance FiniteBits Foo where + finiteBitSize = ... +#if MIN_VERSION_base(4,8,0) || !(MIN_VERSION_base(4,7,0)) + countLeadingZeros = ... + countTrailingZeros = ... +#endif +``` +This is a very unsatisfactory solution, and for this reason, we do not pursue +it. For similar reasons, we do not backport data types. + +### Other compatibility packages + +If you _really_ need your favorite data type or type class in `base` to be +backported, you might be in luck, since several data types have their own +compatibility packages on Hackage. Here is a list of such packages: + +* [`bifunctors`](http://hackage.haskell.org/package/bifunctors) + for the [`Bifunctor`](http://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Bifunctor.html#t:Bifunctor) + type class, introduced in `base-4.8.0.0` +* [`generic-deriving`](http://hackage.haskell.org/package/generic-deriving) + for everything in the [`GHC.Generics`](http://hackage.haskell.org/package/base-4.8.0.0/docs/GHC-Generics.html) + module, introduced to `ghc-prim` in GHC 7.2 (and later moved to `base-4.6.0.0`) +* [`nats`](http://hackage.haskell.org/package/nats) + for the [`Natural`](http://hackage.haskell.org/package/base-4.8.0.0/docs/Numeric-Natural.html) + data type, introduced in `base-4.8.0.0` +* [`semigroups`](http://hackage.haskell.org/package/semigroups) + for the [`Semigroup`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:Semigroup) + typeclass and the + [`NonEmpty`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-List-NonEmpty.html#t:NonEmpty), + [`Min`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:Min), + [`Max`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:Max), + [`First`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:First), + [`Last`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:Last), + [`WrappedMonoid`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:WrappedMonoid), + [`Option`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:Option), + and + [`Arg`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:Arg) + data types, introduced in `base-4.9.0.0` +* [`tagged`](http://hackage.haskell.org/package/tagged) + for the [`Proxy`](http://hackage.haskell.org/package/base-4.7.0.0/docs/Data-Proxy.html#t:Proxy) + data type, introduced in `base-4.7.0.0` +* [`transformers`](http://hackage.haskell.org/package/transformers) + for: + * The [`Identity`](http://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Functor-Identity.html#t:Identity) + data type, introduced in `base-4.8.0.0` + * The [`MonadIO`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Control-Monad-IO-Class.html#t:MonadIO), + [`Eq1`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Functor-Classes.html#t:Eq1), + [`Eq2`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Functor-Classes.html#t:Eq2), + [`Ord1`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Functor-Classes.html#t:Ord1), + [`Ord2`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Functor-Classes.html#t:Ord2), + [`Read1`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Functor-Classes.html#t:Read1), + [`Read2`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Functor-Classes.html#t:Read2), + [`Show1`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Functor-Classes.html#t:Show1), + and + [`Show2`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Functor-Classes.html#t:Show2) + typeclasses; and the + [`Compose`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Functor-Compose.html#t:Compose), + [`Product`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Functor-Product.html#t:Product), + and + [`Sum`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Functor-Sum.html#t:Sum) + data types, introduced in `base-4.9.0.0` +* [`void`](http://hackage.haskell.org/package/void) + for the [`Void`](http://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Void.html#t:Void) + data type, introduced in `base-4.8.0.0` + +## Supported versions of GHC/`base` + + * `ghc-8.0.1` / `base-4.9.0.0` + * `ghc-7.10.3` / `base-4.8.2.0` + * `ghc-7.10.2` / `base-4.8.1.0` * `ghc-7.10.1` / `base-4.8.0.0` * `ghc-7.8.4` / `base-4.7.0.2` * `ghc-7.8.3` / `base-4.7.0.1` @@ -129,16 +262,8 @@ * `ghc-7.0.2` / `base-4.3.1.0` * `ghc-7.0.1` / `base-4.3.0.0` -Patches are welcome; add tests for new code! - -## Development +We also make an attempt to keep `base-compat` building with GHC HEAD, but due +to its volatility, it may not work at any given point in time. If it doesn't, +please report it! -For `Prelude.Compat` there is an `Prelude.index` file that was generated from -the output of - - ghc --show-iface Prelude.hi - -To verify that `Prelude.Compat` matches the specification given in -`Prelude.types` run: - - ./check-Prelude.sh +Patches are welcome; add tests for new code! diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/base-compat.cabal new/base-compat-0.9.0/base-compat.cabal --- old/base-compat-0.8.2/base-compat.cabal 2015-05-13 08:36:37.000000000 +0200 +++ new/base-compat-0.9.0/base-compat.cabal 2016-01-15 03:45:49.000000000 +0100 @@ -1,5 +1,5 @@ name: base-compat -version: 0.8.2 +version: 0.9.0 license: MIT license-file: LICENSE copyright: (c) 2012-2015 Simon Hengel, @@ -7,10 +7,10 @@ (c) 2015 Ryan Scott author: Simon Hengel <sol(a)typeful.net>, João Cristóvão <jmacristovao(a)gmail.com>, - Ryan Scott <ryan.gl.scott(a)ku.edu> + Ryan Scott <ryan.gl.scott(a)gmail.com> maintainer: Simon Hengel <sol(a)typeful.net>, João Cristóvão <jmacristovao(a)gmail.com>, - Ryan Scott <ryan.gl.scott(a)ku.edu> + Ryan Scott <ryan.gl.scott(a)gmail.com> build-type: Simple cabal-version: >= 1.8 category: Compatibility @@ -24,9 +24,20 @@ for recent changes. . Note that @base-compat@ does not add any orphan instances. - There is a separate package - @<http://hackage.haskell.org/package/base-orphans base-orphans>@ + There is a separate package, + @<http://hackage.haskell.org/package/base-orphans base-orphans>@, for that. + . + In addition, `base-compat` does not backport any data types + or type classes. See + @<https://github.com/haskell-compat/base-compat#data-types-and-type-classes this section of the README>@ + for more info. +tested-with: GHC == 7.0.1, GHC == 7.0.2, GHC == 7.0.3, GHC == 7.0.4 + , GHC == 7.2.1, GHC == 7.2.2 + , GHC == 7.4.1, GHC == 7.4.2 + , GHC == 7.6.1, GHC == 7.6.2, GHC == 7.6.3 + , GHC == 7.8.1, GHC == 7.8.2, GHC == 7.8.3, GHC == 7.8.4 + , GHC == 7.10.1, GHC == 7.10.2, GHC == 7.10.3 extra-source-files: CHANGES.markdown, README.markdown source-repository head @@ -47,28 +58,42 @@ src exposed-modules: + Control.Concurrent.Compat Control.Concurrent.MVar.Compat Control.Monad.Compat + Control.Monad.ST.Lazy.Unsafe.Compat + Control.Monad.ST.Unsafe.Compat Data.Bits.Compat Data.Bool.Compat + Data.Complex.Compat Data.Either.Compat Data.Foldable.Compat Data.Function.Compat Data.Functor.Compat + Data.Functor.Const.Compat + Data.IORef.Compat Data.List.Compat Data.Monoid.Compat + Data.Ratio.Compat + Data.STRef.Compat + Data.String.Compat Data.Version.Compat Data.Word.Compat Debug.Trace.Compat Foreign.Compat + Foreign.ForeignPtr.Safe.Compat + Foreign.ForeignPtr.Unsafe.Compat Foreign.Marshal.Alloc.Compat Foreign.Marshal.Array.Compat Foreign.Marshal.Compat + Foreign.Marshal.Safe.Compat + Foreign.Marshal.Unsafe.Compat Foreign.Marshal.Utils.Compat Numeric.Compat Prelude.Compat System.Environment.Compat System.Exit.Compat + System.IO.Unsafe.Compat Text.Read.Compat test-suite spec @@ -80,6 +105,24 @@ test main-is: Spec.hs + other-modules: + Control.Monad.CompatSpec + Data.Bits.CompatSpec + Data.Bool.CompatSpec + Data.Either.CompatSpec + Data.Function.CompatSpec + Data.Functor.CompatSpec + Data.IORef.CompatSpec + Data.List.CompatSpec + Data.Monoid.CompatSpec + Data.STRef.CompatSpec + Data.Version.CompatSpec + Data.Word.CompatSpec + Foreign.Marshal.Alloc.CompatSpec + Foreign.Marshal.Utils.CompatSpec + Numeric.CompatSpec + System.Environment.CompatSpec + Text.Read.CompatSpec build-depends: base >= 4.3 && < 5 , base-compat diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Control/Concurrent/Compat.hs new/base-compat-0.9.0/src/Control/Concurrent/Compat.hs --- old/base-compat-0.8.2/src/Control/Concurrent/Compat.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/src/Control/Concurrent/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,44 @@ +{-# LANGUAGE CPP, NoImplicitPrelude #-} +{-# LANGUAGE RankNTypes #-} +module Control.Concurrent.Compat ( + module Base +, forkFinally +, forkOSWithUnmask +) where + +import Control.Concurrent as Base + +#if !(MIN_VERSION_base(4,6,0)) +import Control.Exception +#endif + +#if !(MIN_VERSION_base(4,9,0)) +import GHC.IO (unsafeUnmask) +import Prelude +#endif + +#if !(MIN_VERSION_base(4,6,0)) +-- | fork a thread and call the supplied function when the thread is about +-- to terminate, with an exception or a returned value. The function is +-- called with asynchronous exceptions masked. +-- +-- > forkFinally action and_then = +-- > mask $ \restore -> +-- > forkIO $ try (restore action) >>= and_then +-- +-- This function is useful for informing the parent when a child +-- terminates, for example. +-- +-- /Since: 4.6.0.0/ +forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId +forkFinally action and_then = + mask $ \restore -> + forkIO $ try (restore action) >>= and_then +#endif + +#if !(MIN_VERSION_base(4,9,0)) +-- | Like 'forkIOWithUnmask', but the child thread is a bound thread, +-- as with 'forkOS'. +forkOSWithUnmask :: ((forall a . IO a -> IO a) -> IO ()) -> IO ThreadId +forkOSWithUnmask io = forkOS (io unsafeUnmask) +#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Control/Monad/Compat.hs new/base-compat-0.9.0/src/Control/Monad/Compat.hs --- old/base-compat-0.8.2/src/Control/Monad/Compat.hs 2015-05-13 08:36:37.000000000 +0200 +++ new/base-compat-0.9.0/src/Control/Monad/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -19,13 +19,30 @@ , (<$!>) #endif +#if !(MIN_VERSION_base(4,9,0)) +, forever +, filterM +, mapAndUnzipM +, zipWithM +, zipWithM_ +, replicateM +, replicateM_ +#endif ) where -#if MIN_VERSION_base(4,8,0) +#if MIN_VERSION_base(4,9,0) import Control.Monad as Base #else import Control.Monad as Base hiding ( - foldM + forever + , filterM + , mapAndUnzipM + , zipWithM + , zipWithM_ + , replicateM + , replicateM_ +# if !(MIN_VERSION_base(4,8,0)) + , foldM , foldM_ , forM , forM_ @@ -37,8 +54,9 @@ , sequence_ , unless , when +# endif ) -import Control.Applicative (Alternative(..)) +import Control.Applicative import Data.Foldable.Compat import Data.Traversable import Prelude.Compat @@ -116,3 +134,51 @@ let z = f x z `seq` return z #endif + +#if !(MIN_VERSION_base(4,9,0)) +-- | @'forever' act@ repeats the action infinitely. +forever :: (Applicative f) => f a -> f b +{-# INLINE forever #-} +forever a = let a' = a *> a' in a' +-- Use explicit sharing here, as it is prevents a space leak regardless of +-- optimizations. + +-- | This generalizes the list-based 'filter' function. +{-# INLINE filterM #-} +filterM :: (Applicative m) => (a -> m Bool) -> [a] -> m [a] +filterM p = foldr (\ x -> liftA2 (\ flg -> if flg then (x:) else id) (p x)) (pure []) + +-- | The 'mapAndUnzipM' function maps its first argument over a list, returning +-- the result as a pair of lists. This function is mainly used with complicated +-- data structures or a state-transforming monad. +mapAndUnzipM :: (Applicative m) => (a -> m (b,c)) -> [a] -> m ([b], [c]) +{-# INLINE mapAndUnzipM #-} +mapAndUnzipM f xs = unzip <$> traverse f xs + +-- | The 'zipWithM' function generalizes 'zipWith' to arbitrary applicative functors. +zipWithM :: (Applicative m) => (a -> b -> m c) -> [a] -> [b] -> m [c] +{-# INLINE zipWithM #-} +zipWithM f xs ys = sequenceA (zipWith f xs ys) + +-- | 'zipWithM_' is the extension of 'zipWithM' which ignores the final result. +zipWithM_ :: (Applicative m) => (a -> b -> m c) -> [a] -> [b] -> m () +{-# INLINE zipWithM_ #-} +zipWithM_ f xs ys = sequenceA_ (zipWith f xs ys) + +-- | @'replicateM' n act@ performs the action @n@ times, +-- gathering the results. +replicateM :: (Applicative m) => Int -> m a -> m [a] +{-# INLINEABLE replicateM #-} +{-# SPECIALISE replicateM :: Int -> IO a -> IO [a] #-} +{-# SPECIALISE replicateM :: Int -> Maybe a -> Maybe [a] #-} +replicateM 0 _ = pure [] +replicateM n x = liftA2 (:) x (replicateM (pred n) x) + +-- | Like 'replicateM', but discards the result. +replicateM_ :: (Applicative m) => Int -> m a -> m () +{-# INLINEABLE replicateM_ #-} +{-# SPECIALISE replicateM_ :: Int -> IO a -> IO () #-} +{-# SPECIALISE replicateM_ :: Int -> Maybe a -> Maybe () #-} +replicateM_ 0 _ = pure () +replicateM_ n x = x *> replicateM_ (pred n) x +#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Control/Monad/ST/Lazy/Unsafe/Compat.hs new/base-compat-0.9.0/src/Control/Monad/ST/Lazy/Unsafe/Compat.hs --- old/base-compat-0.8.2/src/Control/Monad/ST/Lazy/Unsafe/Compat.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/src/Control/Monad/ST/Lazy/Unsafe/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,12 @@ +{-# LANGUAGE CPP, NoImplicitPrelude #-} +module Control.Monad.ST.Lazy.Unsafe.Compat ( + -- * Unsafe operations + unsafeInterleaveST +, unsafeIOToST +) where + +#if MIN_VERSION_base(4,6,0) +import Control.Monad.ST.Lazy.Unsafe (unsafeInterleaveST, unsafeIOToST) +#else +import Control.Monad.ST.Lazy (unsafeInterleaveST, unsafeIOToST) +#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Control/Monad/ST/Unsafe/Compat.hs new/base-compat-0.9.0/src/Control/Monad/ST/Unsafe/Compat.hs --- old/base-compat-0.8.2/src/Control/Monad/ST/Unsafe/Compat.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/src/Control/Monad/ST/Unsafe/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,13 @@ +{-# LANGUAGE CPP, NoImplicitPrelude #-} +module Control.Monad.ST.Unsafe.Compat ( + -- * Unsafe operations + unsafeInterleaveST +, unsafeIOToST +, unsafeSTToIO +) where + +#if MIN_VERSION_base(4,6,0) +import Control.Monad.ST.Unsafe (unsafeInterleaveST, unsafeIOToST, unsafeSTToIO) +#else +import Control.Monad.ST (unsafeInterleaveST, unsafeIOToST, unsafeSTToIO) +#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Data/Complex/Compat.hs new/base-compat-0.9.0/src/Data/Complex/Compat.hs --- old/base-compat-0.8.2/src/Data/Complex/Compat.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/src/Data/Complex/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,50 @@ +{-# LANGUAGE CPP, NoImplicitPrelude #-} +module Data.Complex.Compat ( + module Base +#if MIN_VERSION_base(4,4,0) && !(MIN_VERSION_base(4,8,0)) +, realPart +, imagPart +, mkPolar +, cis +, conjugate +#endif +) where + +#if !(MIN_VERSION_base(4,4,0)) || MIN_VERSION_base(4,8,0) +import Data.Complex as Base +#else +import Data.Complex as Base hiding ( + realPart + , imagPart + , mkPolar + , cis + , conjugate + ) +import Prelude +#endif + +#if MIN_VERSION_base(4,4,0) && !(MIN_VERSION_base(4,8,0)) +-- | Extracts the real part of a complex number. +realPart :: Complex a -> a +realPart (x :+ _) = x + +-- | Extracts the imaginary part of a complex number. +imagPart :: Complex a -> a +imagPart (_ :+ y) = y + +-- | The conjugate of a complex number. +{-# SPECIALISE conjugate :: Complex Double -> Complex Double #-} +conjugate :: Num a => Complex a -> Complex a +conjugate (x:+y) = x :+ (-y) + +-- | Form a complex number from polar components of magnitude and phase. +{-# SPECIALISE mkPolar :: Double -> Double -> Complex Double #-} +mkPolar :: Floating a => a -> a -> Complex a +mkPolar r theta = r * cos theta :+ r * sin theta + +-- | @'cis' t@ is a complex value with magnitude @1@ +-- and phase @t@ (modulo @2*'pi'@). +{-# SPECIALISE cis :: Double -> Complex Double #-} +cis :: Floating a => a -> Complex a +cis theta = cos theta :+ sin theta +#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Data/Functor/Const/Compat.hs new/base-compat-0.9.0/src/Data/Functor/Const/Compat.hs --- old/base-compat-0.8.2/src/Data/Functor/Const/Compat.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/src/Data/Functor/Const/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,4 @@ +{-# LANGUAGE CPP, NoImplicitPrelude #-} +module Data.Functor.Const.Compat (Const(..)) where + +import Control.Applicative (Const(..)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Data/IORef/Compat.hs new/base-compat-0.9.0/src/Data/IORef/Compat.hs --- old/base-compat-0.8.2/src/Data/IORef/Compat.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/src/Data/IORef/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,42 @@ +{-# LANGUAGE CPP, NoImplicitPrelude #-} +module Data.IORef.Compat ( + module Base +, modifyIORef' +, atomicModifyIORef' +, atomicWriteIORef +) where + +import Data.IORef as Base + +#if !(MIN_VERSION_base(4,6,0)) +import Prelude + +-- |Strict version of 'modifyIORef' +-- +-- /Since: 4.6.0.0/ +modifyIORef' :: IORef a -> (a -> a) -> IO () +modifyIORef' ref f = do + x <- readIORef ref + let x' = f x + x' `seq` writeIORef ref x' + +-- | Strict version of 'atomicModifyIORef'. This forces both the value stored +-- in the 'IORef' as well as the value returned. +-- +-- /Since: 4.6.0.0/ +atomicModifyIORef' :: IORef a -> (a -> (a,b)) -> IO b +atomicModifyIORef' ref f = do + b <- atomicModifyIORef ref $ \a -> + case f a of + v@(a',_) -> a' `seq` v + b `seq` return b + +-- | Variant of 'writeIORef' with the \"barrier to reordering\" property that +-- 'atomicModifyIORef' has. +-- +-- /Since: 4.6.0.0/ +atomicWriteIORef :: IORef a -> a -> IO () +atomicWriteIORef ref a = do + x <- atomicModifyIORef ref (\_ -> (a, ())) + x `seq` return () +#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Data/Ratio/Compat.hs new/base-compat-0.9.0/src/Data/Ratio/Compat.hs --- old/base-compat-0.8.2/src/Data/Ratio/Compat.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/src/Data/Ratio/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,32 @@ +{-# LANGUAGE CPP, NoImplicitPrelude #-} +module Data.Ratio.Compat ( + module Base +#if MIN_VERSION_base(4,4,0) && !(MIN_VERSION_base(4,9,0)) +, denominator +, numerator +#endif +) where + +#if !(MIN_VERSION_base(4,4,0)) || MIN_VERSION_base(4,9,0) +import Data.Ratio as Base +#else +import Data.Ratio as Base hiding ( + denominator + , numerator + ) +import GHC.Real (Ratio(..)) +#endif + +#if MIN_VERSION_base(4,4,0) && !(MIN_VERSION_base(4,9,0)) +-- | Extract the numerator of the ratio in reduced form: +-- the numerator and denominator have no common factor and the denominator +-- is positive. +numerator :: Ratio a -> a +numerator (x :% _) = x + +-- | Extract the denominator of the ratio in reduced form: +-- the numerator and denominator have no common factor and the denominator +-- is positive. +denominator :: Ratio a -> a +denominator (_ :% y) = y +#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Data/STRef/Compat.hs new/base-compat-0.9.0/src/Data/STRef/Compat.hs --- old/base-compat-0.8.2/src/Data/STRef/Compat.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/src/Data/STRef/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,21 @@ +{-# LANGUAGE CPP, NoImplicitPrelude #-} +module Data.STRef.Compat ( + module Base +, modifySTRef' +) where + +import Data.STRef as Base + +#if !(MIN_VERSION_base(4,6,0)) +import Control.Monad.ST (ST) +import Prelude (seq) + +-- | Strict version of 'modifySTRef' +-- +-- /Since: 4.6.0.0/ +modifySTRef' :: STRef s a -> (a -> a) -> ST s () +modifySTRef' ref f = do + x <- readSTRef ref + let x' = f x + x' `seq` writeSTRef ref x' +#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Data/String/Compat.hs new/base-compat-0.9.0/src/Data/String/Compat.hs --- old/base-compat-0.8.2/src/Data/String/Compat.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/src/Data/String/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,15 @@ +{-# LANGUAGE CPP, NoImplicitPrelude #-} +module Data.String.Compat ( + module Base +, String +, lines +, words +, unlines +, unwords +) where + +import Data.String as Base + +#if !(MIN_VERSION_base(4,4,0)) +import Prelude (String, lines, words, unlines, unwords) +#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Debug/Trace/Compat.hs new/base-compat-0.9.0/src/Debug/Trace/Compat.hs --- old/base-compat-0.8.2/src/Debug/Trace/Compat.hs 2015-05-13 08:36:37.000000000 +0200 +++ new/base-compat-0.9.0/src/Debug/Trace/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -6,11 +6,21 @@ , traceM , traceShowM ) where + +#if !(MIN_VERSION_base(4,7,0)) || MIN_VERSION_base(4,9,0) import Debug.Trace as Base +#else +import Debug.Trace as Base hiding ( + traceM + , traceShowM + ) +#endif -#if !(MIN_VERSION_base(4,7,0)) +#if !(MIN_VERSION_base(4,9,0)) import Prelude.Compat +#endif +#if !(MIN_VERSION_base(4,7,0)) {-| Like 'trace' but returns the message instead of a third value. @@ -26,11 +36,19 @@ -} traceShowId :: (Show a) => a -> a traceShowId a = trace (show a) a +#endif +#if !(MIN_VERSION_base(4,9,0)) {-| -Like 'trace' but returning unit in an arbitrary monad. Allows for convenient -use in do-notation. Note that the application of 'trace' is not an action in the -monad, as 'traceIO' is in the 'IO' monad. +Like 'trace' but returning unit in an arbitrary 'Applicative' context. Allows +for convenient use in do-notation. + +Note that the application of 'traceM' is not an action in the 'Applicative' +context, as 'traceIO' is in the 'IO' type. While the fresh bindings in the +following example will force the 'traceM' expressions to be reduced every time +the @do@-block is executed, @traceM "not crashed"@ would only be reduced once, +and the message would only be printed once. If your monad is in 'MonadIO', +@liftIO . traceIO@ may be a better option. > ... = do > x <- ... @@ -40,20 +58,20 @@ /Since: 4.7.0.0/ -} -traceM :: (Monad m) => String -> m () -traceM string = trace string $ return () +traceM :: (Applicative f) => String -> f () +traceM string = trace string $ pure () {-| Like 'traceM', but uses 'show' on the argument to convert it to a 'String'. > ... = do > x <- ... -> traceMShow $ x +> traceShowM $ x > y <- ... -> traceMShow $ x + y +> traceShowM $ x + y /Since: 4.7.0.0/ -} -traceShowM :: (Show a, Monad m) => a -> m () +traceShowM :: (Show a, Applicative f) => a -> f () traceShowM = traceM . show #endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Foreign/ForeignPtr/Safe/Compat.hs new/base-compat-0.9.0/src/Foreign/ForeignPtr/Safe/Compat.hs --- old/base-compat-0.8.2/src/Foreign/ForeignPtr/Safe/Compat.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/src/Foreign/ForeignPtr/Safe/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,34 @@ +{-# LANGUAGE CPP, NoImplicitPrelude #-} +module Foreign.ForeignPtr.Safe.Compat ( + -- * Finalised data pointers + ForeignPtr + , FinalizerPtr +#if defined(__HUGS__) || defined(__GLASGOW_HASKELL__) + , FinalizerEnvPtr +#endif + -- ** Basic operations + , newForeignPtr + , newForeignPtr_ + , addForeignPtrFinalizer +#if defined(__HUGS__) || defined(__GLASGOW_HASKELL__) + , newForeignPtrEnv + , addForeignPtrFinalizerEnv +#endif + , withForeignPtr + +#ifdef __GLASGOW_HASKELL__ + , finalizeForeignPtr +#endif + + -- ** Low-level operations + , touchForeignPtr + , castForeignPtr + + -- ** Allocating managed memory + , mallocForeignPtr + , mallocForeignPtrBytes + , mallocForeignPtrArray + , mallocForeignPtrArray0 + ) where + +import Foreign.ForeignPtr diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Foreign/ForeignPtr/Unsafe/Compat.hs new/base-compat-0.9.0/src/Foreign/ForeignPtr/Unsafe/Compat.hs --- old/base-compat-0.8.2/src/Foreign/ForeignPtr/Unsafe/Compat.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/src/Foreign/ForeignPtr/Unsafe/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,11 @@ +{-# LANGUAGE CPP, NoImplicitPrelude #-} +module Foreign.ForeignPtr.Unsafe.Compat ( + -- ** Unsafe low-level operations + unsafeForeignPtrToPtr +) where + +#if MIN_VERSION_base(4,6,0) +import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr) +#else +import Foreign.ForeignPtr (unsafeForeignPtrToPtr) +#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Foreign/Marshal/Safe/Compat.hs new/base-compat-0.9.0/src/Foreign/Marshal/Safe/Compat.hs --- old/base-compat-0.8.2/src/Foreign/Marshal/Safe/Compat.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/src/Foreign/Marshal/Safe/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,16 @@ +{-# LANGUAGE CPP, NoImplicitPrelude #-} +module Foreign.Marshal.Safe.Compat ( + -- | The module "Foreign.Marshal.Safe" re-exports the other modules in the + -- @Foreign.Marshal@ hierarchy: + module Foreign.Marshal.Alloc + , module Foreign.Marshal.Array + , module Foreign.Marshal.Error + , module Foreign.Marshal.Pool + , module Foreign.Marshal.Utils + ) where + +import Foreign.Marshal.Alloc +import Foreign.Marshal.Array +import Foreign.Marshal.Error +import Foreign.Marshal.Pool +import Foreign.Marshal.Utils diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Foreign/Marshal/Unsafe/Compat.hs new/base-compat-0.9.0/src/Foreign/Marshal/Unsafe/Compat.hs --- old/base-compat-0.8.2/src/Foreign/Marshal/Unsafe/Compat.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/src/Foreign/Marshal/Unsafe/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,11 @@ +{-# LANGUAGE CPP, NoImplicitPrelude #-} +module Foreign.Marshal.Unsafe.Compat ( + -- * Unsafe functions + unsafeLocalState +) where + +#if MIN_VERSION_base(4,6,0) +import Foreign.Marshal.Unsafe (unsafeLocalState) +#else +import Foreign.Marshal (unsafeLocalState) +#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/Prelude/Compat.hs new/base-compat-0.9.0/src/Prelude/Compat.hs --- old/base-compat-0.8.2/src/Prelude/Compat.hs 2015-05-13 08:36:37.000000000 +0200 +++ new/base-compat-0.9.0/src/Prelude/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -1,6 +1,6 @@ {-# LANGUAGE CPP, NoImplicitPrelude #-} module Prelude.Compat ( -#if MIN_VERSION_base(4,8,0) +#if MIN_VERSION_base(4,9,0) module Base #else either @@ -101,6 +101,7 @@ , (||) , ($) , error +, errorWithoutStackTrace , undefined , seq @@ -257,7 +258,7 @@ ) where -#if MIN_VERSION_base(4,8,0) +#if MIN_VERSION_base(4,9,0) import Prelude as Base @@ -290,9 +291,21 @@ , sum ) -import Data.Word import Data.Foldable.Compat import Data.Traversable -import Data.Monoid + +# if !(MIN_VERSION_base(4,8,0)) import Control.Applicative +import Data.Monoid +import Data.Word +# endif +#endif + +#if !(MIN_VERSION_base(4,9,0)) +-- | A variant of 'error' that does not produce a stack trace. +-- +-- /Since: 4.9.0.0/ +errorWithoutStackTrace :: [Char] -> a +errorWithoutStackTrace s = error s +{-# NOINLINE errorWithoutStackTrace #-} #endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/src/System/IO/Unsafe/Compat.hs new/base-compat-0.9.0/src/System/IO/Unsafe/Compat.hs --- old/base-compat-0.8.2/src/System/IO/Unsafe/Compat.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/src/System/IO/Unsafe/Compat.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,35 @@ +{-# LANGUAGE CPP, NoImplicitPrelude #-} +module System.IO.Unsafe.Compat ( + module Base +, unsafeFixIO +, unsafeDupablePerformIO +) where + +import System.IO.Unsafe as Base + +#if !(MIN_VERSION_base(4,5,0)) +import Control.Exception +import Data.IORef +import GHC.Base +import GHC.IO + +-- | A slightly faster version of `System.IO.fixIO` that may not be +-- safe to use with multiple threads. The unsafety arises when used +-- like this: +-- +-- > unsafeFixIO $ \r -> do +-- > forkIO (print r) +-- > return (...) +-- +-- In this case, the child thread will receive a @NonTermination@ +-- exception instead of waiting for the value of @r@ to be computed. +-- +-- /Since: 4.5.0.0/ +unsafeFixIO :: (a -> IO a) -> IO a +unsafeFixIO k = do + ref <- newIORef (throw NonTermination) + ans <- unsafeDupableInterleaveIO (readIORef ref) + result <- k ans + writeIORef ref result + return result +#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Control/Monad/CompatSpec.hs new/base-compat-0.9.0/test/Control/Monad/CompatSpec.hs --- old/base-compat-0.8.2/test/Control/Monad/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Control/Monad/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,16 @@ +module Control.Monad.CompatSpec (main, spec) where + +import Test.Hspec + +import Control.Monad.Compat +import Prelude () +import Prelude.Compat + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "(<$!>)" $ do + it "is a strict version of (<$>)" $ do + not <$!> [True, False] `shouldBe` not <$> [True, False] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Data/Bits/CompatSpec.hs new/base-compat-0.9.0/test/Data/Bits/CompatSpec.hs --- old/base-compat-0.8.2/test/Data/Bits/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Data/Bits/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,34 @@ +{-# LANGUAGE CPP #-} +module Data.Bits.CompatSpec (main, spec) where + +import Test.Hspec +import Data.Bits.Compat + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "bitDefault" $ + it "sets the ith bit with all other bits clear" $ do + bitDefault 0 `shouldBe` (1 :: Int) + bitDefault 1 `shouldBe` (2 :: Int) + bitDefault 2 `shouldBe` (4 :: Int) + bitDefault 3 `shouldBe` (8 :: Int) + describe "testBitDefault" $ + it "returns True if the nth bit of the argument is 1" $ do + testBitDefault (10 :: Int) 0 `shouldBe` False + testBitDefault (10 :: Int) 1 `shouldBe` True + testBitDefault (10 :: Int) 2 `shouldBe` False + testBitDefault (10 :: Int) 3 `shouldBe` True + describe "popCountDefault" $ + it "returns the number of set bits in the argument" $ do + popCountDefault (0 :: Int) `shouldBe` 0 + popCountDefault (1 :: Int) `shouldBe` 1 + popCountDefault (10 :: Int) `shouldBe` 2 +#if MIN_VERSION_base(4,7,0) + describe "toIntegralSized" $ + it "converts an Integral type to another as measured by bitSizeMaybe" $ do + toIntegralSized (42 :: Integer) `shouldBe` (Just 42 :: Maybe Int) + toIntegralSized (12345678901234567890 :: Integer) `shouldBe` (Nothing :: Maybe Int) +#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Data/Bool/CompatSpec.hs new/base-compat-0.9.0/test/Data/Bool/CompatSpec.hs --- old/base-compat-0.8.2/test/Data/Bool/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Data/Bool/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,18 @@ +module Data.Bool.CompatSpec (main, spec) where + +import Test.Hspec + +import Data.Bool.Compat + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "bool" $ do + it "evaluates to first parameter if condition is False" $ do + bool "KO" "OK" False `shouldBe` "KO" + + it "evaluates to second parameter if condition is True" $ do + bool "KO" "OK" True `shouldBe` "OK" + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Data/Either/CompatSpec.hs new/base-compat-0.9.0/test/Data/Either/CompatSpec.hs --- old/base-compat-0.8.2/test/Data/Either/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Data/Either/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,25 @@ +module Data.Either.CompatSpec (main, spec) where + +import Test.Hspec + +import Data.Either.Compat + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "isLeft" $ do + it "returns True for a Left value" $ do + isLeft (Left "23" :: Either String String) `shouldBe` True + + it "returns False for a Right value" $ do + isLeft (Right "23" :: Either String String) `shouldBe` False + + describe "isRight" $ do + it "returns False for a Left value" $ do + isRight (Left "23" :: Either String String) `shouldBe` False + + it "returns True for a Right value" $ do + isRight (Right "23" :: Either String String) `shouldBe` True + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Data/Function/CompatSpec.hs new/base-compat-0.9.0/test/Data/Function/CompatSpec.hs --- old/base-compat-0.8.2/test/Data/Function/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Data/Function/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,13 @@ +module Data.Function.CompatSpec (main, spec) where + +import Test.Hspec +import Data.Function.Compat + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "&" $ do + it "reverses function application" $ do + (False & not) `shouldBe` True diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Data/Functor/CompatSpec.hs new/base-compat-0.9.0/test/Data/Functor/CompatSpec.hs --- old/base-compat-0.8.2/test/Data/Functor/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Data/Functor/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,17 @@ +module Data.Functor.CompatSpec (main, spec) where + +import Test.Hspec +import Data.Functor.Compat + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "void" $ do + it "discards computation result" $ do + void (return 1 :: IO Int) `shouldReturn` () + + describe "$>" $ do + it "is the same as flipped <$" $ do + (Just 5 :: Maybe Int) $> 6 `shouldBe` (Just 6 :: Maybe Int) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Data/IORef/CompatSpec.hs new/base-compat-0.9.0/test/Data/IORef/CompatSpec.hs --- old/base-compat-0.8.2/test/Data/IORef/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Data/IORef/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,22 @@ +module Data.IORef.CompatSpec (main, spec) where + +import Test.Hspec + +import Control.Monad +import Data.IORef.Compat + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "modifyIORef'" $ + it "mutates the contents of an IORef strictly" $ do + ref <- newIORef 0 + replicateM_ 1000000 $ modifyIORef' ref (+1) + readIORef ref `shouldReturn` (1000000 :: Int) + describe "atomicModifyIORef'" $ + it "atomically modifies the contents of an IORef strictly" $ do + ref <- newIORef 0 + replicateM_ 1000000 . atomicModifyIORef' ref $ \n -> (n+1, ()) + readIORef ref `shouldReturn` (1000000 :: Int) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Data/List/CompatSpec.hs new/base-compat-0.9.0/test/Data/List/CompatSpec.hs --- old/base-compat-0.8.2/test/Data/List/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Data/List/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,43 @@ +module Data.List.CompatSpec (main, spec) where + +import Test.Hspec +import Data.List.Compat + +data Asymmetric = A | B deriving Show + +instance Eq Asymmetric where + A == _ = True + B == _ = False + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "dropWhileEnd" $ do + it "drops the largest suffix of a list in which a predicate holds for all elements" $ do + dropWhileEnd (== ' ') "foo " `shouldBe` "foo" + dropWhileEnd (== ' ') "foo bar" `shouldBe` "foo bar" + describe "isSubsequenceOf" $ do + it "returns True if the first list is a subsequence of the second list" $ do + isSubsequenceOf "GHC" "The Glorious Haskell Compiler" `shouldBe` True + isSubsequenceOf "JHC" "The Glorious Haskell Compiler" `shouldBe` False + describe "nub" $ + it "preserves the order of arguments to (==)" $ + nub [A, B] `shouldBe` [A] + describe "nubBy" $ + it "preserves the order of arguments to the equality function" $ + nubBy (<) "12" `shouldBe` "1" + describe "sortOn" $ do + it "sorts a list by comparing the results of a key function applied to each element" $ do + sortOn (>='b') "cba" `shouldBe` "acb" + describe "uncons" $ do + it "decomposes a list into its head and tail" $ do + uncons "" `shouldBe` Nothing + uncons "12" `shouldBe` Just ('1', "2") + describe "union" $ + it "nubs arguments in the same order as (==)" $ do + union [A] [A, B] `shouldBe` [A] + describe "unionBy" $ + it "nubs arguments in the same order as nubBy's equality function" $ do + unionBy (<) "1" "21" `shouldBe` "11" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Data/Monoid/CompatSpec.hs new/base-compat-0.9.0/test/Data/Monoid/CompatSpec.hs --- old/base-compat-0.8.2/test/Data/Monoid/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Data/Monoid/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,16 @@ +module Data.Monoid.CompatSpec (main, spec) where + +import Test.Hspec +import Test.QuickCheck + +import Data.Monoid.Compat + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "<>" $ do + it "is an infix synonym for mappend" $ do + property $ \xs ys -> do + xs <> ys `shouldBe` (mappend xs ys :: String) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Data/STRef/CompatSpec.hs new/base-compat-0.9.0/test/Data/STRef/CompatSpec.hs --- old/base-compat-0.8.2/test/Data/STRef/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Data/STRef/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,19 @@ +module Data.STRef.CompatSpec (main, spec) where + +import Test.Hspec + +import Control.Monad +import Control.Monad.ST +import Data.STRef.Compat + +main :: IO () +main = hspec spec + +spec :: Spec +spec = + describe "modifySTRef'" $ + it "should mutate the contents of an STRef strictly" $ + shouldBe (1000000 :: Int) $ runST $ do + ref <- newSTRef 0 + replicateM_ 1000000 $ modifySTRef' ref (+1) + readSTRef ref diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Data/Version/CompatSpec.hs new/base-compat-0.9.0/test/Data/Version/CompatSpec.hs --- old/base-compat-0.8.2/test/Data/Version/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Data/Version/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,10 @@ +module Data.Version.CompatSpec (spec) where + +import Test.Hspec +import Data.Version.Compat + +spec :: Spec +spec = do + describe "makeVersion" $ + it "constructs a tagless Version" $ + makeVersion [1,2,3] `shouldBe` Version [1,2,3] [] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Data/Word/CompatSpec.hs new/base-compat-0.9.0/test/Data/Word/CompatSpec.hs --- old/base-compat-0.8.2/test/Data/Word/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Data/Word/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,22 @@ +module Data.Word.CompatSpec (main, spec) where + +import Test.Hspec +import Data.Word.Compat + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "byteSwap16" $ + it "reverses the order of bytes in a Word16 value" $ do + byteSwap16 0x1100 `shouldBe` 0x0011 + byteSwap16 0x1010 `shouldBe` 0x1010 + describe "byteSwap32" $ + it "reverses the order of bytes in a Word32 value" $ do + byteSwap32 0x11001010 `shouldBe` 0x10100011 + byteSwap32 0x10101111 `shouldBe` 0x11111010 + describe "byteSwap64" $ + it "reverses the order of bytes in a Word64 value" $ do + byteSwap64 0x1010111110101111 `shouldBe` 0x1111101011111010 + byteSwap64 0x1100000000000011 `shouldBe` 0x1100000000000011 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Foreign/Marshal/Alloc/CompatSpec.hs new/base-compat-0.9.0/test/Foreign/Marshal/Alloc/CompatSpec.hs --- old/base-compat-0.8.2/test/Foreign/Marshal/Alloc/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Foreign/Marshal/Alloc/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,17 @@ +module Foreign.Marshal.Alloc.CompatSpec (main, spec) where + +import Test.Hspec + +import Control.Exception +import Foreign.Marshal.Alloc.Compat +import Foreign.Storable + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "calloc" $ + it "allocates memory with bytes of value zero" $ do + bracket calloc free $ \ptr -> do + peek ptr `shouldReturn` (0 :: Int) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Foreign/Marshal/Utils/CompatSpec.hs new/base-compat-0.9.0/test/Foreign/Marshal/Utils/CompatSpec.hs --- old/base-compat-0.8.2/test/Foreign/Marshal/Utils/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Foreign/Marshal/Utils/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,20 @@ +module Foreign.Marshal.Utils.CompatSpec (main, spec) where + +import Test.Hspec + +import Foreign.Marshal.Alloc +import Foreign.Marshal.Utils.Compat +import Foreign.Ptr +import Foreign.Storable + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "fillBytes" $ + it "fills a given number of bytes in memory area with a byte value" $ do + alloca $ \ptr -> do + let _ = ptr :: Ptr Int + fillBytes ptr 0 $ sizeOf ptr + peek ptr `shouldReturn` 0 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Numeric/CompatSpec.hs new/base-compat-0.9.0/test/Numeric/CompatSpec.hs --- old/base-compat-0.8.2/test/Numeric/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Numeric/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,24 @@ +module Numeric.CompatSpec (main, spec) where + +import Test.Hspec +import Numeric.Compat + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "showFFloatAlt" $ do + it "shows a RealFloat value, always using decimal notation" $ + showFFloatAlt Nothing (12 :: Double) "" `shouldBe` "12.0" + it "allows to specify the number of decimal places" $ + showFFloatAlt (Just 4) (12 :: Double) "" `shouldBe` "12.0000" + describe "showGFloatAlt" $ do + it "shows a RealFloat value, using decimal notation if the absolute value lies between 0.1 and 9,999,999" $ + showGFloatAlt Nothing (12 :: Double) "" `shouldBe` "12.0" + it "shows a RealFloat value, using decimal notation and specifying the number of decimal places" $ + showGFloatAlt (Just 4) (12 :: Double) "" `shouldBe` "12.0000" + it "shows a RealFloat value, using scientific notation if the absolute value falls outside of the range" $ + 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" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/System/Environment/CompatSpec.hs new/base-compat-0.9.0/test/System/Environment/CompatSpec.hs --- old/base-compat-0.8.2/test/System/Environment/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/System/Environment/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,120 @@ +{-# LANGUAGE CPP #-} +module System.Environment.CompatSpec (main, spec) where + +import Test.Hspec +import Test.QuickCheck + +import qualified Control.Exception as E +import GHC.IO.Exception (IOErrorType (InvalidArgument)) +import System.Environment.Compat +import System.IO.Error + +main :: IO () +main = hspec spec + +withEnv :: String -> String -> IO a -> IO a +withEnv k v action = E.bracket save restore $ \_ -> do + setEnv k v >> action + where + save = lookupEnv k + restore = maybe (unsetEnv k) (setEnv k) + +withoutEnv :: String -> IO a -> IO a +withoutEnv k action = E.bracket save restore $ \_ -> do + unsetEnv k >> action + where + save = lookupEnv k + restore = maybe (unsetEnv k) (setEnv k) + +spec :: Spec +spec = do + describe "lookupEnv" $ do + it "returns specified environment variable" $ do + withEnv "FOOBAR" "23" $ do + lookupEnv "FOOBAR" `shouldReturn` Just "23" + + it "returns Nothing if specified environment variable is not set" $ do + withoutEnv "FOOBAR" $ do + lookupEnv "FOOBAR" `shouldReturn` Nothing + + describe "unsetEnv" $ do + it "removes specified environment variable" $ do + setEnv "FOO" "foo" + unsetEnv "FOO" + getEnv "FOO" `shouldThrow` isDoesNotExistError + + it "does nothing if specified environment variable is not set" $ do + unsetEnv "BAR" + unsetEnv "BAR" + getEnv "BAR" `shouldThrow` isDoesNotExistError + + it "throws an exception if key is the empty string" $ do + unsetEnv "" `shouldThrow` (== InvalidArgument) . ioeGetErrorType + + it "throws an exception if key contains '='" $ do + unsetEnv "some=key" `shouldThrow` (== InvalidArgument) . ioeGetErrorType + + it "works for arbitrary keys" $ + property $ \k -> ('\NUL' `notElem` k && '=' `notElem` k && (not . null) k) ==> do + setEnv k "foo" + unsetEnv k + getEnv k `shouldThrow` isDoesNotExistError + + describe "setEnv" $ do + it "sets specified environment variable to given value" $ do + unsetEnv "FOO" + setEnv "FOO" "foo" + getEnv "FOO" `shouldReturn` "foo" + + it "resets specified environment variable, if it is already set" $ do + unsetEnv "FOO" + setEnv "FOO" "foo" + setEnv "FOO" "bar" + getEnv "FOO" `shouldReturn` "bar" + + it "removes specified environment variable when value is the empty string" $ do + setEnv "FOO" "foo" + setEnv "FOO" "" + getEnv "FOO" `shouldThrow` isDoesNotExistError + + it "removes specified environment variable when first character of value is NUL" $ do + setEnv "FOO" "foo" + setEnv "FOO" "\NULfoo" + getEnv "FOO" `shouldThrow` isDoesNotExistError + + it "truncates value at NUL character" $ do + unsetEnv "FOO" + setEnv "FOO" "foo\NULbar" + getEnv "FOO" `shouldReturn` "foo" + + it "truncates key at NUL character" $ do + unsetEnv "FOO" + setEnv "FOO\NULBAR" "foo" + getEnv "FOO" `shouldReturn` "foo" + +#if __GLASGOW_HASKELL__ >= 702 + it "works for unicode" $ do + unsetEnv "FOO" + setEnv "FOO" "foo-\955-bar" + getEnv "FOO" `shouldReturn` "foo-\955-bar" +#endif + + it "works for arbitrary values" $ + property $ \v -> ('\NUL' `notElem` v && (not . null) v) ==> do + setEnv "FOO" v + getEnv "FOO" `shouldReturn` v + + it "works for unicode keys" $ do + setEnv "foo-\955-bar" "foo" + getEnv "foo-\955-bar" `shouldReturn` "foo" + + it "throws an exception if key is the empty string" $ do + setEnv "" "foo" `shouldThrow` (== InvalidArgument) . ioeGetErrorType + + it "throws an exception if key contains '='" $ do + setEnv "some=key" "foo" `shouldThrow` (== InvalidArgument) . ioeGetErrorType + + it "works for arbitrary keys" $ + property $ \k -> ('\NUL' `notElem` k && '=' `notElem` k && (not . null) k) ==> do + setEnv k "foo" + getEnv k `shouldReturn` "foo" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-compat-0.8.2/test/Text/Read/CompatSpec.hs new/base-compat-0.9.0/test/Text/Read/CompatSpec.hs --- old/base-compat-0.8.2/test/Text/Read/CompatSpec.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/base-compat-0.9.0/test/Text/Read/CompatSpec.hs 2016-01-15 03:45:49.000000000 +0100 @@ -0,0 +1,24 @@ +module Text.Read.CompatSpec (main, spec) where + +import Test.Hspec + +import Text.Read.Compat + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "readMaybe" $ do + it "parses a value" $ do + readMaybe "23" `shouldBe` (Just 23 :: Maybe Int) + + it "returns Nothing if parsing fails" $ do + readMaybe "xx" `shouldBe` (Nothing :: Maybe Int) + + describe "readEither" $ do + it "parses a value" $ do + readEither "23" `shouldBe` (Right 23 :: Either String Int) + + it "returns Left if parsing fails" $ do + readEither "xx" `shouldBe` (Left "Prelude.read: no parse" :: Either String Int)

1 0

commit ghc-base-orphans for openSUSE:Factory
by root＠hilbert.suse.de 28 Jan '16

28 Jan '16

Hello community, here is the log from the commit of package ghc-base-orphans for openSUSE:Factory checked in at 2016-01-28 17:23:33 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-base-orphans (Old) and /work/SRC/openSUSE:Factory/.ghc-base-orphans.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-base-orphans" Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-base-orphans/ghc-base-orphans.changes 2015-12-23 08:50:12.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.ghc-base-orphans.new/ghc-base-orphans.changes 2016-01-28 17:24:30.000000000 +0100 @@ -1,0 +2,6 @@ +Wed Jan 20 08:48:09 UTC 2016 - mimi.vx(a)gmail.com + +- update to 0.5.0 +* Backported instances introduced in GHC 8.0/base-4.9 + +------------------------------------------------------------------- Old: ---- base-orphans-0.4.5.tar.gz New: ---- base-orphans-0.5.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-base-orphans.spec ++++++ --- /var/tmp/diff_new_pack.HLOfB0/_old 2016-01-28 17:24:30.000000000 +0100 +++ /var/tmp/diff_new_pack.HLOfB0/_new 2016-01-28 17:24:30.000000000 +0100 @@ -20,7 +20,7 @@ %bcond_with tests Name: ghc-base-orphans -Version: 0.4.5 +Version: 0.5.0 Release: 0 Summary: Backwards-compatible orphan instances for base Group: System/Libraries ++++++ base-orphans-0.4.5.tar.gz -> base-orphans-0.5.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-orphans-0.4.5/CHANGES.markdown new/base-orphans-0.5.0/CHANGES.markdown --- old/base-orphans-0.4.5/CHANGES.markdown 2015-12-15 18:26:53.000000000 +0100 +++ new/base-orphans-0.5.0/CHANGES.markdown 2016-01-15 03:45:07.000000000 +0100 @@ -1,3 +1,8 @@ +## Changes in 0.5.0 + - GHC 8.0 compatibility + - Backported instances introduced in GHC 8.0/`base-4.9` + (see https://github.com/haskell-compat/base-orphans/issues/32) + ## Changes in 0.4.5 - Import `Control.Monad.Instances` (which exports `Functor` and `Monad` instances for `(->) r`, and `Functor` instances for `(,) a` and `Either a`) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-orphans-0.4.5/README.markdown new/base-orphans-0.5.0/README.markdown --- old/base-orphans-0.4.5/README.markdown 2015-12-15 18:26:53.000000000 +0100 +++ new/base-orphans-0.5.0/README.markdown 2016-01-15 03:45:07.000000000 +0100 @@ -31,25 +31,33 @@ ## What is covered - * Added `Applicative` and `Alternative` instances for `ReadP` and `ReadPrec` - * Added `Bits`, `Bounded`, and `Integral` instances for `CDev` - * Added `Eq` and `Ord` instances for `Control.Exception.ErrorCall` - * Added `Eq`, `Ord`, `Read`, and `Show` instances for data types in `GHC.Generics` - * Added `Functor`, `Applicative`, `Alternative`, and `MonadPlus` instances for `ArrowMonad` - * Added `Functor`, `Applicative`, and `Monad` instances for `First` and `Last` - * Added `Monoid`, `Eq`, `Ord`, `Read`, and `Show` instances for `Const` - * Added `Read` and `Show` instances for `Down` - * Added `Eq`, `Ord`, `Read`, and `Show` instances for `ZipList` - * Added `Monad` instance for `WrappedMonad` - * Added `Data` and `IsList` instances for `Version` + * `Applicative` and `Alternative` instances for `ReadP` and `ReadPrec` * `Applicative` instance for strict and lazy `ST` + * `Applicative`, `Foldable`, `Functor`, `Monad`, and `Traversable` instances for `Complex`, + `Dual`, `First`, `Last`, `Product`, and `Sum` * `Bits` instance for `Bool` + * `Bits`, `Bounded`, and `Integral` instances for `CDev` + * `Bounded`, `Enum`, `Ix`, and `Storable` instances for `Const` and `Identity` + * `Data` instances for `All` and `Any` + * `Data`, `MonadFix` and `MonadZip` instances for `Alt`, `Dual`, `First`, `Last`, + `Product`, and `Sum` + * `Data` and `IsList` instances for `Version` + * `Eq` and `Ord` instances for `Control.Exception.ErrorCall` + * `Eq`, `Ord`, `Read`, and `Show` instances for data types in `GHC.Generics` + * `Eq`, `Ord`, `Read`, `Show`, `Foldable`, and `Traversable` instances for `ZipList` * `Foldable` instance for `Either`, `(,)` and `Const` * `Functor` instance for `Handler`, `ArgOrder`, `OptDescr`, and `ArgDescr` + * `Functor`, `Applicative`, `Alternative`, and `MonadPlus` instances for `ArrowMonad` + * `Monad` instance for `(,)` + * `Monad` instance for `WrappedMonad` + * `MonadZip` instance for `Maybe` + * `Monoid`, `Eq`, `Ord`, `Read`, and `Show` instances for `Const` + * `Monoid` instances for `Identity` and `IO` * `Num` instance for `Sum` and `Product` * `Read` instance for `Fixed` + * `Read` and `Show` instances for `Down` * `Show` instance for `Fingerprint` - * `Storable` instance for `Complex` and `Ratio` + * `Storable` instance for `()`, `Complex`, and `Ratio` * `Traversable` instance for `Either`, `(,)` and `Const` * `Typeable` instance for most data types, typeclasses, and promoted data constructors (when possible) @@ -60,9 +68,14 @@ [`Generics.Deriving.Instances`](https://hackage.haskell.org/package/generic-deriving-1.8.0/docs/Generics-Deriving-Instances.html) module of the [`generic-deriving`](https://hackage.haskell.org/package/generic-deriving) library. +* The `Alternative IO` and `MonadPlus IO` instances. These can be found in the + [`Control.Monad.Trans.Error`](http://hackage.haskell.org/package/transformers-0.4.3.0/docs/src/Control-Monad-Trans-Error.html#line-69) + module of the [`transformers`](http://hackage.haskell.org/package/transformers) library. ## Supported versions of GHC/`base` + * `ghc-8.0.1` / `base-4.9.0.0` + * `ghc-7.10.3` / `base-4.8.2.0` * `ghc-7.10.2` / `base-4.8.1.0` * `ghc-7.10.1` / `base-4.8.0.0` * `ghc-7.8.4` / `base-4.7.0.2` diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-orphans-0.4.5/base-orphans.cabal new/base-orphans-0.5.0/base-orphans.cabal --- old/base-orphans-0.4.5/base-orphans.cabal 2015-12-15 18:26:53.000000000 +0100 +++ new/base-orphans-0.5.0/base-orphans.cabal 2016-01-15 03:45:07.000000000 +0100 @@ -1,71 +1,71 @@ --- This file has been generated from package.yaml by hpack version 0.8.0. --- --- see: https://github.com/sol/hpack - -name: base-orphans -version: 0.4.5 -synopsis: Backwards-compatible orphan instances for base -description: @base-orphans@ defines orphan instances that mimic instances available in later versions of @base@ to a wider (older) range of compilers. @base-orphans@ does not export anything except the orphan instances themselves and complements @<http://hackage.haskell.org/package/base-compat base-compat>@. - See the README for what instances are covered: <https://github.com/haskell-compat/base-orphans#readme>. See also the <https://github.com/haskell-compat/base-orphans#what-is-not-covered what is not covered> section. -category: Compatibility -homepage: https://github.com/haskell-compat/base-orphans#readme -bug-reports: https://github.com/haskell-compat/base-orphans/issues -author: Simon Hengel <sol(a)typeful.net>, - João Cristóvão <jmacristovao(a)gmail.com>, - Ryan Scott <ryan.gl.scott(a)gmail.com> -maintainer: Simon Hengel <sol(a)typeful.net>, - João Cristóvão <jmacristovao(a)gmail.com>, - Ryan Scott <ryan.gl.scott(a)gmail.com> -copyright: (c) 2012-2015 Simon Hengel, - (c) 2014 João Cristóvão, - (c) 2015 Ryan Scott -license: MIT -license-file: LICENSE -build-type: Simple -cabal-version: >= 1.10 - -extra-source-files: - CHANGES.markdown - README.markdown - -source-repository head - type: git - location: https://github.com/haskell-compat/base-orphans - -library - hs-source-dirs: - src - ghc-options: -Wall - build-depends: - base >= 4.3 && < 5, - ghc-prim - exposed-modules: - Data.Orphans - other-modules: - Data.Orphans.Prelude - default-language: Haskell2010 - -test-suite spec - type: exitcode-stdio-1.0 - main-is: Spec.hs - hs-source-dirs: - test - ghc-options: -Wall - build-depends: - base >= 4.3 && < 5, - base-orphans, - hspec == 2.*, - QuickCheck - other-modules: - Control.Applicative.OrphansSpec - Control.Exception.OrphansSpec - Data.Bits.OrphansSpec - Data.Foldable.OrphansSpec - Data.Monoid.OrphansSpec - Data.Traversable.OrphansSpec - Data.Version.OrphansSpec - Foreign.Storable.OrphansSpec - GHC.Fingerprint.OrphansSpec - System.Posix.Types.IntWord - System.Posix.Types.OrphansSpec - default-language: Haskell2010 +-- This file has been generated from package.yaml by hpack version 0.8.0. +-- +-- see: https://github.com/sol/hpack + +name: base-orphans +version: 0.5.0 +synopsis: Backwards-compatible orphan instances for base +description: @base-orphans@ defines orphan instances that mimic instances available in later versions of @base@ to a wider (older) range of compilers. @base-orphans@ does not export anything except the orphan instances themselves and complements @<http://hackage.haskell.org/package/base-compat base-compat>@. + See the README for what instances are covered: <https://github.com/haskell-compat/base-orphans#readme>. See also the <https://github.com/haskell-compat/base-orphans#what-is-not-covered what is not covered> section. +category: Compatibility +homepage: https://github.com/haskell-compat/base-orphans#readme +bug-reports: https://github.com/haskell-compat/base-orphans/issues +author: Simon Hengel <sol(a)typeful.net>, + João Cristóvão <jmacristovao(a)gmail.com>, + Ryan Scott <ryan.gl.scott(a)gmail.com> +maintainer: Simon Hengel <sol(a)typeful.net>, + João Cristóvão <jmacristovao(a)gmail.com>, + Ryan Scott <ryan.gl.scott(a)gmail.com> +copyright: (c) 2012-2015 Simon Hengel, + (c) 2014 João Cristóvão, + (c) 2015 Ryan Scott +license: MIT +license-file: LICENSE +build-type: Simple +cabal-version: >= 1.10 + +extra-source-files: + CHANGES.markdown + README.markdown + +source-repository head + type: git + location: https://github.com/haskell-compat/base-orphans + +library + hs-source-dirs: + src + ghc-options: -Wall + build-depends: + base >= 4.3 && < 5, + ghc-prim + exposed-modules: + Data.Orphans + other-modules: + Data.Orphans.Prelude + default-language: Haskell2010 + +test-suite spec + type: exitcode-stdio-1.0 + main-is: Spec.hs + hs-source-dirs: + test + ghc-options: -Wall + build-depends: + base >= 4.3 && < 5, + base-orphans, + hspec == 2.*, + QuickCheck + other-modules: + Control.Applicative.OrphansSpec + Control.Exception.OrphansSpec + Data.Bits.OrphansSpec + Data.Foldable.OrphansSpec + Data.Monoid.OrphansSpec + Data.Traversable.OrphansSpec + Data.Version.OrphansSpec + Foreign.Storable.OrphansSpec + GHC.Fingerprint.OrphansSpec + System.Posix.Types.IntWord + System.Posix.Types.OrphansSpec + default-language: Haskell2010 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-orphans-0.4.5/src/Data/Orphans/Prelude.hs new/base-orphans-0.5.0/src/Data/Orphans/Prelude.hs --- old/base-orphans-0.4.5/src/Data/Orphans/Prelude.hs 2015-12-15 18:26:53.000000000 +0100 +++ new/base-orphans-0.5.0/src/Data/Orphans/Prelude.hs 2016-01-15 03:45:07.000000000 +0100 @@ -10,7 +10,7 @@ Note that this module does not export any modules that could introduce name clashes. -} module Data.Orphans.Prelude -#if MIN_VERSION_base(4,8,0) +#if MIN_VERSION_base(4,9,0) () where #else (module OrphansPrelude) where @@ -100,4 +100,8 @@ import Control.Concurrent.SampleVar as OrphansPrelude # endif +# if MIN_VERSION_base(4,8,0) +import Data.Functor.Identity as OrphansPrelude +# endif + #endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-orphans-0.4.5/src/Data/Orphans.hs new/base-orphans-0.5.0/src/Data/Orphans.hs --- old/base-orphans-0.4.5/src/Data/Orphans.hs 2015-12-15 18:26:53.000000000 +0100 +++ new/base-orphans-0.5.0/src/Data/Orphans.hs 2016-01-15 03:45:07.000000000 +0100 @@ -5,6 +5,7 @@ {-# LANGUAGE DeriveTraversable #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} @@ -42,13 +43,16 @@ import Control.Monad.Instances () #endif -#if __GLASGOW_HASKELL__ < 710 -import Control.Exception as Exception -import Control.Monad.ST.Lazy as Lazy +#if !(MIN_VERSION_base(4,9,0)) import Data.Data as Data import qualified Data.Foldable as F (Foldable(..)) import Data.Monoid as Monoid import qualified Data.Traversable as T (Traversable(..)) +#endif + +#if __GLASGOW_HASKELL__ < 710 +import Control.Exception as Exception +import Control.Monad.ST.Lazy as Lazy import GHC.Exts as Exts import GHC.IO.Exception as Exception import Text.ParserCombinators.ReadP as ReadP @@ -60,7 +64,7 @@ # endif #endif -#if !(MIN_VERSION_base(4,8,0)) +#if !(MIN_VERSION_base(4,9,0)) import Data.Orphans.Prelude #endif @@ -392,6 +396,242 @@ pokeElemOff q 1 i #endif +#if !(MIN_VERSION_base(4,9,0)) +instance Storable () where + sizeOf _ = 0 + alignment _ = 1 + peek _ = return () + poke _ _ = return () + +deriving instance Bounded a => Bounded (Const a b) +deriving instance Enum a => Enum (Const a b) +deriving instance Ix a => Ix (Const a b) +deriving instance Storable a => Storable (Const a b) + +deriving instance Data All +deriving instance Data Monoid.Any +deriving instance Data a => Data (Dual a) +deriving instance Data a => Data (First a) +deriving instance Data a => Data (Last a) +deriving instance Data a => Data (Product a) +deriving instance Data a => Data (Sum a) + +instance F.Foldable Dual where + foldMap = coerce + + foldl = coerce + foldl1 _ = getDual + foldr f z (Dual x) = f x z + foldr1 _ = getDual +# if MIN_VERSION_base(4,6,0) + foldl' = coerce + foldr' = F.foldr +# endif +# if MIN_VERSION_base(4,8,0) + elem = (. getDual) #. (==) + length _ = 1 + maximum = getDual + minimum = getDual + null _ = False + product = getDual + sum = getDual + toList (Dual x) = [x] +# endif + +instance F.Foldable Sum where + foldMap = coerce + + foldl = coerce + foldl1 _ = getSum + foldr f z (Sum x) = f x z + foldr1 _ = getSum +# if MIN_VERSION_base(4,6,0) + foldl' = coerce + foldr' = F.foldr +# endif +# if MIN_VERSION_base(4,8,0) + elem = (. getSum) #. (==) + length _ = 1 + maximum = getSum + minimum = getSum + null _ = False + product = getSum + sum = getSum + toList (Sum x) = [x] +# endif + +instance F.Foldable Product where + foldMap = coerce + + foldl = coerce + foldl1 _ = getProduct + foldr f z (Product x) = f x z + foldr1 _ = getProduct +# if MIN_VERSION_base(4,6,0) + foldl' = coerce + foldr' = F.foldr +# endif +# if MIN_VERSION_base(4,8,0) + elem = (. getProduct) #. (==) + length _ = 1 + maximum = getProduct + minimum = getProduct + null _ = False + product = getProduct + sum = getProduct + toList (Product x) = [x] +# endif + +# if MIN_VERSION_base(4,8,0) +(#.) :: Coercible b c => (b -> c) -> (a -> b) -> (a -> c) +(#.) _f = coerce +# endif + +# if !(MIN_VERSION_base(4,7,0)) +coerce :: a -> b +coerce = unsafeCoerce +# endif + +instance Functor Dual where + fmap = coerce + +instance Applicative Dual where + pure = Dual + (<*>) = coerce + +instance Monad Dual where + return = Dual + m >>= k = k (getDual m) + +instance Functor Sum where + fmap = coerce + +instance Applicative Sum where + pure = Sum + (<*>) = coerce + +instance Monad Sum where + return = Sum + m >>= k = k (getSum m) + +instance Functor Product where + fmap = coerce + +instance Applicative Product where + pure = Product + (<*>) = coerce + +instance Monad Product where + return = Product + m >>= k = k (getProduct m) + +instance F.Foldable First where + foldMap f = F.foldMap f . getFirst + +instance F.Foldable Last where + foldMap f = F.foldMap f . getLast + +instance Monoid a => Monoid (IO a) where + mempty = pure mempty + mappend = liftA2 mappend + +-- see: #10190 https://git.haskell.org/ghc.git/commitdiff/9db005a444722e31aca1956b058e069b… +instance Monoid a => Monad ((,) a) where + return x = (mempty, x) + (u, a) >>= k = case k a of (v, b) -> (u `mappend` v, b) + +instance MonadFix Dual where + mfix f = Dual (fix (getDual . f)) + +instance MonadFix Sum where + mfix f = Sum (fix (getSum . f)) + +instance MonadFix Product where + mfix f = Product (fix (getProduct . f)) + +instance MonadFix First where + mfix f = First (mfix (getFirst . f)) + +instance MonadFix Last where + mfix f = Last (mfix (getLast . f)) + +instance T.Traversable Dual where + traverse f (Dual x) = Dual <$> f x + +instance T.Traversable Sum where + traverse f (Sum x) = Sum <$> f x + +instance T.Traversable Product where + traverse f (Product x) = Product <$> f x + +instance T.Traversable First where + traverse f (First x) = First <$> T.traverse f x + +instance T.Traversable Last where + traverse f (Last x) = Last <$> T.traverse f x + +deriving instance F.Foldable ZipList +deriving instance T.Traversable ZipList + +# if MIN_VERSION_base(4,4,0) +deriving instance Functor Complex +deriving instance F.Foldable Complex +deriving instance T.Traversable Complex + +instance Applicative Complex where + pure a = a :+ a + f :+ g <*> a :+ b = f a :+ g b + +instance Monad Complex where + return a = a :+ a + a :+ b >>= f = realPart (f a) :+ imagPart (f b) + +-- | Extracts the real part of a complex number. +realPart :: Complex a -> a +realPart (x :+ _) = x + +-- | Extracts the imaginary part of a complex number. +imagPart :: Complex a -> a +imagPart (_ :+ y) = y + +instance MonadZip Dual where + -- Cannot use coerce, it's unsafe + mzipWith = liftM2 + +instance MonadZip Sum where + mzipWith = liftM2 + +instance MonadZip Product where + mzipWith = liftM2 + +instance MonadZip Maybe where + mzipWith = liftM2 + +instance MonadZip First where + mzipWith = liftM2 + +instance MonadZip Last where + mzipWith = liftM2 +# endif + +# if MIN_VERSION_base(4,8,0) +deriving instance (Data (f a), Typeable f, Typeable a) + => Data (Alt (f :: * -> *) (a :: *)) + +instance MonadFix f => MonadFix (Alt f) where + mfix f = Alt (mfix (getAlt . f)) + +instance MonadZip f => MonadZip (Alt f) where + mzipWith f (Alt ma) (Alt mb) = Alt (mzipWith f ma mb) + +deriving instance Bounded a => Bounded (Identity a) +deriving instance Enum a => Enum (Identity a) +deriving instance Ix a => Ix (Identity a) +deriving instance Monoid a => Monoid (Identity a) +deriving instance Storable a => Storable (Identity a) +# endif +#endif + #if __GLASGOW_HASKELL__ < 710 deriving instance Typeable All deriving instance Typeable AnnotationWrapper

1 0

commit ghc-async for openSUSE:Factory
by root＠hilbert.suse.de 28 Jan '16

28 Jan '16

Hello community, here is the log from the commit of package ghc-async for openSUSE:Factory checked in at 2016-01-28 17:23:30 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-async (Old) and /work/SRC/openSUSE:Factory/.ghc-async.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-async" Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-async/ghc-async.changes 2015-05-21 08:11:04.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-async.new/ghc-async.changes 2016-01-28 17:24:28.000000000 +0100 @@ -1,0 +2,11 @@ +Sun Jan 24 10:10:44 UTC 2016 - mimi.vx(a)gmail.com + +- update to 2.1.0 +* Bump base dependency to allow 4.10 +* Remove invalid Monad instance for Concurrently +* Add Monoid and Semigroup instances for Concurrently +* Add forConcurrently (flipped version of mapConcurrently) +* Add STM version of all applicable IO functions: waitAnySTM, waitAnyCatchSTM, + waitEitherSTM, waitEitherCatchSTM, waitEitherSTM_, and waitBothSTM. + +------------------------------------------------------------------- Old: ---- async-2.0.2.tar.gz New: ---- async-2.1.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-async.spec ++++++ --- /var/tmp/diff_new_pack.Fjk1y6/_old 2016-01-28 17:24:29.000000000 +0100 +++ /var/tmp/diff_new_pack.Fjk1y6/_new 2016-01-28 17:24:29.000000000 +0100 @@ -19,14 +19,14 @@ %global pkg_name async Name: ghc-async -Version: 2.0.2 +Version: 2.1.0 Release: 0 Summary: Run IO operations asynchronously and wait for their results License: BSD-3-Clause Group: System/Libraries Url: http://hackage.haskell.org/package/%{pkg_name} -Source0: http://hackage.haskell.org/packages/archive/%{pkg_name}/%{version}/%{pkg_na… +Source0: http://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{ver… BuildRoot: %{_tmppath}/%{name}-%{version}-build BuildRequires: ghc-Cabal-devel ++++++ async-2.0.2.tar.gz -> async-2.1.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/async-2.0.2/Control/Concurrent/Async.hs new/async-2.1.0/Control/Concurrent/Async.hs --- old/async-2.0.2/Control/Concurrent/Async.hs 2014-12-22 12:32:14.000000000 +0100 +++ new/async-2.1.0/Control/Concurrent/Async.hs 2016-01-05 17:42:20.000000000 +0100 @@ -105,11 +105,17 @@ waitEither_, waitBoth, + -- ** Waiting for multiple 'Async's in STM + waitAnySTM, waitAnyCatchSTM, + waitEitherSTM, waitEitherCatchSTM, + waitEitherSTM_, + waitBothSTM, + -- ** Linking link, link2, -- * Convenient utilities - race, race_, concurrently, mapConcurrently, + race, race_, concurrently, mapConcurrently, forConcurrently, Concurrently(..), ) where @@ -122,7 +128,14 @@ #endif import Control.Monad import Control.Applicative +#if !MIN_VERSION_base(4,8,0) +import Data.Monoid (Monoid(mempty,mappend)) import Data.Traversable +#endif +#if MIN_VERSION_base(4,9,0) +import Data.Semigroup (Semigroup((<>))) +#endif + import GHC.Exts import GHC.IO hiding (finally, onException) @@ -316,9 +329,15 @@ -- If multiple 'Async's complete or have completed, then the value -- returned corresponds to the first completed 'Async' in the list. -- +{-# INLINE waitAnyCatch #-} waitAnyCatch :: [Async a] -> IO (Async a, Either SomeException a) -waitAnyCatch asyncs = - atomically $ +waitAnyCatch = atomically . waitAnyCatchSTM + +-- | A version of 'waitAnyCatch' that can be used inside an STM transaction. +-- +-- @since 2.1.0 +waitAnyCatchSTM :: [Async a] -> STM (Async a, Either SomeException a) +waitAnyCatchSTM asyncs = foldr orElse retry $ map (\a -> do r <- waitCatchSTM a; return (a, r)) asyncs @@ -336,9 +355,15 @@ -- If multiple 'Async's complete or have completed, then the value -- returned corresponds to the first completed 'Async' in the list. -- +{-# INLINE waitAny #-} waitAny :: [Async a] -> IO (Async a, a) -waitAny asyncs = - atomically $ +waitAny = atomically . waitAnySTM + +-- | A version of 'waitAny' that can be used inside an STM transaction. +-- +-- @since 2.1.0 +waitAnySTM :: [Async a] -> STM (Async a, a) +waitAnySTM asyncs = foldr orElse retry $ map (\a -> do r <- waitSTM a; return (a, r)) asyncs @@ -350,11 +375,19 @@ waitAny asyncs `finally` mapM_ cancel asyncs -- | Wait for the first of two @Async@s to finish. +{-# INLINE waitEitherCatch #-} waitEitherCatch :: Async a -> Async b -> IO (Either (Either SomeException a) (Either SomeException b)) -waitEitherCatch left right = - atomically $ +waitEitherCatch left right = atomically (waitEitherCatchSTM left right) + +-- | A version of 'waitEitherCatch' that can be used inside an STM transaction. +-- +-- @since 2.1.0 +waitEitherCatchSTM :: Async a -> Async b + -> STM (Either (Either SomeException a) + (Either SomeException b)) +waitEitherCatchSTM left right = (Left <$> waitCatchSTM left) `orElse` (Right <$> waitCatchSTM right) @@ -372,18 +405,30 @@ -- that finished first raised an exception, then the exception is -- re-thrown by 'waitEither'. -- +{-# INLINE waitEither #-} waitEither :: Async a -> Async b -> IO (Either a b) -waitEither left right = - atomically $ +waitEither left right = atomically (waitEitherSTM left right) + +-- | A version of 'waitEither' that can be used inside an STM transaction. +-- +-- @since 2.1.0 +waitEitherSTM :: Async a -> Async b -> STM (Either a b) +waitEitherSTM left right = (Left <$> waitSTM left) `orElse` (Right <$> waitSTM right) -- | Like 'waitEither', but the result is ignored. -- +{-# INLINE waitEither_ #-} waitEither_ :: Async a -> Async b -> IO () -waitEither_ left right = - atomically $ +waitEither_ left right = atomically (waitEitherSTM_ left right) + +-- | A version of 'waitEither_' that can be used inside an STM transaction. +-- +-- @since 2.1.0 +waitEitherSTM_:: Async a -> Async b -> STM () +waitEitherSTM_ left right = (void $ waitSTM left) `orElse` (void $ waitSTM right) @@ -399,9 +444,15 @@ -- an exception before they have both finished, then the exception is -- re-thrown by 'waitBoth'. -- +{-# INLINE waitBoth #-} waitBoth :: Async a -> Async b -> IO (a,b) -waitBoth left right = - atomically $ do +waitBoth left right = atomically (waitBothSTM left right) + +-- | A version of 'waitBoth' that can be used inside an STM transaction. +-- +-- @since 2.1.0 +waitBothSTM :: Async a -> Async b -> STM (a,b) +waitBothSTM left right = do a <- waitSTM left `orElse` (waitSTM right >> retry) @@ -519,7 +570,9 @@ `catchAll` (putMVar done . Left) rid <- forkIO $ restore (right >>= putMVar done . Right . Right) `catchAll` (putMVar done . Left) - let stop = killThread lid >> killThread rid + let stop = killThread rid >> killThread lid + -- kill right before left, to match the semantics of + -- the version using withAsync. (#27) r <- restore (collect done) `onException` stop stop return r @@ -538,6 +591,14 @@ mapConcurrently :: Traversable t => (a -> IO b) -> t a -> IO (t b) mapConcurrently f = runConcurrently . traverse (Concurrently . f) +-- | `forConcurrently` is `mapConcurrently` with its arguments flipped +-- +-- > pages <- forConcurrently ["url1", "url2", "url3"] $ \url -> getURL url +-- +-- @since 2.1.0 +forConcurrently :: Traversable t => t a -> (a -> IO b)-> IO (t b) +forConcurrently = flip mapConcurrently + -- ----------------------------------------------------------------------------- -- | A value of type @Concurrently a@ is an @IO@ operation that can be @@ -571,10 +632,23 @@ Concurrently as <|> Concurrently bs = Concurrently $ either id id <$> race as bs -instance Monad Concurrently where - return = pure - Concurrently a >>= f = - Concurrently $ a >>= runConcurrently . f +#if MIN_VERSION_base(4,9,0) +-- | Only defined by @async@ for @base >= 4.9@ +-- +-- @since 2.1.0 +instance Semigroup a => Semigroup (Concurrently a) where + (<>) = liftA2 (<>) + +-- | @since 2.1.0 +instance (Semigroup a, Monoid a) => Monoid (Concurrently a) where + mempty = pure mempty + mappend = (<>) +#else +-- | @since 2.1.0 +instance Monoid a => Monoid (Concurrently a) where + mempty = pure mempty + mappend = liftA2 mappend +#endif -- ---------------------------------------------------------------------------- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/async-2.0.2/async.cabal new/async-2.1.0/async.cabal --- old/async-2.0.2/async.cabal 2014-12-22 12:32:14.000000000 +0100 +++ new/async-2.1.0/async.cabal 2016-01-05 17:42:20.000000000 +0100 @@ -1,4 +1,6 @@ name: async +version: 2.1.0 +-- don't forget to update ./changelog.md! synopsis: Run IO operations asynchronously and wait for their results description: @@ -21,47 +23,7 @@ * The API makes it possible to build a tree of threads that are automatically killed when their parent dies (see 'withAsync'). - . - Changes in 2.0.2: - . - * Add a Monad instance for Concurrently - * Bump base dependency to allow 4.9 - . - Changes in 2.0.1.6: - . - * Add workaround to waitCatch for #14 - . - Changes in 2.0.1.5: - . - * Bump @base@ dependencies for GHC 7.8 - . - Changes in 2.0.1.4: - . - * Bump @base@ dependency of test suite - . - Changes in 2.0.1.3: - . - * Bump @base@ dependency to allow 4.6 - . - Changes in 2.0.1.2: - . - * Bump @stm@ dependency to 2.4 - . - Changes in 2.0.1.1: - . - * Safe Haskell support: @Control.Concurrent.Async@ is now @Trustworthy@ - . - Changes in 2.0.1.0: - . - * Added a @Functor@ instance for @Async@ - . - * Added @asyncBound@, @asyncOn@, @asyncWithUnmask@, @asyncOnWithUnmask@, @withAsyncBound@, @withAsyncOn@, @withAsyncWithUnmask@, @withAsyncOnWithUnmask@. - . - * Added @mapConcurrently@ - . - * Added @Concurrently@ (with @Applicative@ and @Alternative@ instances) -version: 2.0.2 license: BSD3 license-file: LICENSE author: Simon Marlow @@ -69,12 +31,13 @@ copyright: (c) Simon Marlow 2012 category: Concurrency build-type: Simple -cabal-version: >=1.8 +cabal-version: >=1.10 homepage: https://github.com/simonmar/async bug-reports: https://github.com/simonmar/async/issues -tested-with: GHC==7.0.3, GHC==7.2.2, GHC==7.4.1 +tested-with: GHC==7.11.*, GHC==7.10.3, GHC==7.8.4, GHC==7.6.3, GHC==7.4.2, GHC==7.2.2, GHC==7.0.4 extra-source-files: + changelog.md bench/race.hs source-repository head @@ -82,14 +45,19 @@ location: https://github.com/simonmar/async.git library + default-language: Haskell2010 + other-extensions: CPP, MagicHash, RankNTypes, UnboxedTuples + if impl(ghc>=7.1) + other-extensions: Trustworthy exposed-modules: Control.Concurrent.Async - build-depends: base >= 4.3 && < 4.9, stm >= 2.2 && < 2.5 + build-depends: base >= 4.3 && < 4.10, stm >= 2.2 && < 2.5 test-suite test-async + default-language: Haskell2010 type: exitcode-stdio-1.0 hs-source-dirs: test main-is: test-async.hs - build-depends: base >= 4.3 && < 4.9, + build-depends: base >= 4.3 && < 4.10, async, test-framework, test-framework-hunit, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/async-2.0.2/changelog.md new/async-2.1.0/changelog.md --- old/async-2.0.2/changelog.md 1970-01-01 01:00:00.000000000 +0100 +++ new/async-2.1.0/changelog.md 2016-01-05 17:42:20.000000000 +0100 @@ -0,0 +1,45 @@ +## Changes in 2.1.0: + + - Bump base dependency to allow 4.10 + - Remove invalid Monad instance for `Concurrently` + - Add `Monoid` and `Semigroup` instances for `Concurrently` + - Add `forConcurrently` (flipped version of `mapConcurrently`) + - Add STM version of all applicable IO functions: + `waitAnySTM`, `waitAnyCatchSTM`, `waitEitherSTM`, + `waitEitherCatchSTM`, `waitEitherSTM_`, and `waitBothSTM`. + +## Changes in 2.0.2: + + - Add a Monad instance for `Concurrently` + - Bump base dependency to allow 4.9 + +## Changes in 2.0.1.6: + + - Add workaround to waitCatch for #14 + +## Changes in 2.0.1.5: + + - Bump `base` dependencies for GHC 7.8 + +## Changes in 2.0.1.4: + + - Bump `base` dependency of test suite + +## Changes in 2.0.1.3: + + - Bump `base` dependency to allow 4.6 + +## Changes in 2.0.1.2: + + - Bump `stm` dependency to 2.4 + +## Changes in 2.0.1.1: + + - Safe Haskell support: `Control.Concurrent.Async` is now `Trustworthy` + +## Changes in 2.0.1.0: + + - Added a `Functor` instance for `Async` + - Added `asyncBound`, `asyncOn`, `asyncWithUnmask`, `asyncOnWithUnmask`, `withAsyncBound`, `withAsyncOn`, `withAsyncWithUnmask`, `withAsyncOnWithUnmask`. + - Added `mapConcurrently` + - Added `Concurrently` (with `Applicative` and `Alternative` instances)

1 0

commit ghc-aeson for openSUSE:Factory
by root＠hilbert.suse.de 28 Jan '16

28 Jan '16

Hello community, here is the log from the commit of package ghc-aeson for openSUSE:Factory checked in at 2016-01-28 17:23:29 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-aeson (Old) and /work/SRC/openSUSE:Factory/.ghc-aeson.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-aeson" Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-aeson/ghc-aeson.changes 2016-01-08 15:22:37.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.ghc-aeson.new/ghc-aeson.changes 2016-01-28 17:24:27.000000000 +0100 @@ -2,50 +1,0 @@ -Wed Dec 23 15:40:06 UTC 2015 - mimi.vx(a)gmail.com - -- update to 0.10.0.0 -* Performance improvements: - + Direct encoding via the new toEncoding method is over 2x faster than toJSON. - (You must write or code-gen a toEncoding implementation to unlock this speedup. - See below for details.) - + Improved string decoding gives a 12% speed win in parsing string-heavy JSON - payloads (very common). - + Encoding and decoding of time-related types are 10x faster (!!) as a result of - bypassing Data.Time.Format and the arbitrary-precision Integer type. - + When using toEncoding, [Char] can be encoded without a conversion to Text. - This is fast and efficient. - + Parsing into an Object is now 5% faster and more allocation-efficient. -* SUBTLE API CHANGES, READ CAREFULLY: - + With the exception of long-deprecated code, the API changes below should be - upwards compatible from older versions of aeson. If you run into upgrade - problems, please file an issue with details. - + The ToJSON class has a new method, toEncoding, that allows direct encoding - from a Haskell value to a lazy bytestring without construction of an - intermediate Value. - + The performance benefits of direct encoding are significant: more than 2x - faster than before, with less than 1/3 the memory usage. - + To preserve API compatibility across upgrades from older versions of this - library, the default implementation of toEncoding uses toJSON. You will not - see any performance improvement unless you write an implementation of - toEncoding, which can be very simple: - instance ToJSON Coord where - toEncoding = genericToEncoding defaultOptions - (Behind the scenes, the encode function uses toEncoding now, so if you - implement toEncoding for your types, you should see a speedup immediately.) - + If you use Template Haskell or GHC Generics to auto-generate your ToJSON - instances, you'll benefit from fast toEncoding implementations for free! - + When converting from a Value to a target Haskell type, FromJSON instances now - provide much better error messages, including a complete JSON path from the - root of the object to the offending element. This greatly eases debugging. - + It is now possible to use Template Haskell to generate FromJSON and ToJSON - instances for types in data families. - + If you use Template Haskell or generics, and used to use the camelTo function - to rename fields, the new camelTo2 function is smarter. For example, camelTo - will rename CamelAPICase to camelapi_case (ugh!), while camelTo2 will map - it to camel_api_case (yay!). - + New ToJSON and FromJSON instances for the following time-related types: Day, - LocalTime. - + The Result type is now an instance of Foldable and Traversable. - + The Data.Aeson.Generic module has been removed. It was deprecated in late 2013. - + The instance of Monad for the Result type lacked an implementation of fail - (oops). This has been corrected. - -------------------------------------------------------------------- Old: ---- aeson-0.10.0.0.tar.gz New: ---- aeson-0.9.0.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-aeson.spec ++++++ --- /var/tmp/diff_new_pack.9IKUB4/_old 2016-01-28 17:24:28.000000000 +0100 +++ /var/tmp/diff_new_pack.9IKUB4/_new 2016-01-28 17:24:28.000000000 +0100 @@ -20,8 +20,8 @@ %bcond_with tests -Name: ghc-aeson -Version: 0.10.0.0 +Name: ghc-%{pkg_name} +Version: 0.9.0.1 Release: 0 Summary: Fast JSON parsing and encoding License: BSD-3-Clause @@ -41,6 +41,7 @@ BuildRequires: ghc-dlist-devel BuildRequires: ghc-hashable-devel BuildRequires: ghc-mtl-devel +BuildRequires: ghc-old-locale-devel BuildRequires: ghc-scientific-devel BuildRequires: ghc-syb-devel BuildRequires: ghc-template-haskell-devel ++++++ aeson-0.10.0.0.tar.gz -> aeson-0.9.0.1.tar.gz ++++++ ++++ 12680 lines of diff (skipped)

1 0

commit python-dfVFS for openSUSE:Factory
by root＠hilbert.suse.de 28 Jan '16

28 Jan '16

Hello community, here is the log from the commit of package python-dfVFS for openSUSE:Factory checked in at 2016-01-28 17:23:27 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-dfVFS (Old) and /work/SRC/openSUSE:Factory/.python-dfVFS.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "python-dfVFS" Changes: -------- --- /work/SRC/openSUSE:Factory/python-dfVFS/python-dfVFS.changes 2015-08-21 12:43:03.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.python-dfVFS.new/python-dfVFS.changes 2016-01-28 17:24:24.000000000 +0100 @@ -1,0 +2,9 @@ +Wed Dec 2 21:00:42 UTC 2015 - Greg.Freemyer(a)gmail.com + +- update to v0~20160108 + * still pre-release and no ChangeLog available + * required by plaso v1.4.0 which is in feature freeze at this point +- update pyvshadow requires to version v0~20160110 +- add Requires: pyfsntfs + +------------------------------------------------------------------- Old: ---- dfvfs-20150708.tar.gz New: ---- dfvfs-20160108.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-dfVFS.spec ++++++ --- /var/tmp/diff_new_pack.A9WWUQ/_old 2016-01-28 17:24:27.000000000 +0100 +++ /var/tmp/diff_new_pack.A9WWUQ/_new 2016-01-28 17:24:27.000000000 +0100 @@ -1,7 +1,7 @@ # # spec file for package python-dfVFS # -# Copyright (c) 2015 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -16,7 +16,7 @@ # -%define timestamp 20150708 +%define timestamp 20160108 Name: python-dfVFS Version: 0~%{timestamp} Release: 0 @@ -31,6 +31,7 @@ BuildRequires: python-setuptools Requires: pybde Requires: pyewf +Requires: pyfsntfs Requires: pyqcow Requires: pysigscan Requires: pysmdev @@ -41,7 +42,7 @@ Requires: pytsk Requires: pyvhdi Requires: pyvmdk -Requires: pyvshadow +Requires: pyvshadow >= 0~20160110 BuildRoot: %{_tmppath}/%{name}-%{version}-build BuildArch: noarch ++++++ dfvfs-20150708.tar.gz -> dfvfs-20160108.tar.gz ++++++ /work/SRC/openSUSE:Factory/python-dfVFS/dfvfs-20150708.tar.gz /work/SRC/openSUSE:Factory/.python-dfVFS.new/dfvfs-20160108.tar.gz differ: char 5, line 1

1 0