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.
// 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 }
Punto: (3, 4) Distancia al origen: 7 Punto: (-2, 5) Distancia al origen: 7 Area del rectangulo: 42
Cómo funciona
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.