Source code in the e programming language

/** Missing scalar multiplication, but we don't need it. */
def makeVector2(x, y) {
  return def vector {
    to x() { return x }
    to y() { return y }
    to add(other) { return makeVector2(x + other.x(), y + other.y()) }
    to clockwise() { return makeVector2(-y, x) }
  }
}

/** Bugs: (1) The printing is specialized. (2) No bounds check on the column. */
def makeFlex2DArray(rows, cols) {
  def storage := ([null] * (rows * cols)).diverge()
  return def flex2DArray {
    to __printOn(out) {
      for y in 0..!rows {
        for x in 0..!cols {
          out.print(.format("%3d", [flex2DArray[y, x]]))
        }
        out.println()
      }
    }
    to get(r, c) { return storage[r * cols + c] }
    to put(r, c, v) { storage[r * cols + c] := v }
  }
}

def spiral(size) {
  def array := makeFlex2DArray(size, size)
  var i := -1                   # Counter of numbers to fill
  var p := makeVector2(0, 0)    # "Position"
  var dp := makeVector2(1, 0)   # "Velocity"
  
  # If the cell we were to fill next (even after turning) is full, we're done.
  while (array[p.y(), p.x()] == null) {
  
    array[p.y(), p.x()] := (i += 1) # Fill cell
    def next := p + dp              # Look forward
    
    # If the cell we were to fill next is already full, then turn clockwise.
    # Gimmick: If we hit the edges of the array, by the modulo we wrap around
    # and see the already-filled cell on the opposite edge.
    if (array[next.y() %% size, next.x() %% size] != null) {
      dp := dp.clockwise()
    }
    
    # Move forward
    p += dp
  }
  
  return array
}

? print(spiral(5))
 0  1  2  3  4
15 16 17 18  5
14 23 24 19  6
13 22 21 20  7
12 11 10  9  8