Mailinglist Archive: opensuse-commit (1903 mails)

< Previous Next >
commit ghc-extra for openSUSE:Factory
Hello community,

here is the log from the commit of package ghc-extra for openSUSE:Factory
checked in at 2019-04-28 20:12:35
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/ghc-extra (Old)
and /work/SRC/openSUSE:Factory/.ghc-extra.new.5536 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "ghc-extra"

Sun Apr 28 20:12:35 2019 rev:20 rq:698549 version:1.6.15

Changes:
--------
--- /work/SRC/openSUSE:Factory/ghc-extra/ghc-extra.changes 2018-12-21
08:21:26.117569095 +0100
+++ /work/SRC/openSUSE:Factory/.ghc-extra.new.5536/ghc-extra.changes
2019-04-28 20:12:47.294443281 +0200
@@ -1,0 +2,9 @@
+Tue Apr 23 02:01:56 UTC 2019 - psimons@xxxxxxxx
+
+- Update extra to version 1.6.15.
+ 1.6.15, released 2019-04-22
+ #45, add NonEmpty.Extra for extra appending functions
+ #42, add fromMaybeM
+ Remove support for GHC 7.4, 7.6 and 7.8
+
+-------------------------------------------------------------------

Old:
----
extra-1.6.14.tar.gz

New:
----
extra-1.6.15.tar.gz

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ ghc-extra.spec ++++++
--- /var/tmp/diff_new_pack.IJzstb/_old 2019-04-28 20:12:48.286442665 +0200
+++ /var/tmp/diff_new_pack.IJzstb/_new 2019-04-28 20:12:48.286442665 +0200
@@ -1,7 +1,7 @@
#
# spec file for package ghc-extra
#
-# Copyright (c) 2018 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2019 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,7 +19,7 @@
%global pkg_name extra
%bcond_with tests
Name: ghc-%{pkg_name}
-Version: 1.6.14
+Version: 1.6.15
Release: 0
Summary: Extra functions I use
License: BSD-3-Clause
@@ -32,6 +32,7 @@
BuildRequires: ghc-filepath-devel
BuildRequires: ghc-process-devel
BuildRequires: ghc-rpm-macros
+BuildRequires: ghc-semigroups-devel
BuildRequires: ghc-time-devel
BuildRequires: ghc-unix-devel
%if %{with tests}

++++++ extra-1.6.14.tar.gz -> extra-1.6.15.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/CHANGES.txt new/extra-1.6.15/CHANGES.txt
--- old/extra-1.6.14/CHANGES.txt 2018-12-10 20:24:13.000000000 +0100
+++ new/extra-1.6.15/CHANGES.txt 2019-04-22 20:26:14.000000000 +0200
@@ -1,5 +1,9 @@
Changelog for Extra

+1.6.15, released 2019-04-22
+ #45, add NonEmpty.Extra for extra appending functions
+ #42, add fromMaybeM
+ Remove support for GHC 7.4, 7.6 and 7.8
1.6.14, released 2018-12-10
Add mapLeft and mapRight
1.6.13, released 2018-10-14
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/Generate.hs new/extra-1.6.15/Generate.hs
--- old/extra-1.6.14/Generate.hs 2017-11-24 12:54:00.000000000 +0100
+++ new/extra-1.6.15/Generate.hs 2019-04-22 20:25:59.000000000 +0200
@@ -37,11 +37,11 @@
,"module Extra {-# DEPRECATED \"This module is provided as
documentation of all new functions, you should import the more specific modules
directly.\" #-} ("] ++
concat [ [" -- * " ++ mod
," -- | Extra functions available in @" ++ show mod ++ "@."
- ," " ++ unwords (map (++",") funs)]
- | (mod,funs,_) <- ifaces] ++
+ ," " ++ unwords (map (++",") $ filter (notHidden mod)
funs)]
+ | (mod,funs@(_:_),_) <- ifaces] ++
[" ) where"
,""] ++
- ["import " ++ x | x <- mods]
+ ["import " ++ addHiding mod | (mod,_:_,_) <- ifaces]
writeFileBinaryChanged "test/TestGen.hs" $ unlines $
["-- GENERATED CODE - DO NOT MODIFY"
,"-- See Generate.hs for details of how to generate"
@@ -66,6 +66,17 @@
when (Just x /= old) $
writeFileBinary file x

+hidden :: String -> [String]
+hidden "Data.List.NonEmpty.Extra" = ["cons", "snoc", "sortOn", "union",
"unionBy"]
+hidden _ = []
+
+notHidden :: String -> String -> Bool
+notHidden mod fun = fun `notElem` hidden mod
+
+addHiding :: String -> String
+addHiding mod
+ | xs@(_:_) <- hidden mod = mod ++ " hiding (" ++ intercalate ", " xs ++ ")"
+ | otherwise = mod

validIdentifier xs =
(take 1 xs == "(" || isName (takeWhile (/= '(') xs)) &&
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/LICENSE new/extra-1.6.15/LICENSE
--- old/extra-1.6.14/LICENSE 2018-01-21 17:16:40.000000000 +0100
+++ new/extra-1.6.15/LICENSE 2019-02-25 16:47:08.000000000 +0100
@@ -1,4 +1,4 @@
-Copyright Neil Mitchell 2014-2018.
+Copyright Neil Mitchell 2014-2019.
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.6.14/README.md new/extra-1.6.15/README.md
--- old/extra-1.6.14/README.md 2018-05-21 20:30:10.000000000 +0200
+++ new/extra-1.6.15/README.md 2019-04-22 20:25:59.000000000 +0200
@@ -1,11 +1,11 @@
-# Extra [![Hackage
version](https://img.shields.io/hackage/v/extra.svg?label=Hackage)](https://hackage.haskell.org/package/extra)
[![Stackage
version](https://www.stackage.org/package/extra/badge/nightly?label=Stackage)](https://www.stackage.org/package/extra)
[![Linux Build
Status](https://img.shields.io/travis/ndmitchell/extra/master.svg?label=Linux%20build)](https://travis-ci.org/ndmitchell/extra)
[![Windows Build
Status](https://img.shields.io/appveyor/ci/ndmitchell/extra/master.svg?label=Windows%20build)](https://ci.appveyor.com/project/ndmitchell/extra)
+# Extra [![Hackage
version](https://img.shields.io/hackage/v/extra.svg?label=Hackage)](https://hackage.haskell.org/package/extra)
[![Stackage
version](https://www.stackage.org/package/extra/badge/nightly?label=Stackage)](https://www.stackage.org/package/extra)
[![Linux build
status](https://img.shields.io/travis/ndmitchell/extra/master.svg?label=Linux%20build)](https://travis-ci.org/ndmitchell/extra)
[![Windows build
status](https://img.shields.io/appveyor/ci/ndmitchell/extra/master.svg?label=Windows%20build)](https://ci.appveyor.com/project/ndmitchell/extra)

-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. A few examples:
+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.10. A few examples:

* `Control.Monad.Extra.concatMapM` provides a monadic version of `concatMap`,
in the same way that `mapM` is a monadic version of `map`.
* `Data.Tuple.Extra.fst3` provides a function to get the first element of a
triple.
* `Control.Exception.Extra.retry` provides a function that retries an `IO`
action a number of times.
-* `System.Environment.Extra.lookupEnv` is a function available in GHC 7.6 and
above. On GHC 7.6 and above this package reexports the version from
`System.Environment` while on GHC 7.4 and below it defines an equivalent
version.
+* `Data.Either.Extra.fromLeft` is a function available in GHC 8.0 and above.
On GHC 8.0 and above this package reexports the version from `Data.Either`
while on GHC 7.10 and below it defines an equivalent version.

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.

diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/extra.cabal new/extra-1.6.15/extra.cabal
--- old/extra-1.6.14/extra.cabal 2018-12-10 20:24:24.000000000 +0100
+++ new/extra-1.6.15/extra.cabal 2019-04-22 20:32:36.000000000 +0200
@@ -1,13 +1,13 @@
cabal-version: >= 1.18
build-type: Simple
name: extra
-version: 1.6.14
+version: 1.6.15
license: BSD3
license-file: LICENSE
category: Development
author: Neil Mitchell <ndmitchell@xxxxxxxxx>
maintainer: Neil Mitchell <ndmitchell@xxxxxxxxx>
-copyright: Neil Mitchell 2014-2018
+copyright: Neil Mitchell 2014-2019
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==8.6.3, GHC==8.4.4, GHC==8.2.2, GHC==8.0.2,
GHC==7.10.3, GHC==7.8.4, GHC==7.6.3, GHC==7.4.2
+tested-with: GHC==8.6.4, GHC==8.4.4, GHC==8.2.2, GHC==8.0.2, GHC==7.10.3

extra-doc-files:
CHANGES.txt
@@ -31,11 +31,13 @@
default-language: Haskell2010
hs-source-dirs: src
build-depends:
- base >= 4.4 && < 5,
+ base >= 4.8 && < 5,
directory,
filepath,
process,
clock >= 0.7,
+ -- For GHC 7.10 since Data.List.NonEmpty wasn't in base then
+ semigroups,
time
if !os(windows)
build-depends: unix
@@ -50,6 +52,7 @@
Data.Either.Extra
Data.IORef.Extra
Data.List.Extra
+ Data.List.NonEmpty.Extra
Data.Tuple.Extra
Data.Typeable.Extra
Data.Version.Extra
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/src/Control/Concurrent/Extra.hs
new/extra-1.6.15/src/Control/Concurrent/Extra.hs
--- old/extra-1.6.14/src/Control/Concurrent/Extra.hs 2018-12-10
15:33:37.000000000 +0100
+++ new/extra-1.6.15/src/Control/Concurrent/Extra.hs 2019-02-25
16:55:33.000000000 +0100
@@ -1,5 +1,4 @@
-{-# LANGUAGE CPP, TupleSections, ConstraintKinds #-}
-{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
+{-# LANGUAGE TupleSections, ConstraintKinds #-}

-- | Extra functions for "Control.Concurrent".
--
@@ -14,8 +13,8 @@
-- see the <httdp://hackage.haskell.org/package/async async> package.
module Control.Concurrent.Extra(
module Control.Concurrent,
- getNumCapabilities, setNumCapabilities, withNumCapabilities,
- forkFinally, once, onceFork,
+ withNumCapabilities,
+ once, onceFork,
-- * Lock
Lock, newLock, withLock, withLockTry,
-- * Var
@@ -43,39 +42,6 @@
withNumCapabilities _ act = act


-#if __GLASGOW_HASKELL__ < 702
--- | A version of 'getNumCapabilities' that works on all versions of GHC, but
returns 1 before GHC 7.2.
-getNumCapabilities :: IO Int
-getNumCapabilities = return 1
-#endif
-
-#if __GLASGOW_HASKELL__ < 706
--- | A version of 'setNumCapabilities' that works on all versions of GHC, but
has no effect before GHC 7.6.
-setNumCapabilities :: Int -> IO ()
-setNumCapabilities n = return ()
-#endif
-
-
-#if __GLASGOW_HASKELL__ < 706
--- | 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.
-forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
-forkFinally action and_then =
- mask $ \restore ->
- forkIO $ try (restore action) >>= and_then
-#endif
-
-
-- | Given an action, produce a wrapped action that runs at most once.
-- If the function raises an exception, the same exception will be reraised
each time.
--
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/src/Control/Exception/Extra.hs
new/extra-1.6.15/src/Control/Exception/Extra.hs
--- old/extra-1.6.14/src/Control/Exception/Extra.hs 2018-12-10
15:34:38.000000000 +0100
+++ new/extra-1.6.15/src/Control/Exception/Extra.hs 2019-02-25
16:56:30.000000000 +0100
@@ -13,7 +13,7 @@
retry, retryBool,
errorWithoutStackTrace,
showException, stringException,
- errorIO, displayException,
+ errorIO,
-- * Exception catching/ignoring
ignore,
catch_, handle_, try_,
@@ -52,13 +52,6 @@
showException = stringException . show


-#if __GLASGOW_HASKELL__ < 710
--- | Render this exception value in a human-friendly manner.
--- Part of the 'Exception' class in GHC 7.10 onwards.
-displayException :: Exception e => e -> String
-displayException = show
-#endif
-
#if __GLASGOW_HASKELL__ < 800
-- | A variant of 'error' that does not produce a stack trace.
errorWithoutStackTrace :: String -> a
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/src/Control/Monad/Extra.hs
new/extra-1.6.15/src/Control/Monad/Extra.hs
--- old/extra-1.6.14/src/Control/Monad/Extra.hs 2018-12-07 12:00:34.000000000
+0100
+++ new/extra-1.6.15/src/Control/Monad/Extra.hs 2019-04-22 20:25:59.000000000
+0200
@@ -9,7 +9,7 @@
whenJust, whenJustM,
whenMaybe, whenMaybeM,
unit,
- maybeM, eitherM,
+ maybeM, fromMaybeM, eitherM,
-- * Loops
loop, loopM, whileM,
-- * Lists
@@ -70,6 +70,11 @@
maybeM n j x = maybe n j =<< x


+-- | Monadic generalisation of 'fromMaybe'.
+fromMaybeM :: Monad m => m a -> m (Maybe a) -> m a
+fromMaybeM n x = maybe n pure =<< x
+
+
-- | Monadic generalisation of 'either'.
eitherM :: Monad m => (a -> m c) -> (b -> m c) -> m (Either a b) -> m c
eitherM l r x = either l r =<< x
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/src/Data/Either/Extra.hs
new/extra-1.6.15/src/Data/Either/Extra.hs
--- old/extra-1.6.14/src/Data/Either/Extra.hs 2018-12-10 16:20:39.000000000
+0100
+++ new/extra-1.6.15/src/Data/Either/Extra.hs 2019-02-25 16:58:14.000000000
+0100
@@ -9,7 +9,7 @@
-- <https://hackage.haskell.org/package/either either>.
module Data.Either.Extra(
module Data.Either,
- isLeft, isRight, fromLeft, fromRight, fromEither,
+ fromLeft, fromRight, fromEither,
fromLeft', fromRight',
eitherToMaybe, maybeToEither,
mapLeft, mapRight,
@@ -61,18 +61,6 @@
fromRight' _ = error "fromRight', given a Left"


-#if __GLASGOW_HASKELL__ < 708
--- | Test if an 'Either' value is the 'Left' constructor.
--- Provided as standard with GHC 7.8 and above.
-isLeft :: Either l r -> Bool
-isLeft Left{} = True; isLeft _ = False
-
--- | Test if an 'Either' value is the 'Right' constructor.
--- Provided as standard with GHC 7.8 and above.
-isRight :: Either l r -> Bool
-isRight Right{} = True; isRight _ = False
-#endif
-
-- | Pull the value out of an 'Either' where both alternatives
-- have the same type.
--
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/src/Data/IORef/Extra.hs
new/extra-1.6.15/src/Data/IORef/Extra.hs
--- old/extra-1.6.14/src/Data/IORef/Extra.hs 2017-05-09 22:38:47.000000000
+0200
+++ new/extra-1.6.15/src/Data/IORef/Extra.hs 2019-02-25 16:55:23.000000000
+0100
@@ -1,11 +1,9 @@
-{-# LANGUAGE CPP #-}
-{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}

-- | This module extends "Data.IORef" with operations forcing the value
written to the IORef.
-- Some of these functions are available in later versions of GHC, but not
all.
module Data.IORef.Extra(
module Data.IORef,
- modifyIORef', writeIORef', atomicModifyIORef', atomicWriteIORef,
atomicWriteIORef'
+ writeIORef', atomicWriteIORef'
) where

import Data.IORef
@@ -23,30 +21,3 @@
atomicWriteIORef' ref x = do
evaluate x
atomicWriteIORef ref x
-
-
-#if __GLASGOW_HASKELL__ < 706
-
--- | Version of 'modifyIORef' that evaluates the function.
-modifyIORef' :: IORef a -> (a -> a) -> IO ()
-modifyIORef' ref f = do
- x <- readIORef ref
- writeIORef' ref $ f x
-
--- | Strict version of 'atomicModifyIORef'. This forces both the value stored
--- in the 'IORef' as well as the value returned.
-atomicModifyIORef' :: IORef a -> (a -> (a,b)) -> IO b
-atomicModifyIORef' ref f = do
- b <- atomicModifyIORef ref
- (\x -> let (a, b) = f x
- in (a, a `seq` b))
- b `seq` return b
-
--- | Variant of 'writeIORef' with the \"barrier to reordering\" property that
--- 'atomicModifyIORef' has.
-atomicWriteIORef :: IORef a -> a -> IO ()
-atomicWriteIORef ref a = do
- x <- atomicModifyIORef ref $ const (a, ())
- x `seq` return ()
-
-#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/src/Data/List/Extra.hs
new/extra-1.6.15/src/Data/List/Extra.hs
--- old/extra-1.6.14/src/Data/List/Extra.hs 2018-12-07 12:00:54.000000000
+0100
+++ new/extra-1.6.15/src/Data/List/Extra.hs 2019-02-25 16:59:08.000000000
+0100
@@ -1,5 +1,4 @@
-{-# LANGUAGE CPP, TupleSections, BangPatterns, ConstraintKinds #-}
-{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
+{-# LANGUAGE TupleSections, BangPatterns, ConstraintKinds #-}

-- | This module extends "Data.List" with extra functions of a similar nature.
-- The package also exports the existing "Data.List" functions.
@@ -13,17 +12,17 @@
unescapeHTML, unescapeJSON,
-- * Splitting
dropEnd, takeEnd, splitAtEnd, breakEnd, spanEnd,
- dropWhileEnd, dropWhileEnd', takeWhileEnd,
+ dropWhileEnd', takeWhileEnd,
stripSuffix, stripInfix, stripInfixEnd,
dropPrefix, dropSuffix,
wordsBy, linesBy,
breakOn, breakOnEnd, splitOn, split, chunksOf,
-- * Basics
- notNull, list, uncons, unsnoc, cons, snoc, drop1, mconcatMap,
+ notNull, list, unsnoc, cons, snoc, drop1, mconcatMap,
-- * List operations
groupSort, groupSortOn, groupSortBy,
nubOrd, nubOrdBy, nubOrdOn,
- nubOn, groupOn, sortOn,
+ nubOn, groupOn,
nubSort, nubSortBy, nubSortOn,
maximumOn, minimumOn,
disjoint, allSame, anySame,
@@ -114,17 +113,6 @@
list nil cons [] = nil
list nil cons (x:xs) = cons x xs

-#if __GLASGOW_HASKELL__ < 709
--- | If the list is empty returns 'Nothing', otherwise returns the 'head' and
the 'tail'.
---
--- > uncons "test" == Just ('t',"est")
--- > uncons "" == Nothing
--- > \xs -> uncons xs == if null xs then Nothing else Just (head xs, tail xs)
-uncons :: [a] -> Maybe (a, [a])
-uncons [] = Nothing
-uncons (x:xs) = Just (x,xs)
-#endif
-
-- | If the list is empty returns 'Nothing', otherwise returns the 'init' and
the 'last'.
--
-- > unsnoc "test" == Just ("tes",'t')
@@ -353,18 +341,6 @@
unescapeJSON [] = []


-#if __GLASGOW_HASKELL__ < 709
--- | Sort a list by comparing the results of a key function applied to each
--- element. @sortOn f@ is equivalent to @sortBy (comparing f)@, but has the
--- performance advantage of only evaluating @f@ once for each element in the
--- input list. This is called the decorate-sort-undecorate paradigm, or
--- Schwartzian transform.
---
--- > sortOn fst [(3,"z"),(1,""),(3,"a")] == [(1,""),(3,"z"),(3,"a")]
-sortOn :: Ord b => (a -> b) -> [a] -> [a]
-sortOn f = map snd . sortBy (compare `on` fst) . map (\x -> let y = f x in y
`seq` (y, x))
-#endif
-
-- | A version of 'group' where the equality is done on some extracted value.
groupOn :: Eq b => (a -> b) -> [a] -> [[a]]
groupOn f = groupBy ((==) `on2` f)
@@ -571,12 +547,6 @@
split f (x:xs) | y:ys <- split f xs = (x:y) : ys


-#if __GLASGOW_HASKELL__ < 704
-dropWhileEnd :: (a -> Bool) -> [a] -> [a]
-dropWhileEnd p = foldr (\x xs -> if p x && null xs then [] else x : xs) []
-#endif
-
-
-- | A version of 'dropWhileEnd' but with different strictness properties.
-- The function 'dropWhileEnd' can be used on an infinite list and tests the
property
-- on each character. In contrast, 'dropWhileEnd'' is strict in the spine of
the list
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/src/Data/List/NonEmpty/Extra.hs
new/extra-1.6.15/src/Data/List/NonEmpty/Extra.hs
--- old/extra-1.6.14/src/Data/List/NonEmpty/Extra.hs 1970-01-01
01:00:00.000000000 +0100
+++ new/extra-1.6.15/src/Data/List/NonEmpty/Extra.hs 2019-04-22
20:25:59.000000000 +0200
@@ -0,0 +1,93 @@
+{-# LANGUAGE CPP #-}
+
+-- | Extra functions for working with 'NonEmpty' lists. The package
+-- also exports the existing "Data.List.NonEmpty" functions.
+module Data.List.NonEmpty.Extra(
+ module Data.List.NonEmpty,
+ (|:), (|>), snoc,
+ appendl, appendr,
+ sortOn, union, unionBy,
+ maximum1, minimum1, maximumBy1, minimumBy1, maximumOn1, minimumOn1
+ ) where
+
+import Data.Function
+import qualified Data.List as List
+import Data.List.NonEmpty
+
+#if __GLASGOW_HASKELL__ <= 802
+import Data.Semigroup ((<>))
+#endif
+
+infixl 5 |>, |:
+
+-- | /O(n)/. Append an element to a non-empty list.
+--
+-- > (1 :| [2,3]) |> 4 |> 5 == 1 :| [2,3,4,5]
+(|>) :: NonEmpty a -> a -> NonEmpty a
+(|>) xs x = xs <> pure x
+
+-- | Synonym for '|>'.
+snoc :: NonEmpty a -> a -> NonEmpty a
+snoc = (|>)
+
+-- | /O(n)/. Append an element to a list.
+--
+-- > [1,2,3] |: 4 |> 5 == 1 :| [2,3,4,5]
+(|:) :: [a] -> a -> NonEmpty a
+(|:) xs x = foldr cons (pure x) xs
+
+-- | Append a list to a non-empty list.
+--
+-- > appendl (1 :| [2,3]) [4,5] == 1 :| [2,3,4,5]
+appendl :: NonEmpty a -> [a] -> NonEmpty a
+appendl (x :| xs) l = x :| (xs ++ l)
+
+-- | Append a non-empty list to a list.
+--
+-- > appendr [1,2,3] (4 :| [5]) == 1 :| [2,3,4,5]
+appendr :: [a] -> NonEmpty a -> NonEmpty a
+appendr l nel = foldr cons nel l
+
+-- | Sort by comparing the results of a function applied to each element.
+-- The sort is stable, and the function is evaluated only once for
+-- each element.
+sortOn :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty a
+sortOn f = fromList . List.sortOn f . toList
+
+-- | Return the union of two non-empty lists. Duplicates, and elements of the
+-- first list, are removed from the the second list, but if the first list
+-- contains duplicates, so will the result.
+--
+-- > (1 :| [3, 5, 3]) `union` (4 :| [5, 3, 5, 2]) == 1 :| [3, 5, 3, 4, 2]
+union :: Eq a => NonEmpty a -> NonEmpty a -> NonEmpty a
+union = unionBy (==)
+
+-- | The non-overloaded version of 'union'.
+unionBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a -> NonEmpty a
+unionBy eq xs ys = fromList $ List.unionBy eq (toList xs) (toList ys)
+
+-- | The largest element of a non-empty list.
+maximum1 :: Ord a => NonEmpty a -> a
+maximum1 = List.maximum
+
+-- | The least element of a non-empty list.
+minimum1 :: Ord a => NonEmpty a -> a
+minimum1 = List.minimum
+
+-- | The largest element of a non-empty list with respect to the given
+-- comparison function.
+maximumBy1 :: (a -> a -> Ordering) -> NonEmpty a -> a
+maximumBy1 = List.maximumBy
+
+-- | The least element of a non-empty list with respect to the given
+-- comparison function.
+minimumBy1 :: (a -> a -> Ordering) -> NonEmpty a -> a
+minimumBy1 = List.minimumBy
+
+-- | A version of 'maximum1' where the comparison is done on some extracted
value.
+maximumOn1 :: Ord b => (a -> b) -> NonEmpty a -> a
+maximumOn1 f = maximumBy1 (compare `on` f)
+
+-- | A version of 'minimum1' where the comparison is done on some extracted
value.
+minimumOn1 :: Ord b => (a -> b) -> NonEmpty a -> a
+minimumOn1 f = minimumBy1 (compare `on` f)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/src/Data/Typeable/Extra.hs
new/extra-1.6.15/src/Data/Typeable/Extra.hs
--- old/extra-1.6.14/src/Data/Typeable/Extra.hs 2016-06-15 20:34:55.000000000
+0200
+++ new/extra-1.6.15/src/Data/Typeable/Extra.hs 2019-02-25 17:04:47.000000000
+0100
@@ -1,129 +1,10 @@
-{-# LANGUAGE CPP, ScopedTypeVariables, TypeOperators, GADTs,
StandaloneDeriving #-}
-{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}

-- | This module extends "Data.Typeable" with extra functions available in
later GHC versions.
-- The package also exports the existing "Data.Typeable" functions.
+--
+-- Currently this module has no functionality beyond "Data.Typeable".
module Data.Typeable.Extra(
- typeRep, (:~:)(..), Proxy(..),
module Data.Typeable
) where

import Data.Typeable
-
-#if __GLASGOW_HASKELL__ < 708
-
-import Data.Ix
-import Data.Monoid
-import Control.Monad
-import Control.Applicative
-
-
--- | Takes a value of type @a@ and returns a concrete representation
--- of that type.
---
--- > typeRep (Proxy :: Proxy Int) == typeOf (1 :: Int)
-typeRep :: forall proxy a. Typeable a => proxy a -> TypeRep
-typeRep _ = typeOf (undefined :: a)
-
-
-infix 4 :~:
-
--- | Propositional equality. If @a :~: b@ is inhabited by some terminating
--- value, then the type @a@ is the same as the type @b@. To use this equality
--- in practice, pattern-match on the @a :~: b@ to get out the @Refl@
constructor;
--- in the body of the pattern-match, the compiler knows that @a ~ b@.
-data a :~: b where
- Refl :: a :~: a
-
-deriving instance Eq (a :~: b)
-deriving instance Show (a :~: b)
-deriving instance Ord (a :~: b)
-
-instance a ~ b => Read (a :~: b) where
- readsPrec d = readParen (d > 10) (\r -> [(Refl, s) | ("Refl",s) <- lex r ])
-
-instance a ~ b => Enum (a :~: b) where
- toEnum 0 = Refl
- toEnum _ = errorWithoutStackTrace "Data.Type.Equality.toEnum: bad argument"
-
- fromEnum Refl = 0
-
-instance a ~ b => Bounded (a :~: b) where
- minBound = Refl
- maxBound = Refl
-
-
-
--- | A canonical proxy type
-data Proxy t = Proxy
-
--- It's common to use (undefined :: Proxy t) and (Proxy :: Proxy t)
--- interchangeably, so all of these instances are hand-written to be
--- lazy in Proxy arguments.
-
-instance Eq (Proxy s) where
- _ == _ = True
-
-instance Ord (Proxy s) where
- compare _ _ = EQ
-
-instance Show (Proxy s) where
- showsPrec _ _ = showString "Proxy"
-
-instance Read (Proxy s) where
- readsPrec d = readParen (d > 10) (\r -> [(Proxy, s) | ("Proxy",s) <- lex r ])
-
-errorWithoutStackTrace = error
-
-instance Enum (Proxy s) where
- succ _ = errorWithoutStackTrace "Proxy.succ"
- pred _ = errorWithoutStackTrace "Proxy.pred"
- fromEnum _ = 0
- toEnum 0 = Proxy
- toEnum _ = errorWithoutStackTrace "Proxy.toEnum: 0 expected"
- enumFrom _ = [Proxy]
- enumFromThen _ _ = [Proxy]
- enumFromThenTo _ _ _ = [Proxy]
- enumFromTo _ _ = [Proxy]
-
-instance Ix (Proxy s) where
- range _ = [Proxy]
- index _ _ = 0
- inRange _ _ = True
- rangeSize _ = 1
-
-instance Bounded (Proxy s) where
- minBound = Proxy
- maxBound = Proxy
-
-instance Monoid (Proxy s) where
- mempty = Proxy
- mappend _ _ = Proxy
- mconcat _ = Proxy
-
-instance Functor Proxy where
- fmap _ _ = Proxy
- {-# INLINE fmap #-}
-
-instance Applicative Proxy where
- pure _ = Proxy
- {-# INLINE pure #-}
- _ <*> _ = Proxy
- {-# INLINE (<*>) #-}
-
-instance Alternative Proxy where
- empty = Proxy
- {-# INLINE empty #-}
- _ <|> _ = Proxy
- {-# INLINE (<|>) #-}
-
-instance Monad Proxy where
- return = pure
- _ >>= _ = Proxy
- {-# INLINE (>>=) #-}
-
-instance MonadPlus Proxy where
- mzero = empty
- mplus = (<|>)
-
-#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/src/Data/Version/Extra.hs
new/extra-1.6.15/src/Data/Version/Extra.hs
--- old/extra-1.6.14/src/Data/Version/Extra.hs 2017-12-07 13:09:51.000000000
+0100
+++ new/extra-1.6.15/src/Data/Version/Extra.hs 2019-02-25 17:05:16.000000000
+0100
@@ -1,11 +1,10 @@
-{-# LANGUAGE CPP, ConstraintKinds #-}
-{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
+{-# LANGUAGE ConstraintKinds #-}

-- | This module extends "Data.Version" with extra utilities.
-- The package also exports the existing "Data.Version" functions.
module Data.Version.Extra(
module Data.Version,
- makeVersion, readVersion
+ readVersion
) where

import Partial
@@ -14,16 +13,6 @@
import Text.ParserCombinators.ReadP


-#if __GLASGOW_HASKELL__ < 710
-
--- | Construct tag-less 'Version'
---
--- > showVersion (makeVersion [1,2,3]) == "1.2.3"
-makeVersion :: [Int] -> Version
-makeVersion b = Version b []
-
-#endif
-
-- | Read a 'Version' or throw an exception.
--
-- > \x -> readVersion (showVersion x) == x
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/src/Extra.hs
new/extra-1.6.15/src/Extra.hs
--- old/extra-1.6.14/src/Extra.hs 2018-12-10 15:41:09.000000000 +0100
+++ new/extra-1.6.15/src/Extra.hs 2019-04-22 20:25:59.000000000 +0200
@@ -8,40 +8,37 @@
module Extra {-# DEPRECATED "This module is provided as documentation of all
new functions, you should import the more specific modules directly." #-} (
-- * Control.Concurrent.Extra
-- | Extra functions available in @"Control.Concurrent.Extra"@.
- getNumCapabilities, setNumCapabilities, withNumCapabilities, forkFinally,
once, onceFork, Lock, newLock, withLock, withLockTry, Var, newVar, readVar,
writeVar, modifyVar, modifyVar_, withVar, Barrier, newBarrier, signalBarrier,
waitBarrier, waitBarrierMaybe,
+ withNumCapabilities, once, onceFork, Lock, newLock, withLock, withLockTry,
Var, newVar, readVar, writeVar, modifyVar, modifyVar_, withVar, Barrier,
newBarrier, signalBarrier, waitBarrier, waitBarrierMaybe,
-- * Control.Exception.Extra
-- | Extra functions available in @"Control.Exception.Extra"@.
- Partial, retry, retryBool, errorWithoutStackTrace, showException,
stringException, errorIO, displayException, ignore, catch_, handle_, try_,
catchJust_, handleJust_, tryJust_, catchBool, handleBool, tryBool,
+ Partial, retry, retryBool, errorWithoutStackTrace, showException,
stringException, errorIO, ignore, catch_, handle_, try_, catchJust_,
handleJust_, tryJust_, catchBool, handleBool, tryBool,
-- * Control.Monad.Extra
-- | Extra functions available in @"Control.Monad.Extra"@.
- whenJust, whenJustM, whenMaybe, whenMaybeM, unit, maybeM, eitherM, loop,
loopM, whileM, partitionM, concatMapM, concatForM, mconcatMapM, mapMaybeM,
findM, firstJustM, fold1M, fold1M_, whenM, unlessM, ifM, notM, (||^), (&&^),
orM, andM, anyM, allM,
+ whenJust, whenJustM, whenMaybe, whenMaybeM, unit, maybeM, fromMaybeM,
eitherM, loop, loopM, whileM, partitionM, concatMapM, concatForM, mconcatMapM,
mapMaybeM, findM, firstJustM, fold1M, fold1M_, whenM, unlessM, ifM, notM,
(||^), (&&^), orM, andM, anyM, allM,
-- * Data.Either.Extra
-- | Extra functions available in @"Data.Either.Extra"@.
- isLeft, isRight, fromLeft, fromRight, fromEither, fromLeft', fromRight',
eitherToMaybe, maybeToEither, mapLeft, mapRight,
+ fromLeft, fromRight, fromEither, fromLeft', fromRight', eitherToMaybe,
maybeToEither, mapLeft, mapRight,
-- * Data.IORef.Extra
-- | Extra functions available in @"Data.IORef.Extra"@.
- modifyIORef', writeIORef', atomicModifyIORef', atomicWriteIORef,
atomicWriteIORef',
+ writeIORef', atomicWriteIORef',
-- * Data.List.Extra
-- | Extra functions available in @"Data.List.Extra"@.
- lower, upper, trim, trimStart, trimEnd, word1, line1, escapeHTML,
escapeJSON, unescapeHTML, unescapeJSON, dropEnd, takeEnd, splitAtEnd, breakEnd,
spanEnd, dropWhileEnd, dropWhileEnd', takeWhileEnd, stripSuffix, stripInfix,
stripInfixEnd, dropPrefix, dropSuffix, wordsBy, linesBy, breakOn, breakOnEnd,
splitOn, split, chunksOf, notNull, list, uncons, unsnoc, cons, snoc, drop1,
mconcatMap, groupSort, groupSortOn, groupSortBy, nubOrd, nubOrdBy, nubOrdOn,
nubOn, groupOn, sortOn, nubSort, nubSortBy, nubSortOn, maximumOn, minimumOn,
disjoint, allSame, anySame, repeatedly, for, firstJust, concatUnzip,
concatUnzip3, zipFrom, zipWithFrom, replace, merge, mergeBy,
+ lower, upper, trim, trimStart, trimEnd, word1, line1, escapeHTML,
escapeJSON, unescapeHTML, unescapeJSON, dropEnd, takeEnd, splitAtEnd, breakEnd,
spanEnd, dropWhileEnd', takeWhileEnd, stripSuffix, stripInfix, stripInfixEnd,
dropPrefix, dropSuffix, wordsBy, linesBy, breakOn, breakOnEnd, splitOn, split,
chunksOf, notNull, list, unsnoc, cons, snoc, drop1, mconcatMap, groupSort,
groupSortOn, groupSortBy, nubOrd, nubOrdBy, nubOrdOn, nubOn, groupOn, nubSort,
nubSortBy, nubSortOn, maximumOn, minimumOn, disjoint, allSame, anySame,
repeatedly, for, firstJust, concatUnzip, concatUnzip3, zipFrom, zipWithFrom,
replace, merge, mergeBy,
+ -- * Data.List.NonEmpty.Extra
+ -- | Extra functions available in @"Data.List.NonEmpty.Extra"@.
+ (|:), (|>), appendl, appendr, maximum1, minimum1, maximumBy1, minimumBy1,
maximumOn1, minimumOn1,
-- * Data.Tuple.Extra
-- | Extra functions available in @"Data.Tuple.Extra"@.
first, second, (***), (&&&), dupe, both, fst3, snd3, thd3, curry3,
uncurry3,
- -- * Data.Typeable.Extra
- -- | Extra functions available in @"Data.Typeable.Extra"@.
- typeRep, (:~:)(..), Proxy(..),
-- * Data.Version.Extra
-- | Extra functions available in @"Data.Version.Extra"@.
- makeVersion, readVersion,
+ readVersion,
-- * Numeric.Extra
-- | Extra functions available in @"Numeric.Extra"@.
showDP, intToDouble, intToFloat, floatToDouble, doubleToFloat,
-- * System.Directory.Extra
-- | Extra functions available in @"System.Directory.Extra"@.
withCurrentDirectory, createDirectoryPrivate, listContents,
listDirectories, listFiles, listFilesInside, listFilesRecursive,
- -- * System.Environment.Extra
- -- | Extra functions available in @"System.Environment.Extra"@.
- getExecutablePath, lookupEnv,
-- * System.Info.Extra
-- | Extra functions available in @"System.Info.Extra"@.
isWindows, isMac,
@@ -54,9 +51,6 @@
-- * System.Time.Extra
-- | Extra functions available in @"System.Time.Extra"@.
Seconds, sleep, timeout, showDuration, offsetTime, offsetTimeIncrease,
duration,
- -- * Text.Read.Extra
- -- | Extra functions available in @"Text.Read.Extra"@.
- readEither, readMaybe,
) where

import Control.Concurrent.Extra
@@ -65,14 +59,12 @@
import Data.Either.Extra
import Data.IORef.Extra
import Data.List.Extra
+import Data.List.NonEmpty.Extra hiding (cons, snoc, sortOn, union, unionBy)
import Data.Tuple.Extra
-import Data.Typeable.Extra
import Data.Version.Extra
import Numeric.Extra
import System.Directory.Extra
-import System.Environment.Extra
import System.Info.Extra
import System.IO.Extra
import System.Process.Extra
import System.Time.Extra
-import Text.Read.Extra
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/src/Numeric/Extra.hs
new/extra-1.6.15/src/Numeric/Extra.hs
--- old/extra-1.6.14/src/Numeric/Extra.hs 2016-07-02 05:59:24.000000000
+0200
+++ new/extra-1.6.15/src/Numeric/Extra.hs 2019-02-25 16:47:08.000000000
+0100
@@ -7,7 +7,7 @@
) where

import Numeric
-import Control.Arrow
+

---------------------------------------------------------------------
-- Data.String
@@ -18,8 +18,7 @@
-- > showDP 0 pi == "3"
-- > showDP 2 3 == "3.00"
showDP :: RealFloat a => Int -> a -> String
-showDP n x = a ++ (if n > 0 then "." else "") ++ b ++ replicate (n - length b)
'0'
- where (a,b) = second (drop 1) $ break (== '.') $ showFFloat (Just n) x ""
+showDP n x = showFFloat (Just n) x ""


---------------------------------------------------------------------
@@ -40,5 +39,3 @@
-- | Specialised numeric conversion, type restricted version of 'realToFrac'.
doubleToFloat :: Double -> Float
doubleToFloat = realToFrac
-
-
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/src/System/Environment/Extra.hs
new/extra-1.6.15/src/System/Environment/Extra.hs
--- old/extra-1.6.14/src/System/Environment/Extra.hs 2017-05-09
22:38:47.000000000 +0200
+++ new/extra-1.6.15/src/System/Environment/Extra.hs 2019-02-25
17:06:01.000000000 +0100
@@ -1,26 +1,10 @@
-{-# LANGUAGE CPP #-}
-{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}

-- | Extra functions for "System.Environment". All these functions are
available in later GHC versions,
-- but this code works all the way back to GHC 7.2.
+--
+-- Currently this module has no functionality beyond "System.Environment".
module System.Environment.Extra(
module System.Environment,
- getExecutablePath, lookupEnv
) where

import System.Environment
-
-#if __GLASGOW_HASKELL__ < 706
-import Control.Exception.Extra
-import System.IO.Error
-import Data.Functor
-
--- | Alias for 'getProgName' in GHC 7.4 and below, otherwise
--- returns the absolute pathname of the current executable.
-getExecutablePath :: IO FilePath
-getExecutablePath = getProgName
-
--- | Return the value of the environment variable var, or Nothing if there is
no such value.
-lookupEnv :: String -> IO (Maybe String)
-lookupEnv x = catchBool isDoesNotExistError (Just <$> getEnv x) (const $
return Nothing)
-#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/src/Text/Read/Extra.hs
new/extra-1.6.15/src/Text/Read/Extra.hs
--- old/extra-1.6.14/src/Text/Read/Extra.hs 2017-12-07 12:52:28.000000000
+0100
+++ new/extra-1.6.15/src/Text/Read/Extra.hs 2019-02-25 17:08:09.000000000
+0100
@@ -1,38 +1,9 @@
-{-# LANGUAGE CPP #-}
-{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}

-- | This module provides "Text.Read" with functions added in later versions.
+--
+-- Currently this module has no functionality beyond "Text.Read".
module Text.Read.Extra(
module Text.Read,
- readEither, readMaybe
) where

import Text.Read
-
-#if __GLASGOW_HASKELL__ < 706
-
-import Text.ParserCombinators.ReadP as P
-
--- | Parse a string using the 'Read' instance.
--- Succeeds if there is exactly one valid result.
--- A 'Left' value indicates a parse error.
-readEither :: Read a => String -> Either String a
-readEither s =
- case [ x | (x,"") <- readPrec_to_S read' minPrec s ] of
- [x] -> Right x
- [] -> Left "Prelude.read: no parse"
- _ -> Left "Prelude.read: ambiguous parse"
- where
- read' =
- do x <- readPrec
- lift P.skipSpaces
- return x
-
--- | Parse a string using the 'Read' instance.
--- Succeeds if there is exactly one valid result.
-readMaybe :: Read a => String -> Maybe a
-readMaybe s = case readEither s of
- Left _ -> Nothing
- Right a -> Just a
-
-#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/test/TestGen.hs
new/extra-1.6.15/test/TestGen.hs
--- old/extra-1.6.14/test/TestGen.hs 2018-12-10 15:41:24.000000000 +0100
+++ new/extra-1.6.15/test/TestGen.hs 2019-04-22 20:25:59.000000000 +0200
@@ -94,9 +94,6 @@
testGen "list 1 (\\v _ -> v - 2) [5,6,7] == 3" $ list 1 (\v _ -> v - 2)
[5,6,7] == 3
testGen "list 1 (\\v _ -> v - 2) [] == 1" $ list 1 (\v _ -> v - 2) []
== 1
testGen "\\nil cons xs -> maybe nil (uncurry cons) (uncons xs) == list nil
cons xs" $ \nil cons xs -> maybe nil (uncurry cons) (uncons xs) == list nil
cons xs
- testGen "uncons \"test\" == Just ('t',\"est\")" $ uncons "test" == Just
('t',"est")
- testGen "uncons \"\" == Nothing" $ uncons "" == Nothing
- testGen "\\xs -> uncons xs == if null xs then Nothing else Just (head xs,
tail xs)" $ \xs -> uncons xs == if null xs then Nothing else Just (head xs,
tail xs)
testGen "unsnoc \"test\" == Just (\"tes\",'t')" $ unsnoc "test" == Just
("tes",'t')
testGen "unsnoc \"\" == Nothing" $ unsnoc "" == Nothing
testGen "\\xs -> unsnoc xs == if null xs then Nothing else Just (init xs,
last xs)" $ \xs -> unsnoc xs == if null xs then Nothing else Just (init xs,
last xs)
@@ -151,7 +148,6 @@
testGen "escapeJSON \"\\ttab\\nnewline\\\\\" ==
\"\\\\ttab\\\\nnewline\\\\\\\\\"" $ escapeJSON "\ttab\nnewline\\" ==
"\\ttab\\nnewline\\\\"
testGen "escapeJSON \"\\ESC[0mHello\" == \"\\\\u001b[0mHello\"" $
escapeJSON "\ESC[0mHello" == "\\u001b[0mHello"
testGen "\\xs -> unescapeJSON (escapeJSON xs) == xs" $ \xs -> unescapeJSON
(escapeJSON xs) == xs
- testGen "sortOn fst [(3,\"z\"),(1,\"\"),(3,\"a\")] ==
[(1,\"\"),(3,\"z\"),(3,\"a\")]" $ sortOn fst [(3,"z"),(1,""),(3,"a")] ==
[(1,""),(3,"z"),(3,"a")]
testGen "groupSort [(1,'t'),(3,'t'),(2,'e'),(2,'s')] ==
[(1,\"t\"),(2,\"es\"),(3,\"t\")]" $ groupSort [(1,'t'),(3,'t'),(2,'e'),(2,'s')]
== [(1,"t"),(2,"es"),(3,"t")]
testGen "\\xs -> map fst (groupSort xs) == sort (nub (map fst xs))" $ \xs
-> map fst (groupSort xs) == sort (nub (map fst xs))
testGen "\\xs -> concatMap snd (groupSort xs) == map snd (sortOn fst xs)"
$ \xs -> concatMap snd (groupSort xs) == map snd (sortOn fst xs)
@@ -227,14 +223,17 @@
testGen "\\xs -> nubOrd xs == nub xs" $ \xs -> nubOrd xs == nub xs
testGen "nubOrdOn length [\"a\",\"test\",\"of\",\"this\"] ==
[\"a\",\"test\",\"of\"]" $ nubOrdOn length ["a","test","of","this"] ==
["a","test","of"]
testGen "nubOrdBy (compare `on` length) [\"a\",\"test\",\"of\",\"this\"]
== [\"a\",\"test\",\"of\"]" $ nubOrdBy (compare `on` length)
["a","test","of","this"] == ["a","test","of"]
+ testGen "(1 :| [2,3]) |> 4 |> 5 == 1 :| [2,3,4,5]" $ (1 :| [2,3]) |> 4 |>
5 == 1 :| [2,3,4,5]
+ testGen "[1,2,3] |: 4 |> 5 == 1 :| [2,3,4,5]" $ [1,2,3] |: 4 |> 5 == 1 :|
[2,3,4,5]
+ testGen "appendl (1 :| [2,3]) [4,5] == 1 :| [2,3,4,5]" $ appendl (1 :|
[2,3]) [4,5] == 1 :| [2,3,4,5]
+ testGen "appendr [1,2,3] (4 :| [5]) == 1 :| [2,3,4,5]" $ appendr [1,2,3]
(4 :| [5]) == 1 :| [2,3,4,5]
+ testGen "(1 :| [3, 5, 3]) `union` (4 :| [5, 3, 5, 2]) == 1 :| [3, 5, 3, 4,
2]" $ (1 :| [3, 5, 3]) `union` (4 :| [5, 3, 5, 2]) == 1 :| [3, 5, 3, 4, 2]
testGen "first succ (1,\"test\") == (2,\"test\")" $ first succ (1,"test")
== (2,"test")
testGen "second reverse (1,\"test\") == (1,\"tset\")" $ second reverse
(1,"test") == (1,"tset")
testGen "(succ *** reverse) (1,\"test\") == (2,\"tset\")" $ (succ ***
reverse) (1,"test") == (2,"tset")
testGen "(succ &&& pred) 1 == (2,0)" $ (succ &&& pred) 1 == (2,0)
testGen "dupe 12 == (12, 12)" $ dupe 12 == (12, 12)
testGen "both succ (1,2) == (2,3)" $ both succ (1,2) == (2,3)
- testGen "typeRep (Proxy :: Proxy Int) == typeOf (1 :: Int)" $ typeRep
(Proxy :: Proxy Int) == typeOf (1 :: Int)
- testGen "showVersion (makeVersion [1,2,3]) == \"1.2.3\"" $ showVersion
(makeVersion [1,2,3]) == "1.2.3"
testGen "\\x -> readVersion (showVersion x) == x" $ \x -> readVersion
(showVersion x) == x
testGen "readVersion \"hello\" == undefined" $ erroneous $ readVersion
"hello"
testGen "showDP 4 pi == \"3.1416\"" $ showDP 4 pi == "3.1416"
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-1.6.14/test/TestUtil.hs
new/extra-1.6.15/test/TestUtil.hs
--- old/extra-1.6.14/test/TestUtil.hs 2018-10-02 16:08:01.000000000 +0200
+++ new/extra-1.6.15/test/TestUtil.hs 2019-04-22 20:25:59.000000000 +0200
@@ -1,4 +1,4 @@
-{-# LANGUAGE ScopedTypeVariables, CPP, FlexibleInstances #-}
+{-# LANGUAGE ScopedTypeVariables, FlexibleInstances #-}
{-# OPTIONS_GHC -fno-warn-orphans #-} -- OK because a test module

module TestUtil
@@ -22,7 +22,8 @@
import Data.Either.Extra as X
import Data.Function as X
import Data.IORef.Extra as X
-import Data.List.Extra as X
+import Data.List.Extra as X hiding (union, unionBy)
+import Data.List.NonEmpty.Extra as X (NonEmpty(..), (|>), (|:), appendl,
appendr, union, unionBy)
import Data.Monoid as X
import Data.Tuple.Extra as X
import Data.Typeable.Extra as X
@@ -65,11 +66,6 @@
| a == b = True
| otherwise = error $ "Not equal!\n" ++ show a ++ "\n" ++ show b

-#if __GLASGOW_HASKELL__ < 707
-instance Eq ErrorCall where
- ErrorCall x == ErrorCall y = x == y
-#endif
-
runTests :: IO () -> IO ()
runTests t = do
-- ensure that capturing output is robust


< Previous Next >
This Thread
  • No further messages