Docs Zero exécutables : Hello, World

Q: Quel est le programme hello world en Zero ?

Le hello world canonique de Zero tient en cinq lignes : pub fun main(world: World) -> Void raises { check world.out.write("hello from zero\n") }. Enregistrez-le dans hello.0 et lancez zero run hello.0.

Q: Que signifie `pub fun main` en Zero ?

pub rend une déclaration publique — visible en dehors de son module. fun déclare une fonction. main est le point d'entrée conventionnel que Zero cherche dans une cible exécutable. Ensemble, pub fun main déclare le point d'entrée public que le runtime appelle au démarrage du programme.

Q: Que font `raises` et `check` dans le hello world ?

raises sur main déclare que la fonction peut échouer. check world.out.write(...) appelle une fonction faillible et, en cas d'échec, propage l'erreur vers l'appelant — ici, c'est le runtime, qui sort avec un statut non nul. Sans check, le compilateur refuserait de compiler l'appel parce que l'erreur ne serait pas traitée.

Q: Quelle extension de fichier utilise Zero ?

Les fichiers source Zero utilisent l'extension .0 (le chiffre zéro, pas la lettre O). Un fichier hello.0 est un fichier source Zero. Le compilateur s'invoque avec des commandes comme zero check hello.0 et zero run hello.0.

Écrivez le fichier

Ouvrez votre éditeur et enregistrez les cinq lignes suivantes dans un fichier hello.0 à un endroit pratique — ou bien cliquez sur Run dans le bloc ci-dessous :

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

Voilà — un programme Zero complet. Pour l'exécuter en local :

zero run hello.0

Vous devriez voir :

hello from zero

Si vous obtenez command not found, revenez à Installer Zero et assurez-vous que zero --version fonctionne d'abord.

Déballer chaque token

Même ce tout petit programme montre déjà presque tout ce qui rend Zero différent. Lisons-le de gauche à droite.

`pub`

pub marque une déclaration comme publique — visible en dehors de son module actuel. Le runtime doit pouvoir trouver main depuis l'extérieur de la portée du fichier, donc main doit être pub. Une fonction utilitaire privée à l'intérieur du même fichier n'en aurait pas besoin.

`fun`

fun introduit une déclaration de fonction. Zero utilise fun, pas fn (Rust) ni func (Go) ni function (JavaScript). Un seul mot-clé, employé de la même manière à chaque fois.

`main`

Le nom conventionnel du point d'entrée. Quand une cible exécutable Zero démarre, le runtime cherche pub fun main(world: World) et l'appelle. Vous pouvez nommer les autres fonctions comme vous voulez, mais main est réservé par convention au point d'entrée du programme.

`(world: World)`

L'unique paramètre s'appelle world et est de type World. Le runtime construit une valeur World avant d'appeler main et la passe en argument. Cette valeur porte les capacités du programme : accès à stdout, stdin, au système de fichiers, au réseau, et ainsi de suite, selon ce que le runtime décide d'accorder.

Le nom du paramètre est libre — (w: World) ou (io: World) compilerait sans problème. La convention dans les exemples est world, et on s'y tient.

`-> Void`

Le type de retour. Void signifie que la fonction ne retourne rien d'utile — elle est là pour ses effets de bord, pas pour sa valeur. Beaucoup de fonctions que vous écrirez retourneront de vrais types comme i32 ou un shape que vous avez défini.

`raises`

Un raises nu (sans type d'erreur précis) sur main dit « cette fonction peut échouer ». Pour main, cela veut dire que le programme peut se terminer avec un statut non nul si un check quelque part dans le corps propage une erreur vers le haut. On verra des formes plus restreintes — raises { InvalidInput } par exemple — dans Raises et Check.

`check world.out.write("hello from zero\n")`

C'est la ligne qui fait réellement quelque chose. Trois sous-morceaux :

world.out — le flux de sortie standard, exposé comme un champ de la capacité World.
.write("hello from zero\n") — une méthode qui écrit une chaîne dans ce flux. Elle renvoie un résultat qui pourrait indiquer un échec (l'écriture pourrait rater ; le flux pourrait être fermé).
check — propage cet échec vers le haut s'il survient. Sans check, le compilateur se plaindrait que le résultat de write est ignoré silencieusement.

Le \n à la fin est un saut de ligne littéral. Sans lui, la sortie ne passerait pas à la ligne et le prompt du shell se retrouverait sur la même ligne que votre message.

Ce qui vient de se passer

Quand vous avez lancé zero run hello.0 :

Le compilateur a analysé votre fichier et vérifié les types.
Il a produit un petit exécutable natif pour votre plateforme.
Le runtime a construit une capacité World pour le processus en cours.
Il a appelé main(world).
Votre code a écrit "hello from zero\n" dans le flux out de ce world — qui est connecté au stdout de votre terminal.
main a retourné Void, le runtime a fait le ménage, et le programme s'est terminé avec le statut 0.

Pas de ramasse-miettes, pas d'initialisation cachée du runtime, pas de bootstrap implicite de modules. Tout le programme se résume à la fonction que vous avez écrite, plus le code de la bibliothèque standard qu'elle a appelé.

Essayez un petit changement

Faites que le programme passe par une liaison pour le message avant de l'écrire :

pub fun main(world: World) -> Void raises {
    let message = "hello from a binding\n"
    check world.out.write(message)
}

Lancez-le à nouveau — même sortie, mais vous avez maintenant rencontré les liaisons let et vérifié que les chaînes sont des valeurs de premier ordre qu'on peut faire circuler.

Une variante qui plante

Que se passe-t-il si vous oubliez le check ?

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

zero check hello.0 refusera de compiler ça. Le résultat de write est une valeur faillible ; l'ignorer est une erreur de compilation. Soit vous faites check (vous propagez l'erreur), soit vous la gérez explicitement. C'est la même idée que les résultats must_use de Rust, sauf qu'ici elle s'applique à chaque appel faillible.

La suite : la CLI Zero

Vous avez utilisé zero run ici. La CLI propose un petit ensemble de commandes qu'il vaut le coup de connaître — check, run, build, test, fix, explain — chacune avec un mode --json structuré conçu pour être consommé par les agents.

Questions fréquentes

Quel est le programme hello world en Zero ?

Le hello world canonique de Zero tient en cinq lignes : pub fun main(world: World) -> Void raises { check world.out.write("hello from zero\n") }. Enregistrez-le dans hello.0 et lancez zero run hello.0.

Que signifie pub fun main en Zero ?

pub rend une déclaration publique — visible en dehors de son module. fun déclare une fonction. main est le point d'entrée conventionnel que Zero cherche dans une cible exécutable. Ensemble, pub fun main déclare le point d'entrée public que le runtime appelle au démarrage du programme.

Pourquoi main prend-il un paramètre World ?

Zero n'a pas d'E/S globales. Tout ce qui dialogue avec le monde extérieur — stdout, stdin, fichiers, réseau — passe par des capacités passées explicitement. Le runtime remet à main une valeur World, et cette valeur (ou des morceaux d'elle) est la seule manière pour les fonctions de faire des E/S. Ça rend les effets de bord visibles dans les signatures de fonctions.

Que font raises et check dans le hello world ?

raises sur main déclare que la fonction peut échouer. check world.out.write(...) appelle une fonction faillible et, en cas d'échec, propage l'erreur vers l'appelant — ici, c'est le runtime, qui sort avec un statut non nul. Sans check, le compilateur refuserait de compiler l'appel parce que l'erreur ne serait pas traitée.

Quelle extension de fichier utilise Zero ?

Les fichiers source Zero utilisent l'extension .0 (le chiffre zéro, pas la lettre O). Un fichier hello.0 est un fichier source Zero. Le compilateur s'invoque avec des commandes comme zero check hello.0 et zero run hello.0.

Concepts liés

Zero Hello World : écrire et exécuter votre premier programme .0