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 →
Associated Types
Element

A type for which Self provides a containment test.

Import 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)