Discussion :

[bbertrand]

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...

[Jedai]

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ï

[bbertrand]

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.

[bbertrand]

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.

[Jedai]

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.

[bbertrand]

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 )