> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Swift 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`:** 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`:** Created via a **postfix** operator where only the lower bound is provided. It defines a range extending upward from the bound. * **`PartialRangeThrough`:** 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_) -> ()`. ```swift theme={"dark"} // Infix: Evaluates to ClosedRange 1...5 // Postfix: Evaluates to PartialRangeFrom 10... // Prefix: Evaluates to PartialRangeThrough ...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` of the specified type, making the parameter accessible as a standard array within the function's local scope. ```swift theme={"dark"} // 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.

Tired of Poor Swift Skills? Fix That With Deep Grasping! Learn More