AdjacentPairsSequence
A sequence of adjacent pairs of elements built from an underlying sequence.
struct AdjacentPairsSequence<Base> where Base : Sequence
Use the adjacentPairs()
method on a sequence to create an AdjacentPairsSequence
instance.
A sequence of adjacent pairs of elements built from an underlying sequence.
struct AdjacentPairsSequence<Base> where Base : Sequence
Use the adjacentPairs()
method on a sequence to create an AdjacentPairsSequence
instance.
import Algorithms
Swift Algorithms is an open-source package of sequence and collection algorithms, along with their related types.
protocol Sequence<Element>
A type that provides sequential, iterated access to its elements.
struct AdjacentPairsCollection<Base> where Base : Collection
A collection of adjacent pairs of elements built from an underlying collection.
struct WindowsOfCountCollection<Base> where Base : Collection
A collection wrapper that presents a sliding window over the elements of a collection.
struct SplitSequence<Base> where Base : Sequence
A sequence that lazily splits a base sequence into subsequences separated by elements that satisfy the given whereSeparator
predicate.
struct SplitCollection<Base> where Base : Collection
A collection that lazily splits a base collection into subsequences separated by elements that satisfy the given whereSeparator
predicate.
protocol Copyable
A type whose values can be implicitly or explicitly copied.
protocol Escapable
var underestimatedCount: Int { get }
func makeIterator() -> Iterator
struct Iterator
The iterator for an AdjacentPairsSequence
or AdjacentPairsCollection
instance.
var lazy: LazySequence<Self> { get }
A sequence containing the same elements as this sequence, but on which some operations, such as map
and filter
, are implemented lazily.
func adjacentPairs() -> AdjacentPairsSequence<Self>
Returns a sequence of overlapping adjacent pairs of the elements of this sequence.
func allSatisfy(_ predicate: (Self.Element) throws -> Bool) rethrows -> Bool
Returns a Boolean value indicating whether every element of a sequence satisfies a given predicate.
func compactMap<ElementOfResult>(_ transform: (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 compacted<Unwrapped>() -> CompactedSequence<Self, Unwrapped> where Self.Element == Unwrapped?
Returns a new Sequence
that iterates over every non-nil element from the original Sequence
.
func contains(where predicate: (Self.Element) throws -> Bool) rethrows -> Bool
Returns a Boolean value indicating whether the sequence contains an element that satisfies the given predicate.
func count<E>(where predicate: (Self.Element) throws(E) -> Bool) throws(E) -> Int where E : Error
Returns the number of elements in the sequence that satisfy the given predicate.
func drop(while predicate: (Self.Element) throws -> Bool) rethrows -> DropWhileSequence<Self>
Returns a sequence by skipping the initial, consecutive elements that satisfy the given predicate.
func dropFirst(_ k: Int = 1) -> DropFirstSequence<Self>
Returns a sequence containing all but the given number of initial elements.
func dropLast(_ k: Int = 1) -> [Self.Element]
Returns a sequence containing all but the given number of final elements.
func elementsEqual<OtherSequence>(_ other: OtherSequence, by areEquivalent: (Self.Element, OtherSequence.Element) throws -> Bool) rethrows -> Bool where OtherSequence : Sequence
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(_ isIncluded: (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 predicate: (Self.Element) throws -> Bool) rethrows -> Self.Element?
Returns the first element of the sequence that satisfies the given predicate.
func firstNonNil<Result>(_ transform: (Element) throws -> Result?) rethrows -> Result?
Returns the first non-nil
result obtained from applying the given transformation to the elements of the sequence.
func flatMap<SegmentOfResult>(_ transform: (Self.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element] where SegmentOfResult : Sequence
Returns an array containing the concatenated results of calling the given transformation with each element of this sequence.
func forEach(_ body: (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 grouped<GroupKey>(by keyForValue: (Element) throws -> GroupKey) rethrows -> [GroupKey : [Element]] where GroupKey : Hashable
Groups up elements of self
into a new Dictionary, whose values are Arrays of grouped elements, each keyed by the group key returned by the given closure.
func interspersed(with separator: Element) -> InterspersedSequence<Self>
Returns a sequence containing elements of this sequence with the given separator inserted in between each element.
func keyed<Key>(by keyForValue: (Element) throws -> Key) rethrows -> [Key : Element] where Key : Hashable
Creates a new Dictionary from the elements of self
, keyed by the results returned by the given keyForValue
closure.
func keyed<Key>(by keyForValue: (Element) throws -> Key, resolvingConflictsWith resolve: (Key, Element, Element) throws -> Element) rethrows -> [Key : Element] where Key : Hashable
Creates a new Dictionary from the elements of self
, keyed by the results returned by the given keyForValue
closure. As the dictionary is built, the initializer calls the resolve
closure with the current and new values for any duplicate keys. Pass a closure as resolve
that returns the value to use in the resulting dictionary: The closure can choose between the two values, combine them to produce a new value, or even throw an error.
func lexicographicallyPrecedes<OtherSequence>(_ other: OtherSequence, by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> Bool where OtherSequence : Sequence, Self.Element == OtherSequence.Element
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, E>(_ transform: (Self.Element) throws(E) -> T) throws(E) -> [T] where E : Error
Returns an array containing the results of mapping the given closure over the sequence’s elements.
@warn_unqualified_access func max(by areInIncreasingOrder: (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 max(count: Int, sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> [Element]
Returns the largest elements of this sequence, as sorted by the given predicate.
@warn_unqualified_access func min(by areInIncreasingOrder: (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 min(count: Int, sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> [Element]
Returns the smallest elements of this sequence, as sorted by the given predicate.
func minAndMax(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> (min: Element, max: Element)?
Returns both the minimum and maximum elements in the sequence, using the given predicate as the comparison between elements.
func partitioned(by predicate: (Element) throws -> Bool) rethrows -> (falseElements: [Element], trueElements: [Element])
Returns two arrays containing the elements of the sequence that don’t and do satisfy the given predicate, respectively.
func prefix(_ maxLength: Int) -> PrefixSequence<Self>
Returns a sequence, up to the specified maximum length, containing the initial elements of the sequence.
func prefix(while predicate: (Self.Element) throws -> Bool) rethrows -> [Self.Element]
Returns a sequence containing the initial, consecutive elements that satisfy the given predicate.
func randomSample(count k: Int) -> [Element]
Randomly selects the specified number of elements from this sequence.
func randomSample<G>(count k: Int, using rng: inout G) -> [Element] where G : RandomNumberGenerator
Randomly selects the specified number of elements from this sequence.
func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (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 initialResult: Result, _ updateAccumulatingResult: (inout Result, Self.Element) throws -> ()) rethrows -> Result
Returns the result of combining the elements of the sequence using the given closure.
func reductions(_ transform: (Element, Element) throws -> Element) rethrows -> [Element]
Returns an array containing the accumulated results of combining the elements of the sequence using the given closure.
func reductions<Result>(_ initial: Result, _ transform: (Result, Element) throws -> Result) rethrows -> [Result]
Returns an array containing the accumulated results of combining the elements of the sequence using the given closure.
func reductions<Result>(into initial: Result, _ transform: (inout Result, Element) throws -> Void) rethrows -> [Result]
Returns an array containing the accumulated results of combining the elements of the sequence using the given closure.
func reversed() -> [Self.Element]
Returns an array containing the elements of this sequence in reverse order.
func shuffled() -> [Self.Element]
Returns the elements of the sequence, shuffled.
func shuffled<T>(using generator: inout T) -> [Self.Element] where T : RandomNumberGenerator
Returns the elements of the sequence, shuffled using the given generator as a source for randomness.
func sorted(by areInIncreasingOrder: (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(maxSplits: Int = Int.max, omittingEmptySubsequences: Bool = true, whereSeparator isSeparator: (Self.Element) throws -> Bool) rethrows -> [ArraySlice<Self.Element>]
Returns the longest possible subsequences of the sequence, in order, that don’t contain elements satisfying the given predicate. Elements that are used to split the sequence are not returned as part of any subsequence.
func starts<PossiblePrefix>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Self.Element, PossiblePrefix.Element) throws -> Bool) rethrows -> Bool where PossiblePrefix : Sequence
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 striding(by step: Int) -> StridingSequence<Self>
Returns a sequence stepping through the elements every step
starting at the first value. Any remainders of the stride will be trimmed.
func suffix(_ maxLength: Int) -> [Self.Element]
Returns a subsequence, up to the given maximum length, containing the final elements of the sequence.
func uniqued<Subject>(on projection: (Element) throws -> Subject) rethrows -> [Element] where Subject : Hashable
Returns an array with the unique elements of this sequence (as determined by the given projection), in the order of the first occurrence of each unique element.
func withContiguousStorageIfAvailable<R>(_ body: (UnsafeBufferPointer<Self.Element>) throws -> R) rethrows -> R?
func flatMap<ElementOfResult>(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
func scan(_ transform: (Element, Element) throws -> Element) rethrows -> [Element]
func scan<Result>(_ initial: Result, _ transform: (Result, Element) throws -> Result) rethrows -> [Result]
func scan<Result>(into initial: Result, _ transform: (inout Result, Element) throws -> Void) rethrows -> [Result]
protocol LazySequenceProtocol : Sequence
A sequence on which normally-eager sequence operations are implemented lazily.
var elements: Self { get }
Identical to self
.
func compactMap<ElementOfResult>(_ transform: @escaping (Self.Elements.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Self.Elements, ElementOfResult?>>, ElementOfResult>
Returns the non-nil
results of mapping the given transformation over this sequence.
func flatMap<SegmentOfResult>(_ transform: @escaping (Self.Elements.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Self.Elements, SegmentOfResult>>> where SegmentOfResult : Sequence
Returns the concatenated results of mapping the given transformation over this sequence.
func map<U>(_ transform: @escaping (Self.Element) -> U) -> LazyMapSequence<Self.Elements, U>
Returns a LazyMapSequence
over this Sequence
. The elements of the result are computed lazily, each time they are read, by calling transform
function on a base element.
func reductions<Result>(_ initial: Result, _ transform: @escaping (Result, Element) -> Result) -> ExclusiveReductionsSequence<Elements, Result>
Returns a sequence containing the accumulated results of combining the elements of the sequence using the given closure.
func reductions<Result>(into initial: Result, _ transform: @escaping (inout Result, Element) -> Void) -> ExclusiveReductionsSequence<Elements, Result>
Returns a sequence containing the accumulated results of combining the elements of the sequence using the given closure.
func uniqued<Subject>(on projection: @escaping (Element) -> Subject) -> UniquedSequence<Self, Subject> where Subject : Hashable
Returns a lazy sequence with the unique elements of this sequence (as determined by the given projection), in the order of the first occurrence of each unique element.
func flatMap<ElementOfResult>(_ transform: @escaping (Self.Elements.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Self.Elements, ElementOfResult?>>, ElementOfResult>
Returns the non-nil
results of mapping the given transformation over this sequence.
func scan<Result>(_ initial: Result, _ transform: @escaping (Result, Element) -> Result) -> ExclusiveReductionsSequence<Elements, Result>
func scan<Result>(into initial: Result, _ transform: @escaping (inout Result, Element) -> Void) -> ExclusiveReductionsSequence<Elements, Result>