Traits

Los traits definen comportamiento compartido que múltiples tipos pueden implementar. Son el mecanismo de abstracción principal de Nyx — similar a las interfaces en Go o a las clases de tipos en Haskell — pero con cuerpos de método completos y soporte de despacho genérico.

Código

// Traits: definir Display, implementar para struct, llamar método

trait Display {
    fn to_string(self) -> String
}

struct Point {
    x: int,
    y: int
}

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

struct Color {
    r: int,
    g: int,
    b: int
}

impl Display for Color {
    fn to_string(self) -> String {
        return "rgb(" + int_to_string(self.r) + ", " + int_to_string(self.g) + ", " + int_to_string(self.b) + ")"
    }
}

fn main() -> int {
    let p: Point = Point { x: 3, y: 4 }
    print("Punto: " + p.to_string())

    let c: Color = Color { r: 255, g: 128, b: 0 }
    print("Color: " + c.to_string())

    return 0
}

Salida

Punto: (3, 4)
Color: rgb(255, 128, 0)

Explicación

Un bloque trait declara un conjunto de firmas de método que cualquier tipo que lo implemente debe proveer. Aquí Display requiere un único método to_string que toma el receptor por valor y retorna un String. El trait en sí mismo no contiene datos — es puramente un contrato de comportamiento.

Cada bloque impl Display for T provee el cuerpo concreto para cada método que exige el trait. Point formatea sus campos como un par de coordenadas, mientras que Color usa la notación CSS rgb(). Ambos structs son por lo demás completamente independientes; lo único que comparten es la adhesión al trait Display.

Una vez que un struct implementa un trait, sus métodos se llaman con la sintaxis de punto habitual — p.to_string() despacha a la implementación de Point en tiempo de compilación (despacho estático). Esto te da polimorfismo sin sobrecarga en tiempo de ejecución.

Source: examples/by-example/21-traits.nx