Passare un array a una funzione con numero variabile di arg in Swift

In The Swift Programming Language , dice:

Le funzioni possono anche accettare un numero variabile di argomenti, raccogliendoli in un array.

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

Quando chiamo una tale funzione con un elenco di numeri separato da virgole (`sumOf (1, 2, 3, 4), vengono resi disponibili come array all'interno della funzione.

Domanda: cosa succede se ho già un array di numeri che voglio passare a questa funzione?

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

Questo non riesce con un errore del compilatore, "Impossibile trovare un sovraccarico per '__conversion' che accetta gli argomenti forniti". C'è un modo per trasformare un array esistente in un elenco di elementi che posso passare a una funzione variadica?

Splatting non è ancora nella lingua , come confermato dagli sviluppatori. La soluzione alternativa per ora è utilizzare un sovraccarico o attendere se non è possibile aggiungere sovraccarichi.

Ecco un lavoro che ho trovato. So che non è esattamente quello che vuoi, ma sembra funzionare.

Passaggio 1: dichiarare la funzione che si desidera con un array anziché con argomenti variadici:

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

Step 2: chiama questo dalla tua funzione variadic:

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

Passaggio 3: chiamare in entrambi i modi:

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

Sembra strano, ma sta funzionando nei miei test. Fammi sapere se questo causa problemi imprevisti a nessuno. Swift sembra essere in grado di separare la differenza tra le due chiamate con lo stesso nome di funzione.

Inoltre, con questo metodo se Apple aggiorna la lingua come suggerisce la risposta di @ manojid, dovrai solo aggiornare queste funzioni. Altrimenti, dovrai passare e rinominare molto.

Puoi lanciare la funzione:

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

È possibile utilizzare una funzione di supporto in quanto tale:

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

So che questa risposta non risponde alla tua domanda esatta, ma ne sento la pena notare. Anch'io stavo iniziando a giocare con Swift e ho subito incontrato una domanda simile. La risposta di Manojlds è migliore per la tua domanda, sono d'accordo, ma ancora una volta ho trovato un'altra soluzione. Anche a me piace che Logan stia meglio.

Nel mio caso volevo solo passare un array:

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])

Volevo solo condividere, nel caso qualcun altro stesse pensando come me. Il più delle volte preferirei passare l'array in questo modo, ma non credo ancora "Swiftly". :)

Ho fatto questo (Wrapper + Identity Mapping):

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

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

Swift 5

Questo è un approccio con @dynamicCallablefunzionalità che consente di evitare il sovraccarico o unsafeBitCastma è necessario effettuare uno specifico structper chiamare:

@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