Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package ghc-extra for openSUSE:Factory checked in at 2025-12-05 16:55:48 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-extra (Old) and /work/SRC/openSUSE:Factory/.ghc-extra.new.1939 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-extra" Fri Dec 5 16:55:48 2025 rev:39 rq:1321134 version:1.8.1 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-extra/ghc-extra.changes 2024-12-20 23:12:26.196965397 +0100 +++ /work/SRC/openSUSE:Factory/.ghc-extra.new.1939/ghc-extra.changes 2025-12-05 16:56:18.119545470 +0100 @@ -1,0 +2,8 @@ +Sun Nov 23 14:32:04 UTC 2025 - Peter Simons <[email protected]> + +- Update extra to version 1.8.1. + 1.8.1, released 2025-11-23 + #118, future proof for GHC 9.16 gaining nubOrd and nubOrdBy + Test with GHC 9.12 + +------------------------------------------------------------------- Old: ---- extra-1.8.tar.gz New: ---- extra-1.8.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-extra.spec ++++++ --- /var/tmp/diff_new_pack.wRWmu6/_old 2025-12-05 16:56:18.675568716 +0100 +++ /var/tmp/diff_new_pack.wRWmu6/_new 2025-12-05 16:56:18.679568884 +0100 @@ -1,7 +1,7 @@ # # spec file for package ghc-extra # -# Copyright (c) 2024 SUSE LLC +# Copyright (c) 2025 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -20,7 +20,7 @@ %global pkgver %{pkg_name}-%{version} %bcond_with tests Name: ghc-%{pkg_name} -Version: 1.8 +Version: 1.8.1 Release: 0 Summary: Extra functions I use License: BSD-3-Clause ++++++ extra-1.8.tar.gz -> extra-1.8.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/extra-1.8/CHANGES.txt new/extra-1.8.1/CHANGES.txt --- old/extra-1.8/CHANGES.txt 2001-09-09 03:46:40.000000000 +0200 +++ new/extra-1.8.1/CHANGES.txt 2001-09-09 03:46:40.000000000 +0200 @@ -1,5 +1,8 @@ Changelog for Extra (* = breaking change) +1.8.1, released 2025-11-23 + #118, future proof for GHC 9.16 gaining nubOrd and nubOrdBy + Test with GHC 9.12 1.8, released 2024-10-19 #109, add guarded to lift predicates into Alternatives * #112, make Data.List.Extra.compareLength work on list/int only diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/extra-1.8/LICENSE new/extra-1.8.1/LICENSE --- old/extra-1.8/LICENSE 2001-09-09 03:46:40.000000000 +0200 +++ new/extra-1.8.1/LICENSE 2001-09-09 03:46:40.000000000 +0200 @@ -1,4 +1,4 @@ -Copyright Neil Mitchell 2014-2024. +Copyright Neil Mitchell 2014-2025. All rights reserved. Redistribution and use in source and binary forms, with or without diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/extra-1.8/extra.cabal new/extra-1.8.1/extra.cabal --- old/extra-1.8/extra.cabal 2001-09-09 03:46:40.000000000 +0200 +++ new/extra-1.8.1/extra.cabal 2001-09-09 03:46:40.000000000 +0200 @@ -1,13 +1,13 @@ cabal-version: 1.18 build-type: Simple name: extra -version: 1.8 +version: 1.8.1 license: BSD3 license-file: LICENSE category: Development author: Neil Mitchell <[email protected]> maintainer: Neil Mitchell <[email protected]> -copyright: Neil Mitchell 2014-2024 +copyright: Neil Mitchell 2014-2025 synopsis: Extra functions I use. description: A library of extra functions for the standard Haskell libraries. Most functions are simple additions, filling out missing functionality. A few functions are available in later versions of GHC, but this package makes them available back to GHC 7.2. @@ -15,7 +15,7 @@ The module "Extra" documents all functions provided by this library. Modules such as "Data.List.Extra" provide extra functions over "Data.List" and also reexport "Data.List". Users are recommended to replace "Data.List" imports with "Data.List.Extra" if they need the extra functionality. homepage: https://github.com/ndmitchell/extra#readme bug-reports: https://github.com/ndmitchell/extra/issues -tested-with: GHC==9.10, GHC==9.8, GHC==9.6, GHC==9.4, GHC==9.2, GHC==9.0, GHC==8.10, GHC==8.8 +tested-with: GHC==9.12, GHC==9.10, GHC==9.8, GHC==9.6, GHC==9.4, GHC==9.2, GHC==9.0, GHC==8.10, GHC==8.8 extra-doc-files: CHANGES.txt diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/extra-1.8/src/Control/Monad/Extra.hs new/extra-1.8.1/src/Control/Monad/Extra.hs --- old/extra-1.8/src/Control/Monad/Extra.hs 2001-09-09 03:46:40.000000000 +0200 +++ new/extra-1.8.1/src/Control/Monad/Extra.hs 2001-09-09 03:46:40.000000000 +0200 @@ -35,10 +35,12 @@ -- -- > whenJust Nothing print == pure () -- > whenJust (Just 1) print == print 1 +{-# INLINABLE whenJust #-} whenJust :: Applicative m => Maybe a -> (a -> m ()) -> m () whenJust mg f = maybe (pure ()) f mg -- | Like 'whenJust', but where the test can be monadic. +{-# INLINABLE whenJustM #-} whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m () -- Can't reuse whenMaybe on GHC 7.8 or lower because Monad does not imply Applicative whenJustM mg f = maybeM (pure ()) f mg @@ -49,6 +51,7 @@ -- > pureIf @Maybe False 5 == Nothing -- > pureIf @[] True 5 == [5] -- > pureIf @[] False 5 == [] +{-# INLINABLE pureIf #-} pureIf :: (Alternative m) => Bool -> a -> m a pureIf b a = if b then pure a else empty @@ -57,10 +60,12 @@ -- -- > whenMaybe True (print 1) == fmap Just (print 1) -- > whenMaybe False (print 1) == pure Nothing +{-# INLINABLE whenMaybe #-} whenMaybe :: Applicative m => Bool -> m a -> m (Maybe a) whenMaybe b x = if b then Just <$> x else pure Nothing -- | Like 'whenMaybe', but where the test can be monadic. +{-# INLINABLE whenMaybeM #-} whenMaybeM :: Monad m => m Bool -> m a -> m (Maybe a) -- Can't reuse whenMaybe on GHC 7.8 or lower because Monad does not imply Applicative whenMaybeM mb x = do @@ -71,21 +76,25 @@ -- with overloaded return types. -- -- > \(x :: Maybe ()) -> unit x == x +{-# INLINABLE unit #-} unit :: m () -> m () unit = id -- | Monadic generalisation of 'maybe'. +{-# INLINABLE maybeM #-} maybeM :: Monad m => m b -> (a -> m b) -> m (Maybe a) -> m b maybeM n j x = maybe n j =<< x -- | Monadic generalisation of 'fromMaybe'. +{-# INLINABLE fromMaybeM #-} fromMaybeM :: Monad m => m a -> m (Maybe a) -> m a fromMaybeM n x = maybeM n pure x -- | Monadic generalisation of 'either'. +{-# INLINABLE eitherM #-} eitherM :: Monad m => (a -> m c) -> (b -> m c) -> m (Either a b) -> m c eitherM l r x = either l r =<< x @@ -95,6 +104,7 @@ -- > guarded even 2 == [2] -- > guarded odd 2 == Nothing -- > guarded (not.null) "My Name" == Just "My Name" +{-# INLINABLE guarded #-} guarded :: Alternative m => (a -> Bool) -> a -> m a guarded pred x = if pred x then pure x else empty @@ -103,6 +113,7 @@ -- > guardedA (return . even) 42 == Just [42] -- > guardedA (return . odd) 42 == Just [] -- > guardedA (const Nothing) 42 == (Nothing :: Maybe [Int]) +{-# INLINABLE guardedA #-} guardedA :: (Functor f, Alternative m) => (a -> f Bool) -> a -> f (m a) guardedA pred x = fmap inner (pred x) where inner b = if b then pure x else empty @@ -111,11 +122,13 @@ -- -- > fold1M (\x y -> Just x) [] == undefined -- > fold1M (\x y -> Just $ x + y) [1, 2, 3] == Just 6 +{-# INLINABLE fold1M #-} fold1M :: (Partial, Monad m) => (a -> a -> m a) -> [a] -> m a fold1M f (x:xs) = foldM f x xs fold1M f xs = error "fold1M: empty list" -- | Like 'fold1M' but discards the result. +{-# INLINABLE fold1M_ #-} fold1M_ :: (Partial, Monad m) => (a -> a -> m a) -> [a] -> m () fold1M_ f xs = fold1M f xs >> pure () @@ -126,6 +139,7 @@ -- -- > partitionM (Just . even) [1,2,3] == Just ([2], [1,3]) -- > partitionM (const Nothing) [1,2,3] == Nothing +{-# INLINABLE partitionM #-} partitionM :: Monad m => (a -> m Bool) -> [a] -> m ([a], [a]) partitionM f [] = pure ([], []) partitionM f (x:xs) = do @@ -142,10 +156,12 @@ -- | Like 'concatMapM', but has its arguments flipped, so can be used -- instead of the common @fmap concat $ forM@ pattern. +{-# INLINABLE concatForM #-} concatForM :: Monad m => [a] -> (a -> m [b]) -> m [b] concatForM = flip concatMapM -- | A version of 'mconcatMap' that works with a monadic predicate. +{-# INLINABLE mconcatMapM #-} mconcatMapM :: (Monad m, Monoid b) => (a -> m b) -> [a] -> m b mconcatMapM f = liftM mconcat . mapM f @@ -161,6 +177,7 @@ -- or 'Right' to abort the loop. -- -- > loop (\x -> if x < 10 then Left $ x * 2 else Right $ show x) 1 == "16" +{-# INLINABLE loop #-} loop :: (a -> Either a b) -> a -> b loop act x = case act x of Left x -> loop act x @@ -168,6 +185,7 @@ -- | A monadic version of 'loop', where the predicate returns 'Left' as a seed for the next loop -- or 'Right' to abort the loop. +{-# INLINABLE loopM #-} loopM :: Monad m => (a -> m (Either a b)) -> a -> m b loopM act x = do res <- act x @@ -183,6 +201,7 @@ -- @ -- -- If you need some state persisted between each test, use 'loopM'. +{-# INLINABLE whileM #-} whileM :: Monad m => m Bool -> m () whileM act = do b <- act @@ -190,6 +209,7 @@ -- | Keep running an operation until it becomes a 'Nothing', accumulating the -- monoid results inside the 'Just's as the result of the overall loop. +{-# INLINABLE whileJustM #-} whileJustM :: (Monad m, Monoid a) => m (Maybe a) -> m a whileJustM act = go mempty where @@ -201,6 +221,7 @@ -- | Keep running an operation until it becomes a 'Just', then return the value -- inside the 'Just' as the result of the overall loop. +{-# INLINABLE untilJustM #-} untilJustM :: Monad m => m (Maybe a) -> m a untilJustM act = do res <- act @@ -211,18 +232,22 @@ -- Booleans -- | Like 'when', but where the test can be monadic. +{-# INLINABLE whenM #-} whenM :: Monad m => m Bool -> m () -> m () whenM b t = ifM b t (pure ()) -- | Like 'unless', but where the test can be monadic. +{-# INLINABLE unlessM #-} unlessM :: Monad m => m Bool -> m () -> m () unlessM b f = ifM b (pure ()) f -- | Like @if@, but where the test can be monadic. +{-# INLINABLE ifM #-} ifM :: Monad m => m Bool -> m a -> m a -> m a ifM b t f = do b <- b; if b then t else f -- | Like 'not', but where the test can be monadic. +{-# INLINABLE notM #-} notM :: Functor m => m Bool -> m Bool notM = fmap not @@ -233,6 +258,7 @@ -- > Just True ||^ undefined == Just True -- > Just False ||^ Just True == Just True -- > Just False ||^ Just False == Just False +{-# INLINABLE (||^) #-} (||^) :: Monad m => m Bool -> m Bool -> m Bool (||^) a b = ifM a (pure True) b @@ -243,6 +269,7 @@ -- > Just False &&^ undefined == Just False -- > Just True &&^ Just True == Just True -- > Just True &&^ Just False == Just False +{-# INLINABLE (&&^) #-} (&&^) :: Monad m => m Bool -> m Bool -> m Bool (&&^) a b = ifM a b (pure False) @@ -251,6 +278,7 @@ -- > anyM Just [False,True ,undefined] == Just True -- > anyM Just [False,False,undefined] == undefined -- > \(f :: Int -> Maybe Bool) xs -> anyM f xs == orM (map f xs) +{-# INLINABLE anyM #-} anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool anyM p = foldr ((||^) . p) (pure False) @@ -259,6 +287,7 @@ -- > allM Just [True,False,undefined] == Just False -- > allM Just [True,True ,undefined] == undefined -- > \(f :: Int -> Maybe Bool) xs -> anyM f xs == orM (map f xs) +{-# INLINABLE allM #-} allM :: Monad m => (a -> m Bool) -> [a] -> m Bool allM p = foldr ((&&^) . p) (pure True) @@ -267,6 +296,7 @@ -- > orM [Just False,Just True ,undefined] == Just True -- > orM [Just False,Just False,undefined] == undefined -- > \xs -> Just (or xs) == orM (map Just xs) +{-# INLINABLE orM #-} orM :: Monad m => [m Bool] -> m Bool orM = anyM id @@ -275,6 +305,7 @@ -- > andM [Just True,Just False,undefined] == Just False -- > andM [Just True,Just True ,undefined] == undefined -- > \xs -> Just (and xs) == andM (map Just xs) +{-# INLINABLE andM #-} andM :: Monad m => [m Bool] -> m Bool andM = allM id @@ -285,10 +316,12 @@ -- > findM (Just . isUpper) "teST" == Just (Just 'S') -- > findM (Just . isUpper) "test" == Just Nothing -- > findM (Just . const True) ["x",undefined] == Just (Just "x") +{-# INLINABLE findM #-} findM :: Monad m => (a -> m Bool) -> [a] -> m (Maybe a) findM p = foldr (\x -> ifM (p x) (pure $ Just x)) (pure Nothing) -- | Like 'findM', but also allows you to compute some additional information in the predicate. +{-# INLINABLE firstJustM #-} firstJustM :: Monad m => (a -> m (Maybe b)) -> [a] -> m (Maybe b) firstJustM p [] = pure Nothing firstJustM p (x:xs) = maybeM (firstJustM p xs) (pure . Just) (p x) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/extra-1.8/src/Data/List/Extra.hs new/extra-1.8.1/src/Data/List/Extra.hs --- old/extra-1.8/src/Data/List/Extra.hs 2001-09-09 03:46:40.000000000 +0200 +++ new/extra-1.8.1/src/Data/List/Extra.hs 2001-09-09 03:46:40.000000000 +0200 @@ -816,6 +816,7 @@ f (x:xs) = x : f xs f [] = [] +#if __GLASGOW_HASKELL__ <= 914 -- | /O(n log n)/. The 'nubOrd' function removes duplicate elements from a list. -- In particular, it keeps only the first occurrence of each element. -- Unlike the standard 'nub' operator, this version requires an 'Ord' instance @@ -826,6 +827,7 @@ -- > \xs -> nubOrd xs == nub xs nubOrd :: Ord a => [a] -> [a] nubOrd = nubOrdBy compare +#endif -- | A version of 'nubOrd' which operates on a portion of the value. -- @@ -833,6 +835,7 @@ nubOrdOn :: Ord b => (a -> b) -> [a] -> [a] nubOrdOn f = map snd . nubOrdBy (compare `on` fst) . map (f &&& id) +#if __GLASGOW_HASKELL__ <= 914 -- | A version of 'nubOrd' with a custom predicate. -- -- > nubOrdBy (compare `on` length) ["a","test","of","this"] == ["a","test","of"] @@ -841,6 +844,7 @@ where f seen [] = [] f seen (x:xs) | memberRB cmp x seen = f seen xs | otherwise = x : f (insertRB cmp x seen) xs +#endif --------------------------------------------------------------------- -- OKASAKI RED BLACK TREE diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/extra-1.8/src/Data/List/NonEmpty/Extra.hs new/extra-1.8.1/src/Data/List/NonEmpty/Extra.hs --- old/extra-1.8/src/Data/List/NonEmpty/Extra.hs 2001-09-09 03:46:40.000000000 +0200 +++ new/extra-1.8.1/src/Data/List/NonEmpty/Extra.hs 2001-09-09 03:46:40.000000000 +0200 @@ -80,18 +80,22 @@ union :: Eq a => NonEmpty a -> NonEmpty a -> NonEmpty a union = unionBy (==) +#if __GLASGOW_HASKELL__ <= 914 -- | @nubOrd@ for 'NonEmpty'. Behaves the same as 'Data.List.Extra.nubOrd'. -- -- > Data.List.NonEmpty.Extra.nubOrd (1 :| [2, 3, 3, 4, 1, 2]) == 1 :| [2, 3, 4] -- > \xs -> Data.List.NonEmpty.Extra.nubOrd xs == Data.List.NonEmpty.Extra.nub xs nubOrd :: Ord a => NonEmpty a -> NonEmpty a nubOrd = nubOrdBy compare +#endif +#if __GLASGOW_HASKELL__ <= 914 -- | @nubOrdBy@ for 'NonEmpty'. Behaves the same as 'Data.List.Extra.nubOrdBy'. -- -- > Data.List.NonEmpty.Extra.nubOrdBy (compare `on` Data.List.length) ("a" :| ["test","of","this"]) == "a" :| ["test","of"] nubOrdBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a nubOrdBy cmp = fromList . List.nubOrdBy cmp . toList +#endif -- | @nubOrdOn@ for 'NonEmpty'. Behaves the same as 'Data.List.Extra.nubOrdOn'. --
