Changelog

beta-2.0.0 — une grande modernisation du langage, et un interpréteur 6 fois plus rapide :

Objets :

Classes : ton.class Nom extends Parent { ... } avec champs, constructeur init, méthodes, self, super, toString(), et variables d'objet typées (ton.Point p = Point(1, 2)) — voir Classes & objets.
L'opérateur point partout : obj.champ, obj.methode(), dict.cle, et la syntaxe d'appel uniforme ("hi".upper(), arr.filter(...).map(...)) — voir Syntaxe méthode.

Nouvelle syntaxe :

Fonctions fléchées x => x * 2, (a, b) => { ... }, et le pipe x |> f(y).
f-strings f"Salut {name} !", chaînes brutes entre backticks, échappements \u{...}.
Intervalles 0..10 / 1..=10, tranches a[1:3], indices négatifs a[-1].
ton.let / ton.var / ton.const, et déstructuration ton.let [a, ...reste] = arr, ton.let {x, y: alias} = obj.
for k, v in dict, for i, x in tableau, for c in "texte", variables de boucle sans ton., un nouveau scope à chaque itération.
Chaînage optionnel a?.b, a?.[i], f?.() ; ??= ; ** (puissance) ; spread dans les appels f(...args).
Littéraux numériques 1_000_000, 1e9, 0xFF, 0b1010, 0o755.
throw de n'importe quelle valeur (dicts, objets) ; catch err sans parenthèses.
Espaces de noms IMPORT://module as alias et IMPORT://dossier/module.
print(a, b, c) avec plusieurs arguments ; print, int, float, bool, dict utilisables comme valeurs de fonction.

Bibliothèque standard : ~45 nouvelles fonctions — sum, avg, sorted, sort avec comparateur, range, zip, enumerate, unique, flatten, chunk, groupBy, flatMap, count, findIndex, forEach, items, dict, merge, remove, insert, removeAt, padStart, padEnd, startsWith, endsWith, repeat, chars, lines, capitalize, int, float, fixed, isinstance, copy, deepcopy, exit... — voir Fonctions natives.

Outils :

REPL : ton618 sans argument ; ton618 -e "code" pour une ligne.
Meilleures erreurs : la ligne de code, une trace à travers les appels de fonction, « did you mean ...? » pour les noms mal orthographiés, et les numéros de ligne sur les erreurs des fonctions natives.
Limite de récursion rattrapable (10 000 appels) au lieu d'un plantage.
Une suite de tests de non-régression (tests/, make test, lancée par la CI).

Changements de comportement :

Les nombres s'affichent sous leur forme exacte la plus courte : 3.14 au lieu de 3.140000, 0.5 au lieu de 0.500000 (aussi dans str(), json() et la concaténation).
Un continue dans un switch dans une boucle continue maintenant la boucle (il était avalé par le switch).
Les erreurs des fonctions natives rattrapées par catch commencent maintenant par Error at line N: comme toutes les autres erreurs d'exécution.
Une closure créée dans une boucle for ... in capture la variable de son itération (elle voyait la dernière valeur).

Performances : environ 6 fois plus rapide sur du code typique — les noms sont résolus via des symboles internés, les scopes sont des vecteurs plats, le contrôle de flux n'utilise plus d'exceptions C++, et les blocs qui ne déclarent rien n'allouent pas de scope.

beta-1.0.10 — tensor_to_bytes/tensor_from_bytes, de vrais fichiers binaires :

tensor_to_bytes(t) / tensor_from_bytes(octets, forme) : empaquette/décode les données d'un tenseur en octets bruts IEEE-754 float64. Combiné à writefile/readfile (désormais ouverts en mode binaire, pour que les octets fassent l'aller-retour exactement même sous Windows, pas seulement Linux/Mac), ça permet à un module .ton d'écrire de vrais fichiers binaires — plus besoin d'encoder les nombres en JSON texte et de perdre en précision à cause de l'arrondi à ~6 chiffres significatifs de json_stringify. Les fichiers modèles .atm du module communautaire atome utilisent désormais ça plutôt que du JSON.

beta-1.0.9 — --uninstall-ton supprime aussi ./modules/ :

Changement de comportement : ton618 --uninstall-ton supprime désormais aussi tout le dossier ./modules/ du répertoire courant (tous les modules récupérés là avec ton618 install <module>), en plus de supprimer le binaire et son entrée PATH. Les scripts autonomes scripts/uninstall.sh/uninstall.ps1 font pareil. Pour ne supprimer qu'un seul module, utilise plutôt ton618 uninstall <module> — voir Installer des modules.

beta-1.0.8 — ton618 install/uninstall normalisent le nom du module en minuscules :

Correction de bug : ton618 install <module> met désormais le nom du module en minuscules avant de construire l'URL brute GitHub et le chemin local ./modules/<nom>.ton (la recherche dans le registre, elle, utilise toujours le nom exactement tel que tapé). Tous les modules existants suivent la convention du nom de fichier en minuscules (atome.ton, etc.), et les URLs raw.githubusercontent.com sont sensibles à la casse — une entrée de registre publiée avec une autre casse (par exemple Atome) provoquait donc un 404 au lieu de trouver le vrai fichier, en minuscules, à la racine du dépôt. ton618 uninstall <module> a été corrigé de la même façon, pour continuer à cibler le fichier réellement écrit par install.

beta-1.0.7 — tensor_argmax et tensor_conv1d :

tensor_argmax(t) : l'index de l'élément le plus grand (ou un par ligne pour un tenseur 2D).
tensor_conv1d(signal, noyau, [pas]) : convolution 1D (corrélation croisée) sur des tenseurs à un seul canal — la primitive sur laquelle le module communautaire atome construit sa couche Conv1D (multi-canaux, suivie par l'autodiff), vérifiée par un test de gradient numérique.

beta-1.0.6 — ton.tensor, un module natif pour du ML basique :

Nouveau module intégré ton.tensor : tableaux numériques 1D/2D avec opérations élément par élément, multiplication matricielle, transposition, réductions, activations courantes (relu/sigmoid/tanh/softmax) et leurs gradients, plus conversion tableau/tenseur — implémenté en vraies boucles C++ pour un vrai gain de vitesse par rapport à la même boucle écrite à la main en TON618. CPU uniquement, pas d'autodiff intégré — voir ton.tensor pour la liste complète des fonctions et ses limites honnêtes. Le module communautaire atome (ton618 install atome, une fois publié) est construit dessus et a gagné 5 à 16x en vitesse en migrant vers lui, sans aucun changement à sa propre API publique.

beta-1.0.5 — opérateurs binaires (bits) et spread :

Opérateurs binaires : &, |, ^, ~, <<, >>, plus leurs formes d'assignation composée (&=, |=, ^=, <<=, >>=). Les opérandes sont tronqués en entiers 64 bits, l'opération appliquée, puis reconvertis — voir Opérateurs.
Spread (...) dans les littéraux de tableau : [...a, x, ...b] éclate les éléments d'autres tableaux directement dedans — voir Tableaux.
Spread (...) dans les littéraux de dict : {...d1, cle: val, ...d2} fusionne les entrées d'autres dicts, une entrée plus tardive écrasant une entrée précédente avec la même clé (à sa position d'origine) — voir Dictionnaires.

beta-1.0.4 — ton618 uninstall <module>, et un nom plus clair pour l'ancien --uninstall :

ton618 --uninstall (qui désinstallait l'interpréteur ton618 lui-même) est renommé en ton618 --uninstall-ton, pour laisser la place à la commande ci-dessous et éviter de confondre les deux.
ton618 uninstall <module> : supprime ./modules/<module>.ton — le pendant de ton618 install <module> (voir Installer des modules).

beta-1.0.3 — nouveaux opérateurs, paramètres de fonction flexibles, et finally :

Paramètres par défaut : function saluer(nom, salutation = "Bonjour") { ... } — 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.
Paramètres rest : function somme(...nombres) { ... } collecte les arguments en trop dans un tableau ; peut être mélangé avec des paramètres fixes tant que ... est en dernier. Les messages d'erreur d'arité s'adaptent maintenant (expects between 1 and 2 argument(s), expects at least 1 argument(s)).
?? (opérateur de coalescence nulle) : valeur ?? defaut retourne valeur sauf si elle vaut nil, auquel cas il retourne defaut — le défaut n'est jamais évalué autrement (court-circuit). Voir Opérateurs.
in (opérateur d'appartenance) : valeur in tableau, valeur in dict (teste les clés), valeur in chaine (test de sous-chaîne). Voir Opérateurs.
finally : try/catch gagne un bloc finally qui s'exécute toujours — en cas de succès, d'erreur attrapée, ou à travers un return — et catch est maintenant optionnel tant que finally est présent (try { ... } finally { ... }). Voir Gestion des erreurs.
ton618 install <module> : récupère les métadonnées d'un module depuis le registre de modules TON618 et télécharge son code directement depuis GitHub dans ./modules/. Voir Installer des modules.
Un nouveau skill IA pour créer des modules TON618 (par opposition à écrire des scripts), en plus du skill généraliste existant — voir exemples/skills/ton618-module-author/.

beta-1.0.2 — formatage de chaînes simplifié, et un skill IA :

L'interpolation de chaînes ("Bonjour ${nom}!") a été retirée au profit du bien plus simple format(modele, ...args) : format("Bonjour {}!", nom). L'interpolation demandait au lexer de relancer récursivement le lexing d'expressions arbitraires embarquées dans les littéraux chaîne (en suivant les guillemets et accolades imbriqués) — beaucoup de machinerie pour ce qu'une simple fonction de traitement de chaînes fait tout aussi bien, avec bien moins de choses à garder en tête. Voir Formatage de chaînes.
Un skill IA pour TON618, à la fois en SKILL.md façon Claude Code et en AGENTS.md générique, pour qu'un agent IA écrive du .ton correct sans avoir à redériver le langage depuis ce document — voir le lien "Skills for AI" à côté du playground, ou exemples/skills/.

beta-1.0.1 — corrections de bugs, nouvelle syntaxe, et une bibliothèque standard bien plus grande :

Corrections de justesse :

<, <=, >, >= vérifient maintenant le type et prennent en charge les chaînes : auparavant ils comparaient silencieusement le champ nombre interne quel que soit le type, donc par ex. "apple" < "banana" s'évaluait comme 0 < 0 (false) au lieu d'une comparaison lexicographique. Ils comparent maintenant les nombres numériquement, les chaînes/html lexicographiquement, et lèvent une erreur pour toute autre combinaison.
==/!= font maintenant une égalité structurelle pour les tableaux et dicts (récursivement, élément par élément) au lieu d'être toujours "différents" l'un de l'autre quel que soit le contenu ; une chaîne et une valeur html avec le même texte sont maintenant égales aussi.
% lève maintenant une erreur pour une division par zéro au lieu de produire silencieusement NaN, comme /.

Nouvelle syntaxe :

~~Interpolation de chaînes~~ — ajoutée ici, remplacée par format() en beta-1.0.2 (voir plus haut)
switch / case / default, sans fallthrough et avec prise en charge de plusieurs valeurs par case
Indexation de chaînes : s[0] lit un caractère (les chaînes restent immuables — assigner à un index est une erreur)

Nouvelle bibliothèque standard :

Trois nouveaux modules intégrés : ton.encoding (base64/hex/URL), ton.regex (basé sur <regex>), ton.path (manipulation de chemins)
Nouvelles natives toujours disponibles : find, any, all, writefile
Nouveau dans ton.os : os_appendfile, os_readlines, os_isfile, os_isdir, os_rename, os_tempdir, os_copy
Nouveau dans ton.strings : strings_trim_start, strings_trim_end, strings_words, strings_center, strings_replace_first, strings_snake_case, strings_camel_case
Nouveau dans ton.mathutils : mathutils_min_of, mathutils_max_of
Nouveau dans ton.json : json_pretty
Nouveau dans ton.sys : sys_arch, sys_version ; sys_platform() reconnaît maintenant aussi "termux"

Serveur local :

Les gestionnaires de route reçoivent maintenant la requête sous forme de ton.dict ({method, path, query, params, body}) au lieu d'être appelés sans arguments — un changement cassant depuis beta-1.0.0, qui résout l'ancienne limitation "impossible de lire le corps POST ou les paramètres d'URL". Les routes peuvent utiliser des segments de chemin :nom (/user/:id).

Distribution & outillage :

Les binaires précompilés sont maintenant construits et publiés par GitHub Actions (.github/workflows/release.yml), compilant en croisé Linux x64, Windows x64, et Termux/Android arm64 à chaque release taguée
ton618 --update [version] : retélécharge le binaire correspondant à la plateforme actuelle depuis les GitHub Releases et remplace celui en cours d'exécution
ton618 --version / -v : affiche la version, la plateforme détectée, et l'architecture
.github/workflows/pages.yml publie exemples/ (doc + playground) sur GitHub Pages, avec prise en charge de domaine personnalisé (exemples/CNAME)
Le playground du navigateur (ton618-lite.js) implémente maintenant aussi ton.mathutils, ton.strings, find/any/all, json_pretty, switch/case, et l'indexation de chaînes — comblant plusieurs écarts où il se comportait silencieusement différemment de l'interpréteur réel

Ajouts antérieurs au langage (avant beta-1.0.1) :

Assignation composée : +=, -=, *=, /=, %=
Incrémentation/décrémentation : ++, -- (postfixe, sur variables et cibles indexées)
Opérateur ternaire : cond ? a : b
Boucle for ... in sur tableaux et dictionnaires, aux côtés d'un for classique style C
Gestion d'erreurs try / catch / throw
Type ton.dict, avec littéraux {cle: valeur, ...}, indexation [], et keys()/values()/has()
Expressions de fonction : ton.function(params) { ... } comme valeur inline, pour les callbacks
Une grande bibliothèque standard : type, assert, input, aides maths/chaînes/tableaux/dicts, map/filter/reduce
Un guide documenté pour écrire des modules, et huit (maintenant onze) modules système intégrés
Un playground dans le navigateur (exemples/playground.html, propulsé par exemples/ton618-lite.js)
documentation.html affiche DOCUMENTATION.md directement (embarqué au moment de l'édition via make docs)

Modifier cette page sur GitHub