Tutoriel : votre premier programme Golo dans Turbo Golo

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204

# Tutoriel : votre premier programme Golo dans Turbo Golo

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

Aucune connaissance préalable de Turbo Golo n'est nécessaire. Il vous faut Go 1.26 ou plus récent pour compiler l'éditeur, et l'interpréteur `golo` pour exécuter 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 l'interpréteur :

```bash
golo --version
```

```
v0.1.1 | dev.20260802.🤓
```

Si la commande est introuvable, installez-le d'abord — [un téléchargement ou un script suffit](../how-to/install-goloscript.md).

## Étape 1 — Installer l'éditeur

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

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

```
==> Checking the language server
  ✓ golo at /usr/local/bin/golo — completion comes from `golo lsp`

==> Ready
```

Nous avons maintenant une commande `turbo-golo`.

## Étape 2 — Créer un dossier

```bash
mkdir /tmp/hello
cd /tmp/hello
```

C'est là tout ce qu'il faut pour créer un projet Golo : Golo n'a pas de manifeste, un script est un fichier, et un programme est un dossier de fichiers. **Le dossier dans lequel vous démarrez l'éditeur** est celui où les commandes du menu Golo s'exécuteront, démarrez-le donc ici.

## Étape 3 — Ouvrir un fichier qui n'existe pas encore

```bash
turbo-golo hello.golo
```

L'écran se remplit. En haut :

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

Dix menus, et le neuvième porte le nom du langage. Au milieu, une fenêtre vide intitulée `hello.golo`. En bas, à droite, vous devriez voir :

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

`LSP: ready` signifie que `golo lsp` — l'interpréteur, en mode serveur de langage — a démarré dans ce dossier. Nous nous en servirons à l'étape 8.

## Étape 4 — Écrire le programme

Tapez ceci. Tapez-le exactement ; nous allons regarder les couleurs juste après.

```golo
module hello.World

# Greet someone several times
struct Greeting = { name, times }

function greet = |g| {
  foreach i in range(1, g: times() + 1) {
    println("Hello, " + g: name() + "! (" + i + ")")
  }
}

function main = |args| {
  greet(Greeting("Golo", 3))
}
```

Si une liste de complétion s'ouvre pendant que vous tapez — un `.` en demande une de lui-même, et `hello.` en est un — continuez à taper ou appuyez sur `Échap` ; `Entrée` accepterait la première entrée.

Appuyez sur `F2` pour enregistrer. La barre d'état affiche `Saved hello.golo`.

## Étape 5 — Lire les couleurs

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

| Quoi | Couleur |
| --- | --- |
| `module`, `struct`, `function`, `foreach`, `in` | blanc vif, gras — mots-clés |
| `hello.World`, `Greeting` | cyan vif — un chemin de module, et un type |
| `greet`, là où il est déclaré comme là où il est appelé | jaune vif, gras — fonctions |
| `range`, `println` | cyan vif, gras — des fonctions fournies par l'interpréteur |
| `name`, `times`, `g`, `i`, `args` | jaune vif — noms ordinaires |
| `"Hello, "`, `"! ("`, `")"`, `"Golo"` | vert — chaînes |
| `1`, `3` | magenta — nombres |
| `# Greet someone several times` | gris — un commentaire |
| `\|`, `:`, `+`, `=` | blanc — opérateurs |

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 convention de Golo qui tranche : les structs, les unions et leurs variantes sont les noms que l'on écrit avec une majuscule, une majuscule est donc colorée comme un type.

**`greet` est jaune là où il est déclaré**, après `function`, bien qu'aucune parenthèse ne le suive à cet endroit. Le nom qui suit `function` est une fonction par sa position — [et c'est une règle délibérée](../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 **Golo** — après Edit, Search, Run, Code, Options, Window et Snippets. Plus rapide : `Alt-G`.

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-golo/tools.toml`. Lisez-le si vous voulez — il explique chacune de ses clés — puis fermez-le avec `Ctrl-W`.

Regardez la barre de menus : un menu **Tools** est apparu entre Golo et Help. La dernière entrée du fichier de départ nomme un menu à elle, et cette seule ligne est tout le mécanisme.

Rouvrez le menu Golo. Il contient maintenant huit 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 lancer

Appuyez sur `Alt-G` et choisissez **Run**. Une boîte demande une valeur avant de lancer la commande, parce que Golo n'a pas de manifeste qui dise quel fichier est le programme :

```
┌──────────────── Run ────────────────┐
│  script, e.g. main.golo             │
│  [                               ]  │
└─────────────────────────────────────┘
```

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

```
Hello, Golo! (1)
Hello, Golo! (2)
Hello, Golo! (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 à la fin du fichier, après la dernière `}`, et ajoutez un commentaire comme un autre langage l'écrirait :

```golo
// run it
```

Appuyez sur `F2` pour enregistrer.

En moins d'une seconde, 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 :

```
⚠ GoloScript has no '//' line comments. GoloScript comments are '#' for a single line (e.g. …
```

Personne ne l'a demandé. `golo lsp` le publie de lui-même chaque fois qu'il relit le fichier — une erreur de syntaxe aurait valu la même marque, et celle-ci est un lint que le serveur ajoute parce que c'est la première erreur que fait quiconque arrive d'un autre langage.

Remplacez le `//` par `#` 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 écrit un programme Golo dans l'éditeur, l'avez 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/)