E aee jovens, tudo bem com vocês?

Nesta postagem iremos entender sobre funções sem retorno, diferença entre declarações e expressões, e funções com retorno dentro da Rust

Então, lets'go!!!

Funções

Até o momento todo o código que estamos usando foram colocados dentro de uma das mais importantes funções dentro da Rust - a função main, que é o enterpoint dos nossos programas.

Para criarmos uma função devemos usar a palavra reservada fn, por convenção os nomes das funções utilizam o estilo snake_case.

Vamos criar um projeto e executar o VS Code com os comandos abaixo no terminal:

cargo new functions
code .

No arquivo main.rs vamos copiar e colar o conteúdo que segue:

fn  main() {
    other_function();

    let x =  sum(3, 2);
    println!("{}", x);

    let y =  return_explicit(4, 7);
    println!("{}", y);

    let z =  return_values();
    println!("{} - {}", z.0, z.1);
}

// função sem retorno
fn  other_function() {
    println!("Testando função sem retorno");
}

// função com retorno
fn  sum(num1: i32, num2: i32) -> i32 {
    num1 + num2
}

// função com retorno expicito
fn  return_explicit(num1: i32, num2: i32) -> i32 {
    return num1 + num2;
}

fn return_values() -> (i32, f64) {
    return (17, 3.14);
}

Funções em Rust podem ser definidas tendo parâmetros ou não, os parâmetros são passados dentro dos parenteses como podemos ver na função sum(num1: i32, num2: i32), e a função fn other_function() não possui nenhum parâmetro. Quando estamos usando parâmetros eles devem ter um tipo definido, e se formos utilizar mais de um separamos eles com uma virgula.

Funções sem retorno

No exemplo do projeto functions a função other_function() não tem nenhum retorno, ou seja, será executado o corpo e finalizada sem que eu possa atribuir um valor de retorno.

Declarações e Expressões

Declarações são instruções que executam alguma ação e não retornam um resultado. Por exemplo quando criamos uma variável let x = 17; isso é uma declaração.

A maior parte do que faremos em Rust são expressões, por exemplo uma operação matemática como 13 + 4, uma chamada de função como estamos fazendo dentro da função main other_function();, chamar uma macro, tudo isso são expressões.

Funções com retorno

Todo retorno de função tem um tipo, e deve ser especificado após o -> conforme vimos na função fn sum(num1: i32, num2: i32) -> i32
neste caso tem um retorno de um numero do tipo inteiro de 32 bits.

O retorno será o sinônimo do valor da ultima expressão no bloco do corpo da função. Podemos também explicitar o retorno com a palavra reservada return como no nosso exemplo return_explicit(), mas na maioria das vezes vamos ver o retorno implícito de uma expressão.

Vejamos nosso exemplo dentro do projeto functions a função sum:

fn  sum(num1: i32, num2: i32) -> i32 {
    num1 + num2
}

Na expressão num1 + num2 ela não termina com um ponto-e-vírgula pois será o retorno da nossa função.

Podemos também ter retorno de múltiplos valores como no exemplo abaixo:

fn return_values() -> (i32, f64) {
    return (17, 3.14);
}

Vamos executar o nosso programa functions utilizando o comando:

cargo run

Teremos um resultado parecido com:

Compiling functions v0.1.0 (/home/pehdepano/dev/workspace/rust/learning_rust/05 - Functions/functions)
  Finished dev [unoptimized + debuginfo] target(s) in 1.15s
    Running `target/debug/functions`
Testando função sem retorno
5
11
17 - 3.14

Até aqui conseguimos entender bem como funcionam alguns conceitos da linguagem e um pouco sobre as funções em Rust.

Vou adicionar o fonte desta postagem no Github, segue o link: Aprendendo Rust

Quaisquer dúvidas ou sugestões para que eu melhore nas postagens deixe um comentário, e continue acompanhando os próximos posts.

Referencias

O livro de Rust

Tour of Rust

CodeShow