Skip to main content

use-crate

use crate | Rust​

  • use crate | Rust

O que é use crate no Rust​

O que significa​

No Rust, crate é uma palavra reservada que representa o seu projeto atual (o pacote que está sendo compilado).

Então:

use crate::alguma_coisa;

significa:

✅ “importa alguma_coisa de dentro do meu próprio projeto”

Para que serve o use​

O use serve para trazer um caminho (path) para o escopo atual, permitindo usar nomes sem escrever o caminho completo toda hora.

Exemplo sem use:

crate::utils::formatar_nome();

Com use:

use crate::utils::formatar_nome;

formatar_nome();

Exemplo comum com módulos​

Estrutura típica:

src/
 ├─ main.rs
 └─ utils.rs

utils.rs:

pub fn somar(a: i32, b: i32) -> i32 {
    a + b
}

main.rs:

mod utils;

use crate::utils::somar;

fn main() {
    println!("{}", somar(2, 3));
}

crate:: vs super:: vs self::​

  • crate:: → começa da raiz do projeto
  • super:: → sobe um nível no módulo (pai)
  • self:: → se refere ao módulo atual

Exemplo rápido:

use crate::modulo_raiz::Algo;
use super::AlgoDoPai;
use self::AlgoLocal;

Quando você vai ver use crate::...​

Você vai ver bastante quando:

  • o código está dividido em vários módulos (mod)
  • você quer organizar imports de forma limpa
  • quer evitar repetir caminhos longos

O que é pub(crate) e para que serve​

Visibilidade em Rust​

Por padrão, tudo em Rust é privado. Você precisa usar pub para tornar algo visível fora do módulo.

Rust permite granularidade fina de visibilidade, e pub(crate) é uma dessas opções.

O que significa pub(crate)​

pub(crate) fn minha_funcao() {}

significa:

✅ “essa função é pública dentro do crate, mas não fora dele”

Ou seja:

  • acessível por qualquer módulo do projeto
  • não acessível por outros crates (bibliotecas externas)

Comparação de visibilidade​

ModificadorVisibilidade
(sem pub)apenas no módulo atual
pubpúblico para qualquer crate
pub(crate)público apenas dentro do projeto
pub(super)visível apenas para o módulo pai

Exemplo prático​

mod utils {
    pub(crate) fn interno() {
        println!("visível no crate");
    }
}

fn main() {
    crate::utils::interno(); // funciona
}

Se outro crate tentar usar:

use meu_crate::utils::interno;

❌ Isso NÃO compila — porque não é público externamente.

Quando usar pub(crate)​

Use quando você quer:

  • expor funções entre módulos internos
  • evitar “vazar” APIs internas para usuários externos
  • manter encapsulamento no nível do crate

Isso é muito comum em bibliotecas bem estruturadas.

Relação com módulos e organização​

Rust incentiva fortemente o uso de módulos e controle de visibilidade para:

  • garantir encapsulamento
  • evitar acoplamento desnecessário
  • deixar a API pública mais limpa

Esse padrão é reforçado pela própria organização de crates e módulos