struct PartialRangeUpTo

A partial half-open interval up to, but not including, an upper bound.

Inheritance RangeExpression

You create PartialRangeUpTo instances by using the prefix half-open range operator (prefix ..<).

let upToFive = ..<5.0

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

upToFive.contains(3.14)       // true
upToFive.contains(6.28)       // false
upToFive.contains(5.0)        // false

You can use a PartialRangeUpTo instance of a collection's indices to represent the range from the start of the collection up to, but not including, the partial range's upper bound.

let numbers = [10, 20, 30, 40, 50, 60, 70]
// Prints "[10, 20, 30]"


init init(_:) Required


@inlinable public init(_ upperBound: Bound)

Instance Variables

let upperBound Required


let upperBound: Bound

Instance Methods

func contains(_ element: Bound) -> Bool Required

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

  • Parameter element: The element to check for containment.


public func contains(_ element: Bound) -> Bool
func relative(to collection: C) -> Range<Bound> Required

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.


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

Type Methods

func ~=(pattern: Self, value: Self.Bound) -> Bool Required


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