Problème de programmation en scheme

Bonjour,

j'ai un gros problème de programmation sur dr scheme. Je cherche a mettre en place un jeu de morpion, mon problème se situe au niveau de la fonction "applique" il me semble mais je n'arrive pas à mettre la main dessus.
Après plusieurs essais comme vous pourrez le constatez plusieurs éléments du code ne servent pas à grand chose, je commence à perdre toute motivation pour ce logiciel.
Si quelqu'un pouvait m'aider ça m'arrangerai énormément j'avoue être à court d'idées. Je vous envoie la totalité de mon code, histoire de bien capter le pbm... Merci d'avance pour tout.

Dsl pour la syntaxe...

(define tablier '(r r r r r r r r r))

(define (position n liste)
(if (= n 1) (car liste) (position (- n 1) (cdr liste))))

(define (extraire lp tablier)
(define (aux pos acc)
(if (null? pos) (reverse acc)
(aux (cdr pos) (cons (position (car pos) tablier) acc))))
(aux lp '()))


;(define L1 (extraire '(1 2 3) tablier))
;(define L2 (extraire '(4 5 6) tablier))
;(define L3 (extraire '(7 8 9) tablier))
;(define L4 (extraire '(1 4 7) tablier))
;(define L5 (extraire '(2 5 8) tablier))
;(define L6 (extraire '(3 6 9) tablier))
;(define L7 (extraire '(1 5 9) tablier))
;(define L8 (extraire '(3 5 7) tablier))

(define (modifier tabl n)
(if (= n 1) (if (eq? (car tabl) 'r) (cons 'x (cdr tabl))
(begin (display 'erreur) tabl))
(cons (car tabl) (modifier (cdr tabl) (- n 1))) ))

(define (modifier2 tabl n)
(if (= n 1) (if (eq? (car tabl) 'r) (cons 'o (cdr tabl))
(begin (display 'erreur) tabl))
(cons (car tabl) (modifier2 (cdr tabl) (- n 1)))))


(define (modifier_mmc tabl pos val)
(if (= pos 1) (if (eq? (car tabl) 'r) (cons val (cdr tabl))
(begin (display 'erreur) tabl))
(cons (car tabl) (modifier_mmc (cdr tabl) (- pos 1) val)) ))

(define (modifier_mmcLst tabl lpos lval)
(if (null? lpos) tabl
(modifier_mmcLst (modifier_mmc tabl (car lpos) (car lval)) (cdr lpos) (cdr lval))))

(define Base '(
( (R O O) (O O O))
( (O R O) (O O O))
( (O O R) (O O O))
( (R X X) (O X X))
( (X R X) (X O X))
( (X X R) (X X O))
( (R R O) (O R O))
( (R O R) (O O R))
( (O R R) (O R O))
( (R R R) (O R R))
( (R R X) (O R X))
( (R X R) (R X O))
( (X R R) (X R O))
( (R O X) (O O X))
( (R X O) (O X O))
( (O R X) (O O X))
( (O X R) (O X O))
( (X O R) (X O O))
( (X R O) (X O O))))
;(O X O)
;(O O X)
;(O X X)
;(X X X)
;(X O X)
;(X X O)
;(X O O)
;(O O O)






(define (case lig col) (+ (* (- lig 1) 3) col))



(define (jeu tablier)
(jeu (remplir (ordi tablier)))
)


(define (select tablier regles)
(if (equal? (extraire '(1 2 3) tablier) (caar regles))
( cons '(1 2 3) (extraire '(1 2 3) tablier))
(if (equal? (extraire '(4 5 6) tablier) (caar regles))
(cons '(4 5 6) (extraire '(4 5 6) tablier))
(if (equal? (extraire '(7 8 9) tablier) (caar regles))
(cons '(7 8 9) (extraire '(7 8 9) tablier) )
(if (equal? (extraire '(1 4 7) tablier) (caar regles))
(cons '(1 4 7) (extraire '(1 4 7) tablier))
(if (equal? (extraire '(2 5 8) tablier) (caar regles))
(cons '(2 5 8) (extraire '(2 5 8) tablier))
(if (equal? (extraire '(3 6 9) tablier) (caar regles))
(cons '(3 6 9) (extraire '(3 6 9) tablier))
(if (equal? (extraire '(1 5 9) tablier) (caar regles))
(cons '(1 5 9) (extraire '(1 5 9) tablier))
(if (equal? (extraire '(3 5 7) tablier) (caar regles))
(cons '(3 5 7) (extraire '(3 5 7) tablier) )
(select tablier (cdr regles)))))))))))






(define (ordi unTablier)
(let ((PtiTablier (cdr (select unTablier base))))
(display (cherche PtiTablier base))))


(define (estPossible NotreEtat plist)
(equal? NotreEtat plist)
)

(define (applique tablier Plist regles)
(let( (NEtat (cdr (select tablier regles))) )
(if (equal? NEtat Plist) (modifier_mmcLst tablier (car (select tablier regles)) (cdr (car regles)))
(applique tablier PList (cdr regles)))))


(define (cherche unEtat regles)
(if (null? regles) unEtat
(let (
(first (caar regles))
(rest (cdr regles)))
(if (estPossible unEtat first) (applique unEtat first regles)
(cherche unEtat rest)))))



(define (elem k L)
(if (null? L) #f
(if (equal? k (car L)) #t (elem k (cdr L))
)
)
)





(define maList '())



(define (remplir tablier) ;remplir la case par le joueur
(display "donnez le numero de ligne et ensuite de colonne ")
(let ((cl (read)) (cc (read)))
(begin (display (modifier tablier (case cl cc))) (modifier tablier (case cl cc)))))



(define (partiefinie)
(if (eq? (elem 'r tablier) #f) #t))

(define (gagne)
(if (eq? (partiefinie) #t) (display "personne ne gagne")
(if (equal? (or (L1 L2 L3 L4 L5 L6 L7 L8)) '(x x x))
(display "le joueur gagne")
(if (equal? (or (L1 L2 L3 L4 L5 L6 L7 L8)) '(o o o))
(display "l'ordinateur gagne")
)
)
)
)