Set (FSharp.Core)

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.

 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: 'T seq -> Set<'T> member Add: value: 'T -> Set<'T> member Contains: value: 'T -> bool override Equals: obj -> bool ...

--------------------
new: elements: 'T seq -> 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]

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.

 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

--------------------
new: elements: 'T seq -> 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

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.

 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

--------------------
new: elements: 'T seq -> 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

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.

 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

--------------------
new: elements: 'T seq -> 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]

The empty set for the type 'T.

Returns: Set<'T>

 Set.empty<int>

Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
new: elements: 'T seq -> 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 [ ].

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.

 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

--------------------
new: elements: 'T seq -> 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

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.

 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

--------------------
new: elements: 'T seq -> 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]

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.

 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

--------------------
new: elements: 'T seq -> Set<'T>

val empty<'T (requires comparison)> : Set<'T> (requires comparison)

val printfn: format: Printf.TextWriterFormat<'T> -> 'T

val fold<'T,'State (requires comparison)> : 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]

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.

 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

--------------------
new: elements: 'T seq -> 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]

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.

 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

--------------------
new: elements: 'T seq -> 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

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.

 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

--------------------
new: elements: 'T seq -> 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]

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

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

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

 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: string list seq

Multiple items
val seq: sequence: 'T seq -> 'T seq

--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>

module Seq from Microsoft.FSharp.Collections

val map: mapping: ('T -> 'U) -> source: 'T seq -> 'U seq

Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
new: elements: 'T seq -> Set<'T>

val ofList: elements: 'T list -> Set<'T> (requires comparison)

val intersectMany: sets: Set<'T> seq -> 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"]

Returns "true" if the set is empty.

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

Returns: bool: True if set is empty.

 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

--------------------
new: elements: 'T seq -> 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

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.

 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

--------------------
new: elements: 'T seq -> 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

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.

 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

--------------------
new: elements: 'T seq -> 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

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.

 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

--------------------
new: elements: 'T seq -> 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

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.

 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

--------------------
new: elements: 'T seq -> 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

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.

 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

--------------------
new: elements: 'T seq -> 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

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.

 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

--------------------
new: elements: 'T seq -> 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]

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.

 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

--------------------
new: elements: 'T seq -> 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

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.

 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

--------------------
new: elements: 'T seq -> 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

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

array : 'T array: The input array.

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

 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

--------------------
new: elements: 'T seq -> 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"

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.

 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

--------------------
new: elements: 'T seq -> 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"

Builds a new collection from the given enumerable object.

elements : 'T seq: The input sequence.

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

 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

--------------------
new: elements: 'T seq -> Set<'T>

val ofSeq: elements: 'T seq -> 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"

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.

 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

--------------------
new: elements: 'T seq -> 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])

Splits the set into two sets, by applying the given partitioning function to each element. Returns Choice1Of2 elements in the first set and Choice2Of2 elements in the second set.

partitioner : 'T -> Choice<'T1, 'T2>: The function to transform and classify each input element into one of two output types.
set : Set<'T>: The input set.

Returns: Set<'T1> * Set<'T2>: A tuple of two sets. The first containing values from Choice1Of2 results and the second containing values from Choice2Of2 results.

 let inputs = Set.ofList [1; 2; 3; 4; 5]

 let evens, odds =
     inputs |> Set.partitionWith (fun x ->
         if x % 2 = 0 then Choice1Of2 (x * 10)
         else Choice2Of2 (string x))

val inputs: Set<int>

Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
new: elements: 'T seq -> Set<'T>

val ofList: elements: 'T list -> Set<'T> (requires comparison)

val evens: obj

val odds: obj

union case Choice.Choice1Of2: 'T1 -> Choice<'T1,'T2>

union case Choice.Choice2Of2: 'T2 -> Choice<'T1,'T2>

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

Evaluates evens to set [20; 40] and odds to set ["1"; "3"; "5"].

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.

 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

--------------------
new: elements: 'T seq -> 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]

The set containing the given element.

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

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

 Set.singleton 7

Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
new: elements: 'T seq -> Set<'T>

val singleton: value: 'T -> Set<'T> (requires comparison)

Evaluates to set [ 7 ].

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

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

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

 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

--------------------
new: elements: 'T seq -> 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 array

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.

 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

--------------------
new: elements: 'T seq -> 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"

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

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

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

 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

--------------------
new: elements: 'T seq -> Set<'T>

val empty<'T (requires comparison)> : Set<'T> (requires comparison)

Multiple items
val seq: int seq

--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>

val toSeq: set: Set<'T> -> 'T seq (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]

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.

 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

--------------------
new: elements: 'T seq -> 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]

Computes the union of a sequence of sets.

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

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

 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: string list seq

Multiple items
val seq: sequence: 'T seq -> 'T seq

--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>

module Seq from Microsoft.FSharp.Collections

val map: mapping: ('T -> 'U) -> source: 'T seq -> 'U seq

Multiple items
module Set from Microsoft.FSharp.Collections

--------------------
new: elements: 'T seq -> Set<'T>

val ofList: elements: 'T list -> Set<'T> (requires comparison)

val intersectMany: sets: Set<'T> seq -> 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"]