Swift 6 Concurrency vs Kotlin Coroutines Comparison

// Swift 6 — Sendable model + actor for parallel downloads
import Foundation

struct UserProfile: Sendable, Decodable {
    let id: Int
    let name: String
}

actor ProfileCache {
    private var storage: [Int: UserProfile] = [:]

    func value(for id: Int) -> UserProfile? {
        storage[id]
    }

    func insert(_ profile: UserProfile) {
        storage[profile.id] = profile
    }
}

enum ProfileError: Error {
    case invalidResponse
}

func fetchProfile(id: Int) async throws -> UserProfile {
    let url = URL(string: "https://api.example.com/users/\(id)")!
    let (data, response) = try await URLSession.shared.data(from: url)
    guard let http = response as? HTTPURLResponse, http.statusCode == 200 else {
        throw ProfileError.invalidResponse
    }
    return try JSONDecoder().decode(UserProfile.self, from: data)
}

func loadProfiles(ids: [Int], cache: ProfileCache) async throws -> [UserProfile] {
    try await withThrowingTaskGroup(of: UserProfile.self) { group in
        for id in ids {
            group.addTask {
                if let cached = await cache.value(for: id) {
                    return cached
                }
                let profile = try await fetchProfile(id: id)
                await cache.insert(profile)
                return profile
            }
        }
        var results: [UserProfile] = []
        for try await profile in group {
            results.append(profile)
        }
        return results
    }
}

// Kotlin Coroutines — structured concurrency + Mutex for parallel downloads
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.serialization.Serializable
import io.ktor.client.*
import io.ktor.client.call.body
import io.ktor.client.request.get

@Serializable
data class UserProfile(val id: Int, val name: String)

class ProfileCache {
    private val mutex = Mutex()
    private val storage = mutableMapOf<Int, UserProfile>()

    suspend fun get(id: Int): UserProfile? = mutex.withLock { storage[id] }

    suspend fun put(profile: UserProfile) = mutex.withLock {
        storage[profile.id] = profile
    }
}

suspend fun fetchProfile(client: HttpClient, id: Int): UserProfile =
    client.get("https://api.example.com/users/$id").body()

suspend fun loadProfiles(
    client: HttpClient,
    ids: List<Int>,
    cache: ProfileCache
): List<UserProfile> = coroutineScope {
    ids.map { id ->
        async {
            cache.get(id) ?: fetchProfile(client, id).also { cache.put(it) }
        }
    }.awaitAll()
}

// Cancellation is cooperative: long-running work must check isActive
suspend fun loadWithTimeout(client: HttpClient, ids: List<Int>, cache: ProfileCache) =
    withTimeoutOrNull(5_000) { loadProfiles(client, ids, cache) } ?: emptyList()