Swift Subscripts

• Subscripts are shortcuts for accessing member elements of collections, lists, or sequences.
• They enable setting and retrieving values by index without needing separate methods.
• Examples include accessing elements in an Array instance as someArray[index] and elements in a Dictionary instance as someDictionary[key].
• A single type can define multiple subscripts, with the appropriate overload selected based on the index value type.
• Subscripts aren't limited to a single dimension and can have multiple input parameters.

Subscript Syntax

• Subscripts query instances of a type using square brackets after the instance name.
• Their syntax resembles instance method and computed property syntax.
• Subscript definitions use the subscript keyword, input parameters, and a return type.
• Subscripts can be read-write or read-only, indicated by a getter and setter like computed properties.

  subscript(index: Int) -> Int {
      get {
          // Return an appropriate subscript value here.
      }
      set(newValue) {
          // Perform a suitable setting action here.
      }
  }
  

• The type of newValue is the same as the return value of the subscript.
• If the setter’s (newValue) parameter isn’t specified, a default parameter called newValue is provided.
• Read-only subscripts can be simplified by removing the get keyword and its braces.

  subscript(index: Int) -> Int {
      // Return an appropriate subscript value here.
  }
  

• TimesTable structure example:

  struct TimesTable {
      let multiplier: Int
      subscript(index: Int) -> Int {
          return multiplier * index
      }
  }
  let threeTimesTable = TimesTable(multiplier: 3)
  print("six times three is \(threeTimesTable[6])") // Prints "six times three is 18"
  

• A TimesTable instance is created with a multiplier of 3.
• Querying the threeTimesTable instance with threeTimesTable[6] returns 18 (3 times 6).

Subscript Usage

• The meaning of "subscript" depends on the context.
• Subscripts are typically a shortcut for accessing member elements in a collection, list, or sequence.
• Implement subscripts in the most appropriate way for your class or structure’s functionality.
• Swift's Dictionary type uses a subscript to set and retrieve values.

  var numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
  numberOfLegs["bird"] = 2
  

• The numberOfLegs dictionary is inferred to be of type [String: Int].
• Subscript assignment adds a String key of "bird" and an Int value of 2 to the dictionary.

Subscript Options

• Subscripts can take any number of input parameters of any type and return a value of any type.
• Like functions, subscripts can take a varying number of parameters and provide default parameter values.
• Unlike functions, subscripts can’t use in-out parameters.
• A class or structure can provide multiple subscript implementations (subscript overloading).
• The appropriate subscript is inferred based on the types of values within the subscript brackets.
• Subscripts can have multiple parameters.
• Example is Matrix structure:

  struct Matrix {
      let rows: Int, columns: Int
      var grid: [Double]
      init(rows: Int, columns: Int) {
          self.rows = rows
          self.columns = columns
          grid = Array(repeating: 0.0, count: rows * columns)
      }
      func indexIsValid(row: Int, column: Int) -> Bool {
          return row >= 0 && row < rows && column < columns
      }
      subscript(row: Int, column: Int) -> Double {
          get {
              assert(indexIsValid(row: row, column: column), "Index out of range")
              return grid[(row * columns) + column]
          }
          set {
              assert(indexIsValid(row: row, column: column), "Index out of range")
              grid[(row * columns) + column] = newValue
          }
      }
  }
  

• The Matrix initializer takes rows and columns parameters.
• It creates an array large enough to store rows * columns values of type Double.
• Each position in the matrix is initialized to 0.0.

  var matrix = Matrix(rows: 2, columns: 2)
  

• Creates a new Matrix instance with two rows and two columns.
• Values can be set by passing row and column values into the subscript, separated by a comma.

  matrix[0, 1] = 1.5
  matrix[1, 0] = 3.2
  

• Sets a value of 1.5 at the top right (row is 0, column is 1) and 3.2 at the bottom left (row is 1, column is 0).
• The Matrix subscript includes an assertion to ensure that row and column values are valid.
• The indexIsValid(row:column:) method checks whether the requested row and column are within bounds.

  func indexIsValid(row: Int, column: Int) -> Bool {
      return row >= 0 && row < rows && column >= 0 && column < columns
  }
  

• Accessing an out-of-bounds subscript triggers an assertion.

Type Subscripts

• Instance subscripts are called on an instance of a particular type.
• Type subscripts are called on the type itself.
• Indicate a type subscript by writing the static keyword before the subscript keyword.
• Classes can use the class keyword instead of static to allow subclasses to override the superclass’s implementation.

  enum Planet: Int {
      case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
      static subscript(n: Int) -> Planet {
          return Planet(rawValue: n)!
      }
  }
  let mars = Planet[4]
  print(mars)