(assert (a))
(facts)
(reset)

(assert (essaie "cou-cou" 1 1.1))
(facts)
(reset)
(clear)

(assert (a))
(assert (a))
(set-fact-duplication TRUE)
(assert (a))
(assert (a))
(facts)
 

(deftemplate person			;  une relation pour un person
	"record pour une person"	;  commentaire optionnel
	(slot name			        ; nom du person
		   (type STRING)		   ; Type chaine de caract¸res
		   (default "Pierre Dupont"))	; Par dˇfaut 
	(slot age				
		   (type INTEGER)		   ;  age est un entier
		   (default -1))			   ; si on ne sait pas
)

(assert (person (name "jim")))
(modify 0 (age "seven"))

(deftemplate person			;  une relation pour un person
	"record pour une person"	;  commentaire optionnel
	(slot name			        ; nom du person
		   (type STRING)		   ; Type chaine de caract¸res
  )	
(slot age )
)

(ppdeftemplate person)
(deftemplate MAIN::person "record pour une person"
   (slot name (type STRING) (default "Pierre Dupont"))
   (slot age (type INTEGER)))

(assert (person))
(assert (person (name "joe")))
(assert (person (name "jim") (age 39)))

(modify 2 (age ten))
(facts)
(modify 4 (name "John Doe"))
(modify 7 (age ten))
	(list-deftemplates)
	(ppdeftemplate person)
	(undeftemplate person)

;; allowed symbols example

(clear)

;; On peut limiter les valeurs possible

(deftemplate person			;  une relation pour un person
	 "record pour une person"	;  commentaire optionnel
	(slot name				; nom du person
	 	(type STRING)		; Type chaine de caract¸res
	 	(default "Pierre Dupont"))	; Par dˇfaut 
	(slot age				; masculin ou fˇminine
	 	(type NUMBER)		;  age est un entier
	 	(default -1)		; si on ne sait pas
	 	(range -1 122))  ; declare les valeurs possible
 (slot metier      ; sa mˇtier
   (type SYMBOL)
   (allowed-symbols artiste ingenieur comercant)
 )
)


(assert (person))

;; deffacts example 

(deftemplate emplacement
	(slot nom (type SYMBOL) (default NIL))
	(slot x (type NUMBER) (default -1))
	(slot y (type NUMBER)(default -1))
	(multislot voisins (default NIL))
)

(deftemplate emplacement
	(slot nom (type SYMBOL) (default NIL))
	(slot x (type NUMBER) (default -1))
	(slot y (type NUMBER)(default -1))
	(multislot voisins (type SYMBOL) (default NIL))
)

(deffacts reseaux-d-emplacements
	 (emplacement (nom A) (x 0) (y 0) (voisins B C))
 	(emplacement (nom B) (x 0) (y 1) (voisins A D))
	 (emplacement (nom C) (x 1) (y 0) (voisins A I))
)

	(list-deftemplates)
	(ppdeftemplate <template-name>)
	(undeftemplate <template-name>)



(clear)
(deffacts faits-de-nuit
	"Ceux-ci sont vrai le nuit"
	(soleil couche)
	(etoiles visibles)
)
(reset)


;; rule examples
(set-fact-duplication TRUE)

(defrule eat-cookies
	(cookie)
=>
	(printout t "I want a cookie" crlf))

(defrule eat-cookies
	?c <- (cookie)
=>
	(printout t "cookie " ?c " is mine." crlf)
  (retract ?c)
)


(assert (cookie))
(assert (cookie))
(facts)

(run 1)

(clear)

;; variables d'indice 

(defrule rule-A
	?f <- (a)
=>
	(printout t "Il Existe  " ?f  crlf)
)
(assert (a))
(run)

Il Existe  <Fact-4>

CLIPS> (ppdefrule rule-A)
(defrule MAIN::rule-A
   ?f <- (a)
   =>
   (printout t "Il Existe  " ?f crlf))
CLIPS> (ppdefrule eat-cookies)
(defrule MAIN::eat-cookies
   (cookie)
   =>
   (printout t "I want a cookie" crlf))
CLIPS> 


(defrule rule-A
	?f <- (a)
=>
	(printout t "Retracting  " ?f  crlf)
	(retract ?f)
)
(assert (a))
(run)



(defrule rule-A-Bis
	?f <- (a)
=>
)

(deftemplate A (slot B (default 0)))

(assert (A))

(defrule rule-A
	?f <- (A (B 0))
=>
	(printout t "Changing  " ?f  crlf)
	(modify ?f (B 1))
)

(defrule rule-A-2
	?f <- (A (B 1))
=>
	(printout t "Changing  " ?f  crlf)
	(modify ?f (B 1))
)


(assert (A))


;;; example de variables - Variable d'attribut

(clear)

(assert (a b c d e f))
(assert (a b c))
(assert (b c d))
(defrule test 
   (a ? ?)
=>
  (printout t "test est execute." crlf)
)

(defrule test2
    (a $?x )
=> 
  (printout t "test est execute avec. " $?x crlf)
)

(defrule test2
    (a $? ?x $?)
=> 
  (printout t "x = "  ?x "!!" crlf)
)


(defrule traiter-1-sur-3
   (a ?x ?)
=>
(printout t "x = " ?x crlf)
)

(defrule traiter-1-sur-3
   (? ?x ?)
=>
(printout t "x = " ?x crlf)
)

(defrule traiter-1-sur-3
   (a ?x ?)
   (b ? ?x)
=>
(printout t "x = " ?x crlf)
)

(assert (


(run)

(defrule traiter-une-liste
   (a $?x)
=>
(printout t "x = " $?x crlf)
)
(run)

(defrule traiter-une-liste
   (a $?x $?)
=>
(printout t "x = " $?x crlf)
)



(defrule test0
   (a $? ?x $?)
=>
(printout t "x = " ?x crlf)
)
(run)

(defrule test0
   (a $? ?x)
=>
(printout t "x = " $?x crlf)
)
(run)

(defrule test1
   (a $?x)
=>
(printout t "x = " $?x crlf)
)
(run)

(defrule test1
   (a $? ?x $?)
=>
(printout t "x = " ?x crlf)
)
(run)

(defrule test3
   (a $?x $?)
=>
(printout t "x = " $?x crlf)
)
(run)

(clear)

(defrule traiter-une-liste
   (a $?x)
=>
(printout t "x = " $?x crlf)
)


;; Avec deftemplate
(deftemplate A (slot B))

(deftemplate A (slot B (default 0)))
(defrule rule-A
	?f <- (A (B 0))
=>
	(printout t "Changing  " ?f  crlf)
	(modify ?f (B 1))
)
(assert (A ))
(assert (A (B 1)))
(run)

(defrule test
   "Dont do this!@!!"
   (a ?n1 ?x)
   (b ?n2 ?y&:(eq ?x ?y))
=>
   
)

(defrule test
  "Do this"
   (a ?n1 ?x)
   (b ?n2 ?x)
=>
   
)




(deftemplate person			;  une relation pour un person
	"record pour une person"	;  commentaire optionnel
	(slot famille				; nom du person
		(type STRING)		; Type chaine de caract¸res
		(default " Dupont"))	; Par dˇfaut 
	(slot prenom				; nom du person
		(type STRING)		; Type chaine de caract¸res
		(default "Pierre"))	; Par dˇfaut 
	)


(defrule Find-same-name
	?P1 <- (person (famille ?n1) (prenom ?b))
	?P2 <- (person (famille ?n2) (prenom ?b))
=>
	(printout t ?b " " ?n1 " et  " ?b " "  ?n2 " Ont le meme prenom" crlf)
)

(defrule Find-same-name
	?P1 <- (person (famille ?n1) (prenom ?b))
	?P2 <- (person (famille ?n2) (prenom ?b))
  (test (neq ?n1 ?n2))
=>
	(printout t ?b " " ?n1 " et  " ?b " "  ?n2 " Ont le meme prenom" crlf)
)

(defrule Find-same-name
	?P1 <- (person (famille ?n1) (prenom ?b))
	?P2 <- (person (famille ?n2) (prenom ?b))
  (test (neq ?P1 ?P2))
=>
	(printout t ?b " " ?n1 " et  " ?b " "  ?n2 " Ont le meme prenom" crlf)
)

(defrule Find-same-name
	?P1 <- (person (famille ?n1) (prenom ?b))
	?P2 <- (person (famille ?n2) (prenom ?b))
  (test (neq ?n1 ?n2))
=>
	(printout t ?b ?n1 " et  " ?b ?n2 "Ont le meme prenom" crlf)
 (retract ?P2)
)

(assert (person (famille "dupont") (prenom "pierre")))
(assert (person (famille "durant") (prenom "pierre")))
(assert (person))


(deftemplate person			;  une relation pour un person
	"record pour une person"	;  commentaire optionnel
	(slot famille				; nom du person
		(type STRING)		; Type chaine de caract¸res
		(default "Dupont"))	; Par dˇfaut 
	(slot prenom				; nom du person
		(type STRING)		; Type chaine de caract¸res
		(default "Pierre"))	; Par dˇfaut 
	)

(assert (person (famille "Dupres")))


(defrule Find-same-name
	?P1 <- (person (famille ?n1) (prenom ?b))
	?P2 <- (person (famille ?n2) (prenom ?b))
=>
	(printout t ?b " " ?n1 " et  " ?b " "  ?n2 " Ont le meme prenom" crlf)
)



(defrule Find-same-name
	(person (famille ?n1) (prenom ?b))
	(person (famille ?n2) (prenom ?b))
  (test (neq ?n1 ?n2))
=>
	(printout t ?b " " ?n1 " et  " ?b " "  ?n2 " Ont le meme prenom" crlf)
)

(defrule Find-same-name
   ?P1 <- (person (famille ?n1) (prenom ?b))
	   ?P2 <- (person (famille ?n2) (prenom ?b))
    (test (neq ?n1 ?n2))
=>
	(printout t ?b ?n1 " et  " ?b ?n2 " Ont le meme prenom" crlf)
 (retract ?P2)
)

(assert (person (famille "dupont") (prenom "pierre")))
(assert (person (famille "durant") (prenom "pierre")))



(defrule test3
   (couleur ?x & vert | bleu)
=>
   (assert (ok))
)
(defrule feu-rouge
	(couleur ?x&~vert&~jaune)
=>
	(assert (il faut arreter))
      (printout t "arret" crlf)
)

(defrule test3
   (couleur)
=>
   (assert (ok))
)
(assert (couleur vert))
(assert (couleur rouge))
	
(defrule feu-rouge
	(couleur ?x&~vert&~jaune)
=>
	(assert (il faut arreter))
      (printout t "arret" crlf)
)


(defrule example-2
  (data ?x&~:(symbolp ?x))
  =>)


(defrule example-5
  (data $?x&:(> (length$ $?x) 3))
  =>)



(deffunction ma-fonction (?x)
	(printout t "L'argument est " ?x crlf)
)

(ma-fonction fou)

(deffunction test (?a ?b) 
   (return (+ ?a ?b) )
)

(deffunction test (?a ?b) 
   (+ ?a ?b) 
)


(deffunction test (?a ?b) 
		(+ ?a ?b) (* ?a ?b)
)

(deffunction test (?a ?b) 
		(return (create$ (+ ?a ?b) (* ?a ?b)))
)

(deffunction distance (?x1 ?y1 ?x2 ?y2)
   (bind ?dx (- ?x1 ?x2))
   (bind ?dy (- ?y1 ?y2))
   (sqrt (+ (* ?dx ?dx) (* ?dy ?dy)))
)
(distance 0 0 1 1)

(defrule test
  =>
(assert (distance (distance 0 0 1 1)))
)

(defrule test
  =>
(assert (distance distance))
)

(deftemplate distance
  (slot d)
)

(



(test 3 2)

(deftemplate person			;  une relation pour un person
	"record pour une person"	;  commentaire optionnel
	(slot famille)	; Par dˇfaut 
	(slot prenom)				; nom du person
	)

(defrule ask-user
	?P <- (person (famille nil) (prenom nil))
=>	
	(printout t "Prenom? ")
	(bind ?prenom (read))
	(printout t "Nom de famille? ")
	(modify ?P (prenom ?prenom) (famille (read)))
)

(defrule ask-user
	(person)
=>	
	(printout t "Prenom? ")
	(bind ?prenom (read))
	(printout t "Nom de famille? ")
	(assert (person ?prenom (read)))
)

(deftemplate A (slot B))


(defrule test
 ?x<-  (A)
=>
 (modify ?x)
)

(


(defrule ask-user-more
	(person ?pre ?nom)
=>	
	(printout t "addresse du  "?pre " " ?nom
   "?")
	(bind ?address (readline))
	(assert (person ?pre ?nom ?address))
)

(defrule ask-user-more
	(person ?pre ?nom)
=>	
	(printout t "addresse du  "?pre " " ?nom
   "?")
	(bind ?address (readline))
	(assert (person ?pre ?nom (str-explode ?address)))
)

(assert (person))


(defrule j-existe-je-pense
	 (je pense)
=>
	 (assert-string "(Je pense que j'existe)")
)

(defrule exemple
	(personne nom ?x)
	 (not (pere-de ?x  ?y))
	=>
)


(defrule test-halt
    (person)
=>
(halt)
(assert (catch fire))
)

(defrule test
   (go)
=>
(build "(deftemplate Thing (slot a))")
)