// Basic function func greet(person: String) -> String { return "Hello, \(person)!" } print(greet(person: "CodeOrbitPro")) // Multiple return values via tuple func minMax(array: [Int]) -> (min: Int, max: Int)? { guard !array.isEmpty else { return nil } var currentMin = array[0] var currentMax = array[0] for value in array[1.. currentMax { currentMax = value } } return (currentMin, currentMax) } if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) { print("Min: \(bounds.min), Max: \(bounds.max)") } // Parameter labels func calculateArea(for width: Double, and height: Double) -> Double { return width * height } print(calculateArea(for: 5.0, and: 10.0)) // Default parameters func increment(number: Int, by amount: Int = 1) -> Int { return number + amount } print(increment(number: 5)) // Uses default (6) print(increment(number: 5, by: 3)) // Custom increment (8) // Variadic parameters func average(_ numbers: Double...) -> Double { var total = 0.0 for number in numbers { total += number } return total / Double(numbers.count) } print(average(1, 2, 3, 4, 5)) // In-out parameters (modify original variable) func swapTwoInts(_ a: inout Int, _ b: inout Int) { let temporaryA = a a = b b = temporaryA } var x = 3 var y = 107 swapTwoInts(&x, &y) print("x is now \(x), y is now \(y)") // Function types let mathFunction: (Int, Int) -> Int = { $0 + $1 } print("Sum: \(mathFunction(2, 3))")

// Arrays var programmingLanguages = ["Swift", "Kotlin", "Python"] programmingLanguages.append("JavaScript") programmingLanguages.insert("Rust", at: 1) print("Languages: \(programmingLanguages)") print("First language: \(programmingLanguages.first ?? "")") print("Count: \(programmingLanguages.count)") // Array operations let numbers = [1, 2, 3, 4, 5] let doubled = numbers.map { $0 * 2 } let evenNumbers = numbers.filter { $0 % 2 == 0 } let sum = numbers.reduce(0, +) print("Doubled: \(doubled)") print("Even: \(evenNumbers)") print("Sum: \(sum)") // Sets (unique, unordered) var programmingSet: Set = ["Swift", "Python", "Java"] programmingSet.insert("Kotlin") programmingSet.insert("Swift") // Won't add duplicate print("Set: \(programmingSet)") let swiftSet: Set = ["Swift", "iOS", "Xcode"] let pythonSet: Set = ["Python", "Django", "Data Science"] print("Union: \(swiftSet.union(pythonSet))") print("Intersection: \(swiftSet.intersection(pythonSet))") // Dictionaries var userScores = ["Alice": 95, "Bob": 87, "Charlie": 92] userScores["David"] = 88 // Add new entry userScores["Alice"] = 96 // Update existing for (name, score) in userScores { print("\(name): \(score)") } // Safe dictionary access if let bobScore = userScores["Bob"] { print("Bob's score: \(bobScore)") } // Default values let eveScore = userScores["Eve", default: 0] print("Eve's score: \(eveScore)") // Collection transformations let scores = [85, 92, 78, 95, 88] let scoreDescriptions = scores.map { score -> String in switch score { case 90...100: return "\(score): Excellent ⭐⭐⭐" case 80..<90: return "\(score): Good ⭐⭐" case 70..<80: return "\(score): Fair ⭐" default: return "\(score): Needs improvement" } } print(scoreDescriptions)

// Basic enum enum CompassPoint { case north case south case east case west } var direction = CompassPoint.north direction = .east // Type inference allows shorthand // Switch on enum switch direction { case .north: print("Heading north 🧭") case .south: print("Heading south") case .east: print("Heading east") case .west: print("Heading west") } // Raw values (String, Int, Character) enum Planet: Int { case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune } let earth = Planet.earth print("Earth is planet #\(earth.rawValue)") // Associated values enum Barcode { case upc(Int, Int, Int, Int) case qrCode(String) } let productBarcode = Barcode.upc(8, 85909, 51226, 3) let siteBarcode = Barcode.qrCode("https://codeorbitpro.com") 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)") } // Methods in enums enum TrafficLight { case red, yellow, green func description() -> String { switch self { case .red: return "Stop 🛑" case .yellow: return "Caution ⚠️" case .green: return "Go ✅" } } mutating func next() { switch self { case .red: self = .green case .yellow: self = .red case .green: self = .yellow } } } var light = TrafficLight.red print(light.description()) light.next() print("Next light: \(light.description())") // CaseIterable for iteration enum Beverage: CaseIterable { case coffee, tea, juice, water } print("Available beverages:") for beverage in Beverage.allCases { print("- \(beverage)") } // Recursive enum indirect enum ArithmeticExpression { case number(Int) case addition(ArithmeticExpression, ArithmeticExpression) case multiplication(ArithmeticExpression, ArithmeticExpression) } let expression = ArithmeticExpression.addition( .number(5), .multiplication(.number(2), .number(3)) ) func evaluate(_ expression: ArithmeticExpression) -> Int { switch expression { case let .number(value): return value case let .addition(left, right): return evaluate(left) + evaluate(right) case let .multiplication(left, right): return evaluate(left) * evaluate(right) } } print("Expression result: \(evaluate(expression))") // 5 + (2 * 3) = 11

// Struct definition struct Resolution { var width = 0 var height = 0 // Computed property var aspectRatio: Double { return Double(width) / Double(height) } // Method func description() -> String { return "\(width)x\(height)" } } // Class definition class VideoMode { var resolution = Resolution() var frameRate = 0.0 var name: String? // Property observers var duration: Double = 0 { willSet { print("About to set duration to \(newValue)") } didSet { print("Duration changed from \(oldValue) to \(duration)") } } // Initializer init(resolution: Resolution, frameRate: Double, name: String?) { self.resolution = resolution self.frameRate = frameRate self.name = name } // Deinitializer (classes only) deinit { print("VideoMode instance is being deallocated") } } // Value type behavior (struct) var hd = Resolution(width: 1920, height: 1080) var cinema = hd // This creates a COPY cinema.width = 2048 print("HD width: \(hd.width)") // 1920 (unchanged) print("Cinema width: \(cinema.width)") // 2048 // Reference type behavior (class) let video = VideoMode(resolution: hd, frameRate: 60.0, name: "Sample") let alsoVideo = video // This shares the SAME instance alsoVideo.frameRate = 30.0 print("Video frameRate: \(video.frameRate)") // 30.0 (changed) print("AlsoVideo frameRate: \(alsoVideo.frameRate)") // 30.0 // Identity operators (classes only) if video === alsoVideo { print("video and alsoVideo refer to the same instance") } // Inheritance class Animal { var name: String init(name: String) { self.name = name } func makeSound() -> String { return "Some generic animal sound" } } class Dog: Animal { var breed: String init(name: String, breed: String) { self.breed = breed super.init(name: name) } override func makeSound() -> String { return "Woof! 🐕" } // Final method cannot be overridden final func fetch() -> String { return "\(name) fetches the ball!" } } let myDog = Dog(name: "Buddy", breed: "Golden Retriever") print(myDog.makeSound()) print(myDog.fetch())

// Basic protocol protocol Vehicle { var numberOfWheels: Int { get } var maxSpeed: Double { get } func start() func stop() func description() -> String } // Protocol with mutating method protocol Toggleable { mutating func toggle() } // Protocol inheritance protocol ElectricVehicle: Vehicle { var batteryCapacity: Double { get } func charge(to percentage: Double) } // Protocol adoption by struct struct Car: Vehicle { let numberOfWheels: Int = 4 let maxSpeed: Double = 200.0 func start() { print("Car engine started 🚗") } func stop() { print("Car stopped") } func description() -> String { return "Car with \(numberOfWheels) wheels, max speed: \(maxSpeed) km/h" } } // Protocol adoption by class class Bicycle: Vehicle, Toggleable { var numberOfWheels: Int = 2 var maxSpeed: Double = 30.0 var isLocked: Bool = false func start() { print("Bicycle ready to ride 🚲") } func stop() { print("Bicycle stopped") } func description() -> String { return "Bicycle with \(numberWheels) wheels" } // Mutating method (struct would need mutating keyword) func toggle() { isLocked.toggle() print("Bicycle \(isLocked ? "locked" : "unlocked")") } } // Using protocols let myCar = Car() let myBike = Bicycle() let vehicles: [Vehicle] = [myCar, myBike] for vehicle in vehicles { print(vehicle.description()) vehicle.start() } // Protocol extensions extension Vehicle { func honk() { print("Beep beep! 🔊") } // Default implementation func description() -> String { return "Vehicle with \(numberOfWheels) wheels" } } myCar.honk() // Protocol with associated type (generic protocol) protocol Container { associatedtype Item var count: Int { get } mutating func append(_ item: Item) subscript(i: Int) -> Item { get } } struct IntStack: Container { typealias Item = Int private var items: [Item] = [] var count: Int { items.count } mutating func append(_ item: Item) { items.append(item) } subscript(i: Int) -> Item { return items[i] } } // Protocol composition protocol Named { var name: String { get } } protocol Aged { var age: Int { get } } struct Person: Named, Aged { let name: String let age: Int } func wishHappyBirthday(to celebrant: Named & Aged) { print("Happy birthday, \(celebrant.name), you're \(celebrant.age)! 🎂") } let birthdayPerson = Person(name: "CodeOrbitPro", age: 25) wishHappyBirthday(to: birthdayPerson) // Conditional protocol conformance extension Array: Container where Element: Equatable { typealias Item = Element mutating func append(_ item: Item) { self.append(item) } }

// Generic function func swapTwoValues(_ a: inout T, _ b: inout T) { let temporaryA = a a = b b = temporaryA } var string1 = "hello" var string2 = "world" swapTwoValues(&string1, &string2) print("string1 is now \(string1), string2 is now \(string2)") var int1 = 3 var int2 = 107 swapTwoValues(&int1, &int2) print("int1 is now \(int1), int2 is now \(int2)") // Generic type struct Stack { private var items: [Element] = [] mutating func push(_ item: Element) { items.append(item) } mutating func pop() -> Element? { return items.popLast() } func peek() -> Element? { return items.last } var isEmpty: Bool { return items.isEmpty } var count: Int { return items.count } } // Using generic type var intStack = Stack() intStack.push(1) intStack.push(2) intStack.push(3) print("Popped: \(intStack.pop() ?? 0)") // 3 var stringStack = Stack() stringStack.push("Swift") stringStack.push("Generics") print("Top item: \(stringStack.peek() ?? "")") // "Generics" // Type constraints func findIndex(of valueToFind: T, in array: [T]) -> Int? { for (index, value) in array.enumerated() { if value == valueToFind { return index } } return nil } let doubleIndex = findIndex(of: 9.3, in: [3.14159, 0.1, 0.25, 9.3]) let stringIndex = findIndex(of: "Swift", in: ["Objective-C", "Swift", "Kotlin"]) print("Double index: \(doubleIndex ?? -1)") print("String index: \(stringIndex ?? -1)") // Multiple constraints protocol Container { associatedtype Item var count: Int { get } mutating func append(_ item: Item) subscript(i: Int) -> Item { get } } func allItemsMatch (_ container1: C1, _ container2: C2) -> Bool where C1.Item == C2.Item, C1.Item: Equatable { if container1.count != container2.count { return false } for i in 0..(indices: Indices) -> [Element] where Indices.Iterator.Element == Int { var result: [Element] = [] for index in indices { if index < items.count { result.append(items[index]) } } return result } } // Using generic subscript intStack.push(10) intStack.push(20) intStack.push(30) let selectedItems = intStack[[0, 2]] print("Selected items: \(selectedItems)") // [10, 30] // Opaque return types (Swift 5.1+) protocol Shape { func draw() -> String } struct Square: Shape { var size: Int func draw() -> String { return "Square with size \(size)" } } struct FlippedShape: Shape { var shape: T func draw() -> String { return "Flipped \(shape.draw())" } } // Returns some Shape (opaque type) func makeTrapezoid() -> some Shape { let top = Square(size: 2) let middle = Square(size: 4) let bottom = Square(size: 6) // Combine shapes... return FlippedShape(shape: top) } let trapezoid = makeTrapezoid() print(trapezoid.draw())

// Defining error types enum NetworkError: Error { case invalidURL case noConnection case timeout(seconds: Int) case serverError(statusCode: Int) case decodingError(message: String) } enum ValidationError: Error { case emptyField(fieldName: String) case invalidEmail case passwordTooShort(minLength: Int) case ageRestriction(minimumAge: Int) } // Throwing function func fetchData(from urlString: String) throws -> String { guard !urlString.isEmpty else { throw NetworkError.invalidURL } guard urlString.hasPrefix("http") else { throw NetworkError.invalidURL } // Simulate network conditions let randomNumber = Int.random(in: 1...10) switch randomNumber { case 1...3: throw NetworkError.noConnection case 4...5: throw NetworkError.timeout(seconds: 30) case 6...7: throw NetworkError.serverError(statusCode: 500) default: return "Sample data from \(urlString)" } } // do-catch error handling func loadUserData() { do { let data = try fetchData(from: "https://api.example.com") print("Success: \(data)") // Multiple throwing calls in same do block let moreData = try fetchData(from: "https://api2.example.com") print("More data: \(moreData)") } catch NetworkError.invalidURL { print("Error: Invalid URL provided") } catch NetworkError.noConnection { print("Error: No internet connection") } catch NetworkError.timeout(let seconds) { print("Error: Request timed out after \(seconds) seconds") } catch NetworkError.serverError(let statusCode) { print("Error: Server responded with status code \(statusCode)") } catch { print("An unexpected error occurred: \(error)") } } loadUserData() // try? converts errors to optionals let optionalData = try? fetchData(from: "https://bad-url") if let data = optionalData { print("Got data: \(data)") } else { print("Failed to get data (error converted to nil)") } // try! asserts error won't occur (crashes if it does) // let forcedData = try! fetchData(from: "https://api.example.com") // Dangerous! // defer statement for cleanup func processFile(filename: String) throws { print("Opening file: \(filename)") defer { print("Closing file: \(filename)") // This runs no matter how the function exits } defer { print("First defer runs last (LIFO)") } let data = try fetchData(from: "https://files.example.com/\(filename)") print("Processing: \(data)") // Even if error thrown above, defer still runs } // Using Result type for error handling func validateUser(email: String, password: String) -> Result { guard !email.isEmpty else { return .failure(.emptyField(fieldName: "email")) } guard email.contains("@") && email.contains(".") else { return .failure(.invalidEmail) } guard password.count >= 8 else { return .failure(.passwordTooShort(minLength: 8)) } return .success("User validated successfully") } // Handling Result let validationResult = validateUser(email: "user@example.com", password: "weak") switch validationResult { case .success(let message): print("Validation success: \(message)") case .failure(let error): switch error { case .emptyField(let field): print("Please fill in the \(field) field") case .invalidEmail: print("Please enter a valid email address") case .passwordTooShort(let minLength): print("Password must be at least \(minLength) characters") default: print("Validation failed") } } // Rethrowing functions func processWithRetry(attempts: Int, operation: () throws -> String) rethrows -> String { for attempt in 1...attempts { do { return try operation() } catch { print("Attempt \(attempt) failed: \(error)") if attempt == attempts { throw error } } } fatalError("Should never reach here") } // Using rethrows do { let result = try processWithRetry(attempts: 3) { return try fetchData(from: "https://api.example.com") } print("Final result: \(result)") } catch { print("All attempts failed: \(error)") }

// Basic async function func fetchUserProfile(userId: Int) async throws -> String { // Simulate network delay try await Task.sleep(nanoseconds: 1_000_000_000) // 1 second if userId == 1 { return "User Profile: CodeOrbitPro (Swift Developer)" } else { throw NetworkError.serverError(statusCode: 404) } } // Async function without throwing func calculateStatistics(scores: [Int]) async -> (min: Int, max: Int, average: Double) { // Simulate heavy computation await Task.yield() // Yield to allow other tasks to run guard !scores.isEmpty else { return (0, 0, 0.0) } let min = scores.min() ?? 0 let max = scores.max() ?? 0 let average = Double(scores.reduce(0, +)) / Double(scores.count) return (min, max, average) } // Using async/await Task { do { let profile = try await fetchUserProfile(userId: 1) print("Fetched: \(profile)") let scores = [85, 92, 78, 95, 88] let stats = await calculateStatistics(scores: scores) print("Stats - Min: \(stats.min), Max: \(stats.max), Avg: \(stats.average)") } catch { print("Error: \(error)") } } // Concurrent execution with async let func fetchMultipleData() async { async let userData = fetchUserProfile(userId: 1) async let productData = fetchProductInfo(productId: 42) async let settings = loadUserSettings() do { // All three fetches run concurrently let (user, product, settings) = try await (userData, productData, settings) print("User: \(user), Product: \(product), Settings: \(settings)") } catch { print("One of the fetches failed: \(error)") } } // Helper functions for above example func fetchProductInfo(productId: Int) async throws -> String { try await Task.sleep(nanoseconds: 500_000_000) return "Product #\(productId): Swift Programming Guide" } func loadUserSettings() async throws -> String { try await Task.sleep(nanoseconds: 300_000_000) return "Settings: Dark Mode, Notifications Enabled" } // Task groups for dynamic concurrency func downloadMultipleFiles(urls: [String]) async throws -> [String] { try await withThrowingTaskGroup(of: String.self) { group in var downloadedFiles: [String] = [] // Add child tasks for each URL for url in urls { group.addTask { try await downloadFile(from: url) } } // Collect results as they complete for try await file in group { downloadedFiles.append(file) print("Downloaded: \(file)") } return downloadedFiles } } // Helper for download func downloadFile(from url: String) async throws -> String { try await Task.sleep(nanoseconds: UInt64.random(in: 500_000_000...2_000_000_000)) return "File from \(url)" } // Actor for shared mutable state actor BankAccount { private var balance: Double private let accountNumber: String init(accountNumber: String, initialBalance: Double) { self.accountNumber = accountNumber self.balance = initialBalance } func deposit(amount: Double) { balance += amount print("Deposited \(amount). New balance: \(balance)") } func withdraw(amount: Double) -> Bool { if amount <= balance { balance -= amount print("Withdrew \(amount). New balance: \(balance)") return true } else { print("Insufficient funds. Balance: \(balance), Attempted: \(amount)") return false } } func getBalance() -> Double { return balance } } // Using actor Task { let account = BankAccount(accountNumber: "123456", initialBalance: 1000.0) // Must use await to interact with actor await account.deposit(amount: 500.0) let success = await account.withdraw(amount: 200.0) let currentBalance = await account.getBalance() print("Withdrawal successful: \(success), Current balance: \(currentBalance)") } // @MainActor for UI updates @MainActor class UserViewModel: ObservableObject { @Published var userName: String = "" @Published var isLoading: Bool = false func loadUser() async { isLoading = true // This runs on main thread automatically do { let profile = try await fetchUserProfile(userId: 1) userName = profile } catch { userName = "Error loading user" } isLoading = false } } // Async properties and subscripts struct AsyncDataLoader { subscript(index: Int) async throws -> String { try await Task.sleep(nanoseconds: 100_000_000) return "Data at index \(index)" } var firstItem: String { get async throws { try await self[0] } } } // Using async properties Task { let loader = AsyncDataLoader() let first = try await loader.firstItem print("First item: \(first)") let third = try await loader[2] print("Third item: \(third)") }

// ARC Basics class Person { let name: String var apartment: Apartment? init(name: String) { self.name = name print("\(name) is being initialized") } deinit { print("\(name) is being deinitialized") } } class Apartment { let unit: String weak var tenant: Person? // Weak reference to avoid cycle init(unit: String) { self.unit = unit print("Apartment \(unit) is being initialized") } deinit { print("Apartment \(unit) is being deinitialized") } } // Strong reference cycle example var john: Person? = Person(name: "John Appleseed") var unit4A: Apartment? = Apartment(unit: "4A") john!.apartment = unit4A unit4A!.tenant = john // Weak reference, doesn't create cycle // When we nil these, both deallocate john = nil // Prints: "John Appleseed is being deinitialized" unit4A = nil // Prints: "Apartment 4A is being deinitialized" // Strong reference cycle (problematic) class Customer { let name: String var creditCard: CreditCard? // Strong reference init(name: String) { self.name = name } deinit { print("\(name) is being deinitialized") } } class CreditCard { let number: String unowned let customer: Customer // Unowned reference (assumes customer exists longer) init(number: String, customer: Customer) { self.number = number self.customer = customer } deinit { print("Card #\(number) is being deinitialized") } } var customer: Customer? = Customer(name: "Jane Doe") customer!.creditCard = CreditCard(number: "1234-5678-9012-3456", customer: customer!) // Both deallocate properly (no cycle due to unowned) customer = nil // Prints both deinitialization messages // Closure capture lists class HTMLElement { let name: String let text: String? // Closure with strong reference to self lazy var asHTML: () -> String = { [weak self] in guard let self = self else { return "" } if let text = self.text { return "<\(self.name)>\(text)" } else { return "<\(self.name) />" } } init(name: String, text: String? = nil) { self.name = name self.text = text } deinit { print("\(name) is being deinitialized") } } var paragraph: HTMLElement? = HTMLElement(name: "p", text: "Hello, Swift!") print(paragraph!.asHTML()) paragraph = nil // Deallocates properly thanks to [weak self] // Unowned vs Weak class Country { let name: String var capitalCity: City! // Implicitly unwrapped optional init(name: String, capitalName: String) { self.name = name self.capitalCity = City(name: capitalName, country: self) } } class City { let name: String unowned let country: Country // Country will exist as long as City init(name: String, country: Country) { self.name = name self.country = country } } let country = Country(name: "Canada", capitalName: "Ottawa") print("\(country.name)'s capital is \(country.capitalCity.name)") // MemoryLayout for type information print("MemoryLayout.size: \(MemoryLayout.size)") // 8 on 64-bit print("MemoryLayout.alignment: \(MemoryLayout.alignment)") // 8 print("MemoryLayout.stride: \(MemoryLayout.stride)") // 8 struct Point3D { var x, y, z: Double } print("MemoryLayout.size: \(MemoryLayout.size)") // 24 (3 * 8) print("MemoryLayout.stride: \(MemoryLayout.stride)") // 24 // Unsafe memory operations (advanced) let count = 3 let pointer = UnsafeMutablePointer.allocate(capacity: count) pointer.initialize(repeating: 0, count: count) pointer[0] = 10 pointer[1] = 20 pointer[2] = 30 // Convert to buffer for safer access let buffer = UnsafeBufferPointer(start: pointer, count: count) for (index, value) in buffer.enumerated() { print("Element \(index): \(value)") } // Clean up pointer.deallocate() // Copy-on-write demonstration struct ImageData { private var _data: [UInt8] init(data: [UInt8]) { _data = data } // Copy-on-write: Only copy when mutated mutating func modifyPixel(at index: Int, value: UInt8) { // Ensure we have a unique copy before modifying if !isKnownUniquelyReferenced(&_data) { _data = _data.copy() } _data[index] = value } var data: [UInt8] { return _data } } var image1 = ImageData(data: [0, 128, 255]) var image2 = image1 // Shares underlying array initially image2.modifyPixel(at: 0, value: 255) // Now makes a copy print("Image1: \(image1.data), Image2: \(image2.data)")

// Property Wrappers @propertyWrapper struct Clamped { private var value: T private let range: ClosedRange var wrappedValue: T { get { value } set { value = min(max(range.lowerBound, newValue), range.upperBound) } } init(wrappedValue: T, _ range: ClosedRange) { self.range = range self.value = min(max(range.lowerBound, wrappedValue), range.upperBound) } } struct GameCharacter { @Clamped(0...100) var health: Int = 100 @Clamped(0...100) var mana: Int = 50 } var character = GameCharacter() character.health = 150 // Clamped to 100 character.mana = -10 // Clamped to 0 print("Health: \(character.health), Mana: \(character.mana)") // Result Builders (Domain Specific Languages) @resultBuilder struct HTMLBuilder { static func buildBlock(_ components: String...) -> String { return components.joined(separator: "\n") } static func buildArray(_ components: [String]) -> String { return components.joined(separator: "\n") } static func buildOptional(_ component: String?) -> String { return component ?? "" } static func buildEither(first component: String) -> String { return component } static func buildEither(second component: String) -> String { return component } } @HTMLBuilder func makePage(title: String, showHeader: Bool) -> String { "" "" "" if showHeader { "

\(title)

" } "

" "

Welcome to our site!

" "

" for item in ["Home", "About", "Contact"] { "\(item)" } "" "" } let page = makePage(title: "CodeOrbitPro", showHeader: true) print("Generated HTML page:\n\(page)") // Dynamic Member Lookup @dynamicMemberLookup struct DynamicObject { private var storage: [String: Any] = [:] subscript(dynamicMember member: String) -> Any? { get { storage[member] } set { storage[member] = newValue } } } var obj = DynamicObject() obj.name = "Swift" // Dynamically creates property obj.version = 5.9 obj.isAwesome = true print("Object: \(obj.name ?? ""), Version: \(obj.version ?? 0)") // Key Paths struct Student { let name: String var grade: Double var passed: Bool { grade >= 60.0 } } let students = [ Student(name: "Alice", grade: 95.0), Student(name: "Bob", grade: 58.5), Student(name: "Charlie", grade: 72.0) ] // Sort by grade using key path let sortedByGrade = students.sorted(by: \.grade) print("Sorted by grade: \(sortedByGrade.map { $0.name })") // Map to names using key path let names = students.map(\.name) print("Names: \(names)") // Filter by passed using key path let passingStudents = students.filter(\.passed) print("Passing students: \(passingStudents.count)") // Custom Operators infix operator ^^: ExponentiationPrecedence precedencegroup ExponentiationPrecedence { higherThan: MultiplicationPrecedence associativity: right } func ^^(base: Double, exponent: Double) -> Double { return pow(base, exponent) } let result = 2.0 ^^ 3.0 // 8.0 print("2 ^ 3 = \(result)") // @autoclosure func assert(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = "") { #if DEBUG if !condition() { fatalError("Assertion failed: \(message())") } #endif } let x = 5 assert(x > 0, "x must be positive") // No need for closure syntax // #available for API availability if #available(iOS 15.0, macOS 12.0, *) { print("Can use iOS 15/macOS 12 APIs") } else { print("Need to use older APIs") } // Custom string interpolation extension String.StringInterpolation { mutating func appendInterpolation(_ value: Date, style: DateFormatter.Style) { let formatter = DateFormatter() formatter.dateStyle = style appendLiteral(formatter.string(from: value)) } mutating func appendInterpolation(repeat str: String, _ count: Int) { appendLiteral(String(repeating: str, count: count)) } } let today = Date() print("Today is \(today, style: .long)") print("Cheers! \(repeat: "🎉", 3)") // Protocol with primary associated types (Swift 5.7) protocol Storage { associatedtype Element func store(_ item: Element) func retrieve() -> Element? } struct Box: Storage { private var item: Item? func store(_ item: Item) { // Implementation } func retrieve() -> Item? { return item } } // Opaque parameter types func processStorage(_ storage: some Storage) { // Can work with any Storage that stores Ints } // Advanced pattern matching enum AdvancedPattern { case point(x: Int, y: Int) case circle(radius: Double) case rectangle(width: Double, height: Double) } let shape = AdvancedPattern.point(x: 10, y: 20) if case .point(let x, _) = shape, x > 5 { print("Point with x > 5: \(x)") } // Using ~= operator for custom pattern matching struct RangePattern { let lower: T let upper: T } func ~= (pattern: RangePattern, value: T) -> Bool { return value >= pattern.lower && value <= pattern.upper } let score = 85 let gradeRange = RangePattern(lower: 90, upper: 100) switch score { case gradeRange: print("Grade: A") case RangePattern(lower: 80, upper: 89): print("Grade: B") case RangePattern(lower: 70, upper: 79): print("Grade: C") default: print("Grade: F") }