Funções

Funções são difundidas em códigos em Rust. Você já viu uma das mais importantes funções da linguagem: a função main, que é o ponto de entrada de diversos programas. Você também já viu a notação fn, que permite você declarar uma nova função.

Códigos em Rust usam, por convenção, o estilo snake case para nomes de função e variável. No snake case, todas as letras são minúsculas e sublinhado (underline) separa as palavras. Aqui está um programa que contém uma definição de função de exemplo:

Nome do arquivo: src/main.rs

fn main() {
    println!("Olá, mundo!");

    outra_funcao();
}

fn outra_funcao() {
    println!("Outra função.");
}

As definições de funções em Rust iniciam com fn e tem um par de parênteses depois do nome da função. As chaves dizem ao compilador onde o corpo da função começa e termina.

Podemos chamar qualqer função que tenhamos definido, inserindo seu nome, seguido de um conjunto de parenteses. Pelo fato da outra_funcao ter sido definida no programa, ela pode ser chamada dentro da função main. Note que definimos outra_funcao depois da função main; poderíamos ter definido antes também. Rust não se importa onde você definiu suas funções, apenas que elas foram definidas em algum lugar.

Vamos começar um novo projeto binário, chamado funcoes para explorar mais funções. Coloque o exemplo outra_funcao em src/main.rs e execute-o. Você verá a seguinte saída:

$ cargo run
   Compiling funcoes v0.1.0 (file:///projects/funcoes)
    Finished dev [unoptimized + debuginfo] target(s) in 0.28 secs
     Running `target/debug/funcoes`
Olá, mundo!
Outra função.

As linhas são executadas na ordem em que aparecem na função main. Primeiro, a mensagem "Olá, mundo!" é exibida, e então outra_funcao é chamada e exibida a mensagem.

Parâmetros de função

Funções também podem ser definidas tendo parâmetros, que são variáveis especiais que fazem parte da assinatura da função. Quando uma função tem parâmetros, você pode fornecer tipos específicos para esses parâmetros. Tecnicamente, os valores definidos são chamados de argumentos, mas informalmente, as pessoas tendem a usar as palavras parâmetro e argumento para falar tanto de variáveis da definição da função como os valores passados quando você chama uma função.

A seguinte versão (reescrita) da outra_funcao mostra como os parâmetros aparecem no Rust:

Nome do arquivo: src/main.rs

fn main() {
    outra_funcao(5);
}

fn outra_funcao(x: i32) {
    println!("O valor de x é: {}", x);
}

Tente executar este programa; você verá a seguinte saída:

$ cargo run
   Compiling funcoes v0.1.0 (file:///projects/funcoes)
    Finished dev [unoptimized + debuginfo] target(s) in 1.21 secs
     Running `target/debug/funcoes`
O valor de x é: 5

A declaração de outra_funcao tem um parâmetro chamado x. O tipo do x é especificado como i32. Quando 5 é passado para a outra_funcao, a macro println! coloca 5 onde o par de chaves estava na string de formato.

Nas assinaturas de função, você deve declarar o tipo de cada parâmetro. Essa é decisão deliberada no design do Rust: exigir anotações de tipo na definição da função, significa que o compilador quase nunca precisará que as use em outro lugar do código para especificar o que você quer.

Quando você precisa que uma função tenha vários parâmetros, separe as declarações de parâmetros com vírgula, como a seguir:

Nome do arquivo: src/main.rs

fn main() {
    outra_funcao(5, 6);
}

fn outra_funcao(x: i32, y: i32) {
    println!("O valor de x é: {}", x);
    println!("O valor de y é: {}", y);
}

Este exemplo cria uma função com dois parâmetros, ambos com o tipo i32. Então a função exibe os valores de ambos os parâmetros. Note que os parâmetros de função não precisam ser do mesmo tipo, isto apenas aconteceu neste exemplo.

Vamos tentar executar este código. Substitua o programa src/main.rs, atualmente em seu projeto funcoes com o exemplo anterior e execute-o usando cargo run:

$ cargo run
   Compiling funcoes v0.1.0 (file:///projects/funcoes)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs
     Running `target/debug/funcoes`
O valor de x é: 5
O valor de y é: 6

Porque nós chamamos a função com 5 sendo o valor dex e 6 é passado como o valor de y, as duas cadeias são impressas com esses valores.

Corpos de função

Corpos de função são constituídos por uma série de declarações que terminam, opcionalmente, em uma expressão. Até agora, foram apresentadas apenas funções sem uma expressão final, mas você viu uma expressão como parte de instruções. Porque Rust é uma linguagem baseada em expressão, essa é uma importante distinção a ser entendida. Outras linguagens não têm as mesmas distinções, então, vamos ver o que são declarações e expressões e como elas afetam o corpo das funções.

Declarações e Expressões

Na verdade, já usamos declarações e expressões. Declarações são instruções que executam alguma ação e não retornam um resultado. E expressões retornam um resultado. Vamos ver alguns exemplos.

Criar uma variável e atribuir um valor a ela com a palavra-chave let é uma declaração. Na Listagem 3-1, let y = 6; é uma declaração:

Nome do arquivo: src/main.rs

fn main() {
    let y = 6;
}

Listagem 3-1: A declaração da função main contendo uma declaração.

Definições de função também são definições; todo o exemplo é uma declaração em si.

Definições não retornam valores. Assim sendo, você não pode atribuir uma declaração let para outra variável, como o código a seguir tenta fazer; você receberá um erro:

Nome do arquivo: src/main.rs

fn main() {
    let x = (let y = 6);
}

Quando você rodar esse programa, o erro será o seguinte:

$ cargo run
   Compiling funcoes v0.1.0 (file:///projects/funcoes)
error: expected expression, found statement (`let`)
 --> src/main.rs:2:14
  |
2 |     let x = (let y = 6);
  |              ^^^
  |
  = note: variable declaration using `let` is a statement

A declaração let y = 6 não retorna um valor, então não existe nada para o x se ligar. Isso é diferente do que acontece em outras linguagens, como C e Ruby, onde a atribuição retorna o valor atribuído. Nestas linguagens, você pode escrever x = y = 6 e ter ambos, x e y contendo o valor 6; esse não é o caso em Rust.

Expressões avaliam algo e compõem a maior parte do código que você escreverá em Rust. Considere uma simples operação matemática, como um 5 + 6, que é uma expressão que avalia o valor 11. Expressões podem fazer parte de declarações: na Listagem 3-1, o 6 na declaração let y = 6; é uma expressão que avalia o valor 6. A chamada de função é uma expressão. Chamar uma macro é uma expressão. O bloco que vamos usar para criar um novo escopo, {}, é uma expressão, por exemplo:

Nome do arquivo: src/main.rs

fn main() {
    let x = 5;

    let y = {
        let x = 3;
        x + 1
    };

    println!("O valor de y é: {}", y);
}

A expressão:

{
    let x = 3;
    x + 1
}

é um bloco que, nesse exemplo, avalia 4. Esse valor fica vinculado ao y como parte da declaração let. Note o x + 1 sem um ponto e vírgula no final, que é diferente da maioria das linhas vistas até agora. Expressões não terminam com ponto e vírgula. Se você adicionar um ponto e vírgula ao fim de uma expressão, você a transforma em uma declaração, que então não retornará um valor. Tenha isso em mente, enquanto explora os valores e expressões de retorno da função a seguir.

Funções com valor de retorno

Funções podem retornar valores para o código que os chama. Não nomeamos valores de retorno, mas declaramos o tipo deles depois de uma seta (->). Em Rust, o valor de retorno da função é sinônimo do valor da expressão final no bloco do corpo de uma função. Você pode retornar cedo de uma função usando a palavra-chave return e especificando um valor, mas a maioria das funções retorna a última expressão implicitamente. Veja um exemplo de uma função que retorna um valor:

Nome do arquivo: src/main.rs

fn cinco() -> i32 {
    5
}

fn main() {
    let x = cinco();

    println!("O valor de x é: {}", x);
}

Não há chamadas de função, macros ou até mesmo declarações let na funçãocinco

  • apenas o número 5 por si só. Essa é uma função perfeitamente válida em Rust. Observe que o tipo de retorno da função também é especificado como -> i32. Tente executar este código; a saída deve ficar assim:
$ cargo run
   Compiling funcoes v0.1.0 (file:///projects/funcoes)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30 secs
     Running `target/debug/funcoes`
O valor de x é: 5

O 5 emcinco é o valor de retorno da função, e é por isso que o tipo de retorno é i32. Vamos verificar isso com mais detalhes. Existem dois bits importantes: primeiro, a linha let x = cinco (); mostra que estamos usando o valor de retorno de uma função para inicializar uma variável. Porque a função cinco retorna um5, essa linha é a mesma que a seguinte:


# #![allow(unused_variables)]
#fn main() {
let x = 5;
#}

Em segundo lugar, a função cinco não tem parâmetros e define o tipo de valor de retorno, mas o corpo da função é um 5 solitário sem ponto e vírgula porque é uma expressão cujo valor queremos retornar.

Vamos ver outro exemplo:

Nome do arquivo: src/main.rs

fn main() {
    let x = soma_um(5);

    println!("O valor de x é: {}", x);
}

fn soma_um(x: i32) -> i32 {
    x + 1
}

A execução deste código irá imprimir O valor de x é: 6. Mas se colocarmos um ponto e vírgula no final da linha que contém x + 1, alterando-o de expressão para uma declaração, receberemos um erro.

Nome do arquivo: src/main.rs

fn main() {
    let x = soma_um(5);

    println!("O valor de x é: {}", x);
}

fn soma_um(x: i32) -> i32 {
    x + 1;
}

Executar este código produz um erro, da seguinte maneira:

error[E0308]: mismatched types
 --> src/main.rs:7:28
  |
7 |   fn soma_um(x: i32) -> i32 {
  |  ____________________________^
8 | |     x + 1;
  | |          - help: consider removing this semicolon
9 | | }
  | |_^ expected i32, found ()
  |
  = note: expected type `i32`
             found type `()`

A principal mensagem de erro, "tipos incompatíveis", revela o problema central com este código. A definição da função soma_um diz que retornará uma i32, mas as declarações não avaliam um valor expresso por(), a tupla vazia. Portanto, nada é retornado, o que contradiz a função definição e resulta em erro. Nesta saída, Rust fornece uma mensagem para possivelmente ajudar a corrigir este problema: sugere a remoção do ponto e vírgula, que iria corrigir o erro.