Riferimento linguistico

Questa pagina è il riferimento orientato all'utente per l'attuale seed Specifica della lingua. I capitoli completi di grammatica e semantica operativa si trovano qui sotto compiler/llvm. Per i limiti attuali e le richieste di chiusura, vedere Stato corrente.

Codifica sorgente e nomi

.sd i file sono UTF-8. I commenti e il contenuto delle stringhe possono contenere Unicode. string possiede valido UTF-8 e str è di sola lettura preso in prestito UTF-8 vista puntatore più lunghezza byte. La lunghezza del testo è misurata in byte; Le operazioni scalari, grafema, normalizzazione e locale Unicode appartengono alle librerie.

Gli identificatori di origine utilizzano intenzionalmente ASCII:

Il nome del linguaggio formale è seed. I tipi non sono in maiuscolo. _ elimina un'associazione; un carattere di sottolineatura iniziale può contrassegnare una rilegatura privata intenzionalmente inutilizzata.

I commenti di riga iniziano con //. Blocca i commenti /* ... */ nido. La grammatica pulita non utilizza # commenti.

Il caricatore di origine convalida l'intero file come UTF-8 prima della lexing e rifiuta il NUL incorporato; vengono convalidate anche le stringhe letterali decodificate.

Legami, costanti e mutazione

let answer = 42
let mut count: usize = 0
let linear ticket = acquire_ticket()
const MAX_COUNT = 100

Il compilatore corrente accetta anche espressioni scalari tipizzate, tabelle costanti u32 fisse private come const TABLE: [4]u32 = [1 as u32, 2 as u32, 3 as u32, 4 as u32], testo statico, tuple e strutture. Le letture indicizzate e di campo utilizzano l'archiviazione statica immutabile con controlli dei limiti ordinari. I valori aggregati pubblici mantengono la loro rappresentazione ricorsiva nelle build elide di origine schema-14.

I collegamenti sono immutabili a meno che non siano dichiarati mut. L'assegnazione a un'associazione, a un campo o a un indice tramite un'associazione richiede che l'associazione sia modificabile. linear crea un obbligo esattamente una volta.

Per scartare un valore restituito, associarlo a un nome univoco che inizia con _: let _unused = expression. Gli scarti con nome evitano l'errore di "associazione attiva duplicata" prodotto dal semplice let _ = expression se utilizzato più volte nello stesso ambito. Un carattere di sottolineatura iniziale in qualsiasi identificatore contrassegna l'associazione come intenzionalmente inutilizzata.

Funzioni, metodi e rendimenti

fn add(left: i64, right: i64) -> i64 {
    left + right
}

fn document.title_size() -> usize {
    len(self.title)
}

unsafe fn read_register(address: *mmio mut i64) -> i64 {
    raw_volatile_read<i64>(address, 0)
}

L'espressione finale di un blocco è il suo valore. ret expression ritorna presto; il compilatore pulito non utilizza return. Una dichiarazione di metodo include il tipo nominale prima del punto e riceve implicitamente self; non scrivere self nella sua lista dei parametri. fn type_name.drop() è un distruttore consumante. @borrow su un metodo o un metodo di caratteristica dà self un prestito lessicale condiviso. @mut richiede invece un ricevitore indirizzabile mutabile, detiene un prestito esclusivo per la chiamata e apporta mutazioni self visibile al chiamante. I due attributi si escludono a vicenda.

Utilizzo delle dichiarazioni pubbliche pub. Le dichiarazioni straniere utilizzano esplicito extern chiamando convention/link metadati e non è sicuro chiamarli finché non vengono inseriti in una funzione sicura controllata. La classificazione degli argomenti della piattaforma C è specifica del target: Windows x86-64 passa indirettamente parametri aggregati più grandi di otto byte, quindi str, le fette e le strutture C equivalenti interagiscono con MinGW/MSVC-style chiamati.

Tipi di nucleo

alloc_result<t> abbrevia result<t, alloc_error> senza introdurre una nuova identità di tipo, rappresentazione, regola di pulizia o ABI.

Ospitato main potrebbe tornare result<i64, e>. ok(status) esce con quello stato; alloc_error utilizza la diagnostica dell'allocazione fissa. Un altro e deve essere Copia, non avere distruttore e implementare @borrow fn e.display() -> str; la sua vista viene scritta una volta prima dello stato 1, dopo la pulizia ordinaria.

@static_view extern fn ... è la dichiarazione FFI sottoposta ad audit per un reso str/slice di cui si trova l'archiviazione process/static tutta la vita. L'attributo viene rifiutato in via ordinaria seed funziona e non rende sicura la chiamata estera.

Gli attributi degli effetti possono annotare dichiarazioni fn: @no_alloc, @allocates, @blocking, @panics, @io, @interrupt_safe. I tipi di callback qualificati utilizzano @no_runtime_effects fn(...) -> t per dichiarare un riepilogo completo degli effetti vuoto. Uno unsafe struct può dichiarare @unsafe_send per affermare la capacità di invio o @repr("null_niche") per abilitare l'ottimizzazione del puntatore nullo su un singolo campo puntatore grezzo per ?wrapper.

Il numero intero add/subtract/multiply esegue il ritorno a capo in modo deterministico in base alla larghezza del tipo. Divisione per zero, minimo con segno diviso per -1, spostamenti non validi, cast sicuri non validi e trap di indicizzazione sicura non riuscita. I profili di rilascio preservano queste regole. L'ampliamento esplicito degli interi utilizza la firma dell'origine; il restringimento mantiene i bit bassi e le modifiche di uguale larghezza preservano i bit. Integer/float e i cast di larghezza float seguono la conversione IEEE-754. La conversione da virgola mobile a intero richiede unsafe e un input rappresentabile con destinazione finita.

I letterali byte utilizzano b'A' e avere tipo u8. Uno o più byte ASCII grezzi \\n/\\r/\\t/\\0/\\\\/\\'/\\xNN la fuga è accettata. Utilizzare b'\\xFF' per un byte non ASCII; seed deliberatamente non ha un tipo letterale di carattere dipendente dalla locale.

Strutture, ADT e unioni

struct document {
    title: string
}

type parse_result {
    parsed(document)
    invalid(str)
}

union scalar_bits {
    integer: u64
    decimal: f64
}

Una struttura letterale è document.{ title: owned_title }. Un costruttore ADT è qualificato, ad esempio parse_result.parsed(value)e il suo carico utile viene ispezionato in modo esaustivo match. Un ADT senza carico utile sostituisce l'eredità enum parola chiave:

type color { red green blue }

L'unione grezza construction/access non è sicura. Le alternative con tag sicuri utilizzano ADT.

Opzioni, risultati e propagazione

fn find(enabled: bool) -> ?i64 {
    if enabled { some(42) } else { none }
}

fn allocate_name(view: str) -> result<string, alloc_error> {
    view.to_string()
}

some(value) e none di tipo previsto costruiscono un'opzione. result.ok(value) e result.error(problem) costruiscono un risultato. ? consuma il contenitore, cede il suo payload success/present o restituisce l'errore corrispondente dalla funzione corrente. La propagazione dei risultati può modificare il tipo di successo ma deve preservare il tipo di errore. Non esegue alcuna allocazione o clonazione implicita.

is_some/is_none e is_ok/is_error ispezionare tramite prestito condiviso. unwrap_or(fallback) consuma il contenitore e pulisce il valore posseduto non selezionato esattamente una volta. or_abort(), expect(message)e solo principale or_exit(status) sono confini espliciti dell'applicazione; non si nascondono mai nell'ordinario ? propagazione.

? non può oltrepassare un limite spawn mentre l'attività delineata ABI restituisce void.

Controllare il flusso e i modelli

I moduli di controllo implementati sono orientati all'espressione if/elif/else, while, for, esaustivo match, blocchi, break, continue, e ret. elif è l'ortografia richiesta; else if non è accettato. Le armi di corrispondenza non hanno virgole. Copertina dei modelli bindings/discards, valori letterali, tuple, strutture e varianti ADT qualificate; le guardie mantengono uno scrutatore di sola mossa finché il braccio selezionato non lo trasferisce effettivamente.

for su intervalli, array fissi e sezioni si riducono a un'allocazione libera index/length ciclo. for index, value in enumerate(items) aggiunge a usize indice senza un iteratore heap. Gli elementi di solo spostamento richiedono esplicitamente indexing/ownership manipolazione.

Testo, visualizzazioni e conversioni

• i valori letterali hanno il tipo preso in prestito statico str;
• di proprietà string prende automaticamente in prestito come str quando previsto;
• len restituisce usize per testo, buffer, sezioni e array;
• string.view() restituisce str;
• bytes.view() e shared_bytes.view() restituiscono []u8;
• bytes.mutable_view() restituisce un esclusivo mut []u8 con la versione completa lunghezza assegnata; bytes.zeroed(length) alloca fallibilmente length byte inizializzati zero e il suo mutable_view() copre l'intera allocazione; byte_buffer.mutable_view() restituisce solo il prefisso inizializzato (lunghezza 0 per un nuovo buffer), non la capacità: utilizza bytes.zeroed quando è necessaria una destinazione di scrittura modificabile a lunghezza intera;
• bytes.zeroed(length) richiede i64 e alloca fallibilmente length byte inizializzati zero;
• gli array fissi derivano viste condivise compatibili e derivano gli array modificabili viste esclusive;
• str.slice(start, count) è selezionato e zero copie;
• vengono controllate anche le porzioni di testo UTF-8 confini dei punti di codice;
• str.equal(other) e str.find_ascii(delimiter, start) controllato lo sono senza assegnazione; compiler/llvm/libs/text crea un cursore diviso con provenienza sicura dagli intervalli di byte restituiti;
• []u8.slice(start, count) è una visualizzazione secondaria a copia zero controllata e []u8.equal(other) confronta lunghezza e contenuto senza assegnazione;
• str.to_string() / string.from(str) ritorno result<string, alloc_error>;
• str.to_bytes() / bytes.from(str) ritorno result<bytes, alloc_error>;
• bytes.to_shared() / shared_bytes.from(bytes) consumano i byte del proprietario e restituire result<shared_bytes, alloc_error>.
• bytes.into_prefix(length) consuma il proprietario, confronta length con lunghezza inizializzata e restituisce la stessa allocazione con una lunghezza logica più breve. Non assegna né copia; il proprietario originale viene spostato.
• [n]t.mutable_view() -> mut []t ricava una vista mutevole esclusiva quando il file il proprietario dell'array è modificabile.

L'interpolazione digitata phase-1/2 è esente da allocazione a meno che non sia esplicitamente materializzata:

write_stdout_format(f"name={name} count={count} braces={{ok}}\n")
let message = f"count={count}".to_string()?

Le espressioni valutano una volta da sinistra a destra. I valori supportati sono str, preso in prestito string, boole numeri interi incorporati. L'effimero format_args il risultato deve essere passato direttamente o consumato da .to_string()?; non può essere assegnato let, restituito, catturato o archiviato. Integer/text/bool sono implementate le specifiche di larghezza, riempimento, allineamento e base intera. Utilizzo di tipi personalizzati trait display { @borrow fn display() -> str } con invio statico diretto. I float supportano l'output generale predefinito plus f/F, e/E, e g/G con precisione fino a 18. Personalizzato :? la formattazione utilizza l'analogo preso in prestito debug.debug() -> str tratto.

Generi e tratti

I parametri generici utilizzano maiuscole e minuscole. Le definizioni vengono verificate rispetto ai loro limiti, quindi le istanze concrete raggiungibili vengono monomorfizzate. L'invio dei tratti è statico e diretto: non sono presenti vtable, boxing, allocazioni o cloni impliciti. Vengono verificate la completezza dell'implementazione, le firme, la coerenza e le regole orfane. Modelli generici pubblici, istanze comuni, parametri format_args effimeri, rappresentazione nominale di nicchia nulla, ricevitori modificabili esclusivi, callback qualificati e firme richiamabili in scatola persistono nello schema corrente-16 .sdi. Le istanze del metodo materializzato vengono esportate solo da un'interfaccia che possiede anche la definizione del metodo generico. Un involucro attorno ad un tipo generico importato registra quindi il suo contratto pubblico senza una specializzazione orfana; un consumatore eliso alla fonte ottiene il modello del metodo dall'interfaccia di dipendenza del wrapper e materializza lì l'istanza concreta.

inline fn richiede l'inlining limitato. Un pub inline fn pubblica il proprio corpo verificato e l'hash del corpo deterministico nello schema-13 .sdi mantenendo un simbolo di fallback esportato. Le dichiarazioni in linea hanno un budget di origine di 4096 byte; una modifica del corpo invalida gli artefatti dipendenti. Le partizioni di slice mutabili utilizzano view.split_at_mut(index) e i modelli di tupla possono dichiarare associazioni mutabili come (mut left, mut right). Gli assegni suddivisi index <= len, non assegnano nulla e mantengono il proprietario comune in prestito esclusivo fino alla morte di entrambi i fratelli.

Chiusure e richiamate

fn apply(values: [3]i64, callback: fn(i64) -> i64) -> i64 {
    let mut total = 0
    for value in values {
        total = total + callback(value)
    }
    total
}

let base = 40
let total = apply([1, 2, 3], |value: i64| base + value)
let retained = (box |value: i64| base + value).or_abort()

|...| e la posizione del prefisso || creano richiamabili anonimi. I tipi di parametri possono essere omessi quando vengono forniti da un fn(...) -> t previsto. Una chiusura semplice utilizza l'archiviazione di cattura dello stack, non alloca nulla e non può sfuggire al suo proprietario lessicale. La funzionalità di copia acquisisce la copia; le catture possedute si spostano; le acquisizioni sono immutabili. Acquisizioni prese in prestito, modificabili, legate a una regione, già spostate e altre acquisizioni non sicure da archiviare vengono rifiutate.

box |...| è la forma di escape esplicita e restituisce result<box fn(...) -> t, alloc_error>. Il proprietario può essere archiviato o restituito, ma è di solo spostamento, non clonabile e non inviabile. Drop distrugge le sue catture esattamente una volta e libera la sua allocazione. L'assegnazione regionale rimane lessicale. Non esiste alcuna conversione implicita tra chiusure stack e boxed.

I callback seed fn(...) -> t utilizzano un descrittore code/environment a un puntatore. I puntatori alle funzioni C/platform rimangono sottili e accettano solo funzioni con nome. Gli effetti di chiusura vengono dedotti dal corpo e confrontati con contratti di callback qualificati come @no_runtime_effects fn() -> void. Le chiusure ricorsive non sono supportate.

Riepilogo della proprietà

• scalari e aggregati di sola copia copia;
• le risorse si spostano e rendono indisponibile il luogo di origine;
• .clone() è esplicito e capability/effect controllato;
• le viste prese in prestito hanno provenienza senza sintassi a vita;
• la pulizia strutturata viene eseguita esattamente una volta sulle normali uscite strutturate;
• panic/trap/abort non svolge né esegue distruttori;
• linear t deve essere consumato esattamente una volta;
• la proprietà parziale viene tracciata tramite campi, campi nidificati, array noti indici, payload ADT attivi, unioni, generici, canali, valori di funzione e .sdi; gli spostamenti delle risorse con indice dinamico rimangono rifiutati.

Vedere Proprietà per il modello operativo.

Regioni, attività e biblioteche

region(capacity) { body } installa un allocatore di bump controllato dal lessico. Valori, visualizzazioni o puntatori legati alla regione non possono sfuggire. Attività strutturate acquisite all'interno di un'unione di regioni prima che venga rilasciato lo spazio di archiviazione di backup.

spawn { body } è strutturato: ogni bordo che lascia l'ambito lessicale proprietario attende il proprio gruppo di lavoro prima della pulizia. La cattura è la copia o lo spostamento in base alla funzionalità. Canali, join digitati, eventi, cancellazione e sincronizzazione sono forniti dall'ordinario compiler/llvm/libs/task pacchetto. La grammatica pulita non ha built-in chan<t>, send, recvo spawn distaccato.

Substrato non sicuro

raw_try_alloc<t>, raw_null<t>, raw_is_null<t>, raw_read<t>, raw_write<t>, raw_free<t>, raw_slice<t>, atomici, accesso volatile, recinzioni, cast dello spazio degli indirizzi, assemblaggio grezzo, FFI, le chiamate di sistema e le unioni grezze richiedono unsafe. Le normali applicazioni dovrebbero utilizzare wrapper sicuri dalle librerie.

Lanciatore di archivi

./seed/seed check [--lib] [path|file.sd]
./seed/seed build [path] [-o output] [compiler flags]
./seed/seed run [path] [-- program arguments]
./seed/seed test [path] [compiler flags]
./seed/seed format [--check] [file.sd]
./seed/seed new path [--name package_name]
./seed/seed pkg resolve|add|update|prune ...
./seed/seed install [path|package] [--profile release] [--system] [--prefix path] [--dry-run]
./seed/seed uninstall package [--system] [--prefix path] [--dry-run]
./seed/seed doc [path] [--output file]
./seed/seed lint [--json] [path]
./seed/seed lsp
./seed/seed publish --check [path]
./seed/seed mobile android <setup|build|stage|check|package|run|doctor>

check è un controllo ristretto della fonte diretta. Si risolve in modo relativo source/interface importazioni e manifesto locale path dipendenze; non compila prima un pacchetto di repository nudo mancante. Utilizzare build o run durante la convalida dell'integrazione del pacchetto che dipende dalla gestione temporanea automatica della libreria principale.

build esegue la compilazione incrementale con risoluzione automatica delle dipendenze. Importazioni di pacchetti semplici (ad es. use "vec") sono allestiti in modo isolato target/profile negozio. Una seconda build riutilizza la corrispondenza .sdi/artefatti nativi. test inoltra i flag finali del compilatore, inclusi quelli ripetuti --link-object e --link-library input, a ogni binario di test. Ciò è necessario per i test della libreria la cui superficie Seed sicura è supportata da un nativo esterno ABI.

install compila il pacchetto in modalità di rilascio e lo installa a livello di sistema: eseguibili in ~/.local/bin (o /usr/local/bin con --system), generazioni di dipendenza a ~/.local/lib/seed/generations/e si interfaccia con ~/.local/share/seed/interfaces/. Utilizzare --profile debug per build di debug e --prefix /custom/path per posizioni di installazione personalizzate.

uninstall rimuove un pacchetto precedentemente installato e le relative generazioni di dipendenze. Sia install che uninstall supportano --dry-run per l'anteprima. Il record transazionale del pacchetto installato include destinazione, profilo, identità di generazione delle dipendenze, checksum del compilatore, checksum dell'artefatto installato, checksum dell'origine e checksum del blocco in modo che un'applicazione distribuita possa essere tracciata fino ai suoi esatti input di build.

La pubblicazione remota è separata; seed publish --check convalida l'integrità del pacchetto e del blocco localmente senza eseguire script senza restrizioni. I pacchetti compilati utilizzano la destinazione qualificata .sdi inoltre --install-library/--install-interface. I monorepos locali possono mantenere più pacchetti con versione indipendente collegati da relative path dipendenze. I checksum dell'albero guidano le ricostruzioni; lo sviluppo locale ordinario non richiede un repository, un tag o una pubblicazione Git per ciascuna libreria.

Il programma di avvio legge [build].profile = "debug" | "release" | "release-small"; il vecchio release = true è mappato su release. Un profilo CLI esplicito sovrascrive il manifest. Per impostazione predefinita seed install viene rilasciato indipendentemente dal manifest a meno che --profile non sia esplicito. L'impostazione predefinita delle applicazioni è src/main.sd; una cassaforte relativa opzionale [package].entry seleziona un'altra fonte all'interno del pacchetto. Le importazioni di pacchetti semplici si risolvono prima con gli artefatti installati corrispondenti; altrimenti vengono compilati con il profilo dell'applicazione in un archivio target/profile isolato. Le build ospitate li collegano dinamicamente per impostazione predefinita. Una seconda build riutilizza gli artefatti .sdi/nativi corrispondenti; le modifiche alla libreria dinamica privata non ricostruiscono i consumer, mentre le modifiche pubbliche .sdi o ABI lo fanno.

L'installazione dell'utente inserisce gli eseguibili ~/.local/bin, generazioni di dipendenza immutabile in ~/.local/lib/seede i mirror dell'interfaccia con versione sono sotto ~/.local/share/seed/interfaces. --system utilizza l'ambito del sistema della piattaforma (/usr/local su Unix); --prefix sovrascrive la radice. L'installazione e la rimozione sono registrate in base alla proprietà e sono atomiche e nessun comando modifica silenziosamente i file di avvio della shell o le variabili di ambiente del caricatore.

Operatori

Precedenza binaria dal più alto al più basso:

1. moltiplicativo (*, /, %)
2. additivo (+, -)
3. turni (<<, >>)
4. confronti (<, <=, >, >=)
5. uguaglianza (==, !=)
6. AND bit per bit (&), XOR (^), OR (|)
7. AND logico (&&)
8. OR logico (||)

&& e || cortocircuito: a && b valuta b solo quando a è true, e a || b valuta b solo quando a è false. Entrambi gli operandi devono esserlo bool e il risultato è bool. Il cortocircuito si applica anche al ripiegamento costante, quindi false && expensive() e true || expensive() sono espressioni costanti valide anche quando expensive() non è costante.

Compilatore pulito diretto

L'eseguibile è compiler/llvm/build/seed. Il suo elenco di flag autorevole è seed --help.

# Source processing
seed --check source.sd
seed --format|--format-check|--format-write source.sd

# Code generation
seed --emit-llvm out.ll source.sd
seed --emit-object out.o source.sd
seed --emit-binary out source.sd
seed --emit-shared library.so source.sd
seed --emit-static-library library.a source.sd
seed --emit-raw out.bin source.sd
seed --run source.sd -- arguments

# Interface inspection
seed --interface-print file.sdi
seed --interface-hash file.sdi
seed --emit-interface out.sdi source.sd

# Library management
seed --install-library artifact --install-interface file.sdi --package name [--seed-home path]

# Debug dumps
seed --lex source.sd
seed --ast-print source.sd
seed --types-print source.sd
seed --symbols-print source.sd
seed --hir-print source.sd
seed --safety-print source.sd
seed --mir-print source.sd
seed --layout-print source.sd
seed --abi-print source.sd
seed --low-mir-print source.sd
seed --llvm-print source.sd

# Build options
seed --release source.sd
seed --release-small source.sd
seed --thin-lto source.sd
seed --pgo-generate dir source.sd
seed --pgo-use profile source.sd
seed --profile-print source.sd
seed --target target source.sd
seed --runtime linux-native|linux-libc source.sd
seed --runtime-profile profile source.sd
seed --runtime-feature feature source.sd
seed --static source.sd
seed --static=all source.sd
seed --sysroot path source.sd
seed --soname name source.sd
seed --entry symbol source.sd
seed --linker-script path source.sd
seed --code-model model source.sd
seed --relocation-model model source.sd
seed --no-red-zone source.sd
seed --link-object file.o source.sd
seed --link-library lib.so|lib.a|package source.sd
seed --cache-dir path source.sd
seed --seed-home path source.sd
seed --package name source.sd

# Diagnostics
seed --diagnostics human|json source.sd
seed --version
seed --help

Debug/inspection le modalità includono token, AST, tipi, simboli, HIR, sicurezza, MIR, layout, ABI, MIR basso e LLVM stampa. Target/runtime le opzioni includono --target, --runtime-profile, --runtime-feature, --runtime, --sysroot, entry/linker-script controlli e separati object/library collegamento.

--release usi seed-safe-o2-v1; --release-small usi seed-safe-oz-v1. Entrambi sono sicuri. ThinLTO e PGO sono opzioni esplicite di sola versione; il collegamento statico è indipendente. Non esiste alcun operativo --unchecked o --fast-unsafe profilo.

Stato dell'obiettivo

Il supporto degli oggetti e il supporto ospitato end-to-end sono affermazioni separate. Linux x86-64/AArch64 sono i percorsi ospitati chiusi. Indipendente x86-64/AArch64/RISC-V64 avere prove di avvio ai livelli dichiarati. Windows x86-64 ha PE/runtime/DLL/ task/network prova sotto richiesta Vino. macOS x86-64 e arm64 hanno l'SDK esplicito executable/dylib/static collegamento, runtime e pianificazione pthread. Intel nativa x86-64 l'esecuzione rimane; arm64 è solo cross-link. Vedi compiler/llvm/tests/GATE14_TARGET_MATRIX.tsv.

Su un Mac Intel, esegui SEED_MACOS_RUNNER_POLICY=required make -C seed/compiler/llvm gate14-macos-x86_64-test. Lo script rileva l'SDK con xcrun e utilizza ld di Apple a meno che non venga sovrascritto esplicitamente.