koher

キャパシティが増加したタイミングでバッファが作り直されている気がします

これはそうだと思います。その上で、↓のような疑問を持っています。

まず、 ArraySlice の挙動として、 popFirst した場合 startIndex がインクリメントされるだけで、各要素のインデックスは変化しません。

var a: ArraySlice<Int> = [2, 3, 5]
_ = a.popFirst()
print(a[1]) // 3

koher

let xzs = [
    (3333, 8650),
    (3333, 8634),
    (3342, 8634),
    (3342, 8633),
    (3352, 8633),
    (3352, 8634),
    (3360, 8634),
    (3360, 8638),
    (3361, 8638),

koher

// `Foo` is an immutable class
final class Foo {
    let value: Int
    init(_ value: Int) {
        self.value = value
    }
}

// Adds `mutating func` to `Foo`
protocol Incremental {

koher

// もし if let が存在しなかったら・・・

let a: Int? = Int("...")

if a != nil {
    // ここでは a は nil ではないとわかっているけど、
    // a の型は Int? なので↓のような計算はできない。
    print(a * 2) // コンパイルエラー
  
    // a は nil でないとわかっているのに、↓のように

koher

struct DirectProduct<Left: Sequence, Right: Sequence>: Sequence {
    let left: Left
    let right: Right
    let iteratorType: Iterator.Type
    
    init(_ left: Left, _ right: Right) {
        self.left = left
        self.right = right
        iteratorType = Iterator1.self
    }

koher

do { // 一時的な変数 foo のスコープを切る
  let foo: Foo
  switch bar {
  case .a:
    foo = ...
  case .b:
    foo = ...
  case .c:
    foo = ...
  }

koher

protocol Animal {
    func foo() -> Int
}

struct Cat: Animal {
    var value: Int = 42
    func foo() -> Int { return value }
}

func useAnimal(_ animal: Animal) -> Int {

koher

struct Person {
    var name: String
    var age: Int
}

var a = [
    Person(name: "Foo", age: 20),
    Person(name: "Bar", age: 30),
]

koher

protocol CatProtocol {
    var name: String { get set }
    func nya() -> String
    mutating func sleep()
    func clone() -> Self
    func cast<T>(to: T.Type) -> T?
}

class Cat : CatProtocol {
    required init() {}

koher

let array = [2, 3, 3, 4, 7, 2, 1, 4, 0, 9, 1, 2]

// array の要素の値ごとに集計
// 2 が 3 個、 3 が 2 個 などを知りたい
let nToCount: [Int: Int] = array.reduce(into: [:]) { nToCount, n in
    nToCount[n, default: 0] += 1
}

// 結果を表示
for (n, count) in (nToCount.sorted { $0.key < $1.key }) {