`struct PartialRangeThrough`

A partial interval up to, and including, an upper bound.

Inheritance | `RangeExpression` |
---|

### Initializers

### Instance Variables

### Instance Methods

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

- Parameter element: The element to check for containment.

#### Declaration

`public func contains(_ element: Bound) -> Bool`

Returns the range of indices described by this range expression within the given collection.

You can use the `relative(to:)`

method to convert a range expression,
which could be missing one or both of its endpoints, into a concrete
range that is bounded on both sides. The following example uses this
method to convert a partial range up to `4`

into a half-open range,
using an array instance to add the range's lower bound.

```
let numbers = [10, 20, 30, 40, 50, 60, 70]
let upToFour = ..<4
let r1 = upToFour.relative(to: numbers)
// r1 == 0..<4
```

The `r1`

range is bounded on the lower end by `0`

because that is the
starting index of the `numbers`

array. When the collection passed to
`relative(to:)`

starts with a different index, that index is used as the
lower bound instead. The next example creates a slice of `numbers`

starting at index `2`

, and then uses the slice with `relative(to:)`

to
convert `upToFour`

to a concrete range.

```
let numbersSuffix = numbers[2...]
// numbersSuffix == [30, 40, 50, 60, 70]
let r2 = upToFour.relative(to: numbersSuffix)
// r2 == 2..<4
```

Use this method only if you need the concrete range it produces. To access a slice of a collection using a range expression, use the collection's generic subscript that uses a range expression as its parameter.

```
let numbersPrefix = numbers[upToFour]
// numbersPrefix == [10, 20, 30, 40]
```

- Parameter collection: The collection to evaluate this range expression in relation to.

#### Declaration

`public func relative<C>(to collection: C) -> Range<Bound> where Bound == C.Index, C: Collection`

### Type Methods

#### Declaration

`@inlinable public static func ~=(pattern: Self, value: Self.Bound) -> Bool`

You create

`PartialRangeThrough`

instances by using the prefix closed range operator (prefix`...`

).You can use a

`PartialRangeThrough`

instance to quickly check if a value is contained in a particular range of values. For example:You can use a

`PartialRangeThrough`

instance of a collection's indices to represent the range from the start of the collection up to, and including, the partial range's upper bound.