Swift Array.map questione chiusura

Question

voglio migliorare su una chiusura che ho scritto utilizzando la funzione Array.map di Swift

praticamente sto prendendo un array e rimappatura tutti i suoi elementi utilizzando una chiusura.

// Here's the array: 
var numbersArray = [1, 2, 3, 4, 5] 

// Here's the closure - it takes whatever number is passed into it and 
// multiplies it by 2.0 
var multiplier = { (currentNum: Int) -> Double in 
    let result = Double(currentNum) * 2.0 
    return result 
} 

// And here's how I'm calling it: 
var newArray = numbersArray.map(multiplier) 

E questo funziona perfettamente.

Ma cosa succede se voglio moltiplicare tutto per 2.1? o 3,5? o qualche valore? In altre parole, cosa succede se voglio rendere l'importo che moltiplico anche per una variabile ? E sarà passato alla chiusura come secondo argomento?

Ho provato ad aggiungere alla lista di argomenti come questo:

var multiplier = { (currentNum: Int, factor: Double) -> Double in 
    let result = Double(currentNum) * factor 
    return result 
} 

e poi cambiare la mia chiamata a questo:

var newArray = numbersArray.map(multiplier, 3.5) 

ma sto ottenendo tutti i tipi di errori (e ho provato Ovviamente tutte le varianti di questo.)

Cosa sto facendo male?

Answer 1

È possibile utilizzare una funzione di ordine superiore per produrre una funzione personalizzata che è possibile utilizzare con la funzione mappa dell'array. Come questo:

var numbersArray = [1, 2, 3, 4, 5] 

func multiplier(factor: Double) -> (Int)->Double 
{ 
    return { (currentNum: Int) -> Double in 
     let result = Double(currentNum) * factor 
     return result 
    } 
} 

var newArray = numbersArray.map(multiplier(2.5)) 

Answer 2

Edit: Nota: Questa caratteristica del linguaggio è stata rimossa a Swift 2.

Un modo veloce-er di risposta di Connor (ma sulla stessa linea), è quello di utilizzare un curry funzione. Dalla programmazione Swift language-> Lingua Reference> Declarations-> Funzioni curry e Metodi:

Una funzione dichiarata in questo modo è inteso come una funzione il cui ritorno tipo è un'altra funzione.

Così si può semplificare questo:

func multiplier(factor: Double) -> (Int)->Double 
{ 
    return { (currentNum: Int) -> Double in 
     let result = Double(currentNum) * factor 
     return result 
    } 
} 

a questo:

func multiplier(factor: Double)(currentNum: Int) -> Double { 
    return Double(currentNum) * factor 
} 

e usarlo esattamente nello stesso modo:

let numbersArray = [1, 2, 3, 4, 5] 
let multipliedArray = numbersArray.map(multiplier(3.5))