Core built-in e librerie standard

seed mantiene piccolo il nucleo del linguaggio. File, rete, processi, formattazione, raccolte e sincronizzazione sono normali librerie compilate separatamente, non integrate universali. La superficie integrata del compilatore pulito è sotto; il catalogo dei pacchetti operativi gestiti dal compilatore è documentato in Riferimento libreria, mentre l'albero Grove di generazione mista è classificato separatamente in Grove Compatibility Tree.

Tipi di nucleo

Il compilatore definisce void, never, bool, numeri interi a larghezza fissa, isize, usize, f32, f64, str, string, bytes, shared_bytes, alloc_errore quello nascosto region_handle. byte è accettato come u8. AllocResult<T> è la scorciatoia canonica per Result<T, alloc_error>. Ospitato main() -> Result<i64, E> associa il successo allo stato del processo. alloc_error ha la diagnostica fissa; un altro E deve essere Copia, non avere distruttore e implementare preso in prestito display() -> str. Il fallimento viene stampato una volta prima dello stato 1, dopo la pulizia e senza svolgimento.

Operazioni sicure note al compilatore

Operazione	Contratto
`len(value)`	`usize` byte/element lunghezza per `str`, `string`, `bytes`, `shared_bytes`, slice e array
`size_of(type)`	vista `align_of(type)` di sola lettura senza allocazione con la provenienza dell'origine
`[size_of(i64)]u8`	controllata la visualizzazione secondaria priva di allocazione che preserva il tipo di elemento e la mutabilità
`str.bytes()`	controllato una coppia priva di allocazione di visualizzazioni lessicali esclusive e non sovrapposte
`[]u8`	riempie una sezione di elementi di copia senza allocazione
`slice.slice(start, count)`	Trasferimento di elementi di copia di uguale lunghezza, sicuro da sovrapposizione, senza assegnazione
`mut_slice.split_at_mut(index)`	consumando il troncamento logico controllato che riutilizza l'allocazione e la capacità
`mut_slice.fill(value)` / `mut_slice.copy_from(source)`	costruzione di opzioni canoniche; `bytes.into_prefix(length)` necessita del previsto `Some(value)`
`None` / `None`	costruzione del risultato canonico con previsto `?T`
`Ok(value)` / `Err(problem)`	ispezione presa in prestito senza assegnazione
`Result<T, E>` / `option.is_some()`	ispezione presa in prestito senza assegnazione
`option.is_none()`	consumo di default con esatta pulizia del valore posseduto non selezionato
`result.is_ok()` / `result.is_error()`	confine fatale esplicito e irremovibile
`option_or_result.unwrap_or(value)`	confine solo principale `or_abort()` option/result utilizzando il ritorno ordinario ripulito
`expect(message)`	clone strutturale esplicito quando esiste la capacità; viene monitorato l’effetto dell’allocazione
`or_exit(status)`	presi in prestito senza allocazione `i64`
`value.clone()`	di sola lettura senza allocazione `string.view()`
`str`	lessicale esclusivo `bytes.view()` che copre l'intera lunghezza allocata
`[]u8`	fallibile inizializzato a zero `bytes.mutable_view()`; `mut []u8` deve essere `bytes.zeroed(length)`
`Result<bytes, alloc_error>`	allocazione fallibile della capacità interna; i chiamanti devono inizializzare ogni byte prima di esporre un prefisso
`length`	di sola lettura senza allocazione `i64`
`unsafe { bytes.uninitialized(length) }` / `shared_bytes.view()`	porzione compatibile esplicita priva di allocazione; la vista mutabile richiede un proprietario mutabile
`[]u8`	confronto di byte UTF-8 senza allocazione
`array.view()`	ricerca delimitatrice controllata senza allocazione; delimitatori non ASCII rifiutati
`array.mutable_view()`	senza assegnazione `str.equal(other)` uguaglianza di lunghezza e contenuto
`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` operazioni matematiche
`f64`	controllato la visualizzazione secondaria a copia zero preservando la provenienza
`math`	sottovista generica controllata a copia zero `str.slice(start, count)` che preserva la provenienza
`slice.slice(start, count)`	senza assegnazione `[]t` uguaglianza di lunghezza e contenuto
`byte_view.equal(other)` / `[]u8`	`str.to_string()`; allocazione esplicita
`string.from(view)` / `Result<string, alloc_error>`	`str.to_bytes()`; esplicito copy/allocation
`bytes.from(view)` / `Result<bytes, alloc_error>`	consumare byte posseduti; `bytes.to_shared()`
`shared_bytes.from(data)`	ambito di allocazione bump controllato lessicale
`Result<shared_bytes, alloc_error>`	lettura parziale fallibile limitata; i chiamanti possono elaborare EOF/data in modo incrementale senza conservare tutto l'input

L'indicizzazione sicura di arrays/slices accetta ogni larghezza intera incorporata e controlla l'indice matematico prima della formazione del puntatore. Le API di testo espongono byte; L'elaborazione Unicode scalar/grapheme appartiene alle librerie.

Limitazione nota: le letture dell'indice variabile (region(capacity) { body } dove io.input_stream.read(chunk) è una variabile) non sono supportate su buf[i] o su sottosezioni derivate da i tramite mut []u8. Le letture a indice fisso ([]u8) funzionano su tutti i tipi di slice. I parametri diretti della funzione .slice() e la sezione originale da buf[0] supportano le letture degli indici variabili. Per aggirare questa limitazione, definire l'ambito delle viste modificabili all'interno di un blocco e utilizzare i parametri della funzione []u8 di sola lettura o la sezione bytes.view() originale per l'accesso all'indice variabile.

[]u8 nota: bytes.view() restituisce una vista del prefisso inizializzato, che è di lunghezza 0 per un buffer appena creato. La scrittura oltre la lunghezza restituita provoca un trap fuori limite. Per preparare una destinazione di scrittura di n byte, utilizzare byte_buffer (incrementare o ridurre il prefisso inizializzato; i nuovi byte sono zero) o byte_buffer.mutable_view() (aggiungere n byte inizializzati con zero); entrambi sono fallibili con byte_buffer.resize_zeroed(n) in termini di crescita e preservano l'invariante del prefisso impegnato su ogni percorso, incluso il fallimento dell'allocazione. Per scrivere in un buffer non elaborato, utilizzare byte_buffer.push_zeroed(n) il cui alloc_error copre l'intera allocazione oppure utilizzare i metodi bytes.zeroed(n) mutable_view()/byte_buffer/push/extend.

Substrato del compilatore non sicuro

Le seguenti operazioni richiedono un blocco reserve o resize:

Famiglia	Operazioni
memoria grezza digitata	`unsafe`, `unsafe fn`, `raw_try_alloc<t>`, `raw_null<t>`, `raw_is_null<t>`, `raw_read<t>`, `raw_write<t>`
atomi	acquire/release aiutanti più ordinato load/store/fetch-add/exchange/compare-exchange
ordinare	compilatore e recinzioni atomiche con ordini di memoria convalidati
dispositivi	digitato volatile read/write e cast dello spazio degli indirizzi
architettura	intrinseche dell'assemblaggio grezzo tipizzato
interoperabilità	puntatori grezzi, FFI, chiamate di sistema e unioni grezze

raw_free<t> segnala il conteggio negativo, l'overflow delle dimensioni o l'errore dell'allocatore come raw_slice<t>. I raw read/write/free si affidano al chiamante non sicuro controllato per limiti, inizializzazione, provenienza, sincronizzazione e rilascio esatto una volta.

Pacchetti bibliotecari ordinari

Il compilatore pulito mette in scena i pacchetti rappresentativi in raw_try_alloc<t>:

Pacchetto	Ruolo
`alloc_error`	indiretto di proprietà fallibile e sicuro per valori ricorsivi e di grandi dimensioni
`compiler/llvm/libs`	costruzione fallibile di byte crescebili, mutazione, visualizzazioni e consumo `box` conversione
`byte_buffer`	wrapper output/file ospitato sul runtime ABI
`bytes`	iterativo senza allocazione O(n) `file` Fibonacci con esplicito negative/overflow `fibonacci`
`i64`	wrapper di rete ospitato
`None`	input partial/read-all ospitato digitato, output text/bytes/format write-all, buffering limitato e `net`/`io` per output rapido
`print`	portatile `println`/`math` radice quadrata, valore assoluto, minimo e massimo
`f32`	controllato l'analisi dei numeri interi signed/unsigned e gli helper predefiniti espliciti
`f64`	argomenti di processo senza allocazione, visualizzazioni dell'ambiente e identità del processo
`parse`	pacchetto di serializzazione sicuro rappresentativo
`process`	ordinamento scalare a sezioni modificabili e ordinamento statico `serialize` per valori di solo spostamento
`sort`	helper generici per inversione, rotazione e finestra a larghezza fissa senza allocazione; le fette centrali forniscono `order_key`/`slice`
`fill`	UTF-8 validazione, controllo Unicode-scalare senza allocazione iteration/counting, conversione della stringa di proprietà e cursori token delimitati da ASCII
`copy_from`	millisecondi ospitati monotonici più orologio da parete Unix seconds/milliseconds
`text`	vettore generico fallibile con costruttori capacity/filled e `time` reserve/push/update/pop, oltre a coda, set e mappa
`vec`	canali con divisione della proprietà, digitati one-shot e `@mut` join, eventi, cancellazioni, gruppi di attesa, semafori, barriere e blocchi
`task`	wrapper di sistemi sicuri su spazi di indirizzi, MMIO, atomici, pagine, DMA, init-once e meccanismi locali della CPU

Il launcher è incrementale build/run path mette automaticamente in scena questi pacchetti principali del repository quando un pacchetto ordinario utilizza un'importazione semplice come Result<T, E> o system; non è richiesta l'installazione manuale dell'interfaccia o un'FFI visibile dall'applicazione. Il più stretto use "vec" il sottocomando non mette prima in scena un pacchetto nudo mancante. Gli utenti del compilatore diretto possono utilizzare una fonte esplicita o use "fibonacci" pacchetto. Questi non sono nomi di lingue magiche.

Formattazione e output

Il linguaggio implementa typed phase-1/2 check interpolazione. Una stringa f produce effimero .sdi senza allocazione heap. f"..." è la superficie tipizzata canonica per testo, porzione di byte e output in formato. Per risultati rapidi, format_args scrive su stdout e compiler/llvm/libs/io scrive con una nuova riga finale. print(text) esegue una materializzazione fallibile esplicita. Width/fill/alignment, specificatori di base interi e prestiti senza allocazione println(text) la formattazione dei tratti è implementata. La fase 2 aggiunge libc-free .to_string()?/display formattazione fissa, scientifica e generale più presa in prestito display/debug tratti.

Avviso di compatibilità

lvm-v1 e storico Grove/runtime le tabelle espongono molti nomi come f32, f64, str_cat, read_file, e net_connect. La loro esistenza in un compilatore archiviato non li rende integrati puliti del compilatore. Quando esegui il porting del codice legacy, importa o implementa un wrapper sicuro corrente e lascialo vec_new contratto definisce proprietà, effetti, ABI e disponibilità.