Integraciones principales y bibliotecas estándar

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

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

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. Las lecturas y escrituras de índice variable funcionan en mut []u8 y en subporciones derivadas a través de .slice(), con los mismos límites verificados que cualquier otra forma de porción (verificada por tests/gate18/mut_slice_dynamic_index_consumer.sd).

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 preparar un destino de escritura de n bytes, utilice byte_buffer.resize_zeroed(n) (aumentar o reducir el prefijo inicializado; los nuevos bytes son cero) o byte_buffer.push_zeroed(n) (agregue n bytes inicializados en cero); ambos son falibles con alloc_error 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 bytes.zeroed(n) cuyo mutable_view() cubre la asignación total, o el uso byte_buffer metodos push/extend/reserve/resize.

Construcción de cadenas canónicas: acumula con push/push_str/extend, luego materializa una vez con text.utf8_string_from_bytes(buffer.view()), que valida UTF-8 e informa Utf8Error en lugar de reventar. La validación reside en la biblioteca text auditada a propósito: los estados intermedios del búfer pueden contener secuencias parciales, por lo que solo el paso final verifica:

use "byte_buffer"
use "text"

fn main() -> AllocResult<i64> {
    let mut builder = byte_buffer_new(8 as usize)?
    builder.push_str("hello ")?
    builder.push_str("world")?
    let built = match text.utf8_string_from_bytes(builder.view()) {
        Ok(value) => value,
        Err(_) => {
            return Ok(1)
        }
    }
    if built.view().equal("hello world") { Ok(0) } else { Ok(2) }
}

Sustrato de compilador inseguro

Las siguientes operaciones requieren un bloque unsafe o unsafe fn:

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:

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 escrito. phase-1/2 f"..." interpolación. Una cuerda f produce resultados efímeros. format_args 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 stdout y println(text) escribe con una nueva línea al final. print toma str, entonces print(f"...") no realiza verificación de tipos: las cadenas f producen efímeros format_args. uso print_format / println_format (lo mismo single/two-write disciplina como print/println) para salida interpolada:

use "io"

fn main() -> Result<i64, IoError> {
    let count = 42
    print_format(f"events={count}\n")?
    println_format(f"done")?
    Ok(0)
}

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