Blocos impl — Métodos_

PT-BR:
Métodos são funções associadas a um tipo, declaradas em blocos impl. Um método pode ser um método de instância (recebe self) ou um método estático (não recebe self, funciona como construtor ou utilitário).

EN-US:
Methods are functions associated with a type, declared in impl blocks. A method can be an instance method (receives self) or a static method (does not receive self, works as a constructor or utility).

Receptores / Receivers

Exemplo Completo / Complete Example

module metodos

from std.io import println

record Ponto {
    x: int,
    y: int
}

impl Ponto {
    // Método estático (construtor) / Static method (constructor)
    func novo(x: int, y: int) returns Ponto {
        Ponto { x: x, y: y }
    }

    // Método de leitura / Read method
    func obter_x(&self) returns int {
        self.x
    }

    func obter_y(&self) returns int {
        self.y
    }

    // Método de cálculo / Calculation method
    func distancia_da_origem(&self) returns float {
        let soma_quadrados = (self.x * self.x + self.y * self.y)
        // simplificado — sem sqrt / simplified — without sqrt
        soma_quadrados
    }

    // Método que retorna novo valor / Method returning new value
    func mover(&self, dx: int, dy: int) returns Ponto {
        Ponto { x: self.x + dx, y: self.y + dy }
    }

    // Método com mut self / Method with mut self
    func escalar(&mut self, fator: int) {
        self.x = self.x * fator
        self.y = self.y * fator
    }

    // Método para exibição / Display method
    func para_string(&self) returns string {
        f"({self.x}, {self.y})"
    }
}

public func main() {
    // Construtor estático / Static constructor
    let p1 = Ponto::novo(10, 20)

    // Métodos de instância / Instance methods
    let x = p1.obter_x()
    // 10
    let y = p1.obter_y()
    // 20

    // Method chaining (encadeamento) / Method chaining
    let p2 = p1.mover(5, 5).mover(3, 3)
    // p2 = (18, 28)

    println(p1.para_string())
    // (10, 20)
    println(p2.para_string())
    // (18, 28)
}

Métodos em Enums / Methods on Enums

enum Forma {
    Circulo { raio: float },
    Retangulo { largura: float, altura: float }
}

impl Forma {
    func area(&self) returns float {
        match self {
            when Forma::Circulo { raio } then raio * raio * 3.14159,
            when Forma::Retangulo { largura, altura } then largura * altura
        }
    }

    func perimetro(&self) returns float {
        match self {
            when Forma::Circulo { raio } then 2.0 * 3.14159 * raio,
            when Forma::Retangulo { largura, altura } then 2.0 * (largura + altura)
        }
    }
}

public func main() {
    let c = Forma::Circulo { raio: 5.0 }
    let r = Forma::Retangulo { largura: 4.0, altura: 6.0 }

    println(f"Área do círculo: {c.area()}")
        // ~78.54
    println(f"Área do retângulo: {r.area()}")
      // 24.0
}

Métodos em Structs Aninhadas / Methods on Nested Structs

record Retangulo {
    canto: Ponto,
    largura: int,
    altura: int
}

impl Retangulo {
    func novo(x: int, y: int, l: int, a: int) returns Retangulo {
        Retangulo {
            canto: Ponto::novo(x, y),
            largura: l,
            altura: a
        }
    }

    func area(&self) returns int {
        self.largura * self.altura
    }

    func canto_x(&self) returns int {
        self.canto.obter_x()    // Chama método do Ponto aninhado
    }
}

---