Referencia de idioma

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

Esta página es la referencia orientada al usuario para el actual seed Especificación de idioma. Los capítulos completos de gramática y semántica operativa se encuentran bajo compiler/llvm. Para conocer los límites actuales y las reclamaciones de cierre, consulte Estado actual.

Codificación fuente y nombres.

.sd los archivos son UTF-8. Los comentarios y el contenido de las cadenas pueden contener Unicode. string posee valido UTF-8 y str es un préstamo de solo lectura UTF-8 Vista de puntero más longitud de bytes. La longitud del texto se mide en bytes; Las operaciones Unicode escalares, grafemas, normalización y configuración regional pertenecen a las bibliotecas.

Los identificadores de fuente utilizan intencionalmente ASCII:

amable regla Ejemplo
variable, función, campo, módulo [a-z][a-z0-9_]* my_document
estructura, enumeración, unión, rasgo, parámetro genérico [A-Z][a-zA-Z0-9]* Document, T
variante de enumeración [A-Z][a-zA-Z0-9]* Some, Ok, Red
constante [A-Z][A-Z0-9_]* MAX_DOCUMENT_SIZE

El nombre del idioma formal es seed, siempre en minúsculas. Los nombres de los valores utilizan minúsculas tipo serpiente; Los tipos nominales y las variantes de enumeración utilizan UpperCamelCase y coinciden con [A-Z][a-zA-Z0-9]*. Las constantes usan mayúsculas de serpiente. _ es el enlace de descarte; un guión bajo inicial puede marcar un enlace privado no utilizado intencionalmente.

Los comentarios de línea comienzan con //. Bloquear comentarios /* ... */ nido. La gramática limpia no utiliza # comentarios.

El cargador de origen valida todo el archivo como UTF-8 antes de procesarlo y rechaza NUL incrustado; Los literales de cadena decodificados también se validan.

Enlaces, constantes y mutaciones.

const MAX_COUNT: usize = 100

fn release(ticket: i64) {}

fn main() -> i64 {
    let answer = 42
    let mut count: usize = 0
    count += 1
    let linear ticket = 7
    release(ticket)
    if count < MAX_COUNT { answer } else { 0 }
}

El compilador actual también acepta expresiones escalares escritas, tablas de constantes fijas privadas u32 como const TABLE: [4]u32 = [1 as u32, 2 as u32, 3 as u32, 4 as u32], texto estático, tuplas y estructuras. Las lecturas indexadas y de campo utilizan almacenamiento estático inmutable con comprobaciones de límites ordinarias. Los valores agregados públicos conservan su representación recursiva en las compilaciones eliminadas del código fuente del esquema 14.

La anotación de tipo constante es opcional y coincide con const_decl = "const", constant_ident, [ ":", type ], "=", expression: una constante sin anotaciones infiere su tipo a partir de su inicializador (const MAX_ITEMS = 64 es i64, const OFFSETS = [1, 4, 9] es [3]i64), incluido texto estático, tuplas, estructuras y constantes con nombre. Un inicializador cuyo tipo no se puede inferir necesita una anotación explícita y se rechaza con R037 en la declaración.

Los enlaces son inmutables a menos que se declare mut. La asignación a un enlace, campo o índice a través de un enlace requiere que ese enlace sea mutable. linear crea una obligación exactamente una vez.

let también acepta patrones irrefutables: desestructuración de tuplas (let (a, b) = pair), desestructuración de estructuras (let Point { x, y } = origin), comodines (_) y anidamiento. Cada hoja nombrada se convierte en un enlace ordinario que se saca del componente del inicializador, por lo que la propiedad, la linealidad y la limpieza rastrean los componentes de forma independiente. Se rechazan los patrones refutables (variantes, literales) (error[B043]); use match para esos.

Una anotación let acepta cualquier tipo válido en una posición de parámetro (matrices, sectores, tuplas, punteros, tipos de funciones, genéricos, nombres calificados) y se compara con el tipo de inicializador inferido (error[H059] en caso de discrepancia). Las consultas de diseño en tiempo de compilación size_of(type) y align_of(type) se evalúan con respecto al objetivo activo y son válidas en contextos constantes: inicializadores constantes y longitudes de matriz como [size_of(i64)]u8; en otros lugares se rechazan con error[H129].

Para descartar un valor de retorno, utilice let _ = expression que evalúa y limpia el valor sin crear un vínculo; repetido _ en un ámbito es legal y _ nunca es accesible. let _unused = expression con un guión bajo al principio también marca un enlace no utilizado intencionalmente, pero crea un enlace con nombre.

Funciones, métodos y retornos.

struct Document {
    title: string
}

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

@borrow
fn Document.title_size() -> usize {
    len(self.title)
}

@mut
fn Document.rename(next: string) {
    self.title = move next
}

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

La expresión final de un bloque es su valor. return expression regresa temprano; el compilador limpio no utiliza ret. Una declaración de método incluye el tipo nominal antes del punto y recibe implícitamente self; no escriba self en su lista de parámetros. fn TypeName.drop() es un destructor consumidor. @borrow en un método o método de rasgo le da a self un préstamo léxico compartido. En cambio, @mut requiere un receptor direccionable mutable, tiene un préstamo exclusivo para la llamada y hace que las mutaciones en self sean visibles para la persona que llama. Los dos atributos son mutuamente excluyentes.

str los retornos se basan en la procedencia, no se limitan a los métodos: una función gratuita puede devolver una vista estática o derivada de una entrada. Una vista derivada de un local de propiedad. string/bytes el valor no puede escapar (V001); devolver al propietario cuando la propiedad deba abandonar la función. No existe una sintaxis de por vida.

Uso de declaraciones públicas pub. Las declaraciones extranjeras utilizan explícitamente extern llamando convention/link metadatos y no es seguro llamarlos hasta que estén incluidos en una función segura auditada. La clasificación de argumentos de la plataforma C es específica del objetivo: Windows x86-64 pasa parámetros agregados de más de ocho bytes indirectamente, por lo que str, cortes y estructuras C equivalentes interoperan con MinGW/MSVC-style destinatarios.

Tipos de núcleos

categoría Tipos
controlar void, never, bool
entero i8, i16, i32, i64, u8, u16, u32, u64, isize, usize; byte alias u8
flotar f32, f64
text/buffer str, string, bytes, shared_bytes
formateo format_args (efímero)
aggregate/view [N]T, []T, mut []T, tuplas, nominales structs/enums/unions
fracaso ?T, Result<T, E>, alloc_error
invocable no propietario fn(T) -> U, escapando box fn(T) -> U
bajo nivel punteros sin procesar más user, kernel, physical, mmio, y dma espacios de direcciones
exactamente una vez linear T

AllocResult<T> abrevia Result<T, alloc_error> sin introducir una nueva identidad de tipo, representación, regla de limpieza o ABI.

El main alojado puede devolver Result<i64, E>. Ok(status) sale con ese estado; alloc_error utiliza el diagnóstico de asignación fija. Otro E debe ser Copiar, no tener destructor e implementar @borrow fn E.display() -> str; su vista se escribe una vez antes del estado 1, después de la limpieza ordinaria.

@static_view extern fn ... es la declaración FFI auditada para un retorno str/slice cuyo almacenamiento es process/static vida. El atributo se rechaza en ordinario. seed funciona y no hace que la llamada al exterior sea segura.

Los atributos de efecto pueden anotar declaraciones fn: @no_alloc, @allocates, @blocking, @panics, @io, @interrupt_safe. Los tipos de devolución de llamada calificados utilizan @no_runtime_effects fn(...) -> T para declarar un resumen de efectos vacío completo. Un unsafe struct puede declarar @unsafe_send para afirmar la capacidad de envío, o @repr("null_niche") para habilitar la optimización de puntero nulo en un único campo de puntero sin formato para ?Wrapper.

El entero add/subtract/multiply se ajusta de forma determinista al ancho del tipo. División por cero, mínimo con signo dividido por -1, turnos no válidos, conversiones seguras no válidas y trampa de indexación segura fallida. Los perfiles de versión conservan estas reglas. La ampliación explícita de enteros utiliza la firma de la fuente; el estrechamiento mantiene bits bajos y los cambios de signo de igual ancho preservan los bits. Integer/float y las conversiones de ancho flotante siguen la conversión IEEE-754. El valor flotante a entero requiere unsafe y una entrada representable de destino finito.

Uso de bytes literales b'A' y tener tipo u8. Un byte ASCII sin procesar o uno \\n/\\r/\\t/\\0/\\\\/\\'/\\xNN Se acepta la fuga. uso b'\\xFF' para un byte que no sea ASCII; seed deliberadamente no tiene ningún tipo literal de carácter dependiente de la configuración regional.

Los literales enteros son decimales, 0x hexadecimal o 0b binario, con _ como separador de dígitos opcional (20_000_000, 0xFF, 0b1010). Cada forma aceptada llega a Codegen en todos los lugares donde se permite un literal, incluidos los literales de matriz y los literales repetidos.

Un literal de matriz repetida llena una matriz fija a partir de un literal: let slots: [4]usize = [0; 4], [255; 3], [[0; 2]; 3]. El tipo de elemento proviene de la anotación o del tipo esperado de la matriz, por lo que no es necesaria ninguna conversión. El valor debe ser un literal (o una conversión de uno, o una matriz de ellos): un valor de lugar o de llamada se rechaza como B048 en lugar de evaluarse silenciosamente una vez por elemento, y el recuento debe ser un literal entero positivo (B049) de como máximo 65536 (B050), porque los elementos se materializan individualmente; los rellenos más grandes pertenecen a un búfer de montón o a un bucle explícito.

Estructuras, ADT y sindicatos

struct Document {
    title: string
}

enum LookupResult {
    Found(Document)
    Missing
}

union ScalarBits {
    integer: u64
    decimal: f64
}

trait Identity {
    fn id() -> i64
}

Un literal de estructura es Document { title: owned_title }. Un constructor de ADT está cualificado, por ejemplo LookupResult.Found(value), y su carga útil se inspecciona mediante un exhaustivo match. Una enumeración sin carga útil:

enum Color { Red Green Blue }

La unión sin formato construction/access no es segura. Las alternativas etiquetadas seguras utilizan ADT.

Opciones, resultados y propagación.

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) y None de tipo esperado construyen una opción. Ok(value) y Err(problem) construyen un resultado. ? consume el contenedor, genera su carga útil success/present o devuelve el error correspondiente de la función actual. La propagación de resultados puede cambiar el tipo de éxito pero debe preservar el tipo de error. No realiza ninguna asignación ni clonación implícita.

is_some/is_none y is_ok/is_error inspeccionar mediante préstamo compartido. unwrap_or(fallback) consume el contenedor y limpia el valor de propiedad no seleccionado exactamente una vez. or_abort(), expect(message)y solo principal or_exit(status) son límites de aplicación explícitos; nunca se esconden dentro de lo ordinario ? propagación.

? puede cruzar un límite spawn cuando el cuerpo es falible: spawn { fallible_work()? } almacena Result<T, E> en una celda de unión y la expresión spawn produce un identificador task_join cuyo wait() devuelve Result<T, E>; la carga útil y el error deben ser tipos de copia sin destructores. Un ? dentro de un cierre anidado en un cuerpo de generación vacío aún se rechaza.

Controlar el flujo y los patrones

Las formas de control implementadas están orientadas a expresiones. if/else if/else, while, loop, for, exhaustivo match, bloques, break, continue, y return. else if es la ortografía requerida; elif no es aceptado. Los brazos coincidentes no necesitan comas a menos que el límite sea ambiguo: un brazo cuyo cuerpo termina en una expresión seguida de una (/[ El patrón requiere la coma (B044). Cubierta de patrones bindings/discards, literales, tuplas, estructuras y variantes ADT calificadas; Los guardias mantienen una vigilancia de solo movimiento hasta que el brazo seleccionado realmente la transfiere. _ es un verdadero enlace de descarte: let _ = expr evalúa y limpia sin atar, repetido _ en un ámbito es legal, y _ nunca es accesible. ref es un modificador de patrón contextual que vincula una carga útil de solo movimiento mediante un préstamo de solo lectura cuando el escrutado es un lugar prestado (Some(ref info) en un @borrow self campo); los enlaces de referencia no se pueden mover ni mutar, ref _ se descarta sin moverse, y una partida en la que cada carga útil de solo movimiento está vinculada a la referencia no consume el escrutinio. Escrutadores temporales cuyas cargas útiles de transferencia de armas de solo movimiento se materializan en un enlace de propiedad implícito, por lo que match fallible() { Ok(v) => ... } compila sin let x = expr envoltorio.

if let y while let son las formas concisas terminadas match: if let Some(x) = found { ... } else { ... } y while let Some(x) = next { ... }. Ambos se desazuran a un partido a dos brazos, tan vinculante, move/borrow El comportamiento y la limpieza son exactamente las reglas del partido. if let Some(...) nombra su complemento None; cualquier otro patrón variante mantiene un brazo comodín, y H032 rechaza que cuando el escrutado lleve una carga útil de solo movimiento - escriba el explícito match brazos allí. Un patrón irrefutable (while let name = value) es rechazado como H029.

for sobre rangos, matrices fijas y cortes se reduce a un nivel libre de asignación index/length bucle. for index, value in enumerate(items) agrega un usize índice sin un iterador de montón. Los elementos de solo movimiento requieren explícita indexing/ownership manipulación.

Texto, vistas y conversiones

La interpolación phase-1/2 escrita no tiene asignación a menos que se materialice explícitamente:

use "file"

fn main() -> Result<i64, alloc_error> {
    let name = "widget"
    let count = 3
    write_stdout_format(f"name={name} count={count} braces={{ok}}\n")
    let message = f"count={count}".to_string()?
    Ok(len(message) as i64)
}

Las expresiones se evalúan una vez de izquierda a derecha. Los valores admitidos son str, prestado string, booly enteros integrados, como expresiones arbitrarias, no solo nombres: llamadas, operadores y anidamiento, todo funciona (f"{a + b}", f"{p.distance()}"). lo efímero format_args El resultado debe pasarse directamente o consumirse por .to_string()?; no se puede asignar con let, devuelto, capturado o almacenado. Integer/text/bool Se implementan especificaciones de ancho, relleno, alineación y base de números enteros. Uso de tipos personalizados trait Display { @borrow fn display() -> str } con despacho estático directo. Los flotantes admiten la salida general predeterminada más f/F, e/E, y g/G con precisión hasta 18. Personalizado :? el formateo utiliza el análogo prestado Debug.debug() -> str rasgo.

Genéricos y rasgos

Los parámetros genéricos utilizan UpperCamelCase. Las definiciones se comparan con sus límites y luego las instancias alcanzables concretas se monomorfizan. Un parámetro puede declarar múltiples límites de rasgos con + (fn f<T: Metric + Named>(x: T)); cada límite debe nombrar un rasgo declarado, el argumento debe implementarlos todos (error[H072] por límite faltante), y los métodos de rasgo se resuelven a través de cualquier límite. Los bloques impl pueden ser genéricos en sí mismos: impl<T: Show> Show for Pair<T> implementa el rasgo para cada instancia cuyos argumentos satisfacen los límites del impl; los argumentos de destino deben ser exactamente los parámetros del impl en orden (error[P042]), y se rechaza un impl genérico que se superpone a otro impl del mismo rasgo para el mismo tipo (error[R019]). El envío de rasgos es estático y directo: no hay vtables, boxeo, asignación o clonación implícitos. Se verifican la integridad implícita, las firmas, la coherencia y las reglas huérfanas. Plantillas genéricas públicas, instancias comunes, efímeras. format_args Los parámetros, la representación nominal de nicho nulo, los receptores mutables exclusivos, las devoluciones de llamadas calificadas y las firmas invocables en cuadros persisten a través del esquema actual-17. .sdi. Las instancias de métodos materializados se exportan únicamente mediante una interfaz que también posee la definición del método genérico. Por lo tanto, un contenedor alrededor de un tipo genérico importado registra su contrato público sin una especialización huérfana; un consumidor excluido del código fuente obtiene la plantilla del método de la interfaz de dependencia del contenedor y materializa la instancia concreta allí.

inline fn solicita una inserción limitada. Un pub inline fn publica su cuerpo verificado y su hash de cuerpo determinista en el esquema-13 .sdi mientras conserva un símbolo alternativo exportado. Las declaraciones en línea tienen un presupuesto de origen de 4096 bytes; un cambio de cuerpo invalida los artefactos dependientes. Las particiones de sectores mutables utilizan view.split_at_mut(index) y los patrones de tupla pueden declarar enlaces mutables como (mut left, mut right). La división verifica index <= len, no asigna nada y mantiene al propietario común en préstamo exclusivo hasta que ambos hermanos mueren.

Cierres y devoluciones de llamada

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

fn main() -> i64 {
    let base = 40
    let total = apply([1, 2, 3], |value: i64| base + value)
    let retained = (box |value: i64| base + value).or_abort()
    total + retained(1)
}

|...| y la posición de prefijo || crean llamadas anónimas. Los tipos de parámetros se pueden omitir cuando un fn(...) -> T esperado los proporciona. Un cierre simple utiliza almacenamiento de captura de pila, no asigna nada y no puede escapar de su propietario léxico. Copia de capturas con capacidad de copia; las capturas propias se mueven; las capturas son inmutables. Se rechazan las capturas prestadas, mutables, ligadas a regiones, ya trasladadas y otras capturas que no son seguras para almacenar.

box |...| es la forma de escape explícita y devuelve Result<box fn(...) -> T, alloc_error>. El propietario puede almacenarse o devolverse, pero solo se puede mover, no se puede clonar ni enviar. Drop destruye sus capturas exactamente una vez y libera su asignación. La asignación de regiones sigue siendo léxica. No existe una conversión implícita entre cierres de pila y de caja.

Las devoluciones de llamada de semilla fn(...) -> T utilizan un descriptor code/environment de un solo puntero. Los punteros de función C/platform permanecen delgados y solo aceptan funciones con nombre. Los efectos de cierre se infieren del cuerpo y se comparan con contratos de devolución de llamada calificados, como @no_runtime_effects fn() -> void. Los cierres recursivos no son compatibles.

Resumen de propiedad

Consulte Ownership para conocer el modelo operativo.

Regiones, tareas y bibliotecas

region(capacity) { body } instala un asignador de realces comprobados léxicos. Los valores, vistas o indicadores vinculados a la región no pueden escapar. Las tareas estructuradas capturadas dentro de una región se unen antes de que se libere su almacenamiento de respaldo.

spawn { body } está estructurado: cada borde que sale del alcance léxico propietario espera a su grupo de tareas antes de la limpieza. Capturar es copiar o mover según la capacidad. Un cuerpo falible (? adentro, o una cola de tipo Result<T, E>) produce una combinación escrita: el esquema almacena el resultado en una celda de combinación y handle.wait() regresa Result<T, E>; task_result_* permanece para uniones manuales. Los canales, uniones escritas, eventos, cancelación y sincronización son proporcionados por el ordinario. compiler/llvm/libs/task paquete. La gramática limpia no tiene incorporada chan<t>, send, recv, o desove separado.

use "name" importa un módulo de origen o una interfaz .sdi eliminada del origen. Las funciones públicas importadas se pueden llamar con o sin su calificador de módulo: use "process" hace que tanto environment("HOME") como process.environment("HOME") sean válidos. Un símbolo calificado desconocido informa error[H002]: unknown symbol in module.

Sustrato inseguro

raw_try_alloc<t>, raw_null<t>, raw_is_null<t>, raw_read<t>, raw_write<t>, raw_free<t>, raw_slice<t>, atómica, acceso volátil, vallas, conversiones de espacio de direcciones, ensamblaje sin formato, FFI, llamadas al sistema y uniones sin formato requieren unsafe. Las aplicaciones normales deberían consumir contenedores seguros de las bibliotecas.

Lanzador de repositorio

./seed/seed check [--lib] [path|file.sd]
./seed/seed check [--json|--deep] [--report report.json] [--max-ms n] [--max-rss-kib n] [--max-files n] [--max-loc n] [--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 fmt [--check] [file.sd]  # short alias
./seed/seed fmt --write directory/
./seed/seed fmt --check --json [--output file] [file.sd|directory]

With `--check`, a directory recursively checks its `.sd` files; `.git`,
`target`, and `.seed` directories are ignored.
With `--json`, the formatter emits `seed.format.v1` with per-file status and
stable checked/needs-format/error counts; a non-zero status still includes the
complete JSON result.
./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] [--json] [--check-links] [--output file]
./seed/seed lint [--json] [--deny-warnings] [--cache dir] [--no-cache] [--fix] [--output file] [path]
./seed/seed explain [--json] CODE
./seed/seed explain [--json] --list
./seed/seed lsp
./seed/seed repl [--json]
./seed/seed publish --check [--json] [path]
./seed/seed publish --check [path]
./seed/seed mobile android <setup|sign|build|stage|check|package|run|doctor>

check es una verificación estrecha de fuente directa que ejecuta todo el proceso semántico, incluidas todas las pruebas de seguridad obligatorias (propiedad, procedencia, efectos, limpieza, préstamos, concurrencia); la reutilización de un HIR almacenado en caché no evita ninguno de ellos. check --deep agrega solo el pase didáctico de pelusa después de pasar la verificación semántica; nunca reemplaza una prueba. Se resuelve relativo source/interface importaciones y manifiesto local path dependencias; no compila primero un paquete de repositorio básico que falta. uso build o run al validar la integración de paquetes que depende de la preparación automática de la biblioteca central.

check --report report.json escribe un determinista seed.check-report.v1 resumen con la fuente, file/LOC recuentos, indicador de modo profundo, resultado, tiempo total transcurrido y fases separadas de resolución de fuente, verificación semántica y (cuando se solicite) de pelusa profunda. En hosts POSIX también registra peak_child_rss_kib para el compiler/lint subprocesos. Si falla la pelusa profunda, el informe marca tanto la fase de pelusa profunda como el resultado general como fail e incluye su error/warning cuenta. El informe también incluye tiempos de fase del compilador interno y RSS pico cuando el LLVM El perfilador está disponible. --max-ms y --max-rss-kib agregar presupuestos de CI explícitos; son verificaciones posteriores a la ejecución: el subproceso del compilador se ejecuta hasta su finalización, luego las herramientas juzgan el tiempo de la pared (desde el inicio de la herramienta) y el RSS máximo secundario contra los techos. Los presupuestos excedidos se registran en el informe y fallan el comando después de emitir una salida estructurada (budgets.violations más el distinto check budget exceeded error). --max-files y --max-loc aplique la misma política al tamaño de fuente alcanzable.

Los fallos del compilador se dividen en dos clases. Una falla semántica es una violación del programa reportada como diagnóstico específico (códigos como S001, H022) con tramos, notas y ayuda. Una falla de infraestructura (compilador sin memoria o violación del contrato de la cadena de herramientas) se informa como error[I-code]: detail (I900 respaldo) o el mensaje genérico "el compilador se quedó sin memoria o violó un contrato de infraestructura", sin que se publique ningún artefacto de salida. Tampoco lo es el lado del programa. alloc_error, que es un tipo de resultado de tiempo de ejecución recuperable dentro de los programas generados (consulte el capítulo sobre propiedad).

check --json emite los diagnósticos legibles por máquina del compilador más el marcado source y un establo summary con error/warning cuenta. Se puede combinar con --deep para incluir el seed.lint.v1 carga útil de pelusa profunda; agregar --deny-warnings para hacer que las advertencias del compilador y de deep-lint no pasen la verificación mientras aún se emite el mensaje completo JSON sobre. --output file escribe eso JSON atómicamente y mantiene la salida estándar limpia, incluso cuando falla la verificación.

doc --json emite un seed.doc.v1 Índice de documentación que contiene declaraciones públicas, Markdown renderizado, dependencias solo de interfaz y diagnósticos de enlaces estructurados. doc --check-links convierte los enlaces no resueltos en un estado fallido. lint --deny-warnings de manera similar, convierte las advertencias de pelusa en un estado fallido sin cambiar el comportamiento de advertencia predeterminado; lint --output file escribe el JSON o resultado de texto de forma atómica, incluso en una ejecución de pelusa fallida. Los resultados de Lint se reutilizan desde un caché por fuente con dirección de contenido en .seed/cache/lint por defecto; --cache dir o SEED_LINT_CACHE lo anula, y --no-cache obliga a correr en frío. --prune-days N elimina las entradas de caché antiguas e informa el recuento. SEED_BUILD_JOBS controla las comprobaciones de fuentes paralelas limitadas y al mismo tiempo preserva el orden de diagnóstico. Las entradas de caché utilizan el seed.lint-cache.v1 sobre; Las entradas con formato incorrecto o antiguas se reconstruyen y se informan como cache.invalidated. Sólo documentación L001 los diagnósticos se almacenan en caché de forma independiente según la declaración pública, por lo que las ediciones no relacionadas pueden reutilizarlos; La verificación semántica sigue siendo de fuente completa. --fix aplica solo correcciones seguras de comentarios de documentación y deshabilita la reutilización de caché para esa ejecución.

La caché HIR verificada del compilador se puede mantener explícitamente con --cache-prune-days N junto con --cache-dir dir. Elimina sólo los archivos de identidad .hci normales y antiguos de ese directorio; Se conservan los archivos no relacionados, enlaces simbólicos, publicaciones temporales y entradas recientes. La poda es consultiva y nunca pasa por alto la compilación o la verificación de seguridad.

explain --json CODE emite un registro seed.explain.v1 que contiene el título, el significado, un ejemplo no válido y una guía de reparación para un código de diagnóstico. Sin --json, conserva la explicación detallada orientada al ser humano. explain --list enumera el catálogo disponible; El modo JSON emite seed.explain-catalog.v1 con los registros estructurados completos.

repl es una sesión orientada a líneas de verificación únicamente. Cada línea ingresada se valida como parte de la actual fn main región antes de ser aceptado. Uso de regiones multilínea :begin y :end transaccionalmente; :check, :show, :reset, :undo, :help, y :quit gestionar la sesión. :show imprime solo la región aceptada, excluyendo cualquier transacción abierta. No ejecuta código ni debilita las reglas de propiedad. La finalización de LSP sigue la gramática actual, incluida return, loop, break, y continue; No se sugieren las ortografías heredadas eliminadas. repl --json emite uno seed.repl-event.v1 JSON objeto por evento para editores y consumidores de automatización, incluidas líneas de transacciones pendientes y salida de sesión. check --max-files N y check --max-loc N Rechazar proyectos que superen los presupuestos explícitos a escala de fuentes accesibles y registrar las infracciones en el informe de verificación. JSON sobre de diagnóstico. el JSON El sobre también expone lo observado. metrics para archivos accesibles, LOC, milisegundos transcurridos y RSS secundario máximo. el result El campo es explícitamente pass o fail, incluidos los fracasos presupuestarios. con --report, JSON El modo también incorpora el informe de fase completo mientras escribe el archivo de informe solicitado de forma atómica.

publish --check --json emite seed.publish-check.v1 con el paquete, versión y pass/fail resultado para integraciones de CI; --output file lo escribe atómicamente. Los errores de validación aún devuelven un estado distinto de cero después de emitir el resultado estructurado. Los sobres de falla incluyen estable error_code y el resuelto project, por lo que los consumidores no necesitan analizar el texto de error humano. Las clases conocidas incluyen PUBLISH_MANIFEST, PUBLISH_LICENSE, PUBLISH_DEPENDENCY, PUBLISH_PLATFORM, y PUBLISH_FFI_INSTALL.

build realiza una compilación incremental con resolución automática de dependencias. Importaciones de paquetes básicos (p. ej. use "vec") se organizan en un lugar aislado target/profile tienda. Una segunda compilación reutiliza la coincidencia .sdi/artefactos nativos. test reenvía los indicadores finales del compilador, incluidos los repetidos --link-object y --link-library entradas, a cada binario de prueba. Esto es necesario para las pruebas de biblioteca cuya superficie Seed segura está respaldada por un nativo externo. ABI.

install compila el paquete en modo de lanzamiento y lo instala en todo el sistema: ejecutables para ~/.local/bin (o /usr/local/bin con --system), generaciones de dependencia a ~/.local/lib/seed/generations/e interfaces para ~/.local/share/seed/interfaces/. uso --profile debug para compilaciones de depuración y --prefix /custom/path para ubicaciones de instalación personalizadas.

uninstall elimina un paquete previamente instalado y sus generaciones de dependencia. Tanto install como uninstall admiten --dry-run para vista previa. El registro transaccional del paquete instalado incluye destino, perfil, identidad de generación de dependencia, suma de verificación del compilador, suma de verificación del artefacto instalado, suma de verificación del origen y suma de verificación de bloqueo para que se pueda rastrear una aplicación implementada hasta sus entradas de compilación exactas.

La publicación remota es independiente; seed publish --check valida la integridad del paquete y del bloqueo localmente sin ejecutar scripts sin restricciones. Los paquetes compilados utilizan objetivos calificados. .sdi más --install-library/--install-interface. Paquetes declarando extern fn también debe proporcionar INSTALL.md describir la configuración nativa requerida para sus plataformas declaradas; el archivo debe ser legible UTF-8 y no vacío. Los monorepos locales pueden mantener múltiples paquetes con versiones independientes conectados por path dependencias. Las sumas de verificación de sus árboles impulsan las reconstrucciones; El desarrollo local ordinario no requiere un repositorio, etiqueta o publicación de Git para cada biblioteca.

El lanzador lee [build].profile = "debug" | "release" | "release-small"; legado release = true mapas para release. Un explícito CLI El perfil anula el manifiesto. seed install por defecto se publica independientemente del manifiesto a menos que --profile es explícito. Las aplicaciones están predeterminadas en src/main.sd; un pariente seguro opcional [package].entry selecciona otra fuente dentro del paquete. Las importaciones de paquetes básicos se resuelven primero en hacer coincidir los artefactos instalados; de lo contrario, se compilan con el perfil de la aplicación en un archivo aislado. target/profile tienda. Las compilaciones alojadas las vinculan dinámicamente de forma predeterminada. Una segunda compilación reutiliza la coincidencia .sdi/artefactos nativos; Los cambios privados en la biblioteca dinámica no reconstruyen a los consumidores, mientras que los públicos .sdi o ABI los cambios sí.

La instalación del usuario coloca los ejecutables en ~/.local/bin, dependencia inmutable generaciones en ~/.local/lib/seedy espejos de interfaz versionados en ~/.local/share/seed/interfaces. --system utiliza el alcance del sistema de plataforma (/usr/local en Unix); --prefix anula la raíz. La instalación y eliminación son atómicas y registradas por propiedad, y ningún comando edita silenciosamente los archivos de inicio del shell o las variables de entorno del cargador.

Operadores

Prioridad binaria de mayor a menor:

  1. multiplicativo (*, /, %)
  2. aditivo (+, -)
  3. turnos (<<, >>)
  4. comparaciones (<, <=, >, >=)
  5. igualdad (==, !=)
  6. bit a bit AND (&), XOR (^), O (|)
  7. Y lógico (&&)
  8. O lógico (||)

&& y || cortocircuito: a && b evalúa b solo cuando a es true, y a || b evalúa b solo cuando a es false. Ambos operandos deben ser bool y el resultado es bool. El cortocircuito también se aplica al plegado constante, por lo que false && expensive() y true || expensive() son expresiones constantes válidas incluso cuando expensive() no es constante.

Compilador limpio directo

El ejecutable es compiler/llvm/build/seed. Su lista de banderas autorizadas es 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 Los modos incluyen token, AST, tipos, símbolos, HIR, seguridad, MIR, diseño, ABI, MIR bajo y LLVM impresión. Target/runtime las opciones incluyen --target, --runtime-profile, --runtime-feature, --runtime, --sysroot, entry/linker-script controles y separar object/library vinculación.

--release usos seed-safe-o2-v1; --release-small usos seed-safe-oz-v1. Ambos están a salvo. ThinLTO y PGO son opciones explícitas de solo lanzamiento; El enlace estático es independiente. No hay operativo --unchecked o --fast-unsafe perfil.

Estado objetivo

La compatibilidad con objetos y la compatibilidad con alojamiento de extremo a extremo son afirmaciones independientes. Linux x86-64/AArch64 son las rutas alojadas cerradas. Independiente x86-64/AArch64/RISC-V64 tener evidencia de arranque en sus niveles declarados. Windows x86-64 tiene PE/runtime/DLL/ task/network evidencia bajo vino requerido. macOS x86-64 y arm64 tienen SDK explícito executable/dylib/static vinculación, tiempo de ejecución y programación de subprocesos. Intel nativo x86-64 la ejecución permanece; arm64 es solo de enlace cruzado. Ver compiler/llvm/tests/GATE14_TARGET_MATRIX.tsv.

En una Mac Intel, ejecute SEED_MACOS_RUNNER_POLICY=required make -C seed/compiler/llvm gate14-macos-x86_64-test. El script descubre el SDK con xcrun y utiliza ld de Apple a menos que se anule explícitamente.