View difference between Paste ID: 2ZiAJMvR and U5nBk8x6

-type ArrayOfNum = Array<Num>
+# Syntaxe de Bootmonkey (BM)
 # Par PifyZ, booti386, Gorgio et SuperMonkey
-const TOPICS_BY_PAGE = 20
+# Dernière mise à jour : 30/07/2014
 
 enum Volume {
     LOW    = 20,
     MEDIUM = 50,
     HIGH   = 100
 }
 
 interface Animal {
     Void
 }
 
 class Point2D {
     Num x, y
 
     new(Num x, Num y) {
         @x = x
         @y = y
     }
 
     Void add(Num x, Num y) {
         @x += x
         @y += y
     }
 
     Void add(Point2D p) {
         @add(p.x, p.y)
     }
 }
 
 class Point3D < Point2D {
     Num z
 
     new(Num x, Num y, Num z) {
         @(x, y)
         @z = z
     }
 
     Void add(Num x, Num y, Num z) {
         @x += x
         @y += y
         @z += z
     }
 
     Void add(Point3D p) {
         @add(p.x, p.y, p.z)
     }
 }
 
-for i = 0 to 50 [ by 2 ] {
+if condition { } else if condition { } else { }
-
+
 # S'inspirer de :
 # - http://haxe.org/manual/lf-pattern-matching.html
-// Déclarer une variable
+# - http://fr.wikibooks.org/wiki/OCaml/Structures#Filtrage_par_motifs
-type nom_variable [ = valeur ]
+switch value { when < 0 { } when < 5 { } when >= 5 { } }
 when ::= < 0 (inférieur) | <> 20 (différent) | 0 or 5 (ou) | 0 to 5 (entre (bornes includes))
-// Déclarer une fonction
+
 # Boucles
 loop { }
-// Déclarer une classe
+loop 8 { }
 loop 8 by 2 { }
 
-// Déclarer un attribut
+while condition { }
-[public|ptotected|private] [static] [final] type nom_attribut [ = valeur ]
+do { } while condition
 
-// Déclarer une méthode
+for i = 0 to 8 { }
 for i = 0 to 8 by 2 { }
 for _ = 0 to 8 by 2 { }
-// La suite de fibonacci
+
 for      in a_list { }
 for _    in a_list { }
 for _, _ in a_list { }
 for v    in a_list { }
 for _, v in a_list { }
 for k, _ in a_list { }
-}
+for k, v in a_list { }
 
 for      in a_dict { }
 for _    in a_dict { }
 for _, _ in a_dict { }
 for v    in a_dict { }
 for _, v in a_dict { }
 for k, _ in a_dict { }
 for k, v in a_dict { }
 
 for      in a_str { }
 for _    in a_str { }
 for _, _ in a_str { }
 for v    in a_str { }
 for _, v in a_str { }
 for k, _ in a_str { }
 for k, v in a_str { }
 
 _ est un mot-clé spécial qui permet de ne pas capturer une valeur ou de ne pas en envoyer
 
 # Déclarer un type
 "type" nom_type = type
 
 exemple :
 
 type Player = {
     Str name,
     { Num x, Num y } position
 }
 
 # Déclarer une variable
 [const] type nom_variable [ = valeur ]
 
 # Déclarer une fonction
 type nom_fonction(arguments) { }
 
 # Déclarer une classe
 class NomClasse [ < NomClasseParente ] { }
 
 # Déclarer un attribut
 [public|ptotected|private] [static|const] type nom_attribut [ = valeur ]
 
 # Déclarer une méthode
 [public|protected|private] [static] [final] type nom_methode(arguments) { }
 
 # Suite de fibonacci
 Num fibo(Num n) {
     if n <= 1 {
         n
     } else {
         fibo(n - 1) + fibo(n - 2)
     }
 }
 
 # Types
 Bool
 Num
 Chr
 Str
 List<T>
 Dict<V>
 Func<(T n)*>:T
 Obj
 Var
 (Null)
 
 Bool vaut true ou false
 Num est un nombre (int ou float confondus)
 Chr est un caractère : 'a', 'z'
 Str est une chaîne de caractère : "Hello World!", """Pour les textes comportant de nombreux guillemets"""
 List<T> est une liste de valeur : [ "Aymeric", "Guillaume", "Aurélie" ]
 Dict<V> est un dictionnaire clé-valeur : { "Aymeric": 18, "Guillaume": 15, "Aurélie": 21 }
 Func<(T n)*>:T est une fonction :
 Obj est un objet :
 Var est un type dynamique non défini :
 Null est la valeur renvoyée quand la variable n'existe pas ou vaut Null