// 只能赋值一次，再次赋值会报错
let hello = "world"
print(hello)

// hello 可以多次赋值
var hello = "world"
print(hello)
print("hello \(hello)")

let label: String = "The width is"

let age: Int = 25
let smallNumber: Int8 = 127
let largeNumber: Int64 = 9223372036854775807

let pi: Float = 3.14159
let pi: Double = 3.141592653589793

let latitude: Double = 34.011_286
let longitude: Double = -118.495_308

print("Latitude: \(latitude)")  // 输出: Latitude: 34.011286
print("Longitude: \(longitude)") // 输出: Longitude: -118.495308

const latitude = 34.011_286;
const longitude = -118.495_308;

console.log(`Latitude: ${latitude}`);  // 输出: Latitude: 34.011286
console.log(`Longitude: ${longitude}`); // 输出: Longitude: -118.495308

let isSwiftAwesome: Bool = true

// 定义字符串
let greeting: String = "Hello, World!"

// 包含转义字符的字符串
let quote: String = "He said, \"Swift is awesome!\""

// 字符串插值
let name: String = "Alice"
let message: String = "Hello, \(name)"

// 正确的字符定义（注意仍然使用双引号）
let letter: Character = "A"
let emoji: Character = "😊"
// 错误示例：let invalidCharacter: Character = "AB"  // 会报编译错误

class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

let person1 = Person(name: "Alice")
let person2 = person1
let person3 = Person(name: "Alice")

// person1 和 person2 指向同一个实例
if person1 === person2 {
    print("person1 and person2 refer to the same instance.")
} else {
    print("person1 and person2 do not refer to the same instance.")
}

// person1 和 person3 指向不同的实例，但其内容相同
if person1 === person3 {
    print("person1 and person3 refer to the same instance.")
} else {
    print("person1 and person3 do not refer to the same instance.")  // 这一句会执行
}

if person1 !== person3 {
    print("person1 and person3 do not refer to the same instance.")
} else {
    print("person1 and person3 refer to the same instance.")
}

struct Point: Equatable {
    var x: Int
    var y: Int
}

let point1 = Point(x: 1, y: 1)
let point2 = Point(x: 1, y: 1)

if point1 == point2 {
    print("point1 and point2 have the same content.")
} else {
    print("point1 and point2 have different content.")
}

class Person: Equatable {
    var name: String

    init(name: String) {
        self.name = name
    }

    // 实现 Equatable 协议的方法
    static func == (lhs: Person, rhs: Person) -> Bool {
        return lhs.name == rhs.name
    }
}

let person1 = Person(name: "Alice")
let person2 = Person(name: "Alice")

if person1 == person2 {
    print("person1 and person2 have the same content.")
} else {
    print("person1 and person2 have different content.")
}

var optionalString: String? = "Hello"

var optionalString: String? = "Hello"
if optionalString != nil {
    print(optionalString!)  // 输出: Hello
}

// if let 语法
if let unwrappedString = optionalString {
    print(unwrappedString)  // 输出: Hello
}

// guard let 语法
func printOptionalString(_ string: String?) {
    guard let unwrappedString = string else {
        print("No value")
        return
    }
    print(unwrappedString)
}
printOptionalString(optionalString)  // 输出: Hello

var implicitUnwrappedString: String! = "Hello"
print(implicitUnwrappedString)  // 输出: Hello

class Person {
    var name: String?
    var address: Address?
}

class Address {
    var city: String?
}

let person = Person()
person.address = Address()
person.address?.city = "San Francisco"

// 使用可选链
if let city = person.address?.city {
    print("City is \(city)")  // 输出: City is San Francisco
} else {
    print("City is not set")
}

let optionalString: String? = nil
let defaultValue = optionalString ?? "Default Value"
print(defaultValue)  // 输出: Default Value

// 可选参数
func greet(name: String?) {
    guard let name = name else {
        print("Hello, guest!")
        return
    }
    print("Hello, \(name)!")
}

greet(name: "Alice")  // 输出: Hello, Alice!
greet(name: nil)      // 输出: Hello, guest!

// 可选返回类型
func findNameInDictionary(dict: [String: String], key: String) -> String? {
    return dict[key]
}

let names = ["Alice": "Engineer", "Bob": "Manager"]
if let title = findNameInDictionary(dict: names, key: "Alice") {
    print("Alice's title is \(title).")
} else {
    print("Title not found.")
}

let label = "The width is"
let width = 94
let widthLabel = label + String(width)

let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."

let emptyArray: [String] = []
let numbers: [Int] = [1, 2, 3, 4, 5]
let names: [String] = ["Alice", "Bob", "Charlie"]

let uniqueNumbers: Set<Int> = [1, 2, 3, 4, 4, 5]
// uniqueNumbers = [1, 2, 3, 4, 5]

let studentGrades: [String: String] = ["Alice": "A", "Bob": "B"]
let emptyDictionary: [String: Float] = [:]

let http404Error = (404, "Not Found")
let person = (name: "Alice", age: 25)
print(person.name)  // 输出: Alice
print(person.age)   // 输出: 25

struct ReplaxModel: Hashable, Codable {
    var id: Int
    var name: String
    var park: String
    var state: String
    var description: String
    
    private var imageName: String
}

var fruits = ["Apple", "Banana", "Cherry"]
let firstFruit = fruits[0]  // 访问第一个元素，返回 "Apple"
fruits[1] = "Blueberry"     // 修改第二个元素的值为 "Blueberry"
print(fruits)               // 输出 ["Apple", "Blueberry", "Cherry"]

var ages = ["Alice": 25, "Bob": 28]
let aliceAge = ages["Alice"]  // 访问 Alice 的年龄，返回 25
ages["Bob"] = 30               // 修改 Bob 的年龄为 30
print(ages)                    // 输出 ["Alice": 25, "Bob": 30]

struct Matrix {
    let rows: Int, columns: Int
    var grid: [Double]
    
    init(rows: Int, columns: Int) {
        self.rows = rows
        self.columns = columns
        self.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
        }
    }
}

var matrix = Matrix(rows: 2, columns: 2)
matrix[0, 1] = 1.5
matrix[1, 0] = 3.2
print(matrix[0, 1])  // 输出 1.5
print(matrix[1, 0])  // 输出 3.2

subscript(parameters) -> ReturnType {
    get {
        // 返回适当的值
    }
    set(newValue) {
        // 执行适当的赋值操作
    }
}

let username = "admin"
let password = "1234"

if username == "admin" && password == "1234" {
    print("Login successful")
} else {
    print("Login failed")
}

if let name = optionalName {
    greeting = "Hello, \(name)"
}

let names = ["Anna", "Alex", "Brian", "Jack"]
for name in names {
    print("Hello, \(name)!")
}

for _ in 0..<10 {
    let newItem = Item(context: viewContext)
    newItem.timestamp = Date()
}

enum FileError: Error {
    case fileNotFound
    case unreadable
    case encodingFailed
}

func readFile(filename: String) throws -> String {
    // 模拟抛出错误
    throw FileError.fileNotFound
}

do {
    let content = try readFile(filename: "example.txt")
    print(content)
} catch FileError.fileNotFound {
    print("File not found.")
} catch FileError.unreadable {
    print("File is unreadable.")
} catch FileError.encodingFailed {
    print("Failed to encode the file.")
} catch {
    print("An unexpected error occurred: \(error).")
}

if let content = try? readFile(filename: "example.txt") {
    print(content)
} else {
    print("Failed to read the file.")
}

let content = try! readFile(filename: "example.txt")
print(content)

enum DivisionError: Error {
    case dividedByZero
}

func divide(_ num: Int, by divisor: Int) throws -> Int {
    if divisor == 0 {
        throw DivisionError.dividedByZero
    }
    return num / divisor
}

do {
    let result = try divide(10, by: 2)
    print("Result: \(result)")
} catch DivisionError.dividedByZero {
    print("Cannot divide by zero.")
} catch {
    print("An unexpected error occurred: \(error).")
}

guard condition else {
    // 如果条件不满足，则执行退出操作
    return  // 或其他退出操作
}

// 如果条件满足，继续执行下面的代码

func validateAge(age: Int) {
    guard age >= 18 else {
        print("You must be at least 18 years old.")
        return
    }
    print("Access granted.")
}

validateAge(age: 20)  // 输出: Access granted.
validateAge(age: 16)  // 输出: You must be at least 18 years old.

func printUsername(user: [String: String]) {
    guard let username = user["username"] else {
        print("No username found.")
        return
    }
    print("Username is \(username).")
}

let user1 = ["username": "Alice"]
let user2 = ["email": "alice@example.com"]

printUsername(user: user1)  // 输出: Username is Alice.
printUsername(user: user2)  // 输出: No username found.

func process(order: [String: Any]) {
    guard
        let productID = order["productID"] as? Int,
        let quantity = order["quantity"] as? Int,
        quantity > 0
    else {
        print("Invalid order.")
        return
    }
    print("Processing order for productID \(productID) with quantity \(quantity).")
}

let order1 = ["productID": 123, "quantity": 10]
let order2 = ["productID": "abc", "quantity": 0]

process(order: order1)  // 输出: Processing order for productID 123 with quantity 10.
process(order: order2)  // 输出: Invalid order.

// 使用 if 嵌套
func processIf(order: [String: Any]) {
    if let productID = order["productID"] as? Int {
        if let quantity = order["quantity"] as? Int {
            if quantity > 0 {
                print("Processing order for productID \(productID) with quantity \(quantity).")
            } else {
                print("Invalid quantity.")
            }
        } else {
            print("Invalid quantity.")
        }
    } else {
        print("Invalid productID.")
    }
}

// 使用 guard 提前退出
func processGuard(order: [String: Any]) {
    guard
        let productID = order["productID"] as? Int,
        let quantity = order["quantity"] as? Int,
        quantity > 0
    else {
        print("Invalid order.")
        return
    }
    print("Processing order for productID \(productID) with quantity \(quantity).")
}

enum CompassPoint {
    case north
    case south
    case east
    case west
}

var direction = CompassPoint.north

direction = .east

enum Barcode {
    case upc(Int, Int, Int, Int)
    case qrCode(String)
}

var productBarcode = Barcode.upc(8, 85909, 51226, 3)
productBarcode = .qrCode("ABCDEFGHIJKLMNOP")

switch productBarcode {
case .upc(let numberSystem, let manufacturer, let product, let check):
    print("UPC: \(numberSystem), \(manufacturer), \(product), \(check)")
case .qrCode(let productCode):
    print("QR Code: \(productCode)")
}

enum Planet: Int {
    case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
}

let earthsOrder = Planet.earth.rawValue // earthsOrder是3

let possiblePlanet = Planet(rawValue: 3) // possiblePlanet 是 Planet.earth

enum CompassPoint {
    case north, south, east, west
    
    mutating func next() {
        switch self {
        case .north:
            self = .east
        case .east:
            self = .south
        case .south:
            self = .west
        case .west:
            self = .north
        }
    }
}

var direction = CompassPoint.north
direction.next()  // direction 现在是 .east

enum ArithmeticExpression {
    case number(Int)
    indirect case addition(ArithmeticExpression, ArithmeticExpression)
    indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
}

// 你也可以在枚举前加上 indirect 关键字
indirect enum ArithmeticExpression {
    case number(Int)
    case addition(ArithmeticExpression, ArithmeticExpression)
    case multiplication(ArithmeticExpression, ArithmeticExpression)
}

let five = ArithmeticExpression.number(5)
let four = ArithmeticExpression.number(4)
let sum = ArithmeticExpression.addition(five, four)
let product = ArithmeticExpression.multiplication(sum, ArithmeticExpression.number(2))

func evaluate(_ expression: ArithmeticExpression) -> Int {
    switch expression {
    case .number(let value):
        return value
    case .addition(let left, let right):
        return evaluate(left) + evaluate(right)
    case .multiplication(let left, let right):
        return evaluate(left) * evaluate(right)
    }
}

let result = evaluate(product) // result 是 18

func greet(name: String) -> String {
    return "Hello, \(name)!"
}

let greeting = greet(name: "Alice")
print(greeting)  // 输出: "Hello, Alice!"

func sum(a: Int, b: Int) -> Int {
    return a + b
}

let result = sum(a: 5, b: 3)
print(result)  // 输出: 8

func join(string s1: String, with s2: String, separator: String) -> String {
    return s1 + separator + s2
}

let joinedString = join(string: "Hello", with: "World", separator: ", ")
print(joinedString)  // 输出: "Hello, World"

func greet(#name: String, #age: Int) {
    print("Hello, \(name)! You are \(age) years old.")
}

greet(name: "Alice", age: 30)
// 输出: Hello, Alice! You are 30 years old.

func sum(_ a: Int, _ b: Int) -> Int {
    return a + b
}

let result = sum(10, 20)
print(result)  // 输出: 30

// 推荐的参数标签和参数名不同使用方式
func greet(person name: String, from hometown: String) {
    print("Hello, \(name)! Glad you could visit from \(hometown).")
}

greet(person: "Alice", from: "New York")

func greet(name: String = "Guest") -> String {
    return "Hello, \(name)!"
}

print(greet())  // 输出: "Hello, Guest!"
print(greet(name: "Bob"))  // 输出: "Hello, Bob!"

func square(number: Int) -> Int {
    return number * number
}

let squaredValue = square(number: 4)
print(squaredValue)  // 输出: 16

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    guard let minElement = array.min(), let maxElement = array.max() else {
        return nil
    }
    return (minElement, maxElement)
}

if let bounds = minMax(array: [1, 2, 3, 4, 5]) {
    print("min: \(bounds.min), max: \(bounds.max)")
}

func applyOperation(_ a: Int, _ b: Int, operation: (Int, Int) -> Int) -> Int {
    return operation(a, b)
}

let result = applyOperation(4, 2, operation: { $0 * $1 })
print(result)  // 输出: 8

func makeIncrementer(amount: Int) -> (Int) -> Int {
    func incrementer(value: Int) -> Int {
        return value + amount
    }
    return incrementer
}

let incrementByFive = makeIncrementer(amount: 5)
let result = incrementByFive(10)
print(result)  // 输出: 15

func outerFunction() -> () -> Int {
    var total = 0
    func innerFunction() -> Int {
        total += 1
        return total
    }
    return innerFunction
}

let incrementer = outerFunction()
print(incrementer())  // 输出: 1
print(incrementer())  // 输出: 2

let numbers = [1, 2, 3, 4, 5]
let doubledNumbers = numbers.map { $0 * 2 }
print(doubledNumbers)  // 输出: [2, 4, 6, 8, 10]

func sum(of numbers: Int...) -> Int {
    return numbers.reduce(0, +)
}

let result = sum(of: 1, 2, 3, 4, 5)
print(result)  // 输出: 15

func swapValues(_ a: inout Int, _ b: inout Int) {
    let temp = a
    a = b
    b = temp
}

var x = 3
var y = 5
swapValues(&x, &y)
print(x, y)  // 输出: 5 3

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var x = 5
var y = 10
print("Before swap: x = \(x), y = \(y)")  // 输出: Before swap: x = 5, y = 10

swapTwoInts(&x, &y)
print("After swap: x = \(x), y = \(y)")  // 输出: After swap: x = 10, y = 5

func bubbleSort(_ array: inout [Int]) {
    let n = array.count
    for i in 0..<n {
        for j in 1..<n-i {
            if array[j-1] > array[j] {
                let temp = array[j-1]
                array[j-1] = array[j]
                array[j] = temp
            }
        }
    }
}

var numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
print("Before sort: \(numbers)")  // 输出: Before sort: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

bubbleSort(&numbers)
print("After sort: \(numbers)")  // 输出: After sort: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

protocol Drawable {
    func draw()
}

protocol Identifiable {
    var id: String { get }
}

struct Circle: Drawable {
    func draw() {
        print("Drawing a circle")
    }
}

class User: Identifiable {
    var id: String

    init(id: String) {
        self.id = id
    }
}

struct UserProfile: Identifiable, Drawable {
    var id: String

    func draw() {
        print("Drawing user profile with id: \(id)")
    }
}

protocol FullyNamed {
    var fullName: String { get }
}

protocol Person {
    var name: String { get set }
    var age: Int { get set }
}

protocol Toggleable {
    mutating func toggle()
}

enum LightSwitch: Toggleable {
    case off, on

    mutating func toggle() {
        switch self {
        case .off:
            self = .on
        case .on:
            self = .off
        }
    }
}

protocol Named {
    var name: String { get }
}

protocol Aged {
    var age: Int { get }
}

protocol Person: Named, Aged { }

func describe<T: Named & Aged>(person: T) {
    print("\(person.name) is \(person.age) years old.")
}

protocol Greetable {
    func greet()
}

extension Greetable {
    func greet() {
        print("Hello!")
    }
}

struct Person: Greetable {}

let person = Person()
person.greet() // 输出: Hello!

protocol Container {
    associatedtype Item
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}

struct Stack<Element>: Container {
    var items: [Element] = []
    
    var count: Int {
        return items.count
    }
    
    subscript(i: Int) -> Element {
        return items[i]
    }
}

struct Resolution {
    var width: Int
    var height: Int
}

let res = Resolution(width: 1920, height: 1080)

print("The resolution width is \(res.width)")

// 如果需要修改，需要将实例声明为 var
var modifiableRes = res
modifiableRes.width = 1280
print("The new resolution width is \(modifiableRes.width)")

struct Resolution {
    var width: Int
    var height: Int
    
    func display() {
        print("Resolution: \(width)x\(height)")
    }
    
    mutating func resize(toWidth width: Int, andHeight height: Int) {
        self.width = width
        self.height = height
    }
}

var res = Resolution(width: 1920, height: 1080)
res.display() // 输出: Resolution: 1920x1080
res.resize(toWidth: 1280, andHeight: 720)
res.display() // 输出: Resolution: 1280x720

struct Resolution {
    var width: Int
    var height: Int
    
    init(width: Int, height: Int) {
        self.width = width
        self.height = height
    }
}

let res1 = Resolution(width: 1920, height: 1080)
var res2 = res1
res2.width = 1280

print("res1 width: \(res1.width)") // 输出: res1 width: 1920
print("res2 width: \(res2.width)") // 输出: res2 width: 1280

class Person {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func greet() {
        print("Hello, my name is \(self.name)")
    }
}

class Point {
    var x: Int
    var y: Int
    
    init(x: Int, y: Int) {
        self.x = x
        self.y = y
    }
    
    func setCoordinates(x: Int, y: Int) {
        self.x = x
        self.y = y
    }
}

class MyClass {
    var closure: (() -> Void)?
    
    func setupClosure() {
        self.closure = {
            self.doSomething()
        }
    }
    
    func doSomething() {
        print("Doing something")
    }
}

class SomeClass {
    var closure: (() -> Void)?
    
    func setupClosure() {
        self.closure = { [weak self] in
            self?.doSomething()
        }
    }
    
    func doSomething() {
        print("Doing something")
    }
}

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var int1 = 1
var int2 = 2
swapTwoValues(&int1, &int2) // int1 现在是 2，int2 是 1

var str1 = "Hello"
var str2 = "World"
swapTwoValues(&str1, &str2) // str1 现在是 "World"，str2 是 "Hello"

struct Stack<Element> {
    private var items: [Element] = []

    mutating func push(_ item: Element) {
        items.append(item)
    }

    mutating func pop() -> Element? {
        return items.popLast()
    }

    func top() -> Element? {
        return items.last
    }

    var isEmpty: Bool {
        return items.isEmpty
    }
}

var intStack = Stack<Int>()
intStack.push(1)
intStack.push(2)
print(intStack.top()!) // 输出 2

var stringStack = Stack<String>()
stringStack.push("Hello")
stringStack.push("World")
print(stringStack.top()!) // 输出 "World"

func findIndex<T: Equatable>(of valueToFind: T, in array: [T]) -> Int? {
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}

let numbers = [1, 2, 3, 4, 5]
if let index = findIndex(of: 3, in: numbers) {
    print("Index of 3 in numbers is \(index)") // 输出 "Index of 3 in numbers is 2"
}

func someFunction<T, U>(param1: T, param2: U) where T: Equatable, U: Comparable {  
    // 在这个函数中，T 需要遵循 Equatable 协议，U 需要遵循 Comparable 协议  
}

protocol Container {
    associatedtype ItemType
    mutating func append(_ item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType { get }
}

struct IntStack: Container {
    // existing implementation of IntStack
    var items = [Int]()
    mutating func push(_ item: Int) {
        items.append(item)
    }
    mutating func pop() -> Int {
        return items.removeLast()
    }

    // conformance to the Container protocol
    typealias ItemType = Int

    mutating func append(_ item: Int) {
        self.push(item)
    }

    var count: Int {
        return items.count
    }

    subscript(i: Int) -> Int {
        return items[i]
    }
}

import SwiftUI

struct ContentView: View {
    var body: some View {
        Text("Hello, world!")
            .padding()
    }
}

#Preview {
    ContentView()
}

if #available(iOS 14, *) {
    // 代码只在 iOS 14 及以上版本运行
} else {
    // 其他版本的替代实现代码
}

class Rectangle {
    var width: Double
    var height: Double

    var area: Double {
        get {
            return width * height
        }
        set {
            width = sqrt(newValue)
            height = sqrt(newValue)
        }
    }

    init(width: Double, height: Double) {
        self.width = width
        self.height = height
    }
}

let rectangle = Rectangle(width: 4.0, height: 3.0)

print(rectangle.area) // 输出：12.0

rectangle.area = 25.0 // 设置 area 为 25.0

print(rectangle.width) // 输出：5.0
print(rectangle.height) // 输出：5.0

class Circle {
    var radius: Double

    var area: Double {
        get {
            return Double.pi * radius * radius
        }
        set(newAreaValue) { // 使用 newAreaValue 作为参数名
            radius = sqrt(newAreaValue / Double.pi) // 使用 newAreaValue 访问参数值
        }
    }

    init(radius: Double) {
        self.radius = radius
    }
}

let circle = Circle(radius: 2.0)
circle.area = 12.56 // 设置 area 为 12.56
print(circle.radius) // 输出：2.0

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

let nameKeyPath = \Person.name
let ageKeyPath = \Person.age

var person = Person(name: "Alice", age: 30)

let personName = person[keyPath: nameKeyPath]  // "Alice"
let personAge = person[keyPath: ageKeyPath]    // 30

person[keyPath: nameKeyPath] = "Bob"
person[keyPath: ageKeyPath] = 35

print(person)  // 输出: Person(name: "Bob", age: 35)

struct Address {
    var city: String
    var zipcode: String
}

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

let addressKeyPath = \Person.address
let cityKeyPath = \Person.address.city

let person = Person(name: "Alice", age: 30, address: Address(city: "New York", zipcode: "10001"))

let personAddress = person[keyPath: addressKeyPath]  // Address(city: "New York", zipcode: "10001")
let personCity = person[keyPath: cityKeyPath]        // "New York"

let nameKeyPath = \Person.name
let person = Person(name: "Alice", age: 30)

// 错误：类型不匹配
let city = person[keyPath: nameKeyPath] // 编译错误

struct Point {
    var x: Int
    var y: Int

    mutating func moveBy(dx: Int, dy: Int) {
        x += dx
        y += dy
    }
}

var point = Point(x: 0, y: 0)
point.moveBy(dx: 5, dy: 3)
print("Point is now at (\(point.x), \(point.y))") // 输出: Point is now at (5, 3)