IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Caml Discussion :

val mutable [x; y] : syntax error


Sujet :

Caml

  1. #1
    Membre à l'essai
    Profil pro
    Étudiant
    Inscrit en
    Octobre 2006
    Messages
    17
    Détails du profil
    Informations personnelles :
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Octobre 2006
    Messages : 17
    Points : 11
    Points
    11
    Par défaut val mutable [x; y] : syntax error
    Bonjour, je me trompe peut-être à chaque ligne en essayant d'utiliser une liste pour me créer une classe point :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    class point x_init y_init =
       object 
         val mutable [x; y] = [x_init; y_init]
         method get_x = [x; _]
         method get_y = [_; y]
         method set_x x1 = [x; _] <- [x1; _]
         method set_y y1 = [_; y] <- [_; y1]	
         method translate x1 y1 = [x; y] <- [x+x1; y+y1]
         method move_to x1 y1 = [x; y] <- [x1; y1] 
         method draw = Gr.plot x y		
       end;;
    j'obtiens une "syntax error" ici : Ca doit être évident, mais je débute en ocaml ^^, quelle est mon erreur ?

  2. #2
    alex_pi
    Invité(e)
    Par défaut Ceci est une réponse à coté de la plaque
    Hi MrGecko !

    Je ne suis pas franchement un pro de la partie objet de OCaml, donc je ne peux pas particulièrement t'aider dans ce domaine, mais je vais tenter de te mettre sur la voie : Une liste n'est pas faites pour stocker un nombre donné d'élements. Pour celà, il y a les tuples. Pour la paire par exemple, la syntaxe est (x, y). Mais en l'occurence, vu que tu accèdes plutôt séparement à chaque composante de ton point, pourquoi ne pas plutôt avoir deux attributs abscisse et ordonnée ?

    En revanche (et c'est là que la réponse commence à être completement à coté de la plaque), si tu es vraiment un débutant en OCaml, crois moi, tu ne *veux pas* commencer par les objets ! Ce n'est clairement pas la meilleure part d'OCaml...

    Tu peux plutôt faire un truc comme :
    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
     
    (*** Définition de la signature ***)
    module type TypePoint = 
    sig
      type t
      val new_t : int -> int -> t
      val get_x : t -> int
      val get_y : t -> int
      val set_x : t -> int -> unit
      val set_y : t -> int -> unit
      val translate : t -> int -> int -> unit
      val move_to : t -> int -> int -> unit
    end
     
    (*** définition du module ***)
    module Point:TypePoint = 
    struct
      type t = {mutable x : int;
    	    mutable y : int}
     
      let new_t x y = {x = x; y = y}
      let get_x t = t.x 
      let get_y t = t.y 
      let set_x t x1 = t.x <- x1
      let set_y t y1 = t.y <- y1
      let translate t x1 y1 = 
        t.x <- t.x + x1; 
        t.y <- t.y + y1
      let move_to t x1 y1 =
        t.x <- x1; 
        t.y <- y1
    end
    C'est la définition de la signature du module (qui est inféré automatiquement par "ocamlc -i", puis "tuné" pour cacher certaines choses) qui permet l'encapsulation. Si dans la suite du code tu ouvres le module (open Point), tu pourras faire "let p = new_t 3 4", mais tu ne pourras pas faire "p.x", car la signature cache le fait que le type "t" est une structure avec deux enregistrements. Donc si un jour tu veux la changer, pas de problème.
    Et supposons que tu te dises "oui mais parfois, mais points ont des coordonnées flottante" ? et bien c'est là que la magie des foncteurs entre en jeu :
    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
     
    (*** signature du module argument ***)
    module type Coord = 
    sig
      type t
      val add : t -> t -> t
    end
     
    (*** signature du module point ***)
    module type TypePoint = 
    sig
      type coord
      type t
      val new_t : coord -> coord -> t
      val get_x : t -> coord
      val get_y : t -> coord
      val set_x : t -> coord -> unit
      val set_y : t -> coord -> unit
      val translate : t -> coord -> coord -> unit
      val move_to : t -> coord -> coord -> unit
    end
     
    (*** définition du foncteur. 
       Prend en argument un module C de signature Coord
       et produit un module signature TypePoint avec coord = C.t ***)
    module MakePoint (C:Coord) : TypePoint with type coord = C.t = 
    struct
      type coord = C.t
      let (+) = C.add
      type t = {mutable x : coord;
    	    mutable y : coord}
     
      let new_t x y = {x = x; y = y}
      let get_x t = t.x 
      let get_y t = t.y 
      let set_x t x1 = t.x <- x1
      let set_y t y1 = t.y <- y1
      let translate t x1 y1 = 
        t.x <- t.x + x1; 
        t.y <- t.y + y1
      let move_to t x1 y1 =
        t.x <- x1; 
        t.y <- y1
    end
     
    (*** exemple avec les entier ***)
    module CoordInt = 
    struct
      type t = int
      let add = (+)
    end
     
    module PointInt = MakePoint (CoordInt)
     
    (*** let les flotants ***)
    module CoordFloat = 
    struct
      type t = float
      let add = (+.)
    end
     
    module PointFloat = MakePoint (CoordFloat)
    Les foncteurs étaient quelque chose qui me "faisait peur" il y a peu, mais maintenant que j'ai vraiment découvert, c'est un vrai bonheur !

    Bref, pour résumer, familiarise toi d'abord avec les types, l'approche fonctionnelle, le polymorphisme, les modules, les foncteurs... Et il sera temps à ce moment de s'attaquer aux objets :-)

  3. #3
    Membre émérite
    Avatar de SpiceGuid
    Homme Profil pro
    Inscrit en
    Juin 2007
    Messages
    1 704
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loire (Rhône Alpes)

    Informations forums :
    Inscription : Juin 2007
    Messages : 1 704
    Points : 2 990
    Points
    2 990
    Par défaut
    +1

    Ton apprentissage d'OCaml doit se conclure par les foncteurs et les classes. Il doit commencer par les tableaux (approche impérative) ou les listes (approche fonctionnelle).

    Si tu es un débutant alors aide toi d'un tutoriel, par exemple (en français):
    http://pauillac.inria.fr/~quercia/cd...s/cours.pdf.gz

    Et là tu vas vite comprendre la puissance de OCaml puisque déjà au 1er chapitre, paragraphe 4, l'auteur donne une implémentation OCaml de la multiplication Knuth-Karatsuba.
    Du même auteur: mon projet, le dernier article publié, le blog dvp et le jeu vidéo.
    Avant de poser une question je lis les règles du forum.

  4. #4
    Membre à l'essai
    Profil pro
    Étudiant
    Inscrit en
    Octobre 2006
    Messages
    17
    Détails du profil
    Informations personnelles :
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Octobre 2006
    Messages : 17
    Points : 11
    Points
    11
    Par défaut
    pour résumer, familiarise toi d'abord avec les types, l'approche fonctionnelle, le polymorphisme, les modules
    j'ai suivi un cour la dessus cette année, en caml light.
    je voulais simplement utiliser une liste pour éviter de faire
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     val mutable x = x_init
    val mutable y = y_init
    et pour me refmiliariser avec les listes, mais apparement ce n'est pas le bon choix, j'étais moi-même très hésitant, voilà pourquoi je suis venu.

    merci pour ton lien SpiceGuid, bien que me faisant frissoner par son approche académique, il me sera surement très utile, j'ai commencé à lire les premiers chapitres, il ne me reste plus qu'à en tenir compte ^_^;

    J'avais même totalement zappé qu'il y'avait déjà un type Point.

  5. #5
    Membre émérite
    Avatar de SpiceGuid
    Homme Profil pro
    Inscrit en
    Juin 2007
    Messages
    1 704
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loire (Rhône Alpes)

    Informations forums :
    Inscription : Juin 2007
    Messages : 1 704
    Points : 2 990
    Points
    2 990
    Par défaut
    Pour faire simple: oui tu te trompe à chaque ligne en croyant que les éléments d'une liste peuvent être mutable, une liste est une structure immutable.

    Ne fais pas l'erreur de croire que la principale nouveauté de OCaml c'est la POO, OCaml apporte trois principales nouveautés:
    • la compilation en code natif
    • un système de module
    • les variants polymorphes


    Tu dois utiliser OCaml pour l'une de ces trois raisons.
    Si tu as absolument besoin de code reuse (c'est le slogan de la POO) tu peux utiliser des variants polymorphes: voir code reuse.
    Du même auteur: mon projet, le dernier article publié, le blog dvp et le jeu vidéo.
    Avant de poser une question je lis les règles du forum.

  6. #6
    Nouveau membre du Club
    Inscrit en
    Mars 2007
    Messages
    42
    Détails du profil
    Informations forums :
    Inscription : Mars 2007
    Messages : 42
    Points : 39
    Points
    39
    Par défaut
    Je suis à peu près d'accord avec tout ce qui a été dit ; cependant, on ne peut pas entièrement se passer de la partie objet d'Ocaml, ne serait ce que parce que Lablgtk l'utilise (ce qui la rend assez délicate à appréhender...) mais aussi parce que ça peut être plus "naturel" pour certaines applications, je pense au GUI en fait. Oui, Lablgtk est un GUI.
    En revanche débuter par la POO Ocaml n'est pas forcément l'idéal.

    Sinon ton programme ne compile pas, parce que tu associes une val (variable) à la déconstruction d'une liste, ce qui n'est pas faisable, je crois.
    Val n'est pas Let...

    Préfère les uplets (ou tupple) aux listes, pour la déconstruction.

  7. #7
    Membre éprouvé
    Avatar de InOCamlWeTrust
    Profil pro
    Inscrit en
    Septembre 2006
    Messages
    1 036
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2006
    Messages : 1 036
    Points : 1 284
    Points
    1 284
    Par défaut
    Citation Envoyé par SpiceGuid
    Pour faire simple: oui tu te trompe à chaque ligne en croyant que les éléments d'une liste peuvent être mutable, une liste est une structure immutable.
    Non, il faut être précis dans les mots : ce sont les listes elles-mêmes qui ne sont pas modifiables. Si un élément d'une liste est un structure avec champs modifiables ou une référence (ce qui est la même chose), la valeur de cet élément devient modifiable.

    Citation Envoyé par SpiceGuid
    Ne fais pas l'erreur de croire que la principale nouveauté de OCaml c'est la POO
    Si, justement, la principale nouveauté d'OCaml est sa couche objet, qui apporte énormément de nouveautés par rapport à ce qui se faisait (et ce qui se fait toujours) ailleurs... entres autres, le sous-typage sans héritage et les objets fonctionnels sont deux concepts très intéressants.

    Citation Envoyé par SpiceGuid
    OCaml apporte trois principales nouveautés :
    la compilation en code natif
    ... que l'on trouvait déjà dans Caml Special Light, donc avant OCaml.

    Citation Envoyé par SpiceGuid
    un système de module
    ... que l'on trouvait déjà dans Caml Light, mais en moins riche.

    Citation Envoyé par SpiceGuid
    les variants polymorphes
    ... pas franchement une nouveauté, et surtout une chose à l'intérêt très limité en pratique. Si je ne me trompe pas, je crois que OCaml (c'est-à-dire tout le système, compilateurs compris) a lui-même été écrit sans type polymorphe.

    Citation Envoyé par SpiceGuid
    Tu dois utiliser OCaml pour l'une de ces trois raisons.
    Si tu as absolument besoin de code reuse (c'est le slogan de la POO) tu peux utiliser des variants polymorphes: voir code reuse.
    Le type polymorphe est à utiliser avec modération. On perd toutes les bonnes propriétés dûes au typage statique et le code s'en retrouve fragilisé, car l'analyse est moins précise. ca peut être très utile dans certains cas très précis, mais en général, je pense que l'approche classique mêlée à de l'objet utilisé à bon escient est bien meilleure.
    When Colt produced the first practical repeating handgun, it gave rise to the saying God created men, but Colt made them equal.

  8. #8
    Membre émérite
    Avatar de SpiceGuid
    Homme Profil pro
    Inscrit en
    Juin 2007
    Messages
    1 704
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loire (Rhône Alpes)

    Informations forums :
    Inscription : Juin 2007
    Messages : 1 704
    Points : 2 990
    Points
    2 990
    Par défaut
    En effet, c'est la structure d'une liste qui n'est pas modifiable, les éléments d'une liste sont modifiables si ce sont des references (ref) ou si certains champs sont mutable.
    Du même auteur: mon projet, le dernier article publié, le blog dvp et le jeu vidéo.
    Avant de poser une question je lis les règles du forum.

Discussions similaires

  1. [Configuration] Problème après l'installation (Parse error: syntax error,..)
    Par beur dans le forum EDI, CMS, Outils, Scripts et API
    Réponses: 8
    Dernier message: 21/03/2006, 15h08
  2. syntax error
    Par ludovik dans le forum C
    Réponses: 5
    Dernier message: 18/03/2006, 22h32
  3. Syntax error
    Par vincedjs dans le forum Langage
    Réponses: 3
    Dernier message: 01/02/2006, 17h58
  4. Syntax Error / Questions
    Par kedare dans le forum Général Python
    Réponses: 15
    Dernier message: 12/09/2005, 15h05
  5. "vector" provoque "syntax error", malgré
    Par seenkay dans le forum Autres éditeurs
    Réponses: 5
    Dernier message: 24/08/2003, 04h21

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