Le language a subi de nombreux tests, mais il reste certainement quelques bugs et contournements de syntaxe.

L'objectif de ce language est de pouvoir écrire du code le plus clair possible.
Dans ce sens, toute instruction sera écrite dans un français correct avec des phrases claires (attention à ne pas oublier les accents :3).
Pro tip : Tout comme en français, si vous ne voulez pas avoir une phrase trop compliquée, ne la faites pas trop longue.



Première spécificité du langage : chaque phrase doit commencer par une majuscule et se terminer par un point ou point d'interrogation.
/!\ Toute majuscule sera considérée comme le début d'une nouvelle phrase. De même, un point ou un point d'interrogation sera considéré comme une fin de phrase.

La ponctuation parfaite avec de telles règles n'existe malheureusement pas. Il est donc possible que vous vous retrouviez avec plusieurs points ou points d'interrogation à la suite ou avec des phrases imbriquées dans d'autres…

Les phrases sont divisées en deux type :

• les instructions qui effectuent des actions (se terminent par un point)
• les expressions qui renvoient une valeur (se terminent par un point d'interrogation)

Vous devrez certainement écrire des nombres dans votre programme.
Les plus perspicaces l'auront peut-être deviné, il faudra les écrire en lettres, selon la règle de 1990 :

• tirets entre tous les nombres sauf autour de million et de milliard
• cent et vingt ne prennent de "s" au pluriel que s'ils ne sont pas suivis d'un nombre autre que million et milliard
• million et milliard prennent un "s" au pluriel
• mille est invariable

Les nombres à virgule devront être écrits avec tous les zéros et la virgule par exemple 2.00512 : "deux virgule zéro zéro cinq-cent-douze"

La syntaxes sera décrite de cette manière :


"{expression}" signifie que la syntaxe requiert une expression (sans les "{}") et "{instruction}" requiert une instruction.
Si un type de base est présent aux côtés du mot expression, cela signifie que le type est à respecter.

Si


apparaît, cela veut dire qu'il faut mettre au moins une instruction mais qu'il est possible d'en mettre autant que l'on veut.

Dans le cas de


il faut mettre au moins une expression mais il est à nouveau possible d'en mettre autant que l'on veut.
La présence des virgules entre les différentes expressions est à noter car celle-ci est obligatoire.

Lorsque "<mettre un truc ici>" apparaît, il faut mettre un élément (également sans les "<>"), souvent un nom de variable, de fonction ou un nombre, suivant ce qui est écrit à l'intérieur.

Les structures de données pourront vous paraître incompréhensible au premier abord mais des exemples seront donnés à la fin de la documentation.

Les expressions de base sontcelles que vous utiliserez probablement le plus souvent
Il peut s'agir :

• D'un entier
expression

• D'un nombre à virgule (ou flottant)
expression

• D'un booléen
expression

• D'une chaîne de caractères
expression

• De rien (ou non défini)
le rien peut être utile dans certaines situations
expression

Les variables sont indispensables pour stocker de l'information à réutiliser plus tard.

On peut définir une variable sans lui donner de valeur :
instruction


Ou lui en assigner à sa création :
instruction


Pour lui assigner une valeur une fois définie, on utilisera la syntaxe suivante qui est plus générale car elle est également utilisée pour d'autres structures de données décrites plus tard.
instruction


Pour accéder au contenu de la variable il suffit de faire
expression


Exemple :

Une liste est stockée dans une variable. Le nom de cette variable devient donc le nom de la liste.

Il y a deux moyens de définir une liste :

• Comme une liste vide :
expression

• Comme une liste d'éléments:
expression


Une fois stockée dans une variable, on peut y accéder avec
expression


On peut accéder à un élément de la liste avec
expression


où "{expression: liste}" est souvent "La liste <nom de la liste>?".

Plusieurs opérations sont possibles sur les listes :

• Ajouter un élément à la fin d'une liste :
instruction


• Insérer un élément au milieu de la liste :
instruction


• Supprimer un élément :
instruction


• Remplacer un élément :
instruction

Les opérateurs les plus courants sont disponibles dans ce langage, et la plupart d'entres-eux ne fonctionnent que sur les types numériques de base i.e. les entiers, les flottants et les booléens.
"{expression numérique}" désigne "{expression : entier / flottant / booléen}"

Parmi ces opérateurs, on retrouve

• La somme :
expression

• La différence :
expression

• Le produit :
expression

• Le quotient :
expression

• Le quotient entier :
expression

• Le reste (ou modulo) :
expression

- La partie entière :
expression


Il y a également quelques opérateurs booléens simples:

• La négation booléenne :
expression

• La conjonction booléenne :
expression

• La disjonction booléenne :
expression

Pour vos programmes, vous aurez certainement besoin d'executer certains éléments de code seulement si une certaine condition est vérifiée.
Pour cela, vous pouvez choisir parmi deux structures conditionnelles :

• Si alors :
instruction


/!\ Ne pas oublier le point à la fin de la condition.
Note : La tabulation n'est pas obligatoire mais permet d'augmenter la lisibilité.

• Si alors sinon :
instruction


Note : Le "sinon" n'a pas de majuscule ! Faites attention.

Maintenant passons aux comparateurs.
Pour comparer, vous aurez à votre disposition :

• L'égalité :
expression

• La non égalité :
expression

• L'inégalité inférieure :
expression

• L'inégalité stricte inférieure :
expression

• L'inégalité supérieure :
expression

• L'inégalité stricte supérieure :
expression

Écrire peut être rapidement fatiguant, surtout s'il s'agit de lignes plutôt répétitives.
Pour régler ce problème, vous aurez plusieurs boucles à votre disposition :

• Tant que :
instruction

• Pour :
instruction

• Pour avec pas :
instruction


Vous pourrez également sortir d'une de ces boucles à tout moment avec l'instruction
Quitter boucle :
instruction

En cas d'erreur dans votre code, il est pratique de pouvoir afficher les éléments qui peuvent poser problème.

Il est possible d'afficher une expression dans la console :
instruction


Mais aussi sans retours à la ligne :
instruction


On peut également récupérer la longueur d'une liste ou d'une chaîne de caractère :
expression


Pour récupérer le type de d'une expression sous forme de chaîne de caractère :
expression


Il est possible de récupérer des entrées de l'utilisateur sous différents types :

• Entier :
expression


• Flottant :
expression


• Booléen :
expression


• Chaîne de caractères :
expression

Quoi de mieux qu'un peu d'aléatoire pour pimenter votre code ?
Vous avez accès à deux fonction manipulant l'aléatoire :

• Nombre aléatoire (de 0 jusqu'à très très grand) :
expression


• Seed :
Vous pouvez mettre la seed à la valeur que vous voulez pour obtenir un résultat différent (la seed initiale est à 0)
instruction

La partie entière vous a déjà été introduite précédemment, ici vous pourrez convertir non seulement les types numériques mais également les chaînes de caractères en nombres ou les nombres en chaînes de caractères.
En cas d'échec de conversion, l'expression renvoyée est "Rien?" de type "undefined".

• Conversion en entier :
Si l'entrée est une chaîne, renvoie l'entier associé à l'entier écrit en lettres
expression


• Conversion en flottant :
Si l'entrée est une chaîne, renvoie le flottant associé au flottant écrit en lettres
expression


• Conversion en booléen :
Si l'entrée est une chaîne, renvoie faux si la chaîne est "faux" ou si la chaîne est vide, vrai sinon
expression


• Conversion en chaîne de caractères :
expression

Pour ceux qui voudraient optimiser leur programme, vous pouvez utiliser des pointeurs.
Par exemple lors du passage d'arguments volumineux dans des fonctions comme des grosses listes (ou juste pour le fun)

Pour créer un pointeur :
expression


Créer un pointeur c'est bien mais pouvoir accéder à sa valeur c'est mieux.
On peut accéder à la valeur d'un pointeur de deux manières différentes :

• la valeur pointée :
expression

• la valeur finale pointée :
expression


Si a->b->c avec c = 2, la valeur pointée par a est un pointeur alors que la valeur finale pointée par a est 2.

Si vous vous souvenez, les pointeurs ont été abordés lors de la modification de valeurs.
En effet, la modification de la valeur pointée par un pointeur se fait avec "Que … devienne …".

Exemple :


Permet de stocker la valeur 2 dans la variable x sans avoir à passer par son nom.

Les fonctions sont très utiles pour exécuter un morceau de programme utilisé régulièrement.
Une fonction se définit de la façon suivante :
instruction


Elles peuvent également être définies avec des arguments :
instruction


Pour exécuter une fonction :
instruction


Et avec des arguments :
instruction


Il peut s'avérer utile de pouvoir renvoyer une valeur dans une fonction et de la récupérer.
Pour renvoyer une valeur :
instruction


Pour récupérer la valeur :
expression


Et avec des arguments :
expression

Les commentaires sont parfois utiles pour s'y retrouver.
Toute phrase écrite entre parenthèses sera ignoré.:

Exemple :

Nous avons répertorié ici quelques exemples de codes simples pour que vous puissiez vous familiariser avec le langage en le lisant ou en l'exécutant.

Test pair/ impair


Afficher plusieurs éléments sur la même ligne et parcourir une liste avec un pour


Boucle tant que avec sortie forcée de boucle et assignation variable


Fonctions, récursivité et renvoi de valeurs
exemple de la fonction factorielle


Stockage dans une liste de valeurs entrées par l'utilisateur


Avec l'entrée


le programme renvoie


Exemple avec des pointeurs