à retenir : Parasail, Qore, Frost, Zimbu, Neon, Copper ==================== 11L ==================== + déclaration obligatoire des variables (V v) + enums (T.enum) + iteration sur tableau (L(elt) .tableau) + avec possibilite de differencier premier et dernier passages + extension de tableau (+=) ? + intervalles corrects [..] + switch (S) + typedef (T ... =) - pas de syntaxe speciale pour les regex (mais re:"" pour les creer) - pas d'unsigned - pas d'interpolation de chaîne ==================== Able ==================== + structs (struct) + unions (union) + hashs (Map) + itération sur tableau (for elt in tableau) + interpolation de chaîne ($) + unsigned (u32) = intervalles corrects [..] (..) faciles à confondre avec ouverts (...) -- l'affectation est un moyen de déclarer une variable ==================== Ada ==================== + déclaration obligatoire des variables + intervalles corrects [..] + consts (constant) + struct (record) + enums ((,)) + typedef (type, subtype) + unsigned (natural) + switch (case) + itération sur tableau(for elt of tableau) + tableau extensible (lourdingue: vector) (.Append()) + surcharge d'opérateur + création de bindings C simple et propre - verbeux - pas d'interpolation de chaine - pas de conversion implicite - pas de syntaxe pour les regex =================== Adept =================== + déclaration obligatoire des variables (v Type) + constantes (const) + enums (enum) + structs (struct) + unions (union) + itération sur tableau (each Type in tableau { ... it ... } ) + itération double avec index (each Type in tableau { ... it ... idx ... } ) + extension de tableau (.add()) + switch (switch) + typedef (alias) + unsigned (ubyte, ushort, uint, ulong) =================== Agena =================== + constants + enums (enum) + hashs (~) + sets ({}) + intervalles corrects [..] + extension de tableaux (insert into) + itération sur tableaux (for elt in tableau) + itération double avec index (for i, elt in tableau) + switch (case of) -- pas de déclaration obligatoire des variables - pas de support des regex =================== Agora =================== + déclaration obligatoire des variables (v := init) -- pas de types, typage dynamique =================== Aikido =================== + déclaration obligatoire des variables (var) + constantes (const) + enums (enum) typées + hashs (Map) + structs (class avec membres publics) + switch (switch) + extension de tableau (+=) + itération sur tableau (foreach elt in tableau) + intervalles corrects [..] - pas de syntaxe pour les regex =================== Aime =================== + déclaration obligatoire des variables (Type v, w;) + unsigned (cardinal) =================== Algol 68 =================== + déclaration obligatoire des variables (Type v) + constants (=) + structs (struct) + intervalles corrects [..] + typedef (mode) + surcharge d'opérateurs + création d'opérateurs ! (OP) + écrit en C, a l'air facile à étendre = pour regexp : fonction grep = pas d'itération sur tableau mais upper/lower bounds accessibles - pas d'extension de tableau, mais facile à définir un OP -- pas d'enum ===================== Angelscript ===================== + déclaration obligatoire des variables (Type v;) + constants (const) + enums (enum) + hashs (dictionary) + extension de tableau (.insertLast()) + switch (switch) sur entiers constants seulement + typedef (typedef) + unsigned + surcharge d'operateurs - pas d'iteration sur tableau - pas d'interpolation de chaine ===================== Ante ===================== -- syntaxe Python en encore plus fasciste ===================== Aphid ===================== -- pas de déclaration de variables ===================== Apricot ===================== -- Lisp =================== Argile =================== + déclaration obligatoire des variables (let type v) + enums (enum) + structs (class) + unions (union) + itération sur tableaux (for each elt in tableau) + hashs (hash, %) + très bonne intégration des regex + génère du C, possibilité d'appeler du C directement = constantes (macros) - les variables peuvent être redéclarées :-( (let x = 12; let x = "oh!") - pas de doc pour la bibliothèque =================== Ark =================== -- Lisp =================== Astro =================== + déclaration obligatoire des variables (var v) + constantes (let) + enums (enum) + structs (type) - écrit en Rust - les constantes peuvent être redéfinies (let x 12; let x "aie") - intervalles incorrects [..[ =================== ATS =================== -- ML =================== Avail =================== + déclaration obligatoire des variables (v1 : type; v2 ::= v1) + sets ({}) + itération sur tableau (for each elt of tableau) + itération double avec index (for each elt, i of tableau) + typedef (private method t2 is [t1]) + unsigned (natural number) - écrit en Java/Kotlin - VM - comment faire des structs ? - doc très incomplète =================== Ballerina =================== + declaration obligatoire des variables (var v ou Type v) + itération sur tableau (foreach var elt in tableau) + intervalles corrects [..] + switch sur chaine (match) + operateur Elvis + hash (map) + constants (const) + interpolation de chaine (${}) + extension de tableau (.push()) + struct (record) + inclusion de struct (...) + gestion d'erreurs (int|error) + typedef (type) + unsigned -- pas d'enum ! - pas encore de syntaxe spéciale pour les regex (ca devrait arriver) - Java =================== Beast =================== + déclaration obligatoire des variables (Type! v) + enums (enum) = constantes pas encore implémentées -- pas fini, abandonné =================== Beef =================== + déclaration obligatoire des variables (var v ou Type v) + constantes (let) + structs (struct), imbriquées, avec méthodes + types unsigned + enum (typées) + typedef (typealias) + itération sur tableau (for let elt in tableau), ro ou rw au choix + switch (switch) sur chaine et autres. + pas d'exception mais un type Result -- installation : veut télécharger des trucs via git -- script erroné - repart de 0 à chaque fois (pas de Makefile) -- veut compiler cette horreur de LLVM alors qu'il est installé sur le système -- sous Windows: crashdumpe au démarrage ================== BlitzMax ================== + déclaration obligatoire des variables (Local v : Type) en mode strcit + constantes (Const) + enum (Enum) + structs (Type) + itération sur tableau (For Local elt = EachIn tableau) + switch (Select) + unsigned (UInt, Short, ULong) + surcharge d'opérateur - intervalles incorrects [..[ pour les slices mais corrects pour les boucle For To ... - pas d'interpolation de chaine ================== Blunt ================== + déclaration obligatoire des variables (data v Type) + constantes (constant) + enums (enum) + structs (struct) - intervalles incorrects [..[ ================== Bon ================== -- pas de déclaration de variable ================== Boron ================== = Rebol ================== Bosque ================== + déclaration obligatoire des variables (var v = init;) -- pas de boucles ================== Braid ================== + enums (type |) + structs (type {}) + unions (type |) -- pas de variables ? ================== Brat ================== -- pas de déclaration de variable ================== C# ================== + constants (const) + interpolation de chaine ({}) + extension de tableau List (.Add()) + itération sur tableau (foreach(Type elt in tableau)) (ou var à la place de Type) + switch (switch) sur chaine et tout, avec condition supplémentaire (when) + struct (struct ), avec méthodes + enum + hash (Dictionary) + ensembles (HashSet / SortedSet) + unsigned + surcharge d'opérateurs existants (mais pas définition de nouveaux) - pas de syntaxe spéciale pour les regex - pas d'itération double avec index, mais on doit pouvoir bricoler une macro avec Select popur ça - pas d'imbrication/héritage pour les struct, mais il y a les classes - .Net - hyper-méga lourdingue ==================== C++ ==================== + déclaration obligatoire des variable - pas d'interpolation de chaine - pas de syntaxe spéciale pour les regex - impossible de surcharger les opérateurs sur les types de base (donc sur les chaines) - 300 lignes de messages d'erreur à chaque petit problème de template, c'est-à-dire tout le temps =================== C2 =================== + déclaration obligatoire des variables (Type v;) + enums (enum) + structs (struct) + unions (union) + switch (switch, sswitch) sur chaine + typedef (type) - pas d'extension de tableau - dépend de LLVM =================== CandleScript =================== -- pour Web, HTML =================== CarML =================== - ML =================== Cerberus X =================== + déclaration obligatoire des variables (Local v:Type = init) en mode strict + constantes (Const) - intervalles incorrects [..[ - pas d'unsigned =================== Céu =================== + déclaration obligatoire des variables (var Type v;) + struct (data with) + intervalles corrects [..] [->] et exclusifs [->[ + unsigned (u8/16/32/64) + possibilité d'insertion de code C =================== Ceylon =================== + typedef (alias et subtype) + struct (class avec attributes) + interpolation de chaine (``var``) + declaration obligatoire des variables (value v ou Type v) + switch (switch) est une expression + itération sur tableau (for elt in tableau) - pas d'enum ? - pas de syntaxe spéciale pour les regex - Java =================== C-for-all =================== + déclaration obligatoire des variables (Type v;) + constants (const, enum) + enums (enum) + structs (struct) + intervalles corrects [..] avec ~= (attention à ~ qui est [..[) + switch (switch, close) de base avec seulemnt des intervalles, pas de chaine ou autre + unsigned + surcharge d'opérateurs (et d'autres choses) - pas d'itération sur tableau - pas d'extension de tableau - pas d'interpolation de chaine ===================== Ch ===================== + switch (switch) sur chaine - freeware - pas d'itération sur tableau, seulement sur chaine ===================== ChaiScript ===================== + déclaration obligatoire des variables (var v) + interpolation de chaine (${}) + itération sur tableau (for(elt : tableau)) + extension de tableau (.push_back()) + switch (switch) ================== Chaos ================== + déclaration obligatoire des variables (Type v = init) + hashs {dict) + itération sur tableau (foreach tableau as elt) -- conditions(si, cas) gerbées de la tronche ================== Chapel ================== + déclaration obligatoire des variables (var v = 10; ou var v: int;) + constants (const, param, config) + unsigned (uint, uint(16), ...) + typedef (type nb = uint;) + tuples + sets (domain) + hashs (domain(string)) + structs (record, class) + unions (union) + enums (enum) typées + switch (select) + itération sur tableaux (for elt in tableau) + tableaux extensibles (list) avec append() + intervalles corrects [..] + compréhensions + possibilités de paramètres nommés = surcharge d'opérateurs - pas de syntaxe pour les regex (mais possibilité de surcharger des opérateurs) - pas d'interpolation de chaîne - pas de litéral pour un tableau vide ! -- a introduit des putains de lifetime pour copier Rust ================== Cheez ================== + extension de tableau (.add()) ================== Citrine ================== + déclaration obligatoire des variables (doigt-vers-la-droite v := init.) + hash (Map) - icones partout - Smalltalk - pas de if mais des true: ================== Clean ================== + déclaration obligatoire des variables (avec type) + enums (|) + structs (records, {}) + compréhensions - très fonctionnel (doc imbittable) ================== Clever ================== + décalaration obligatoire des variables (var v;) + constantes (const) -- dynamique, pas de types dans els décla ou les fonctions ================== Cloe ================== -- Lisp ================== Cobra ================== - .Net --- pas de déclaration obligatoire des variables ================= Coconut ================= -- fonctionnel ================= COMAL ================= + switch (CASE) ================= Concurnas ================= -- l'affectation vaut une déclaration de variables ================= Converge ================= -- syntaxe python en mode fasciste ================= Copper ================= + déclaration obligatoire des variables ( var v : Type) + constantes (const) + enums (stype) + structs (struct) + switch (switch) + typedef (const) + unsigned (Unsigned8/16/32/64) - pas de possibilté de spécifier le type des retours de fonction ================= Copper (2) ================= + déclaration obligatoire des variables ( var v : Type ou var v = init) + constantes (const) + enums (stype) + structs (struct) + itération sur tableau (tableau each do elt + itération double avec index (tableau eachWithIndex do i, elt) + switch (switch) + typedef (const) + unsigned (Uint8/16/32/64) ================= CoreScript ================= + déclaration obligatoire des variables (var) - espaces obligatoires autour des signes = - un grand rien ? ================= Crack ================= + déclaration obligatoire des variables + constantes (const) + interpolation de chaîne + itération sur tableau - pas de type énuméré - pas d'intervalles - chaines immuables - pas de syntaxe spéciale pour les regex - dépend de LLVM (3.3) -- erreur en compilant le langage =================== Crayon =================== -- pas de déclaration de variables -- typage dynamique =================== Crystal =================== -- pas de déclaration de variables ==================== Cyan ==================== + déclaration obligatoire des variable (var Type v; ou var v = init ) + constantes (let) + itération sur tableau ( tableau foreach: { (: Type elt :) ... }; ou for elt in tableau {}) + intervalles corrects [..] (..), et ouverts (..<) + interpolation de chaine ($) - pas d'unsigned ==================== D ==================== + déclaration obligatoire des variable (Type v;) + enums (enum) + structs (struct) + hashs + iteration sur tableau (foreach(elt; tableau)) + itéation double avec index (foreach(i, elt; tableau)) + extension de tableau (~=) + switch (switch) sur chaines + unsigned + typedef (alias) + surcharge d'opérateurs (mais pas sur types de base, dont chaine) - intervalles [..[ - pas de syntaxe spéciale pour les regex - difficulté avec stdlib: les fonctions retournent des templates et autres merdes dans le genre qui ne sont pas vraiment des objets ou des types clairs ==================== Dachs ==================== + déclaration obligatoire des variables (var v := init ou var v : Type) + constantes (let) + switch (case) ==================== Dafny ==================== + déclaration obligatoire des variables (var v := init; ou var v: type := init;) - intervalle incorrect [..[ ==================== Dao ==================== + déclaration obligatoire des variables (var) + constantes (const, invar) + enums (enum) + hashs (map) + structs (type tuple, ou class avec champs public) + unions (|) + itération sur tableau (for(elt in tableau) + extension de liste (append(), push()) + intervalles corrects [..] + switch (switch), sur chaines + retour de tuples + typedef (type) + surcharge d'opérateurs = possibilité de bindings C, mais pas super simple pour les types un peu compliqués - pas de syntaxe particulière pour les regex ? ==================== Dart ==================== + déclaration obligatoire des variables (var v, Type v) + constantes (const, final) + enums (enum) typées + structs (class) + hashs (map, {}) + ensembles (set, <>{}) + itération sur tableau (for (var elt in tableau), ou: tableau.ForEach((elt) ) + switch (switch) sur chaine + interpolation de chaine ($,${}) + surcharge d'opérateurs (pas de création) - pas d'unsigned - pas de syntaxe spéciale pour les regex - Dart tools may send usage metrics and crash reports to Google. By downloading the Dart SDK, you agree to the Google Terms of Service. ================== DaScript ================== + déclaration obligatoire des variables (var v = init ou var v : Type) + constantes (let) + enums (enum) + structs (struct) + unions (variant) + hashs (table) + itération sur tableau (for elt in tableau) + typedef (typedef) + interpolation de chaine ({}) + unsigned (uint/2/3/4/8/16/64) + compréhensions = syntaxe python ou bien avec {} et ; - chaines immuables - intervalles incorrects [..[ ================== Delta ================== + déclaration obligatoire des variables (var v = init ou Type v) + constantes (const) + structs (struct) + unions (union) + itération sur tableau (for(var elt in tableau) {}) + extension de liste (.push()) + switch (switch) + surcharge par nom de paramètre + retour de tuples + unsigned (uint/8/16/32/64) + bindings C directs = intervalles corrects [..] (...) et incorrects [..[ (..) faciles à confondre - pas de support pour les regex ================== Dictu ================== -- typage dynamique ================== Dino ================== + déclaration obligatoire des variables - typage dynamique ================== Dodo ================== + déclaration obligatoire des variables (def v = init ou Type v) + constantes (def c() = init) + hashs ([:]) + ensembles ([:]) + itération sur tableau (for elt in tableau) + intervalles corrects [..] (...), avec longueur possible + typedef (def) + syntaxe pour regex (//) = enums très bizarres ================== Dotlang ================== - pas d'unsigned à part byte ================== Duck ================== -- pas de déclaration des variables ================== Dylan ================== + déclaration obligatoire des variables (let) + intervalles corrects [..] (from to) + itération sur tableau (for (elt in tableau)) + extension de tableau (add!()) () + switch (select) sur chaine et tout + constants (define constant) + structs (class avec slots) + ensembles (set) + hash (table, plist) - pas d'enums - obligation d'entourer les opérateurs d'espaces - pas de syntaxe spéciale pour les regex - pas d'interpolation de chaine - type après les variables dans les déclarations (mais optionnels) ================== Dyon ================== + déclaration obligatoire des variables (v := init) - en Rust - tous les nombres sont des flottants - pas d'interpolation de chaine - pas de type à part pour les fonctions - pas de structs ? ================== Dyvil ================== + déclaration obligatoire des variables (var v) + structs (class avec fields var) + extension de tableaux (+=, ++=) + typedef (type) + interpolation de chaine (\()) - JVM - pas d'unsigned - doc incomplète =================== E =================== + déclaration obligatoire des variables (var) + constants (def) + structs (classes) + itération sur tableau (for elt in tableau) + itération double avec index (for i => elt in tableau) + extension de tableau (.push()) + intervalles corrects [..] + interpolation de chaine ($) - pas d'unsigned - types vérifiés à l'exécution seulement - Java ===================== eC ===================== + déclaration obligatoire des variables (Type v;) + constants (define) + enum (enum) typées avec héritage + structs (struct, class) + hashs (Map<>) + itération sur tableau (for(elt : tableau)) + extension de tableau (.Add()) + switch (switch) + typedef (typedef) + unsigned - pas de syntaxe spéciale pour les regex -- je segfaulte, tu segfaultes, nous segfaultons ================== Efene ================== -- fonctionnel, pattern -- syntaxe Python ================== Egison ================== -- fonctionnel, ML ================== Eiffel ================== + déclaration obligatoire des variables (v: TYPE) + structs (class) + iteration sur tableau (across tableau as elt loop ... elt.item ... end) + iteration double sur tableau avec index (... elt.index ...) + switch (inspect) = pas d'intervalles à part dans les switchs ? si : |..| - pas d'interpolation de chaines -- pas d'enum - lourd ================== ElastiC ================== + déclaration obligatoire des variables (local v;) + hashs (%[]) + itération sur tableau (for(elt in tableau)) -- pas de types ================== Elena ================== + déclaration obligatoire des variables (var v; var Type w; Type v;) + constantes (const) + structs (struct, ou class avec field) + hashs (Dictionary) + itération sur tableau (tableau.forEach:(elt) { ...}) + unsigned (uint, byte) - qu'est-ce que c'est que ce script de build à la con ? - pas d'enum ================== Elixir ================== -- pas de variables variables ================== Encore ================== -- let ... in ... ================== Epoch ================== - pas de doc ? ================== Eta ================== -- fonctionnel ================== Euphoria ================== + déclaration obligatoire des variables (Type v) + constants (constant) + intervalles corrects [..] + switch (switch ou switch with fallthru) + enums (enum / enum type) + hash (map) mais sans syntaxe spéciale - pas d'itération sur tableau - pas de syntaxe spéciale pour les regex ================== F# ================== + déclaration obligatoire des variables (let, let mutable) + constants (let + attribut []) + intervalles corrects [..] + itération sur tableau (for elt in tableau) + extension de tableau ResizeArray (.Add()) + switch (match) sur chaine et tout, avec possibilité de condition supplémentaire (when) + struct (struct / class) + enum + hash + ensemble (Set) + typedef (type) + définition de nouveaux opérateurs - pas de syntaxe spéciale pour les regex (mais assez facile à implementer (active patterns pour match, et let (=~) target regex = System.Text.RegularExpressions.Regex.IsMatch(target, regex)) - pas d'interpolation de chaine (mais existe en C# et est en discussion pour F#) - .Net - ne marche pas avec Mono, il faut Dotnet - par défaut, indentation à la python, en version fasciste; mais #indent "off" permet d'utiliser une version avec marqueurs de blocs, mais cette dernière est difficile à appréhender - beaucoup trop fonctionnel (tout est axé sur l'immutabilité, faire autrement est plus compliqué à chaque fois) =================== F* =================== -- fonctionnel =================== Falcon =================== + si "directive strict=on", alors déclaration obligatoire des variables (def) + appartenance (in) + itération sur tableau (for elt in tableau) + itération avec sections spéciales pour premier et dernier élément + extension de tableau (+) + interpolation de chaine ($) + comprehensions + switch (switch) sur chaines et range + constants (const) + enum (légèrement typées?) + struct (class avec properties), inclusion avec from - intervalles [..[ -- pas vraiment de type fixe ? Note : langage à l'arrêt depuis des années, écrit en C++ assez clair, peut-être facile à modifier. =================== Fancy =================== + structs (class avec read_write_slots:) + hashs (<[]>) + itération sur tableau (tableau each: |elt| {}) + intervalles corrects (upto) + interpolation de chaine (#{}) + très bonne intégration des regex - pas d'unsigned -- pas de déclaration de variables =================== Fantom =================== + declaration obligatoire des variables (:=) + enum (enum class) + hash (map) + struct (class avec fields) + switch (switch) sur chaine + extension de tableau (List) (add) + interpolation de chaine ($/${}) - pas d'unsigned ? - pas de syntaxe spéciale pour les regex - Java ==================== Fanx ==================== + declaration obligatoire des variables (Type v := init) + constantes (const, readonly) + structs (struct, class) + intervalles corrects [..] (..), et ouverts [..[ (..<) + interpolation de chaine ($/${}) ==================== Felix ==================== + déclaration obligatoire des variables (var v;) + constants (macro val: c'est original!) + enums (variant ou enum) + structs (struct ou typedef + record) + unions (variant) + intervalles corrects [..] (upto) + itération sur tableau (for elt in tableau) + typedef (typedef) + interpolation de chaine (limitée) + switch (match) sur chaine et tout - pas de syntaxe spéciale pour les regex - documentation incomplète - message d'erreur à la compilation peu utiles - portée bizarre =================== Fennel =================== -- Lisp =================== Ferite =================== + déclaration obligatoire des variables (Type v, w;) + itération sur tableaux (foreach(elt, tableau)) + un peu de syntaxe pour les regex (=~) - pas d'unsigned =================== Finch =================== -- pas de déclaration des variables =================== Flax =================== + declaration obligatoire des variables (var v: Type ou var v = init) + constantes (let) + enums (enum) avec précision du type sous-jacent + structs (struct) + unions (union) + itération sur tableau (for elt in tableau) + itération double avec index (for elt, i in tableau) + extension de tableau (.append() ou += ) + intervalles corrects [..] (...), et ouverts (..<) + typedef (typealias, @strong typealias) + opérateur ternaire + unsigned (UInt/8/16/32/64) + bindings C simples (FFI) - doc pas finie - LLVM 11 - pas de support pour les regex - pas d'interpolation de chaine ? - pas de switch ? =================== Flix =================== - fonctionnel - JVM =================== Flow (Flow9) =================== -- variables immuables =================== Floyd =================== + déclaration obligatoire des variables (mutable v = init) + constantes (let) + hashs ({:}) + itération sur tableau (for elt in tableau) + intervalles corrects [..] (...), et ouverts (..<) - pas d'unsigned -- chaînes, structures et tableau immuables =================== Free BASIC =================== + declaration obligatoire des variables (VAR v, DIM v AS Type) + constants (CONST) + enum (ENUM) typees ou non + structs (TYPE) + struct imbriquee avec EXTENDS + typedef (TYPE ... AS) + unsigned + intervalles corrects [..] (n to m) + switch (SELECT CASE) sur chaines (peut-être sur tout?) + surcharge d'opérateur (mais pas des types de base!) + création d'opérateurs ? - pas d'itération sur tableau ! (mais on peut faire une macro de 4 lignes) - pas de syntaxe spéciale pour les regex (mais surcharge/création d'opérateurs) =================== Free Pascal =================== + déclaration obligatoire des variables (bloc var, v : Type) + constants (const) + structs (record / class) + ensembles (set) + enum (set) + typedef (type) + intervalles corrects [..] + itération sur tableau (for elt in tableau) + switch (case) sur chaines (constantes) + surcharge d'opérateur + unsigned (natural) - pas de syntaxe spéciale pour les regex - toujours un peu lourd - mélange entre Pascal clasique et Objet et Delphi résultant en une multitude de trucs qui font la même chose à quelques détails près et qu'il est compliqué de choisir et d'entremêler - trucs qui promettent des facilités mais qui en fait ne marchent que dans des cas limités ou qui nécessitent d'écrire beaucoup de boilerplate inutile à chaque fois : record variant + tableaux dynamiques, listes ... =================== Frege =================== + intervalles correct [..] - JVM - très fonctionnel =================== Frost =================== + déclaration obligatoire des variables (var v : Type ou var v := init) + constantes (def, constant) + enums (choice) + structs (class avec var) + union (choice) + itération sur tableau (for elt in tableau) + switch (match) + interpolation de chaîne (\{}) + unsigned (UInt8/16/32/64) + surcharge de fonction par type de retour = intervalles corrects [..] (...) faciles à confondre avec [..[ (..) = un peu de syntaxe pour les regex /abcd/ - pas réussi à le compiler =================== Frink =================== + très bonne intégration des regex + itération sur tableau (for elt = tableau) + extension de tableau (.push[]) + hash (dict) + ensemble (set) + interpolation de chaine ($/${}) + struct (class) - pas de globales -- Java --- pas de moyen d'obliger à déclarer les variables =================== Fun =================== + déclaration obligatoire des variables (var v = init) + itération sur tableau (for elt in tableau do) + itération double avec index (for elt, i in tableau do) + switch (case) + possibilité de paramètres nommés + un peu de syntaxe pour les regex (//, =~, !~) - un seul type de nombres - typage dynamique, pas de type dans les paramètres de fonctions =================== Funject =================== -- fonctionnel, patterns =================== Futhark =================== + itération sur tableau (for elt in tableau) + intervalles corrects [..] (...), et ouverts (..<) + typedef (type) + unsigned (u8/16/32/64) -- fonctionnel, let ... in =================== Gambas =================== - pas de compilateur de fichier isolé : veut un projet - IDE sous Linux demande Webkit - IDE sous Windows a de grosses fuites de mémoire et des bugs ================== Gawk ================== + switch (switch) sur chaine (constante) et regexp + itération sur tableau (for (elt in tableau)) + bonne syntaxe pour les regex - typage trop faible (chaine ou nombre) et trop dynamique =================== Gentee =================== + déclaration obligatoire des variables (Type v w) + constantes (const) + enums (const IOTA) + structs (struct) + hashs (map) + itération sur tableau (for elt in tableau) + itération double avec index (for elt, i in tableau) + extension de tableau (+=) + intervalles corrects [..] + switch (switch) sur chaine + interpolation de chaines (%{} ou \{}) - pas d'unsigned - pas de syntaxe particulière pour les regex - pas de bindings C mais Go =================== Ghost =================== + déclaration obligatoire des variables (v := init) =================== Gleam =================== -- fonctionnel =================== Go =================== + déclaration obligatoire des variables (var) + constants (const) + structs (struct) + hashs (map) + itération sur tableau (for _, elt := range tableau) + itération double avec index (for i, elt := range tableau) + extension de taleau (slice) (append(,)) + switch (switch) sur chaines et tout + typedef (type) + unsigned - intervalles [..[ - pas de syntaxe spéciale pour les regex et pas de création/surcharge d'opérateur - pas de conversion/promotion automatique - boucle sur éléments lourdingue ( for _, elt ) =================== Golem =================== + déclaration obligatoire des variables (let v = init) + constantes (const) + hashs (dict {:}) + ensembles (set {}) + itération sur tableau (for elt in tableau) + extension de tableau (.add()) + switch (switch) sur tout -- pas de types =================== Golo =================== + déclaration obligatoire des variables (var v = init) + constantes (let) + hashs (map) + itération sur tableau (foreach elt in tableau) - initialisation obligatoire des variables - pas d'unsigned - JVM =================== Gosu =================== + déclaration obligatoire des variables (var) + itération sur tableau (for (elt in tableau)) + itération avec index (for (elt in tableau index i)) + intervalles corrects [..] + structs (class avec properties) + extension de tableau (List) (.add()) + interpolation de chaînes (${}) + hash (map) - pas de typedef ? - Java - documentation très parcellaire ===================== Gravity ===================== + déclaration obligatoire des variables (var v;) + enums (enum) + struct (class) + hash (map, [""]) + itération sur tableau (list) (for (elt in tableau), ou: tableau.loop(...)) + extension de tableau (.push()) + intervalles corrects [..] + interpolation de chaine (\()) - type après nom de variable dans les déclarations (mais pas obligatoire) - typage faible - pas d'unsigned - pas de switch =================== Groovy =================== + déclaration obligatoire des variables (def v ou Type v) + hash (maps) + interpolation de chaine (${}/$) + de la syntaxe pour les regex (=~ /abc/, ==~ /abc/) = regex capture group plus chiants : (mystr ==~ /a(b)c/).each {dummy, m1, m2 -> ... } ou : m = (mystr ==~ /a(b)c/); m1 = m.group(1); m2 = m.group(2); ... + operateur Elvis + enums (typées) + switch (switch) sur chaine et tout le reste + intervalles corrects [..] + appartenance (in) + structs (class avec properties) + itération sur tableau (for elt in tableau) - pas d'unsigned ? (à cause de Java) - pas de typedef ! -- Java =================== Gura =================== + interpolation de chaine (${}) - pas de declaration de variables ? ==================== Gypsum ==================== - pas de doc ==================== Hack ==================== -- pas de déclaration de variable ==================== Halunke ==================== - énormément de ((())()) -- pas de variables ==================== Hamler ==================== -- fonctionnel ==================== Harbour ==================== + déclaration obligatoire des variables (local v) + hashs + itération sur tableau (FOR EACH elt IN tableau) + itération double avec index (ajouter i:__enumIndex()) + switch (SWITCH) =================== Have =================== + structs (struct) = génère du Go - pas de doc - pas fini, abandonné depuis 2016/2017 =================== Haxe =================== + compile vers C++ + fonctions avec valeurs par défaut & paramètres optionnels + typedef (typedef) + struct ({}) + classes (class) + enums (enum) typées + switch (switch) est une expression (if aussi, tout est une expr) + switch sur tout type + switch avec condition supplémentaire (if) + hash (KeyValue) + for in tableau, for k=>v in kv + interpolation de chaîne ($/${}) + comprehensions + extension de tableau (push) + surcharge d'opérateurs (mais pas création) = un peu de syntaxe pour les regexp (~/ /) -- intervalles [..[ (voir si modifier hasNext d'IntIterator suffit) - exceptions (try catch) - pas d'intervalles décroissants - besoin d'installer OPAM (OCaml) ==================== Hollywood ==================== -- pas de déclaration de variables - 99 euros - insensible à la casse ==================== Huginn ==================== -- pas de déclaration de variables ==================== Hymn ==================== -- syntaxe Python ==================== Hypatia ==================== -- ML ==================== ICI ==================== + structs (struct) + hashs (struct) + bonne syntaxe pour les regex (~, ~!, ~~, ~~~, ~~=) + itération sur tableau (forall (elt in tableau)) + switch sur chaine (switch) -- pas de construction de type ================== Inko ================== + déclaration obligatoire des variables (let mut) + constantes (let) + hashs (Map) + structs (class avec @attributs) ? + itération sur tableaux (tableau.each do (elt)) + switch (match) + interpolation de chaines ({}) - pas d'enum ? - pas de if, mais des .if_true bien pénibles - VM - en Rust - pas d'unsigned ================== Io ================== + déclaration obligatoire des variables (let v: Type) + structs (struct) - intervalles incorrects [..[ (..) - pas de doc ================== Ioke ================== + bonne syntaxe pour les regex - Java - bizarre =================== Jam =================== -- pas de déclaration de variable =================== Jancy =================== + déclaration obligatoire des variables (Type v;) + enums (enum) + structs (struct) + switch (switch) et avec regex (reswitch) + unsigned (unsigned char/short/int/long uint8/16/32/64_t) + typedef (typedef) + alias de variables (alias) + interpolation de chaine ($) = les tableaux dynamiques sont une classe (biblio), pas un type intégré - pas d'itération sur tableau - LLVM =================== Jank / idiolisp =================== -- fonctionnel, Clojure =================== Janet (dst) =================== -- List =================== Javascript =================== + déclaration obligatoire des variables (var v; ou let v=init;) en mode strict + constantes (const) + itération sur tableau (for(var elt in tableau)) - Javascript -- typage dynamique =================== Jazz =================== + déclaration obligatoire des variables (var v = init;) + constantes (constexpr) + structs (struct) + typedef (alias) + unsigned (u8/16/32) =================== Jen =================== + déclaration obligatoire des variables (v := init) + itération sur tableau (for elt in tableau:) -- syntaxe à la Python =================== Jingle =================== + déclaration obligatoire des variables (var v:: Type = init) + constantes (const, let) -- typage dynamique =================== Jinx =================== - lourd - pas vraiment de type =================== Jolie =================== + itération sur tableau (for(elt in tableau)) + structs (type) + typedef (type) - pas d'unsigned -- pas de déclaration des variables =================== Joxa =================== -- Lisp =================== Julia =================== -- pas de déclaration obligatoire des variables =================== Kai =================== + déclaration obligatoire des variables (v: Type = init) + enum (enum) + structs (struct) + unions (union) + itération sur tableau (for elt in tableau) + itération double avec index (for elt, i in tableau) + extension de tableaux (append(,)) + switch(switch) + retour de tuples + unsigned (u8/16/32/64) - doc disparue ? =================== Kit =================== + enums + structs (avec champs private) + méthodes dans structs + switch (match) + typedef (alias typedef, ou différent: abstract) + itération sur tableau (for elt in tableau) + compile vers C + appel de fonctions C direct, sans rien de spécial à faire - pas de regex du tout ? - types après le nom de variable - écrit en Haskell (GHC, Stack) - pas complètement fini et un peu abandonné =================== Kitten =================== -- concaténatif =================== Kixtart =================== + déclaration obligatoire des variables (DIM $v) si option Explicit =================== Klassic =================== + déclaration obligatoire des variables (mutable v = init) + constantes (val) + hashs (%[]) + ensembles (%()) =================== Kotlin =================== + interpolation de chaînes + constants (const) + switch (when) est une expression, if aussi + switch sur chaines et tout + itération sur tableau (for (elt in tableau)) + itération avec index ( for ((i, elt) in tableau.withIndex()) ou tableau.forEachIndexed { i, elt -> ) + intervalles corrects [..] + classes + enums (enum class) + typedef (typealias) + unsigned (experimental) = surcharge d'opérateurs, mais pas de création sauf avec infix - pas de syntaxe spéciale pour les regex - Java (native target aussi ?) ===================== L++ ===================== -- Lisp ===================== Lang5 ===================== -- Forth ================= Langur ================= + déclaration obligatoire des variables (var .v) + constantes (val) + hashs ({:}) + itération sur tableau (for .elt in .tableau) + switch (given), sur regex + intervalles corrects [..] (..) + interpolation de chaine (\) = un peu de syntaxe pour les regex (re//, re:i//) = pas d'itération double, mais itération sur index (for .i of .tableau) -- pas de types, pas de struct ================= Latro ================= -- fonctionnel ================= Latte ================= + intervalles corrects [..] (..), et pour [..[, il y a (.:) - JVM - indentation ===================== LDPL ===================== + déclaration obligatoire des variables (data: v is Type) + itération sur tableau (FOR elt IN tableau) + extension de tableau (PUSH TO) - insensible à la casse ===================== Lemon ===================== + déclaration obligatoire des variables (var v, w;) + itération sur tableau (for(var elt in tableau) {...}) - pas de switch - pas de types dans les paramètres de fonction ou les déclarations de variables =================== Leola =================== - JVM - typage dynamique =================== Lever =================== -- indentation fasciste =================== LFE =================== -- Lisp ===================== Lice ===================== -- Lisp ===================== Lily ===================== + déclaration obligatoire des variables (var) + enums (enum, scoped enum) typées ou non + hashs (Hash[]) + structs (class avec properties) + itération sur tableau (List) (tableau.each(|elt| )) + intervalles corrects [..] + switch (match) sur chaines et tout + type Option + interpolation de chaine (^()) + écrit en C = syntaxe style Ruby - pas d'unsigned (à part Byte) - pas de constantes ? au pire il y a les enums, mais bof - pas de typedef ? - pas de support des regex -- obligé de foutre des read_line().encode().unwrap() pour enfin obtenir une chaine... ===================== Lima ===================== + déclaration obligatoire des variables (mut var v = init ou mut Type v = init) dans les fonctions + constantes (var) + itération sur tableau (df tableau elt: ) - indentation qui compte ===================== Limbo ===================== + déclaration obligatoire des variables (:) + constantes (con) + structs (atd) - pas d'unsigned à part byte - pas d'itération sur tableau - pas de tableau de taille fixe ================== Linotte ================== + déclaration obligatoire des variables (v est un type) + struct (espèce) + itération sur tableau avec variable automatique (pour chaque tableau) + extension de tableau (ajoute elt dans tableau) + interpolation de chaîne - en Java - un seul type de nombre ================== Lioness ================== -- pas de déclaration de variables ================== Lisaac ================== + déclaration obligatoire des variables (+ v : TYPE;) ================== LiveCode ================== + constantes (constant) + itération sur tableau (reapeat for each element elt in tableau) + switch (switch) -- la déclaration des variables n'est pas obligatoire - lourdingue ================== Lobster ================== + déclaration obligatoire des variables (var v = init) + constantes (let) + structs (struct) avec inclusion + structs avec méthodes (class) + enums (typées) + switch (switch) est une expression + switch sur chaine (et nombres, mais pas sur autre objects) + extension de tableau (vector) (push()) -- aucun support des regex - syntaxe python (indentation et tout, mais tabs autorisées) - pas de hash (dans le langage au moins) =================== Loci =================== - quasiment du C++ =================== Loglan 82 =================== + déclaration obligatoire des variables (var v: Type;) + switch (case) =================== Lush =================== -- Lisp =================== Lux =================== -- Lisp =================== Magpie =================== + déclaration obligatoire des variables (var v = init) + constantes (val) + structs (defclass avec fields et patterns) + itération sur tableau (for elt in tableau do) + itération double avec index (for i = 0 countingUp for elt = tableau do) + switch (match) - type après le nom de variable dans les déclarations -- Java ================== Mars ================== -- syntaxe à la Phyton (indentation) ================== Maude ================== -- très bizarre ================== Mendel ================== + constantes (const) - en JS/Node ================== Min ================== - indentation style Python - JVM -- pas de déclaration de variable ================== MiniScript ================== + itération sur tableau (for elt in tableau) -- pas de déclaration de variable ================== Mita ================== + déclaration obligatoire des variables (var v = init;) + constantes (let) + enums (enum) + structs (struct) + unions (alt) + switch (where) + typedef (let) + interpolation de chaine (${}) + possibilité de paramètres nommés + unsigned (uint8/16/32) = bindings C possibles - pas d'itération sur tableau - pas de paramètres optionnels ================== Moe ================== + déclaration obligatoire des variables (v, w: Type ou v := init) + constantes (immutable) + enums (enum) + structs (struct) + switch (switch) + typedef (typedef) + unsigned (u8/16/32/64) - pas encore de for_each ================== Mond ================== + déclaration obligatoire des variables (var v;) + constantes (const) + hashs ({:}) + itération sur tableau (foreach(var elt in tableau)) + intervalles correct [..] (:) pour les slices = pas d'intervalle mais hyper facile à définir - .Net - tous les nombres sont des flottants ================== Monkey 2 ================== + déclaration obligatoire des variables (Local v : Type ou Local v := init) + constantes (Const) + enums (Enum) + structs (Struct) + itération sur tableau (For local elt := EachIn tableau) + extension de Stack (.Add()) + switch (Select) + typedef (alias) + unsigned (UByte/Short/Int/Long) ================== Monte ================== + déclaration obligatoire des variables (var v := init;) + constantes (def) + hashs (map, {}) + itération sur tableau (for elt in (tableau)) + itération double avec index (for i => elt in (tableau)) + extension de tableau (.push()) - syntaxe python - typage dynamique ================== Moon lang ================== + déclaration obligatoire des variables (let v: Type = init; ou let v = init;) + enums (enum) + structs (struct) + itération sur tableau (for elt in tableau) + switch (match), sur chaines + typedef (type = ) - intervalles incorrects [..[ - pas d'unsigned ================== Muon ================== + déclaration obligatoire des variables (v := init) + constantes (:) + enums (enum) + structs (struct) + itération sur tableaux (for tableau { ... it ... } ou for elt in tableau {}) + itération double avec index (for elt, i in tableau {}) + unsigned (byte, ushort, uint, ulong) - chaines immuables ================== Mun ================== + déclaration obligatoire des variables (let v:Type; ou let v = init;) + structs (struct) + unsigned (u8/16/32/64/128/size) - pas de boucle for ================== Myrddin ================== + déclaration obligatoire des variables (var v ou var v : Type) + constantes (const) + structs (struct) + unions (union) + itération sur tableau (for (elt) : tableau) + switch (match) + erreurs gérées par option, result + typedef (type) + unsigned (uint, uint8/16/32/64) = les tableaux ont une taille fixe, mais il y a des slices - intervalles [..[ - format de chaine avec {} - pas de type chaîne - pas de conversion automatique entre types - pas de syntaxe pour les regex ================== Mythryl ================== + intervalles corrects [..] + de la syntaxe pour les regex (=~, //) + itération sur tableaux (foreach tableau {... #i ...}) + switch (case) ===================== Neat (fcc) ===================== + déclaration obligatoire des variables (Type v, w;) + constantes (alias) + enums (enum) avec entrée/sortie sur chaîne + structs (struct) + itération sur tableau (for elt <- tableau {}) + interpolation de chaîne ($) - pas du tout de support pour les regex ===================== Neko ===================== + déclaration obligatoire des variables (var) + switch (switch) - pas de type dans les paramètres de fonction - pas d'interpolation de chaine - pas de boucle For d'aucune sorte - pas d'unsigned - VM ================== Nelua ================== + déclaration obligatoire des variables (local v) + constantes (local v , ou local v ) + enums (@enum) + structs (@record) + switch (switch) + intervalles corrects [..] + unsigned (uinteger, uint8/16/32/64) + retour de tuples + bindings C simples = unions (union) : TODO = hashs (table) : TODO = itération sur itérateur (for) : TODO ================== Nemerle ================== + déclaration obligatoire des variables (def, mutable) + constants (def) + interpolation de chaine ($/$()) + intervalles corrects [..] + itération sur tableau (foreach (elt in tableau)) + itération double avec index (foreach (elt in tableau with i)) + switch (match) sur chaines et tout ET REGEX ! + struct (struct / class) + enum + hash (Hashtable) + comprehensions + typedef (type) + unsigned - lourdingue - . Net -- Pas de version Linux pour les versions > 1 !!! =================== Neon =================== + déclaration obligatoire des variables (VAR v: Type) + constantes (LET, CONSTANT) + enums (ENUM) + structs (RECORD, CLASS) + itération sur tableau (FOREACH elt IN tableau DO) + switch (CASE) sur chaine + typedef (TYPE IS) + intervalles corrects [..] (TO) + interpolation de chaine (\()) + possibilité de paramètres nommés - un seul type de nombres : Decimal128 - pas de support des regex =================== Never =================== + déclaration obligatoire des variables (let v = init; var v = init;) + enums (enum) + structs (record) + unions (enum) + itération sur tableau (for (elt in tableau)) + intervalles corrects [..] + compréhensions = switch (match) seulement sur Enum ? - interprété - enums trop typées =================== Newt =================== + déclaration obligatoire des variables (v := init ou v:Type ou v:Type=init) + enums (sum types sans type) + structs (mutable records) + unions (sum types |) - pas d'unsigned (à part byte?) =================== Nial (QNial7) =================== -- pas de déclaration obligatoire des variables =================== Nice =================== + déclaration obligatoire des variables (var ; ou Type v; + constantes (let) + enums (enum) + structs (class) + itération sur tableau (for(Type elt: tableau) {}) + intervalles correct [..] + retour de tuples - JVM =================== Nim =================== + compile vers C + intervalles corrects [..] - syntaxe python, tabs interdites ! - se complique année après année, se rustifie - pas de syntaxe spéciale pour les regex =================== Nit =================== + déclaration obligatoire des variables (var v, var v: Type) + structs (class avec attributes) + hashs (HashMap) + itération sur tableau (for elt in tableau do) + interpolation de chaine + intervalles correct [..], et aussi intervalles [..[ ! = typedef (type) seulement à l'intérieur d'une classe - pas d'enum - pas de constantes =================== Nitrogen =================== + déclaration obligatoire des variables (let v = init) + constantes (const) + hashs ({:}) + itération sur tableau (for elt in tableau) + itération double avec index (for i, elt in tableau) =================== Np =================== + déclaration obligatoire des variables (new v = init) + itération sur tableau (tableau:each{elt | ... } ) =================== Objeck =================== + constantes (consts) + enums (enum) + switch (select) + itération sur tableau (each(elt : tableau) { ) + interpolation de chaine ({$}) - pas d'obligation de déclarer les variables =================== Oden =================== -- fonctionnel =================== Odin =================== + initialisation des variables pas obligatoires + constantes (::) + intervalles corrects [..] + hash (map) + itération avec index (for elt, i in tableau) + switch, acceptant les chaînes, intervalles et autres conditions, avec fallthrough optionnel + tous les paramètres de fonctions sont passés uniquement par valeur + possibilité de valeur par défaut + surcharge + possibilité de paramètres nommés + retour multiple + typedef (alias ou distinct) + extension d'un tableau (fonction append(), pas d'opérateur) + enum (typées) + bits sets + méthodes dans structs + struct imbriquées avec using + import de fonctions C très simple - len est signé - pas de conversion automatique entre types signés et non-signés (ou bien si?) - main : pas d'arguments ? - main : pas de retour de valeur ? - types après noms de variables - itération sur tableau seulement read-only - pas d'interpolation de chaîne - dépend de LLVM =================== Onyx =================== =================== OOC =================== + interpolation de chaine (#{}) + switch (match) sur chaine + enum + itération sur tableau (for (elt in tableau) / tableau each(|elt| ) + itération double avec index (for ((i, elt) in tableau)) + hash (HashMap / HashBag) + struct (class ou cover) + compile vers C + unsigned - pas de syntaxe spéciale pour les regex - intervalles [..[ - type après le nom de variable (mais pas nécessaire) Note: langage à l'arrêt depuis 4 ou 5 ans, son code est très clair, il devrait être facile d'en tirer un "OOD" avec les ranges inclusifs, et peut être des opérateurs pour les regex. - problème pour compiler des programmes (erreurs dans le code généré ou pour trouver les bibliothèques SDK) ==================== OORexx ==================== -- pas de déclaration des variables ==================== Orc ==================== -- bizarre ==================== Panda (panda-lang.org) ==================== + déclaration obligatoire des variables (mut Type v = init ou late mut Type v) + constantes (Type c) + structs (classe avec champs open) + itération sur tableau (foreach(Type elt : tableau) {}) - JVM - pas d'unsigned ==================== Par ==================== + hashs (Map<>) -- fonctionnel ==================== Parasail ==================== + déclaration obligatoire des variables (var v : Type) + constantes (const) + typedef (type) + enums + hashs + structs (interface, class) + switch (case of) + extension de tableaux (|=) + itération sur tableau (for elt in tableau , for each elt of tableau) + itération double avec index (for each [i => elt] of tableau) + intervalles corrects [..] et autres ..<, <.., <..< + paramètres nommés optionnels + interpolation de chaine (`(v)) + surcharge d'opérateurs (et création ?) -- pas réussi à le compiler ==================== Parser3 ==================== -- pas de déclaration de variables ==================== Pawn ==================== + déclaration obligatoire des variables (new) + constants (const) -- pas de types =================== Perl =================== + très bonne intégration des regex + intervalles corrects [..] + enums - pas de types - pas de structs (intégrées) =================== Phix =================== + déclaration obligatoire des variables (Type v) + constants (constant) + enums (enum ou enum type) typées ou non + structs (struct, class) + intervalles corrects [..] + extension de tableau (&=) + switch (switch) sur chaine et tout avec ou sans break/fallthrough - pas d'itération sur tableau - indices démarrant à 1 et non 0 - pas de syntaxe spéciale pour les regex ==================== PHP ==================== + constants (define et const) + switch (switch et match) + itération sur tableau (foreach ($tableau as $elt)) + itération double avec index/clé (foreach ($tableau as $i => $elt)) -- pas de déclaration de variable =================== Pike =================== + intervalle [..] + itération sur tableau (foreach(tableau, elt)) + itération double avec index (foreach(tableau; i; elt)) + extension de tableau (+=) + switch sur chaines (constantes) et range + structs (class) + hash (mappings) + typedef (typedef) = enum (pauvre: comme en C) = surcharge opérateurs (LFUN) ? - pas d'unsigned ! - pas de bonne syntaxe pour les regex - documentation incomplète =================== Pixie =================== -- Lisp =================== Plasma =================== + unsigned (Uint/8/16/32/64) =================== Ply =================== + déclaration obligatoire des variables (v := init) + typedef (type) = génére du Go =================== PointerScript =================== + déclaration obligatoire des variables (var v; ou var v = init;) + structs (struct) + itération sur tableau (foreach(elt in tableau) {}) + itération double avec index (foreach(i, elt in tableau) {}) + interpolation de chaines ($) = pas d'unsigned, sauf dans les structs (uchar/short/int/long/longlong/8/16/32/64) - typage assez faible (pas possible de dire "un tableau de tel Type") - intervalles incorrects [..[ =================== Pony =================== + déclaration de variables obligatoire (var, let) + structs (struct, class) + itération sur tableau (for elt in tableau.values()) + switch (match) + unsigned + typedef (type) - pas d'enum, il faut se farcir une union de primitives définies une par une - pas de globales - bizarre (acteurs) - pas de syntaxe spéciale pour les regex, mais opérateur égalité surchargé =================== Pop-11 =================== + déclaration de variables obligatoire (lvars v, w;) + constantes (constant) + itération sur tableau (FOR elt IN tableau DO) =================== PPL =================== + déclaration de variables obligatoire (var v Type ou var v = init) + constantes (const) + itération sur tableaux (repeat for each elt in tableau) + itération double avec index (repeat for each elt in tableau counter:i) + interpolation de chaine ({{}}) =================== Processing =================== + déclaration de variables obligatoire (Type v;) + classes - pas d'itération sur tableau =================== PureBASIC =================== - 79 euros - pas d'itération sur tableau (seulement sur liste) =================== Pyret =================== + déclaration obligatoire des variables (var v = init) + constantes (=) + structs (data) + itération sur tableau (for each(elt from tableau):) + switch (cases(Type) v) + typedef (type, newtype) - initialisation obligatoire des variables -- Javascript =================== Pyxell =================== + génère du C++ -- syntaxe Python -- pas d'obligation de déclarer les variables =================== Qore =================== + très bonne intégration des regex (chaine =~ /hai+/, chaine =~ s/(.*)ne/$1se/) + déclaration obligatoire des variables si %require-types (type v; ou my type v;) + constantes (const) + types + hashs (hash, {}) + extension des listes (push, unshift, +=) + itération sur tableau (foreach elt in (tableau) {) + switch (switch) sur tout (chaines, regex) = structs (class) avec membres comme des clés de hashs - pas d'enum ? - pas d'unsigned ? - pas d'interpolation de chaine ? =================== Quorum =================== - pas d'obligation de déclarer les variables =================== Radon =================== + itération sur tableau (for elt in tableau do) -- pas de déclaration de variables =================== Rain =================== -- typage dynamique =================== Raku =================== + très bonne intégration des regex + intervalle [..] + structs (class avec has) + switch (given/when) sur tout + enums (typees) + hash + interpolation de chaine ($) + itération sur tableau (for @tableau -> $elt) + extension de tableau (push) (pas d'opérateur? bizarre) + appartenance (smartmatch ~~) + création d'opérateurs - erreurs peu compréhensibles - comment spécifier les types retournés par un tuple ? ==================== Ravi ==================== - Lua ==================== Reason ==================== = espèce de mix variables/constantes avec let - pas d'unsigned ? - écrit en Javascript ? ==================== Rebol ==================== - pas de déclaration de variable (assignation seulement) ==================== Red ==================== + hash (hash!, map!) + ensemble de bits (bitset!) + itération sur tableau (foreach elt tableau) + switch (switch, select) sur tout = pas de regex, mais du parsing à la REBOL - pas d'unsigned - pas de déclaration obligatoire des variables ==================== Reia ==================== = syntaxe Ruby -- pas de déclaration de variable ==================== Rhai ==================== + déclaration obligatoire des variables (let v; ou let v = init;) + constantes (const) + switch (switch) sur tout littéral + itération sur tableau (for elt in tableau) - en Rust - pas d'interpolation de chaine - intervalles incorrects [..[ (range) - typage faible ==================== Ring ==================== -- pas de déclaration de variable -- typage dynamique ==================== Rip ==================== -- fonctionnel ==================== Rogue ==================== -- syntaxe Python -- pas de doc ==================== Rolez ==================== + déclaration obligatoire des variables (var v : Type; ou var v= init;) + constantes (val) - Java ==================== Rune ==================== + déclaration obligatoire des variables (let v = init;) + structs (struct) - en Rust - typage faible ==================== Ruota ==================== + déclaration obligatoire des variables (v := init;) -- typage dynamique ==================== SAC ==================== -- pas de déclaration des variables =================== Sather =================== + déclaration obligatoire des variables (v: Type; w ::= init;) + constantes (const) + enums (const) sans type + structs (immutable class) + itération sur tableau ( loop ... e = tableau.elt! ...) + itération double avec index ( loop ... e = tableau.elt!; i = tableau.ind! ...) + switch (switch ou case?) + bindings C simples - pas de syntaxe particulière pour les regex =================== Scala =================== + déclaration obligatoire des variables (var v ou var v: Type) + constants (val) + structs (class) + hashs (Map) + switch (match) sur chaine, est une expression, peut inclure des conditions supplémentaires + itération sur tableaux (for (elt <- tableau) ou tableau.foreach { case elt =>}) + tableaux extensibles (ArrayBuffer), avec += + intervalles corrects [..], avec "to": 1 to 10 ([..[ avec "until") + interpolation de chaînes ($v ou ${v}) = un peu de syntaxe spéciale pour les regex ("".r) + et mécanisme intéressant avec unapply d'interpolation qui peut en plus être conjugué avec des regex = typedef(type), mais a besoin d'être défini dans un "package object" (ou une classe) -- pas d'unsigned ! - type après le nom de variable - Java =================== Scaly =================== + déclaration obligatoire des variables (var v init ou mutable v init ou var/mutable v : Type) + constantes (let) + création d'opérateurs + unsigned (byte, ushort, uint, ulong) =================== Scopes =================== -- indentation à la Python =================== Seed 7 =================== + constantes (const) + intervalles corrects [..] + hash + ensembles (set) + surcharge de fonctions + typedef ? (subtype) + extension de tableau (&:=) + enum (typées?) + struct héritées (sub) + possibilité de créer et redéfinir non seulemnt des opérateurs mais aussi des mots-clés - initialisation obligatoire des variables - déclaration un peu lourde (const/var + type + val. init.) - pas d'interpolation de chaîne - import de fonctions C assez alambiqué (mais présent) - documentation qui fait mal à la tête - messages d'erreur incompréhensibles ! - trucs qui passent avec l'interpréteur mais pas le compilateur ! ================== Self ================== - imbittable ================== SenseTalk ================== -- pas de déclaration des variables - typage dynamique ================== SETL / SetlX ================== + itération sur tableaux (for elt in tableau) -- pas de déclaration de variable ================== Shadow ================== + déclaration obligatoire des variables (var v = init; ou Type v;) + struct (class avec get set) + itération sur tableau (foreach(Type elt in tableau) {}) + switch (switch) sur chaînes + unsigned (ubyte, ushort, uint, ulong) - pas encore d'enums ================== Sidef ================== + en Perl + très bonne intégration des regex + intervalle [..] + itération sur tableau (for elt in tableau) + hash + ensemble (Set) + enum (simpliste, sans nom de type) + constants (const ou define) + struct (class avec attributes, ou struct) + switch sur chaine et autre (given/when) + extension de tableau (<<) + interpolation de chaine (#{}) = on peut mettre un type pour les paramètres de fonctions - pas de type pour les déclarations de variables, seulement pour les paramètres de fonctions -- typage beaucoup trop dynamique : pas possible de définir des Array(String) par exemple, seulement des Array. ==================== Simit ==================== + déclaration obligatoire des variables (var v : Type; ou var v = init;) + constantes (const) + strcuts (element) + itération sur tableaux (for elt in tableau) - intervalles incorrects [..[ - pas d'unsigned ==================== SIMPOL ==================== + déclaration obligatoire des variables (Type v) + constantes (const) + structs (type) - besoin de \ pour continuer sur les lignes suivantes - pas de boucle For ==================== Sink ==================== + déclaration obligatoire des variables (var v) + constantes (enum) + enums (enum) + itération sur tableau (for elt: tableau ou for var elt: tableau) + itération double avec index (for elt, i: tableau) - intervalles incorrects [..[ (range) -- pas de struct ==================== Skew ==================== + déclaration obligatoire des variables (var v = init ou var v Type = init) + constantes (const) + interpolation de chaîne (\()) - intervalles incorrects [..[ - Node ==================== Skila (skila-1) ==================== + déclaration obligatoire des variables (var v Type = init ou var v =init) + constantes (let) + enums (enum) + structs (class avec champs var ou plutôt in def chps Type get set;) + hashs ({}) + itération sur tableau (for elt in tableau do) + possibilité de paramètres nommés + alias de variable (using) + interpolation de variable (${}) + regex /abc/ ==================== SkookumScript ==================== + déclaration obligatoire des variables (!v) + switch (case) ==================== S-lang ==================== + déclaration obligatoire des variables (variable v, w;) + intervalles corrects [..] + struct (struct, typedef struct) + itération sur tableau (foreach elt (tableau) + switch (switch) + interpolation de chaine ($,${}) -- pas d'information de type pour les paramètres de fonction ou les déclarations de variables, seulement pour les tableaux ===================== Sleep ===================== -- du Perl sur Java ===================== Smudge ===================== + déclaration obligatoire des variables (var v = init;) -- pas de types ===================== Snap ===================== + déclaration obligatoire des variables (var/let v: Type = init) + constantes (const) + enums (enum) + structs (class) + hashs ({:}) + ensembles ({}) + itération sur tableau (for(var elt in tableau) {}) + extension de List (.add()) + intervalles corrects [..] ? + typedef (type) - pas de switch ===================== Snek ===================== -- pas de déclaration de variable ===================== SPARforte (AdaScript) ===================== + déclaration obligatoire des variables (v, w : Type) + constantes (constant) + enums (()) + structs (record) + intervalles corrects [..] + switch (case is when) + typedef (type, subtype) + unsigned (natural, positive) - pas d'itération sur tableau ? -- pas réussi à le compiler ===================== Sparkling ===================== + déclaration obligatoire des variables (let v;) + constantes (extern) + hashs ({}) + extension de tableau (.push()) ===================== Sparrow ===================== + déclaration obligatoire des variables (var v, w : Type ou var v = init) + structs (datatype) + itération sur tableau (for elt = tableau.all) + unsigned (UInt8/16/32/64) = intervalles corrects [..] et incorrects faciles à confondre: ... vs .. - syntaxe Python mais possibilité d'utiliser des { - pas d'enum ===================== Spiral ===================== -- ML ? ===================== SPL ===================== + déclaration obligatoire des variables (var v;) ===================== Spry ===================== -- fonctionnel, Smalltalk -- pas de déclaration de variables ===================== Squirrel ===================== + déclaration obligatoire des variables (local v;) + constantes (const) + enums (enum) + hashs (table, {}) + classes (class) + itération sur tableau (foreach(elt in tableau)) + itération double avec index (foreach(i, elt in tableau)) + extension de tableau (.append()) + switch (switch) - typage dynamique - pas d'unsigned =================== Stanza =================== + déclaration obligatoire des variables (var v : Type) + constantes (val) -- indentation fasciste =================== Suneido =================== + itération sur tableau (foreach(value elt in tableau)) -- pas d'obligation de déclarer les variables =================== SuperCollider (sclang) =================== + déclaration obligatoire des variables (var v, w;) =================== Swahili =================== + déclaration obligatoire des variables (wacha v = init) + itération sur tableau (kwa elt katika tableau) =================== Swift =================== + déclaration obligatoire des variables (let, var) + intervalles corrects [..] + extension de tableau (.append(), +=) + itération sur tableau (for elt in tableau) + itération double avec index (for (i, elt) in tableau.enumerated()) + switch (switch) sur tout, avec condition supplémentaire (when) + interpolation de chaine (\()) + constants (let) + enums (enum) + structs (struct, class) + hash (dictionary) + ensembles (set) + typedef (typealias) + unsigned (Uint8...) + définition d'opérateurs - exceptions - type après les variables dans les déclarations (mais optionnels) - pas de tableau de taille fixe - souvent curieusement lourdingue ou verbeux (heritage d'Objective-C) ================== Szl ================== + déclaration obligatoire des variables ($local v init) + extension de tableau ($list.append) - intervales incorrects [..[ ================== T1 ================== + structs (struct) -- tordu ================== Tab ================== + hashs (Map) + unsigned (UInt) ================== Tern ================== + déclaration obligatoire des variables (let v = init; let v : Type = init) + constantes (const) + hashs ({}) + class + itération sur tableau (for(elt in tableau)) + typedef (type) + interpolation de chaines (${}) = enums bizarres - en Java ================== Terra ================== + déclaration obligatoire des variables (var v : Type ou var v = init) + structs (struct) + switch (switch) - Intervalles incorrects [..[ ================== THT ================== -- orienté Web (comme PHP) -- pas de déclaration de variables ================== Titan ================== + déclaration obligatoire des variables (local v = init ou local v) + structs (record) + hashs ({}) - pas d'unsigned ================== Typescript ================== + interpolation de chaine (${}) + enum -- tous les nombres sont des flottants ! - Javascript =================== Umka =================== + déclaration obligatoire des variables (var v =, var v: type, var v:=, var(v, w)) + constants (const) + switch (switch) + typedef (type) + structs (struct) + itération sur tableaux (for elt in tableau) + itération sur tableaux avec indice (for i, elt in tableau) + extension de tableaux (append(T, elt) ou append(T, T2)) + unsigned (uint, uint8, uint16, uint32) - pas de syntaxe pour les regex - pas d'interpolation de chaîne - pas d'enum - pas d'intervalle ================== Unicon ================== + intervalle [..] + switch - pas de déclaration obligatoire - pas de type assigné - les indices commencent à 1 et pas 0 - compliqué ================== Unison ================== + enums (unique type) + structs (type s = {}) + typedef (type, unique type) + unsigned (Nat) -- fonctionnel =================== Urn =================== -- Lisp =================== V =================== + déclaration obligatoire des variables (:=) + interpolation de chaînes 'aaa $var' + retour multiple et optionel, gestion des codes d'erreur simplifiée + extension d'un tableau (<<) + appartenance à un tableau (in) + hash (map) + itération avec index (for i, elt in tableau) + switch, acceptant les chaînes (match) + if et match sont des expressions + enum + struct imbriquées (struct) + méthodes sur type (remplace les classes) + constantes (const, peuvent être déterminées par des fonctions) + import de fonctions C très simple + unsigned = pas de typedef ? Ou bien 'type' sert à ça ? - chaînes immuables - intervalles [..[ - pas de syntaxe spéciale pour les regex - globales interdites - problèmes de conversion signé / non signé - pas de surcharge des fonctions - initialisation obligatoire des variables - interdiction d'écrire les constantes en majuscules ??? (pourtant on en trouve dans les examples) - types après noms de variables dans les déclarations de structs - compilation : Makefile essaye de lancer git et télécharger un truc - compilation à la main : plein de warning hello_word ne marche pas ==================== Vale ==================== + déclaration obligatoire des variables (v! = init ou v! Type = init) + constantes (=) + structs (struct) + itération sur tableau ( tableau.each((elt){... elt ...}) ou tableau.each({... _ ...}) ) + itération double avec indice ( tableau.eachI((i, elt){... elt ...}) + extension de liste (.add()) ==================== Verse ==================== + déclaration obligatoire des variables (v : Type; ou v := init;) + enums (enum) + structs(struct) + itération sur tableau (for elt in tableau) + itération double avec index (for elt, i in tableau) + unsigned (uint, u8/16/32/64) + génère du C = intervalles corrects [..] ? (:) - pas de doc ==================== Verve ==================== -- fonctionnel ==================== Volt ==================== + déclaration obligatoire des variables (:) + constants (const, immutable) + structs (struct) avec méthodes + enums (enum) + unsigned + typedef (alias) + itération sur tableau (foreach(elt; tableau)) + itération double avec index (foreach(i, elt; tableau) + extension de tableau (~=) + switch (switch) + interpolation de chaine (${}) - intervalles [..[ - chaines immutables - dépend de LLVM ==================== Vox ==================== + enums (enum) typées + structs (struct) + typedef (alias) + unsigned (u8/16/32/64) - intervalles incorrects [..[ = plein de TODOs, à revoir plus tard =================== Wake =================== + déclaration obligatoire des variables (with/needs/var Type v ou with/needs/var v Type) + itération sur tableau (foreach(tableau)) + type option - bizarre (confusion volontaire entre types et variables) =================== Whiley =================== + structs ({}) - pas d'itération sur tableau - indentation à la Python - Java - intervalles [..[ =================== Winxed =================== + déclaration obligatoire des variables (Type v;) + hashs ({:}) + itération sur tableaux (for(Type elt in tableau) {}) + possibilité de paramètres nommés (moches) =================== Wollock =================== + déclaration obligatoire des variables (var v = init) + constantes (const) + hashs (Dictionary()) + ensembles (#{}) + itération sur tableau (tableau.forEach({elt => ... }) ) = itération double avec index ? (tableau.forEach({i, elt => ... }) ) =================== Wrapl =================== + déclaration obligatoire des variables (VAR v;) + constantes (DEF) + interpolation de chaine ({}) - chaines immuables =================== Wren =================== + déclaration obligatoire des variables (var v = ...) + hash (Map) + itération sur tableau (for (elt in tableau)) + intervalle [..] + commentaires imbriqués + interpolation de chaine (%()) + compile vers C/C++ -- pas de types =================== Wu =================== + déclaration obligatoire des variables (v: Type = init ou v := init) + structs (struct) + switch (switch) = itération sur tableaux (for elt in iter(tableau)) = itération double avec index (for i, elt in ipairs(tableau)) - écrit en Rust =================== Wuff =================== + déclaration obligatoire des variables (var v : Type) -- ? =================== Xojo =================== + déclaration obligatoire des variables (Var v As type) + constantes (Const) + enums (Enum) + itération sur tableau (For Each elt As type In tableau) + extension de tableau (.Add()) + switch (Select) sur chaines et tout - pas d'unsigned - 299 $ =================== XPL0 =================== + déclaration obligatoire des variables (Type v, w;) + constantes (define) + enums (define) basiques + switch (case) - pas d'itération sur tableau =================== Xtend =================== + déclaration obligatoire de variables (var v ou var Type v) + constantes (val) + switch (switch) sur chaine et tout + interpolation de chaine («») + itération sur tableau (for (elt: tableau)) + itération avec index (tableau.foreach[elt, i]) + structs (class avec fields) + enum + intervalles corrects [..] - pas de syntaxe spéciale pour les regex - Java =================== YaBasic =================== -- pas de déclaration des variables =================== Yoric =================== -- pas de déclaration des variables =================== Zig =================== - pas d'extension de tableau - pas de type chaîne - pas d'interpolation de chaînes - chaines multilignes à grand coups de double backslash \\ à chaque ligne (impossible de trouver plus chiant comme système ?) - gestion obligatoire des erreurs - import (include) de fonctions standard lourdingue (à rallonge) - pas de commentaires multilignes - intervalles [..[ - dépend de LLVM - veut LLVM 10 et pas le 8 qui est installé =================== Zenon =================== + déclaration obligatoire des variables (mutable Type v;) + constantes (const) + structs (struct) + unions (union) + itération sur tableau ( for(elt : tableau) { ... *elt ...}) + switch (switch) + compile vers C++ = enums (enum) pas possible d'assigner une valeur précise - chaines immuable =================== Zimbu =================== + déclaration obligatoire des variables (Type v, w ou VAR v) + enums (ENUM) bien complètes + classes (class) + hashs (Dicts, [:]) + itération sur tableau (FOR elt IN tableau) + itération double avec index (FOR i, elt IN tableau) + extension de liste (.add()) + switch (SWITCH CASE MATCH) sur chaînes + intervalles corrects [..] (TO) + typedef (TYPE, ALIAS) + unsigned (nat, nat8/16/32/64) + possibilité d'arguments nommés + retour de tuples + génère du C, bindings C faciles ? + bonne syntaxe pour les regex (=~, !~, =~?, !~?) + interpolation de chaîne (\()) - code introuvable (Bram Moolenaar) =================== Zkl =================== + déclaration obligatoire de variables (var v ) + hashs (Dictionary) + itération sur tableau (foreach elt in (tableau)) -- pas d'enums =================== Zonnon =================== + déclaration obligatoire des variables (var v, w : Type) + constantes (const) + enums (()) + structs (record) + switch (case) + typedef (type) - pas d'itération sur tableau