Glossário

A seguir, há um glossário que tem como objetivo fornecer uma definição breve de muitos termos de Rust. Para traduções, isso também serve para conectar o termo de volta ao original em inglês.

• alocar:
  Alocação dinâmica de memória no heap.
• argumento:
  Informação que é passada para uma função ou método.
• Rust bare-metal:
  Desenvolvimento de baixo nível em Rust, frequentemente implantado em um sistema sem um sistema operacional. Veja Rust bare-metal.
• bloco:
  Veja Blocos e escopo.
• empréstimo:
  Veja Empréstimo.
• verificador de empréstimo:
  A parte do compilador Rust que verifica se todos os empréstimos são válidos.
• chaves:
  { e }. Elas delimitam blocos.
• compilar:
  O processo de converter o código-fonte em código executável ou um programa usável.
• chamada:
  Para invocar ou executar uma função ou método.
• canal:
  Usado para passar mensagens com segurança entre threads.
• Comprehensive Rust 🦀:
  Os cursos aqui são chamados conjuntamente de Comprehensive Rust 🦀.
• concorrência:
  A execução de várias tarefas ou processos ao mesmo tempo.
• Concorrência em Rust:
  Veja Concorrência em Rust.
• constante:
  Um valor que não muda durante a execução de um programa.
• fluxo de controle:
  A ordem na qual as instruções individuais são executadas em um programa.
• falha (crash):
  Uma falha ou término inesperado e não tratado de um programa.
• enumeração:
  Um tipo de dado que contém uma das várias constantes nomeadas, possivelmente com uma tupla ou struct associada.
• erro:
  Uma condição ou resultado inesperado que desvia do comportamento esperado.
• tratamento de erro:
  O processo de gerenciar e responder a erros que ocorrem durante a execução do programa.
• exercício:
  Uma tarefa ou problema projetado para praticar e testar habilidades de programação.
• função:
  Um bloco de código reutilizável que executa uma tarefa específica.
• coletor de lixo:
  Um mecanismo que libera automaticamente a memória ocupada por objetos que não estão mais em uso.
• genéricos:
  Um recurso que permite escrever código com espaços reservados para tipos, possibilitando a reutilização de código com diferentes tipos de dados.
• imutável:
  Incapaz de ser alterado após a criação.
• teste de integração:
  Um tipo de teste que verifica as interações entre diferentes partes ou componentes de um sistema.
• palavra-chave:
  Uma palavra reservada em uma linguagem de programação que tem um significado específico e não pode ser usada como um identificador.
• biblioteca:
  Uma coleção de rotinas ou código pré-compilado que pode ser usado por programas.
• macro:
  Macros Rust podem ser reconhecidas por um ! no nome. Macros são usadas quando funções normais não são suficientes. Um exemplo típico é format!, que aceita um número variável de argumentos, o que não é suportado por funções Rust.
• função main:
  Programas Rust começam a executar a partir da função main.
• correspondência:
  Uma construção de fluxo de controle em Rust que permite a correspondência de padrões no valor de uma expressão.
• vazamento de memória:
  Uma situação em que um programa falha em liberar memória que não é mais necessária, levando a um aumento gradual no uso de memória.
• método:
  Uma função associada a um objeto ou a um tipo em Rust.
• módulo:
  Um espaço de nomes que contém definições, como funções, tipos ou traits, para organizar o código em Rust.
• mover:
  A transferência de propriedade de um valor de uma variável para outra em Rust.
• mutável:
  Uma propriedade em Rust que permite que variáveis sejam modificadas depois de terem sido declaradas.
• propriedade (ownership):
  O conceito em Rust que define qual parte do código é responsável por gerenciar a memória associada a um valor.
• pânico:
  Uma condição de erro irreversível em Rust que resulta no término do programa.
• parâmetro:
  Um valor que é passado para uma função ou método quando é chamado.
• padrão:
  Uma combinação de valores, literais ou estruturas que podem ser correspondidos a uma expressão em Rust.
• carga (payload):
  Os dados ou informações transportados por uma mensagem, evento ou estrutura de dados.
• programa:
  Um conjunto de instruções que um computador pode executar para realizar uma tarefa específica ou resolver um problema particular.
• linguagem de programação:
  Um sistema formal usado para comunicar instruções a um computador, como Rust.
• receptor:
  O primeiro parâmetro em um método Rust que representa a instância na qual o método é chamado.
• contagem de referências:
  Uma técnica de gerenciamento de memória na qual o número de referências a um objeto é rastreado, e o objeto é desalocado quando a contagem atinge zero.
• return:
  Uma palavra-chave em Rust usada para indicar o valor a ser retornado de uma função.
• Rust:
  Uma linguagem de programação de sistemas que se concentra em segurança, desempenho e concorrência.
• Fundamentos de Rust:
  Dias 1 a 4 deste curso.
• Rust no Android:
  Veja Rust no Android.
• Rust no Chromium:
  Veja Rust no Chromium.
• seguro (safe):
  Refere-se a código que adere às regras de propriedade e empréstimo de Rust, prevenindo erros relacionados à memória.
• escopo:
  A região de um programa onde uma variável é válida e pode ser usada.
• biblioteca padrão:
  Uma coleção de módulos que fornecem funcionalidades essenciais em Rust.
• static:
  Uma palavra-chave em Rust usada para definir variáveis estáticas ou itens com um tempo de vida 'static.
• string:
  Um tipo de dado que armazena dados textuais. Veja Strings para mais informações.
• estrutura (struct):
  Um tipo de dado composto em Rust que agrupa variáveis de diferentes tipos sob um único nome.
• test:
  Um módulo Rust contendo funções que testam a correção de outras funções.
• thread:
  Uma sequência de execução separada em um programa, permitindo execução concorrente.
• segurança de thread:
  A propriedade de um programa que garante comportamento correto em um ambiente multithread.
• trait:
  Uma coleção de métodos definidos para um tipo desconhecido, fornecendo uma maneira de alcançar polimorfismo em Rust.
• restrição de trait:
  Uma abstração onde você pode exigir que os tipos implementem alguns traits de seu interesse.
• tupla:
  Um tipo de dado composto em Rust que agrupa variáveis de diferentes tipos. Os campos da tupla não têm nomes e são acessados por seus números ordinais.
• tipo:
  Uma classificação que especifica quais operações podem ser realizadas em valores de um tipo particular em Rust.
• inferência de tipo:
  A capacidade do compilador Rust de deduzir o tipo de uma variável ou expressão.
• comportamento indefinido:
  Ações ou condições em Rust que não têm um resultado especificado, frequentemente levando a comportamento imprevisível do programa.
• união (union):
  Um tipo de dado que pode conter valores de diferentes tipos, mas apenas um de cada vez.
• teste unitário:
  Rust vem com suporte embutido para executar pequenos testes unitários e testes de integração maiores. Veja Testes Unitários.
• tipo unitário:
  Tipo que não contém dados, escrito como uma tupla sem membros.
• não seguro (unsafe):
  O subconjunto de Rust que permite que você acione comportamentos indefinidos. Veja Rust não seguro.
• variável:
  Uma localização de memória que armazena dados. Variáveis são válidas em um escopo.