Rust Funções Básico
Funções e expressões
Em Rust, funções são declaradas com a palavra-chave fn. Diferente de muitas linguagens, o corpo de uma função é uma expressão que produz um valor, e esse valor pode ser retornado implicitamente (sem return).
A distinção entre expressões (que avaliam para um valor) e statements (que executam ações e não retornam valor) é fundamental. Por exemplo, let x = 5; é um statement, enquanto 5 é uma expressão. Um bloco { ... } também é uma expressão: seu valor é a última expressão dentro dele, desde que não termine com ponto e vírgula.
Essa característica permite escrever funções de forma concisa e expressiva, usando o retorno implícito. Se você adicionar um ponto e vírgula na última linha, o bloco passa a valer () (unit), o que pode causar erro de tipo se a função espera outro retorno.
Pontos-chave
- Funções são declaradas com
fn nome(parametros) -> TipoDeRetorno { corpo }. - O corpo da função é uma expressão; o valor da última expressão é retornado implicitamente.
- Statements como
lete;não produzem valor; expressões como5 + 3produzem. - Blocos
{ ... }são expressões e podem ser usados como valor em atribuições. - Usar
returné opcional, mas útil para retornos antecipados.
// Função que soma dois números e retorna o resultado implicitamente
fn soma(a: i32, b: i32) -> i32 {
a + b // sem ponto e vírgula: esta é a expressão de retorno
}
// Função que usa um bloco como expressão para calcular um valor
fn dobro_se_par(n: i32) -> i32 {
let resultado = if n % 2 == 0 {
n * 2 // bloco if é uma expressão
} else {
n
};
resultado
}
// Função que retorna antecipadamente com return
fn absoluto(n: i32) -> i32 {
if n < 0 {
return -n; // return explícito
}
n // retorno implícito
}
fn main() {
let x = 5;
let y = 3;
println!("soma({}, {}) = {}", x, y, soma(x, y));
let a = 4;
let b = 7;
println!("dobro_se_par({}) = {}", a, dobro_se_par(a));
println!("dobro_se_par({}) = {}", b, dobro_se_par(b));
let neg = -10;
println!("absoluto({}) = {}", neg, absoluto(neg));
}