Understanding Subscripts in Swift

Subscripts in Swift aren’t limited to collections like arrays or dictionaries. They’re simply a convenient syntax for accessing values, much like methods, whether or not the underlying type contains a list, sequence, or collection.

In the TimesTable example, the subscript:

SWIFTCopied
subscript(index: Int) -> Int {
    return multiplier * index
}

does not operate on a stored collection. Instead, it computes a value based on the input parameter (index) and the property multiplier. This means that even though it looks very similar to accessing an element in a collection, it’s really just syntactic sugar for a getter method.

Here’s a quick comparison:

• TimesTable: The subscript performs a calculation (multiplication) without referring to an array or any stored sequence. It’s a computed property accessed using subscript syntax.

• Matrix Example:
  In contrast, a subscript on a Matrix struct might access an underlying array (grid). The subscript verifies that the row and column are valid and then accesses the appropriate element in the array:

  SWIFTCopied
  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 >= 0 && 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 example uses a subscript to access an element within an array, while the TimesTable example uses a subscript merely to return the result of a calculation. In both cases, the syntax is consistent, but the underlying implementation can vary according to your needs.

Key Takeaway:
Subscripts provide a way to access data through a convenient syntax—they aren’t inherently tied to collections or sequences. They can be used to compute values on the fly, as shown in the TimesTable example, or to access stored data as in a collection type like Matrix.