Scope: Gestione del Ciclo di Vita delle Coroutine ​

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

    return "OK";
}

processUser(123);
// La funzione è tornata, ma tre coroutine sono ancora in esecuzione!
// Chi le controlla? Quando finiranno?
// Chi gestirà le eccezioni se si verificano?

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

    // Attendi finché tutte le coroutine nello scope non terminano
    $scope->awaitCompletion(Async\timeout(1000));

    return "OK";
}

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

// Ora la funzione tornerà solo quando TUTTE le coroutine saranno terminate

class UserService
{
    // Solo un oggetto unico possiederà uno Scope unico
    // Le coroutine vivono finché vive l'oggetto UserService
    private Scope $scope;

    public function __construct() {
        // Crea una cupola per tutte le coroutine del servizio
        $this->scope = new Async\Scope();
    }

    public function sendNotification($userId) {
        // Lancia una coroutine all'interno della nostra cupola
        $this->scope->spawn(function() use ($userId) {
            // Questa coroutine è associata a UserService
            sendEmail($userId);
        });
    }

    public function __destruct() {
        // Quando l'oggetto viene eliminato, le risorse vengono pulite in modo garantito
        // Tutte le coroutine all'interno vengono automaticamente cancellate
        $this->scope->dispose();
    }
}

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

// Elimina il servizio - tutte le sue coroutine vengono automaticamente cancellate
unset($service);

$mainScope = new Async\Scope();

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

    // Crea uno scope figlio
    $childScope = Async\Scope::inherit();

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

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

    // Attendi il completamento dei sotto-task
    $childScope->awaitCompletion(Async\timeout(5000));

    echo "Tutti i sotto-task completati\n";
});

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

$scope = new Async\Scope();

$scope->spawn(function() {
    try {
        while (true) {
            echo "Lavoro in corso...\n";
            Async\delay(1000);
        }
    } catch (Async\AsyncCancellation $e) {
        echo "Sono stato cancellato!\n";
    }
});

$scope->spawn(function() {
    try {
        while (true) {
            echo "Lavoro anche io...\n";
            Async\delay(1000);
        }
    } catch (Async\AsyncCancellation $e) {
        echo "Anch'io!\n";
    }
});

// Lavora per 3 secondi
Async\delay(3000);

// Cancella TUTTE le coroutine nello scope
$scope->cancel();

// Entrambe le coroutine riceveranno AsyncCancellation

$scope = new Async\Scope();

// Imposta un handler degli errori
$scope->setExceptionHandler(function (Async\Scope $scope, Async\Coroutine $coroutine, Throwable $e) {
    echo "Errore nello scope: " . $e->getMessage() . "\n";
    // Può registrarlo, inviarlo a Sentry, ecc.
});

$scope->spawn(function() {
    throw new Exception("Qualcosa si è rotto!");
});

$scope->spawn(function() {
    echo "Sto funzionando bene\n";
});

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

// Output:
// Errore nello scope: Qualcosa si è rotto!
// Sto funzionando bene

$scope = new Async\Scope();

$scope->spawn(function() {
    try {
        echo "Inizio lavoro\n";
        Async\delay(10000); // Operazione lunga
        echo "Terminato\n"; // Non verrà eseguito
    } finally {
        // Questo è GARANTITO che venga eseguito
        echo "Pulizia risorse\n";
        closeConnection();
    }
});

Async\delay(1000);
$scope->cancel(); // Cancella dopo un secondo

// Output:
// Inizio lavoro
// Pulizia risorse

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

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

// Ottieni tutti i risultati (attende il completamento di tutti i task)
$results = await($group->all());

// O ottieni il primo risultato completato
$first = await($group->race());

// O il primo riuscito (ignorando gli errori)
$any = await($group->any());

$group = new Async\TaskGroup();

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

// Itera sui risultati man mano che diventano pronti
foreach ($group as $key => [$result, $error]) {
    if ($error) {
        echo "Task $key fallito: {$error->getMessage()}\n";
    } else {
        echo "Task $key: $result\n";
    }
}

// Al livello più alto: la coroutine finisce nello scope globale
spawn(function() {
    echo "Sono nello scope globale\n";
});

// Dentro una coroutine: la coroutine finisce nello scope del chiamante
$scope = new Async\Scope();
$scope->spawn(function() {
    spawn(function() {
        echo "Sono in \$scope, come il mio genitore\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 {
        // Cancella tutte le richieste attive
        $this->scope->cancel();
    }

    public function __destruct() {
        // Quando il client viene distrutto, tutte le richieste vengono automaticamente cancellate
        $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');

// Cancella tutte le richieste
$client->cancelAll();

// O semplicemente distruggi il client - stesso effetto
unset($client);

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

// Il controllo non tornerà finché entrambi i task non saranno completati
$scope->awaitCompletion(Async\timeout(5000));

$scope->cancel();
// Tutte le coroutine in $scope riceveranno un segnale di cancellazione.
// Gli Scope figli verranno anch'essi cancellati -- ricorsivamente, a qualsiasi profondità.

$scope->dispose();
// Lo Scope è chiuso. Tutte le coroutine sono cancellate.
// Non è possibile aggiungere nuove coroutine a questo Scope.

$scope->disposeSafely();
// Lo Scope è chiuso. Le coroutine continuano a lavorare come zombie.
// Lo Scope le traccia ma non le conta come attive.