RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://fsharp.github.io/fsharp-core-docs/reference/fsharp-collections-fsharpmap-2.html below:

Map<'Key, 'Value> (FSharp.Core) | FSharp.Core

Returns a new map with the binding added to the given map. If a binding with the given key already exists in the input map, the existing binding is replaced by the new binding in the result map.

key : 'Key: The key to add.
value : 'Value: The value to add.

Returns: Map<'Key, 'Value>: The resulting map.

 let sample = Map [ (1, "a"); (2, "b") ]

 sample.Add (3, "c") // evaluates to map [(1, "a"); (2, "b"); (3, "c")]
 sample.Add (2, "aa") // evaluates to map [(1, "a"); (2, "aa")]

val sample: Map<int,string>

Multiple items

module Map from Microsoft.FSharp.Collections

--------------------

type Map<'Key,'Value (requires comparison)> = interface IReadOnlyDictionary<'Key,'Value> interface IReadOnlyCollection<KeyValuePair<'Key,'Value>> interface IEnumerable interface IStructuralEquatable interface IComparable interface IEnumerable<KeyValuePair<'Key,'Value>> interface ICollection<KeyValuePair<'Key,'Value>> interface IDictionary<'Key,'Value> new: elements: ('Key * 'Value) seq -> Map<'Key,'Value> member Add: key: 'Key * value: 'Value -> Map<'Key,'Value> ...

--------------------

new: elements: ('Key * 'Value) seq -> Map<'Key,'Value>

member Map.Add: key: 'Key * value: 'Value -> Map<'Key,'Value>

Returns a new map with the value stored under key changed according to f.

key : 'Key: The input key.
f : 'Value option -> 'Value option: The change function.

Returns: Map<'Key, 'Value>: The resulting map.

 let sample = Map [ (1, "a"); (2, "b") ]

 let f x =
     match x with
     | Some s -> Some (s + "z")
     | None -> None

 sample.Change (1, f) // evaluates to map [(1, "az"); (2, "b")]

val sample: Map<int,string>

Multiple items

module Map from Microsoft.FSharp.Collections

--------------------

new: elements: ('Key * 'Value) seq -> Map<'Key,'Value>

val f: x: string option -> string option

val x: string option

union case Option.Some: Value: 'T -> Option<'T>

val s: string

union case Option.None: Option<'T>

member Map.Change: key: 'Key * f: ('Value option -> 'Value option) -> Map<'Key,'Value>

Tests if an element is in the domain of the map.

key : 'Key: The input key.

Returns: bool: True if the map contains the given key.

 let sample = Map [ (1, "a"); (2, "b") ]

 sample.ContainsKey 1 // evaluates to true
 sample.ContainsKey 3 // evaluates to false

val sample: Map<int,string>

Multiple items

module Map from Microsoft.FSharp.Collections

--------------------

new: elements: ('Key * 'Value) seq -> Map<'Key,'Value>

member Map.ContainsKey: key: 'Key -> bool

The number of bindings in the map.

Returns: int

 let sample = Map [ (1, "a"); (2, "b") ]

 sample.Count // evaluates to 2

val sample: Map<int,string>

Multiple items

module Map from Microsoft.FSharp.Collections

--------------------

new: elements: ('Key * 'Value) seq -> Map<'Key,'Value>

property Map.Count: int with get

Returns true if there are no bindings in the map.

Returns: bool

 let emptyMap: Map<int, string> = Map.empty
 emptyMap.IsEmpty // evaluates to true

 let notEmptyMap = Map [ (1, "a"); (2, "b") ]
 notEmptyMap.IsEmpty // evaluates to false

val emptyMap: Map<int,string>

Multiple items

module Map from Microsoft.FSharp.Collections

--------------------

new: elements: ('Key * 'Value) seq -> Map<'Key,'Value>

Multiple items

val int: value: 'T -> int (requires member op_Explicit)

--------------------

type int = int32

--------------------

type int<'Measure> = int

Multiple items

val string: value: 'T -> string

--------------------

type string = System.String

val empty<'Key,'T (requires comparison)> : Map<'Key,'T> (requires comparison)

property Map.IsEmpty: bool with get

val notEmptyMap: Map<int,string>

Lookup an element in the map. Raise KeyNotFoundException if no binding exists in the map.

key : 'Key: The input key.

Returns: 'Value: The value mapped to the key.

 let sample = Map [ (1, "a"); (2, "b") ]

 sample.[1] // evaluates to "a"
 sample.[3] // throws KeyNotFoundException

val sample: Map<int,string>

Multiple items

module Map from Microsoft.FSharp.Collections

--------------------

new: elements: ('Key * 'Value) seq -> Map<'Key,'Value>

The keys in the map. The sequence will be ordered by the keys of the map.

Returns: ICollection<'Key>

 let sample = Map [ (1, "a"); (2, "b") ]

 sample.Keys // evaluates to seq [1; 2]

val sample: Map<int,string>

Multiple items

module Map from Microsoft.FSharp.Collections

--------------------

new: elements: ('Key * 'Value) seq -> Map<'Key,'Value>

property Map.Keys: System.Collections.Generic.ICollection<int> with get

Removes an element from the domain of the map. No exception is raised if the element is not present.

key : 'Key: The input key.

Returns: Map<'Key, 'Value>: The resulting map.

 let sample = Map [ (1, "a"); (2, "b") ]

 sample.Remove 1 // evaluates to map [(2, "b")]
 sample.Remove 3 // equal to sample

val sample: Map<int,string>

Multiple items

module Map from Microsoft.FSharp.Collections

--------------------

new: elements: ('Key * 'Value) seq -> Map<'Key,'Value>

member Map.Remove: key: 'Key -> Map<'Key,'Value>

Lookup an element in the map, returning a Some value if the element is in the domain of the map and None if not.

key : 'Key: The input key.

Returns: 'Value option: The mapped value, or None if the key is not in the map.

 let sample = Map [ (1, "a"); (2, "b") ]

 sample.TryFind 1 // evaluates to Some "a"
 sample.TryFind 3 // evaluates to None

val sample: Map<int,string>

Multiple items

module Map from Microsoft.FSharp.Collections

--------------------

new: elements: ('Key * 'Value) seq -> Map<'Key,'Value>

member Map.TryFind: key: 'Key -> 'Value option

Lookup an element in the map, assigning to value if the element is in the domain of the map and returning false if not.

key : 'Key: The input key.
value : byref<'Value>: A reference to the output value.

Returns: bool: true if the value is present, false if not.

 let sample = Map [ (1, "a"); (2, "b") ]

 sample.TryGetValue 1 // evaluates to (true, "a")
 sample.TryGetValue 3 // evaluates to (false, null)

 let mutable x = ""
 sample.TryGetValue (1, &x) // evaluates to true, x set to "a"

 let mutable y = ""
 sample.TryGetValue (3, &y) // evaluates to false, y unchanged

val sample: Map<int,string>

Multiple items

module Map from Microsoft.FSharp.Collections

--------------------

new: elements: ('Key * 'Value) seq -> Map<'Key,'Value>

member Map.TryGetValue: key: 'Key * [<System.Runtime.InteropServices.Out>] value: byref<'Value> -> bool

val mutable x: string

val mutable y: string

All the values in the map, including the duplicates. The sequence will be ordered by the keys of the map.

Returns: ICollection<'Value>

 let sample = Map [ (1, "a"); (2, "b") ]

 sample.Values // evaluates to seq ["a"; "b"]

val sample: Map<int,string>

Multiple items

module Map from Microsoft.FSharp.Collections

--------------------

new: elements: ('Key * 'Value) seq -> Map<'Key,'Value>

property Map.Values: System.Collections.Generic.ICollection<string> with get

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4