Data.Group

A Group is a Monoid for which the monoid operation can be undone.

That is, \( G \) is a group if each \( g \in G \) has an inverse element \( g^{ -1 } \) such that

\[ g^{ -1 } < \! > g = \text{mempty} = g < \! > g^{ -1 } \]

Such inverses are necessarily unique.

In Haskell, groups are mostly useful to describe objects possessing certain symmetries (such as translation or rotation).

To automatically derive Group instances, you can:

• Use DerivingVia to coerce an existing instance:

> newtype Seconds   = Seconds { getSeconds :: Double }
> newtype TimeDelta = TimeDelta { timeDeltaInSeconds :: Seconds }
>   deriving ( Semigroup, Monoid, Group )
>     via Sum Double

• Use Generic and Generically:

> data MyRecord
>   = MyRecord
>   { field1 :: Sum Double
>   , field2 :: Product Double
>   , field3 :: Ap [] ( Sum Int, Sum Int )
>   }
>   deriving Generic
>   deriving ( Semigroup, Monoid, Group )
>     via Generically MyRecord

Documentation

class Monoid g => Group g where

A Group is a Monoid with inverses:

•  inverse g <> g = g <> inverse g = mempty

•  inverse (g <> h) = inverse h <> inverse g

Minimal complete definition

inverse | gtimes

Methods

inverse :: g -> g

Group inversion anti-homomorphism.

gtimes :: Integral n => n -> g -> g

Take the n-th power of an element.

Instances

Group ()

Trivial group.

Defined in Data.Group

Methods

inverse :: () -> ()

gtimes :: Integral n => n -> () -> ()

Group a => Group (IO a)

Defined in Data.Group

Methods

inverse :: IO a -> IO a

gtimes :: Integral n => n -> IO a -> IO a

Group g => Group (Par1 g)

Defined in Data.Group

Methods

inverse :: Par1 g -> Par1 g

gtimes :: Integral n => n -> Par1 g -> Par1 g

Group a => Group (Identity a)

Defined in Data.Group

Methods

inverse :: Identity a -> Identity a

gtimes :: Integral n => n -> Identity a -> Identity a

Group a => Group (Dual a)

Opposite group.

Defined in Data.Group

Methods

inverse :: Dual a -> Dual a

gtimes :: Integral n => n -> Dual a -> Dual a

Num a => Group (Sum a)

Additive groups (via Num).

Defined in Data.Group

Methods

inverse :: Sum a -> Sum a

gtimes :: Integral n => n -> Sum a -> Sum a

Fractional a => Group (Product a)

Multiplicative group (via Num).

Defined in Data.Group

Methods

inverse :: Product a -> Product a

gtimes :: Integral n => n -> Product a -> Product a

Group a => Group (Down a)

Defined in Data.Group

Methods

inverse :: Down a -> Down a

gtimes :: Integral n => n -> Down a -> Down a

(Generic g, Monoid (Rep g ()), GGroup (Rep g)) => Group (Generically g)

Defined in Data.Group

Methods

inverse :: Generically g -> Generically g

gtimes :: Integral n => n -> Generically g -> Generically g

Monoid a => Group (Isom a)

Defined in Data.Group

Methods

inverse :: Isom a -> Isom a

gtimes :: Integral n => n -> Isom a -> Isom a

Group a => Group (r -> a)

Defined in Data.Group

Methods

inverse :: (r -> a) -> r -> a

gtimes :: Integral n => n -> (r -> a) -> r -> a

Group (U1 p)

Defined in Data.Group

Methods

inverse :: U1 p -> U1 p

gtimes :: Integral n => n -> U1 p -> U1 p

(Group g1, Group g2) => Group (g1, g2)

Defined in Data.Group

Methods

inverse :: (g1, g2) -> (g1, g2)

gtimes :: Integral n => n -> (g1, g2) -> (g1, g2)

Group a => Group (Op a b)

Defined in Data.Group

Methods

inverse :: Op a b -> Op a b

gtimes :: Integral n => n -> Op a b -> Op a b

Group a => Group (ST s a)

Defined in Data.Group

Methods

inverse :: ST s a -> ST s a

gtimes :: Integral n => n -> ST s a -> ST s a

Group (Proxy p)

Defined in Data.Group

Methods

inverse :: Proxy p -> Proxy p

gtimes :: Integral n => n -> Proxy p -> Proxy p

Group (f p) => Group (Rec1 f p)

Defined in Data.Group

Methods

inverse :: Rec1 f p -> Rec1 f p

gtimes :: Integral n => n -> Rec1 f p -> Rec1 f p

(Group g1, Group g2, Group g3) => Group (g1, g2, g3)

Defined in Data.Group

Methods

inverse :: (g1, g2, g3) -> (g1, g2, g3)

gtimes :: Integral n => n -> (g1, g2, g3) -> (g1, g2, g3)

Group a => Group (Const a b)

Defined in Data.Group

Methods

inverse :: Const a b -> Const a b

gtimes :: Integral n => n -> Const a b -> Const a b

(Group a, Applicative f) => Group (Ap f a)

Lifting group operations through an applicative functor.

Defined in Data.Group

Methods

inverse :: Ap f a -> Ap f a

gtimes :: Integral n => n -> Ap f a -> Ap f a

Group g => Group (K1 i g p)

Defined in Data.Group

Methods

inverse :: K1 i g p -> K1 i g p

gtimes :: Integral n => n -> K1 i g p -> K1 i g p

(Group (f1 p), Group (f2 p)) => Group ((f1 :*: f2) p)

Defined in Data.Group

Methods

inverse :: (f1 :*: f2) p -> (f1 :*: f2) p

gtimes :: Integral n => n -> (f1 :*: f2) p -> (f1 :*: f2) p

(Group g1, Group g2, Group g3, Group g4) => Group (g1, g2, g3, g4)

Defined in Data.Group

Methods

inverse :: (g1, g2, g3, g4) -> (g1, g2, g3, g4)

gtimes :: Integral n => n -> (g1, g2, g3, g4) -> (g1, g2, g3, g4)

Group (f p) => Group (M1 i c f p)

Defined in Data.Group

Methods

inverse :: M1 i c f p -> M1 i c f p

gtimes :: Integral n => n -> M1 i c f p -> M1 i c f p

(Group g1, Group g2, Group g3, Group g4, Group g5) => Group (g1, g2, g3, g4, g5)

Defined in Data.Group

Methods

inverse :: (g1, g2, g3, g4, g5) -> (g1, g2, g3, g4, g5)

gtimes :: Integral n => n -> (g1, g2, g3, g4, g5) -> (g1, g2, g3, g4, g5)

anti :: Group g => g -> Dual g

The inverse anti-automorphism of a group lifts to a isomorphism with the opposite group.

reflexive :: Dual (Dual a) -> a

Reflexive property Dual (should be included in base, maybe under another name).

data Isom a

Data type to keep track of a pair of inverse elements.

Constructors

(:|:) infix 7

Fields

• to :: a
• from :: Dual a

Instances

Data a => Data (Isom a)

Defined in Data.Group

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Isom a -> c (Isom a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Isom a)

toConstr :: Isom a -> Constr

dataTypeOf :: Isom a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Isom a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Isom a))

gmapT :: (forall b. Data b => b -> b) -> Isom a -> Isom a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Isom a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Isom a -> r

gmapQ :: (forall d. Data d => d -> u) -> Isom a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Isom a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Isom a -> m (Isom a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Isom a -> m (Isom a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Isom a -> m (Isom a)

Read a => Read (Isom a)

Defined in Data.Group

Methods

readsPrec :: Int -> ReadS (Isom a)

readList :: ReadS [Isom a]

readPrec :: ReadPrec (Isom a)

readListPrec :: ReadPrec [Isom a]

Show a => Show (Isom a)

Defined in Data.Group

Methods

showsPrec :: Int -> Isom a -> ShowS

show :: Isom a -> String

showList :: [Isom a] -> ShowS

Generic (Isom a)

Defined in Data.Group

Associated Types

type Rep (Isom a) :: Type -> Type

Methods

from :: Isom a -> Rep (Isom a) x

to :: Rep (Isom a) x -> Isom a

Semigroup a => Semigroup (Isom a)

Defined in Data.Group

Methods

(<>) :: Isom a -> Isom a -> Isom a

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

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

Monoid a => Monoid (Isom a)

Defined in Data.Group

Methods

mempty :: Isom a

mappend :: Isom a -> Isom a -> Isom a

mconcat :: [Isom a] -> Isom a

NFData a => NFData (Isom a)

Defined in Data.Group

Methods

rnf :: Isom a -> ()

Monoid a => Group (Isom a)

Defined in Data.Group

Methods

inverse :: Isom a -> Isom a

gtimes :: Integral n => n -> Isom a -> Isom a

Generic1 Isom

Defined in Data.Group

Associated Types

type Rep1 Isom :: k -> Type

Methods

from1 :: Isom a -> Rep1 Isom a

to1 :: Rep1 Isom a -> Isom a

type Rep (Isom a)

Defined in Data.Group

type Rep (Isom a) = D1 (MetaData "Isom" "Data.Group" "acts-0.2.0.0-IZeK4JTej10COOINsXz0BM" False) (C1 (MetaCons ":|:" PrefixI True) (S1 (MetaSel (Just "to") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "from") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Dual a))))

type Rep1 Isom

Defined in Data.Group

type Rep1 Isom = D1 (MetaData "Isom" "Data.Group" "acts-0.2.0.0-IZeK4JTej10COOINsXz0BM" False) (C1 (MetaCons ":|:" PrefixI True) (S1 (MetaSel (Just "to") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "from") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Dual)))