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

Data.Monoid.Deletable

Description

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

Synopsis

# Documentation

data Deletable m Source #

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

 Source # Methodsfmap :: (a -> b) -> Deletable a -> Deletable b #(<\$) :: a -> Deletable b -> Deletable a # Source # Methodsfold :: 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 # Source # Methodstraverse :: 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) Source # Methodsgfoldl :: (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 #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) Source # MethodsreadsPrec :: Int -> ReadS (Deletable m) # Show m => Show (Deletable m) Source # MethodsshowsPrec :: Int -> Deletable m -> ShowS #show :: Deletable m -> String #showList :: [Deletable m] -> ShowS # Semigroup m => Semigroup (Deletable m) Source # 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) Source # Methodsmappend :: Deletable m -> Deletable m -> Deletable m #mconcat :: [Deletable m] -> Deletable m #

unDelete :: Deletable m -> m Source #

Project the wrapped value out of a Deletable value.

toDeletable :: m -> Deletable m Source #

Inject a value into a Deletable wrapper. Satisfies the property

unDelete . toDeletable === id

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

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