Set<'T, 'ComparerTag> (fantomas) | fantomas

Set<'T, 'ComparerTag> Type

Namespace: Internal.Utilities.Collections.Tagged
Assembly: Fantomas.FCS.dll
Base Type: obj
All Interfaces: IComparable , ICollection<'T> , IEnumerable<'T> , IEnumerable

Immutable sets based on binary trees, default tag Immutable sets where a constraint tag carries information about the class of key-comparer being used.

Instance members

Instance member	Description
`this.Add` Full Usage: `this.Add` Parameters: arg0 : `'T` Returns: `Set<'T, 'ComparerTag>`	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. arg0 : `'T` Returns: `Set<'T, 'ComparerTag>`
`this.Choose` Full Usage: `this.Choose` Returns: `'T`	The number of elements in the set. Returns: `'T`
`this.Contains` Full Usage: `this.Contains` Parameters: arg0 : `'T` Returns: `bool`	A useful shortcut for Set.contains. See the Set module for further operations on sets. arg0 : `'T` Returns: `bool`
`this.Count` Full Usage: `this.Count` Returns: `int`	Return the number of elements in the set. Returns: `int`
`this.Exists` Full Usage: `this.Exists` Parameters: predicate : `'T -> bool` Returns: `bool`	Test if any element of the collection satisfies the given predicate. If the input function is f and the elements are i0...iN then computes p i0 or ... or p iN. predicate : `'T -> bool` Returns: `bool`
`this.Filter` Full Usage: `this.Filter` Parameters: predicate : `'T -> bool` Returns: `Set<'T, 'ComparerTag>`	Return a new collection containing only the elements of the collection for which the given predicate returns True. predicate : `'T -> bool` Returns: `Set<'T, 'ComparerTag>`
`this.Fold` Full Usage: `this.Fold` Parameters: arg0 : `'T -> 'State -> 'State` arg1 : `'State` Returns: `'State`	Apply the given accumulating function to all the elements of the set. arg0 : `'T -> 'State -> 'State` arg1 : `'State` Returns: `'State`
`this.ForAll` Full Usage: `this.ForAll` Parameters: predicate : `'T -> bool` Returns: `bool`	Test 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` Returns: `bool`
`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`
`this.IsSubsetOf` Full Usage: `this.IsSubsetOf` Parameters: arg0 : `Set<'T, 'ComparerTag>` Returns: `bool`	Evaluates to True if all elements of the second set are in the first. arg0 : `Set<'T, 'ComparerTag>` Returns: `bool`
`this.IsSupersetOf` Full Usage: `this.IsSupersetOf` Parameters: arg0 : `Set<'T, 'ComparerTag>` Returns: `bool`	Evaluates to True if all elements of the first set are in the second. arg0 : `Set<'T, 'ComparerTag>` Returns: `bool`
`this.Iterate` Full Usage: `this.Iterate` Parameters: arg0 : `'T -> unit`	Apply the given function to each binding in the collection. arg0 : `'T -> unit`
`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`
`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`
`this.Partition` Full Usage: `this.Partition` Parameters: predicate : `'T -> bool` Returns: `Set<'T, 'ComparerTag> * Set<'T, 'ComparerTag>`	Build two new sets, one containing the elements for which the given predicate returns True, and another with the remaining elements. predicate : `'T -> bool` Returns: `Set<'T, 'ComparerTag> * Set<'T, 'ComparerTag>`
`this.Remove` Full Usage: `this.Remove` Parameters: arg0 : `'T` Returns: `Set<'T, 'ComparerTag>`	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. arg0 : `'T` Returns: `Set<'T, 'ComparerTag>`
`this.ToArray` Full Usage: `this.ToArray` Returns: `'T array`	The elements of the set as an array. Returns: `'T array`
`this.ToList` Full Usage: `this.ToList` Returns: `'T list`	The elements of the set as a list. Returns: `'T list`

Static members

Static member	Description
`arg0 + arg1` Full Usage: `arg0 + arg1` Parameters: arg0 : `Set<'T, 'ComparerTag>` arg1 : `Set<'T, 'ComparerTag>` Returns: `Set<'T, 'ComparerTag>`	Compute the union of the two sets. arg0 : `Set<'T, 'ComparerTag>` arg1 : `Set<'T, 'ComparerTag>` Returns: `Set<'T, 'ComparerTag>`
`arg0 - arg1` Full Usage: `arg0 - arg1` Parameters: arg0 : `Set<'T, 'ComparerTag>` arg1 : `Set<'T, 'ComparerTag>` Returns: `Set<'T, 'ComparerTag>`	Return a new set with the elements of the second set removed from the first. arg0 : `Set<'T, 'ComparerTag>` arg1 : `Set<'T, 'ComparerTag>` Returns: `Set<'T, 'ComparerTag>`
`Set.Compare(a, b)` Full Usage: `Set.Compare(a, b)` Parameters: a : `Set<'T, 'ComparerTag>` b : `Set<'T, 'ComparerTag>` Returns: `int`	Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b. a : `Set<'T, 'ComparerTag>` b : `Set<'T, 'ComparerTag>` Returns: `int`
`Set.Create(arg1, arg2)` Full Usage: `Set.Create(arg1, arg2)` Parameters: arg0 : `'ComparerTag` arg1 : `'T seq` Returns: `Set<'T, 'ComparerTag>`	A set based on the given comparer containing the given initial elements. arg0 : `'ComparerTag` arg1 : `'T seq` Returns: `Set<'T, 'ComparerTag>`
`Set.Difference(arg1, arg2)` Full Usage: `Set.Difference(arg1, arg2)` Parameters: arg0 : `Set<'T, 'ComparerTag>` arg1 : `Set<'T, 'ComparerTag>` Returns: `Set<'T, 'ComparerTag>`	Return a new set with the elements of the second set removed from the first. arg0 : `Set<'T, 'ComparerTag>` arg1 : `Set<'T, 'ComparerTag>` Returns: `Set<'T, 'ComparerTag>`
`Set.Empty(arg1)` Full Usage: `Set.Empty(arg1)` Parameters: arg0 : `'ComparerTag` Returns: `Set<'T, 'ComparerTag>`	The empty set based on the given comparer. arg0 : `'ComparerTag` Returns: `Set<'T, 'ComparerTag>`
`Set.Equality(arg1, arg2)` Full Usage: `Set.Equality(arg1, arg2)` Parameters: arg0 : `Set<'T, 'ComparerTag>` arg1 : `Set<'T, 'ComparerTag>` Returns: `bool`	Compares two sets and returns True if they are equal or False otherwise. arg0 : `Set<'T, 'ComparerTag>` arg1 : `Set<'T, 'ComparerTag>` Returns: `bool`
`Set.Intersection(arg1, arg2)` Full Usage: `Set.Intersection(arg1, arg2)` Parameters: arg0 : `Set<'T, 'ComparerTag>` arg1 : `Set<'T, 'ComparerTag>` Returns: `Set<'T, 'ComparerTag>`	Compute the intersection of the two sets. arg0 : `Set<'T, 'ComparerTag>` arg1 : `Set<'T, 'ComparerTag>` Returns: `Set<'T, 'ComparerTag>`
`Set.Singleton(arg1, arg2)` Full Usage: `Set.Singleton(arg1, arg2)` Parameters: arg0 : `'ComparerTag` arg1 : `'T` Returns: `Set<'T, 'ComparerTag>`	A singleton set based on the given comparison operator. arg0 : `'ComparerTag` arg1 : `'T` Returns: `Set<'T, 'ComparerTag>`
`Set.Union(arg1, arg2)` Full Usage: `Set.Union(arg1, arg2)` Parameters: arg0 : `Set<'T, 'ComparerTag>` arg1 : `Set<'T, 'ComparerTag>` Returns: `Set<'T, 'ComparerTag>`	Compute the union of the two sets. arg0 : `Set<'T, 'ComparerTag>` arg1 : `Set<'T, 'ComparerTag>` Returns: `Set<'T, 'ComparerTag>`