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.Deletable

Description

A monoid transformer that allows deleting information from a concatenation of monoidal values.

Synopsis

Documentation

data Deletable m #

If m is a Monoid, then Deletable m (intuitively speaking) adds two distinguished new elements [ and ], such that an occurrence of [ "deletes" everything from it to the next ]. For example,

abc[def]gh == abcgh

This is all you really need to know to use Deletable m values; to understand the actual implementation, read on.

To properly deal with nesting and associativity we need to be able to assign meanings to things like [[, ][, and so on. (We cannot just define, say, [[ == [, since then ([[)] == [] == id but [([]) == [id == [.) Formally, elements of Deletable m are triples of the form (r, m, l) representing words ]^r m [^l. When combining two triples (r1, m1, l1) and (r2, m2, l2) there are three cases:

  • If l1 == r2 then the [s from the left and ]s from the right exactly cancel, and we are left with (r1, m1 <> m2, l2).
  • If l1 < r2 then all of the [s cancel with some of the ]s, but m1 is still inside the remaining ]s and is deleted, yielding (r1 + r2 - l1, m2, l2)
  • The remaining case is symmetric with the second.

Constructors

Deletable Int m Int 

Instances

Functor Deletable # 

Methods

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

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

Foldable Deletable # 

Methods

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

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

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

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

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

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

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

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

toList :: Deletable a -> [a] #

null :: Deletable a -> Bool #

length :: Deletable a -> Int #

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

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

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

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

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

Traversable Deletable # 

Methods

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

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

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

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

Data m => Data (Deletable m) # 

Methods

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

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

toConstr :: Deletable m -> Constr #

dataTypeOf :: Deletable m -> DataType #

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

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

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

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

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

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

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

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

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

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

Read m => Read (Deletable m) # 
Show m => Show (Deletable m) # 
Semigroup m => Semigroup (Deletable m) # 

Methods

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

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

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

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

unDelete :: Deletable m -> m #

Project the wrapped value out of a Deletable value.

toDeletable :: m -> Deletable m #

Inject a value into a Deletable wrapper. Satisfies the property

unDelete . toDeletable === id

deleteL :: Monoid m => Deletable m #

A "left bracket", which causes everything between it and the next right bracket to be deleted.

deleteR :: Monoid m => Deletable m #

A "right bracket", denoting the end of the section that should be deleted.