Unique

Methods to strip repeated elements from a sequence or collection.

The uniqued() method returns a sequence, dropping duplicate elements from a sequence. The uniqued(on:) method does the same, using the result of the given closure to determine the "uniqueness" of each element.

let numbers = [1, 2, 3, 3, 2, 3, 3, 2, 2, 2, 1]

let unique = numbers.uniqued()
// Array(unique) == [1, 2, 3]

Detailed Design

Both methods are available for sequences, with the simplest limited to when the element type conforms to Hashable. Both methods preserve the relative order of the elements. uniqued(on:) has a matching lazy version that is added to LazySequenceProtocol.

extension Sequence where Element: Hashable {
    func uniqued() -> UniquedSequence<Self, Element>
}

extension Sequence {
    func uniqued<Subject>(on projection: (Element) throws -> Subject) rethrows -> [Element]
        where Subject: Hashable
}

extension LazySequenceProtocol {
    func uniqued<Subject>(on projection: @escaping (Element) -> Subject) -> UniquedSequence<Self, Subject>
        where Subject: Hashable
}

Complexity

The eager uniqued(on:) method is O(n) in both time and space complexity. The lazy versions are O(1).

Comparison with other languages

C++: The <algorithm> library defines a unique function that removes consecutive equal elements.

Ruby: Ruby defines a uniq() method that acts like uniqued(), as well as a variant that takes a mapping block to a property that should be unique, matching uniqued(on:).

Rust: Rust includes unique() and unique_by() methods that lazily compute the unique elements of a collection, storing the set of already seen elements in the iterator.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Unique.md

Unique.md

Unique

Files

Unique.md

Latest commit

History

Unique.md

File metadata and controls

Unique