Data.Incremental

Documentation

class Incremental a where

Minimal complete definition

patch, diff

Associated Types

type Delta a

the difference type

Methods

patch :: a -> Delta a -> a

maybe a (patch a) (diff b a) ≡ b

diff :: a -> a -> Maybe (Delta a)

returns Nothing when there is no update

Instances

Incremental Bool

Associated Types

type Delta Bool :: *

Methods

patch :: Bool -> Delta Bool -> Bool

diff :: Bool -> Bool -> Maybe (Delta Bool)

Incremental Char

Associated Types

type Delta Char :: *

Methods

patch :: Char -> Delta Char -> Char

diff :: Char -> Char -> Maybe (Delta Char)

Incremental Double

Associated Types

type Delta Double :: *

Methods

patch :: Double -> Delta Double -> Double

diff :: Double -> Double -> Maybe (Delta Double)

Incremental Float

Associated Types

type Delta Float :: *

Methods

patch :: Float -> Delta Float -> Float

diff :: Float -> Float -> Maybe (Delta Float)

Incremental Int

Associated Types

type Delta Int :: *

Methods

patch :: Int -> Delta Int -> Int

diff :: Int -> Int -> Maybe (Delta Int)

Incremental Int8

Associated Types

type Delta Int8 :: *

Methods

patch :: Int8 -> Delta Int8 -> Int8

diff :: Int8 -> Int8 -> Maybe (Delta Int8)

Incremental Int16

Associated Types

type Delta Int16 :: *

Methods

patch :: Int16 -> Delta Int16 -> Int16

diff :: Int16 -> Int16 -> Maybe (Delta Int16)

Incremental Int32

Associated Types

type Delta Int32 :: *

Methods

patch :: Int32 -> Delta Int32 -> Int32

diff :: Int32 -> Int32 -> Maybe (Delta Int32)

Incremental Int64

Associated Types

type Delta Int64 :: *

Methods

patch :: Int64 -> Delta Int64 -> Int64

diff :: Int64 -> Int64 -> Maybe (Delta Int64)

Incremental Integer

Associated Types

type Delta Integer :: *

Methods

patch :: Integer -> Delta Integer -> Integer

diff :: Integer -> Integer -> Maybe (Delta Integer)

Incremental Natural

Associated Types

type Delta Natural :: *

Methods

patch :: Natural -> Delta Natural -> Natural

diff :: Natural -> Natural -> Maybe (Delta Natural)

Incremental Ordering

Associated Types

type Delta Ordering :: *

Methods

patch :: Ordering -> Delta Ordering -> Ordering

diff :: Ordering -> Ordering -> Maybe (Delta Ordering)

Incremental Word

Associated Types

type Delta Word :: *

Methods

patch :: Word -> Delta Word -> Word

diff :: Word -> Word -> Maybe (Delta Word)

Incremental Word8

Associated Types

type Delta Word8 :: *

Methods

patch :: Word8 -> Delta Word8 -> Word8

diff :: Word8 -> Word8 -> Maybe (Delta Word8)

Incremental Word16

Associated Types

type Delta Word16 :: *

Methods

patch :: Word16 -> Delta Word16 -> Word16

diff :: Word16 -> Word16 -> Maybe (Delta Word16)

Incremental Word32

Associated Types

type Delta Word32 :: *

Methods

patch :: Word32 -> Delta Word32 -> Word32

diff :: Word32 -> Word32 -> Maybe (Delta Word32)

Incremental Word64

Associated Types

type Delta Word64 :: *

Methods

patch :: Word64 -> Delta Word64 -> Word64

diff :: Word64 -> Word64 -> Maybe (Delta Word64)

Incremental ()

Associated Types

type Delta () :: *

Methods

patch :: () -> Delta () -> ()

diff :: () -> () -> Maybe (Delta ())

Incremental Void

Associated Types

type Delta Void :: *

Methods

patch :: Void -> Delta Void -> Void

diff :: Void -> Void -> Maybe (Delta Void)

Incremental a => Incremental (Maybe a)

Associated Types

type Delta (Maybe a) :: *

Methods

patch :: Maybe a -> Delta (Maybe a) -> Maybe a

diff :: Maybe a -> Maybe a -> Maybe (Delta (Maybe a))

Incremental (Fixed a)

Associated Types

type Delta (Fixed a) :: *

Methods

patch :: Fixed a -> Delta (Fixed a) -> Fixed a

diff :: Fixed a -> Fixed a -> Maybe (Delta (Fixed a))

Incremental a => Incremental (Identity a)

Associated Types

type Delta (Identity a) :: *

Methods

patch :: Identity a -> Delta (Identity a) -> Identity a

diff :: Identity a -> Identity a -> Maybe (Delta (Identity a))

Num a => Incremental (Sum a)

Associated Types

type Delta (Sum a) :: *

Methods

patch :: Sum a -> Delta (Sum a) -> Sum a

diff :: Sum a -> Sum a -> Maybe (Delta (Sum a))

Incremental a => Incremental (IntMap a)

Associated Types

type Delta (IntMap a) :: *

Methods

patch :: IntMap a -> Delta (IntMap a) -> IntMap a

diff :: IntMap a -> IntMap a -> Maybe (Delta (IntMap a))

Ord a => Incremental (Set a)

Associated Types

type Delta (Set a) :: *

Methods

patch :: Set a -> Delta (Set a) -> Set a

diff :: Set a -> Set a -> Maybe (Delta (Set a))

Incremental (Fresh a)

Always updated

Associated Types

type Delta (Fresh a) :: *

Methods

patch :: Fresh a -> Delta (Fresh a) -> Fresh a

diff :: Fresh a -> Fresh a -> Maybe (Delta (Fresh a))

Eq a => Incremental (Hetero a)

diff checks equality

Associated Types

type Delta (Hetero a) :: *

Methods

patch :: Hetero a -> Delta (Hetero a) -> Hetero a

diff :: Hetero a -> Hetero a -> Maybe (Delta (Hetero a))

(Incremental a, Incremental b) => Incremental (a, b)

Associated Types

type Delta (a, b) :: *

Methods

patch :: (a, b) -> Delta (a, b) -> (a, b)

diff :: (a, b) -> (a, b) -> Maybe (Delta (a, b))

Incremental (Proxy * a)

Associated Types

type Delta (Proxy * a) :: *

Methods

patch :: Proxy * a -> Delta (Proxy * a) -> Proxy * a

diff :: Proxy * a -> Proxy * a -> Maybe (Delta (Proxy * a))

(Ord k, Incremental a) => Incremental (Map k a)

Associated Types

type Delta (Map k a) :: *

Methods

patch :: Map k a -> Delta (Map k a) -> Map k a

diff :: Map k a -> Map k a -> Maybe (Delta (Map k a))

(Incremental a, Incremental b, Incremental c) => Incremental (a, b, c)

Associated Types

type Delta (a, b, c) :: *

Methods

patch :: (a, b, c) -> Delta (a, b, c) -> (a, b, c)

diff :: (a, b, c) -> (a, b, c) -> Maybe (Delta (a, b, c))

Incremental a => Incremental (Const * a b)

Associated Types

type Delta (Const * a b) :: *

Methods

patch :: Const * a b -> Delta (Const * a b) -> Const * a b

diff :: Const * a b -> Const * a b -> Maybe (Delta (Const * a b))

data Alter a

Constructors

Insert a

Update (Delta a)

Delete

Upsert a (Delta a)

Instances

(Show a, Show (Delta a)) => Show (Alter a)

Methods

showsPrec :: Int -> Alter a -> ShowS

show :: Alter a -> String

showList :: [Alter a] -> ShowS

Generic (Alter a)

Associated Types

type Rep (Alter a) :: * -> *

Methods

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

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

(Incremental a, Semigroup (Delta a)) => Semigroup (Alter a)

Methods

(<>) :: Alter a -> Alter a -> Alter a

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

stimes :: Integral b => b -> Alter a -> Alter a

(Incremental a, Semigroup (Delta a), Monoid (Delta a)) => Monoid (Alter a)

Methods

mempty :: Alter a

mappend :: Alter a -> Alter a -> Alter a

mconcat :: [Alter a] -> Alter a

(NFData a, NFData (Delta a)) => NFData (Alter a)

Methods

rnf :: Alter a -> ()

type Rep (Alter a)

type Rep (Alter a) = D1 * (MetaData "Alter" "Data.Incremental" "incremental-0-9B8t7JiTrwqLYdhnWqXCmt" False) ((:+:) * ((:+:) * (C1 * (MetaCons "Insert" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))) (C1 * (MetaCons "Update" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Delta a))))) ((:+:) * (C1 * (MetaCons "Delete" PrefixI False) (U1 *)) (C1 * (MetaCons "Upsert" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Delta a)))))))

newtype Hetero a

Constructors

Hetero

Fields

• getHetero :: a

Instances

Bounded a => Bounded (Hetero a)

Methods

minBound :: Hetero a

maxBound :: Hetero a

Enum a => Enum (Hetero a)

Methods

succ :: Hetero a -> Hetero a

pred :: Hetero a -> Hetero a

toEnum :: Int -> Hetero a

fromEnum :: Hetero a -> Int

enumFrom :: Hetero a -> [Hetero a]

enumFromThen :: Hetero a -> Hetero a -> [Hetero a]

enumFromTo :: Hetero a -> Hetero a -> [Hetero a]

enumFromThenTo :: Hetero a -> Hetero a -> Hetero a -> [Hetero a]

Eq a => Eq (Hetero a)

Methods

(==) :: Hetero a -> Hetero a -> Bool

(/=) :: Hetero a -> Hetero a -> Bool

Floating a => Floating (Hetero a)

Methods

pi :: Hetero a

exp :: Hetero a -> Hetero a

log :: Hetero a -> Hetero a

sqrt :: Hetero a -> Hetero a

(**) :: Hetero a -> Hetero a -> Hetero a

logBase :: Hetero a -> Hetero a -> Hetero a

sin :: Hetero a -> Hetero a

cos :: Hetero a -> Hetero a

tan :: Hetero a -> Hetero a

asin :: Hetero a -> Hetero a

acos :: Hetero a -> Hetero a

atan :: Hetero a -> Hetero a

sinh :: Hetero a -> Hetero a

cosh :: Hetero a -> Hetero a

tanh :: Hetero a -> Hetero a

asinh :: Hetero a -> Hetero a

acosh :: Hetero a -> Hetero a

atanh :: Hetero a -> Hetero a

log1p :: Hetero a -> Hetero a

expm1 :: Hetero a -> Hetero a

log1pexp :: Hetero a -> Hetero a

log1mexp :: Hetero a -> Hetero a

Fractional a => Fractional (Hetero a)

Methods

(/) :: Hetero a -> Hetero a -> Hetero a

recip :: Hetero a -> Hetero a

fromRational :: Rational -> Hetero a

Integral a => Integral (Hetero a)

Methods

quot :: Hetero a -> Hetero a -> Hetero a

rem :: Hetero a -> Hetero a -> Hetero a

div :: Hetero a -> Hetero a -> Hetero a

mod :: Hetero a -> Hetero a -> Hetero a

quotRem :: Hetero a -> Hetero a -> (Hetero a, Hetero a)

divMod :: Hetero a -> Hetero a -> (Hetero a, Hetero a)

toInteger :: Hetero a -> Integer

Num a => Num (Hetero a)

Methods

(+) :: Hetero a -> Hetero a -> Hetero a

(-) :: Hetero a -> Hetero a -> Hetero a

(*) :: Hetero a -> Hetero a -> Hetero a

negate :: Hetero a -> Hetero a

abs :: Hetero a -> Hetero a

signum :: Hetero a -> Hetero a

fromInteger :: Integer -> Hetero a

Ord a => Ord (Hetero a)

Methods

compare :: Hetero a -> Hetero a -> Ordering

(<) :: Hetero a -> Hetero a -> Bool

(<=) :: Hetero a -> Hetero a -> Bool

(>) :: Hetero a -> Hetero a -> Bool

(>=) :: Hetero a -> Hetero a -> Bool

max :: Hetero a -> Hetero a -> Hetero a

min :: Hetero a -> Hetero a -> Hetero a

Real a => Real (Hetero a)

Methods

toRational :: Hetero a -> Rational

RealFloat a => RealFloat (Hetero a)

Methods

floatRadix :: Hetero a -> Integer

floatDigits :: Hetero a -> Int

floatRange :: Hetero a -> (Int, Int)

decodeFloat :: Hetero a -> (Integer, Int)

encodeFloat :: Integer -> Int -> Hetero a

exponent :: Hetero a -> Int

significand :: Hetero a -> Hetero a

scaleFloat :: Int -> Hetero a -> Hetero a

isNaN :: Hetero a -> Bool

isInfinite :: Hetero a -> Bool

isDenormalized :: Hetero a -> Bool

isNegativeZero :: Hetero a -> Bool

isIEEE :: Hetero a -> Bool

atan2 :: Hetero a -> Hetero a -> Hetero a

RealFrac a => RealFrac (Hetero a)

Methods

properFraction :: Integral b => Hetero a -> (b, Hetero a)

truncate :: Integral b => Hetero a -> b

round :: Integral b => Hetero a -> b

ceiling :: Integral b => Hetero a -> b

floor :: Integral b => Hetero a -> b

Generic (Hetero a)

Associated Types

type Rep (Hetero a) :: * -> *

Methods

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

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

Semigroup a => Semigroup (Hetero a)

Methods

(<>) :: Hetero a -> Hetero a -> Hetero a

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

stimes :: Integral b => b -> Hetero a -> Hetero a

Monoid a => Monoid (Hetero a)

Methods

mempty :: Hetero a

mappend :: Hetero a -> Hetero a -> Hetero a

mconcat :: [Hetero a] -> Hetero a

NFData a => NFData (Hetero a)

Methods

rnf :: Hetero a -> ()

Eq a => Incremental (Hetero a)

diff checks equality

Associated Types

type Delta (Hetero a) :: *

Methods

patch :: Hetero a -> Delta (Hetero a) -> Hetero a

diff :: Hetero a -> Hetero a -> Maybe (Delta (Hetero a))

type Rep (Hetero a)

type Rep (Hetero a) = D1 * (MetaData "Hetero" "Data.Incremental" "incremental-0-9B8t7JiTrwqLYdhnWqXCmt" True) (C1 * (MetaCons "Hetero" PrefixI True) (S1 * (MetaSel (Just Symbol "getHetero") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)))

type Delta (Hetero a)

type Delta (Hetero a) = a

newtype Fresh a

Constructors

Fresh

Fields

• getFresh :: a

Instances

Bounded a => Bounded (Fresh a)

Methods

minBound :: Fresh a

maxBound :: Fresh a

Enum a => Enum (Fresh a)

Methods

succ :: Fresh a -> Fresh a

pred :: Fresh a -> Fresh a

toEnum :: Int -> Fresh a

fromEnum :: Fresh a -> Int

enumFrom :: Fresh a -> [Fresh a]

enumFromThen :: Fresh a -> Fresh a -> [Fresh a]

enumFromTo :: Fresh a -> Fresh a -> [Fresh a]

enumFromThenTo :: Fresh a -> Fresh a -> Fresh a -> [Fresh a]

Eq a => Eq (Fresh a)

Methods

(==) :: Fresh a -> Fresh a -> Bool

(/=) :: Fresh a -> Fresh a -> Bool

Floating a => Floating (Fresh a)

Methods

pi :: Fresh a

exp :: Fresh a -> Fresh a

log :: Fresh a -> Fresh a

sqrt :: Fresh a -> Fresh a

(**) :: Fresh a -> Fresh a -> Fresh a

logBase :: Fresh a -> Fresh a -> Fresh a

sin :: Fresh a -> Fresh a

cos :: Fresh a -> Fresh a

tan :: Fresh a -> Fresh a

asin :: Fresh a -> Fresh a

acos :: Fresh a -> Fresh a

atan :: Fresh a -> Fresh a

sinh :: Fresh a -> Fresh a

cosh :: Fresh a -> Fresh a

tanh :: Fresh a -> Fresh a

asinh :: Fresh a -> Fresh a

acosh :: Fresh a -> Fresh a

atanh :: Fresh a -> Fresh a

log1p :: Fresh a -> Fresh a

expm1 :: Fresh a -> Fresh a

log1pexp :: Fresh a -> Fresh a

log1mexp :: Fresh a -> Fresh a

Fractional a => Fractional (Fresh a)

Methods

(/) :: Fresh a -> Fresh a -> Fresh a

recip :: Fresh a -> Fresh a

fromRational :: Rational -> Fresh a

Integral a => Integral (Fresh a)

Methods

quot :: Fresh a -> Fresh a -> Fresh a

rem :: Fresh a -> Fresh a -> Fresh a

div :: Fresh a -> Fresh a -> Fresh a

mod :: Fresh a -> Fresh a -> Fresh a

quotRem :: Fresh a -> Fresh a -> (Fresh a, Fresh a)

divMod :: Fresh a -> Fresh a -> (Fresh a, Fresh a)

toInteger :: Fresh a -> Integer

Num a => Num (Fresh a)

Methods

(+) :: Fresh a -> Fresh a -> Fresh a

(-) :: Fresh a -> Fresh a -> Fresh a

(*) :: Fresh a -> Fresh a -> Fresh a

negate :: Fresh a -> Fresh a

abs :: Fresh a -> Fresh a

signum :: Fresh a -> Fresh a

fromInteger :: Integer -> Fresh a

Ord a => Ord (Fresh a)

Methods

compare :: Fresh a -> Fresh a -> Ordering

(<) :: Fresh a -> Fresh a -> Bool

(<=) :: Fresh a -> Fresh a -> Bool

(>) :: Fresh a -> Fresh a -> Bool

(>=) :: Fresh a -> Fresh a -> Bool

max :: Fresh a -> Fresh a -> Fresh a

min :: Fresh a -> Fresh a -> Fresh a

Real a => Real (Fresh a)

Methods

toRational :: Fresh a -> Rational

RealFloat a => RealFloat (Fresh a)

Methods

floatRadix :: Fresh a -> Integer

floatDigits :: Fresh a -> Int

floatRange :: Fresh a -> (Int, Int)

decodeFloat :: Fresh a -> (Integer, Int)

encodeFloat :: Integer -> Int -> Fresh a

exponent :: Fresh a -> Int

significand :: Fresh a -> Fresh a

scaleFloat :: Int -> Fresh a -> Fresh a

isNaN :: Fresh a -> Bool

isInfinite :: Fresh a -> Bool

isDenormalized :: Fresh a -> Bool

isNegativeZero :: Fresh a -> Bool

isIEEE :: Fresh a -> Bool

atan2 :: Fresh a -> Fresh a -> Fresh a

RealFrac a => RealFrac (Fresh a)

Methods

properFraction :: Integral b => Fresh a -> (b, Fresh a)

truncate :: Integral b => Fresh a -> b

round :: Integral b => Fresh a -> b

ceiling :: Integral b => Fresh a -> b

floor :: Integral b => Fresh a -> b

Generic (Fresh a)

Associated Types

type Rep (Fresh a) :: * -> *

Methods

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

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

Semigroup a => Semigroup (Fresh a)

Methods

(<>) :: Fresh a -> Fresh a -> Fresh a

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

stimes :: Integral b => b -> Fresh a -> Fresh a

Monoid a => Monoid (Fresh a)

Methods

mempty :: Fresh a

mappend :: Fresh a -> Fresh a -> Fresh a

mconcat :: [Fresh a] -> Fresh a

NFData a => NFData (Fresh a)

Methods

rnf :: Fresh a -> ()

Incremental (Fresh a)

Always updated

Associated Types

type Delta (Fresh a) :: *

Methods

patch :: Fresh a -> Delta (Fresh a) -> Fresh a

diff :: Fresh a -> Fresh a -> Maybe (Delta (Fresh a))

type Rep (Fresh a)

type Rep (Fresh a) = D1 * (MetaData "Fresh" "Data.Incremental" "incremental-0-9B8t7JiTrwqLYdhnWqXCmt" True) (C1 * (MetaCons "Fresh" PrefixI True) (S1 * (MetaSel (Just Symbol "getFresh") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)))

type Delta (Fresh a)

type Delta (Fresh a) = a