Closures_

PT-BR:
Closures são funções anônimas que podem ser armazenadas em variáveis ou passadas como argumentos. São definidas com a sintaxe |parâmetros| corpo.

EN-US:
Closures are anonymous functions that can be stored in variables or passed as arguments. They are defined with the |parameters| body syntax.

Sintaxe Básica / Basic Syntax

module closures

from std.io import println

public func main() {
    // Closure de um parâmetro / Single-parameter closure
    let dobrar = |x: int| x * 2
    let resultado = dobrar(5)
    // 10

    // Closure de múltiplos parâmetros / Multi-parameter closure
    let somar = |a: int, b: int| a + b
    let s = somar(3, 4)
          // 7

    // Closure sem parâmetros / Zero-parameter closure
    let quarenta_e_dois = || 42
    let n = quarenta_e_dois()
    // 42

    // Closure com bloco / Closure with block
    let valor_absoluto = |x: int| {
        if x < 0 {
            return x * -1
        }
        return x
    }

    println(f"{valor_absoluto(-5)}")
    // 5
    println(f"{valor_absoluto(7)}")
     // 7
}

Closures como Argumentos / Closures as Arguments

PT-BR:
Uma função que aceita uma closure usa o tipo func(T) returns R como parâmetro.

EN-US:
A function that accepts a closure uses the func(T) returns R type as a parameter.

func aplicar(x: int, f: func(int) returns int) returns int {
    return f(x)
}

func aplicar_duas_vezes(x: int, f: func(int) returns int) returns int {
    return f(f(x))
}

func mapear(arr: [int], n: int, f: func(int) returns int) returns [int] {
    let resultado = [0, 0, 0, 0, 0]
  // pré-alocado
    for i in 0..n {
        resultado[i] = f(arr[i])
    }
    return resultado
}

public func main() {
    // Passando closure diretamente / Passing closure directly
    let r1 = aplicar(5, |x: int| x * 3)
          // 15
    let r2 = aplicar_duas_vezes(2, |x: int| x + 1)
  // 4

    // Passando função nomeada / Passing named function
    let dobro = |x: int| x * 2
    let r3 = aplicar(10, dobro)
    // 20

    // Usando em operação de mapa / Using in map operation
    let nums = [1, 2, 3, 4, 5]
    let quadrados = mapear(nums, 5, |x: int| x * x)
    // quadrados = [1, 4, 9, 16, 25]
}

Tipo de Closure / Closure Type

// O tipo func(int) returns int descreve uma closure de int para int
// The type func(int) returns int describes a closure from int to int

// Closures como variáveis tipadas / Closures as typed variables
let transformador: func(int) returns int = |x: int| x + 10

// Funções que retornam closures / Functions that return closures
func escolher(incrementar: bool) returns func(int) returns int {
    if incrementar {
        return |x: int| x + 1
    }
    return |x: int| x - 1
}

public func main() {
    let transformar = escolher(true)
    let resultado = transformar(7)
    // 8
}

Field shorthand is supported when a local variable has the same name as the struct field. Ponto { x, y } is equivalent to Ponto { x: x, y: y }.

Closures capturam variáveis externas por valor no momento em que a closure é criada. Closures capture external variables by value when the closure is created.

func make_adder(delta: int) returns func(int) returns int {
    return |x: int| x + delta
}

Mutar diretamente uma variável capturada dentro da closure não é permitido nesta versão; passe um valor novo explicitamente ou retorne o novo estado. Directly mutating a captured variable inside the closure is not allowed in this version; pass a new value explicitly or return the new state.

Closures em Expressões / Closures in Expressions

// Closure diretamente em expressão / Closure directly in expression
let val = aplicar(4, |n: int| n * n) + 1
   // 17

// Closures em condições / Closures in conditions
let verificar = |x: int| x > 0 && x < 100
if verificar(42) {
    println("Válido!")
}

---

Próximo / Next: 04 — Avançado / Advanced
Anterior / Previous: 02 — Fundamentos / Fundamentals