Data.Monoid.MSet

Monoid and group actions (M-Sets and G-Sets). The category of MSets (and GSets) is monadic (unlike the category of SSets).

Documentation

class (Monoid m, SSet m a) => MSet m a where

Lawful instance should satisfy:

act mempty = id

g `act` h `act` a = g <> h `act` a

This is the same as to say that act is a monoid homomorphism from m to the monoid of endomorphisms of a (i.e. maps from a to a).

Note that if g is a Group then an MSet is simply a GSet, this is because monoids and groups share the same morphisms (a monoid homomorphis between groups necessarily preserves inverses).

Minimal complete definition

Nothing

Methods

mact :: m -> a -> a

Instances

Monoid m => MSet m m

Defined in Data.Monoid.MSet

Methods

mact :: m -> m -> m

MSet m a => MSet m (IO a)

Defined in Data.Monoid.MSet

Methods

mact :: m -> IO a -> IO a

MSet m a => MSet m (Down a)

Defined in Data.Monoid.MSet

Methods

mact :: m -> Down a -> Down a

MSet m a => MSet m (Maybe a)

Defined in Data.Monoid.MSet

Methods

mact :: m -> Maybe a -> Maybe a

MSet m a => MSet m (Identity a)

Defined in Data.Monoid.MSet

Methods

mact :: m -> Identity a -> Identity a

(MSet m a, Ord a) => MSet m (Set a)

Defined in Data.Monoid.MSet

Methods

mact :: m -> Set a -> Set a

MSet m a => MSet m (NonEmpty a)

Defined in Data.Monoid.MSet

Methods

mact :: m -> NonEmpty a -> NonEmpty a

MSet m a => MSet m [a]

Defined in Data.Monoid.MSet

Methods

mact :: m -> [a] -> [a]

Monoid m => MSet m (FreeMSet m a)

Defined in Data.Monoid.MSet

Methods

mact :: m -> FreeMSet m a -> FreeMSet m a

MSet m b => MSet m (a -> b)

Defined in Data.Monoid.MSet

Methods

mact :: m -> (a -> b) -> a -> b

MSet m b => MSet m (Either a b)

Defined in Data.Monoid.MSet

Methods

mact :: m -> Either a b -> Either a b

(MSet m a, MSet m b) => MSet m (a, b)

Defined in Data.Monoid.MSet

Methods

mact :: m -> (a, b) -> (a, b)

MSet m a => MSet m (Const a b)

Defined in Data.Monoid.MSet

Methods

mact :: m -> Const a b -> Const a b

(MSet m a, MSet m b, MSet m c) => MSet m (a, b, c)

Defined in Data.Monoid.MSet

Methods

mact :: m -> (a, b, c) -> (a, b, c)

(Functor f, Functor h, MSet m a) => MSet m (Sum f h a)

Defined in Data.Monoid.MSet

Methods

mact :: m -> Sum f h a -> Sum f h a

(Functor f, Functor h, MSet m a) => MSet m (Product f h a)

Defined in Data.Monoid.MSet

Methods

mact :: m -> Product f h a -> Product f h a

(MSet m a, MSet m b, MSet m c, MSet m d) => MSet m (a, b, c, d)

Defined in Data.Monoid.MSet

Methods

mact :: m -> (a, b, c, d) -> (a, b, c, d)

(MSet m a, MSet m b, MSet m c, MSet m d, MSet m e) => MSet m (a, b, c, d, e)

Defined in Data.Monoid.MSet

Methods

mact :: m -> (a, b, c, d, e) -> (a, b, c, d, e)

(MSet m a, MSet m b, MSet m c, MSet m d, MSet m e, MSet m f) => MSet m (a, b, c, d, e, f)

Defined in Data.Monoid.MSet

Methods

mact :: m -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)

(MSet m a, MSet m b, MSet m c, MSet m d, MSet m e, MSet m f, MSet m h) => MSet m (a, b, c, d, e, f, h)

Defined in Data.Monoid.MSet

Methods

mact :: m -> (a, b, c, d, e, f, h) -> (a, b, c, d, e, f, h)

(MSet m a, MSet m b, MSet m c, MSet m d, MSet m e, MSet m f, MSet m h, MSet m i) => MSet m (a, b, c, d, e, f, h, i)

Defined in Data.Monoid.MSet

Methods

mact :: m -> (a, b, c, d, e, f, h, i) -> (a, b, c, d, e, f, h, i)

MSet m a => MSet (Identity m) a

Defined in Data.Monoid.MSet

Methods

mact :: Identity m -> a -> a

MSet (Endo a) a

Defined in Data.Monoid.MSet

Methods

mact :: Endo a -> a -> a

Num s => MSet (Sum s) s

Defined in Data.Monoid.MSet

Methods

mact :: Sum s -> s -> s

Monoid m => MSet (Sum Natural) m

Defined in Data.Monoid.MSet

Methods

mact :: Sum Natural -> m -> m

Num s => MSet (Product s) s

Defined in Data.Monoid.MSet

Methods

mact :: Product s -> s -> s

MSet m b => MSet (S m) (Endo b)

Defined in Data.Monoid.MSet

Methods

mact :: S m -> Endo b -> Endo b

class Semigroup s => SSet s a where

A lawful instance should satisfy:

g `act` h `act` a = g <> h `act` a

This is the same as to say that act is a semigroup homomorphism from s to the monoid of endomorphisms of a (i.e. maps from a to a).

Note that if g is a Group then MAct g is simply a GSet, this is because monoids and groups share the same morphisms (a monoid homomorphis between groups necessarily preserves inverses).

Methods

act :: s -> a -> a

Instances

Semigroup s => SSet s s

Defined in Data.Semigroup.SSet

Methods

act :: s -> s -> s

SSet s a => SSet s (IO a)

Defined in Data.Semigroup.SSet

Methods

act :: s -> IO a -> IO a

SSet s a => SSet s (Down a)

Defined in Data.Semigroup.SSet

Methods

act :: s -> Down a -> Down a

SSet s a => SSet s (Maybe a)

Defined in Data.Semigroup.SSet

Methods

act :: s -> Maybe a -> Maybe a

SSet s a => SSet s (Identity a)

Defined in Data.Semigroup.SSet

Methods

act :: s -> Identity a -> Identity a

(SSet s a, Ord a) => SSet s (Set a)

Defined in Data.Semigroup.SSet

Methods

act :: s -> Set a -> Set a

SSet s a => SSet s (NonEmpty a)

Defined in Data.Semigroup.SSet

Methods

act :: s -> NonEmpty a -> NonEmpty a

SSet s a => SSet s [a]

Defined in Data.Semigroup.SSet

Methods

act :: s -> [a] -> [a]

SSet s b => SSet s (a -> b)

Defined in Data.Semigroup.SSet

Methods

act :: s -> (a -> b) -> a -> b

SSet s b => SSet s (Either a b)

Defined in Data.Semigroup.SSet

Methods

act :: s -> Either a b -> Either a b

(SSet s a, SSet s b) => SSet s (a, b)

Defined in Data.Semigroup.SSet

Methods

act :: s -> (a, b) -> (a, b)

Semigroup m => SSet m (FreeMSet m a)

Defined in Data.Monoid.MSet

Methods

act :: m -> FreeMSet m a -> FreeMSet m a

SSet s a => SSet s (Const a b)

Defined in Data.Semigroup.SSet

Methods

act :: s -> Const a b -> Const a b

(SSet s a, SSet s b, SSet s c) => SSet s (a, b, c)

Defined in Data.Semigroup.SSet

Methods

act :: s -> (a, b, c) -> (a, b, c)

(Functor f, Functor h, SSet s a) => SSet s (Sum f h a)

Defined in Data.Semigroup.SSet

Methods

act :: s -> Sum f h a -> Sum f h a

(Functor f, Functor h, SSet s a) => SSet s (Product f h a)

Defined in Data.Semigroup.SSet

Methods

act :: s -> Product f h a -> Product f h a

(SSet s a, SSet s b, SSet s c, SSet s d) => SSet s (a, b, c, d)

Defined in Data.Semigroup.SSet

Methods

act :: s -> (a, b, c, d) -> (a, b, c, d)

(SSet s a, SSet s b, SSet s c, SSet s d, SSet s e) => SSet s (a, b, c, d, e)

Defined in Data.Semigroup.SSet

Methods

act :: s -> (a, b, c, d, e) -> (a, b, c, d, e)

(SSet s a, SSet s b, SSet s c, SSet s d, SSet s e, SSet s f) => SSet s (a, b, c, d, e, f)

Defined in Data.Semigroup.SSet

Methods

act :: s -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)

(SSet s a, SSet s b, SSet s c, SSet s d, SSet s e, SSet s f, SSet s h) => SSet s (a, b, c, d, e, f, h)

Defined in Data.Semigroup.SSet

Methods

act :: s -> (a, b, c, d, e, f, h) -> (a, b, c, d, e, f, h)

(SSet s a, SSet s b, SSet s c, SSet s d, SSet s e, SSet s f, SSet s h, SSet s i) => SSet s (a, b, c, d, e, f, h, i)

Defined in Data.Semigroup.SSet

Methods

act :: s -> (a, b, c, d, e, f, h, i) -> (a, b, c, d, e, f, h, i)

SSet s a => SSet (Identity s) a

Defined in Data.Semigroup.SSet

Methods

act :: Identity s -> a -> a

SSet (Endo a) a

Defined in Data.Semigroup.SSet

Methods

act :: Endo a -> a -> a

Group g => SSet (Sum Integer) g

Defined in Data.Semigroup.SSet

Methods

act :: Sum Integer -> g -> g

Num s => SSet (Sum s) s

Defined in Data.Semigroup.SSet

Methods

act :: Sum s -> s -> s

Monoid s => SSet (Sum Natural) s

Defined in Data.Semigroup.SSet

Methods

act :: Sum Natural -> s -> s

Num s => SSet (Product s) s

Defined in Data.Semigroup.SSet

Methods

act :: Product s -> s -> s

SSet s a => SSet (S s) (Endo a)

Defined in Data.Semigroup.SSet

Methods

act :: S s -> Endo a -> Endo a

newtype Endo a

The monoid of endomorphisms under composition.

>>> let computation = Endo ("Hello, " ++) <> Endo (++ "!")
>>> appEndo computation "Haskell"
"Hello, Haskell!"

Constructors

Endo

Fields

• appEndo :: a -> a

Instances

Generic (Endo a)

Defined in Data.Semigroup.Internal

Associated Types

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

Methods

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

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

Semigroup (Endo a)

Since: base-4.9.0.0

Defined in Data.Semigroup.Internal

Methods

(<>) :: Endo a -> Endo a -> Endo a

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

stimes :: Integral b => b -> Endo a -> Endo 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

SSet (Endo a) a

Defined in Data.Semigroup.SSet

Methods

act :: Endo a -> a -> a

MSet (Endo a) a

Defined in Data.Monoid.MSet

Methods

mact :: Endo a -> a -> a

SSet s a => SSet (S s) (Endo a)

Defined in Data.Semigroup.SSet

Methods

act :: S s -> Endo a -> Endo a

MSet m b => MSet (S m) (Endo b)

Defined in Data.Monoid.MSet

Methods

mact :: S m -> Endo b -> Endo b

type Rep (Endo a)

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

type Rep (Endo a) = D1 (MetaData "Endo" "Data.Semigroup.Internal" "base" True) (C1 (MetaCons "Endo" PrefixI True) (S1 (MetaSel (Just "appEndo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (a -> a))))

rep :: SSet s a => s -> Endo a

fact :: (Functor f, SSet s a) => s -> f a -> f a

Any SSet wrapped in a functor is a valid SSet.

newtype FreeMSet m a

Constructors

FreeMSet

Fields

• runFreeMSet :: (m, a)

Instances

Semigroup m => SSet m (FreeMSet m a)

Defined in Data.Monoid.MSet

Methods

act :: m -> FreeMSet m a -> FreeMSet m a

Monoid m => MSet m (FreeMSet m a)

Defined in Data.Monoid.MSet

Methods

mact :: m -> FreeMSet m a -> FreeMSet m a

Monoid m => Monad (FreeMSet m)

Defined in Data.Monoid.MSet

Methods

(>>=) :: FreeMSet m a -> (a -> FreeMSet m b) -> FreeMSet m b

(>>) :: FreeMSet m a -> FreeMSet m b -> FreeMSet m b

return :: a -> FreeMSet m a

fail :: String -> FreeMSet m a

Functor (FreeMSet m)

Defined in Data.Monoid.MSet

Methods

fmap :: (a -> b) -> FreeMSet m a -> FreeMSet m b

(<$) :: a -> FreeMSet m b -> FreeMSet m a

Monoid m => Applicative (FreeMSet m)

Defined in Data.Monoid.MSet

Methods

pure :: a -> FreeMSet m a

(<*>) :: FreeMSet m (a -> b) -> FreeMSet m a -> FreeMSet m b

liftA2 :: (a -> b -> c) -> FreeMSet m a -> FreeMSet m b -> FreeMSet m c

(*>) :: FreeMSet m a -> FreeMSet m b -> FreeMSet m b

(<*) :: FreeMSet m a -> FreeMSet m b -> FreeMSet m a

Monoid m => FreeAlgebra (FreeMSet m)

Defined in Data.Monoid.MSet

Methods

returnFree :: a -> FreeMSet m a

foldMapFree :: (AlgebraType (FreeMSet m) d, AlgebraType0 (FreeMSet m) a) => (a -> d) -> FreeMSet m a -> d

codom :: AlgebraType0 (FreeMSet m) a => Proof (AlgebraType (FreeMSet m) (FreeMSet m a)) (FreeMSet m a)

forget :: AlgebraType (FreeMSet m) a => Proof (AlgebraType0 (FreeMSet m) a) (FreeMSet m a)

(Eq m, Eq a) => Eq (FreeMSet m a)

Defined in Data.Monoid.MSet

Methods

(==) :: FreeMSet m a -> FreeMSet m a -> Bool

(/=) :: FreeMSet m a -> FreeMSet m a -> Bool

(Ord m, Ord a) => Ord (FreeMSet m a)

Defined in Data.Monoid.MSet

Methods

compare :: FreeMSet m a -> FreeMSet m a -> Ordering

(<) :: FreeMSet m a -> FreeMSet m a -> Bool

(<=) :: FreeMSet m a -> FreeMSet m a -> Bool

(>) :: FreeMSet m a -> FreeMSet m a -> Bool

(>=) :: FreeMSet m a -> FreeMSet m a -> Bool

max :: FreeMSet m a -> FreeMSet m a -> FreeMSet m a

min :: FreeMSet m a -> FreeMSet m a -> FreeMSet m a

(Show m, Show a) => Show (FreeMSet m a)

Defined in Data.Monoid.MSet

Methods

showsPrec :: Int -> FreeMSet m a -> ShowS

show :: FreeMSet m a -> String

showList :: [FreeMSet m a] -> ShowS

type AlgebraType0 (FreeMSet m :: Type -> Type) (a :: l)

Defined in Data.Monoid.MSet

type AlgebraType0 (FreeMSet m :: Type -> Type) (a :: l) = ()

type AlgebraType (FreeMSet m :: Type -> Type) (a :: Type)

Defined in Data.Monoid.MSet

type AlgebraType (FreeMSet m :: Type -> Type) (a :: Type) = MSet m a

hoistFreeMSet

Arguments

:: (m -> n)

monoid homomorphism

-> FreeMSet m a

-> FreeMSet n a

foldrMSet :: forall m a b. MSet m b => (a -> b -> b) -> b -> (m, a) -> b

foldrFree for FreeMSet

newtype S s

A newtype wrapper to avoid overlapping instances.

Constructors

S

Fields

• runS :: s

Instances

Eq s => Eq (S s)

Defined in Data.Semigroup.SSet

Methods

(==) :: S s -> S s -> Bool

(/=) :: S s -> S s -> Bool

Ord s => Ord (S s)

Defined in Data.Semigroup.SSet

Methods

compare :: S s -> S s -> Ordering

(<) :: S s -> S s -> Bool

(<=) :: S s -> S s -> Bool

(>) :: S s -> S s -> Bool

(>=) :: S s -> S s -> Bool

max :: S s -> S s -> S s

min :: S s -> S s -> S s

Show s => Show (S s)

Defined in Data.Semigroup.SSet

Methods

showsPrec :: Int -> S s -> ShowS

show :: S s -> String

showList :: [S s] -> ShowS

Semigroup m => Semigroup (S m)

Defined in Data.Semigroup.SSet

Methods

(<>) :: S m -> S m -> S m

sconcat :: NonEmpty (S m) -> S m

stimes :: Integral b => b -> S m -> S m

Monoid m => Monoid (S m)

Defined in Data.Semigroup.SSet

Methods

mempty :: S m

mappend :: S m -> S m -> S m

mconcat :: [S m] -> S m

SSet s a => SSet (S s) (Endo a)

Defined in Data.Semigroup.SSet

Methods

act :: S s -> Endo a -> Endo a

MSet m b => MSet (S m) (Endo b)

Defined in Data.Monoid.MSet

Methods

mact :: S m -> Endo b -> Endo b