Hello community, here is the log from the commit of package ghc-list-t for openSUSE:Factory checked in at 2016-10-22 13:20:26 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-list-t (Old) and /work/SRC/openSUSE:Factory/.ghc-list-t.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-list-t" Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-list-t/ghc-list-t.changes 2016-07-20 09:23:35.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-list-t.new/ghc-list-t.changes 2016-10-22 13:20:28.000000000 +0200 @@ -1,0 +2,5 @@ +Thu Sep 15 06:54:59 UTC 2016 - [email protected] + +- Update to version 1 revision 0 with cabal2obs. + +------------------------------------------------------------------- Old: ---- list-t-0.4.7.tar.gz New: ---- list-t-1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-list-t.spec ++++++ --- /var/tmp/diff_new_pack.LssDu0/_old 2016-10-22 13:20:29.000000000 +0200 +++ /var/tmp/diff_new_pack.LssDu0/_new 2016-10-22 13:20:29.000000000 +0200 @@ -19,15 +19,14 @@ %global pkg_name list-t %bcond_with tests Name: ghc-%{pkg_name} -Version: 0.4.7 +Version: 1 Release: 0 Summary: ListT done right License: MIT -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-base-prelude-devel BuildRequires: ghc-mmorph-devel BuildRequires: ghc-monad-control-devel @@ -40,7 +39,6 @@ BuildRequires: ghc-HTF-devel BuildRequires: ghc-mtl-prelude-devel %endif -# End cabal-rpm deps %description A correct implementation of the list monad-transformer. Useful for basic @@ -60,20 +58,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 ++++++ list-t-0.4.7.tar.gz -> list-t-1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/list-t-0.4.7/library/ListT.hs new/list-t-1/library/ListT.hs --- old/list-t-0.4.7/library/ListT.hs 2016-05-23 15:29:28.000000000 +0200 +++ new/list-t-1/library/ListT.hs 2016-08-11 23:50:07.000000000 +0200 @@ -1,11 +1,9 @@ -{-# LANGUAGE UndecidableInstances, CPP #-} +{-# LANGUAGE UndecidableInstances #-} module ListT ( - ListT, - -- * Classes - MonadTransUncons(..), - MonadCons(..), + ListT(..), -- * Execution utilities + uncons, head, tail, null, @@ -16,6 +14,7 @@ traverse_, splitAt, -- * Construction utilities + cons, fromFoldable, fromMVar, unfold, @@ -25,16 +24,12 @@ -- | -- These utilities only accumulate the transformations -- without actually traversing the stream. - -- They only get applied with a single traversal, - -- which happens at the execution. - Transformation, + -- They only get applied in a single traversal, + -- which only happens at the execution. traverse, take, drop, slice, - -- * Positive numbers - Positive, - positive, ) where @@ -57,7 +52,7 @@ -- <http://hackage.haskell.org/package/monadplus "monadplus"> -- with it. newtype ListT m a = - ListT { unListT :: m (Maybe (a, ListT m a)) } + ListT (m (Maybe (a, ListT m a))) instance Monad m => Monoid (ListT m a) where mempty = @@ -74,7 +69,7 @@ instance Functor m => Functor (ListT m) where fmap f = - ListT . (fmap . fmap) (f *** fmap f) . unListT + ListT . (fmap . fmap) (f *** fmap f) . uncons instance (Monad m, Functor m) => Applicative (ListT m) where pure = @@ -116,7 +111,7 @@ instance MFunctor ListT where hoist f = - ListT . f . (liftM . fmap) (id *** hoist f) . unListT + ListT . f . (liftM . fmap) (id *** hoist f) . uncons instance MMonad ListT where embed f (ListT m) = @@ -128,7 +123,6 @@ liftBase = lift . liftBase -#if MIN_VERSION_monad_control(1,0,0) instance MonadBaseControl b m => MonadBaseControl b (ListT m) where type StM (ListT m) a = StM m (Maybe (a, ListT m a)) @@ -139,93 +133,55 @@ lift (restoreM inner) >>= \case Nothing -> mzero Just (h, t) -> cons h t -#else -instance MonadBaseControl b m => MonadBaseControl b (ListT m) where - newtype StM (ListT m) a = - StM (StM m (Maybe (a, ListT m a))) - liftBaseWith runToBase = - lift $ liftBaseWith $ \runInner -> - runToBase $ liftM StM . runInner . uncons - restoreM (StM inner) = - lift (restoreM inner) >>= \case - Nothing -> mzero - Just (h, t) -> cons h t -#endif instance MonadError e m => MonadError e (ListT m) where throwError = ListT . throwError - catchError m handler = ListT $ catchError (unListT m) $ unListT . handler - --- * Classes -------------------------- - --- | --- A monad transformer capable of deconstructing like a list. -class MonadTrans t => MonadTransUncons t where - -- | - -- Execute in the inner monad, - -- getting the head and the tail. - -- Returns nothing if it's empty. - uncons :: Monad m => t m a -> m (Maybe (a, t m a)) - -instance MonadTransUncons ListT where - {-# INLINE uncons #-} - uncons (ListT m) = m - - --- | --- A monad capable of constructing like a list. -class MonadPlus m => MonadCons m where - -- | - -- Prepend an element. - cons :: a -> m a -> m a - -instance MonadCons [] where - cons a m = a : m - -instance Monad m => MonadCons (ListT m) where - {-# INLINABLE cons #-} - cons h t = ListT $ return (Just (h, t)) - -instance MonadCons m => MonadCons (ReaderT e m) where - cons a m = ReaderT $ cons a . runReaderT m + catchError m handler = ListT $ catchError (uncons m) $ uncons . handler -- * Execution in the inner monad ------------------------- -- | +-- Execute in the inner monad, +-- getting the head and the tail. +-- Returns nothing if it's empty. +uncons :: ListT m a -> m (Maybe (a, ListT m a)) +uncons (ListT m) = + m + +-- | -- Execute, getting the head. Returns nothing if it's empty. {-# INLINABLE head #-} -head :: (Monad m, MonadTransUncons t) => t m a -> m (Maybe a) +head :: Monad m => ListT m a -> m (Maybe a) head = liftM (fmap fst) . uncons -- | -- Execute, getting the tail. Returns nothing if it's empty. {-# INLINABLE tail #-} -tail :: (Monad m, MonadTransUncons t) => t m a -> m (Maybe (t m a)) +tail :: Monad m => ListT m a -> m (Maybe (ListT m a)) tail = liftM (fmap snd) . uncons -- | -- Execute, checking whether it's empty. {-# INLINABLE null #-} -null :: (Monad m, MonadTransUncons t) => t m a -> m Bool +null :: Monad m => ListT m a -> m Bool null = liftM (maybe True (const False)) . uncons -- | -- Execute, applying a left fold. {-# INLINABLE fold #-} -fold :: (Monad m, MonadTransUncons t) => (r -> a -> m r) -> r -> t m a -> m r +fold :: Monad m => (r -> a -> m r) -> r -> ListT m a -> m r fold s r = uncons >=> maybe (return r) (\(h, t) -> s r h >>= \r' -> fold s r' t) -- | -- A version of 'fold', which allows early termination. {-# INLINABLE foldMaybe #-} -foldMaybe :: (Monad m, MonadTransUncons t) => (r -> a -> m (Maybe r)) -> r -> t m a -> m r +foldMaybe :: Monad m => (r -> a -> m (Maybe r)) -> r -> ListT m a -> m r foldMaybe s r l = liftM (maybe r id) $ runMaybeT $ do (h, t) <- MaybeT $ uncons l @@ -235,29 +191,29 @@ -- | -- Execute, folding to a list. {-# INLINABLE toList #-} -toList :: (Monad m, MonadTransUncons t) => t m a -> m [a] +toList :: Monad m => ListT m a -> m [a] toList = liftM ($ []) . fold (\f e -> return $ f . (e :)) id -- | --- Execute, folding to a list in a reverse order. +-- Execute, folding to a list in the reverse order. -- Performs more efficiently than 'toList'. {-# INLINABLE toReverseList #-} -toReverseList :: (Monad m, MonadTransUncons t) => t m a -> m [a] +toReverseList :: Monad m => ListT m a -> m [a] toReverseList = ListT.fold (\l -> return . (:l)) [] -- | -- Execute, traversing the stream with a side effect in the inner monad. {-# INLINABLE traverse_ #-} -traverse_ :: (Monad m, MonadTransUncons t) => (a -> m ()) -> t m a -> m () +traverse_ :: Monad m => (a -> m ()) -> ListT m a -> m () traverse_ f = fold (const f) () -- | -- Execute, consuming a list of the specified length and returning the remainder stream. {-# INLINABLE splitAt #-} -splitAt :: (Monad m, MonadTransUncons t, MonadPlus (t m)) => Int -> t m a -> m ([a], t m a) +splitAt :: Monad m => Int -> ListT m a -> m ([a], ListT m a) splitAt = \case n | n > 0 -> \l -> @@ -274,32 +230,38 @@ ------------------------- -- | +-- Prepend an element. +cons :: Monad m => a -> ListT m a -> ListT m a +cons h t = + ListT $ return (Just (h, t)) + +-- | -- Construct from any foldable. {-# INLINABLE fromFoldable #-} -fromFoldable :: (MonadCons m, Foldable f) => f a -> m a +fromFoldable :: (Monad m, Foldable f) => f a -> ListT m a fromFoldable = foldr cons mzero -- | --- Construct from an MVar, interpreting a value of Nothing as an end. -fromMVar :: (MonadCons m, MonadIO m) => MVar (Maybe a) -> m a +-- Construct from an MVar, interpreting the value of Nothing as the end. +fromMVar :: (MonadIO m) => MVar (Maybe a) -> ListT m a fromMVar v = fix $ \loop -> liftIO (takeMVar v) >>= maybe mzero (flip cons loop) -- | -- Construct by unfolding a pure data structure. {-# INLINABLE unfold #-} -unfold :: (MonadCons m) => (b -> Maybe (a, b)) -> b -> m a +unfold :: Monad m => (b -> Maybe (a, b)) -> b -> ListT m a unfold f s = maybe mzero (\(h, t) -> cons h (unfold f t)) (f s) -- | -- Construct by unfolding a monadic data structure -- --- This is the most memory-efficient way to construct a ListT where +-- This is the most memory-efficient way to construct ListT where -- the length depends on the inner monad. {-# INLINABLE unfoldM #-} -unfoldM :: (Monad m) => (b -> m (Maybe (a, b))) -> b -> ListT m a +unfoldM :: Monad m => (b -> m (Maybe (a, b))) -> b -> ListT m a unfoldM f = go where go s = ListT $ f s >>= \case Nothing -> return Nothing @@ -308,7 +270,7 @@ -- | -- Produce an infinite stream. {-# INLINABLE repeat #-} -repeat :: (MonadCons m) => a -> m a +repeat :: Monad m => a -> ListT m a repeat = fix . cons @@ -317,19 +279,10 @@ ------------------------- -- | --- A function, which updates the contents of a list transformer. --- --- Since it's merely just a function, --- you can run it by passing a list transformer as an argument. -type Transformation m a b = - forall t. (Monad m, MonadCons (t m), MonadTransUncons t) => - t m a -> t m b - --- | -- A transformation, -- which traverses the stream with an action in the inner monad. {-# INLINABLE traverse #-} -traverse :: (a -> m b) -> Transformation m a b +traverse :: Monad m => (a -> m b) -> ListT m a -> ListT m b traverse f s = lift (uncons s) >>= mapM (\(h, t) -> lift (f h) >>= \h' -> cons h' (traverse f t)) >>= @@ -339,7 +292,7 @@ -- A transformation, -- reproducing the behaviour of @Data.List.'Data.List.take'@. {-# INLINABLE take #-} -take :: Int -> Transformation m a a +take :: Monad m => Int -> ListT m a -> ListT m a take = \case n | n > 0 -> \t -> @@ -354,7 +307,7 @@ -- A transformation, -- reproducing the behaviour of @Data.List.'Data.List.drop'@. {-# INLINABLE drop #-} -drop :: Int -> Transformation m a a +drop :: Monad m => Int -> ListT m a -> ListT m a drop = \case n | n > 0 -> @@ -366,30 +319,11 @@ -- A transformation, -- which slices a list into chunks of the specified length. {-# INLINABLE slice #-} -slice :: Positive Int -> Transformation m a [a] +slice :: Monad m => Int -> ListT m a -> ListT m [a] slice n l = do - (h, t) <- lift $ splitAt (case n of Positive n -> n) l + (h, t) <- lift $ splitAt n l case h of [] -> mzero _ -> cons h (slice n t) - --- * Positive numbers -------------------------- - --- | --- A newtype wrapper around a number, --- which ensures that it is greater than zero. -newtype Positive n = - Positive n - deriving (Show, Read, Eq, Ord, Typeable, Data, Generic) - --- | --- A smart constructor for positive numbers. -positive :: (Ord n, Num n) => n -> Maybe (Positive n) -positive = - \case - n | n > 0 -> Just $ Positive n - _ -> Nothing - diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/list-t-0.4.7/list-t.cabal new/list-t-1/list-t.cabal --- old/list-t-0.4.7/list-t.cabal 2016-05-23 15:29:28.000000000 +0200 +++ new/list-t-1/list-t.cabal 2016-08-11 23:50:07.000000000 +0200 @@ -1,7 +1,7 @@ name: list-t version: - 0.4.7 + 1 synopsis: ListT done right description: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/list-t-0.4.7/tests/Main.hs new/list-t-1/tests/Main.hs --- old/list-t-0.4.7/tests/Main.hs 2016-05-23 15:29:28.000000000 +0200 +++ new/list-t-1/tests/Main.hs 2016-08-11 23:50:07.000000000 +0200 @@ -145,7 +145,7 @@ test_slice = assertEqual ["abc", "def", "gh"] =<< do - toList $ L.slice (fromJust $ L.positive 3) $ L.fromFoldable ("abcdefgh" :: [Char]) + toList $ L.slice 3 $ L.fromFoldable ("abcdefgh" :: [Char]) toList :: Monad m => L.ListT m a -> m [a]
