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	Since: 4.9.0.0
Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # stimes :: Integral b => b -> Ordering -> Ordering #
Semigroup ()	Since: 4.9.0.0
Methods (<>) :: () -> () -> () # sconcat :: NonEmpty () -> () # stimes :: Integral b => b -> () -> () #
Semigroup Void	Since: 4.9.0.0
Methods (<>) :: Void -> Void -> Void # sconcat :: NonEmpty Void -> Void # stimes :: Integral b => b -> Void -> Void #
Semigroup Event	Since: 4.10.0.0
Methods (<>) :: Event -> Event -> Event # sconcat :: NonEmpty Event -> Event # stimes :: Integral b => b -> Event -> Event #
Semigroup Lifetime	Since: 4.10.0.0
Methods (<>) :: Lifetime -> Lifetime -> Lifetime # sconcat :: NonEmpty Lifetime -> Lifetime # stimes :: Integral b => b -> Lifetime -> Lifetime #
Semigroup All	Since: 4.9.0.0
Methods (<>) :: All -> All -> All # sconcat :: NonEmpty All -> All # stimes :: Integral b => b -> All -> All #
Semigroup Any	Since: 4.9.0.0
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 ShortText #
Methods (<>) :: ShortText -> ShortText -> ShortText # sconcat :: NonEmpty ShortText -> ShortText # stimes :: Integral b => b -> ShortText -> ShortText #
Semigroup ForeignLibType #
Methods (<>) :: ForeignLibType -> ForeignLibType -> ForeignLibType # sconcat :: NonEmpty ForeignLibType -> ForeignLibType # stimes :: Integral b => b -> ForeignLibType -> ForeignLibType #
Semigroup ExecutableScope #	`Any` like semigroup, where `ExecutablePrivate` is 'Any True'
Methods (<>) :: ExecutableScope -> ExecutableScope -> ExecutableScope # sconcat :: NonEmpty ExecutableScope -> ExecutableScope # stimes :: Integral b => b -> ExecutableScope -> ExecutableScope #
Semigroup TestSuiteInterface #
Methods (<>) :: TestSuiteInterface -> TestSuiteInterface -> TestSuiteInterface # sconcat :: NonEmpty TestSuiteInterface -> TestSuiteInterface # stimes :: Integral b => b -> TestSuiteInterface -> TestSuiteInterface #
Semigroup BenchmarkInterface #
Methods (<>) :: BenchmarkInterface -> BenchmarkInterface -> BenchmarkInterface # sconcat :: NonEmpty BenchmarkInterface -> BenchmarkInterface # stimes :: Integral b => b -> BenchmarkInterface -> BenchmarkInterface #
Semigroup UnqualComponentName #
Methods (<>) :: UnqualComponentName -> UnqualComponentName -> UnqualComponentName # sconcat :: NonEmpty UnqualComponentName -> UnqualComponentName # stimes :: Integral b => b -> UnqualComponentName -> UnqualComponentName #
Semigroup SetupBuildInfo #
Methods (<>) :: SetupBuildInfo -> SetupBuildInfo -> SetupBuildInfo # sconcat :: NonEmpty SetupBuildInfo -> SetupBuildInfo # stimes :: Integral b => b -> SetupBuildInfo -> SetupBuildInfo #
Semigroup DependencyMap #
Methods (<>) :: DependencyMap -> DependencyMap -> DependencyMap # sconcat :: NonEmpty DependencyMap -> DependencyMap # stimes :: Integral b => b -> DependencyMap -> DependencyMap #
Semigroup BuildInfo #
Methods (<>) :: BuildInfo -> BuildInfo -> BuildInfo # sconcat :: NonEmpty BuildInfo -> BuildInfo # stimes :: Integral b => b -> BuildInfo -> BuildInfo #
Semigroup TestSuite #
Methods (<>) :: TestSuite -> TestSuite -> TestSuite # sconcat :: NonEmpty TestSuite -> TestSuite # stimes :: Integral b => b -> TestSuite -> TestSuite #
Semigroup Library #
Methods (<>) :: Library -> Library -> Library # sconcat :: NonEmpty Library -> Library # stimes :: Integral b => b -> Library -> Library #
Semigroup ForeignLib #
Methods (<>) :: ForeignLib -> ForeignLib -> ForeignLib # sconcat :: NonEmpty ForeignLib -> ForeignLib # stimes :: Integral b => b -> ForeignLib -> ForeignLib #
Semigroup Executable #
Methods (<>) :: Executable -> Executable -> Executable # sconcat :: NonEmpty Executable -> Executable # stimes :: Integral b => b -> Executable -> Executable #
Semigroup Benchmark #
Methods (<>) :: Benchmark -> Benchmark -> Benchmark # sconcat :: NonEmpty Benchmark -> Benchmark # stimes :: Integral b => b -> Benchmark -> Benchmark #
Semigroup Component #
Methods (<>) :: Component -> Component -> Component # sconcat :: NonEmpty Component -> Component # stimes :: Integral b => b -> Component -> Component #
Semigroup FlagAssignment #
Methods (<>) :: FlagAssignment -> FlagAssignment -> FlagAssignment # sconcat :: NonEmpty FlagAssignment -> FlagAssignment # stimes :: Integral b => b -> FlagAssignment -> FlagAssignment #
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 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]	Since: 4.9.0.0
Methods (<>) :: [a] -> [a] -> [a] # sconcat :: NonEmpty [a] -> [a] # stimes :: Integral b => b -> [a] -> [a] #
Semigroup a => Semigroup (Maybe a)	Since: 4.9.0.0
Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe a #
Semigroup a => Semigroup (IO a)	Since: 4.10.0.0
Methods (<>) :: IO a -> IO a -> IO a # sconcat :: NonEmpty (IO a) -> IO a # stimes :: Integral b => b -> IO a -> IO a #
Ord a => Semigroup (Min a)	Since: 4.9.0.0
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)	Since: 4.9.0.0
Methods (<>) :: Max a -> Max a -> Max a # sconcat :: NonEmpty (Max a) -> Max a # stimes :: Integral b => b -> Max a -> Max a #
Semigroup (First a)	Since: 4.9.0.0
Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # stimes :: Integral b => b -> First a -> First a #
Semigroup (Last a)	Since: 4.9.0.0
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)	Since: 4.9.0.0
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)	Since: 4.9.0.0
Methods (<>) :: Option a -> Option a -> Option a # sconcat :: NonEmpty (Option a) -> Option a # stimes :: Integral b => b -> Option a -> Option a #
Semigroup (NonEmpty a)	Since: 4.9.0.0
Methods (<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a # sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a # stimes :: Integral b => b -> NonEmpty a -> NonEmpty a #
Semigroup a => Semigroup (Identity a)	Since: 4.9.0.0
Methods (<>) :: Identity a -> Identity a -> Identity a # sconcat :: NonEmpty (Identity a) -> Identity a # stimes :: Integral b => b -> Identity a -> Identity a #
Semigroup a => Semigroup (Dual a)	Since: 4.9.0.0
Methods (<>) :: Dual a -> Dual a -> Dual a # sconcat :: NonEmpty (Dual a) -> Dual a # stimes :: Integral b => b -> Dual a -> Dual a #
Semigroup (Endo a)	Since: 4.9.0.0
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)	Since: 4.9.0.0
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)	Since: 4.9.0.0
Methods (<>) :: Product a -> Product a -> Product a # sconcat :: NonEmpty (Product a) -> Product a # stimes :: Integral b => b -> Product a -> Product a #
Semigroup (First a)	Since: 4.9.0.0
Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # stimes :: Integral b => b -> First a -> First a #
Semigroup (Last a)	Since: 4.9.0.0
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 #
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 #
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 (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)	Since: 4.9.0.0
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)	Since: 4.9.0.0
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)	Since: 4.9.0.0
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)	Since: 4.9.0.0
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)	Since: 4.9.0.0
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)	Since: 4.9.0.0
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)	Since: 4.9.0.0
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)	Since: 4.9.0.0
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 (ParsecT s u m a)
Methods (<>) :: ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a # sconcat :: NonEmpty (ParsecT s u m a) -> ParsecT s u m a # stimes :: Integral b => b -> ParsecT s u m a -> ParsecT s u m a #
(Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e)	Since: 4.9.0.0
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	Since: 2.1
Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Monoid ()	Since: 2.1
Methods mempty :: () # mappend :: () -> () -> () # mconcat :: [()] -> () #
Monoid EventLifetime	Since: 4.8.0.0
Methods mempty :: EventLifetime # mappend :: EventLifetime -> EventLifetime -> EventLifetime # mconcat :: [EventLifetime] -> EventLifetime #
Monoid Event	Since: 4.3.1.0
Methods mempty :: Event # mappend :: Event -> Event -> Event # mconcat :: [Event] -> Event #
Monoid Lifetime	`mappend` takes the longer of two lifetimes. Since: 4.8.0.0
Methods mempty :: Lifetime # mappend :: Lifetime -> Lifetime -> Lifetime # mconcat :: [Lifetime] -> Lifetime #
Monoid All	Since: 2.1
Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
Monoid Any	Since: 2.1
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 ShortText #
Methods mempty :: ShortText # mappend :: ShortText -> ShortText -> ShortText # mconcat :: [ShortText] -> ShortText #
Monoid ForeignLibType #
Methods mempty :: ForeignLibType # mappend :: ForeignLibType -> ForeignLibType -> ForeignLibType # mconcat :: [ForeignLibType] -> ForeignLibType #
Monoid ExecutableScope #	`mempty` = `ExecutablePublic`
Methods mempty :: ExecutableScope # mappend :: ExecutableScope -> ExecutableScope -> ExecutableScope # mconcat :: [ExecutableScope] -> ExecutableScope #
Monoid TestSuiteInterface #
Methods mempty :: TestSuiteInterface # mappend :: TestSuiteInterface -> TestSuiteInterface -> TestSuiteInterface # mconcat :: [TestSuiteInterface] -> TestSuiteInterface #
Monoid BenchmarkInterface #
Methods mempty :: BenchmarkInterface # mappend :: BenchmarkInterface -> BenchmarkInterface -> BenchmarkInterface # mconcat :: [BenchmarkInterface] -> BenchmarkInterface #
Monoid UnqualComponentName #
Methods mempty :: UnqualComponentName # mappend :: UnqualComponentName -> UnqualComponentName -> UnqualComponentName # mconcat :: [UnqualComponentName] -> UnqualComponentName #
Monoid SetupBuildInfo #
Methods mempty :: SetupBuildInfo # mappend :: SetupBuildInfo -> SetupBuildInfo -> SetupBuildInfo # mconcat :: [SetupBuildInfo] -> SetupBuildInfo #
Monoid DependencyMap #
Methods mempty :: DependencyMap # mappend :: DependencyMap -> DependencyMap -> DependencyMap # mconcat :: [DependencyMap] -> DependencyMap #
Monoid BuildInfo #
Methods mempty :: BuildInfo # mappend :: BuildInfo -> BuildInfo -> BuildInfo # mconcat :: [BuildInfo] -> BuildInfo #
Monoid TestSuite #
Methods mempty :: TestSuite # mappend :: TestSuite -> TestSuite -> TestSuite # mconcat :: [TestSuite] -> TestSuite #
Monoid Library #
Methods mempty :: Library # mappend :: Library -> Library -> Library # mconcat :: [Library] -> Library #
Monoid ForeignLib #
Methods mempty :: ForeignLib # mappend :: ForeignLib -> ForeignLib -> ForeignLib # mconcat :: [ForeignLib] -> ForeignLib #
Monoid Executable #
Methods mempty :: Executable # mappend :: Executable -> Executable -> Executable # mconcat :: [Executable] -> Executable #
Monoid Benchmark #
Methods mempty :: Benchmark # mappend :: Benchmark -> Benchmark -> Benchmark # mconcat :: [Benchmark] -> Benchmark #
Monoid FlagAssignment #
Methods mempty :: FlagAssignment # mappend :: FlagAssignment -> FlagAssignment -> FlagAssignment # mconcat :: [FlagAssignment] -> FlagAssignment #
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 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]	Since: 2.1
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 = se` for all `s ∈ S`." Since there used to be no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead. Since: 2.1*
Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Monoid a => Monoid (IO a)	Since: 4.9.0.0
Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
(Ord a, Bounded a) => Monoid (Min a)	Since: 4.9.0.0
Methods mempty :: Min a # mappend :: Min a -> Min a -> Min a # mconcat :: [Min a] -> Min a #
(Ord a, Bounded a) => Monoid (Max a)	Since: 4.9.0.0
Methods mempty :: Max a # mappend :: Max a -> Max a -> Max a # mconcat :: [Max a] -> Max a #
Monoid m => Monoid (WrappedMonoid m)	Since: 4.9.0.0
Methods mempty :: WrappedMonoid m # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # mconcat :: [WrappedMonoid m] -> WrappedMonoid m #
Semigroup a => Monoid (Option a)	Since: 4.9.0.0
Methods mempty :: Option a # mappend :: Option a -> Option a -> Option a # mconcat :: [Option a] -> Option a #
Monoid a => Monoid (Identity a)
Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
Monoid a => Monoid (Dual a)	Since: 2.1
Methods mempty :: Dual a # mappend :: Dual a -> Dual a -> Dual a # mconcat :: [Dual a] -> Dual a #
Monoid (Endo a)	Since: 2.1
Methods mempty :: Endo a # mappend :: Endo a -> Endo a -> Endo a # mconcat :: [Endo a] -> Endo a #
Num a => Monoid (Sum a)	Since: 2.1
Methods mempty :: Sum a # mappend :: Sum a -> Sum a -> Sum a # mconcat :: [Sum a] -> Sum a #
Num a => Monoid (Product a)	Since: 2.1
Methods mempty :: Product a # mappend :: Product a -> Product a -> Product a # mconcat :: [Product a] -> Product a #
Monoid (First a)	Since: 2.1
Methods mempty :: First a # mappend :: First a -> First a -> First a # mconcat :: [First a] -> First a #
Monoid (Last a)	Since: 2.1
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 #
(Semigroup dir, Monoid dir) => Monoid (InstallDirs dir) #
Methods mempty :: InstallDirs dir # mappend :: InstallDirs dir -> InstallDirs dir -> InstallDirs dir # mconcat :: [InstallDirs dir] -> InstallDirs dir #
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 #
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)	Since: 2.1
Methods mempty :: a -> b # mappend :: (a -> b) -> (a -> b) -> a -> b # mconcat :: [a -> b] -> a -> b #
(Monoid a, Monoid b) => Monoid (a, b)	Since: 2.1
Methods mempty :: (a, b) # mappend :: (a, b) -> (a, b) -> (a, b) # mconcat :: [(a, b)] -> (a, b) #
Monoid (Proxy k s)	Since: 4.7.0.0
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)	Since: 2.1
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)	Since: 4.8.0.0
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)	Since: 2.1
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, Semigroup (ParsecT s u m a)) => Monoid (ParsecT s u m a)
Methods mempty :: ParsecT s u m a # mappend :: ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a # mconcat :: [ParsecT s u m a] -> ParsecT s u m a #
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)	Since: 2.1
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	Since: 4.8.0.0
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	Since: 4.9.0.0
Methods (<>) :: All -> All -> All # sconcat :: NonEmpty All -> All # stimes :: Integral b => b -> All -> All #
Monoid All	Since: 2.1
Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
Binary All	Since: 0.8.4.0
Methods put :: All -> Put # get :: Get All # putList :: [All] -> Put #
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	Since: 4.8.0.0
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	Since: 4.9.0.0
Methods (<>) :: Any -> Any -> Any # sconcat :: NonEmpty Any -> Any # stimes :: Integral b => b -> Any -> Any #
Monoid Any	Since: 2.1
Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [Any] -> Any #
Binary Any	Since: 0.8.4.0
Methods put :: Any -> Put # get :: Get Any # putList :: [Any] -> Put #
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 #

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' #
Methods fmap :: (a -> b) -> Last' a -> Last' b # (<$) :: a -> Last' b -> Last' a #
Applicative Last' #
Methods pure :: a -> Last' a # (<>) :: Last' (a -> b) -> Last' a -> Last' b # liftA2 :: (a -> b -> c) -> Last' a -> Last' b -> Last' c # (>) :: Last' a -> Last' b -> Last' b # (<*) :: Last' a -> Last' b -> Last' a #
Eq a => Eq (Last' a) #
Methods (==) :: Last' a -> Last' a -> Bool # (/=) :: Last' a -> Last' a -> Bool #
Ord a => Ord (Last' a) #
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) #
Methods readsPrec :: Int -> ReadS (Last' a) # readList :: ReadS [Last' a] # readPrec :: ReadPrec (Last' a) # readListPrec :: ReadPrec [Last' a] #
Show a => Show (Last' a) #
Methods showsPrec :: Int -> Last' a -> ShowS # show :: Last' a -> String # showList :: [Last' a] -> ShowS #
Generic (Last' a) #
Associated Types type Rep (Last' a) :: * -> * # Methods from :: Last' a -> Rep (Last' a) x # to :: Rep (Last' a) x -> Last' 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 (Last' a) #
Methods mempty :: Last' a # mappend :: Last' a -> Last' a -> Last' a # mconcat :: [Last' a] -> Last' a #
Binary a => Binary (Last' a) #
Methods put :: Last' a -> Put # get :: Get (Last' a) # putList :: [Last' a] -> Put #
type Rep (Last' a) #
type Rep (Last' a) = D1 * (MetaData "Last'" "Distribution.Compat.Semigroup" "Cabal-2.2.0.0-KtVb5LuYqFjKrhxFyS8D9H" 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 #

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 #

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