StructureSwift5.9.0

# ClosedRange

An interval from a lower bound up to, and including, an upper bound.

``@frozen struct ClosedRange<Bound> where Bound : Comparable``

You create a `ClosedRange` instance by using the closed range operator (`...`).

``let throughFive = 0...5``

A `ClosedRange` instance contains both its lower bound and its upper bound.

``````throughFive.contains(3)
// true
throughFive.contains(10)
// false
throughFive.contains(5)
// true``````

Because a closed range includes its upper bound, a closed range whose lower bound is equal to the upper bound contains that value. Therefore, a `ClosedRange` instance cannot represent an empty range.

``````let zeroInclusive = 0...0
zeroInclusive.contains(0)
// true
zeroInclusive.isEmpty
// false``````

## Using a Closed Range as a Collection of Consecutive Values

When a closed range uses integers as its lower and upper bounds, or any other type that conforms to the `Strideable` protocol with an integer stride, you can use that range in a `for`-`in` loop or with any sequence or collection method. The elements of the range are the consecutive values from its lower bound up to, and including, its upper bound.

``````for n in 3...5 {
print(n)
}
// Prints "3"
// Prints "4"
// Prints "5"``````

Because floating-point types such as `Float` and `Double` are their own `Stride` types, they cannot be used as the bounds of a countable range. If you need to iterate over consecutive floating-point values, see the `stride(from:through:by:)` function.

## Citizens in Swift

### Members

• `init(uncheckedBounds: (lower: Bound, upper: Bound))`

Creates an instance with the given bounds.

• `let lowerBound: Bound`

The range’s lower bound.

• `let upperBound: Bound`

The range’s upper bound.

## Citizens in Swift

`where Bound:Strideable, Bound.Stride:SignedInteger`

### Conformances

• `protocol BidirectionalCollection`

A collection that supports backward as well as forward traversal.

• `protocol Collection`

A sequence whose elements can be traversed multiple times, nondestructively, and accessed by an indexed subscript.

• `protocol RandomAccessCollection`

A collection that supports efficient random-access index traversal.

• `protocol Sequence`

### Members

• `init(Range<Bound>)`

Creates an instance equivalent to the given `Range`.

• `var endIndex: ClosedRange<Bound>.Index`

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

• `var startIndex: ClosedRange<Bound>.Index`

The position of the first element in the range.

• `subscript(Range<ClosedRange<Bound>.Index>) -> Slice<ClosedRange<Bound>>`
• `subscript(ClosedRange<Bound>.Index) -> Bound`

Accesses the element at specified position.

• `func distance(from: ClosedRange<Bound>.Index, to: ClosedRange<Bound>.Index) -> Int`
• `func index(ClosedRange<Bound>.Index, offsetBy: Int) -> ClosedRange<Bound>.Index`
• `func index(after: ClosedRange<Bound>.Index) -> ClosedRange<Bound>.Index`
• `func index(before: ClosedRange<Bound>.Index) -> ClosedRange<Bound>.Index`
• `enum Index`
• `typealias Element`
• `typealias Iterator`
• `typealias SubSequence`
• `init(ClosedRange<Bound>)`

Now that Range is conditionally a collection when Bound: Strideable, CountableRange is no longer needed. This is a deprecated initializer for any remaining uses of Range(countableRange).

## Citizens in Swift

`where Bound:Comparable`

### Conformances

• `protocol CustomDebugStringConvertible`

A type with a customized textual representation suitable for debugging purposes.

• `protocol CustomReflectable`

A type that explicitly supplies its own mirror.

• `protocol CustomStringConvertible`

A type with a customized textual representation.

• `protocol Equatable`

A type that can be compared for value equality.

• `protocol RangeExpression`

A type that can be used to slice a collection.

### Members

• `var customMirror: Mirror`
• `var debugDescription: String`

A textual representation of the range, suitable for debugging.

• `var description: String`

A textual representation of the range.

• `var isEmpty: Bool`

A Boolean value indicating whether the range contains no elements.

• `static func == (ClosedRange<Bound>, ClosedRange<Bound>) -> Bool`

Returns a Boolean value indicating whether two ranges are equal.

• `func clamped(to: ClosedRange<Bound>) -> ClosedRange<Bound>`

Returns a copy of this range clamped to the given limiting range.

• `func contains(Bound) -> Bool`

Returns a Boolean value indicating whether the given element is contained within the range.

• `func overlaps(ClosedRange<Bound>) -> Bool`
• `func overlaps(Range<Bound>) -> Bool`
• `func relative<C>(to: C) -> Range<Bound>`

### Features

• `static func != (Self, Self) -> Bool`
• `static func ~= (Self, Self.Bound) -> Bool`

Returns a Boolean value indicating whether a value is included in a range.

## Citizens in Swift

`where Bound:Comparable, Bound:Decodable`

### Conformances

• `protocol Decodable`

A type that can decode itself from an external representation.

### Members

• `init(from: Decoder) throws`

## Citizens in Swift

`where Bound:Comparable, Bound:Encodable`

### Conformances

• `protocol Encodable`

A type that can encode itself to an external representation.

### Members

• `func encode(to: Encoder) throws`

## Citizens in Swift

`where Bound:Comparable, Bound:Sendable`

### Conformances

• `protocol Sendable`

A type whose values can safely be passed across concurrency domains by copying.

## Citizens in Swift

`where Bound:Comparable, Bound:Hashable`

### Conformances

• `protocol Hashable`

A type that can be hashed into a `Hasher` to produce an integer hash value.

### Members

• `func hash(into: inout Hasher)`