Domain.Algebra.Group

Monoids

class Semigroup a => Monoid a where

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

• x <> mempty = x

• mempty <> x = x

• x <> (y <> z) = (x <> y) <> z (Semigroup law)

• mconcat = foldr '(<>)' 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.

NOTE: Semigroup is a superclass of Monoid since base-4.11.0.0.

Minimal complete definition

mempty

Methods

mempty :: a

Identity of mappend

mappend :: a -> a -> a

An associative operation

NOTE: This method is redundant and has the default implementation mappend = '(<>)' since base-4.11.0.0.

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: base-2.1

Defined in GHC.Base

Methods

mempty :: Ordering

mappend :: Ordering -> Ordering -> Ordering

mconcat :: [Ordering] -> Ordering

Monoid ()

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: ()

mappend :: () -> () -> ()

mconcat :: [()] -> ()

Monoid All

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: All

mappend :: All -> All -> All

mconcat :: [All] -> All

Monoid Any

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Any

mappend :: Any -> Any -> Any

mconcat :: [Any] -> Any

Monoid ByteString

Defined in Data.ByteString.Lazy.Internal

Methods

mempty :: ByteString

mappend :: ByteString -> ByteString -> ByteString

mconcat :: [ByteString] -> ByteString

Monoid ByteString

Defined in Data.ByteString.Internal

Methods

mempty :: ByteString

mappend :: ByteString -> ByteString -> ByteString

mconcat :: [ByteString] -> ByteString

Monoid IntSet

Defined in Data.IntSet.Internal

Methods

mempty :: IntSet

mappend :: IntSet -> IntSet -> IntSet

mconcat :: [IntSet] -> IntSet

Monoid Id

Defined in Ideas.Common.Id

Methods

mempty :: Id

mappend :: Id -> Id -> Id

mconcat :: [Id] -> Id

Monoid Latex

Defined in Ideas.Text.Latex

Methods

mempty :: Latex

mappend :: Latex -> Latex -> Latex

mconcat :: [Latex] -> Latex

Monoid Environment

Defined in Ideas.Common.Environment

Methods

mempty :: Environment

mappend :: Environment -> Environment -> Environment

mconcat :: [Environment] -> Environment

Monoid Message

Defined in Ideas.Utils.TestSuite

Methods

mempty :: Message

mappend :: Message -> Message -> Message

mconcat :: [Message] -> Message

Monoid Rating

Defined in Ideas.Utils.TestSuite

Methods

mempty :: Rating

mappend :: Rating -> Rating -> Rating

mconcat :: [Rating] -> Rating

Monoid Result

Defined in Ideas.Utils.TestSuite

Methods

mempty :: Result

mappend :: Result -> Result -> Result

mconcat :: [Result] -> Result

Monoid Status

Defined in Ideas.Utils.TestSuite

Methods

mempty :: Status

mappend :: Status -> Status -> Status

mconcat :: [Status] -> Status

Monoid TestSuite

Defined in Ideas.Utils.TestSuite

Methods

mempty :: TestSuite

mappend :: TestSuite -> TestSuite -> TestSuite

mconcat :: [TestSuite] -> TestSuite

Monoid StrategyCfg

Defined in Ideas.Common.Strategy.Configuration

Methods

mempty :: StrategyCfg

mappend :: StrategyCfg -> StrategyCfg -> StrategyCfg

mconcat :: [StrategyCfg] -> StrategyCfg

Monoid Location

Defined in Ideas.Common.Traversal.Navigator

Methods

mempty :: Location

mappend :: Location -> Location -> Location

mconcat :: [Location] -> Location

Monoid [a]

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: [a]

mappend :: [a] -> [a] -> [a]

mconcat :: [[a]] -> [a]

Semigroup 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 e*e = e and e*s = s = s*e for all s ∈ S."

Since 4.11.0: constraint on inner a value generalised from Monoid to Semigroup.

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: Maybe a

mappend :: Maybe a -> Maybe a -> Maybe a

mconcat :: [Maybe a] -> Maybe a

Monoid a => Monoid (IO a)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

mempty :: IO a

mappend :: IO a -> IO a -> IO a

mconcat :: [IO a] -> IO a

(Ord a, Bounded a) => Monoid (Min a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mempty :: Min a

mappend :: Min a -> Min a -> Min a

mconcat :: [Min a] -> Min a

(Ord a, Bounded a) => Monoid (Max a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mempty :: Max a

mappend :: Max a -> Max a -> Max a

mconcat :: [Max a] -> Max a

Monoid m => Monoid (WrappedMonoid m)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mempty :: WrappedMonoid m

mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m

mconcat :: [WrappedMonoid m] -> WrappedMonoid m

Semigroup a => Monoid (Option a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mempty :: Option a

mappend :: Option a -> Option a -> Option a

mconcat :: [Option a] -> Option a

Monoid a => Monoid (Identity a)

Defined in Data.Functor.Identity

Methods

mempty :: Identity a

mappend :: Identity a -> Identity a -> Identity a

mconcat :: [Identity a] -> Identity a

Monoid (First a)

Since: base-2.1

Defined in Data.Monoid

Methods

mempty :: First a

mappend :: First a -> First a -> First a

mconcat :: [First a] -> First a

Monoid (Last a)

Since: base-2.1

Defined in Data.Monoid

Methods

mempty :: Last a

mappend :: Last a -> Last a -> Last a

mconcat :: [Last a] -> Last a

Monoid a => Monoid (Dual a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Dual a

mappend :: Dual a -> Dual a -> Dual a

mconcat :: [Dual a] -> Dual a

Monoid (Endo a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Endo a

mappend :: Endo a -> Endo a -> Endo a

mconcat :: [Endo a] -> Endo a

Num a => Monoid (Sum a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Sum a

mappend :: Sum a -> Sum a -> Sum a

mconcat :: [Sum a] -> Sum a

Num a => Monoid (Product a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Product a

mappend :: Product a -> Product a -> Product a

mconcat :: [Product a] -> Product a

Monoid (IntMap a)

Defined in Data.IntMap.Internal

Methods

mempty :: IntMap a

mappend :: IntMap a -> IntMap a -> IntMap a

mconcat :: [IntMap a] -> IntMap a

Monoid (Seq a)

Defined in Data.Sequence.Internal

Methods

mempty :: Seq a

mappend :: Seq a -> Seq a -> Seq a

mconcat :: [Seq a] -> Seq a

Ord a => Monoid (Set a)

Defined in Data.Set.Internal

Methods

mempty :: Set a

mappend :: Set a -> Set a -> Set a

mconcat :: [Set a] -> Set a

Monoid a => Monoid (WithZero a)

Defined in Domain.Algebra.Group

Methods

mempty :: WithZero a

mappend :: WithZero a -> WithZero a -> WithZero a

mconcat :: [WithZero a] -> WithZero a

Monoid (MergeSet a)

Defined in Data.Set.Internal

Methods

mempty :: MergeSet a

mappend :: MergeSet a -> MergeSet a -> MergeSet a

mconcat :: [MergeSet a] -> MergeSet a

SemiRing a => Monoid (Multiplicative a)

Defined in Domain.Algebra.Field

Methods

mempty :: Multiplicative a

mappend :: Multiplicative a -> Multiplicative a -> Multiplicative a

mconcat :: [Multiplicative a] -> Multiplicative a

SemiRing a => Monoid (Additive a)

Defined in Domain.Algebra.Field

Methods

mempty :: Additive a

mappend :: Additive a -> Additive a -> Additive a

mconcat :: [Additive a] -> Additive a

Boolean a => Monoid (Or a)

Defined in Domain.Algebra.Boolean

Methods

mempty :: Or a

mappend :: Or a -> Or a -> Or a

mconcat :: [Or a] -> Or a

Boolean a => Monoid (And a)

Defined in Domain.Algebra.Boolean

Methods

mempty :: And a

mappend :: And a -> And a -> And a

mconcat :: [And a] -> And a

(CoGroup a, Group a) => Monoid (SmartGroup a)

Defined in Domain.Algebra.SmartGroup

Methods

mempty :: SmartGroup a

mappend :: SmartGroup a -> SmartGroup a -> SmartGroup a

mconcat :: [SmartGroup a] -> SmartGroup a

(CoMonoidZero a, MonoidZero a) => Monoid (SmartZero a)

Defined in Domain.Algebra.SmartGroup

Methods

mempty :: SmartZero a

mappend :: SmartZero a -> SmartZero a -> SmartZero a

mconcat :: [SmartZero a] -> SmartZero a

(CoMonoid a, Monoid a) => Monoid (Smart a)

Defined in Domain.Algebra.SmartGroup

Methods

mempty :: Smart a

mappend :: Smart a -> Smart a -> Smart a

mconcat :: [Smart a] -> Smart a

Monoid (Examples a)

Defined in Ideas.Common.Examples

Methods

mempty :: Examples a

mappend :: Examples a -> Examples a -> Examples a

mconcat :: [Examples a] -> Examples a

Ord a => Monoid (OrSet a)

Defined in Domain.Math.Data.OrList

Methods

mempty :: OrSet a

mappend :: OrSet a -> OrSet a -> OrSet a

mconcat :: [OrSet a] -> OrSet a

Monoid (OrList a)

Defined in Domain.Math.Data.OrList

Methods

mempty :: OrList a

mappend :: OrList a -> OrList a -> OrList a

mconcat :: [OrList a] -> OrList a

Monoid (Recognizer a)

Defined in Ideas.Common.Rule.Recognizer

Methods

mempty :: Recognizer a

mappend :: Recognizer a -> Recognizer a -> Recognizer a

mconcat :: [Recognizer a] -> Recognizer a

Monoid (Prefix a)

Defined in Ideas.Common.Strategy.Prefix

Methods

mempty :: Prefix a

mappend :: Prefix a -> Prefix a -> Prefix a

mconcat :: [Prefix a] -> Prefix a

Monoid (Option a)

Defined in Ideas.Common.Strategy.Traversal

Methods

mempty :: Option a

mappend :: Option a -> Option a -> Option a

mconcat :: [Option a] -> Option a

Monoid b => Monoid (a -> b)

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: a -> b

mappend :: (a -> b) -> (a -> b) -> a -> b

mconcat :: [a -> b] -> a -> b

(Monoid a, Monoid b) => Monoid (a, b)

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: (a, b)

mappend :: (a, b) -> (a, b) -> (a, b)

mconcat :: [(a, b)] -> (a, b)

Monoid (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

mempty :: Proxy s

mappend :: Proxy s -> Proxy s -> Proxy s

mconcat :: [Proxy s] -> Proxy s

Ord k => Monoid (Map k v)

Defined in Data.Map.Internal

Methods

mempty :: Map k v

mappend :: Map k v -> Map k v -> Map k v

mconcat :: [Map k v] -> Map k v

Monoid (Trans a b)

Defined in Ideas.Common.Rule.Transformation

Methods

mempty :: Trans a b

mappend :: Trans a b -> Trans a b -> Trans a b

mconcat :: [Trans a b] -> Trans a b

(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)

Since: base-2.1

Defined in GHC.Base

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 a b)

Defined in Data.Functor.Const

Methods

mempty :: Const a b

mappend :: Const a b -> Const a b -> Const a b

mconcat :: [Const a b] -> Const a b

Alternative f => Monoid (Alt f a)

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

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 (Constant a b)

Defined in Data.Functor.Constant

Methods

mempty :: Constant a b

mappend :: Constant a b -> Constant a b -> Constant a b

mconcat :: [Constant a b] -> Constant a b

(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)

Since: base-2.1

Defined in GHC.Base

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)

The Monoid instance for ParsecT is used for the same purposes as the Semigroup instance.

Since: parsec-3.1.12

Defined in Text.Parsec.Prim

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: base-2.1

Defined in GHC.Base

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)

(<>) :: Semigroup a => a -> a -> a infixr 6

An associative operation.

Groups

class Monoid a => Group a where

Minimal complete definition: inverse or appendInverse

Methods

inverse :: a -> a

appendInv :: a -> a -> a

Instances

Field a => Group (Multiplicative a)

Defined in Domain.Algebra.Field

Methods

inverse :: Multiplicative a -> Multiplicative a

appendInv :: Multiplicative a -> Multiplicative a -> Multiplicative a

Ring a => Group (Additive a)

Defined in Domain.Algebra.Field

Methods

inverse :: Additive a -> Additive a

appendInv :: Additive a -> Additive a -> Additive a

(CoGroup a, Group a) => Group (SmartGroup a)

Defined in Domain.Algebra.SmartGroup

Methods

inverse :: SmartGroup a -> SmartGroup a

appendInv :: SmartGroup a -> SmartGroup a -> SmartGroup a

(<>-) :: Group a => a -> a -> a infixl 6

Monoids with a zero element

class Monoid a => MonoidZero a where

Minimal complete definition

mzero

Methods

mzero :: a

Instances

Monoid a => MonoidZero (WithZero a)

Defined in Domain.Algebra.Group

Methods

mzero :: WithZero a

SemiRing a => MonoidZero (Multiplicative a)

Defined in Domain.Algebra.Field

Methods

mzero :: Multiplicative a

Boolean a => MonoidZero (Or a)

Defined in Domain.Algebra.Boolean

Methods

mzero :: Or a

Boolean a => MonoidZero (And a)

Defined in Domain.Algebra.Boolean

Methods

mzero :: And a

(MonoidZero a, CoGroup a, Group a) => MonoidZero (SmartGroup a)

Defined in Domain.Algebra.SmartGroup

Methods

mzero :: SmartGroup a

(MonoidZero a, CoMonoidZero a) => MonoidZero (SmartZero a)

Defined in Domain.Algebra.SmartGroup

Methods

mzero :: SmartZero a

(MonoidZero a, CoMonoid a) => MonoidZero (Smart a)

Defined in Domain.Algebra.SmartGroup

Methods

mzero :: Smart a

Ord a => MonoidZero (OrSet a)

Defined in Domain.Math.Data.OrList

Methods

mzero :: OrSet a

MonoidZero (OrList a)

Defined in Domain.Math.Data.OrList

Methods

mzero :: OrList a

data WithZero a

Instances

Functor WithZero

Defined in Domain.Algebra.Group

Methods

fmap :: (a -> b) -> WithZero a -> WithZero b

(<$) :: a -> WithZero b -> WithZero a

Applicative WithZero

Defined in Domain.Algebra.Group

Methods

pure :: a -> WithZero a

(<*>) :: WithZero (a -> b) -> WithZero a -> WithZero b

liftA2 :: (a -> b -> c) -> WithZero a -> WithZero b -> WithZero c

(*>) :: WithZero a -> WithZero b -> WithZero b

(<*) :: WithZero a -> WithZero b -> WithZero a

Foldable WithZero

Defined in Domain.Algebra.Group

Methods

fold :: Monoid m => WithZero m -> m

foldMap :: Monoid m => (a -> m) -> WithZero a -> m

foldr :: (a -> b -> b) -> b -> WithZero a -> b

foldr' :: (a -> b -> b) -> b -> WithZero a -> b

foldl :: (b -> a -> b) -> b -> WithZero a -> b

foldl' :: (b -> a -> b) -> b -> WithZero a -> b

foldr1 :: (a -> a -> a) -> WithZero a -> a

foldl1 :: (a -> a -> a) -> WithZero a -> a

toList :: WithZero a -> [a]

null :: WithZero a -> Bool

length :: WithZero a -> Int

elem :: Eq a => a -> WithZero a -> Bool

maximum :: Ord a => WithZero a -> a

minimum :: Ord a => WithZero a -> a

sum :: Num a => WithZero a -> a

product :: Num a => WithZero a -> a

Traversable WithZero

Defined in Domain.Algebra.Group

Methods

traverse :: Applicative f => (a -> f b) -> WithZero a -> f (WithZero b)

sequenceA :: Applicative f => WithZero (f a) -> f (WithZero a)

mapM :: Monad m => (a -> m b) -> WithZero a -> m (WithZero b)

sequence :: Monad m => WithZero (m a) -> m (WithZero a)

Eq a => Eq (WithZero a)

Defined in Domain.Algebra.Group

Methods

(==) :: WithZero a -> WithZero a -> Bool

(/=) :: WithZero a -> WithZero a -> Bool

Ord a => Ord (WithZero a)

Defined in Domain.Algebra.Group

Methods

compare :: WithZero a -> WithZero a -> Ordering

(<) :: WithZero a -> WithZero a -> Bool

(<=) :: WithZero a -> WithZero a -> Bool

(>) :: WithZero a -> WithZero a -> Bool

(>=) :: WithZero a -> WithZero a -> Bool

max :: WithZero a -> WithZero a -> WithZero a

min :: WithZero a -> WithZero a -> WithZero a

Semigroup a => Semigroup (WithZero a)

Defined in Domain.Algebra.Group

Methods

(<>) :: WithZero a -> WithZero a -> WithZero a

sconcat :: NonEmpty (WithZero a) -> WithZero a

stimes :: Integral b => b -> WithZero a -> WithZero a

Monoid a => Monoid (WithZero a)

Defined in Domain.Algebra.Group

Methods

mempty :: WithZero a

mappend :: WithZero a -> WithZero a -> WithZero a

mconcat :: [WithZero a] -> WithZero a

CoMonoid a => CoMonoidZero (WithZero a)

Defined in Domain.Algebra.Group

Methods

isMonoidZero :: WithZero a -> Bool

CoMonoid a => CoMonoid (WithZero a)

Defined in Domain.Algebra.Group

Methods

isEmpty :: WithZero a -> Bool

isAppend :: WithZero a -> Maybe (WithZero a, WithZero a)

Monoid a => MonoidZero (WithZero a)

Defined in Domain.Algebra.Group

Methods

mzero :: WithZero a

fromWithZero :: WithZero a -> Maybe a

CoMonoid, CoGroup, and CoMonoidZero (for matching)

class CoMonoid a where

Minimal complete definition

isEmpty, isAppend

Methods

isEmpty :: a -> Bool

isAppend :: a -> Maybe (a, a)

Instances

CoMonoid [a]

Defined in Domain.Algebra.Group

Methods

isEmpty :: [a] -> Bool

isAppend :: [a] -> Maybe ([a], [a])

CoMonoid (Set a)

Defined in Domain.Algebra.Group

Methods

isEmpty :: Set a -> Bool

isAppend :: Set a -> Maybe (Set a, Set a)

CoMonoid a => CoMonoid (WithZero a)

Defined in Domain.Algebra.Group

Methods

isEmpty :: WithZero a -> Bool

isAppend :: WithZero a -> Maybe (WithZero a, WithZero a)

CoSemiRing a => CoMonoid (Multiplicative a)

Defined in Domain.Algebra.Field

Methods

isEmpty :: Multiplicative a -> Bool

isAppend :: Multiplicative a -> Maybe (Multiplicative a, Multiplicative a)

CoSemiRing a => CoMonoid (Additive a)

Defined in Domain.Algebra.Field

Methods

isEmpty :: Additive a -> Bool

isAppend :: Additive a -> Maybe (Additive a, Additive a)

CoBoolean a => CoMonoid (Or a)

Defined in Domain.Algebra.Boolean

Methods

isEmpty :: Or a -> Bool

isAppend :: Or a -> Maybe (Or a, Or a)

CoBoolean a => CoMonoid (And a)

Defined in Domain.Algebra.Boolean

Methods

isEmpty :: And a -> Bool

isAppend :: And a -> Maybe (And a, And a)

CoMonoid a => CoMonoid (SmartGroup a)

Defined in Domain.Algebra.SmartGroup

Methods

isEmpty :: SmartGroup a -> Bool

isAppend :: SmartGroup a -> Maybe (SmartGroup a, SmartGroup a)

CoMonoid a => CoMonoid (SmartZero a)

Defined in Domain.Algebra.SmartGroup

Methods

isEmpty :: SmartZero a -> Bool

isAppend :: SmartZero a -> Maybe (SmartZero a, SmartZero a)

CoMonoid a => CoMonoid (Smart a)

Defined in Domain.Algebra.SmartGroup

Methods

isEmpty :: Smart a -> Bool

isAppend :: Smart a -> Maybe (Smart a, Smart a)

CoMonoid (OrSet a)

Defined in Domain.Math.Data.OrList

Methods

isEmpty :: OrSet a -> Bool

isAppend :: OrSet a -> Maybe (OrSet a, OrSet a)

CoMonoid (OrList a)

Defined in Domain.Math.Data.OrList

Methods

isEmpty :: OrList a -> Bool

isAppend :: OrList a -> Maybe (OrList a, OrList a)

class CoMonoid a => CoGroup a where

Minimal complete definition

isInverse

Methods

isInverse :: a -> Maybe a

isAppendInv :: a -> Maybe (a, a)

Instances

CoField a => CoGroup (Multiplicative a)

Defined in Domain.Algebra.Field

Methods

isInverse :: Multiplicative a -> Maybe (Multiplicative a)

isAppendInv :: Multiplicative a -> Maybe (Multiplicative a, Multiplicative a)

CoRing a => CoGroup (Additive a)

Defined in Domain.Algebra.Field

Methods

isInverse :: Additive a -> Maybe (Additive a)

isAppendInv :: Additive a -> Maybe (Additive a, Additive a)

CoGroup a => CoGroup (SmartGroup a)

Defined in Domain.Algebra.SmartGroup

Methods

isInverse :: SmartGroup a -> Maybe (SmartGroup a)

isAppendInv :: SmartGroup a -> Maybe (SmartGroup a, SmartGroup a)

class CoMonoid a => CoMonoidZero a where

Minimal complete definition

isMonoidZero

Methods

isMonoidZero :: a -> Bool

Instances

CoMonoid a => CoMonoidZero (WithZero a)

Defined in Domain.Algebra.Group

Methods

isMonoidZero :: WithZero a -> Bool

CoSemiRing a => CoMonoidZero (Multiplicative a)

Defined in Domain.Algebra.Field

Methods

isMonoidZero :: Multiplicative a -> Bool

CoBoolean a => CoMonoidZero (Or a)

Defined in Domain.Algebra.Boolean

Methods

isMonoidZero :: Or a -> Bool

CoBoolean a => CoMonoidZero (And a)

Defined in Domain.Algebra.Boolean

Methods

isMonoidZero :: And a -> Bool

CoMonoidZero a => CoMonoidZero (SmartGroup a)

Defined in Domain.Algebra.SmartGroup

Methods

isMonoidZero :: SmartGroup a -> Bool

CoMonoidZero a => CoMonoidZero (SmartZero a)

Defined in Domain.Algebra.SmartGroup

Methods

isMonoidZero :: SmartZero a -> Bool

CoMonoidZero a => CoMonoidZero (Smart a)

Defined in Domain.Algebra.SmartGroup

Methods

isMonoidZero :: Smart a -> Bool

CoMonoidZero (OrSet a)

Defined in Domain.Math.Data.OrList

Methods

isMonoidZero :: OrSet a -> Bool

CoMonoidZero (OrList a)

Defined in Domain.Math.Data.OrList

Methods

isMonoidZero :: OrList a -> Bool

associativeList :: CoMonoid a => a -> [a]