Closed Range

The ... operator in Swift serves dual semantic roles depending on its syntactic context: it functions as the Range Operator (including closed, partial, and unbounded variants) to define intervals of values, and as the Variadic Parameter Operator to denote a function parameter that accepts an indefinite number of arguments of a uniform type.

1. The Range Operator

When used in expression contexts, ... acts as a range operator. For bounded ranges, it requires the underlying operand types to conform to the Comparable protocol. The compiler resolves this operator into one of four distinct types based on its fixity (infix, prefix, or postfix):

• ClosedRange<Bound>: Created via an infix operator where both a lower and upper bound are provided. The range includes both bounds, and the lower bound must not exceed the upper bound.
• PartialRangeFrom<Bound>: Created via a postfix operator where only the lower bound is provided. It defines a range extending upward from the bound.
• PartialRangeThrough<Bound>: Created via a prefix operator where only the upper bound is provided. It defines a range with no lower bound, extending up to and including the upper bound. When used to slice a collection, its effective lower bound is dynamically determined by the collection’s startIndex.
• UnboundedRange: Created when the operator is used without bounds within a valid context, such as a collection subscript. The unbounded ... is parsed as a reference to a postfix operator function. Unlike the other range types which are generic structs, UnboundedRange is a typealias for a function type (UnboundedRange_) -> ().

// Infix: Evaluates to ClosedRange<Int>
1...5 

// Postfix: Evaluates to PartialRangeFrom<Int>
10... 

// Prefix: Evaluates to PartialRangeThrough<Int>
...50 

// Postfix (Unbounded): Evaluates to UnboundedRange within a valid context
collection[...]

2. The Variadic Parameter Operator

When appended to a type declaration within a function signature, ... acts as the variadic parameter operator. It instructs the compiler to accept zero or more comma-separated values of the specified type.

During compilation, Swift automatically packs the provided arguments into an Array<Element> of the specified type, making the parameter accessible as a standard array within the function’s local scope.

// Syntax definition for a variadic parameter
func process(arguments: String...) {
    // Inside the function body, 'arguments' is resolved as [String]
    let internalArray: [String] = arguments
}

Technical Constraints for Variadic Parameters:

• The ... operator must be placed immediately after the type identifier (e.g., String...), not the parameter name.
• A function may declare multiple variadic parameters, provided the compiler can unambiguously resolve the arguments at the call site (typically enforced via distinct argument labels).
• Variadic parameters cannot be marked with the inout modifier.

Master Swift with Deep Grasping Methodology!

Learn More