An array that's never empty.

OneArray.swift

enum OneArray<T> {
  case one(T)
  case many([T])

  // Want empty value? Fuck you.
  init?<S: Sequence where S.Iterator.Element == T>(_ s: S) {
    switch s.underestimatedCount {
    case 0:
      return nil
    case 1:
      self = .one(s.first(where: { _ in true })!)
    default:
      self = .many(Array(s))
    }
  }

  // Use it like a normal array. TODO: conform to Collection
  subscript(_ index: Int) -> T {
    get {
      switch self {
      case .one(let value):
        return value
      case .many(let values):
        return values[index]
      }
    }
    set(newValue) {
      switch (self, index) {
      case (.one, 0):
        self = .one(newValue)
      case (.one, _):
        break
      case (.many(let values), _):
        var newValues = values
        newValues[index] = newValue
        self = .many(newValues)
      }
    }
  }

  var count: Int {
    switch self {
    case .one:
      return 1
    case .many(let values):
      return values.count
    }
  }

  // .first and .last are not optional, NICE.
  var first: T {
    switch self {
    case .one(let value):
      return value
    case .many(let values):
      return values.first!
    }
  }

  var last: T {
    switch self {
    case .one(let value):
      return value
    case .many(let values):
      return values.last!
    }
  }
}