Working with Modern Concurrency

func fetchUserData() async -> String {
    let url = URL(string: "https://api.example.com/user")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return String(data: data, encoding: .utf8) ?? ""
}

func main() async {
    let userData = await fetchUserData()
    print(userData)
}

func fetchImage() async -> Data {
    let url = URL(string: "https://api.example.com/image")!
    return try await URLSession.shared.data(from: url).0
}

func fetchText() async -> String {
    let url = URL(string: "https://api.example.com/text")!
    return try await URLSession.shared.data(from: url).0
}

func main() async {
    let task1 = Task { await fetchImage() }
    let task2 = Task { await fetchText() }
    
    let image = await task1.value
    let text = await task2.value
}

func fetchUserData(from userId: String) async throws -> [String: Any] {
    let url = URL(string: "https://api.example.com/users/\(userId)")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONSerialization.jsonObject(with: data) as! [String: Any]
}

import Foundation

func fetchData() async throws -> String {
    try await Task.sleep(nanoseconds: 1_000_000_000) // 1 second
    return "Fetched data"
}

Task {
    do {
        let result = try await fetchData()
        print(result)
    } catch {
        print("Error: \(error)")
    }
}

import Foundation

func fetchItem(_ id: Int) async throws -> String {
    try await Task.sleep(nanoseconds: 100_000_000) // 0.1 seconds
    return "Item \(id)"
}

func fetchItems() async throws -> [String] {
    return try await withThrowingTaskGroup(of: String.self) { group in
        var results: [String] = []
        
        for i in 1...3 {
            group.addTask {
                return try await fetchItem(i)
            }
        }
        
        for await result in group {
            results.append(result)
        }
        
        return results
    }
}

Task {
    do {
        let items = try await fetchItems()
        print(items)
    } catch {
        print("Error: \(error)")
    }
}

import Foundation

let stream = AsyncStream<String> { continuation in
    DispatchQueue.global().async {
        for i in 1...5 {
            let value = "Value \(i)"
            continuation.yield(value)
            Thread.sleep(forTimeInterval: 0.5)
        }
        continuation.finish()
    }
}

Task {
    for await value in stream {
        print(value)
    }
}

import Foundation

func fetchAsyncData() -> AsyncStream<String> {
    return AsyncStream { continuation in
        Task {
            for i in 1...3 {
                let data = "Data \(i)"
                continuation.yield(data)
                try? await Task.sleep(nanoseconds: 1_000_000_000)
            }
            continuation.finish()
        }
    }
}

Task {
    for await data in fetchAsyncData() {
        print("Received: \(data)")
    }
}

import Foundation

func createAsyncStream() -> AsyncStream<Int> {
    return AsyncStream<Int> { continuation in
        for i in 1...5 {
            DispatchQueue.main.asyncAfter(deadline: .now() + Double(i)) {
                continuation.yield(i * 10)
            }
        }
        continuation.finish()
    }
}

Task {
    for await value in createAsyncStream() {
        print("Received: \\(value)")
    }
}

actor Counter {
    private var count = 0

    func increment() {
        count += 1
    }

    func getValue() -> Int {
        return count
    }
}

// Usage
let counter = Counter()
Task {
    await counter.increment()
    print(await counter.getValue())
}

actor DataFetcher {
    private var cache: [String: String] = [:]

    func fetchData(from url: String) async throws -> String {
        if let cached = cache[url] {
            return cached
        }

        // Simulate network fetch
        let data = "Fetched data from \(url)"
        cache[url] = data
        return data
    }
}

// Usage
let fetcher = DataFetcher()
Task {
    do {
        let data = try await fetcher.fetchData(from: "https://api.example.com")
        print(data)
    } catch {
        print("Error fetching data: \(error)")
    }
}

import SwiftUI

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

struct ContentView: View {
    @State private var count = 0
    
    var body: some View {
        VStack {
            Text("Count: \(count)")
            Button("Increment") {
                Task {
                    await updateCounter()
                }
            }
        }
    }
    
    @MainActor
    func updateCounter() {
        count += 1
    }
}

struct User: Sendable {
    let name: String
    let id: Int
}

actor UserManager {
    private var users: [User] = []
    
    func addUser(_ user: User) {
        users.append(user)
    }
}

let task = Task {
    for i in 0..<1000 {
        if Task.isCancelled { break }
        print("Processing item \(i)")
        try? await Task.sleep(nanoseconds: 1_000_000)
    }
}

task.cancel()

let task = Task {
    withTaskCancellationHandler {
        print("Task is not cancelled, proceeding")
    } operation: {
        try await Task.sleep(nanoseconds: 5_000_000)
    }
}

func fetchData() async throws -> String {
    return try await withCheckedContinuation { continuation in
        DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
            continuation.resume(returning: "Data fetched successfully")
        }
    }
}

Task(priority: .high) {
    // High priority task
    print("Running high priority task")
}