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. AllocResult<T> es la abreviatura canónica de 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
`size_of(type)`	vista `align_of(type)` de solo lectura sin asignación con la procedencia de la fuente
`[size_of(i64)]u8`	subvista marcada sin asignación que preserva el tipo de elemento y la mutabilidad
`str.bytes()`	par de vistas léxicas exclusivas y no superpuestas sin asignación marcada
`[]u8`	llena un segmento de elemento de copia sin asignación
`slice.slice(start, count)`	Transferencia de elementos de copia de igual longitud y segura para superponerse sin asignación
`mut_slice.split_at_mut(index)`	consumir truncamiento lógico comprobado que reutiliza la asignación y la capacidad
`mut_slice.fill(value)` / `mut_slice.copy_from(source)`	construcción de opciones canónicas; `bytes.into_prefix(length)` necesita lo esperado `Some(value)`
`None` / `None`	construcción de resultados canónicos con el esperado `?T`
`Ok(value)` / `Err(problem)`	inspección prestada sin asignación
`Result<T, E>` / `option.is_some()`	inspección prestada sin asignación
`option.is_none()`	consumir valor predeterminado con limpieza exacta del valor de propiedad no seleccionado
`result.is_ok()` / `result.is_error()`	límite fatal explícito que no se deshace
`option_or_result.unwrap_or(value)`	límite principal `or_abort()` option/result usando retorno limpio ordinario
`expect(message)`	clon estructural explícito cuando existe capacidad; Se realiza un seguimiento del efecto de asignación.
`or_exit(status)`	prestado sin asignación `i64`
`value.clone()`	Sin asignación, de solo lectura `string.view()`.
`str`	Léxico exclusivo `bytes.view()` que cubre toda la longitud asignada.
`[]u8`	falible inicializado en cero `bytes.mutable_view()`; `mut []u8` debe ser `bytes.zeroed(length)`
`Result<bytes, alloc_error>`	asignación falible de capacidad interna; las personas que llaman deben inicializar cada byte antes de exponer un prefijo
`length`	Sin asignación, de solo lectura `i64`.
`unsafe { bytes.uninitialized(length) }` / `shared_bytes.view()`	segmento compatible explícito sin asignación; la vista mutable requiere un propietario mutable
`[]u8`	comparación de bytes UTF-8 sin asignación
`array.view()`	búsqueda de delimitadores sin asignación marcada; delimitadores no ASCII rechazados
`array.mutable_view()`	sin asignación `str.equal(other)` igualdad de longitud y contenido
`str.find_ascii(delimiter, start)` / `intrinsic_sqrt_f32/f64(value)` / `intrinsic_abs_f32/f64(value)` / `intrinsic_min_f32/f64(a, b)`	`intrinsic_max_f32/f64(a, b)`/`f32` operaciones matemáticas
`f64`	subvista de copia cero comprobada que preserva la procedencia
`math`	Subvista genérica de copia cero comprobada `str.slice(start, count)` que preserva la procedencia
`slice.slice(start, count)`	sin asignación `[]t` igualdad de longitud y contenido
`byte_view.equal(other)` / `[]u8`	`str.to_string()`; asignación explícita
`string.from(view)` / `Result<string, alloc_error>`	`str.to_bytes()`; explícito copy/allocation
`bytes.from(view)` / `Result<bytes, alloc_error>`	consumir bytes propios; `bytes.to_shared()`
`shared_bytes.from(data)`	alcance de asignación de impactos verificado léxico
`Result<shared_bytes, alloc_error>`	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 (region(capacity) { body } donde io.input_stream.read(chunk) es una variable) no se admiten en buf[i] ni en subporciones derivadas de i a través de mut []u8. Las lecturas de índice fijo ([]u8) funcionan en todos los tipos de sectores. Los parámetros de función directa .slice() y el segmento original de buf[0] 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.

[]u8 nota: bytes.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 fuera de límites. Para preparar un destino de escritura de n bytes, utilice byte_buffer (aumentar o reducir el prefijo inicializado; los nuevos bytes son cero) o byte_buffer.mutable_view() (agregue n bytes inicializados en cero); ambos son falibles con byte_buffer.resize_zeroed(n) sobre el crecimiento y preservar la invariante del prefijo comprometido en todos los caminos, incluido el fallo de asignación. Para escribir en un búfer sin formato, use byte_buffer.push_zeroed(n) cuyo alloc_error cubre la asignación total, o el uso bytes.zeroed(n) metodos mutable_view()/byte_buffer/push/extend.

Sustrato de compilador inseguro

Las siguientes operaciones requieren un bloque reserve o resize:

familia	Operaciones
memoria bruta escrita	`unsafe`, `unsafe fn`, `raw_try_alloc<t>`, `raw_null<t>`, `raw_is_null<t>`, `raw_read<t>`, `raw_write<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_free<t> informa el recuento negativo, el desbordamiento de tamaño o el error del asignador como raw_slice<t>. Raw read/write/free se basa en 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 raw_try_alloc<t>:

Paquete	Rol
`alloc_error`	Dirección indirecta de propiedad segura y falible para valores recursivos y grandes
`compiler/llvm/libs`	Construcción, mutación, vistas y consumo de bytes falibles y cultivables. `box` conversión
`byte_buffer`	contenedor output/file alojado durante el tiempo de ejecución ABI
`bytes`	iterativo sin asignación O (n) `file` Fibonacci con explícito negative/overflow `fibonacci`
`i64`	contenedor de red alojado
`None`	entrada partial/read-all alojada escrita, salida text/bytes/format de escritura total, almacenamiento en búfer limitado y `net`/`io` para salida rápida
`print`	portátil `println`/`math` raíz cuadrada, valor absoluto, mínimo y máximo
`f32`	marcado signed/unsigned análisis de enteros y ayudantes predeterminados explícitos
`f64`	Argumentos de proceso, vistas del entorno e identidad del proceso sin asignación.
`parse`	paquete de serialización seguro representativo
`process`	clasificación escalar de corte mutable y clasificación estática `serialize` para valores de solo movimiento
`sort`	asistentes genéricos de ventana de ancho fijo, rotación y reversa sin asignación; los cortes centrales proporcionan `order_key`/`slice`
`fill`	UTF-8 validación, escalar Unicode verificado sin asignación iteration/counting, conversión de cadena propia y cursores de token delimitados por ASCII
`copy_from`	milisegundos alojados monótonos más reloj de pared Unix seconds/milliseconds
`text`	vector genérico falible con constructores capacity/filled y `time` reserve/push/update/pop, además de cola, conjunto y mapa
`vec`	canales de propiedad dividida, one-shot mecanografiados y `@mut` uniones, eventos, cancelaciones, grupos de espera, semáforos, barreras y bloqueos
`task`	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 Result<T, E> o system; no se requiere instalación manual de la interfaz ni FFI visible en la aplicación. el más estrecho use "vec" El subcomando no prepara primero un paquete básico que falta. Los usuarios directos del compilador pueden consumir una fuente explícita o use "fibonacci" paquete. Estos no son nombres de idiomas mágicos.

Formateo y salida

El lenguaje implementa la interpolación phase-1/2 check escrita. Una cadena f produce un .sdi efímero sin asignación de montón. f"..." es la superficie escrita canónica para salida de texto, segmento de bytes y formato. Para una salida rápida, format_args escribe en la salida estándar y compiler/llvm/libs/io escribe con una nueva línea al final. print(text) realiza una materialización falible explícita. Se implementan Width/fill/alignment, especificadores de base de números enteros y formato de rasgo println(text) prestado sin asignación. La fase 2 agrega formato fijo, científico y general .to_string()?/display 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 f32, f64, str_cat, read_file, y net_connect. 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 vec_new contrato define propiedad, efectos, ABI y disponibilidad.