Discussion: Grammaire R++ V0.1

  1. #1
    Membre éclairé

    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    septembre 2007
    Messages
    200
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Santé

    Informations forums :
    Inscription : septembre 2007
    Messages : 200
    Points : 714
    Points
    714

    Par défaut Grammaire R++ V0.1

    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.
    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). ]]
    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 :
    1. 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
    2. 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.
    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>
    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.
    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

  2. #2
    Membre à l'essai
    Homme Profil pro
    Inscrit en
    août 2013
    Messages
    7
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : août 2013
    Messages : 7
    Points : 10
    Points
    10

    Par défaut

    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.

  3. #3
    Membre éclairé

    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    septembre 2007
    Messages
    200
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Santé

    Informations forums :
    Inscription : septembre 2007
    Messages : 200
    Points : 714
    Points
    714

    Par défaut

    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 ?

  4. #4
    Membre à l'essai
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    août 2013
    Messages
    10
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Service public

    Informations forums :
    Inscription : août 2013
    Messages : 10
    Points : 13
    Points
    13

    Par défaut instruction ... et fin de structure

    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.

  5. #5
    Membre à l'essai
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    août 2013
    Messages
    10
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Service public

    Informations forums :
    Inscription : août 2013
    Messages : 10
    Points : 13
    Points
    13

    Par défaut Manque la définition du mot clé "method"

    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é ?

  6. #6
    Membre éclairé

    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    septembre 2007
    Messages
    200
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Santé

    Informations forums :
    Inscription : septembre 2007
    Messages : 200
    Points : 714
    Points
    714

    Par défaut

    Citation Envoyé par haddad_malek Voir le message
    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/

Discussions similaires

  1. [LambdaProlog] grammaire en Java
    Par khokho dans le forum APIs
    Réponses: 3
    Dernier message: 04/07/2005, 11h26
  2. grammaire yacc lex simili C
    Par BigBarbare dans le forum Autres éditeurs
    Réponses: 1
    Dernier message: 16/05/2005, 22h40
  3. Décomposition d'une propriété : grammaire ?
    Par mathieu dans le forum Général Algorithmique
    Réponses: 3
    Dernier message: 04/05/2004, 10h47
  4. Réponses: 2
    Dernier message: 21/05/2002, 11h25

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo