Skip to main content

Swift Features

Modern Swift Features​

1. Property Wrappers​

@propertyWrapper
struct Clamped<T: Comparable> {
    let min: T
    let max: T
    private var value: T

    var wrappedValue: T {
        get { value }
        set { value = min(max(newValue, min), max) }
    }

    init(wrappedValue: T, min: T, max: T) {
        self.min = min
        self.max = max
        self.value = min(max(wrappedValue, min), max)
    }
}

class Temperature {
    @Clamped(min: -273.15, max: 100.0)
    var celsius: Double = 25.0
}

2. Result Type​

enum NetworkError: Error {
    case invalidURL
    case noData
}

func fetchData(completion: @escaping (Result<Data, NetworkError>) -> Void) {
    guard let url = URL(string: "https://api.example.com") else {
        completion(.failure(.invalidURL))
        return
    }

    URLSession.shared.dataTask(with: url) { data, _, _ in
        if let data = data {
            completion(.success(data))
        } else {
            completion(.failure(.noData))
        }
    }.resume()
}

Advanced Patterns​

1. Generic Constraints​

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

class Stack<Element: Equatable>: Container {
    private var items = [Element]()

    var count: Int { items.count }

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

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

2. Custom Operators​

infix operator **: BitwiseShiftPrecedence

func ** (base: Double, power: Double) -> Double {
    return pow(base, power)
}

let result = 2.0 ** 3.0 // 8.0

Concurrency​

1. Structured Concurrency​

func fetchUserData() async throws -> UserData {
    async let profile = fetchProfile()
    async let settings = fetchSettings()
    async let friends = fetchFriends()

    return try await UserData(
        profile: profile,
        settings: settings,
        friends: friends
    )
}

2. Actors​

actor BankAccount {
    private var balance: Decimal

    init(initialBalance: Decimal) {
        self.balance = initialBalance
    }

    func deposit(_ amount: Decimal) {
        balance += amount
    }

    func withdraw(_ amount: Decimal) throws {
        guard balance >= amount else {
            throw BankError.insufficientFunds
        }
        balance -= amount
    }
}

Swift Package Manager​

1. Package Definition​

// Package.swift
import PackageDescription

let package = Package(
    name: "MyLibrary",
    platforms: [.iOS(.v14), .macOS(.v11)],
    products: [
        .library(
            name: "MyLibrary",
            targets: ["MyLibrary"])
    ],
    dependencies: [
        .package(url: "https://github.com/example/package.git", from: "1.0.0")
    ],
    targets: [
        .target(
            name: "MyLibrary",
            dependencies: [])
    ]
)

Next Steps​

  1. Learn about Memory Management
  2. Explore Protocol-Oriented Programming
  3. Study Testing and Debugging