В списке L из каждой группы подряд идущих равных элементов оставить только один элемент

(defun compress (w &optional b)
  (cond ((null w) nil)
        ((equal (car w) b) (compress (cdr w) b))
        ((cons (car w) (compress (cdr w) (car w))))))
 
> (compress '(a a b c c c d e e))
(A B C D E)

(defun compress (w)
  (cond ((null w) nil)
        ((equal (car w) (cadr w)) (compress (cdr w)))
        ((cons (car w)
               (labels ((press (w b)
                          (cond ((null w) nil)
                                ((equal (car w) b) (press (cdr w) b))
                                ((cons (car w)
                                       (press (cdr w) (car w)))))))
                 (press (cdr w) nil))))))
 
> (compress '(nil nil nil a a b c nil nil nil c c d e e nil nil nil))
(NIL A B C NIL C D E NIL)

(defun compress (w &optional b f)
  (cond ((null w) nil)
        (f (if (equal (car w) b)
               (compress (cdr w) b t)
               (cons (car w) (compress (cdr w) (car w) t))))
        ((cons (car w) (compress (cdr w) (car w) t)))))
 
> (compress '(nil nil nil a a b c nil nil nil c c d e e nil nil nil))
(NIL A B C NIL C D E NIL)

(defun compress (w &optional b f)
  (cond ((null w) nil)
        ((and f (equal (car w) b)) (compress (cdr w) b t))
        ((cons (car w) (compress (cdr w) (car w) t)))))
 
> (compress '(nil nil nil a a b c nil nil nil c c d e e nil nil nil))
(NIL A B C NIL C D E NIL)

(defun sine-adjacent (w &optional b)
  (cond ((null w) nil)
        ((eq b (car w)) (sine-adjacent (cdr w) b))
        ((cons (car w) (sine-adjacent (cdr w) (car w))))))
 
> (sine-adjacent '(1 2 3 3 4 5 4 4 3 1 1 1))
(1 2 3 4 5 4 3 1)

(defun sine-adjacent (w &optional b)
  (when w (if (eq b (car w))
              (sine-adjacent (cdr w) b)
              (cons (car w)
                    (sine-adjacent (cdr w) (car w))))))
 
> (sine-adjacent '(1 2 3 3 4 5 4 4 3 1 1 1))
(1 2 3 4 5 4 3 1)

defun sine-adjacent (w &optional b ac)
  (cond ((null w) (reverse ac))
        ((eq b (car w)) (sine-adjacent (cdr w) b ac))
        ((sine-adjacent (cdr w) (car w) (cons (car w) ac)))))
 
> (sine-adjacent '(1 2 3 3 4 5 4 4 3 1 1 1))
(1 2 3 4 5 4 3 1)

(defun sine-adjacent (w &optional ac)
  (cond ((null w) (reverse ac))
        ((eq (car w) (cadr w)) (sine-adjacent (cdr w) ac))
        ((sine-adjacent (cdr w) (cons (car w) ac)))))
 
> (sine-adjacent '(1 2 3 3 4 5 4 4 3 1 1 1))
(1 2 3 4 5 4 3 1)

(defun sine-adjacent (w)
  (when w (if (eq (car w) (cadr w))
              (sine-adjacent (cdr w))
              (cons (car w)
                    (sine-adjacent (cdr w))))))
 
> (sine-adjacent '(1 2 3 3 4 5 4 4 3 1 1 1))
(1 2 3 4 5 4 3 1)

(defun sine-adjacent (w)
  (cons (car w)
        (loop for a in w
              for b in (cdr w)
              unless (equalp a b) collect b)))
 
> (sine-adjacent '(1 2 3 3 4 5 4 4 3 1 1 1))
(1 2 3 4 5 4 3 1)

;; racket-lang.org
(define (foo lst)
  (cons (first lst)
        (for/list ((i lst) (j (rest lst)) #:unless (eq? i j))
          j)))

(defun task (lst)
 (let ((res nil)) 
  (iter (for i in lst) (for j in (cdr lst)) 
     (unless (eq i j) (collecting i into res))) 
  (append res (last lst))))
 
==> task
 
(task '(1 2 3 3 4 5 4 4 3))
 
==> (1 2 3 4 5 4 3)
 
(task '(1 2 3 3 4 5 4 4 3 1 1 1))
 
==> (1 2 3 4 5 4 3 1)