Pular para o conteúdo
Rust em Português

Lição 6 de 18 · 15 min

Funções

Como declarar funções com fn, passar parâmetros com tipo, devolver valores e entender a diferença entre expressão e instrução.

Ao terminar, você vai saber:

  • Declarar e chamar funções com fn
  • Passar parâmetros sempre com o tipo escrito
  • Devolver valores com -> e com a última expressão
  • Diferenciar expressão de instrução
  • Escrever comentários de linha e de documentação

Você já conhece uma função: a main, por onde todo programa começa. Agora é hora de criar as suas. Função é um pedaço de código com nome, que você pode chamar quantas vezes quiser. Ela evita repetição e deixa o programa mais fácil de ler.

Declarando uma função

Use a palavra fn, o nome, parênteses e chaves:

fn main() {
    dar_bom_dia();
    dar_bom_dia();
}

fn dar_bom_dia() {
    println!("Bom dia! Já tomou café?");
}

Alguns detalhes:

  • O nome segue o padrão snake_case: letras minúsculas e palavras separadas por _. O compilador avisa se você fugir disso.
  • A ordem não importa: dar_bom_dia está declarada depois da main e funciona do mesmo jeito.

Parâmetros

Parâmetros são os valores que a função recebe. No Rust, cada parâmetro precisa ter o tipo escrito. Aqui não tem inferência, e isso é de propósito: a assinatura da função vira uma documentação confiável.

fn main() {
    cumprimentar("Paulo", 34);
    cumprimentar("Aline", 22);
}

fn cumprimentar(nome: &str, idade: u32) {
    println!("Olá, {nome}! Você tem {idade} anos.");
}

Os parâmetros são separados por vírgula, cada um no formato nome: tipo. O &str é o tipo de um texto que a função só vai ler. Você vai entender o & direitinho no módulo de ownership.

Devolvendo um valor

Para a função devolver algo, escreva -> e o tipo do retorno:

fn main() {
    let total = somar(15, 27);
    println!("Total: {total}");
}

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

Repare: não tem return e não tem ponto e vírgula depois de a + b. No Rust, o valor da última expressão do corpo é o retorno da função. Para entender isso, precisamos falar de expressões e instruções.

Expressão e instrução

Essa é uma das ideias mais importantes do Rust.

  • Instrução (statement) faz alguma coisa e não produz valor. Exemplo: let x = 5;.
  • Expressão (expression) produz um valor. Exemplos: 5, a + b, somar(1, 2).

O ponto e vírgula transforma uma expressão em instrução: ele “joga fora” o valor. Por isso:

  • a + b no fim da função: é expressão, o valor é devolvido.
  • a + b; no fim da função: vira instrução, nada é devolvido.

Um bloco entre chaves também é uma expressão. O valor dele é o da última linha sem ponto e vírgula:

fn main() {
    let preco_final = {
        let preco = 100;
        let desconto = 15;
        preco - desconto // sem ponto e vírgula: é o valor do bloco
    };

    println!("Preço final: {preco_final}");
}

O erro mais comum

Todo mundo esquece disso no começo e coloca ponto e vírgula onde não devia:

fn dobro(numero: i32) -> i32 {
    numero * 2;
}

fn main() {
    println!("{}", dobro(4));
}
error[E0308]: mismatched types
  |
1 | fn dobro(numero: i32) -> i32 {
  |    -----                 ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
2 |     numero * 2;
  |               - help: remove this semicolon to return this value

Lendo com calma: a função promete devolver i32, mas o corpo devolve (). Esse () (lê-se “unit”) é o tipo de “nada”, o valor de quem não devolve nada. E o compilador aponta exatamente o culpado: “remove this semicolon to return this value”, ou seja, tire o ponto e vírgula.

E o return?

O return existe, sim. Ele serve para sair da função antes do fim:

fn main() {
    println!("{}", calcular_frete(250.0));
    println!("{}", calcular_frete(80.0));
}

fn calcular_frete(valor_da_compra: f64) -> f64 {
    if valor_da_compra >= 200.0 {
        return 0.0; // frete grátis, sai daqui mesmo
    }

    valor_da_compra * 0.1
}

O estilo do Rust é: return para sair mais cedo, última expressão para o caso normal.

Devolvendo mais de um valor

Uma função devolve um valor só, mas esse valor pode ser uma tupla:

fn main() {
    let (quociente, resto) = dividir(17, 5);
    println!("17 dividido por 5 dá {quociente} e sobra {resto}.");
}

fn dividir(dividendo: u32, divisor: u32) -> (u32, u32) {
    (dividendo / divisor, dividendo % divisor)
}

Comentários

Você já viu os comentários de linha, com //. Tudo depois deles até o fim da linha é ignorado pelo compilador.

fn main() {
    // Comentário numa linha só
    let juros = 0.02; // também pode ficar no fim da linha

    /* Comentário de bloco:
       pode ocupar várias linhas,
       mas é pouco usado no dia a dia */

    println!("{juros}");
}

Existe ainda o comentário de documentação, com ///. Ele fica em cima de uma função e explica o que ela faz. Ferramentas como o cargo doc e o rust-analyzer usam esse texto para gerar documentação e mostrar dicas no editor.

/// Calcula a média de duas notas.
///
/// Recebe as duas notas e devolve a média com casas decimais.
fn media(nota1: f64, nota2: f64) -> f64 {
    (nota1 + nota2) / 2.0
}

fn main() {
    println!("Média: {}", media(7.0, 8.5));
}

Uma dica: comente o porquê, não o o quê. // soma 1 em cima de contador += 1 não ajuda ninguém. // conta o próprio usuário na lista ajuda.

Funções e macros

Por fim, uma diferença que confunde no começo: println! não é função, é macro. Macros têm ! no nome e podem fazer coisas que funções não podem, como receber um número variável de argumentos. Por enquanto, basta saber diferenciar pelo !.

Resumo

  • Funções são declaradas com fn e nomes em snake_case.
  • Todo parâmetro tem o tipo escrito; o retorno vem depois de ->.
  • A última expressão sem ponto e vírgula é o valor devolvido.
  • Expressão produz valor; o ponto e vírgula a transforma em instrução.
  • return serve para sair mais cedo.
  • // comenta uma linha; /// documenta uma função.

Desafio

Escreva uma função imc que recebe peso (em quilos) e altura (em metros) como f64 e devolve o índice de massa corporal (peso dividido pela altura ao quadrado). Escreva outra função, classificar, que recebe o IMC e devolve um &str: "abaixo do peso" se for menor que 18.5, "peso normal" se for menor que 25, e "acima do peso" nos outros casos. Use return para sair mais cedo e a última expressão para o caso final.

Ver uma resposta
/// Calcula o índice de massa corporal.
fn imc(peso: f64, altura: f64) -> f64 {
    peso / (altura * altura)
}

/// Diz em que faixa o IMC está.
fn classificar(valor: f64) -> &'static str {
    if valor < 18.5 {
        return "abaixo do peso";
    }
    if valor < 25.0 {
        return "peso normal";
    }
    "acima do peso"
}

fn main() {
    let valor = imc(70.0, 1.75);
    println!("IMC: {valor:.1}, {}", classificar(valor));
}

O &'static str é um texto fixo, escrito direto no código, que vale durante o programa inteiro. Esse 'static é um tipo de lifetime, assunto para mais adiante. Por enquanto, leia como “texto fixo”.

Salvo só neste navegador.