# Tutoriel : votre premier programme MoonBit dans Turbo MoonBit

À la fin de ce tutoriel, vous aurez écrit, formaté, lancé et cassé un petit programme MoonBit sans quitter l'éditeur — et vu l'éditeur vous dire où était l'erreur.

Aucune connaissance préalable de Turbo MoonBit n'est nécessaire. Il vous faut Go 1.26 ou plus récent pour compiler l'éditeur, et la chaîne d'outils MoonBit pour compiler le programme.

## Prérequis

Vérifiez Go :

```bash
go version
```

Vous devriez voir quelque chose comme :

```
go version go1.26.5 linux/arm64
```

Vérifiez la chaîne d'outils MoonBit :

```bash
moon version --all
```

Vous devriez voir trois lignes, chacune se terminant par un chemin :

```
moon 0.1.20260904 (94521db 2026-09-04) ~/.moon/bin/moon
moonc v0.10.12+1634b282e (2026-09-07) ~/.moon/bin/moonc
moonrun 0.1.20260904 (94521db 2026-09-04) ~/.moon/bin/moonrun
```

Si la commande est introuvable, installez d'abord la chaîne d'outils — [une seule commande suffit](../how-to/install-the-moonbit-toolchain.md).

## Étape 1 — Installer l'éditeur

```bash
git clone https://rickub.com/turbo-editors/turbo-moonbit.git
cd turbo-moonbit
make install
```

L'installeur compile, installe, puis vérifie ce qu'il a installé. Les dernières lignes sont :

```
==> Checking the language server
  ✓ moon-lsp at ~/.moon/bin/moon-lsp

==> Ready
```

Nous avons maintenant une commande `turbo-moonbit`.

## Étape 2 — Créer un projet

```bash
cd /tmp
moon new hello
cd hello
```

```
Created username/hello at hello
```

`moon new` écrit un `moon.mod`, un `moon.pkg`, un fichier de bibliothèque, quelques fichiers de test, et un `cmd/main/main.mbt` contenant un hello-world. **C'est `moon.mod` que Turbo MoonBit cherche** pour trouver la racine d'un projet, et c'est le dossier dans lequel `moon-lsp` sera lancé.

## Étape 3 — Ouvrir le fichier

```bash
turbo-moonbit cmd/main/main.mbt
```

L'écran se remplit. En haut :

```
 File  Edit  Search  Run  Code  Options  Window  Snippets  MoonBit  Help
```

Dix menus, et le neuvième porte le nom du langage. En bas, à droite, vous devriez voir :

```
1:1  LSP: ready
```

`LSP: ready` signifie que `moon-lsp` a démarré dans ce dossier. Nous nous en servirons à l'étape 8.

## Étape 4 — Écrire le programme

Sélectionnez tout avec `Ctrl-A` et appuyez sur `Suppr`, puis tapez ceci. Tapez-le exactement ; nous allons regarder les couleurs juste après.

```moonbit
///|
struct Greeting {
  name : String
  times : Int
}

///|
fn greet(g : Greeting) -> Unit {
  for i in 0..<g.times {
    println("Hello, \{g.name}! (\{i + 1})")
  }
}

///|
fn main {
  greet({ name: "MoonBit", times: 3 })
}
```

Appuyez sur `F2` pour enregistrer. L'étoile à côté de `main.mbt` dans le titre de la fenêtre disparaît.

## Étape 5 — Lire les couleurs

Regardez ce que vous venez de taper. Dans le thème par défaut `turbo-classic` :

| Quoi | Couleur |
| --- | --- |
| `struct`, `fn`, `for`, `in` | blanc vif, gras — mots-clés |
| `Greeting`, `String`, `Int`, `Unit` | cyan vif — types |
| `greet`, là où il est déclaré comme là où il est appelé | jaune vif, gras — fonctions |
| `println` | cyan vif, gras — un nom fourni par le langage |
| `name`, `times`, `g`, `i` | jaune vif — noms ordinaires |
| `"Hello, \{g.name}! (\{i + 1})"` | vert, **en entier** — une seule chaîne |
| `0`, `1`, `3` | magenta — nombres |
| `///\|` | gris — un commentaire |

Deux de ces lignes méritent un second regard.

**`Greeting` est cyan et `greet` est jaune**, et personne n'a dit à l'éditeur lequel des deux est un type. C'est la règle propre à MoonBit qui tranche : un nom commençant par une majuscule ne peut être qu'un type, un trait ou un constructeur.

**La chaîne est verte du premier guillemet au dernier**, interpolations comprises. Le `\{g.name}` qu'elle contient n'est pas coloré comme du code — [et c'est délibéré](../explanation/colouring-and-completion.md).

## Étape 6 — Donner ses outils au projet

Appuyez sur `F10` pour ouvrir la barre de menus, puis sur `→` **huit fois** pour atteindre **MoonBit** — après Edit, Search, Run, Code, Options, Window et Snippets. Plus rapide : `Alt-M`.

Le menu contient deux entrées, et une seule est disponible :

```
┌───────────────────┐
│ Create tools file │
│ Open tools file   │   ← grisée ; il n'y a pas encore de fichier à ouvrir
└───────────────────┘
```

Choisissez **Create tools file**.

Une seconde fenêtre s'ouvre sur le fichier qui vient d'être écrit, `.turbo-moonbit/tools.toml`. Lisez-le si vous voulez — il explique chacune de ses clés — puis fermez-le avec `Ctrl-W`.

Rouvrez le menu MoonBit. Il contient maintenant neuf commandes, et les deux entrées ont échangé leurs rôles : `Create tools file` est grisée, et c'est `Open tools file` qui est choisissable.

## Étape 7 — Le formater, et le lancer

Appuyez sur `Alt-M` et choisissez **Format**.

Une boîte de dialogue s'ouvre, se remplit, et affiche `— exit 0`. Appuyez sur `Échap`.

Regardez la dernière ligne de votre fonction `main`. Elle a changé :

```moonbit
  greet({ name: "MoonBit", times: 3, })
```

`moon fmt` a ajouté une virgule finale, et l'éditeur a rechargé le fichier dont on venait de lui dire qu'il avait changé sous ses pieds.

Maintenant `Alt-M`, puis **Run**. Une boîte demande une valeur avant de lancer la commande :

```
┌──────────────── Run ────────────────┐
│  package, e.g. cmd/main             │
│  [                               ]  │
└─────────────────────────────────────┘
```

Tapez `cmd/main` et appuyez sur `Entrée`. Une fenêtre de terminal s'ouvre et le programme s'y exécute :

```
Hello, MoonBit! (1)
Hello, MoonBit! (2)
Hello, MoonBit! (3)
```

Un terminal plutôt qu'une boîte de dialogue, parce qu'un programme qui lit le clavier doit pouvoir recevoir une réponse. Le programme est terminé, la fenêtre a donc cessé de se comporter comme un terminal et toutes les touches reviennent à l'éditeur : appuyez sur `Ctrl-W` pour la fermer.

## Étape 8 — Le casser, et voir où

Allez sur la ligne du `println` et remplacez `g.name` par `g.nam`. Appuyez sur `F2` pour enregistrer.

En une seconde ou deux, deux choses se produisent. Un `×` rouge apparaît dans la gouttière, juste à gauche du numéro de cette ligne. Et la barre d'état affiche :

```
⚠ The value identifier nam is unbound.
```

Personne ne l'a demandé. `moon-lsp` le publie de lui-même chaque fois qu'il relit le fichier.

Remettez le `e` et enregistrez de nouveau ; la marque et le message disparaissent tous les deux.

## Étape 9 — Changer de thème

`F10`, puis `→` **cinq fois** pour atteindre **Options** — après Edit, Search, Run et Code. Choisissez **Theme…**.

Une liste s'ouvre sur le thème dans lequel vous êtes. Appuyez sur `↓` jusqu'à `cobalt` puis `Entrée`. Tout l'écran change, en gardant la même forme.

Appuyez sur `Alt-X` pour quitter. L'éditeur pose d'abord la question des fichiers non enregistrés, s'il y en a.

## Et maintenant ?

Vous avez créé un projet MoonBit, écrit un programme dans l'éditeur, formaté, lancé, cassé, et vu l'éditeur dire où. Pour aller plus loin :

- Pour faire des choses précises → les [guides pratiques](../how-to/)
- Pour savoir exactement ce qui est coloré et comment → [langages colorés](../reference/languages.md)
- Pour comprendre pourquoi l'éditeur est bâti ainsi → les [explications](../explanation/)