Set<'T> (FSharp.Core)

Set<'T> Type

Namespace: FSharp.Collections
Assembly: FSharp.Core.dll
Base Type: obj
All Interfaces: IReadOnlyCollection<'T> , IComparable , ICollection<'T> , IEnumerable<'T> , IEnumerable

Immutable sets based on binary trees, where elements are ordered by F# generic comparison. By default comparison is the F# structural comparison function or uses implementations of the IComparable interface on element values.

See the Set module for further operations on sets. All members of this class are thread-safe and may be used concurrently from multiple threads.

Constructors

Constructor Description

Constructor	Description
`Set(elements)` Full Usage: `Set(elements)` Parameters: elements : `seq<'T>` - The input sequence. Returns: `Set<'T>` The result set.	Create a set containing elements drawn from the given sequence. elements : `seq<'T>` The input sequence. Returns: `Set<'T>` The result set. Example `let sequenceOfNumbers = seq { 1 .. 3 } let numbersInSet = Set(sequenceOfNumbers) printfn $"The set is {numbersInSet}"`


                
                  
                    
                      Set(elements)

Full Usage: Set(elements)

Parameters:

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

Returns: Set<'T> The result set.

Create a set containing elements drawn from the given sequence.

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

Returns: Set<'T>: The result set.

Example


 let sequenceOfNumbers = seq { 1 .. 3 }
 let numbersInSet = Set(sequenceOfNumbers)
 printfn $"The set is {numbersInSet}"

Instance members

Instance member	Description
`this.Add` Full Usage: `this.Add` Parameters: value : `'T` - The value to add to the set. Returns: `Set<'T>` The result set.	A useful shortcut for Set.add. Note this operation produces a new set and does not mutate the original set. The new set will share many storage nodes with the original. See the Set module for further operations on sets. value : `'T` The value to add to the set. Returns: `Set<'T>` The result set. Example `let set = Set.empty.Add(1).Add(1).Add(2) printfn $"The new set is: {set}"` The sample evaluates to the following output: `The new set is: set [1; 2]`
`this.Contains` Full Usage: `this.Contains` Parameters: value : `'T` - The value to check. Returns: `bool` True if the set contains `value`.	A useful shortcut for Set.contains. See the Set module for further operations on sets. value : `'T` The value to check. Returns: `bool` True if the set contains `value`. 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`
`this.Count` Full Usage: `this.Count` Returns: `int`	The number of elements in the set Returns: `int` Example `let set = Set.empty.Add(1).Add(1).Add(2) printfn $"The set has {set.Count} elements"` The sample evaluates to the following output: `The set has 3 elements`
`this.IsEmpty` Full Usage: `this.IsEmpty` Returns: `bool`	A useful shortcut for Set.isEmpty. See the Set module for further operations on sets. Returns: `bool` 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`
`this.IsProperSubsetOf` Full Usage: `this.IsProperSubsetOf` Parameters: otherSet : `Set<'T>` - The set to test against. Returns: `bool` True if this set is a proper subset of `otherSet`.	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. otherSet : `Set<'T>` The set to test against. Returns: `bool` True if this set is a proper subset of `otherSet`. 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 subset of set [1; 2; 3; 4]? true`
`this.IsProperSupersetOf` Full Usage: `this.IsProperSupersetOf` Parameters: otherSet : `Set<'T>` - The set to test against. Returns: `bool` True if this set is a proper superset of `otherSet`.	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. otherSet : `Set<'T>` The set to test against. Returns: `bool` True if this set is a proper superset of `otherSet`. 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`
`this.IsSubsetOf` Full Usage: `this.IsSubsetOf` Parameters: otherSet : `Set<'T>` - The set to test against. Returns: `bool` True if this set is a subset of `otherSet`.	Evaluates to "true" if all elements of the first set are in the second. otherSet : `Set<'T>` The set to test against. Returns: `bool` True if this set is a subset of `otherSet`. 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}"` The sample evaluates to the following output: `Is set [1; 2; 3] a subset of set [1; 2; 3; 4]? true`
`this.IsSupersetOf` Full Usage: `this.IsSupersetOf` Parameters: otherSet : `Set<'T>` - The set to test against. Returns: `bool` True if this set is a superset of `otherSet`.	Evaluates to "true" if all elements of the second set are in the first. otherSet : `Set<'T>` The set to test against. Returns: `bool` True if this set is a superset of `otherSet`. 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`
`this.MaximumElement` Full Usage: `this.MaximumElement` Returns: `'T`	Returns the highest element in the set according to the ordering being used for the set. Returns: `'T` Example `let set = Set.empty.Add(1).Add(2).Add(3) printfn $"MaximumElement: {set.MaximumElement}"` The sample evaluates to the following output: `MaximumElement: 3`
`this.MinimumElement` Full Usage: `this.MinimumElement` Returns: `'T`	Returns the lowest element in the set according to the ordering being used for the set. Returns: `'T` Example `let set = Set.empty.Add(1).Add(2).Add(3) printfn $"MinimumElement: {set.MinimumElement}"` The sample evaluates to the following output: `MinimumElement: 1`
`this.Remove` Full Usage: `this.Remove` Parameters: value : `'T` - The value to remove from the set. Returns: `Set<'T>` The result set.	A useful shortcut for Set.remove. Note this operation produces a new set and does not mutate the original set. The new set will share many storage nodes with the original. See the Set module for further operations on sets. value : `'T` The value to remove from the set. Returns: `Set<'T>` The result set. Example `let set = Set.empty.Add(1).Add(1).Add(2) printfn $"The new set is: {set}"` The sample evaluates to the following output: `The new set is: set [2]`

Static members

Static member Description

Static member	Description
`set1 + set2` Full Usage: `set1 + set2` Parameters: set1 : `Set<'T>` - The first input set. set2 : `Set<'T>` - The second input set. Returns: `Set<'T>` The union of the two input sets.	Compute 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 the two input sets. Example `let set1 = Set.empty.Add(1).Add(2).Add(3) let set2 = Set.empty.Add(2).Add(3).Add(4) printfn $"Output is %A" {set1 + set2}"` The sample evaluates to the following output: `The new set is: set [1; 2; 3; 4]`
`set1 - set2` Full Usage: `set1 - set2` Parameters: set1 : `Set<'T>` - The first input set. set2 : `Set<'T>` - The second input set. Returns: `Set<'T>` A set containing elements of the first set that are not contained in the second set.	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 second input set. Returns: `Set<'T>` A set containing elements of the first set that are not contained in the second set. Example `let set1 = Set.empty.Add(1).Add(2).Add(3) let set2 = Set.empty.Add(2).Add(3).Add(4) printfn $"The new set is: {set1 - set2}"` The sample evaluates to the following output: `The new set is: set [1]`


                
                  
                    
                      set1 + set2

Full Usage: set1 + set2

Parameters:

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

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

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

Compute 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 the two input sets.

Example


 let set1 = Set.empty.Add(1).Add(2).Add(3)
 let set2 = Set.empty.Add(2).Add(3).Add(4)
 printfn $"Output is %A" {set1 + set2}"

The sample evaluates to the following output: The new set is: set [1; 2; 3; 4]


                
                  
                    
                      set1 - set2

Full Usage: set1 - set2

Parameters:

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

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

Returns: Set<'T> A set containing elements of the first set that are not contained in the second set.

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 second input set.

Returns: Set<'T>: A set containing elements of the first set that are not contained in the second set.

Example


 let set1 = Set.empty.Add(1).Add(2).Add(3)
 let set2 = Set.empty.Add(2).Add(3).Add(4)
 printfn $"The new set is: {set1 - set2}"

The sample evaluates to the following output: The new set is: set [1]