## Set Module

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

set : Set<'T>

The input set.

Returns: Set<'T>

A new set containing value.

##### Example


printfn $"The new set is: {set}" 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))}"
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


printfn $"The set has {set.Count} elements" 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}"
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>
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


printfn $"Does the set contain 1? {Set.exists (fun x -> x = 1) set}" 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}"
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


printfn $"The sum of the set is {Set.fold (+) 0 set}" printfn$"The product of the set is {Set.fold (*) 1 set}"
printfn $"The set is {Set.foldBack (fun x acc -> x :: acc) set []}" 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}"
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


printfn $"The intersection of {set1} and {set2} is {Set.intersect set1 set2}" 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 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}"
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


printfn $"Is {set1} a proper subset of {set2}? {Set.isProperSubset set1 set2}" 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}"
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


printfn $"Is {set1} a subset of {set2}? {Set.isSubset set1 set2}" 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}"
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


Set.iter (fun x -> printfn $"The set contains {x}") set 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}"
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


printfn $"The min element of {set} is {Set.minElement set}" 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}"
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}" The sample evaluates to the following output: The set is set [(1, 2, 3)] and type is "FSharpSet1"  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}"
The sample evaluates to the following output: The set is set [(1, 2, 3)] and type is "FSharpSet1"

 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}" The sample evaluates to the following output: The set is set [(1, 2, 3)] and type is "FSharpSet1"  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}"
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


printfn $"The set without 1 is {Set.remove 1 set}" 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 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}"
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 list = Set.toList set
printfn $"The set is {list} and type is {list.GetType().Name}" The sample evaluates to the following output: The set is [1; 2; 3] and type is "FSharpList1"  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}"
The sample evaluates to the following output: he set is set [1; 2; 3] and type is Microsoft.FSharp.Collections.FSharpSet1[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


printfn \$"The union of {set1} and {set2} is {(Set.union set1 set2)}"
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


|> printfn "The intersection of %A is %A" headersByFile
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"]`