A type that represents the words of this integer.

SDK

- Xcode 9.0+

Framework

- Swift Standard Library

Structure# Int.Words

A type that represents the words of this integer.

SDK

- Xcode 9.0+

Framework

- Swift Standard Library

`typealias Int`.Words.Indices

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

`typealias Int`.Words.Element

A type representing the sequence’s elements.

`typealias Int`.Words.Index

A type that represents a position in the collection.

`typealias Int`.Words.Iterator

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

`typealias Int`.Words.SubSequence

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

`var count: Int`

The number of elements in the collection.

`var end`Index : Int

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

`var first: UInt?`

The first element of the collection.

`var indices: Int`.Words.Indices

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

`var indices: Range<Int>`

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

`var is`Empty : Bool

A Boolean value indicating whether the collection is empty.

`var last: UInt?`

The last element of the collection.

`var lazy: Lazy`Sequence<Int.Words>

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

and `filter`

, are implemented lazily.

`var start`Index : Int

The position of the first element in a nonempty collection.

`var underestimated`Count : Int

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

`func all`Satisfy ((UInt) -> Bool) -> Bool

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

`func compact`Map <ElementOfResult>((UInt) -> ElementOfResult?) -> [ElementOfResult]

Returns an array containing the non-`nil`

results of calling the given transformation with each element of this sequence.

`func contains(UInt) -> Bool`

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

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

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

`func difference<C>(from: C) -> Collection`Difference<UInt>

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

`func difference<C>(from: C, by: (C`.Element, UInt) -> Bool) -> CollectionDifference<UInt>

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: (UInt) -> Bool) -> Slice<Int`.Words>

Returns a subsequence by skipping elements while `predicate`

returns `true`

and returning the remaining elements.

`func drop`First (Int) -> Slice<Int.Words>

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

`func drop`Last (Int) -> Slice<Int.Words>

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

`func elements`Equal <OtherSequence>(OtherSequence) -> Bool

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: (UInt, 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() -> Enumerated`Sequence<Int.Words>

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

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

`func first(where: (UInt) -> Bool) -> UInt?`

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

`func first`Index (of: UInt) -> Int?

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

`func first`Index (where: (UInt) -> Bool) -> Int?

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

`func flat`Map <SegmentOfResult>((UInt) -> SegmentOfResult) -> [SegmentOfResult.Element]

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

`func for`Each ((UInt) -> Void)

Calls the given closure on each element in the sequence in the same order as a `for`

-`in`

loop.

`func form`Index (inout Int, offsetBy : Int)

Offsets the given index by the specified distance.

`func form`Index (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 form`Index (after: inout Int)

Replaces the given index with its successor.

`func form`Index (before: inout Int)

Replaces the given index with its predecessor.

`func index(Int, offset`By : Int) -> Int

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

`func index(Int, offset`By : 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 before the given index.

`func index(of: UInt) -> Int?`

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

`func index(where: (UInt) -> Bool) -> Int?`

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

`func last(where: (UInt) -> Bool) -> UInt?`

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

`func last`Index (of: UInt) -> Int?

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

`func last`Index (where: (UInt) -> Bool) -> Int?

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

`func lexicographically`Precedes <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 lexicographically`Precedes <OtherSequence>(OtherSequence, by: (UInt, UInt) -> 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 make`Iterator () -> IndexingIterator<Int.Words>

Returns an iterator over the elements of the collection.

`func map<T>((UInt) -> T) -> [T]`

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

`func max() -> UInt?`

Returns the maximum element in the sequence.

`func max(by: (UInt, UInt) -> Bool) -> UInt?`

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

`func min() -> UInt?`

Returns the minimum element in the sequence.

`func min(by: (UInt, UInt) -> Bool) -> UInt?`

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

`func prefix(Int) -> Slice<Int`.Words>

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

`func prefix(through: Int) -> Slice<Int`.Words>

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

`func prefix(up`To : Int) -> Slice<Int.Words>

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

`func prefix(while: (UInt) -> Bool) -> Slice<Int`.Words>

Returns a subsequence containing the initial elements until `predicate`

returns `false`

and skipping the remaining elements.

`func random`Element () -> UInt?

Returns a random element of the collection.

`func random`Element <T>(using: inout T) -> UInt?

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

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

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

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

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

`func reversed() -> Reversed`Collection<Int.Words>

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

`func shuffled() -> [UInt]`

Returns the elements of the sequence, shuffled.

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

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

`func sorted() -> [UInt]`

Returns the elements of the sequence, sorted.

`func sorted(by: (UInt, UInt) -> Bool) -> [UInt]`

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

`func split(max`Splits : Int, omittingEmptySubsequences : Bool, whereSeparator : (UInt) -> Bool) -> [Slice<Int.Words>]

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

`func split(separator: UInt, max`Splits : Int, omittingEmptySubsequences : Bool) -> [Slice<Int.Words>]

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

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

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

`func suffix(from: Int) -> Slice<Int`.Words>

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

`func with`ContiguousStorageIfAvailable <R>((UnsafeBufferPointer<UInt>) -> 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.

`subscript(Range<Int>) -> Slice<Int`.Words>

Accesses a contiguous subrange of the collection’s elements.

`subscript(Int) -> UInt`

Accesses the element at the specified position.

`subscript<R>(R) -> Slice<Int`.Words>

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

`static var bit`Width : Int

The number of bits used for the underlying binary representation of values of this type.

`var bit`Width : Int

The number of bits in the binary representation of this value.

`var nonzero`BitCount : Int

The number of bits equal to 1 in this value’s binary representation.

`var leading`ZeroBitCount : Int

The number of leading zeros in this value’s binary representation.

`var trailing`ZeroBitCount : Int

The number of trailing zeros in this value’s binary representation.

`var words: Int`.Words

A collection containing the words of this value’s binary representation, in order from the least significant to most significant.