FSharp.Core

Set Module

Namespace: FSharp.Collections
Assembly: FSharp.Core.dll

Contains operations for working with values of type Set.

Functions and values

Function or value Description

Set.add value set

Full Usage: Set.add value set

Parameters:
    value : 'T - The value to add.
    set : Set<'T> - The input set.

Returns: Set<'T> A new set containing value.

Returns a new set with an element added to the set. No exception is raised if the set already contains the given element.

value : 'T

The value to add.

set : Set<'T>

The input set.

Returns: Set<'T>

A new set containing value.

Example 

 let set = Set.empty.Add(1).Add(1).Add(2)
 printfn $"The new set is: {set}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: The new set is: set [1; 2]

Set.contains element set

Full Usage: Set.contains element set

Parameters:
    element : 'T - The element to test.
    set : Set<'T> - The input set.

Returns: bool True if element is in set.

Evaluates to "true" if the given element is in the given set.

element : 'T

The element to test.

set : Set<'T>

The input set.

Returns: bool

True if element is in set.

Example 

 let set = Set.empty.Add(2).Add(3)
 printfn $"Does the set contain 1? {set.Contains(1))}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
member Set.Contains: value: 'T -> bool
The sample evaluates to the following output: Does the set contain 1? false

Set.count set

Full Usage: Set.count set

Parameters:
    set : Set<'T> - The input set.

Returns: int The number of elements in the set.

Returns the number of elements in the set. Same as size.

set : Set<'T>

The input set.

Returns: int

The number of elements in the set.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3)
 printfn $"The set has {set.Count} elements"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
property Set.Count: int with get
The sample evaluates to the following output: The set has 3 elements

Set.difference set1 set2

Full Usage: Set.difference set1 set2

Parameters:
    set1 : Set<'T> - The first input set.
    set2 : Set<'T> - The set whose elements will be removed from set1.

Returns: Set<'T> The set with the elements of set2 removed from set1.

Returns a new set with the elements of the second set removed from the first.

set1 : Set<'T>

The first input set.

set2 : Set<'T>

The set whose elements will be removed from set1.

Returns: Set<'T>

The set with the elements of set2 removed from set1.

Example 

 let set1 = Set.empty.Add(1).Add(2).Add(3)
 let set2 = Set.empty.Add(2).Add(3).Add(4)
 printfn $"The difference of {set1} and {set2} is {Set.difference set1 set2}"
val set1: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val set2: Set<int>
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: The difference of set [1; 2; 3] and set [2; 3; 4] is set [1]

Set.empty

Full Usage: Set.empty

Returns: Set<'T>

The empty set for the type 'T.

Returns: Set<'T>
Example 

 Set.empty<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
Evaluates to set [ ].

Set.exists predicate set

Full Usage: Set.exists predicate set

Parameters:
    predicate : 'T -> bool - The function to test set elements.
    set : Set<'T> - The input set.

Returns: bool True if any element of set satisfies predicate.

Tests if any element of the collection satisfies the given predicate. If the input function is predicate and the elements are i0...iN then computes p i0 or ... or p iN.

predicate : 'T -> bool

The function to test set elements.

set : Set<'T>

The input set.

Returns: bool

True if any element of set satisfies predicate.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3)
 printfn $"Does the set contain 1? {Set.exists (fun x -> x = 1) set}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val exists: predicate: ('T -> bool) -> set: Set<'T> -> bool (requires comparison)
val x: int
The sample evaluates to the following output: Does the set contain 1? true

Set.filter predicate set

Full Usage: Set.filter predicate set

Parameters:
    predicate : 'T -> bool - The function to test set elements.
    set : Set<'T> - The input set.

Returns: Set<'T> The set containing only the elements for which predicate returns true.

Returns a new collection containing only the elements of the collection for which the given predicate returns True.

predicate : 'T -> bool

The function to test set elements.

set : Set<'T>

The input set.

Returns: Set<'T>

The set containing only the elements for which predicate returns true.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3).Add(4)
 printfn $"The set with even numbers is {Set.filter (fun x -> x % 2 = 0) set}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val filter: predicate: ('T -> bool) -> set: Set<'T> -> Set<'T> (requires comparison)
val x: int
The sample evaluates to the following output: The set with even numbers is set [2; 4]

Set.fold folder state set

Full Usage: Set.fold folder state set

Parameters:
    folder : 'State -> 'T -> 'State - The accumulating function.
    state : 'State - The initial state.
    set : Set<'T> - The input set.

Returns: 'State The final state.

Applies the given accumulating function to all the elements of the set

folder : 'State -> 'T -> 'State

The accumulating function.

state : 'State

The initial state.

set : Set<'T>

The input set.

Returns: 'State

The final state.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3)
 printfn $"The sum of the set is {Set.fold (+) 0 set}"
 printfn $"The product of the set is {Set.fold (*) 1 set}"
 printfn $"The reverse of the set is {Set.fold (fun x y -> y :: x) [] set}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val fold: folder: ('State -> 'T -> 'State) -> state: 'State -> set: Set<'T> -> 'State (requires comparison)
val x: int list
val y: int
The sample evaluates to the following output: The sum of the set is 6 The product of the set is 6 The reverse of the set is [3; 2; 1]

Set.foldBack folder set state

Full Usage: Set.foldBack folder set state

Parameters:
    folder : 'T -> 'State -> 'State - The accumulating function.
    set : Set<'T> - The input set.
    state : 'State - The initial state.

Returns: 'State The final state.

Applies the given accumulating function to all the elements of the set.

folder : 'T -> 'State -> 'State

The accumulating function.

set : Set<'T>

The input set.

state : 'State

The initial state.

Returns: 'State

The final state.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3)
 printfn $"The sum of the set is {Set.foldBack (+) set 0}"
 printfn $"The set is {Set.foldBack (fun x acc -> x :: acc) set []}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val foldBack: folder: ('T -> 'State -> 'State) -> set: Set<'T> -> state: 'State -> 'State (requires comparison)
val x: int
val acc: int list
The sample evaluates to the following output: The sum of the set is 6 The set is [1; 2; 3]

Set.forall predicate set

Full Usage: Set.forall predicate set

Parameters:
    predicate : 'T -> bool - The function to test set elements.
    set : Set<'T> - The input set.

Returns: bool True if all elements of set satisfy predicate.

Tests if all elements of the collection satisfy the given predicate. If the input function is f and the elements are i0...iN and "j0...jN" then computes p i0 && ... && p iN.

predicate : 'T -> bool

The function to test set elements.

set : Set<'T>

The input set.

Returns: bool

True if all elements of set satisfy predicate.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3)
 printfn $"Does the set contain even numbers? {Set.forall (fun x -> x % 2 = 0) set}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val forall: predicate: ('T -> bool) -> set: Set<'T> -> bool (requires comparison)
val x: int
The sample evaluates to the following output: Does the set contain even numbers? false

Set.intersect set1 set2

Full Usage: Set.intersect set1 set2

Parameters:
    set1 : Set<'T> - The first input set.
    set2 : Set<'T> - The second input set.

Returns: Set<'T> The intersection of set1 and set2.

Computes the intersection of the two sets.

set1 : Set<'T>

The first input set.

set2 : Set<'T>

The second input set.

Returns: Set<'T>

The intersection of set1 and set2.

Example 

 let set1 = Set.empty.Add(1).Add(2).Add(3)
 let set2 = Set.empty.Add(2).Add(3).Add(4)
 printfn $"The intersection of {set1} and {set2} is {Set.intersect set1 set2}"
val set1: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val set2: Set<int>
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: The intersection of set [1; 2; 3] and set [2; 3; 4] is set [2; 3]

Set.intersectMany sets

Full Usage: Set.intersectMany sets

Parameters:
    sets : seq<Set<'T>> - The sequence of sets to intersect.

Returns: Set<'T> The intersection of the input sets.

Computes the intersection of a sequence of sets. The sequence must be non-empty.

sets : seq<Set<'T>>

The sequence of sets to intersect.

Returns: Set<'T>

The intersection of the input sets.

Example 

 let headersByFile = seq{
 yield [ "id"; "name"; "date"; "color" ]
 yield [ "id"; "age"; "date" ]
 yield [ "id"; "sex"; "date"; "animal" ]
 }
 headersByFile
 |> Seq.map Set.ofList
 |> Set.intersectMany
 |> printfn "The intersection of %A is %A" headersByFile
val headersByFile: seq<string list>
Multiple items
val seq: sequence: seq<'T> -> seq<'T>

--------------------
type seq<'T> = System.Collections.Generic.IEnumerable<'T>
module Seq from Microsoft.FSharp.Collections
val map: mapping: ('T -> 'U) -> source: seq<'T> -> seq<'U>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val ofList: elements: 'T list -> Set<'T> (requires comparison)
val intersectMany: sets: seq<Set<'T>> -> Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: The intersection of seq [["id"; "name"; "date"; "color"]; ["id"; "age"; "date"]; ["id"; "sex"; "date"; "animal"]] is set ["date"; "id"]

Set.isEmpty set

Full Usage: Set.isEmpty set

Parameters:
    set : Set<'T> - The input set.

Returns: bool True if set is empty.

Returns "true" if the set is empty.

set : Set<'T>

The input set.

Returns: bool

True if set is empty.

Example 

 let set = Set.empty.Add(2).Add(3)
 printfn $"Is the set empty? {set.IsEmpty}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
property Set.IsEmpty: bool with get
The sample evaluates to the following output: Is the set empty? false

Set.isProperSubset set1 set2

Full Usage: Set.isProperSubset set1 set2

Parameters:
    set1 : Set<'T> - The potential subset.
    set2 : Set<'T> - The set to test against.

Returns: bool True if set1 is a proper subset of set2.

Evaluates to "true" if all elements of the first set are in the second, and at least one element of the second is not in the first.

set1 : Set<'T>

The potential subset.

set2 : Set<'T>

The set to test against.

Returns: bool

True if set1 is a proper subset of set2.

Example 

 let set1 = Set.empty.Add(1).Add(2).Add(3)
 let set2 = Set.empty.Add(1).Add(2).Add(3).Add(4)
 printfn $"Is {set1} a proper subset of {set2}? {Set.isProperSubset set1 set2}"
val set1: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val set2: Set<int>
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: Is set [1; 2; 3] a proper subset of set [1; 2; 3; 4]? true

Set.isProperSuperset set1 set2

Full Usage: Set.isProperSuperset set1 set2

Parameters:
    set1 : Set<'T> - The potential superset.
    set2 : Set<'T> - The set to test against.

Returns: bool True if set1 is a proper superset of set2.

Evaluates to "true" if all elements of the second set are in the first, and at least one element of the first is not in the second.

set1 : Set<'T>

The potential superset.

set2 : Set<'T>

The set to test against.

Returns: bool

True if set1 is a proper superset of set2.

Example 

 let set1 = Set.empty.Add(1).Add(2).Add(3)
 let set2 = Set.empty.Add(1).Add(2).Add(3).Add(4)
 printfn $"Is {set1} a proper superset of {set2}? {Set.isProperSuperset set1 set2}"
val set1: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val set2: Set<int>
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: Is set [1; 2; 3] a proper superset of set [1; 2; 3; 4]? false

Set.isSubset set1 set2

Full Usage: Set.isSubset set1 set2

Parameters:
    set1 : Set<'T> - The potential subset.
    set2 : Set<'T> - The set to test against.

Returns: bool True if set1 is a subset of set2.

Evaluates to "true" if all elements of the first set are in the second

set1 : Set<'T>

The potential subset.

set2 : Set<'T>

The set to test against.

Returns: bool

True if set1 is a subset of set2.

Example 

 let set1 = Set.empty.Add(1).Add(2).Add(3)
 let set2 = Set.empty.Add(1).Add(2).Add(3).Add(4)
 printfn $"Is {set1} a subset of {set2}? {Set.isSubset set1 set2}"
val set1: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val set2: Set<int>
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: Is set [1; 2; 3] a subset of set [1; 2; 3; 4]? true

Set.isSuperset set1 set2

Full Usage: Set.isSuperset set1 set2

Parameters:
    set1 : Set<'T> - The potential superset.
    set2 : Set<'T> - The set to test against.

Returns: bool True if set1 is a superset of set2.

Evaluates to "true" if all elements of the second set are in the first.

set1 : Set<'T>

The potential superset.

set2 : Set<'T>

The set to test against.

Returns: bool

True if set1 is a superset of set2.

Example 

 let set1 = Set.empty.Add(1).Add(2).Add(3)
 let set2 = Set.empty.Add(1).Add(2).Add(3).Add(4)
 printfn $"Is {set1} a superset of {set2}? {Set.isSuperset set1 set2}"
val set1: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val set2: Set<int>
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: Is set [1; 2; 3] a superset of set [1; 2; 3; 4]? false

Set.iter action set

Full Usage: Set.iter action set

Parameters:
    action : 'T -> unit - The function to apply to each element.
    set : Set<'T> - The input set.

Applies the given function to each element of the set, in order according to the comparison function.

action : 'T -> unit

The function to apply to each element.

set : Set<'T>

The input set.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3)
 Set.iter (fun x -> printfn $"The set contains {x}") set
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val iter: action: ('T -> unit) -> set: Set<'T> -> unit (requires comparison)
val x: int
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: The set contains 1 The set contains 2 The set contains 3

Set.map mapping set

Full Usage: Set.map mapping set

Parameters:
    mapping : 'T -> 'U - The function to transform elements of the input set.
    set : Set<'T> - The input set.

Returns: Set<'U> A set containing the transformed elements.

Returns a new collection containing the results of applying the given function to each element of the input set.

mapping : 'T -> 'U

The function to transform elements of the input set.

set : Set<'T>

The input set.

Returns: Set<'U>

A set containing the transformed elements.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3)
 printfn $"The set with doubled values is {Set.map (fun x -> x * 2) set}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val map: mapping: ('T -> 'U) -> set: Set<'T> -> Set<'U> (requires comparison and comparison)
val x: int
The sample evaluates to the following output: The set with doubled values is set [2; 4; 6]

Set.maxElement set

Full Usage: Set.maxElement set

Parameters:
    set : Set<'T> - The input set.

Returns: 'T The max value from the set.

Returns the highest element in the set according to the ordering being used for the set.

set : Set<'T>

The input set.

Returns: 'T

The max value from the set.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3)
 printfn $"The min element of {set} is {Set.minElement set}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: The max element of set [1; 2; 3] is 3

Set.minElement set

Full Usage: Set.minElement set

Parameters:
    set : Set<'T> - The input set.

Returns: 'T The min value from the set.

Returns the lowest element in the set according to the ordering being used for the set.

set : Set<'T>

The input set.

Returns: 'T

The min value from the set.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3)
 printfn $"The min element of {set} is {Set.minElement set}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: The min element of set [1; 2; 3] is 1

Set.ofArray array

Full Usage: Set.ofArray array

Parameters:
    array : 'T[] - The input array.

Returns: Set<'T> A set containing the elements of array.

Builds a set that contains the same elements as the given array.

array : 'T[]

The input array.

Returns: Set<'T>

A set containing the elements of array.

Example 

 let set = Set.ofArray [|1, 2, 3|]
 printfn $"The set is {set} and type is {set.GetType().Name}"
val set: Set<int * int * int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val ofArray: array: 'T array -> Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: The set is set [(1, 2, 3)] and type is "FSharpSet`1"

Set.ofList elements

Full Usage: Set.ofList elements

Parameters:
    elements : 'T list - The input list.

Returns: Set<'T> A set containing the elements form the input list.

Builds a set that contains the same elements as the given list.

elements : 'T list

The input list.

Returns: Set<'T>

A set containing the elements form the input list.

Example 

 let set = Set.ofList [1, 2, 3]
 printfn $"The set is {set} and type is {set.GetType().Name}"
val set: Set<int * int * int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val ofList: elements: 'T list -> Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: The set is set [(1, 2, 3)] and type is "FSharpSet`1"

Set.ofSeq elements

Full Usage: Set.ofSeq elements

Parameters:
    elements : seq<'T> - The input sequence.

Returns: Set<'T> The set containing elements.

Builds a new collection from the given enumerable object.

elements : seq<'T>

The input sequence.

Returns: Set<'T>

The set containing elements.

Example 

 let set = Set.ofSeq [1, 2, 3]
 printfn $"The set is {set} and type is {set.GetType().Name}"
val set: Set<int * int * int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val ofSeq: elements: seq<'T> -> Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: The set is set [(1, 2, 3)] and type is "FSharpSet`1"

Set.partition predicate set

Full Usage: Set.partition predicate set

Parameters:
    predicate : 'T -> bool - The function to test set elements.
    set : Set<'T> - The input set.

Returns: Set<'T> * Set<'T> A pair of sets with the first containing the elements for which predicate returns true and the second containing the elements for which predicate returns false.

Splits the set into two sets containing the elements for which the given predicate returns true and false respectively.

predicate : 'T -> bool

The function to test set elements.

set : Set<'T>

The input set.

Returns: Set<'T> * Set<'T>

A pair of sets with the first containing the elements for which predicate returns true and the second containing the elements for which predicate returns false.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3).Add(4)
 printfn $"The set with even numbers is {Set.partition (fun x -> x % 2 = 0) set}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val partition: predicate: ('T -> bool) -> set: Set<'T> -> Set<'T> * Set<'T> (requires comparison)
val x: int
The sample evaluates to the following output: The partitioned sets are: (set [2; 4], set [1; 3])

Set.remove value set

Full Usage: Set.remove value set

Parameters:
    value : 'T - The element to remove.
    set : Set<'T> - The input set.

Returns: Set<'T> The input set with value removed.

Returns a new set with the given element removed. No exception is raised if the set doesn't contain the given element.

value : 'T

The element to remove.

set : Set<'T>

The input set.

Returns: Set<'T>

The input set with value removed.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3)
 printfn $"The set without 1 is {Set.remove 1 set}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val remove: value: 'T -> set: Set<'T> -> Set<'T> (requires comparison)
The sample evaluates to the following output: The set without 1 is set [2; 3]

Set.singleton value

Full Usage: Set.singleton value

Parameters:
    value : 'T - The value for the set to contain.

Returns: Set<'T> The set containing value.

The set containing the given element.

value : 'T

The value for the set to contain.

Returns: Set<'T>

The set containing value.

Example 

 Set.singleton 7
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val singleton: value: 'T -> Set<'T> (requires comparison)
Evaluates to set [ 7 ].

Set.toArray set

Full Usage: Set.toArray set

Parameters:
    set : Set<'T> - The input set.

Returns: 'T[] An ordered array of the elements of set.

Builds an array that contains the elements of the set in order.

set : Set<'T>

The input set.

Returns: 'T[]

An ordered array of the elements of set.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3)
 let array = Set.toArray set
 printfn$ "The set is {set} and type is {array.GetType().Name}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
Multiple items
val array: int array

--------------------
type 'T array = 'T array
val toArray: set: Set<'T> -> 'T array (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: The set is [|1; 2; 3|] and type is System.Int32[]

Set.toList set

Full Usage: Set.toList set

Parameters:
    set : Set<'T> - The input set.

Returns: 'T list An ordered list of the elements of set.

Builds a list that contains the elements of the set in order.

set : Set<'T>

The input set.

Returns: 'T list

An ordered list of the elements of set.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3)
 let list = Set.toList set
 printfn $"The set is {list} and type is {list.GetType().Name}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
Multiple items
val list: int list

--------------------
type 'T list = List<'T>
val toList: set: Set<'T> -> 'T list (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: The set is [1; 2; 3] and type is "FSharpList`1"

Set.toSeq set

Full Usage: Set.toSeq set

Parameters:
    set : Set<'T> - The input set.

Returns: seq<'T> An ordered sequence of the elements of set.

Returns an ordered view of the collection as an enumerable object.

set : Set<'T>

The input set.

Returns: seq<'T>

An ordered sequence of the elements of set.

Example 

 let set = Set.empty.Add(1).Add(2).Add(3)
 let seq = Set.toSeq set
 printfn $"The set is {set} and type is {seq.GetType().Name}"
val set: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
Multiple items
val seq: seq<int>

--------------------
type seq<'T> = System.Collections.Generic.IEnumerable<'T>
val toSeq: set: Set<'T> -> seq<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: he set is set [1; 2; 3] and type is Microsoft.FSharp.Collections.FSharpSet`1[System.Int32]

Set.union set1 set2

Full Usage: Set.union set1 set2

Parameters:
    set1 : Set<'T> - The first input set.
    set2 : Set<'T> - The second input set.

Returns: Set<'T> The union of set1 and set2.

Computes the union of the two sets.

set1 : Set<'T>

The first input set.

set2 : Set<'T>

The second input set.

Returns: Set<'T>

The union of set1 and set2.

Example 

 let set1 = Set.empty.Add(1).Add(2).Add(3)
 let set2 = Set.empty.Add(2).Add(3).Add(4)
 printfn $"The union of {set1} and {set2} is {(Set.union set1 set2)}"
val set1: Set<int>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val empty<'T (requires comparison)> : Set<'T> (requires comparison)
val set2: Set<int>
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val union: set1: Set<'T> -> set2: Set<'T> -> Set<'T> (requires comparison)
The sample evaluates to the following output: The union of set [1; 2; 3] and set [2; 3; 4] is set [1; 2; 3; 4]

Set.unionMany sets

Full Usage: Set.unionMany sets

Parameters:
    sets : seq<Set<'T>> - The sequence of sets to union.

Returns: Set<'T> The union of the input sets.

Computes the union of a sequence of sets.

sets : seq<Set<'T>>

The sequence of sets to union.

Returns: Set<'T>

The union of the input sets.

Example 

 let headersByFile = seq{
 yield [ "id"; "name"; "date"; "color" ]
 yield [ "id"; "age"; "date" ]
 yield [ "id"; "sex"; "date"; "animal" ]
 }
 headersByFile
 |> Seq.map Set.ofList
 |> Set.intersectMany
 |> printfn "The intersection of %A is %A" headersByFile
val headersByFile: seq<string list>
Multiple items
val seq: sequence: seq<'T> -> seq<'T>

--------------------
type seq<'T> = System.Collections.Generic.IEnumerable<'T>
module Seq from Microsoft.FSharp.Collections
val map: mapping: ('T -> 'U) -> source: seq<'T> -> seq<'U>
Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> = interface IReadOnlyCollection<'T> interface IStructuralEquatable interface IComparable interface IEnumerable interface IEnumerable<'T> interface ICollection<'T> new: elements: seq<'T> -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: seq<'T> -> Set<'T>
val ofList: elements: 'T list -> Set<'T> (requires comparison)
val intersectMany: sets: seq<Set<'T>> -> Set<'T> (requires comparison)
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
The sample evaluates to the following output: The union of seq [["id"; "name"; "date"; "color"]; ["id"; "age"; "date"]; ["id"; "sex"; "date"; "animal"]] is set ["age"; "animal"; "color"; "date"; "id"; "name"; "sex"]