Map Class

Immutable map module AVL tree implementation AVL tree is a self-balancing binary search tree. http://en.wikipedia.org/wiki/AVL_tree

DECLARATION
public static partial class Map
NAMESPACE
LanguageExt

Methods

add<K, V>(Map<K, V>, K, V)
SUMMARY

Atomically adds a new item to the map

PARAMETERS
map
Map<K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<K, V> add<K, V>(Map<K, V> map, K key, V value)
RETURNS
Map<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
add<OrdK, K, V>(Map<OrdK, K, V>, K, V)
SUMMARY

Atomically adds a new item to the map

PARAMETERS
map
Map<OrdK, K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<OrdK, K, V> add<OrdK, K, V>(Map<OrdK, K, V> map, K key, V value)
RETURNS
Map<OrdK, K, V>
New Map with the item added
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
ArgumentException
Throws ArgumentException if the key already exists
ArgumentNullException
Throws ArgumentNullException the key or value are null
addOrUpdate<K, V>(Map<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
Map<K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<K, V> addOrUpdate<K, V>(Map<K, V> map, K key, V value)
RETURNS
Map<K, V>
New Map with the item added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the key or value are null
addOrUpdate<K, V>(Map<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
Map<K, V>
key
K
Key to find
Some
Func<V, V>
None
Func<V>
DECLARATION
[Pure]
public static Map<K, V> addOrUpdate<K, V>(Map<K, V> map, K key, Func<V, V> Some, Func<V> None)
RETURNS
Map<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>(Map<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
Map<K, V>
key
K
Key to find
Some
Func<V, V>
None
V
DECLARATION
[Pure]
public static Map<K, V> addOrUpdate<K, V>(Map<K, V> map, K key, Func<V, V> Some, V None)
RETURNS
Map<K, V>
New map with the mapped value
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException if None is null
Exception
Throws Exception if Some returns null
addOrUpdate<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<OrdK, K, V> addOrUpdate<OrdK, K, V>(Map<OrdK, K, V> map, K key, V value)
RETURNS
Map<OrdK, K, V>
New Map with the item added
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the key or value are null
addOrUpdate<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
key
K
Key to find
Some
Func<V, V>
None
Func<V>
DECLARATION
[Pure]
public static Map<OrdK, K, V> addOrUpdate<OrdK, K, V>(Map<OrdK, K, V> map, K key, Func<V, V> Some, Func<V> None)
RETURNS
Map<OrdK, K, V>
New map with the mapped value
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
Exception
Throws Exception if None returns null
Exception
Throws Exception if Some returns null
addOrUpdate<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
key
K
Key to find
Some
Func<V, V>
None
V
DECLARATION
[Pure]
public static Map<OrdK, K, V> addOrUpdate<OrdK, K, V>(Map<OrdK, K, V> map, K key, Func<V, V> Some, V None)
RETURNS
Map<OrdK, K, V>
New map with the mapped value
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException if None is null
Exception
Throws Exception if Some returns null
addOrUpdateRange<K, V>(Map<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
Map<K, V>
range
IEnumerable<Tuple<K, V>>
Range of tuples to add
DECLARATION
[Pure]
public static Map<K, V> addOrUpdateRange<K, V>(Map<K, V> map, IEnumerable<Tuple<K, V>> range)
RETURNS
Map<K, V>
New Map with the items added
addOrUpdateRange<K, V>(Map<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
Map<K, V>
range
IEnumerable<ValueTuple<K, V>>
Range of tuples to add
DECLARATION
[Pure]
public static Map<K, V> addOrUpdateRange<K, V>(Map<K, V> map, IEnumerable<ValueTuple<K, V>> range)
RETURNS
Map<K, V>
New Map with the items added
addOrUpdateRange<K, V>(Map<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
Map<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 Map<K, V> addOrUpdateRange<K, V>(Map<K, V> map, IEnumerable<KeyValuePair<K, V>> range)
RETURNS
Map<K, V>
New Map with the items added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
addOrUpdateRange<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
range
IEnumerable<Tuple<K, V>>
Range of tuples to add
DECLARATION
[Pure]
public static Map<OrdK, K, V> addOrUpdateRange<OrdK, K, V>(Map<OrdK, K, V> map, IEnumerable<Tuple<K, V>> range)
RETURNS
Map<OrdK, K, V>
New Map with the items added
CONSTRAINTS
where OrdK : struct Ord<K>
addOrUpdateRange<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
range
IEnumerable<ValueTuple<K, V>>
Range of tuples to add
DECLARATION
[Pure]
public static Map<OrdK, K, V> addOrUpdateRange<OrdK, K, V>(Map<OrdK, K, V> map, IEnumerable<ValueTuple<K, V>> range)
RETURNS
Map<OrdK, K, V>
New Map with the items added
CONSTRAINTS
where OrdK : struct Ord<K>
addOrUpdateRange<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, 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 Map<OrdK, K, V> addOrUpdateRange<OrdK, K, V>(Map<OrdK, K, V> map, IEnumerable<KeyValuePair<K, V>> range)
RETURNS
Map<OrdK, K, V>
New Map with the items added
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
addRange<K, V>(Map<K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map.

PARAMETERS
map
Map<K, V>
keyValues
IEnumerable<Tuple<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<K, V> addRange<K, V>(Map<K, V> map, IEnumerable<Tuple<K, V>> keyValues)
RETURNS
Map<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>(Map<K, V>, IEnumerable<ValueTuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map.

PARAMETERS
map
Map<K, V>
keyValues
IEnumerable<ValueTuple<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<K, V> addRange<K, V>(Map<K, V> map, IEnumerable<ValueTuple<K, V>> keyValues)
RETURNS
Map<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>(Map<K, V>, IEnumerable<KeyValuePair<K, V>>)
SUMMARY

Atomically adds a range of items to the map.

PARAMETERS
map
Map<K, V>
keyValues
IEnumerable<KeyValuePair<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<K, V> addRange<K, V>(Map<K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues)
RETURNS
Map<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<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically adds a range of items to the map.

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

Atomically adds a range of items to the map.

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

Atomically adds a range of items to the map.

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

Equivalent to map and filter but the filtering is done based on whether the returned Option is Some or None. If the item is None then it's filtered out, if not the the mapped Some value is used.

PARAMETERS
map
Map<K, T>
selector
Func<T, Option<R>>
Predicate
DECLARATION
[Pure]
public static Map<K, R> choose<K, T, R>(Map<K, T> map, Func<T, Option<R>> selector)
RETURNS
Map<K, R>
Filtered map
choose<K, T, R>(Map<K, T>, Func<K, T, Option<R>>)
SUMMARY

Equivalent to map and filter but the filtering is done based on whether the returned Option is Some or None. If the item is None then it's filtered out, if not the the mapped Some value is used.

PARAMETERS
map
Map<K, T>
selector
Func<K, T, Option<R>>
Predicate
DECLARATION
[Pure]
public static Map<K, R> choose<K, T, R>(Map<K, T> map, Func<K, T, Option<R>> selector)
RETURNS
Map<K, R>
Filtered map
choose<OrdK, K, T, R>(Map<OrdK, K, T>, Func<T, Option<R>>)
SUMMARY

Equivalent to map and filter but the filtering is done based on whether the returned Option is Some or None. If the item is None then it's filtered out, if not the the mapped Some value is used.

PARAMETERS
map
Map<OrdK, K, T>
selector
Func<T, Option<R>>
Predicate
DECLARATION
[Pure]
public static Map<OrdK, K, R> choose<OrdK, K, T, R>(Map<OrdK, K, T> map, Func<T, Option<R>> selector)
RETURNS
Map<OrdK, K, R>
Filtered map
CONSTRAINTS
where OrdK : struct Ord<K>
choose<OrdK, K, T, R>(Map<OrdK, K, T>, Func<K, T, Option<R>>)
SUMMARY

Equivalent to map and filter but the filtering is done based on whether the returned Option is Some or None. If the item is None then it's filtered out, if not the the mapped Some value is used.

PARAMETERS
map
Map<OrdK, K, T>
selector
Func<K, T, Option<R>>
Predicate
DECLARATION
[Pure]
public static Map<OrdK, K, R> choose<OrdK, K, T, R>(Map<OrdK, K, T> map, Func<K, T, Option<R>> selector)
RETURNS
Map<OrdK, K, R>
Filtered map
CONSTRAINTS
where OrdK : struct Ord<K>
clear<K, V>(Map<K, V>)
SUMMARY

Clears all items from the map

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

Clears all items from the map

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

Checks for existence of a key in the map

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

Checks for existence of a key in the map

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

Checks for existence of a key in the map

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

Checks for existence of a key in the map

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

Checks for existence of a key in the map

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

Checks for existence of a key in the map

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

Checks for existence of a key in the map

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

Checks for existence of a key in the map

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

Creates a new Map seeded with the keyValues provided

DECLARATION
[Pure]
public static Map<K, V> create<K, V>()
RETURNS
Map<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 Map<K, V> create<K, V>(Tuple<K, V> head, Tuple<K, V> tail)
RETURNS
Map<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 Map<K, V> create<K, V>(KeyValuePair<K, V> head, KeyValuePair<K, V> tail)
RETURNS
Map<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 Map<K, V> create<K, V>(ValueTuple<K, V> head, ValueTuple<K, V> tail)
RETURNS
Map<K, V>
create<OrdK, K, V>()
SUMMARY

Creates a new empty Map

DECLARATION
[Pure]
public static Map<OrdK, K, V> create<OrdK, K, V>()
RETURNS
Map<OrdK, K, V>
CONSTRAINTS
where OrdK : struct Ord<K>
create<OrdK, 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 Map<OrdK, K, V> create<OrdK, K, V>(Tuple<K, V> head, Tuple<K, V> tail)
RETURNS
Map<OrdK, K, V>
CONSTRAINTS
where OrdK : struct Ord<K>
create<OrdK, 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 Map<OrdK, K, V> create<OrdK, K, V>(KeyValuePair<K, V> head, KeyValuePair<K, V> tail)
RETURNS
Map<OrdK, K, V>
CONSTRAINTS
where OrdK : struct Ord<K>
create<OrdK, 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 Map<OrdK, K, V> create<OrdK, K, V>(ValueTuple<K, V> head, ValueTuple<K, V> tail)
RETURNS
Map<OrdK, K, V>
CONSTRAINTS
where OrdK : struct Ord<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 Map<K, V> createRange<K, V>(IEnumerable<Tuple<K, V>> keyValues)
RETURNS
Map<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 Map<K, V> createRange<K, V>(IEnumerable<ValueTuple<K, V>> keyValues)
RETURNS
Map<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 Map<K, V> createRange<K, V>(IEnumerable<KeyValuePair<K, V>> keyValues)
RETURNS
Map<K, V>
createRange<OrdK, 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 Map<OrdK, K, V> createRange<OrdK, K, V>(IEnumerable<Tuple<K, V>> keyValues)
RETURNS
Map<OrdK, K, V>
CONSTRAINTS
where OrdK : struct Ord<K>
createRange<OrdK, 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 Map<OrdK, K, V> createRange<OrdK, K, V>(IEnumerable<ValueTuple<K, V>> keyValues)
RETURNS
Map<OrdK, K, V>
CONSTRAINTS
where OrdK : struct Ord<K>
createRange<OrdK, 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 Map<OrdK, K, V> createRange<OrdK, K, V>(IEnumerable<KeyValuePair<K, V>> keyValues)
RETURNS
Map<OrdK, K, V>
CONSTRAINTS
where OrdK : struct Ord<K>
empty<K, V>()
SUMMARY

Creates a new empty Map

DECLARATION
[Pure]
public static Map<K, V> empty<K, V>()
RETURNS
Map<K, V>
empty<OrdK, K, V>()
SUMMARY

Creates a new empty Map

DECLARATION
[Pure]
public static Map<OrdK, K, V> empty<OrdK, K, V>()
RETURNS
Map<OrdK, K, V>
CONSTRAINTS
where OrdK : struct Ord<K>
except<K, V>(Map<K, V>, Map<K, V>)
SUMMARY

Map differencing based on key. this - other.

PARAMETERS
left
Map<K, V>
right
Map<K, V>
DECLARATION
[Pure]
public static Map<K, V> except<K, V>(Map<K, V> left, Map<K, V> right)
RETURNS
Map<K, V>
except<OrdK, K, V>(Map<OrdK, K, V>, Map<OrdK, K, V>)
SUMMARY

Map differencing based on key. this - other.

PARAMETERS
left
Map<OrdK, K, V>
right
Map<OrdK, K, V>
DECLARATION
[Pure]
public static Map<OrdK, K, V> except<OrdK, K, V>(Map<OrdK, K, V> left, Map<OrdK, K, V> right)
RETURNS
Map<OrdK, K, V>
CONSTRAINTS
where OrdK : struct Ord<K>
exists<K, V>(Map<K, V>, Func<K, V, bool>)
SUMMARY

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

PARAMETERS
map
Map<K, V>
pred
Func<K, V, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<K, V>(Map<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>(Map<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
Map<K, V>
pred
Func<Tuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<K, V>(Map<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>(Map<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
Map<K, V>
pred
Func<ValueTuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<K, V>(Map<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>(Map<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
Map<K, V>
pred
Func<KeyValuePair<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<K, V>(Map<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>(Map<K, V>, Func<V, bool>)
SUMMARY

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

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

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

PARAMETERS
map
Map<OrdK, K, V>
pred
Func<K, V, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<OrdK, K, V>(Map<OrdK, 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 OrdK : struct Ord<K>
exists<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
pred
Func<Tuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<OrdK, K, V>(Map<OrdK, 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 OrdK : struct Ord<K>
exists<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
pred
Func<ValueTuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<OrdK, K, V>(Map<OrdK, 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 OrdK : struct Ord<K>
exists<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
pred
Func<KeyValuePair<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<OrdK, K, V>(Map<OrdK, 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 OrdK : struct Ord<K>
exists<OrdK, K, V>(Map<OrdK, K, V>, Func<V, bool>)
SUMMARY

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

PARAMETERS
map
Map<OrdK, K, V>
pred
Func<V, bool>
Predicate
DECLARATION
[Pure]
public static bool exists<OrdK, K, V>(Map<OrdK, 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 OrdK : struct Ord<K>
filter<K, V>(Map<K, V>, Func<V, bool>)
SUMMARY

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

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

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

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

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

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

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

PARAMETERS
map
Map<OrdK, K, V>
predicate
Func<K, V, bool>
DECLARATION
[Pure]
public static Map<OrdK, K, V> filter<OrdK, K, V>(Map<OrdK, K, V> map, Func<K, V, bool> predicate)
RETURNS
Map<OrdK, K, V>
New map with items filtered
CONSTRAINTS
where OrdK : struct Ord<K>
find<K, V, R>(Map<K, V>, K, Func<V, R>, Func<R>)
SUMMARY

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

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

Retrieve a value from the map by key

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

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

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

Retrieve a value from the map by key

PARAMETERS
map
Map<OrdK, K, V>
key
K
Key to find
DECLARATION
[Pure]
public static Option<V> find<OrdK, K, V>(Map<OrdK, K, V> map, K key)
RETURNS
Option<V>
Found value
CONSTRAINTS
where OrdK : struct Ord<K>
findRange<K, V>(Map<K, V>, K, K)
SUMMARY

Retrieve a range of values

PARAMETERS
map
Map<K, V>
keyFrom
K
Range start (inclusive)
keyTo
K
Range to (inclusive)
DECLARATION
[Pure]
public static IEnumerable<V> findRange<K, V>(Map<K, V> map, K keyFrom, K keyTo)
RETURNS
IEnumerable<V>
Range of values
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keyFrom or keyTo are null
findRange<OrdK, K, V>(Map<OrdK, K, V>, K, K)
SUMMARY

Retrieve a range of values

PARAMETERS
map
Map<OrdK, K, V>
keyFrom
K
Range start (inclusive)
keyTo
K
Range to (inclusive)
DECLARATION
[Pure]
public static IEnumerable<V> findRange<OrdK, K, V>(Map<OrdK, K, V> map, K keyFrom, K keyTo)
RETURNS
IEnumerable<V>
Range of values
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keyFrom or keyTo are null
findSeq<K, V>(Map<K, V>, K)
SUMMARY

Retrieve a value from the map by key as an enumerable

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

Retrieve a value from the map by key as an enumerable

PARAMETERS
map
Map<OrdK, K, V>
key
K
Key to find
DECLARATION
[Pure]
public static IEnumerable<V> findSeq<OrdK, K, V>(Map<OrdK, K, V> map, K key)
RETURNS
IEnumerable<V>
Found value
CONSTRAINTS
where OrdK : struct Ord<K>
fold<OrdK, S, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
state
S
Initial state
folder
Func<S, K, V, S>
Fold function
DECLARATION
[Pure]
public static S fold<OrdK, S, K, V>(Map<OrdK, K, V> map, S state, Func<S, K, V, S> folder)
RETURNS
S
Folded state
CONSTRAINTS
where OrdK : struct Ord<K>
fold<OrdK, S, K, V>(Map<OrdK, K, V>, S, Func<S, V, S>)
SUMMARY

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

PARAMETERS
map
Map<OrdK, K, V>
state
S
Initial state
folder
Func<S, V, S>
Fold function
DECLARATION
[Pure]
public static S fold<OrdK, S, K, V>(Map<OrdK, K, V> map, S state, Func<S, V, S> folder)
RETURNS
S
Folded state
CONSTRAINTS
where OrdK : struct Ord<K>
fold<S, K, V>(Map<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
Map<K, V>
state
S
Initial state
folder
Func<S, K, V, S>
Fold function
DECLARATION
[Pure]
public static S fold<S, K, V>(Map<K, V> map, S state, Func<S, K, V, S> folder)
RETURNS
S
Folded state
fold<S, K, V>(Map<K, V>, S, Func<S, V, S>)
SUMMARY

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

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

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

PARAMETERS
map
Map<K, V>
pred
Func<V, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<K, V>(Map<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>(Map<K, V>, Func<K, V, bool>)
SUMMARY

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

PARAMETERS
map
Map<K, V>
pred
Func<K, V, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<K, V>(Map<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>(Map<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
Map<K, V>
pred
Func<Tuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<K, V>(Map<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>(Map<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
Map<K, V>
pred
Func<ValueTuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<K, V>(Map<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>(Map<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
Map<K, V>
pred
Func<KeyValuePair<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<K, V>(Map<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
forall<OrdK, K, V>(Map<OrdK, K, V>, Func<V, bool>)
SUMMARY

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

PARAMETERS
map
Map<OrdK, K, V>
pred
Func<V, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<OrdK, K, V>(Map<OrdK, 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 OrdK : struct Ord<K>
forall<OrdK, K, V>(Map<OrdK, K, V>, Func<K, V, bool>)
SUMMARY

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

PARAMETERS
map
Map<OrdK, K, V>
pred
Func<K, V, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<OrdK, K, V>(Map<OrdK, 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 OrdK : struct Ord<K>
forall<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
pred
Func<Tuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<OrdK, K, V>(Map<OrdK, 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 OrdK : struct Ord<K>
forall<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
pred
Func<ValueTuple<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<OrdK, K, V>(Map<OrdK, 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 OrdK : struct Ord<K>
forall<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
pred
Func<KeyValuePair<K, V>, bool>
Predicate
DECLARATION
[Pure]
public static bool forall<OrdK, K, V>(Map<OrdK, 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 OrdK : struct Ord<K>
freeze<K, V>(IDictionary<K, V>)
SUMMARY

Convert any IDictionary into an immutable Map K V

PARAMETERS
dict
IDictionary<K, V>
DECLARATION
[Pure]
public static Map<K, V> freeze<K, V>(IDictionary<K, V> dict)
RETURNS
Map<K, V>
Freeze<K, V>(IDictionary<K, V>)
SUMMARY

Convert any IDictionary into an immutable Map K V

PARAMETERS
dict
IDictionary<K, V>
DECLARATION
[Pure]
public static Map<K, V> Freeze<K, V>(this IDictionary<K, V> dict)
RETURNS
Map<K, V>
freeze<OrdK, K, V>(IDictionary<K, V>)
SUMMARY

Convert any IDictionary into an immutable Map K V

PARAMETERS
dict
IDictionary<K, V>
DECLARATION
[Pure]
public static Map<OrdK, K, V> freeze<OrdK, K, V>(IDictionary<K, V> dict)
RETURNS
Map<OrdK, K, V>
CONSTRAINTS
where OrdK : struct Ord<K>
Freeze<OrdK, K, V>(IDictionary<K, V>)
SUMMARY

Convert any IDictionary into an immutable Map K V

PARAMETERS
dict
IDictionary<K, V>
DECLARATION
[Pure]
public static Map<OrdK, K, V> Freeze<OrdK, K, V>(this IDictionary<K, V> dict)
RETURNS
Map<OrdK, K, V>
CONSTRAINTS
where OrdK : struct Ord<K>
intersect<K, A, B, R>(Map<K, A>, Map<K, B>, WhenMatched<K, A, B, R>)
SUMMARY

PARAMETERS
left
Map<K, A>
right
Map<K, B>
merge
WhenMatched<K, A, B, R>
DECLARATION
[Pure]
public static Map<K, R> intersect<K, A, B, R>(Map<K, A> left, Map<K, B> right, WhenMatched<K, A, B, R> merge)
RETURNS
Map<K, R>
intersect<OrdK, K, A, B, R>(Map<OrdK, K, A>, Map<OrdK, K, B>, WhenMatched<K, A, B, R>)
SUMMARY

PARAMETERS
left
Map<OrdK, K, A>
right
Map<OrdK, K, B>
merge
WhenMatched<K, A, B, R>
DECLARATION
[Pure]
public static Map<OrdK, K, R> intersect<OrdK, K, A, B, R>(Map<OrdK, K, A> left, Map<OrdK, K, B> right, WhenMatched<K, A, B, R> merge)
RETURNS
Map<OrdK, K, R>
CONSTRAINTS
where OrdK : struct Ord<K>
iter<K, V>(Map<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
Map<K, V>
action
Action<V>
Action to execute
DECLARATION
public static Unit iter<K, V>(Map<K, V> map, Action<V> action)
iter<K, V>(Map<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
Map<K, V>
action
Action<K, V>
Action to execute
DECLARATION
public static Unit iter<K, V>(Map<K, V> map, Action<K, V> action)
iter<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
action
Action<V>
Action to execute
DECLARATION
public static Unit iter<OrdK, K, V>(Map<OrdK, K, V> map, Action<V> action)
CONSTRAINTS
where OrdK : struct Ord<K>
iter<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
action
Action<K, V>
Action to execute
DECLARATION
public static Unit iter<OrdK, K, V>(Map<OrdK, K, V> map, Action<K, V> action)
CONSTRAINTS
where OrdK : struct Ord<K>
length<K, T>(Map<K, T>)
SUMMARY

Number of items in the map

PARAMETERS
map
Map<K, T>
DECLARATION
[Pure]
public static int length<K, T>(Map<K, T> map)
RETURNS
int
length<OrdK, K, T>(Map<OrdK, K, T>)
SUMMARY

Number of items in the map

PARAMETERS
map
Map<OrdK, K, T>
DECLARATION
[Pure]
public static int length<OrdK, K, T>(Map<OrdK, K, T> map)
RETURNS
int
CONSTRAINTS
where OrdK : struct Ord<K>
map<K, T, U>(Map<K, T>, Func<T, U>)
SUMMARY

Atomically maps the map to a new map

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

Atomically maps the map to a new map

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

Atomically maps the map to a new map

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

Atomically maps the map to a new map

PARAMETERS
map
Map<OrdK, K, T>
f
Func<K, T, U>
DECLARATION
[Pure]
public static Map<OrdK, K, U> map<OrdK, K, T, U>(Map<OrdK, K, T> map, Func<K, T, U> f)
RETURNS
Map<OrdK, K, U>
Mapped items in a new map
CONSTRAINTS
where OrdK : struct Ord<K>
remove<K, V>(Map<K, V>, K)
SUMMARY

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

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

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

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

Atomically updates an existing item

PARAMETERS
map
Map<K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<K, V> setItem<K, V>(Map<K, V> map, K key, V value)
RETURNS
Map<K, V>
New Map with the item added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the key or value are null
setItem<K, V>(Map<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
Map<K, V>
key
K
Key to find
mapper
Func<V, V>
DECLARATION
[Pure]
public static Map<K, V> setItem<K, V>(Map<K, V> map, K key, Func<V, V> mapper)
RETURNS
Map<K, V>
New map with the mapped value
setItem<OrdK, K, V>(Map<OrdK, K, V>, K, V)
SUMMARY

Atomically updates an existing item

PARAMETERS
map
Map<OrdK, K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<OrdK, K, V> setItem<OrdK, K, V>(Map<OrdK, K, V> map, K key, V value)
RETURNS
Map<OrdK, K, V>
New Map with the item added
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the key or value are null
setItem<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
key
K
Key to find
mapper
Func<V, V>
DECLARATION
[Pure]
public static Map<OrdK, K, V> setItem<OrdK, K, V>(Map<OrdK, K, V> map, K key, Func<V, V> mapper)
RETURNS
Map<OrdK, K, V>
New map with the mapped value
CONSTRAINTS
where OrdK : struct Ord<K>
setItems<K, V>(Map<K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically sets a series of items using the Tuples provided

PARAMETERS
map
Map<K, V>
items
IEnumerable<Tuple<K, V>>
Items to set
DECLARATION
[Pure]
public static Map<K, V> setItems<K, V>(Map<K, V> map, IEnumerable<Tuple<K, V>> items)
RETURNS
Map<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>(Map<K, V>, IEnumerable<ValueTuple<K, V>>)
SUMMARY

Atomically sets a series of items using the Tuples provided

PARAMETERS
map
Map<K, V>
items
IEnumerable<ValueTuple<K, V>>
Items to set
DECLARATION
[Pure]
public static Map<K, V> setItems<K, V>(Map<K, V> map, IEnumerable<ValueTuple<K, V>> items)
RETURNS
Map<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>(Map<K, V>, IEnumerable<KeyValuePair<K, V>>)
SUMMARY

Atomically sets a series of items using the KeyValuePairs provided

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

Atomically sets a series of items using the Tuples provided

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

Atomically sets a series of items using the Tuples provided

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

Atomically sets a series of items using the KeyValuePairs provided

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

Skips 'amount' values and returns a new tree without the skipped values.

PARAMETERS
map
Map<K, V>
amount
int
Amount to skip
DECLARATION
[Pure]
public static IEnumerable<ValueTuple<K, V>> skip<K, V>(Map<K, V> map, int amount)
RETURNS
IEnumerable<ValueTuple<K, V>>
Enumerable of map items
skip<OrdK, K, V>(Map<OrdK, K, V>, int)
SUMMARY

Skips 'amount' values and returns a new tree without the skipped values.

PARAMETERS
map
Map<OrdK, K, V>
amount
int
Amount to skip
DECLARATION
[Pure]
public static IEnumerable<ValueTuple<K, V>> skip<OrdK, K, V>(Map<OrdK, K, V> map, int amount)
RETURNS
IEnumerable<ValueTuple<K, V>>
Enumerable of map items
CONSTRAINTS
where OrdK : struct Ord<K>
symmetricExcept<K, V>(Map<K, V>, Map<K, V>)
SUMMARY

Keys that are in both maps are dropped and the remaining items are merged and returned.

PARAMETERS
left
Map<K, V>
right
Map<K, V>
DECLARATION
[Pure]
public static Map<K, V> symmetricExcept<K, V>(Map<K, V> left, Map<K, V> right)
RETURNS
Map<K, V>
symmetricExcept<OrdK, K, V>(Map<OrdK, K, V>, Map<OrdK, K, V>)
SUMMARY

Keys that are in both maps are dropped and the remaining items are merged and returned.

PARAMETERS
left
Map<OrdK, K, V>
right
Map<OrdK, K, V>
DECLARATION
[Pure]
public static Map<OrdK, K, V> symmetricExcept<OrdK, K, V>(Map<OrdK, K, V> left, Map<OrdK, K, V> right)
RETURNS
Map<OrdK, K, V>
CONSTRAINTS
where OrdK : struct Ord<K>
tryAdd<K, V>(Map<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
Map<K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<K, V> tryAdd<K, V>(Map<K, V> map, K key, V value)
RETURNS
Map<K, V>
New Map with the item added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the key or value are null
tryAdd<K, V>(Map<K, V>, K, V, Func<Map<K, V>, V, Map<K, V>>)
SUMMARY

Atomically adds a new item to the map. If the key already exists then the Fail handler is called with the unaltered map and the value already set for the key, it expects a new map returned.

PARAMETERS
map
Map<K, V>
key
K
Key
value
V
Value
Fail
Func<Map<K, V>, V, Map<K, V>>
Delegate to handle failure, you're given the unaltered map and the value already set for the key
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<K, V> tryAdd<K, V>(Map<K, V> map, K key, V value, Func<Map<K, V>, V, Map<K, V>> Fail)
RETURNS
Map<K, V>
New Map with the item added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the key or value are null
tryAdd<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<OrdK, K, V> tryAdd<OrdK, K, V>(Map<OrdK, K, V> map, K key, V value)
RETURNS
Map<OrdK, K, V>
New Map with the item added
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the key or value are null
tryAdd<OrdK, K, V>(Map<OrdK, K, V>, K, V, Func<Map<OrdK, K, V>, V, Map<OrdK, K, V>>)
SUMMARY

Atomically adds a new item to the map. If the key already exists then the Fail handler is called with the unaltered map and the value already set for the key, it expects a new map returned.

PARAMETERS
map
Map<OrdK, K, V>
key
K
Key
value
V
Value
Fail
Func<Map<OrdK, K, V>, V, Map<OrdK, K, V>>
Delegate to handle failure, you're given the unaltered map and the value already set for the key
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<OrdK, K, V> tryAdd<OrdK, K, V>(Map<OrdK, K, V> map, K key, V value, Func<Map<OrdK, K, V>, V, Map<OrdK, K, V>> Fail)
RETURNS
Map<OrdK, K, V>
New Map with the item added
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the key or value are null
tryAddRange<K, V>(Map<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
Map<K, V>
keyValues
IEnumerable<Tuple<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<K, V> tryAddRange<K, V>(Map<K, V> map, IEnumerable<Tuple<K, V>> keyValues)
RETURNS
Map<K, V>
New Map with the items added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
tryAddRange<K, V>(Map<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
Map<K, V>
keyValues
IEnumerable<ValueTuple<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<K, V> tryAddRange<K, V>(Map<K, V> map, IEnumerable<ValueTuple<K, V>> keyValues)
RETURNS
Map<K, V>
New Map with the items added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
tryAddRange<K, V>(Map<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
Map<K, V>
keyValues
IEnumerable<KeyValuePair<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<K, V> tryAddRange<K, V>(Map<K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues)
RETURNS
Map<K, V>
New Map with the items added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
tryAddRange<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
keyValues
IEnumerable<Tuple<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<OrdK, K, V> tryAddRange<OrdK, K, V>(Map<OrdK, K, V> map, IEnumerable<Tuple<K, V>> keyValues)
RETURNS
Map<OrdK, K, V>
New Map with the items added
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
tryAddRange<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
keyValues
IEnumerable<ValueTuple<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<OrdK, K, V> tryAddRange<OrdK, K, V>(Map<OrdK, K, V> map, IEnumerable<ValueTuple<K, V>> keyValues)
RETURNS
Map<OrdK, K, V>
New Map with the items added
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
tryAddRange<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
keyValues
IEnumerable<KeyValuePair<K, V>>
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<OrdK, K, V> tryAddRange<OrdK, K, V>(Map<OrdK, K, V> map, IEnumerable<KeyValuePair<K, V>> keyValues)
RETURNS
Map<OrdK, K, V>
New Map with the items added
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the keys or values are null
trySetItem<K, V>(Map<K, V>, K, V)
SUMMARY

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

PARAMETERS
map
Map<K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<K, V> trySetItem<K, V>(Map<K, V> map, K key, V value)
RETURNS
Map<K, V>
New Map with the item added
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the value is null
trySetItem<K, V>(Map<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
Map<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 Map<K, V> trySetItem<K, V>(Map<K, V> map, K key, Func<V, V> Some)
RETURNS
Map<K, V>
New map with the item set
EXCEPTIONS
Exception
Throws Exception if Some returns null
trySetItem<K, V>(Map<K, V>, K, Func<V, V>, Func<Map<K, V>, Map<K, V>>)
SUMMARY

Atomically sets an item by first retrieving it, applying a map, and then putting it back. Calls the None delegate to return a new map if the item can't be found

PARAMETERS
map
Map<K, V>
key
K
Key
Some
Func<V, V>
delegate to map the existing value to a new one before setting
None
Func<Map<K, V>, Map<K, V>>
delegate to return a new map if the item can't be found
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<K, V> trySetItem<K, V>(Map<K, V> map, K key, Func<V, V> Some, Func<Map<K, V>, Map<K, V>> None)
RETURNS
Map<K, V>
New map with the item set
EXCEPTIONS
Exception
Throws Exception if Some returns null
Exception
Throws Exception if None returns null
trySetItem<OrdK, K, V>(Map<OrdK, K, V>, K, V)
SUMMARY

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

PARAMETERS
map
Map<OrdK, K, V>
key
K
Key
value
V
Value
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<OrdK, K, V> trySetItem<OrdK, K, V>(Map<OrdK, K, V> map, K key, V value)
RETURNS
Map<OrdK, K, V>
New Map with the item added
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
ArgumentNullException
Throws ArgumentNullException the value is null
trySetItem<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, 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 Map<OrdK, K, V> trySetItem<OrdK, K, V>(Map<OrdK, K, V> map, K key, Func<V, V> Some)
RETURNS
Map<OrdK, K, V>
New map with the item set
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
Exception
Throws Exception if Some returns null
trySetItem<OrdK, K, V>(Map<OrdK, K, V>, K, Func<V, V>, Func<Map<K, V>, Map<K, V>>)
SUMMARY

Atomically sets an item by first retrieving it, applying a map, and then putting it back. Calls the None delegate to return a new map if the item can't be found

PARAMETERS
map
Map<OrdK, K, V>
key
K
Key
Some
Func<V, V>
delegate to map the existing value to a new one before setting
None
Func<Map<K, V>, Map<K, V>>
delegate to return a new map if the item can't be found
REMARKS
Null is not allowed for a Key or a Value
DECLARATION
[Pure]
public static Map<OrdK, K, V> trySetItem<OrdK, K, V>(Map<OrdK, K, V> map, K key, Func<V, V> Some, Func<Map<K, V>, Map<K, V>> None)
RETURNS
Map<OrdK, K, V>
New map with the item set
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
Exception
Throws Exception if Some returns null
Exception
Throws Exception if None returns null
trySetItems<K, V>(Map<K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically sets a series of items using the Tuples provided.

PARAMETERS
map
Map<K, V>
items
IEnumerable<Tuple<K, V>>
Items to set
DECLARATION
[Pure]
public static Map<K, V> trySetItems<K, V>(Map<K, V> map, IEnumerable<Tuple<K, V>> items)
RETURNS
Map<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>(Map<K, V>, IEnumerable<ValueTuple<K, V>>)
SUMMARY

Atomically sets a series of items using the Tuples provided.

PARAMETERS
map
Map<K, V>
items
IEnumerable<ValueTuple<K, V>>
Items to set
DECLARATION
[Pure]
public static Map<K, V> trySetItems<K, V>(Map<K, V> map, IEnumerable<ValueTuple<K, V>> items)
RETURNS
Map<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>(Map<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
Map<K, V>
items
IEnumerable<KeyValuePair<K, V>>
Items to set
DECLARATION
[Pure]
public static Map<K, V> trySetItems<K, V>(Map<K, V> map, IEnumerable<KeyValuePair<K, V>> items)
RETURNS
Map<K, V>
New map with the items set
trySetItems<K, V>(Map<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
Map<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 Map<K, V> trySetItems<K, V>(Map<K, V> map, IEnumerable<K> keys, Func<V, V> Some)
RETURNS
Map<K, V>
New map with the items set
trySetItems<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<Tuple<K, V>>)
SUMMARY

Atomically sets a series of items using the Tuples provided.

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

Atomically sets a series of items using the Tuples provided.

PARAMETERS
map
Map<OrdK, K, V>
items
IEnumerable<ValueTuple<K, V>>
Items to set
DECLARATION
[Pure]
public static Map<OrdK, K, V> trySetItems<OrdK, K, V>(Map<OrdK, K, V> map, IEnumerable<ValueTuple<K, V>> items)
RETURNS
Map<OrdK, K, V>
New map with the items set
CONSTRAINTS
where OrdK : struct Ord<K>
EXCEPTIONS
ArgumentException
Throws ArgumentException if any of the keys aren't in the map
trySetItems<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, K, V>
items
IEnumerable<KeyValuePair<K, V>>
Items to set
DECLARATION
[Pure]
public static Map<OrdK, K, V> trySetItems<OrdK, K, V>(Map<OrdK, K, V> map, IEnumerable<KeyValuePair<K, V>> items)
RETURNS
Map<OrdK, K, V>
New map with the items set
CONSTRAINTS
where OrdK : struct Ord<K>
trySetItems<OrdK, K, V>(Map<OrdK, 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
Map<OrdK, 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 Map<OrdK, K, V> trySetItems<OrdK, K, V>(Map<OrdK, K, V> map, IEnumerable<K> keys, Func<V, V> Some)
RETURNS
Map<OrdK, K, V>
New map with the items set
CONSTRAINTS
where OrdK : struct Ord<K>
union<K, A, B, C>(Map<K, A>, Map<K, B>, WhenMissing<K, A, C>, WhenMissing<K, B, C>, WhenMatched<K, A, B, C>)
SUMMARY

Union two maps. The merge function is called keys are present in both map.

PARAMETERS
left
Map<K, A>
right
Map<K, B>
MapLeft
WhenMissing<K, A, C>
MapRight
WhenMissing<K, B, C>
Merge
WhenMatched<K, A, B, C>
DECLARATION
[Pure]
public static Map<K, C> union<K, A, B, C>(Map<K, A> left, Map<K, B> right, WhenMissing<K, A, C> MapLeft, WhenMissing<K, B, C> MapRight, WhenMatched<K, A, B, C> Merge)
RETURNS
Map<K, C>
union<K, A, B>(Map<K, A>, Map<K, B>, WhenMissing<K, B, A>, WhenMatched<K, A, B, A>)
SUMMARY

Union two maps. The merge function is called keys are present in both map.

PARAMETERS
left
Map<K, A>
right
Map<K, B>
MapRight
WhenMissing<K, B, A>
Merge
WhenMatched<K, A, B, A>
DECLARATION
[Pure]
public static Map<K, A> union<K, A, B>(Map<K, A> left, Map<K, B> right, WhenMissing<K, B, A> MapRight, WhenMatched<K, A, B, A> Merge)
RETURNS
Map<K, A>
union<K, A, B>(Map<K, A>, Map<K, B>, WhenMissing<K, A, B>, WhenMatched<K, A, B, B>)
SUMMARY

Union two maps. The merge function is called keys are present in both map.

PARAMETERS
left
Map<K, A>
right
Map<K, B>
MapLeft
WhenMissing<K, A, B>
Merge
WhenMatched<K, A, B, B>
DECLARATION
[Pure]
public static Map<K, B> union<K, A, B>(Map<K, A> left, Map<K, B> right, WhenMissing<K, A, B> MapLeft, WhenMatched<K, A, B, B> Merge)
RETURNS
Map<K, B>
union<K, V>(Map<K, V>, Map<K, V>, WhenMatched<K, V, V, V>)
SUMMARY

Union two maps. The merge function is called keys are present in both map.

PARAMETERS
left
Map<K, V>
right
Map<K, V>
Merge
WhenMatched<K, V, V, V>
DECLARATION
[Pure]
public static Map<K, V> union<K, V>(Map<K, V> left, Map<K, V> right, WhenMatched<K, V, V, V> Merge)
RETURNS
Map<K, V>
union<OrdK, K, A, B, C>(Map<OrdK, K, A>, Map<OrdK, K, B>, WhenMissing<K, A, C>, WhenMissing<K, B, C>, WhenMatched<K, A, B, C>)
SUMMARY

Union two maps. The merge function is called keys are present in both map.

PARAMETERS
left
Map<OrdK, K, A>
right
Map<OrdK, K, B>
MapLeft
WhenMissing<K, A, C>
MapRight
WhenMissing<K, B, C>
Merge
WhenMatched<K, A, B, C>
DECLARATION
[Pure]
public static Map<OrdK, K, C> union<OrdK, K, A, B, C>(Map<OrdK, K, A> left, Map<OrdK, K, B> right, WhenMissing<K, A, C> MapLeft, WhenMissing<K, B, C> MapRight, WhenMatched<K, A, B, C> Merge)
RETURNS
Map<OrdK, K, C>
CONSTRAINTS
where OrdK : struct Ord<K>
union<OrdK, K, A, B>(Map<OrdK, K, A>, Map<OrdK, K, B>, WhenMissing<K, B, A>, WhenMatched<K, A, B, A>)
SUMMARY

Union two maps. The merge function is called keys are present in both map.

PARAMETERS
left
Map<OrdK, K, A>
right
Map<OrdK, K, B>
MapRight
WhenMissing<K, B, A>
Merge
WhenMatched<K, A, B, A>
DECLARATION
[Pure]
public static Map<OrdK, K, A> union<OrdK, K, A, B>(Map<OrdK, K, A> left, Map<OrdK, K, B> right, WhenMissing<K, B, A> MapRight, WhenMatched<K, A, B, A> Merge)
RETURNS
Map<OrdK, K, A>
CONSTRAINTS
where OrdK : struct Ord<K>
union<OrdK, K, A, B>(Map<OrdK, K, A>, Map<OrdK, K, B>, WhenMissing<K, A, B>, WhenMatched<K, A, B, B>)
SUMMARY

Union two maps. The merge function is called keys are present in both map.

PARAMETERS
left
Map<OrdK, K, A>
right
Map<OrdK, K, B>
MapLeft
WhenMissing<K, A, B>
Merge
WhenMatched<K, A, B, B>
DECLARATION
[Pure]
public static Map<OrdK, K, B> union<OrdK, K, A, B>(Map<OrdK, K, A> left, Map<OrdK, K, B> right, WhenMissing<K, A, B> MapLeft, WhenMatched<K, A, B, B> Merge)
RETURNS
Map<OrdK, K, B>
CONSTRAINTS
where OrdK : struct Ord<K>
union<OrdK, K, V>(Map<OrdK, K, V>, Map<OrdK, K, V>, WhenMatched<K, V, V, V>)
SUMMARY

Union two maps. The merge function is called keys are present in both map.

PARAMETERS
left
Map<OrdK, K, V>
right
Map<OrdK, K, V>
Merge
WhenMatched<K, V, V, V>
DECLARATION
[Pure]
public static Map<OrdK, K, V> union<OrdK, K, V>(Map<OrdK, K, V> left, Map<OrdK, K, V> right, WhenMatched<K, V, V, V> Merge)
RETURNS
Map<OrdK, K, V>
CONSTRAINTS
where OrdK : struct Ord<K>