LeekScript 4

LeekScript 4

> LeekScript

Le LeekScript 4 est la quatrième version du langage LeekScript, sortie le 1 juillet 2022. Cette page récapitule toutes les nouveautés apportées par cette version.

Array et Map séparés

Dans les versions du LeekScript 1 à 3, les tableaux étaient à fois des listes ([1, 2, 3, 4]) et des tables associatives (['a': 5, 'b': 12]). A partir du LeekScript 4, les deux aspects sont séparés dans deux types différents : les listes (Array) et les tables (Map). Ces deux nouveaux types sont plus performants que l'ancien type commun, et donnent une plus grande clarté dans l'utilisation.

Une liste Array est une suite continue d'éléments, commençant à l'indice 0. Ils sont équivalents à ArrayList de Java ou vector de C++. On peut accéder rapidement à un élément avec sa position, insérer/supprimer un élément à n'importe quelle position.

• Contrairement aux anciens tableaux, il n'est plus possible de créer un élément à la volée de cette façon : array[10] = v.
• Toutes les fonctions du LS et du combat renvoient ce nouveau type de liste (sauf getRegisters qui renvoie une Map).
• Le nouveau type Array utilise toutes les fonctions de la catégorie "Liste" de la documentation.
• Un accès en dehors de la liste renvoie null et un avertissement.

Une table Map est un objet qui relie une clé à une valeur. Ils sont équivalents aux HashMap de Java ou unordered_map de C++, les couples de (clé, valeur) ne sont pas ordonnés. Les clés peuvent être de tout type : nombre (entier ou réel), chaîne de caractère, objet, etc. On peut rapidement récupérer une valeur associée à une clé donnée. Ce nouveau type remplace l'aspect "associatif" des anciens tableaux

• Le nouveau type Map utilise toutes les fonctions de la catégorie "Table" de la documentation, préfixées par "map".
• Pour créer une table vide, deux syntaxes sont possibles :
• var table = [:]
• var table = new Map()

Nouvelles fonctions pour les listes

• arraySome(liste, predicat) : renvoie true si predicat renvoie true pour au moins un élément de la liste.
• arrayEvery(liste, predicat) : renvoie true si predicat renvoie true pour tous les éléments de la liste.
• removeAll(liste, element) : supprime tous les éléments "element" de la liste.
• arrayFrequencies(liste) : renvoie une table associant (element => quantité).
• arrayChunk(liste, taille) : renvoie une liste contenant des sous-listes de taille N.
• arrayUnique(liste) : renvoie un nouveau tableau sans les doublons.
• arrayRandom(liste, n) : renvoie une liste de N éléments aléatoires.

Retour de limite de RAM

Les nouvelles listes et cartes étant beaucoup plus performantes et légères en opérations, il était nécessaire de rétablir une limite au niveau de la RAM (mémoire de travail du programme). En effet, avec très peu d'opération il est possible de remplir des Giga de RAM facilement.

La limite de RAM est fixée à 100Mo (avant la MàJ 2.40) pour chaque IA (entité + invocations) par combat, ce qui correspond à 12 500 000 éléments de liste, de table ou d'objet. Cette limite est effective en LS4 car les anciens tableaux n'utilisent pas ce système de RAM, ils n'en n'ont pas besoin car leur consommation d'opération est suffisamment grande.

Les fonctions getMaxRAM() et getUsedRAM() sont ajoutés pour surveiller sa consommation de RAM en temps réel.

Entiers sur 64 bits au lieu de 32

Les entiers sont maintenant représentés sur 64 bits au lieu de 32 auparavant (dans toutes les version du LeekScript). L'augmentation permet de faire des calculs avec des nombres plus grands et permet d'avoir plus de bits pour les manipulations binaires.

Fonctions flèches

La syntaxe "Fonction flèche" est maintenant disponible pour écrire plus simplement des fonctions anonymes :

Paramètres par défaut

Dans les constructeurs, méthodes et méthodes statiques, il est maintenant possible d'utiliser des valeurs par défaut pour chaque paramètre :

Accès d'une plage d'une liste et indices négatifs

Deux nouvelles possibilités sont ajoutées pour accéder à des listes :

• Accès aux derniers éléments : liste[-1] renvoie le dernier, liste[-2] renvoie l'avant-dernier.
• Accès d'une plage : liste[10:20] renvoie une nouvelles liste contenant les éléments de la position 10 (inclus) à 20 (exclu).
• Accès d'une plage avec incrément : liste[10:20:3] renvoie les éléments à la position 10, 13, 16, 19.
• Incrément négatif : liste[20:10:-3] renvoie les éléments à la position 20, 17, 14, 11
• La fonction arraySlice(start, end, increment) qui remplace subArray a le même comportement que la syntaxe liste[start:end:increment].

Changement de l'opérateur == et opérateur === déprécié

L'opérateur ==, qui réalisait certaines vérifications d'égalités exotiques comme 1 == true ou 12 == [12] pouvant prêter à confusion a désormais le même comportement que l'opérateur === qui lui est déprécié.

• Si vous utilisiez uniquement des ===, vous pouvez les remplacer par des == sans problème.
• Si vous utilisiez des ==, il est possible que certains d'entre eux effectuaient une comparaison avec des nombres et/ou des booléens et doivent donc être remplacés par une expression plus complexe.

Nombres en Hexadécimal et Binaire

Il est possible d'écrire des nombres sous forme hexadécimale et binaire, en plus de décimale (merci à Karang pour la PR) :

var a = 0xabcdef // 11259375 var b = 0b110110101 // 437

Séparateurs "_" de nombre

Il est possible d'écrire de longues constantes numériques avec des séparateurs souligner "_", exemple :

var un_milliard = 1_000_000_000

Ordre des arguments des callbacks

Dans les fonctions arrayMap, arrayFilter, arrayIter, arrayPartition, arrayFoldLeft/Right, les fonctions callbacks prennent les arguments (value, clé/index) toujours dans cette ordre. L'ordre était (clé, valeur) et (valeur) précédemment.

De plus, toutes ces fonctions prennent en 3ème paramètre le tableau en train d'être parcouru.

Il est donc possible de passer n'importe quel nombre d'argument à un callback, les valeurs manquantes étant remplacées par des null.

Changements sur fonctions

• La position end de la fonction subArray est désormais exclusif en LS4+.
• La fonction removeElement ne laisse plus de trous en LS4+.
• La fonction arrayFlatten ne copie plus les éléments.
• Les fonctions assocReverse, assocSort, keySort sont supprimées et removeKey est remplacée par mapRemove en LS4+.
• Correction du coût de arrayMin.
• randFloat est renommée en randReal.
• codePointAt(string, [index]) : renvoie le codepoint unicode (nombre entier) situé à la position index (ou 0) dans la chaîne.

Vérification basique des types des arguments

Toutes les fonctions du jeu ont été typées précisément, ce qui permet de rajouter des erreurs lorsqu'un paramètre est incompatible avec le type attendu d'une fonction.

L'inférence de type étant encore très basique et vouée à évoluer, ces erreurs de type sont pour l'instant des avertissements.

Priorité de a = b = c

Il est maintenant possible d'écrire a = b = c sans parenthèses.

Clé dupliquée dans une déclaration de table

Lors de la déclaration d'une table, une erreur (LS4+) ou un warning est renvoyé si une clé apparaît en double :

Complexité des fonctions dans la documentation

La complexité de chaque fonction est affichée dans la documentation.

JSON encodage/décodage des objets et nouvelles listes

Les fonctions JSON jsonEncode et jsonDecode gèrent maintenant les nouvelles listes et les objets :

jsonDecode("[1, 2, 3]") : renvoie une nouvelle liste

jsonEncode("{a: 2, b: 4}") / jsonDecode("{a:2,b:4}") : fonctionne avec des objets.

Fonctions sur les nombres

• bitCount(x) : renvoie le nombre de bits à 1 dans le nombre.
• trailingZeros(x) : renvoie le nombre de bits à 0 à la fin du nombre.
• leadingZeros(x) : renvoie le nombre de bits à 0 au début du nombre.
• bitReverse(x) : renvoie un nouveau nombre avec tous les bits inversés de gauche à droite.
• byteReverse(x) : renvoie un nouveau nombre avec tous les bytes (groupe de 8 bits) inversés de gauche à droite.
• rotateLeft(x, y) : renvoie un nouveau nombre avec les bits décalés de y par la gauche (remet les bits par la droite).
• rotateRight(x, y) : renvoie un nouveau nombre avec les bits décalés de y par la droite (remet les bits par la gauche).
• hexString(x) : renvoie une chaîne représentant le nombre en hexadécimal.
• binString(x) : renvoie une chaîne représentant le nombre en binaire.
• realBits(x) : renvoie les bits du nombre sous la forme d'un entier.
• bitsToReal(x) : renvoie un nombre réel à partir de bits stockés dans un entier.
• isFinite(x) : détermine si le nombre x est fini.
• isInfinite(x) : détermine si le nombre x est infini.
• isNaN(x) : détermine si le nombre x est une valeur NaN.
• isPermutation(x, y) : renvoie true si le nombre x est une permutation du nombre y.

Constantes pour les nombres

• NaN : Constante représentant une valeur NaN. On a X == NaN égal false tout le temps (d'où la fonction isNaN).
• Infinity : Constante représentant l'infini. Pour avoir son opposé, utiliser -Infinity.
• Integer.MIN_VALUE et Integer.MAX_VALUE : entier minimum (-2^63 = 9223372036854775808) et maximum (2^63-1 = 9223372036854775807)
• Real.MIN_VALUE et Real.MAX_VALUE : réel minimum (2.2250738585072014e-308) et maximum (1.7976931348623157e308)

Mot-clé final pour les champs de classe.

Il est possible d'utiliser le mot-clé final devant un champ de classe pour indiquer que ce champ n'est plus affectable après la construction de l'objet. Une affectation est l'utilisation de l'opérateur =, il est toujours possible de modifier le contenu du champ si il est de type objet ou liste par exemple. Pour un champ final de type tableau, il faut donc utiliser arrayClear(objet.champ) au lieu de objet.champ = [].

Opérateur \ et \= de division entière

Les opérateurs \ et \= sont ajoutés pour réaliser des division entières ou euclidiennes, par exemple :

Il faut savoir que les deux nombres sont convertis en entiers s'ils n'en sont pas déjà :

Corrections et améliorations diverses

• Correction d'un bug lorsqu'un paramètre de méthode est capturé.
• L'initialisation statique est faite au tour 1 de chaque entité, au lieu d'avant le combat. Il n'est donc plus possible d'utiliser 20M d'opérations avant le combat et cela corrige un bug de combat lors d'un dépassement d'opérations durant cette initialisation.
• La localisation des erreurs est plus précise.
• debug([10, "20", "salut"]) renvoie [10, "20", "salut"] au lieu de [10, 20, salut].
• Correction d'un bug d'utilisation de break et continue dans une fonction et en dehors du boucle.
• Il est interdit de redéfinir une fonction à partir du LS4.
• Correction de bugs sur les méthodes statiques utilisées avec A['m'] et var m = A.m.
• Ajout d'une erreur si une méthode est dupliquée dans une classe.
• La fonction search renvoie -1 et plus null quand l'élément n'est pas trouvé.