;; Solution 1.
  (define-struct regle (conditions consequence))
  
  ;; Solution 2.
  ;;(define-struct regle (id conditions consequence))
  
  
  ;; Pour rendre la syntaxe des règles plus claires.
  (define (si . a) a)
  (define (alors a) a)
  
  ;; Liste de règles
  (define base-de-regles
    (list
     (make-regle (si '(cet animal donne du lait))
          (alors '(cet animal est un  mammifere)))
     (make-regle (si '(cet animal a des plumes))
          (alors '(cet animal est un  oiseau)))
     (make-regle (si '(cet animal vole)
      '(cet animal pond des oeufs))
          (alors '(cet animal est un  oiseau)))
     (make-regle (si '(cet animal est un  mammifere)
      '(cet animal mange de la viande))
          (alors '(cet animal est un  carnivore)))
     (make-regle (si '(cet animal est un  carnivore)
      '(cet animal est de couleur fauve)
      '(cet animal a des taches noires))
          (alors '(cet animal est un  guepard)))
     (make-regle (si '(cet animal a des dents pointues)
      '(cet animal a des griffes))
          (alors '(cet animal est un  carnivore)))
     (make-regle (si '(cet animal a des poils))
          (alors '(cet animal est un  mammifere)))
     (make-regle (si '(cet animal est un  oiseau)
      '(cet animal est jaune))
          (alors '(cet animal est un canari)))
     )
    )
  
  ;; Liste de faits
  (define base-de-faits '())
  
  ;; Solution 2.
  ;;(define regles-activees '())
  
  
  ;; On rentre les faits, puis on lance l'inférence
  (define (main)
    (display "Entrez les faits observés")
    (newline)
    (set! base-de-faits (read))
    (inferer))
  
  ;; On parcours l'ensemble des règles.
  ;; Si un règle a été appliquée, on relance le parcours.
  (define (inferer)
    (if (parcourir-regles base-de-regles) (inferer) '()))
  
  ;; On teste chaque règle.
  (define (parcourir-regles regles)
    (if (null? regles) #f
        (or (teste-regle (car regles))
     (parcourir-regles (cdr regles)))))
  
  ;; On regarde si la règle peut être appliquée.
  ;; Pour cela il faut que les conditions soient vérifiées
  ;; et que la conséquence ne soit pas déjà présente
  ;; dans les faits.
  (define (teste-regle regle)
    (and (sont-verifiees (regle-conditions regle))
         (ajoute-aux-faits (regle-consequence regle))))
  
  (define (sont-verifiees conditions)
    (if (null? conditions)
        #t
        (and (est-verifiee (car conditions) base-de-faits)
      (sont-verifiees (cdr conditions)))))
  (define (est-verifiee condition faits)
    (if (null? faits)
        #f
        (or (equal? (car faits) condition)
            (est-verifiee condition (cdr faits)))))
  
  ;; ajoute-aux-faits regarde si la conséquence à ajouter
  ;; aux faits est déjà dans ceux-ci. Si oui, elle renvoit faux.
  ;; Sinon, elle affiche la conséquence, l'ajoute aux faits et
  ;; renvoie vrai.
  (define (ajoute-aux-faits consequence)
    (if (member consequence base-de-faits)
        #f
        (begin
   (set! base-de-faits (cons consequence base-de-faits))
          (write consequence)
          (newline)
   #t
   )))
  
  ;; Un exemple de base de faits:
  ;((cet animal a des poils)
  ;(cet animal a des dents pointues)
  ;(cet animal a des griffes)
  ;(cet animal a des taches noires)
  ;(cet animal est de couleur fauve))