monoid-extras-0.4.2: Various extra monoid-related definitions and utilities

Copyright(c) 2011-2015 diagrams-core team (see LICENSE)
LicenseBSD-style (see LICENSE)
Maintainerdiagrams-discuss@googlegroups.com
Safe HaskellSafe
LanguageHaskell2010

Data.Monoid.Split

Description

Sometimes we want to accumulate values from some monoid, but have the ability to introduce a "split" which separates values on either side. Only the rightmost split is kept. For example,

a b c | d e | f g h == a b c d e | f g h

In the diagrams graphics framework this is used when accumulating transformations to be applied to primitive diagrams: the freeze operation introduces a split, since only transformations occurring outside the freeze should be applied to attributes.

Synopsis

Documentation

data Split m #

A value of type Split m is either a single m, or a pair of m's separated by a divider. Single m's combine as usual; single m's combine with split values by combining with the value on the appropriate side; when two split values meet only the rightmost split is kept, with both the values from the left split combining with the left-hand value of the right split.

Data.Monoid.Cut is similar, but uses a different scheme for composition. Split uses the asymmetric constructor :|, and Cut the symmetric constructor :||:, to emphasize the inherent asymmetry of Split and symmetry of Cut. Split keeps only the rightmost split and combines everything on the left; Cut keeps the outermost splits and throws away everything in between.

Constructors

M m 
m :| m infix 5 

Instances

Functor Split # 

Methods

fmap :: (a -> b) -> Split a -> Split b #

(<$) :: a -> Split b -> Split a #

Foldable Split # 

Methods

fold :: Monoid m => Split m -> m #

foldMap :: Monoid m => (a -> m) -> Split a -> m #

foldr :: (a -> b -> b) -> b -> Split a -> b #

foldr' :: (a -> b -> b) -> b -> Split a -> b #

foldl :: (b -> a -> b) -> b -> Split a -> b #

foldl' :: (b -> a -> b) -> b -> Split a -> b #

foldr1 :: (a -> a -> a) -> Split a -> a #

foldl1 :: (a -> a -> a) -> Split a -> a #

toList :: Split a -> [a] #

null :: Split a -> Bool #

length :: Split a -> Int #

elem :: Eq a => a -> Split a -> Bool #

maximum :: Ord a => Split a -> a #

minimum :: Ord a => Split a -> a #

sum :: Num a => Split a -> a #

product :: Num a => Split a -> a #

Traversable Split # 

Methods

traverse :: Applicative f => (a -> f b) -> Split a -> f (Split b) #

sequenceA :: Applicative f => Split (f a) -> f (Split a) #

mapM :: Monad m => (a -> m b) -> Split a -> m (Split b) #

sequence :: Monad m => Split (m a) -> m (Split a) #

Eq m => Eq (Split m) # 

Methods

(==) :: Split m -> Split m -> Bool #

(/=) :: Split m -> Split m -> Bool #

Data m => Data (Split m) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Split m -> c (Split m) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Split m) #

toConstr :: Split m -> Constr #

dataTypeOf :: Split m -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Split m)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Split m)) #

gmapT :: (forall b. Data b => b -> b) -> Split m -> Split m #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Split m -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Split m -> r #

gmapQ :: (forall d. Data d => d -> u) -> Split m -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Split m -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Split m -> m (Split m) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Split m -> m (Split m) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Split m -> m (Split m) #

Read m => Read (Split m) # 
Show m => Show (Split m) # 

Methods

showsPrec :: Int -> Split m -> ShowS #

show :: Split m -> String #

showList :: [Split m] -> ShowS #

Semigroup m => Semigroup (Split m) #

If m is a Semigroup, then Split m is a semigroup which combines values on either side of a split, keeping only the rightmost split.

Methods

(<>) :: Split m -> Split m -> Split m #

sconcat :: NonEmpty (Split m) -> Split m #

stimes :: Integral b => b -> Split m -> Split m #

(Semigroup m, Monoid m) => Monoid (Split m) # 

Methods

mempty :: Split m #

mappend :: Split m -> Split m -> Split m #

mconcat :: [Split m] -> Split m #

Action m n => Action (Split m) n #

By default, the action of a split monoid is the same as for the underlying monoid, as if the split were removed.

Methods

act :: Split m -> n -> n #

split :: Monoid m => Split m #

A convenient name for mempty :| mempty, so M a <> split <> M b == a :| b.

unsplit :: Semigroup m => Split m -> m #

"Unsplit" a split monoid value, combining the two values into one (or returning the single value if there is no split).