Modules système intégrés

TON618 est livré avec douze modules système intégrés. Ce ne sont pas des fichiers sur le disque — ils vivent dans l'interpréteur — mais tu les importes quand même avec IMPORT://ton.<nom> avant de les utiliser, exactement comme un module utilisateur :

IMPORT://ton.sys
IMPORT://ton.os
IMPORT://ton.requests
IMPORT://ton.random
IMPORT://ton.time
IMPORT://ton.json
IMPORT://ton.mathutils
IMPORT://ton.strings
IMPORT://ton.encoding
IMPORT://ton.regex
IMPORT://ton.path
IMPORT://ton.tensor

Appeler une des fonctions ci-dessous sans d'abord importer son module échoue avec une erreur "undefined function" — c'est voulu : un script ne paie (et n'expose) que les fonctions intégrées qu'il a effectivement demandées. Chaque module suit la convention de nommage recommandée pour les modules utilisateur ci-dessus : chaque fonction est préfixée par le nom du module lui-même.

#ton.sys — informations sur l'exécution & le processus

#ton.os — variables d'environnement & système de fichiers

#ton.requests — un client HTTP minimal

Un petit client HTTP sans dépendance (sockets bruts, même esprit que le serveur intégré). Limitation : http:// seulement, pas de TLS/https:// — il n'y a pas de bibliothèque SSL embarquée, donc il peut parler à des services locaux, d'autres serveurs TON618, ou n'importe quel point d'accès HTTP simple, mais pas à une API exclusivement HTTPS.

Les trois renvoient un ton.dict de même forme :

{
    ok: true,      // si une réponse a été reçue du tout
    status: 200,     // le code de statut HTTP (0 si la requête a totalement échoué)
    body: "...",       // le corps brut de la réponse
    error: ""            // une raison lisible quand ok est faux
}

IMPORT://ton.requests

ton.dict res = requests_get("http://localhost:8081/api/users")
if res["ok"] {
    print("Status: " + str(res["status"]))
    print(res["body"])
} else {
    print("Requête échouée : " + res["error"])
}

#ton.random — outils de hasard supplémentaires

Complète le random() toujours disponible avec quelques motifs courants :

#ton.time — horloges & timestamps

#ton.json — parsing JSON & affichage indenté

Le json(x) toujours disponible transforme déjà une valeur en JSON compact. IMPORT://ton.json ajoute l'autre sens, plus un format multi-lignes :

IMPORT://ton.json
IMPORT://ton.requests

ton.dict res = requests_get("http://localhost:8081/api/users")
ton.array users = json_parse(res["body"])
print(len(users))

#ton.mathutils — trigonométrie, logs & stats

Complète les sqrt/pow/abs/floor/ceil/round/min/max toujours disponibles avec trigonométrie, logarithmes, et petits outils de statistiques/théorie des nombres :

IMPORT://ton.mathutils

print(mathutils_gcd(48, 18))          // 6
print(mathutils_mean([1, 2, 3, 4]))   // 2.5
print(mathutils_clamp(15, 0, 10))     // 10

#ton.strings — aides supplémentaires sur les chaînes

Complète les upper/lower/trim/split/replace/contains/substring toujours disponibles :

IMPORT://ton.strings

print(strings_capitalize("hello world"))  // "Hello world"
print(strings_pad_left("7", 3, "0"))      // "007"

#ton.encoding — base64, hex, et encodage URL

Encodeurs/décodeurs sans dépendance pour les formats dont les scripts ont le plus souvent besoin en parlant à des API web :

IMPORT://ton.encoding

print(base64_encode("hello world"))  // aGVsbG8gd29ybGQ=
print(url_encode("a b/c"))            // a%20b%2Fc

#ton.regex — recherche de motifs

Reposant sur la bibliothèque standard <regex> de C++ (syntaxe ECMAScript) — pas de dépendance externe, et la même variante de regex que JavaScript.

IMPORT://ton.regex

print(regex_test("hello123", "[0-9]+"))                          // true
print(regex_replace("2024-01-15", "(\\d+)-(\\d+)-(\\d+)", "$3/$2/$1"))  // 15/01/2024

#ton.path — manipulation de chemins de fichiers

Manipulation de chaînes/chemins pure — aucun accès disque (voir ton.os pour ça).

IMPORT://ton.path

print(path_join("a", "b", "c.txt"))     // a/b/c.txt
print(path_extension("/foo/bar.txt"))    // .txt

#ton.tensor — petits tableaux numériques 1D/2D pour du ML basique

Un tenseur est un ton.dict avec deux champs — {shape: [...], data: [...]} (data est plat, ordre ligne par ligne) — donc il s'affiche, se str()-ise et se json()-ise comme n'importe quel dict. Les fonctions ci-dessous implémentent les opérations élément-par-élément/matmul/réduction en vraies boucles C++ (sans repasser par l'AST), un vrai gain de vitesse par rapport à la même boucle écrite à la main en TON618 — mais lis les limites honnêtes ci-dessous avant de construire quoi que ce soit d'ambitieux dessus. Cette même convention {shape, data} est celle sur laquelle le module communautaire atome (un simple fichier .ton, pas une partie de l'interpréteur — voir ton618 install atome) construit sa couche d'autodiff/entraînement.

IMPORT://ton.tensor

ton.dict a = tensor_from_array([[1, 2], [3, 4]])
ton.dict b = tensor_from_array([[5, 6], [7, 8]])
print(tensor_to_array(tensor_matmul(a, b)))   // [[19, 22], [43, 50]]
print(tensor_to_array(tensor_relu(tensor_from_array([-1, 0, 2]))))  // [0, 0, 2]

Limites honnêtes — à lire avant de construire quoi que ce soit d'ambitieux sur ton.tensor :

• CPU uniquement. Il n'y a aucun backend de calcul GPU (pas de bindings CUDA/OpenCL) nulle part dans cet interpréteur, et ça ne changera pas — le "support GPU" n'est pas quelque chose qu'un module .ton peut ajouter tout seul.
• Formes 1D et 2D seulement — pas de tenseurs 3D+ (donc pas de batchs d'images, pas de tenseurs façon têtes d'attention, etc. sans les astuces d'aplatissement/reshape faites toi-même).
• Seulement une diffusion scalaire (plus l'exception explicite tensor_add_bias ci-dessus) — tenseur + tenseur-de-forme-différente (diffusion façon NumPy) ne marche pas.
• Pas d'autodiff intégré. ton.tensor te donne les opérations forward et les helpers _grad correspondants pour construire la rétropropagation à la main — il n'y a pas de suivi automatique du graphe de calcul. Voir le module communautaire atome (ton618 install atome) pour une couche d'autodiff/entraînement construite à partir de zéro sur cette base.
• Pas du tout compétitif avec une vraie bibliothèque numérique. Ce sont toujours des boucles C++ sur un tableau de Value typé dynamiquement — un vrai travail pour un petit langage, mais loin des performances BLAS/cuDNN. Bien pour apprendre, des modèles jouets, et de petites expériences ; pas pour entraîner quoi que ce soit à échelle réelle.

Modifier cette page sur GitHub