Bibliothèques intégrées de base et standard

seed garde le noyau du langage petit. Les fichiers, la mise en réseau, les processus, le formatage, les collections et la synchronisation sont des bibliothèques ordinaires compilées séparément, et non des bibliothèques intégrées universelles. La surface intégrée du compilateur propre se trouve ci-dessous ; le catalogue de packages opérationnels par étapes par le compilateur est documenté dans Library Reference, tandis que la génération mixte Grove l'arbre est classé séparément dans Grove Arbre de compatibilité.

Types de base

Le compilateur définit void, never, bool, entiers à largeur fixe, isize, usize, f32, f64, str, string, bytes, shared_bytes, alloc_error, et le caché region_handle. byte est accepté comme u8. AllocResult<T> est le raccourci canonique pour Result<T, alloc_error>. Hébergé main() -> Result<i64, E> mappe le succès à l’état du processus. alloc_error a le diagnostic fixe ; un autre E doit être une copie, ne pas avoir de destructeur et implémenter emprunté display() -> str. L'échec est imprimé une fois avant l'état 1, après nettoyage et sans déroulement.

Opérations sécurisées connues du compilateur

Fonctionnement	Contrat
`len(value)`	`usize` byte/element longueur pour `str`, `string`, `bytes`, `shared_bytes`, tranches et tableaux
`size_of(type)`	vue `align_of(type)` en lecture seule sans allocation avec la provenance de la source
`[size_of(i64)]u8`	sous-vue vérifiée sans allocation préservant le type d'élément et la mutabilité
`str.bytes()`	paire vérifiée sans allocation de vues lexicales exclusives et sans chevauchement
`[]u8`	remplit une tranche d'élément de copie sans allocation
`slice.slice(start, count)`	Transfert d'éléments de copie de longueur égale et sans chevauchement sans allocation
`mut_slice.split_at_mut(index)`	consommer une troncature logique vérifiée qui réutilise l'allocation et la capacité
`mut_slice.fill(value)` / `mut_slice.copy_from(source)`	construction d'options canoniques ; Besoins attendus pour `bytes.into_prefix(length)` `Some(value)`
`None` / `None`	construction du résultat canonique avec attendu `?T`
`Ok(value)` / `Err(problem)`	inspection empruntée sans allocation
`Result<T, E>` / `option.is_some()`	inspection empruntée sans allocation
`option.is_none()`	consommation par défaut avec nettoyage exact de la valeur possédée non sélectionnée
`result.is_ok()` / `result.is_error()`	limite fatale explicite sans déroulement
`option_or_result.unwrap_or(value)`	limite principale uniquement `or_abort()` option/result utilisant un retour nettoyé ordinaire
`expect(message)`	clone structurel explicite lorsque la capacité existe ; l'effet d'allocation est suivi
`or_exit(status)`	prêté sans allocation `i64`
`value.clone()`	lecture seule sans allocation `string.view()`
`str`	lexical exclusif `bytes.view()` couvrant toute la longueur allouée
`[]u8`	faillible initialisé à zéro `bytes.mutable_view()`; `mut []u8` doit être `bytes.zeroed(length)`
`Result<bytes, alloc_error>`	une allocation faillible des capacités internes ; les appelants doivent initialiser chaque octet avant d'exposer un préfixe
`length`	lecture seule sans allocation `i64`
`unsafe { bytes.uninitialized(length) }` / `shared_bytes.view()`	tranche compatible explicite sans allocation ; la vue mutable nécessite un propriétaire mutable
`[]u8`	comparaison d'octets UTF-8 sans allocation
`array.view()`	recherche de délimiteur sans allocation vérifiée ; délimiteurs non-ASCII rejetés
`array.mutable_view()`	égalité de longueur et de contenu `str.equal(other)` sans allocation
`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` opérations mathématiques
`f64`	sous-vue vérifiée sans copie préservant la provenance
`math`	générique vérifié zéro copie `str.slice(start, count)` sous-vue préservant la provenance
`slice.slice(start, count)`	égalité de longueur et de contenu `[]t` sans allocation
`byte_view.equal(other)` / `[]u8`	`str.to_string()`; allocation explicite
`string.from(view)` / `Result<string, alloc_error>`	`str.to_bytes()`; explicite copy/allocation
`bytes.from(view)` / `Result<bytes, alloc_error>`	consommer les octets possédés ; `bytes.to_shared()`
`shared_bytes.from(data)`	portée de l'allocation de bosses vérifiée lexicale
`Result<shared_bytes, alloc_error>`	lecture partielle faillible limitée ; les appelants peuvent traiter EOF/data de manière incrémentielle sans conserver toutes les entrées

L'indexation sécurisée de arrays/slices accepte chaque largeur entière intégrée et vérifie l'index mathématique avant la formation du pointeur. Les API de texte exposent des octets ; Le traitement Unicode scalar/grapheme appartient aux bibliothèques.

Limitation connue : les lectures d'index variable (region(capacity) { body } où io.input_stream.read(chunk) est une variable) ne sont pas prises en charge sur buf[i] ou sur les sous-tranches dérivées de i via mut []u8. Les lectures à index fixe ([]u8) fonctionnent sur tous les types de tranches. Les paramètres de fonction directs .slice() et la tranche originale de buf[0] prennent en charge les lectures à index variable. Pour contourner cette limitation, étendue aux vues mutables dans un bloc et utilisez les paramètres de fonction []u8 en lecture seule ou la tranche bytes.view() d'origine pour l'accès à l'index variable.

[]u8 remarque : bytes.view() renvoie une vue du préfixe initialisé, qui est de longueur 0 pour un tampon fraîchement créé. L'écriture au-delà de la longueur renvoyée provoque un piège hors limites. Pour préparer une cible d'écriture de n octets, utilisez byte_buffer (augmenter ou réduire le préfixe initialisé ; les nouveaux octets sont nuls) ou byte_buffer.mutable_view() (ajouter n octets initialisés à zéro); les deux sont faillibles avec byte_buffer.resize_zeroed(n) sur la croissance et préserver l'invariant du préfixe engagé sur chaque chemin, y compris l'échec de l'allocation. Pour écrire dans un tampon brut, utilisez byte_buffer.push_zeroed(n) dont alloc_error couvre la totalité de l’allocation, ou l’utilisation bytes.zeroed(n) méthodes mutable_view()/byte_buffer/push/extend.

Substrat de compilateur dangereux

Les opérations suivantes nécessitent un reserve bloquer ou resize:

Famille	Opérations
mémoire brute typée	`unsafe`, `unsafe fn`, `raw_try_alloc<t>`, `raw_null<t>`, `raw_is_null<t>`, `raw_read<t>`, `raw_write<t>`
atomiques	acquire/release aides plus commandées load/store/fetch-add/exchange/compare-exchange
commande	compilateur et clôtures atomiques avec commandes de mémoire validées
appareils	typé volatile read/write et conversions d'espace d'adressage
architecture	intrinsèques d'assemblage brut typés
interopérabilité	pointeurs bruts, FFI, appels système et unions brutes

raw_free<t> signale un décompte négatif, un dépassement de taille ou une défaillance de l'allocateur sous la forme raw_slice<t>. Raw read/write/free s'appuie sur l'appelant non sécurisé audité pour les limites, l'initialisation, la provenance, la synchronisation et la publication exacte.

Forfaits de bibliothèque ordinaires

Le compilateur propre organise les packages représentatifs sous raw_try_alloc<t>:

Forfait	Rôle
`alloc_error`	indirection faillible et sûre pour les valeurs récursives et grandes
`compiler/llvm/libs`	construction, mutation, vues et consommation d'octets évolutifs faillibles `box` transformation
`byte_buffer`	wrapper output/file hébergé sur le runtime ABI
`bytes`	O(n) itératif sans allocation `file` Fibonacci avec negative/overflow explicite `fibonacci`
`i64`	wrapper de réseau hébergé
`None`	entrée partial/read-all hébergée, sortie text/bytes/format en écriture complète, mise en mémoire tampon limitée et `net`/`io` pour une sortie rapide
`print`	portable `println`/`math` racine carrée, valeur absolue, minimum et maximum
`f32`	vérifié l'analyse des entiers signed/unsigned et les aides par défaut explicites
`f64`	arguments de processus sans allocation, vues d'environnement et identité de processus
`parse`	package de sérialisation sécurisé représentatif
`process`	tri scalaire par tranches mutables et tri statique `serialize` pour les valeurs de déplacement uniquement
`sort`	des assistants génériques d'inversion, de rotation et de fenêtre à largeur fixe sans allocation ; les tranches de base fournissent `order_key`/`slice`
`fill`	UTF-8 validation, vérification sans allocation Unicode-scalaire iteration/counting, conversion de chaîne détenue et curseurs de jeton délimités par ASCII
`copy_from`	millisecondes hébergées monotones plus horloge murale Unix seconds/milliseconds
`text`	vecteur générique faillible avec les constructeurs capacity/filled et `time` reserve/push/update/pop, plus file d'attente, ensemble et carte
`vec`	chaînes à propriété partagée, typées one-shot et `@mut` jointures, événements, annulations, groupes d'attente, sémaphores, barrières et verrous
`task`	wrappers de systèmes sécurisés sur les espaces d'adressage, MMIO, atomiques, pages, DMA, init-once et mécanismes locaux du CPU

L'incrément du lanceur build/run path met automatiquement en scène ces packages principaux du référentiel lorsqu'un package ordinaire utilise une importation simple telle que Result<T, E> ou system; aucune installation manuelle de l'interface ou FFI visible par l'application n'est requis. Le plus étroit use "vec" La sous-commande ne prépare pas d'abord un package nu manquant. Les utilisateurs du compilateur direct peuvent consommer une source explicite ou use "fibonacci" paquet. Ce ne sont pas des noms de langue magiques.

Formatage et sortie

Le langage implémente le typage phase-1/2 check interpolation. Une f-string donne des résultats éphémères .sdi sans allocation de tas. f"..." est la surface typée canonique pour la sortie de texte, de tranche d'octet et de format. Pour une sortie rapide, format_args écrit sur la sortie standard et compiler/llvm/libs/io écrit avec une nouvelle ligne finale. print(text) effectue une matérialisation faillible explicite. Width/fill/alignment, spécificateurs de base entière et emprunts sans allocation println(text) le formatage des traits est implémenté. La phase 2 ajoute sans libc .to_string()?/display formatage fixe, scientifique et général plus emprunté display/debug traits.

Avertissement de compatibilité

llvm-v1 et historique Grove/runtime les tableaux exposent de nombreux noms tels que f32, f64, str_cat, read_file, et net_connect. Leur existence dans un compilateur archivé ne les rend pas propres au compilateur intégré. Lors du portage du code existant, importez ou implémentez un wrapper sécurisé actuel et laissez-le vec_new le contrat définit la propriété, les effets, ABI et la disponibilité.