Larva 0.8.0

Larva 0.8.0 es la cadena de herramientas del lenguaje Antril, junto con Antril 0.8.0, su paquete de lenguaje. Esta página enumera lo que contiene la versión, área por área, con enlaces a la documentación. Para instalarla, visita la página de descargas o ejecuta el instalador de una línea para tu sistema (consulta Instalación más abajo).

Lo más destacado

• Instaladores para Windows, Linux y macOS. El asistente de instalación de Windows, un zip portátil y, como novedad en esta versión, archivos .tar.gz con install.sh para Linux y macOS. Los instaladores funcionan para el usuario actual, sin permisos de administrador.
• Instalación en una línea desde www.antril.org, con install.ps1 en Windows e install.sh en Linux y macOS.
• La biblioteca estándar se distribuye compilada. System.Core se instala como System.Core.dll, una biblioteca de Larva, en lugar de archivos fuente que se compilaban la primera vez que se usaban.
• Los lenguajes son paquetes firmados. Antril vive en Languages/Antril, con el hash de cada archivo en su manifiesto y el manifiesto firmado. larva languages verifica cada paquete de lenguaje instalado.
• Un registro de lenguajes, nuevo y todavía en evolución: larva languages install, publish y más, con paquetes firmados por su autor y por antril.org.
• Hive viene integrado en larva: paquetes firmados, rangos de versiones, hive.lock y un registro de paquetes público en www.antril.org con cuentas y tokens de API.
• Memoria por proyecto. gc: default, refcount, arena o manual en .queen, y las bibliotecas compiladas para otro modo se enlazan como su propio dominio de GC.
• Cuatro back ends: LLVM, el back end x86-64 propio de Larva, WebAssembly y la VM de IL.
• VS Code: las extensiones de Antril y Larva, con un servidor de lenguaje que además verifica los préstamos mientras escribes.

Qué trae la 0.8.0

El lenguaje Antril

• Tipos primitivos de i8 a i256, de u8 a u256 y de f16 a f256, además de iptr/uptr, str y any. Un tipo sin ? nunca contiene null. Consulta Fundamentos.
• Clases con secciones de acceso (public:, private:, internal:, inherited:, friendly:, file:), tipos value, clases base y finales, interfaces con cuerpos predeterminados, propiedades, clases estáticas y destructores. Consulta Tipos.
• Registros que se comparan por contenido y se copian con with. Tuplas de cualquier cantidad de elementos. Enums sobre enteros, str o un value, y bitflag enums. Consulta Registros y Enums.
• Una sola palabra clave, loop, para todo tipo de bucle, y switch con patrones de constante, comparación, rango, tipo, propiedad y posición. Consulta Control de flujo.
• Tipos de función (func<A> : R) y lambdas que capturan, iteradores con yield, genéricos con restricciones como T : number, T : new() y T : op +(T, T) : T, y genéricos variádicos (T... con static loop). Consulta Funciones y genéricos.
• Operadores definidos por el usuario, incluidos símbolos nuevos con su propia precedencia, y bloques de extensión (ext, static ext, ext<T : …> con restricciones). Consulta Operadores y Bloques de extensión.
• Declaraciones exception, con try, catch y finally. Consulta Errores y excepciones.
• async/await sobre Task y Task<T>, y clases reactivas con campos reactive, valores computed, bloques effect y métodos reacts. Consulta Código asíncrono y reactivo.
• Destructores en todos los modos de memoria, bloques region { }, referencias &T/&mut T verificadas por el verificador de préstamos (off de forma predeterminada, warn o enforce), punteros en código unsafe, unsafe: deny por proyecto y búferes fijos, incluido fixed T[] guardado dentro del objeto de una clase final. Consulta Memoria.
• Llamadas directas a C con [Import], disposición de structs de C, punteros a funciones y exportaciones. Consulta Interoperabilidad con C.
• La referencia del lenguaje completa, incluido cada diagnóstico.

Larva

• larva new con las plantillas Console-App y Library. Las plantillas se guardan como HIR de Larva, y cada lenguaje las escribe como su propio código fuente. Consulta new.
• larva run compila el proyecto actual solo cuando algo cambió, y luego lo ejecuta. Consulta run.
• larva build con --check, --dll, --target native|wasm|wasm-llvm, --backend llvm|x64, de -O0 a -O3, --borrowcheck, --cpu y --timings. Consulta build.
• larva lib compila código fuente en una biblioteca de Larva: un .dll que contiene código de Larva compilado. Consulta lib.
• larva config define valores predeterminados para toda la máquina: modo de GC, back end, destino, optimización, CPU, reflexión, verificador de préstamos, código inseguro, genéricos, acceso predeterminado y registros de Hive. Consulta config.
• Archivos de proyecto .queen con los chunks PROJ, BUILD, DEPS, SOURCES, FILES, RESOURCES y HIVE, y recursos incrustados en el programa (System.Resources). Consulta Archivos de proyecto.
• larva types, larva show y larva search exploran la biblioteca estándar, las bibliotecas y tu propio código fuente, en Antril o como HIR (--lang hir). Consulta Explorar código.
• larva bind escribe una biblioteca de Larva para un .dll o .so nativo, a partir de un encabezado de C (preprocesado con clang cuando está instalado) o de una descripción .bind. Los perfiles de bindings escritos en Antril (--profile) deciden cada nombre. Consulta Bindings nativos.
• Paquetes de lenguaje: larva languages enumera y verifica los paquetes instalados, y larva languages key y pack los firman. Los paquetes del registro de lenguajes, que es nuevo, se instalan con larva languages install. Consulta Paquetes de lenguaje y El registro de lenguajes.
• Back ends: LLVM (el predeterminado, con optimización), el back end x86-64 propio de Larva (más rápido para compilar), WebAssembly mediante LLVM (--target wasm-llvm) o mediante el back end propio de Larva (--target wasm), y la VM de IL para módulos .lvm (larva run, dis, link, native). Consulta Arquitectura.
• Memoria: un recolector de basura generacional por trazado con una zona joven (nursery) de copia en paralelo, conteo de referencias, arenas y memoria manual. Una dependencia cuyo gc: difiere del del programa se enlaza como su propio dominio de GC, y el texto y los bytes cruzan entre dominios con System.Exchange. Consulta Recolección de basura y Dominios de GC.

Biblioteca estándar

• System.Core está escrita en Antril y se instala compilada, como System.Core.dll. Explórala en el explorador de la biblioteca.
• Colecciones, texto, Math sobre todos los tipos numéricos (exacta con enteros y con f128/f256), Random, DateTime, reflexión y Resources en System.
• Archivos, carpetas, rutas y flujos en System.IO. JSON (JsonValue) y expresiones regulares (Regex) en System.Text.
• TCP y HttpClient.Get en System.Net. Process y Stopwatch en System.Diagnostics.
• Hilos, bloqueos, operaciones atómicas y Parallel en System.Threading. Tareas en System.Threading.Tasks. System.Reactive.
• System.Bindings.dll, contra la que se escriben los perfiles de bindings.

Consulta la descripción general de System.Core.

Hive

• larva hive add, install, restore, info, list, verify y trust para usar paquetes, y key, pack y publish para crearlos. Consulta Usar paquetes y Publicar paquetes.
• Paquetes con nombre Author/Name, con rangos de versiones (@1.2, @^1.2, @>=1.2) y un hive.lock que fija el hash, la clave y el registro de cada versión.
• Paquetes firmados con ECDSA P-256. Cada archivo tiene su hash en el manifiesto. Las claves de firma se recuerdan en la primera instalación, y nada de un paquete se ejecuta al instalarlo.
• Paquetes compilados y de código fuente, y paquetes que envuelven una biblioteca compilada en otro lugar, como un binding nativo.
• Registros de paquetes en la web, en cualquier servidor HTTPS estático o en una carpeta. El registro público es https://www.antril.org/hive-api, con cuentas, autores y tokens de API. Consulta La API del registro y Cuentas, tokens y autores.

Editores

• Antril para VS Code: resaltado de sintaxis, fragmentos de código, iconos de archivo y colores semánticos para archivos .ant. Instala Larva junto con ella.
• Larva para VS Code ejecuta larva lsp para cada lenguaje instalado. Ofrece errores mientras escribes (verificador de préstamos incluido), autocompletado, información al pasar el cursor, navegación hacia tipos de biblioteca descompilados y soporte para .queen. Agrega los comandos New Project from a Template, Run, Check, Build Native Executable, Build WebAssembly, Bind a Native Library, Generate Bindings from the Profile Open, List a Native Library's Exports, Show Type (decompiled) y Restart Language Server. Consulta VS Code.
• larva lsp funciona con cualquier editor que hable el Language Server Protocol. Consulta El servidor de lenguaje.

Instalación

O en una sola línea:

$ irm https://www.antril.org/install.ps1 | iex

$ curl -fsSL https://www.antril.org/install.sh | sh

Las opciones se pasan a install.sh, por ejemplo curl -fsSL https://www.antril.org/install.sh | sh -s -- --no-path.

• El asistente de instalación instala en %LOCALAPPDATA%\Programs\Larva. Puede agregar Larva a tu PATH, registrarla en Configuración > Aplicaciones, hacer de https://www.antril.org/hive-api el registro de paquetes predeterminado y mostrar los archivos de Larva con sus iconos. Cada una de estas opciones se puede desactivar (--no-path, --no-registry, --no-hive, --no-types). --uninstall desinstala Larva.
• install.sh instala en ~/.local/share/larva (en macOS, ~/Library/Application Support/Larva) y deja un comando larva en ~/.local/bin. Acepta --prefix, --no-path, --no-hive, --no-types y --uninstall.
• En Windows, instalar sobre una versión anterior elimina solo los archivos que instaló esa versión. Todo lo demás que haya en la carpeta se deja intacto.
• Herramientas opcionales: las herramientas de compilación de MSVC para ejecutables nativos en Windows, clang para preprocesar encabezados de C en larva bind, y Node.js para ejecutar compilaciones de WebAssembly fuera de un navegador.

Consulta Instalar Larva y Los instaladores.

Limitaciones conocidas

• Los paquetes para Linux y macOS son nuevos y están menos probados que el instalador de Windows. Por favor, informa los problemas en el foro.
• Los ejecutables nativos se enlazan con las herramientas de MSVC. Las compilaciones nativas en Linux y macOS todavía no están terminadas.
• gc: custom se acepta, pero todavía no hay una interfaz para que un proyecto defina su propio recolector. Esos proyectos se compilan con el recolector por trazado.
• El back end de WebAssembly propio de Larva (--target wasm) genera módulos inválidos para algunos programas y no admite enteros de 256 bits. Usa --target wasm-llvm.
• Main no puede recibir argumentos de texto, y Main() : i32 imprime su resultado en lugar de terminar con él como código de salida.
• larva build compila el programa completo cada vez. Está prevista una caché incremental por ensamblado.
• Todavía no se pueden retirar versiones de Hive (yank) en www.antril.org.

Consulta Lo que todavía no está implementado.