Cancelar desde Swift

// @NativeCoroutines sobre un Flow o una función: mismo nombre
for try await v in asyncSequence(for: pokedex.heartbeatForIos()) { /* … */ }
 
// @NativeCoroutinesState sobre un StateFlow: valor + secuencia con sufijo Flow
let ahora = vm.uiStateForIos                          // el valor actual
for try await v in asyncSequence(for: vm.uiStateForIosFlow) { /* … */ }   // los cambios

package com.sebastiannarvaez.pokedex
 
import com.rickclephas.kmp.nativecoroutines.NativeCoroutines
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
 
class Prueba {
    // Una funcion `suspend` lenta que avisa si la cancelan.
    suspend fun lenta(): String {
        try {
            delay(5000)
            return "fin normal"
        } catch (e: CancellationException) {
            // Cancelar una corrutina lanza esta excepcion dentro de ella.
            println("KOTLIN: cancelada")
            // Se relanza siempre: si se tragara, la corrutina creeria que nadie
            // la ha parado y seguiria como si nada.
            throw e
        }
    }
 
    // La misma, pero con el envoltorio de la libreria.
    @NativeCoroutines
    suspend fun lentaNc(): String = lenta()
 
    // Un flujo que cuenta cuando lo detienen.
    @NativeCoroutines
    val latidos: Flow<Int> = flow {
        try {
            var i = 0
            while (true) {
                emit(i)
                i++              // sube el contador en uno
                delay(300)
            }
        } finally {
            // `finally` corre siempre al salir del bloque, tambien si cancelan.
            println("KOTLIN: flow detenido")
        }
    }
}

// `probar` lanza un trabajo, lo cancela al segundo y cuenta cuando termina de verdad.
// `trabajo` es una closure (una funcion que se pasa como parametro): no recibe nada,
// puede esperar y fallar (`async throws`) y devuelve un String. Es la llamada a Kotlin.
// `@escaping` avisa de que Swift la guarda para llamarla mas tarde, dentro de la Task.
func probar(_ nombre: String, _ trabajo: @escaping () async throws -> String) async {
    // `Date()` es el instante de ahora: se apunta para saber cuántos segundos pasaron.
    let t0 = Date()
    // Una función dentro de otra: `timeIntervalSince(t0)` da los segundos desde t0
    // y `String(format: "%.1f s", …)` los escribe con un decimal, como «1.0 s».
    func segundos() -> String { String(format: "%.1f s", Date().timeIntervalSince(t0)) }
    // `Task { … }` lanza el trabajo por su cuenta, para poder cancelarlo desde fuera.
    let tarea = Task {
        // Si el trabajo acaba solo, imprime su resultado y el tiempo.
        do { print(nombre, "terminó:", try await trabajo(), segundos()) }
        // Si lo cancelan, `try await` lanza un error y cae aquí.
        catch { print(nombre, "cancelado:", segundos()) }
    }
    try? await Task.sleep(nanoseconds: 1_000_000_000)   // espera 1 s
    tarea.cancel()                                       // y cancela la Task de Swift
    try? await Task.sleep(nanoseconds: 5_000_000_000)   // deja tiempo para ver el resultado
}

.task {
    // La funcion suspend tal cual (sin libreria).
    await probar("estándar") { try await Prueba().lenta() }
    // La misma, con el envoltorio. `asyncFunction(for:)` es a una función `suspend`
    // lo que `asyncSequence(for:)` es a un `Flow`: la vuelve `async` y propaga la cancelación.
    await probar("librería") { try await asyncFunction(for: Prueba().lentaNc()) }
    // El flujo: se recorre un segundo y se cancela.
    let flujo = Task {
        for try await v in asyncSequence(for: Prueba().latidos) { print("SWIFT recibe", v) }
        print("SWIFT: el bucle terminó sin error")
    }
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    flujo.cancel()
    try? await Task.sleep(nanoseconds: 1_000_000_000)
}

estándar terminó: fin normal 5.0 s
KOTLIN: cancelada
librería cancelado: 1.0 s
SWIFT recibe 0
SWIFT recibe 1
SWIFT recibe 2
SWIFT recibe 3
KOTLIN: flow detenido
SWIFT: el bucle terminó sin error