No Rust existe uma das funções mais importantes que já conhecemos que é main. O main é responsável por ser o ponto partida, onde inicia o software.

As funções são escrita no Rust com base em conversão chamada snake case isso vale para as variáveis também.

O caso de cobra (ou snake_case ) é a prática de escrever palavras ou frases compostas nas quais os elementos são separados por um caractere sublinhado (_) e sem espaços, com a letra inicial de cada elemento em minúscula no composto e a primeira letra superior ou minúsculas — como em “foo_bar” e “Hello_world”.

Vamos para o exemplo abaixo para que possamos entender a nomenclatura.

fn main() {
    let x = 10;
    print_number(x);
}

fn print_number(x: i32) {
    println!("o valor de entrada é: {}", x)
}

/*
    o valor de entrada é: 10
*/

No exemplo temos uma função chamada print_number que a entrada tem um tipo inteiro e o objetivo é imprimir o valor que entrou.

Em cada assinatura de função você terá que declarar o tipo de valor que será de entrada, caso precise declarar uma função com varias entradas basta separar por virgula.

Segue o exemplo abaixo.

fn main() {
    let x = 10;
    let y = 20;
    print_number(x, y);
}

fn print_number(x: i32, y: i32) {
    println!("o valor de x: {} e y: {}", x, y)
}

/*
    o valor de x: 10 e y: 20
*/

Declarações e Expressões

Declarações são instruções de código que não retornam resultado e nas expressões o resultado vem.

Se criar uma variável chamada de numero com o valor de entrada seis, estamos realizando uma declaração pois não há retorno.

fn main () {
 let numero = 6;
}

No caso de declarar uma variável que retorna algo deixa de ser declaração e se torna expressão.

Segue abaixo o exemplo.

fn main() {
    let numero_1 = 6;
    let resposta = {
        let numero_2 = 30;
        numero_2 + numero_1
    };

    println!("resposta: {}", resposta)
}

/*
    resposta: 36
*/

Nesse caso o resultado retornou 36 por que usamos um bloco que contém um novo escopo por meio {}, isso torna uma expressão.

Funções com retorno

As funções podem retornar ou não valores para aqueles que solicitam, no Rust para que essa funções nos retornem algo usamos uma seta ->, na maioria das funções podemos usar a palavra-chave chamada return especificando um retorno mas nessa linguagem o retorno já está implícito na ultima expressão.

Segue abaixo o exemplo.

fn soma(x: i32, y: i32) -> i32 {
    x + y   
}

fn main() {
    let result = soma(10, 20);
    println!("resultado: {}", result)
}

/*
    resposta: 30
*/

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