Data.Incremental.Map

newtype IMap k v

A change structure for Map which tracks changes for each key.

Constructors

• IMap (Map k v)

Instances

• (Eq k, Eq v) => Eq (IMap k v)
• (Show k, Show v) => Show (IMap k v)
• Newtype (IMap k v) _
• (Ord k, Patch v dv) => Patch (IMap k v) (MapChanges k v dv)
• (Ord k, Diff v dv) => Diff (IMap k v) (MapChanges k v dv)

newtype MapChanges k v dv

A change for each possible key.

Constructors

• MapChanges (Map k (MapChange v dv))

Instances

• (Eq k, Eq v, Eq dv) => Eq (MapChanges k v dv)
• Newtype (MapChanges k v dv) _
• (Show k, Show v, Show dv) => Show (MapChanges k v dv)
• (Ord k, Patch v dv) => Semigroup (MapChanges k v dv)
• (Ord k, Patch v dv) => Monoid (MapChanges k v dv)
• (Ord k, Patch v dv) => Patch (IMap k v) (MapChanges k v dv)
• (Ord k, Diff v dv) => Diff (IMap k v) (MapChanges k v dv)

data MapChange v dv

A change for a single key is an addition, removal, or update.

Constructors

• Add v
• Remove
• Update dv

Instances

• (Eq v, Eq dv) => Eq (MapChange v dv)
• (Show v, Show dv) => Show (MapChange v dv)

insert :: forall dv v k. Ord k => Patch v dv => k -> v -> Change (IMap k v)

remove :: forall dv v k. Ord k => Patch v dv => k -> Change (IMap k v)

updateAt :: forall dv v k. Ord k => Patch v dv => k -> Change v -> Change (IMap k v)

static :: forall dv v k. Ord k => Patch v dv => Map k (Jet v) -> Jet (IMap k v)

Construct a map whose values can change but whose keys are fixed.

singleton :: forall dv v k. Ord k => Patch v dv => k -> Jet v -> Jet (IMap k v)

Construct a map from a key/value pair.

map :: forall db b da a k. Ord k => Patch a da => Patch b db => (Jet a -> Jet b) -> Jet (IMap k a) -> Jet (IMap k b)

Update every key by applying a function.

modifyAt :: forall dv v k. Ord k => Patch v dv => k -> (Jet v -> Jet v) -> Jet (IMap k v) -> Jet (IMap k v)

Update a single key by applying a function.

size :: forall da a k. Ord k => Patch a da => Jet (IMap k a) -> Jet (Atomic Int)

Compute the size of an IMap, incrementally.

zip :: forall db b da a k. Ord k => Patch a da => Patch b db => Jet (IMap k a) -> Jet (IMap k b) -> Jet (IMap k (Tuple a b))

Zip two maps, keeping those keys which are common to both input maps.

toIArray :: forall da a k. Ord k => Patch a da => Jet (IMap k a) -> Jet (IArray (Tuple (Atomic k) a))

Convert an IMap into an IArray of tuples of keys and values, in order, incrementally.