openSUSE Commits
Threads by month
- ----- 2024 -----
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2023 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2022 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2021 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2020 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2019 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2018 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2017 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2016 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2015 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2014 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2013 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2012 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2011 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2010 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2009 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2008 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2007 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2006 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
January 2016
- 1 participants
- 1523 discussions
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
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
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
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
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
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
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
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
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
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