Início / coding / Perguntas / 78052092
Accepted
Roman
Asked: 2024-02-24 18:47:03 +0800 CST

Wrapper de método estático para mapa em Swift

  • 772

Cada método em Swift possui uma função estática correspondente gerada automaticamente pelo Swift.
Mas estou tendo dificuldades para aplicar esse conceito map.
Por exemplo. Esta é uma maneira canônica de fazer as coisas:

let numbers = Set([1, 2, 3])
let doubled = numbers.map { $0 * 2 }
print(doubled) // [2, 4, 6]

O que eu quero é fazer com que o código a seguir seja compilado e funcione (porque em teoria ele deveria compilar e funcionar exatamente como o código acima):

let numbers = Set([1, 2, 3])
let doubled = Set.map(numbers) { $0 * 2 }
print(doubled) // [2, 4, 6]

PS A propósito, como esse recurso é chamado oficialmente?

swift

1 respostas

  1. Best Answer

    Supondo que você queira dizer o fato de que um método de instância como este:

    class C {
    func foo(x: T1, y: T2) -> R { ... }
}

    também pode ser chamado como se fosse um método estático como este:

    class C {
    static func foo(`self`: C) -> (T1, T2) -> R { ... }
}

    Isso é chamado de currying , mas apenas no primeiro parâmetro. Normalmente curry foo(acima) significaria func foo() -> (C) -> (T1) -> (T2) -> R. Veja também: https://stackoverflow.com/a/25375190/5133585

    Você pode usar a versão estática mapassim:

    let numbers = Set([1, 2, 3])
let doubled = try Set.map(numbers)() { $0 * 2 }
print(doubled)

    Observe que o extra ()depois de map(numbers). Sem ele, o analisador pensaria que o encerramento é um argumento para a Set.mapchamada. É ()necessário deixar claro que o encerramento é um argumento para a função retornada por map . Você também não pode usar a sintaxe de encerramento final:

    try Set.map(numbers)({ $0 * 2 })

    Você também precisa try, porque mapé declarado com rethrows:

    func map<T>(_ transform: (Self.Element) throws -> T) rethrows -> [T]

    Normalmente rethrowssignifica que se transformnão joga, maptambém não joga. Mas como a versão estática de mapapenas pega a Sete retorna a ((Self.Element) throws -> T) -> [T], ela não pode saber se o fechamento que você vai passar é lançado ou não. Portanto, ele permanece do lado seguro e assume que irá lançar.

    • 2

relate perguntas