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
Última versão 1.20.0 (31 de agosto de 2017; há 0 dias)
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, Standard ML, Swift
Influenciou Swift, Idris
Licença: Licença MIT
Página oficial rust-lang.org

Rust é uma linguagem de programação multi-paradigma compilada desenvolvida pela Mozilla Research.[1] É projetada para ser "segura, concorrente e prática",[2][3] suportando os estilos puramente funcional, procedural, e orientado a objetos.

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.[4]

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.[5] Estes princípios fazem com que Rust seja rápida para ser usada em aplicações de baixo nível como o browser Servo[6] 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,[7] 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.[8]

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".[9] 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.[10] Tipos genéricos são utilizados extensamente.

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

Canais de lançamento[editar | editar código-fonte]

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.[14][15][16]

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:[17]

$ 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. «The Rust Language». Lambda the Ultimate. 8 de julho de 2010. Consultado em 30 de outubro de 2010 
  2. «The Rust Programming Language». Consultado em 21 de outubro de 2012 
  3. «Doc language FAQ». Consultado em 21 de outubro de 2012 
  4. «Announcing Rust 1.0 - The Rust Programming Language Blog». blog.rust-lang.org. Consultado em 12 de outubro de 2015 
  5. «Rust in 2016 - The Rust Programming Language Blog». blog.rust-lang.org. Consultado em 12 de outubro de 2015 
  6. «servo/servo». GitHub. Consultado em 12 de outubro de 2015 
  7. «Rust Means Never Having to Close a Socket». Inside Skylight. Consultado em 12 de outubro de 2015 
  8. «Fearless Concurrency with Rust - The Rust Programming Language Blog». blog.rust-lang.org. Consultado em 12 de outubro de 2015 
  9. http://www.stroustrup.com/ETAPS-corrected-draft.pdf
  10. «Abstraction without overhead: traits in Rust - The Rust Programming Language Blog». blog.rust-lang.org. Consultado em 12 de outubro de 2015 
  11. «Cargo Guide» (em inglês). Consultado em 26 de setembro de 2017 
  12. a b «The Manifest Format» (em inglês). Consultado em 26 de setembro de 2017 
  13. «Documentation - The Rust Programming Language» (em inglês). 1 de outubro de 2016. Consultado em 26 de setembro de 2017 
  14. 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 
  15. «Release Channels - The Rust Programming Language» (em inglês). The Rust Project Developers. Consultado em 6 de setembro de 2017 
  16. «Releases · rust-lang/rust». github.com. Consultado em 6 de setembro de 2017 
  17. «Hello, World! - The Rust Programming Language» (em inglês). The Rust Project Developers. Consultado em 6 de setembro de 2017 

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