No overview available.

SDK

- Xcode 7.0+

Framework

- Swift Standard Library

Generic Structure# AnySequence

No overview available.

SDK

- Xcode 7.0+

Framework

- Swift Standard Library

`init<S>(S)`

Creates a new sequence that wraps and forwards operations to `base`

.

`init<I>(() -> I)`

Creates a sequence whose `make`

method forwards to `make`

.

`var lazy: Lazy`Sequence<AnySequence<Element>>

A sequence containing the same elements as this sequence, but on which some operations, such as `map`

and `filter`

, are implemented lazily.

`var underestimated`Count : Int

Returns a value less than or equal to the number of elements in the sequence, nondestructively.

`func contains(where: ((Element)) -> Bool)`

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

`func drop`First ()

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

`func drop`Last ()

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

`func elements`Equal <OtherSequence>(OtherSequence)

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

`func elements`Equal <OtherSequence>(OtherSequence, by: ((Element), (Element)) -> 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()`

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 first(where: ((Element)) -> Bool)`

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

`func joined()`

Returns the elements of this sequence of sequences, concatenated.

`func joined<Separator>(separator: Separator)`

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

`func joined(separator: String)`

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

`func lexicographically`Precedes <OtherSequence>(OtherSequence)

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 lexicographically`Precedes <OtherSequence>(OtherSequence, by: ((Element), (Element)) -> 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 make`Iterator ()

Returns an iterator over the elements of this sequence.

`func map<T>(((Element)) -> T)`

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

`func max()`

Returns the maximum element in the sequence.

`func max(by: ((Element), (Element)) -> Bool)`

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

`func min()`

Returns the minimum element in the sequence.

`func min(by: ((Element), (Element)) -> Bool)`

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

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

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

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

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

`func reversed()`

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

`func sorted()`

Returns the elements of the sequence, sorted.

`func sorted(by: ((Element), (Element)) -> Bool)`

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

`func split(separator: (Element), max`Splits : Int, omittingEmptySubsequences : Bool)

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

`func starts<Possible`Prefix>( with: PossiblePrefix)

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

`func starts<Possible`Prefix>( with: PossiblePrefix, by: ((Element), (Element)) -> 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.

`struct Any`Collection

A type-erased wrapper over any collection with indices that support forward traversal.

`struct Any`BidirectionalCollection

A type-erased wrapper over any collection with indices that support bidirectional traversal.

`struct Any`RandomAccessCollection

A type-erased wrapper over any collection with indices that support random access traversal.

`struct Any`Iterator

A type-erased iterator of `Element`

.

`struct Any`Index

A wrapper over an underlying index that hides the specific underlying type.

`struct Any`Hashable

A type-erased hashable value.