Generic Structure

LazyCollection

A collection containing the same elements as a Base collection, but on which some operations such as map and filter are implemented lazily.

Declaration

struct LazyCollection<Base> where Base : Collection

Overview

  • See also: LazySequenceProtocol, LazyCollection

Topics

Type Aliases

typealias LazyCollection.Element

A type that represents a valid position in the collection.

typealias LazyCollection.Elements

The type of the underlying collection.

typealias LazyCollection.Index

A type that represents a valid position in the collection.

Instance Properties

var count: Int

Returns the number of elements.

var count: Int

The number of elements in the collection.

var elements: Base

The underlying collection.

var elements: LazyCollection<Base>

Identical to self.

var endIndex: Base.Index

The collection’s “past the end” position—that is, the position one greater than the last valid subscript argument.

var first: Base.Element?

The first element of the collection.

var first: Base.Element?

Returns the first element of self, or nil if self is empty.

var indices: DefaultIndices<LazyCollection<Base>>

The indices that are valid for subscripting the collection, in ascending order.

var indices: Range<Base.Index>

The indices that are valid for subscripting the collection, in ascending order.

var isEmpty: Bool

A Boolean value indicating whether the collection is empty.

var isEmpty: Bool

A Boolean value indicating whether the collection is empty.

var last: Base.Element?

The last element of the collection.

var last: Base.Element?
var lazy: LazySequence<LazyCollection<Base>>

A sequence containing the same elements as this sequence, but on which some operations, such as map and filter, are implemented lazily.

var lazy: LazyCollection<LazyCollection<Base>>

A view onto this collection that provides lazy implementations of normally eager operations, such as map and filter.

var lazy: Base
var lazy: Base
var startIndex: Base.Index

The position of the first element in a non-empty collection.

var underestimatedCount: Int

A value less than or equal to the number of elements in the sequence, calculated nondestructively.

var underestimatedCount: Int

A value less than or equal to the number of elements in the sequence, calculated nondestructively.

var underestimatedCount: Int

A value less than or equal to the number of elements in the collection.

Instance Methods

func allSatisfy((Base.Element) -> Bool) -> Bool

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

func compactMap<ElementOfResult>((Base.Element) -> ElementOfResult?) -> [ElementOfResult]

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

func contains(Base.Element) -> Bool

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

func contains(where: (Base.Element) -> Bool) -> Bool

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

func drop(while: (Base.Element) -> Bool) -> LazyDropWhileCollection<Base>

Returns a lazy collection that skips any initial elements that satisfy predicate.

func dropFirst() -> Slice<LazyCollection<Base>>

Returns a subsequence containing all but the first element of the sequence.

func dropFirst(Int) -> Slice<LazyCollection<Base>>

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

func dropLast() -> Slice<LazyCollection<Base>>

Returns a subsequence containing all but the last element of the sequence.

func dropLast(Int) -> Slice<LazyCollection<Base>>

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

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: (Base.Element, OtherSequence.Element) -> Bool) -> 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<LazyCollection<Base>>

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((Base.Element) -> Bool) -> LazyFilterCollection<Base>

Returns the elements of self that satisfy predicate.

func first(where: (Base.Element) -> Bool) -> Base.Element?

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

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

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

func firstIndex(where: (Base.Element) -> Bool) -> Base.Index?

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

func forEach((Base.Element) -> Void)

Calls the given closure on each element in the sequence in the same order as a for-in loop.

func formIndex(inout Base.Index, offsetBy: Int)

Offsets the given index by the specified distance.

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

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

func formIndex(after: inout Base.Index)

Replaces the given index with its successor.

func formIndex(before: inout Base.Index)

Replaces the given index with its predecessor.

func index(before: LazyCollection<Base>.Index) -> LazyCollection<Base>.Index
func joined() -> FlattenSequence<LazyCollection<Base>>

Returns the elements of this sequence of sequences, concatenated.

func joined() -> LazySequence<FlattenSequence<Base>>

Returns a lazy sequence that concatenates the elements of this sequence of sequences.

func joined() -> FlattenCollection<LazyCollection<Base>>

Returns the elements of this collection of collections, concatenated.

func joined() -> LazyCollection<FlattenCollection<Base>>

A concatenation of the elements of self.

func joined<Separator>(separator: Separator) -> JoinedSequence<LazyCollection<Base>>

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

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: String) -> String

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

func last(where: (Base.Element) -> Bool) -> Base.Element?

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

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

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

func lastIndex(where: (Base.Element) -> Bool) -> Base.Index?

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

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: (Base.Element, Base.Element) -> Bool) -> 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 makeIterator() -> LazyCollection<Base>.Iterator

Returns an iterator over the elements of this sequence.

func map<U>((Base.Element) -> U) -> LazyMapSequence<Base, 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 map<U>((Base.Element) -> U) -> LazyMapCollection<Base, U>

Returns a LazyMapCollection over this Collection. The elements of the result are computed lazily, each time they are read, by calling transform function on a base element.

func map<T>((Base.Element) -> T) -> [T]

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

func map<T>((Base.Element) -> T) -> [T]

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

func max() -> Base.Element?

Returns the maximum element in the sequence.

func max(by: (Base.Element, Base.Element) -> Bool) -> Base.Element?

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

func min() -> Base.Element?

Returns the minimum element in the sequence.

func min(by: (Base.Element, Base.Element) -> Bool) -> Base.Element?

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

func prefix(Int) -> Slice<LazyCollection<Base>>

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

func prefix(through: Base.Index) -> Slice<LazyCollection<Base>>

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

func prefix(upTo: Base.Index) -> Slice<LazyCollection<Base>>

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

func prefix(while: (Base.Element) -> Bool) -> LazyPrefixWhileCollection<Base>

Returns a lazy collection of the initial consecutive elements that satisfy predicate.

func randomElement() -> Base.Element?

Returns a random element of the collection.

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

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

func reduce<Result>(Result, (Result, Base.Element) -> Result) -> Result

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

func reduce<Result>(into: Result, (inout Result, Base.Element) -> ()) -> Result

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

func reversed() -> [Base.Element]

Returns an array containing the elements of this sequence in reverse order.

func shuffled() -> [Base.Element]

Returns the elements of the sequence, shuffled.

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

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

func sorted() -> [Base.Element]

Returns the elements of the sequence, sorted.

func sorted(by: (Base.Element, Base.Element) -> Bool) -> [Base.Element]

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

func split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Element) -> Bool) -> [Slice<LazyCollection<Base>>]

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

func split(separator: Base.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Slice<LazyCollection<Base>>]

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

func split(separator: Base.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Slice<LazyCollection<Base>>]

Returns the longest possible subsequences of the collection, 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: (Base.Element, PossiblePrefix.Element) -> Bool) -> 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 suffix(Int) -> Slice<LazyCollection<Base>>

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

func suffix(from: Base.Index) -> Slice<LazyCollection<Base>>

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

Subscripts

subscript(Range<Base.Index>) -> Slice<LazyCollection<Base>>

Accesses a contiguous subrange of the collection’s elements.

subscript<R>(R) -> Slice<LazyCollection<Base>>

Accesses the contiguous subrange of the collection’s elements specified by a range expression.

Relationships

Conforms To

See Also

Lazy Wrappers

struct LazySequence

A sequence containing the same elements as a Base sequence, but on which some operations such as map and filter are implemented lazily.

struct LazyMapSequence

A Sequence whose elements consist of those in a Base Sequence passed through a transform function returning Element. These elements are computed lazily, each time they’re read, by calling the transform function on a base element.

struct LazyMapCollection

A Collection whose elements consist of those in a Base Collection passed through a transform function returning Element. These elements are computed lazily, each time they’re read, by calling the transform function on a base element.

struct LazyFilterSequence

A sequence whose elements consist of the elements of some base sequence that also satisfy a given predicate.

struct LazyFilterCollection

A lazy Collection wrapper that includes the elements of an underlying collection that satisfy a predicate.

struct LazyPrefixWhileSequence

A sequence whose elements consist of the initial consecutive elements of some base sequence that satisfy a given predicate.

struct LazyPrefixWhileCollection

A lazy ${Collection} wrapper that includes the initial consecutive elements of an underlying collection that satisfy a predicate.

struct LazyDropWhileSequence

A sequence whose elements consist of the elements that follow the initial consecutive elements of some base sequence that satisfy a given predicate.

struct LazyDropWhileCollection

A lazy wrapper that includes the elements of an underlying collection after any initial consecutive elements that satisfy a predicate.