Fonctions

ton.function additionner(a, b) {
    return a + b
}
print(additionner(2, 3))   // 5

Les fonctions sont des valeurs : elles peuvent être stockées dans des variables, passées en argument, et renvoyées par d'autres fonctions. Les expressions de fonction en créent une en ligne, le plus souvent comme callback :

ton.array doubles = map([1, 2, 3], ton.function(n) { return n * 2 })

Une expression de fonction peut optionnellement porter un nom (ton.function label(n) { ... }) utilisé seulement pour un affichage débogueur/erreur plus clair — il n'est pas lié comme variable sous ce nom.

Paramètres par défaut — donne à un paramètre = expression pour le rendre optionnel ; le défaut est évalué au moment de l'appel (dans l'ordre, donc un défaut plus tardif peut référencer un paramètre précédent) et seulement quand l'argument est omis :

ton.function saluer(nom, salutation = "Bonjour") {
    return salutation + ", " + nom + " !"
}
print(saluer("kuro"))              // Bonjour, kuro !
print(saluer("kuro", "Salut"))     // Salut, kuro !

ton.function paire(a, b = a + 1) {
    return str(a) + "-" + str(b)
}
print(paire(5))   // 5-6

Paramètres rest — préfixe le dernier paramètre par ... pour collecter les arguments en trop dans un tableau :

ton.function somme(...nombres) {
    ton.int total = 0
    for ton.n in nombres { total += n }
    return total
}
print(somme(1, 2, 3, 4))   // 10
print(somme())              // 0

Une fonction peut mélanger paramètres fixes et rest (function label(prefixe, ...items) { ... }), mais ... ne peut apparaître que sur le dernier.

Appeler une fonction avec trop peu d'arguments requis (ou trop, sans paramètre rest) est une erreur d'exécution — le message s'adapte selon que la fonction a des défauts/un rest ('ton.f' expects 2 argument(s) but got 1., 'ton.f' expects between 1 and 2 argument(s) but got 0., 'ton.f' expects at least 1 argument(s) but got 0.).

Les fermetures (closures) fonctionnent comme attendu : une fonction se souvient des variables du scope où elle a été déclarée, même après que ce scope ait par ailleurs terminé.

Fonctions fléchées (depuis beta-2.0.0) — une façon courte d'écrire une fonction anonyme, idéale pour les callbacks. Un seul paramètre n'a pas besoin de parenthèses ; un corps qui est une expression est renvoyé automatiquement ; un corps { bloc } marche comme une fonction normale.

ton.let double = n => n * 2
ton.let add = (a, b = 1) => a + b
ton.let greet = (name) => {
    ton.string msg = "Salut " + name
    return msg
}
print(double(21), add(1), greet("kuro"))   // 42 2 Salut kuro

Spread dans les appels — f(...args) passe les éléments d'un tableau comme arguments séparés : max(...[4, 9, 2]).

L'opérateur pipe |> — x |> f appelle f(x), et x |> f(a, b) appelle f(x, a, b). Il transforme des appels imbriqués en une chaîne qui se lit de gauche à droite :

ton.function inc(x, by = 1) { return x + by }
print(5 |> inc |> inc(10) |> str)              // 16
[1, 2, 3, 4] |> filter(n => n % 2 == 0) |> sum |> print   // 6

print est aussi une valeur de fonction : ["a", "b"].forEach(print). print(a, b, c) affiche ses arguments séparés par des espaces.

Les callbacks passés à map, filter, find, findIndex, forEach, any, all, count et flatMap reçoivent l'indice en second argument s'ils déclarent deux paramètres : names.map((name, i) => f"{i}. {name}").

La récursion profonde fonctionne (l'interpréteur tourne sur une grande pile), et une récursion infinie s'arrête avec une erreur rattrapable Maximum recursion depth (10000) exceeded au lieu de planter.

Modifier cette page sur GitHub