No Rust temos alguns recursos que são chamado de sistema de módulos eles englobam alguns recursos.

1. Os módulos é uma forma de organizar o seu código e reutilizar com alguns controles e privacidade.

2. Existem caminhos é uma maneira de dar nomes ao itens.

3. Existe palavra de chave para caminho com base no seu escopo e temos a palavra pub que é uma forma de colocar os itens públicos.

4. Isso já acontece com os pacotes externos como por exemplo nos post anteriores usamos o String::from e reqwest::get.

Se pensarmos em módulos no Rust vem na mente varias coisas como “componentes”, “reuso” e por ai vai. No Rust possibilita usar módulos para organização de recurso e código.

Veja o exemplo abaixo.


mod user {
  fn create() {

  }
}


fn main() {

}

Vamos fazer uma leitura simples sobre, o modulo user tem uma função create() como escopo principal. Podemos organizar ele como hierarquia de módulos veja o exemplo.


mod user {
  mod hourse {
    mod room {

    }
  }
  mod car {
    
  }
}


fn main() {

}

Neste exemplo definimos um módulo chamado user e colocando outros dentro dele como hourse e car sendo que o hourse temos room.

Para acesso dos módulos usaremos o caminho dele para os demais com base na sua hierarquia.

Segue o exemplo.


mod user {
  pub mod hourse {

    fn print_room() {
      print!("limpando...");
    }
    
    pub mod room {
      pub fn clear() {
        super::print_room();
      }
    }
  }

  mod car {}
}

use crate::user::hourse;

fn main() {
  hourse::room::clear()
}

/*
  limpando...
*/

Então, na linha 19 temos o caminho absoluto usando o crate e na linha 20 temos o relativo são duas forma que podemos utilizar para chamar o nosso módulo. A nossa saída do terminal informa um error error[E0603]: module hourse is private o Rust informa que o nosso modulo chamado hourse e room é privado e assim não podemos acessar-lo.

Para que possa ter acesso aos dados, podemos modificar os métodos colocando em público, usando o pub.

Segue o exemplo.


mod user {
  pub mod hourse {

    fn print_room() {
      print!("limpando...");
    }
    
    pub mod room {
      pub fn clear() {
        super::print_room();
      }
    }
  }

  mod car {}
}

use crate::user::hourse;

fn main() {
  hourse::room::clear()
}

/*
  limpando...
*/

Agora tudo certo executamos da forma correta, pois usamos os módulos em público e suas funções também.

Caso precise acessar uma função fora do escopo de um módulo específico como podemos chamar ?

Segue o exemplo.


mod user {
  pub mod hourse {

    fn print_room() {
      print!("limpando...");
    }
    
    pub mod room {
      pub fn clear() {
        super::print_room();
      }
    }
  }

  mod car {}
}

use crate::user::hourse;

fn main() {
  hourse::room::clear()
}

/*
  limpando...
*/

Nesse caso usando o super::print_room() para solicitar a chamada da função. O super lembra bastante o caminho do sistema de arquivos, colocando :: começando pelo o caminho do módulo pai em vez do módulo atual.

Podemos acessar os nossos módulos por escopo usando o use alguns módulos são repetidos os caminhos, para que não fique só repetindo escrita usaremos ele direto no escopo.

Segue o exemplo.


mod user {
  pub mod hourse {

    fn print_room() {
      print!("limpando...");
    }
    
    pub mod room {
      pub fn clear() {
        super::print_room();
      }
    }
  }

  mod car {}
}

use crate::user::hourse;

fn main() {
  hourse::room::clear()
}

/*
  limpando...
*/

No exemplo usando crate para pegar o caminho relativo até o hourse deixando o room acessível para uso do escopo atual.

O Rust fornece varias maneiras de organização de pacotes, suas crates em módulos e referindo-se a partir de outro, que podemos especificar pelo o caminho relativo ou absoluto. Os módulos definem o código que é privado por padrão, mas você pode optar em torná-las em publico com a palavra chave pub.

Então galera é isso, espero que tenham gostado até a próxima.