Escrever programas que lidam bem com a memória não é tarefa fácil. Em C++, é fácil escrever programas que não desalocam objetos (os famosos memory-leaks) ou que tentam usar objetos que já foram desalocados. Em C# (e Java), é fácil sobrecarregar o GC e sofrer penalidades sérias de performance.

Rust tenta resolver esse problema através de uma abordagem original. Por sinal, a promessa da linguagem é detectar mau uso da memória durante o processo de compilação.

Como funciona a desalocação de objetos em Rust

Em Rust, todo objeto no heap é de propriedade de uma, e somente uma, variável. Quando esta variável sai de contexto, Rust automaticamente remove o objeto da memória.

fn foo() {
  let a = String::from("Foo");
  println!("The value of A is {}", a);
}

No código acima, a string está alocada na heap e é de propriedade da variável a. Quando essa variável sai de contexto, Rust tem segurança para tirar a string da memória.

Em C++, teríamos de usar um smart-pointer para ter comportamento semelhante. Em C#, o objeto permaneceria em memória até que o GC fizesse a coleta (não é possível determinar claramente quando isso acontecerá).

Transferência de ownership entre variáveis

Em Rust, quando atribuímos o valor de uma proprieade, para a outra, transferimos a “propriedade” do valor. Assim, a variável que continha o valor perde direito de acesso.

Por exemplo, o código que segue é inválido:

fn main() {
  let a = String::from("Foo");
  let b = a;
  println!("A is {} and B is {}", a, b); // essa linha causa um erro de compilação.
}

O problema aqui foi que estamos tentando acessar o valor da variável a que já não possui permissão de acesso ao valor pois transferiu a ownership para b.

Transferência de ownership ao chamar uma função

Em Rust, quando chamamos uma função passando um valor como parâmetro, transferimos o ownership do valor para a variável que representa o parâmetro na função.

O código a seguir é inválido em Rust:

fn main() {
  let a = String::from("Foo");
  print_string(a);
  println!("A is {}", a); // essa linha causa um erro de compilação.
}

fn print_string(s: String) {
  println!("{}", s);
}

O código acima é inválido porque, na chamada da função, ocorre a transferência de ownership da variável a para s no momento em que ocorre a chamada da função print_string. Por sinal, o valor é desalocado quando s sai de contexto (retorno da função).

Transferência de ownership para uma estrutura de dados mais complexa

Em Rust, quando atribuímos um valor a um elemento de uma tupla, transferímos o onwership desse valor para tupla.

O código que segue também é inválido:

fn main() {
  let a = String::from("Foo");
  let (_, length) = get_string_length(a);
  println!("Length of A is {}.", length);
}

fn get_string_length(s: String) -> (String, usize) {
  (s, s.len()) // esse código gera um erro de compilação
}

Aqui, o problema ocorre porque, ao atribuir o valor de s para o primeiro elemento da tupla, perdemos a permissão de acessar o valor na atribuição do segundo elemento.

Aliás, esse código se resolveria facilmente assim:

fn main() {
  let a = String::from("Foo");
  let (_, length) = get_string_length(a);
  println!("Length of A is {}.", length);
}

fn get_string_length(s: String) -> (String, usize) {
  let l = s.len(); // <-- usamos o valor de "s" antes de atribuir para a tupla
  (s, l) 
}

Mas afinal, por que o conceito de ownership é tão interessante?

Pelo pouco que podemos ver até aqui, o conceito de ownership parece impor uma série de dificuldades ao programador. Entretanto, ela se compensa!

Sabendo que apenas uma variável, em um dado momento, tem a propriedade de um valor, o compilador de Rust consegue gerar código nativo inteligente de desalocação, com segurança assegurada durante a compilação, sem os memory-leaks das linguagens não gerenciadas e sem os overheads de processamento causados pelos GCs.

Rust não tem um runtime. Programas em Rust são muito rápidos!

Tomando e devolvendo ownership

Considere o código VÁLIDO abaixo:

fn main() {
  let a = String::from("Foo");
  let a = print_string(a);
  println!("A is {}", a);
}
fn print_string(s: String) -> String {
  println!("{}", s);
  s
}

Nesse código, ocorre a transferência de ownership da variável a para a função para a função print_string, mas essa devolve o ownership retornando s que é transferido para um shadow de a.

É uma solução, mas, concordemos, “feia pra caramba”!

Variáveis que referenciam um valor, mas sem ownership

Para tornar a vida do programador um pouco menos difícil, Rust possui o conceito de referências semelhante ao que temos em C++. Porém, diferente de C++, com garantias, em tempo de compilação, de que as variáveis de referência não irão “viver” mais tempo que a variável com ownership do valor referenciado.

O código a seguir é válido:

fn main() {
  let a = String::from("Foo");
  let b = &a;
  println!("A is {} and B is {}", a, b); 
}

Dessa vez, a variável b possui uma referência para o valor em a. Não ouve transferência de ownership. Aliás, o compilador garante que não b não tenha “vida“ mais longa do que a.

O seguinte código não seria válido:

fn main() {
  let b;
  {
    let a = String::from("Foo");
    b = &a; // essa linha causa erro de compilação
  }
  println!("B is {}", b); 
}

Aqui, tentou-se atribuir a b uma referência para o valor a. O problema, aqui, foi que a variável a sai de contexto antes que b.

O seguinte código também é válido:

fn main() {
  let a = String::from("Foo");
  let length = get_string_length(&a);
  println!("Length of A is {}.", length);
}
fn get_string_length(s: &String) -> usize {
  s.len()
}

Nesse código, get_string_length recebe uma referência para o valor da variável a. Não há transferência de ownership.

Como saber mais sobre Rust

Quase tudo que aprendi sobre Rust foi escrevendo código e estudando o excelente The Rust Programming Language que está disponível gratuitamente online. Aliás, boa parte do código que está aqui foi inspirado em algum exemplo que encontrei nesse livro.

Se você precisa de performance extrema e não quer escrever C# feito, nem recorrer a C++! Rust pode ser a resposta.

Antes de ir embora

A seguinte função não compila em Rust.

fn longest(x: &str, y: &str) -> &str {
  if x.len() > y.len() {
    x
  } else {
    y
  }
}

Baseado no que aprendeu até aqui, saberia me dizer a causa? (Em tempo, esse código foi extraído do livro que indiquei acima).

Era isso… por enquanto

Esse foi o primeiro post com código aqui na Eximia! Espero que tenham gostado.

Continuarei escrevendo sobre aspectos interessantes que encontrei em Rust. Enquanto isso, , que tal conversarmos sobre o que mostrei aqui nos comentários?

Créditos para a imagem da capa para edunham.