Langage AL

AL est un nouveau langage (signifiant Algoid Language). Il a été inspiré par java, python, smalltalk et lua, mais il n'est pas ces langages.
L'intérêt d'Algoid Language est d'être simple, mais complet.
Son but est d'aider à apprendre comment programmer et par la suite comment utiliser les différents paradigmes :
Impératif, procédural, fonctionnel et récursif, objet orienté prototype (héritage multiple) et programmation orientée aspect.
Il intègre des idiomes puissants comme le protocole meta-objet (inspiré de python) et cascade (inspiré de smalltalk).
Et parce qu'un jour vous allez, je l'espère, travailler avec un langage standard de l'industrie (très certainement proche du c et du java) AL a été conçu aussi proche de leurs syntaxes que possible.
Cette syntaxe avec ses accolades et ses symboles peut sembler très compliquée, mais on s'y fait vite et elle a l'avantage d'être concise.

En outre, les idiomes fondamentaux d'AL sont :

  • Toutes les fonctions sont des expressions.
  • Tous les objets sont des expressions.
  • Toutes les expressions sont des objets.
  • Donc toutes les fonctions sont des meta-fonctions et tous les objets sont des meta-objets.

Le reste est inspiré des différents langages énoncés plus haut.

Index

Language structure


Language primitives


[dynamic] type


[dynamic] void


[dynamic] boolean


[dynamic] number


[dynamic] string


[dynamic] array


[dynamic] function


[dynamic] object


Racine de l'API


al


al.order


al.combine


al.types


util


math


ui


text


algo.color


algo


algo.stamp


instruction

L'élément unitaire du langage AL est l'instruction.
En AL, le point-virgule est totalement optionnel. Il existe parce qu'AL est inspiré du C et qu'en C il est obligatoire. Donc vous pouvez écrire votre programme avec ou sans. Préférez avec parce que la majorité des langages le demande. Ca devient une habitude.

SYNTAX : instruction [';'] 

Les instructions en AL se divisent en deux familles : les expressions (ou valeurs du programme) et les instructions de contr√īle (issu de l'imp√©ratif).

block

Un bloc est une suite d'instructions encapsulées dans une portée locale.
La portée signifie que toute variable déclarée à l'intérieur n'est accessible que depuis cette portée et qu'elle sera détruite dès la sortie de celle-ci.

SYNTAX : '{' {[instruction]} '}' 

expression

Toute valeur du langage s'appelle une expression. AL comprend plusieurs types d'expressions : VOID, BOOLEAN, NUMBER, STRING, FUNCTION, OBJECT, ARRAY.
AL est un langage dynamique, il ne nécessite pas de manipulation des types. Le trans-typage ce fait automatiquement, selon le besoin et les opérateurs utilisés.

SYNTAX :
nil
true | false
nan | infinity | number
'"' string '"'
array | function | object
ident '[' expr ']' 

Les opérateurs binaires sont les suivant :

symboledéscription
&&(booléen) et : true (vrai) et true (vrai) donne true (vrai)
||(booléen) ou : true (vrai) ou false (faux) donne true (vrai)
==est égale
!=est différent
<est plus petit que
>est plus grand que
<=est plus petit ou égale à
>=est plus grand ou égale à
+(number) plus
-(number) moins
*(number) multiplie
/(number) divise
%(number) modulo
..(string) concatène
->(function) puis

Les opérateurs unaires sont les suivants :

symboledescription
!(boolean) not (non) : !true (non vrai) donne false (faux)
-(number) moins : -i est équivaut à 0 - i
++incrementation : i++ équivaut à i = i + 1 ou i += 1
--decrement : i-- équivaut à i = i - 1 ou i -= 1

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

        ui.showLog();
        set i = 100 / 2 + 4 * -2;
        i++;
        set b = true || false;
        util.log("result : " .. i .. " and 1 or 0 : " .. b);
     


AL supporte également plusieurs valeurs constantes : true, false, nil, nan, infinity :
- true et false sont les deux valeurs booléenne
- nil représente la valeur null
- nan signifie "not a number" (résultat d'une opération non autorisée)
- infinity représente un nombre infinit (utiliser -infinity pour la valeur négative)

statement

Déclare une variable dans la portée courante.
Les variables déclarées peuvent être utilisées par la suite dans la même portée ou dans une portée imbriqué la la portée courante.

SYNTAX : 'set' ident [symbol expr] ';' 

Les symboles sont les suivants :

symboledéscription
=égale i = n;
+=plus égale, équivaut à i = i + n
-=moins égale, équivaut à i = i - n
*=multiplie égale, équivaut à i = i * n
/=divise égale, équivaut à i = i / n
%=modulo égale, équivaut à i = i % n
..=concatène égale (pour les strings), équivaut à s = s .. t
->=puis égale (pour les functions), équivaut à f = f -> g

La déclaration est elle même une expression.

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

      ui.showLog();
      set i = 10;
      i += 20;
      util.log("result: " .. i);
     

while

While est la première instruction impérative. Elle boucle tant que sa condition renvoie true (vrai).

SYNTAX : 'while' '(' condition ')' block 

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

      ui.showLog();
      set i = 10;
      while (i-- > 0) {
        util.log("result: " .. i);
      }
     

do

Boucle jusqu'à ce que la condition renvoie false (faux).

SYNTAX : 'do' block 'until' '(' condition ')' 

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

      ui.showLog();
      set i = 10;
      do {
        util.log("result: " .. i);
      } until (i-- <= 0)
     

loop

Boucle le nombre de fois indiqué par le paramètre limite.

SYNTAX : 'loop' (limit) block 

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

      ui.showLog();
      set a = 0;
      loop (10) {
        util.log("loop: " .. a);
        a++;
      }
     

for

La boucle for initialise une variable et répète le bloc d'instruction tant que la progression de la variable respecte la condition.

SYNTAX : 'for' ([initialization] ';' [condition] ';' [progression]) block 

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

      ui.showLog();
      for (set i = 0; i < 10; i++) {
        util.log("loop: " .. i);
      }    
     

if

IF exécute un bloc d'instruction si sa condition est true (vrai) sinon, c'est le bloc Else qui est exécuté.
Elseif exécuté si la condition précédente n'est pas true (vrai) et si la sienne l'est.

SYNTAX : 'if' '(' condition ')' block {['elseif' '(' condition ')' block]} ['else' block] 

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

      ui.showLog();
      for (set i = 0; i<4; i++) {
        if (i == 0) {
          util.log("i is 0");
        } elseif (i == 1) {
          util.log("then 1");
        } else {
          util.log("then others");
        }
      }    
     

En langage AL, IF est aussi un expression. Elle peut être utilisée pour décrire une valeur conditionnelle.

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

      ui.showLog();
      set i = 0;
      set s = if (i==0) "zero" elseif (i == 1) "one" else "other";
      util.log ("if i=" .. i .. ", s=" .. s);
     

function

Définit un bloc d'instruction réutilisable dans une portée propre avec des paramètre en entrée et un paramètre de sortie.
La particularité d'AL, c'est que ses fonctions (ainsi que ses objets) sont considérés comme des valeurs. Ce sont des expressions et donc, peuvent se terminer par un point-virgule.

SYNTAX : 'function' ['(' [arg [{',' arg}]] ')'] '{' instruction '}' 

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

      set f = function (x) {
        ui.message("x parameter is " .. x);
      };
      f (10);    
     

lambda

Une expression lambda est une fonction avec une écriture simplifiée. Elle ne peut-être déclarée que comme paramètre d'une autre fonction. Elle a été créée pour simplifier l'écriture des foncteurs de la programmation fonctionnelle.

SYNTAX : ['(' [arg [{',' arg}]] ')'] '{' instruction '}' 

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5

      util.pulse({
        algo.go(10);
      }, 50);
     

object

Définit un ensemble de déclarations réutilisables dans leur portée propre.
Les déclarations peuvent être : des attributs (variables), des méthodes (fonctions) et des objets imbriqués.

SYNTAX : 'object' '(' {parent {[ ',' parent ]}} ')' '{' declarations '}' 

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

      ui.showLog ();
      set o = object () {
        set a = 0;
        set b = "my b attribut";
      };
      util.log ("o.a = " .. o.a);
      util.log ("o.b = " .. o.b);
     

Toute fonction déclarée dans un objet est appelé méthode. Les méthodes constituent les comportements de l'objet.
Une méthode désignée pour accéder à un attribut est appelé un accesseur.
Une méthode désignée pour modifier un attribut est appelé un mutateur.

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

      set o = object () {
        set a = 0;
        // the a setter
        set setA = function(a) {
          this.a = a;
        };
        // the a getter
        set getA = function() {
          return this.a;
        };
        // a method
        set doubleA = function() {
          this.a = this.a * this.a;
        };
     
      };
     
      o.setA(2);
      ui.message("o.a parameter is " .. o.getA());
      o.doubleA();
      ui.message("and its double is " .. o.getA());    
     

Les objets peuvent être dupliqués en conservants la même structure interne. Cela s'appel cloner un objet.
En AL les objets sont construits et peuvent être clonés. Il existe deux façons pour cloner; l'instruction new duplique l'objet et ses états actuels et la méthode clone.
Cette dernière permet d'attribuer de nouvelles valeurs aux états de l'objet en les lui passant en paramètre.

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

      ui.showLog();
      set o = object () {
        set a = 7;
        set b = "my attribute b";
        set toString = function () {
          return "o {a=" .. a .. ", b=" .. b .. "};"
        };
      };
      set p = o.clone (8, "another parameter");
      util.log (o);
      util.log (p);
     

This est une référence de l'objet à lui même.

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

        ui.showLog();
      set o = object () {
        set a;
        set setA = function (a) {
          this.a = a;
        };
        set getA = function () {
          return this.a;
        };
      };
      o.setA (7);
      util.log (o.getA());
     

Supers[n] est un tableau qui permet d'accéder à la liste des super objets (héritage multiple).

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

      set q = object() {
        set ret7 = function () {
          return 7;
        };
      };
     
      set p1 = object() {};
     
      set p2 = object(q) {};
     
      set o = object (p1, p2) {
        set test = function () {
          return this.supers[1].supers[0].ret7();
        };
      };
     
      ui.message("o.test result is " .. o.test());     
     

array

Définit un tableau d'éléments ou un dictionnaire (liste associative) indéxé par n'importe quelle expression.
Lors de la définition de tableaux imbriqués, le mot clé 'array' n'est obligatoire que pour le premier tableau (le root). Il devient optionnel ensuite.

SYNTAX :
item : [ expr ':' ] expr
array : [ 'array' ]1 '{' item [{ ',' item }] '}' 

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

      ui.showLog();
      set a = array {7, 8, 9, 10, 11};
      for (set i=0; i < a.length(); i++) {
        util.log("a[" .. i .. "] is " .. a[i]);
      }
      // or more elegent
      a.each (function (item, index) {
        util.log("a[" .. index .. "] is " .. item);
      });
     

Les tableaux peuvent être utilisés comme des tableaux associatifs.
Ils gardent leur comportement de tableau, mais leurs valeurs sont référencées par une expression clé :

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

      ui.showLog();
      set a = array {"a" : 7, "b" : 8, "c" : 9, "d" : 10, "e" : 11};
      a.each (function (item, index, key) {
        util.log("a[" .. key .. "] is " .. item);
      });
     
      util.log ("Find a[c] = " .. a["c"]);
     

Le framework Algoid

Un langage c'est une somme de structures de contr√īle et de primitives qui permettent de manipuler les √©tats.
Le framework est une librairie additionnelle (composé de fonctions et d'objets) qui met à disposition une somme d'outils.

Une particularité du langage AL est que chaque fois qu'une valeur est utilisée, AL met à disposition des méthodes pour agir sur elle.
Cet idiome a été inspiré de Smalltalk (cascade) et de Python (magic methods).

type

En AL, toutes les variables héritent de l'objet type. Lorsqu'une variable est déclarée, AL créer un objet approprié qui est aussi un objet type. Type à des propriétés et des méthodes qui sont donc communes à tous les types de variables.

property

*.getType ()

Renvoie le type AL de la donnée. Voir Types AL pour la référence complète.

*.is (type)

Vérifie que la donnée soit du type indiqué comme paramètre. Voir Types AL pour la référence complète.

*.isNull ()

Vérifie si le type de la variable est VOID (égale à nil).

*.ifNull (value)

Vérifie si le type de la variable est VOID (égale à nil). Si tel est le cas, la fonction retourne la valeur en paramètre.

*.ifNotBreak (type)

V√©rifie que la donn√©e soit du type indiqu√© comme param√®tre. Si tel n'est pas le cas, la fonction renvoie nil et termine la cha√ģne d'appel de fonctions. Voir Types AL pour la r√©f√©rence compl√®te.

*.ifNullBreak ()

Vérifie si le type de la variable est VOID (égale à nil). Si tel est le cas, la fonction retourne la valeur en paramètre.

*.equals (b)

Vérifie si boolean est égale à b.

*.toString ()

Renvoie l'expression de la donné sous forme de texte. Dans le cas d'un type complexe (comme array, function ou object), renvoie l'ensemble des valeurs du type sous forme de texte.

method

*.add (item [, index])

Index est un paramètre optionnel.
Si index est absent, il crée un tableau avec la valeur en première position et y ajoute un élément à sa fin.
Sinon, il crée le tableau et ajoute l'élément à la position indiquée.

*.addAll (array [, index])

Index est un paramètre optionnel.
Si index est absent, il crée un tableau avec la valeur en première position et y ajoute tous les éléments à la fin.
Sinon, il crée le tableau et ajoute les éléments à la position indiquée.

event

*.onChanged ( function(value){} )

Un évènement qui se lève chaque fois que la valeur est modifiée dans le programme.

void

Quand une variable sans valeur est déclaré, AL créer un objet VOID. Cet objet à des propriétés et des méthodes. Voir l'objet Type pour les méthodes et les propriétés communes aux types.

boolean

Quand un booléen est déclaré, AL créer un objet. Cet objet à des propriétés et des méthodes. Voir l'objet Type pour les méthodes et les propriétés communes aux types.

property

boolean.not ()

Retourne la valeur inverse du booléen.

boolean.and (b)

Retourne le résultat de l'opération boolean && b.

boolean.or (b)

Retourne le résultat de l'opération boolean || b.

boolean.xor (b)

Retourne le résultat de l'opération (boolean || !b) && (!boolean || b). En d'autres termes, boolean différent de b

boolean.ifTrue (function () {})

Execute la fonction en paramètre is la valeur boolééene est vrai.
Equivalent fonctionel de l'instruction If.

boolean.ifFalse (function () {})

Execute la fonction en paramètre is la valeur boolééene est fausse.
Equivalent fonctionel de l'instruction Else.

boolean.whileDo (function () {})

Execute la fonction en paramètre tant que la valeur boolééene est vrai.
Equivalent fonctionel de l'instruction While.

boolean.untilDo (function () {})

Execute la fonction en paramètre tant que la valeur boolééene est vrai.
Equivalent fonctionel de l'instruction While.

number

Quand un nombre est déclaré, AL créer un objet. Cet objet à des propriétés et des méthodes. Voir l'objet Type pour les méthodes et les propriétés communes aux types.
Attention, les parenthèses doivent être employés avec ce type parce que le point est réservé aux décimales. ex : (7).isNumber();

number.isInteger ()

Vérifie si le type de la variable est de type NUMBER et entière.

number.isReal ()

Vérifie si le type de la variable est de type NUMBER et réel.

number.isNan ()

Vérifie si la valeur n'est pas un nombre, càd si le résultat de l'opération est invalide.

number.isInfinite ()

Vérifie si la valeur est infinie.

method

number.toInteger ()

Retourne la valeur entière du nombre.

number.minus ()

Retourne la valeur inverse du nombre, équivalant de -n.

number.increment ([n])

Retourne le nombre incr√©ment√©, √Čquivalant de number + n. Si n n'est pas param√©tr√©, il est √©gale √† 1

number.decrement ()

Retourne le nombre d√©cr√©ment√©, √Čquivalant de number + n. Si n n'est pas param√©tr√©, il est √©gale √† 1

number.addition (n)

Equivaut à l'opération number + n.

number.substract (n)

Equivaut à l'opération number - n.

number.multiply (n)

Equivaut à l'opération number * n.

number.divide (n)

Equivaut à l'opération number / n.

number.modulo (n)

Equivaut à l'opération number % n.

number.limit (min, max)

Encadre la valeur entre le minimum et le maximum.

number.greaterThan (n)

Equivaut à l'opération number > n.

number.smallerThan (n)

Equivaut à l'opération number < n.

number.greaterOrEquals (n)

Equivaut à l'opération number >= n.

number.smallerOrEquals (n)

Equivaut à l'opération number <= n.

number.between (min, max)

Retourne vrai si number est entre min et max. C'est l'√Čquivalant de number >= min && number <= max.

number.decodePoint ()

Renvoie le caractère correspondant au code codepoint.

number.loopFor (function (index) {} [, init, [, increment]])

Equivaut à l'instruction impérative for (set index = init; index < number; index += increment). Exécute la fonction depuis 0 (ou init, optionel) jusqu'au nombre en incrémentant de 1 (ou increment, optionel) chaque fois.

string

Quand une cha√ģne de caract√®re est utilis√©e, AL cr√©er un objet STRING. Cet objet √† des propri√©t√©s et des m√©thodes. Voir l'objet Type pour les m√©thodes et les propri√©t√©s communes aux types.

property

string.isEmpty ()

V√©rifie si la cha√ģne est vide ("").

string.length ()

Retourne le nombre de caract√®res de la cha√ģne.

string.getChar (index)

Retourne le caract√®re √† la position index dans la cha√ģne.

method

string.contains (subString)

Retourne vrai si la chaine contiens la sous-chaine.

string.concat (string)

Concat√®ne la cha√ģne de caract√®res avec celle en param√®tre.

string.indexOf (subString, index)

Retourne la position de la sous-cha√ģne contenue dans la cha√ģne.
Index est optionnel et indique à quelle position la recherche est commencé.

string.count (subString)

Retourne le nombre de sous cha√ģne trouv√©s dans la cha√ģne.

string.upper ()

Retourne l'√©quivalent en majuscule de la cha√ģne.

string.lower ()

Retourne l'√©quivalent en minuscule de la cha√ģne.

string.append (substring [, index])

Retourne le r√©sultat de la concat√©nation entre la cha√ģne et la sous-cha√ģne.
Index est optionnel et sp√©cifie la position o√Ļ la sous-cha√ģne doit √™tre ins√©r√©e.
√Čquivalant de l'op√©rateur ".."

string.appendSep (substring , separator)

Retourne le r√©sultat de la concat√©nation entre la cha√ģne et la sous-cha√ģne pr√©c√©d√©e d'un s√©parateur si elle n'√©tait pas vide.

string.subString (begin [, end])

Renvoie la coupe de la cha√ģne en une sous-cha√ģne entre le d√©but et la fin.
End, le param√®tre de fin est optionnel. Il indique la fin de la sous-cha√ģne, s'il n'est pas indiqu√©, alors c'est la fin de la cha√ģne qui est prise.

string.subStringOf (begin [, end])

Renvoie la coupe de la cha√ģne en une sous-cha√ģne entre les sous-cha√ģne de d√©but et de fin.
End est optionnel.

string.replace (from, to)

Renvoie la cha√ģne dont la sous-cha√ģne from a √©t√© remplac√© par la sous-cha√ģne to.

string.replaceAt (subString, index)

Renvoie la cha√ģne dont la sous-cha√ģne a √©t√© remplac√© √† la position index.

string.remove (index [, length])

Renvoie la cha√ģne dont le caract√®re √† la position √† √©t√© remplac√©.
Length est optionnel, if assigné il indique le nombre de caractère à supprimer.

string.split (separator)

Divise la cha√ģne de caract√®re en un tableau de cha√ģnes selon le s√©parateur choisi.
Utiliser le s√©parateur "" pour convertir une cha√ģne en tableau de caract√®res.

string.splitAt (array)

Divise la cha√ģne de caract√®re en un tableau de cha√ģnes selon les indexes sp√©cifi√©s dans le tableau (array) choisi.

string.trim ()

Renvoie la cha√ģne dont les √©spaces inutiles au d√©but et √† la fin de la cha√ģne ont √©t√© supprim√©s.

string.create (subString, count)

Cr√©er une cha√ģne en dupliquant une sous-chaine de 0 √† "count" fois.

string.encodePoint ()

Cr√©er un tableau dont les valeurs sont les codespoints unicode de la cha√ģne.

functional method

string.each (function (char [, index]) {} [, step])

It√®re sur tous les caract√®res de la cha√ģne.
La fonction exécutée doit définir un paramètre pour récupérer le caractère à chaque itération de la boucle.
Le second param√®tre index est optionnel et fournis la position du caract√®re dans la cha√ģne.Step est optionnel, il repr√©sente le nombre de caract√®re √† sauter avant la prochaine it√©ration.

array

Quand un tableau est déclaré, AL créer un objet. Cet objet à des propriétés et des méthodes. Voir l'objet Type pour les méthodes et les propriétés communes aux types.

property

array.isEmpty ()

Vérifie si le tableau est vide ({}).

array.length ()

Retourne le nombre d'éléments du tableau.

array.getItem (identity)

Obtient l\élément du tableau à la position indiquée par identity.
Identity peu-t-être la position ou la clé de l'élément.

array.setItem (identity, item)

Définit la valeur du tableau à la position indiquée par identity.
Identity peu-t-être la position ou la clé de l'élément.

array.getFirst ()

Obtient le premier élément du tableau.

array.getLast ()

Obtient le dernier élément du tableau.

prototype

array.clone ()

Duplique le tableau vers un nouveau.
Chaque modification faite à un clone n'affecte pas l'objet original.

method

array.clear ()

Enlève tous les éléments du tableau.

array.contains (item)

Teste si l'élément est contenu par le tableau.

array.containsAll (array)

Teste si tous les éléments du sous ensemble sont contenus par le tableau.

array.containsAny (array)

Teste si au moins un des éléments du sous ensemble est contenu par le tableau.

array.remove (identity)

Supprime un élément du tableau à la position de identity.
Identity peu-t-être la position ou la clé de l'élément.

array.pop ([identity])

Identity est un paramètre optionnel, il peu-t-être la position ou la clé de l'élément.
Si identity est absent, retourne le dernier élément du tableau et le supprime.
Si identity est spécifié, retourne l'élément à la position et le supprime du tableau.
Utiliser array.add() et array.pop() pour avoir un comportement de pile LiFo (Last in First out, ou en français DEPS Dernier entré Premier sortie). Utiliser array.add() et array.pop(0) pour avoir un comportement de file FiFo (First in First out, ou en français PEPS Premier entré Premier sortie)

array.indexOf (item)

Retourne la position de l'élément dans le tableau.

array.count (item)

Retourne le nombre d'élément d'une certaine valeur trouvée dans le tableau.

array.swap(identity1, identity2)

Intervertie les deux éléments aux positions identity1 et identity2.
Identity1 et 2 peuvent être les positions ou les clés des éléments.

array.decodePoint ()

Cr√©e une cha√ģne de caract√®res √† partir de sa repr√©sentation codepoint.

functional method

array.find (function (item [, index [, key]] [, pos]) {})

Trouve l'élément du tableau pour lequel la fonction retourne la valeur vraie.
La fonction exécutée doit définir un paramètre pour récupérer l'élément à chaque itération de la boucle.
Le second paramètre index est optionnel et fournis la position de l'élément dans le tableau.
Le troisième paramètre est également optionnel, il fournis la clé de l'élément.
Pos est un paramètre également optionnel de la méthode find. Elle indique à partir de quel indice la recherche doit commencer.

array.create (count, function ([index]) {})

Créer un tableau de n éléments. Chaque élément est calculé par la fonction passée en paramètre.

array.each (function (item [, index [, key]]) {})

Itère sur tous les éléments du tableau.
La fonction exécutée doit définir un paramètre pour récupérer l'élément à chaque itération de la boucle.
Le second paramètre index est optionnel et fournis la position de l'élément dans le tableau.
Le troisième paramètre est également optionnel, il fournis la clé de l'élément.

array.eachOnRow (row, function (item [, index [, key]]) {})

Dans un tableau à deux dimensions, itère sur tous les éléments de la ligne du tableau.
La fonction exécutée doit définir un paramètre pour récupérer l'élément à chaque itération de la boucle.
Le second paramètre index est optionnel et fournis la position de l'élément dans le tableau.
Le troisième paramètre est également optionnel, il fournis la clé de l'élément.

array.eachOnCol (col, function (item [, index [, key]]) {})

Dans un tableau à deux dimensions (une table), itère sur tous les éléments de la colonne du tableau.
La fonction exécutée doit définir un paramètre pour récupérer l'élément à chaque itération de la boucle.
Le second paramètre index est optionnel et fournis la position de l'élément dans le tableau.
Le troisième paramètre est également optionnel, il fournis la clé de l'élément.

array.eachItem (function (item [, index [, key]]) {})

Dans un tableau à plusieurs dimensions (un arbre), itère sur tous les éléments du tableau, si l'élément est un tableau, il va itérer sur les éléments du tableau récursivement.
La fonction exécutée doit définir un paramètre pour récupérer l'élément à chaque itération de la boucle.
Le second paramètre index est optionnel et fournis la position de l'élément dans le tableau.
Le troisième paramètre est également optionnel, il fournis la clé de l'élément.

array.filter (function (item [, index [, key]]) {})

Filtre les éléments du tableau sur la valeur de retour d'une fonction.
La fonction doit retourner un booléen.
Si la valeur du booléen est vrai, l'élément est conservé, sinon il est supprimé du tableau.
La fonction exécutée doit définir un paramètre pour récupérer l'élément à chaque itération de la boucle.
Le second paramètre index est optionnel et fournis la position de l'élément dans le tableau.
Le troisième paramètre est également optionnel, il fournis la clé de l'élément.

array.sort ([function (item1, item2){}])

Renvoie un tableau trié sur les éléments du tableau.
La fonction est optionnelle.

array.min ([function (item1, item2){}])

Retourne la valeur minimale contenue dans le tableau.
La fonction est optionnelle. Voir sort pour plus de détails;

array.max ([function (item1, item2){}])

Retourne la valeur maximale contenue dans le tableau.
La fonction est optionnelle. Voir sort pour plus de détails;

array.join (function (item1, item2 [, index [, key]]){})

Joint tous les éléments du tableau ensemble.
La fonction est nécessaire pour savoir comment joindre séquencielement les éléments.
C'est util pour concaténer un tableau en un string ou pour ajouter tous les nombre d'un tableau.

array.merge (array, function (item1, item2, index [, key]){})

Renvoie le résultat de la fusion de deux tableaux. Chaque élément du premier tableau est fusionné avec l'élément correspondant du second tableau.
La fonction détermine le comportement de la fusion en retournant la valeur souhaitée pour chaque élément.
Note: si le second tableau est trop court, les éléments seront répétés depuis le début jusqu\à la complétion.

array.union (array)

Retourne l'union du tableau et du subset.

array.intersection (array)

Retourne l'intersection du tableau et du subset.

array.complement (array)

Retourne le complement du tableau et du subset.

array.difference (array)

Retourne la difference du tableau et du subset.

array.product (array)

Retourne le produit cartesien du tableau et du subset.

function

Quand une fonction est déclarée, AL créer un objet. Cet objet à des propriétés et des méthodes. Voir l'objet Type pour les méthodes et les propriétés communes aux types.

property

function.parameterExists (name)

Vérifie que le paramètre existe dans la définition de la fonction.

function.getParametersNames ()

Retourne un tableau contenant tous les noms des paramètres définit par la fonction.

function.setParameter (name, value))

Assigne la valeur au paramètre de la fonction dont le nom correspond à name. Le paramètre est créé s'il n'existe pas. Utilisé pour assigner les paramètres avant l'appelle de la fonction (util lors du passage d'une fonction à une autre sans copie des paramètres).

function.setParameters ({ values })

Assigne les valeurs aux paramètres de la fonction. Attention, les valeurs des paramètres doivent être regroupés dans un tableau (entre {}). Utilisé pour assigner tous les paramètres avant l'appelle de la fonction (util lors du passage d'une fonction à une autre sans copie des paramètres).

method

function.removeParameter (name)

Supprime dynamiquement un paramètre de la définition de la fonction.

functional method

function.concat (function)

Retourne une fonction résultat de la concaténation des deux fonctions. Les paramètres sont fusionnés et les traitements s'exécutent en suivant. Equivaut à l'opérateur ->

function.decorate (function)

Renvoie une nouvelle fonction résultat de la décoration de la fonction par une fonction décoratrice. L'éxécution de la fonction décorée est encapsulé dans la fonction décoratrice. Nécessaire au paradigme Aspect.

object

Quand un objet est déclaré, AL créer un meta-objet. Cet objet à des propriétés et des méthodes. Voir l'objet Type pour les méthodes et les propriétés communes aux types.

prototype

object.clone ()

Duplique l'objet vers un nouveau.
Chaque modification faite à un clone n'affecte pas l'objet original.
C'est l'équivalent de l'opérateur new.

property

object.attributeExists (name)

Vérifie que l'attribut existe dans la définition de l'objet.

object.getAttributesNames ()

Retourne un tableau contenant tous les noms des attributs définit par l'objet.

object.isA ()

Vérifie que l'objet soit une instance ou un sous objet de celui en paramètre.

object.setAttribute (name, value)

Assigne ou ajoute (si absent) dynamiquement un attribut à la définition de l'objet. L'attribut peut-être un attribut, une méthode ou un objet imbriqué.

method

object.toString = function () {}

Remplace le text par défaut de l'object.

object.merge (object)

Renvoie un objet résultat de la fusion de deux objets. Les définitions sont fusionnées ensemble par addition des attributs et des méthodes.

object.removeAttribute (name)

Supprime dynamiquement un attribut de la définition de l'objet. L'attribut peut-être un attribut, une méthode ou un objet imbriqué.

API root

print (text)

Ecrit le texte.

al

property

al.allObjects

Retourne tous les objets et les méthodes qui peuvent être utilisés dans l'API Algoid.

al.allLocalObjects

Retourne tous les objets et les méthodes qui peuvent être utilisés dans la portée courante.

al.clock

Retourne le temps en seconde depuis lequel Algoid a été lancé.

al.order

method

al.order.ascending (item1, item2)

Trie l'ordre du tableau de façon ascendante.

al.order.descending (item1, item2)

Trie l'ordre du tableau de façon ascendante.

al.order.random (item1, item2)

Inverse l'ordre du tableau.

al.order.reverse (item1, item2)

Inverse l'ordre du tableau.

al.combine

al.combine.sum (item1, item2)

Combine les éléments d'un tableau ensemble par sommage.

al.combine.product (item1, item2)

Combine les éléments d'un tableau ensemble par produit.

al.combine.concat (item1, item2, index, key, separator)

Combine les éléments d'un tableau ensemble par concaténation.

al.types

property

al.types.VOID

Le type AL VOID. Représente une valeur nulle.

al.types.BOOL

Le type AL BOOL. Représente une valeur booléenne (true, false).

al.types.NUMBER

Le type AL NUMBER. Représente une valeur numérique (1, 2, 3.5, 7 ....).

al.types.STRING

Le type AL STRING. Repr√©sente une cha√ģne de caract√®re ("Hi, I am algoid !").

al.types.ARRAY

Le type AL ARRAY. Représente un tableau de données ({true, 5, "Hi"}).

al.types.FUNCTION

Le type AL FUNCTION. Représente une fonction.

al.types.OBJECT

Le type AL OBJECT. Représente un objet.

util

method

util.eval (code)

Execute le code en paramètre dans la portée courante.

util.wait (milli)

Attendre le temps indiqué en milli-secondes

util.pulse (function ([index]) {}, milli [, count[, after]])

Execute la foncion chaque fois que le temps (milli-secondes) est écoulé.
La fonction appellé reçoit un paramètre optionel appellé index qui spécifie le numéro d'appel.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.
Le paramère optionel count spécifie combien de fois pulse fonctionne avant d'être arreté. Appel la fonction after un fois pulse finis.

util.notice (function, milli)

Execute la fonction après un temps donné.

util.pullOn (array, milli)

PullOn accepte un tableau de fonction qu'il execute sequentiellement avec un delai entre chaque appel.

util.clearTasks (array, milli)

Supprime toutes les t√Ęches et les evenements √† venir, mais pas la t√Ęche courante.

util.log (msg)

Ecrit le message dans le journal.

util.warn (msg)

Ecrit le warning dans le journal (orange).

util.err (msg)

Ecrit l'erreur dans le journal (rouge).

math

constant

math.E

La constante mathématique e.

math.PI

La constante mathématique PI.

method

math.abs (number)

Retourne la valeur absolue (positive) du nombre.

math.acos (factor)

Calcule l'arc cosinus d'un angle en degré.

math.aim (number, number)

Calcule l'angle pour suivre une cible depuis les coordonnées (0, 0) du plan.

math.asin (factor)

Calcule l'arc sinun d'un angle en degré.

math.atan (factor)

Calcule l'arc tangente d'un angle en degré.

math.ceil (number)

Renvoie la plus petite valeur entière directement suppérieur au nombre : 10.9 = 11

math.cos (angle)

Calcule le cosinus d'un angle en degré.

math.dbl (number)

Calcule le nombre à la puissance 2.

math.diagonal (number, number)

Calcule la longueur de la diagonale (hypothénuse) d'un rectangle.

math.exp (number)

Calcule la valeur exponentielle du nombre.

math.floor (number)

Renvoie la partie entière du nombre : 10.9 = 10

math.log (number[, base])

Renvoie le logarithme naturel du nombre. Is la base est assignée, renvoie le logarithme du nombre de la base donnée.

math.max (number, number)

Retourne le plus grand des deux nombres.

math.min (number, number)

Retourne le plus petit des deux nombres.

math.pow (number, power)

Calcule le nombre à la puissance n.

math.random (factor)

Génère un nombre aléatoire entre 0 et factor à l\exception de celui-ci.

math.round (number)

Arrondi le nombre réel en un nombre naturel : 10.9 = 11

math.sin (angle)

Calcule le sinun d'un angle en degré.

math.sqrt (number)

Calcule la racine carrée du nombre.

math.tan (angle)

Calcule la tangente d'un angle en degré.

ui

ui.message (msg)

Affiche une fenêtre popup de message dans l'application.

ui.fullScreen ()

Montre la fenêtre d'exécution en mode plein écran.

ui.halfScreen ()

Montre la fenêtre d'exécution en mode demi écran.

ui.miniScreen ()

Cache la fenêtre d'exécution et montre le code source.

ui.showText ()

Montre la fenêtre d'invite en mode demi écran.

ui.showAlgo ()

Fait défiler les fenêtres jusqu'à celle d'algo.

ui.showScope ()

Fait défiler les fenêtres jusqu'à celle du debuger.

ui.showLog ()

Fait défiler les fenêtres jusqu'à celle du journal.

ui.clearLog ()

Vide le journal.

ui.showMenu ()

(Seulement sur android !) Montre le menu glissant √† la droite de la fen√™tre algo.

ui.hideMenu ()

(Seulement sur android !) Cache le menu glissant √† la droite de la fen√™tre algo.

text

text.clear ()

Vide la fenêtre d'invite.

text.output (msg)

Ecrit une nouvelle ligne dans la fenêtre d'invite.

text.inputText (msg)

Ecrit une nouvelle ligne de saisie utilisateur (texte) dans la fenêtre d'invite.
Retourne une cha√ģne de caract√®re.

text.inputNumber (msg)

Ecrit une nouvelle ligne de saisie utilisateur (nombre) dans la fenêtre d'invite.
Retourne un nombre.

algo.color

constant

algo.color.TRANSP

La constante de couleur transparente (-1). Voir la table des couleurs.

algo.color.BLACK

La constante de couleur noire (0). Voir la table des couleurs.

algo.color.DARK_BLUE

La constante de couleur bleu foncé (1). Voir la table des couleurs.

algo.color.DARK_GREEN

La constante de couleur vert foncé (2). Voir la table des couleurs.

algo.color.DARK_CYAN

La constante de couleur cyan foncé (3). Voir la table des couleurs.

algo.color.DARK_RED

La constante de couleur rouge foncé (4). Voir la table des couleurs.

algo.color.DARK_MAGENTA

La constante de couleur violet foncé (5). Voir la table des couleurs.

algo.color.BROWN

La constante de couleur marron (6). Voir la table des couleurs.

algo.color.GRAY

La constante de couleur gris (7). Voir la table des couleurs.

algo.color.DARK_GRAY

La constante de couleur gris foncé (8). Voir la table des couleurs.

algo.color.BLUE

La constante de couleur bleu (9). Voir la table des couleurs.

algo.color.GREEN

La constante de couleur vert (10). Voir la table des couleurs.

algo.color.CYAN

La constante de couleur cyan (11). Voir la table des couleurs.

algo.color.RED

La constante de couleur rouge (12). Voir la table des couleurs.

algo.color.MAGENTA

La constante de couleur violet (13). Voir la table des couleurs.

algo.color.YELLOW

La constante de couleur jaune (14). Voir la table des couleurs.

algo.color.WHITE

La constante de couleur blanc (15). Voir la table des couleurs.

algo

property

algo.setColor (color)

Détermine la couleur des futures formes d'Algo.

couleur valeur couleur valeur
transp.-1   
noir0 gris sombre8
bleue sombre1 bleue9
vert sombre2 vert10
cyan sombre3 cyan11
rouge sombre4 rouge12
violet sombre5 violet13
marron6 jaune14
gris clair7 blanc15

algo.setRGB (red, green, blue)

Détermine la couleur RGB des futures formes d'Algo.

algo.setBgColor (color)

Détermine la couleur de fond d'Algo.

algo.setBgRGB (red, green, blue)

Détermine la couleur RGB du fond d'Algo.

algo.setAlpha (color)

Détermine la transparence de la couleur des futures formes. La valeur doit être entre 0 et 1.

algo.setTextSize (size)

Détermine la taille du futures texte d'Algo.

algo.setStroke (size)

Détermine l'épaisseur du trait des futures formes et chemins d'Algo.

algo.setStack ()

Détermine les nombre d'éléments simultanément visible dans Algo.

algo.getX ()

Obtient la coordoné X d'Algo.

algo.getY ()

Obtient la coordoné Y d'Algo.

algo.getAngle ()

Obtient l'angle d'Algo.

algo.getTop ()

Obtient la coordoné du haut de la fenêtre Algo (inférieur à 0).

algo.getBottom ()

Obtient la coordoné du bas de la fenêtre Algo (supérieur à 0).

algo.getLeft ()

Obtient la coordoné de la gauche de la fenêtre Algo (inférieur à 0).

algo.getRight ()

Obtient la coordoné de la droite de la fenêtre Algo (supérieur à 0).

algo.getWidth ()

Obtient la largeur de la fenêtre Algo.

algo.getHeight ()

Obtient la hauteur de la fenêtre Algo.

method

algo.show ()

Montre la tortue.

algo.hide ()

Cache la tortue.

algo.clear ()

Vide Algo de tous ses éléments visibles.

algo.autoClear ()

Vide Algo de tous ses éléments visibles sans effet de scintillement. Util pour la programmation d'animation et de jeux vidéos. A placer au début de la boucle de rendu.

algo.removeFirst ()

Supprimer le premier élément dessiné dans Algo.

algo.removeLast ()

Supprimer le dernier élément dessiné dans Algo.

algo.goTo (x, y)

Déplace la tortue aux coordonnées absolus x, y sur la grille.

algo.lineTo (x, y)

Dessine une ligne depuis la position actuelle vers les coordonnées x, y.

algo.go (len)

Fait avancer la tortue en dessinant une ligne.

algo.jump (len)

Fait avancer la tortue sans dessiner de ligne.

algo.turnRight (angle)

Tourne la tortue à droite.

algo.turnLeft (angle)

Tourne la tortue à gauche.

algo.rotateTo (angle)

Tourne la tortue vers un angle absolu.

algo.circle (diameter)

Dessine un cercle à la position courante.

algo.disc (diameter)

Dessine un cercle plein (un disque) à la position courante.

algo.square (size)

Dessine un carré à la position courante.

algo.box (size)

Dessine un carré plein (une boite) à la position courante.

algo.rect (width, height)

Dessine un rectangle à la position courante.

algo.plane (width, height)

Dessine un rectangle plein (un plan) à la position courante.

algo.oval (width, height)

Dessine un ovale à la position courante.

algo.platter (width, height)

Dessine un ovale plein à la position courante.

algo.path (array[, closed = true])

Dessine un chemin fermé. Le paramètre optionel closed définit si la forme est fermé, sa valeur par défaut est vrai. Attention, nécessite un tableau de paires x, y en entrée. Le premier point est toujours la position courante.

algo.poly (array[, closed = true])

Dessine un chemin fermé plein (un polygone). Le paramètre optionel closed définit si la forme est fermée, sa valeur par défaut est vrai. Attention, nécessite un tableau de paires x, y en entrée. Le premier point est toujours la position courante.

algo.curve (array[, closed = true])

Dessine un chemin courbe. Le paramètre optionel closed définit si la forme est fermée, sa valeur par défaut est vrai. Attention, nécessite un tableau de paires x, y en entrée. Le premier point est toujours la position courante.

algo.curvedPoly (array[, closed = true])

Dessine un chemin plein courbé (un polygone). Le paramètre optionel closed définit si la forme est fermée, sa valeur par défaut est vrai. Attention, nécessite un tableau de paires x, y en entrée. Le premier point est toujours la position courante.

algo.text (text)

Dessine du texte à la position courante.

event

algo.onClick (function (x, y))

(Seulement sur desktop !) Execute la fonction d√©finit lorsque l'utilisateur clique avec la souris sur algo.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onRelease (function (x, y))

(Seulement sur desktop !) Ex√©cute la fonction d√©finit lorsque l'utilisateur √† finit de cliqu√© Algo avec la souris.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onMove (function (x, y))

(Seulement sur desktop !) Ex√©cute la fonction d√©finit lorsque l'utilisateur glisse la souris sur algo.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onDrag (function (x, y))

(Seulement sur desktop !) Ex√©cute la fonction d√©finit lorsque l'utilisateur clique et glisse la souris sur algo.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onWheel (function (rotation))

(Seulement sur desktop !) Ex√©cute la fonction d√©finit lorsque l'utilisateur utilise la roue de la souris sur algo.
Retourne 1 pour bas et -1 pour haut.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onKey (function (key))

(Seulement sur desktop !) Ex√©cute la fonction d√©finit lorsque l'utilisateur tape une touche du clavier.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onTap (function (x, y))

Execute la fonction définit lorsque l'utilisateur tape avec son doigt sur algo.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onTouch (function (x, y))

Exécute la fonction définit lorsque l'utilisateur glisse son doigt sur algo.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onUp (function (x, y))

Exécute la fonction définit lorsque l'utilisateur à finit de taper Algo avec son doigt.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onGravity (function (x, y, z))

(Seulement sur android !) Ex√©cute la fonction d√©finit lorsque l'utilisateur tourne l'appareil. x, y et z sont les axes 3d sur lesquels s'√©xerce la force de gravit√© en m/s.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onAcceleration (function (x, y, z))

(Seulement sur android !) Ex√©cute la fonction d√©finit lorsque l'utilisateur d√©place l'appareil. x, y et z sont les axes 3d sur lesquels s'√©xerce la force d'acceleration en m/s.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onGyroscope (function (x, y, z))

(Seulement sur android !) Ex√©cute la fonction d√©finit lorsque l'utilisateur tourne l'appareil. x, y et z sont les axes 3d sur lesquels s'√©xerce la force de rotation en degr√©/s.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onOrientation (function (z, x, y))

(Seulement sur android !) Ex√©cute la fonction d√©finit lorsque l'utilisateur tourne l'appareil par rapport au champ magnetique de la terre. z, x et y sont l'Azimute, le tangage et le roulis et leur unit√© est le en degr√©.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onProximity (function (dist))

(Seulement sur android !) Ex√©cute la fonction d√©finit lorsque l'utilisateur de rapproche ou s'√©loigne de l'appareil. Distance est en cm.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onTemperature (function (t))

(Seulement sur android !) Ex√©cute la fonction d√©finit lorsque la temp√©rature ambiente est modifi√©e. t est en ¬įC.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.onLight (function (l))

(Seulement sur android !) Ex√©cute la fonction d√©finit lorsque la lumi√®re ambiente est modifi√©e. l est en lx.
Lorsque la fonction renvoie une valeur, cela termine l'evenement.

algo.stamp

Un tampon est un objet graphique bitmap qui peut-être dessiné par duplication (tamponné) dans algo.

property

algo.stamp.id

L'identifiant interne du tampon dans algo.

algo.stamp.width

La largeur du tampon.

algo.stamp.height

La hauteur du tampon.

prototype

algo.stamp.clone (colors, size)

Crée un nouveau tampon avec les informations bitmap et la taille.

algo.stamp.load (filename)

(Seulement sur desktop !) Cr√©e un nouveau tampon √† partir d'une image.

Le nom du fichier doit correspondre à un fichier existant. Cela peut-être un chemin absolut ou un chemin relatif à plusieurs repertoires par défaut ([project root]/img ou [application root]/img) ou [user root]/img.

 
exemple: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
set stamp = algo.stamp.load("PlanetCute/Character Princess Girl");

algo.onTouch((x, y) {
  algo.autoClear();
  algo.goTo(x, y);
  stamp.draw();
});
algo.hide();

method

algo.stamp.delete ()

Supprime le tampon dans algo

algo.stamp.draw ()

Duplique et dessine le tampon dans algo.

Forme de Backus-Naur d'Algoid Language

// expressions et précédence des opérateurs
assign ::= var ident ( "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "..=" | "->=" ) expr [ ";" ]
expr ::= concat | assign
concat ::= or [ ( ".." | "->" ) or ]
or ::= and [ "||" and ]
and ::= compar [ "&&" compar ]
compar ::= oper [ "==" | "!=" | "<" | "<=" | ">" | ">=" oper ]
oper ::= mult [ "+" | "-" mult ]
mult ::= unary [ "*" | "/" | "%" unary ]
unary ::= ( ["-" | "!" | new ] ident) | ( ident [ "++" | "--" ] )

// identifiants
ident ::= call [ "." call ]
call ::= index "(" [ expr [ { "," expr } ] ] ")"
index ::= value [ { "[" expr "]" } ]

// valeurs
boolean ::= true | false
number ::= nan | infinity | ("0"-"9") [ { ("0"-"9") } ]
string ::= """ [ { .. caractère ASCII .. } ] """
value ::= "(" expr ")" | object | lambda | function | array | if | this | supers | ident | nil | boolean | number | string

// structures
assign ::= set ident "=" expr [ ";" ]
lambda ::= [ "(" [ ident ] [ { "," ident } ] ")" ] "{" body "}"
function ::= function "(" [ ident ] [ { "," ident } ] ")" "{" body "}"
return ::= return expr [ ";" ]
array ::= array<1*> [ "(" ")" ] "{" [ item [ { "," item } ] ] "}"
item ::= [ expr ":" ] expr
object ::= object "(" [ ident [ "," ident ] ] ")" "{" [ { assign } ] "}"

// impératifs
if ::= if "(" expr ")" body [ { elseif "(" expr ")" body } ] [ else body ]
loop ::= loop "(" [ expr ] ")" body
for ::= for "(" [ assign ] ";" [ expr ] ";" [ expr] ")" body
while ::= while "(" expr ")" body
until ::= do body until "(" expr ")"
break ::= break [ ";" ]

// autres
comment ::= ( "//" .. caractère ASCII .. .. fin de ligne .. ) | ( "/*" .. caractère ASCII .. "*/")
body ::= instruction | "{" [ { instruction } ] "}"
instruction ::= comment | return | loop | for | while | until | break | expr [ ";" ] | ";" | body

apprendre à programmer devient simple et amusant !
Algoid
EN | FR