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

Haskell Discussion :

Comment réactualiser une liste ?


Sujet :

Haskell

  1. #1
    Membre à l'essai
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2014
    Messages
    34
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2014
    Messages : 34
    Points : 20
    Points
    20
    Par défaut Comment réactualiser une liste ?
    Bonjour

    Ma question porte sur la modification d’une liste en cours d’exécution d’un programme.

    Voici le contexte de cette problématique:

    1) Je suis débutant en Haskell, que j'étudie pour le plaisir. J'ai commencé un petit programme de géométrie plane,
    permettant d’afficher ( les figures sont exportées dans Gnu-TeXmacs ) des points, droites, cercles etc… Cela marche déjà assez bien.

    Parmi les éléments de constructions les plus élémentaires, il y a les points:

    Code haskell : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
      Type Coord = ( Float, Float )
      Data  Object = Point { label :: String, coords :: Coord}       
                         |   ....
                         |   ....

    Les points sont donc donnés par leur coordonnées et un label ( qui peut être affiché ).
    Object contient plusieurs autres objets géométriques pouvant être définis les uns à partir des autres par des étapes de construction successives.

    2) Durant l’exécution du programme ( par ghci ) l’utilisateur peut être amené à introduire d’autres points,
    - soit en directement, par exemple : pA = Point "A" (4,3) - soit en le définissant en tant qu’intersection ( droites , cercles ...) , ou par d'autres propriétés .

    3) Tout point doit permettre de définir d’autres objets géométriques.
    C’est pourquoi il serait souhaitable de connaitre à chaque étape la liste des points définis.
    On peut poser par exemple par

    Code haskell : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
      listpoints :: [ Object ]
      listpoints = [ ]

    Pour la liste initiales des points.
    Pour ajouter des éléments à cette, on peut faire une manip du genre :

    Code haskell : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
      temp = listpoints
      listpoint = pA : temp

    le problème est que j’aimerais que cette réactualisation de listpoint se fasse automatiquement lors de l’introduction
    d’un nouveau points de construction ( telle que exposée en (2) ).

    Avec Mathematica cela pourrait se faire ainsi :

    Code haskell : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
      listpoint = {}
      defpoint[newpt_] := 
         With[ {label = Input["nom du point"], coord = Input["label"]}, 
            newpt = {label, coord}; 
            listpoint = Prepend[listpoint, newpt]  ]

    mais un tel bricolage ne semble pas possible en programmation fonctionnelle !
    Alors comment faire ? Avez-vous des idées ? Toute suggestion est bienvenue...

  2. #2
    Expert éminent
    Avatar de Jedai
    Homme Profil pro
    Enseignant
    Inscrit en
    avril 2003
    Messages
    6 245
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : avril 2003
    Messages : 6 245
    Points : 8 560
    Points
    8 560
    Par défaut
    Ce que tu demandes est complètement contraire à la philosophie fonctionnelle (et à un certain nombre de bonnes pratiques même dans le paradigme impératif) : tu veux une modification de l'état global et tu veux même qu'elle soit "automatique", autrement dit "cachée". Haskell est un langage de programmation fonctionnelle pure et les mécanismes nécessaires à ta demande sont donc indisponibles par défaut (je ne dirais pas que c'est vraiment impossible, si tu es près à utiliser des fonctions "unsafe").

    A la place, je te propose de changer ton modèle : tes Object pourraient être composés de plusieurs Objects (dont des points, cercles et autres) et tu créerais une fonction listPoints :: Object -> [Object] :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    data Object = Point {..} | Circle {label :: String, center :: Object, radius :: Float } | ... | Figure [Object] 
     
    listPoints :: Object -> [Object]
    listPoints p@(Point {}) = [p]
    listPoints (Circle _ p _) = [p]
    ...
    listPoints (Figure fs) = concatMap listPoints fs
    Ceci a plusieurs avantages : non seulement tu peux avoir plusieurs figures dans un même programme sans mélanger leurs points mais tu peux garder plusieurs versions d'une même figure, transformer toute une figure avec la transformation souhaitée (symétrie, rotation,...) et réunir des figures (par simple superposition ou en modifiant les coordonnées pour qu'elles soit côte côte, etc).

    --
    Jedaï

  3. #3
    Membre à l'essai
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2014
    Messages
    34
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2014
    Messages : 34
    Points : 20
    Points
    20
    Par défaut
    Merci Jedaï , ta réponse répond parfaitement à mon attente, et même plus ...
    car non seulement elle résout le problème, mais elle montre aussi une autre perspective, très intéressante et beaucoup plus élégante.

  4. #4
    Membre à l'essai
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2014
    Messages
    34
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2014
    Messages : 34
    Points : 20
    Points
    20
    Par défaut
    Je peux à présent avoir la liste des points de toutes les figures que je construit. Cela marche parfaitement.

    Par contre, je ne peux pas avoir la liste des points disponibles, ce qui n’est pas la même chose.
    A moins de considérer comme une figure toute nouvelle configuration ( dans l’ensemble des objets définis ) …
    Mais dans ce cas, peut-on éviter cette malheureuse modification automatique de l'état global ?

    Pour poser ma question autrement : est-il possible d’avoir à disposition la liste des points définis avec leurs coordonnées telle qu'on la trouve dans les logiciels de géométrie dynamique ( comme Géogébra ) ?
    J’ai installé FLKT ( https://hackage.haskell.org/package/fltkhs ) et j’aimerais faire apparaitre une telle liste dans une fenêtre.

  5. #5
    Expert éminent
    Avatar de Jedai
    Homme Profil pro
    Enseignant
    Inscrit en
    avril 2003
    Messages
    6 245
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : avril 2003
    Messages : 6 245
    Points : 8 560
    Points
    8 560
    Par défaut
    Je ne suis pas sûr de bien comprendre... A priori dans ton logiciel, tu es en train de bâtir une figure (par instance/fenêtre de ton application ?), elle devrait être accessible à ton programme (peut-être dans une IORef ? ou une (T)(M)Var si tu utilises plusieurs fils d'exécution) et tu devrais pouvoir afficher la liste des points qui la constitue. Un raffinement probablement nécessaire serait d'utiliser un ensemble (Data.Set) de points plutôt qu'une liste car il est vraisemblable qu'un même point soit réutilisé plusieurs fois dans une figure.
    Toute opération modifiant ta figure devrait déclencher le rafraîchissement des vues en dépendant (dont la liste des points disponibles).

    Si cela ne t'aide pas, il me faudra plus de détails sur ce que tu cherches à faire et idéalement l'accès à ton code.

  6. #6
    Membre à l'essai
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2014
    Messages
    34
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2014
    Messages : 34
    Points : 20
    Points
    20
    Par défaut
    Bonjour Gedaï,

    Finalement mon problème est résolu.
    Je vais essayer de le reformuler et de donner la solution que j'ai trouvé.

    Reformulation

    Le but est non seulement d’exporter des figures, mais de pouvoir en construire par étapes successives
    Chaque étape peut faire apparaitre de nouveaux points, qui peuvent ou non être exploités dans les étapes ultérieures.


    C’est pourquoi je cherchais une liste des points ( et pourquoi pas aussi une liste des droites, une liste des cercles … ) se réactualisant continuellement, et pouvant être affichée dans une fenêtre séparée.
    Mais comme tu l’as dis cela est complètement contraire à la philosophie fonctionnelle.

    Solution

    A chaque création d’une figure correspond une chaine de caractère qui code la figure dans TeXmacs.
    Qu’il n'y ait qu’une seule étape ou plusieurs , on considère toute étape exportée dans la fenêtre comme des figures.
    Pour chaque figure on peut connaitre la liste des points grace à listPoints


    donc j’ai défini :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    class ToTM a where
          objectTm :: a -> String
     
    instance ToTM Object where
             objectTm ( Point _ coords ) = …
             objectTm ( Line ….  ) = …
    c’est à dire qu’à chaque sorte d’objet ( Point, Ligne etc.. ) correspond une chaine de code interprétable par GNU TeXmacs.


    Puis

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    let tmeg :: [Object] -> IO ()
        tmeg set = do
           exportTM "FroHaskell" $ graphicTm $ tobj set
           writeFile "/Users/Ordi/Desktop/listpt.txt" $ objectTm $ Figure set
    qui permet simultanément :
    - d’exporter la chaine d’une construction corresponddant à une ensemble d’objets [Object] dans un fichier d’entension tm.
    - d’exporter les labels et les coordonnées de chaque point utilisé, informations extraites de listPoints [Object] dont tu m’as donné la recette ( dans un fichier txt ).

    En tout cas cela marche.
    Le but final n’est évidemment pas avoir ces labels et ces points dans un fichier txt, mais d’être capable de les ré-utiliser avec FLKT.

    Il me reste à étudier comment FLKT fonctionne
    ( pour le moment j’arrive juste à créer un petit bouton qui passe de «*Bonjour*» à «*Au-revoir » lorsque l’ on presse dessus )

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Comment récupérer la liste des contacts de outlook express?
    Par arnaud_verlaine dans le forum Outlook Express / Windows Mail
    Réponses: 6
    Dernier message: 12/10/2004, 15h53
  2. [PDFBox]Comment manipuler une LIST
    Par marcotop dans le forum Documents
    Réponses: 11
    Dernier message: 27/08/2004, 15h46
  3. [MAP] comment récupérer la liste des clé ordonnées
    Par Alec6 dans le forum Collection et Stream
    Réponses: 7
    Dernier message: 21/07/2004, 16h37
  4. Comment récupérer la liste des logiciels installés sur une machine ?
    Par david_chardonnet dans le forum API, COM et SDKs
    Réponses: 3
    Dernier message: 19/09/2003, 17h41
  5. Comment obtenir la liste des paramètres d'une SP ?
    Par Le Gritche dans le forum MS SQL Server
    Réponses: 2
    Dernier message: 14/03/2003, 16h54

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