function processUser($userId) {
    spawn(sendEmail(...), $userId);
    spawn(updateCache(...), $userId);
    spawn(logActivity(...), $userId);

    return "OK";
}

processUser(123);
// 함수는 반환되었지만 세 개의 코루틴이 여전히 실행 중입니다!
// 누가 이것들을 감시하고 있나요? 언제 끝날까요?
// 예외가 발생하면 누가 처리할까요?

function processUser($userId):string {
    spawn(sendEmail(...), $userId);
    spawn(updateCache(...), $userId);
    spawn(logActivity(...), $userId);

    // scope 내의 모든 코루틴이 완료될 때까지 대기
    $scope->awaitCompletion(new Async\Timeout(1000));

    return "OK";
}

$scope = new Async\Scope();
$scope->spawn(processUser(...), 123);
$scope->awaitCompletion(new Async\Timeout(5000));

// 이제 함수는 모든 코루틴이 완료된 후에만 반환됩니다

class UserService
{
    // 하나의 고유 객체만이 고유한 Scope를 소유합니다
    // 코루틴은 UserService 객체와 동일한 수명을 가집니다
    private Scope $scope;

    public function __construct() {
        // 모든 서비스 코루틴을 위한 돔을 생성합니다
        $this->scope = new Async\Scope();
    }

    public function sendNotification($userId) {
        // 돔 내부에서 코루틴을 실행합니다
        $this->scope->spawn(function() use ($userId) {
            // 이 코루틴은 UserService에 바인딩되어 있습니다
            sendEmail($userId);
        });
    }

    public function __destruct() {
        // 객체가 삭제되면 리소스가 확실히 정리됩니다
        // 내부의 모든 코루틴이 자동으로 취소됩니다
        $this->scope->dispose();
    }
}

$service = new UserService();
$service->sendNotification(123);
$service->sendNotification(456);

// 서비스를 삭제하면 모든 코루틴이 자동으로 취소됩니다
unset($service);

$mainScope = new Async\Scope();

$mainScope->spawn(function() {
    echo "메인 작업\n";

    // 자식 스코프 생성
    $childScope = Async\Scope::inherit();

    $childScope->spawn(function() {
        echo "하위 작업 1\n";
    });

    $childScope->spawn(function() {
        echo "하위 작업 2\n";
    });

    // 하위 작업 완료 대기
    $childScope->awaitCompletion();

    echo "모든 하위 작업 완료\n";
});

$mainScope->awaitCompletion();

$scope = new Async\Scope();

$scope->spawn(function() {
    try {
        while (true) {
            echo "작업 중...\n";
            Async\sleep(1000);
        }
    } catch (Async\AsyncCancellation $e) {
        echo "취소되었습니다!\n";
    }
});

$scope->spawn(function() {
    try {
        while (true) {
            echo "역시 작업 중...\n";
            Async\sleep(1000);
        }
    } catch (Async\AsyncCancellation $e) {
        echo "저도요!\n";
    }
});

// 3초 동안 작업
Async\sleep(3000);

// scope 내의 모든 코루틴 취소
$scope->cancel();

// 두 코루틴 모두 AsyncCancellation을 수신합니다

$scope = new Async\Scope();

// 오류 핸들러 설정
$scope->setExceptionHandler(function(Throwable $e) {
    echo "스코프 내 오류: " . $e->getMessage() . "\n";
    // 로그 기록, Sentry로 전송 등이 가능합니다
});

$scope->spawn(function() {
    throw new Exception("뭔가 고장났습니다!");
});

$scope->spawn(function() {
    echo "저는 정상 작동 중입니다\n";
});

$scope->awaitCompletion();

// 출력:
// 스코프 내 오류: 뭔가 고장났습니다!
// 저는 정상 작동 중입니다

$scope = new Async\Scope();

$scope->spawn(function() {
    try {
        echo "작업 시작\n";
        Async\sleep(10000); // 긴 작업
        echo "완료\n"; // 실행되지 않음
    } finally {
        // 이것은 반드시 실행됩니다
        echo "리소스 정리 중\n";
        closeConnection();
    }
});

Async\sleep(1000);
$scope->cancel(); // 1초 후 취소

// 출력:
// 작업 시작
// 리소스 정리 중

$group = new Async\TaskGroup(concurrency: 5);

$group->spawn(fn() => fetchUser(1));
$group->spawn(fn() => fetchUser(2));
$group->spawn(fn() => fetchUser(3));

// 모든 결과 가져오기 (모든 작업 완료 대기)
$results = await($group->all());

// 또는 첫 번째 완료된 결과 가져오기
$first = await($group->race());

// 또는 첫 번째 성공한 결과 가져오기 (오류 무시)
$any = await($group->any());

$group = new Async\TaskGroup();

$group->spawnWithKey('user', fn() => fetchUser(1));
$group->spawnWithKey('orders', fn() => fetchOrders(1));

// 결과가 준비되는 대로 반복
foreach ($group as $key => [$result, $error]) {
    if ($error) {
        echo "작업 $key 실패: {$error->getMessage()}\n";
    } else {
        echo "작업 $key: $result\n";
    }
}

// 스코프를 지정하지 않은 경우
spawn(function() {
    echo "글로벌 스코프에 있습니다\n";
});

// 이것과 동일합니다:
Async\Scope::global()->spawn(function() {
    echo "글로벌 스코프에 있습니다\n";
});

class HttpClient {
    private Scope $scope;

    public function __construct() {
        $this->scope = new Async\Scope();
    }

    public function get(string $url): Async\Awaitable {
        return $this->scope->spawn(function() use ($url) {
            $ch = curl_init($url);
            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

            try {
                return curl_exec($ch);
            } finally {
                curl_close($ch);
            }
        });
    }

    public function cancelAll(): void {
        // 모든 활성 요청 취소
        $this->scope->cancel();
    }

    public function __destruct() {
        // 클라이언트가 파괴되면 모든 요청이 자동으로 취소됩니다
        $this->scope->dispose();
    }
}

$client = new HttpClient();

$req1 = $client->get('https://api1.com/data');
$req2 = $client->get('https://api2.com/data');
$req3 = $client->get('https://api3.com/data');

// 모든 요청 취소
$client->cancelAll();

// 또는 클라이언트를 파괴 - 동일한 효과
unset($client);

$scope = new Async\Scope();
$scope->spawn(function() { /* 작업 1 */ });
$scope->spawn(function() { /* 작업 2 */ });

// 두 작업이 모두 완료될 때까지 제어가 반환되지 않습니다
$scope->awaitCompletion();

$scope->cancel();
// $scope 내의 모든 코루틴이 취소 신호를 받습니다.
// 자식 Scope도 취소됩니다 -- 재귀적으로, 어떤 깊이든.

$scope->dispose();
// Scope가 닫혔습니다. 모든 코루틴이 취소되었습니다.
// 이 Scope에 새 코루틴을 추가할 수 없습니다.

$scope->disposeSafely();
// Scope가 닫혔습니다. 코루틴은 좀비로 계속 작동합니다.
// Scope는 이들을 추적하지만 활성으로 계산하지 않습니다.