03 · 구조적 vs 비구조적 동시성

func loadProfile() async throws -> Profile {
    async let user  = fetchUser()     // 자식 태스크 생성(동시 진행)
    async let posts = fetchPosts()

    return Profile(user: try await user, posts: try await posts)   // 여기서 수거
}

func child(_ name: String, seconds: Double) async -> String {
    print("  [\(name)] 시작")
    do {
        try await Task.sleep(for: .seconds(seconds))
        print("  [\(name)] 정상 완료")
        return name
    } catch {
        print("  [\(name)] 취소 감지 → 정리하고 종료")   // 취소되면 sleep이 throw
        return "\(name)(취소)"
    }
}

func earlyReturn() async -> String {
    async let a = child("A", seconds: 2)
    async let b = child("B", seconds: 3)

    print("부모: a·b를 await 하지 않고 조기 return")
    return "조기종료"           // ← 여기서 스코프를 벗어난다
}

let r = await earlyReturn()
print("=== 부모 반환: \(r) ===")

부모: a·b를 await 하지 않고 조기 return
  [A] 시작
  [B] 시작
  [B] 취소 감지 → 정리하고 종료      ← ① 자동으로 취소됐다
  [A] 취소 감지 → 정리하고 종료
=== 부모 반환: 조기종료 ===          ← ② 자식이 다 끝난 '뒤에' 부모가 반환됐다

struct Boom: Error {}

func failing() async throws -> String {
    print("  [F] 시작")
    try await Task.sleep(for: .seconds(1))
    print("  [F] 에러 발생")
    throw Boom()
}

func errorPropagation() async throws -> String {
    async let f = failing()                  // 1초 뒤 실패
    async let s = child("S", seconds: 5)     // 5초 걸리는 작업
    return try await f + (await s)           // f가 throw → 스코프 탈출
}

do { _ = try await errorPropagation() }
catch { print("=== 부모가 에러를 받음: \(error) ===") }

  [F] 시작
  [S] 시작
  [F] 에러 발생
  [S] 취소 감지 → 정리하고 종료      ← 5초를 다 기다리지 않고 정리됐다
=== 부모가 에러를 받음: Boom() ===

func demo() {
    let parent = Task {
        Task {                   // 비구조적: 부모 트리 '밖'에 있다
            await longWork()     // parent.cancel() 해도 이 Task는 자동 취소 X
        }
    }
    parent.cancel()              // 안쪽 Task는 계속 돎!
}

// detached: 우선순위·task-local·격리를 아무것도 상속하지 않음
Task.detached { await cleanup() }

func unstructured() async -> String {
    Task { _ = await child("C", seconds: 2) }   // async let 이 아니라 Task {}
    print("부모(비구조적): 바로 return")
    return "조기종료"
}

let r = await unstructured()
print("=== 부모 반환: \(r) ===")
try? await Task.sleep(for: .seconds(2.5))       // 부모가 끝난 뒤를 지켜본다

부모(비구조적): 바로 return
  [C] 시작
=== 부모 반환: 조기종료 ===       ← ① 자식을 기다리지 않고 먼저 반환됐다
  [C] 정상 완료                   ← ② 취소되지도 않고 끝까지 실행됐다