- TrackingHashMap <K, V>
- Empty = new TrackingHashMap<K,V>(TrieMap<EqDefault<K>, K, V>.Empty)
- Changes
- TrackingHashMap (IEnumerable<(K Key, V Value)> items)
- TrackingHashMap (IEnumerable<(K Key, V Value)> items, bool tryAdd)
- Snapshot ()
- item (K key)
- itemOrNone (K key)
- this []
- IsEmpty
- Count
- Length
- ToReadOnlyDictionary ()
- Filter (Func<V, bool> pred)
- Filter (Func<K, V, bool> pred)
- Add (K key, V value)
- TryAdd (K key, V value)
- AddOrUpdate (K key, V value)
- AddOrUpdate (K key, Func<V, V> Some, Func<V> None)
- AddOrUpdate (K key, Func<V, V> Some, V None)
- AddRange (IEnumerable<Tuple<K, V>> range)
- AddRange (IEnumerable<(K Key, V Value)> range)
- TryAddRange (IEnumerable<Tuple<K, V>> range)
- TryAddRange (IEnumerable<(K Key, V Value)> range)
- TryAddRange (IEnumerable<KeyValuePair<K, V>> range)
- AddOrUpdateRange (IEnumerable<Tuple<K, V>> range)
- AddOrUpdateRange (IEnumerable<(K Key, V Value)> range)
- AddOrUpdateRange (IEnumerable<KeyValuePair<K, V>> range)
- Remove (K key)
- Find (K key)
- FindSeq (K key)
- Find <R> (K key, Func<V, R> Some, Func<R> None)
- FindOrAdd (K key, Func<V> None)
- FindOrAdd (K key, V value)
- FindOrMaybeAdd (K key, Func<Option<V>> None)
- FindOrMaybeAdd (K key, Option<V> None)
- SetItem (K key, V value)
- SetItem (K key, Func<V, V> Some)
- TrySetItem (K key, V value)
- TrySetItem (K key, Func<V, V> Some)
- ContainsKey (K key)
- Contains (K key, V value)
- Contains (V value)
- Contains <EqV> (V value)
- Contains <EqV> (K key, V value)
- Clear ()
- AddRange (IEnumerable<KeyValuePair<K, V>> pairs)
- SetItems (IEnumerable<KeyValuePair<K, V>> items)
- SetItems (IEnumerable<Tuple<K, V>> items)
- SetItems (IEnumerable<(K Key, V Value)> items)
- TrySetItems (IEnumerable<KeyValuePair<K, V>> items)
- TrySetItems (IEnumerable<Tuple<K, V>> items)
- TrySetItems (IEnumerable<(K Key, V Value)> items)
- TrySetItems (IEnumerable<K> keys, Func<V, V> Some)
- RemoveRange (IEnumerable<K> keys)
- Contains (KeyValuePair<K, V> pair)
- Keys
- Values
- ToDictionary ()
- ToDictionary <KR, VR> ( Func<(K Key, V Value), KR> keySelector, Func<(K Key, V Value), VR> valueSelector)
- GetEnumerator ()
- ToSeq ()
- ToHashMap ()
- ToString ()
- ToFullString (string separator = ", ")
- ToFullArrayString (string separator = ", ")
- AsEnumerable ()
- == (TrackingHashMap<K, V> lhs, TrackingHashMap<K, V> rhs)
- != (TrackingHashMap<K, V> lhs, TrackingHashMap<K, V> rhs)
- + (TrackingHashMap<K, V> lhs, TrackingHashMap<K, V> rhs)
- Append (TrackingHashMap<K, V> rhs)
- - (TrackingHashMap<K, V> lhs, TrackingHashMap<K, V> rhs)
- Subtract (TrackingHashMap<K, V> rhs)
- IsProperSubsetOf (IEnumerable<(K Key, V Value)> other)
- IsProperSubsetOf (IEnumerable<K> other)
- IsProperSupersetOf (IEnumerable<(K Key, V Value)> other)
- IsProperSupersetOf (IEnumerable<K> other)
- IsSubsetOf (IEnumerable<(K Key, V Value)> other)
- IsSubsetOf (IEnumerable<K> other)
- IsSubsetOf (TrackingHashMap<K, V> other)
- IsSupersetOf (IEnumerable<(K Key, V Value)> other)
- IsSupersetOf (IEnumerable<K> rhs)
- Intersect (IEnumerable<K> rhs)
- Intersect (IEnumerable<(K Key, V Value)> rhs)
- Intersect (IEnumerable<(K Key, V Value)> rhs, WhenMatched<K, V, V, V> Merge)
- Intersect (HashMap<K, V> rhs, WhenMatched<K, V, V, V> Merge)
- Intersect (TrackingHashMap<K, V> rhs, WhenMatched<K, V, V, V> Merge)
- Overlaps (IEnumerable<(K Key, V Value)> other)
- Overlaps (IEnumerable<K> other)
- Except (IEnumerable<K> rhs)
- Except (IEnumerable<(K Key, V Value)> rhs)
- SymmetricExcept (TrackingHashMap<K, V> rhs)
- SymmetricExcept (IEnumerable<(K Key, V Value)> rhs)
- Union (IEnumerable<(K, V)> rhs)
- Union (IEnumerable<(K Key, V Value)> other, WhenMatched<K, V, V, V> Merge)
- Union <W> (IEnumerable<(K Key, W Value)> other, WhenMissing<K, W, V> MapRight, WhenMatched<K, V, W, V> Merge)
- Equals (object? obj)
- Equals (TrackingHashMap<K, V> other)
- Equals <EqV> (TrackingHashMap<K, V> other)
- EqualsKeys (TrackingHashMap<K, V> other)
- GetHashCode ()
- Do (Action<V> f)
- Where (Func<V, bool> pred)
- Where (Func<K, V, bool> pred)
- ForAll (Func<K, V, bool> pred)
- ForAll (Func<Tuple<K, V>, bool> pred)
- ForAll (Func<(K Key, V Value), bool> pred)
- ForAll (Func<KeyValuePair<K, V>, bool> pred)
- ForAll (Func<V, bool> pred)
- Exists (Func<K, V, bool> pred)
- Exists (Func<Tuple<K, V>, bool> pred)
- Exists (Func<(K Key, V Value), bool> pred)
- Exists (Func<KeyValuePair<K, V>, bool> pred)
- Exists (Func<V, bool> pred)
- Iter (Action<K, V> action)
- Iter (Action<V> action)
- Iter (Action<Tuple<K, V>> action)
- Iter (Action<(K Key, V Value)> action)
- Iter (Action<KeyValuePair<K, V>> action)
- Fold <S> (S state, Func<S, K, V, S> folder)
- Fold <S> (S state, Func<S, V, S> folder)
- TrackingHashMap <EqK, K, V>
- Empty = new TrackingHashMap<EqK, K,V>(TrieMap<EqK, K, V>.Empty)
- Changes
- TrackingHashMap (IEnumerable<(K Key, V Value)> items)
- TrackingHashMap (IEnumerable<(K Key, V Value)> items, bool tryAdd)
- Snapshot ()
- item (K key)
- itemOrNone (K key)
- this []
- IsEmpty
- Count
- Length
- ToReadOnlyDictionary ()
- Filter (Func<V, bool> pred)
- Filter (Func<K, V, bool> pred)
- Add (K key, V value)
- TryAdd (K key, V value)
- AddOrUpdate (K key, V value)
- AddOrUpdate (K key, Func<V, V> Some, Func<V> None)
- AddOrUpdate (K key, Func<V, V> Some, V None)
- AddRange (IEnumerable<Tuple<K, V>> range)
- AddRange (IEnumerable<(K Key, V Value)> range)
- TryAddRange (IEnumerable<Tuple<K, V>> range)
- TryAddRange (IEnumerable<(K Key, V Value)> range)
- TryAddRange (IEnumerable<KeyValuePair<K, V>> range)
- AddOrUpdateRange (IEnumerable<Tuple<K, V>> range)
- AddOrUpdateRange (IEnumerable<(K Key, V Value)> range)
- AddOrUpdateRange (IEnumerable<KeyValuePair<K, V>> range)
- Remove (K key)
- Find (K key)
- FindSeq (K key)
- Find <R> (K key, Func<V, R> Some, Func<R> None)
- FindOrAdd (K key, Func<V> None)
- FindOrAdd (K key, V value)
- FindOrMaybeAdd (K key, Func<Option<V>> None)
- FindOrMaybeAdd (K key, Option<V> None)
- SetItem (K key, V value)
- SetItem (K key, Func<V, V> Some)
- TrySetItem (K key, V value)
- TrySetItem (K key, Func<V, V> Some)
- ContainsKey (K key)
- Contains (K key, V value)
- Contains (V value)
- Contains <EqV> (V value)
- Contains <EqV> (K key, V value)
- Clear ()
- AddRange (IEnumerable<KeyValuePair<K, V>> pairs)
- SetItems (IEnumerable<KeyValuePair<K, V>> items)
- SetItems (IEnumerable<Tuple<K, V>> items)
- SetItems (IEnumerable<(K Key, V Value)> items)
- TrySetItems (IEnumerable<KeyValuePair<K, V>> items)
- TrySetItems (IEnumerable<Tuple<K, V>> items)
- TrySetItems (IEnumerable<(K Key, V Value)> items)
- TrySetItems (IEnumerable<K> keys, Func<V, V> Some)
- RemoveRange (IEnumerable<K> keys)
- Contains (KeyValuePair<K, V> pair)
- Keys
- Values
- ToDictionary ()
- ToDictionary <KR, VR> ( Func<(K Key, V Value), KR> keySelector, Func<(K Key, V Value), VR> valueSelector)
- GetEnumerator ()
- ToSeq ()
- ToHashMap ()
- ToString ()
- ToFullString (string separator = ", ")
- ToFullArrayString (string separator = ", ")
- AsEnumerable ()
- == (TrackingHashMap<EqK, K, V> lhs, TrackingHashMap<EqK, K, V> rhs)
- != (TrackingHashMap<EqK, K, V> lhs, TrackingHashMap<EqK, K, V> rhs)
- + (TrackingHashMap<EqK, K, V> lhs, TrackingHashMap<EqK, K, V> rhs)
- Append (TrackingHashMap<EqK, K, V> rhs)
- - (TrackingHashMap<EqK, K, V> lhs, TrackingHashMap<EqK, K, V> rhs)
- Subtract (TrackingHashMap<EqK, K, V> rhs)
- IsProperSubsetOf (IEnumerable<(K Key, V Value)> other)
- IsProperSubsetOf (IEnumerable<K> other)
- IsProperSupersetOf (IEnumerable<(K Key, V Value)> other)
- IsProperSupersetOf (IEnumerable<K> other)
- IsSubsetOf (IEnumerable<(K Key, V Value)> other)
- IsSubsetOf (IEnumerable<K> other)
- IsSubsetOf (TrackingHashMap<EqK, K, V> other)
- IsSupersetOf (IEnumerable<(K Key, V Value)> other)
- IsSupersetOf (IEnumerable<K> rhs)
- Intersect (IEnumerable<K> rhs)
- Intersect (IEnumerable<(K Key, V Value)> rhs)
- Intersect (IEnumerable<(K Key, V Value)> rhs, WhenMatched<K, V, V, V> Merge)
- Intersect (HashMap<EqK, K, V> rhs, WhenMatched<K, V, V, V> Merge)
- Intersect (TrackingHashMap<EqK, K, V> rhs, WhenMatched<K, V, V, V> Merge)
- Overlaps (IEnumerable<(K Key, V Value)> other)
- Overlaps (IEnumerable<K> other)
- Except (IEnumerable<K> rhs)
- Except (IEnumerable<(K Key, V Value)> rhs)
- SymmetricExcept (TrackingHashMap<EqK, K, V> rhs)
- SymmetricExcept (IEnumerable<(K Key, V Value)> rhs)
- Union (IEnumerable<(K, V)> rhs)
- Union (IEnumerable<(K Key, V Value)> other, WhenMatched<K, V, V, V> Merge)
- Union <W> (IEnumerable<(K Key, W Value)> other, WhenMissing<K, W, V> MapRight, WhenMatched<K, V, W, V> Merge)
- Equals (object? obj)
- Equals (TrackingHashMap<EqK, K, V> other)
- Equals <EqV> (TrackingHashMap<EqK, K, V> other)
- EqualsKeys (TrackingHashMap<EqK, K, V> other)
- GetHashCode ()
- Do (Action<V> f)
- Where (Func<V, bool> pred)
- Where (Func<K, V, bool> pred)
- ForAll (Func<K, V, bool> pred)
- ForAll (Func<Tuple<K, V>, bool> pred)
- ForAll (Func<(K Key, V Value), bool> pred)
- ForAll (Func<KeyValuePair<K, V>, bool> pred)
- ForAll (Func<V, bool> pred)
- Exists (Func<K, V, bool> pred)
- Exists (Func<Tuple<K, V>, bool> pred)
- Exists (Func<(K Key, V Value), bool> pred)
- Exists (Func<KeyValuePair<K, V>, bool> pred)
- Exists (Func<V, bool> pred)
- Iter (Action<K, V> action)
- Iter (Action<V> action)
- Iter (Action<Tuple<K, V>> action)
- Iter (Action<(K Key, V Value)> action)
- Iter (Action<KeyValuePair<K, V>> action)
- Fold <S> (S state, Func<S, K, V, S> folder)
- Fold <S> (S state, Func<S, V, S> folder)
- TrackingHashMapExtensions
- ToTrackingHashMap <K, V> (this IEnumerable<(K, V)> items)
- ToTrackingHashMap <K, V> (this IEnumerable<Tuple<K, V>> items)
- ToTrackingHashMap <K, V> (this IEnumerable<KeyValuePair<K, V>> items)
- ToTrackingHashMap <K1, K2, V> (this IEnumerable<(K1, K2, V)> items)
- ToTrackingHashMap <K1, K2, V> (this IEnumerable<Tuple<K1, K2, V>> items)
- ToTrackingHashMap <K1, K2, K3, V> (this IEnumerable<(K1, K2, K3, V)> items)
- ToTrackingHashMap <K1, K2, K3, V> (this IEnumerable<Tuple<K1, K2, K3, V>> items)
- ToTrackingHashMap <K1, K2, K3, K4, V> (this IEnumerable<(K1, K2, K3, K4, V)> items)
- ToTrackingHashMap <K1, K2, K3, K4, V> (this IEnumerable<Tuple<K1, K2, K3, K4, V>> items)
- Count <K, V> (this TrackingHashMap<K, V> self)
- Sum <K> (this TrackingHashMap<K, int> self)
- Find <A, B, T> (this TrackingHashMap<A, TrackingHashMap<B, T>> self, A outerKey, B innerKey)
- Find <A, B, C, T> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, T>>> self, A aKey, B bKey, C cKey)
- Find <A, B, T, R> (this TrackingHashMap<A, TrackingHashMap<B, T>> self, A outerKey, B innerKey, Func<T, R> Some, Func<R> None)
- Find <A, B, C, T, R> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, T>>> self, A aKey, B bKey, C cKey, Func<T, R> Some, Func<R> None)
- Find <A, B, C, D, T, R> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, TrackingHashMap<D, T>>>> self, A aKey, B bKey, C cKey, D dKey, Func<T, R> Some, Func<R> None)
- AddOrUpdate <A, B, T> (this TrackingHashMap<A, TrackingHashMap<B, T>> self, A outerKey, B innerKey, Func<T, T> Some, Func<T> None)
- AddOrUpdate <A, B, T> (this TrackingHashMap<A, TrackingHashMap<B, T>> self, A outerKey, B innerKey, T value)
- AddOrUpdate <A, B, C, T> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, T>>> self, A aKey, B bKey, C cKey, T value)
- AddOrUpdate <A, B, C, T> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, T>>> self, A aKey, B bKey, C cKey, Func<T, T> Some, Func<T> None)
- AddOrUpdate <A, B, C, D, T> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, TrackingHashMap<D, T>>>> self, A aKey, B bKey, C cKey, D dKey, T value)
- AddOrUpdate <A, B, C, D, T> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, TrackingHashMap<D, T>>>> self, A aKey, B bKey, C cKey, D dKey, Func<T, T> Some, Func<T> None)
- Remove <A, B, T> (this TrackingHashMap<A, TrackingHashMap<B, T>> self, A outerKey, B innerKey)
- Remove <A, B, C, T> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, T>>> self, A aKey, B bKey, C cKey)
- TrackingHashMapExtensions
- ToTrackingHashMap <EqK, K, V> (this IEnumerable<(K, V)> items)
- ToTrackingHashMap <EqK, K, V> (this IEnumerable<Tuple<K, V>> items)
- ToTrackingHashMap <EqK, K, V> (this IEnumerable<KeyValuePair<K, V>> items)
- TrackingHashMap
- clear <K, V> (TrackingHashMap<K, V> map)
- empty <K, V> ()
- create <K, V> ()
- create <K, V> (Tuple<K, V> head, params Tuple<K, V>[] tail)
- create <K, V> ((K, V) head, params (K, V)[] tail)
- create <K, V> (KeyValuePair<K, V> head, params KeyValuePair<K,V>[] tail)
- createRange <K, V> (IEnumerable<Tuple<K, V>> keyValues)
- createRange <K, V> (IEnumerable<(K, V)> keyValues)
- createRange <K, V> (IEnumerable<KeyValuePair<K, V>> keyValues)
- add <K, V> (TrackingHashMap<K, V> map, K key, V value)
- tryAdd <K, V> (TrackingHashMap<K, V> map, K key, V value)
- addOrUpdate <K, V> (TrackingHashMap<K, V> map, K key, V value)
- addOrUpdate <K, V> (TrackingHashMap<K, V> map, K key, Func<V, V> Some, Func<V> None)
- addOrUpdate <K, V> (TrackingHashMap<K, V> map, K key, Func<V, V> Some, V None)
- addRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<Tuple<K, V>> keyValues)
- addRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<(K, V)> keyValues)
- addRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues)
- tryAddRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<Tuple<K, V>> keyValues)
- tryAddRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<(K, V)> keyValues)
- tryAddRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues)
- addOrUpdateRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<Tuple<K, V>> range)
- addOrUpdateRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<(K, V)> range)
- addOrUpdateRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> range)
- remove <K, V> (TrackingHashMap<K, V> map, K key)
- containsKey <K, V> (TrackingHashMap<K, V> map, K key)
- contains <K, V> (TrackingHashMap<K, V> map, KeyValuePair<K, V> kv)
- contains <K, V> (TrackingHashMap<K, V> map, Tuple<K, V> kv)
- contains <K, V> (TrackingHashMap<K, V> map, (K, V) kv)
- setItem <K, V> (TrackingHashMap<K, V> map, K key, V value)
- trySetItem <K, V> (TrackingHashMap<K, V> map, K key, V value)
- trySetItem <K, V> (TrackingHashMap<K, V> map, K key, Func<V, V> Some)
- setItems <K, V> (TrackingHashMap<K, V> map, IEnumerable<Tuple<K, V>> items)
- setItems <K, V> (TrackingHashMap<K, V> map, IEnumerable<(K, V)> items)
- setItems <K, V> (TrackingHashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> items)
- trySetItems <K, V> (TrackingHashMap<K, V> map, IEnumerable<Tuple<K, V>> items)
- trySetItems <K, V> (TrackingHashMap<K, V> map, IEnumerable<(K, V)> items)
- trySetItems <K, V> (TrackingHashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> items)
- trySetItems <K, V> (TrackingHashMap<K, V> map, IEnumerable<K> keys, Func<V, V> Some)
- find <K, V> (TrackingHashMap<K, V> map, K key)
- findSeq <K, V> (TrackingHashMap<K, V> map, K key)
- find <K, V, R> (TrackingHashMap<K, V> map, K key, Func<V, R> Some, Func<R> None)
- setItem <K, V> (TrackingHashMap<K, V> map, K key, Func<V, V> mapper)
- iter <K, V> (TrackingHashMap<K, V> map, Action<V> action)
- iter <K, V> (TrackingHashMap<K, V> map, Action<K, V> action)
- forall <K, V> (TrackingHashMap<K, V> map, Func<V, bool> pred)
- forall <K, V> (TrackingHashMap<K, V> map, Func<K, V, bool> pred)
- forall <K, V> (TrackingHashMap<K, V> map, Func<Tuple<K, V>, bool> pred)
- forall <K, V> (TrackingHashMap<K, V> map, Func<(K Key, V Value), bool> pred)
- forall <K, V> (TrackingHashMap<K, V> map, Func<KeyValuePair<K, V>, bool> pred)
- filter <K, V> (TrackingHashMap<K, V> map, Func<V, bool> predicate)
- filter <K, V> (TrackingHashMap<K, V> map, Func<K, V, bool> predicate)
- length <K, T> (TrackingHashMap<K, T> map)
- fold <S, K, V> (TrackingHashMap<K, V> map, S state, Func<S, K, V, S> folder)
- fold <S, K, V> (TrackingHashMap<K, V> map, S state, Func<S, V, S> folder)
- exists <K, V> (TrackingHashMap<K, V> map, Func<K, V, bool> pred)
- exists <K, V> (TrackingHashMap<K, V> map, Func<Tuple<K, V>, bool> pred)
- exists <K, V> (TrackingHashMap<K, V> map, Func<(K Key, V Value), bool> pred)
- exists <K, V> (TrackingHashMap<K, V> map, Func<KeyValuePair<K, V>, bool> pred)
- exists <K, V> (TrackingHashMap<K, V> map, Func<V, bool> pred)
- TrackingHashMap
- clear <EqK, K, V> (TrackingHashMap<EqK, K, V> map)
- empty <EqK, K, V> ()
- create <EqK, K, V> ()
- create <EqK, K, V> (Tuple<K, V> head, params Tuple<K, V>[] tail)
- create <EqK, K, V> ((K, V) head, params (K, V)[] tail)
- create <EqK, K, V> (KeyValuePair<K, V> head, params KeyValuePair<K,V>[] tail)
- createRange <EqK, K, V> (IEnumerable<Tuple<K, V>> keyValues)
- createRange <EqK, K, V> (IEnumerable<(K, V)> keyValues)
- createRange <EqK, K, V> (IEnumerable<KeyValuePair<K, V>> keyValues)
- add <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, V value)
- tryAdd <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, V value)
- addOrUpdate <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, V value)
- addOrUpdate <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, Func<V, V> Some, Func<V> None)
- addOrUpdate <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, Func<V, V> Some, V None)
- addRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> keyValues)
- addRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<(K, V)> keyValues)
- addRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues)
- tryAddRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> keyValues)
- tryAddRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<(K, V)> keyValues)
- tryAddRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues)
- addOrUpdateRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> range)
- addOrUpdateRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<(K, V)> range)
- addOrUpdateRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> range)
- remove <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key)
- containsKey <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key)
- contains <EqK, K, V> (TrackingHashMap<EqK, K, V> map, KeyValuePair<K, V> kv)
- contains <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Tuple<K, V> kv)
- contains <EqK, K, V> (TrackingHashMap<EqK, K, V> map, (K, V) kv)
- setItem <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, V value)
- trySetItem <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, V value)
- trySetItem <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, Func<V, V> Some)
- setItems <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> items)
- setItems <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<(K, V)> items)
- setItems <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> items)
- trySetItems <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> items)
- trySetItems <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<(K, V)> items)
- trySetItems <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> items)
- trySetItems <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<K> keys, Func<V, V> Some)
- find <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key)
- findSeq <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key)
- find <EqK, K, V, R> (TrackingHashMap<EqK, K, V> map, K key, Func<V, R> Some, Func<R> None)
- setItem <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, Func<V, V> mapper)
- iter <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Action<V> action)
- iter <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Action<K, V> action)
- forall <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<V, bool> pred)
- forall <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<K, V, bool> pred)
- forall <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<Tuple<K, V>, bool> pred)
- forall <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<(K Key, V Value), bool> pred)
- forall <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<KeyValuePair<K, V>, bool> pred)
- filter <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<V, bool> predicate)
- filter <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<K, V, bool> predicate)
- length <EqK, K, T> (TrackingHashMap<EqK, K, T> map)
- fold <EqK, S, K, V> (TrackingHashMap<EqK, K, V> map, S state, Func<S, K, V, S> folder)
- fold <EqK, S, K, V> (TrackingHashMap<EqK, K, V> map, S state, Func<S, V, S> folder)
- exists <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<K, V, bool> pred)
- exists <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<Tuple<K, V>, bool> pred)
- exists <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<(K Key, V Value), bool> pred)
- exists <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<KeyValuePair<K, V>, bool> pred)
- exists <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<V, bool> pred)
struct TrackingHashMap <K, V> Source #
Unsorted immutable hash-map that tracks changes.
Changes are accessible via the Changes
property. It is a HashMap
of Change
values from either the initial
empty state of the collection, or since the last call to Snapshot()
.
The fact that the changes are represented as a single-value HashMap
shows that the tracked changes are not an
ever increasing log of changes, but instead a morphism between one previous state of the TrackingHashMap
and
another. Therefore there's at most one morphism for each key, and potentially none.
The morphisms are:
* `EntryAdded`
* `EntryMapped`
* `EntryRemoved`
A new 'zero-changes starting-state' can be created by calling Snapshot()
. Snapshot
creates the first
snapshot (effectively clears the Changes
to zero), and Changes
will collect the difference from this point
to any morphed future-state as collection-transforming operations are performed
type | K | Key type |
type | V | Value |
field TrackingHashMap<K, V> Empty = new TrackingHashMap<K,V>(TrieMap<EqDefault<K>, K, V>.Empty) Source #
constructor TrackingHashMap (IEnumerable<(K Key, V Value)> items) Source #
constructor TrackingHashMap (IEnumerable<(K Key, V Value)> items, bool tryAdd) Source #
method TrackingHashMap<K, V> Snapshot () Source #
Creates a 'zero change' snapshot. The data does not change!
Useful for creating new starting points for capturing the difference between two snapshots of the
TrackingHashMap
. Snapshot
creates the first snapshot (effectively clears the Changes
to zero), and
Changes
will collect the difference from this point to any morphed future point as collection
transforming operations are performed
returns | Map with changes zeroed |
method Lens<TrackingHashMap<K, V>, Option<V>> itemOrNone (K key) Source #
Item or none at index lens
method IReadOnlyDictionary<K, V> ToReadOnlyDictionary () Source #
Get a IReadOnlyDictionary for this map. No mapping is required, so this is very fast.
method TrackingHashMap<K, V> Filter (Func<V, bool> pred) Source #
Atomically filter out items that return false when a predicate is applied
param | pred | Predicate |
returns | New map with items filtered |
method TrackingHashMap<K, V> Filter (Func<K, V, bool> pred) Source #
Atomically filter out items that return false when a predicate is applied
param | pred | Predicate |
returns | New map with items filtered |
method TrackingHashMap<K, V> Add (K key, V value) Source #
Atomically adds a new item to the map
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<K, V> TryAdd (K key, V value) Source #
Atomically adds a new item to the map. If the key already exists, then the new item is ignored
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<K, V> AddOrUpdate (K key, V value) Source #
Atomically adds a new item to the map. If the key already exists, the new item replaces it.
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<K, V> AddOrUpdate (K key, Func<V, V> Some, Func<V> None) Source #
Retrieve a value from the map by key, map it to a new value, put it back. If it doesn't exist, add a new one based on None result.
param | key | Key to find |
returns | New map with the mapped value |
method TrackingHashMap<K, V> AddOrUpdate (K key, Func<V, V> Some, V None) Source #
Retrieve a value from the map by key, map it to a new value, put it back. If it doesn't exist, add a new one based on None result.
param | key | Key to find |
returns | New map with the mapped value |
method TrackingHashMap<K, V> AddRange (IEnumerable<Tuple<K, V>> range) Source #
Atomically adds a range of items to the map.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> AddRange (IEnumerable<(K Key, V Value)> range) Source #
Atomically adds a range of items to the map.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> TryAddRange (IEnumerable<Tuple<K, V>> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> TryAddRange (IEnumerable<(K Key, V Value)> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> TryAddRange (IEnumerable<KeyValuePair<K, V>> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.
Null is not allowed for a Key or a Value
param | range | Range of KeyValuePairs to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> AddOrUpdateRange (IEnumerable<Tuple<K, V>> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> AddOrUpdateRange (IEnumerable<(K Key, V Value)> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> AddOrUpdateRange (IEnumerable<KeyValuePair<K, V>> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.
Null is not allowed for a Key or a Value
param | range | Range of KeyValuePairs to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> Remove (K key) Source #
Atomically removes an item from the map If the key doesn't exists, the request is ignored.
param | key | Key |
returns | New map with the item removed |
method Option<V> Find (K key) Source #
Retrieve a value from the map by key
param | key | Key to find |
returns | Found value |
method IEnumerable<V> FindSeq (K key) Source #
Retrieve a value from the map by key as an enumerable
param | key | Key to find |
returns | Found value |
method R Find <R> (K key, Func<V, R> Some, Func<R> None) Source #
Retrieve a value from the map by key and pattern match the result.
param | key | Key to find |
returns | Found value |
method (TrackingHashMap<K, V> Map, V Value) FindOrAdd (K key, Func<V> None) Source #
Try to find the key in the map, if it doesn't exist, add a new item by invoking the delegate provided.
param | key | Key to find |
param | None | Delegate to get the value |
returns | Updated map and added value |
method (TrackingHashMap<K, V>, V Value) FindOrAdd (K key, V value) Source #
Try to find the key in the map, if it doesn't exist, add a new item provided.
param | key | Key to find |
param | value | Delegate to get the value |
returns | Updated map and added value |
method (TrackingHashMap<K, V> Map, Option<V> Value) FindOrMaybeAdd (K key, Func<Option<V>> None) Source #
Try to find the key in the map, if it doesn't exist, add a new item by invoking the delegate provided.
param | key | Key to find |
param | None | Delegate to get the value |
returns | Updated map and added value |
method (TrackingHashMap<K, V> Map, Option<V> Value) FindOrMaybeAdd (K key, Option<V> None) Source #
Try to find the key in the map, if it doesn't exist, add a new item by invoking the delegate provided.
param | key | Key to find |
param | None | Delegate to get the value |
returns | Updated map and added value |
method TrackingHashMap<K, V> SetItem (K key, V value) Source #
Atomically updates an existing item
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<K, V> SetItem (K key, Func<V, V> Some) Source #
Retrieve a value from the map by key, map it to a new value, put it back.
param | key | Key to set |
returns | New map with the mapped value |
method TrackingHashMap<K, V> TrySetItem (K key, V value) Source #
Atomically updates an existing item, unless it doesn't exist, in which case it is ignored
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<K, V> TrySetItem (K key, Func<V, V> Some) Source #
Atomically sets an item by first retrieving it, applying a map, and then putting it back. Silently fails if the value doesn't exist
param | key | Key to set |
param | Some | delegate to map the existing value to a new one before setting |
returns | New map with the item set |
method bool ContainsKey (K key) Source #
Checks for existence of a key in the map
param | key | Key to check |
returns | True if an item with the key supplied is in the map |
method bool Contains (K key, V value) Source #
Checks for existence of a key in the map
param | key | Key to check |
returns | True if an item with the key supplied is in the map |
method bool Contains (V value) Source #
Checks for existence of a value in the map
param | value | Value to check |
returns | True if an item with the value supplied is in the map |
method bool Contains <EqV> (V value) Source #
Checks for existence of a value in the map
param | value | Value to check |
returns | True if an item with the value supplied is in the map |
method bool Contains <EqV> (K key, V value) Source #
Checks for existence of a key in the map
param | key | Key to check |
returns | True if an item with the key supplied is in the map |
method TrackingHashMap<K, V> Clear () Source #
Clears all items from the map
Functionally equivalent to calling Map.empty as the original structure is untouched
returns | Empty map |
method TrackingHashMap<K, V> AddRange (IEnumerable<KeyValuePair<K, V>> pairs) Source #
Atomically adds a range of items to the map
param | pairs | Range of KeyValuePairs to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> SetItems (IEnumerable<KeyValuePair<K, V>> items) Source #
Atomically sets a series of items using the KeyValuePairs provided
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<K, V> SetItems (IEnumerable<Tuple<K, V>> items) Source #
Atomically sets a series of items using the Tuples provided.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<K, V> SetItems (IEnumerable<(K Key, V Value)> items) Source #
Atomically sets a series of items using the Tuples provided.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<K, V> TrySetItems (IEnumerable<KeyValuePair<K, V>> items) Source #
Atomically sets a series of items using the KeyValuePairs provided. If any of the items don't exist then they're silently ignored.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<K, V> TrySetItems (IEnumerable<Tuple<K, V>> items) Source #
Atomically sets a series of items using the Tuples provided If any of the items don't exist then they're silently ignored.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<K, V> TrySetItems (IEnumerable<(K Key, V Value)> items) Source #
Atomically sets a series of items using the Tuples provided If any of the items don't exist then they're silently ignored.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<K, V> TrySetItems (IEnumerable<K> keys, Func<V, V> Some) Source #
Atomically sets a series of items using the keys provided to find the items and the Some delegate maps to a new value. If the items don't exist then they're silently ignored.
param | keys | Keys of items to set |
param | Some | Function map the existing item to a new one |
returns | New map with the items set |
method TrackingHashMap<K, V> RemoveRange (IEnumerable<K> keys) Source #
Atomically removes a set of keys from the map
param | keys | Keys to remove |
returns | New map with the items removed |
method bool Contains (KeyValuePair<K, V> pair) Source #
Returns true if a Key/Value pair exists in the map
param | pair | Pair to find |
returns | True if exists, false otherwise |
method IReadOnlyDictionary<K, V> ToDictionary () Source #
Convert the map to an IDictionary
returns |
method IDictionary<KR, VR> ToDictionary <KR, VR> ( Func<(K Key, V Value), KR> keySelector, Func<(K Key, V Value), VR> valueSelector) Source #
Map the map the a dictionary
method IEnumerator<(K Key, V Value)> GetEnumerator () Source #
GetEnumerator - IEnumerable interface
method string ToString () Source #
Format the collection as [(key: value), (key: value), (key: value), ...]
The elipsis is used for collections over 50 items
To get a formatted string with all the items, use ToFullString
or ToFullArrayString
.
method string ToFullString (string separator = ", ") Source #
Format the collection as (key: value), (key: value), (key: value), ...
method string ToFullArrayString (string separator = ", ") Source #
Format the collection as [(key: value), (key: value), (key: value), ...]
method IEnumerable<(K Key, V Value)> AsEnumerable () Source #
method bool IsProperSubsetOf (IEnumerable<(K Key, V Value)> other) Source #
Returns True if 'other' is a proper subset of this set
returns | True if 'other' is a proper subset of this set |
method bool IsProperSubsetOf (IEnumerable<K> other) Source #
Returns True if 'other' is a proper subset of this set
returns | True if 'other' is a proper subset of this set |
method bool IsProperSupersetOf (IEnumerable<(K Key, V Value)> other) Source #
Returns True if 'other' is a proper superset of this set
returns | True if 'other' is a proper superset of this set |
method bool IsProperSupersetOf (IEnumerable<K> other) Source #
Returns True if 'other' is a proper superset of this set
returns | True if 'other' is a proper superset of this set |
method bool IsSubsetOf (IEnumerable<(K Key, V Value)> other) Source #
Returns True if 'other' is a superset of this set
returns | True if 'other' is a superset of this set |
method bool IsSubsetOf (IEnumerable<K> other) Source #
Returns True if 'other' is a superset of this set
returns | True if 'other' is a superset of this set |
method bool IsSubsetOf (TrackingHashMap<K, V> other) Source #
Returns True if 'other' is a superset of this set
returns | True if 'other' is a superset of this set |
method bool IsSupersetOf (IEnumerable<(K Key, V Value)> other) Source #
Returns True if 'other' is a superset of this set
returns | True if 'other' is a superset of this set |
method bool IsSupersetOf (IEnumerable<K> rhs) Source #
Returns True if 'other' is a superset of this set
returns | True if 'other' is a superset of this set |
method TrackingHashMap<K, V> Intersect (IEnumerable<K> rhs) Source #
Returns the elements that are in both this and other
method TrackingHashMap<K, V> Intersect (IEnumerable<(K Key, V Value)> rhs) Source #
Returns the elements that are in both this and other
method TrackingHashMap<K, V> Intersect (IEnumerable<(K Key, V Value)> rhs, WhenMatched<K, V, V, V> Merge) Source #
Returns the elements that are in both this and other
method TrackingHashMap<K, V> Intersect (HashMap<K, V> rhs, WhenMatched<K, V, V, V> Merge) Source #
Returns the elements that are in both this and other
method TrackingHashMap<K, V> Intersect (TrackingHashMap<K, V> rhs, WhenMatched<K, V, V, V> Merge) Source #
Returns the elements that are in both this and other
method bool Overlaps (IEnumerable<(K Key, V Value)> other) Source #
Returns True if other overlaps this set
method TrackingHashMap<K, V> Except (IEnumerable<K> rhs) Source #
Returns this - other. Only the items in this that are not in other will be returned.
method TrackingHashMap<K, V> Except (IEnumerable<(K Key, V Value)> rhs) Source #
Returns this - other. Only the items in this that are not in other will be returned.
method TrackingHashMap<K, V> SymmetricExcept (TrackingHashMap<K, V> rhs) Source #
Only items that are in one set or the other will be returned. If an item is in both, it is dropped.
method TrackingHashMap<K, V> SymmetricExcept (IEnumerable<(K Key, V Value)> rhs) Source #
Only items that are in one set or the other will be returned. If an item is in both, it is dropped.
method TrackingHashMap<K, V> Union (IEnumerable<(K, V)> rhs) Source #
Finds the union of two sets and produces a new set with the results
param | other | Other set to union with |
returns | A set which contains all items from both sets |
method TrackingHashMap<K, V> Union (IEnumerable<(K Key, V Value)> other, WhenMatched<K, V, V, V> Merge) Source #
Union two maps.
The WhenMatched
merge function is called when keys are present in both map to allow resolving to a
sensible value.
method TrackingHashMap<K, V> Union <W> (IEnumerable<(K Key, W Value)> other, WhenMissing<K, W, V> MapRight, WhenMatched<K, V, W, V> Merge) Source #
Union two maps.
The WhenMatched
merge function is called when keys are present in both map to allow resolving to a
sensible value.
The WhenMissing
function is called when there is a key in the right-hand side, but not the left-hand-side.
This allows the V2
value-type to be mapped to the target V
value-type.
method bool Equals (object? obj) Source #
Equality of keys and values with EqDefault<V>
used for values
method bool Equals (TrackingHashMap<K, V> other) Source #
Equality of keys and values with EqDefault<V>
used for values
method bool Equals <EqV> (TrackingHashMap<K, V> other) Source #
Equality of keys and values with EqV
used for values
method bool EqualsKeys (TrackingHashMap<K, V> other) Source #
Equality of keys only
method int GetHashCode () Source #
method TrackingHashMap<K, V> Do (Action<V> f) Source #
Impure iteration of the bound values in the structure
returns | Returns the original unmodified structure |
method TrackingHashMap<K, V> Where (Func<V, bool> pred) Source #
Atomically filter out items that return false when a predicate is applied
param | pred | Predicate |
returns | New map with items filtered |
method TrackingHashMap<K, V> Where (Func<K, V, bool> pred) Source #
Atomically filter out items that return false when a predicate is applied
param | pred | Predicate |
returns | New map with items filtered |
method bool ForAll (Func<K, V, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool ForAll (Func<Tuple<K, V>, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool ForAll (Func<(K Key, V Value), bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool ForAll (Func<KeyValuePair<K, V>, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool ForAll (Func<V, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool Exists (Func<K, V, bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool Exists (Func<Tuple<K, V>, bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool Exists (Func<(K Key, V Value), bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool Exists (Func<KeyValuePair<K, V>, bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool Exists (Func<V, bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method Unit Iter (Action<K, V> action) Source #
Atomically iterate through all key/value pairs in the map (in order) and execute an action on each
param | action | Action to execute |
returns | Unit |
method Unit Iter (Action<V> action) Source #
Atomically iterate through all values in the map (in order) and execute an action on each
param | action | Action to execute |
returns | Unit |
method Unit Iter (Action<Tuple<K, V>> action) Source #
Atomically iterate through all key/value pairs (as tuples) in the map (in order) and execute an action on each
param | action | Action to execute |
returns | Unit |
method Unit Iter (Action<(K Key, V Value)> action) Source #
Atomically iterate through all key/value pairs (as tuples) in the map (in order) and execute an action on each
param | action | Action to execute |
returns | Unit |
method Unit Iter (Action<KeyValuePair<K, V>> action) Source #
Atomically iterate through all key/value pairs in the map (in order) and execute an action on each
param | action | Action to execute |
returns | Unit |
struct TrackingHashMap <EqK, K, V> Source #
Unsorted immutable hash-map that tracks changes.
Changes are accessible via the Changes
property. It is a HashMap
of Change
values from either the initial
empty state of the collection, or since the last call to Snapshot()
.
The fact that the changes are represented as a single-value HashMap
shows that the tracked changes are not an
ever increasing log of changes, but instead a morphism between one previous state of the TrackingHashMap
and
another. Therefore there's at most one morphism for each key, and potentially none.
The morphisms are:
* `EntryAdded`
* `EntryMapped`
* `EntryRemoved`
A new 'zero-changes starting-state' can be created by calling Snapshot()
. Snapshot
creates the first
snapshot (effectively clears the Changes
to zero), and Changes
will collect the difference from this point
to any morphed future-state as collection-transforming operations are performed
type | K | Key type |
type | V | Value |
field TrackingHashMap<EqK, K, V> Empty = new TrackingHashMap<EqK, K,V>(TrieMap<EqK, K, V>.Empty) Source #
constructor TrackingHashMap (IEnumerable<(K Key, V Value)> items) Source #
constructor TrackingHashMap (IEnumerable<(K Key, V Value)> items, bool tryAdd) Source #
method TrackingHashMap<EqK, K, V> Snapshot () Source #
Creates a 'zero change' snapshot. The data does not change!
Useful for creating new starting points for capturing the difference between two snapshots of the
TrackingHashMap
. Snapshot
creates the first snapshot (effectively clears the Changes
to zero), and
Changes
will collect the difference from this point to any morphed future point as collection-
transforming operations are performed
returns | Map with changes zeroed |
method Lens<TrackingHashMap<EqK, K, V>, Option<V>> itemOrNone (K key) Source #
Item or none at index lens
method IReadOnlyDictionary<K, V> ToReadOnlyDictionary () Source #
Get a IReadOnlyDictionary for this map. No mapping is required, so this is very fast.
method TrackingHashMap<EqK, K, V> Filter (Func<V, bool> pred) Source #
Atomically filter out items that return false when a predicate is applied
param | pred | Predicate |
returns | New map with items filtered |
method TrackingHashMap<EqK, K, V> Filter (Func<K, V, bool> pred) Source #
Atomically filter out items that return false when a predicate is applied
param | pred | Predicate |
returns | New map with items filtered |
method TrackingHashMap<EqK, K, V> Add (K key, V value) Source #
Atomically adds a new item to the map
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<EqK, K, V> TryAdd (K key, V value) Source #
Atomically adds a new item to the map. If the key already exists, then the new item is ignored
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<EqK, K, V> AddOrUpdate (K key, V value) Source #
Atomically adds a new item to the map. If the key already exists, the new item replaces it.
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<EqK, K, V> AddOrUpdate (K key, Func<V, V> Some, Func<V> None) Source #
Retrieve a value from the map by key, map it to a new value, put it back. If it doesn't exist, add a new one based on None result.
param | key | Key to find |
returns | New map with the mapped value |
method TrackingHashMap<EqK, K, V> AddOrUpdate (K key, Func<V, V> Some, V None) Source #
Retrieve a value from the map by key, map it to a new value, put it back. If it doesn't exist, add a new one based on None result.
param | key | Key to find |
returns | New map with the mapped value |
method TrackingHashMap<EqK, K, V> AddRange (IEnumerable<Tuple<K, V>> range) Source #
Atomically adds a range of items to the map.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> AddRange (IEnumerable<(K Key, V Value)> range) Source #
Atomically adds a range of items to the map.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> TryAddRange (IEnumerable<Tuple<K, V>> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> TryAddRange (IEnumerable<(K Key, V Value)> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> TryAddRange (IEnumerable<KeyValuePair<K, V>> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.
Null is not allowed for a Key or a Value
param | range | Range of KeyValuePairs to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> AddOrUpdateRange (IEnumerable<Tuple<K, V>> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> AddOrUpdateRange (IEnumerable<(K Key, V Value)> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> AddOrUpdateRange (IEnumerable<KeyValuePair<K, V>> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.
Null is not allowed for a Key or a Value
param | range | Range of KeyValuePairs to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> Remove (K key) Source #
Atomically removes an item from the map If the key doesn't exists, the request is ignored.
param | key | Key |
returns | New map with the item removed |
method Option<V> Find (K key) Source #
Retrieve a value from the map by key
param | key | Key to find |
returns | Found value |
method IEnumerable<V> FindSeq (K key) Source #
Retrieve a value from the map by key as an enumerable
param | key | Key to find |
returns | Found value |
method R Find <R> (K key, Func<V, R> Some, Func<R> None) Source #
Retrieve a value from the map by key and pattern match the result.
param | key | Key to find |
returns | Found value |
method (TrackingHashMap<EqK, K, V> Map, V Value) FindOrAdd (K key, Func<V> None) Source #
Try to find the key in the map, if it doesn't exist, add a new item by invoking the delegate provided.
param | key | Key to find |
param | None | Delegate to get the value |
returns | Updated map and added value |
method (TrackingHashMap<EqK, K, V>, V Value) FindOrAdd (K key, V value) Source #
Try to find the key in the map, if it doesn't exist, add a new item provided.
param | key | Key to find |
param | value | Delegate to get the value |
returns | Updated map and added value |
method (TrackingHashMap<EqK, K, V> Map, Option<V> Value) FindOrMaybeAdd (K key, Func<Option<V>> None) Source #
Try to find the key in the map, if it doesn't exist, add a new item by invoking the delegate provided.
param | key | Key to find |
param | None | Delegate to get the value |
returns | Updated map and added value |
method (TrackingHashMap<EqK, K, V> Map, Option<V> Value) FindOrMaybeAdd (K key, Option<V> None) Source #
Try to find the key in the map, if it doesn't exist, add a new item by invoking the delegate provided.
param | key | Key to find |
param | None | Delegate to get the value |
returns | Updated map and added value |
method TrackingHashMap<EqK, K, V> SetItem (K key, V value) Source #
Atomically updates an existing item
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<EqK, K, V> SetItem (K key, Func<V, V> Some) Source #
Retrieve a value from the map by key, map it to a new value, put it back.
param | key | Key to set |
returns | New map with the mapped value |
method TrackingHashMap<EqK, K, V> TrySetItem (K key, V value) Source #
Atomically updates an existing item, unless it doesn't exist, in which case it is ignored
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<EqK, K, V> TrySetItem (K key, Func<V, V> Some) Source #
Atomically sets an item by first retrieving it, applying a map, and then putting it back. Silently fails if the value doesn't exist
param | key | Key to set |
param | Some | delegate to map the existing value to a new one before setting |
returns | New map with the item set |
method bool ContainsKey (K key) Source #
Checks for existence of a key in the map
param | key | Key to check |
returns | True if an item with the key supplied is in the map |
method bool Contains (K key, V value) Source #
Checks for existence of a key in the map
param | key | Key to check |
returns | True if an item with the key supplied is in the map |
method bool Contains (V value) Source #
Checks for existence of a value in the map
param | value | Value to check |
returns | True if an item with the value supplied is in the map |
method bool Contains <EqV> (V value) Source #
Checks for existence of a value in the map
param | value | Value to check |
returns | True if an item with the value supplied is in the map |
method bool Contains <EqV> (K key, V value) Source #
Checks for existence of a key in the map
param | key | Key to check |
returns | True if an item with the key supplied is in the map |
method TrackingHashMap<EqK, K, V> Clear () Source #
Clears all items from the map
Functionally equivalent to calling Map.empty as the original structure is untouched
returns | Empty map |
method TrackingHashMap<EqK, K, V> AddRange (IEnumerable<KeyValuePair<K, V>> pairs) Source #
Atomically adds a range of items to the map
param | pairs | Range of KeyValuePairs to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> SetItems (IEnumerable<KeyValuePair<K, V>> items) Source #
Atomically sets a series of items using the KeyValuePairs provided
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<EqK, K, V> SetItems (IEnumerable<Tuple<K, V>> items) Source #
Atomically sets a series of items using the Tuples provided.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<EqK, K, V> SetItems (IEnumerable<(K Key, V Value)> items) Source #
Atomically sets a series of items using the Tuples provided.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<EqK, K, V> TrySetItems (IEnumerable<KeyValuePair<K, V>> items) Source #
Atomically sets a series of items using the KeyValuePairs provided. If any of the items don't exist then they're silently ignored.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<EqK, K, V> TrySetItems (IEnumerable<Tuple<K, V>> items) Source #
Atomically sets a series of items using the Tuples provided If any of the items don't exist then they're silently ignored.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<EqK, K, V> TrySetItems (IEnumerable<(K Key, V Value)> items) Source #
Atomically sets a series of items using the Tuples provided If any of the items don't exist then they're silently ignored.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<EqK, K, V> TrySetItems (IEnumerable<K> keys, Func<V, V> Some) Source #
Atomically sets a series of items using the keys provided to find the items and the Some delegate maps to a new value. If the items don't exist then they're silently ignored.
param | keys | Keys of items to set |
param | Some | Function map the existing item to a new one |
returns | New map with the items set |
method TrackingHashMap<EqK, K, V> RemoveRange (IEnumerable<K> keys) Source #
Atomically removes a set of keys from the map
param | keys | Keys to remove |
returns | New map with the items removed |
method bool Contains (KeyValuePair<K, V> pair) Source #
Returns true if a Key/Value pair exists in the map
param | pair | Pair to find |
returns | True if exists, false otherwise |
method IReadOnlyDictionary<K, V> ToDictionary () Source #
Convert the map to an IDictionary
returns |
method IDictionary<KR, VR> ToDictionary <KR, VR> ( Func<(K Key, V Value), KR> keySelector, Func<(K Key, V Value), VR> valueSelector) Source #
Map the map the a dictionary
method IEnumerator<(K Key, V Value)> GetEnumerator () Source #
GetEnumerator - IEnumerable interface
method string ToString () Source #
Format the collection as [(key: value), (key: value), (key: value), ...]
The elipsis is used for collections over 50 items
To get a formatted string with all the items, use ToFullString
or ToFullArrayString
.
method string ToFullString (string separator = ", ") Source #
Format the collection as (key: value), (key: value), (key: value), ...
method string ToFullArrayString (string separator = ", ") Source #
Format the collection as [(key: value), (key: value), (key: value), ...]
method IEnumerable<(K Key, V Value)> AsEnumerable () Source #
method bool IsProperSubsetOf (IEnumerable<(K Key, V Value)> other) Source #
Returns True if 'other' is a proper subset of this set
returns | True if 'other' is a proper subset of this set |
method bool IsProperSubsetOf (IEnumerable<K> other) Source #
Returns True if 'other' is a proper subset of this set
returns | True if 'other' is a proper subset of this set |
method bool IsProperSupersetOf (IEnumerable<(K Key, V Value)> other) Source #
Returns True if 'other' is a proper superset of this set
returns | True if 'other' is a proper superset of this set |
method bool IsProperSupersetOf (IEnumerable<K> other) Source #
Returns True if 'other' is a proper superset of this set
returns | True if 'other' is a proper superset of this set |
method bool IsSubsetOf (IEnumerable<(K Key, V Value)> other) Source #
Returns True if 'other' is a superset of this set
returns | True if 'other' is a superset of this set |
method bool IsSubsetOf (IEnumerable<K> other) Source #
Returns True if 'other' is a superset of this set
returns | True if 'other' is a superset of this set |
method bool IsSubsetOf (TrackingHashMap<EqK, K, V> other) Source #
Returns True if 'other' is a superset of this set
returns | True if 'other' is a superset of this set |
method bool IsSupersetOf (IEnumerable<(K Key, V Value)> other) Source #
Returns True if 'other' is a superset of this set
returns | True if 'other' is a superset of this set |
method bool IsSupersetOf (IEnumerable<K> rhs) Source #
Returns True if 'other' is a superset of this set
returns | True if 'other' is a superset of this set |
method TrackingHashMap<EqK, K, V> Intersect (IEnumerable<K> rhs) Source #
Returns the elements that are in both this and other
method TrackingHashMap<EqK, K, V> Intersect (IEnumerable<(K Key, V Value)> rhs) Source #
Returns the elements that are in both this and other
method TrackingHashMap<EqK, K, V> Intersect (IEnumerable<(K Key, V Value)> rhs, WhenMatched<K, V, V, V> Merge) Source #
Returns the elements that are in both this and other
method TrackingHashMap<EqK, K, V> Intersect (HashMap<EqK, K, V> rhs, WhenMatched<K, V, V, V> Merge) Source #
Returns the elements that are in both this and other
method TrackingHashMap<EqK, K, V> Intersect (TrackingHashMap<EqK, K, V> rhs, WhenMatched<K, V, V, V> Merge) Source #
Returns the elements that are in both this and other
method bool Overlaps (IEnumerable<(K Key, V Value)> other) Source #
Returns True if other overlaps this set
method TrackingHashMap<EqK, K, V> Except (IEnumerable<K> rhs) Source #
Returns this - other. Only the items in this that are not in other will be returned.
method TrackingHashMap<EqK, K, V> Except (IEnumerable<(K Key, V Value)> rhs) Source #
Returns this - other. Only the items in this that are not in other will be returned.
method TrackingHashMap<EqK, K, V> SymmetricExcept (TrackingHashMap<EqK, K, V> rhs) Source #
Only items that are in one set or the other will be returned. If an item is in both, it is dropped.
method TrackingHashMap<EqK, K, V> SymmetricExcept (IEnumerable<(K Key, V Value)> rhs) Source #
Only items that are in one set or the other will be returned. If an item is in both, it is dropped.
method TrackingHashMap<EqK, K, V> Union (IEnumerable<(K, V)> rhs) Source #
Finds the union of two sets and produces a new set with the results
param | other | Other set to union with |
returns | A set which contains all items from both sets |
method TrackingHashMap<EqK, K, V> Union (IEnumerable<(K Key, V Value)> other, WhenMatched<K, V, V, V> Merge) Source #
Union two maps.
The WhenMatched
merge function is called when keys are present in both map to allow resolving to a
sensible value.
method TrackingHashMap<EqK, K, V> Union <W> (IEnumerable<(K Key, W Value)> other, WhenMissing<K, W, V> MapRight, WhenMatched<K, V, W, V> Merge) Source #
Union two maps.
The WhenMatched
merge function is called when keys are present in both map to allow resolving to a
sensible value.
The WhenMissing
function is called when there is a key in the right-hand side, but not the left-hand-side.
This allows the V2
value-type to be mapped to the target V
value-type.
method bool Equals (object? obj) Source #
Equality of keys and values with EqDefault<V>
used for values
method bool Equals (TrackingHashMap<EqK, K, V> other) Source #
Equality of keys and values with EqDefault<V>
used for values
method bool Equals <EqV> (TrackingHashMap<EqK, K, V> other) Source #
Equality of keys and values with EqV
used for values
method bool EqualsKeys (TrackingHashMap<EqK, K, V> other) Source #
Equality of keys only
method int GetHashCode () Source #
method TrackingHashMap<EqK, K, V> Do (Action<V> f) Source #
Impure iteration of the bound values in the structure
returns | Returns the original unmodified structure |
method TrackingHashMap<EqK, K, V> Where (Func<V, bool> pred) Source #
Atomically filter out items that return false when a predicate is applied
param | pred | Predicate |
returns | New map with items filtered |
method TrackingHashMap<EqK, K, V> Where (Func<K, V, bool> pred) Source #
Atomically filter out items that return false when a predicate is applied
param | pred | Predicate |
returns | New map with items filtered |
method bool ForAll (Func<K, V, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool ForAll (Func<Tuple<K, V>, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool ForAll (Func<(K Key, V Value), bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool ForAll (Func<KeyValuePair<K, V>, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool ForAll (Func<V, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool Exists (Func<K, V, bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool Exists (Func<Tuple<K, V>, bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool Exists (Func<(K Key, V Value), bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool Exists (Func<KeyValuePair<K, V>, bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool Exists (Func<V, bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method Unit Iter (Action<K, V> action) Source #
Atomically iterate through all key/value pairs in the map (in order) and execute an action on each
param | action | Action to execute |
returns | Unit |
method Unit Iter (Action<V> action) Source #
Atomically iterate through all values in the map (in order) and execute an action on each
param | action | Action to execute |
returns | Unit |
method Unit Iter (Action<Tuple<K, V>> action) Source #
Atomically iterate through all key/value pairs (as tuples) in the map (in order) and execute an action on each
param | action | Action to execute |
returns | Unit |
method Unit Iter (Action<(K Key, V Value)> action) Source #
Atomically iterate through all key/value pairs (as tuples) in the map (in order) and execute an action on each
param | action | Action to execute |
returns | Unit |
method Unit Iter (Action<KeyValuePair<K, V>> action) Source #
Atomically iterate through all key/value pairs in the map (in order) and execute an action on each
param | action | Action to execute |
returns | Unit |
class TrackingHashMapExtensions Source #
method TrackingHashMap<K, V> ToTrackingHashMap <K, V> (this IEnumerable<(K, V)> items) Source #
Create an immutable tracking hash-map
method TrackingHashMap<K, V> ToTrackingHashMap <K, V> (this IEnumerable<Tuple<K, V>> items) Source #
Create an immutable tracking hash-map
method TrackingHashMap<K, V> ToTrackingHashMap <K, V> (this IEnumerable<KeyValuePair<K, V>> items) Source #
Create an immutable tracking hash-map
method TrackingHashMap<K1, TrackingHashMap<K2, V>> ToTrackingHashMap <K1, K2, V> (this IEnumerable<(K1, K2, V)> items) Source #
Create an immutable tracking hash-map
method TrackingHashMap<K1, TrackingHashMap<K2, V>> ToTrackingHashMap <K1, K2, V> (this IEnumerable<Tuple<K1, K2, V>> items) Source #
Create an immutable tracking hash-map
method TrackingHashMap<K1, TrackingHashMap<K2, TrackingHashMap<K3, V>>> ToTrackingHashMap <K1, K2, K3, V> (this IEnumerable<(K1, K2, K3, V)> items) Source #
Create an immutable tracking hash-map
method TrackingHashMap<K1, TrackingHashMap<K2, TrackingHashMap<K3, V>>> ToTrackingHashMap <K1, K2, K3, V> (this IEnumerable<Tuple<K1, K2, K3, V>> items) Source #
Create an immutable tracking hash-map
method TrackingHashMap<K1, TrackingHashMap<K2, TrackingHashMap<K3, TrackingHashMap<K4, V>>>> ToTrackingHashMap <K1, K2, K3, K4, V> (this IEnumerable<(K1, K2, K3, K4, V)> items) Source #
Create an immutable tracking hash-map
method TrackingHashMap<K1, TrackingHashMap<K2, TrackingHashMap<K3, TrackingHashMap<K4, V>>>> ToTrackingHashMap <K1, K2, K3, K4, V> (this IEnumerable<Tuple<K1, K2, K3, K4, V>> items) Source #
Create an immutable tracking hash-map
method Option<T> Find <A, B, T> (this TrackingHashMap<A, TrackingHashMap<B, T>> self, A outerKey, B innerKey) Source #
method Option<T> Find <A, B, C, T> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, T>>> self, A aKey, B bKey, C cKey) Source #
method R Find <A, B, T, R> (this TrackingHashMap<A, TrackingHashMap<B, T>> self, A outerKey, B innerKey, Func<T, R> Some, Func<R> None) Source #
method R Find <A, B, C, T, R> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, T>>> self, A aKey, B bKey, C cKey, Func<T, R> Some, Func<R> None) Source #
method R Find <A, B, C, D, T, R> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, TrackingHashMap<D, T>>>> self, A aKey, B bKey, C cKey, D dKey, Func<T, R> Some, Func<R> None) Source #
method TrackingHashMap<A, TrackingHashMap<B, T>> AddOrUpdate <A, B, T> (this TrackingHashMap<A, TrackingHashMap<B, T>> self, A outerKey, B innerKey, Func<T, T> Some, Func<T> None) Source #
method TrackingHashMap<A, TrackingHashMap<B, T>> AddOrUpdate <A, B, T> (this TrackingHashMap<A, TrackingHashMap<B, T>> self, A outerKey, B innerKey, T value) Source #
method TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, T>>> AddOrUpdate <A, B, C, T> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, T>>> self, A aKey, B bKey, C cKey, T value) Source #
method TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, T>>> AddOrUpdate <A, B, C, T> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, T>>> self, A aKey, B bKey, C cKey, Func<T, T> Some, Func<T> None) Source #
method TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, TrackingHashMap<D, T>>>> AddOrUpdate <A, B, C, D, T> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, TrackingHashMap<D, T>>>> self, A aKey, B bKey, C cKey, D dKey, T value) Source #
method TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, TrackingHashMap<D, T>>>> AddOrUpdate <A, B, C, D, T> (this TrackingHashMap<A, TrackingHashMap<B, TrackingHashMap<C, TrackingHashMap<D, T>>>> self, A aKey, B bKey, C cKey, D dKey, Func<T, T> Some, Func<T> None) Source #
class TrackingHashMapExtensions Source #
method TrackingHashMap<EqK, K, V> ToTrackingHashMap <EqK, K, V> (this IEnumerable<(K, V)> items) Source #
Create an immutable tracking hash-map
method TrackingHashMap<EqK, K, V> ToTrackingHashMap <EqK, K, V> (this IEnumerable<Tuple<K, V>> items) Source #
Create an immutable tracking hash-map
method TrackingHashMap<EqK, K, V> ToTrackingHashMap <EqK, K, V> (this IEnumerable<KeyValuePair<K, V>> items) Source #
Create an immutable tracking hash-map
class TrackingHashMap Source #
Immutable tracking hash-map module
method TrackingHashMap<K, V> clear <K, V> (TrackingHashMap<K, V> map) Source #
Clears all items from the map
Functionally equivalent to calling Map.empty as the original structure is untouched
param | map | Map to clear |
returns | Empty map |
method TrackingHashMap<K, V> create <K, V> (Tuple<K, V> head, params Tuple<K, V>[] tail) Source #
Creates a new Map seeded with the keyValues provided
method TrackingHashMap<K, V> create <K, V> ((K, V) head, params (K, V)[] tail) Source #
Creates a new Map seeded with the keyValues provided
method TrackingHashMap<K, V> create <K, V> (KeyValuePair<K, V> head, params KeyValuePair<K,V>[] tail) Source #
Creates a new Map seeded with the keyValues provided
method TrackingHashMap<K, V> createRange <K, V> (IEnumerable<Tuple<K, V>> keyValues) Source #
Creates a new Map seeded with the keyValues provided
method TrackingHashMap<K, V> createRange <K, V> (IEnumerable<(K, V)> keyValues) Source #
Creates a new Map seeded with the keyValues provided
method TrackingHashMap<K, V> createRange <K, V> (IEnumerable<KeyValuePair<K, V>> keyValues) Source #
Creates a new Map seeded with the keyValues provided
method TrackingHashMap<K, V> add <K, V> (TrackingHashMap<K, V> map, K key, V value) Source #
Atomically adds a new item to the map
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<K, V> tryAdd <K, V> (TrackingHashMap<K, V> map, K key, V value) Source #
Atomically adds a new item to the map. If the key already exists, then the new item is ignored
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<K, V> addOrUpdate <K, V> (TrackingHashMap<K, V> map, K key, V value) Source #
Atomically adds a new item to the map. If the key already exists, the new item replaces it.
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<K, V> addOrUpdate <K, V> (TrackingHashMap<K, V> map, K key, Func<V, V> Some, Func<V> None) Source #
Retrieve a value from the map by key, map it to a new value, put it back. If it doesn't exist, add a new one based on None result.
param | key | Key to find |
returns | New map with the mapped value |
method TrackingHashMap<K, V> addOrUpdate <K, V> (TrackingHashMap<K, V> map, K key, Func<V, V> Some, V None) Source #
Retrieve a value from the map by key, map it to a new value, put it back. If it doesn't exist, add a new one based on None result.
param | key | Key to find |
returns | New map with the mapped value |
method TrackingHashMap<K, V> addRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<Tuple<K, V>> keyValues) Source #
Atomically adds a range of items to the map.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> addRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<(K, V)> keyValues) Source #
Atomically adds a range of items to the map.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> addRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues) Source #
Atomically adds a range of items to the map.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> tryAddRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<Tuple<K, V>> keyValues) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> tryAddRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<(K, V)> keyValues) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> tryAddRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.
Null is not allowed for a Key or a Value
param | range | Range of KeyValuePairs to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> addOrUpdateRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<Tuple<K, V>> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> addOrUpdateRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<(K, V)> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> addOrUpdateRange <K, V> (TrackingHashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.
Null is not allowed for a Key or a Value
param | range | Range of KeyValuePairs to add |
returns | New Map with the items added |
method TrackingHashMap<K, V> remove <K, V> (TrackingHashMap<K, V> map, K key) Source #
Atomically removes an item from the map If the key doesn't exists, the request is ignored.
param | key | Key |
returns | New map with the item removed |
method bool containsKey <K, V> (TrackingHashMap<K, V> map, K key) Source #
Checks for existence of a key in the map
param | key | Key to check |
returns | True if an item with the key supplied is in the map |
method bool contains <K, V> (TrackingHashMap<K, V> map, KeyValuePair<K, V> kv) Source #
Checks for existence of a key in the map
param | key | Key to check |
returns | True if an item with the key supplied is in the map |
method bool contains <K, V> (TrackingHashMap<K, V> map, Tuple<K, V> kv) Source #
Checks for existence of a key in the map
param | key | Key to check |
returns | True if an item with the key supplied is in the map |
method bool contains <K, V> (TrackingHashMap<K, V> map, (K, V) kv) Source #
Checks for existence of a key in the map
param | key | Key to check |
returns | True if an item with the key supplied is in the map |
method TrackingHashMap<K, V> setItem <K, V> (TrackingHashMap<K, V> map, K key, V value) Source #
Atomically updates an existing item
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<K, V> trySetItem <K, V> (TrackingHashMap<K, V> map, K key, V value) Source #
Atomically updates an existing item, unless it doesn't exist, in which case it is ignored
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<K, V> trySetItem <K, V> (TrackingHashMap<K, V> map, K key, Func<V, V> Some) Source #
Atomically sets an item by first retrieving it, applying a map (Some), and then putting it back. Silently fails if the value doesn't exist.
param | key | Key to set |
param | Some | delegate to map the existing value to a new one before setting |
returns | New map with the item set |
method TrackingHashMap<K, V> setItems <K, V> (TrackingHashMap<K, V> map, IEnumerable<Tuple<K, V>> items) Source #
Atomically sets a series of items using the Tuples provided
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<K, V> setItems <K, V> (TrackingHashMap<K, V> map, IEnumerable<(K, V)> items) Source #
Atomically sets a series of items using the Tuples provided
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<K, V> setItems <K, V> (TrackingHashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> items) Source #
Atomically sets a series of items using the KeyValuePairs provided
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<K, V> trySetItems <K, V> (TrackingHashMap<K, V> map, IEnumerable<Tuple<K, V>> items) Source #
Atomically sets a series of items using the Tuples provided.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<K, V> trySetItems <K, V> (TrackingHashMap<K, V> map, IEnumerable<(K, V)> items) Source #
Atomically sets a series of items using the Tuples provided.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<K, V> trySetItems <K, V> (TrackingHashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> items) Source #
Atomically sets a series of items using the KeyValuePairs provided. If any of the items don't exist then they're silently ignored.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<K, V> trySetItems <K, V> (TrackingHashMap<K, V> map, IEnumerable<K> keys, Func<V, V> Some) Source #
Atomically sets a series of items using the keys provided to find the items and the Some delegate maps to a new value. If the items don't exist then they're silently ignored.
param | keys | Keys of items to set |
param | Some | Function map the existing item to a new one |
returns | New map with the items set |
method Option<V> find <K, V> (TrackingHashMap<K, V> map, K key) Source #
Retrieve a value from the map by key
param | key | Key to find |
returns | Found value |
method IEnumerable<V> findSeq <K, V> (TrackingHashMap<K, V> map, K key) Source #
Retrieve a value from the map by key as an enumerable
param | key | Key to find |
returns | Found value |
method R find <K, V, R> (TrackingHashMap<K, V> map, K key, Func<V, R> Some, Func<R> None) Source #
Retrieve a value from the map by key and pattern match the result.
param | key | Key to find |
returns | Found value |
method TrackingHashMap<K, V> setItem <K, V> (TrackingHashMap<K, V> map, K key, Func<V, V> mapper) Source #
Retrieve a value from the map by key, map it to a new value, put it back.
param | key | Key to find |
returns | New map with the mapped value |
method Unit iter <K, V> (TrackingHashMap<K, V> map, Action<V> action) Source #
Atomically iterate through all key/value pairs in the map (in order) and execute an action on each
param | action | Action to execute |
returns | Unit |
method Unit iter <K, V> (TrackingHashMap<K, V> map, Action<K, V> action) Source #
Atomically iterate through all key/value pairs in the map (in order) and execute an action on each
param | action | Action to execute |
returns | Unit |
method bool forall <K, V> (TrackingHashMap<K, V> map, Func<V, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool forall <K, V> (TrackingHashMap<K, V> map, Func<K, V, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool forall <K, V> (TrackingHashMap<K, V> map, Func<Tuple<K, V>, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool forall <K, V> (TrackingHashMap<K, V> map, Func<(K Key, V Value), bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool forall <K, V> (TrackingHashMap<K, V> map, Func<KeyValuePair<K, V>, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method TrackingHashMap<K, V> filter <K, V> (TrackingHashMap<K, V> map, Func<V, bool> predicate) Source #
Atomically filter out items that return false when a predicate is applied
param | pred | Predicate |
returns | New map with items filtered |
method TrackingHashMap<K, V> filter <K, V> (TrackingHashMap<K, V> map, Func<K, V, bool> predicate) Source #
Atomically filter out items that return false when a predicate is applied
param | pred | Predicate |
returns | New map with items filtered |
method S fold <S, K, V> (TrackingHashMap<K, V> map, S state, Func<S, K, V, S> folder) Source #
Atomically folds all items in the map (in order) using the folder function provided.
type | S | State type |
param | state | Initial state |
param | folder | Fold function |
returns | Folded state |
method S fold <S, K, V> (TrackingHashMap<K, V> map, S state, Func<S, V, S> folder) Source #
Atomically folds all items in the map (in order) using the folder function provided.
type | S | State type |
param | state | Initial state |
param | folder | Fold function |
returns | Folded state |
method bool exists <K, V> (TrackingHashMap<K, V> map, Func<K, V, bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool exists <K, V> (TrackingHashMap<K, V> map, Func<Tuple<K, V>, bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool exists <K, V> (TrackingHashMap<K, V> map, Func<(K Key, V Value), bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
class TrackingHashMap Source #
Immutable tracking hash-map module
method TrackingHashMap<EqK, K, V> clear <EqK, K, V> (TrackingHashMap<EqK, K, V> map) Source #
Clears all items from the map
Functionally equivalent to calling Map.empty as the original structure is untouched
param | map | Map to clear |
returns | Empty map |
method TrackingHashMap<EqK, K, V> empty <EqK, K, V> () Source #
Creates a new empty TrackingHashMap
method TrackingHashMap<EqK, K, V> create <EqK, K, V> () Source #
Creates a new empty TrackingHashMap
method TrackingHashMap<EqK, K, V> create <EqK, K, V> (Tuple<K, V> head, params Tuple<K, V>[] tail) Source #
Creates a new Map seeded with the keyValues provided
method TrackingHashMap<EqK, K, V> create <EqK, K, V> ((K, V) head, params (K, V)[] tail) Source #
Creates a new Map seeded with the keyValues provided
method TrackingHashMap<EqK, K, V> create <EqK, K, V> (KeyValuePair<K, V> head, params KeyValuePair<K,V>[] tail) Source #
Creates a new Map seeded with the keyValues provided
method TrackingHashMap<EqK, K, V> createRange <EqK, K, V> (IEnumerable<Tuple<K, V>> keyValues) Source #
Creates a new Map seeded with the keyValues provided
method TrackingHashMap<EqK, K, V> createRange <EqK, K, V> (IEnumerable<(K, V)> keyValues) Source #
Creates a new Map seeded with the keyValues provided
method TrackingHashMap<EqK, K, V> createRange <EqK, K, V> (IEnumerable<KeyValuePair<K, V>> keyValues) Source #
Creates a new Map seeded with the keyValues provided
method TrackingHashMap<EqK, K, V> add <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, V value) Source #
Atomically adds a new item to the map
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<EqK, K, V> tryAdd <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, V value) Source #
Atomically adds a new item to the map. If the key already exists, then the new item is ignored
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<EqK, K, V> addOrUpdate <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, V value) Source #
Atomically adds a new item to the map. If the key already exists, the new item replaces it.
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<EqK, K, V> addOrUpdate <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, Func<V, V> Some, Func<V> None) Source #
Retrieve a value from the map by key, map it to a new value, put it back. If it doesn't exist, add a new one based on None result.
param | key | Key to find |
returns | New map with the mapped value |
method TrackingHashMap<EqK, K, V> addOrUpdate <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, Func<V, V> Some, V None) Source #
Retrieve a value from the map by key, map it to a new value, put it back. If it doesn't exist, add a new one based on None result.
param | key | Key to find |
returns | New map with the mapped value |
method TrackingHashMap<EqK, K, V> addRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> keyValues) Source #
Atomically adds a range of items to the map.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> addRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<(K, V)> keyValues) Source #
Atomically adds a range of items to the map.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> addRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues) Source #
Atomically adds a range of items to the map.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> tryAddRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> keyValues) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> tryAddRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<(K, V)> keyValues) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.
Null is not allowed for a Key or a Value
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> tryAddRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.
Null is not allowed for a Key or a Value
param | range | Range of KeyValuePairs to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> addOrUpdateRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> addOrUpdateRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<(K, V)> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.
param | range | Range of tuples to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> addOrUpdateRange <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> range) Source #
Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.
Null is not allowed for a Key or a Value
param | range | Range of KeyValuePairs to add |
returns | New Map with the items added |
method TrackingHashMap<EqK, K, V> remove <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key) Source #
Atomically removes an item from the map If the key doesn't exists, the request is ignored.
param | key | Key |
returns | New map with the item removed |
method bool containsKey <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key) Source #
Checks for existence of a key in the map
param | key | Key to check |
returns | True if an item with the key supplied is in the map |
method bool contains <EqK, K, V> (TrackingHashMap<EqK, K, V> map, KeyValuePair<K, V> kv) Source #
Checks for existence of a key in the map
param | key | Key to check |
returns | True if an item with the key supplied is in the map |
method bool contains <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Tuple<K, V> kv) Source #
Checks for existence of a key in the map
param | key | Key to check |
returns | True if an item with the key supplied is in the map |
method bool contains <EqK, K, V> (TrackingHashMap<EqK, K, V> map, (K, V) kv) Source #
Checks for existence of a key in the map
param | key | Key to check |
returns | True if an item with the key supplied is in the map |
method TrackingHashMap<EqK, K, V> setItem <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, V value) Source #
Atomically updates an existing item
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<EqK, K, V> trySetItem <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, V value) Source #
Atomically updates an existing item, unless it doesn't exist, in which case it is ignored
Null is not allowed for a Key or a Value
param | key | Key |
param | value | Value |
returns | New Map with the item added |
method TrackingHashMap<EqK, K, V> trySetItem <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, Func<V, V> Some) Source #
Atomically sets an item by first retrieving it, applying a map (Some), and then putting it back. Silently fails if the value doesn't exist.
param | key | Key to set |
param | Some | delegate to map the existing value to a new one before setting |
returns | New map with the item set |
method TrackingHashMap<EqK, K, V> setItems <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> items) Source #
Atomically sets a series of items using the Tuples provided
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<EqK, K, V> setItems <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<(K, V)> items) Source #
Atomically sets a series of items using the Tuples provided
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<EqK, K, V> setItems <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> items) Source #
Atomically sets a series of items using the KeyValuePairs provided
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<EqK, K, V> trySetItems <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> items) Source #
Atomically sets a series of items using the Tuples provided.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<EqK, K, V> trySetItems <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<(K, V)> items) Source #
Atomically sets a series of items using the Tuples provided.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<EqK, K, V> trySetItems <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> items) Source #
Atomically sets a series of items using the KeyValuePairs provided. If any of the items don't exist then they're silently ignored.
param | items | Items to set |
returns | New map with the items set |
method TrackingHashMap<EqK, K, V> trySetItems <EqK, K, V> (TrackingHashMap<EqK, K, V> map, IEnumerable<K> keys, Func<V, V> Some) Source #
Atomically sets a series of items using the keys provided to find the items and the Some delegate maps to a new value. If the items don't exist then they're silently ignored.
param | keys | Keys of items to set |
param | Some | Function map the existing item to a new one |
returns | New map with the items set |
method Option<V> find <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key) Source #
Retrieve a value from the map by key
param | key | Key to find |
returns | Found value |
method IEnumerable<V> findSeq <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key) Source #
Retrieve a value from the map by key as an enumerable
param | key | Key to find |
returns | Found value |
method R find <EqK, K, V, R> (TrackingHashMap<EqK, K, V> map, K key, Func<V, R> Some, Func<R> None) Source #
Retrieve a value from the map by key and pattern match the result.
param | key | Key to find |
returns | Found value |
method TrackingHashMap<EqK, K, V> setItem <EqK, K, V> (TrackingHashMap<EqK, K, V> map, K key, Func<V, V> mapper) Source #
Retrieve a value from the map by key, map it to a new value, put it back.
param | key | Key to find |
returns | New map with the mapped value |
method Unit iter <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Action<V> action) Source #
Atomically iterate through all key/value pairs in the map (in order) and execute an action on each
param | action | Action to execute |
returns | Unit |
method Unit iter <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Action<K, V> action) Source #
Atomically iterate through all key/value pairs in the map (in order) and execute an action on each
param | action | Action to execute |
returns | Unit |
method bool forall <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<V, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool forall <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<K, V, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool forall <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<Tuple<K, V>, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool forall <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<(K Key, V Value), bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool forall <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<KeyValuePair<K, V>, bool> pred) Source #
Return true if all items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method TrackingHashMap<EqK, K, V> filter <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<V, bool> predicate) Source #
Atomically filter out items that return false when a predicate is applied
param | pred | Predicate |
returns | New map with items filtered |
method TrackingHashMap<EqK, K, V> filter <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<K, V, bool> predicate) Source #
Atomically filter out items that return false when a predicate is applied
param | pred | Predicate |
returns | New map with items filtered |
method int length <EqK, K, T> (TrackingHashMap<EqK, K, T> map) Source #
Number of items in the map
method S fold <EqK, S, K, V> (TrackingHashMap<EqK, K, V> map, S state, Func<S, K, V, S> folder) Source #
Atomically folds all items in the map (in order) using the folder function provided.
type | S | State type |
param | state | Initial state |
param | folder | Fold function |
returns | Folded state |
method S fold <EqK, S, K, V> (TrackingHashMap<EqK, K, V> map, S state, Func<S, V, S> folder) Source #
Atomically folds all items in the map (in order) using the folder function provided.
type | S | State type |
param | state | Initial state |
param | folder | Fold function |
returns | Folded state |
method bool exists <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<K, V, bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool exists <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<Tuple<K, V>, bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool exists <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<(K Key, V Value), bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |
method bool exists <EqK, K, V> (TrackingHashMap<EqK, K, V> map, Func<KeyValuePair<K, V>, bool> pred) Source #
Return true if any items in the map return true when the predicate is applied
param | pred | Predicate |
returns | True if all items in the map return true when the predicate is applied |