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. alloc_result<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
`str.bytes()`	visualização `[]u8` somente leitura, livre de alocação e com a origem da origem
`slice.slice(start, count)`	subvisão livre de alocação verificada, preservando o tipo e a mutabilidade do elemento
`mut_slice.split_at_mut(index)`	verificado par livre de alocação de visualizações lexicais exclusivas e não sobrepostas
`mut_slice.fill(value)`	preenche uma fatia do elemento Copy sem alocação
`mut_slice.copy_from(source)`	Transferência de elemento de cópia de comprimento igual e segura sobreposição sem alocação
`bytes.into_prefix(length)`	consumindo truncamento lógico verificado que reutiliza a alocação e capacidade
`some(value)` / `none`	construção de opção canônica; `none` necessidades esperadas `?t`
`result.ok(value)` / `result.error(problem)`	construção de resultado canônico com esperado `result<t,e>`
`option.is_some()` / `option.is_none()`	inspeção de empréstimo sem alocação
`result.is_ok()` / `result.is_error()`	inspeção de empréstimo sem alocação
`option_or_result.unwrap_or(value)`	consumindo padrão com limpeza exata do valor de propriedade não selecionado
`or_abort()` / `expect(message)`	limite fatal não desenrolado explícito
`or_exit(status)`	limite principal `i64` option/result usando retorno limpo comum
`value.clone()`	clone estrutural explícito quando existe capacidade; o efeito de alocação é rastreado
`string.view()`	emprestado sem alocação `str`
`bytes.view()`	livre de alocação somente leitura `[]u8`
`bytes.mutable_view()`	lexical exclusivo `mut []u8` cobrindo todo o comprimento alocado
`bytes.zeroed(length)`	falível inicializado com zero `result<bytes, alloc_error>`; `length` deve ser `i64`
`unsafe { bytes.uninitialized(length) }`	alocação falível de capacidade interna; os chamadores devem inicializar cada byte antes de expor um prefixo
`shared_bytes.view()`	livre de alocação somente leitura `[]u8`
`array.view()` / `array.mutable_view()`	fatia compatível sem alocação explícita; visão mutável requer um proprietário mutável
`str.equal(other)`	comparação de bytes UTF-8 sem alocação
`str.find_ascii(delimiter, start)`	pesquisa de delimitador livre de alocação verificada; delimitadores não-ASCII rejeitados
`byte_slice_equal(a, b)`	igualdade de comprimento e conteúdo `[]u8` livre de alocação
`sqrt(value)` / `abs(value)` / `min(a, b)` / `max(a, b)`	`f32`/`f64` operações matemáticas
`str.slice(start, count)`	subvisão de cópia zero verificada preservando a procedência
`slice.slice(start, count)`	subvisão genérica verificada de cópia zero `[]t` preservando a proveniência
`byte_view.equal(other)`	igualdade de comprimento e conteúdo `[]u8` livre de alocação
`str.to_string()` / `string.from(view)`	`result<string, alloc_error>`; alocação explícita
`str.to_bytes()` / `bytes.from(view)`	`result<bytes, alloc_error>`; explícito copy/allocation
`bytes.to_shared()` / `shared_bytes.from(data)`	consumir bytes próprios; `result<shared_bytes, alloc_error>`
`region(capacity) { body }`	escopo de alocação de colisão verificado lexicalmente
`io.input_stream.read(chunk)`	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 (buf[i] onde i é uma variável) não são suportadas em mut []u8 ou em subfatias derivadas de []u8 via .slice(). As leituras de índice fixo (buf[0]) funcionam em todos os tipos de fatia. Os parâmetros diretos da função []u8 e a fatia original de bytes.view() 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.

byte_buffer nota: byte_buffer.mutable_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 escrever em um buffer bruto, use bytes.zeroed(n) cujo mutable_view() cobre a alocação total ou o uso byte_buffer métodos push/extend/reserve/resize.

Substrato do compilador inseguro

As seguintes operações requerem um bloco unsafe ou unsafe fn:

Família	Operações
memória bruta digitada	`raw_try_alloc<t>`, `raw_null<t>`, `raw_is_null<t>`, `raw_read<t>`, `raw_write<t>`, `raw_free<t>`, `raw_slice<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_try_alloc<t> relata contagem negativa, estouro de tamanho ou falha no alocador como alloc_error. 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 organiza pacotes representativos em compiler/llvm/libs:

Pacote	Função
`box`	indireção de propriedade segura falível para valores recursivos e grandes
`byte_buffer`	construção falível de bytes crescentes, mutação, visualizações e consumo `bytes` conversão
`file`	wrapper output/file hospedado durante o tempo de execução ABI
`fibonacci`	iterativo livre de alocação O (n) `i64` Fibonacci com negative/overflow explícito `none`
`net`	wrapper de rede hospedada
`io`	entrada partial/read-all hospedada digitada, saída text/bytes/format write-all, buffer limitado e `print`/`println` para saída rápida
`math`	portátil `f32`/`f64` raiz quadrada, valor absoluto, mínimo e máximo
`parse`	verificação de análise de número inteiro signed/unsigned e auxiliares padrão explícitos
`process`	argumentos de processo livres de alocação, visualizações de ambiente e identidade de processo
`serialize`	pacote de serialização seguro representativo
`sort`	classificação escalar de fatia mutável e classificação estática `order_key` para valores somente de movimentação
`slice`	auxiliares genéricos de janela reversa, rotação e largura fixa, sem alocação; fatias principais fornecem `fill`/`copy_from`
`text`	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
`time`	milissegundos hospedados monotônicos mais relógio de parede Unix seconds/milliseconds
`vec`	vetor genérico falível com construtores capacity/filled e `@mut` reserve/push/update/pop, além de fila, conjunto e mapa
`task`	canais de divisão de propriedade, digitados one-shot e `result<t,e>` junções, eventos, cancelamento, grupos de espera, semáforos, barreiras e bloqueios
`system`	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 use "vec" ou use "fibonacci"; nenhuma instalação manual de interface ou FFI visível ao aplicativo é necessária. Quanto mais estreito check O subcomando não prepara primeiro um pacote vazio ausente. Os usuários diretos do compilador podem consumir uma fonte explícita ou .sdi pacote. Estes não são nomes de idiomas mágicos.

Formatação e saída

A linguagem implementa digitada phase-1/2 f"..." interpolação. Uma string F produz efêmero format_args sem alocação de heap. compiler/llvm/libs/io é a superfície digitada canônica para texto, fatia de bytes e saída de formato. Para saída rápida, print(text) escreve em stdout e println(text) escreve com uma nova linha à direita. .to_string()? realiza materialização falível explícita. Width/fill/alignment, especificadores de base inteira e emprestados sem alocação display a formatação de características é implementada. A Fase 2 adiciona libc-free f32/f64 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 str_cat, read_file, net_connect, vec_newe sd_*. 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 .sdi contrato define propriedade, efeitos, ABI e disponibilidade.