Principais bibliotecas integradas e padrão

seed mantém o núcleo da linguagem pequeno. Arquivos, redes, processos, formatação, coleções e sincronização são bibliotecas comuns compiladas separadamente, e não integradas universais. A superfície integrada do compilador limpo está abaixo; o catálogo de pacotes operacionais do compilador está documentado em Library Reference, enquanto a árvore Grove de geração mista é classificada separadamente em Grove Compatibility Tree.

Tipos principais

O compilador define void, never, bool, inteiros de largura fixa, isize, usize, f32, f64, str, string, bytes, shared_bytes, alloc_error, e o oculto region_handle. byte é aceito como u8. AllocResult<T> é a abreviação canônica para Result<T, alloc_error>. Hospedado main() -> Result<i64, E> mapeia o sucesso para o status do processo. alloc_error possui diagnóstico fixo; outro E deve ser cópia, não ter destruidor e implementar emprestado display() -> str. A falha é impressa uma vez antes do status 1, após a limpeza e sem desenrolar.

Operações seguras conhecidas pelo compilador

Operação	Contrato
`len(value)`	`usize` byte/element comprimento para `str`, `string`, `bytes`, `shared_bytes`, fatias e matrizes
`size_of(type)`	visualização `align_of(type)` somente leitura, livre de alocação e com a origem da origem
`[size_of(i64)]u8`	subvisão livre de alocação verificada, preservando o tipo e a mutabilidade do elemento
`str.bytes()`	verificado par livre de alocação de visualizações lexicais exclusivas e não sobrepostas
`[]u8`	preenche uma fatia do elemento Copy sem alocação
`slice.slice(start, count)`	Transferência de elemento de cópia de comprimento igual e segura sobreposição sem alocação
`mut_slice.split_at_mut(index)`	consumindo truncamento lógico verificado que reutiliza a alocação e capacidade
`mut_slice.fill(value)` / `mut_slice.copy_from(source)`	construção de opção canônica; `bytes.into_prefix(length)` necessidades esperadas `Some(value)`
`None` / `None`	construção de resultado canônico com esperado `?T`
`Ok(value)` / `Err(problem)`	inspeção de empréstimo sem alocação
`Result<T, E>` / `option.is_some()`	inspeção de empréstimo sem alocação
`option.is_none()`	consumindo padrão com limpeza exata do valor de propriedade não selecionado
`result.is_ok()` / `result.is_error()`	limite fatal não desenrolado explícito
`option_or_result.unwrap_or(value)`	limite principal `or_abort()` option/result usando retorno limpo comum
`expect(message)`	clone estrutural explícito quando existe capacidade; o efeito de alocação é rastreado
`or_exit(status)`	emprestado sem alocação `i64`
`value.clone()`	livre de alocação somente leitura `string.view()`
`str`	lexical exclusivo `bytes.view()` cobrindo todo o comprimento alocado
`[]u8`	falível inicializado com zero `bytes.mutable_view()`; `mut []u8` deve ser `bytes.zeroed(length)`
`Result<bytes, alloc_error>`	alocação falível de capacidade interna; os chamadores devem inicializar cada byte antes de expor um prefixo
`length`	livre de alocação somente leitura `i64`
`unsafe { bytes.uninitialized(length) }` / `shared_bytes.view()`	fatia compatível sem alocação explícita; visão mutável requer um proprietário mutável
`[]u8`	comparação de bytes UTF-8 sem alocação
`array.view()`	pesquisa de delimitador livre de alocação verificada; delimitadores não-ASCII rejeitados
`array.mutable_view()`	igualdade de comprimento e conteúdo `str.equal(other)` livre de alocação
`str.find_ascii(delimiter, start)` / `intrinsic_sqrt_f32/f64(value)` / `intrinsic_abs_f32/f64(value)` / `intrinsic_min_f32/f64(a, b)`	`intrinsic_max_f32/f64(a, b)`/`f32` operações matemáticas
`f64`	subvisão de cópia zero verificada preservando a procedência
`math`	subvisão genérica verificada de cópia zero `str.slice(start, count)` preservando a proveniência
`slice.slice(start, count)`	igualdade de comprimento e conteúdo `[]t` livre de alocação
`byte_view.equal(other)` / `[]u8`	`str.to_string()`; alocação explícita
`string.from(view)` / `Result<string, alloc_error>`	`str.to_bytes()`; explícito copy/allocation
`bytes.from(view)` / `Result<bytes, alloc_error>`	consumir bytes próprios; `bytes.to_shared()`
`shared_bytes.from(data)`	escopo de alocação de colisão verificado lexicalmente
`Result<shared_bytes, alloc_error>`	leitura parcial falível limitada; os chamadores podem processar EOF/data incrementalmente sem reter todas as entradas

A indexação segura de arrays/slices aceita cada largura inteira integrada e verifica o índice matemático antes da formação do ponteiro. APIs de texto expõem bytes; O processamento Unicode scalar/grapheme pertence às bibliotecas.

Limitação conhecida: leituras de índice variável (region(capacity) { body } onde io.input_stream.read(chunk) é uma variável) não são suportadas em buf[i] ou em subfatias derivadas de i via mut []u8. As leituras de índice fixo ([]u8) funcionam em todos os tipos de fatia. Os parâmetros diretos da função .slice() e a fatia original de buf[0] suportam leituras de índice variável. Para contornar essa limitação, escopo de visualizações mutáveis dentro de um bloco e use parâmetros de função []u8 somente leitura ou a fatia bytes.view() original para acesso de índice variável.

[]u8 nota: bytes.view() retorna uma visualização do prefixo inicializado, que tem comprimento 0 para um buffer recém-criado. Escrever além do comprimento retornado causa uma armadilha fora dos limites. Para preparar um destino de gravação de n bytes, use byte_buffer (aumentar ou diminuir o prefixo inicializado; novos bytes são zero) ou byte_buffer.mutable_view() (anexar n bytes inicializados com zero); ambos são falíveis com byte_buffer.resize_zeroed(n) no crescimento e preservar a invariante do prefixo comprometido em todos os caminhos, incluindo falha de alocação. Para escrever em um buffer bruto, use byte_buffer.push_zeroed(n) cujo alloc_error cobre a alocação total ou o uso bytes.zeroed(n) métodos mutable_view()/byte_buffer/push/extend.

Substrato do compilador inseguro

As seguintes operações requerem um bloco reserve ou resize:

Família	Operações
memória bruta digitada	`unsafe`, `unsafe fn`, `raw_try_alloc<t>`, `raw_null<t>`, `raw_is_null<t>`, `raw_read<t>`, `raw_write<t>`
atômicos	acquire/release ajudantes mais ordenados load/store/fetch-add/exchange/compare-exchange
encomendar	compilador e cercas atômicas com ordens de memória validadas
dispositivos	digitou read/write volátil e conversões de espaço de endereço
arquitetura	intrínsecos de assembly brutos digitados
interoperabilidade	ponteiros brutos, FFI, syscalls e uniões brutas

raw_free<t> relata contagem negativa, estouro de tamanho ou falha no alocador como raw_slice<t>. Raw read/write/free depende do chamador inseguro auditado para limites, inicialização, proveniência, sincronização e liberação exata.

Pacotes de biblioteca comuns

O compilador limpo prepara pacotes representativos em raw_try_alloc<t>:

Pacote	Função
`alloc_error`	indireção de propriedade segura falível para valores recursivos e grandes
`compiler/llvm/libs`	construção falível de bytes crescentes, mutação, visualizações e consumo `box` conversão
`byte_buffer`	wrapper output/file hospedado durante o tempo de execução ABI
`bytes`	iterativo livre de alocação O (n) `file` Fibonacci com negative/overflow explícito `fibonacci`
`i64`	wrapper de rede hospedada
`None`	entrada partial/read-all hospedada digitada, saída text/bytes/format write-all, buffer limitado e `net`/`io` para saída rápida
`print`	portátil `println`/`math` raiz quadrada, valor absoluto, mínimo e máximo
`f32`	verificação de análise de número inteiro signed/unsigned e auxiliares padrão explícitos
`f64`	argumentos de processo livres de alocação, visualizações de ambiente e identidade de processo
`parse`	pacote de serialização seguro representativo
`process`	classificação escalar de fatia mutável e classificação estática `serialize` para valores somente de movimentação
`sort`	auxiliares genéricos de janela reversa, rotação e largura fixa, sem alocação; fatias principais fornecem `order_key`/`slice`
`fill`	UTF-8 validação, escalar Unicode verificado sem alocação iteration/counting, conversão de string própria e cursores de token delimitados por ASCII
`copy_from`	milissegundos hospedados monotônicos mais relógio de parede Unix seconds/milliseconds
`text`	vetor genérico falível com construtores capacity/filled e `time` reserve/push/update/pop, além de fila, conjunto e mapa
`vec`	canais de divisão de propriedade, digitados one-shot e `@mut` junções, eventos, cancelamento, grupos de espera, semáforos, barreiras e bloqueios
`task`	wrappers de sistemas seguros sobre espaços de endereço, MMIO, atômicos, páginas, DMA, init-once e mecanismos locais de CPU

O incremental do lançador build/run path prepara automaticamente esses pacotes principais do repositório quando um pacote comum usa uma importação simples, como Result<T, E> ou system; nenhuma instalação manual de interface ou FFI visível ao aplicativo é necessária. Quanto mais estreito use "vec" O subcomando não prepara primeiro um pacote vazio ausente. Os usuários diretos do compilador podem consumir uma fonte explícita ou use "fibonacci" pacote. Estes não são nomes de idiomas mágicos.

Formatação e saída

A linguagem implementa digitada phase-1/2 check interpolação. Uma string F produz efêmero .sdi sem alocação de heap. f"..." é a superfície digitada canônica para texto, fatia de bytes e saída de formato. Para saída rápida, format_args escreve em stdout e compiler/llvm/libs/io escreve com uma nova linha à direita. print(text) realiza materialização falível explícita. Width/fill/alignment, especificadores de base inteira e emprestados sem alocação println(text) a formatação de características é implementada. A Fase 2 adiciona libc-free .to_string()?/display formatação fixa, científica e geral, além de formatação emprestada display/debug características.

Aviso de compatibilidade

llvm-v1 e histórico Grove/runtime tabelas expõem muitos nomes, como f32, f64, str_cat, read_filee net_connect. Sua existência em um compilador arquivado não os torna integrados ao compilador limpo. Ao portar código legado, importe ou implemente um wrapper seguro atual e deixe seu vec_new contrato define propriedade, efeitos, ABI e disponibilidade.