Safe Haskell	None
Language	Haskell2010

Distribution.Compat.Semigroup

Description

Compatibility layer for Data.Semigroup

Synopsis

Documentation

class Semigroup a where #

The class of semigroups (types with an associative binary operation).

Since: 4.9.0.0

Methods

(<>) :: a -> a -> a infixr 6 #

An associative operation.

(a <> b) <> c = a <> (b <> c)

If a is also a Monoid we further require

(<>) = mappend

Instances

Semigroup Ordering
Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # stimes :: Integral b => b -> Ordering -> Ordering #
Semigroup ()
Methods (<>) :: () -> () -> () # sconcat :: NonEmpty () -> () # stimes :: Integral b => b -> () -> () #
Semigroup Void
Methods (<>) :: Void -> Void -> Void # sconcat :: NonEmpty Void -> Void # stimes :: Integral b => b -> Void -> Void #
Semigroup All
Methods (<>) :: All -> All -> All # sconcat :: NonEmpty All -> All # stimes :: Integral b => b -> All -> All #
Semigroup Any
Methods (<>) :: Any -> Any -> Any # sconcat :: NonEmpty Any -> Any # stimes :: Integral b => b -> Any -> Any #
Semigroup ShortByteString
Methods (<>) :: ShortByteString -> ShortByteString -> ShortByteString # sconcat :: NonEmpty ShortByteString -> ShortByteString # stimes :: Integral b => b -> ShortByteString -> ShortByteString #
Semigroup ByteString
Methods (<>) :: ByteString -> ByteString -> ByteString # sconcat :: NonEmpty ByteString -> ByteString # stimes :: Integral b => b -> ByteString -> ByteString #
Semigroup ByteString
Methods (<>) :: ByteString -> ByteString -> ByteString # sconcat :: NonEmpty ByteString -> ByteString # stimes :: Integral b => b -> ByteString -> ByteString #
Semigroup Builder
Methods (<>) :: Builder -> Builder -> Builder # sconcat :: NonEmpty Builder -> Builder # stimes :: Integral b => b -> Builder -> Builder #
Semigroup IntSet
Methods (<>) :: IntSet -> IntSet -> IntSet # sconcat :: NonEmpty IntSet -> IntSet # stimes :: Integral b => b -> IntSet -> IntSet #
Semigroup Doc
Methods (<>) :: Doc -> Doc -> Doc # sconcat :: NonEmpty Doc -> Doc # stimes :: Integral b => b -> Doc -> Doc #
Semigroup CDialect #
Methods (<>) :: CDialect -> CDialect -> CDialect # sconcat :: NonEmpty CDialect -> CDialect # stimes :: Integral b => b -> CDialect -> CDialect #
Semigroup ExecutableScope #
Methods (<>) :: ExecutableScope -> ExecutableScope -> ExecutableScope # sconcat :: NonEmpty ExecutableScope -> ExecutableScope # stimes :: Integral b => b -> ExecutableScope -> ExecutableScope #
Semigroup ForeignLibType #
Methods (<>) :: ForeignLibType -> ForeignLibType -> ForeignLibType # sconcat :: NonEmpty ForeignLibType -> ForeignLibType # stimes :: Integral b => b -> ForeignLibType -> ForeignLibType #
Semigroup ShortText #
Methods (<>) :: ShortText -> ShortText -> ShortText # sconcat :: NonEmpty ShortText -> ShortText # stimes :: Integral b => b -> ShortText -> ShortText #
Semigroup BenchmarkInterface #
Methods (<>) :: BenchmarkInterface -> BenchmarkInterface -> BenchmarkInterface # sconcat :: NonEmpty BenchmarkInterface -> BenchmarkInterface # stimes :: Integral b => b -> BenchmarkInterface -> BenchmarkInterface #
Semigroup TestSuiteInterface #
Methods (<>) :: TestSuiteInterface -> TestSuiteInterface -> TestSuiteInterface # sconcat :: NonEmpty TestSuiteInterface -> TestSuiteInterface # stimes :: Integral b => b -> TestSuiteInterface -> TestSuiteInterface #
Semigroup DependencyMap #
Methods (<>) :: DependencyMap -> DependencyMap -> DependencyMap # sconcat :: NonEmpty DependencyMap -> DependencyMap # stimes :: Integral b => b -> DependencyMap -> DependencyMap #
Semigroup SetupBuildInfo #
Methods (<>) :: SetupBuildInfo -> SetupBuildInfo -> SetupBuildInfo # sconcat :: NonEmpty SetupBuildInfo -> SetupBuildInfo # stimes :: Integral b => b -> SetupBuildInfo -> SetupBuildInfo #
Semigroup UnqualComponentName #
Methods (<>) :: UnqualComponentName -> UnqualComponentName -> UnqualComponentName # sconcat :: NonEmpty UnqualComponentName -> UnqualComponentName # stimes :: Integral b => b -> UnqualComponentName -> UnqualComponentName #
Semigroup BuildInfo #
Methods (<>) :: BuildInfo -> BuildInfo -> BuildInfo # sconcat :: NonEmpty BuildInfo -> BuildInfo # stimes :: Integral b => b -> BuildInfo -> BuildInfo #
Semigroup Benchmark #
Methods (<>) :: Benchmark -> Benchmark -> Benchmark # sconcat :: NonEmpty Benchmark -> Benchmark # stimes :: Integral b => b -> Benchmark -> Benchmark #
Semigroup Executable #
Methods (<>) :: Executable -> Executable -> Executable # sconcat :: NonEmpty Executable -> Executable # stimes :: Integral b => b -> Executable -> Executable #
Semigroup ForeignLib #
Methods (<>) :: ForeignLib -> ForeignLib -> ForeignLib # sconcat :: NonEmpty ForeignLib -> ForeignLib # stimes :: Integral b => b -> ForeignLib -> ForeignLib #
Semigroup Library #
Methods (<>) :: Library -> Library -> Library # sconcat :: NonEmpty Library -> Library # stimes :: Integral b => b -> Library -> Library #
Semigroup TestSuite #
Methods (<>) :: TestSuite -> TestSuite -> TestSuite # sconcat :: NonEmpty TestSuite -> TestSuite # stimes :: Integral b => b -> TestSuite -> TestSuite #
Semigroup Component #
Methods (<>) :: Component -> Component -> Component # sconcat :: NonEmpty Component -> Component # stimes :: Integral b => b -> Component -> Component #
Semigroup BenchmarkFlags #
Methods (<>) :: BenchmarkFlags -> BenchmarkFlags -> BenchmarkFlags # sconcat :: NonEmpty BenchmarkFlags -> BenchmarkFlags # stimes :: Integral b => b -> BenchmarkFlags -> BenchmarkFlags #
Semigroup TestFlags #
Methods (<>) :: TestFlags -> TestFlags -> TestFlags # sconcat :: NonEmpty TestFlags -> TestFlags # stimes :: Integral b => b -> TestFlags -> TestFlags #
Semigroup TestShowDetails #
Methods (<>) :: TestShowDetails -> TestShowDetails -> TestShowDetails # sconcat :: NonEmpty TestShowDetails -> TestShowDetails # stimes :: Integral b => b -> TestShowDetails -> TestShowDetails #
Semigroup ReplFlags #
Methods (<>) :: ReplFlags -> ReplFlags -> ReplFlags # sconcat :: NonEmpty ReplFlags -> ReplFlags # stimes :: Integral b => b -> ReplFlags -> ReplFlags #
Semigroup BuildFlags #
Methods (<>) :: BuildFlags -> BuildFlags -> BuildFlags # sconcat :: NonEmpty BuildFlags -> BuildFlags # stimes :: Integral b => b -> BuildFlags -> BuildFlags #
Semigroup CleanFlags #
Methods (<>) :: CleanFlags -> CleanFlags -> CleanFlags # sconcat :: NonEmpty CleanFlags -> CleanFlags # stimes :: Integral b => b -> CleanFlags -> CleanFlags #
Semigroup HaddockFlags #
Methods (<>) :: HaddockFlags -> HaddockFlags -> HaddockFlags # sconcat :: NonEmpty HaddockFlags -> HaddockFlags # stimes :: Integral b => b -> HaddockFlags -> HaddockFlags #
Semigroup DoctestFlags #
Methods (<>) :: DoctestFlags -> DoctestFlags -> DoctestFlags # sconcat :: NonEmpty DoctestFlags -> DoctestFlags # stimes :: Integral b => b -> DoctestFlags -> DoctestFlags #
Semigroup HscolourFlags #
Methods (<>) :: HscolourFlags -> HscolourFlags -> HscolourFlags # sconcat :: NonEmpty HscolourFlags -> HscolourFlags # stimes :: Integral b => b -> HscolourFlags -> HscolourFlags #
Semigroup RegisterFlags #
Methods (<>) :: RegisterFlags -> RegisterFlags -> RegisterFlags # sconcat :: NonEmpty RegisterFlags -> RegisterFlags # stimes :: Integral b => b -> RegisterFlags -> RegisterFlags #
Semigroup SDistFlags #
Methods (<>) :: SDistFlags -> SDistFlags -> SDistFlags # sconcat :: NonEmpty SDistFlags -> SDistFlags # stimes :: Integral b => b -> SDistFlags -> SDistFlags #
Semigroup InstallFlags #
Methods (<>) :: InstallFlags -> InstallFlags -> InstallFlags # sconcat :: NonEmpty InstallFlags -> InstallFlags # stimes :: Integral b => b -> InstallFlags -> InstallFlags #
Semigroup CopyFlags #
Methods (<>) :: CopyFlags -> CopyFlags -> CopyFlags # sconcat :: NonEmpty CopyFlags -> CopyFlags # stimes :: Integral b => b -> CopyFlags -> CopyFlags #
Semigroup ConfigFlags #
Methods (<>) :: ConfigFlags -> ConfigFlags -> ConfigFlags # sconcat :: NonEmpty ConfigFlags -> ConfigFlags # stimes :: Integral b => b -> ConfigFlags -> ConfigFlags #
Semigroup AllowOlder #
Methods (<>) :: AllowOlder -> AllowOlder -> AllowOlder # sconcat :: NonEmpty AllowOlder -> AllowOlder # stimes :: Integral b => b -> AllowOlder -> AllowOlder #
Semigroup AllowNewer #
Methods (<>) :: AllowNewer -> AllowNewer -> AllowNewer # sconcat :: NonEmpty AllowNewer -> AllowNewer # stimes :: Integral b => b -> AllowNewer -> AllowNewer #
Semigroup RelaxDeps #
Methods (<>) :: RelaxDeps -> RelaxDeps -> RelaxDeps # sconcat :: NonEmpty RelaxDeps -> RelaxDeps # stimes :: Integral b => b -> RelaxDeps -> RelaxDeps #
Semigroup GlobalFlags #
Methods (<>) :: GlobalFlags -> GlobalFlags -> GlobalFlags # sconcat :: NonEmpty GlobalFlags -> GlobalFlags # stimes :: Integral b => b -> GlobalFlags -> GlobalFlags #
Semigroup GhcOptions #
Methods (<>) :: GhcOptions -> GhcOptions -> GhcOptions # sconcat :: NonEmpty GhcOptions -> GhcOptions # stimes :: Integral b => b -> GhcOptions -> GhcOptions #
Semigroup [a]
Methods (<>) :: [a] -> [a] -> [a] # sconcat :: NonEmpty [a] -> [a] # stimes :: Integral b => b -> [a] -> [a] #
Semigroup a => Semigroup (Maybe a)
Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe a #
Semigroup a => Semigroup (Identity a)
Methods (<>) :: Identity a -> Identity a -> Identity a # sconcat :: NonEmpty (Identity a) -> Identity a # stimes :: Integral b => b -> Identity a -> Identity a #
Ord a => Semigroup (Min a)
Methods (<>) :: Min a -> Min a -> Min a # sconcat :: NonEmpty (Min a) -> Min a # stimes :: Integral b => b -> Min a -> Min a #
Ord a => Semigroup (Max a)
Methods (<>) :: Max a -> Max a -> Max a # sconcat :: NonEmpty (Max a) -> Max a # stimes :: Integral b => b -> Max a -> Max a #
Semigroup (First a)
Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # stimes :: Integral b => b -> First a -> First a #
Semigroup (Last a)
Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # stimes :: Integral b => b -> Last a -> Last a #
Monoid m => Semigroup (WrappedMonoid m)
Methods (<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # sconcat :: NonEmpty (WrappedMonoid m) -> WrappedMonoid m # stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m #
Semigroup a => Semigroup (Option a)
Methods (<>) :: Option a -> Option a -> Option a # sconcat :: NonEmpty (Option a) -> Option a # stimes :: Integral b => b -> Option a -> Option a #
Semigroup (NonEmpty a)
Methods (<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a # sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a # stimes :: Integral b => b -> NonEmpty a -> NonEmpty a #
Semigroup a => Semigroup (Dual a)
Methods (<>) :: Dual a -> Dual a -> Dual a # sconcat :: NonEmpty (Dual a) -> Dual a # stimes :: Integral b => b -> Dual a -> Dual a #
Semigroup (Endo a)
Methods (<>) :: Endo a -> Endo a -> Endo a # sconcat :: NonEmpty (Endo a) -> Endo a # stimes :: Integral b => b -> Endo a -> Endo a #
Num a => Semigroup (Sum a)
Methods (<>) :: Sum a -> Sum a -> Sum a # sconcat :: NonEmpty (Sum a) -> Sum a # stimes :: Integral b => b -> Sum a -> Sum a #
Num a => Semigroup (Product a)
Methods (<>) :: Product a -> Product a -> Product a # sconcat :: NonEmpty (Product a) -> Product a # stimes :: Integral b => b -> Product a -> Product a #
Semigroup (First a)
Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # stimes :: Integral b => b -> First a -> First a #
Semigroup (Last a)
Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # stimes :: Integral b => b -> Last a -> Last a #
Semigroup (PutM ())
Methods (<>) :: PutM () -> PutM () -> PutM () # sconcat :: NonEmpty (PutM ()) -> PutM () # stimes :: Integral b => b -> PutM () -> PutM () #
Semigroup (IntMap a)
Methods (<>) :: IntMap a -> IntMap a -> IntMap a # sconcat :: NonEmpty (IntMap a) -> IntMap a # stimes :: Integral b => b -> IntMap a -> IntMap a #
Semigroup (Seq a)
Methods (<>) :: Seq a -> Seq a -> Seq a # sconcat :: NonEmpty (Seq a) -> Seq a # stimes :: Integral b => b -> Seq a -> Seq a #
Ord a => Semigroup (Set a)
Methods (<>) :: Set a -> Set a -> Set a # sconcat :: NonEmpty (Set a) -> Set a # stimes :: Integral b => b -> Set a -> Set a #
Semigroup (Doc a)
Methods (<>) :: Doc a -> Doc a -> Doc a # sconcat :: NonEmpty (Doc a) -> Doc a # stimes :: Integral b => b -> Doc a -> Doc a #
Semigroup (Last' a) #
Methods (<>) :: Last' a -> Last' a -> Last' a # sconcat :: NonEmpty (Last' a) -> Last' a # stimes :: Integral b => b -> Last' a -> Last' a #
Semigroup (DList a) #
Methods (<>) :: DList a -> DList a -> DList a # sconcat :: NonEmpty (DList a) -> DList a # stimes :: Integral b => b -> DList a -> DList a #
Semigroup (Condition a) #
Methods (<>) :: Condition a -> Condition a -> Condition a # sconcat :: NonEmpty (Condition a) -> Condition a # stimes :: Integral b => b -> Condition a -> Condition a #
Ord a => Semigroup (NubListR a) #
Methods (<>) :: NubListR a -> NubListR a -> NubListR a # sconcat :: NonEmpty (NubListR a) -> NubListR a # stimes :: Integral b => b -> NubListR a -> NubListR a #
Ord a => Semigroup (NubList a) #
Methods (<>) :: NubList a -> NubList a -> NubList a # sconcat :: NonEmpty (NubList a) -> NubList a # stimes :: Integral b => b -> NubList a -> NubList a #
Semigroup dir => Semigroup (InstallDirs dir) #
Methods (<>) :: InstallDirs dir -> InstallDirs dir -> InstallDirs dir # sconcat :: NonEmpty (InstallDirs dir) -> InstallDirs dir # stimes :: Integral b => b -> InstallDirs dir -> InstallDirs dir #
Semigroup (Flag a) #
Methods (<>) :: Flag a -> Flag a -> Flag a # sconcat :: NonEmpty (Flag a) -> Flag a # stimes :: Integral b => b -> Flag a -> Flag a #
Semigroup (PackageIndex InstalledPackageInfo) #
Methods (<>) :: PackageIndex InstalledPackageInfo -> PackageIndex InstalledPackageInfo -> PackageIndex InstalledPackageInfo # sconcat :: NonEmpty (PackageIndex InstalledPackageInfo) -> PackageIndex InstalledPackageInfo # stimes :: Integral b => b -> PackageIndex InstalledPackageInfo -> PackageIndex InstalledPackageInfo #
Semigroup b => Semigroup (a -> b)
Methods (<>) :: (a -> b) -> (a -> b) -> a -> b # sconcat :: NonEmpty (a -> b) -> a -> b # stimes :: Integral b => b -> (a -> b) -> a -> b #
Semigroup (Either a b)
Methods (<>) :: Either a b -> Either a b -> Either a b # sconcat :: NonEmpty (Either a b) -> Either a b # stimes :: Integral b => b -> Either a b -> Either a b #
(Semigroup a, Semigroup b) => Semigroup (a, b)
Methods (<>) :: (a, b) -> (a, b) -> (a, b) # sconcat :: NonEmpty (a, b) -> (a, b) # stimes :: Integral b => b -> (a, b) -> (a, b) #
Semigroup (Proxy k s)
Methods (<>) :: Proxy k s -> Proxy k s -> Proxy k s # sconcat :: NonEmpty (Proxy k s) -> Proxy k s # stimes :: Integral b => b -> Proxy k s -> Proxy k s #
Ord k => Semigroup (Map k v)
Methods (<>) :: Map k v -> Map k v -> Map k v # sconcat :: NonEmpty (Map k v) -> Map k v # stimes :: Integral b => b -> Map k v -> Map k v #
(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c)
Methods (<>) :: (a, b, c) -> (a, b, c) -> (a, b, c) # sconcat :: NonEmpty (a, b, c) -> (a, b, c) # stimes :: Integral b => b -> (a, b, c) -> (a, b, c) #
Semigroup a => Semigroup (Const k a b)
Methods (<>) :: Const k a b -> Const k a b -> Const k a b # sconcat :: NonEmpty (Const k a b) -> Const k a b # stimes :: Integral b => b -> Const k a b -> Const k a b #
Alternative f => Semigroup (Alt * f a)
Methods (<>) :: Alt * f a -> Alt * f a -> Alt * f a # sconcat :: NonEmpty (Alt * f a) -> Alt * f a # stimes :: Integral b => b -> Alt * f a -> Alt * f a #
(Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d)
Methods (<>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # sconcat :: NonEmpty (a, b, c, d) -> (a, b, c, d) # stimes :: Integral b => b -> (a, b, c, d) -> (a, b, c, d) #
(Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e)
Methods (<>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # sconcat :: NonEmpty (a, b, c, d, e) -> (a, b, c, d, e) # stimes :: Integral b => b -> (a, b, c, d, e) -> (a, b, c, d, e) #

class Monoid a where #

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:

```
mappend mempty x = x
```
```
mappend x mempty = x
```

mappend x (mappend y z) = mappend (mappend x y) z

```
mconcat = foldr mappend mempty
```

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of Monoid, e.g. Sum and Product.

Minimal complete definition

mempty, mappend

Methods

mempty :: a #

Identity of mappend

mappend :: a -> a -> a #

An associative operation

mconcat :: [a] -> a #

Fold a list using the monoid. For most types, the default definition for mconcat will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

Instances

Monoid Ordering
Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Monoid ()
Methods mempty :: () # mappend :: () -> () -> () # mconcat :: [()] -> () #
Monoid All
Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
Monoid Any
Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [Any] -> Any #
Monoid ShortByteString
Methods mempty :: ShortByteString # mappend :: ShortByteString -> ShortByteString -> ShortByteString # mconcat :: [ShortByteString] -> ShortByteString #
Monoid ByteString
Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Monoid ByteString
Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Monoid Builder
Methods mempty :: Builder # mappend :: Builder -> Builder -> Builder # mconcat :: [Builder] -> Builder #
Monoid IntSet
Methods mempty :: IntSet # mappend :: IntSet -> IntSet -> IntSet # mconcat :: [IntSet] -> IntSet #
Monoid Doc
Methods mempty :: Doc # mappend :: Doc -> Doc -> Doc # mconcat :: [Doc] -> Doc #
Monoid CDialect #
Methods mempty :: CDialect # mappend :: CDialect -> CDialect -> CDialect # mconcat :: [CDialect] -> CDialect #
Monoid ExecutableScope #
Methods mempty :: ExecutableScope # mappend :: ExecutableScope -> ExecutableScope -> ExecutableScope # mconcat :: [ExecutableScope] -> ExecutableScope #
Monoid ForeignLibType #
Methods mempty :: ForeignLibType # mappend :: ForeignLibType -> ForeignLibType -> ForeignLibType # mconcat :: [ForeignLibType] -> ForeignLibType #
Monoid ShortText #
Methods mempty :: ShortText # mappend :: ShortText -> ShortText -> ShortText # mconcat :: [ShortText] -> ShortText #
Monoid BenchmarkInterface #
Methods mempty :: BenchmarkInterface # mappend :: BenchmarkInterface -> BenchmarkInterface -> BenchmarkInterface # mconcat :: [BenchmarkInterface] -> BenchmarkInterface #
Monoid TestSuiteInterface #
Methods mempty :: TestSuiteInterface # mappend :: TestSuiteInterface -> TestSuiteInterface -> TestSuiteInterface # mconcat :: [TestSuiteInterface] -> TestSuiteInterface #
Monoid DependencyMap #
Methods mempty :: DependencyMap # mappend :: DependencyMap -> DependencyMap -> DependencyMap # mconcat :: [DependencyMap] -> DependencyMap #
Monoid SetupBuildInfo #
Methods mempty :: SetupBuildInfo # mappend :: SetupBuildInfo -> SetupBuildInfo -> SetupBuildInfo # mconcat :: [SetupBuildInfo] -> SetupBuildInfo #
Monoid UnqualComponentName #
Methods mempty :: UnqualComponentName # mappend :: UnqualComponentName -> UnqualComponentName -> UnqualComponentName # mconcat :: [UnqualComponentName] -> UnqualComponentName #
Monoid BuildInfo #
Methods mempty :: BuildInfo # mappend :: BuildInfo -> BuildInfo -> BuildInfo # mconcat :: [BuildInfo] -> BuildInfo #
Monoid Benchmark #
Methods mempty :: Benchmark # mappend :: Benchmark -> Benchmark -> Benchmark # mconcat :: [Benchmark] -> Benchmark #
Monoid Executable #
Methods mempty :: Executable # mappend :: Executable -> Executable -> Executable # mconcat :: [Executable] -> Executable #
Monoid ForeignLib #
Methods mempty :: ForeignLib # mappend :: ForeignLib -> ForeignLib -> ForeignLib # mconcat :: [ForeignLib] -> ForeignLib #
Monoid Library #
Methods mempty :: Library # mappend :: Library -> Library -> Library # mconcat :: [Library] -> Library #
Monoid TestSuite #
Methods mempty :: TestSuite # mappend :: TestSuite -> TestSuite -> TestSuite # mconcat :: [TestSuite] -> TestSuite #
Monoid BenchmarkFlags #
Methods mempty :: BenchmarkFlags # mappend :: BenchmarkFlags -> BenchmarkFlags -> BenchmarkFlags # mconcat :: [BenchmarkFlags] -> BenchmarkFlags #
Monoid TestFlags #
Methods mempty :: TestFlags # mappend :: TestFlags -> TestFlags -> TestFlags # mconcat :: [TestFlags] -> TestFlags #
Monoid TestShowDetails #
Methods mempty :: TestShowDetails # mappend :: TestShowDetails -> TestShowDetails -> TestShowDetails # mconcat :: [TestShowDetails] -> TestShowDetails #
Monoid ReplFlags #
Methods mempty :: ReplFlags # mappend :: ReplFlags -> ReplFlags -> ReplFlags # mconcat :: [ReplFlags] -> ReplFlags #
Monoid BuildFlags #
Methods mempty :: BuildFlags # mappend :: BuildFlags -> BuildFlags -> BuildFlags # mconcat :: [BuildFlags] -> BuildFlags #
Monoid CleanFlags #
Methods mempty :: CleanFlags # mappend :: CleanFlags -> CleanFlags -> CleanFlags # mconcat :: [CleanFlags] -> CleanFlags #
Monoid HaddockFlags #
Methods mempty :: HaddockFlags # mappend :: HaddockFlags -> HaddockFlags -> HaddockFlags # mconcat :: [HaddockFlags] -> HaddockFlags #
Monoid DoctestFlags #
Methods mempty :: DoctestFlags # mappend :: DoctestFlags -> DoctestFlags -> DoctestFlags # mconcat :: [DoctestFlags] -> DoctestFlags #
Monoid HscolourFlags #
Methods mempty :: HscolourFlags # mappend :: HscolourFlags -> HscolourFlags -> HscolourFlags # mconcat :: [HscolourFlags] -> HscolourFlags #
Monoid RegisterFlags #
Methods mempty :: RegisterFlags # mappend :: RegisterFlags -> RegisterFlags -> RegisterFlags # mconcat :: [RegisterFlags] -> RegisterFlags #
Monoid SDistFlags #
Methods mempty :: SDistFlags # mappend :: SDistFlags -> SDistFlags -> SDistFlags # mconcat :: [SDistFlags] -> SDistFlags #
Monoid InstallFlags #
Methods mempty :: InstallFlags # mappend :: InstallFlags -> InstallFlags -> InstallFlags # mconcat :: [InstallFlags] -> InstallFlags #
Monoid CopyFlags #
Methods mempty :: CopyFlags # mappend :: CopyFlags -> CopyFlags -> CopyFlags # mconcat :: [CopyFlags] -> CopyFlags #
Monoid ConfigFlags #
Methods mempty :: ConfigFlags # mappend :: ConfigFlags -> ConfigFlags -> ConfigFlags # mconcat :: [ConfigFlags] -> ConfigFlags #
Monoid AllowOlder #
Methods mempty :: AllowOlder # mappend :: AllowOlder -> AllowOlder -> AllowOlder # mconcat :: [AllowOlder] -> AllowOlder #
Monoid AllowNewer #
Methods mempty :: AllowNewer # mappend :: AllowNewer -> AllowNewer -> AllowNewer # mconcat :: [AllowNewer] -> AllowNewer #
Monoid RelaxDeps #
Methods mempty :: RelaxDeps # mappend :: RelaxDeps -> RelaxDeps -> RelaxDeps # mconcat :: [RelaxDeps] -> RelaxDeps #
Monoid GlobalFlags #
Methods mempty :: GlobalFlags # mappend :: GlobalFlags -> GlobalFlags -> GlobalFlags # mconcat :: [GlobalFlags] -> GlobalFlags #
Monoid GhcOptions #
Methods mempty :: GhcOptions # mappend :: GhcOptions -> GhcOptions -> GhcOptions # mconcat :: [GhcOptions] -> GhcOptions #
Monoid [a]
Methods mempty :: [a] # mappend :: [a] -> [a] -> [a] # mconcat :: [[a]] -> [a] #
Monoid a => Monoid (Maybe a)	Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `ee = e` and `es = s = s*e` for all `s ∈ S`." Since there is no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead.
Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Monoid a => Monoid (IO a)
Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
Ord a => Monoid (Max a)
Methods mempty :: Max a # mappend :: Max a -> Max a -> Max a # mconcat :: [Max a] -> Max a #
Ord a => Monoid (Min a)
Methods mempty :: Min a # mappend :: Min a -> Min a -> Min a # mconcat :: [Min a] -> Min a #
Monoid a => Monoid (Identity a)
Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
(Ord a, Bounded a) => Monoid (Min a)
Methods mempty :: Min a # mappend :: Min a -> Min a -> Min a # mconcat :: [Min a] -> Min a #
(Ord a, Bounded a) => Monoid (Max a)
Methods mempty :: Max a # mappend :: Max a -> Max a -> Max a # mconcat :: [Max a] -> Max a #
Monoid m => Monoid (WrappedMonoid m)
Methods mempty :: WrappedMonoid m # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # mconcat :: [WrappedMonoid m] -> WrappedMonoid m #
Semigroup a => Monoid (Option a)
Methods mempty :: Option a # mappend :: Option a -> Option a -> Option a # mconcat :: [Option a] -> Option a #
Monoid a => Monoid (Dual a)
Methods mempty :: Dual a # mappend :: Dual a -> Dual a -> Dual a # mconcat :: [Dual a] -> Dual a #
Monoid (Endo a)
Methods mempty :: Endo a # mappend :: Endo a -> Endo a -> Endo a # mconcat :: [Endo a] -> Endo a #
Num a => Monoid (Sum a)
Methods mempty :: Sum a # mappend :: Sum a -> Sum a -> Sum a # mconcat :: [Sum a] -> Sum a #
Num a => Monoid (Product a)
Methods mempty :: Product a # mappend :: Product a -> Product a -> Product a # mconcat :: [Product a] -> Product a #
Monoid (First a)
Methods mempty :: First a # mappend :: First a -> First a -> First a # mconcat :: [First a] -> First a #
Monoid (Last a)
Methods mempty :: Last a # mappend :: Last a -> Last a -> Last a # mconcat :: [Last a] -> Last a #
Monoid (PutM ())
Methods mempty :: PutM () # mappend :: PutM () -> PutM () -> PutM () # mconcat :: [PutM ()] -> PutM () #
Monoid (IntMap a)
Methods mempty :: IntMap a # mappend :: IntMap a -> IntMap a -> IntMap a # mconcat :: [IntMap a] -> IntMap a #
Monoid (Seq a)
Methods mempty :: Seq a # mappend :: Seq a -> Seq a -> Seq a # mconcat :: [Seq a] -> Seq a #
Ord a => Monoid (Set a)
Methods mempty :: Set a # mappend :: Set a -> Set a -> Set a # mconcat :: [Set a] -> Set a #
Monoid (Doc a)
Methods mempty :: Doc a # mappend :: Doc a -> Doc a -> Doc a # mconcat :: [Doc a] -> Doc a #
Monoid (Last' a) #
Methods mempty :: Last' a # mappend :: Last' a -> Last' a -> Last' a # mconcat :: [Last' a] -> Last' a #
Monoid (DList a) #
Methods mempty :: DList a # mappend :: DList a -> DList a -> DList a # mconcat :: [DList a] -> DList a #
Monoid (Condition a) #
Methods mempty :: Condition a # mappend :: Condition a -> Condition a -> Condition a # mconcat :: [Condition a] -> Condition a #
Ord a => Monoid (NubListR a) #
Methods mempty :: NubListR a # mappend :: NubListR a -> NubListR a -> NubListR a # mconcat :: [NubListR a] -> NubListR a #
Ord a => Monoid (NubList a) #	Monoid operations on NubLists. For a valid Monoid instance we need to satistfy the required monoid laws; identity, associativity and closure. Identity : by inspection: mempty `mappend` NubList xs == NubList xs `mappend` mempty Associativity : by inspection: (NubList xs `mappend` NubList ys) `mappend` NubList zs == NubList xs `mappend` (NubList ys `mappend` NubList zs) Closure : appending two lists of type a and removing duplicates obviously does not change the type.
Methods mempty :: NubList a # mappend :: NubList a -> NubList a -> NubList a # mconcat :: [NubList a] -> NubList a #
(Semigroup dir, Monoid dir) => Monoid (InstallDirs dir) #
Methods mempty :: InstallDirs dir # mappend :: InstallDirs dir -> InstallDirs dir -> InstallDirs dir # mconcat :: [InstallDirs dir] -> InstallDirs dir #
Monoid (Flag a) #
Methods mempty :: Flag a # mappend :: Flag a -> Flag a -> Flag a # mconcat :: [Flag a] -> Flag a #
Monoid (PackageIndex InstalledPackageInfo) #
Methods mempty :: PackageIndex InstalledPackageInfo # mappend :: PackageIndex InstalledPackageInfo -> PackageIndex InstalledPackageInfo -> PackageIndex InstalledPackageInfo # mconcat :: [PackageIndex InstalledPackageInfo] -> PackageIndex InstalledPackageInfo #
Monoid b => Monoid (a -> b)
Methods mempty :: a -> b # mappend :: (a -> b) -> (a -> b) -> a -> b # mconcat :: [a -> b] -> a -> b #
(Monoid a, Monoid b) => Monoid (a, b)
Methods mempty :: (a, b) # mappend :: (a, b) -> (a, b) -> (a, b) # mconcat :: [(a, b)] -> (a, b) #
Monoid (Proxy k s)
Methods mempty :: Proxy k s # mappend :: Proxy k s -> Proxy k s -> Proxy k s # mconcat :: [Proxy k s] -> Proxy k s #
Ord k => Monoid (Map k v)
Methods mempty :: Map k v # mappend :: Map k v -> Map k v -> Map k v # mconcat :: [Map k v] -> Map k v #
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)
Methods mempty :: (a, b, c) # mappend :: (a, b, c) -> (a, b, c) -> (a, b, c) # mconcat :: [(a, b, c)] -> (a, b, c) #
Monoid a => Monoid (Const k a b)
Methods mempty :: Const k a b # mappend :: Const k a b -> Const k a b -> Const k a b # mconcat :: [Const k a b] -> Const k a b #
Alternative f => Monoid (Alt * f a)
Methods mempty :: Alt * f a # mappend :: Alt * f a -> Alt * f a -> Alt * f a # mconcat :: [Alt * f a] -> Alt * f a #
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)
Methods mempty :: (a, b, c, d) # mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # mconcat :: [(a, b, c, d)] -> (a, b, c, d) #
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)
Methods mempty :: (a, b, c, d, e) # mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e) #

newtype All :: * #

Boolean monoid under conjunction (&&).

Constructors

All
Fields getAll :: Bool

Instances

Bounded All
Methods minBound :: All # maxBound :: All #
Eq All
Methods (==) :: All -> All -> Bool # (/=) :: All -> All -> Bool #
Data All
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> All -> c All # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c All # toConstr :: All -> Constr # dataTypeOf :: All -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c All) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c All) # gmapT :: (forall b. Data b => b -> b) -> All -> All # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All -> r # gmapQ :: (forall d. Data d => d -> u) -> All -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> All -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> All -> m All # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All #
Ord All
Methods compare :: All -> All -> Ordering # (<) :: All -> All -> Bool # (<=) :: All -> All -> Bool # (>) :: All -> All -> Bool # (>=) :: All -> All -> Bool # max :: All -> All -> All # min :: All -> All -> All #
Read All
Methods readsPrec :: Int -> ReadS All # readList :: ReadS [All] # readPrec :: ReadPrec All # readListPrec :: ReadPrec [All] #
Show All
Methods showsPrec :: Int -> All -> ShowS # show :: All -> String # showList :: [All] -> ShowS #
Generic All
Associated Types type Rep All :: * -> * # Methods from :: All -> Rep All x # to :: Rep All x -> All #
Semigroup All
Methods (<>) :: All -> All -> All # sconcat :: NonEmpty All -> All # stimes :: Integral b => b -> All -> All #
Monoid All
Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
NFData All	Since: 1.4.0.0
Methods rnf :: All -> () #
type Rep All
type Rep All = D1 (MetaData "All" "Data.Monoid" "base" True) (C1 (MetaCons "All" PrefixI True) (S1 (MetaSel (Just Symbol "getAll") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool)))

newtype Any :: * #

Boolean monoid under disjunction (||).

Constructors

Any
Fields getAny :: Bool

Instances

Bounded Any
Methods minBound :: Any # maxBound :: Any #
Eq Any
Methods (==) :: Any -> Any -> Bool # (/=) :: Any -> Any -> Bool #
Data Any
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Any -> c Any # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Any # toConstr :: Any -> Constr # dataTypeOf :: Any -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Any) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Any) # gmapT :: (forall b. Data b => b -> b) -> Any -> Any # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r # gmapQ :: (forall d. Data d => d -> u) -> Any -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Any -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Any -> m Any # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any #
Ord Any
Methods compare :: Any -> Any -> Ordering # (<) :: Any -> Any -> Bool # (<=) :: Any -> Any -> Bool # (>) :: Any -> Any -> Bool # (>=) :: Any -> Any -> Bool # max :: Any -> Any -> Any # min :: Any -> Any -> Any #
Read Any
Methods readsPrec :: Int -> ReadS Any # readList :: ReadS [Any] # readPrec :: ReadPrec Any # readListPrec :: ReadPrec [Any] #
Show Any
Methods showsPrec :: Int -> Any -> ShowS # show :: Any -> String # showList :: [Any] -> ShowS #
Generic Any
Associated Types type Rep Any :: * -> * # Methods from :: Any -> Rep Any x # to :: Rep Any x -> Any #
Semigroup Any
Methods (<>) :: Any -> Any -> Any # sconcat :: NonEmpty Any -> Any # stimes :: Integral b => b -> Any -> Any #
Monoid Any
Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [Any] -> Any #
NFData Any	Since: 1.4.0.0
Methods rnf :: Any -> () #
type Rep Any
type Rep Any = D1 (MetaData "Any" "Data.Monoid" "base" True) (C1 (MetaCons "Any" PrefixI True) (S1 (MetaSel (Just Symbol "getAny") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool)))

newtype Last' a Source #

Cabal's own Last copy to avoid requiring an orphan Binary instance.

Once the oldest binary version we support provides a Binary instance for Last we can remove this one here.

NB: Last is defined differently and not a Monoid

Constructors

Last'
Fields getLast' :: Maybe a

Instances

Functor Last' Source #
Methods fmap :: (a -> b) -> Last' a -> Last' b # (<$) :: a -> Last' b -> Last' a #
Applicative Last' Source #
Methods pure :: a -> Last' a # (<>) :: Last' (a -> b) -> Last' a -> Last' b # (>) :: Last' a -> Last' b -> Last' b # (<*) :: Last' a -> Last' b -> Last' a #
Eq a => Eq (Last' a) Source #
Methods (==) :: Last' a -> Last' a -> Bool # (/=) :: Last' a -> Last' a -> Bool #
Ord a => Ord (Last' a) Source #
Methods compare :: Last' a -> Last' a -> Ordering # (<) :: Last' a -> Last' a -> Bool # (<=) :: Last' a -> Last' a -> Bool # (>) :: Last' a -> Last' a -> Bool # (>=) :: Last' a -> Last' a -> Bool # max :: Last' a -> Last' a -> Last' a # min :: Last' a -> Last' a -> Last' a #
Read a => Read (Last' a) Source #
Methods readsPrec :: Int -> ReadS (Last' a) # readList :: ReadS [Last' a] # readPrec :: ReadPrec (Last' a) # readListPrec :: ReadPrec [Last' a] #
Show a => Show (Last' a) Source #
Methods showsPrec :: Int -> Last' a -> ShowS # show :: Last' a -> String # showList :: [Last' a] -> ShowS #
Generic (Last' a) Source #
Associated Types type Rep (Last' a) :: * -> * # Methods from :: Last' a -> Rep (Last' a) x # to :: Rep (Last' a) x -> Last' a #
Semigroup (Last' a) Source #
Methods (<>) :: Last' a -> Last' a -> Last' a # sconcat :: NonEmpty (Last' a) -> Last' a # stimes :: Integral b => b -> Last' a -> Last' a #
Monoid (Last' a) Source #
Methods mempty :: Last' a # mappend :: Last' a -> Last' a -> Last' a # mconcat :: [Last' a] -> Last' a #
Binary a => Binary (Last' a) Source #
Methods put :: Last' a -> Put # get :: Get (Last' a) # putList :: [Last' a] -> Put #
type Rep (Last' a) Source #
type Rep (Last' a) = D1 (MetaData "Last'" "Distribution.Compat.Semigroup" "Cabal-2.0.0.2-B4YxsRmpeLCDyDZ1N9nEz7" True) (C1 (MetaCons "Last'" PrefixI True) (S1 (MetaSel (Just Symbol "getLast'") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe a))))

gmappend :: (Generic a, GSemigroup (Rep a)) => a -> a -> a Source #

Generically generate a Semigroup (<>) operation for any type implementing Generic. This operation will append two values by point-wise appending their component fields. It is only defined for product types.

gmappend a (gmappend b c) = gmappend (gmappend a b) c

gmempty :: (Generic a, GMonoid (Rep a)) => a Source #

Generically generate a Monoid mempty for any product-like type implementing Generic.

It is only defined for product types.

gmappend gmempty a = a = gmappend a gmempty