Início / coding / Perguntas / 77899784
Accepted
Roman
Asked: 2024-01-29 20:41:28 +0800 CST

Palavra-chave “alguma” com parâmetro variado em Swift

  • 772
protocol myProtocol {}

func doSomething(with params: (some myProtocol)...) {
    // Implementation goes here
}

extension Int: myProtocol {}

doSomething(with: 1, 2, 3)

Erro de compilação na linha de declaração func:

'alguns' tipos são permitidos apenas em propriedades, subscritos e funções

Eu poderia simplesmente omitir completamente a palavra-chave, mas ela será considerada 'qualquer' por padrão. Conseqüentemente, não posso passar os parâmetros para uma função que espera [some SyntaxProtocol]como parâmetro.

swift

2 respostas

  1. Use genéricos para obter o mesmo resultado somee permitir apenas um tipo específico que esteja em conformidade com o protocolo

    func doSomething<ProtocolType: myProtocol>(with params: (ProtocolType)...) {
    // Implementation goes here
}
    • 3
  2. Best Answer

    Por que você não pode usar someparâmetros variados

    Proibir o uso de tipos opacossome Protocol ( ) em parâmetros variados foi uma decisão consciente dos desenvolvedores da linguagem. Porque entraria em conflito com outro recurso de linguagem proposto chamado variadic generics:

    Genéricos variados

    Um tipo opaco não pode ser usado em um parâmetro variado:

    func acceptLots(_: some P...)

    Esta restrição existe porque a semântica implícita nesta proposta pode não ser a semântica apropriada se o Swift ganhar genéricos variados. Especificamente, a semântica implícita nesta proposta em si (sem genéricos variados) seria equivalente a:

    func acceptLots<_T: P>(_: _T...)

    where acceptLotsrequer que todos os argumentos tenham o mesmo tipo:

    acceptLots(1, 1, 2, 3, 5, 8)          // okay
acceptLots("Hello", "Swift", "World") // okay
acceptLots("Swift", 6)                // error: argument for `some P` could be either String or Int

    Com genéricos variados, pode-se, em vez disso, transformar o parâmetro genérico implícito em um pacote de parâmetros genéricos, como segue:

    func acceptLots<_Ts: P...>(_: _Ts...)

    Neste caso, acceptLotsaceita qualquer número de argumentos, todos os quais podem ter tipos diferentes:

    acceptLots(1, 1, 2, 3, 5, 8)          // okay, Ts contains six Int types
acceptLots("Hello", "Swift", "World") // okay, Ts contains three String types
acceptLots(Swift, 6)                  // okay, Ts contains String and Int

    Fonte: https://github.com/apple/swift-evolution/blob/main/proposals/0341-opaque-parameters.md#variadic-generics

    Então, não é algum bug ou descuido. Está funcionando como pretendido.

    Qual é o significado dessa somepalavra-chave na declaração do tipo de parâmetro?

    Mas o que você deve fazer com seu código? Bem, precisamos verificar por que esse recurso de idioma foi adicionado e o que ele está fazendo "nos bastidores":

    E foi introduzido para tornar a função com uso intenso de genéricos "mais leve" e mais fácil de ler .

    Para transformar código como:

    func horizontal<V1: View, V2: View>(_ v1: V1, _ v2: V2) -> some View {
  HStack {
    v1
    v2
  }
}

    nisso:

    func horizontal(_ v1: some View, _ v2: some View) -> some View {
  HStack {
    v1
    v2
  }
}

    Ambos os trechos são equivalentes, a versão some Viewdurante a compilação apenas se transforma em versão de função genérica.

    Tal como acontece com os tipos de resultados opacos, some Pindica um tipo sem nome e conhecido apenas por sua restrição: ele está em conformidade com o protocolo P. Quando um tipo opaco ocorre dentro de um tipo de parâmetro, ele é substituído por um parâmetro genérico (sem nome) . Por exemplo, a função dada:

    func f(_ p: some P) { }

    é equivalente a uma função genérica descrita a seguir, com um parâmetro de tipo sintetizado (não nomeado) _T:

    func f<_T: P>(_ p: _T)

    Fonte: https://github.com/apple/swift-evolution/blob/main/proposals/0341-opaque-parameters.md#proposed-solution

    O que você deveria fazer

    Como foi dito antes: este açúcar sintático está explicitamente indisponível para parâmetros variados. Portanto, a única solução óbvia seria voltar à sintaxe "não açucarada" e usar parâmetros genéricos:

    func doSomething<P: myProtocol>(with params: P...) {
// Implementation goes here
}

    E funcionará como pretendido (se você pretende que todos os parâmetros da lista variada tenham exatamente o mesmo tipo, isso confirma myProtocol, ofc).

    • 2

relate perguntas