Structs

Los structs permiten agrupar datos relacionados bajo un tipo con nombre. Se les puede asociar comportamiento con un bloque impl, dándoles métodos que operan sobre sus campos a través de un parámetro self.

Código

// Structs: definición, campos, impl con métodos, instanciación

struct Point {
    x: int,
    y: int
}

impl Point {
    fn distance_from_origin(self) -> int {
        // distancia Manhattan: |x| + |y|
        var ax: int = self.x
        if ax < 0 {
            ax = ax * -1
        }
        var ay: int = self.y
        if ay < 0 {
            ay = ay * -1
        }
        return ax + ay
    }

    fn to_string(self) -> String {
        return "(" + int_to_string(self.x) + ", " + int_to_string(self.y) + ")"
    }
}

struct Rectangle {
    width: int,
    height: int
}

impl Rectangle {
    fn area(self) -> int {
        return self.width * self.height
    }
}

fn main() -> int {
    let p1: Point = Point { x: 3, y: 4 }
    print("Punto: " + p1.to_string())
    print("Distancia al origen: " + int_to_string(p1.distance_from_origin()))

    let p2: Point = Point { x: -2, y: 5 }
    print("Punto: " + p2.to_string())
    print("Distancia al origen: " + int_to_string(p2.distance_from_origin()))

    let rect: Rectangle = Rectangle { width: 6, height: 7 }
    print("Area del rectangulo: " + int_to_string(rect.area()))

    return 0
}

Salida

Punto: (3, 4)
Distancia al origen: 7
Punto: (-2, 5)
Distancia al origen: 7
Area del rectangulo: 42

Explicación

Un struct se define con la palabra clave struct, un nombre, y una lista de campos tipados separados por comas dentro de llaves. Los nombres de structs siguen PascalCase por convención. Los campos se acceden con notación de punto: instance.field.

Los métodos se definen en un bloque impl para el struct. El primer parámetro self se refiere a la instancia sobre la que se llama el método — es similar a this en otros lenguajes. Los métodos pueden acceder a cualquier campo del struct a través de self.field_name.

La instanciación de structs usa la sintaxis de inicialización de campos: TypeName { field: value, ... }. Todos los campos deben proporcionarse; no hay valores por defecto a menos que se escriba explícitamente un método constructor.

El ejemplo de distancia Manhattan muestra cómo los métodos pueden contener lógica arbitraria, variables locales y control de flujo — son simplemente funciones asociadas a un tipo. Puede haber múltiples bloques impl para el mismo struct, y cada struct puede tener su propio impl independiente.

Source: examples/by-example/08-structs.nx