Sortie du langage de programmation Haxe 4.0

Disponible version de la boîte à outils Hax 4.0, qui comprend le langage de programmation multi-paradigmes de haut niveau du même nom avec un typage fort, un compilateur croisé et une bibliothèque standard de fonctions. Le projet prend en charge la traduction vers C++, HashLink/C, JavaScript, C#, Java, PHP, Python et Lua, ainsi que la compilation vers JVM, HashLink/JIT, Flash et Neko bytecode, avec accès aux capacités natives de chaque plateforme cible. Code du compilateur distribué par sous licence GPLv2, ainsi qu'une librairie standard et une machine virtuelle développées pour Haxe neko sous licence MIT.

La langue est orienté vers l'expression avec un typage fort. Les concepts de programmation orientés objet, génériques et fonctionnels sont pris en charge.
La syntaxe Haxe est proche d'ECMAScript et se développe ses fonctionnalités telles que le typage statique, l'inférence d'autotype, la correspondance de modèles, les génériques, les boucles for basées sur un itérateur, les macros AST, GADT (Types de données algébriques généralisés), les types abstraits, les structures anonymes, les définitions de tableaux simplifiées, les expressions de compilation conditionnelles, l'attachement de métadonnées aux champs , classes et expressions, interpolation de chaîne (« Mon nom est $name »), paramètres de type (« new Main‹String›('foo') ») et beaucoup plus.

classe Test {
fonction statique main() {
var personnes = [
"Elizabeth" => "Programmation",
"Joël" => "Conception"
];

pour (nom dans people.keys()) {
var job = personnes[nom];
trace('$name fait $job pour gagner sa vie !');
}
}
}

principal des innovations version 4.0 :

• Nouvelle syntaxe pour spécifier le type de fonction "(name:String, age:Int)->Bool" ou "(String, Int)->Bool" au lieu de "String->Int->Bool".
• La syntaxe de la fonction fléchée est "(a, b) -> a + b" au lieu de "function(a, b) return a + b".
• Protection contre les problèmes liés à l'utilisation de valeurs Null (fonctionnalité expérimentale, activée en option pour certains champs, classes ou packages).
• Le mot-clé "final" concerne les champs de classe et les variables locales immuables. "final" peut également être utilisé pour définir des fonctions afin d'éviter qu'elles ne soient remplacées par l'héritage et pour les classes/interfaces qui ne peuvent pas être héritées.
• support Standard Unicode pour le type de base "String" sur toutes les cibles de compilation sauf Neko.
• Interpréteur intégré réécrit à partir de zéro, qui porte désormais le nom Éval. Grâce au nouvel interpréteur, les scripts et les macros s'exécutent beaucoup plus rapidement. Le mode de débogage interactif est pris en charge.
• Nouveau système cible pour la compilation (cible) Lien de hachage - un runtime haute performance conçu spécifiquement pour Haxe, prenant en charge la compilation en bytecode pour JIT ou C, a une intégration facile avec C, ainsi qu'un accès aux types et pointeurs numériques de bas niveau.
• Nouvelle cible JVM - vous permet de générer du bytecode jvm en sautant l'étape de compilation du code Java en ajoutant l'indicateur "-D jvm" lors du ciblage en Java.
• La possibilité de déployer en ligne au moment d'appeler des fonctions ou des constructeurs, même s'ils ne sont pas déclarés comme tels.
• Possibilité d'inclusion extensions statiques lors de la déclaration d'un type (tel que "enum") à l'aide de "@:using(path.ToExtension)".
• Les types abstraits prennent désormais en charge une version "set" de l'opérateur "@:op(a.b)" pour recharger les expressions "obj.foo = bar".
• La syntaxe de boucle "for" prend désormais en charge l'itération clé-valeur : "for (key => value in collection) {}".
• Prise en charge de l'utilisation d'un balisage de type XML dans les expressions : « var a = ‹hi/›; ». Pour l’instant, cette fonctionnalité n’est disponible que pour l’analyse avec des macros et est en phase de conception.
• La syntaxe des champs facultatifs dans la notation « complète » des types de structure anonymes est : « { var ?f:Int; }" (une alternative au court "{ ?f:Int }").
• Les valeurs d'énumération peuvent désormais être des valeurs par défaut pour les arguments de fonction : "function foo‹T›(option:Option‹T› = None)".
• La syntaxe « enum abstract Name(BasicType) {} » ne nécessite plus le préfixe « @: » dans « enum ».
• Numérotation automatique pour les énumérations abstraites :

  enum résumé Foo(Int) {
  variété A ; // 0
  variété B ; // 1
  }
  enum barre abstraite (chaîne) {
  variété A ; // "UN"
  variété B ; // "B"
  }

• Le mot clé "extern" ne nécessite plus l'utilisation du préfixe "@:".
• Suppression de l'option "met en oeuvre Dynamic" pour accéder aux champs de classe via des chaînes. Disponible pour les classes externes ou via une implémentation par un type abstrait.
• Ajout de la syntaxe "A & B" pour l'intersection de types, qui s'applique actuellement uniquement aux structures anonymes et aux contraintes de paramètres de type. L'ancienne syntaxe de contrainte a été supprimée.
• La création d'instances "Map" vides est disponible via la syntaxe "var map:Map‹Int, String› = [];" semblable à un tableau.
• Ajout de la structure de données "haxe.ds.ReadOnlyArray".
• Les métadonnées peuvent désormais avoir des espaces de noms (« @:prefix.name function() {…} »). De même avec les définitions : « #if (some.flag ... #end ».
• Nouveau protocole de service pour les IDE utilisés dans plugin pour VSCode.
• Mise à jour des définitions externes (extern) pour les API Web et ajout de celles manquantes.

Source: opennet.ru