Bonjour tout le monde,
 
   Voilà, j'ai lu quelque part qu'il manquait un topic sur le scheme (si, si !). Justement, ce n'en sera pas un. Nous avons réflechi avec Chronoklazm (si il me permet de le citer), que faire connaître le scheme au travers d'un petit exemple sera plus pédagogique et, peut être cela suscitera-t-il des vocations. Pour celui qui cherche un langage à apprendre, ce sera un exemple concret, il pourra voir si il "sent" ce langage ou non. Pour celui qui programme déjà gageons que cela le changera de Fibonacci et autres algorythmes barbares.
 
  Nous allons donc concevoir un répertoire téléphonique. Celui-ci sera pourvu d'une interface graphique, de "champs" de base tels : Nom, Prénom, Adresse, Télephone (fixe,travail,portable), adresse de courriel. Ces derniers pourront être complétés par une photo, des rendez-vous communs,... cela sera à discuter.
  Pour la structure des données, nous pouvons choisir entre les ABC (arbre binaires de consultation), une a-liste et les éléments pourront être des structures.
 
  Ce qui me paraît important est que celui qui veut contribuer, le fasse selon ce qu'il sait le plus faire :qui sera plus porté sur les a-listes, qui sur les vecteurs,... A cet effet, chaque contributeur explicitera son code. Je me charge de faire le tri (allez-y molo quand même).
 
D'abord, un peu d'historique et une brève présentation de Scheme (Merci à Chronoklazm):
Presentation :
 
  Scheme est un langage de programmation, fonctionnel et imperatif, il est le dernier representant en date de la famille de Lisp dont il hérite syntaxiquement (niveau 3 dans l'échelle d'abstraction). Crée dans les années 70 par par Gerald Jay Sussman et Guy L. Steel dans le but d'épurer le Lisp tout en lui conservant sa spécificité. "C'est un langage réduit à l'essentiel et pourtant fortement expressif"(J. Chazarin). Il est utilisé à des fins d'enseignement, peu dans le monde professionnel.  
 
Pourquoi Scheme ?  
 
  Au départ, il fut appelé Schemer dans la tradition des langages d'IA, mais le système d'exploitation ITS limitait les noms de fichiers à 6 lettres. C'est donc devenu Scheme.
 
Les qualités de ce langage sont (liste non-exhaustive) :
 
   - Comprendre comment "ça" marche et debuter la prog.
   - Une syntaxe assez simple.
   - Differents IDE gratuits (dont Drscheme et Bigloo).
   - Une multitude de libraires annexes.
 
Plus en detail :  
 
   - Fonctions recursives locales.
   - Fonctions d'arité variable.
   - Fonctions d'ordre supérieur, curryfication, ...
   - Gestion de la POO (heritages multiples, polymorphisme ...)
   - Gestion des continuations.
   - Programmation "lazy" : méchanismes d'évaluation paresseuse.  
   - Possibilité de definir ces propres structure de contrôle.
   - Lexeur et Parseur fournis (drscheme)
   - Programmtion symbolique (IA par exemple)
   - Liaison statique (comme en C, Java ... mais pas en Lisp !)
   - Reflexif.
   - Typage faible (quasi inexistant).
   
 Il y a des inconvenients bien entendu, ce sont la performance car Scheme est un langage pour la plupart du temps interpreté et non compilé (quoique Bigloo bat gcc sur certains calculs) ainsi que les parentheses auxquelles il faut s'habituer.
 
 Dans un adage il est écrit "il suffit de connaitre 2 langages de programmation pour être capable de comprendre tous les langages".  
  - FORTRAN (1955) Ces proprietes sont la programmation numerique et la programmation imperative (manipulation explicite de la mémoire).
  - LISP (1958) Ces proprietés sont la programmation symbolique (I.A. par exemple) et la programmation imperative et aussi fonctionelle (implementation du lambda-calcul) ou au lieu d'affecter une variable on substitue sa valeur.
 
Quelques petits liens pour commencer
 
  Mais déjà voyons nous poindre le souci des implémentations de scheme entre :
                    -DrScheme de PLT: www.drscheme.org
                    -STk            : http://kaolin.essi.fr/STk/
                    -Open-scheme    : www.open-scheme.com
                    - D'autres : guile, bigloo : http://www-sop.inria.fr/mimosa/fp/Bigloo/
nous risquons de ne plus nous y retrouver. Donc, si vous contribuez, indiquez, ce que vous utilisez et ce que vous faites (et idem le tri pour bibi).
 
   J'avais oublié, allez par là aussi: http://www.schemers.org/
 
  Pour l'interface graphique: http://mreddesigner.lozi.org , mais rien ne vous empêche de la faire en GTK, seulement indiquez clairement la méthode pour arriver au résultat (arguments de compil,...). Il n'y a rien de plus énervant pour un débutant que de taper deux pages de code et se planter dans la finalisation.
 
  Ca peut aussi servir :  
 
http://schemecookbook.org/  :comme c'est écrit dessus.
http://mitpress.mit.edu/sicp/  
http://users.info.unicaen.fr/~marc/ens/deug/cours.html
http://www.htdp.org/ : une référence
 
Qu'est ce qu'on fait dans ce topic ?
 
 -> On va tenter de vous initier à différents points théoriques importants (doublets,structures, CPS,...)
 -> On fait un Super_annuaire (code complet (bientôt) page 2. Mais il est interessant de lire son évolution).
 ->Chronoklazm nous a fait une simulation d'un élastique avec interfaçage graphique en opengl (page 2)
 -> Encore d'autre choses à venir.
               ---------------------------------------------
  J'oubliais, il serait intéressant d'avoir une architecture modulaire, comme ça on s'y retrouvera mieux.
 
  Voilà pour l'intro, j'espère avoir été clair. Les spécifications plus détaillées du programme viendront au fur et à mesure et les suggestions sont les bienvenues. Messieurs, à vos claviers. Et un grand merci à Chronoklazm   qui, s'il le désire doit être associé à cette création de topic. (Si ça devient le brin, j'assumerai seul).

Le premier "cours" est enfin disponible. Il n'a pas la prétention de remplacer ce que vous pouvez voir avec vos prof, ni prendre la place d'un bon bouquin. Nous allons simplement tenter d'éclaircir les choses en vous donnant des exemples simples. Ces cours doivent vous aider, alors à vous aussi de nous dire ce que vous ne comprenez pas. Ces chapitres, comme toute autre chose peuvent être amenés à évoluer. Repassez par la case départ de temps en temps.
 
Les doublets
 
Définitions:
    Une S-expression: Une S-expression n'est autre que toute expression syntaxiquement correcte en scheme. Cela peut être un nombre, une chaîne, une succession de S-expression entre 2 parenthèses (S-exp1 ... S-exp2).  
     
    Le doublet est un couple de valeur de S-expressions. En fait en construisant un doublet,nous construisons notre premier élément composé. C'est aussi, en terme d'abstraction, le "père" de la liste, qui n'est qu'un cas particulier d'un doublet.
 
     Constructeur : c'est la primitive cons. Exemples de construction: (cons 1 2), si 'x et 'y sont des symboles (cons 'x 'y), (cons 1(cons 2 3).
Accesseurs (pointeurs): car et cdr. Ou si vous préférez un style plus Lisp (first et rest).  
      Représentation: sous forme de paire pointée
 
Ex: Nos exemples précédents nous donnent: (cons 1 2)->(1 . 2); (cons 'x 'y)->(x . y) et le dernier (1 .(2 . 3))
 Ou aussi (define a (cons 1 2)) . Tapez en console: a -> (1 . 2)  
 Pour acceder aux valeurs le car du doublet (le premier élément): (car(cons 'x 'y)) -> x
                          le cdr du doublet (le deuxième élément): (cdr(cons 'x 'y)) -> y
Je vous laisse trouver la suite: (car a) (cdr a) ou (first a) (rest a)
 
Représentation sous forme d'arbre:  
    doublet (a . b)  /\          doublet ((a . b) . c)  /\
                         /  \                                     /  \
                        a    b                                 /\   c
                                                              a  b
Avec des assemblages de doublets, nous pouvons construire des structures de données complexes. En fait, rien qu'avec cela, vous pouvez modéliser à peu près ce que vous voulez (structure d'une protéine, syntaxe d'un langage,...).
 
Avec les doublets, on peut définir des listes d'association ou a-listes qui sont des listes de doublets. Cela permet de représenter des données comme les tables, les entrées de dictionnaire,...
 
 Voici une petite représentation visuelle du doublet: [bientôt une image]
 
 Comme cela vous a été présenté un peu plus haut, il est possible de construire une liste avec la fonction cons:
 =>(cons x (cons y '()))
(x y)
Mot à mot ca veut dire le car est x et le cdr pointe vers un autre doublet dont le car est y et le cdr est vide.  
Ce qui revient exactement à faire (list x y) ou encore '(x y). Attention, en Scheme l'apostrophe devant des parenthèses signifie list: "(list 1 2) eqv '(1 2)" . Mais un apostrophe en dehors de ce cas donne un symbole: 'a -> a; '('a) est équivalent à (list(quote a)) et est différent de (list 'a). Mais nous reviendrons peut-être sur les listes un peu plus tard.
 
Quelques exemples:
 
1- Association simple:
  Plus bas dans le topic, Chronoklazm nous propose de créer une correspondance entre les pays et leur code international:
 

2- On peut y faire du calcul numérique
  Vous voulez calculer votre moyenne et vous rememorer les notes que vous avez eues cette année:  

essayez (assoc "Anglais" list_notes). Magique. Vous avez assoc, assov et assq qui sont les pendants d'equal?, eq? et eqv? pour les nombres.
 
  La moyenne :
 

 
Si vous avez des coefficients la structure pourrait être la suivante ("Anglais" . (note . coef)).  
 
  Lorsque les structures deviennent complexes, on se perd vite dans les car de cdr de caar,... Ce que je fais, c'est de prendre par la fin, ce que je cherche. Par exemple je veux connaître les coef de l'Anglais. Dans ma structure, le coef est le deuxième élément du doublet (note . coef). C'est donc un cdr. Cet ensemble appartient au doublet (matière . (note.coef)) et c'est le deuxième élément de ce doublet: c'est encore un cdr. On repasse tout à l'endroit, de gauche à droite (sens de la lecture, même pour l'ordi) ce qui nous donne, pour acceder au coef(cdr(cdr liste_notes))).  
 
  Une autre petite mise au point intéressante à faire et qui nous est pointée par Chronoklazm (j'y avais pas prêté attention), c'est la différence de style entre le Scheme de Drscheme et le style MIT. Exemple :  
(define (nom-nonction param1 param2 ...) corps de la fonction ...) => Style DrScheme  
 equivaut à  
(define nom-fonction (lambda (param1 param2 ...) (corps de la fonction ...)) => Style MIT . Au cas ou vous poseriez quelques questions sur les différences vues entre différents bouquin.
 
Des questions?

Ici sera le code proprement dit

Vrac, pour l'instant. Je me permets cette méthode, mais d'ici peu j'espère que çà aidera à la visibilité de ce chapitre.

Bon on commence doucement avec quelques fonctions tres simples, pas d'interface graphique pour le moment :
 
!! Pour comprendre un minimum il faut connaitre le comportement des primitives de bases (car, cdr, list, map et son equivalent for-each, assoc, set! ...) !!
 
! Attention en Scheme le passage des parametres se fait par COPIE (on dit aussi "appel par valeur" ~ "call by value" ) !
 
!!! Il ne faut pas comprendre de travers ce qui precede. Lorqu'un parametre d'une procedure est une liste (ou un vecteur ou une string), ce qu'on passe à la procedure est bien un POINTEUR: l'adresse de cette liste en memoire. On PEUT donc modifier l'interieur de l'objet de maniere definitive dans la procedure, mais pas l'adresse de son point d'entrée. Comme en Java ... !!!
 
 
;;; L'annuaire principal une simple liste (apres on fera avec les vectors)
(define annuaire '())
 
;;; A-liste des codes telephoniques des pays (bidon biensur)
(define codes  
               ; l'apostrophe equivaut a faire (list ...) et le point signifie que l'on rempli un doublet (donc le car du doublet est "France" et le cdr est 33)
              '(("France" . 33)
                ("Russie" . 95)
                ("Mexique" . 78)
                ("Chine" . 62)))
 
;;; La structure personne
(define-struct personne  
               (nom  
                prenom  
                num-dom    ; numero fixe
                num-port   ; numero portable
                pays        
                infos        
                ))
 
;;; Fonction qui rajoute une personne à l'annuaire, renvoi un annuaire (version simple)
(define (add-pers pers A)
  (if (null? A) ; si liste vide on renvoi ...
      pers        
      (cons pers A)))
 
;;; Fonction qui supprime une personne (version fonctionelle simple, recursivité enveloppé)
(define (del-pers A pers)
  (cond ((null? A) '())
        ((equal? (car A) pers) (del-pers (cdr A) pers))
        (else
         (cons (car A) (del-pers (cdr A) pers))))) ; Ici l'appel recursif a (del-pers ...) est enveloppé avec cons, d'ou epaissisement de la pile etc ...
 
 
;;; Fonction qui affiche l'annuaire, ici il ne faut pas avoir peur de la lambda, si on veut un peu d'abstraction on peut la considerer comme une tenaille qui prend chaque element (ici se sera 'x') d'une liste et lui fait faire des choses.
(define (show A)
  (for-each (lambda (x)  
                   (printf "_\nNom: ~a \nPrenom: ~a \nCode pays: ~a \nNumeros: ~a\n"  
                         (personne-nom x)  
                         (personne-prenom x)
                         (let ((cible (assoc (personne-pays x) codes)))  
                           (if cible      ; Toute chose differente de #f en Scheme est vrai
                               (cdr cible)
                               "Inconnu !" ))    
                         (list (personne-num-dom x)
                               (personne-num-port x))))  
  A ; on fait tout ca sur l'annuiare
))
 
;;; Fonction qui renvoi le Nom et Prenom correspondant au numero de tel donné en parametre (qui est une string)
(define (give-name number A)
  (for-each (lambda (x) (if [or (equal? (personne-num-dom x) number)  
                                (equal? (personne-num-port x) number)]
                            (printf "~a ~a" (personne-nom x) (personne-prenom x)) ; si #t
                            (void))) ; sinon on renvoi rien (serai moins joli avec map)
                            A))
 
;;; Exemples d'instanciation
(define dubois (make-personne "DUBOIS" "John" "0493000000" "0600000000" "France" "" ))
 
(define dupont (make-personne "DUPONT" "Bob"  "0493111111" "0611111111" "Chine" "" ))
 
(define dupuis (make-personne "DUPUIS" "Sam"  "0493222222" "0622222222" "Pologne" "" ))
 
(define dulard (make-personne "DULARD" "Mike" "0493333333" "0633333333" "Mexique" "" ))
 
;;; Initialisation physique de l'annuaire
(set! annuaire (list dubois dupont dupuis))
 
;;; Show est une fonction void (for-each est une fonction a effet de bord)
(show annuaire)
 
(printf "___________________________" )
 
;;; Void aussi
(give-name "0493000000" annuaire)
 
 
Et on obtient dans la console :
 

 
______________________________________________________________________________________
 

;;; Fonction un peu plus compliquée, trie la liste selon l'ordre alphabetique des noms.  
;;; A noter l'utilisation de la fonction "fait maison" de DrScheme: (quicksort list proc) ou proc donne la regle selon laquelle on trie la liste.
;;; Style "ordre superieur" (en 2 lignes)
 
(define (sort-by-nom A)
  (quicksort A (lambda (x y) (string<? (personne-nom x) (personne-nom y)))))
 
 
(executé sous DrScheme)

Ca serai pas mal d'avoir un champs de recherche unique qui donne aussi bien qq chose si on entre un nom, prenom que si on entre un numero
 
Et puis j'ai jamais reussi à trouver le moyen de faire un vrai STAND-ALONE avec DrScheme, cad un .exe (localisé pour Winows biensur) qui n'a pas besion des libs de DrScheme ...
 
Quelqu'un a til un idée ???

Bonsoir,
 Désolé pour le retard, mais j'avais quelque peu cassé mon OS. Je vois, je m'absente deux jours et déjà, je sens que je ne sers pas à grand chose. A part vider les poubelles, tu veux que je fasse quoi?   Peut-être un exemple de splash-screen basique.  
 Concernant ta question sur le programme en stand-alone, la seule réponse que j'avais trouvé, mais pas testée était, en passant par mzscheme de convertir les fichiers en C et de lancer une compile. Comme ça ,il utilise les bibliothèques C déjà sur ton système. Mais, bon faire du scheme pour finir avec du C ,cela me semble loin de ta question.
 Sinon chapeau pour ton cours magistral. j'ose à peine pointer mon nez au milieu de tout ça.
  A bientôt.

Salut, quand tu dis qu'on peut convertir les fichiers en C, j'ai jamais fait mais ca pourrait le faire un .exe libre de toute oppression du DrScheme faut faire comment? t'as pas un lien ?
 
Sinon tu pourrais eventuellement faire la partie graphique genre on commence ensemble (je vais pas avoir beacoup de temps cette semaine).
 
Je voulais aussi savoir ce que tu pensais du fait qu'on pourrais renommer le topic pour lui donner un nom plus general genre "Topic Scheme" ou "Just do it in Scheme" ou encore "Be smart - use Scheme" ... car je pensais rajouter quelques petits exemples sur les primitives et autres formes speciales de bases.

Salut,
 
 Pour ce qui est du renommage, ok pas de problème, t'es ici chez toi. Be smart...use scheme me paraît pas mal. Je ne sais pas si c'est possible, mais à tout seigneur, tout honneur, ton pseudo pourrait apparaître aussi en tant que créateur du topic, ce serait sympa.
  Maintenant, concernant la transposition de scheme en C, j'ai trouvé ceci:
         * Déjà dans la doc de Drscheme : "PLT mzc: Mzc compiler manual" qui renvoi à "Inside  PLT MzScheme" mais je pense que tu y avais déjà fait un tour. Ils ne sont pas dans la documentation par défaut.
         * Puis: -"The 90 minutes Scheme to C compiler": http://www.iro.umontreal.ca/~bouch [...] es-en.html
                 - CHICKEN Scheme compiler : http://www.call-with-current-continuation.org/
                 - Scheme-to-C : http://www.computer-dictionary-onl [...] cheme-to-C  Mais celui-ci me paraît vieux, supporte windows 3.1.
         * Sinon, regarde du côté de guile: il me semble que GIMP et Gnucash l'utilisent. http://www.gnu.org/software/guile/guile.html Euh, pour Windows, je ne suis pas certain.
 
 Voilà, là-dessus, je ne peux pas t'aider plus.  
 
  Ok pour l'interface graphique. Bon question temps, ç'est chaud pour moi aussi, mais nous ne sommes pas obligés de courrir. N'hésite pas à faire des remarques si mon code te paraît un peu...pas propre. Je ne suis pas du genre à me vexer. Allez, à bientôt.

Je suis revenu,
 
 Non, je n'avais oublié personne ni n'étais parti avec la caisse. Toutes mes excuses, mais des soucis de santé m'ont quelque peu éloignés de mon ordi et de pas mal de choses d'ailleurs. Donc, comme promis nous allons débuter l'interface graphique. Petit à petit, je le crains, je ferai de mon mieux.
 
Nous modifierons les choses au fur et à mesure et nous allons commencer par l'écran d'introduction ou en anglais le splash screen. Tout d'abord, créez l'image que vous voulez voir apparaître et mettez la dans un dossier /images au cas où nous en aurions plusieurs en cours de route.
 
 Voici le code, il est réalisé avec Drscheme et vous devez avoir séléctionné le langage Graphique(mred) si vous voulez que cela fonctionne directement. Je pense que nous créerons plus tard un fichier "main" qui nous permettra de charger tout ce dont nous aurons besoin comme suppléments.
 
;On crée la fenêtre qui contiendra l'image
(define splash (instantiate frame%("Bienvenue" )(parent #f)(width 450)(height 300)))
;on lui assigne un conteneur acceptant les images
(define canvas1 (instantiate canvas% (splash)(style '())
                (paint-callback (lambda(canvas dc)(intro-paint dc)))
                (label "image de garde" )))
; Voici l'emplacement et la construction de l'image
(define image_debut(make-object bitmap% "./images/image.png" 'png #f));N'oubliez pas le point avant le slash  
;on la dessine
(define (intro-paint dc)
        (send dc draw-bitmap image_debut 0 0 'solid))
;cette fonction montre l'écran d'accueil pendant un temps donné
(define (montre_splash seconds)
        (send splash show #t) ;envoie à la fenêtre principale l'ordre de s'afficher
        (sleep/yield seconds)
        (send splash show #f)) ; L'inverse
; La sus-citée fonction est appelée
(montre_splash 1.5) ; temps en secondes
 
  Voilà, vous avez votre premier splash screen, pour ceux qui débutent. Avec Drscheme construire une interface n'est pas très compliqué pour des choses simples. Pour du plus complexe, ce ne l'est pas plus qu'avec d'autres langage permettant des interfaces graphiques. Si vous pensez que je suis avare en explications, n'hésitez pas. Désolé, ce sera tout pour ce soir, A bientôt.

Olé amigo !
 
12 lignes de code pour faire afficher une belle fenetre, ca fracasse Y a pas beacoup de langages dans lesquels on peut faire ca !
 

ouf j'ai eu un cours de scheme en dernière session, on a même fait un jeu d'arkanoid
 
spas vraiment un truc qui me plait à vrai dire

T'aime pas quand c'est facile ?  

Salut Kronoklazm,
 Je ne t'avais pas abandonné, désolé. Au fait, j'ai oublié de te dire, si un jour tu passes à Reims, viens faire une pause à la maison.
 
  12 lignes effectivement, c'est court. Et encore lorsque nous intègrerons un petit éditeur de texte dans la fenêtre principale avec les outils fournis en standrard avec Drscheme, là ça va arracher.
 
 Pour Burgergold, c'est quoi qui te rebutes dans le Scheme ? Par contre je te comprend un peu. C'est un langage de fainéant: en peu de lignes tu peux faire des choses incroyables surtout si tu tapes dans le récursif, par contre il te faut trois heures pour les faire ces trois lignes, il y a toujours une parenthèse mal placée. A ta disposition pour en parler.
 
 Promis, d'ici la fin du week-end, la fenêtre principale sera postée. Salut à tous

 
j'aurais pas tendance à dire le scheme de language facile
 
c'est un language qui ne suis pas les autres, vachement difficile à lire et pas très intuitif
 
J'ai le C tatoué sur le coeur moua

Bonsoir,
  Allez, on continue, voici la fenêtre principale du programme. Au début, je pensais organiser les choses au mieux, mais finalement, peut-être qu'un peu de vrac n'est pas si mal. Une fois tout en place, nous vous expliquerons comment tout mettre en ordre. En attendant, n'hésitez pas à expérimenter ce qui vous est proposé. Pour notre interface, j'ai mis le minimum d'options dans le code, par souci de place et de clarté. Comme précisé plus haut, n'hésitez pas à aller dans la doc et d'expérimenter. Ce que nous vous donnons fonctionne, c'est déjà une bonne base.
 
Dernière modification, le 21 mars 2005(la version "finale" en page 2)
Ajouté: les champs finaux: Nom, prenom,Adresse,Code Postal,Ville,Téléphone fixe et téléphone portable. Trois boutons : Rechercher, Nouveau, Enregistrer.  
La fonction qui permet de faire une page vierge pour un nouvel enregistrement. Attention : il conviendra de remplacer dans le menu-item "nouveau" le renvoi à la procédure (files-open)par (nouveau).
A faire: améliorer la géometrie de l'ensemble (la portion texte est trop petite et les boutons non centrés)
;définition de la fenêtre principale
(define principale (instantiate frame% ("Super_annuaire" )(parent #f)
                     (width 400)(height 300);on définit une taille
                     (min-width 0)(min-height 0)
                     ;on peut la redimensionner
                     (stretchable-width #t)
                     (stretchable-height #t)))
;Et une barre de menu
(define menu(new menu-bar% (parent principale)))
;On agrémente cette barre
    ;Commençons par l'item Fichier
(define menu_fichier (new menu% (label "Fichier" )(parent menu)(help-string "file-menu" )))
    ; Et remplissons le
(new menu-item% (label "&Nouveau" )(shortcut #\n)(parent menu_fichier)
     (callback (lambda(item event)(files-open))));les fonctions seront écrites plus tard
(new menu-item% (label "&Ouvrir" )(shortcut #\o)(parent menu_fichier)
     (callback(lambda(item event) (file-new))))
;Un peu de visibilité
(new separator-menu-item% (parent menu_fichier))
;On continue
(new menu-item%(label "&Sauvegarder" )(shortcut #\S)(parent menu_fichier)
     (callback (lambda (menu-item control-event) (files-save))))
(new menu-item%(label "&Save as" )(parent menu_fichier)
     (callback (lambda (menu-item control-event) (files-save-as))))
;On change de catégorie
(new separator-menu-item% (parent menu_fichier))
 
(new menu-item%(label "Quitter" )(shortcut #\Q)(parent menu_fichier)
     (callback (lambda (item event) (exit))))
;Menu Edition et fait en utilisant ce que Drshme a fait pour nous (servira aussi pour l'éditeur de texte)
(define m-edit(instantiate menu%("Edit" menu)))
(define m-font(instantiate menu%("Font" menu)))
(append-editor-operation-menu-items m-edit)
(append-editor-font-menu-items m-font)
;; Un peu d'aide?
(define help-menu (new menu%
                                  (label "Aide" )  
                                  (parent menu)  
                                  (help-string "Help menu" )))
 
(new menu-item%
     (label "&About mon prg" )
     (shortcut #\?)
     (parent help-menu)
     (callback (lambda (item event) (help-about-dialog))))
;Passons à l'organisation de la fenêtre
;un panel principal sur lequel nous grefferons "sous panel" pour placer nos champs
 
(define pane (new pane% (parent principale)(border 0)
                  (min-width 0)
                  (min-height 0)
                  (stretchable-width #t)
                  (stretchable-height #t)))
;un panel horizontal
(define horizontal-panel1 (new horizontal-pane%(parent pane)))
 
;un panel vertical pour agencer les items les uns sous les autres
(define vertical-panel1(new vertical-pane% (parent horizontal-panel1)))
;un deuxième pour faire 2 colonnes
(define vertical-panel2(new vertical-pane% (parent horizontal-panel1)))
;on commence à placer les champs
; le Nom
(define nom(new text-field% (parent vertical-panel1)(label"Nom:" )
                (callback(lambda(text-field control-event)(void)))
                (init-value "" )(style '(single))(enabled #t)
                (vert-margin 2)(horiz-margin 2)))
;le Prénom
(define prenom(new text-field%(parent vertical-panel1)(label "Prénom:" )
                   (callback(lambda(text-field control-event)(void)))
                (init-value "" )(style '(single))(enabled #t)
                (vert-margin 2)(horiz-margin 2)))
;l'Adresse
(define adresse(new text-field%(parent vertical-panel1)(label"Adresse:" )
                    (callback(lambda(text-field control-event)(void)))
                (init-value "" )(style '(single))(enabled #t)
                (vert-margin 2)(horiz-margin 2)))
;Code postal
(define Code_postal(new text-field%(parent vertical-panel1)(label"Code postal:" )
                    (callback(lambda(text-field control-event)(void)))
                (init-value "" )(style '(single))(enabled #t)
                (vert-margin 2)(horiz-margin 2)))
;Ville
(define ville(new text-field%(parent vertical-panel1)(label"Ville:" )
                    (callback(lambda(text-field control-event)(void)))
                (init-value "" )(style '(single))(enabled #t)
                (vert-margin 2)(horiz-margin 2)))
 ;Téléphone fixe
(define telephone_fixe(new text-field%(parent vertical-panel2)(label "Téléphone fixe" )
                    (callback(lambda(text-field control-event)(void)))
                (init-value "" )(style '(single))(enabled #t)
                (vert-margin 2)(horiz-margin 2)))  
;telephone portable
(define telephone_portable(new text-field%(parent vertical-panel2)(label "Téléphone portable" )
                    (callback(lambda(text-field control-event)(void)))
                (init-value "" )(style '(single))(enabled #t)
                (vert-margin 2)(horiz-margin 2)))
 
;Vous pouvez continuer avec ce que vous voulez vous avez la technique
;Nous mettrons à jour au fur et à mesure de l'avancée du prg
;Passons à l'édieur de texte
(define editeur(instantiate editor-canvas% (principale)))
(define texte(instantiate text%()))
(send editeur set-editor texte)
 
;un panel horizontal pour les boutons
(define horiz-panel(new horizontal-pane%(parent principale) (border 2)(spacing 2)))
;les boutons
  ;Pour la fonction rechercher
(define bouton_Recherche(new button%(parent horiz-panel)( label "Rechercher" )
                             (callback(lambda(button event)(recherche)))))
                             
;Boutton pour créer une nouvelle fiche
(define bouton_nouveau(new button%(parent horiz-panel)(label"Nouveau" )
                                          (callback(lambda(button event)(nouveau)))
                                          (style '())(enabled #t)
                                          (vert-margin 2)(horiz-margin 2)))
;Et un pour sauvegarder
(define bouton_sauvegarde(new button%(parent horiz-panel)(label"Enregistrer" )
                              (callback(lambda(button event)(sauvegarder)))))
 
;Créer une nouvelle page vierge
(define(nouveau)(send nom set-value " " )(send prenom set-value "" )
  (send adresse set-value"" )(send Code_postal set-value"" )(send ville set-value"" )
  (send telephone_fixe set-value"" )(send telephone_portable set-value"" ))
;C'est un peu bovin comme méthode. Nous aurions pu définir les attributs par défaut de la page et appeler ces attributs, mais bon, je suis un bourrin
 
(send principale show #t)
 
 Voilà. Pas de questions? Bonne question. Bien entendu, vous pouvez avoir un focus au passage de la souris et tout plein de belles choses, mais les mettre ici nuierai à la lisibilité, surtout pour les débutants.
 
  Si quelqu'un veut faire une interface en Tk ou autre, pas de soucis. N'hésitez pas à poser des questions et à revenir de temps en temps sur cette partie qui pourra changer en fonction de ce que nous aurons à y mettre.  
Bien à vous et bonne nuit.

Sympatique, tu l'as fait à la main ou avec mreddesigner ?
 
On fait comment alors, on utilise l'espace d'en-bas pour les requetes (faut un bouton-envoi je pense dans ce cas la) ? ou on utilise les champs aussi (à la pression de la touche entrée) ?

Merci,
  Entièrement avec mes petites mimines, mreddesigner met d'office un max d'options, ça me paraissait un peu trop au cas où des débutants se pointeraient.
  Au temps pour moi, j'ai oublié les boutons. On pourrait mettre "Rechercher" "Nouveau" et "Enregistrer". Au niveau des champs, je pensais mettre : "Nom", "Prénom", "Téléphone fixe", "Télephone portable","Adresse", "Code postal","Ville", "Courriel", et pourquoi pas photo. La zone texte pourrait servir à mettre des info plus personnelles (comme date anniversaire, plat préféré,...). Je fais ça le plus vite possible.
  Au niveau des recherches, on peut faire plusieurs choses: une liste déroulante  dans laquelle les noms seront classés par ordre alphabétique, plus une fonction de recherche accessible par le bouton "Recherche".On "scanne" le ou les champ(s) rempli(s) par l'utilisateur, et on voit ce qu'on en fait. Mais attention, si tu veux faire trop compliqué, tu sais qu'à un moment donné, je ne pourrai plus t'aider.
 Au fait, c'est lisible ou il faut que j'explicite plus?
 Sinon, tu es allé voir du côté de chez Guile ?  
A bientôt

Oui j'ai telecharger Guile mais je me suis pas trop attardé dessus encore ... TODO !
 
Sinon c'est lisible, y'a pas de souci (pour moi en tout cas).
 
C'est ok pour les listes deroulantes ... et dans la semaine je vais linker l'interface avec le reste.
 
Autre chose, j'ai fait une petite fonction qui met les petites balises qu'on galere a copier/coller a chaque fois qu'on veut poster du source scheme tout mimi ici (avec les define et autres mot-cles colorié en bleu).
 
Seulement voila quand on lit un fichier ouvert avec call-with-input-machin on litle fichier par blocs (cad par doublets) ce qui est hyper-puissant et en meme temps deroutant ... bref ca marche pas top encore. Et faut que je face aussi les tags pour les commentaires.
 
En gros ce qu'il me faut c'est une variante de for-each mais qui applique sa lambda en profondeur (pas seulement au premier etage) trop la fleme de la faire.
 
En entrée on a un .scm et en sortie un .txt dans le repertoire courant (la ou est le source de la fonction).
 

 
PS : Euh le truc que j'aime bien en scheme c'est qu'un fichier .scm est une liste.  

Bon là c'est deja plus du concret
 
Ca marche nikel sauf que les indentations sont faites n'importe comment et pour les commentaires je suis zebé, car j'ai l'impression que (read p-in) me bouffe les commentaires (cad les strings commencant par ; jusqu'a la fin de ligne, saloperie de read !) sinon c'est du bon, on peut eventuellement develloper un peu plus pour definir d'autres couleurs pour les mot-cles les strings etc ...
 
Voila le source de la fonction generé par elle-même :
 

 
J'ai indenter à la main, enfin essayé
 
Quelqu'un as t-il une idée pour l'indentation et les commentaires ?
 
EDIT : Tout ca sans aucun automate ni lex/flex etc ...

Salut,
 ça a l'air sympa ton petit truc. Mais pleins de questions m'assaillent. Je passerai sur le "qu'est-ce qui dit?" "qu'est-ce qui fait ?" pour être plus concret.Donc, je comprends pas tout: qu'est-ce qui fait que dans ton code, il rajoute les balise couleur de ce forum? Ou bien, tu veux juste indenter et transformer en  txt pour que cela soit plus facile. Moi, j'ouvre mon code avec kwrite et après, je copie/colle. Sous win essaie Jedit mais je suis persuadé que tu connais. C'est vrai c'est pas du code "maison" c'est donc moins bien. Attention loin de moi l'idée de dire c'est inutile, bien au contraire. Je capte pas tout, je vais me coucher.
  J'avais essayé de te faire une petite interfce graphique pour ton code, à base de (get-file), mais ça fonctionnait sur la première version. La deuxième, je la comprends encore moins et ça fonctionne pas. J'avais prévenu, à part sortir les poubelles,...
 Blague à part, tu as vu le nombre de visites que nous avons. Ca ma paraît honnête, mais as-tu une idée de ce qui fait que les personnes ne postent pas. Nous sommes trop vagues, pas assez spécifiques ou c'est...scheme tout simplement?
  Sinon, obligations familiales faisant loi, ce week-end sera vaqué. Alors Joyeuses Pâques à tous et attention sur la route.

Pouquoi les personnes ne postent pas ?
A mon avis, soit:
  - ils ne comprennent rien.
  - ils s'en foutent.
  - ils font des trucs plus interessants que ca (Blabla@prog par exemple).
  - ils ont gardé leurs à priori à 2 balles sur Scheme.
  - ils n'ont pas le temps.
  - ils sont fatigués.
  - ils ne savent pas écrire.
  - ils aiment pas les parentheses.
  - ils ont trop peur de dire des conneries.
  - ils font chier !!!!!!!
 
En gros faut qu'on s'oriente plus vers la mailing-list de Scheme, mais là c'est la cour des grands, on comprendras rien.  
 
Sinon pour l'explication :
 
"Qu'est-ce qui fait que mon code rajoute les balise de couleur de ce forum ?
 
En gros, que fait la fonction "joly-source" ?  
Elle prend un fichier source ".scm" et rend un fichier ".txt" avec les mot-clés qui sont entre des balises de couleurs de ce forum.  
 
Elle ouvre le fichier entree en lecture et le fichier sortie en ecriture, elle "consomme" la "liste" (qui est en fait le fichier source) grace a "(read p-in)", donc la fonction "iter" est simplement un parcours de liste sauf que la liste s'arrete quand on lis "eof" (fin de fichier).  
Jusqu'ici c'est pas tres compliqué.
Pourquoi "for-each-all", pour cela il faut deja savoir qu'est que "for-each".
 
"for-each" est une primitive de scheme qui applique une fonction a chaque element d'une liste d'une maniere "à effet de bord" cad qu'elle ne renvoi rien (#void quoi), à la difference de map.  
 
Par exemple :
 
;; J'applique la fonction f(x)=x+1 à la liste '(1 2 3)
=>(for-each (lambda (x) (+ x 1)) '(1 2 3))  
rien
 
;; J'applique la fonction f(x)=x+1 à la liste '(1 2 3)
=>(map (lambda (x) (+ x 1)) '(1 2 3))  
(2 3 4)
 
;; J'applique la fonction f(x)=[imprimer( x+1 )] à la liste '(1 2 3)
=>(for-each (lambda (x) (printf "~a" (+ x 1))) '(1 2 3))
affiche 234
 
 
Maintenant pour "for-each-all", pour comprendre le mecanisme de cette fonction il faut connaitre la signification d'un doublet ou pair en Scheme:
 
Rappel : Un doublet ou une paire est un ADT (Abstract Data Type) il est constitué de deux elements; le car et le cdr.
Ils ont une portée historique dont j'ai oublié les details.
 
Exemple :
 
;; Creation d'un doublet, 'x et 'y sont des symboles.
=>(cons 'x 'y)
(x . y)
 
;; Le car d'un doublet
=>(cdr (cons 'x 'y))
x  
 
;; Le car d'un doublet
=>(cdr (cons 'x 'y))
y
 
;; Creation d'une liste avec la fonction cons
=>(cons 'x (cons 'y '()))
(x y)
Mot à mot ca veut dire le car est x et le cdr pointe vers un autre doublet dont le car est y et le cdr est vide.  
Ce qui revient exactement à faire (list 'x 'y) ou encore '(x y).  
 
Mais on pourrait tres bien avoir des listes de listes. Ou plus precisement un doublet dont le car pointe vers une liste et le cdr pareil. Donc ce n'est plus une liste "plate" , elle n'a plus 1 mais n etages (si on voit ca comme un arbre). Dans ce cas là, une fonction comme map ou for-each ne passera pas par "TOUS" les element de la liste mais seulement par le premier etage ... DONC on doit recrire une methode qui applique une fonction a TOUS les elements d'une liste, cad s'executer recursivement sur le CAR et le CDR d'un doublet.
 
Bref ...
 
Pour le comment, il y a un detail a preciser et tout deviendra clair : (fprintf p-out  "~a " y) ou le ~a est en bleu qui est en fait [#000...ff]~a[/#000...ff], mais comme cette balise est interpreté par le parseur du forum, elle apparait en bleu.
Bonnes fêtes !!!!

Merci pour les liens. Bien que ce ne soit pas vraiment le sujet du topic, pourrais tu donner quelques exemple de progs commentés en Clean ? Juste comme ca pour la culture generale et puis qui sait, ca pourrais peut etre plaire a quelqu'un.
 
Tu connais Refal5 ? Si oui tu le mettrais ou dans l'arborescence ?
 
Je vais prochainement faire un ptit post sur les streams, c'est assez facile en Scheme de faire des listes infinies et  donc definir l'ensemble des entiers naturels et autres.
 
De même aborder les continuations et le mecanisme d'exceptions de Scheme ... (IBM a recement fait savoir qu'elle implementera un navigateur internet en utilisant Scheme et le systeme des continuations)
 
Je pense que dans ce topic on devrait essayer de partager nos connaissances concernant l'application de ce genre de methodes dans la vie pratique. Des idées ?? Ca motive plus que balancer de la theorie dans la face juste en disant "c'est dur, ca sert dans l'industrie et l'intelligence artificielle".

Je m'y connais pas trop dans ces termes là mais c'est du declaratif recursif je crois. (j'ai lu un truc comme quoi c'était une tentative de faire de la supercompilation) enfin bref un truc exotique ...

Bon pour en revenir un peu a l'agenda ... j'ai fait quelques corrections dans le gui et le reste.  
 
On peut seulement faire afficher le tout, chercher une personne par nom/prenom (là il ya une petite couille quand deux personnes qui ont le meme nom mais pas le meme prenom on affiche seulement les numeros de la premiere personne qui a ce nom). Ainsi que enregistrer une personne ...
Reste plus qu'a faire la sauvegarde/chargement d'un annuaire dans un fichier et les differents types de recherche.
 
fichier agenda-core.scm :
 
;;; L'annuaire principal une simple liste (apres on fera avec les vectors)
(define annuaire '())
 
;;; A-liste des codes telephoniques des pays (bidon biensur)
(define codes  
               ; l'apostrophe equivaut a faire (list ...) et le point signifie que l'on rempli un doublet (donc le car du doublet est "France" et le cdr est 33)
              '(("France" . 33)
                ("Russie" . 95)
                ("Mexique" . 78)
                ("Chine" . 62)))
 
;;; La structure personne
(define-struct personne  
               (nom  
                prenom  
                adresse  
                code_postal
                ville
                tel_fixe    ; numero fixe
                tel_port   ; numero portable
                pays        
                infos        
                ))
 
;;; Fonction qui rajoute une personne à l'annuaire, renvoi un annuaire (version simple)
(define (add-pers pers A)
  (if (null? A) ; si liste vide on renvoi ...
      (list pers)        
      (set-cdr! (last-pair A) (cons pers '())))) ; ici on fait un effet de bord sur l'annuaire
 
 
;;; Fonction qui supprime une personne (version fonctionelle simple, recursivité enveloppé)
(define (del-pers A pers)
  (cond ((null? A) '())
        ((equal? (car A) pers) (del-pers (cdr A) pers))
        (else
         (cons (car A) (del-pers (cdr A) pers))))) ; Ici l'appel recursif a (del-pers ...) est enveloppé avec cons, d'ou epaissisement de la pile etc ...
 
 
;;; Fonction qui affiche l'annuaire, ici il ne faut pas avoir peur de la lambda, si on veut un peu d'abstraction on peut la considerer comme une tenaille qui prend chaque element (ici se sera 'x') d'une liste et lui fait faire des choses.
(define (show A text)
  (for-each  
   (lambda (x)  
     (send text insert  
           (format "_\nNom: ~a \nPrenom: ~a \nAdresse: ~a \nCode postal: ~a \nVille: ~a \nCode pays: ~a \nNumeros: ~a\n"  
                   (personne-nom x)  
                   (personne-prenom x)
                   (personne-adresse x)
                   (personne-code_postal x)
                   (personne-ville x)
                   (let ((cible (assoc (personne-pays x) codes)))  
                     (if cible      ; Toute chose differente de #f en Scheme est vrai
                         (cdr cible)
                         "Inconnu !" ))    
                   (list (personne-tel_fixe x)
                         (personne-tel_port x)))))  
   A ; on fait tout ca sur l'annuiare
   ))
 
;;; Fonction qui renvoi les Nom et Prenom correspondant au numero de tel donné en parametre (qui est une string)
(define (give-name number A)
  (for-each (lambda (x) (if [or (equal? (personne-tel_fixe x) number)  
                                (equal? (personne-tel_port x) number)]
                            (printf "~a ~a" (personne-nom x) (personne-prenom x)) ; si #t
                            (void)))  
                            A))
 
;;; Fonction qui renvoi les numeros de tel correspondant au Nom Prenom ...
(define (give-tel nom prenom adresse code_postal ville pays A text)
  (for-each (lambda (x) (if [or (equal? (personne-nom x) nom)  
                                (equal? (personne-prenom x) prenom)]
                            (send text insert  
                                  (format "Fixe: ~a  Portable: ~a\n"  
                                          (personne-tel_fixe x) (personne-tel_port x))) ; si #t
                            (void))) A))
 
 
;;; Fonction un peu plus compliquée, trie la liste selon l'ordre alphabetique des noms.  
;;; A noter l'utilisation de la fonction "fait maison" de DrScheme: (quicksort list proc) ou proc donne la regle selon laquelle on trie la liste.
;;; Style "ordre superieur" (en 2 lignes)
(define (sort-by-nom A)
  (quicksort A (lambda (x y) (string<? (personne-nom x) (personne-nom y)))))
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Exemples d'instanciation
(define dubois (make-personne "DUBOIS" "John"  
                              "23 Avenue Truc" 06111 "Lyon"  
                              "0493000000" "0600000000"  
                              "France"  
                              "" ))
 
(define dupont (make-personne "DUPONT" "Bob"  
                              "12 Rue X" "Pekin" 07222
                              "0493111111" "0611111111"  
                              "Chine" "" ))
 
(define dupuis (make-personne "DUPUIS" "Sam"  
                              "7 Promenade Y" 89123 "Varsovie"
                              "0493222222" "0622222222"  
                              "Pologne"  
                              "" ))
 
(define dulard (make-personne "DULARD" "Mike"
                              "87 Route K" 56789 "Tijuana"
                              "0493333333" "0633333333"  
                              "Mexique"  
                              "" ))
 
;;; Initialisation physique de l'annuaire
(set! annuaire (list dubois dupont dupuis))
 
 
.......................................................................
; fichier agenda-gui.scm  
 
(load "agenda-core.scm" )
 
 
;définition de la fenêtre principale
(define principale (instantiate frame% ("Super_annuaire" )(parent #f)
                     (width 600)(height 650);on définit une taille
                     (min-width 0)(min-height 0)
                     ;on peut la redimensionner
                     (stretchable-width #t)
                     (stretchable-height #t)))
 
;Et une barre de menu
(define menu (new menu-bar% (parent principale)))
 
;On agrémente cette barre
;Commençons par l'item Fichier
(define menu_fichier (new menu%  
                          (label "Fichier" )
                          (parent menu)
                          (help-string "file-menu" )))
;Et remplissons le
(new menu-item%  
     (label "&Nouveau" )
     (shortcut #\n)
     (parent menu_fichier)
     (callback (lambda (item event) (files-open))));les fonctions seront écrites plus tard
 
(new menu-item%  
     (label "&Ouvrir" )
     (shortcut #\o)
     (parent menu_fichier)
     (callback (lambda (item event) (file-new))))
 
;Un peu de visibilité
(new separator-menu-item% (parent menu_fichier))
 
;On continue
(new menu-item%(label "&Sauvegarder" )(shortcut #\S)(parent menu_fichier)
     (callback (lambda (menu-item control-event) (files-save))))
 
(new menu-item%(label "&Save as" )(parent menu_fichier)
     (callback (lambda (menu-item control-event) (files-save-as))))
 
;On change de catégorie
(new separator-menu-item% (parent menu_fichier))
 
(new menu-item%(label "Quitter" )(shortcut #\Q)(parent menu_fichier)
     (callback (lambda (item event) (exit))))
 
;Menu Edition et fait en utilisant ce que Drshme a fait pour nous (servira aussi pour l'éditeur de texte)
(define m-edit (instantiate menu%("Edit" menu)))
 
(define m-font (instantiate menu%("Font" menu)))
 
(append-editor-operation-menu-items m-edit)
 
(append-editor-font-menu-items m-font)
 
;; Un peu d'aide?
(define help-menu (new menu%
                       (label "Aide" )  
                       (parent menu)  
                       (help-string "Help menu" )))
 
(new menu-item%
     (label "&About mon prg" )
     (shortcut #\?)
     (parent help-menu)
     (callback (lambda (item event) (help-about-dialog))))
 
;Passons à l'organisation de la fenêtre
;un panel principal sur lequel nous grefferons "sous panel" pour placer nos champs
 
(define pane (new pane% (parent principale)(border 0)
                  (min-width 0)
                  (min-height 0)
                  (stretchable-width #t)
                  (stretchable-height #t)))
 
;un panel horizontal
(define horizontal-panel1 (new horizontal-pane%(parent pane)))
 
;un panel vertical pour agencer les items les uns sous les autres
(define vertical-panel1(new vertical-pane% (parent horizontal-panel1)))
 
;un deuxième pour faire 2 colonnes
(define vertical-panel2(new vertical-pane% (parent horizontal-panel1)))
 
;on commence à placer les champs
;le Nom
(define nom(new text-field% (parent vertical-panel1)(label"Nom:" )
                (callback (lambda (text-field control-event)(void)))
                (init-value "" )(style '(single))(enabled #t)
                (vert-margin 2)(horiz-margin 2)))
 
;le Prénom
(define prenom (new text-field%
                    (parent vertical-panel1)
                    (label "Prénom:" )
                    (callback(lambda(text-field control-event) (void)))
                    (init-value "" )
                    (style '(single))
                    (enabled #t)
                    (vert-margin 2)
                    (horiz-margin 2)))
 
;l'Adresse
(define adresse (new text-field%
                     (parent vertical-panel1)
                     (label"Adresse:" )
                     (callback (lambda (text-field control-event)(void)))
                     (init-value "" )
                     (style '(single))
                     (enabled #t)
                     (vert-margin 2)
                     (horiz-margin 2)))
 
;Code postal
(define Code_postal(new text-field%
                        (parent vertical-panel1)
                        (label"Code postal:" )
                        (callback (lambda (text-field control-event)(void)))
                        (init-value "" )
                        (style '(single))
                        (enabled #t)
                        (vert-margin 2)
                        (horiz-margin 2)))
 
;Ville
(define ville (new text-field%  
                   (parent vertical-panel1)  
                   (label "Ville:" )
                   (callback (lambda (text-field control-event)(void)))
                   (init-value "" )
                   (style '(single))
                   (enabled #t)
                   (vert-margin 2)
                   (horiz-margin 2)))
 
;Pays
(define pays (new text-field%
                        (parent vertical-panel1)
                        (label "Pays:" )
                        (callback (lambda (text-field control-event)(void)))
                        (init-value "" )
                        (style '(single))
                        (enabled #t)
                        (vert-margin 2)
                        (horiz-margin 2)))
 
;Téléphone fixe
(define telephone_fixe (new text-field%
                            (parent vertical-panel2)
                            (label "Téléphone fixe:" )
                            (callback (lambda (text-field control-event)(void)))
                            (init-value "" )
                            (style '(single))
                            (enabled #t)
                            (vert-margin 2)
                            (horiz-margin 2)))  
 
;telephone portable
(define telephone_portable (new text-field%  
                                (parent vertical-panel2)
                                (label "Téléphone portable:" )
                                (callback (lambda (text-field control-event)(void)))
                                (init-value "" )
                                (style '(single))
                                (enabled #t)
                                (vert-margin 2)
                                (horiz-margin 2)))
 
;Vous pouvez continuer avec ce que vous voulez vous avez la technique
;Nous mettrons à jour au fur et à mesure de l'avancée du prg
;Passons à l'édieur de texte
(define editeur (instantiate editor-canvas% (principale)))
 
(define texte (instantiate text%()))
 
(send editeur set-editor texte)
 
;un panel horizontal pour les boutons
(define horiz-panel (new horizontal-pane% (parent principale) (border 2)(spacing 2)))
 
;les boutons
;Pour la fonction rechercher
(define bouton_Recherche(new button%
                             (parent horiz-panel)
                             (label "Rechercher" )
                             (callback (lambda (button event)
                                         (recherche ; on lance une recherche
                                          (send nom get-value)
                                          (send prenom get-value)
                                          (send adresse get-value)
                                          (send code_postal get-value)
                                          (send ville get-value)
                                          (send Pays get-value)
                                          annuaire ; dans l'annuaire courant
                                          )))))  
                             
;Boutton pour créer une nouvelle fiche
(define bouton_nouveau (new button%  
                            (parent horiz-panel)
                            (label"Nouveau" )
                            (callback(lambda(button event)(nouveau)))
                            (style '())(enabled #t)
                            (vert-margin 2)(horiz-margin 2)))
   
;Et un pour sauvegarder
(define bouton_enregistrer (new button%
                               (parent horiz-panel)
                               (label "Enregistrer" )
                               (callback  
                                (lambda (button event)
                                  (enregistrer ; On enregistre une personne à l'appel de cette fonction
                                   (send nom get-value)
                                   (send prenom get-value)
                                   (send adresse get-value)
                                   (send Code_postal get-value)
                                   (send ville get-value)
                                   (send telephone_fixe get-value)
                                   (send telephone_portable get-value)
                                   (send pays get-value)
                                   annuaire ))))) ; dans l'annuaire existant
 
;Affiche toutes les personnes disponibles
(define bouton_afficher_tout (new button%
                                  (parent horiz-panel)
                                  (label "Afficher tout" )
                                  (callback  
                                   (lambda (button event)
                                     (show annuaire texte)))))  
                                   
 
 
;; Vide tous les champs dispo pour creer une nouvelle fiche.
(define (nouveau)
  (map (lambda (x) (send x set-value "" ))
       (list nom prenom adresse Code_postal ville telephone_fixe telephone_portable pays)))
 
;; Sauvegarde d'une fiche
(define (enregistrer nom prenom adresse code_postal ville telephone_fixe telephone_portable pays annuaire)
  (add-pers (make-personne nom prenom adresse code_postal ville telephone_fixe telephone_portable pays "" ) annuaire))  
 
;; Recherche d'un numero
(define (recherche nom prenom adresse code_postal ville pays annuaire)
  (give-tel nom prenom adresse code_postal ville pays annuaire texte))
 
;; Lancement de la fentre principale
(send principale show #t)  
 
.......................................................................
 
Trop la fleme de colorier ...
 
EDIT : Petit screen-shot pour la route
http://img32.exs.cx/img32/8862/agendabeta8nj.jpg
 
REDIT : J'ai decouvert un truc là, en fait on peut meme faire une recherche dynamique, cad a chaque entrée d'une lettre ou d'un chiffre dans l'un des champs on peut lancer une recherche à la volée.    

Franchement c'est vrai qu'elles sont chiantes, ca fouete l'oeil je l'avoue Mais fallais bien garder quelque chose de son papa (je parle surtout de Lisp).
Mais on s'y habitue vite et on y fait plus attention apres, pire on peut plus s'en passer.
 
Si on les enleve on se retrouve avec du Caml (enfin faut rajouter le typage fort aussi).
 
Et sinon, j'attends avec impatience un ptit quelque chose sur Clean enfin sans vouloir abuser quoi ...

 
C'est quoi ?
 
Sinon je pari que Clean est un langage a liaison dynamique donc pas de fermeture ... (je vois pas trop comment la faire dans un environement dynamique, ca doit etre surement possible)  
 
La je suis entrain de me prendre le choux a reimplementer amb, sans continuations c'est ingerable (et les continuations sans la lambda en tant que closure c'est mort aussi enfin faut se prendre mechament tete quoi). Et alors sans structure de controle (genre define-syntax ou meme define-macro) c'est à la limite du suicide.
 
La politique de Scheme consiste a inclure les memes nouveautés et autres possibilités disponibles dans d'autres languages, c'est en partie chose faite ... et c'est l'une des raisons de son "relatif" succés.

Voilà,
 Encore une fois, je m'absente et c'est parti. Je fais finir par croire que le problème de ce topic, c'est moi   .
 
 Merci, sur les explications sur ton programme. En fait en tout bon débutant je m'attendais à une déclaration "formelle" des balises. Genre un "triplet" construit avec les mots clefs, dont le car serait [#000...ff], le caar le mot clef et le cdr la fermeture de balise. Maintenant, je comprends mieux. En fait, tu encapsules le mot clef à l'intérieur d'un contenant qui posséde la caractéristique voulue. Donc notre mot-clef en "hérite", mais la posséde pas. C'est juste une question de niveau...d'expertise.Edit: laisse tomber cette explication, ça y est j'ai compris.
 
 Au fait, chapeau pour ce que tu nous a fait. Merci.
 
 -> Chronoklazm, sinon, après tout ce beau travail que nous a fait, dis-moi si me je trompe, je sens que tu as envie de partir vers d'autres sphères et de passer à la vitesse supérieure. Tu veux laisser ce bel ouvrage tel quel en disant, maintenant vous avez toutes les armes, entraînez-vous? Pour moi, pas de souci. Tu peux faire monter le niveau et les débutants ont un exemple concret bien expliqué qui ne peut que les allécher. Objectif rempli.Ton programme de simulation de corde élastique en skim et open-gl ça m'a l'air intéressant (je dis ça mais je dis rien). Ca va faire drôle de se mettre dans la peau d'un spectateur.  
Allez à plus

 
 
 
Salut.
 
J'y connais rien en Scheme mais vu que le but c'est d'en parler, serait-il possible d'avoir une vrai présentation de celui-ci dans le 1er post (Quel type de langage, avantage, inconvénient, utilisation, etc, etc)?
 
Je sais j'ai qu'à aller voir les liens mais tant qu'à faire, vu que c'est le but du topic, autant le mettre direct dedans.
 
Voilà.

 
Tu as raison, c'est une remarque constructive dont en prendras compte avec le_courtois, promis (avant ce week-end ce seras fait)!
 
 

 
 Je ne vois pas ou est le probleme, je n'ai pas dis que c'était bien ni mal, j'ai juste dis que sans les structures de controles ... bein c'est la memerde Je m'explique un peu, les structures de controles en Scheme permettent le passage par reference et sont donc indispensables. T'as une dent contre elles ou bien ?  
 
 Sinon j'ai pas tres bien compris cette histoire d'effet "cut", c'est bien ou mal ? A partir du moment ou un langage possede les continuations, les goto et autres ne sont pas vraiment un probleme.
 

 
Non, surtout pas j'aimerais bien qu'on termine notre petit agenda, ce qui nous empeche pas de faire autres chose, bien entendu. Mon objectif est d'avoir à la fin un ptit executable windows en statique (sans les dll et companie) ...   Histoire, qu'une fois finit on puisse dire: voilà les gens ! On peut faire des choses en Scheme qui pourraient eventuellement servir.
 
Et pour la simulation de la corde c'est quand tu veux (c'est accessible a tout le monde et un peu de physique ne nous fera pas de mal), ca va ramer sur les petites machines mais ce sera une occasion pour optimiser un peu le tout ! Faut faire des fractales en 3D aussi et puis et puis ... pleins de trucs "Tellement de choses à faire et si peu de temps !"  
 
PS : Anna, se sera un grand honneur pour nous tous ici presents de lire et poster sur TON topic sur les langages fonctionnels purs. Je sais que t'as surement autre chose à faire mais, bordel y a pas que du PHP, C, HTML dans la vie (de ce topic ?). Je plaisante bien sur mais en tout cas moi je suis interessé, et j'éspere ne pas être le seul !

 
T'es la bienvenue, voyons        

annadivx-> Ben non,pars pas !
 
Chronoklazm -> T'as raison, c'était stupide de ma part, cette proposition. C'est la semaine, en ce moment j'arrête pas.
 Je vais tenter me m'atteler à l'historique.Edit: pour m'éviter de poster des idioties, veux-tu superviser ma prose ? On passe par les messages privés ou autrement?
 
Niala->bien vu, merci.

a

Merci à tous pour ce topic de compet'! je desesperais de trouver un jour des tips concernant les GUI en scheme!!
moi j'ai un peu les memes questions que mon predecesseur : plus j'en saurai sur le GUI, plus je serai content!
 
encore bravo, et surement à tres bientot sur ce forum, le temps de dormir quelques heures

Bon si tu as deja fait du graphique avec d'autres langages, ca ne devrait pas trop poser de probleme sinon tu recupere le texte de ton text-field% (send Tirer get-text) Attention tu va recuperer une string donc faudras la parser !! Si c'est des coordonées valides tu fait un send sur ton canvas% principal pour dessiner dedans.  
Tu peux meme recuperer les coordonées de la souris quand on click sur le canvas pour en faire une action consequente (regarde l'aide sur les canvas).  
 
A mon avis tu devrais faire deux canvas dans le cadre1, ensuite moi je ferais des grilles (de ptites images de mer dedans) car avoir une seule image en tant que champs de jeu ne te permet pas de redessiner une partie seuelement (y a ptet un moyen mais ca doit etre chaud). Donc dans ton canvas il faut encore faire des choses dedans ...
 

"A pane% object has a degenerate placement strategy for managing its children; it places them all in the upper left corner and does not stretch any of them. The horizontal-pane% and vertical-pane% classes provide useful geometry management." Faut jongler avec alignement je crois ...
 

"A dc<%> object is a drawing context for drawing graphics and text. It represents output devices in a generic way; e.g., a canvas has a drawing context, as does a printer."

Je te remercie  chronoklazm ...
Cependant j'ai pas fait de pgm avt a part maple (mais ca a rien a voir)
du coup je vois pas comment on peut changer l'image qui se trouve a l'endroit (32*x , 32 *y) dans mon cas ...
si tu pouvais m'aider ...
aussi je comprends tjrs pas la fction canvas :
ca ca veut dire quoi :

 ???
merci d'avance ...

aussi j'ai une autre question :
Comment fait-on pour vérifier le type d'un parametre
je veux une fonction qui me dit si f est une fction...
si y est une chaine de caractere  
comme (integer? x) nous dit si x est entier real? un reel ...
Merci d'avance

 
> (procedure? (lambda(x)()))
#t

 
"A canvas% object is a general-purpose window for drawing and handling events."
Comme je te l'ai dit plus haut, changer une zone de ton canvas est assez chaud. Mais je crois que tu ne peux pas le faire directement.
 
Il faut passer par un bitmap-dc% :
 
"Drawing to a bitmap-dc% with a color bitmap is guaranteed to produce the same result as drawing into a canvas% instance (with appropriate clipping and offsets)."
 
Perso, j'ai jamais fait.

 
EDIT : Pour dessiner dans le canvas il faut passer par le paint-callback ou c est le canvas et e l'environnemt.
Un truc du style
(paint-callback  
     (lambda (c e)  
         (let ((dc (send c (get-dc))))
           (send dc clear)
           ...)))
 
RE-EDIT : La prochaine fois fait un topic carrement.