HashMap Class

Immutable hash-map module

DECLARATION
public static partial class HashMap
NAMESPACE
LanguageExt

Methods

add<EqK, K, V>(HashMap<EqK, K, V>, K, V)
SUMMARY

Atomically adds a new item to the map

PARAMETERS
map
HashMap<EqK, K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<EqK, K, V> add<EqK, K, V>(HashMap<EqK, K, V> map, K key, V value)
RETURNS
HashMap<EqK, K, V>
New Map with the item added
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentException
Throws ArgumentException if the key already exists
ArgumentNullException
Throws ArgumentNullException the key or value are null
add<K, V>(HashMap<K, V>, K, V)
SUMMARY

Atomically adds a new item to the map

PARAMETERS
map
HashMap<K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<K, V> add<K, V>(HashMap<K, V> map, K key, V value)
RETURNS
HashMap<K, V>
New Map with the item added
EXCEPTIONS
ArgumentException
Throws ArgumentException if the key already exists
ArgumentNullException
Throws ArgumentNullException the key or value are null
addOrUpdate<EqK, K, V>(HashMap<EqK, K, V>, K, V)
SUMMARY

Atomically adds a new item to the map. If the key already exists, the new item replaces it.

PARAMETERS
map
HashMap<EqK, K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<EqK, K, V> addOrUpdate<EqK, K, V>(HashMap<EqK, K, V> map, K key, V value)
RETURNS
HashMap<EqK, K, V>
New Map with the item added
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the key or value are null
addOrUpdate<EqK, K, V>(HashMap<EqK, K, V>, K, Func<V, V>, Func<V>)
SUMMARY

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.

PARAMETERS
map
HashMap<EqK, K, V>
key
K
Key to find
Some
Func<V, V>
None
Func<V>
DECLARATION
[Pure]
public static HashMap<EqK, K, V> addOrUpdate<EqK, K, V>(HashMap<EqK, K, V> map, K key, Func<V, V> Some, Func<V> None)
RETURNS
HashMap<EqK, K, V>
New map with the mapped value
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
Exception
Throws Exception if None returns null
Exception
Throws Exception if Some returns null
addOrUpdate<EqK, K, V>(HashMap<EqK, K, V>, K, Func<V, V>, V)
SUMMARY

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.

PARAMETERS
map
HashMap<EqK, K, V>
key
K
Key to find
Some
Func<V, V>
None
V
DECLARATION
[Pure]
public static HashMap<EqK, K, V> addOrUpdate<EqK, K, V>(HashMap<EqK, K, V> map, K key, Func<V, V> Some, V None)
RETURNS
HashMap<EqK, K, V>
New map with the mapped value
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException if None is null
Exception
Throws Exception if Some returns null
addOrUpdate<K, V>(HashMap<K, V>, K, V)
SUMMARY

Atomically adds a new item to the map. If the key already exists, the new item replaces it.

PARAMETERS
map
HashMap<K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<K, V> addOrUpdate<K, V>(HashMap<K, V> map, K key, V value)
RETURNS
HashMap<K, V>
New Map with the item added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the key or value are null
addOrUpdate<K, V>(HashMap<K, V>, K, Func<V, V>, Func<V>)
SUMMARY

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.

PARAMETERS
map
HashMap<K, V>
key
K
Key to find
Some
Func<V, V>
None
Func<V>
DECLARATION
[Pure]
public static HashMap<K, V> addOrUpdate<K, V>(HashMap<K, V> map, K key, Func<V, V> Some, Func<V> None)
RETURNS
HashMap<K, V>
New map with the mapped value
EXCEPTIONS
Exception
Throws Exception if None returns null
Exception
Throws Exception if Some returns null
addOrUpdate<K, V>(HashMap<K, V>, K, Func<V, V>, V)
SUMMARY

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.

PARAMETERS
map
HashMap<K, V>
key
K
Key to find
Some
Func<V, V>
None
V
DECLARATION
[Pure]
public static HashMap<K, V> addOrUpdate<K, V>(HashMap<K, V> map, K key, Func<V, V> Some, V None)
RETURNS
HashMap<K, V>
New map with the mapped value
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException if None is null
Exception
Throws Exception if Some returns null
addOrUpdateRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.

PARAMETERS
map
HashMap<EqK, K, V>
range
IEnumerable<Tuple<K, V>>
Range of tuples to add
DECLARATION
[Pure]
public static HashMap<EqK, K, V> addOrUpdateRange<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> range)
RETURNS
HashMap<EqK, K, V>
New Map with the items added
CONSTRAINTS
where EqK : struct Eq<K>
addOrUpdateRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.

PARAMETERS
map
HashMap<EqK, K, V>
range
IEnumerable<ValueTuple<K, V>>
Range of tuples to add
DECLARATION
[Pure]
public static HashMap<EqK, K, V> addOrUpdateRange<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<ValueTuple<K, V>> range)
RETURNS
HashMap<EqK, K, V>
New Map with the items added
CONSTRAINTS
where EqK : struct Eq<K>
addOrUpdateRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
SUMMARY

Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.

PARAMETERS
map
HashMap<EqK, K, V>
range
IEnumerable<KeyValuePair<K, V>>
Range of KeyValuePairs to add
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<EqK, K, V> addOrUpdateRange<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> range)
RETURNS
HashMap<EqK, K, V>
New Map with the items added
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
addOrUpdateRange<K, V>(HashMap<K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.

PARAMETERS
map
HashMap<K, V>
range
IEnumerable<Tuple<K, V>>
Range of tuples to add
DECLARATION
[Pure]
public static HashMap<K, V> addOrUpdateRange<K, V>(HashMap<K, V> map, IEnumerable<Tuple<K, V>> range)
RETURNS
HashMap<K, V>
New Map with the items added
addOrUpdateRange<K, V>(HashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.

PARAMETERS
map
HashMap<K, V>
range
IEnumerable<ValueTuple<K, V>>
Range of tuples to add
DECLARATION
[Pure]
public static HashMap<K, V> addOrUpdateRange<K, V>(HashMap<K, V> map, IEnumerable<ValueTuple<K, V>> range)
RETURNS
HashMap<K, V>
New Map with the items added
addOrUpdateRange<K, V>(HashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
SUMMARY

Atomically adds a range of items to the map. If any of the keys exist already then they're replaced.

PARAMETERS
map
HashMap<K, V>
range
IEnumerable<KeyValuePair<K, V>>
Range of KeyValuePairs to add
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<K, V> addOrUpdateRange<K, V>(HashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> range)
RETURNS
HashMap<K, V>
New Map with the items added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
addRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map.

PARAMETERS
map
HashMap<EqK, K, V>
keyValues
IEnumerable<Tuple<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<EqK, K, V> addRange<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> keyValues)
RETURNS
HashMap<EqK, K, V>
New Map with the items added
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys already exist
ArgumentNullException
Throws ArgumentNullException the keys or values are null
addRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map.

PARAMETERS
map
HashMap<EqK, K, V>
keyValues
IEnumerable<ValueTuple<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<EqK, K, V> addRange<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<ValueTuple<K, V>> keyValues)
RETURNS
HashMap<EqK, K, V>
New Map with the items added
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys already exist
ArgumentNullException
Throws ArgumentNullException the keys or values are null
addRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
SUMMARY

Atomically adds a range of items to the map.

PARAMETERS
map
HashMap<EqK, K, V>
keyValues
IEnumerable<KeyValuePair<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<EqK, K, V> addRange<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues)
RETURNS
HashMap<EqK, K, V>
New Map with the items added
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys already exist
ArgumentNullException
Throws ArgumentNullException the keys or values are null
addRange<K, V>(HashMap<K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map.

PARAMETERS
map
HashMap<K, V>
keyValues
IEnumerable<Tuple<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<K, V> addRange<K, V>(HashMap<K, V> map, IEnumerable<Tuple<K, V>> keyValues)
RETURNS
HashMap<K, V>
New Map with the items added
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys already exist
ArgumentNullException
Throws ArgumentNullException the keys or values are null
addRange<K, V>(HashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map.

PARAMETERS
map
HashMap<K, V>
keyValues
IEnumerable<ValueTuple<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<K, V> addRange<K, V>(HashMap<K, V> map, IEnumerable<ValueTuple<K, V>> keyValues)
RETURNS
HashMap<K, V>
New Map with the items added
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys already exist
ArgumentNullException
Throws ArgumentNullException the keys or values are null
addRange<K, V>(HashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
SUMMARY

Atomically adds a range of items to the map.

PARAMETERS
map
HashMap<K, V>
keyValues
IEnumerable<KeyValuePair<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<K, V> addRange<K, V>(HashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues)
RETURNS
HashMap<K, V>
New Map with the items added
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys already exist
ArgumentNullException
Throws ArgumentNullException the keys or values are null
clear<EqK, K, V>(HashMap<EqK, K, V>)
SUMMARY

Clears all items from the map

PARAMETERS
map
HashMap<EqK, K, V>
Map to clear
REMARKS
Functionally equivalent to calling Map.empty as the original structure is untouched
DECLARATION
[Pure]
public static HashMap<EqK, K, V> clear<EqK, K, V>(HashMap<EqK, K, V> map)
RETURNS
HashMap<EqK, K, V>
Empty map
CONSTRAINTS
where EqK : struct Eq<K>
clear<K, V>(HashMap<K, V>)
SUMMARY

Clears all items from the map

PARAMETERS
map
HashMap<K, V>
Map to clear
REMARKS
Functionally equivalent to calling Map.empty as the original structure is untouched
DECLARATION
[Pure]
public static HashMap<K, V> clear<K, V>(HashMap<K, V> map)
RETURNS
HashMap<K, V>
Empty map
contains<EqK, K, V>(HashMap<EqK, K, V>, KeyValuePair<K, V>)
SUMMARY

Checks for existence of a key in the map

PARAMETERS
map
HashMap<EqK, K, V>
kv
KeyValuePair<K, V>
DECLARATION
[Pure]
public static bool contains<EqK, K, V>(HashMap<EqK, K, V> map, KeyValuePair<K, V> kv)
RETURNS
bool
True if an item with the key supplied is in the map
CONSTRAINTS
where EqK : struct Eq<K>
contains<EqK, K, V>(HashMap<EqK, K, V>, Tuple<K, V>)
SUMMARY

Checks for existence of a key in the map

PARAMETERS
map
HashMap<EqK, K, V>
kv
Tuple<K, V>
DECLARATION
[Pure]
public static bool contains<EqK, K, V>(HashMap<EqK, K, V> map, Tuple<K, V> kv)
RETURNS
bool
True if an item with the key supplied is in the map
CONSTRAINTS
where EqK : struct Eq<K>
contains<EqK, K, V>(HashMap<EqK, K, V>, ValueTuple<K, V>)
SUMMARY

Checks for existence of a key in the map

PARAMETERS
map
HashMap<EqK, K, V>
kv
ValueTuple<K, V>
DECLARATION
[Pure]
public static bool contains<EqK, K, V>(HashMap<EqK, K, V> map, ValueTuple<K, V> kv)
RETURNS
bool
True if an item with the key supplied is in the map
CONSTRAINTS
where EqK : struct Eq<K>
contains<K, V>(HashMap<K, V>, KeyValuePair<K, V>)
SUMMARY

Checks for existence of a key in the map

PARAMETERS
map
HashMap<K, V>
kv
KeyValuePair<K, V>
DECLARATION
[Pure]
public static bool contains<K, V>(HashMap<K, V> map, KeyValuePair<K, V> kv)
RETURNS
bool
True if an item with the key supplied is in the map
contains<K, V>(HashMap<K, V>, Tuple<K, V>)
SUMMARY

Checks for existence of a key in the map

PARAMETERS
map
HashMap<K, V>
kv
Tuple<K, V>
DECLARATION
[Pure]
public static bool contains<K, V>(HashMap<K, V> map, Tuple<K, V> kv)
RETURNS
bool
True if an item with the key supplied is in the map
contains<K, V>(HashMap<K, V>, ValueTuple<K, V>)
SUMMARY

Checks for existence of a key in the map

PARAMETERS
map
HashMap<K, V>
kv
ValueTuple<K, V>
DECLARATION
[Pure]
public static bool contains<K, V>(HashMap<K, V> map, ValueTuple<K, V> kv)
RETURNS
bool
True if an item with the key supplied is in the map
containsKey<EqK, K, V>(HashMap<EqK, K, V>, K)
SUMMARY

Checks for existence of a key in the map

PARAMETERS
map
HashMap<EqK, K, V>
key
K
Key to check
DECLARATION
[Pure]
public static bool containsKey<EqK, K, V>(HashMap<EqK, K, V> map, K key)
RETURNS
bool
True if an item with the key supplied is in the map
CONSTRAINTS
where EqK : struct Eq<K>
containsKey<K, V>(HashMap<K, V>, K)
SUMMARY

Checks for existence of a key in the map

PARAMETERS
map
HashMap<K, V>
key
K
Key to check
DECLARATION
[Pure]
public static bool containsKey<K, V>(HashMap<K, V> map, K key)
RETURNS
bool
True if an item with the key supplied is in the map
create<EqK, K, V>()
SUMMARY

Creates a new empty HashMap

DECLARATION
[Pure]
public static HashMap<EqK, K, V> create<EqK, K, V>()
RETURNS
HashMap<EqK, K, V>
CONSTRAINTS
where EqK : struct Eq<K>
create<EqK, K, V>(Tuple<K, V>, Tuple<K, V>)
SUMMARY

Creates a new Map seeded with the keyValues provided

PARAMETERS
head
Tuple<K, V>
tail
Tuple<K, V>
DECLARATION
[Pure]
public static HashMap<EqK, K, V> create<EqK, K, V>(Tuple<K, V> head, Tuple<K, V> tail)
RETURNS
HashMap<EqK, K, V>
CONSTRAINTS
where EqK : struct Eq<K>
create<EqK, K, V>(ValueTuple<K, V>, ValueTuple<K, V>)
SUMMARY

Creates a new Map seeded with the keyValues provided

PARAMETERS
head
ValueTuple<K, V>
tail
ValueTuple<K, V>
DECLARATION
[Pure]
public static HashMap<EqK, K, V> create<EqK, K, V>(ValueTuple<K, V> head, ValueTuple<K, V> tail)
RETURNS
HashMap<EqK, K, V>
CONSTRAINTS
where EqK : struct Eq<K>
create<EqK, K, V>(KeyValuePair<K, V>, KeyValuePair<K, V>)
SUMMARY

Creates a new Map seeded with the keyValues provided

PARAMETERS
head
KeyValuePair<K, V>
tail
KeyValuePair<K, V>
DECLARATION
[Pure]
public static HashMap<EqK, K, V> create<EqK, K, V>(KeyValuePair<K, V> head, KeyValuePair<K, V> tail)
RETURNS
HashMap<EqK, K, V>
CONSTRAINTS
where EqK : struct Eq<K>
create<K, V>()
SUMMARY

Creates a new empty HashMap

DECLARATION
[Pure]
public static HashMap<K, V> create<K, V>()
RETURNS
HashMap<K, V>
create<K, V>(Tuple<K, V>, Tuple<K, V>)
SUMMARY

Creates a new Map seeded with the keyValues provided

PARAMETERS
head
Tuple<K, V>
tail
Tuple<K, V>
DECLARATION
[Pure]
public static HashMap<K, V> create<K, V>(Tuple<K, V> head, Tuple<K, V> tail)
RETURNS
HashMap<K, V>
create<K, V>(ValueTuple<K, V>, ValueTuple<K, V>)
SUMMARY

Creates a new Map seeded with the keyValues provided

PARAMETERS
head
ValueTuple<K, V>
tail
ValueTuple<K, V>
DECLARATION
[Pure]
public static HashMap<K, V> create<K, V>(ValueTuple<K, V> head, ValueTuple<K, V> tail)
RETURNS
HashMap<K, V>
create<K, V>(KeyValuePair<K, V>, KeyValuePair<K, V>)
SUMMARY

Creates a new Map seeded with the keyValues provided

PARAMETERS
head
KeyValuePair<K, V>
tail
KeyValuePair<K, V>
DECLARATION
[Pure]
public static HashMap<K, V> create<K, V>(KeyValuePair<K, V> head, KeyValuePair<K, V> tail)
RETURNS
HashMap<K, V>
createRange<EqK, K, V>(IEnumerable<Tuple<K, V>>)
SUMMARY

Creates a new Map seeded with the keyValues provided

PARAMETERS
keyValues
IEnumerable<Tuple<K, V>>
DECLARATION
[Pure]
public static HashMap<EqK, K, V> createRange<EqK, K, V>(IEnumerable<Tuple<K, V>> keyValues)
RETURNS
HashMap<EqK, K, V>
CONSTRAINTS
where EqK : struct Eq<K>
createRange<EqK, K, V>(IEnumerable<ValueTuple<K, V>>)
SUMMARY

Creates a new Map seeded with the keyValues provided

PARAMETERS
keyValues
IEnumerable<ValueTuple<K, V>>
DECLARATION
[Pure]
public static HashMap<EqK, K, V> createRange<EqK, K, V>(IEnumerable<ValueTuple<K, V>> keyValues)
RETURNS
HashMap<EqK, K, V>
CONSTRAINTS
where EqK : struct Eq<K>
createRange<EqK, K, V>(IEnumerable<KeyValuePair<K, V>>)
SUMMARY

Creates a new Map seeded with the keyValues provided

PARAMETERS
keyValues
IEnumerable<KeyValuePair<K, V>>
DECLARATION
[Pure]
public static HashMap<EqK, K, V> createRange<EqK, K, V>(IEnumerable<KeyValuePair<K, V>> keyValues)
RETURNS
HashMap<EqK, K, V>
CONSTRAINTS
where EqK : struct Eq<K>
createRange<K, V>(IEnumerable<Tuple<K, V>>)
SUMMARY

Creates a new Map seeded with the keyValues provided

PARAMETERS
keyValues
IEnumerable<Tuple<K, V>>
DECLARATION
[Pure]
public static HashMap<K, V> createRange<K, V>(IEnumerable<Tuple<K, V>> keyValues)
RETURNS
HashMap<K, V>
createRange<K, V>(IEnumerable<ValueTuple<K, V>>)
SUMMARY

Creates a new Map seeded with the keyValues provided

PARAMETERS
keyValues
IEnumerable<ValueTuple<K, V>>
DECLARATION
[Pure]
public static HashMap<K, V> createRange<K, V>(IEnumerable<ValueTuple<K, V>> keyValues)
RETURNS
HashMap<K, V>
createRange<K, V>(IEnumerable<KeyValuePair<K, V>>)
SUMMARY

Creates a new Map seeded with the keyValues provided

PARAMETERS
keyValues
IEnumerable<KeyValuePair<K, V>>
DECLARATION
[Pure]
public static HashMap<K, V> createRange<K, V>(IEnumerable<KeyValuePair<K, V>> keyValues)
RETURNS
HashMap<K, V>
empty<EqK, K, V>()
SUMMARY

Creates a new empty Map

DECLARATION
[Pure]
public static HashMap<EqK, K, V> empty<EqK, K, V>()
RETURNS
HashMap<EqK, K, V>
CONSTRAINTS
where EqK : struct Eq<K>
empty<K, V>()
SUMMARY

Creates a new empty HashMap

DECLARATION
[Pure]
public static HashMap<K, V> empty<K, V>()
RETURNS
HashMap<K, V>
exists<EqK, K, V>(HashMap<EqK, K, V>, Func<K, V, bool>)
SUMMARY

Return true if *any* items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<EqK, K, V>
pred
Func<K, V, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<EqK, K, V>(HashMap<EqK, K, V> map, Func<K, V, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
CONSTRAINTS
where EqK : struct Eq<K>
exists<EqK, K, V>(HashMap<EqK, K, V>, Func<Tuple<K, V>, bool>)
SUMMARY

Return true if *any* items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<EqK, K, V>
pred
Func<Tuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<EqK, K, V>(HashMap<EqK, K, V> map, Func<Tuple<K, V>, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
CONSTRAINTS
where EqK : struct Eq<K>
exists<EqK, K, V>(HashMap<EqK, K, V>, Func<ValueTuple<K, V>, bool>)
SUMMARY

Return true if *any* items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<EqK, K, V>
pred
Func<ValueTuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<EqK, K, V>(HashMap<EqK, K, V> map, Func<ValueTuple<K, V>, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
CONSTRAINTS
where EqK : struct Eq<K>
exists<EqK, K, V>(HashMap<EqK, K, V>, Func<KeyValuePair<K, V>, bool>)
SUMMARY

Return true if *any* items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<EqK, K, V>
pred
Func<KeyValuePair<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<EqK, K, V>(HashMap<EqK, K, V> map, Func<KeyValuePair<K, V>, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
CONSTRAINTS
where EqK : struct Eq<K>
exists<EqK, K, V>(HashMap<EqK, K, V>, Func<V, bool>)
SUMMARY

Return true if *any* items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<EqK, K, V>
pred
Func<V, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<EqK, K, V>(HashMap<EqK, K, V> map, Func<V, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
CONSTRAINTS
where EqK : struct Eq<K>
exists<K, V>(HashMap<K, V>, Func<K, V, bool>)
SUMMARY

Return true if *any* items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<K, V>
pred
Func<K, V, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<K, V>(HashMap<K, V> map, Func<K, V, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
exists<K, V>(HashMap<K, V>, Func<Tuple<K, V>, bool>)
SUMMARY

Return true if *any* items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<K, V>
pred
Func<Tuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<K, V>(HashMap<K, V> map, Func<Tuple<K, V>, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
exists<K, V>(HashMap<K, V>, Func<ValueTuple<K, V>, bool>)
SUMMARY

Return true if *any* items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<K, V>
pred
Func<ValueTuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<K, V>(HashMap<K, V> map, Func<ValueTuple<K, V>, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
exists<K, V>(HashMap<K, V>, Func<KeyValuePair<K, V>, bool>)
SUMMARY

Return true if *any* items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<K, V>
pred
Func<KeyValuePair<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<K, V>(HashMap<K, V> map, Func<KeyValuePair<K, V>, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
exists<K, V>(HashMap<K, V>, Func<V, bool>)
SUMMARY

Return true if *any* items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<K, V>
pred
Func<V, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<K, V>(HashMap<K, V> map, Func<V, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
filter<EqK, K, V>(HashMap<EqK, K, V>, Func<V, bool>)
SUMMARY

Atomically filter out items that return false when a predicate is applied

PARAMETERS
map
HashMap<EqK, K, V>
predicate
Func<V, bool>
DECLARATION
[Pure]
public static HashMap<EqK, K, V> filter<EqK, K, V>(HashMap<EqK, K, V> map, Func<V, bool> predicate)
RETURNS
HashMap<EqK, K, V>
New map with items filtered
CONSTRAINTS
where EqK : struct Eq<K>
filter<EqK, K, V>(HashMap<EqK, K, V>, Func<K, V, bool>)
SUMMARY

Atomically filter out items that return false when a predicate is applied

PARAMETERS
map
HashMap<EqK, K, V>
predicate
Func<K, V, bool>
DECLARATION
[Pure]
public static HashMap<EqK, K, V> filter<EqK, K, V>(HashMap<EqK, K, V> map, Func<K, V, bool> predicate)
RETURNS
HashMap<EqK, K, V>
New map with items filtered
CONSTRAINTS
where EqK : struct Eq<K>
filter<K, V>(HashMap<K, V>, Func<V, bool>)
SUMMARY

Atomically filter out items that return false when a predicate is applied

PARAMETERS
map
HashMap<K, V>
predicate
Func<V, bool>
DECLARATION
[Pure]
public static HashMap<K, V> filter<K, V>(HashMap<K, V> map, Func<V, bool> predicate)
RETURNS
HashMap<K, V>
New map with items filtered
filter<K, V>(HashMap<K, V>, Func<K, V, bool>)
SUMMARY

Atomically filter out items that return false when a predicate is applied

PARAMETERS
map
HashMap<K, V>
predicate
Func<K, V, bool>
DECLARATION
[Pure]
public static HashMap<K, V> filter<K, V>(HashMap<K, V> map, Func<K, V, bool> predicate)
RETURNS
HashMap<K, V>
New map with items filtered
find<EqK, K, V, R>(HashMap<EqK, K, V>, K, Func<V, R>, Func<R>)
SUMMARY

Retrieve a value from the map by key and pattern match the result.

PARAMETERS
map
HashMap<EqK, K, V>
key
K
Key to find
Some
Func<V, R>
None
Func<R>
DECLARATION
[Pure]
public static R find<EqK, K, V, R>(HashMap<EqK, K, V> map, K key, Func<V, R> Some, Func<R> None)
RETURNS
R
Found value
CONSTRAINTS
where EqK : struct Eq<K>
find<EqK, K, V>(HashMap<EqK, K, V>, K)
SUMMARY

Retrieve a value from the map by key

PARAMETERS
map
HashMap<EqK, K, V>
key
K
Key to find
DECLARATION
[Pure]
public static Option<V> find<EqK, K, V>(HashMap<EqK, K, V> map, K key)
RETURNS
Option<V>
Found value
CONSTRAINTS
where EqK : struct Eq<K>
find<K, V, R>(HashMap<K, V>, K, Func<V, R>, Func<R>)
SUMMARY

Retrieve a value from the map by key and pattern match the result.

PARAMETERS
map
HashMap<K, V>
key
K
Key to find
Some
Func<V, R>
None
Func<R>
DECLARATION
[Pure]
public static R find<K, V, R>(HashMap<K, V> map, K key, Func<V, R> Some, Func<R> None)
RETURNS
R
Found value
find<K, V>(HashMap<K, V>, K)
SUMMARY

Retrieve a value from the map by key

PARAMETERS
map
HashMap<K, V>
key
K
Key to find
DECLARATION
[Pure]
public static Option<V> find<K, V>(HashMap<K, V> map, K key)
RETURNS
Option<V>
Found value
findSeq<EqK, K, V>(HashMap<EqK, K, V>, K)
SUMMARY

Retrieve a value from the map by key as an enumerable

PARAMETERS
map
HashMap<EqK, K, V>
key
K
Key to find
DECLARATION
[Pure]
public static IEnumerable<V> findSeq<EqK, K, V>(HashMap<EqK, K, V> map, K key)
RETURNS
IEnumerable<V>
Found value
CONSTRAINTS
where EqK : struct Eq<K>
findSeq<K, V>(HashMap<K, V>, K)
SUMMARY

Retrieve a value from the map by key as an enumerable

PARAMETERS
map
HashMap<K, V>
key
K
Key to find
DECLARATION
[Pure]
public static IEnumerable<V> findSeq<K, V>(HashMap<K, V> map, K key)
RETURNS
IEnumerable<V>
Found value
fold<EqK, S, K, V>(HashMap<EqK, K, V>, S, Func<S, K, V, S>)
SUMMARY

Atomically folds all items in the map (in order) using the folder function provided.

PARAMETERS
map
HashMap<EqK, K, V>
state
S
Initial state
folder
Func<S, K, V, S>
Fold function
DECLARATION
[Pure]
public static S fold<EqK, S, K, V>(HashMap<EqK, K, V> map, S state, Func<S, K, V, S> folder)
RETURNS
S
Folded state
CONSTRAINTS
where EqK : struct Eq<K>
fold<EqK, S, K, V>(HashMap<EqK, K, V>, S, Func<S, V, S>)
SUMMARY

Atomically folds all items in the map (in order) using the folder function provided.

PARAMETERS
map
HashMap<EqK, K, V>
state
S
Initial state
folder
Func<S, V, S>
Fold function
DECLARATION
[Pure]
public static S fold<EqK, S, K, V>(HashMap<EqK, K, V> map, S state, Func<S, V, S> folder)
RETURNS
S
Folded state
CONSTRAINTS
where EqK : struct Eq<K>
fold<S, K, V>(HashMap<K, V>, S, Func<S, K, V, S>)
SUMMARY

Atomically folds all items in the map (in order) using the folder function provided.

PARAMETERS
map
HashMap<K, V>
state
S
Initial state
folder
Func<S, K, V, S>
Fold function
DECLARATION
[Pure]
public static S fold<S, K, V>(HashMap<K, V> map, S state, Func<S, K, V, S> folder)
RETURNS
S
Folded state
fold<S, K, V>(HashMap<K, V>, S, Func<S, V, S>)
SUMMARY

Atomically folds all items in the map (in order) using the folder function provided.

PARAMETERS
map
HashMap<K, V>
state
S
Initial state
folder
Func<S, V, S>
Fold function
DECLARATION
[Pure]
public static S fold<S, K, V>(HashMap<K, V> map, S state, Func<S, V, S> folder)
RETURNS
S
Folded state
forall<EqK, K, V>(HashMap<EqK, K, V>, Func<V, bool>)
SUMMARY

Return true if all items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<EqK, K, V>
pred
Func<V, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<EqK, K, V>(HashMap<EqK, K, V> map, Func<V, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
CONSTRAINTS
where EqK : struct Eq<K>
forall<EqK, K, V>(HashMap<EqK, K, V>, Func<K, V, bool>)
SUMMARY

Return true if all items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<EqK, K, V>
pred
Func<K, V, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<EqK, K, V>(HashMap<EqK, K, V> map, Func<K, V, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
CONSTRAINTS
where EqK : struct Eq<K>
forall<EqK, K, V>(HashMap<EqK, K, V>, Func<Tuple<K, V>, bool>)
SUMMARY

Return true if all items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<EqK, K, V>
pred
Func<Tuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<EqK, K, V>(HashMap<EqK, K, V> map, Func<Tuple<K, V>, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
CONSTRAINTS
where EqK : struct Eq<K>
forall<EqK, K, V>(HashMap<EqK, K, V>, Func<ValueTuple<K, V>, bool>)
SUMMARY

Return true if all items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<EqK, K, V>
pred
Func<ValueTuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<EqK, K, V>(HashMap<EqK, K, V> map, Func<ValueTuple<K, V>, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
CONSTRAINTS
where EqK : struct Eq<K>
forall<EqK, K, V>(HashMap<EqK, K, V>, Func<KeyValuePair<K, V>, bool>)
SUMMARY

Return true if all items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<EqK, K, V>
pred
Func<KeyValuePair<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<EqK, K, V>(HashMap<EqK, K, V> map, Func<KeyValuePair<K, V>, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
CONSTRAINTS
where EqK : struct Eq<K>
forall<K, V>(HashMap<K, V>, Func<V, bool>)
SUMMARY

Return true if all items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<K, V>
pred
Func<V, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<K, V>(HashMap<K, V> map, Func<V, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
forall<K, V>(HashMap<K, V>, Func<K, V, bool>)
SUMMARY

Return true if all items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<K, V>
pred
Func<K, V, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<K, V>(HashMap<K, V> map, Func<K, V, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
forall<K, V>(HashMap<K, V>, Func<Tuple<K, V>, bool>)
SUMMARY

Return true if all items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<K, V>
pred
Func<Tuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<K, V>(HashMap<K, V> map, Func<Tuple<K, V>, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
forall<K, V>(HashMap<K, V>, Func<ValueTuple<K, V>, bool>)
SUMMARY

Return true if all items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<K, V>
pred
Func<ValueTuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<K, V>(HashMap<K, V> map, Func<ValueTuple<K, V>, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
forall<K, V>(HashMap<K, V>, Func<KeyValuePair<K, V>, bool>)
SUMMARY

Return true if all items in the map return true when the predicate is applied

PARAMETERS
map
HashMap<K, V>
pred
Func<KeyValuePair<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<K, V>(HashMap<K, V> map, Func<KeyValuePair<K, V>, bool> pred)
RETURNS
bool
True if all items in the map return true when the predicate is applied
iter<EqK, K, V>(HashMap<EqK, K, V>, Action<V>)
SUMMARY

Atomically iterate through all key/value pairs in the map (in order) and execute an action on each

PARAMETERS
map
HashMap<EqK, K, V>
action
Action<V>
Action to execute
DECLARATION
public static Unit iter<EqK, K, V>(HashMap<EqK, K, V> map, Action<V> action)
CONSTRAINTS
where EqK : struct Eq<K>
iter<EqK, K, V>(HashMap<EqK, K, V>, Action<K, V>)
SUMMARY

Atomically iterate through all key/value pairs in the map (in order) and execute an action on each

PARAMETERS
map
HashMap<EqK, K, V>
action
Action<K, V>
Action to execute
DECLARATION
public static Unit iter<EqK, K, V>(HashMap<EqK, K, V> map, Action<K, V> action)
CONSTRAINTS
where EqK : struct Eq<K>
iter<K, V>(HashMap<K, V>, Action<V>)
SUMMARY

Atomically iterate through all key/value pairs in the map (in order) and execute an action on each

PARAMETERS
map
HashMap<K, V>
action
Action<V>
Action to execute
DECLARATION
public static Unit iter<K, V>(HashMap<K, V> map, Action<V> action)
iter<K, V>(HashMap<K, V>, Action<K, V>)
SUMMARY

Atomically iterate through all key/value pairs in the map (in order) and execute an action on each

PARAMETERS
map
HashMap<K, V>
action
Action<K, V>
Action to execute
DECLARATION
public static Unit iter<K, V>(HashMap<K, V> map, Action<K, V> action)
length<EqK, K, T>(HashMap<EqK, K, T>)
SUMMARY

Number of items in the map

PARAMETERS
map
HashMap<EqK, K, T>
DECLARATION
[Pure]
public static int length<EqK, K, T>(HashMap<EqK, K, T> map)
RETURNS
int
CONSTRAINTS
where EqK : struct Eq<K>
length<K, T>(HashMap<K, T>)
SUMMARY

Number of items in the map

PARAMETERS
map
HashMap<K, T>
DECLARATION
[Pure]
public static int length<K, T>(HashMap<K, T> map)
RETURNS
int
map<EqK, K, T, U>(HashMap<EqK, K, T>, Func<T, U>)
SUMMARY

Atomically maps the map to a new map

PARAMETERS
map
HashMap<EqK, K, T>
f
Func<T, U>
DECLARATION
[Pure]
public static HashMap<EqK, K, U> map<EqK, K, T, U>(HashMap<EqK, K, T> map, Func<T, U> f)
RETURNS
HashMap<EqK, K, U>
Mapped items in a new map
CONSTRAINTS
where EqK : struct Eq<K>
map<EqK, K, T, U>(HashMap<EqK, K, T>, Func<K, T, U>)
SUMMARY

Atomically maps the map to a new map

PARAMETERS
map
HashMap<EqK, K, T>
f
Func<K, T, U>
DECLARATION
[Pure]
public static HashMap<EqK, K, U> map<EqK, K, T, U>(HashMap<EqK, K, T> map, Func<K, T, U> f)
RETURNS
HashMap<EqK, K, U>
Mapped items in a new map
CONSTRAINTS
where EqK : struct Eq<K>
map<K, T, U>(HashMap<K, T>, Func<T, U>)
SUMMARY

Atomically maps the map to a new map

PARAMETERS
map
HashMap<K, T>
f
Func<T, U>
DECLARATION
[Pure]
public static HashMap<K, U> map<K, T, U>(HashMap<K, T> map, Func<T, U> f)
RETURNS
HashMap<K, U>
Mapped items in a new map
map<K, T, U>(HashMap<K, T>, Func<K, T, U>)
SUMMARY

Atomically maps the map to a new map

PARAMETERS
map
HashMap<K, T>
f
Func<K, T, U>
DECLARATION
[Pure]
public static HashMap<K, U> map<K, T, U>(HashMap<K, T> map, Func<K, T, U> f)
RETURNS
HashMap<K, U>
Mapped items in a new map
remove<EqK, K, V>(HashMap<EqK, K, V>, K)
SUMMARY

Atomically removes an item from the map If the key doesn't exists, the request is ignored.

PARAMETERS
map
HashMap<EqK, K, V>
key
K
Key
DECLARATION
[Pure]
public static HashMap<EqK, K, V> remove<EqK, K, V>(HashMap<EqK, K, V> map, K key)
RETURNS
HashMap<EqK, K, V>
New map with the item removed
CONSTRAINTS
where EqK : struct Eq<K>
remove<K, V>(HashMap<K, V>, K)
SUMMARY

Atomically removes an item from the map If the key doesn't exists, the request is ignored.

PARAMETERS
map
HashMap<K, V>
key
K
Key
DECLARATION
[Pure]
public static HashMap<K, V> remove<K, V>(HashMap<K, V> map, K key)
RETURNS
HashMap<K, V>
New map with the item removed
setItem<EqK, K, V>(HashMap<EqK, K, V>, K, V)
SUMMARY

Atomically updates an existing item

PARAMETERS
map
HashMap<EqK, K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<EqK, K, V> setItem<EqK, K, V>(HashMap<EqK, K, V> map, K key, V value)
RETURNS
HashMap<EqK, K, V>
New Map with the item added
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the key or value are null
setItem<EqK, K, V>(HashMap<EqK, K, V>, K, Func<V, V>)
SUMMARY

Retrieve a value from the map by key, map it to a new value, put it back.

PARAMETERS
map
HashMap<EqK, K, V>
key
K
Key to find
mapper
Func<V, V>
DECLARATION
[Pure]
public static HashMap<EqK, K, V> setItem<EqK, K, V>(HashMap<EqK, K, V> map, K key, Func<V, V> mapper)
RETURNS
HashMap<EqK, K, V>
New map with the mapped value
CONSTRAINTS
where EqK : struct Eq<K>
setItem<K, V>(HashMap<K, V>, K, V)
SUMMARY

Atomically updates an existing item

PARAMETERS
map
HashMap<K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<K, V> setItem<K, V>(HashMap<K, V> map, K key, V value)
RETURNS
HashMap<K, V>
New Map with the item added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the key or value are null
setItem<K, V>(HashMap<K, V>, K, Func<V, V>)
SUMMARY

Retrieve a value from the map by key, map it to a new value, put it back.

PARAMETERS
map
HashMap<K, V>
key
K
Key to find
mapper
Func<V, V>
DECLARATION
[Pure]
public static HashMap<K, V> setItem<K, V>(HashMap<K, V> map, K key, Func<V, V> mapper)
RETURNS
HashMap<K, V>
New map with the mapped value
setItems<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically sets a series of items using the Tuples provided

PARAMETERS
map
HashMap<EqK, K, V>
items
IEnumerable<Tuple<K, V>>
Items to set
DECLARATION
[Pure]
public static HashMap<EqK, K, V> setItems<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> items)
RETURNS
HashMap<EqK, K, V>
New map with the items set
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys aren't in the map
setItems<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
SUMMARY

Atomically sets a series of items using the Tuples provided

PARAMETERS
map
HashMap<EqK, K, V>
items
IEnumerable<ValueTuple<K, V>>
Items to set
DECLARATION
[Pure]
public static HashMap<EqK, K, V> setItems<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<ValueTuple<K, V>> items)
RETURNS
HashMap<EqK, K, V>
New map with the items set
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys aren't in the map
setItems<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
SUMMARY

Atomically sets a series of items using the KeyValuePairs provided

PARAMETERS
map
HashMap<EqK, K, V>
items
IEnumerable<KeyValuePair<K, V>>
Items to set
DECLARATION
[Pure]
public static HashMap<EqK, K, V> setItems<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> items)
RETURNS
HashMap<EqK, K, V>
New map with the items set
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys aren't in the map
setItems<K, V>(HashMap<K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically sets a series of items using the Tuples provided

PARAMETERS
map
HashMap<K, V>
items
IEnumerable<Tuple<K, V>>
Items to set
DECLARATION
[Pure]
public static HashMap<K, V> setItems<K, V>(HashMap<K, V> map, IEnumerable<Tuple<K, V>> items)
RETURNS
HashMap<K, V>
New map with the items set
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys aren't in the map
setItems<K, V>(HashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
SUMMARY

Atomically sets a series of items using the Tuples provided

PARAMETERS
map
HashMap<K, V>
items
IEnumerable<ValueTuple<K, V>>
Items to set
DECLARATION
[Pure]
public static HashMap<K, V> setItems<K, V>(HashMap<K, V> map, IEnumerable<ValueTuple<K, V>> items)
RETURNS
HashMap<K, V>
New map with the items set
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys aren't in the map
setItems<K, V>(HashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
SUMMARY

Atomically sets a series of items using the KeyValuePairs provided

PARAMETERS
map
HashMap<K, V>
items
IEnumerable<KeyValuePair<K, V>>
Items to set
DECLARATION
[Pure]
public static HashMap<K, V> setItems<K, V>(HashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> items)
RETURNS
HashMap<K, V>
New map with the items set
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys aren't in the map
tryAdd<EqK, K, V>(HashMap<EqK, K, V>, K, V)
SUMMARY

Atomically adds a new item to the map. If the key already exists, then the new item is ignored

PARAMETERS
map
HashMap<EqK, K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<EqK, K, V> tryAdd<EqK, K, V>(HashMap<EqK, K, V> map, K key, V value)
RETURNS
HashMap<EqK, K, V>
New Map with the item added
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the key or value are null
tryAdd<K, V>(HashMap<K, V>, K, V)
SUMMARY

Atomically adds a new item to the map. If the key already exists, then the new item is ignored

PARAMETERS
map
HashMap<K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<K, V> tryAdd<K, V>(HashMap<K, V> map, K key, V value)
RETURNS
HashMap<K, V>
New Map with the item added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the key or value are null
tryAddRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.

PARAMETERS
map
HashMap<EqK, K, V>
keyValues
IEnumerable<Tuple<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<EqK, K, V> tryAddRange<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> keyValues)
RETURNS
HashMap<EqK, K, V>
New Map with the items added
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
tryAddRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.

PARAMETERS
map
HashMap<EqK, K, V>
keyValues
IEnumerable<ValueTuple<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<EqK, K, V> tryAddRange<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<ValueTuple<K, V>> keyValues)
RETURNS
HashMap<EqK, K, V>
New Map with the items added
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
tryAddRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
SUMMARY

Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.

PARAMETERS
map
HashMap<EqK, K, V>
keyValues
IEnumerable<KeyValuePair<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<EqK, K, V> tryAddRange<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues)
RETURNS
HashMap<EqK, K, V>
New Map with the items added
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
tryAddRange<K, V>(HashMap<K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.

PARAMETERS
map
HashMap<K, V>
keyValues
IEnumerable<Tuple<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<K, V> tryAddRange<K, V>(HashMap<K, V> map, IEnumerable<Tuple<K, V>> keyValues)
RETURNS
HashMap<K, V>
New Map with the items added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
tryAddRange<K, V>(HashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.

PARAMETERS
map
HashMap<K, V>
keyValues
IEnumerable<ValueTuple<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<K, V> tryAddRange<K, V>(HashMap<K, V> map, IEnumerable<ValueTuple<K, V>> keyValues)
RETURNS
HashMap<K, V>
New Map with the items added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
tryAddRange<K, V>(HashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
SUMMARY

Atomically adds a range of items to the map. If any of the keys exist already then they're ignored.

PARAMETERS
map
HashMap<K, V>
keyValues
IEnumerable<KeyValuePair<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<K, V> tryAddRange<K, V>(HashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues)
RETURNS
HashMap<K, V>
New Map with the items added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
trySetItem<EqK, K, V>(HashMap<EqK, K, V>, K, V)
SUMMARY

Atomically updates an existing item, unless it doesn't exist, in which case it is ignored

PARAMETERS
map
HashMap<EqK, K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<EqK, K, V> trySetItem<EqK, K, V>(HashMap<EqK, K, V> map, K key, V value)
RETURNS
HashMap<EqK, K, V>
New Map with the item added
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the value is null
trySetItem<EqK, K, V>(HashMap<EqK, K, V>, K, Func<V, V>)
SUMMARY

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.

PARAMETERS
map
HashMap<EqK, K, V>
key
K
Key to set
Some
Func<V, V>
delegate to map the existing value to a new one before setting
DECLARATION
[Pure]
public static HashMap<EqK, K, V> trySetItem<EqK, K, V>(HashMap<EqK, K, V> map, K key, Func<V, V> Some)
RETURNS
HashMap<EqK, K, V>
New map with the item set
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
Exception
Throws Exception if Some returns null
trySetItem<K, V>(HashMap<K, V>, K, V)
SUMMARY

Atomically updates an existing item, unless it doesn't exist, in which case it is ignored

PARAMETERS
map
HashMap<K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static HashMap<K, V> trySetItem<K, V>(HashMap<K, V> map, K key, V value)
RETURNS
HashMap<K, V>
New Map with the item added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the value is null
trySetItem<K, V>(HashMap<K, V>, K, Func<V, V>)
SUMMARY

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.

PARAMETERS
map
HashMap<K, V>
key
K
Key to set
Some
Func<V, V>
delegate to map the existing value to a new one before setting
DECLARATION
[Pure]
public static HashMap<K, V> trySetItem<K, V>(HashMap<K, V> map, K key, Func<V, V> Some)
RETURNS
HashMap<K, V>
New map with the item set
EXCEPTIONS
Exception
Throws Exception if Some returns null
trySetItems<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically sets a series of items using the Tuples provided.

PARAMETERS
map
HashMap<EqK, K, V>
items
IEnumerable<Tuple<K, V>>
Items to set
DECLARATION
[Pure]
public static HashMap<EqK, K, V> trySetItems<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<Tuple<K, V>> items)
RETURNS
HashMap<EqK, K, V>
New map with the items set
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys aren't in the map
trySetItems<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
SUMMARY

Atomically sets a series of items using the Tuples provided.

PARAMETERS
map
HashMap<EqK, K, V>
items
IEnumerable<ValueTuple<K, V>>
Items to set
DECLARATION
[Pure]
public static HashMap<EqK, K, V> trySetItems<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<ValueTuple<K, V>> items)
RETURNS
HashMap<EqK, K, V>
New map with the items set
CONSTRAINTS
where EqK : struct Eq<K>
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys aren't in the map
trySetItems<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
SUMMARY

Atomically sets a series of items using the KeyValuePairs provided. If any of the items don't exist then they're silently ignored.

PARAMETERS
map
HashMap<EqK, K, V>
items
IEnumerable<KeyValuePair<K, V>>
Items to set
DECLARATION
[Pure]
public static HashMap<EqK, K, V> trySetItems<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<KeyValuePair<K, V>> items)
RETURNS
HashMap<EqK, K, V>
New map with the items set
CONSTRAINTS
where EqK : struct Eq<K>
trySetItems<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<K>, Func<V, V>)
SUMMARY

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.

PARAMETERS
map
HashMap<EqK, K, V>
keys
IEnumerable<K>
Keys of items to set
Some
Func<V, V>
Function map the existing item to a new one
DECLARATION
[Pure]
public static HashMap<EqK, K, V> trySetItems<EqK, K, V>(HashMap<EqK, K, V> map, IEnumerable<K> keys, Func<V, V> Some)
RETURNS
HashMap<EqK, K, V>
New map with the items set
CONSTRAINTS
where EqK : struct Eq<K>
trySetItems<K, V>(HashMap<K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically sets a series of items using the Tuples provided.

PARAMETERS
map
HashMap<K, V>
items
IEnumerable<Tuple<K, V>>
Items to set
DECLARATION
[Pure]
public static HashMap<K, V> trySetItems<K, V>(HashMap<K, V> map, IEnumerable<Tuple<K, V>> items)
RETURNS
HashMap<K, V>
New map with the items set
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys aren't in the map
trySetItems<K, V>(HashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
SUMMARY

Atomically sets a series of items using the Tuples provided.

PARAMETERS
map
HashMap<K, V>
items
IEnumerable<ValueTuple<K, V>>
Items to set
DECLARATION
[Pure]
public static HashMap<K, V> trySetItems<K, V>(HashMap<K, V> map, IEnumerable<ValueTuple<K, V>> items)
RETURNS
HashMap<K, V>
New map with the items set
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys aren't in the map
trySetItems<K, V>(HashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
SUMMARY

Atomically sets a series of items using the KeyValuePairs provided. If any of the items don't exist then they're silently ignored.

PARAMETERS
map
HashMap<K, V>
items
IEnumerable<KeyValuePair<K, V>>
Items to set
DECLARATION
[Pure]
public static HashMap<K, V> trySetItems<K, V>(HashMap<K, V> map, IEnumerable<KeyValuePair<K, V>> items)
RETURNS
HashMap<K, V>
New map with the items set
trySetItems<K, V>(HashMap<K, V>, IEnumerable<K>, Func<V, V>)
SUMMARY

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.

PARAMETERS
map
HashMap<K, V>
keys
IEnumerable<K>
Keys of items to set
Some
Func<V, V>
Function map the existing item to a new one
DECLARATION
[Pure]
public static HashMap<K, V> trySetItems<K, V>(HashMap<K, V> map, IEnumerable<K> keys, Func<V, V> Some)
RETURNS
HashMap<K, V>
New map with the items set