Rust (linguagem de programação)
Rust | |
---|---|
![]() | |
Paradigma | Multiparadigma: concorrente, estruturada, funcional, genérica, imperativa |
Surgido em | 2010 (10–11 anos) |
Última versão | 1.49.0 (31 de dezembro de 2020[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, Limbo, Newsqueak, OCaml, Ruby, Scheme, Standard ML, Swift[2] |
Influenciou | Crystal, Elm, Idris, Nim, PHP,[3] SPARK, Swift, Verona, Zig |
Plataforma |
AArch64 (Linux), i686, x86-64[4]
ARM e AArch64, PowerPC e PPC64, i386, i586, MIPS e MIPS64, SPARC, RISC, S390x, asm.js, WebAssembly[4] |
Sistema operacional |
|
Licença: | MIT ou Apache 2.0[5] |
Extensão do arquivo: | .rs , .rlib
|
Página oficial | www |
Rust é uma linguagem de programação multiparadigma compilada desenvolvida pela Mozilla Research.[6] É projetada para ser "segura, concorrente e prática", mas diferente de outras linguagens seguras, Rust não usa coletor de lixo.[7][8] Possui suporte nativo ao WebAssembly.[9][10]
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.[11]
Foi considerada pelo público a linguagem "mais amada" por cinco anos consecutivos, de acordo com pesquisas conduzidas pelo site Stack Overflow de 2016 a 2020,[12][13][14][15][16] e está entre as 25 linguagens mais populares, de acordo com pesquisas conduzidas pela RedMonk desde 2018.[17][18][19]
DesignEditar
Rust se baseia nos seguintes princípios: segurança sem coletor de lixo, concorrência sem disputa de dados e abstração sem overhead.[20] 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[21] 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,[22] 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.[23]
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".[24] 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.[25] 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.[26][27][28]
Eventualmente a sintaxe da linguagem evolui, e novas palavras-chave podem ser adicionadas. Para evitar a quebra de compatibilidade com códigos antigos, novas edições são lançadas, que projetos antigos podem ativar opcionalmente.[29] Também é possível usar palavras-chave como identificadores, usando a seguinte sintaxe:[30]
// `match` é uma palavra-chave
fn r#match(needle: &str, haystack: &str) -> bool {
haystack.contains(needle)
}
Enumerações e casamento de padrõesEditar
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.[31] Exemplo de declaração de enumerações e o casamento de padrões:
enum Browser {
Chrome,
Firefox,
Safari,
Edge,
Ie(u8),
}
let browser = Browser::Ie(11);
match browser {
Browser::Chrome | Browser::Edge => println!("Chromium"),
Browser::Ie(version) => println!("Internet Explorer {}", version),
_ => println!("Outro navegador"),
}
O comando match
pode retornar valores e também pode ser usado com outros tipos.[31] Exemplo:
let age = 27;
let category = match age {
// `0..=4` é um padrão inclusivo (inclui 0, 1, 2, 3 e 4)
0..=4 => "bebê",
5..=13 => "criança",
14..=17 => "adolescente",
_ => "adulto",
};
println!("Com {} ano(s) você é considerado {}.", age, category);
Rust usa enumerações para representar a inexistência de um valor na forma de enum Option<T> { None, Some(T) }
.[31] Exemplo:
let website = Some("http://www.example.com"); // `website: Option<&str>`
match website {
None => println!("Website não especificado."),
Some(addr) => println!("Website: {}", addr),
}
// Forma alternativa
if let Some(addr) = website {
println!("Website: {}", addr);
}
Tratamento de errosEditar
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) }
.[32] Exemplo:
use std::fs::File;
use std::io::prelude::*;
fn main() {
match File::open("exemplo.txt") {
// Se o arquivo existir
Ok(mut file) => {
let mut txt = String::new();
file.read_to_string(&mut txt).ok();
println!("{}", txt);
}
// Se o arquivo não existir
Err(err) => eprintln!("Erro: {}", err),
}
}
É possível simplificar o código retornando os erros com o operador ?
:[32]
use std::fs::File;
use std::io::prelude::*;
// `type std::io::Result<T> = Result<T, std::io::Error>`
fn main() -> std::io::Result<()> {
let mut file = File::open("exemplo.txt")?;
let mut txt = String::new();
file.read_to_string(&mut txt)?;
println!("{}", txt);
Ok(()) // Retorna `()` como sucesso
}
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.[32] Exemplo:
let num = 10 / 0; // "Pânico"
panic!("Isto não deveria acontecer!"); // Alerta "pânico" manualmente
Rust permite recuperar de alguns "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++.[33]
Genéricos, tempo de vida, e posseEditar
Rust possui suporte a programação genérica[34] e o conceito de ownership[35] (posse). Valores podem ter apenas um dono; quando o dono sai de escopo, o valor é destruído. Valores podem ser emprestados (borrowing) ou movidos (move).[36] Em certas ocasiões, como em referências circulares, é necessário especificar o lifetime (tempo de vida) de uma referência.[37] Exemplo de uma árvore binária em Rust:
// `'a` é um lifetime, e `T` é um tipo genérico
#[derive(Debug)]
enum Tree<'a, T> {
Empty,
Node(T, &'a Tree<'a, T>, &'a Tree<'a, T>),
}
use Tree::{Empty, Node};
let tree = &Node(5.96, &Empty, &Node(1.0, &Empty, &Empty));
// O primeiro membro é movido; ignora demais membros
if let Node(value, ..) = tree {
println!("{:?}", value);
}
// Ignora o primeiro membro; o terceiro membro é emprestado
if let Node(_, left, ref right) = tree {
println!("-> {:?}", left);
println!("-> {:?}", right);
}
Rust é mais restrita que outras linguagens; um valor imutável pode ter várias referências, mas um valor mutável pode ter apenas uma. Para o segundo caso, é necessário usar uma das várias estruturas de referência como std::rc::Rc
(contagem de referências), std::cell::RefCell
(mutabilidade interna), entre outras.[38] Outra possibilidade é o uso de alocação de arena.[39]
Se houver ambiguidade na invocação de um método genérico, o tipo pode ser explicitado com o símbolo turbofish (::<>
).[40] Exemplo:
let dollar = "5.96".parse::<f64>().unwrap();
println!("US$ 1.00 = R$ {}", dollar);
TraçosEditar
Rust possui suporte a traços (traits) que podem ser implementados por estruturas, enumerações e uniões.[41][42] Traços podem ser deriváveis, como o Debug
, onde é gerado um código padrão para implementar o traço em um objeto marcado com o atributo #[derive(…)]
.[43] A implementação padrão é definida através de macros procedurais.[44] Exemplo de traços:
trait Animal {
fn walk(&self);
}
trait Feline: Animal {
// Traços podem fornecer definições padrões para métodos
fn meow(&self) {
println!("Miau!");
}
}
E para implementar os traços:[41]
struct Cat<'a> {
name: &'a str,
}
impl Animal for Cat<'_> {
fn walk(&self) {
println!("{} anda.", self.name);
}
}
impl Feline for Cat<'_> {}
// E o mesmo para `Dog`…
E a invocação dos métodos:[41]
let cat = Cat { name: "Charlotte" };
cat.walk(); // É um animal
cat.meow(); // É um felino
Estruturas, enumerações, uniões e funções podem especificar os traços dos membros/parâmetros de forma estática (genérica):[41]
fn make_walk<T>(animal: &T)
where
T: Animal,
{
animal.walk();
}
// Ou o equivalente:
fn make_walk<T: Animal>(animal: &T) {
animal.walk();
}
// Ou de forma mais compacta (incompatível com o turbofish):
fn make_walk(animal: &impl Animal) {
animal.walk();
}
Ou de forma dinâmica (trait objects):[42]
fn make_walk(animal: &dyn Animal) {
animal.walk();
}
Em ambos os casos a instância é passada da mesma maneira:[41][42]
let cat = Cat { name: "Charlotte" };
let dog = Dog { name: "Duke" };
make_walk(&cat);
make_walk(&dog);
Iteradores e clausurasEditar
Rust possui um literal para representar iteradores, e traz em sua biblioteca padrão métodos para transformá-los, usando clausuras.[45][46] No exemplo a seguir o programa lista os números primos entre 4 e 20:
let mut numbers = vec![];
// `4..=20` é um iterador inclusivo (inclui 20)
for i in 4..=20 {
// `2..i` é um iterador exclusivo, ex.: `2..5` inclui 2, 3 e 4.
// `|x| i % x != 0` é uma clausura que recebe `x` e retorna um booliano.
if (2..i).all(|x| i % x != 0) {
numbers.push(i);
}
}
println!("Os números primos entre 4 e 20 são: {:?}", numbers);
Clausuras podem capturar valores do ambiente de três maneiras: emprestando imutavelmente, mutavelmente ou movendo. A última é realizada com a palavra-chave move
.[46] Exemplo:
use std::thread;
let msg = "Olá, Mundo!".to_owned();
thread::spawn(move || {
println!("{}", msg); // `msg` movido aqui
});
As clausuras são representadas por três traços:[46]
Fn
– Empresta valores do ambiente imutavelmenteFnMut
– Empresta valores do ambiente mutavelmente; aceita também instâncias deFn
FnOnce
– Move os valores do ambiente e pode ser chamada apenas uma vez; aceita também instâncias deFn
eFnMut
Exemplo:
fn convert<F>(num: f64, handler: F) -> f64
where
F: FnOnce(f64) -> f64, // Assinatura da clausura
{
handler(num)
}
fn main() {
let y = convert(499.0, |num| num * 5.96);
println!("{}", y);
}
Clausuras possuem um tipo único, mesmo que com a mesma assinatura; por esse motivo, para retornar uma clausura de uma função, é necessário usar uma sintaxe especial:[41]
fn convert() -> impl FnOnce(f64) -> f64 {
move |num| num * 5.96
}
fn main() {
let f = convert();
println!("{}", f(499.0));
}
ExemplosEditar
Programa Olá MundoEditar
fn main() {
println!("Olá, Mundo!");
}
Pode ser compilado e executado com o seguinte comando:[47]
$ cargo run
Algoritmo de Trabb Pardo-KnuthEditar
use std::io::{stdin, BufRead};
fn f(t: f64) -> f64 {
t.abs().sqrt() + 5.0 * t.powi(3)
}
fn main() {
let mut a = [0f64; 11];
for (t, input) in a.iter_mut().zip(stdin().lock().lines()) {
*t = input.unwrap().parse().unwrap();
}
a.iter().enumerate().rev().for_each(|(i, &t)| match f(t) {
y if y > 400.0 => println!("{} TOO LARGE", i),
y => println!("{} {}", i, y),
});
}
Rust lida com transbordamento numérico retornando f64::NAN
.
ConcorrênciaEditar
Exemplo retirado da documentação oficial:[48]
use std::sync::mpsc::channel;
use std::thread;
fn main() {
let (tx, rx) = channel();
let sender = thread::spawn(move || {
tx.send("Olá, Mundo!".to_owned())
.expect("Não foi possível enviar para o canal");
});
let receiver = thread::spawn(move || {
let value = rx.recv().expect("Não foi possível receber do canal");
println!("{}", value);
});
sender.join().expect("O remetente entrou em pânico");
receiver.join().expect("O destinatário entrou em pânico");
}
FerramentasEditar
Cargo é a ferramenta de produtividade oficial, e usa arquivos TOML para listar dependências e configurações de um projeto. Um projeto pode ser testado usando o comando $ cargo test
.[49][50] A documentação de um projeto pode ser gerada a partir de comentários especiais em Markdown, usando o comando $ cargo doc
.[50][51]
Rust possui uma implementação do Language Server Protocol, o RLS, que fornece autocompletar, formatação e refatoração independente do editor de texto ou ambiente de desenvolvimento integrado. Uma implementação alternativa existe, o rust-analyzer. Os seguintes editores dão suporte ao RLS de forma nativa ou através de extensões/plugins:[52][53]
- Visual Studio Code – fornecido pela extensão oficial
- Sublime Text – fornecido pelo pacote oficial Rust Enhanced
- Atom – fornecido pelo pacote oficial ide-rust
- Visual Studio – fornecido por uma extensão
- Eclipse – fornecido pelo plugin Corrosion
- GNOME Builder – suporte nativo
Outras ferramentas dão suporte a Rust através de implementações próprias sem o uso do RLS:
- Vim – fornecido pelo plugin oficial rust.vim
- IntelliJ IDEA – fornecido pelo plugin IntelliJ Rust
- Emacs – fornecido pelo plugin oficial rust-mode
Software desenvolvido em RustEditar
- Navegadores web
- Rede
- Discord – um serviço de chat para gamers; Rust usado no servidor e no aplicativo[55]
- Tor – uma rede anônima; usa Rust em alguns componentes[56]
- OpenDNS – um serviço de DNS[57][58][59]
- Cloudflare Workers – CDN com WebAssembly[60]
- npm Registry – um serviço de hospedagem de dependências para Node.js[61]
- Sistemas operacionais
- Microsoft Windows – usa Rust em alguns componentes[62]
- Redox – um sistema operacional tipo Unix com micronúcleo[63]
- Stratis – um sistema de arquivos usado pelo Fedora e RHEL[64]
- Magic Pocket – sistema de armazenamento do Dropbox[65]
- Outros
- librsvg – um motor de renderização de SVG;[66][67] é usado pelo GNOME e pela Fundação Wikimedia[68]
- ripgrep – um substituto moderno do grep; é usado pelo Visual Studio Code[69]
- Deno – um substituto do Node.js desenvolvido pelo criador original[70]
- Xi – um editor de texto usado pelo Google Fuchsia[71][72]
- Diem – uma criptomoeda criada pelo Facebook[73][74]
Ver tambémEditar
Referências
- ↑ «Announcing Rust 1.49.0». blog.rust-lang.org (em inglês). 31 de dezembro de 2020. Consultado em 31 de dezembro de 2020
- ↑ «Appendix: Influences - The Rust Reference» (em inglês). The Rust Project Developers. Consultado em 29 de novembro de 2020
- ↑ Tovilo, Ilija (22 de maio de 2020). «PHP RFC: Match expression v2». wiki.php.net. Consultado em 29 de novembro de 2020
- ↑ a b c d «Rust Platform Support». forge.rust-lang.org (em inglês). Consultado em 19 de novembro de 2020
- ↑ «rust/COPYRIGHT at master · rust-lang/rust». github.com. Consultado em 21 de julho de 2018
- ↑ «The Rust Language». Lambda the Ultimate. 8 de julho de 2010. Consultado em 30 de outubro de 2010
- ↑ «The Rust Programming Language». Consultado em 21 de outubro de 2012
- ↑ «Doc language FAQ». Consultado em 21 de outubro de 2012
- ↑ Rediger, Jan-Erik (26 de novembro de 2017). «wasm32-unknown-unknown landed & enabled». www.hellorust.com. Consultado em 11 de dezembro de 2017
- ↑ Gattozzi, Michael (5 de dezembro de 2017). «Rust and the case for WebAssembly in 2018». mgattozzi.com. Consultado em 11 de dezembro de 2017
- ↑ «Announcing Rust 1.0 - The Rust Programming Language Blog». blog.rust-lang.org. Consultado em 12 de outubro de 2015
- ↑ «Stack Overflow Developer Survey 2016 Results». Stack Overflow. Consultado em 11 de dezembro de 2017
- ↑ «Stack Overflow Developer Survey 2017». Stack Overflow. Consultado em 11 de dezembro de 2017
- ↑ «Stack Overflow Developer Survey 2018». Stack Overflow. Consultado em 16 de abril de 2018
- ↑ «Stack Overflow Developer Survey 2019». Stack Overflow. Consultado em 9 de julho de 2019
- ↑ «Stack Overflow Developer Survey 2020». Stack Overflow. Consultado em 21 de julho de 2020
- ↑ O'Grady, Stephen (7 de março de 2018). «The RedMonk Programming Language Rankings: January 2018» (em inglês). RedMonk. Consultado em 13 de março de 2018
- ↑ O'Grady, Stephen (20 de março de 2019). «The RedMonk Programming Language Rankings: January 2019» (em inglês). RedMonk. Consultado em 9 de julho de 2019
- ↑ O'Grady, Stephen (28 de fevereiro de 2020). «The RedMonk Programming Language Rankings: January 2020» (em inglês). RedMonk. Consultado em 21 de julho de 2020
- ↑ «Rust in 2016 - The Rust Programming Language Blog». blog.rust-lang.org. Consultado em 12 de outubro de 2015
- ↑ «servo/servo». GitHub. Consultado em 12 de outubro de 2015
- ↑ «Rust Means Never Having to Close a Socket». Inside Skylight. Consultado em 12 de outubro de 2015
- ↑ «Fearless Concurrency with Rust - The Rust Programming Language Blog». blog.rust-lang.org. Consultado em 12 de outubro de 2015
- ↑ http://www.stroustrup.com/ETAPS-corrected-draft.pdf
- ↑ «Abstraction without overhead: traits in Rust - The Rust Programming Language Blog». blog.rust-lang.org. Consultado em 12 de outubro de 2015
- ↑ 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
- ↑ «Release Channels - The Rust Programming Language» (em inglês). The Rust Project Developers. Consultado em 6 de setembro de 2017
- ↑ «Releases · rust-lang/rust». github.com. Consultado em 15 de fevereiro de 2018
- ↑ «Appendix E: Editions - The Rust Programming Language» (em inglês). Consultado em 19 de outubro de 2020
- ↑ «Appendix A: Keywords - The Rust Programming Language» (em inglês). Consultado em 19 de outubro de 2020
- ↑ 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
- ↑ 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
- ↑ «Function std::panic::catch_unwind» (em inglês). The Rust Project Developers. Consultado em 15 de fevereiro de 2018
- ↑ «Generic Types, Traits, and Lifetimes - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 28 de julho de 2020
- ↑ «What is Ownership? - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 28 de julho de 2020
- ↑ «References and Borrowing - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 30 de agosto de 2020
- ↑ «Validating References with Lifetimes - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 23 de janeiro de 2021
- ↑ «RefCell<T> and the Interior Mutability Pattern - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 30 de agosto de 2020
- ↑ «Graphs and arena allocation | Rust for C++ Programmers» (em inglês). Consultado em 30 de agosto de 2020
- ↑ «Appendix B: Operators and Symbols - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 31 de dezembro de 2020
- ↑ a b c d e f «Traits: Defining Shared Behavior - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 30 de dezembro de 2020
- ↑ a b c «Using Trait Objects That Allow for Values of Different Types - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 30 de dezembro de 2020
- ↑ «Appendix C: Derivable Traits - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 23 de janeiro de 2021
- ↑ «Appendix D: Macros - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 23 de janeiro de 2021
- ↑ «Iterators - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 5 de dezembro de 2017
- ↑ a b c «Closures - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 5 de dezembro de 2017
- ↑ «Hello, World! - The Rust Programming Language, Second Edition» (em inglês). The Rust Project Developers. Consultado em 6 de setembro de 2017
- ↑ «std::thread - Rust». doc.rust-lang.org (em inglês). Consultado em 31 de agosto de 2020
- ↑ «Cargo Guide» (em inglês). Consultado em 26 de setembro de 2017
- ↑ a b «The Manifest Format» (em inglês). Consultado em 26 de setembro de 2017
- ↑ «Documentation - The Rust Programming Language» (em inglês). 1 de outubro de 2016. Consultado em 26 de setembro de 2017
- ↑ «Rust and IDEs». forge.rust-lang.org (em inglês). Consultado em 29 de março de 2018
- ↑ «Are we (I)DE yet?». areweideyet.com (em inglês). Consultado em 29 de março de 2018
- ↑ Herman, Dave (12 de julho de 2016). «Shipping Rust in Firefox» (em inglês). Mozilla. Consultado em 9 de agosto de 2020
- ↑ Howarth, Jesse (4 de fevereiro de 2020). «Why Discord is switching from Go to Rust» (em inglês). Discord. Consultado em 9 de agosto de 2020
- ↑ «The Wilmington Watch: A Tor Network Team Hackfest» (em inglês). blog.torproject.org. 5 de julho de 2017. Consultado em 9 de agosto de 2020
- ↑ Balbaert, Ivo (27 de maio de 2015). Rust Essentials. [S.l.]: Packt Publishing. p. 6. ISBN 978-1785285769. Consultado em 9 de agosto de 2020
- ↑ Frank, Denis (5 de dezembro de 2013). «Using HyperLogLog to Detect Malware Faster Than Ever». OpenDNS Security Labs. Consultado em 9 de agosto de 2020
- ↑ Denis, Frank (4 de outubro de 2013). «ZeroMQ: Helping us Block Malicious Domains in Real Time». OpenDNS Security Labs. Consultado em 9 de agosto de 2020
- ↑ Pack, Steven (16 de outubro de 2018). «Serverless Rust with Cloudflare Workers» (em inglês). Cloudflare. Consultado em 9 de agosto de 2020
- ↑ «Community makes Rust an easy choice for npm» (PDF) (em inglês). The Rust Project Developers. 25 de fevereiro de 2019. Consultado em 9 de agosto de 2020
- ↑ «Using Rust in Windows - Microsoft Security Response Center» (em inglês). Microsoft. 7 de novembro 2019. Consultado em 9 de agosto de 2020
- ↑ Yegulalp, Serdar (21 de março de 2016). «Rust's Redox OS could show Linux a few new tricks» (em inglês). InfoWorld. Consultado em 9 de agosto de 2020
- ↑ «Fedora 29 new features: Startis now officially in Fedora». www.marksei.com (em inglês). 10 de outubro de 2018. Consultado em 9 de agosto de 2020
- ↑ Metz, Cade (14 de março 2016). «The Epic Story of Dropbox's Exodus From the Amazon Cloud Empire» (em inglês). Wired. Consultado em 9 de agosto de 2020
- ↑ Federico Mena Quintero (3 de janeiro de 2017). «Librsvg 2.41.0 is released». mail.gnome.org (em inglês). Consultado em 9 de agosto de 2020
- ↑ Federico Mena Quintero (9 de agosto de 2017). «Replacing C library code with Rust: What I learned with librsvg» (PDF). people.gnome.org (em inglês). Consultado em 9 de agosto de 2020
- ↑ «Image administration - MediaWiki» (em inglês). MediaWiki. Consultado em 9 de agosto de 2020
- ↑ «Visual Studio Code March 2017 (version 1.11) - Text search improvements». code.visualstudio.com (em inglês). Março de 2017. Consultado em 9 de agosto de 2020
- ↑ Ryan Dahl; Bert Belder; Bartek Iwańczuk (12 de maio de 2020). «Deno 1.0» (em inglês). Consultado em 9 de agosto de 2020
- ↑ Levien, Raph (23 de janeiro de 2018). «Xi: an editor for the next 20 years» (em inglês). Consultado em 9 de agosto de 2020
- ↑ «A modern editor with a backend written in Rust» (em inglês). Google. Consultado em 9 de agosto de 2020
- ↑ «Diem association» (em inglês). www.diem.com. Consultado em 20 de dezembro de 2020
- ↑ «GitHub - diem/diem: Diem's mission is to enable a simple global payment system and financial infrastructure that empowers billions of people.». github.com (em inglês). Consultado em 20 de dezembro de 2020
Ligações externasEditar
- Sítio oficial
- Rust no GitHub
- «The Rust Programming Language» (em inglês). Livro oficial
- «Rust Playground» (em inglês). Experimente Rust online