Presentamos Antril y Larva 0.8

Hoy publicamos Larva 0.8.0, junto con Antril 0.8.0. Antril es un lenguaje de tipado estático con clases, tipos por valor, registros, genéricos, código asíncrono y código reactivo. Cada proyecto elige cómo se gestiona su memoria: un recolector de basura por trazado, conteo de referencias, arenas o delete manual. Larva es la cadena de herramientas que hay detrás de un solo comando, larva. Crea proyectos, los compila a código nativo o a WebAssembly, gestiona paquetes, genera bindings para bibliotecas de C y ejecuta el servidor de lenguaje con el que habla tu editor. Este artículo es un recorrido breve por ambos y por cómo empezar.

Instalación

En Windows, desde PowerShell:

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

En Linux y macOS:

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

El script acepta las opciones de install.sh. Por ejemplo, --no-path instala sin agregar ~/.local/bin a tu PATH:

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

Si prefieres descargar un archivo, la página de descarga tiene el asistente de instalación para Windows, un zip portátil y los archivos comprimidos para Linux y macOS. El asistente y install.sh instalan para el usuario actual, sin permisos de administrador. Los paquetes para Linux y macOS son nuevos en esta versión y se han probado menos que el instalador de Windows, así que avísanos si algo falla. Instalar Larva enumera todas las opciones.

Después, compruébalo desde una terminal nueva:

$ larva --version
larva 0.8.0

Un primer programa

larva new crea un proyecto a partir de una plantilla:

$ larva new Console-App Hello
C:\work\Hello: Console App in Antril (Program.ant, Hello.queen)
  larva build Hello\Hello.queen

El proyecto es una carpeta con un archivo de proyecto .queen y un Program.ant:

import System;

into namespace Hello
{
	/// The program's entry.
	Main()
	{
		Console.WriteLine("Hello from Larva!");
	}
}

larva run compila el programa si algo cambió y luego lo ejecuta:

$ cd Hello
$ larva run
C:\work\Hello\bin\Hello.exe (llvm back end, O3, entry Hello::Hello.$Module.Main)
Hello from Larva!

La primera línea es el informe de compilación de larva. Va al flujo de errores, así que la salida de tu programa queda separada. Tu primer programa recorre el proyecto paso a paso.

Cómo se ve Antril

Este es un Program.ant un poco más grande. Usa un registro, un switch con patrones de propiedades, interpolación de cadenas, una lambda y una copia con with:

import System;

into namespace Hello
{
	public record class Planet
	{
		public:
			str Name;
			f64 Mass;
			new(str Name, f64 Mass);
	}

	Describe(Planet p) : str => p switch
	{
		{ Mass: < 0.1 } => "tiny",
		{ Mass: < 10.0 } => "rocky",
		_ => "a giant",
	};

	Main()
	{
		List<Planet> planets = new List<Planet>();
		planets.Add(new Planet("Mercury", 0.055));
		planets.Add(new Planet("Earth", 1.0));
		planets.Add(new Planet("Jupiter", 317.8));

		loop (Planet p in planets)
			Console.WriteLine($"{p.Name,-8} {Describe(p)}");

		func<Planet> : bool heavy = p => p.Mass >= 1.0;
		Console.WriteLine($"{planets.Where(heavy).Count} of {planets.Count} weigh at least one Earth");
		Console.WriteLine(planets[1] with { Name = "Terra" });
	}
}

$ larva run
Mercury  tiny
Earth    rocky
Jupiter  a giant
2 of 3 weigh at least one Earth
Planet { Name = Terra, Mass = 1 }

Algunas cosas para notar:

• Los tipos van primero, los resultados al final. Una variable es f64 Mass. Una función es Describe(Planet p) : str. Un tipo de función es func<Planet> : bool.
• Los miembros se agrupan por acceso. public: se aplica a todos los miembros que le siguen hasta la próxima etiqueta, como una sección.
• Una sola palabra clave para todos los bucles. loop (x in items), loop (condition), loop (i32 i = 0..10) y la forma de tres partes son todos loop.
• Las funciones libres viven en espacios de nombres. into namespace Hello { … } contiene funciones, tipos y constantes. Main es simplemente una función libre.
• Los tipos primitivos llegan más lejos de lo habitual. Los enteros van de i8 a i256 y de u8 a u256, y los de punto flotante de f16 a f256. str es texto, y un tipo sin ? nunca puede contener null.

El recorrido por el lenguaje cubre el resto: clases y tipos value, interfaces con cuerpos por defecto, enumeraciones sobre enteros, cadenas o valores, tuplas, genéricos con restricciones como T : number o T : op +(T, T) : T, genéricos variádicos, operadores personalizados con símbolos nuevos, bloques de extensión, excepciones, iteradores con yield, async/await y campos reactivos con valores computed y effects.

La memoria es una opción del proyecto

El código Antril no dice cómo se devuelve la memoria. Lo dice el proyecto, con una sola clave en su archivo .queen:

chunk BUILD:
   gc: refcount

El mismo código fuente compila en todos los modos. Lo que cambia es cuándo se liberan los objetos y, por lo tanto, cuándo se ejecutan los destructores (destroy()). Un programa también puede usar bibliotecas compiladas para otro modo. Además, Antril tiene referencias &T y &mut T comprobadas por un verificador de préstamos (desactivado por defecto, como advertencias o como errores), punteros en código unsafe y búferes fijos guardados dentro de un objeto. Todo esto está en Memoria.

Larva, la cadena de herramientas

Todo pasa por larva:

larva build tiene varios back ends. LLVM es el predeterminado y optimiza. El back end x86-64 propio de Larva (--backend x64) compila más rápido. WebAssembly (--target wasm-llvm) genera un app.wasm, un app.js que lo carga y un app.html que lo ejecuta en una página. El comando larva describe todas las opciones.

En Windows, los ejecutables nativos se enlazan con las herramientas de compilación de MSVC. Las compilaciones nativas en Linux y macOS todavía no están terminadas: allí, por ahora, larva comprueba el código y compila bibliotecas.

Los lenguajes son paquetes

Larva en sí no contiene ningún lenguaje de programación. Cada lenguaje es un paquete de lenguaje: un frontend que convierte el texto fuente en el modelo de programa tipado de Larva, una vista que vuelve a escribir ese modelo como código fuente y los servicios para el editor. Antril es el paquete que está en Languages/Antril. Sus archivos tienen su hash en el manifiesto, y el manifiesto está firmado:

$ larva languages
Antril 0.8.0  (antril: .ant)
  …
  status:    ok (files verified)

Todas las herramientas trabajan sobre ese modelo compartido: compilaciones, paquetes, bindings, el explorador de tipos y el servidor de lenguaje. Así, una biblioteca escrita en un lenguaje se puede usar desde otro como un .dll compilado. El libro de internos explica cómo se cargan y verifican los paquetes.

La biblioteca estándar

System.Core está escrita en Antril y se instala ya compilada, como System.Core.dll junto a larva. Un programa solo necesita import System;. Incluye colecciones, texto y StringBuilder, Math sobre todos los tipos numéricos, archivos y flujos, JSON y expresiones regulares, TCP y HTTP, procesos, hilos, tareas, primitivas reactivas e interoperabilidad con C. Explórala en el explorador de la biblioteca o desde la terminal:

$ larva search Sqrt
System.Math.Sqrt<T : INumber<T>>(T x) : T
System.Math.ISqrt<T : INumber<T>>(T x) : T

Hive

Hive es el gestor de paquetes, integrado en larva. Un paquete es una biblioteca firmada con un nombre Author/Name. Viene del registro de paquetes público en antril.org, de otro servidor o de una carpeta:

$ larva hive add Antril-Organization/SDL3@^3.5

Un próximo artículo del blog explica cómo se firman los paquetes y los lenguajes.

Soporte para editores

Hay dos extensiones para VS Code. Instala Antril y traerá Larva con ella. La extensión de Larva ejecuta larva lsp. Muestra los errores mientras escribes (incluidos los del verificador de préstamos), autocompletado, información al pasar el cursor e ir a la definición, también dentro de la biblioteca estándar, que se abre descompilada como Antril. También entiende los archivos .queen y agrega comandos como New Project from a Template, Run, Build WebAssembly y Bind a Native Library. La extensión de Antril agrega resaltado de sintaxis, fragmentos de código e íconos de archivo para los archivos .ant. Otros editores que hablen el Language Server Protocol pueden ejecutar larva lsp de la misma forma.

Lo que todavía falta

Preferimos decirlo con claridad. La página de arquitectura mantiene la lista:

• gc: custom se acepta, pero todavía no hay una interfaz para escribir tu propio recolector. Esos proyectos se compilan con el recolector por trazado.
• El back end de WebAssembly propio de Larva (--target wasm) produce módulos inválidos para algunos programas. Usa --target wasm-llvm.
• Main todavía no puede recibir argumentos de texto desde la línea de comandos.
• Los ejecutables nativos necesitan las herramientas de MSVC. Las compilaciones nativas en Linux y macOS no están terminadas.
• larva build compila el programa completo cada vez. Está prevista una caché incremental por ensamblado. larva run ya omite la compilación cuando nada cambió.

Para empezar

• Instala Larva, o ve directo a la página de descarga.
• Escribe tu primer programa y luego haz el recorrido por el lenguaje.
• Lee las notas de la versión 0.8.0.
• Encuentra paquetes en Hive, y haz preguntas o muestra lo que construyes en el foro.

Tenemos muchas ganas de ver lo que construyes con él.