Uma coisa que temos que ter em mente é que, essa linguagem é de tipagem estática e forte.

Tipagem Estática é a capacidade de uma linguagem ajudar na segurança de tipos. No momento que determina o tipo de uma variável esse tipo não pode ser alterado durante a compilação

Tipagem forte é capacidade de verificação de tipos em todas as operações em tempo de execução ou compilação.

No Rust existe quatro tipos escalar, que representa um único valor, que são inteiros, ponte flutuante, booleanos e caracteres. Esses tipos você deve recordar de outras linguagem.

Tipo Inteiro

Os tipos inteiros é aquele que não possuem parte fracionada. No rust os tipos de declaração indica o valor associado. A baixo você tem a tabela de associados com base no seu tamanho.

O numero inteiro tem o seu sinal do tipo " i " se pegarmos o i32 como exemplo podemos identificar que é um inteiro que ocupa espaço de 32bits.

Na tabela temos uma coluna que se chama Unsigned ele representa a possibilidade de números negativos ou positivos com o Signed.

Se temos um numero que é duzentos e trinta negativo (-230) podemos informar que é um tipo Signed. Esse tipo é quando o numero necessita que o sinal venha com ele, caso contrario será um Unsigned.

Tipos Flutuante

Ao contrario dos inteiros o tipo flutuante tem casas decimais. O rust tem dois tipos primitivos para o ponto flutuante que são o f32 e f64 com base na sua nomenclatura são de tamanhos 32bits e 64 bits de espaço.

Podemos analisar com o seguinte exemplo:

fn main() {

  let valor1 = 5.0 / f64
  let valor2:f32  = 3.0 / f32 

}

Na linha 2 do código podemos identificar que não foi declarado o tipo e o mesmo veio como f64. Isso acontece quando não declaramos ele vem por padrão.

Tipo Booleano

Como toda a linguagem tem o seu booleano aqui no rust não é diferente o mesmo possui dois valores que é o true ou false.

Podemos declarar ele sem o tipo explícito ou não.

fn main() {

  let veradade = true
  let falso:bool = false

}

Tipo Caractere

O tipo caractere é composto como char esse tipo é o mais primitivo da linguagem ele é composto por aspa simples.

fn main() {

  let z = 'z'

}

Tipo Composto

Esse tipo pode agrupar vários tipos em um único tipo. Na linguagem temos dois primitivos composto que são tuplas e vetores.

Tuplas

Tuplas é uma forma de agrupar vários valores de tipos diferentes em uma só variável.

Podemos vê a tupla com valores múltiplos no exemplo abaixo:

fn main() {

  let tuplas: (f32, f64, u8) = (30.0, 3.5, 1)
  let (a, b, c) = tupla
  println!("o valor do a: {}", a)
  println!("o valor do b: {}", b)
  println!("o valor do c: {}", c)

}

Na linha 6 retiramos cada valor que correspondia a sua tupla para a, b e c, transformando eles em valores separados.

Matriz

É uma forma de ter vários valores em uma coleção com um único tipo, diferente da tupla a matriz tem que ter os seus valores do mesmo tipo.

Podemos vê um caso de uma matriz abaixo.

fn main() {

  let matriz = [1, 2, 3, 4, 5]
  println!("matriz: {}", matriz[0])

}

Na linha 6 acesso o index 0 da matriz, para imprimir o valor resultante que é 1.

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