Classes & objets

Depuis beta-2.0.0 tu peux définir tes propres types. Une classe regroupe des champs (les données) et des méthodes (des fonctions qui travaillent sur ces données). Dans une méthode, self est l'objet sur lequel la méthode a été appelée.

ton.class Point {
    ton.function init(x, y) {
        self.x = x
        self.y = y
    }
    ton.function distanceTo(other) {
        return sqrt((self.x - other.x) ** 2 + (self.y - other.y) ** 2)
    }
    ton.function toString() {
        return f"({self.x}, {self.y})"
    }
}

ton.Point a = Point(0, 0)
ton.let b = Point(3, 4)
print(a.distanceTo(b))     // 5
print(b)                   // (3, 4) — print/str/f-strings utilisent toString()
b.x = 10                   // les champs se lisent et s'écrivent avec le point

• Créer un objet : appelle la classe comme une fonction. Sa méthode init (le constructeur) reçoit les arguments ; sans init, la classe ne prend aucun argument.
• Les déclarations de champs dans le corps de la classe (ton.int count = 0, ton.let items = []) donnent à chaque nouvel objet sa propre valeur initiale, avant que init s'exécute. On peut aussi créer un champ à tout moment en assignant self.nom = ....
• Variables typées : ton.Point p = ... vérifie que la valeur est un Point (ou une sous-classe), ou nil.
• toString(), si elle est définie, sert dès que l'objet est converti en texte. Sans elle, un objet s'affiche Point{x: 3, y: 4} ; json(obj) donne {"x":3,"y":4}.
• Les méthodes sont des valeurs : ton.let f = point.toString garde self lié, donc f() marche plus tard.
• Les objets sont passés par référence (comme les tableaux et les dicts) : == n'est vrai que pour le même objet. copy(obj) / deepcopy(obj) en font une copie.

Héritage — extends fait réutiliser (et redéfinir) tout ce que contient une classe parente ; super.methode(...) appelle la version du parent :

ton.class Animal {
    ton.string sound = "..."
    ton.function init(name) { self.name = name }
    ton.function speak() { return f"{self.name} fait {self.sound}" }
}

ton.class Dog extends Animal {
    ton.int tricks = 0
    ton.function init(name) {
        super.init(name)
        self.sound = "wouf"
    }
    ton.function learn() {
        self.tricks++
        return self              // renvoyer self permet d'enchaîner
    }
}

ton.Dog rex = Dog("Rex")
print(rex.speak())                     // Rex fait wouf
print(rex.learn().learn().tricks)      // 2
print(isinstance(rex, Animal))         // true
print(type(rex))                       // Dog

Les objets marchent avec le reste du langage : "x" in point teste un champ, keys(obj)/values(obj)/items(obj) listent les champs, ton.let {x, y} = point le déstructure, {...point} copie ses champs dans un dict, et throw MonErreur("...") le lance (le catch reçoit l'objet lui-même).

Modifier cette page sur GitHub