Grammaire R++ V0.1

**Christophe Genolini** · 23/08/2013, 12h26

1 En français

1.1 Quelques Tokens

Un <IDENTIFIANT> est une suite de lettres et de chiffres commençant nécessairement par une lettre minuscule.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
toto
tOTO
toTO23

Un <TYPE> est une suite de lettres et de chiffres commençant nécessairement par une lettre majuscule.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Integer  	# Un des type de base du langage
ToTO		# Classe ToTO
Toto		# Classe Toto

1.2 Règles syntaxiques

10. Un programme est un ensemble éventuellement vide de plusieurs instructions (30).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
a <- 4
b <- matrix(c(1,2),c(2,4))
type(b)

30. Une instruction est soit une définition (50), soit une instruction élémentaire (33).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
a <- 4        # Définition
a             # Instruction élémentaire
type(a)       # Instruction élémentaire

33. Une instruction élémentaire est l'utilisation d'une fonction (60) [[[plus tard : une structure (190) et un bloc d'instruction (35)]]]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
a				# Instruction élémentaire get
3+2

50. Une définition est la définition d'une variable (55) [[[plus tard : la définition d'une fonction (250). ]]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

a <- 3

55. La définition d'une variable se fait en spécifiant une variable (180) suivit de <ASSIGN> (c'est à dire de "<-") puis d'une expression (100). Un typeur de R++ se charge de définir le type de l'expression [[[Plus tard : on pourra forcer les types]]] et fixe ainsi le type de la variable. Enfin, comme en python, on peut définir plusieurs variables séparées par des virgules en fournissant plusieurs expressions :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
n <- 2                  # Assignation d'un entier. Le type est déterminé automatiquement par le typeur
notes <- c(2,4,3)       # Assignation d'un vecteur d'entier.
a,b <- 3,"bonjour"      # Assignation de 3 à a et de "Bonjour" à b

[[[Note importante : la modification de la valeur d'une variable devrait se faire avec la fonction set. En pratique, elle utilise la même syntaxe que la définition. zz <- 4 peut donc être :

Soit la déclaration de la variable zz. Dans ce cas, le typeur détermine le type de l'expression, puis affecte ce type à zz
Soit une modification de la variable zz. Dans ce cas, le typeur détermine le type de l'expression, puis vérifie qu'il est compatible avec le type de zz. Si ca n'est pas le cas, cela déclenche une erreur.

Par contre, l'instruction zz[2] <- 3 est nécessairement une modification d'une variable existante.]]]

60. Une action (au sens large) est l'appel d'une fonction. Cette fonction utilise un unique arguments qui est nécessairement une expression (100) [[[Pour l'instant]]]. Cas particulier, une "expression" seule (sans fonction) est une simplification de l'instruction "get(expression)". Elle est donc considérée également comme une fonction. Si une fonction retourne un résultat et que se résultat n'est pas utilisé, alors il est affiché à l'écran (ie il est envoyé à la fonction "show").

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
a                       # fonction "get" appliquée à "a", puis envoyé à "show" pour affichage
show(get(a))            # idem
b <- a                  # fonction "get" appliquée à "a". La valeur de "a" est affecté a "b". "show" n'est pas invoqué.
t(mat)                  # fonction "get" appliqué à "mat", puis "t" appliqué a "get(mat)". Le résultat est envoyé à "show" pour affichage. 
type(mat)               # fonction "type" appliqué à "mat", puis "show"

100. Une expression est un ensemble de valeurs combinées entres elles par des opérateurs binaires (120).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
3*2^3-5*(3+1)
TRUE and FALSE or TRUE
3+f(3,4)-a[3]

120. Un opérateur binaire est un opérateur mathématique qui prend deux valeurs et qui en retourne une.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
+
*
and
or

130. Une valeur est un optionnellement un opérateur unaire (135) suivit soit d'un littéral (140), soit d'une variable (180), soit d'une expression entre parenthèses (100), soit une fonction (60) (Celle-ci doit retourner une valeur mais ça n'est pas à la grammaire de vérifier ce genre de choses).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
3            # litteral 3
-a           # opposé de la variable a
(3+9)        # expression entre parenthèses
f(3)         # fonction f avec pour argument 3

135. Un opérateur unaire est soit <MINUS>, soit <NOT>

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
-
!

140. Un littéral est un <LIT_LOGICAL>, un <LIT_INTEGER>, un <LIT_NUMERIC>, un <LIT_CHARACTER>, un factor (150), un ordered (160) ou un type composé (170).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
TRUE
2
-2.3
!FALSE
"Bonjour"
"F" in c("E","Z","F","P")
"B" in c("E"<"D"<"C"<"B"<"A")
list(1,"bonjour",TRUE,c(1,2))

150. Un factor est un <LIT_CHARACTER> qui fait parti d'un vecteur (non ordonnée) de <LIT_CHARACTER>

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

"F" in c("E","Z","F","P")

160. Un ordered est un <LIT_CHARACTER> qui fait parti d'un vecteur ordonnée de <LIT_CHARACTER>

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

"B" in c("E"<"D"<"C"<"B"<"A")

un vecteur (171), une suite (172), une list(173), une matrice (177) ou un dataFrame (178).

est un ensemble de littéraux (140) tous de même type et de même dimension pour les vecteurs, de même type pour les séries et de type quelconque pour les listes.
dans ce derniers cas, les listes sont naturellement toutes de même type et de même longueur, comme l'impose le vecteur).

170. Un type composé est un vecteur (171), une série (172)ou une liste (173). Cas particulier, un vecteur de vecteur s'appelle une matrix (177), un vecteur de liste s'appelle un dataFrame (178).
A noter, le type d'un vecteur n'est pas vecteur, mais vecteur d'integer ou vecteur de numeric,... De même, les listes sont typées : list(3,"H") est de type list d'integer et character. Ainsi, une tentative d'écriture de 3 dans le deuxième élément de la liste déclencherait une erreur (car le deuxième élément est de type character).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
c(1,3,2)                                               # Vecteur d'integer
series(c(1),c(2,3),c(2))                               # Series (tailles différentes) de vecteur d'integer
c(c("R","R"),c("A","B"),c("F","E"))                    # Vecteur de vecteur de character (ie matrix de character)
list(TRUE,"bon",c(1,2))                                # Liste de logical, character et vecteur d'integer
c(list("tres bon",FALSE,1),list(TRUE,"bon",2))         # Vecteur de liste, tous de même taille
dataFrame(c(FALSE,TRUE),c("tres bon","bon"),c(1,2))    # Idem, mais sous format dataFrame
list(c(FALSE,TRUE),c("tres bon","bon"),c(1,2))         # Liste de vecteur tous de même taille

Note : un dataFrame est un vecteur de liste, mais est stocké sous forme de liste de vecteur (plus simple et plus rapide) et est déclaré avec une syntaxe proche de la liste de vecteur. Cependant, l'acces aux éléments se fait comme un vecteur de liste. Ainsi, M[2,] sera le deuxième élément du vecteur (ie la deuxième liste, c'est à dire la deuxième ligne), M[,3] sera le troisième élément de chaque liste (ie la troisième colonne) et M[2,3] sera le troisième élément de la deuxième liste. Si M est une liste de vecteur, alors la notation serait inversée...

171. Un vecteur est un ensemble éventuellement vide d'expressions (175) toutes de même types et de même longueur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

c(1,3,2)                                               # Vecteur d'integer

172. Une suite est un ensemble éventuellement vide d'expressions (175) toutes de même types, mais pas nécessairement de même longueur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

series(c(1),c(2,3),c(2))                               # Series (tailles différentes) de vecteur d'integer

173. Une liste est un ensemble éventuellement vide d'expressions (175).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

list(TRUE,"bon",c(1,2))                                # Liste de logical, character et vecteur d'integer

175. Un ensemble d'expression est une expression suivit d'un nombre quelconque d'expressions séparée entre elles par des vigules.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

2+3,6,-a

177. Une matrice est un vecteur (171) de vecteur (171).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

matrix(c(1,2),c(2,4),c(4,5))

178. Un dataFrame est un vecteur (171) de liste (173). (Rappel : il est codé comme une liste de vecteur).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

dataFrame(c(1,2),c(TRUE,FALSE),c("A","B"))

180. Une variable est un <IDENTIFIANT> suivit optionnellement d'une liste d'expressions (175) entre crochets. Les arguments doivent être des entiers positifs, des vecteurs d'entier positif ou des vecteurs de logical (de même longueur que le vecteur auquel ils s'appliquent).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
nom
taille[3]
taille[c(TRUE,FALSE,TRUE)]
notes[1,]
notes[2,4]

3 Définition des token

3.0 Quelques règles

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

.                             # point est l'opérateur utilisé pour appliquer une fonction (méthode) à une variable toto.length(). On ne peut plus l'utiliser dans un nom de variable (comme on faisait dans R)

3.1 Expressions régulières

[[[Certains langages permettent d'utiliser les alphabets spécifiques dans les noms de variable (par exemple définir une variable "mariée". A terme, je pense que c'est une bonne chose à inclure.]]]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
letterMaj		[A-Z]
letterMin		[a-z]
letter			letterMaj | letterMin
digit			[0_9]
digitNotNul		[1_9]
other			é | è | ç | à | ê | ù
ascii			letter | digit | other

3.2 Littéraux

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
LIT_LOGICAL		TRUE | FALSE
LIT_INTEGER		("-"|"+")? (digitNotNul digit* | "0")
LIT_NUMERIC		LIT_INTEGER "." digit+ ("E" LIT_INTEGER)?
LIT_CHARACTER		QUOTE1 ascii* QUOTE1 | QUOTE2 ascii* QUOTE2 | QUOTE3 ascii* QUOTE3
LIT_VECTOR              "c"
LIT_SUITE               "suite"
LIT_LIST                "list"
LIT_DATAFRAME		"dataFrame"
LIT_MATRIX		"matrix"

3.3 Les mots clefs du langage

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
TYPE		type
T		t
IN		in
READFILE	readFile

3.4 Operateurs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
PLUS		+
MINUS		-
MULT		*
DIV		/

AND		AND
OR		OR
EQUAL		==
LOWER		<
NOT		!

3.5 Identifiants

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
IDENTIFIANT	letterMin (letter|digit)*
TYPE 		letterMaj (letter|digit)*

3.6 Ponctuation

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
COMMA		,
DOT		.
OPEN_PAR	(
CLOSE_PAR	)
OPEN_BRAC	[
CLOSE_BRAC	]
OPEN_ACC	}
CLOSE_ACC	}

QUOTE1		'
QUOTE2		"
QUOTE3		"""
ASSIGN		<-

4 Règles syntaxiques

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
10.  programme       -> instruction*
30.  instruction     -> definition | singleInstruc
33.  singleInstruc         -> useFunction    /*** V0.2 | structure | blocInstruction ***/
50.  definition        -> defineVariable /*** V0.2 defineFunction ***/
55.  defineVariable    -> variable (<COMMA> variable)* <ASSIGN> expression (<COMMA> expression)*
60.  useFunction       -> <KEY_FUNCTION> <OPEN_PAR> expression <CLOSE_PAR> |  expression

100. expression      -> valeur (operateurBin valeur)*
120. operateurBin    -> <PLUS> | <MULT> | <AND> | <OR> | <LOWER>
130. valeur          -> operateurUni? (litteral | variable | <OPEN_PAR> expression <CLOSE_PAR> | useFunction )
135. operateurUni    -> <NOT> | <MINUS>

140. litteral        -> <LIT_LOGICAL> | <LIT_INTEGER> | <LIT_NUMERIC> | <LIT_CHARACTER> | factor | ordered | typeCompose | matrix | dataFrame
150. factor          -> <LIT_CHARACTER> <IN> <LIT_VECTOR> <OPEN_PAR> <LIT_CHARACTER> (<COMMA> <LIT_CHARACTER>)* <CLOSE_PAR>
160. ordered         -> <LIT_CHARACTER> <IN> <LIT_VECTOR> <OPEN_PAR> <LIT_CHARACTER> (<LOWER> <LIT_CHARACTER>)* <CLOSE_PAR>
170. typeCompose     -> vecteur |suite |list
171. vecteur         -> <LIT_VECTEUR> <OPEN_PAR> listExpression? <CLOSE_PAR>
172. suite           -> <LIT_SUITE> <OPEN_PAR> listExpression? <CLOSE_PAR>
173. list             -> <LIT_LIST> <OPEN_PAR> listExpression? <CLOSE_PAR>
175. listExpression   -> expression (<COMMA> expression)* 
177. matrix          -> <LIT_MATRIX><OPEN_PAR> (vecteur (<COMMA> vecteur)*)? <CLOSE_PAR>
178. dataFrame       -> <LIT_DATAFRAME><OPEN_PAR> (vecteur (<COMMA> vecteur)*)? <CLOSE_PAR>
180. variable        -> <IDENTIFIANT> (<OPEN_BRAC> listExpression <CLOSE_BRAC>)?

5 Exemple de code R++ V0.1

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
  /*****************/
 /* types simples */
/*****************/

/* get et set */
majeur <- TRUE
age <- 18
age
taille <- 1.83
nom <- "Pierre"
metier <- "Cadre" in c("Agriculteur","Patron","Cadre","Ouvrier","Autres")
niveauDEtude <- "L1" in c("L1"<"L2"<"L3"<"M1"<"M2")
b1,b2,b3 <- TRUE,FALSE,!FALSE and TRUE

/* quelques méthodes */
type(nom)
type(age)
nom <- 18 /* [erreur de type]: nom est de type character, 18 est de type integer */

/* expressions logiques */

b1 and b2 and b3   /* Autorisé, evaluation de gauche à droite */
b1 and b2 or b3    /* non autorisé, mais plus tard */
majeur
permis <- FALSE
majeur and permis
2==3

/* expressions numeriques */
type(age)
age*2

/* chaines de caracters */
var <- "dichlorodiphényltrichloroéthane"
var


  /*****************/
 /* types répétés */
/*****************/

/* vecteurs basic */
ages <- c(15,12,19)
type(ages)

/* matrix */

notes <- matrix(
   c(1,2),
   c(3,4),
   c(5,6)
)


/* dataFrame */

age <- (17,20,19)
sexe <- ("Homme","Homme","Femme")
bac <- (FALSE,TRUE,FALSE)
dn <- (age,sexe,bac)
type(dn)

ages[3]
notes[2,1]
dn[2,3]

notes[,1]

dn2 <- readFile("myData.csv")

t(notes)
dn[,1]*2
t(notes) * notes

**P.Courtieu** · 30/08/2013, 15h27

Question:

Cette grammaire suggère qu'il n'y a pas de symbole de "fin d'instruction" dans les séquence (en C ou en java c'est le ";" par exemple). Est-ce vrai? Comment la fin d'une instruction est-elle détectée? On risque d'avoir des ambiguïtés, non?

Tout ceci est sans doute classique pour les habitués de R mais je n'en suis pas, mille excuses.

P.

**Christophe Genolini** · 30/08/2013, 15h38

A priori, je sais que dans R, le symbole de fin d'instruction est ";" mais il est optionnel sauf pour séparer deux instructions qui seraient sur la même ligne.

Je crois qu'en Python, la fin de ligne qui est utilisée comme séparateur : par contre, si une instruction doit tenir sur plusieurs lignes, il faut le préciser via "\".

Ceci étant dit, je pense qu'il doit être possible de faire une grammaire non ambigue sans préciser qu'une instruction est terminée, non ?

**haddad_malek** · 01/09/2013, 12h47

La 1ère fois que j'ai fait un if () then { } else { } en R, j'ai été surpris.
le "else" sur une nouvelle ligne signalait une erreur alors qu'il n'y avait pas d'erreur(s) à mon avis ...
En effet mettre le "else" après le } du if, sur la même ligne , a résolu le pb. La structure if () { } se terminant avec une saut de ligne LF (et un CR parfois) est une structure syntaxique "complète" et le passage à la ligne suivante commence une nouvelle structure syntaxique.
C'est différent des langages de prog. "classiques" (C, C++, java, perl ...) dont les instructions se terminent par un ";". D'autres langages permettent de poursuivre la structure syntaxique (ou des chaines) sur plusieurs lignes (avec "/", "+", ...) ou de séparer les structures syntaxiques (exemple des instructions d'affectation) par des ";", ":", ...

Pour résumer, la fin d'une instruction par ";" (explicitement) ou par un "CR/LF" (implicitement) devrait suffire. En fait cela doit dépendre du système d'exploitation (ou d'un traitement adéquat -comme pour les caractères séparateurs dans un chemin qui sont <> entre Windows et Unix).
Dans les langages "classiques" la fin d'une instruction se fait par ";" et dans de nombreux langages de script (Vbscript par exemple), il n'y a pas de fin d'instruction explicite.

Est-il possible d'avoir le source de R pour avoir plus d'informations et s'en inspirer s'il le faut ?

Autre point : concernant les structures de contrôle (if, while, repeat ...) on peut faire en sorte que ses structures se terminent avec endIf, endWhile, ... ce qui devrait enlever les ambiguïtés.

**haddad_malek** · 01/09/2013, 21h15

Il faudrait ajouter KEY_METHOD = method

Mais j'ai un doute, ici le mot clé vient juste remplacer le mot "function" de R (ou de C), en java il n'y pas de mot clé pour désigner une méthode (ou une fonction) et la notion de "function" n'est pas comprise mais seulement la méthode (...).

A moins d'une autre définition pour "function" ... qui viendrait plus tard.
Doit-on mettre un mot clé ?

**Christophe Genolini** · 02/09/2013, 17h52

Envoyé par haddad_malek

La 1ère fois que j'ai fait un if () then { } else { } en R, j'ai été surpris.

Lol, comme disent les jeunes. R est plein de "surprises", c'est une des raisons de l'existance de notre projet...

C'est différent des langages de prog. "classiques" (C, C++, java, perl ...) dont les instructions se terminent par un ";".

Personnellement, je trouve ca très énervant parce qu'on passe notre temps à ajouter des ";" qu'on a oublié (en tout cas, moi je les oublie tout le temps !)

D'autres langages permettent de poursuivre la structure syntaxique (ou des chaines) sur plusieurs lignes (avec "/", "+", ...) ou de séparer les structures syntaxiques (exemple des instructions d'affectation) par des ";", ":", ...

Oui, je préfère cette approche. C'est je crois ce que fait Python, non ?

Pour résumer, la fin d'une instruction par ";" (explicitement) ou par un "CR/LF" (implicitement) devrait suffire.

La encore, je pense que "CR/LF", c'est ce que fait Python.

Autre point : concernant les structures de contrôle (if, while, repeat ...) on peut faire en sorte que ses structures se terminent avec endIf, endWhile, ... ce qui devrait enlever les ambiguïtés.

Oui, la grammaire V0.2 intégre ce genre de fermeture de structure. L'autre possibilité est de faire comme en Python : la structure est fixée par l'indentation et non plus par un mot clef. J'ai d'ailleurs ouvert une discussion et un sondage à ce sujet : http://www.developpez.net/forums/d13...de-pythonquot/

Grammaire R++ V0.1

Langage R++

Discussions similaires

Partager

Partager