Rust (linguagem de programação)

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Rust
Rust programming language black logo.svg
Paradigma orientada a objetos, estruturada, imperativa compilada, concorrente, funcional
Surgido em 2010 (7–8 anos)
Última versão 1.22.1 (22 de novembro de 2017; há 11 meses[1])
Criado por Graydon Hoare, Rust Project Developers, Mozilla
Estilo de tipagem: Estática, forte, inferida
Compiladores rustc
Influenciada por Alef, C#, C++, Cyclone, Erlang, Haskell, Hermes, Limbo, Newsqueak, NIL, OCaml, Ruby, Scheme, Standard ML, Swift[2]
Influenciou Crystal, Dyon, Swift, Idris
Plataforma i386, i586, i686, x86-64, ARM, MIPS, PowerPC, SPARC, S390x, asm.js, WebAssembly[3]
Sistema operacional Linux, Windows, macOS, FreeBSD, NetBSD, Android, iOS, Fuchsia, Solaris, Redox[3]
Licença: Apache 2.0 / MIT
Extensão do arquivo: .rs, .rlib
Página oficial www.rust-lang.org

Rust é uma linguagem de programação multiparadigma compilada desenvolvida pela Mozilla Research.[4] É projetada para ser "segura, concorrente e prática",[5][6] suportando os estilos puramente funcional, procedural, e orientado a objetos. Possui suporte nativo ao WebAssembly.[7][8]

A linguagem apareceu como um projeto pessoal de Graydon Hoare, empregado da Mozilla. A organização começou a apoiar o projeto em 2009 e anunciou-o em 2010. No mesmo ano, os esforços mudaram do compilador original (escrito em OCaml) para um auto-hospedado feito em Rust. Conhecido por rustc, conseguiu compilar-se pela primeira vez em 2011 e utiliza o LLVM como back-end. Foi lançada pela primeira vez uma versão numerada pré-alfa em 2012. Rust 1.0, a primeira versão estável, foi lançada em 15 de Maio de 2015.[9]

Foi considerada pelo público a linguagem "mais amada", de acordo com uma pesquisa conduzida pelo site Stack Overflow em 2016[10] e em 2017,[11] e está entre as 50 linguagens mais populares, de acordo com o Índice Tiobe.[12]

Design[editar | editar código-fonte]

Rust se baseia nos seguintes princípios: segurança sem coletor de lixo, concorrência sem disputa de dados e abstração sem overhead.[13] Estes princípios fazem com que Rust seja rápida para ser usada em aplicações de baixo nível como o motor de renderização Servo[14] e também prática para projetos de alto nível.

Em Rust não existem ponteiros nulos ou ponteiros soltos, impossibilitando falhas de segmentação. Rust gerencia memória e recursos automaticamente,[15] sem necessitar de um coletor de lixo. A linguagem impede corridas de dados entre threads pois não é possível que duas threads possam modificar um mesmo valor ao mesmo tempo. Para que uma referência possa ser compartilhada entre várias threads, ela deve ser somente leitura. Existem diversas técnicas seguras de comunicação entre threads.[16]

O princípio de abstração sem overhead vem do C++. Nas palavras de Bjarne Stroustrup: "Você não paga por aquilo que você não usa. E mais: aquilo que você usa, não conseguiria programar melhor à mão".[17] Rust permite um alto grau de abstração através do sistema de traits, que são interfaces que podem ser implementadas separadamente da declaração de um tipo.[18] Tipos genéricos são utilizados extensamente.

O projeto Rust usa o conceito de "canais de lançamento", semelhante ao Mozilla Firefox; são 3 canais: Nightly, Beta e Stable ("estável"). Diariamente é lançada uma nova versão Nightly, e a cada seis semanas a última versão desse canal é promovida para Beta, e só receberá atualizações para corrigir falhas sérias. Simultaneamente, a última versão Beta é promovida para Stable.[19][20][1]

Cargo é a ferramenta de produtividade oficial, e usa arquivos TOML para listar dependências e configurações de um projeto.[21][22] A documentação de um projeto pode ser gerada a partir de comentários especiais em Markdown, usando o comando $ cargo doc.[22][23]

Iteradores e clausuras[editar | editar código-fonte]

Rust possui um literal para representar iteradores, e traz em sua biblioteca padrão métodos para transformá-los, usando clausuras.[24][25] No exemplo a seguir o programa lista os 10 primeiros números primos:

pub fn main() {
    let limit = 10;
    let mut numbers = Vec::with_capacity(limit); // Vetor vazio pré-alocado
    let mut i = 2; // Números menores que 2 não são primos

    loop {
        // Verifica se i é divisível apenas por ele mesmo e 1.
        // 2..i é um iterador exclusivo, ex.: 2..5 inclui 2, 3 e 4.
        // |x| i % x != 0 é uma clausura, que recebe um inteiro (x) e retorna um booleano.
        if (2..i).all(|x| i % x != 0) {
            numbers.push(i);
        }
        i += 1;

        // Pára o loop quando conseguir 10 números
        if numbers.len() >= limit {
            break;
        }
    }

    println!("Os {} primeiros números primos são: {:?}", limit, numbers);

    // Cria um iterador para o vetor, filtra os valores e gera um novo vetor.
    // Transformações podem ser combinadas em uma única iteração em collect().
    // O underscore (_) abaixo sinaliza para o compilador tentar inferir o tipo.
    let slice: Vec<_> = numbers.iter().filter(|&&x| x > 10 && x < 20).collect();
    println!("Entre 10 e 20 encontram-se: {:?}", slice);
}

Enumerações e casamento de padrões[editar | editar código-fonte]

Rust possui enumerações de tipagem forte, que podem carregar valores diversos. Casamento de padrões é muito importante em Rust, pois as enumerações são a base do tratamento de erros.[26] Exemplo de declaração de enumerações e o casamento de padrões:

enum Color {
    Red(u8), // Variantes podem carregar valores
    Green(u8),
    Blue(u8),
    Yellow,
    Magenta,
    Cyan,
    Azure,
    Violet,
    Rose,
    Orange,
    Chartreuse,
    SpringGreen,
}

fn main() {
    let color = Color::Red(25);
    match color {
        Color::Red(a) | Color::Green(a) | Color::Blue(a) => {
            println!("Cor primária. Alpha: {}%", a);
        }
        Color::Yellow | Color::Magenta | Color::Cyan => println!("Cor secundária."),
        _ => println!("Cor terciária."), // Demais cores
    }
}

O comando match também pode ser usado com outros tipos.[26] Exemplo:

fn main() {
    let age: u8 = 27; // u8 é um inteiro sem sinal de 8 bits

    // match pode retornar valores também
    let class = match age {
        0...4 => "bebê",
        5...13 => "criança",
        14...17 => "adolescente",
        _ => "adulto",
    }; // ponto-e-vírgula obrigatório quando usa retorno

    println!("Com {} ano(s) você é considerado {}", age, class);
}

Rust usa enumerações para representar a inexistência de um valor na forma de enum Option<T> { None, Some(T) }.[26] Exemplo:

fn main() {
    let website = Some("http://www.example.com"); // website: Option<&str>
    match website {
        Some(addr) => println!("Website: {}", addr),
        None => println!("Website não especificado."),
    }

    let num: Option<i8> = None; // i8 é um inteiro de 8 bits
    // Forma alternativa ao match
    if let Some(n) = num {
        println!("Número: {}", n);
    }

    if num.is_none() {
        println!("Número não especificado.");
    }
}

Tratamento de erros[editar | editar código-fonte]

Rust não possui exceções como em C++. Ao invés disso, possui duas representações de erros: recuperáveis e irrecuperáveis. Os erros recuperáveis são os esperados no fluxo normal de um programa, e são comunicados através do retorno de funções na forma de enum Result<T, E> { Ok(T), Err(E) }.[27] Exemplo:

use std::fs::File;
use std::io::Read; // Trait necessária para usar o método read_to_string()

fn main() {
    match File::open("arquivo.txt") {
        Ok(mut file) => { // Se o arquivo existir
            let mut txt = String::new();
            file.read_to_string(&mut txt).ok(); // ok() ignora o Result desta chamada
            println!("{}", txt);
        }
        Err(err) => println!("Erro: {}", err), // Se o arquivo não existir
    }
}

Os erros irrecuperáveis são usados para sinalizar problemas na lógica de um programa, como divisões por zero, e causam o encerramento do programa.[27] Exemplo:

fn main() {
    let num = 10 / 0; // "Pânico"
    panic!("Isto não deveria acontecer!"); // Alerta "pânico" manualmente
}

Rust permite recuperar de "pânicos" com a função especial std::panic::catch_unwind(), que não deve ser usada para emular o tratamento de exceções de C++.[27]

Exemplos[editar | editar código-fonte]

Programa Olá Mundo[editar | editar código-fonte]

Ver artigo principal: Programa Olá Mundo
fn main() {
    println!("Olá, Mundo!");
}

Pode ser compilado e executado com o seguinte comando:[28]

$ cargo run

Algoritmo de Trabb Pardo-Knuth[editar | editar código-fonte]

Ver artigo principal: Algoritmo de Trabb Pardo-Knuth
fn main() {
    let f = |t: f64| t.abs().sqrt() + 5.0 * t.powi(3);
    let mut a = [0f64; 11];

    for t in &mut a {
        let mut num = String::new();
        std::io::stdin().read_line(&mut num).ok();
        *t = num.trim().parse().unwrap();
    }

    for t in a.iter().rev() {
        match f(*t) {
            y if y > 400.0 || y.is_nan() => println!("Valor muito grande"),
            y => println!("{}", y)
        }
    }
}

Rust lida com transbordamento numérico retornando NAN.

Ver também[editar | editar código-fonte]

Referências

  1. a b «Releases · rust-lang/rust». github.com. Consultado em 15 de dezembro de 2017 
  2. «Appendix: Influences - The Rust Reference» (em inglês). The Rust Project Developers. Consultado em 7 de dezembro de 2017 
  3. a b «Rust Platform Support». forge.rust-lang.org (em inglês). Consultado em 15 de dezembro de 2017 
  4. «The Rust Language». Lambda the Ultimate. 8 de julho de 2010. Consultado em 30 de outubro de 2010 
  5. «The Rust Programming Language». Consultado em 21 de outubro de 2012 
  6. «Doc language FAQ». Consultado em 21 de outubro de 2012 
  7. Rediger, Jan-Erik (26 de novembro de 2017). «wasm32-unknown-unknown landed & enabled». www.hellorust.com. Consultado em 11 de dezembro de 2017 
  8. Gattozzi, Michael (5 de dezembro de 2017). «Rust and the case for WebAssembly in 2018». mgattozzi.com. Consultado em 11 de dezembro de 2017 
  9. «Announcing Rust 1.0 - The Rust Programming Language Blog». blog.rust-lang.org. Consultado em 12 de outubro de 2015 
  10. «Stack Overflow Developer Survey 2016 Results». Stack Overflow. Consultado em 11 de dezembro de 2017 
  11. «Stack Overflow Developer Survey 2017». Stack Overflow. Consultado em 11 de dezembro de 2017 
  12. «TIOBE Index». www.tiobe.com (em inglês). Consultado em 11 de dezembro de 2017 
  13. «Rust in 2016 - The Rust Programming Language Blog». blog.rust-lang.org. Consultado em 12 de outubro de 2015 
  14. «servo/servo». GitHub. Consultado em 12 de outubro de 2015 
  15. «Rust Means Never Having to Close a Socket». Inside Skylight. Consultado em 12 de outubro de 2015 
  16. «Fearless Concurrency with Rust - The Rust Programming Language Blog». blog.rust-lang.org. Consultado em 12 de outubro de 2015 
  17. http://www.stroustrup.com/ETAPS-corrected-draft.pdf
  18. «Abstraction without overhead: traits in Rust - The Rust Programming Language Blog». blog.rust-lang.org. Consultado em 12 de outubro de 2015 
  19. Aaron Turon (12 de dezembro de 2014). «Rust 1.0: Scheduling the trains» (em inglês). The Rust Project Developers. Consultado em 6 de setembro de 2017 
  20. «Release Channels - The Rust Programming Language» (em inglês). The Rust Project Developers. Consultado em 6 de setembro de 2017 
  21. «Cargo Guide» (em inglês). Consultado em 26 de setembro de 2017 
  22. a b «The Manifest Format» (em inglês). Consultado em 26 de setembro de 2017 
  23. «Documentation - The Rust Programming Language» (em inglês). 1 de outubro de 2016. Consultado em 26 de setembro de 2017 
  24. «Iterators - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 5 de dezembro de 2017 
  25. «Closures - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 5 de dezembro de 2017 
  26. a b c «Enums and Pattern Matching - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 2 de dezembro de 2017 
  27. a b c «Error Handling - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 2 de dezembro de 2017 
  28. «Hello, World! - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 6 de setembro de 2017 

Ligações externas[editar | editar código-fonte]