Principais bibliotecas integradas e padrão

<!-- verified-against: seed-llvm; examples: docs-examples-test -->

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

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. As leituras e gravações de índice variável funcionam em mut []u8 e em subfatias derivadas por meio de .slice(), com os mesmos limites verificados de qualquer outra forma de fatia (verificada por tests/gate18/mut_slice_dynamic_index_consumer.sd).

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 preparar um destino de gravação de n bytes, use byte_buffer.resize_zeroed(n) (aumentar ou diminuir o prefixo inicializado; novos bytes são zero) ou byte_buffer.push_zeroed(n) (anexar n bytes inicializados com zero); ambos são falíveis com alloc_error no crescimento e preservar a invariante do prefixo comprometido em todos os caminhos, incluindo falhas de alocação. 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.

Construção canônica de strings: acumule com push/push_str/extend, então se materialize uma vez com text.utf8_string_from_bytes(buffer.view()), que valida UTF-8 e relatórios Utf8Error em vez de prender. A validação reside no auditado text biblioteca propositalmente: estados de buffer intermediários podem conter sequências parciais, portanto, apenas a etapa final verifica:

use "byte_buffer"
use "text"

fn main() -> AllocResult<i64> {
    let mut builder = byte_buffer_new(8 as usize)?
    builder.push_str("hello ")?
    builder.push_str("world")?
    let built = match text.utf8_string_from_bytes(builder.view()) {
        Ok(value) => value,
        Err(_) => {
            return Ok(1)
        }
    }
    if built.view().equal("hello world") { Ok(0) } else { Ok(2) }
}

Substrato do compilador inseguro

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

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 prepara pacotes representativos em compiler/llvm/libs:

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. print leva str, então print(f"...") não digita: strings f produzem efêmero format_args. Usar print_format / println_format (mesmo single/two-write disciplina como print/println) para saída interpolada:

use "io"

fn main() -> Result<i64, IoError> {
    let count = 42
    print_format(f"events={count}\n")?
    println_format(f"done")?
    Ok(0)
}

.to_string()? realiza materialização falível explícita. Width/fill/alignment, especificadores de base inteira e formatação de característica display emprestada sem alocação são implementados. A Fase 2 adiciona formatação fixa, científica e geral f32/f64 livre de libc, além de características display/debug emprestadas.

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.