Safe Haskell	None
Language	Haskell2010

Data.Monoid.Diff.Internal

Synopsis

Documentation

data Diff a Source #

The Difference Monoid.

Constructors

!a :-: !a infixl 6

Instances

Monad Diff Source #
Methods (>>=) :: Diff a -> (a -> Diff b) -> Diff b # (>>) :: Diff a -> Diff b -> Diff b # return :: a -> Diff a # fail :: String -> Diff a #
Functor Diff Source #
Methods fmap :: (a -> b) -> Diff a -> Diff b # (<$) :: a -> Diff b -> Diff a #
MonadFix Diff Source #
Methods mfix :: (a -> Diff a) -> Diff a #
Applicative Diff Source #
Methods pure :: a -> Diff a # (<>) :: Diff (a -> b) -> Diff a -> Diff b # liftA2 :: (a -> b -> c) -> Diff a -> Diff b -> Diff c # (>) :: Diff a -> Diff b -> Diff b # (<*) :: Diff a -> Diff b -> Diff a #
Foldable Diff Source #
Methods fold :: Monoid m => Diff m -> m # foldMap :: Monoid m => (a -> m) -> Diff a -> m # foldr :: (a -> b -> b) -> b -> Diff a -> b # foldr' :: (a -> b -> b) -> b -> Diff a -> b # foldl :: (b -> a -> b) -> b -> Diff a -> b # foldl' :: (b -> a -> b) -> b -> Diff a -> b # foldr1 :: (a -> a -> a) -> Diff a -> a # foldl1 :: (a -> a -> a) -> Diff a -> a # toList :: Diff a -> [a] # null :: Diff a -> Bool # length :: Diff a -> Int # elem :: Eq a => a -> Diff a -> Bool # maximum :: Ord a => Diff a -> a # minimum :: Ord a => Diff a -> a # sum :: Num a => Diff a -> a # product :: Num a => Diff a -> a #
Traversable Diff Source #
Methods traverse :: Applicative f => (a -> f b) -> Diff a -> f (Diff b) # sequenceA :: Applicative f => Diff (f a) -> f (Diff a) # mapM :: Monad m => (a -> m b) -> Diff a -> m (Diff b) # sequence :: Monad m => Diff (m a) -> m (Diff a) #
Distributive Diff Source #
Methods distribute :: Functor f => f (Diff a) -> Diff (f a) # collect :: Functor f => (a -> Diff b) -> f a -> Diff (f b) # distributeM :: Monad m => m (Diff a) -> Diff (m a) # collectM :: Monad m => (a -> Diff b) -> m a -> Diff (m b) #
Representable Diff Source #
Associated Types type Rep (Diff :: * -> ) :: # Methods tabulate :: (Rep Diff -> a) -> Diff a # index :: Diff a -> Rep Diff -> a #
Read1 Diff Source #
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Diff a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Diff a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Diff a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Diff a] #
Show1 Diff Source #
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Diff a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Diff a] -> ShowS #
MonadZip Diff Source #
Methods mzip :: Diff a -> Diff b -> Diff (a, b) # mzipWith :: (a -> b -> c) -> Diff a -> Diff b -> Diff c # munzip :: Diff (a, b) -> (Diff a, Diff b) #
Comonad Diff Source #
Methods extract :: Diff a -> a # duplicate :: Diff a -> Diff (Diff a) # extend :: (Diff a -> b) -> Diff a -> Diff b #
ComonadApply Diff Source #
Methods (<@>) :: Diff (a -> b) -> Diff a -> Diff b # (@>) :: Diff a -> Diff b -> Diff b # (<@) :: Diff a -> Diff b -> Diff a #
Traversable1 Diff Source #
Methods traverse1 :: Apply f => (a -> f b) -> Diff a -> f (Diff b) # sequence1 :: Apply f => Diff (f b) -> f (Diff b) #
Foldable1 Diff Source #
Methods fold1 :: Semigroup m => Diff m -> m # foldMap1 :: Semigroup m => (a -> m) -> Diff a -> m # toNonEmpty :: Diff a -> NonEmpty a #
Apply Diff Source #
Methods (<.>) :: Diff (a -> b) -> Diff a -> Diff b # (.>) :: Diff a -> Diff b -> Diff b # (<.) :: Diff a -> Diff b -> Diff a # liftF2 :: (a -> b -> c) -> Diff a -> Diff b -> Diff c #
Bind Diff Source #
Methods (>>-) :: Diff a -> (a -> Diff b) -> Diff b # join :: Diff (Diff a) -> Diff a #
Extend Diff Source #
Methods duplicated :: Diff a -> Diff (Diff a) # extended :: (Diff a -> b) -> Diff a -> Diff b #
Adjunction Parity Diff Source #
Methods unit :: a -> Diff (Parity a) # counit :: Parity (Diff a) -> a # leftAdjunct :: (Parity a -> b) -> a -> Diff b # rightAdjunct :: (a -> Diff b) -> Parity a -> b #
Bounded a => Bounded (Diff a) Source #
Methods minBound :: Diff a # maxBound :: Diff a #
(Eq a, Semigroup a) => Eq (Diff a) Source #
Methods (==) :: Diff a -> Diff a -> Bool # (/=) :: Diff a -> Diff a -> Bool #
Data a => Data (Diff a) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Diff a -> c (Diff a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Diff a) # toConstr :: Diff a -> Constr # dataTypeOf :: Diff a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Diff a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Diff a)) # gmapT :: (forall b. Data b => b -> b) -> Diff a -> Diff a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Diff a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Diff a -> r # gmapQ :: (forall d. Data d => d -> u) -> Diff a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Diff a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Diff a -> m (Diff a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Diff a -> m (Diff a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Diff a -> m (Diff a) #
(Ord a, Semigroup a) => Ord (Diff a) Source #
Methods compare :: Diff a -> Diff a -> Ordering # (<) :: Diff a -> Diff a -> Bool # (<=) :: Diff a -> Diff a -> Bool # (>) :: Diff a -> Diff a -> Bool # (>=) :: Diff a -> Diff a -> Bool # max :: Diff a -> Diff a -> Diff a # min :: Diff a -> Diff a -> Diff a #
Read a => Read (Diff a) Source #
Methods readsPrec :: Int -> ReadS (Diff a) # readList :: ReadS [Diff a] # readPrec :: ReadPrec (Diff a) # readListPrec :: ReadPrec [Diff a] #
Show a => Show (Diff a) Source #
Methods showsPrec :: Int -> Diff a -> ShowS # show :: Diff a -> String # showList :: [Diff a] -> ShowS #
Generic (Diff a) Source #
Associated Types type Rep (Diff a) :: * -> * # Methods from :: Diff a -> Rep (Diff a) x # to :: Rep (Diff a) x -> Diff a #
Semigroup a => Semigroup (Diff a) Source #
Methods (<>) :: Diff a -> Diff a -> Diff a # sconcat :: NonEmpty (Diff a) -> Diff a # stimes :: Integral b => b -> Diff a -> Diff a #
Monoid a => Monoid (Diff a) Source #
Methods mempty :: Diff a # mappend :: Diff a -> Diff a -> Diff a # mconcat :: [Diff a] -> Diff a #
NFData a => NFData (Diff a) Source #
Methods rnf :: Diff a -> () #
Monoid a => Group (Diff a) Source #
Methods invert :: Diff a -> Diff a # pow :: Integral x => Diff a -> x -> Diff a #
Generic1 * Diff Source #
Associated Types type Rep1 Diff (f :: Diff -> ) :: k -> # Methods from1 :: f a -> Rep1 Diff f a # to1 :: Rep1 Diff f a -> f a #
type Rep Diff Source #
type Rep Diff = Bool
type Rep (Diff a) Source #
type Rep (Diff a) = D1 * (MetaData "Diff" "Data.Monoid.Diff.Internal" "difference-monoid-0.1.0.0-6GZ7n3SsUmUHrUzugzcGeo" False) (C1 * (MetaCons ":-:" (InfixI LeftAssociative 6) False) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * a))))
type Rep1 * Diff Source #
type Rep1 * Diff = D1 * (MetaData "Diff" "Data.Monoid.Diff.Internal" "difference-monoid-0.1.0.0-6GZ7n3SsUmUHrUzugzcGeo" False) (C1 * (MetaCons ":-:" (InfixI LeftAssociative 6) False) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1)))

diff :: Monoid a => a -> Diff a Source #

Lift a monoid into the difference monoid.

>>> diff (Sum 1)
Sum {getSum = 1} :-: Sum {getSum = 0}

retract :: Group a => Diff a -> a Source #

The inverse of diff.

retract . diff = id

foldDiff :: Group b => (a -> b) -> Diff a -> b Source #

A group homomorphism given a monoid homomorphism.

normalize :: (a -> a -> (a, a)) -> Diff a -> Diff a Source #

Given a "normalizing" function, try simplify the representation.

For instance, one such normalizing function may be to take the numeric difference of two types:

>>> let sumNorm x y = if x >= y then (x - y, 0) else (0, y - x)
>>> normalize sumNorm ((foldMap (diff.Sum) [1..10]) <> (invert (foldMap (diff.Sum) [1..5])))
Sum {getSum = 40} :-: Sum {getSum = 0}

runDiff :: (a -> a -> b) -> Diff a -> b Source #

Interpret the difference using a subtraction function.

newtype Parity a Source #

The Parity Comonad. It is left-adjunct to Diff.

Constructors

Parity
Fields runParity :: (Odd, a)

Instances

Monad Parity Source #
Methods (>>=) :: Parity a -> (a -> Parity b) -> Parity b # (>>) :: Parity a -> Parity b -> Parity b # return :: a -> Parity a # fail :: String -> Parity a #
Functor Parity Source #
Methods fmap :: (a -> b) -> Parity a -> Parity b # (<$) :: a -> Parity b -> Parity a #
MonadFix Parity Source #
Methods mfix :: (a -> Parity a) -> Parity a #
Applicative Parity Source #
Methods pure :: a -> Parity a # (<>) :: Parity (a -> b) -> Parity a -> Parity b # liftA2 :: (a -> b -> c) -> Parity a -> Parity b -> Parity c # (>) :: Parity a -> Parity b -> Parity b # (<*) :: Parity a -> Parity b -> Parity a #
Foldable Parity Source #
Methods fold :: Monoid m => Parity m -> m # foldMap :: Monoid m => (a -> m) -> Parity a -> m # foldr :: (a -> b -> b) -> b -> Parity a -> b # foldr' :: (a -> b -> b) -> b -> Parity a -> b # foldl :: (b -> a -> b) -> b -> Parity a -> b # foldl' :: (b -> a -> b) -> b -> Parity a -> b # foldr1 :: (a -> a -> a) -> Parity a -> a # foldl1 :: (a -> a -> a) -> Parity a -> a # toList :: Parity a -> [a] # null :: Parity a -> Bool # length :: Parity a -> Int # elem :: Eq a => a -> Parity a -> Bool # maximum :: Ord a => Parity a -> a # minimum :: Ord a => Parity a -> a # sum :: Num a => Parity a -> a # product :: Num a => Parity a -> a #
Traversable Parity Source #
Methods traverse :: Applicative f => (a -> f b) -> Parity a -> f (Parity b) # sequenceA :: Applicative f => Parity (f a) -> f (Parity a) # mapM :: Monad m => (a -> m b) -> Parity a -> m (Parity b) # sequence :: Monad m => Parity (m a) -> m (Parity a) #
Comonad Parity Source #
Methods extract :: Parity a -> a # duplicate :: Parity a -> Parity (Parity a) # extend :: (Parity a -> b) -> Parity a -> Parity b #
ComonadApply Parity Source #
Methods (<@>) :: Parity (a -> b) -> Parity a -> Parity b # (@>) :: Parity a -> Parity b -> Parity b # (<@) :: Parity a -> Parity b -> Parity a #
Traversable1 Parity Source #
Methods traverse1 :: Apply f => (a -> f b) -> Parity a -> f (Parity b) # sequence1 :: Apply f => Parity (f b) -> f (Parity b) #
Foldable1 Parity Source #
Methods fold1 :: Semigroup m => Parity m -> m # foldMap1 :: Semigroup m => (a -> m) -> Parity a -> m # toNonEmpty :: Parity a -> NonEmpty a #
Apply Parity Source #
Methods (<.>) :: Parity (a -> b) -> Parity a -> Parity b # (.>) :: Parity a -> Parity b -> Parity b # (<.) :: Parity a -> Parity b -> Parity a # liftF2 :: (a -> b -> c) -> Parity a -> Parity b -> Parity c #
Bind Parity Source #
Methods (>>-) :: Parity a -> (a -> Parity b) -> Parity b # join :: Parity (Parity a) -> Parity a #
Extend Parity Source #
Methods duplicated :: Parity a -> Parity (Parity a) # extended :: (Parity a -> b) -> Parity a -> Parity b #
Adjunction Parity Diff Source #
Methods unit :: a -> Diff (Parity a) # counit :: Parity (Diff a) -> a # leftAdjunct :: (Parity a -> b) -> a -> Diff b # rightAdjunct :: (a -> Diff b) -> Parity a -> b #
ComonadEnv Odd Parity Source #
Methods ask :: Parity a -> Odd #
Bounded a => Bounded (Parity a) Source #
Methods minBound :: Parity a # maxBound :: Parity a #
Eq a => Eq (Parity a) Source #
Methods (==) :: Parity a -> Parity a -> Bool # (/=) :: Parity a -> Parity a -> Bool #
Ord a => Ord (Parity a) Source #
Methods compare :: Parity a -> Parity a -> Ordering # (<) :: Parity a -> Parity a -> Bool # (<=) :: Parity a -> Parity a -> Bool # (>) :: Parity a -> Parity a -> Bool # (>=) :: Parity a -> Parity a -> Bool # max :: Parity a -> Parity a -> Parity a # min :: Parity a -> Parity a -> Parity a #
Read a => Read (Parity a) Source #
Methods readsPrec :: Int -> ReadS (Parity a) # readList :: ReadS [Parity a] # readPrec :: ReadPrec (Parity a) # readListPrec :: ReadPrec [Parity a] #
Show a => Show (Parity a) Source #
Methods showsPrec :: Int -> Parity a -> ShowS # show :: Parity a -> String # showList :: [Parity a] -> ShowS #
Ix a => Ix (Parity a) Source #
Methods range :: (Parity a, Parity a) -> [Parity a] # index :: (Parity a, Parity a) -> Parity a -> Int # unsafeIndex :: (Parity a, Parity a) -> Parity a -> Int inRange :: (Parity a, Parity a) -> Parity a -> Bool # rangeSize :: (Parity a, Parity a) -> Int # unsafeRangeSize :: (Parity a, Parity a) -> Int
Semigroup a => Semigroup (Parity a) Source #
Methods (<>) :: Parity a -> Parity a -> Parity a # sconcat :: NonEmpty (Parity a) -> Parity a # stimes :: Integral b => b -> Parity a -> Parity a #
Monoid a => Monoid (Parity a) Source #
Methods mempty :: Parity a # mappend :: Parity a -> Parity a -> Parity a # mconcat :: [Parity a] -> Parity a #
NFData a => NFData (Parity a) Source #
Methods rnf :: Parity a -> () #

>>> import Data.Monoid hiding (diff, (<>))