Entiers
Il existe deux types de nombres différents en Gleam : les entiers et les nombres décimaux.
Les entiers sont des nombres sans partie décimale.
let integer = 3
// -> 3
Gleam propose plusieurs opérateurs qui fonctionnent avec les entiers.
1 + 1 // -> 2
5 - 1 // -> 4
5 / 2 // -> 2
3 * 3 // -> 9
5 % 2 // -> 1
2 > 1 // -> True
2 < 1 // -> False
2 >= 1 // -> True
2 <= 1 // -> False
Nombres décimaux
Les nombres décimaux sont des nombres avec un ou plusieurs chiffres après le séparateur décimal.
let float = 3.45
// -> 3.45
Les nombres décimaux ont aussi leur propre ensemble d'opérateurs.
1.0 +. 1.4 // -> 2.4
5.0 -. 1.5 // -> 3.5
5.0 /. 2.0 // -> 2.5
3.0 *. 3.1 // -> 9.3
2.0 >. 1.0 // -> True
2.0 <. 1.0 // -> False
2.0 >=. 1.0 // -> True
2.0 <=. 1.0 // -> False
Modules
Modules
Le code Gleam est organisé en modules, et chaque fichier est un module Gleam.
Jusqu'à présent, on a écrit des fonctions avec la syntaxe pub fn, qui définit une fonction accessible publiquement aux autres modules. Les fonctions définies avec fn sont privées au module dans lequel elles sont définies et ne peuvent pas être utilisées par d'autres modules.
// This function is public
pub fn add(x, y) {
x + y
}
// This function is private
fn subtract(x, y) {
x - y
}
Les modules Gleam ont des noms, et le nom est basé sur leur chemin de fichier dans le répertoire src ou test.
Par exemple, un module défini dans src\geometry\rectangle.gleam (sous Windows) ou src/geometry/rectangle.gleam (sous les systèmes d'exploitation de type UNIX) serait nommé geometry/rectangle.
Importe des fonctions depuis d'autres modules
L'accès aux fonctions définies dans d'autres modules se fait via des imports.
Toutes les fonctions de ce module qui ont été exposées par celui-ci deviennent accessibles lorsqu'on importe ce module.
Mais la façon d'y accéder varie selon la manière dont le module est importé.
Les imports qualifiés sont utilisés par défaut, et l'accès à une fonction dans un tel module (par exemple la fonction map du module gleam/list) se fait en préfixant le nom du module (list.map).
// Import the int module
import gleam/int
pub fn run(x: Int) -> String {
// Use the to_string function from the int module
int.to_string(x)
}
Par défaut, le nom utilisé pour désigner le module est la dernière partie du nom du module, ici int, mais cela peut être changé en utilisant le mot-clé as.
// Import the int module and refer to it as i
import gleam/int as i
pub fn run(x: Int) -> String {
i.to_string(x)
}
Les imports non qualifiés permettent d'accéder directement aux fonctions exposées de ce module, sans les préfixer.
// Import the to_string function from the int module
import gleam/int.{to_string}
pub fn run(x: Int) -> String {
to_string(x)
}
Les imports qualifiés sont préférés car ils indiquent plus clairement au lecteur d'où vient une fonction, et permettent d'éviter les conflits de noms.
Bibliothèque standard
Gleam dispose d'une bibliothèque standard riche et bien documentée. La documentation est disponible en ligne sur hexdocs.pm/gleam_stdlib. Garde ce lien quelque part : tu l'utiliseras souvent !
La plupart des types de données intégrés ont un module correspondant qui propose des fonctions pour travailler avec ce type de données, par exemple il y a le module gleam/int pour les entiers, le module gleam/string pour les strings, le module gleam/list pour les tableaux, et ainsi de suite.
Exercice d'apprentissage
