`func difference<C>(from: C) -> CollectionDifference<Self.Element>`

Returns the difference needed to produce this collection’s ordered elements from the given collection.

`func difference<C>(from: C, by: (C.Element, Self.Element) -> Bool) -> CollectionDifference<Self.Element>`

Returns the difference needed to produce this collection’s ordered elements from the given collection, using the given predicate as an equivalence test.

`func dropLast(Int) -> Self.SubSequence`

Returns a subsequence containing all but the specified number of final elements.

`func formIndex(before: inout Self.Index)`

Replaces the given index with its predecessor.

`func joined(separator: String) -> String`

Returns a new string by concatenating the elements of the sequence, adding the given separator between each element.

`func last(where: (Self.Element) throws -> Bool) rethrows -> Self.Element?`

Returns the last element of the sequence that satisfies the given predicate.

`func lastIndex(of: Self.Element) -> Self.Index?`

Returns the last index where the specified value appears in the collection.

`func lastIndex(where: (Self.Element) throws -> Bool) rethrows -> Self.Index?`

Returns the index of the last element in the collection that matches the given predicate.

`func reversed() -> ReversedCollection<Self>`

Returns a view presenting the elements of the collection in reverse order.

`func suffix(Int) -> Self.SubSequence`

Returns a subsequence, up to the given maximum length, containing the final elements of the collection.

`func drop(while: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence`

Returns a subsequence by skipping elements while `predicate`

returns `true`

and returning the remaining elements.

`func dropFirst(Int) -> Self.SubSequence`

Returns a subsequence containing all but the given number of initial elements.

`func firstIndex(of: Self.Element) -> Self.Index?`

Returns the first index where the specified value appears in the collection.

`func firstIndex(where: (Self.Element) throws -> Bool) rethrows -> Self.Index?`

Returns the first index in which an element of the collection satisfies the given predicate.

`func formIndex(inout Self.Index, offsetBy: Int)`

Offsets the given index by the specified distance.

`func formIndex(inout Self.Index, offsetBy: Int, limitedBy: Self.Index) -> Bool`

Offsets the given index by the specified distance, or so that it equals the given limiting index.

`func formIndex(after: inout Self.Index)`

Replaces the given index with its successor.

`func makeIterator() -> IndexingIterator<Self>`

Returns an iterator over the elements of the collection.

`func map<T>((Self.Element) throws -> T) rethrows -> [T]`

Returns an array containing the results of mapping the given closure over the sequence’s elements.

`func prefix(Int) -> Self.SubSequence`

Returns a subsequence, up to the specified maximum length, containing the initial elements of the collection.

`func prefix(through: Self.Index) -> Self.SubSequence`

Returns a subsequence from the start of the collection through the specified position.

`func prefix(upTo: Self.Index) -> Self.SubSequence`

Returns a subsequence from the start of the collection up to, but not including, the specified position.

`func prefix(while: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence`

Returns a subsequence containing the initial elements until `predicate`

returns `false`

and skipping the remaining elements.

`func randomElement() -> Self.Element?`

Returns a random element of the collection.

`func randomElement<T>(using: inout T) -> Self.Element?`

Returns a random element of the collection, using the given generator as a source for randomness.

`func split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Self.Element) throws -> Bool) rethrows -> [Self.SubSequence]`

Returns the longest possible subsequences of the collection, in order, that don’t contain elements satisfying the given predicate.

`func split(separator: Self.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Self.SubSequence]`

Returns the longest possible subsequences of the collection, in order, around elements equal to the given element.

`func suffix(from: Self.Index) -> Self.SubSequence`

Returns a subsequence from the specified position to the end of the collection.

`func index(Self.Index, offsetBy: Int, limitedBy: Self.Index) -> Self.Index?`

Returns an index that is the specified distance from the given index, unless that distance is beyond a given limiting index.

`func allSatisfy((Self.Element) throws -> Bool) rethrows -> Bool`

Returns a Boolean value indicating whether every element of a sequence satisfies a given predicate.

`func compactMap<ElementOfResult>((Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]`

Returns an array containing the non-`nil`

results of calling the given transformation with each element of this sequence.

`func contains(Self.Element) -> Bool`

Returns a Boolean value indicating whether the sequence contains the given element.

`func contains(where: (Self.Element) throws -> Bool) rethrows -> Bool`

Returns a Boolean value indicating whether the sequence contains an element that satisfies the given predicate.

`func elementsEqual<OtherSequence>(OtherSequence) -> Bool`

Returns a Boolean value indicating whether this sequence and another sequence contain the same elements in the same order.

`func elementsEqual<OtherSequence>(OtherSequence, by: (Self.Element, OtherSequence.Element) throws -> Bool) rethrows -> Bool`

Returns a Boolean value indicating whether this sequence and another sequence contain equivalent elements in the same order, using the given predicate as the equivalence test.

`func enumerated() -> EnumeratedSequence<Self>`

Returns a sequence of pairs (*n*, *x*), where *n* represents a consecutive integer starting at zero and *x* represents an element of the sequence.

`func filter((Self.Element) throws -> Bool) rethrows -> [Self.Element]`

Returns an array containing, in order, the elements of the sequence that satisfy the given predicate.

`func first(where: (Self.Element) throws -> Bool) rethrows -> Self.Element?`

Returns the first element of the sequence that satisfies the given predicate.

`func flatMap<SegmentOfResult>((Self.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element]`

Returns an array containing the concatenated results of calling the given transformation with each element of this sequence.

`func forEach((Self.Element) throws -> Void) rethrows`

Calls the given closure on each element in the sequence in the same order as a `for`

-`in`

loop.

`func joined() -> FlattenSequence<Self>`

Returns the elements of this sequence of sequences, concatenated.

`func joined(separator: String) -> String`

Returns a new string by concatenating the elements of the sequence, adding the given separator between each element.

`func joined<Separator>(separator: Separator) -> JoinedSequence<Self>`

Returns the concatenated elements of this sequence of sequences, inserting the given separator between each element.

`func lexicographicallyPrecedes<OtherSequence>(OtherSequence) -> Bool`

Returns a Boolean value indicating whether the sequence precedes another sequence in a lexicographical (dictionary) ordering, using the less-than operator (`<`

) to compare elements.

`func lexicographicallyPrecedes<OtherSequence>(OtherSequence, by: (Self.Element, Self.Element) throws -> Bool) rethrows -> Bool`

Returns a Boolean value indicating whether the sequence precedes another sequence in a lexicographical (dictionary) ordering, using the given predicate to compare elements.

`func map<T>((Self.Element) throws -> T) rethrows -> [T]`

Returns an array containing the results of mapping the given closure over the sequence’s elements.

`func max() -> Self.Element?`

Returns the maximum element in the sequence.

`func max(by: (Self.Element, Self.Element) throws -> Bool) rethrows -> Self.Element?`

Returns the maximum element in the sequence, using the given predicate as the comparison between elements.

`func min() -> Self.Element?`

Returns the minimum element in the sequence.

`func min(by: (Self.Element, Self.Element) throws -> Bool) rethrows -> Self.Element?`

Returns the minimum element in the sequence, using the given predicate as the comparison between elements.

`func reduce<Result>(Result, (Result, Self.Element) throws -> Result) rethrows -> Result`

Returns the result of combining the elements of the sequence using the given closure.

`func reduce<Result>(into: Result, (inout Result, Self.Element) throws -> ()) rethrows -> Result`

Returns the result of combining the elements of the sequence using the given closure.

`func shuffled() -> [Self.Element]`

Returns the elements of the sequence, shuffled.

`func shuffled<T>(using: inout T) -> [Self.Element]`

Returns the elements of the sequence, shuffled using the given generator as a source for randomness.

`func sorted() -> [Self.Element]`

Returns the elements of the sequence, sorted.

`func sorted(by: (Self.Element, Self.Element) throws -> Bool) rethrows -> [Self.Element]`

Returns the elements of the sequence, sorted using the given predicate as the comparison between elements.

`func split(separator: Self.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [ArraySlice<Self.Element>]`

Returns the longest possible subsequences of the sequence, in order, around elements equal to the given element.

`func starts<PossiblePrefix>(with: PossiblePrefix) -> Bool`

Returns a Boolean value indicating whether the initial elements of the sequence are the same as the elements in another sequence.

`func starts<PossiblePrefix>(with: PossiblePrefix, by: (Self.Element, PossiblePrefix.Element) throws -> Bool) rethrows -> Bool`

Returns a Boolean value indicating whether the initial elements of the sequence are equivalent to the elements in another sequence, using the given predicate as the equivalence test.

`func withContiguousStorageIfAvailable<R>((UnsafeBufferPointer<Self.Element>) throws -> R) rethrows -> R?`

Executes a closure on the sequence’s contiguous storage.