Generic Structure

Repeated

A collection whose elements are all identical.

Declaration

@frozen struct Repeated<Element>

Overview

You create an instance of the Repeated collection by calling the repeatElement(_:count:) function. The following example creates a collection containing the name “Humperdinck” repeated five times:

let repeatedName = repeatElement("Humperdinck", count: 5)
for name in repeatedName {
    print(name)
}
// "Humperdinck"
// "Humperdinck"
// "Humperdinck"
// "Humperdinck"
// "Humperdinck"

Topics

Type Aliases

typealias Repeated.Index

A type that represents a valid position in the collection.

typealias Repeated.Indices

A type that represents the indices that are valid for subscripting the collection, in ascending order.

typealias Repeated.Iterator

A type that provides the collection’s iteration interface and encapsulates its iteration state.

typealias Repeated.Regions
Available when Element is UInt8.
typealias Repeated.SubSequence

A sequence that represents a contiguous subrange of the collection’s elements.

Instance Properties

let count: Int

The number of elements in this collection.

var endIndex: Repeated<Element>.Index

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

var first: Element?

The first element of the collection.

var indices: Range<Int>

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 last: Element?

The last element of the collection.

var lazy: LazySequence<Repeated<Element>>

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

var regions: Repeated<Data>
Available when Element is UInt8.
let repeatedValue: Element

The value of every element in this collection.

var startIndex: Repeated<Element>.Index

The position of the first element in a nonempty collection.

var underestimatedCount: Int

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

Instance Methods

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

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

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

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

func contains(Element) -> Bool

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

Available when Element conforms to Equatable.
func contains(where: (Element) -> Bool) -> Bool

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

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

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

Available when Element conforms to Equatable.
func difference<C>(from: C, by: (C.Element, Element) -> Bool) -> CollectionDifference<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 distance(from: Int, to: Int) -> Int

Returns the distance between two indices.

func drop(while: (Element) -> Bool) -> Slice<Repeated<Element>>

Returns a subsequence by skipping elements while predicate returns true and returning the remaining elements.

func dropFirst(Int) -> Slice<Repeated<Element>>

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

func dropLast(Int) -> Slice<Repeated<Element>>

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.

Available when Element conforms to Equatable.
func elementsEqual<OtherSequence>(OtherSequence, by: (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<Repeated<Element>>

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((Element) -> Bool) -> [Element]

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

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

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

func firstIndex(of: Element) -> Int?

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

Available when Element conforms to Equatable.
func firstIndex(where: (Element) -> Bool) -> Int?

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

func flatMap<SegmentOfResult>((Element) -> SegmentOfResult) -> [SegmentOfResult.Element]

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

func flatMap<ElementOfResult>((Element) -> ElementOfResult?) -> [ElementOfResult]Deprecated
func forEach((Element) -> Void)

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

func formIndex(inout Int, offsetBy: Int)

Offsets the given index by the specified distance.

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

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

func formIndex(after: inout Int)

Replaces the given index with its successor.

func formIndex(before: inout Int)

Replaces the given index with its predecessor.

func index(Int, offsetBy: Int) -> Int

Returns an index that is the specified distance from the given index.

func index(Int, offsetBy: Int, limitedBy: Int) -> Int?

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

func index(after: Int) -> Int

Returns the position immediately after the given index.

func index(before: Int) -> Int

Returns the position immediately after the given index.

func index(of: Element) -> Int?

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

Available when Element conforms to Equatable.
Deprecated
func index(where: (Element) -> Bool) -> Int?

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

Deprecated
func joined() -> FlattenSequence<Repeated<Element>>

Returns the elements of this sequence of sequences, concatenated.

Available when Element conforms to Sequence.
func joined<Separator>(separator: Separator) -> JoinedSequence<Repeated<Element>>

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

Available when Element conforms to Sequence.
func joined(separator: String) -> String

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

Available when Element is String.
func joined(separator: String) -> String

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

Available when Element conforms to StringProtocol.
func last(where: (Element) -> Bool) -> Element?

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

func lastIndex(of: Element) -> Int?

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

Available when Element conforms to Equatable.
func lastIndex(where: (Element) -> Bool) -> Int?

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.

Available when Element conforms to Comparable.
func lexicographicallyPrecedes<OtherSequence>(OtherSequence, by: (Element, 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() -> IndexingIterator<Repeated<Element>>

Returns an iterator over the elements of the collection.

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

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

func max() -> Element?

Returns the maximum element in the sequence.

Available when Element conforms to Comparable.
func max(by: (Element, Element) -> Bool) -> Element?

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

func min() -> Element?

Returns the minimum element in the sequence.

Available when Element conforms to Comparable.
func min(by: (Element, Element) -> Bool) -> Element?

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

func prefix(Int) -> Slice<Repeated<Element>>

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

func prefix(through: Int) -> Slice<Repeated<Element>>

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

func prefix(upTo: Int) -> Slice<Repeated<Element>>

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

func prefix(while: (Element) -> Bool) -> Slice<Repeated<Element>>

Returns a subsequence containing the initial elements until predicate returns false and skipping the remaining elements.

func randomElement() -> Element?

Returns a random element of the collection.

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

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

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

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

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

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

func reversed() -> ReversedCollection<Repeated<Element>>

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

func shuffled() -> [Element]

Returns the elements of the sequence, shuffled.

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

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

func sorted() -> [Element]

Returns the elements of the sequence, sorted.

Available when Element conforms to Comparable.
func sorted(by: (Element, Element) -> Bool) -> [Element]

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

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

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

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

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

Available when Element conforms to Equatable.
func split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [ArraySlice<Element>]

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

Available when Element conforms to Equatable.
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.

Available when Element conforms to Equatable.
func starts<PossiblePrefix>(with: PossiblePrefix, by: (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<Repeated<Element>>

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

func suffix(from: Int) -> Slice<Repeated<Element>>

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

func withContiguousStorageIfAvailable<R>((UnsafeBufferPointer<Element>) -> R) -> R?

Call body(p), where p is a pointer to the collection’s contiguous storage. If no such storage exists, it is first created. If the collection does not support an internal representation in a form of contiguous storage, body is not called and nil is returned.

Subscripts

subscript(Int) -> Element

Accesses the element at the specified position.

subscript(Range<Int>) -> Slice<Repeated<Element>>

Accesses a contiguous subrange of the collection’s elements.

subscript<R>(R) -> Slice<Repeated<Element>>

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

subscript((UnboundedRange_) -> ()) -> Slice<Repeated<Element>>

Relationships

Conforms To

See Also

Wrappers for Algorithms

struct DropFirstSequence

A sequence that lazily consumes and drops n elements from an underlying Base iterator before possibly returning the first available element.

struct DropWhileSequence

A sequence that lazily consumes and drops n elements from an underlying Base iterator before possibly returning the first available element.

struct EnumeratedSequence

An enumeration of the elements of a sequence or collection.

typealias FlattenCollection
struct FlattenSequence

A sequence consisting of all the elements contained in each segment contained in some Base sequence.

struct JoinedSequence

A sequence that presents the elements of a base sequence of sequences concatenated using a given separator.

struct PrefixSequence

A sequence that only consumes up to n elements from an underlying Base iterator.

struct ReversedCollection

A collection that presents the elements of its base collection in reverse order.

struct StrideTo

A sequence of values formed by striding over a half-open interval.

struct StrideThrough

A sequence of values formed by striding over a closed interval.

struct UnfoldSequence

A sequence whose elements are produced via repeated applications of a closure to some mutable state.

struct Zip2Sequence

A sequence of pairs built out of two underlying sequences.