Concurrency and ARC

import Foundation

// async function: can be suspended at await points
func fetchUser(id: Int) async throws -> String {
    try await Task.sleep(nanoseconds: 100_000_000)   // non-blocking sleep
    return "User\(id)"
}

// Sequential async calls
func loadProfile() async throws -> String {
    let user = try await fetchUser(id: 1)   // waits here
    let posts = try await fetchPosts(for: user)   // waits here
    return "\(user): \(posts)"
}

// Concurrent async calls with async let
func loadFeed() async throws {
    async let user = fetchUser(id: 1)   // starts immediately
    async let posts = fetchPosts(for: "User1")   // starts immediately, in parallel
    // Both running concurrently — await both at once
    let (u, p) = try await (user, posts)
    print("\(u): \(p)")
}

// Task: explicit async unit of work
func startBackgroundWork() {
    Task {
        let result = try? await fetchUser(id: 42)
        print(result ?? "failed")
    }
}

func fetchPosts(for user: String) async throws -> [String] {
    return ["Post1", "Post2"]
}

// actor: reference type where state access is serialised
actor BankAccount {
    private var balance: Double = 0

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

    func withdraw(_ amount: Double) -> Bool {
        guard balance >= amount else { return false }
        balance -= amount
        return true
    }

    var currentBalance: Double { balance }
}

// @MainActor: must run on main thread — for UI updates
@MainActor
class ViewModel {
    var title: String = "Loading..."   // always accessed on main thread

    func loadData() async {
        let data = await fetchData()   // can suspend off main thread
        title = data   // back on main thread — safe
    }

    func fetchData() async -> String {
        return "Loaded!"
    }
}

// Accessing actor state requires await
let account = BankAccount()
Task {
    await account.deposit(100)
    let balance = await account.currentBalance   // await required — async access
    print("Balance: \(balance)")
    // account.balance   // COMPILE ERROR: actor-isolated — must await
}

class Person {
    let name: String
    var apartment: Apartment?
    init(name: String) { self.name = name }
    deinit { print("\(name) is being deinitialized") }
}

class Apartment {
    let unit: String
    // weak: optional reference that becomes nil when Person is deallocated
    // Breaks the retain cycle — Apartment doesn't hold Person alive
    weak var tenant: Person?
    init(unit: String) { self.unit = unit }
    deinit { print("Apartment \(unit) is being deinitialized") }
}

var alice: Person? = Person(name: "Alice")
var apt: Apartment? = Apartment(unit: "4B")

alice?.apartment = apt
apt?.tenant = alice   // weak reference — no retain cycle

alice = nil   // prints "Alice is being deinitialized" — ARC frees immediately
apt = nil     // prints "Apartment 4B is being deinitialized"

// Closure retain cycle — common mistake:
class ViewController {
    var onDismiss: (() -> Void)?

    func setup() {
        // [weak self] prevents self from being retained by the closure
        onDismiss = { [weak self] in
            guard let self = self else { return }
            self.dismiss()
        }
    }
    func dismiss() { print("dismissed") }
}