Come creare un predicato per filtrare array di enumerazioni con valori associati in Swift?

Question

enum EnumType { 
    case WithString(String) 
} 

var enums = [EnumType]() 

enums.append(EnumType.WithString("A")) 
enums.append(EnumType.WithString("B")) 
enums.append(EnumType.WithString("C")) 
enums.append(EnumType.WithString("D")) 
enums.append(EnumType.WithString("E")) 
enums.append(EnumType.WithString("F")) 

Come filtrare la mia matrice enums per trovare quella con il valore associato uguale a C. Che cosa è necessario utilizzare il predicato ?

Answer 1

La funzione di filtro può essere invocata come funzione globale su un array o come metodo di istanza (preferisco la versione successiva in quanto è più OO).

Accetta una chiusura con un parametro (l'elemento valutato) che restituisce un valore booleano (che indica se l'elemento corrisponde alla condizione richiesta).

Poiché è una chiusura semplice in una situazione chiara, è ok usare la forma abbreviata.

immagino che altro "con" i casi sarebbero stati aggiunti al tuo enum, così si potrebbe andare con qualcosa di simile:

let filteredArray = enums.filter { 
    switch $0 { 
     case let .WithString(value): 
     return value == "C" 
     default: 
     return false 
    } 
} 

Questo dovrebbe fare il trucco nel tuo esempio.

Answer 2

var filteredArray = enums.filter { element in 
    switch element { 
    case EnumType.WithString(let string): 
     return string == "A" 
    default: 
     return false 
    } 
} 

Questo probabilmente può essere semplificato con Swift 2.0 legame di valori assosciated in if dichiarazioni.

Answer 3

Come qualcuno già detto, per Swift> 2.0 c'è se caso dichiarazioni disponibili:

enums.filter { 
    if case .WithString("C") = $0 { 
    return true 
    } 
    return false 
} 

Ma, non sembra bello, soprattutto se avete intenzione di ripetere stessa logica. Cosa possiamo fare qui è quello di rendere EnumType conformi alle equatable:

extension EnumType: Equatable { 
} 

func ==(lhs: EnumType, rhs: EnumType) -> Bool { 
    switch (lhs, rhs) { 
    case (.WithString(let lStr), .WithString(let rStr)): 
     return lStr == rStr 
    } 
} 

E ora si può solo:

enums.filter { $0 == .WithString("C") } 

Answer 4

Si potrebbe provare ad aggiungere una semplice estensione con una proprietà calcolata al tuo enum e filtrare a quella proprietà:

extension EnumType { 
    var isC: Bool { 
    switch self { 
    case .WithString(let message): return message == "C" 
    default: return false 
    } 
    } 
} 

Dopo questo, si potrebbe simpy usare il filtraggio come al solito:

enums.filter { $0.isC }