Rust (linguagem de programação) - Rust (programming language)

Ferrugem
Uma letra R maiúscula definida em uma roda dentada
O logotipo oficial da Rust
Paradigmas Multi-paradigma : concorrente , funcional , genérico , imperativo , estruturado
Projetado por Graydon Hoare
Desenvolvedor The Rust Foundation
Apareceu pela primeira vez 7 de julho de 2010 ; 11 anos atrás ( 07-07-2010 )
Versão estável
1.57.0  Edite isso no Wikidata / 2 de dezembro de 2021 ; 29 dias atrás ( 2 de dezembro de 2021 )
Disciplina de digitação Afim , inferido , nominal , estático , forte
Linguagem de implementação Ferrugem
Plataforma AMD64 , i686 , arm , AArch64 , armv7 , mips , mips64 , mipsel , mips64el , powerpc , powerpc64 , powerpc64le , risc-v , s390x , WebAssembly
SO Windows , Linux , macOS , FreeBSD , NetBSD , Illumos , Haiku , Android , Redox , iOS , Fuchsia
Licença MIT ou Apache 2.0
Extensões de nome de arquivo .rs, .rlib
Local na rede Internet www .rust-lang .org
Influenciado por
Influenciado

Rust é um multi-paradigma , linguagem de programação de uso geral projetado para desempenho e segurança , especialmente segura concorrência . Rust é sintaticamente semelhante ao C ++ , mas pode garantir a segurança da memória usando um verificador de empréstimo para validar as referências . A ferrugem atinge a segurança da memória sem coleta de lixo e a contagem de referência é opcional. Rust foi chamado de linguagem de programação de sistemas e, além de recursos de alto nível, como programação funcional , também oferece mecanismos para gerenciamento de memória de baixo nível .

Rust foi originalmente projetado por Graydon Hoare da Mozilla Research, com contribuições de Dave Herman, Brendan Eich e outros. Os designers refinaram a linguagem enquanto escreviam o mecanismo experimental do navegador Servo e o compilador Rust . Ele vem ganhando uso cada vez maior na indústria, e a Microsoft tem experimentado a linguagem para componentes de software seguros e críticos para a segurança.

Rust foi eleita a "linguagem de programação mais amada" na pesquisa de desenvolvedor Stack Overflow todos os anos desde 2016, embora tenha sido usada por apenas 7% dos entrevistados em 2021.

História

Um exemplo de compilar um programa Rust

A linguagem surgiu de um projeto pessoal iniciado em 2006 pelo funcionário da Mozilla Graydon Hoare. Hoare afirmou que o projeto possivelmente recebeu o nome de fungos da ferrugem e que o nome também é uma substring de "robusto". A Mozilla começou a patrocinar o projeto em 2009 e o anunciou em 2010. No mesmo ano, o trabalho mudou do compilador inicial (escrito em OCaml ) para um compilador de hospedagem própria baseado em LLVM escrito em Rust. Batizado de rustc , ele se compilou com sucesso em 2011.

A primeira versão pré-alfa numerada do compilador Rust ocorreu em janeiro de 2012. Rust 1.0, a primeira versão estável, foi lançada em 15 de maio de 2015. Após 1.0, as versões pontuais estáveis ​​são entregues a cada seis semanas, enquanto os recursos são desenvolvidos à noite Rust com lançamentos diários e, em seguida, testado com lançamentos beta que duram seis semanas. A cada 2 a 3 anos, uma nova "Edição" Rust é produzida. Isso é para fornecer um ponto de referência fácil para alterações devido à natureza frequente do cronograma de lançamento do Rust's Train, bem como para fornecer uma janela para fazer alterações significativas. As edições são amplamente compatíveis.

Junto com a tipagem estática convencional , antes da versão 0.4, o Rust também suportava estados tipográficos . O sistema de estado-tipo modelava asserções antes e depois das instruções do programa, por meio do uso de uma checkinstrução especial . Discrepâncias podem ser descobertas em tempo de compilação , em vez de em tempo de execução , como pode ser o caso com asserções em código C ou C ++. O conceito de estado tipográfico não era exclusivo do Rust, pois foi introduzido pela primeira vez na linguagem NIL . Os estados-tipo foram removidos porque, na prática, eram pouco usados, embora a mesma funcionalidade possa ser obtida aproveitando a semântica de movimentação de Rust .

O estilo do sistema de objetos mudou consideravelmente nas versões 0.2, 0.3 e 0.4 do Rust. A versão 0.2 introduziu classes pela primeira vez, e a versão 0.3 adicionou vários recursos, incluindo destruidores e polimorfismo através do uso de interfaces. No Rust 0.4, as características foram adicionadas como um meio de fornecer herança ; interfaces foram unificadas com características e removidas como um recurso separado. As classes também foram removidas e substituídas por uma combinação de implementações e tipos estruturados .

Começando no Rust 0.9 e terminando no Rust 0.11, o Rust tinha dois tipos de ponteiros embutidos : ~e @, simplificando o modelo de memória central . Ele reimplementou esses tipos de ponteiro na biblioteca padrão como Boxe (agora removido) Gc.

Em janeiro de 2014, antes do primeiro lançamento estável, Rust 1.0, o editor-chefe do Dr. Dobb , Andrew Binstock, comentou sobre as chances de Rust se tornar um concorrente do C ++ e de outras linguagens emergentes D , Go e Nim (então Nimrod). De acordo com Binstock, enquanto Rust era "amplamente visto como uma linguagem notavelmente elegante", a adoção diminuiu porque mudava repetidamente entre as versões.

Rust tem uma interface de função estrangeira (FFI) que pode ser chamada de, por exemplo, linguagem C, e pode chamar C. Embora chamar C ++ tenha sido historicamente desafiador (de qualquer linguagem), Rust tem uma biblioteca, CXX, para permitir a chamada para ou de C ++ e "CXX tem sobrecarga zero ou insignificante."

Em agosto de 2020, a Mozilla demitiu 250 de seus 1.000 funcionários em todo o mundo como parte de uma reestruturação corporativa causada pelo impacto de longo prazo da pandemia COVID-19 . Entre os demitidos estava a maior parte da equipe Rust, enquanto a equipe Servo foi completamente dissolvida. O evento levantou preocupações sobre o futuro do Rust.

Na semana seguinte, o Rust Core Team reconheceu o severo impacto das dispensas e anunciou que os planos para uma fundação Rust estavam em andamento. O primeiro objetivo da fundação seria assumir a propriedade de todas as marcas registradas e nomes de domínio e também assumir a responsabilidade financeira por seus custos.

Em 8 de fevereiro de 2021, a formação da Rust Foundation foi oficialmente anunciada por suas cinco empresas fundadoras ( AWS , Huawei , Google , Microsoft e Mozilla).

Em 6 de abril de 2021, o Google anunciou o suporte para Rust no Android Open Source Project como uma alternativa para C / C ++.

Sintaxe

Aqui está um "Olá, mundo!" programa escrito em Rust. A println! macro imprime a mensagem na saída padrão .

fn main() {
    println!("Hello, World!");
}

A sintaxe de oxidação é semelhante a C e C ++ , com blocos de código delimitado por chavetas , e o controlo de fluxo expressões, tais como if, else, while, e for, embora a sintaxe específicas para a definição de funções é mais semelhante ao Pascal . Apesar da semelhança sintática com C e C ++, a semântica do Rust é mais próxima da família de linguagens ML e da linguagem Haskell . Quase todas as partes do corpo de uma função são uma expressão , até mesmo os operadores de fluxo de controle. Por exemplo, a ifexpressão comum também toma o lugar da condicional ternária de C , um idioma usado pelo ALGOL 60 . Como em Lisp , uma função não precisa terminar com uma returnexpressão: neste caso, se o ponto-e-vírgula for omitido, a última expressão na função cria o valor de retorno , conforme visto na seguinte implementação recursiva da função fatorial :

fn factorial(i: u64) -> u64 {
    match i {
        0 => 1,
        n => n * factorial(n-1)
    }
}

A seguinte implementação iterativa usa o ..=operador para criar um intervalo inclusivo:

fn factorial(i: u64) -> u64 {
    (2..=i).product()
}

Recursos mais avançados no Rust incluem o uso de funções genéricas para obter polimorfismo de tipo . A seguir está um programa Rust para calcular a soma de duas coisas, para as quais a adição é implementada, usando uma função genérica:

use std::ops::Add;

fn Sum<T: Add<Output = T> + Copy> (num1: T, num2: T) -> T {
    num1 + num2
}

fn main() {
    let result1 = Sum(10,20);
    println!("Sum is: {:?}", result1);
    
    let result2 = Sum(10.23,20.45);
    println!("Sum is: {:?}", result2);
}

Recursos

Uma apresentação sobre Rust por Emily Dunham da equipe Rust da Mozilla ( conferência linux.conf.au , Hobart, 2017)

Rust tem como objetivo ser uma linguagem para sistemas altamente simultâneos e seguros e para programação em grande escala , ou seja, criando e mantendo limites que preservam a integridade de sistemas grandes. Isso levou a um conjunto de recursos com ênfase em segurança, controle de layout de memória e simultaneidade .

Segurança de memória

Rust é projetado para ser seguro para a memória . Ele não permite ponteiros nulos , ponteiros pendentes ou corridas de dados . Os valores dos dados podem ser inicializados apenas por meio de um conjunto fixo de formulários, todos os quais exigem que suas entradas já tenham sido inicializadas. Para replicar ponteiros sendo válidos ou NULL, como em uma lista vinculada ou estruturas de dados de árvore binária , a biblioteca principal do Rust fornece um tipo de opção , que pode ser usado para testar se um ponteiro tem o valor ou . Rust adicionou sintaxe para gerenciar tempos de vida , que são verificados em tempo de compilação pelo verificador de empréstimo . O código inseguro pode subverter algumas dessas restrições usando a palavra - chave. SomeNoneunsafe

Gerenciamento de memória

Rust não usa coleta de lixo automatizada . A memória e outros recursos são gerenciados por meio da convenção de inicialização de aquisição de recursos , com contagem de referência opcional . Rust fornece gerenciamento determinístico de recursos, com sobrecarga muito baixa . A ferrugem favorece a alocação de valores da pilha e não executa o encaixotamento implícito .

Existe o conceito de referências (usando o &símbolo), que não envolve a contagem de referência em tempo de execução. A segurança de tais ponteiros é verificada em tempo de compilação, evitando ponteiros pendurados e outras formas de comportamento indefinido . O sistema de tipos de Rust separa ponteiros compartilhados e imutáveis ​​do formulário &Tde ponteiros únicos e mutáveis ​​do formulário &mut T. Um ponteiro mutável pode ser forçado a um ponteiro imutável, mas não vice-versa.

Propriedade

Rust tem um sistema de propriedade em que todos os valores têm um proprietário único e o escopo do valor é o mesmo que o escopo do proprietário. Os valores podem ser passados ​​por referência imutável, usando &T, por referência mutável, usando &mut T, ou por valor, usando T. Em todos os momentos, pode haver várias referências imutáveis ​​ou uma referência mutável (um bloqueio leitor-gravador implícito ). O compilador Rust impõe essas regras em tempo de compilação e também verifica se todas as referências são válidas.

Tipos e polimorfismo

O sistema de tipos do Rust suporta um mecanismo chamado traits , inspirado nas classes de tipos da linguagem Haskell . Traits anotam tipos e são usados ​​para definir o comportamento compartilhado entre diferentes tipos: por exemplo, floats e inteiros podem implementar um traço "Adicionar" porque ambos podem ser adicionados; e qualquer tipo que possa ser impresso como string implementa os traços "Display" ou "Debug". Essa facilidade é conhecida como polimorfismo ad hoc .

Rust usa inferência de tipo para variáveis ​​declaradas com a palavra - chavelet . Essas variáveis ​​não requerem que um valor seja atribuído inicialmente para determinar seu tipo. Um erro de tempo de compilação ocorre se qualquer ramificação do código deixar a variável sem uma atribuição. Variáveis ​​atribuídas várias vezes devem ser marcadas com a palavra-chave mut(abreviação de mutável).

Uma função pode receber parâmetros genéricos , o que permite que a mesma função seja aplicada a diferentes tipos. As funções genéricas podem restringir o tipo genérico para implementar uma determinada característica ou características; por exemplo, uma função "adicionar um" pode exigir que o tipo implemente "Adicionar". Isso significa que uma função genérica pode ser verificada por tipo assim que for definida.

A implementação de genéricos Rust é semelhante à implementação típica de modelos C ++: uma cópia separada do código é gerada para cada instanciação. Isso é chamado de monomorfização e contrasta com o esquema de eliminação de tipo normalmente usado em Java e Haskell. O apagamento de tipo de Rust também está disponível usando a palavra-chave dyn. O benefício da monomorfização é o código otimizado para cada caso de uso específico; a desvantagem é o aumento do tempo de compilação e do tamanho dos binários resultantes.

No Rust, os tipos definidos pelo usuário são criados com a structpalavra - chave. Esses tipos geralmente contêm campos de dados como objetos ou classes em outras linguagens. A implpalavra-chave pode definir métodos para a estrutura (dados e funções são definidos separadamente em uma estrutura) ou implementar uma característica para a estrutura. Um traço é um contrato em que uma estrutura possui determinados métodos exigidos implementados. Os traços são usados ​​para restringir parâmetros genéricos e porque os traços podem fornecer uma estrutura com mais métodos do que o definido pelo usuário. Por exemplo, a característica Iteratorrequer que o nextmétodo seja definido para o tipo. Uma vez que o nextmétodo é definido, a característica fornece métodos auxiliares funcionais comuns sobre o iterador como mapou filter.

O sistema de objetos dentro do Rust é baseado em implementações, características e tipos estruturados. As implementações cumprem uma função semelhante às classes em outras linguagens e são definidas com a palavra-chave impl. As características fornecem herança e polimorfismo; eles permitem que métodos sejam definidos e combinados com as implementações. Tipos estruturados são usados ​​para definir campos. Implementações e características não podem definir campos por si mesmas, e apenas características podem fornecer herança. Entre outros benefícios, isso evita o problema do diamante de herança múltipla , como no C ++. Em outras palavras, o Rust oferece suporte à herança de interface, mas substitui a herança de implementação pela composição ; veja composição sobre herança .

Componentes

O Rust apresenta um grande número de componentes que estendem o conjunto de recursos do Rust e tornam o desenvolvimento do Rust mais fácil. A instalação de componentes é normalmente gerenciada por rustup, um instalador de conjunto de ferramentas Rust desenvolvido pelo projeto Rust.

Carga

Cargo é o sistema de construção e gerenciador de pacotes do Rust . Cargo lida com o download de dependências e a construção de dependências. Cargo também atua como um invólucro para clippy e outros componentes Rust. Requer que os projetos sigam uma certa estrutura de diretório.

As dependências de um pacote Rust são especificadas em um Cargo. arquivo toml junto com os requisitos de versão , informando ao Cargo quais versões da dependência são compatíveis com o pacote. Por padrão, o Cargo origina suas dependências do registro crates.io contribuído pelo usuário, mas os repositórios Git e os pacotes no sistema de arquivos local também podem ser especificados como dependências.

Rustfmt

Rustfmt é um formatador de código para Rust. Ele usa o código-fonte do Rust como entrada e altera o espaço em branco e a indentação para produzir o código formatado de acordo com o guia de estilo do Rust ou as regras especificadas em um arquivo rustfmt.toml. Rustfmt pode ser chamado como um programa independente ou em um projeto Rust por meio do Cargo.

Clippy

Clippy é a ferramenta de linting embutida do Rust para melhorar a exatidão, o desempenho e a legibilidade do código do Rust. Ele foi criado em 2014 e recebeu o nome do recurso de mesmo nome do Microsoft Office . Em 2021, o Clippy tinha mais de 450 regras, que podem ser navegadas online e filtradas por categoria. Algumas regras estão desabilitadas por padrão.

RLS

RLS é um servidor de linguagem que fornece IDEs e editores de texto com mais informações sobre um projeto Rust. Ele fornece linting cheques via Clippy , formatação via Rustfmt, automática conclusão de código via Racer , entre outras funções. O desenvolvimento do Racer foi desacelerado em favor do analisador de ferrugem .

Extensões de linguagem

É possível estender a linguagem Rust usando o mecanismo macro procedural.

Macros procedurais usam funções Rust que são executadas em tempo de compilação para modificar o fluxo de tokens do compilador. Isso complementa o mecanismo de macro declarativo (também conhecido como macros, por exemplo ), que usa correspondência de padrões para atingir objetivos semelhantes.

As macros procedurais vêm em três opções:

  • Macros semelhantes a funções custom!(...)
  • Derive macros #[derive(CustomDerive)]
  • Macros de atributos #[custom_attribute]

A println!macro é um exemplo de macro semelhante a uma função e serde_deriveé uma biblioteca comumente usada para gerar código para ler e gravar dados em muitos formatos, como JSON . Macros de atributos são comumente usados para ligações de linguagem, como a extendrbiblioteca para ligações de ferrugem para R .

Os seguintes mostra o código do uso do Serialize, Deserializee Debugderivar macros processuais para implementar JSON leitura e escrita, bem como a capacidade de formatar uma estrutura para a depuração.

use serde_json::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let point = Point { x: 1, y: 2 };

    let serialized = serde_json::to_string(&point).unwrap();
    println!("serialized = {}", serialized);

    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
    println!("deserialized = {:?}", deserialized);
}

Desempenho

O Rust visa "ser tão eficiente e portátil quanto o C ++ idiomático , sem sacrificar a segurança". Como o Rust utiliza o LLVM , quaisquer melhorias de desempenho no LLVM também são transferidas para o Rust.

Adoção

Um ícone de caranguejo laranja brilhante
Alguns usuários do Rust referem-se a si próprios como Rustáceos (um trocadilho com crustáceos ) e usam o Ferris como seu mascote não oficial.


Rust foi adotado por grandes empresas de engenharia de software. Por exemplo, o Dropbox agora é escrito em Rust, bem como alguns componentes na Amazon , Facebook , Discord e Mozilla Foundation . Rust foi a terceira linguagem de programação mais amada na pesquisa anual Stack Overflow de 2015 e ficou em primeiro lugar em 2016–2021.

Navegadores e serviços da web

  • OpenDNS usa Rust em dois de seus componentes.
  • Figma , um editor de gráficos vetoriais baseado na web, foi escrito em Rust.

Sistemas operacionais

  • Redox é um "sistema operacional semelhante ao Unix desenvolvido", incluindo um microkernel escrito em Rust.
  • Teseu, um sistema operacional experimental com "design intralingual", foi escrito em Rust.
  • O sistema operacional baseado em capacidade do Google Fuchsia possui algumas ferramentas escritas em Rust.
  • exa é uma alternativa de linha de comando do Unix / Linux ao ls escrito em Rust.

Outros projetos e plataformas notáveis

  • O Discord usa Rust para partes de seu back-end, bem como codificação de vídeo do lado do cliente, para aumentar a infraestrutura central escrita em Elixir .
  • O Microsoft Azure IoT Edge, uma plataforma usada para executar serviços do Azure e inteligência artificial em dispositivos IoT, tem componentes implementados no Rust.
  • Amethyst e Bevy são motores de jogo baseados em dados construídos em Rust.
  • Ruffle é um emulador SWF de código aberto escrito em Rust.

Governança

Rust Foundation
Rust Foundation logo.png
Formação 8 de fevereiro de 2021 ; 10 meses atrás ( 2021-02-08 )
Fundadores
Modelo Organização sem fins lucrativos
Localização
Shane Miller
Rebecca Rumbul
Local na rede Internet Foundation .rust-lang .org

A Rust Foundation é uma organização sem fins lucrativos constituída em Delaware , Estados Unidos , com o objetivo principal de apoiar a manutenção e o desenvolvimento da linguagem, cultivando os membros da equipe do projeto Rust e as comunidades de usuários, gerenciando a infraestrutura técnica subjacente ao desenvolvimento do Rust , e gerenciar e administrar a marca Rust.

Foi criada em 8 de fevereiro de 2021, com cinco membros corporativos fundadores (Amazon Web Services, Huawei, Google, Microsoft e Mozilla). O conselho da fundação é presidido por Shane Miller. A partir do final de 2021, seu Diretor Executivo e CEO é Rebecca Rumbul. Antes disso, Ashley Williams foi diretor executivo interino.

Desenvolvimento

As conferências sobre ferrugem incluem:

  • RustConf: uma conferência anual em Portland, Oregon . Realizado anualmente desde 2016 (exceto em 2020 e 2021 por causa da pandemia COVID-19 ).
  • Rust Belt Rust: uma conferência #rustlang no Rust Belt
  • RustFest: conferência @rustlang da Europa
  • RustCon Asia
  • Rust LATAM
  • Oxidize Global

Veja também

Notas

Referências

links externos