Multiset

public struct Multiset<Element> where Element : Hashable

A Multiset is an unordered collection of hashable elements.

The Multiset collection has similarities with Set and Dictionary, two collections in the swift standard library The key difference from a set is that a Multiset can have repeated Elements. It does this by storing a dictionary (called ‘content’) of type [Element, Int].

Initialisation

A Multiset can be created by an array literal of type [Element] as in:

let ingredients: Multiset = ["coffee", "milk", "sugar", "sugar"]

or using variadic initialiser for two or more elements:

let fruit = Multiset("Apple", "Orange", "Apple")   // ["Apple":2, "Orange":1]
// But can't do Multiset("Apple") because "Apple" is seen as an array of Characters!)

or using a dictionary literal of type [Element:Int] as in:

let truth: Multiset = [true:3, false:2]

or from a sequence (which may include repeated elements):

let numbers: Multiset = [1000, 2000, 3000, 1000]  // [1000:2, 2000:1, 3000:1]

for an empty multiset you must specify the Generic Parameter:

let words:  Multiset<String> = []
let numbers = Multiset<Int>()

Inserting and Removing Elements

To insert elements:

var multi = Multiset<String>()    // []
multi.insert("Small")             // ["Small":1]
multi.insert("Small")             // ["Small":2]
multi.insert("Big", count: 6)     // ["Small":2, "Big"]

To remove elements:

var multi: Multiset = [1000:1, 2000:1, 3000:10]
multi.remove(1000)                // [2000:1, 3000:10]
multi.remove(3000, count: 3)      // [2000:1, 3000:7]
multi.remove(3000, count: 3)      // [2000:1, 3000:7]

If there aren’t enough elements then remove will not remove any of them and this is indicated by the function returning false:

var multi: Multiset = [2000:1, 3000:7]
let resulta = multi.remove(7777)      // resulta is false
let resultb = multi.remove(3000, count: 10)  // resultb is false

Or to remove as many as are available then use the isPossible override:

var multi: Multiset = [2000:1, 3000:7]
let resulta = multi.remove(ifPossible: 3000, count: 100)  // resulta is 7 and multi is [2000:1]
let resultb = multi.remove(ifPossible: 3000:100)  // resultb is false

To remove all of certain elements:

var multi: Multiset = ["AAA":3, "BBB":4, "CCC":4]
multi.removeAll("AAA")   // ["BBB":4, "CCC":4]
multi.removeAll()        // []

To just set the number of a certain type of element:

var truth: Multiset = [true:3, false:4]
truth.update(count: 5, for: true)    // [true:5, false:4]
truth.update(count: 0, for: false)   // [true:5]
truth.update(count: 7, for: false)   // [true:5, false:7]

Iterating

There are 3 ways to iterate through a multiset:

1) To iterate through all the elements of a multiset:

for size in Multiset(["Big":3, "Small":2]) {
    print(size)
}
Note that elements of the same type will come grouped together
but the order of different groups is not defined so:
either prints "Big"   "Big"   "Big" "Small" "Small"
or     prints "Small" "Small" "Big" "Big"   "Big"

2) To iterate through groups of different types of elements use grouped()

for (element, count) in Multiset(["Big":3, "Small":2]).grouped() {
    print(element, count)
}
Note that the order of the elements is not defined so:
either prints ("Big",3)    and then  ("Small":2)
or     prints ("Small":2)  and then  ("Big",3)

3) To iterate through just the distinct elements of a multiset use distinct():

for size in Multiset(["Big":3, "Small":2]).distinct() {
    print(size)
}
Note that the order of the elements is not defined so:
either prints "Big"    and then  "Small"
or     prints "Small"  and then  "Big"

Sequence and Collection Operations

In addition to the Multiset type’s multiset operations, you can use any nonmutating sequence or collection methods with a multiset.

let factorsOf12: Multiset = [2:2, 3:1]
if factorsOf12.isEmpty {
    print("No factors")
} else {
    print("Twelve has \(factorsOf12.count) factors.")
    print("Twelve has \(factorsOf12.distinctCount) distinct factors.")
}
// Prints "Twelve has 3 factors."
// Prints "Twelve has 2 distinct factors."

let factorsProduct = factors.reduce(1, *)
// 'factorsProduct' == 12

let factorsStrings = factors.sorted().map(String.init)
// 'primeStrings' == ["2", "2", "3"]

And as a collection you can use index operations:

var multi: Multiset = ["AA":3, "BB":3]
if let index = multi.firstIndex(of: "BB") {
    multi.remove(at: index)     // ["AA":3, "BB":2]
 }

Set Algebra Operations

Multiset provides the Set Algebra operations which are the same as the ones used by Set. You can test a multiset for membership of an element or check its intersection with other multisets:

contains(_:) tests whether a multiset contains a specific element.

equal to operator (==) tests whether two multisets contain the same elements and the sanem number of those elements.

isSubset(of:) tests whether another multiset contains at least as many of each of the current multisets elements.

isSuperset(of:) tests whether a multiset contains at least as many of each of another multisets elements.

isStrictSubset(of:) and isStrictSuperset(of:) test whether a multiset is a subset or superset of, but not equal to, another multiset.

isDisjoint(with:) tests whether a multiset has any elements in common with another multiset.

Note

Note that when multisets have more than one of the same element some of these operations may not be as obvious as with sets. For example even though: AAB = Multiset([A:2, B:1]) and ABB = Multiset([A:2, B:1]) both contains A and B and no other elements, neither contains the other.

You can also combine, exclude, or subtract the elements of two multisets:

union(_:) creates a new multiset with the elements of a multiset and another multiset or sequence.

intersection(_:) creates a new multiset with only the elements common to a multiset and another multiset or sequence.

symmetricDifference(_:) creates a new multiset with the elements that are in either a multiset or another multiset or sequence, but not in both.

subtracting(_:) creates a new multiset with the elements of a multiset that are not also in another multiset or sequence.

Note

Note that when multisets have more than one of the same element some of these operations may not be as obvious as with sets. For example if: AAB = Multiset([A:2, B:1]) and ABC = Multiset([A:1, B:1, C:1]) then AAB.symmetricDifference(ABC) is Multiset([A:1, C:1])

You can modify a multiset in place by using these mutating methods: formUnion(_:), formIntersection(_:), formSymmetricDifference(_:), and subtract(_:).

Multiset operations are not limited to use with other multisets. You can perform many operations with sets, arrays or any sequence with the same Element type:

let word = Multiset(Array("SINS"))
word is now ["S":2, "I":1, "N":1] although Multisets are not ordered so may
be a different order.

let scrabbleHand: [Character] = ["MISSING"]

// Tests whether the characters of the word SINS can be found in the
 // array of characters MISSING:
print(word.isSubset(of: scrabbleHand) )
// Prints "true"

// Performs an intersection with an Array<Int>
let primes: Multiset = [2, 3, 5, 7, 11, 13, 17, 19, 23]
let favoriteNumbers = [5, 7, 15, 21]
print(primes.intersection(favoriteNumbers))
// Prints "[5, 7]"

Other reading

Because Multiset has some similarity with both Set and Dictionary, reading the documentation or source for those may also be useful:

https://github.com/apple/swift/blob/master/stdlib/public/core/Set.swift https://github.com/apple/swift/blob/master/stdlib/public/core/Dictionary.swift


                    
                    
                    init()

Creates an empty multiset:

let empty = Multiset<Int>()
print(empty.isEmpty)   // Prints "true"

Declaration

Swift

public init()


                    
                    
                    init(_:)

Create a Multiset from another dictionary:

let multi = Multiset(["A":2, "B":1, "C":5])
let multi2 = Multiset(multi)
print(multi2)    //Prints ["A":2, "B":1, "C":5])

Declaration

Swift

public init(_ dictionary: Dictionary<Element, Int>)


                    
                    
                    init(_:)

Create a new multiset from a finite sequence of items:

let validIndices = Multiset([7,8,7,1,2])
print(validIndices)    //Prints "[7:2, 8:1, 1:1, 2:1]"    (order of elements may vary)

Declaration

Swift

public init<Source: Sequence>(_ sequence: Source)
  where Source.Element == Element


                    
                    
                    init(_:_:_:)

Create a new multiset from a variadic sequence of 2 or more items:

let truth = Multiset(true, false, true, true)
print(truth)    //Prints "[true:3, false:1]"    (order of elements may vary)

Declaration

Swift

public init(_ firstElement: Element, _ secondElement: Element, _ remainingElements: Element...)

init(minimumCapacity:)
Create an empty Multiset with preallocated capacity.

Note that the capacity is the number of unique elements. Multiple copies of the same element don’t require more space because only one copy of each distinct element is stored along with a count of the number of that element.
```
var multi = Multiset<Int>(minimumCapacity: 100)
```
Declaration
Swift

public init(minimumCapacity: Int)


                    
                    
                    capacity

Get capacity of the underlying dictionary

var multi = Multiset<Int>(minimumCapacity: 100)
print(multi.capacity)
// Prints 100

Declaration

Swift

public var capacity: Int { get }


                    
                    
                    reserveCapacity(_:)

Set capacity of the underlying dictionary

var multi = Multiset<Int>()
multi.reserveCapacity(100)
print(multi.capacity)
// Prints 100

Declaration

Swift

public mutating func reserveCapacity(_ minimumCapacity: Int)

init(arrayLiteral:)
Create a multiset containing the elements of the given array literal.

Note that [unlike Set], if the array has repeated items they will be included. Note that the same element can be repeated. A multiset is unordered so the order may not be preserved. (Do not call this initializer directly. It is used by the compiler when you use an array literal.)
```
let drink: Multiset = ["coffee", "milk", "sugar", "sugar"]
print(drink)    // Prints ["sugar":2, "milk":1, "coffee":1]
```
Declaration
Swift

public init(arrayLiteral elements: Element...)

init(dictionaryLiteral:)
Creates a multiset containing the elements of the given dictionary literal.

The values of the Dictionary must be integers representing the number of each element. If a count of zero is used then the element will not be added to the multiset. A multiset is unordered so the order may not be preserved. (Do not call this initializer directly. It is used by the compiler when you use a dictionary literal.)
```
let drink: Multiset = ["coffee":1, "milk":1, "sugar":2, "sweetener":0]
print(drink)    // Prints ["sugar":2, "milk":1, "coffee":1]
```
Declaration
Swift

public init(dictionaryLiteral elements: (Element, Int)...)

count
The number of elements in the multiset

Note that if an element is repeated twice then that counts 2.
```
let multi: Multiset = ["A":2, "B":4]
print(multi.count)    // Prints 6
```
Declaration
Swift

public var count: Int { get }


                    
                    
                    distinctCount

The number of distinct elements in the multiset.

let multi: Multiset = ["A":2, "B":4]
print(multi.distinctCount)    // Prints 2

Declaration

Swift

public var distinctCount: Int { get }


                    
                    
                    count(of:)

The number of elements of a particular type in the multiset.

[In mathematics know as multiplicity]

let multi: Multiset = ["A":2, "B":4]
print(multi.count(of: "B"))    // Prints 4

Declaration

Swift

public func count(of element: Element) -> Int


                    
                    
                    insert(_:count:)

Insert a number of equal elements (or one if no count specified)

var multi = Multiset<String>()  // []
multi.insert("Big", count: 6)   // ["Big":6]
multi.insert("Small")           // ["Big":6, "Small":1]

Note that insert is overloaded slightly oddly to satisfy SetAlgebra.

Declaration

Swift

public mutating func insert(_ newElement: Element, count: Int = 1)


                    
                    
                    remove(_:count:)

Remove a number of equal elements (or one if no count specified)

If all are not availble to remove then don’t remove any and return false

var multi = Multiset(["Big":6, "Small":3])    // ["Big":6, "Small":3]
multi.remove("Big", count:2)                  // ["Big":4, "Small":3]
multi.remove("Small")                         // ["Big":4, "Small":2]
print(multi.remove("Small",count:10))         // Prints false

Declaration

Swift

@discardableResult
public mutating func remove(_ element: Element, count: Int = 1) -> Bool


                    
                    
                    remove(ifPossible:count:)

Remove a number of equal elements as possible (try for just one if no count specified)

If all are not available to remove then just remove as many as possible Return the number removed

var multi = Multiset(["Big":6, "Small":3])           //                  multi is now ["Big":6, "Small":3]
print(multi.remove(ifPossible: "Big", count:2))      // Prints 2         multi is now ["Big":4, "Small":3]
print(multi.remove(ifPossible: "Big"))               // Prints 1         multi is now ["Big":3, "Small":3]
print(multi.remove(ifPossible: "Small", count: 5))   // Prints 3         multi is now ["Big":3]
print(multi.remove(ifPossible: "Medium"))            // Prints 0         multi is now ["Big":3]

Declaration

Swift

@discardableResult
public mutating func remove(ifPossible element: Element, count: Int = 1) -> Int


                    
                    
                    removeAll(_:)

Remove all of a particular element

Returns the count of the number of elements removed

var multi = Multiset(["Big":6, "Small":3])    //               multi is now ["Big":6, "Small":3]
print(multi.removeAll("Small"))               // Prints 3      multi is now ("Big", 6)

Declaration

Swift

@discardableResult
public mutating func removeAll(_ element: Element) -> Int


                    
                    
                    removeAll(_:)

Remove all occurrences of a sequence of elements

Returns the count of the number of elements removed

var multi = Multiset(["Big":6, "Medium":2, "Small":3])    //               multi is now ["Big":6, "Medium":2, "Small":3]
print(multi.removeAll(["Small","Medium"]))                // Prints 5      multi is now ("Big", 6)

Declaration

Swift

@discardableResult
public mutating func removeAll<Source>(_ sequence: Source) -> Int where Element == Source.Element, Source : Sequence

removeAll(keepingCapacity:)
Removes all elements from the multiset

If keepingCapacity = true, the multiset’s buffer capacity is preserved
Declaration
Swift

public mutating func removeAll(keepingCapacity keepCapacity: Bool = false)


                    
                    
                    filter(_:)

Returns a new multiset containing the elements of the multiset that satisfy the given predicate.

let cast: Multiset = ["Vivien", "Marlon", "Kim", "Karl"]
let shortNames = cast.filter { $0.count < 5 }
print(shortNames.isSubset(of: cast))    // Prints true
shortNames.contains("Vivien")    // Prints false

isIncluded ia a closure that takes an element as its argument and returns a Bool value indicating whether the element should be included.

Declaration

Swift

public func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> Multiset


                    
                    
                    MultisetIterator

This iterator works through each element in the dictionary

Multiset is not ordered so the order is not predictable but the same elements will always come together.

for element in Multiset(["Red":2, "Yellow":1]) { print(element) }
// Prints either:        "Yellow" then "Yellow" then "Red"
// or:                   "Red"    then "Yellow" then "Yellow"
// but would never get:  "Yellow" then "Red"    then "Yellow"

Declaration

Swift

public struct MultisetIterator<Element> : IteratorProtocol where Element : Hashable


                    
                    
                    makeIterator()

Declaration

Swift

public func makeIterator() -> MultisetIterator<Element>


                    
                    
                    Index

Declaration

Swift

public typealias Index = MultisetIndex<Element>

startIndex
The starting position for iterating members of the multiset.

If the multiset is empty, startIndex is equal to endIndex.
Declaration
Swift

public var startIndex: Index { get }
endIndex
The past the end position for the multiset—that is, the position one greater than the last valid subscript argument.

If the multiset is empty, endIndex is equal to startIndex.
Declaration
Swift

public var endIndex: Index { get }
subscript(_:)
Accesses the member at the given position.
Declaration
Swift

public subscript(index: Index) -> Element { get }


                    
                    
                    index(after:)

Finds the index which immediately follows the given index

Declaration

Swift

public func index(after index: MultisetIndex<Element>) -> MultisetIndex<Element>

firstIndex(of:)
Returns the index of the first given element in the set, or nil if the element is not a member of the set.
Declaration
Swift

public func firstIndex(of element: Element) -> Index?
first
The first element of the multiset.

The first element of the set is not necessarily the first element added to the set. Don’t expect any particular ordering of set elements. If the set is empty, the value of this property is nil.
Declaration
Swift

public var first: Element? { get }


                    
                    
                    remove(at:)

Removes the element at the given index of the multiset.

Declaration

Swift

@discardableResult
public mutating func remove(at position: Index) -> Element


                    
                    
                    description

A string that represents the contents of the multiset.

let multi = Multiset(["A":2, "B":1, "C":5])
print(multi)    //Prints ["A":2, "B":1, "C":5])

Declaration

Swift

public var description: String { get }


                    
                    
                    debugDescription

A string that represents the contents of the set, suitable for debugging.

let multi = Multiset(["A":2, "B":1, "C":5])
print(multi)    //Prints Multiset["A":2, "B":1, "C":5])

Declaration

Swift

public var debugDescription: String { get }

==(_:_:)
Returns a Boolean value indicating whether two multisets are equal
Declaration
Swift

public static func == (lhs: Multiset<Element>, rhs: Multiset<Element>) -> Bool

hash(into:)
Hashes the essential components of this value by feeding them into the given hasher.
Declaration
Swift

public func hash(into hasher: inout Hasher) -> <<error type>>


                    
                    
                    contains(_:)

Returns a Boolean value that indicates whether the given element exists in the multiset.

let fruit: Multiset = ["Orange":2, "Lemon":5]
if fruit.contains("Orange") {
  print("Found it")    // Prints "Found it"
}

Declaration

Swift

public func contains(_ member: Element) -> Bool


                    
                    
                    union(_:)

Returns a new multiset with elements from this multiset and the given multiset.

If both multisets have some of the same element then the new multiset will have the more numerous of the two.

let juicy: Multiset = ["Orange":2, "Lemon":5]
let yellow: Multiset = ["Lemon":3, "Melon":1]
let juicyOrYellow = juicy.union(yellow)    // ["Orange":2, "Lemon":5, "Melon":1]  (Order may vary)

Declaration

Swift

public func union(_ other: Multiset<Element>) -> Multiset<Element>


                    
                    
                    intersection(_:)

Returns a new multiset with elements that are common to both this multiset and the given multiset.

If both multisets have some of the same element then the new multiset will have the least numerous of the two.

let juicy: Multiset = ["Orange":2, "Lemon":5]
let yellow: Multiset = ["Lemon":3, "Melon":1]
let juicyAndYellow = juicy.intersection(yellow)    // ["Lemon":3]

Declaration

Swift

public func intersection(_ other: Multiset<Element>) -> Multiset<Element>


                    
                    
                    symmetricDifference(_:)

Returns a new multiset with elements that are in either this multiset or the given multiset, but not both.

If both sets have some of the same element then the new multiset will have the difference between the two.

let juicy: Multiset = ["Orange":2, "Lemon":5]
let yellow: Multiset = ["Lemon":3, "Melon":1]
let juicyExclusiveOrYellow = juicy.symmetricDifference(yellow)    // ["Orange":2, "Lemon":2, "Melon":1]  (Order may vary)

Declaration

Swift

public func symmetricDifference(_ other: Multiset<Element>) -> Multiset<Element>


                    
                    
                    subtracting(_:)

Returns a new multiset with elements that are in this multiset but NOT in the given multiset.

If both sets have some of the same element then the new multiset will have the difference between the two.

let juicy: Multiset = ["Orange":2, "Lemon":5]
let yellow: Multiset = ["Lemon":3, "Melon":1]
let juicyButNotYellow = juicy.subtracting(yellow)    // ["Orange":2, "Lemon":2]  (Order may vary)

Declaration

Swift

public func subtracting(_ other: Multiset<Element>) -> Multiset<Element>

isSubset(of:)
Returns a Boolean value that indicates whether this multiset is a subset of the given multiset.

If both multisets have some of the same element then this multiset must have less than or the same number of elements as the given multiset.
```
let stock: Multiset = ["Red":5, "Blue":3, "Yellow":1]
let shopping: Multiset = ["Red":5, "Blue":1]
print(shopping.isSubset(of: stock))    // Prints "true"
```
Declaration
Swift

public func isSubset(of other: Multiset<Element>) -> Bool


                    
                    
                    isDisjoint(with:)

Returns a Boolean value that indicates whether this multiset is disjoint from the given multiset.

If both multisets contain the same element then the sets will not be disjoint

let stock: Multiset = ["Red":5, "Blue":3, "Yellow":1]
let shopping: Multiset = ["Red":1, "Orange":10]
print(shopping.isDisjoint(with: stock))    // Prints "false"

Declaration

Swift

public func isDisjoint(with other: Multiset<Element>) -> Bool

isSuperset(of:)
Returns a Boolean value that indicates whether this multiset is a superset of the given multiset.

If both multisets have some of the same element then this multiset must have more than or the same number of elements as the given multiset.
```
let stock: Multiset = ["Red":5, "Blue":3, "Yellow":1]
let shopping: Multiset = ["Red":5, "Blue":1]
print(stock.isSuperset(of: shopping))    // Prints "true"
```
Declaration
Swift

public func isSuperset(of other: Multiset<Element>) -> Bool
isEmpty
A Boolean value that indicates whether the multiset is empty.
Declaration
Swift

public var isEmpty: Bool { get }


                    
                    
                    insert(_:)

Inserts the given element in the multiset. Note that if the element is already in the multiset then it increases the count of that element.

var fruit: Multiset = ["Orange":2, "Lemon":1]
fruit.insert("Orange")    // ["Orange":3, "Lemon":1]

Note that insert is overloaded slightly oddly to satisfy SetAlgebra.

Declaration

Swift

@discardableResult
public mutating func insert(_ newMember: Element) -> (inserted: Bool, memberAfterInsert: Element)

update(with:)
Updates the element in the multiset.

Note that this is not meaningful for a multiset because the value is always just an Integer but this function needs to be included to conform to Setalgebra. Recommend to not use this.
Declaration
Swift

@discardableResult public mutating func update(with newMember: Element) -> Element?


                    
                    
                    remove(_:)

Removes one of the given element from the multiset.

Return the element or nil if no element to remove. If there are two or more of the given element then decrease the count of that element by one.

var fruit: Multiset = ["Orange":3, "Lemon":1]
fruit.remove("Orange")    // ["Orange":2, "Lemon":1]  (Order may vary)
fruit.remove("Lemon")     // ["Orange":2]

Declaration

Swift

@discardableResult
public mutating func remove(_ member: Element) -> Element?

formUnion(_:)
MARK: Mutating set functions: union, intersection, symmetricDifference, subtract Mutating version of union
Declaration
Swift

public mutating func formUnion(_ other: Multiset<Element>)


                    
                    
                    formIntersection(_:)

Mutating version of intersection

Declaration

Swift

public mutating func formIntersection(_ other: Multiset<Element>)

formSymmetricDifference(_:)
Mutating version of symmetricDifference
Declaration
Swift

public mutating func formSymmetricDifference(_ other: Multiset<Element>)


                    
                    
                    subtract(_:)

Mutating version of subtracting

Declaration

Swift

public mutating func subtract(_ other: Multiset<Element>)

isStrictSubset(of:)
As for isSubset but if the two multisets are equal then return false
Declaration
Swift

public func isStrictSubset(of other: Multiset<Element>) -> Bool
isStrictSuperset(of:)
As for isSuperset but if the two multisets are equal then return false
Declaration
Swift

public func isStrictSuperset(of other: Multiset<Element>) -> Bool

init(_:)
MARK: Initialisers: Create a new multiset from a finite sequence of (element, count) tuples: let multi = Multiset([(A,8),(B,3)]) print(multi) //Prints [A:8,B":3] (order of elements may vary)
Declaration
Swift

public init<Source: Sequence>(_ sequence: Source) where Source.Element == (Element, Int)


                    
                    
                    isSubset(of:)

SEQUENCE VERSION OF: func isSubset(of other: Self) -> Bool

As for isSubset but using a sequence of Elements rather than another multiset.

let lunch: Multiset = ["Spam":2, "Egg":1]
print(lunch.isSubset(of: ["Spam", "Spam", "Spam", "Spam", "Egg"]))    // Prints "true"    X)

Declaration

Swift

public func isSubset<S: Sequence>(of possibleSuperset: S) -> Bool
  where S.Element == Element


                    
                    
                    isStrictSubset(of:)

SEQUENCE VERSION OF: func isStrictSubset(of other: Self) -> Bool {

As for isStrictSubset but using a sequence of Elements rather than another multiset.

let lunch: Multiset = ["Sandwich":1, "Apple":2]
print(lunch.isSubset(of: ["Sandwich", "Apple", "Apple"]))    // Prints "false"

Declaration

Swift

public func isStrictSubset<S: Sequence>(of possibleStrictSuperset: S) -> Bool
  where S.Element == Element


                    
                    
                    isSuperset(of:)

SEQUENCE VERSION OF: func isSuperset(of other: Self) -> Bool

As for isSuperset but using a sequence of Elements rather than another multiset.

let menu: Multiset = ["Sandwich":3, "Apple":2]
print(menu.isSuperset(of: ["Sandwich", "Apple", "Apple"]))    // Prints "true"

Declaration

Swift

public func isSuperset<S: Sequence>(of possibleSubset: S) -> Bool
  where S.Element == Element

isStrictSuperset(of:)
SEQUENCE VERSION OF: func isStrictSuperset(of other: Self) -> Bool {

As for isStrictSuperset but using a sequence of Elements rather than another multiset.

let menu: Multiset = [Sandwich:3, Apple:2] print(menu.isStrictSuperset(of: [Sandwich, Apple, Apple])) // Prints true
Declaration
Swift

public func isStrictSuperset<S: Sequence>(of possibleStrictSubset: S) -> Bool where S.Element == Element


                    
                    
                    isDisjoint(with:)

SEQUENCE VERSION OF: func isDisjoint(with other: Self) -> Bool

As for isDisjoint but using a sequence of Elements rather than another multiset.

let birds: Multiset = ["Duck":2]
print(birds.isDisjoint(with: ["Not a duck", "Horse"]))    // Prints "true"

Declaration

Swift

public func isDisjoint<S: Sequence>(with other: S) -> Bool
  where S.Element == Element

union(_:)
SEQUENCE VERSION OF: func union(_ other: Self) -> Self

As for union but using a sequence of Elements rather than another multiset.
Declaration
Swift

public func union<S: Sequence>(_ other: S) -> Multiset<Element> where S.Element == Element
intersection(_:)
SEQUENCE VERSION OF: func intersection(_ other: Self) -> Self

As for intersection but using a sequence of Elements rather than another multiset.
Declaration
Swift

public func intersection<S: Sequence>(_ other: S) -> Multiset<Element> where S.Element == Element
symmetricDifference(_:)
SEQUENCE VERSION OF: func symmetricDifference(_ other: Self) -> Self

As for symmetricDifference but using a sequence of Elements rather than another multiset.
Declaration
Swift

public func symmetricDifference<S: Sequence>(_ other: S) -> Multiset<Element> where S.Element == Element
subtracting(_:)
SEQUENCE VERSION OF: func subtracting(_ other: Self) -> Self

As for subtracting but using a sequence of Elements rather than another multiset.
Declaration
Swift

public func subtracting<S: Sequence>(_ other: S) -> Multiset<Element> where S.Element == Element
formUnion(_:)
SEQUENCE VERSION OF: mutating func formUnion(_ other: Self)

As for formUnion but using a sequence of Elements rather than another multiset.
Declaration
Swift

public mutating func formUnion<S: Sequence>(_ other: S) where S.Element == Element
formIntersection(_:)
As for formIntersection but using a sequence of Elements rather than another multiset.
Declaration
Swift

public mutating func formIntersection<S: Sequence>(_ other: S) where S.Element == Element
formSymmetricDifference(_:)
As for formSymmetricDifference but using a sequence of Elements rather than another multiset.
Declaration
Swift

public mutating func formSymmetricDifference<S: Sequence>(_ other: S) where S.Element == Element
subtract(_:)
As for subtract but using a sequence of Elements rather than another multiset.
Declaration
Swift

public mutating func subtract<S: Sequence>(_ other: S) where S.Element == Element