Referencia de idioma

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:

El nombre del idioma formal es seed. Los tipos no están en mayúscula. _ descarta un enlace; 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 aplicar lex y rechaza NUL incrustado; Los literales de cadena decodificados también se validan.

Enlaces, constantes y mutaciones.

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

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.

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.

Para descartar un valor de retorno, vincúlelo a un nombre único que comience con _: let _unused = expression. Los descartes con nombre evitan el error de "enlace activo duplicado" que produce el simple let _ = expression cuando se usa varias veces en el mismo ámbito. Un guión bajo inicial en cualquier identificador marca el enlace como no utilizado intencionalmente.

Funciones, métodos y retornos.

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)
}

La expresión final de un bloque es su valor. ret expression regresa temprano; el compilador limpio no utiliza return. 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 type_name.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.

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

alloc_result<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 extranjero 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 efecto 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.

Estructuras, ADT y sindicatos

struct document {
    title: string
}

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

union scalar_bits {
    integer: u64
    decimal: f64
}

Un literal de estructura es document.{ title: owned_title }. Un constructor ADT está calificado, por ejemplo. parse_result.parsed(value), y su carga útil es inspeccionada mediante exhaustivos match. Un ADT sin carga útil reemplaza el legado enum palabra clave:

type 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. result.ok(value) y result.error(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.

? no puede cruzar un límite spawn mientras la tarea descrita ABI devuelve void.

Controlar el flujo y los patrones

Las formas de control implementadas están orientadas a expresiones. if/elif/else, while, for, exhaustivo match, bloques, break, continue, y ret. elif es la ortografía requerida; else if no es aceptado. Los brazos de los partidos no tienen comas. 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.

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

• los literales tienen un tipo prestado estático str;
• El string de propiedad se toma prestado automáticamente como str cuando se espera;
• len devuelve usize para texto, búferes, sectores y matrices;
• string.view() devuelve str;
• bytes.view() y shared_bytes.view() devuelven []u8;
• bytes.mutable_view() devuelve un mut []u8 exclusivo con todo el longitud asignada; bytes.zeroed(length) asigna de manera falible length bytes inicializados en cero y su mutable_view() cubre la asignación completa; byte_buffer.mutable_view() devuelve solo el prefijo inicializado (longitud 0 para un búfer nuevo), no la capacidad; utilice bytes.zeroed cuando se necesite un destino de escritura mutable de longitud completa;
• bytes.zeroed(length) requiere i64 y asigna de manera falible length bytes inicializados en cero;
• los arreglos fijos derivan vistas compartidas compatibles y los arreglos mutables derivan vistas exclusivas;
• str.slice(start, count) está marcado y sin copia;
• Los fragmentos de texto también verifican UTF-8 límites de puntos de código;
• str.equal(other) y str.find_ascii(delimiter, start) marcados son sin asignación; compiler/llvm/libs/text crea un cursor dividido seguro de procedencia de origen a partir de rangos de bytes devueltos;
• []u8.slice(start, count) es una subvista de copia cero marcada y []u8.equal(other) compara longitud y contenido sin asignación;
• str.to_string() / string.from(str) retorno result<string, alloc_error>;
• str.to_bytes() / bytes.from(str) retorno result<bytes, alloc_error>;
• bytes.to_shared() / shared_bytes.from(bytes) consumen el propietario de los bytes y devolver result<shared_bytes, alloc_error>.
• bytes.into_prefix(length) consume al propietario, compara length con el longitud inicializada y devuelve la misma asignación con una longitud lógica más corta. No asigna ni copia; el dueño original se muda.
• [n]t.mutable_view() -> mut []t deriva una vista mutable exclusiva cuando el El propietario de la matriz es mutable.

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

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

Las expresiones se evalúan una vez de izquierda a derecha. Los valores admitidos son str, prestado string, booly enteros integrados. 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 minúsculas tipo serpiente. Las definiciones se comparan con sus límites y luego las instancias alcanzables concretas se monomorfizan. 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-16. .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
}

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

|...| 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

• copia de escalares y agregados de solo copia;
• los recursos se mueven y hacen que el lugar de origen no esté disponible;
• .clone() es explícito y capability/effect está marcado;
• las vistas prestadas tienen procedencia sin sintaxis de por vida;
• la limpieza estructurada se ejecuta exactamente una vez en las salidas estructuradas normales;
• panic/trap/abort no desenrolla ni ejecuta destructores;
• linear t debe consumirse exactamente una vez;
• la propiedad parcial se rastrea a través de campos, campos anidados y matrices conocidas índices, cargas útiles de ADT activas, uniones, genéricos, canales, valores de funciones y .sdi; Los movimientos de recursos de índice dinámico siguen siendo rechazados.

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. 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.

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 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 es una verificación estrecha de fuente directa. 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.

build realiza 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. 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 haciendo 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.