recorrer - Usando el mapa en un diccionario en Swift 2, para devolver un diccionario

recorrer array swift 4

Question

Tengo problemas para descifrar el estilo de map particular de Swift 2:

Estoy leyendo en un diccionario (de un archivo plist), así que tengo un [String: AnyObject] :

let dictionary = NSDictionary(contentsOfFile: path) as? [String: AnyObject] 

Mi objetivo es transformarme de un diccionario de Strings a un diccionario de instancias de registrador. Esto sería [String: XCGLogger] :

let loggers = dictionary
.map { (n, l) in [ n: newLogger(l.0, withLevel: level(l.1)) ] }

Sin embargo, esto devuelve un [[String: XCGLogger]] (que a mí me parece una matriz de diccionarios). La pregunta es ¿cómo devuelvo un diccionario aplanado? Cuando trato de usar flatMap empiezo a correr en círculos alrededor de errores sobre cierres o al no poder llamar a flatMap en un tipo (Key, Value) -> NSDictionary .

Answer 1

Una forma un poco más concisa de la respuesta de @ Renzo sería usar reducir:

let loggers: [String: XCGLogger] = dictionary.reduce([:]){(var loggers, kv) in
loggers[kv.0] = newLogger(kv.1.0, withLevel: level(kv.1.1))
return loggers
}

Sería más conveniente y más claro si Swift pudiera destruir kv en (clave, valor). Esperemos que la versión futura de Swift, podamos hacer esto.

Answer 2

La razón es que el map solo puede devolver matrices y no diccionarios. Para obtener un diccionario tiene varias estrategias, por ejemplo:

var loggers : [String: XCGLogger] = [:]
dictionary.map{(n, l) in loggers[n] = newLogger(l.0, withLevel: level(l.1))}

o quizás:

var loggers : [String: XCGLogger] = [:]
for (n, l) in dictionary {
loggers[n] = newLogger(l.0, withLevel: level(l.1))
}

madereros

Answer 3

extension SequenceType {
func toDict<K : Hashable, V>
(@noescape convert: Generator.Element -> (K, V)) -> [K:V] {
var result: [K:V] = [:]
for x in self {
let (key, val) = convert(x)
result[key] = val
}
return result
}
}
dictionary.toDict { (n, l) in (n, newLogger(l.0, withLevel: level(l.1))) }

O

extension Dictionary {
public init<
S : SequenceType where
S.Generator.Element == (Key, Value)
>(_ seq: S) {
self.init()
for (k, v) in seq { self[k] = v }
}
}
extension SequenceType {
func toDict<K : Hashable, V>
(@noescape convert: Generator.Element -> (K, V)) -> [K:V] {
return Dictionary(lazy(self).map(convert))
}
}
dictionary.toDict { (n, l) in (n, newLogger(l.0, withLevel: level(l.1))) }

O

extension Dictionary {
func map<K : Hashable, V>(@noescape transform: (Key, Value) -> (K, V)) -> [K:V] {
var result: [K:V] = [:]
for x in self {
let (key, val) = transform(x)
result[key] = val
}
return result
}
}
dictionary
.map { (n, l) in (n, newLogger(l.0, withLevel: level(l.1))) }