Rojo contra Azul: al estilo Darwin

Módulos

Los módulos son una forma de agrupar código relacionado, de evitar conflictos de nombres y, por lo general, están presentes en todas las bases de código salvo en las más triviales.

La sintaxis es la siguiente:

mod my_module {
    pub struct MyStruct {}

    pub struct OtherClass {}
}

Fuera del scope del módulo, los tipos que están dentro de módulos se referencian anteponiendo al nombre del tipo la sintaxis de doble dos puntos ::. Como alternativa, y más habitualmente, puedes colocar una directiva use al principio del archivo (o dentro de un módulo), y entonces los tipos se pueden usar sin el prefijo. Dentro de un mismo módulo no es necesario cualificar los nombres de los tipos.

mod my_module {
    #[derive(Drop)]
    pub struct MyStruct {}

    pub struct Foo {}

    #[generate_trait]
    pub impl FooImpl of FooTrait {
        fn bar() {
            let baz = MyStruct {};
        }
    }
}

#[derive(Drop)]
pub struct Qux {}

#[generate_trait]
impl QuxImpl of QuxTrait {
    fn box() {
        let nux = my_module::MyStruct {};
    }
}

mod other_module {
    use super::my_module::*;

    #[derive(Drop)]
    pub struct Tix {}

    #[generate_trait]
    pub impl TixImpl of TixTrait {
        fn jeg() {
            let lor = MyStruct {};
        }
    }
}

Puedes crear un alias de un módulo o de un tipo con la sintaxis use core::array::ArrayTrait as Arr; y después usar el alias en cualquier lugar en el que se pudiera usar el módulo o el tipo.