Map<'Key, 'Value, 'ComparerTag> (fantomas)

Map<'Key, 'Value, 'ComparerTag> Type

Namespace: Internal.Utilities.Collections.Tagged
Assembly: Fantomas.FCS.dll
Base Type: obj
All Interfaces: IComparable , IEnumerable<KeyValuePair<'Key, 'Value>> , IEnumerable

 Immutable maps.  Keys are ordered by construction function specified
 when creating empty maps or by F# structural comparison if no
 construction function is specified.

  
   Maps based on structural comparison are  
   efficient for small keys. They are not a suitable choice if keys are recursive data structures 
   or require non-structural comparison semantics.
 
 Immutable maps.  A constraint tag carries information about the class of key-comparers being used.

Instance members

Instance member	Description
`this.Add` Full Usage: `this.Add` Parameters: arg0 : `'Key` arg1 : `'Value` Returns: `Map<'Key, 'Value, 'ComparerTag>`	Return a new map with the binding added to the given map. arg0 : `'Key` arg1 : `'Value` Returns: `Map<'Key, 'Value, 'ComparerTag>`
`this.ContainsKey` Full Usage: `this.ContainsKey` Parameters: arg0 : `'Key` Returns: `bool`	Test is an element is in the domain of the map. arg0 : `'Key` Returns: `bool`
`this.Count` Full Usage: `this.Count` Returns: `int`	The number of bindings in the map. Returns: `int`
`this.Exists` Full Usage: `this.Exists` Parameters: arg0 : `'Key -> 'Value -> bool` Returns: `bool`	Return True if the given predicate returns true for one of the bindings in the map. Always returns false if the map is empty. arg0 : `'Key -> 'Value -> bool` Returns: `bool`
`this.Filter` Full Usage: `this.Filter` Parameters: arg0 : `'Key -> 'Value -> bool` Returns: `Map<'Key, 'Value, 'ComparerTag>`	Build a new map containing the bindings for which the given predicate returns True. arg0 : `'Key -> 'Value -> bool` Returns: `Map<'Key, 'Value, 'ComparerTag>`
`this.First` Full Usage: `this.First` Parameters: arg0 : `'Key -> 'Value -> 'T option` Returns: `'T option`	Search the map looking for the first element where the given function returns a Some value. arg0 : `'Key -> 'Value -> 'T option` Returns: `'T option`
`this.Fold` Full Usage: `this.Fold` Parameters: folder : `'Key -> 'Value -> 'State -> 'State` arg1 : `'State` Returns: `'State`	Fold over the bindings in the map. folder : `'Key -> 'Value -> 'State -> 'State` arg1 : `'State` Returns: `'State`
`this.FoldAndMap` Full Usage: `this.FoldAndMap` Parameters: arg0 : `'Key -> 'Value -> 'State -> 'T * 'State` arg1 : `'State` Returns: `Map<'Key, 'T, 'ComparerTag> * 'State`	Fold over the bindings in the map. arg0 : `'Key -> 'Value -> 'State -> 'T * 'State` arg1 : `'State` Returns: `Map<'Key, 'T, 'ComparerTag> * 'State`
`this.FoldSection` Full Usage: `this.FoldSection` Parameters: arg0 : `'Key` arg1 : `'Key` arg2 : `'Key -> 'Value -> 'State -> 'State` arg3 : `'State` Returns: `'State`	Given the start and end points of a key range, Fold over the bindings in the map that are in the range, and the end points are included if present (the range is considered a closed interval). arg0 : `'Key` arg1 : `'Key` arg2 : `'Key -> 'Value -> 'State -> 'State` arg3 : `'State` Returns: `'State`
`this.ForAll` Full Usage: `this.ForAll` Parameters: arg0 : `'Key -> 'Value -> bool` Returns: `bool`	Return True if the given predicate returns true for all of the bindings in the map. Always returns true if the map is empty. arg0 : `'Key -> 'Value -> bool` Returns: `bool`
`this.IsEmpty` Full Usage: `this.IsEmpty` Returns: `bool`	Return True if there are no bindings in the map. Returns: `bool`
`this[arg1]` Full Usage: `this[arg1]` Parameters: arg0 : `'Key` Returns: `'Value`	Lookup an element in the map. Raise KeyNotFoundException if no binding exists in the map. arg0 : `'Key` Returns: `'Value`
`this.Iterate` Full Usage: `this.Iterate` Parameters: action : `'Key -> 'Value -> unit`	Apply the given function to each binding in the dictionary. action : `'Key -> 'Value -> unit`
`this.Map` Full Usage: `this.Map` Parameters: mapping : `'Key -> 'Value -> 'T` Returns: `Map<'Key, 'T, 'ComparerTag>`	Build a new collection whose elements are the results of applying the given function to each of the elements of the collection. The index passed to the function indicates the index of element being transformed. mapping : `'Key -> 'Value -> 'T` Returns: `Map<'Key, 'T, 'ComparerTag>`
`this.MapRange` Full Usage: `this.MapRange` Parameters: mapping : `'Value -> 'T` Returns: `Map<'Key, 'T, 'ComparerTag>`	Build a new collection whose elements are the results of applying the given function to each of the elements of the collection. mapping : `'Value -> 'T` Returns: `Map<'Key, 'T, 'ComparerTag>`
`this.Partition` Full Usage: `this.Partition` Parameters: arg0 : `'Key -> 'Value -> bool` Returns: `Map<'Key, 'Value, 'ComparerTag> * Map<'Key, 'Value, 'ComparerTag>`	Build two new maps, one containing the bindings for which the given predicate returns True, and another for the remaining bindings. arg0 : `'Key -> 'Value -> bool` Returns: `Map<'Key, 'Value, 'ComparerTag> * Map<'Key, 'Value, 'ComparerTag>`
`this.Remove` Full Usage: `this.Remove` Parameters: arg0 : `'Key` Returns: `Map<'Key, 'Value, 'ComparerTag>`	Remove an element from the domain of the map. No exception is raised if the element is not present. arg0 : `'Key` Returns: `Map<'Key, 'Value, 'ComparerTag>`
`this.ToArray` Full Usage: `this.ToArray` Returns: `('Key * 'Value) array`	The elements of the set as an array. Returns: `('Key * 'Value) array`
`this.ToList` Full Usage: `this.ToList` Returns: `('Key * 'Value) list`	The elements of the set as a list. Returns: `('Key * 'Value) list`
`this.TryFind` Full Usage: `this.TryFind` Parameters: arg0 : `'Key` Returns: `'Value option`	Lookup an element in the map, returning a Some value if the element is in the domain of the map and None if not. arg0 : `'Key` Returns: `'Value option`

Static members

Static member	Description
`Map.Create(arg1, arg2)` Full Usage: `Map.Create(arg1, arg2)` Parameters: arg0 : `'ComparerTag` arg1 : `('Key * 'Value) seq` Returns: `Map<'Key, 'Value, 'ComparerTag>`	Build a map that contains the bindings of the given IEnumerable and where comparison of elements is based on the given comparison function. arg0 : `'ComparerTag` arg1 : `('Key * 'Value) seq` Returns: `Map<'Key, 'Value, 'ComparerTag>`
`Map.Empty(arg1)` Full Usage: `Map.Empty(arg1)` Parameters: arg0 : `'ComparerTag` Returns: `Map<'Key, 'Value, 'ComparerTag>`	The empty map, and use the given comparer comparison function for all operations associated with any maps built from this map. arg0 : `'ComparerTag` Returns: `Map<'Key, 'Value, 'ComparerTag>`
`Map.FromList(arg1, arg2)` Full Usage: `Map.FromList(arg1, arg2)` Parameters: arg0 : `'ComparerTag` arg1 : `('Key * 'Value) list` Returns: `Map<'Key, 'Value, 'ComparerTag>`	arg0 : `'ComparerTag` arg1 : `('Key * 'Value) list` Returns: `Map<'Key, 'Value, 'ComparerTag>`