Capturando Valores

Parte da seção Lógica e Fluxo do Journey de Swift da Coddy. Lição 40 de 56.

Uma closure se lembra das variáveis que estavam no escopo quando foi criada. O corpo da closure pode lê-las e até modificá-las posteriormente, mesmo depois que a função circundante tiver retornado. Isso é chamado de captura.

func makeCounter() -> () -> Int {
    var count = 0
    return {
        count += 1
        return count
    }
}

let next = makeCounter()
print(next())                    // 1
print(next())                    // 2
print(next())                    // 3

Cada chamada de makeCounter fornece um count totalmente novo, portanto, dois contadores nunca compartilham estado:

let a = makeCounter()
let b = makeCounter()
print(a())                       // 1
print(b())                       // 1
print(a())                       // 2

A captura é o que torna as closures mais poderosas do que funções comuns: elas carregam estado consigo. Você verá o mesmo truque em JavaScript, Python e muitas outras linguagens.

Desafio

Médio

Crie uma pequena fábrica de contadores.

Defina uma função makeCounter(start: Int, step: Int) que retorna um closure do tipo () -> Int. Cada chamada ao closure retorna o próximo valor: a primeira chamada retorna start, a próxima retorna start + step, a próxima start + 2*step e assim por diante.

Leia três inteiros da entrada: start, step e n. Crie um contador com start e step, depois chame-o n vezes e imprima cada resultado em sua própria linha.

Para a entrada 5 / 3 / 4, a saída é:

Experimente você mesmo

let start = Int(readLine()!)!
let step = Int(readLine()!)!
let n = Int(readLine()!)!

// TODO: makeCounter(start:step:) -> () -> Int que captura o valor corrente
// então chame-o n vezes e imprima cada resultado