matt's questions

A proposta dos pacotes de parâmetros de evolução do Swift começa com uma seção de Motivação que cita o seguinte trecho de feiura familiar:

func < (lhs: (), rhs: ()) -> Bool

func < <A, B>(lhs: (A, B), rhs: (A, B)) -> Bool where A: Comparable, B: Comparable

func < <A, B, C>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool where A: Comparable, B: Comparable, C: Comparable

O problema aqui é que para implementar a comparação de tuplas, temos que implementá-la para 2-tuplas, implementá-la novamente para 3-tuplas, e assim por diante. E além disso, essa repetição significa que temos que desistir após algum tamanho máximo arbitrário de tupla (6-tuplas).

Minha pergunta é: exatamente como os pacotes de parâmetros do Swift resolvem esse problema? Olhando nos cabeçalhos do Swift 6, não vejo que a declaração de tupla <tenha mudado em relação às versões anteriores do Swift. (Na verdade, não vejo nenhum uso de pacotes de parâmetros nos cabeçalhos do Swift, ponto final.) E em qualquer caso (e mais direto ao ponto), os pacotes de parâmetros não são sobre tuplas; eles são sobre variadics .

Então posso ver instantaneamente como implementaríamos a comparação entre duas listas variáveis ​​de valores comparáveis:

func isLessThan<each T: Comparable>(lhs: repeat each T, rhs: repeat each T) -> Bool {
    for pair in repeat (each lhs, each rhs) {
        if pair.0 >= pair.1 {
            return false
        }
    }
    return true
}

E podemos chamar assim:

let result = isLessThan(lhs: 1, "a", rhs: 2, "b")

Ótimo — mas essas não são tuplas . Elas são listas variádicas. A raiz do problema é que não há como fazer uma lista variádica dinamicamente: você não pode transformar uma tupla (ou uma sequência) em uma lista variádica.

Então, como os pacotes de parâmetros resolvem o problema motivacional?

Aqui está um pequeno banco de testes mostrando duas tarefas que começam ao mesmo tempo, e a que for concluída primeiro cancela a outra:

func startTest() async throws {
    Task { await test() }
    try await Task.sleep(nanoseconds: 1 * NSEC_PER_SEC)
    // comment out this next line to test the timeout
    NotificationCenter.default.post(name: .init("Test"), object: nil)
}

func test() async {
    let notificationTask = Task {
        for await _ in NotificationCenter.default
            .notifications(named: .init("Test"), object: nil)
            .prefix(1) {}
        print("Done waiting for the notification")
    }
    let timeoutTask = Task {
        try await Task.sleep(nanoseconds: 5 * NSEC_PER_SEC)
        notificationTask.cancel()
        print("I timed out and cancelled the notification task")
    }
    await notificationTask.value
    timeoutTask.cancel()
    print("finished!")
}

Como você pode ver, a ideia é que ou recebamos a notificação em 5 segundos, caso em que o cronômetro de cinco segundos é cancelado, ou expiremos em 5 segundos, caso em que a espera pela notificação é cancelada.

Minha pergunta é: existe uma maneira mais clara de expressar isso? Tentei vários grupos de tarefas e formulações assíncronas, mas não encontrei nada. Talvez este seja o caminho "certo", mas de alguma forma irrita.