Scope : gestion du cycle de vie des coroutines ​

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

    return "OK";
}

processUser(123);
// La fonction a retourne, mais trois coroutines tournent encore !
// Qui les surveille ? Quand vont-elles terminer ?
// Qui va gerer les exceptions si elles surviennent ?

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

    // Attendre que toutes les coroutines du scope terminent
    $scope->awaitCompletion(Async\timeout(1000));

    return "OK";
}

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

// Maintenant la fonction ne retournera que lorsque TOUTES les coroutines auront termine

class UserService
{
    // Un seul objet unique possedera un Scope unique
    // Les coroutines vivent aussi longtemps que l'objet UserService
    private Scope $scope;

    public function __construct() {
        // Creer un dome pour toutes les coroutines du service
        $this->scope = new Async\Scope();
    }

    public function sendNotification($userId) {
        // Lancer une coroutine a l'interieur de notre dome
        $this->scope->spawn(function() use ($userId) {
            // Cette coroutine est liee a UserService
            sendEmail($userId);
        });
    }

    public function __destruct() {
        // Quand l'objet est supprime, les ressources sont nettoyees de maniere garantie
        // Toutes les coroutines a l'interieur sont automatiquement annulees
        $this->scope->dispose();
    }
}

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

// Supprimer le service - toutes ses coroutines sont automatiquement annulees
unset($service);

$mainScope = new Async\Scope();

$mainScope->spawn(function() {
    echo "Tache principale\n";

    // Creer un scope enfant
    $childScope = Async\Scope::inherit();

    $childScope->spawn(function() {
        echo "Sous-tache 1\n";
    });

    $childScope->spawn(function() {
        echo "Sous-tache 2\n";
    });

    // Attendre la fin des sous-taches
    $childScope->awaitCompletion(Async\timeout(5000));

    echo "Toutes les sous-taches terminees\n";
});

$mainScope->awaitCompletion(Async\timeout(5000));

$scope = new Async\Scope();

$scope->spawn(function() {
    try {
        while (true) {
            echo "En cours de travail...\n";
            Async\delay(1000);
        }
    } catch (Async\AsyncCancellation $e) {
        echo "J'ai ete annule !\n";
    }
});

$scope->spawn(function() {
    try {
        while (true) {
            echo "Travaille aussi...\n";
            Async\delay(1000);
        }
    } catch (Async\AsyncCancellation $e) {
        echo "Moi aussi !\n";
    }
});

// Fonctionne pendant 3 secondes
Async\delay(3000);

// Annuler TOUTES les coroutines du scope
$scope->cancel();

// Les deux coroutines recevront AsyncCancellation

$scope = new Async\Scope();

// Configurer un gestionnaire d'erreurs
$scope->setExceptionHandler(function (Async\Scope $scope, Async\Coroutine $coroutine, Throwable $e) {
    echo "Erreur dans le scope : " . $e->getMessage() . "\n";
    // Peut etre journalise, envoye a Sentry, etc.
});

$scope->spawn(function() {
    throw new Exception("Quelque chose s'est casse !");
});

$scope->spawn(function() {
    echo "Je fonctionne bien\n";
});

$scope->awaitCompletion(Async\timeout(5000));

// Sortie :
// Erreur dans le scope : Quelque chose s'est casse !
// Je fonctionne bien

$scope = new Async\Scope();

$scope->spawn(function() {
    try {
        echo "Debut du travail\n";
        Async\delay(10000); // Operation longue
        echo "Termine\n"; // Ne s'executera pas
    } finally {
        // Ceci est GARANTI de s'executer
        echo "Nettoyage des ressources\n";
        closeConnection();
    }
});

Async\delay(1000);
$scope->cancel(); // Annuler apres une seconde

// Sortie :
// Debut du travail
// Nettoyage des ressources

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

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

// Obtenir tous les resultats (attend la fin de toutes les taches)
$results = await($group->all());

// Ou obtenir le premier resultat termine
$first = await($group->race());

// Ou le premier reussi (en ignorant les erreurs)
$any = await($group->any());

$group = new Async\TaskGroup();

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

// Iterer sur les resultats au fur et a mesure qu'ils sont prets
foreach ($group as $key => [$result, $error]) {
    if ($error) {
        echo "Tache $key echouee : {$error->getMessage()}\n";
    } else {
        echo "Tache $key : $result\n";
    }
}

// Au niveau superieur : la coroutine va dans le scope global
spawn(function() {
    echo "Je suis dans le scope global\n";
});

// A l'interieur d'une coroutine : la coroutine va dans le scope de l'appelant
$scope = new Async\Scope();
$scope->spawn(function() {
    spawn(function() {
        echo "Je suis dans \$scope, comme mon parent\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 {
        // Annuler toutes les requetes actives
        $this->scope->cancel();
    }

    public function __destruct() {
        // Quand le client est detruit, toutes les requetes sont automatiquement annulees
        $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');

// Annuler toutes les requetes
$client->cancelAll();

// Ou simplement detruire le client - meme effet
unset($client);

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

// Le controle ne sera rendu que lorsque les deux taches seront terminees
$scope->awaitCompletion(Async\timeout(5000));

$scope->cancel();
// Toutes les coroutines dans $scope recevront un signal d'annulation.
// Les Scopes enfants seront egalement annules -- recursivement, a toute profondeur.

$scope->dispose();
// Le Scope est ferme. Toutes les coroutines sont annulees.
// De nouvelles coroutines ne peuvent pas etre ajoutees a ce Scope.

$scope->disposeSafely();
// Le Scope est ferme. Les coroutines continuent de travailler comme zombies.
// Le Scope les suit mais ne les compte pas comme actives.