> ## 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 Instance Subscript An instance subscript in Swift is a specialized method that enables querying or mutating instances of a class, structure, or enumeration using bracket notation (`[]`). It acts as a syntactic bridge to access elements within an underlying collection, sequence, or custom data structure managed by the instance, bypassing the need for explicit getter and setter methods. ## Syntax Anatomy Subscripts are defined using the `subscript` keyword within the scope of a type. The declaration closely resembles a computed property combined with an instance method. ```swift theme={"dark"} struct CustomContainer { subscript(index: Int) -> String { get { return "Value at \(index)" } set(newValue) { // Perform a suitable mutation using newValue } } } ``` ## Technical Characteristics **1. Mutability and Accessors** Subscripts can be read-write or read-only. * **Read-Write:** Implements both a `get` and a `set` block. In the `set` block, the new value being assigned is implicitly named `newValue`, though its type is inferred from the subscript's return type. You can explicitly name this parameter by providing an identifier in parentheses after the `set` keyword: `set(customName)`. * **Read-Only:** Implements only a `get` block. For brevity, the `get` keyword and its braces can be omitted entirely, allowing the subscript to directly return the value. **2. Parameter Constraints and Capabilities** Unlike standard functions, subscript parameters have specific syntactic rules and restrictions: * **Argument Labels:** By default, subscript parameters do *not* have argument labels. To require a label at the call site, it must be explicitly defined (e.g., `subscript(row r: Int)`). * **Default Values:** Subscripts **cannot** provide default parameter values. Attempting to assign a default value (e.g., `subscript(index: Int = 0)`) will result in a compiler error. This is a notable exception compared to standard functions and initializers. * **Arity and Types:** They can accept any number of input parameters of any type, including variadic parameters. * **Inout Parameters:** Subscripts **cannot** use `inout` parameters. **3. Generic Subscripts** Subscripts can be generic. Both the parameters and the return type can utilize generic type parameters, and they support `where` clauses for strict type constraints. ```swift theme={"dark"} struct TypeSafeStorage { subscript(key: String, fallback defaultValue: T) -> T { // Implementation returning type T return defaultValue } } ``` **4. Subscript Overloading** A single type can define multiple subscripts. The Swift compiler resolves which subscript to invoke based on the arity, the types of the parameters passed within the brackets, the presence of argument labels, and the expected return type. **5. Effects Specifiers (Swift 5.5+)** Read-only subscripts support `async` and `throws` effect specifiers. These are applied to the `get` block to indicate that the subscript access may suspend or yield an error. ```swift theme={"dark"} import Foundation struct RemoteResource { subscript(key: String) -> Data { get async throws { // Asynchronous and throwing execution context return Data() } } } ``` ## Implementation Mechanics The following code block demonstrates the mechanical implementation of subscript overloading, multidimensional parameters, and read-only shorthand within a structure. The properties are marked internal (the default access level) to allow the automatically synthesized memberwise initializer to be accessible. ```swift theme={"dark"} struct GridData { var storage: [Int] let columns: Int // Multidimensional Read-Write Subscript subscript(row: Int, column: Int) -> Int { get { let index = (row * columns) + column return storage[index] } set { let index = (row * columns) + column storage[index] = newValue } } // Overloaded Read-Only Subscript (Shorthand Syntax) subscript(linearIndex: Int) -> Int { return storage[linearIndex] } } // Syntax Visualization var grid = GridData(storage: [0, 0, 0, 0], columns: 2) // Invokes the multidimensional read-write setter grid[1, 0] = 5 // Invokes the multidimensional read-write getter let value = grid[1, 0] // Invokes the overloaded read-only getter let linearValue = grid[2] ``` ## Memory and Value Semantics When a subscript is implemented on a value type (`struct` or `enum`), mutating the instance via the subscript setter requires the instance itself to be assigned to a variable (`var`), not a constant (`let`). The `set` block implicitly mutates `self`. If the subscript is implemented on a reference type (`class`), the setter can be invoked even if the instance reference is held in a constant, provided the underlying storage being mutated is mutable.

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