Hello community,
here is the log from the commit of package ghc-async-dejafu for
openSUSE:Factory checked in at 2017-04-20 20:55:39
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/ghc-async-dejafu (Old)
and /work/SRC/openSUSE:Factory/.ghc-async-dejafu.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-async-dejafu"
Thu Apr 20 20:55:39 2017 rev:2 rq:487957 version:0.1.3.0
Changes:
--------
--- /work/SRC/openSUSE:Factory/ghc-async-dejafu/ghc-async-dejafu.changes
2017-04-07 13:53:09.316761688 +0200
+++ /work/SRC/openSUSE:Factory/.ghc-async-dejafu.new/ghc-async-dejafu.changes
2017-04-20 20:55:39.975949620 +0200
@@ -1,0 +2,5 @@
+Thu Sep 15 07:01:42 UTC 2016 - psim...@suse.com
+
+- Update to version 0.1.3.0 revision 0 with cabal2obs.
+
+-------------------------------------------------------------------
Old:
----
async-dejafu-0.1.2.2.tar.gz
New:
----
async-dejafu-0.1.3.0.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ ghc-async-dejafu.spec ++++++
--- /var/tmp/diff_new_pack.SLbJVH/_old 2017-04-20 20:55:40.807831980 +0200
+++ /var/tmp/diff_new_pack.SLbJVH/_new 2017-04-20 20:55:40.807831980 +0200
@@ -1,7 +1,7 @@
#
# spec file for package ghc-async-dejafu
#
-# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2017 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
@@ -19,32 +19,34 @@
%global pkg_name async-dejafu
%bcond_with tests
Name: ghc-%{pkg_name}
-Version: 0.1.2.2
+Version: 0.1.3.0
Release: 0
Summary: Run MonadConc operations asynchronously and wait for their
results
License: BSD-3-Clause
-Group: System/Libraries
+Group: Development/Languages/Other
Url: https://hackage.haskell.org/package/%{pkg_name}
Source0:
https://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{version}.tar.gz
BuildRequires: ghc-Cabal-devel
-# Begin cabal-rpm deps:
-BuildRequires: ghc-dejafu-devel
+BuildRequires: ghc-concurrency-devel
BuildRequires: ghc-exceptions-devel
BuildRequires: ghc-rpm-macros
BuildRoot: %{_tmppath}/%{name}-%{version}-build
%if %{with tests}
BuildRequires: ghc-HUnit-devel
+BuildRequires: ghc-dejafu-devel
BuildRequires: ghc-hunit-dejafu-devel
%endif
-# End cabal-rpm deps
%description
The <https://hackage.haskell.org/package/async async> library provides a
higher-level interface over threads, allowing users to conveniently run IO
operations asynchronously and wait for their results. This package is a
reimplementation of async using the 'MonadConc' abstraction from
-<https://hackage.haskell.org/package/dejafu dejafu>, providing easy-to-use
-asynchronous operaitons within an easily-testable framework.
+<https://hackage.haskell.org/package/concurrency concurrency>, providing
+easy-to-use asynchronous operaitons within an easily-testable framework.
+
+This library itself is tested with <https://hackage.haskell.org/package/dejafu
+dejafu>.
When these functions are used in an IO context, the behaviour should appear
identical to the original async package.
@@ -63,20 +65,14 @@
%prep
%setup -q -n %{pkg_name}-%{version}
-
%build
%ghc_lib_build
-
%install
%ghc_lib_install
-
%check
-%if %{with tests}
-%{cabal} test
-%endif
-
+%cabal_test
%post devel
%ghc_pkg_recache
++++++ async-dejafu-0.1.2.2.tar.gz -> async-dejafu-0.1.3.0.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/async-dejafu-0.1.2.2/Control/Concurrent/Async.hs
new/async-dejafu-0.1.3.0/Control/Concurrent/Async.hs
--- old/async-dejafu-0.1.2.2/Control/Concurrent/Async.hs 2016-05-03
00:25:35.000000000 +0200
+++ new/async-dejafu-0.1.3.0/Control/Concurrent/Async.hs 2016-08-28
15:57:25.000000000 +0200
@@ -78,47 +78,17 @@
) where
import Control.Applicative
+import Control.Concurrent.Classy.STM.TMVar (newEmptyTMVar, putTMVar, readTMVar)
import Control.Exception (AsyncException(ThreadKilled),
BlockedIndefinitelyOnSTM(..), Exception, SomeException)
import Control.Monad
import Control.Monad.Catch (finally, try, onException)
import Control.Monad.Conc.Class
import Control.Monad.STM.Class
-#if MIN_VERSION_dejafu(0,3,0)
-import Control.Concurrent.Classy.STM.TMVar (newEmptyTMVar, putTMVar, readTMVar)
-#else
-import Control.Concurrent.STM.CTMVar (CTMVar, newEmptyCTMVar, putCTMVar,
readCTMVar)
-#endif
-
#if !MIN_VERSION_base(4,8,0)
import Data.Traversable
#endif
-#if !MIN_VERSION_dejafu(0,3,0)
-type MVar m = CVar m
-
-newEmptyMVar :: MonadConc m => m (MVar m a)
-newEmptyMVar = newEmptyCVar
-
-putMVar :: MonadConc m => MVar m a -> a -> m ()
-putMVar = putCVar
-
-takeMVar :: MonadConc m => MVar m a -> m a
-takeMVar = takeCVar
-
-type STM m = STMLike m
-type TMVar m = CTMVar m
-
-newEmptyTMVar :: MonadSTM stm => stm (TMVar stm a)
-newEmptyTMVar = newEmptyCTMVar
-
-putTMVar :: MonadSTM stm => TMVar stm a -> a -> stm ()
-putTMVar = putCTMVar
-
-readTMVar :: MonadSTM stm => TMVar stm a -> stm a
-readTMVar = readCTMVar
-#endif
-
-----------------------------------------------------------------------------------------
-- Asynchronous and Concurrent Actions
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/async-dejafu-0.1.2.2/async-dejafu.cabal
new/async-dejafu-0.1.3.0/async-dejafu.cabal
--- old/async-dejafu-0.1.2.2/async-dejafu.cabal 2016-05-26 13:31:13.000000000
+0200
+++ new/async-dejafu-0.1.3.0/async-dejafu.cabal 2016-08-28 15:57:25.000000000
+0200
@@ -2,7 +2,7 @@
-- documentation, see http://haskell.org/cabal/users-guide/
name: async-dejafu
-version: 0.1.2.2
+version: 0.1.3.0
synopsis: Run MonadConc operations asynchronously and wait for
their results.
description:
@@ -11,10 +11,13 @@
conveniently run IO operations asynchronously and wait for their
results. This package is a reimplementation of async using the
@MonadConc@ abstraction from
- <https://hackage.haskell.org/package/dejafu dejafu>, providing
+ <https://hackage.haskell.org/package/concurrency concurrency>, providing
easy-to-use asynchronous operaitons within an easily-testable
framework.
.
+ This library itself is tested with
+ <https://hackage.haskell.org/package/dejafu dejafu>.
+ .
When these functions are used in an IO context, the behaviour should
appear identical to the original async package.
@@ -37,15 +40,15 @@
source-repository this
type: git
location: https://github.com/barrucadu/dejafu.git
- tag: async-dejafu-0.1.2.2
+ tag: async-dejafu-0.1.3.0
library
exposed-modules: Control.Concurrent.Async
-- other-modules:
-- other-extensions:
- build-depends: base >=4.8 && <5
- , dejafu >=0.2 && <0.4
- , exceptions >=0.7 && <0.9
+ build-depends: base >=4.8 && <5
+ , concurrency >=1 && <2
+ , exceptions >=0.7 && <0.9
-- hs-source-dirs:
default-language: Haskell2010
ghc-options: -Wall
@@ -54,5 +57,5 @@
hs-source-dirs: tests
type: exitcode-stdio-1.0
main-is: Main.hs
- build-depends: base, async-dejafu, dejafu, HUnit, hunit-dejafu
+ build-depends: base, async-dejafu, concurrency, dejafu>=0.4, HUnit,
hunit-dejafu
default-language: Haskell2010
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/async-dejafu-0.1.2.2/tests/Main.hs
new/async-dejafu-0.1.3.0/tests/Main.hs
--- old/async-dejafu-0.1.2.2/tests/Main.hs 2016-05-21 01:01:15.000000000
+0200
+++ new/async-dejafu-0.1.3.0/tests/Main.hs 2016-08-28 15:57:25.000000000
+0200
@@ -1,4 +1,3 @@
-{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE LambdaCase #-}
@@ -15,16 +14,6 @@
import Test.HUnit (Test(..), runTestTT, test)
import Test.HUnit.DejaFu
-#if !MIN_VERSION_dejafu(0,3,0)
-type MVar m = CVar m
-
-newEmptyMVar :: MonadConc m => m (MVar m a)
-newEmptyMVar = newEmptyCVar
-
-takeMVar :: MonadConc m => MVar m a -> m a
-takeMVar = takeCVar
-#endif
-
main :: IO ()
main = void . runTestTT $ TestList
[ TestLabel "async" $ test
@@ -111,8 +100,7 @@
withasync_waitCatch_blocked :: MonadConc m => m (Maybe
BlockedIndefinitelyOnMVar)
withasync_waitCatch_blocked = do
- _concAllKnown
- r <- withAsync (_concAllKnown >> newEmptyMVar >>= takeMVar) waitCatch
+ r <- withAsync (newEmptyMVar >>= takeMVar) waitCatch
return $ case r of
Left e -> fromException e
_ -> Nothing
