1
2
3
4

let sugar: [Int] = [1, 2]
let desugared: Array<Int> = [1, 2]
print(sugar == desugared, type(of: sugar) == type(of: desugared))
// prints: true true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

let a: [Int] = [1, 2, 3]
let b: Array<Int> = [1, 2, 3]
let c: Int? = 3
let d: Optional<Int> = 3
let e: [String: Int] = ["one": 1]
let f: Dictionary<String, Int> = ["one": 1]

print(a == b, c == d, e == f)
// prints: true true true
print(type(of: a), type(of: c), type(of: e))
// prints: Array<Int> Optional<Int> Dictionary<String, Int>

// 糖可以嵌套，含义就是一层层展开
let nested: [[String: Int]] = [["one": 1]]
let optionalNested: [Int?] = [1, nil]
print(nested, optionalNested.compactMap { $0 })
// prints: [["one": 1]] [1]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

struct Profile {
    var nickname: String?      // 不用写 = nil
    var age: Int
}

let guest = Profile(age: 30)   // 逐成员初始化器直接省略了 nickname
let mia = Profile(nickname: "Mia", age: 30)
print(guest.nickname == nil, mia.nickname ?? "-")
// prints: true Mia

class Session {
    var token: String?         // 类属性同样默认 nil
}
print(Session().token == nil)
// prints: true

func local() {
    var pending: Int?          // 局部变量也不用先赋值
    print(pending == nil)
    pending = 3
    print(pending!)
}
local()
// prints: true
// prints: 3

1
2
3
4
5
6
7
8
9

typealias Pair<T> = (T, T)
typealias Handler<T> = (Result<T, any Error>) -> Void

let point: Pair<Int> = (1, 2)
let handler: Handler<String> = { print($0) }
handler(.success("done"))
print(point.0 + point.1)
// prints: success("done")
// prints: 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

let million = 1_000_000      // 下划线只是给人看的
let hex = 0x1F               // 十六进制：31
let binary = 0b1010          // 二进制：10
let octal = 0o17             // 八进制：15
let scientific = 1e6         // 科学计数法
let small = 1.5e-3           // 0.0015
let hexFloat = 0x1p4         // 十六进制浮点：1 × 2⁴

print(million, hex, binary, octal, scientific, small, hexFloat)
// prints: 1000000 31 10 15 1000000.0 0.0015 16.0
print(type(of: million), type(of: scientific), type(of: hexFloat))
// prints: Int Double Double

1
2
3
4
5
6
7
8

let escapes = "制表\t换行\n反斜杠\\引号\"结束\0"
let smile = "\u{1F600}"      // 用 Unicode 标量写出任意字符
let accent = "\u{00E9}"

print(escapes.count, smile, accent)
// prints: 16 😀 é
print(smile.count, accent.count)
// prints: 1 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

let poem = """
    第一行
      第二行缩进
    第三行
    """
print(poem)
// prints: 第一行
// prints:  第二行缩进
// prints: 第三行
print(poem.split(separator: "\n").count)
// prints: 3

1
2
3
4
5
6

let joined = """
    只有一行\
    其实是同一行
    """
print(joined)
// prints: 只有一行其实是同一行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

let path = #"C:\Users\nick"#              // 不用再把反斜杠写成 \\
let nested = ##"里面写 #" 也没问题"##     // 井号越多，“保护层”越厚
let name = "Mia"
let greeting = #"你好，\#(name)！"#       // 井号数量要和包裹它的数量一致

print(path)
// prints: C:\Users\nick
print(nested)
// prints: 里面写 #" 也没问题
print(greeting)
// prints: 你好，Mia！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func double(_ value: Int) -> Int { value * 2 }
let twice: (Int) -> Int = { $0 * 2 }

struct Point {
    var x = 0
    var y = 0
    var magnitudeSquared: Int { x * x + y * y }
}

print(double(3), twice(3), Point(x: 3, y: 4).magnitudeSquared)
// prints: 6 6 25

1
2
3
4
5
6

func absolute(_ value: Int) -> Int {
    let sign = value < 0 ? -1 : 1   // 这里多了一句
    return value * sign             // 所以 return 不能省
}
print(absolute(-5))
// prints: 5

1

error: missing return in global function expected to return 'Int'

1

error: function produces expected type 'Int'; did you mean to call it with '()'?

1
2
3
4
5
6
7
8
9

func g() -> Int { 7 }

func f() -> Int { g() }        // 单表达式：省的是 return，括号还在
print(f())
// prints: 7

let value: () -> Int = g       // 这里“不写括号”才正确：传的是函数值
print(value())
// prints: 7

1
2
3
4
5

func move(from start: Int, to end: Int) -> Int { end - start }
func move(_ start: Int, _ end: Int) -> Int { end - start }

print(move(from: 1, to: 4), move(1, 4))
// prints: 3 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func a(_ text: String) { print("a: \(text)") }          // 省略 -> Void
func b(_ text: String) -> Void { print("b: \(text)") }
func c(_ text: String) -> () { print("c: \(text)") }    // () 就是 Void

a("x")
// prints: a: x
b("y")
// prints: b: y
c("z")
// prints: c: z

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func greet(_ name: String, greeting: String = "你好") -> String {
    "\(greeting)，\(name)"
}
print(greet("Mia"))
// prints: 你好，Mia
print(greet("Mia", greeting: "早上好"))
// prints: 早上好，Mia

func total(_ numbers: Int...) -> Int { numbers.reduce(0, +) }
print(total(), total(1), total(1, 2, 3))
// prints: 0 1 6

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func doubleInPlace(_ value: inout Int) { value *= 2 }

var n = 21
doubleInPlace(&n)
print(n)
// prints: 42

var x = 1, y = 2
swap(&x, &y)
print(x, y)
// prints: 2 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

struct Counter {
    var count = 0
    func described() -> String { "count=\(count)" }
    static func zero() -> Counter { Counter() }
}

let bound: () -> String = Counter(count: 3).described   // 已经绑定到那个实例
print(bound())
// prints: count=3

let make: () -> Counter = Counter.zero                  // 类型方法直接当函数值
print(make().count)
// prints: 0

1

error: instance member 'described' cannot be used on type 'Counter'

1
2
3
4
5
6
7
8
9

func apply(_ value: Int, _ transform: (Int) -> Int) -> Int { transform(value) }
func square(_ value: Int) -> Int { value * value }

print(apply(5, square), apply(5) { $0 + 1 })
// prints: 25 6

let add: (Int, Int) -> Int = (+)     // 运算符当值用，类型必须写全
print(add(1, 2))
// prints: 3

1

error: ambiguous use of operator '+'

1
2
3
4
5
6
7

func minMax(_ values: [Int]) -> (min: Int, max: Int) {
    (values.min()!, values.max()!)
}

let result = minMax([3, 1, 2])
print(result.min, result.max, result.0)
// prints: 1 3 1

1
2
3
4
5
6
7
8

func describe(_ value: some BinaryInteger) -> String { "\(value)" }
print(describe(42), describe(UInt8(7)))
// prints: 42 7

// 上面这个函数和下面这个泛型版本是同一件事
func describeGeneric<T: BinaryInteger>(_ value: T) -> String { "\(value)" }
print(describeGeneric(42), describeGeneric(UInt8(7)))
// prints: 42 7

1
2
3
4
5
6
7

func pair(_ a: some BinaryInteger, _ b: some BinaryInteger) -> String { "\(a) 和 \(b)" }
print(pair(1, UInt8(2)))          // 一个 Int、一个 UInt8，完全合法
// prints: 1 和 2

func same<T: BinaryInteger>(_ a: T, _ b: T) -> String { "\(a) 与 \(b)" }
print(same(1, 2))
// prints: 1 与 2

1
2
3
4
5
6
7
8

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

let user = User(name: "Mia", age: 30)     // 这个初始化器是编译器写的
print(user.name, user.age)
// prints: Mia 30

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

struct Bag {
    var items: [String] = []
    init(count: Int) {          // 不写 static，也不写返回类型
        items = Array(repeating: "空", count: count)
    }
}

let bag = Bag(count: 2)          // 等于 Bag.init(count: 2)
print(bag.items)
// prints: ["空", "空"]

let make: (Int) -> Bag = Bag.init
print(make(1).items)
// prints: ["空"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

struct Options {
    var retries = 3
    var verbose = false
}
print(Options().retries, Options(retries: 5, verbose: true).verbose)
// prints: 3 true

struct Player {
    let name: String              // let 属性同样会进初始化器
    var level = 1
    private(set) var score = 0    // private(set) 不改变初始化器的可见性
}
print(Player(name: "Mia").level)
// prints: 1
print(Player(name: "Bo", level: 9, score: 100).score)
// prints: 100

1

error: 'Token' initializer is inaccessible due to 'private' protection level

1
2
3
4
5
6

struct Circle {
    var radius: Double
    var area: Double { radius * radius * 3.14159 }   // 没有 get，也没有 return
}
print(Circle(radius: 2).area)
// prints: 12.56636

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

struct Score {
    var value = 0 {
        willSet { print("将变成 \(newValue)") }     // newValue 是隐式提供的
        didSet { print("原来是 \(oldValue)") }       // oldValue 也是
    }
}
var score = Score()
score.value = 10
// prints: 将变成 10
// prints: 原来是 0

1
2
3
4
5
6
7
8

struct Bank {
    private(set) var balance = 0
    mutating func deposit(_ amount: Int) { balance += amount }
}
var bank = Bank()
bank.deposit(100)
print(bank.balance)
// prints: 100

1
2
3
4
5
6
7

struct Point {
    var x = 0
    static var origin: Self { Self(x: 0) }
    func offset(by delta: Int) -> Self { Self(x: x + delta) }
}
print(Point.origin.x, Point(x: 1).offset(by: 2).x)
// prints: 0 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

@propertyWrapper
struct Clamped {
    private var value: Int
    let range: ClosedRange<Int>

    var wrappedValue: Int {
        get { value }
        set { value = min(max(newValue, range.lowerBound), range.upperBound) }
    }
    var projectedValue: String { "允许范围 \(range.lowerBound)...\(range.upperBound)" }

    init(wrappedValue: Int, _ range: ClosedRange<Int>) {
        self.range = range
        self.value = min(max(wrappedValue, range.lowerBound), range.upperBound)
    }
}

struct Player {
    @Clamped(0...100) var health = 80

    func storageValue() -> Int { _health.wrappedValue }   // 同类型内部能看见底层存储
    func limitDescription() -> String { $health }         // $属性 = projectedValue
}

var player = Player()
player.health = 150                    // 走包装器的 setter，被夹到 100
let boosted = Player(health: 120)      // 逐成员初始化器里出现的是包装后的类型 Int
print(player.health, player.storageValue(), boosted.health, player.limitDescription())
// prints: 100 100 100 允许范围 0...100

1
2
3
4

func require<T: Sendable>(_ value: T) -> String { "\(type(of: value)) 是 Sendable" }
struct Measurement { var value: Double }     // 非 public 结构体自动获得 Sendable
print(require(Measurement(value: 1)))
// prints: Measurement 是 Sendable

1
2
3
4
5
6
7
8
9

struct Counter {
    var count = 0
    mutating func bump() { count += 1 }
    func described() -> String { "count=\(count)" }
}
var counter = Counter()
counter.bump()
print(counter.described())
// prints: count=1

1
2
3
4
5
6
7
8
9

final class Node {
    var value: Int
    init(value: Int) {
        self.value = value          // 不写 self，就是把参数赋给参数
    }
    func matches(_ value: Int) -> Bool { self.value == value }
}
print(Node(value: 1).matches(1))
// prints: true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

final class Box {
    var value = 1
    var stored: (() -> Void)?

    func nonEscaping() {
        [1, 2].forEach { index in
            print("\(index): \(value)")      // 非逃逸闭包：可以省 self
        }
    }

    func escaping() {
        stored = { print(self.value) }        // 逃逸闭包：必须写 self
    }
}

let box = Box()
box.nonEscaping()
// prints: 1: 1
// prints: 2: 1
box.escaping()
box.stored?()
// prints: 1

1

error: reference to property 'value' in closure requires explicit use of 'self' to make capture semantics explicit

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

final class Loader {
    var name: String
    var onDone: (() -> Void)?
    init(name: String) { self.name = name }

    func start() {
        onDone = { [weak self] in
            guard let self else { return }     // 绑定简写也适用于 self
            print("完成：\(self.name)")
        }
    }
}
let loader = Loader(name: "任务A")
loader.start()
loader.onDone?()
// prints: 完成：任务A

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

struct User { var name: String }

func greet(_ user: User?) -> String {
    if let user {                          // 等于 if let user = user
        return "你好，\(user.name)"
    }
    return "你好，游客"
}
print(greet(User(name: "Mia")), "|", greet(nil))
// prints: 你好，Mia | 你好，游客

func length(_ text: String?) -> Int {
    guard let text else { return -1 }      // guard 同样适用
    return text.count
}
print(length("swift"), length(nil))
// prints: 5 -1

1
2
3
4
5
6
7
8

func firstLetter(_ text: String?) -> String {
    if let text = text, let first = text.first {   // 可以改名，也可以多个绑定并列
        return String(first)
    }
    return "?"
}
print(firstLetter("swift"), firstLetter(nil))
// prints: s ?

1
2
3
4
5
6

func sum(_ a: Int?, _ b: Int?) -> Int {
    if let a, let b { return a + b }
    return 0
}
print(sum(1, 2), sum(nil, 2))
// prints: 3 0

1
2
3
4
5
6
7

var stack = [1, 2, 3]
var popped: [Int] = []
while case let top? = stack.popLast() {
    popped.append(top)
}
print(popped)
// prints: [3, 2, 1]

1
2
3
4
5
6
7
8

var queue = ["a", "b"]
while let next = queue.popLast() {
    print("取到 \(next)")
}
print(queue.count)
// prints: 取到 b
// prints: 取到 a
// prints: 0

1
2
3
4
5
6
7
8

var maybe: Int? = 3
while let maybe {
    print("值 \(maybe)")
    break                  // 否则会一直循环下去
}
print(maybe as Any)
// prints: 值 3
// prints: Optional(3)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

struct Person { var name: String; var age: Int }
struct Company { var boss: Person? }

let company = Company(boss: Person(name: "Mia", age: 30))
print(company.boss?.name ?? "没有老板")
// prints: Mia

var maybeCompany: Company? = company
maybeCompany?.boss?.age = 31        // 可选链也能站在赋值号左边
print(maybeCompany?.boss?.age ?? 0)
// prints: 31

let primary: String? = nil
let secondary: String? = nil
print(primary ?? secondary ?? "兜底")   // ?? 可以串成一串
// prints: 兜底

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

func run(_ body: () -> Void) { body() }
run { print("A1") }          // 唯一实参：圆括号整个省掉
// prints: A1
run({ print("A2") })         // 不省也完全合法
// prints: A2

func twice(_ times: Int, _ body: () -> Void) {
    for _ in 0..<times { body() }
}
twice(2) { print("C") }      // 前面还有实参：圆括号必须留
// prints: C
// prints: C

// 带标签的单个闭包参数：尾随写法连标签一起省
func wrap(content: () -> String) -> String { "[\(content())]" }
print(wrap { "B1" }, wrap(content: { "B2" }))
// prints: [B1] [B2]

1
2
3
4
5
6
7

struct Card {
    var title: String
    var body: () -> String
}
let card = Card(title: "标题") { "正文" }
print(card.title, card.body())
// prints: 标题 正文

1
2
3
4
5
6
7

func fetch(_ id: Int, success: () -> String, onError: (Int) -> String) -> String {
    success()
}
print(fetch(1) { "ok" } onError: { "err \($0)" })
// prints: ok
print(fetch(1, success: { "ok" }, onError: { "err \($0)" }))
// prints: ok

1
2
3
4
5

let pairs = [(2, 3), (1, 5)]
print(pairs.map { $0.0 * $0.1 })
// prints: [6, 5]
print(pairs.sorted { $0.0 < $1.0 }.map(\.1))
// prints: [5, 3]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func makeMessage() -> String {
    print("（这次真的算了）")
    return "出错了"
}

func check(_ value: Int, _ message: @autoclosure () -> String) {
    if value < 0 { print(message()) }
}

check(1, makeMessage())     // 条件不成立，参数根本不会被求值
check(-1, makeMessage())    // 条件成立，才真正计算
// prints: （这次真的算了）
// prints: 出错了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

final class Holder {
    var name = "N"

    func make() -> [() -> String] {
        let counter = 0
        return [
            { [self] in name },                       // 显式捕获 self，类型不是可选值
            { [counted = counter] in "\(counted)" },  // 捕获时换个名字
            { [weak self] in self?.name ?? "nil" },   // 弱引用，self 变成可选值
        ]
    }
}
print(Holder().make().map { $0() })
// prints: ["N", "0", "N"]

1
2
3
4
5
6
7
8
9

let numbers = [3, 1, 2]
print(numbers.sorted(by: <))
// prints: [1, 2, 3]
print(numbers.sorted(by: >))
// prints: [3, 2, 1]
print(numbers.reduce(0, +))
// prints: 6
print(numbers.reduce(1, *))
// prints: 6

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

struct Word { var text: String; var length: Int }
let words = [Word(text: "swift", length: 5), Word(text: "go", length: 2)]

print(words.map(\.text))
// prints: ["swift", "go"]
print(words.map(\.length))
// prints: [5, 2]
print(words.map(\.text.count))
// prints: [5, 2]
print([1, 2, 3].map(\.self))     // 键路径也可以只指向自己
// prints: [1, 2, 3]

1

error: cannot infer key path type from context; consider explicitly specifying a root type

1

print(words.sorted(by: \Word.text))

1

error: cannot convert key path into a multi-argument function type '(Word, Word) throws -> Bool'

1
2
3
4
5
6

import Foundation

struct Person: Equatable { var name: String; var age: Int }
let people = [Person(name: "Mia", age: 30), Person(name: "Bo", age: 20)]
print(people.sorted(using: KeyPathComparator(\.age)).map(\.name))
// prints: ["Bo", "Mia"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

enum Event {
    case key(String)
    case click(x: Int, y: Int)
}
let events: [Event] = [.click(x: 1, y: 1), .key("a"), .key("b")]

if case .key(let k) = events[1] {       // 只关心这一种情况
    print("按键: \(k)")
}
// prints: 按键: a

for case .key(let k) in events {        // 只处理匹配的元素，其余自动跳过
    print("按键: \(k)")
}
// prints: 按键: a
// prints: 按键: b

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

for x in 1...10 where x % 4 == 0 {
    print("where: \(x)")
}
// prints: where: 4
// prints: where: 8

func describe(_ point: (Int, Int)) -> String {
    switch point {
    case let (x, y) where x == y: return "对角线"
    default: return "其他"
    }
}
print(describe((2, 2)), describe((2, 3)))
// prints: 对角线 其他

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

struct Even {}
func ~= (pattern: Even, value: Int) -> Bool { value % 2 == 0 }

for n in 3...4 {
    switch n {
    case Even(): print("\(n) 是偶数")
    default: print("\(n) 是奇数")
    }
}
// prints: 3 是奇数
// prints: 4 是偶数

1
2
3
4
5
6
7
8

func label(_ point: (Int, Int)) -> String {
    switch point {
    case (0, 0), (1, 1): return "特殊点"
    default: return "普通点"
    }
}
print(label((1, 1)), label((5, 5)))
// prints: 特殊点 普通点

1

error: 'x' must be bound in every pattern

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

let score = 72
let verdict = if score >= 60 { "及格" } else { "不及格" }
print(verdict)
// prints: 及格

let grade = if score >= 90 { "优秀" } else if score >= 60 { "通过" } else { "重修" }
print(grade)
// prints: 通过

let n = -3
let sign = switch n {
case ..<0: "负"
case 0: "零"
default: "正"
}
print(sign)
// prints: 负

1
2

error: non-expression branch of 'if' expression may only end with a 'throw'
error: non-expression branch of 'switch' expression may only end with a 'throw' or 'fallthrough'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

enum ParseError: Error { case negative }

func absolute(_ value: Int) throws -> Int {
    let result = if value < 0 {
        print("检出负数 \(value)")      // 多了一句，但结尾是 throw，所以成立
        throw ParseError.negative
    } else {
        value
    }
    return result
}

print(try absolute(4))
// prints: 4
do {
    _ = try absolute(-4)
} catch {
    print("被拒绝：\(error)")
}
// prints: 检出负数 -4
// prints: 被拒绝：negative

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

enum InputError: Error { case notANumber }

func parse(_ text: String) throws -> Int {
    guard let value = Int(text) else { throw InputError.notANumber }
    return value
}

let parsed: Int
do { parsed = try parse("42") } catch { parsed = -1 }
print(parsed)
// prints: 42

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

enum Color: String { case red, green, blue }

struct Style: OptionSet {
    let rawValue: Int
    static let bold = Style(rawValue: 1 << 0)
    static let italic = Style(rawValue: 1 << 1)
}

let c: Color = .red
let palette: [Color] = [.red, .blue]
let styles: Style = [.bold, .italic]
func paint(_ color: Color) -> String { color.rawValue }

print(c.rawValue, palette.map(\.rawValue), styles.contains(.italic))
// prints: red ["red", "blue"] true
print(paint(.green))
// prints: green

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 下面两行沿用本节上面的定义，为了单独运行，这里再写一遍
enum Color: String { case red, green, blue }
struct Style: OptionSet {
    let rawValue: Int
    static let bold = Style(rawValue: 1 << 0)
    static let italic = Style(rawValue: 1 << 1)
}

let table: [String: Color] = ["warm": .red, "cool": .green]
print(table["warm"]?.rawValue ?? "nil")
// prints: red

// 从 Swift 5.4 起，隐式成员后面还能继续接成员
let combined: Style = .bold.union(.italic)
print(combined.contains(.italic), combined.rawValue)
// prints: true 3

func maybe(_ flag: Bool) -> Int? { flag ? .some(1) : .none }
print(maybe(true) ?? -1, maybe(false) ?? -1)
// prints: 1 -1

1
2
3
4
5
6
7
8
9

enum Color: String { case red, green, blue }

let make = Color.init(rawValue:)
print(make("blue")?.rawValue ?? "nil")
// prints: blue

let makeInt: (String) -> Int? = Int.init      // 这里必须写类型，否则重载无法确定
print(makeInt("42") ?? 0, makeInt("abc") ?? -1)
// prints: 42 -1

1

error: ambiguous use of 'init'

1
2
3
4
5
6
7

struct Multiplier {
    var factor: Int
    func callAsFunction(_ value: Int) -> Int { value * factor }
}
let triple = Multiplier(factor: 3)
print(triple(5), triple(10))
// prints: 15 30

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

struct Matrix {
    let size: Int
    private var storage: [Int]
    init(size: Int) {
        self.size = size
        storage = Array(repeating: 0, count: size * size)
    }
    subscript(row: Int, column: Int) -> Int {
        get { storage[row * size + column] }
        set { storage[row * size + column] = newValue }
    }
}
var matrix = Matrix(size: 2)
matrix[0, 1] = 5
matrix[1, 1] = 7
print(matrix[0, 1], matrix[1, 1], matrix[0, 0])
// prints: 5 7 0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

struct Money: ExpressibleByIntegerLiteral, CustomStringConvertible {
    var cents: Int
    init(integerLiteral value: Int) { cents = value * 100 }
    var description: String { "\(cents / 100) 元 \(cents % 100) 分" }
}
let price: Money = 3          // 字面量 3 被解释成 3 元
print(price)
// prints: 3 元 0 分

struct Route: ExpressibleByArrayLiteral, CustomStringConvertible {
    var stops: [String]
    init(arrayLiteral elements: String...) { stops = elements }
    var description: String { stops.joined(separator: " → ") }
}
let route: Route = ["北京", "上海", "杭州"]
print(route)
// prints: 北京 → 上海 → 杭州

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

@dynamicMemberLookup
struct JSON {
    private var storage: [String: String]
    init(_ storage: [String: String]) { self.storage = storage }

    subscript(dynamicMember key: String) -> String? { storage[key] }
}

let document = JSON(["name": "Mia"])
print(document.name ?? "无", document.age ?? "无")
// prints: Mia 无

@dynamicCallable
struct Adder {
    func dynamicallyCall(withArguments args: [Int]) -> Int { args.reduce(0, +) }
}
print(Adder()(1, 2, 3))
// prints: 6