Safe Haskell	None
Language	Haskell98

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

Minimal complete definition

Nothing

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 BuildInfo #
Methods (<>) :: BuildInfo -> BuildInfo -> BuildInfo # sconcat :: NonEmpty BuildInfo -> BuildInfo # stimes :: Integral b => b -> BuildInfo -> BuildInfo #
Semigroup BenchmarkInterface #
Methods (<>) :: BenchmarkInterface -> BenchmarkInterface -> BenchmarkInterface # sconcat :: NonEmpty BenchmarkInterface -> BenchmarkInterface # stimes :: Integral b => b -> BenchmarkInterface -> BenchmarkInterface #
Semigroup Benchmark #
Methods (<>) :: Benchmark -> Benchmark -> Benchmark # sconcat :: NonEmpty Benchmark -> Benchmark # stimes :: Integral b => b -> Benchmark -> Benchmark #
Semigroup TestSuiteInterface #
Methods (<>) :: TestSuiteInterface -> TestSuiteInterface -> TestSuiteInterface # sconcat :: NonEmpty TestSuiteInterface -> TestSuiteInterface # stimes :: Integral b => b -> TestSuiteInterface -> TestSuiteInterface #
Semigroup TestSuite #
Methods (<>) :: TestSuite -> TestSuite -> TestSuite # sconcat :: NonEmpty TestSuite -> TestSuite # stimes :: Integral b => b -> TestSuite -> TestSuite #
Semigroup Executable #
Methods (<>) :: Executable -> Executable -> Executable # sconcat :: NonEmpty Executable -> Executable # stimes :: Integral b => b -> Executable -> Executable #
Semigroup Library #
Methods (<>) :: Library -> Library -> Library # sconcat :: NonEmpty Library -> Library # stimes :: Integral b => b -> Library -> Library #
Semigroup ModuleRenaming #
Methods (<>) :: ModuleRenaming -> ModuleRenaming -> ModuleRenaming # sconcat :: NonEmpty ModuleRenaming -> ModuleRenaming # stimes :: Integral b => b -> ModuleRenaming -> ModuleRenaming #
Semigroup SetupBuildInfo #
Methods (<>) :: SetupBuildInfo -> SetupBuildInfo -> SetupBuildInfo # sconcat :: NonEmpty SetupBuildInfo -> SetupBuildInfo # stimes :: Integral b => b -> SetupBuildInfo -> SetupBuildInfo #
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 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 AllowNewer #
Methods (<>) :: AllowNewer -> AllowNewer -> AllowNewer # sconcat :: NonEmpty AllowNewer -> AllowNewer # stimes :: Integral b => b -> AllowNewer -> AllowNewer #
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 (Seq a)
Methods (<>) :: Seq a -> Seq a -> Seq a # sconcat :: NonEmpty (Seq a) -> Seq a # stimes :: Integral b => b -> Seq a -> Seq a #
Semigroup (IntMap a)
Methods (<>) :: IntMap a -> IntMap a -> IntMap a # sconcat :: NonEmpty (IntMap a) -> IntMap a # stimes :: Integral b => b -> IntMap a -> IntMap 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 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 (Condition a) #
Methods (<>) :: Condition a -> Condition a -> Condition a # sconcat :: NonEmpty (Condition a) -> Condition a # stimes :: Integral b => b -> Condition a -> Condition a #
HasUnitId a => Semigroup (PackageIndex a) #
Methods (<>) :: PackageIndex a -> PackageIndex a -> PackageIndex a # sconcat :: NonEmpty (PackageIndex a) -> PackageIndex a # stimes :: Integral b => b -> PackageIndex a -> PackageIndex 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 (Flag a) #
Methods (<>) :: Flag a -> Flag a -> Flag a # sconcat :: NonEmpty (Flag a) -> Flag a # stimes :: Integral b => b -> Flag a -> Flag 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 (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

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 BuildInfo #
Methods mempty :: BuildInfo # mappend :: BuildInfo -> BuildInfo -> BuildInfo # mconcat :: [BuildInfo] -> BuildInfo #
Monoid BenchmarkInterface #
Methods mempty :: BenchmarkInterface # mappend :: BenchmarkInterface -> BenchmarkInterface -> BenchmarkInterface # mconcat :: [BenchmarkInterface] -> BenchmarkInterface #
Monoid Benchmark #
Methods mempty :: Benchmark # mappend :: Benchmark -> Benchmark -> Benchmark # mconcat :: [Benchmark] -> Benchmark #
Monoid TestSuiteInterface #
Methods mempty :: TestSuiteInterface # mappend :: TestSuiteInterface -> TestSuiteInterface -> TestSuiteInterface # mconcat :: [TestSuiteInterface] -> TestSuiteInterface #
Monoid TestSuite #
Methods mempty :: TestSuite # mappend :: TestSuite -> TestSuite -> TestSuite # mconcat :: [TestSuite] -> TestSuite #
Monoid Executable #
Methods mempty :: Executable # mappend :: Executable -> Executable -> Executable # mconcat :: [Executable] -> Executable #
Monoid Library #
Methods mempty :: Library # mappend :: Library -> Library -> Library # mconcat :: [Library] -> Library #
Monoid ModuleRenaming #
Methods mempty :: ModuleRenaming # mappend :: ModuleRenaming -> ModuleRenaming -> ModuleRenaming # mconcat :: [ModuleRenaming] -> ModuleRenaming #
Monoid SetupBuildInfo #
Methods mempty :: SetupBuildInfo # mappend :: SetupBuildInfo -> SetupBuildInfo -> SetupBuildInfo # mconcat :: [SetupBuildInfo] -> SetupBuildInfo #
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 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 AllowNewer #
Methods mempty :: AllowNewer # mappend :: AllowNewer -> AllowNewer -> AllowNewer # mconcat :: [AllowNewer] -> AllowNewer #
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 (Seq a)
Methods mempty :: Seq a # mappend :: Seq a -> Seq a -> Seq a # mconcat :: [Seq a] -> Seq a #
Monoid (IntMap a)
Methods mempty :: IntMap a # mappend :: IntMap a -> IntMap a -> IntMap a # mconcat :: [IntMap a] -> IntMap 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 #
(Semigroup dir, Monoid dir) => Monoid (InstallDirs dir) #
Methods mempty :: InstallDirs dir # mappend :: InstallDirs dir -> InstallDirs dir -> InstallDirs dir # mconcat :: [InstallDirs dir] -> InstallDirs dir #
Monoid (Condition a) #
Methods mempty :: Condition a # mappend :: Condition a -> Condition a -> Condition a # mconcat :: [Condition a] -> Condition a #
HasUnitId a => Monoid (PackageIndex a) #
Methods mempty :: PackageIndex a # mappend :: PackageIndex a -> PackageIndex a -> PackageIndex a # mconcat :: [PackageIndex a] -> PackageIndex 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 #
Monoid (Flag a) #
Methods mempty :: Flag a # mappend :: Flag a -> Flag a -> Flag a # mconcat :: [Flag a] -> Flag a #
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-1.24.0.0-3JM9vM0gd2WB0sWdRR0T8c" 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