semigroups 0.19.2 → 0.20.1
raw patch · 6 files changed
Files
- CHANGELOG.markdown +10/−0
- README.markdown +1/−1
- semigroups.cabal +20/−164
- src-ghc7/Data/List/NonEmpty.hs +0/−704
- src-ghc7/Data/Semigroup.hs +0/−1249
- src/Data/Semigroup/Generic.hs +4/−9
CHANGELOG.markdown view
@@ -1,3 +1,13 @@+0.20.1 [2026.01.10]+-------------------+* Drop support for pre-8.0 versions of GHC.++0.20 [2021.11.15]+-----------------+* Support `hashable-1.4`. The `Hashable1` instances added in 0.19.2+ are removed for all types except `NonEmpty`, in accordance with the+ corresponding changes from `hashable-1.4`.+ 0.19.2 [2021.08.30] ------------------- * Backport `Hashable1` instances for `NonEmpty`, `Min`, `Max`, `First`, `Last`,
README.markdown view
@@ -7,7 +7,7 @@ More formally, a semigroup is an algebraic structure consisting of a set together with an associative binary operation. A semigroup generalizes a monoid in that there might not exist an identity element. It also (originally) generalized a group (a monoid with all inverses) to a type where every element did not have to have an inverse, thus the name semigroup. -`Data.Semigroup` and `Data.List.NonEmpty` were added to `base` as of 4.9.0.0. This package now offers a backwards-compatible API and some tools for deriving semigroups with generics.+`Data.Semigroup` and `Data.List.NonEmpty` were added to `base` as of 4.9.0.0. This package now offers some tools for deriving semigroups with generics. Contact Information -------------------
semigroups.cabal view
@@ -1,6 +1,6 @@ name: semigroups category: Algebra, Data, Data Structures, Math-version: 0.19.2+version: 0.20.1 license: BSD3 cabal-version: >= 1.10 license-file: LICENSE@@ -15,175 +15,31 @@ In mathematics, a semigroup is an algebraic structure consisting of a set together with an associative binary operation. A semigroup generalizes a monoid in that there might not exist an identity element. It also (originally) generalized a group (a monoid with all inverses) to a type where every element did not have to have an inverse, thus the name semigroup. build-type: Simple extra-source-files: README.markdown CHANGELOG.markdown-tested-with: GHC == 7.0.4- , GHC == 7.2.2- , GHC == 7.4.2- , GHC == 7.6.3- , GHC == 7.8.4- , GHC == 7.10.3- , GHC == 8.0.2- , GHC == 8.2.2- , GHC == 8.4.4- , GHC == 8.6.5- , GHC == 8.8.4- , GHC == 8.10.7- , GHC == 9.0.1- , GHC == 9.2.*+tested-with:+ GHC == 9.14.1+ GHC == 9.12.2+ GHC == 9.10.3+ GHC == 9.8.4+ GHC == 9.6.7+ GHC == 9.4.8+ GHC == 9.2.8+ GHC == 9.0.2+ GHC == 8.10.7+ GHC == 8.8.4+ GHC == 8.6.5+ GHC == 8.4.4+ GHC == 8.2.2+ GHC == 8.0.2 source-repository head type: git- location: git://github.com/ekmett/semigroups.git--flag hashable- description:- You can disable the use of the `hashable` package using `-f-hashable`.- .- Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.- .- If disabled we will not supply instances of `Hashable`- .- Note: `-f-hashable` implies `-f-unordered-containers`, as we are necessarily not able to supply those instances as well.- default: True- manual: True--flag binary- description:- You can disable the use of the `binary` package using `-f-binary`.- .- Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.- default: True- manual: True--flag bytestring- description:- You can disable the use of the `bytestring` package using `-f-bytestring`.- .- Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.- default: True- manual: True--flag bytestring-builder- description:- Decides whether to use an older version of bytestring along with bytestring-builder or just a newer version of bytestring.- .- This flag normally toggles automatically but you can use `-fbytestring-builder` or `-f-bytestring-builder` to explicitly change it.- default: False- manual: False--flag containers- description:- You can disable the use of the `containers` package using `-f-containers`.- .- Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.- default: True- manual: True--flag deepseq- description:- You can disable the use of the `deepseq` package using `-f-deepseq`.- .- Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.- default: True- manual: True--flag tagged- description:- You can disable the use of the `tagged` package using `-f-tagged`.- .- Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.- default: True- manual: True--flag template-haskell- description:- You can disable the use of the `template-haskell` package using `-f-template-haskell`.- .- Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.- default: True- manual: True--flag text- description:- You can disable the use of the `text` package using `-f-text`.- .- Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.- default: True- manual: True--flag transformers- description:- You can disable the use of the `transformers` and `transformers-compat` packages using `-f-transformers`.- .- Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.- default: True- manual: True--flag unordered-containers- description:- You can disable the use of the `unordered-containers` package using `-f-unordered-containers`.- .- Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.- default: True- manual: True+ location: https://github.com/ekmett/semigroups.git library default-language: Haskell98 hs-source-dirs: src ghc-options: -Wall - build-depends: base >= 2 && < 5-- if impl(ghc >= 7.2)- exposed-modules:- Data.Semigroup.Generic-- -- legacy configuration- if impl(ghc < 7.11.20151002)- -- starting with GHC 8 these modules are provided by `base`- hs-source-dirs: src-ghc7- exposed-modules:- Data.Semigroup- Data.List.NonEmpty-- -- Not needed anymore since GHC 7.10- if impl(ghc < 7.10)- build-depends: nats >= 0.1 && < 2-- if impl(ghc >= 7.2 && < 7.5)- build-depends: ghc-prim-- if flag(binary)- build-depends: binary-- if flag(bytestring)- if flag(bytestring-builder)- build-depends: bytestring >= 0.9 && < 0.10.4,- bytestring-builder >= 0.10.4 && < 1- else- build-depends: bytestring >= 0.10.4 && < 1-- if flag(containers)- build-depends: containers >= 0.3 && < 0.7-- if flag(deepseq)- build-depends: deepseq >= 1.1 && < 1.5-- if flag(tagged)- build-depends: tagged >= 0.4.4 && < 1-- if flag(text)- build-depends: text >= 0.10 && < 2-- if flag(hashable)- build-depends: hashable >= 1.2.5.0 && < 1.4-- if flag(hashable) && flag(unordered-containers)- build-depends: unordered-containers >= 0.2 && < 0.3-- if flag(transformers)- build-depends: transformers >= 0.2 && < 0.7- , transformers-compat >= 0.5 && < 1-- if flag(template-haskell)- build-depends: template-haskell >=2.5.0.0 && <2.11- other-modules: Paths_semigroups+ build-depends: base >= 4.9 && < 5+ exposed-modules:+ Data.Semigroup.Generic
− src-ghc7/Data/List/NonEmpty.hs
@@ -1,704 +0,0 @@-{-# LANGUAGE CPP #-}--#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702-{-# LANGUAGE Trustworthy #-}-#endif--#ifdef __GLASGOW_HASKELL__-#define LANGUAGE_DeriveDataTypeable-{-# LANGUAGE DeriveDataTypeable #-}-#endif--#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702-#define LANGUAGE_DeriveGeneric-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE EmptyDataDecls #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE TypeOperators #-}-#endif--#ifndef MIN_VERSION_base-#define MIN_VERSION_base(x,y,z) 1-#endif--------------------------------------------------------------------------------- |--- Module : Data.List.NonEmpty--- Copyright : (C) 2011-2015 Edward Kmett,--- (C) 2010 Tony Morris, Oliver Taylor, Eelis van der Weegen--- License : BSD-style (see the file LICENSE)------ Maintainer : Edward Kmett <ekmett@gmail.com>--- Stability : provisional--- Portability : portable------ A NonEmpty list forms a monad as per list, but always contains at least--- one element.-------------------------------------------------------------------------------module Data.List.NonEmpty (- -- * The type of non-empty streams- NonEmpty(..)- -- * Non-empty stream transformations- , map -- :: (a -> b) -> NonEmpty a -> NonEmpty b- , intersperse -- :: a -> NonEmpty a -> NonEmpty a- , scanl -- :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b- , scanr -- :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b- , scanl1 -- :: (a -> a -> a) -> NonEmpty a -> NonEmpty a- , scanr1 -- :: (a -> a -> a) -> NonEmpty a -> NonEmpty a- , transpose -- :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)- , sortBy -- :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a- , sortWith -- :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a- -- * Basic functions- , length -- :: NonEmpty a -> Int- , head -- :: NonEmpty a -> a- , tail -- :: NonEmpty a -> [a]- , last -- :: NonEmpty a -> a- , init -- :: NonEmpty a -> [a]- , (<|), cons -- :: a -> NonEmpty a -> NonEmpty a- , uncons -- :: NonEmpty a -> (a, Maybe (NonEmpty a))- , unfoldr -- :: (a -> (b, Maybe a)) -> a -> NonEmpty b- , sort -- :: NonEmpty a -> NonEmpty a- , reverse -- :: NonEmpty a -> NonEmpty a- , inits -- :: Foldable f => f a -> NonEmpty a- , tails -- :: Foldable f => f a -> NonEmpty a- -- * Building streams- , iterate -- :: (a -> a) -> a -> NonEmpty a- , repeat -- :: a -> NonEmpty a- , cycle -- :: NonEmpty a -> NonEmpty a- , unfold -- :: (a -> (b, Maybe a) -> a -> NonEmpty b- , insert -- :: (Foldable f, Ord a) => a -> f a -> NonEmpty a- , some1 -- :: Alternative f => f a -> f (NonEmpty a)- -- * Extracting sublists- , take -- :: Int -> NonEmpty a -> [a]- , drop -- :: Int -> NonEmpty a -> [a]- , splitAt -- :: Int -> NonEmpty a -> ([a], [a])- , takeWhile -- :: Int -> NonEmpty a -> [a]- , dropWhile -- :: Int -> NonEmpty a -> [a]- , span -- :: Int -> NonEmpty a -> ([a],[a])- , break -- :: Int -> NonEmpty a -> ([a],[a])- , filter -- :: (a -> Bool) -> NonEmpty a -> [a]- , partition -- :: (a -> Bool) -> NonEmpty a -> ([a],[a])- , group -- :: Foldable f => Eq a => f a -> [NonEmpty a]- , groupBy -- :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a]- , groupWith -- :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a]- , groupAllWith -- :: (Foldable f, Ord b) => (a -> b) -> f a -> [NonEmpty a]- , group1 -- :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a)- , groupBy1 -- :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)- , groupWith1 -- :: (Foldable f, Eq b) => (a -> b) -> f a -> NonEmpty (NonEmpty a)- , groupAllWith1 -- :: (Foldable f, Ord b) => (a -> b) -> f a -> NonEmpty (NonEmpty a)- -- * Sublist predicates- , isPrefixOf -- :: Foldable f => f a -> NonEmpty a -> Bool- -- * \"Set\" operations- , nub -- :: Eq a => NonEmpty a -> NonEmpty a- , nubBy -- :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a- -- * Indexing streams- , (!!) -- :: NonEmpty a -> Int -> a- -- * Zipping and unzipping streams- , zip -- :: NonEmpty a -> NonEmpty b -> NonEmpty (a,b)- , zipWith -- :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c- , unzip -- :: NonEmpty (a, b) -> (NonEmpty a, NonEmpty b)- -- * Converting to and from a list- , fromList -- :: [a] -> NonEmpty a- , toList -- :: NonEmpty a -> [a]- , nonEmpty -- :: [a] -> Maybe (NonEmpty a)- , xor -- :: NonEmpty a -> Bool- ) where---import qualified Prelude-import Prelude hiding- ( head, tail, map, reverse- , scanl, scanl1, scanr, scanr1- , iterate, take, drop, takeWhile- , dropWhile, repeat, cycle, filter- , (!!), zip, unzip, zipWith, words- , unwords, lines, unlines, break, span- , splitAt, foldr, foldl, last, init- , length- )--import Control.Applicative--#ifdef MIN_VERSION_deepseq-import Control.DeepSeq (NFData(..))-#endif--import Control.Monad-import Control.Monad.Fix--#if MIN_VERSION_base(4,4,0)-import Control.Monad.Zip (MonadZip(..))-#endif--#ifdef LANGUAGE_DeriveDataTypeable-import Data.Data hiding (Infix)-#endif--#if MIN_VERSION_base(4,8,0)-import Data.Foldable hiding (toList, length)-#else-import Data.Foldable hiding (toList)-import Data.Monoid (mappend)-import Data.Traversable-#endif-import qualified Data.Foldable as Foldable-import Data.Function (on)--#ifdef MIN_VERSION_hashable-import Data.Hashable-import Data.Hashable.Lifted-#endif--#ifdef MIN_VERSION_transformers-import Data.Functor.Classes (Eq1(..), Ord1(..), Read1(..), Show1(..))-#endif--import qualified Data.List as List-import Data.Ord (comparing)--#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 708-import qualified GHC.Exts as Exts-#endif--- import Data.Semigroup hiding (Last)--- import Data.Semigroup.Foldable--- import Data.Semigroup.Traversable--#ifdef LANGUAGE_DeriveGeneric-import GHC.Generics-#endif--#ifdef MIN_VERSION_template_haskell-import qualified Language.Haskell.TH.Syntax as TH-#ifndef CURRENT_PACKAGE_KEY-import Data.Version (showVersion)-import Paths_semigroups (version)-#endif-#endif--infixr 5 :|, <|--data NonEmpty a = a :| [a] deriving- ( Eq, Ord, Show, Read-#ifdef LANGUAGE_DeriveDataTypeable- , Data, Typeable-#endif-#ifdef LANGUAGE_DeriveGeneric- , Generic-#if __GLASGOW_HASKELL__ >= 706- , Generic1-#endif-#endif- )--#ifdef MIN_VERSION_hashable-instance Hashable a => Hashable (NonEmpty a) where- hashWithSalt p (a :| as) = p `hashWithSalt` a `hashWithSalt` as---- | @since 0.19.2-instance Hashable1 NonEmpty where- liftHashWithSalt h salt (a :| as) = liftHashWithSalt h (h salt a) as-#endif--#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 708-instance Exts.IsList (NonEmpty a) where- type Item (NonEmpty a) = a- fromList = fromList- toList = toList-#endif--#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL__ < 706-instance Generic1 NonEmpty where- type Rep1 NonEmpty- = D1 D1'NonEmpty- (C1 C1'_0NonEmpty- (S1 NoSelector Par1- :*: S1 NoSelector (Rec1 [])))- from1 (h :| t) = M1 (M1 (M1 (Par1 h) :*: M1 (Rec1 t)))- to1 (M1 (M1 (M1 h :*: M1 t))) = unPar1 h :| unRec1 t--instance Datatype D1'NonEmpty where- datatypeName _ = "NonEmpty"- moduleName _ = "Data.List.NonEmpty"--instance Constructor C1'_0NonEmpty where- conName _ = ":|"- conFixity _ = Infix RightAssociative 5--data D1'NonEmpty-data C1'_0NonEmpty-#endif--#ifdef MIN_VERSION_deepseq-instance NFData a => NFData (NonEmpty a) where- rnf (x :| xs) = rnf x `seq` rnf xs-#endif--instance MonadFix NonEmpty where- mfix f = case fix (f . head) of- ~(x :| _) -> x :| mfix (tail . f)--#if MIN_VERSION_base(4,4,0)-instance MonadZip NonEmpty where- mzip = zip- mzipWith = zipWith- munzip = unzip-#endif--#ifdef MIN_VERSION_transformers-# if !(MIN_VERSION_transformers(0,4,0)) || MIN_VERSION_transformers(0,5,0)-instance Eq1 NonEmpty where- liftEq eq (a :| as) (b :| bs) = eq a b && liftEq eq as bs--instance Ord1 NonEmpty where- liftCompare cmp (a :| as) (b :| bs) = cmp a b `mappend` liftCompare cmp as bs--instance Read1 NonEmpty where- liftReadsPrec rdP rdL p s = readParen (p > 5) (\s' -> do- (a, s'') <- rdP 6 s'- (":|", s''') <- lex s''- (as, s'''') <- rdL s'''- return (a :| as, s'''')) s--instance Show1 NonEmpty where- liftShowsPrec shwP shwL p (a :| as) = showParen (p > 5) $- shwP 6 a . showString " :| " . shwL as-# else-instance Eq1 NonEmpty where- eq1 (a :| as) (b :| bs) = a == b && as == bs--instance Ord1 NonEmpty where- compare1 (a :| as) (b :| bs) = compare a b `mappend` compare as bs--instance Read1 NonEmpty where- readsPrec1 p s = readParen (p > 5) (\s' -> do- (a, s'') <- readsPrec 6 s'- (":|", s''') <- lex s''- (as, s'''') <- readList s'''- return (a :| as, s'''')) s--instance Show1 NonEmpty where- showsPrec1 p (a :| as) = showParen (p > 5) $- showsPrec 6 a . showString " :| " . showList as-# endif-#endif--length :: NonEmpty a -> Int-length (_ :| xs) = 1 + Prelude.length xs-{-# INLINE length #-}--xor :: NonEmpty Bool -> Bool-xor (x :| xs) = foldr xor' x xs- where xor' True y = not y- xor' False y = y---- | 'unfold' produces a new stream by repeatedly applying the unfolding--- function to the seed value to produce an element of type @b@ and a new--- seed value. When the unfolding function returns 'Nothing' instead of--- a new seed value, the stream ends.-unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b-unfold f a = case f a of- (b, Nothing) -> b :| []- (b, Just c) -> b <| unfold f c---- | 'nonEmpty' efficiently turns a normal list into a 'NonEmpty' stream,--- producing 'Nothing' if the input is empty.-nonEmpty :: [a] -> Maybe (NonEmpty a)-nonEmpty [] = Nothing-nonEmpty (a:as) = Just (a :| as)-{-# INLINE nonEmpty #-}---- | 'uncons' produces the first element of the stream, and a stream of the--- remaining elements, if any.-uncons :: NonEmpty a -> (a, Maybe (NonEmpty a))-uncons ~(a :| as) = (a, nonEmpty as)-{-# INLINE uncons #-}--unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b-unfoldr f a = case f a of- (b, mc) -> b :| maybe [] go mc- where- go c = case f c of- (d, me) -> d : maybe [] go me--instance Functor NonEmpty where- fmap f ~(a :| as) = f a :| fmap f as-#if MIN_VERSION_base(4,2,0)- b <$ ~(_ :| as) = b :| (b <$ as)-#endif--instance Applicative NonEmpty where- pure a = a :| []- (<*>) = ap--instance Monad NonEmpty where- return a = a :| []- ~(a :| as) >>= f = b :| (bs ++ bs')- where b :| bs = f a- bs' = as >>= toList . f--instance Traversable NonEmpty where- traverse f ~(a :| as) = (:|) <$> f a <*> traverse f as--instance Foldable NonEmpty where- foldr f z ~(a :| as) = f a (foldr f z as)- foldl f z ~(a :| as) = foldl f (f z a) as- foldl1 f ~(a :| as) = foldl f a as- foldMap f ~(a :| as) = f a `mappend` foldMap f as- fold ~(m :| ms) = m `mappend` fold ms-#if MIN_VERSION_base(4,8,0)- length = length- toList = toList-#endif--#ifdef MIN_VERSION_template_haskell--- | @since 0.19-instance TH.Lift a => TH.Lift (NonEmpty a) where- lift (x :| xs) = do- x' <- TH.lift x- xs' <- TH.lift xs- return $ TH.InfixE (Just x') (TH.ConE neConsName) (Just xs')- where- neConsName = TH.mkNameG_d semigroupsPackageKey "Data.List.NonEmpty" ":|"--semigroupsPackageKey :: String-#ifdef CURRENT_PACKAGE_KEY-semigroupsPackageKey = CURRENT_PACKAGE_KEY-#else-semigroupsPackageKey = "semigroups-" ++ showVersion version-#endif-#endif---- | Extract the first element of the stream.-head :: NonEmpty a -> a-head ~(a :| _) = a-{-# INLINE head #-}---- | Extract the possibly-empty tail of the stream.-tail :: NonEmpty a -> [a]-tail ~(_ :| as) = as-{-# INLINE tail #-}---- | Extract the last element of the stream.-last :: NonEmpty a -> a-last ~(a :| as) = List.last (a : as)-{-# INLINE last #-}---- | Extract everything except the last element of the stream.-init :: NonEmpty a -> [a]-init ~(a :| as) = List.init (a : as)-{-# INLINE init #-}---- | Prepend an element to the stream.-(<|) :: a -> NonEmpty a -> NonEmpty a-a <| ~(b :| bs) = a :| b : bs-{-# INLINE (<|) #-}---- | Synonym for '<|'.-cons :: a -> NonEmpty a -> NonEmpty a-cons = (<|)-{-# INLINE cons #-}---- | Sort a stream.-sort :: Ord a => NonEmpty a -> NonEmpty a-sort = lift List.sort-{-# INLINE sort #-}---- | Converts a normal list to a 'NonEmpty' stream.------ Raises an error if given an empty list.-fromList :: [a] -> NonEmpty a-fromList (a:as) = a :| as-fromList [] = error "NonEmpty.fromList: empty list"-{-# INLINE fromList #-}---- | Convert a stream to a normal list efficiently.-toList :: NonEmpty a -> [a]-toList ~(a :| as) = a : as-{-# INLINE toList #-}---- | Lift list operations to work on a 'NonEmpty' stream.------ /Beware/: If the provided function returns an empty list,--- this will raise an error.-lift :: Foldable f => ([a] -> [b]) -> f a -> NonEmpty b-lift f = fromList . f . Foldable.toList-{-# INLINE lift #-}---- | Map a function over a 'NonEmpty' stream.-map :: (a -> b) -> NonEmpty a -> NonEmpty b-map f ~(a :| as) = f a :| fmap f as-{-# INLINE map #-}---- | The 'inits' function takes a stream @xs@ and returns all the--- finite prefixes of @xs@.-inits :: Foldable f => f a -> NonEmpty [a]-inits = fromList . List.inits . Foldable.toList-{-# INLINE inits #-}---- | The 'tails' function takes a stream @xs@ and returns all the--- suffixes of @xs@.-tails :: Foldable f => f a -> NonEmpty [a]-tails = fromList . List.tails . Foldable.toList-{-# INLINE tails #-}---- | @'insert' x xs@ inserts @x@ into the last position in @xs@ where it--- is still less than or equal to the next element. In particular, if the--- list is sorted beforehand, the result will also be sorted.-insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a-insert a = fromList . List.insert a . Foldable.toList-{-# INLINE insert #-}---- | @'some1' x@ sequences @x@ one or more times.-some1 :: Alternative f => f a -> f (NonEmpty a)-some1 x = (:|) <$> x <*> many x-{-# INLINE some1 #-}---- | 'scanl' is similar to 'foldl', but returns a stream of successive--- reduced values from the left:------ > scanl f z [x1, x2, ...] == z :| [z `f` x1, (z `f` x1) `f` x2, ...]------ Note that------ > last (scanl f z xs) == foldl f z xs.-scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b-scanl f z = fromList . List.scanl f z . Foldable.toList-{-# INLINE scanl #-}---- | 'scanr' is the right-to-left dual of 'scanl'.--- Note that------ > head (scanr f z xs) == foldr f z xs.-scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b-scanr f z = fromList . List.scanr f z . Foldable.toList-{-# INLINE scanr #-}---- | 'scanl1' is a variant of 'scanl' that has no starting value argument:------ > scanl1 f [x1, x2, ...] == x1 :| [x1 `f` x2, x1 `f` (x2 `f` x3), ...]-scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a-scanl1 f ~(a :| as) = fromList (List.scanl f a as)-{-# INLINE scanl1 #-}---- | 'scanr1' is a variant of 'scanr' that has no starting value argument.-scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a-scanr1 f ~(a :| as) = fromList (List.scanr1 f (a:as))-{-# INLINE scanr1 #-}---- | 'intersperse x xs' alternates elements of the list with copies of @x@.------ > intersperse 0 (1 :| [2,3]) == 1 :| [0,2,0,3]-intersperse :: a -> NonEmpty a -> NonEmpty a-intersperse a ~(b :| bs) = b :| case bs of- [] -> []- _ -> a : List.intersperse a bs-{-# INLINE intersperse #-}---- | @'iterate' f x@ produces the infinite sequence--- of repeated applications of @f@ to @x@.------ > iterate f x = x :| [f x, f (f x), ..]-iterate :: (a -> a) -> a -> NonEmpty a-iterate f a = a :| List.iterate f (f a)-{-# INLINE iterate #-}---- | @'cycle' xs@ returns the infinite repetition of @xs@:------ > cycle (1 :| [2,3]) = 1 :| [2,3,1,2,3,...]-cycle :: NonEmpty a -> NonEmpty a-cycle = fromList . List.cycle . toList-{-# INLINE cycle #-}---- | 'reverse' a finite NonEmpty stream.-reverse :: NonEmpty a -> NonEmpty a-reverse = lift List.reverse-{-# INLINE reverse #-}---- | @'repeat' x@ returns a constant stream, where all elements are--- equal to @x@.-repeat :: a -> NonEmpty a-repeat a = a :| List.repeat a-{-# INLINE repeat #-}---- | @'take' n xs@ returns the first @n@ elements of @xs@.-take :: Int -> NonEmpty a -> [a]-take n = List.take n . toList-{-# INLINE take #-}---- | @'drop' n xs@ drops the first @n@ elements off the front of--- the sequence @xs@.-drop :: Int -> NonEmpty a -> [a]-drop n = List.drop n . toList-{-# INLINE drop #-}---- | @'splitAt' n xs@ returns a pair consisting of the prefix of @xs@--- of length @n@ and the remaining stream immediately following this prefix.------ > 'splitAt' n xs == ('take' n xs, 'drop' n xs)--- > xs == ys ++ zs where (ys, zs) = 'splitAt' n xs-splitAt :: Int -> NonEmpty a -> ([a],[a])-splitAt n = List.splitAt n . toList-{-# INLINE splitAt #-}---- | @'takeWhile' p xs@ returns the longest prefix of the stream--- @xs@ for which the predicate @p@ holds.-takeWhile :: (a -> Bool) -> NonEmpty a -> [a]-takeWhile p = List.takeWhile p . toList-{-# INLINE takeWhile #-}---- | @'dropWhile' p xs@ returns the suffix remaining after--- @'takeWhile' p xs@.-dropWhile :: (a -> Bool) -> NonEmpty a -> [a]-dropWhile p = List.dropWhile p . toList-{-# INLINE dropWhile #-}---- | @'span' p xs@ returns the longest prefix of @xs@ that satisfies--- @p@, together with the remainder of the stream.------ > 'span' p xs == ('takeWhile' p xs, 'dropWhile' p xs)--- > xs == ys ++ zs where (ys, zs) = 'span' p xs-span :: (a -> Bool) -> NonEmpty a -> ([a], [a])-span p = List.span p . toList-{-# INLINE span #-}---- | The @'break' p@ function is equivalent to @'span' (not . p)@.-break :: (a -> Bool) -> NonEmpty a -> ([a], [a])-break p = span (not . p)-{-# INLINE break #-}---- | @'filter' p xs@ removes any elements from @xs@ that do not satisfy @p@.-filter :: (a -> Bool) -> NonEmpty a -> [a]-filter p = List.filter p . toList-{-# INLINE filter #-}---- | The 'partition' function takes a predicate @p@ and a stream--- @xs@, and returns a pair of lists. The first list corresponds to the--- elements of @xs@ for which @p@ holds; the second corresponds to the--- elements of @xs@ for which @p@ does not hold.------ > 'partition' p xs = ('filter' p xs, 'filter' (not . p) xs)-partition :: (a -> Bool) -> NonEmpty a -> ([a], [a])-partition p = List.partition p . toList-{-# INLINE partition #-}---- | The 'group' function takes a stream and returns a list of--- streams such that flattening the resulting list is equal to the--- argument. Moreover, each stream in the resulting list--- contains only equal elements. For example, in list notation:------ > 'group' $ 'cycle' "Mississippi" = "M" : "i" : "ss" : "i" : "ss" : "i" : "pp" : "i" : "M" : "i" : ...-group :: (Foldable f, Eq a) => f a -> [NonEmpty a]-group = groupBy (==)-{-# INLINE group #-}---- | 'groupBy' operates like 'group', but uses the provided equality--- predicate instead of `==`.-groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a]-groupBy eq0 = go eq0 . Foldable.toList- where- go _ [] = []- go eq (x : xs) = (x :| ys) : groupBy eq zs- where (ys, zs) = List.span (eq x) xs---- | 'groupWith' operates like 'group', but uses the provided projection when--- comparing for equality-groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a]-groupWith f = groupBy ((==) `on` f)-{-# INLINE groupWith #-}---- | 'groupAllWith' operates like 'groupWith', but sorts the list first so that each--- equivalence class has, at most, one list in the output-groupAllWith :: (Ord b) => (a -> b) -> [a] -> [NonEmpty a]-groupAllWith f = groupWith f . List.sortBy (compare `on` f)-{-# INLINE groupAllWith #-}---- | 'group1' operates like 'group', but uses the knowledge that its--- input is non-empty to produce guaranteed non-empty output.-group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a)-group1 = groupBy1 (==)-{-# INLINE group1 #-}---- | 'groupBy1' is to 'group1' as 'groupBy' is to 'group'.-groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)-groupBy1 eq (x :| xs) = (x :| ys) :| groupBy eq zs- where (ys, zs) = List.span (eq x) xs-{-# INLINE groupBy1 #-}---- | 'groupWith1' is to 'group1' as 'groupWith' is to 'group'-groupWith1 :: (Eq b) => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)-groupWith1 f = groupBy1 ((==) `on` f)-{-# INLINE groupWith1 #-}---- | 'groupAllWith1' is to 'groupWith1' as 'groupAllWith' is to 'groupWith'-groupAllWith1 :: (Ord b) => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)-groupAllWith1 f = groupWith1 f . sortWith f-{-# INLINE groupAllWith1 #-}---- | The 'isPrefix' function returns @True@ if the first argument is--- a prefix of the second.-isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool-isPrefixOf [] _ = True-isPrefixOf (y:ys) (x :| xs) = (y == x) && List.isPrefixOf ys xs-{-# INLINE isPrefixOf #-}---- | @xs !! n@ returns the element of the stream @xs@ at index--- @n@. Note that the head of the stream has index 0.------ /Beware/: a negative or out-of-bounds index will cause an error.-(!!) :: NonEmpty a -> Int -> a-(!!) ~(x :| xs) n- | n == 0 = x- | n > 0 = xs List.!! (n - 1)- | otherwise = error "NonEmpty.!! negative argument"-{-# INLINE (!!) #-}-infixl 9 !!---- | The 'zip' function takes two streams and returns a stream of--- corresponding pairs.-zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a,b)-zip ~(x :| xs) ~(y :| ys) = (x, y) :| List.zip xs ys-{-# INLINE zip #-}---- | The 'zipWith' function generalizes 'zip'. Rather than tupling--- the elements, the elements are combined using the function--- passed as the first argument.-zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c-zipWith f ~(x :| xs) ~(y :| ys) = f x y :| List.zipWith f xs ys-{-# INLINE zipWith #-}---- | The 'unzip' function is the inverse of the 'zip' function.-unzip :: Functor f => f (a,b) -> (f a, f b)-unzip xs = (fst <$> xs, snd <$> xs)-{-# INLINE unzip #-}---- | The 'nub' function removes duplicate elements from a list. In--- particular, it keeps only the first occurrence of each element.--- (The name 'nub' means \'essence\'.)--- It is a special case of 'nubBy', which allows the programmer to--- supply their own inequality test.-nub :: Eq a => NonEmpty a -> NonEmpty a-nub = nubBy (==)---- | The 'nubBy' function behaves just like 'nub', except it uses a--- user-supplied equality predicate instead of the overloaded '=='--- function.-nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a-nubBy eq (a :| as) = a :| List.nubBy eq (List.filter (\b -> not (eq a b)) as)---- | 'transpose' for 'NonEmpty', behaves the same as 'Data.List.transpose'--- The rows/columns need not be the same length, in which case--- > transpose . transpose /= id-transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)-transpose = fmap fromList- . fromList . List.transpose . toList- . fmap toList---- | 'sortBy' for 'NonEmpty', behaves the same as 'Data.List.sortBy'-sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a-sortBy f = lift (List.sortBy f)---- | 'sortWith' for 'NonEmpty', behaves the same as:------ > sortBy . comparing-sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a-sortWith = sortBy . comparing
− src-ghc7/Data/Semigroup.hs
@@ -1,1249 +0,0 @@-{-# LANGUAGE CPP #-}--#ifdef __GLASGOW_HASKELL__-#define LANGUAGE_DeriveDataTypeable-{-# LANGUAGE DeriveDataTypeable #-}-#endif--#if __GLASGOW_HASKELL__ >= 702-{-# LANGUAGE Trustworthy #-}-#endif--#if __GLASGOW_HASKELL__ >= 702-#define LANGUAGE_DeriveGeneric-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE EmptyDataDecls #-}-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE TypeOperators #-}-#endif--#if __GLASGOW_HASKELL__ >= 706-{-# LANGUAGE PolyKinds #-}-#endif--#if __GLASGOW_HASKELL__ >= 708-#define USE_COERCE-{-# LANGUAGE ScopedTypeVariables #-}-#endif--#ifndef MIN_VERSION_base-#define MIN_VERSION_base(x,y,z) 1-#endif---------------------------------------------------------------------------------- |--- Module : Data.Semigroup--- Copyright : (C) 2011-2015 Edward Kmett--- License : BSD-style (see the file LICENSE)------ Maintainer : Edward Kmett <ekmett@gmail.com>--- Stability : provisional--- Portability : portable------ In mathematics, a semigroup is an algebraic structure consisting of a--- set together with an associative binary operation. A semigroup--- generalizes a monoid in that there might not exist an identity--- element. It also (originally) generalized a group (a monoid with all--- inverses) to a type where every element did not have to have an inverse,--- thus the name semigroup.------ The use of @(\<\>)@ in this module conflicts with an operator with the same--- name that is being exported by Data.Monoid. However, this package--- re-exports (most of) the contents of Data.Monoid, so to use semigroups--- and monoids in the same package just------ > import Data.Semigroup---------------------------------------------------------------------------------module Data.Semigroup (- Semigroup(..)- , stimesMonoid- , stimesIdempotent- , stimesIdempotentMonoid- , mtimesDefault- -- * Semigroups- , Min(..)- , Max(..)- , First(..)- , Last(..)- , WrappedMonoid(..)- -- * Re-exported monoids from Data.Monoid- , Monoid(..)- , Dual(..)- , Endo(..)- , All(..)- , Any(..)- , Sum(..)- , Product(..)- -- * A better monoid for Maybe- , Option(..)- , option- -- * Difference lists of a semigroup- , diff- , cycle1- -- * ArgMin, ArgMax- , Arg(..)- , ArgMin- , ArgMax- ) where--import Prelude hiding (foldr1)--#if MIN_VERSION_base(4,8,0)-import Data.Bifunctor-import Data.Void-#else-import Data.Monoid (Monoid(..))-import Data.Foldable-import Data.Traversable-#endif--import Data.Monoid (Dual(..),Endo(..),All(..),Any(..),Sum(..),Product(..))-#if MIN_VERSION_base(4,8,0)-import Data.Monoid (Alt(..))-#endif--import Control.Applicative-import Control.Monad-import Control.Monad.Fix-import qualified Control.Monad.ST as Strict-import qualified Data.Monoid as Monoid-import Data.List.NonEmpty (NonEmpty(..))-#if MIN_VERSION_base(4,6,0)-import Data.Ord (Down(..))-#else-import GHC.Exts (Down(..))-#endif-#if MIN_VERSION_base(4,4,0) && !defined(mingw32_HOST_OS) && !defined(ghcjs_HOST_OS) && !defined(ETA_VERSION)-import GHC.Event-#endif--#ifdef MIN_VERSION_deepseq-import Control.DeepSeq (NFData(..))-#endif--#ifdef MIN_VERSION_containers-import Data.Sequence (Seq, (><))-import Data.Set (Set)-import Data.IntSet (IntSet)-import Data.Map (Map)-import Data.IntMap (IntMap)-#endif--#ifdef MIN_VERSION_binary-# if !(MIN_VERSION_binary(0,8,3))-import qualified Data.Binary.Builder as Builder-# endif-#endif--#ifdef MIN_VERSION_bytestring-import Data.ByteString as BS-import Data.ByteString.Lazy as BL--# if (MIN_VERSION_bytestring(0,10,2)) || defined(MIN_VERSION_bytestring_builder)-import qualified Data.ByteString.Builder as ByteString-# elif MIN_VERSION_bytestring(0,10,0)-import qualified Data.ByteString.Lazy.Builder as ByteString-# endif--# if (MIN_VERSION_bytestring(0,10,4)) || defined(MIN_VERSION_bytestring_builder)-import Data.ByteString.Short-# endif-#endif--#if (MIN_VERSION_base(4,8,0)) || defined(MIN_VERSION_transformers)-import Data.Functor.Identity-#endif--#if (MIN_VERSION_base(4,7,0)) || defined(MIN_VERSION_tagged)-import Data.Proxy-#endif--#ifdef MIN_VERSION_tagged-import Data.Tagged-#endif--#ifdef MIN_VERSION_text-import qualified Data.Text as TS-import qualified Data.Text.Lazy as TL-import qualified Data.Text.Lazy.Builder as Text-#endif--#ifdef MIN_VERSION_hashable-import Data.Hashable-import Data.Hashable.Lifted-#endif--#ifdef MIN_VERSION_unordered_containers-import Data.HashMap.Lazy as Lazy-import Data.HashSet (HashSet)-#endif--#ifdef LANGUAGE_DeriveDataTypeable-import Data.Data-#endif--#ifdef LANGUAGE_DeriveGeneric-import GHC.Generics-#endif--#ifdef USE_COERCE-import Data.Coerce-#endif--infixr 6 <>--class Semigroup a where- -- | An associative operation.- --- -- @- -- (a '<>' b) '<>' c = a '<>' (b '<>' c)- -- @- --- -- If @a@ is also a 'Monoid' we further require- --- -- @- -- ('<>') = 'mappend'- -- @- (<>) :: a -> a -> a-- -- | Reduce a non-empty list with @\<\>@- --- -- The default definition should be sufficient, but this can be overridden for efficiency.- --- sconcat :: NonEmpty a -> a- sconcat (a :| as) = go a as where- go b (c:cs) = b <> go c cs- go b [] = b-- -- | Repeat a value @n@ times.- --- -- Given that this works on a 'Semigroup' it is allowed to fail if you request 0 or fewer- -- repetitions, and the default definition will do so.- --- -- By making this a member of the class, idempotent semigroups and monoids can upgrade this to execute in- -- /O(1)/ by picking @stimes = stimesIdempotent@ or @stimes = stimesIdempotentMonoid@ respectively.- --- -- @since 0.17- stimes :: Integral b => b -> a -> a- stimes y0 x0- | y0 <= 0 = error "stimes: positive multiplier expected"- | otherwise = f x0 y0- where- f x y- | even y = f (x <> x) (y `quot` 2)- | y == 1 = x- | otherwise = g (x <> x) (y `quot` 2) x -- See Note [Half of y - 1]- g x y z- | even y = g (x <> x) (y `quot` 2) z- | y == 1 = x <> z- | otherwise = g (x <> x) (y `quot` 2) (x <> z) -- See Note [Half of y - 1]- {-# INLINE stimes #-}--{- Note [Half of y - 1]- ~~~~~~~~~~~~~~~~~~~~~- Since y is guaranteed to be odd and positive here,- half of y - 1 can be computed as y `quot` 2, optimising subtraction away.--}---- | A generalization of 'Data.List.cycle' to an arbitrary 'Semigroup'.--- May fail to terminate for some values in some semigroups.-cycle1 :: Semigroup m => m -> m-cycle1 xs = xs' where xs' = xs <> xs'--instance Semigroup () where- _ <> _ = ()- sconcat _ = ()- stimes _ _ = ()--instance Semigroup b => Semigroup (a -> b) where- f <> g = \a -> f a <> g a- stimes n f e = stimes n (f e)--instance Semigroup [a] where- (<>) = (++)- stimes n x- | n < 0 = error "stimes: [], negative multiplier"- | otherwise = rep n- where- rep 0 = []- rep i = x ++ rep (i - 1)--instance Semigroup a => Semigroup (Maybe a) where- Nothing <> b = b- a <> Nothing = a- Just a <> Just b = Just (a <> b)- stimes _ Nothing = Nothing- stimes n (Just a) = case compare n 0 of- LT -> error "stimes: Maybe, negative multiplier"- EQ -> Nothing- GT -> Just (stimes n a)--instance Semigroup (Either a b) where- Left _ <> b = b- a <> _ = a- stimes = stimesIdempotent--instance (Semigroup a, Semigroup b) => Semigroup (a, b) where- (a,b) <> (a',b') = (a<>a',b<>b')- stimes n (a,b) = (stimes n a, stimes n b)--instance (Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c) where- (a,b,c) <> (a',b',c') = (a<>a',b<>b',c<>c')- stimes n (a,b,c) = (stimes n a, stimes n b, stimes n c)--instance (Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d) where- (a,b,c,d) <> (a',b',c',d') = (a<>a',b<>b',c<>c',d<>d')- stimes n (a,b,c,d) = (stimes n a, stimes n b, stimes n c, stimes n d)--instance (Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e) where- (a,b,c,d,e) <> (a',b',c',d',e') = (a<>a',b<>b',c<>c',d<>d',e<>e')- stimes n (a,b,c,d,e) = (stimes n a, stimes n b, stimes n c, stimes n d, stimes n e)--instance Semigroup Ordering where- LT <> _ = LT- EQ <> y = y- GT <> _ = GT- stimes = stimesIdempotentMonoid--instance Semigroup a => Semigroup (Dual a) where- Dual a <> Dual b = Dual (b <> a)- stimes n (Dual a) = Dual (stimes n a)--instance Semigroup (Endo a) where-#ifdef USE_COERCE- (<>) = coerce ((.) :: (a -> a) -> (a -> a) -> (a -> a))-#else- Endo f <> Endo g = Endo (f . g)-#endif- stimes = stimesMonoid--instance Semigroup All where-#ifdef USE_COERCE- (<>) = coerce (&&)-#else- All a <> All b = All (a && b)-#endif-- stimes = stimesIdempotentMonoid--instance Semigroup Any where-#ifdef USE_COERCE- (<>) = coerce (||)-#else- Any a <> Any b = Any (a || b)-#endif-- stimes = stimesIdempotentMonoid---instance Num a => Semigroup (Sum a) where-#ifdef USE_COERCE- (<>) = coerce ((+) :: a -> a -> a)-#else- Sum a <> Sum b = Sum (a + b)-#endif- stimes n (Sum a) = Sum (fromIntegral n * a)--instance Num a => Semigroup (Product a) where-#ifdef USE_COERCE- (<>) = coerce ((*) :: a -> a -> a)-#else- Product a <> Product b = Product (a * b)-#endif- stimes n (Product a) = Product (a ^ n)--instance Semigroup a => Semigroup (Down a) where-#ifdef USE_COERCE- (<>) = coerce ((<>) :: a -> a -> a)-#else- Down a <> Down b = Down (a <> b)-#endif- stimes n (Down a) = Down (stimes n a)---- | This is a valid definition of 'stimes' for a 'Monoid'.------ Unlike the default definition of 'stimes', it is defined for 0--- and so it should be preferred where possible.-stimesMonoid :: (Integral b, Monoid a) => b -> a -> a-stimesMonoid n x0 = case compare n 0 of- LT -> error "stimesMonoid: negative multiplier"- EQ -> mempty- GT -> f x0 n- where- f x y- | even y = f (x `mappend` x) (y `quot` 2)- | y == 1 = x- | otherwise = g (x `mappend` x) (y `quot` 2) x -- See Note [Half of y - 1]- g x y z- | even y = g (x `mappend` x) (y `quot` 2) z- | y == 1 = x `mappend` z- | otherwise = g (x `mappend` x) (y `quot` 2) (x `mappend` z) -- See Note [Half of y - 1]---- | This is a valid definition of 'stimes' for an idempotent 'Monoid'.------ When @mappend x x = x@, this definition should be preferred, because it--- works in /O(1)/ rather than /O(log n)/-stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a-stimesIdempotentMonoid n x = case compare n 0 of- LT -> error "stimesIdempotentMonoid: negative multiplier"- EQ -> mempty- GT -> x-{-# INLINE stimesIdempotentMonoid #-}---- | This is a valid definition of 'stimes' for an idempotent 'Semigroup'.------ When @x <> x = x@, this definition should be preferred, because it--- works in /O(1)/ rather than /O(log n)/.-stimesIdempotent :: Integral b => b -> a -> a-stimesIdempotent n x- | n <= 0 = error "stimesIdempotent: positive multiplier expected"- | otherwise = x-{-# INLINE stimesIdempotent #-}--instance Semigroup a => Semigroup (Const a b) where-#ifdef USE_COERCE- (<>) = coerce ((<>) :: a -> a -> a)-#else- Const a <> Const b = Const (a <> b)-#endif- stimes n (Const a) = Const (stimes n a)--#if MIN_VERSION_base(3,0,0)-instance Semigroup (Monoid.First a) where- Monoid.First Nothing <> b = b- a <> _ = a- stimes = stimesIdempotentMonoid--instance Semigroup (Monoid.Last a) where- a <> Monoid.Last Nothing = a- _ <> b = b- stimes = stimesIdempotentMonoid-#endif--#if MIN_VERSION_base(4,8,0)-instance Alternative f => Semigroup (Alt f a) where-# ifdef USE_COERCE- (<>) = coerce ((<|>) :: f a -> f a -> f a)-# else- Alt a <> Alt b = Alt (a <|> b)-# endif- stimes = stimesMonoid-#endif--#if MIN_VERSION_base(4,8,0)-instance Semigroup Void where- a <> _ = a- stimes = stimesIdempotent-#endif--instance Semigroup (NonEmpty a) where- (a :| as) <> ~(b :| bs) = a :| (as ++ b : bs)---newtype Min a = Min { getMin :: a } deriving- ( Eq, Ord, Show, Read-#ifdef LANGUAGE_DeriveDataTypeable- , Data, Typeable-#endif-#ifdef LANGUAGE_DeriveGeneric- , Generic-#if __GLASGOW_HASKELL__ >= 706- , Generic1-#endif-#endif- )--instance Bounded a => Bounded (Min a) where- minBound = Min minBound- maxBound = Min maxBound--instance Enum a => Enum (Min a) where- succ (Min a) = Min (succ a)- pred (Min a) = Min (pred a)- toEnum = Min . toEnum- fromEnum = fromEnum . getMin- enumFrom (Min a) = Min <$> enumFrom a- enumFromThen (Min a) (Min b) = Min <$> enumFromThen a b- enumFromTo (Min a) (Min b) = Min <$> enumFromTo a b- enumFromThenTo (Min a) (Min b) (Min c) = Min <$> enumFromThenTo a b c--#ifdef MIN_VERSION_hashable-instance Hashable a => Hashable (Min a) where- hashWithSalt p (Min a) = hashWithSalt p a---- | @since 0.19.2-instance Hashable1 Min where- liftHashWithSalt h salt (Min a) = h salt a-#endif--instance Ord a => Semigroup (Min a) where-#ifdef USE_COERCE- (<>) = coerce (min :: a -> a -> a)-#else- Min a <> Min b = Min (a `min` b)-#endif- stimes = stimesIdempotent--instance (Ord a, Bounded a) => Monoid (Min a) where- mempty = maxBound- mappend = (<>)--instance Functor Min where- fmap f (Min x) = Min (f x)--instance Foldable Min where- foldMap f (Min a) = f a--instance Traversable Min where- traverse f (Min a) = Min <$> f a--instance Applicative Min where- pure = Min- a <* _ = a- _ *> a = a- Min f <*> Min x = Min (f x)--instance Monad Min where- return = Min- _ >> a = a- Min a >>= f = f a--instance MonadFix Min where- mfix f = fix (f . getMin)--#ifdef MIN_VERSION_deepseq-instance NFData a => NFData (Min a) where- rnf (Min a) = rnf a-#endif--instance Num a => Num (Min a) where- (Min a) + (Min b) = Min (a + b)- (Min a) * (Min b) = Min (a * b)- (Min a) - (Min b) = Min (a - b)- negate (Min a) = Min (negate a)- abs (Min a) = Min (abs a)- signum (Min a) = Min (signum a)- fromInteger = Min . fromInteger--#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL__ < 706-instance Generic1 Min where- type Rep1 Min = D1 D1'Min (C1 C1'_0Min (S1 S1'_0_0Min Par1))- from1 (Min x) = M1 (M1 (M1 (Par1 x)))- to1 (M1 (M1 (M1 x))) = Min (unPar1 x)--instance Datatype D1'Min where- datatypeName _ = "Min"- moduleName _ = "Data.Semigroup"--instance Constructor C1'_0Min where- conName _ = "Min"- conIsRecord _ = True--instance Selector S1'_0_0Min where- selName _ = "getMin"--data D1'Min-data C1'_0Min-data S1'_0_0Min-#endif--newtype Max a = Max { getMax :: a } deriving- ( Eq, Ord, Show, Read-#ifdef LANGUAGE_DeriveDataTypeable- , Data, Typeable-#endif-#ifdef LANGUAGE_DeriveGeneric- , Generic-#if __GLASGOW_HASKELL__ >= 706- , Generic1-#endif-#endif- )--instance Bounded a => Bounded (Max a) where- minBound = Max minBound- maxBound = Max maxBound--instance Enum a => Enum (Max a) where- succ (Max a) = Max (succ a)- pred (Max a) = Max (pred a)- toEnum = Max . toEnum- fromEnum = fromEnum . getMax- enumFrom (Max a) = Max <$> enumFrom a- enumFromThen (Max a) (Max b) = Max <$> enumFromThen a b- enumFromTo (Max a) (Max b) = Max <$> enumFromTo a b- enumFromThenTo (Max a) (Max b) (Max c) = Max <$> enumFromThenTo a b c--#ifdef MIN_VERSION_hashable-instance Hashable a => Hashable (Max a) where- hashWithSalt p (Max a) = hashWithSalt p a---- | @since 0.19.2-instance Hashable1 Max where- liftHashWithSalt h salt (Max a) = h salt a-#endif--instance Ord a => Semigroup (Max a) where-#ifdef USE_COERCE- (<>) = coerce (max :: a -> a -> a)-#else- Max a <> Max b = Max (a `max` b)-#endif- stimes = stimesIdempotent--instance (Ord a, Bounded a) => Monoid (Max a) where- mempty = minBound- mappend = (<>)--instance Functor Max where- fmap f (Max x) = Max (f x)--instance Foldable Max where- foldMap f (Max a) = f a--instance Traversable Max where- traverse f (Max a) = Max <$> f a--instance Applicative Max where- pure = Max- a <* _ = a- _ *> a = a- Max f <*> Max x = Max (f x)--instance Monad Max where- return = Max- _ >> a = a- Max a >>= f = f a--instance MonadFix Max where- mfix f = fix (f . getMax)--#ifdef MIN_VERSION_deepseq-instance NFData a => NFData (Max a) where- rnf (Max a) = rnf a-#endif--instance Num a => Num (Max a) where- (Max a) + (Max b) = Max (a + b)- (Max a) * (Max b) = Max (a * b)- (Max a) - (Max b) = Max (a - b)- negate (Max a) = Max (negate a)- abs (Max a) = Max (abs a)- signum (Max a) = Max (signum a)- fromInteger = Max . fromInteger--#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL__ < 706-instance Generic1 Max where- type Rep1 Max = D1 D1'Max (C1 C1'_0Max (S1 S1'_0_0Max Par1))- from1 (Max x) = M1 (M1 (M1 (Par1 x)))- to1 (M1 (M1 (M1 x))) = Max (unPar1 x)--instance Datatype D1'Max where- datatypeName _ = "Max"- moduleName _ = "Data.Semigroup"--instance Constructor C1'_0Max where- conName _ = "Max"- conIsRecord _ = True--instance Selector S1'_0_0Max where- selName _ = "getMax"--data D1'Max-data C1'_0Max-data S1'_0_0Max-#endif---- | 'Arg' isn't itself a 'Semigroup' in its own right, but it can be placed inside 'Min' and 'Max'--- to compute an arg min or arg max.-data Arg a b = Arg a b deriving- ( Show, Read-#ifdef LANGUAGE_DeriveDataTypeable- , Data, Typeable-#endif-#ifdef LANGUAGE_DeriveGeneric- , Generic-#if __GLASGOW_HASKELL__ >= 706- , Generic1-#endif-#endif- )--type ArgMin a b = Min (Arg a b)-type ArgMax a b = Max (Arg a b)--instance Functor (Arg a) where- fmap f (Arg x a) = Arg x (f a)--instance Foldable (Arg a) where- foldMap f (Arg _ a) = f a--instance Traversable (Arg a) where- traverse f (Arg x a) = Arg x <$> f a--instance Eq a => Eq (Arg a b) where- Arg a _ == Arg b _ = a == b--instance Ord a => Ord (Arg a b) where- Arg a _ `compare` Arg b _ = compare a b- min x@(Arg a _) y@(Arg b _)- | a <= b = x- | otherwise = y- max x@(Arg a _) y@(Arg b _)- | a >= b = x- | otherwise = y--#ifdef MIN_VERSION_deepseq-instance (NFData a, NFData b) => NFData (Arg a b) where- rnf (Arg a b) = rnf a `seq` rnf b `seq` ()-#endif--#ifdef MIN_VERSION_hashable-#if MIN_VERSION_hashable(1,3,0)--- | Instance like defined in @hashable-1.3@-instance Hashable a => Hashable (Arg a b) where- hashWithSalt p (Arg a _b) = hashWithSalt p a-#else--- | Instance like defined in @hashable-1.2@-instance (Hashable a, Hashable b) => Hashable (Arg a b) where- hashWithSalt p (Arg a b) = hashWithSalt p a `hashWithSalt` b-#endif-#endif--#if MIN_VERSION_base(4,8,0)-instance Bifunctor Arg where- bimap f g (Arg a b) = Arg (f a) (g b)-#endif--#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL__ < 706-instance Generic1 (Arg a) where- type Rep1 (Arg a)- = D1 D1'Arg- (C1 C1'_0Arg- (S1 NoSelector (Rec0 a)- :*: S1 NoSelector Par1))- from1 (Arg a b) = M1 (M1 (M1 (K1 a) :*: M1 (Par1 b)))- to1 (M1 (M1 (M1 a :*: M1 b))) = Arg (unK1 a) (unPar1 b)--instance Datatype D1'Arg where- datatypeName _ = "Arg"- moduleName _ = "Data.Semigroup"--instance Constructor C1'_0Arg where- conName _ = "Arg"--data D1'Arg-data C1'_0Arg-#endif---- | Use @'Option' ('First' a)@ to get the behavior of 'Data.Monoid.First' from @Data.Monoid@.-newtype First a = First { getFirst :: a } deriving- ( Eq, Ord, Show, Read-#ifdef LANGUAGE_DeriveDataTypeable- , Data- , Typeable-#endif-#ifdef LANGUAGE_DeriveGeneric- , Generic-#if __GLASGOW_HASKELL__ >= 706- , Generic1-#endif-#endif- )--instance Bounded a => Bounded (First a) where- minBound = First minBound- maxBound = First maxBound--instance Enum a => Enum (First a) where- succ (First a) = First (succ a)- pred (First a) = First (pred a)- toEnum = First . toEnum- fromEnum = fromEnum . getFirst- enumFrom (First a) = First <$> enumFrom a- enumFromThen (First a) (First b) = First <$> enumFromThen a b- enumFromTo (First a) (First b) = First <$> enumFromTo a b- enumFromThenTo (First a) (First b) (First c) = First <$> enumFromThenTo a b c--#ifdef MIN_VERSION_hashable-instance Hashable a => Hashable (First a) where- hashWithSalt p (First a) = hashWithSalt p a---- | @since 0.19.2-instance Hashable1 First where- liftHashWithSalt h salt (First a) = h salt a-#endif--instance Semigroup (First a) where- a <> _ = a- stimes = stimesIdempotent--instance Functor First where- fmap f (First x) = First (f x)--instance Foldable First where- foldMap f (First a) = f a--instance Traversable First where- traverse f (First a) = First <$> f a--instance Applicative First where- pure x = First x- a <* _ = a- _ *> a = a- First f <*> First x = First (f x)--instance Monad First where- return = First- _ >> a = a- First a >>= f = f a--instance MonadFix First where- mfix f = fix (f . getFirst)--#ifdef MIN_VERSION_deepseq-instance NFData a => NFData (First a) where- rnf (First a) = rnf a-#endif--#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL__ < 706-instance Generic1 First where- type Rep1 First = D1 D1'First (C1 C1'_0First (S1 S1'_0_0First Par1))- from1 (First x) = M1 (M1 (M1 (Par1 x)))- to1 (M1 (M1 (M1 x))) = First (unPar1 x)--instance Datatype D1'First where- datatypeName _ = "First"- moduleName _ = "Data.Semigroup"--instance Constructor C1'_0First where- conName _ = "First"- conIsRecord _ = True--instance Selector S1'_0_0First where- selName _ = "getFirst"--data D1'First-data C1'_0First-data S1'_0_0First-#endif---- | Use @'Option' ('Last' a)@ to get the behavior of 'Data.Monoid.Last' from @Data.Monoid@-newtype Last a = Last { getLast :: a } deriving- ( Eq, Ord, Show, Read-#ifdef LANGUAGE_DeriveDataTypeable- , Data, Typeable-#endif-#ifdef LANGUAGE_DeriveGeneric- , Generic-#if __GLASGOW_HASKELL__ >= 706- , Generic1-#endif-#endif- )--instance Bounded a => Bounded (Last a) where- minBound = Last minBound- maxBound = Last maxBound--instance Enum a => Enum (Last a) where- succ (Last a) = Last (succ a)- pred (Last a) = Last (pred a)- toEnum = Last . toEnum- fromEnum = fromEnum . getLast- enumFrom (Last a) = Last <$> enumFrom a- enumFromThen (Last a) (Last b) = Last <$> enumFromThen a b- enumFromTo (Last a) (Last b) = Last <$> enumFromTo a b- enumFromThenTo (Last a) (Last b) (Last c) = Last <$> enumFromThenTo a b c--#ifdef MIN_VERSION_hashable-instance Hashable a => Hashable (Last a) where- hashWithSalt p (Last a) = hashWithSalt p a---- | @since 0.19.2-instance Hashable1 Last where- liftHashWithSalt h salt (Last a) = h salt a-#endif--instance Semigroup (Last a) where- _ <> b = b- stimes = stimesIdempotent--instance Functor Last where- fmap f (Last x) = Last (f x)- a <$ _ = Last a--instance Foldable Last where- foldMap f (Last a) = f a--instance Traversable Last where- traverse f (Last a) = Last <$> f a--instance Applicative Last where- pure = Last- a <* _ = a- _ *> a = a- Last f <*> Last x = Last (f x)--instance Monad Last where- return = Last- _ >> a = a- Last a >>= f = f a--instance MonadFix Last where- mfix f = fix (f . getLast)--#ifdef MIN_VERSION_deepseq-instance NFData a => NFData (Last a) where- rnf (Last a) = rnf a-#endif--#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL__ < 706-instance Generic1 Last where- type Rep1 Last = D1 D1'Last (C1 C1'_0Last (S1 S1'_0_0Last Par1))- from1 (Last x) = M1 (M1 (M1 (Par1 x)))- to1 (M1 (M1 (M1 x))) = Last (unPar1 x)--instance Datatype D1'Last where- datatypeName _ = "Last"- moduleName _ = "Data.Semigroup"--instance Constructor C1'_0Last where- conName _ = "Last"- conIsRecord _ = True--instance Selector S1'_0_0Last where- selName _ = "getLast"--data D1'Last-data C1'_0Last-data S1'_0_0Last-#endif---- (==)/XNOR on Bool forms a 'Semigroup', but has no good name--#ifdef MIN_VERSION_binary-# if !(MIN_VERSION_binary(0,8,3))-instance Semigroup Builder.Builder where- (<>) = mappend-# endif-#endif--#ifdef MIN_VERSION_bytestring-instance Semigroup BS.ByteString where- (<>) = mappend- sconcat (b:|bs) = BS.concat (b:bs)--instance Semigroup BL.ByteString where- (<>) = mappend- sconcat (b:|bs) = BL.concat (b:bs)--# if (MIN_VERSION_bytestring(0,10,0)) || defined(MIN_VERSION_bytestring_builder)-instance Semigroup ByteString.Builder where- (<>) = mappend-# endif--# if (MIN_VERSION_bytestring(0,10,4)) || defined(MIN_VERSION_bytestring_builder)-instance Semigroup ShortByteString where- (<>) = mappend-# endif-#endif--#ifdef MIN_VERSION_text-instance Semigroup TS.Text where- (<>) = mappend--instance Semigroup TL.Text where- (<>) = mappend--instance Semigroup Text.Builder where- (<>) = mappend-#endif--#ifdef MIN_VERSION_unordered_containers-instance (Hashable k, Eq k) => Semigroup (Lazy.HashMap k a) where- (<>) = mappend- stimes = stimesIdempotentMonoid--instance (Hashable a, Eq a) => Semigroup (HashSet a) where- (<>) = mappend- stimes = stimesIdempotentMonoid-#endif---- | Provide a Semigroup for an arbitrary Monoid.-newtype WrappedMonoid m = WrapMonoid- { unwrapMonoid :: m } deriving- ( Eq, Ord, Show, Read-#ifdef LANGUAGE_DeriveDataTypeable- , Data, Typeable-#endif-#ifdef LANGUAGE_DeriveGeneric- , Generic-#if __GLASGOW_HASKELL__ >= 706- , Generic1-#endif-#endif- )--#ifdef MIN_VERSION_hashable-instance Hashable a => Hashable (WrappedMonoid a) where- hashWithSalt p (WrapMonoid a) = hashWithSalt p a---- | @since 0.19.2-instance Hashable1 WrappedMonoid where- liftHashWithSalt h salt (WrapMonoid a) = h salt a-#endif--instance Monoid m => Semigroup (WrappedMonoid m) where-#ifdef USE_COERCE- (<>) = coerce (mappend :: m -> m -> m)-#else- WrapMonoid a <> WrapMonoid b = WrapMonoid (a `mappend` b)-#endif--instance Monoid m => Monoid (WrappedMonoid m) where- mempty = WrapMonoid mempty- mappend = (<>)--instance Bounded a => Bounded (WrappedMonoid a) where- minBound = WrapMonoid minBound- maxBound = WrapMonoid maxBound--instance Enum a => Enum (WrappedMonoid a) where- succ (WrapMonoid a) = WrapMonoid (succ a)- pred (WrapMonoid a) = WrapMonoid (pred a)- toEnum = WrapMonoid . toEnum- fromEnum = fromEnum . unwrapMonoid- enumFrom (WrapMonoid a) = WrapMonoid <$> enumFrom a- enumFromThen (WrapMonoid a) (WrapMonoid b) = WrapMonoid <$> enumFromThen a b- enumFromTo (WrapMonoid a) (WrapMonoid b) = WrapMonoid <$> enumFromTo a b- enumFromThenTo (WrapMonoid a) (WrapMonoid b) (WrapMonoid c) = WrapMonoid <$> enumFromThenTo a b c--#ifdef MIN_VERSION_deepseq-instance NFData m => NFData (WrappedMonoid m) where- rnf (WrapMonoid a) = rnf a-#endif--#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL__ < 706-instance Generic1 WrappedMonoid where- type Rep1 WrappedMonoid = D1 D1'WrappedMonoid (C1 C1'_0WrappedMonoid (S1 S1'_0_0WrappedMonoid Par1))- from1 (WrapMonoid x) = M1 (M1 (M1 (Par1 x)))- to1 (M1 (M1 (M1 x))) = WrapMonoid (unPar1 x)--instance Datatype D1'WrappedMonoid where- datatypeName _ = "WrappedMonoid"- moduleName _ = "Data.Semigroup"--instance Constructor C1'_0WrappedMonoid where- conName _ = "WrapMonoid"- conIsRecord _ = True--instance Selector S1'_0_0WrappedMonoid where- selName _ = "unwrapMonoid"--data D1'WrappedMonoid-data C1'_0WrappedMonoid-data S1'_0_0WrappedMonoid-#endif---- | Repeat a value @n@ times.------ > mtimesDefault n a = a <> a <> ... <> a -- using <> (n-1) times------ Implemented using 'stimes' and 'mempty'.------ This is a suitable definition for an 'mtimes' member of 'Monoid'.------ @since 0.17-mtimesDefault :: (Integral b, Monoid a) => b -> a -> a-mtimesDefault n x- | n == 0 = mempty- | otherwise = unwrapMonoid (stimes n (WrapMonoid x))---- | 'Option' is effectively 'Maybe' with a better instance of 'Monoid', built off of an underlying 'Semigroup'--- instead of an underlying 'Monoid'.------ Ideally, this type would not exist at all and we would just fix the 'Monoid' instance of 'Maybe'-newtype Option a = Option- { getOption :: Maybe a } deriving- ( Eq, Ord, Show, Read-#ifdef LANGUAGE_DeriveDataTypeable- , Data, Typeable-#endif-#ifdef LANGUAGE_DeriveGeneric- , Generic-#if __GLASGOW_HASKELL__ >= 706- , Generic1-#endif-#endif- )--#ifdef MIN_VERSION_hashable-instance Hashable a => Hashable (Option a) where- hashWithSalt p (Option a) = hashWithSalt p a---- | @since 0.19.2-instance Hashable1 Option where- liftHashWithSalt h salt (Option a) = liftHashWithSalt h salt a-#endif--instance Functor Option where- fmap f (Option a) = Option (fmap f a)--instance Applicative Option where- pure a = Option (Just a)- Option a <*> Option b = Option (a <*> b)--instance Monad Option where- return = pure-- Option (Just a) >>= k = k a- _ >>= _ = Option Nothing-- Option Nothing >> _ = Option Nothing- _ >> b = b--instance Alternative Option where- empty = Option Nothing- Option Nothing <|> b = b- a <|> _ = a--instance MonadPlus Option where- mzero = Option Nothing- mplus = (<|>)--instance MonadFix Option where- mfix f = Option (mfix (getOption . f))--instance Foldable Option where- foldMap f (Option (Just m)) = f m- foldMap _ (Option Nothing) = mempty--instance Traversable Option where- traverse f (Option (Just a)) = Option . Just <$> f a- traverse _ (Option Nothing) = pure (Option Nothing)--#ifdef MIN_VERSION_deepseq-instance NFData a => NFData (Option a) where- rnf (Option a) = rnf a-#endif---- | Fold an 'Option' case-wise, just like 'maybe'.-option :: b -> (a -> b) -> Option a -> b-option n j (Option m) = maybe n j m--instance Semigroup a => Semigroup (Option a) where-#ifdef USE_COERCE- (<>) = coerce ((<>) :: Maybe a -> Maybe a -> Maybe a)-#else- Option a <> Option b = Option (a <> b)-#endif- stimes _ (Option Nothing) = Option Nothing- stimes n (Option (Just a)) = case compare n 0 of- LT -> error "stimes: Option, negative multiplier"- EQ -> Option Nothing- GT -> Option (Just (stimes n a))--instance Semigroup a => Monoid (Option a) where- mempty = Option Nothing- mappend = (<>)--#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL__ < 706-instance Generic1 Option where- type Rep1 Option = D1 D1'Option (C1 C1'_0Option (S1 S1'_0_0Option (Rec1 Maybe)))- from1 (Option x) = M1 (M1 (M1 (Rec1 x)))- to1 (M1 (M1 (M1 x))) = Option (unRec1 x)--instance Datatype D1'Option where- datatypeName _ = "Option"- moduleName _ = "Data.Semigroup"--instance Constructor C1'_0Option where- conName _ = "Option"- conIsRecord _ = True--instance Selector S1'_0_0Option where- selName _ = "getOption"--data D1'Option-data C1'_0Option-data S1'_0_0Option-#endif---- | This lets you use a difference list of a 'Semigroup' as a 'Monoid'.-diff :: Semigroup m => m -> Endo m-diff = Endo . (<>)--#ifdef MIN_VERSION_containers-instance Semigroup (Seq a) where- (<>) = (><)--instance Semigroup IntSet where- (<>) = mappend- stimes = stimesIdempotentMonoid--instance Ord a => Semigroup (Set a) where- (<>) = mappend- stimes = stimesIdempotentMonoid--instance Semigroup (IntMap v) where- (<>) = mappend- stimes = stimesIdempotentMonoid--instance Ord k => Semigroup (Map k v) where- (<>) = mappend- stimes = stimesIdempotentMonoid-#endif--#if (MIN_VERSION_base(4,8,0)) || defined(MIN_VERSION_transformers)-instance Semigroup a => Semigroup (Identity a) where-# ifdef USE_COERCE- (<>) = coerce ((<>) :: a -> a -> a)-# else- Identity a <> Identity b = Identity (a <> b)-# endif- stimes n (Identity a) = Identity (stimes n a)-#endif--#if (MIN_VERSION_base(4,7,0)) || defined(MIN_VERSION_tagged)-instance Semigroup (Proxy s) where- _ <> _ = Proxy- sconcat _ = Proxy- stimes _ _ = Proxy-#endif--#ifdef MIN_VERSION_tagged-instance Semigroup a => Semigroup (Tagged s a) where-# ifdef USE_COERCE- (<>) = coerce ((<>) :: a -> a -> a)-# else- Tagged a <> Tagged b = Tagged (a <> b)-# endif- stimes n (Tagged a) = Tagged (stimes n a)-#endif--instance Semigroup a => Semigroup (IO a) where- (<>) = liftA2 (<>)--instance Semigroup a => Semigroup (Strict.ST s a) where-#if MIN_VERSION_base(4,4,0)- (<>) = liftA2 (<>)-#else- (<>) = liftM2 (<>) -- No Applicative instance for ST on GHC 7.0-#endif--#if !defined(mingw32_HOST_OS) && !defined(ghcjs_HOST_OS) && !defined(ETA_VERSION)-# if MIN_VERSION_base(4,4,0)-instance Semigroup Event where- (<>) = mappend- stimes = stimesMonoid-# endif--# if MIN_VERSION_base(4,8,1)-instance Semigroup Lifetime where- (<>) = mappend- stimes = stimesMonoid-# endif-#endif
src/Data/Semigroup/Generic.hs view
@@ -1,12 +1,8 @@ {-# LANGUAGE CPP #-}-{-# LANGUAGE TypeOperators #-} {-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE UndecidableInstances #-}-#if __GLASGOW_HASKELL__ >= 704 {-# LANGUAGE Safe #-}-#else-{-# LANGUAGE Trustworthy #-}-#endif+{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE UndecidableInstances #-} ----------------------------------------------------------------------------- -- | -- Module : Data.Semigroup.Generic@@ -32,9 +28,6 @@ , GSemigroup, GMonoid ) where -#if !(MIN_VERSION_base(4,8,0))-import Data.Monoid (Monoid(..))-#endif #if !(MIN_VERSION_base(4,11,0)) import Data.Semigroup (Semigroup(..)) #endif@@ -107,6 +100,8 @@ -- data Pair a = MkPair a a -- deriving ('Semigroup', 'Monoid') via ('GenericSemigroupMonoid' (Pair a)) -- @+--+-- @since 0.19.1 newtype GenericSemigroupMonoid a = GenericSemigroupMonoid { getGenericSemigroupMonoid :: a }