Map, Filter, Reduce

mfr.swift

//------------------------------------------------------------------------------
// Aula 4 - 27-11-2014 - Funcional - Map, Filter, Reduce
//------------------------------------------------------------------------------
//-- Com cenas dos proximos capitulos (Generics, Structs)

var numeros = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

//-- Sintaxe diferente
reduce(numeros, 0, +)
reduce(numeros, 1, *)

//------------------------------------------------------------------------------
//-- Criando a função Map
func meuMap<T, U>(entrada: [T], transformacao: T -> U) -> [U] {
    var resultado: [U] = []
    
    for item in entrada {
        resultado.append(transformacao(item))
    }
    
    return resultado
}

//-- Testes
let add5 = { x in
    x + 5
}

map(numeros, add5)
meuMap(numeros, add5)

//------------------------------------------------------------------------------
//-- Criando a função Filter
func meuFilter<T>(entrada: [T], condicional: T -> Bool) -> [T] {
    var resultado: [T] = []
    
    for item in entrada {
        if condicional(item) {
            resultado.append(item)
        }
    }
    
    return resultado
}

//-- Testes
let impar = { x -> Bool in
    x % 2 != 0
}

filter(numeros, impar)
meuFilter(numeros, impar)

//------------------------------------------------------------------------------
//-- Criando a função Reduce
func meuReduce<A, R>(sequencia: [A], valorInicial: R, combinacao: (R, A) -> R) -> R {
    var resultado = valorInicial
    
    for item in sequencia {
        resultado = combinacao(resultado, item)
    }
    
    return resultado
}

//-- Testes
reduce(numeros, 100, -)
meuReduce(numeros, 100, -)

//------------------------------------------------------------------------------
//-- Definindo Map a partir do Reduce
func mapComReduce<T, U>(entrada: [T], transformacao: T -> U) -> [U] {
    return reduce(entrada, []) { resultado, x in
        resultado + [ transformacao(x) ]
    }
}

//-- Testes
let mul3 = { x in
    x * 3
}

map(numeros, mul3)
mapComReduce(numeros, mul3)

//------------------------------------------------------------------------------
//-- Definindo Filter a partir do Reduce
func filterComReduce<T>(entrada: [T], condicional: T -> Bool) -> [T] {
    return reduce(entrada, []) { resultado, x in
        return condicional(x) ? resultado + [x] : resultado
    }
}

//-- Testes
let par = { x -> Bool in
    x % 2 == 0
}

filter(numeros, par)
filterComReduce(numeros, par)

//------------------------------------------------------------------------------
//-- Exemplo de uso

struct Cidade {
    let nome: String
    let populacao: Int
}

let cidades = [
    Cidade(nome: "São Paulo",      populacao: 11_895),
    Cidade(nome: "Rio de Janeiro", populacao:  6_453),
    Cidade(nome: "Salvador",       populacao:  2_902),
    Cidade(nome: "Brasília",       populacao:  2_852),
    Cidade(nome: "Fortaleza",      populacao:  2_571),
    Cidade(nome: "Belo Horizonte", populacao:  2_491),
    Cidade(nome: "Manaus",         populacao:  2_020),
    Cidade(nome: "Curitiba",       populacao:  1_864),
    Cidade(nome: "Recife",         populacao:  1_608),
    Cidade(nome: "Porto Alegre",   populacao:  1_472),
    Cidade(nome: "Belém",          populacao:  1_432),
    Cidade(nome: "Goiânia",        populacao:  1_412),
    Cidade(nome: "São Luís",       populacao:  1_064),
    Cidade(nome: "Maceió",         populacao:  1_005),
    Cidade(nome: "Natal",          populacao:    862),
    Cidade(nome: "Campo Grande",   populacao:    843),
    Cidade(nome: "Teresina",       populacao:    840),
    Cidade(nome: "João Pessoa",    populacao:    780),
    Cidade(nome: "Aracaju",        populacao:    623),
    Cidade(nome: "Cuiabá",         populacao:    574),
    Cidade(nome: "Porto Velho",    populacao:    494),
    Cidade(nome: "Florianópolis",  populacao:    461),
    Cidade(nome: "Macapá",         populacao:    446),
    Cidade(nome: "Rio Branco",     populacao:    363),
    Cidade(nome: "Vitória",        populacao:    352),
    Cidade(nome: "Boa Vista",      populacao:    314),
    Cidade(nome: "Palmas",         populacao:    265),
]

func escala(c: Cidade) -> Cidade {
    return Cidade(nome: c.nome, populacao: c.populacao * 1_000)
}

cidades.filter({ cidade in cidade.populacao > 1_500 })
       .map(escala)
       .reduce("Cidade:\tPopulação") { resultado, c in
       return resultado + "\n" + "\(c.nome) : \(c.populacao)"
}