Passando um array para uma função com número variável de argumentos no Swift

Na linguagem de programação Swift , diz:

As funções também podem receber um número variável de argumentos, coletando-os em uma matriz.

  func sumOf(numbers: Int...) -> Int {
      ...
  }

Quando eu chamo essa função com uma lista de números separados por vírgula (`sumOf (1, 2, 3, 4)), eles são disponibilizados como uma matriz dentro da função.

Pergunta: e se eu já tiver uma matriz de números que deseje passar para esta função?

let numbers = [1, 2, 3, 4]
sumOf(numbers)

Isso falha com um erro do compilador, "Não foi possível encontrar uma sobrecarga para '__conversion' que aceita os argumentos fornecidos". Existe uma maneira de transformar uma matriz existente em uma lista de elementos que eu posso passar para uma função variável?

Splatting ainda não está no idioma , conforme confirmado pelos desenvolvedores. A solução alternativa por enquanto é usar uma sobrecarga ou aguardar se você não puder adicionar sobrecargas.

Aqui está uma solução que eu encontrei. Eu sei que não é exatamente o que você quer, mas parece estar funcionando.

Etapa 1: Declare a função que você gostaria com uma matriz em vez de argumentos variados:

func sumOf(numbers: [Int]) -> Int {
    var total = 0
    for i in numbers {
        total += i
    }
    return total
}

Etapa 2: chame isso de dentro da sua função variável:

func sumOf(numbers: Int...) -> Int {
    return sumOf(numbers)
}

Etapa 3: Ligue de qualquer maneira:

var variadicSum = sumOf(1, 2, 3, 4, 5)
var arraySum = sumOf([1, 2, 3, 4, 5])

Parece estranho, mas está funcionando nos meus testes. Deixe-me saber se isso causa problemas imprevistos para alguém. Swift parece capaz de separar a diferença entre as duas chamadas com o mesmo nome de função.

Além disso, com esse método, se a Apple atualizar o idioma como sugere a resposta do @ manojid, você só precisará atualizar essas funções. Caso contrário, você terá que passar por várias renomeações.

Você pode converter a função:

typealias Function = [Int] -> Int
let sumOfArray = unsafeBitCast(sumOf, Function.self)
sumOfArray([1, 2, 3])

Você pode usar uma função auxiliar como tal:

func sumOf (numbers : [Int])  -> Int { return numbers.reduce(0, combine: +) }
func sumOf (numbers : Int...) -> Int { return sumOf (numbers) }

Sei que esta resposta não responde à sua pergunta exata, mas acho que vale a pena notar. Eu também estava começando a brincar com Swift e imediatamente me deparei com uma pergunta semelhante. A resposta da Manojld é melhor para sua pergunta, concordo, mas, novamente, outra solução alternativa que me veio à cabeça. Por acaso também gosto mais do Logan.

No meu caso, eu só queria passar uma matriz:

func sumOf(numbers: Array<Int>) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}

var someNums = [8,7,2,9,12]
sumOf(someNums)
sumOf([10, 15, 20])

Só queria compartilhar, caso alguém mais estivesse pensando como eu. Na maioria das vezes eu preferiria passar o array assim, mas ainda não acho o "Swiftly". :)

Eu fiz isso (Wrapper + Mapeamento de identidade):

func addBarButtonItems(types: REWEBarButtonItemType...) {
    addBarButtonItems(types: types.map { $0 })
}

func addBarButtonItems(types: [REWEBarButtonItemType]) {
    // actual implementation
}

Swift 5

Esta é uma abordagem com @dynamicCallablerecurso que permite evitar sobrecargas ou que unsafeBitCastvocê deve especificar um específico structpara chamar:

@dynamicCallable
struct SumOf {
    func dynamicallyCall(withArguments args: [Int]) -> Int {
        return args.reduce(0, +)
    }
}

let sum = SumOf()

// Use a dynamic method call.
sum(1, 2, 3) // 6

// Call the underlying method directly.
sum.dynamicallyCall(withArguments: [1, 2, 3]) // 6