Integraciones principales y bibliotecas estándar

seed mantiene pequeño el núcleo del lenguaje. Los archivos, las redes, los procesos, el formato, las colecciones y la sincronización son bibliotecas ordinarias compiladas por separado, no integradas universales. La superficie incorporada del compilador limpio está debajo; el catálogo de paquetes operativo preparado por el compilador está documentado en Referencia de biblioteca, mientras que el árbol Grove de generación mixta se clasifica por separado en Grove Árbol de compatibilidad.

Tipos de núcleos

El compilador define void, never, bool, enteros de ancho fijo, isize, usize, f32, f64, str, string, bytes, shared_bytes, alloc_errory lo escondido region_handle. byte es aceptado como u8. alloc_result<t> es la abreviatura canónica para result<t, alloc_error>. Alojado main() -> result<i64, e> asigna el éxito al estado del proceso. alloc_error tiene el diagnóstico fijo; otro e debe ser Copiar, no tener destructor e implementar prestado display() -> str. El fallo se imprime una vez antes del estado 1, después de la limpieza y sin desenrollarse.

Operaciones seguras conocidas por el compilador

Operación	Contrato
`len(value)`	`usize` byte/element longitud para `str`, `string`, `bytes`, `shared_bytes`, cortes y matrices
`str.bytes()`	vista `[]u8` de solo lectura sin asignación con la procedencia de la fuente
`slice.slice(start, count)`	subvista marcada sin asignación que preserva el tipo de elemento y la mutabilidad
`mut_slice.split_at_mut(index)`	par de vistas léxicas exclusivas y no superpuestas sin asignación marcada
`mut_slice.fill(value)`	llena un segmento de elemento de copia sin asignación
`mut_slice.copy_from(source)`	Transferencia de elementos de copia de igual longitud y segura para superponerse sin asignación
`bytes.into_prefix(length)`	consumir truncamiento lógico comprobado que reutiliza la asignación y la capacidad
`some(value)` / `none`	construcción de opciones canónicas; `none` necesita lo esperado `?t`
`result.ok(value)` / `result.error(problem)`	construcción de resultados canónicos con el esperado `result<t,e>`
`option.is_some()` / `option.is_none()`	inspección prestada sin asignación
`result.is_ok()` / `result.is_error()`	inspección prestada sin asignación
`option_or_result.unwrap_or(value)`	consumir valor predeterminado con limpieza exacta del valor de propiedad no seleccionado
`or_abort()` / `expect(message)`	límite fatal explícito que no se deshace
`or_exit(status)`	límite principal `i64` option/result usando retorno limpio ordinario
`value.clone()`	clon estructural explícito cuando existe capacidad; Se realiza un seguimiento del efecto de asignación.
`string.view()`	prestado sin asignación `str`
`bytes.view()`	Sin asignación, de solo lectura `[]u8`.
`bytes.mutable_view()`	Léxico exclusivo `mut []u8` que cubre toda la longitud asignada.
`bytes.zeroed(length)`	falible inicializado en cero `result<bytes, alloc_error>`; `length` debe ser `i64`
`unsafe { bytes.uninitialized(length) }`	asignación falible de capacidad interna; las personas que llaman deben inicializar cada byte antes de exponer un prefijo
`shared_bytes.view()`	Sin asignación, de solo lectura `[]u8`.
`array.view()` / `array.mutable_view()`	segmento compatible explícito sin asignación; la vista mutable requiere un propietario mutable
`str.equal(other)`	comparación de bytes UTF-8 sin asignación
`str.find_ascii(delimiter, start)`	búsqueda de delimitadores sin asignación marcada; delimitadores no ASCII rechazados
`byte_slice_equal(a, b)`	sin asignación `[]u8` igualdad de longitud y contenido
`sqrt(value)` / `abs(value)` / `min(a, b)` / `max(a, b)`	`f32`/`f64` operaciones matemáticas
`str.slice(start, count)`	subvista de copia cero comprobada que preserva la procedencia
`slice.slice(start, count)`	Subvista genérica de copia cero comprobada `[]t` que preserva la procedencia
`byte_view.equal(other)`	sin asignación `[]u8` igualdad de longitud y contenido
`str.to_string()` / `string.from(view)`	`result<string, alloc_error>`; asignación explícita
`str.to_bytes()` / `bytes.from(view)`	`result<bytes, alloc_error>`; explícito copy/allocation
`bytes.to_shared()` / `shared_bytes.from(data)`	consumir bytes propios; `result<shared_bytes, alloc_error>`
`region(capacity) { body }`	alcance de asignación de impactos verificado léxico
`io.input_stream.read(chunk)`	lectura parcial falible limitada; las personas que llaman pueden procesar EOF/data de forma incremental sin conservar todas las entradas

La indexación segura de arrays/slices acepta cada ancho de entero incorporado y verifica el índice matemático antes de la formación del puntero. Las API de texto exponen bytes; El procesamiento Unicode scalar/grapheme pertenece a las bibliotecas.

Limitación conocida: las lecturas de índice variable (buf[i] donde i es una variable) no se admiten en mut []u8 ni en subporciones derivadas de []u8 a través de .slice(). Las lecturas de índice fijo (buf[0]) funcionan en todos los tipos de sectores. Los parámetros de función directa []u8 y el segmento original de bytes.view() admiten lecturas de índice variable. Para solucionar esta limitación, alcance las vistas mutables dentro de un bloque y use los parámetros de función []u8 de solo lectura o el segmento bytes.view() original para acceso de índice variable.

byte_buffer nota: byte_buffer.mutable_view() devuelve una vista del prefijo inicializado, que tiene una longitud de 0 para un búfer recién creado. Escribir más allá de la longitud devuelta provoca una trampa de fuera de límites. Para escribir en un búfer sin formato, use bytes.zeroed(n) cuyo mutable_view() cubre la asignación total, o el uso byte_buffer metodos push/extend/reserve/resize.

Sustrato de compilador inseguro

Las siguientes operaciones requieren un bloque unsafe o unsafe fn:

familia	Operaciones
memoria bruta escrita	`raw_try_alloc<t>`, `raw_null<t>`, `raw_is_null<t>`, `raw_read<t>`, `raw_write<t>`, `raw_free<t>`, `raw_slice<t>`
atómicos	acquire/release ayudantes más ordenados load/store/fetch-add/exchange/compare-exchange
ordenar	Compilador y vallas atómicas con órdenes de memoria validadas.
dispositivos	volátil escrito read/write y conversiones de espacio de direcciones
arquitectura	intrínsecos de ensamblaje sin procesar mecanografiados
interoperabilidad	punteros sin formato, FFI, llamadas al sistema y uniones sin formato

raw_try_alloc<t> informa el recuento negativo, el desbordamiento de tamaño o el error del asignador como alloc_error. Raw read/write/free depende de la persona que llama insegura auditada para los límites, la inicialización, la procedencia, la sincronización y la liberación exacta.

Paquetes de biblioteca ordinarios

El compilador limpio presenta paquetes representativos en compiler/llvm/libs:

Paquete	Rol
`box`	Dirección indirecta de propiedad segura y falible para valores recursivos y grandes
`byte_buffer`	Construcción, mutación, vistas y consumo de bytes falibles y cultivables. `bytes` conversión
`file`	contenedor output/file alojado durante el tiempo de ejecución ABI
`fibonacci`	iterativo sin asignación O (n) `i64` Fibonacci con explícito negative/overflow `none`
`net`	contenedor de red alojado
`io`	entrada partial/read-all alojada escrita, salida text/bytes/format de escritura total, almacenamiento en búfer limitado y `print`/`println` para salida rápida
`math`	portátil `f32`/`f64` raíz cuadrada, valor absoluto, mínimo y máximo
`parse`	marcado signed/unsigned análisis de enteros y ayudantes predeterminados explícitos
`process`	Argumentos de proceso, vistas del entorno e identidad del proceso sin asignación.
`serialize`	paquete de serialización seguro representativo
`sort`	clasificación escalar de corte mutable y clasificación estática `order_key` para valores de solo movimiento
`slice`	asistentes genéricos de ventana de ancho fijo, rotación y reversa sin asignación; los cortes centrales proporcionan `fill`/`copy_from`
`text`	UTF-8 validación, escalar Unicode verificado sin asignación iteration/counting, conversión de cadena propia y cursores de token delimitados por ASCII
`time`	milisegundos alojados monótonos más reloj de pared Unix seconds/milliseconds
`vec`	vector genérico falible con constructores capacity/filled y `@mut` reserve/push/update/pop, además de cola, conjunto y mapa
`task`	canales de propiedad dividida, one-shot mecanografiados y `result<t,e>` uniones, eventos, cancelaciones, grupos de espera, semáforos, barreras y bloqueos
`system`	contenedores de sistemas seguros sobre espacios de direcciones, MMIO, atomics, páginas, DMA, init-once y mecanismos locales de CPU

El incremental del lanzador build/run path prepara automáticamente estos paquetes principales del repositorio cuando un paquete normal utiliza una importación simple como use "vec" o use "fibonacci"; no se requiere instalación manual de la interfaz ni FFI visible en la aplicación. el más estrecho check El subcomando no prepara primero un paquete básico que falta. Los usuarios directos del compilador pueden consumir una fuente explícita o .sdi paquete. Estos no son nombres de idiomas mágicos.

Formateo y salida

El lenguaje implementa la interpolación phase-1/2 f"..." escrita. Una cadena f produce un format_args efímero sin asignación de montón. compiler/llvm/libs/io es la superficie escrita canónica para salida de texto, segmento de bytes y formato. Para una salida rápida, print(text) escribe en la salida estándar y println(text) escribe con una nueva línea al final. .to_string()? realiza una materialización falible explícita. Se implementan Width/fill/alignment, especificadores de base de números enteros y formato de rasgo display prestado sin asignación. La fase 2 agrega formato fijo, científico y general f32/f64 sin libc, además de rasgos display/debug prestados.

Advertencia de compatibilidad

llvm-v1 e histórico Grove/runtime Las tablas exponen muchos nombres como str_cat, read_file, net_connect, vec_new, y sd_*. Su existencia en un compilador archivado no los convierte en elementos integrados limpios del compilador. Al transferir código heredado, importe o implemente un contenedor seguro actual y deje que su .sdi contrato define propiedad, efectos, ABI y disponibilidad.