Hola mundo en Zero: escribe y ejecuta tu primer programa .0

Escribe el archivo

Abre tu editor y guarda estas cinco líneas como hello.0 en cualquier sitio cómodo — o simplemente pulsa Ejecutar en el bloque de abajo:

pub fun main(world: World) -> Void raises {
    check world.out.write("hola desde zero\n")
}

Y ya está: un programa completo en Zero. Para ejecutarlo localmente:

zero run hello.0

Deberías ver:

hola desde zero

Si te apareció command not found, vuelve a Instalar Zero y asegúrate primero de que zero --version funcione.

Desmontando cada token

Incluso este programa diminuto ya muestra casi todo lo que diferencia a Zero. Vamos a leerlo de izquierda a derecha.

pub

pub marca una declaración como pública: visible fuera del módulo actual. El runtime necesita encontrar main desde fuera del propio archivo, así que main tiene que ser pub. Una función auxiliar privada dentro del mismo archivo no lo necesitaría.

fun

fun introduce una declaración de función. Zero usa fun, no fn (Rust) ni func (Go) ni function (JavaScript). Una sola palabra clave, usada igual cada vez.

main

El nombre convencional del punto de entrada. Cuando se ejecuta un destino ejecutable de Zero, el runtime busca pub fun main(world: World) y lo invoca. Puedes llamar al resto de funciones como quieras, pero main está reservado por convención para el punto de entrada del programa.

(world: World)

El único parámetro se llama world y es de tipo World. El runtime construye un valor World antes de llamar a main y se lo pasa. Ese valor lleva las capacidades del programa: acceso a stdout, stdin, sistema de archivos, red, etc., según lo que el runtime decida conceder.

El nombre del parámetro lo eliges tú: (w: World) o (io: World) compilarían igual. La convención en los ejemplos es world, y la vamos a mantener.

-> Void

El tipo de retorno. Void significa que la función no devuelve nada útil: está ahí por sus efectos, no por su valor. Muchas funciones que escribas devolverán tipos reales como i32 o algún shape que hayas definido.

raises

Un raises pelado (sin un tipo de error concreto) en main dice "esta función puede fallar". Para main, eso significa que el programa puede terminar con un estado distinto de cero si cualquier check dentro del cuerpo propaga un error. Veremos formas más estrechas — raises { InvalidInput }, por ejemplo — en Raises y Check.

check world.out.write("hola desde zero\n")

Esta es la línea que hace algo de verdad. Tres subpiezas:

• world.out — el flujo de salida estándar, expuesto como un campo de la capacidad World.
• .write("hola desde zero\n") — un método que escribe una cadena en ese flujo. Devuelve un resultado que podría indicar fallo (la escritura podría fallar; el flujo podría estar cerrado).
• check — propaga ese fallo hacia arriba si ocurre. Sin check, el compilador se quejaría de que el resultado de write se está descartando silenciosamente.

El \n al final es un salto de línea literal. Sin él, la salida no terminaría en una línea nueva y el prompt de tu shell aparecería pegado al mensaje.

Lo que acaba de pasar

Cuando ejecutaste zero run hello.0:

1. El compilador parseó tu archivo e hizo el chequeo de tipos.
2. Produjo un pequeño ejecutable nativo para tu plataforma.
3. El runtime construyó una capacidad World para el proceso actual.
4. Llamó a main(world).
5. Tu código escribió "hola desde zero\n" en el flujo out de ese world, conectado al stdout de tu terminal.
6. main devolvió Void, el runtime hizo limpieza y el programa terminó con estado 0.

No hay recolector de basura, ni inicialización oculta del runtime, ni bootstrap implícito de módulos. El programa entero es la función que escribiste, más el código de la biblioteca estándar al que llamó.

Prueba un cambio pequeño

Haz que el programa use una ligadura para el mensaje antes de escribirlo:

pub fun main(world: World) -> Void raises {
    let message = "hola desde una ligadura\n"
    check world.out.write(message)
}

Ejecútalo otra vez: misma salida, pero ya has visto let bindings y confirmado que las cadenas son valores de primera clase que puedes pasar por ahí.

Una variante que falla

¿Qué pasa si olvidas el check?

pub fun main(world: World) -> Void raises {
    world.out.write("oops\n")
}

zero check hello.0 se negará a compilar esto. El resultado de write es un valor falible; ignorarlo es un error de compilación. O lo check (propagas el error) o lo manejas explícitamente. Es la misma idea que los resultados must_use de Rust, solo que aplicada a cada llamada falible.

Lo siguiente: la CLI de Zero

Aquí has usado zero run. La CLI tiene un conjunto pequeño de comandos que vale la pena conocer — check, run, build, test, fix, explain — cada uno con un modo --json estructurado pensado para que los agentes lo consuman.