;; Partie 1
  
  (define (carre x) (* x x))
  (define (compose-functions l)
    (if (null? (cdr l))
        (eval (car l))
        (lambda (x)
   ((eval (car l)) ((compose-functions (cdr l)) x)))))
  
  
  ;; Partie 2
  (define (max-list l)
    (if (null? (cdr l)) (car l)
        (let ((max-tail (max-list (cdr l)))
       (max-first (car l))
       )
   (if (> max-first max-tail) max-first max-tail))))
  
  (define (max-elem . l)
   (max-list l))
  
  (define (map-list f l)
    (if (null? l)
        ’()
        (cons (f (car l))
              (map-list f (cdr l)))))
  
  ;; Partie 3
  (define ensemble-vide ’())
  (define (ensemble-vide? e)
    (null? e))
  
  (define (ajouter-element x e)
    (cond ((ensemble-vide? e) (list x))
   ((< x (car e)) (cons x e))
   ((= x (car e)) e)
   (#t (cons (car e) (ajouter-element x (cdr e))))))
  
  (define (union e1 e2)
    (if (ensemble-vide? e1)
        e2
        (ajouter-element (car e1) (union (cdr e1) e2))))
  
  (define (appartient? x e2)
    (cond ((ensemble-vide? e2) #f)
   ((< x (car e2)) #f)
   ((= x (car e2)) #t)
   (#t (appartient? x (cdr e2)))))
  
  (define (intersection e1 e2)
    (cond ((ensemble-vide? e1) ensemble-vide)
   ((appartient? (car e1) e2) (ajouter-element (car e1) (intersection (cdr e1) e2)))
   (#t (intersection (cdr e1) e2))))
  
  (define (inclusion? e1 e2)
    (if (ensemble-vide? e1)
        #t
        (and (appartient? (car e1) e2) (inclusion? (cdr e1) e2))))
  
  (define (creer-ensemble  . l)
    (define (creer-ensemble-local  l)
      (if (null? l)
   ensemble-vide
   (ajouter-element (car l) (creer-ensemble-local (cdr l)))))
    (creer-ensemble-local l))
  
  
  ;; Partie 4
  (define (fact n)
   (if (<= n 1) 1 (* n (fact (- n 1)))))
  (define (series f n)
   (if (zero? n) 0
       (+ (f n) (sum f (- n 1)))))
  (define (e-power x n)
   (define (e-taylor i)
     (/ (expt x i) (fact i)))
   (+ #i1 (series e-taylor n)))
  
  ;Somme de la série = exp(x)
  
  
  ;; Partie 5
  (define x ’(salut toi))
  (define y ’(salut toi))
  (equal? x y)
  (eq? x y)
  
  (define x ’salut)
  (define y ’salut)
  (equal? x y)
  (eq? x y)
  
  
  
  
  ;; Partie 6
  (define y 0)
  (set! y 9)
  
  (define (creer-compteur)
    (let ((i 0))
      (list (lambda () i)
     (lambda () (set! i (+ i 1)) i)
     (lambda () (set! i (- i 1)) i)
     )))
  (define (valeur c) ((car c)))
  (define (incremente-compteur c) ((cadr c)))
  (define (decremente-compteur c) ((caddr c)))