## SetAlgebraType

`protocol SetAlgebraType`

A generalized set whose distinct elements are not necessarily disjoint.

In a model of `SetAlgebraType`, some elements may subsume other elements, where

`a` subsumes `b` iff `([a] as Self).isSupersetOf([b])`

In many models of `SetAlgebraType` such as `Set<T>`, `a` subsumes `b` if and only if `a == b`, but that is not always the case. For example, option sets typically do not satisfy that property.

Two elements are disjoint when neither one subsumes the other.

See Also: `OptionSetType`.

• Axioms, where `S` conforms to `SetAlgebraType`, `x` and `y` are of type `S`, and `e` is of type `S.Element`:

• `S() == []`

• `x.intersect(x) == x`
• `x.intersect([]) == []`
• `x.union(x) == x`
• `x.union([]) == x`
• `x.contains(e)` implies `x.union(y).contains(e)`
• `x.union(y).contains(e)` implies `x.contains(e) || y.contains(e)`
• `x.contains(e) && y.contains(e)` iff `x.intersect(y).contains(e)`
• `x.isSubsetOf(y)` iff `y.isSupersetOf(x)`
• `x.isStrictSupersetOf(y)` iff `x.isSupersetOf(y) && x != y`
• `x.isStrictSubsetOf(y)` iff `x.isSubsetOf(y) && x != y`
Inheritance `ArrayLiteralConvertible, Equatable` View Protocol Hierarchy → `Element` A type for which `Self` provides a containment test. `import Swift`

### Initializers

init() Required

Creates an empty set.

• Equivalent to `[] as Self`

#### Declaration

`init()`
init(_:)

Creates the set containing all elements of `sequence`.

#### Declaration

`init<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)`
init(arrayLiteral:)

Create an instance initialized with `elements`.

#### Declaration

`init(arrayLiteral elements: Self.Element...)`

#### Declared In

`ArrayLiteralConvertible`

### Instance Variables

var isEmpty: Bool

Return true iff `self.contains(e)` is `false` for all `e`.

#### Declaration

`var isEmpty: Bool { get }`

### Static Methods

static func element(_:isDisjointWith:)

Returns `true` iff `a` is disjoint with `b`.

Two elements are disjoint when neither one subsumes the other.

See Also: `Self.element(, subsumes:_)`

#### Declaration

`static func element(a: Self.Element, isDisjointWith b: Self.Element) -> Bool`
static func element(_:subsumes:)

Returns `true` iff `a` subsumes `b`.

• Equivalent to `([a] as Self).isSupersetOf([b])`

#### Declaration

`static func element(a: Self.Element, subsumes b: Self.Element) -> Bool`

### Instance Methods

func ==(_:rhs:) Required

Return true if `lhs` is equal to `rhs`.

Equality implies substitutability. When `x == y`, `x` and `y` are interchangeable in any code that only depends on their values.

Class instance identity as distinguished by triple-equals `===` is notably not part of an instance's value. Exposing other non-value aspects of `Equatable` types is discouraged, and any that are exposed should be explicitly pointed out in documentation.

Equality is an equivalence relation

• `x == x` is `true`
• `x == y` implies `y == x`
• `x == y` and `y == z` implies `x == z`

Inequality is the inverse of equality, i.e. `!(x == y)` iff `x != y`.

#### Declaration

`func ==(lhs: Self, rhs: Self) -> Bool`

#### Declared In

`Equatable`
func contains(_:) Required

Returns `true` if `self` contains `member`.

• Equivalent to `self.intersect([member]) == [member]`

#### Declaration

`func contains(member: Self.Element) -> Bool`
func exclusiveOr(_:) Required

Returns the set of elements contained in `self` or in `other`, but not in both `self` and `other`.

#### Declaration

`func exclusiveOr(other: Self) -> Self`
mutating func exclusiveOrInPlace(_:) Required

Replaces `self` with a set containing all elements contained in either `self` or `other`, but not both.

• Equivalent to replacing `self` with `self.exclusiveOr(other)`

#### Declaration

`mutating func exclusiveOrInPlace(other: Self)`
mutating func insert(_:) Required

If `member` is not already contained in `self`, inserts it.

• Equivalent to `self.unionInPlace([member])` Postcondition: `self.contains(member)`

#### Declaration

`mutating func insert(member: Self.Element)`
func intersect(_:) Required

Returns the set of elements contained in both `self` and `other`.

#### Declaration

`func intersect(other: Self) -> Self`
mutating func intersectInPlace(_:) Required

Removes all elements of `self` that are not also present in `other`.

• Equivalent to replacing `self` with `self.intersect(other)` Postcondition: `self.isSubsetOf(other)`

#### Declaration

`mutating func intersectInPlace(other: Self)`
func isDisjointWith(_:)

Return true iff `self.intersect(other).isEmpty`.

#### Declaration

`func isDisjointWith(other: Self) -> Bool`
func isSubsetOf(_:)

Return true iff every element of `self` is contained in `other`.

#### Declaration

`func isSubsetOf(other: Self) -> Bool`
func isSupersetOf(_:)

Return true iff every element of `other` is contained in `self`.

#### Declaration

`func isSupersetOf(other: Self) -> Bool`
mutating func remove(_:) Required

If `member` is contained in `self`, removes and returns it. Otherwise, removes all elements subsumed by `member` and returns `nil`.

Postcondition: `self.intersect([member]).isEmpty`

#### Declaration

`mutating func remove(member: Self.Element) -> Self.Element?`
func subtract(_:)

Return true iff `self.intersect(other).isEmpty`.

#### Declaration

`func subtract(other: Self) -> Self`
mutating func subtractInPlace(_:)

Removes all elements of `other` from `self`.

• Equivalent to replacing `self` with `self.subtract(other)`.

#### Declaration

`mutating func subtractInPlace(other: Self)`
func union(_:) Required

Returns the set of elements contained in `self`, in `other`, or in both `self` and `other`.

#### Declaration

`func union(other: Self) -> Self`
mutating func unionInPlace(_:) Required

Insert all elements of `other` into `self`.

• Equivalent to replacing `self` with `self.union(other)`. Postcondition: `self.isSupersetOf(other)`

#### Declaration

`mutating func unionInPlace(other: Self)`

### Default Implementations

init(_:)

Creates the set containing all elements of `sequence`.

#### Declaration

`init<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)`
init(arrayLiteral:)

Creates a set containing all elements of the given `arrayLiteral`.

This initializer allows an array literal containing `Self.Element` to represent an instance of the set, wherever it is implied by the type context.

#### Declaration

`init(arrayLiteral: Self.Element...)`
var isEmpty: Bool

Returns true iff `self.contains(e)` is `false` for all `e`.

#### Declaration

`var isEmpty: Bool { get }`
static func element(_:isDisjointWith:)

Returns `true` iff `a` is disjoint with `b`.

Two elements are disjoint when neither one subsumes the other.

See Also: `Self.element(, subsumes:_)`

#### Declaration

`static func element(a: Self.Element, isDisjointWith b: Self.Element) -> Bool`
static func element(_:subsumes:)

Returns `true` iff `a` subsumes `b`.

• Equivalent to `([a] as Self).isSupersetOf([b])`

#### Declaration

`static func element(a: Self.Element, subsumes b: Self.Element) -> Bool`
func isDisjointWith(_:)

Returns true iff `self.intersect(other).isEmpty`.

#### Declaration

`func isDisjointWith(other: Self) -> Bool`
func isStrictSubsetOf(_:)

Return true iff every element of `self` is contained in `other` and `other` contains an element that is not contained in `self`.

#### Declaration

`func isStrictSubsetOf(other: Self) -> Bool`
func isStrictSupersetOf(_:)

Returns true iff every element of `other` is contained in `self` and `self` contains an element that is not contained in `other`.

#### Declaration

`func isStrictSupersetOf(other: Self) -> Bool`
func isSubsetOf(_:)

Returns true iff every element of `self` is contained in `other`.

#### Declaration

`func isSubsetOf(other: Self) -> Bool`
func isSupersetOf(_:)

Returns true iff every element of `other` is contained in `self`.

#### Declaration

`func isSupersetOf(other: Self) -> Bool`
func subtract(_:)

Returns true iff `self.intersect(other).isEmpty`.

#### Declaration

`func subtract(other: Self) -> Self`
mutating func subtractInPlace(_:)

Removes all elements of `other` from `self`.

• Equivalent to replacing `self` with `self.subtract(other)`.

#### Declaration

`mutating func subtractInPlace(other: Self)`