Удалить из " нелинейного списка " все повторяющиеся элементы (м.б., не атомы) на Lisp

> (rm '(1 (2 2 3) 4 (3 2 3) (8 9)  5 1 (8 9)) (2 2 3))       
==> ( 4 (3 2 3) 5)

(defun dump-top-level-duplicates (w)
  (cond ((null w) nil)
        ((member (car w) (cdr w) :test #'equalp)
         (dump-top-level-duplicates (remove (car w) (cdr w)
                                            :test #'equalp)))
        ((cons (car w) (dump-top-level-duplicates (cdr w))))))
 
> (dump-top-level-duplicates '(1 (2 2 3) 4 (3 2 3) (8 9) 5 1 (8 9) (2 2 3)))
(4 (3 2 3) 5)

(defun del-dup (lst &optional (r nil))
  (cond ((null lst) (reverse r))
        ((member (car lst) (cdr lst)) (del-dup (remove (car lst) (cdr lst)) r))
        (t (del-dup (cdr lst) (cons (car lst) r)))))
 
==> del-dup
 
(del-dup '(1 (2 2 3) 4 (3 2 3) (8 9) 5 1 (8 9) (2 2 3)))
 
==> (4 (3 2 3) 5)
 
(defun del-dup (lst)
  (let ((r nil))
    (iter (for a in lst)
      (when (= 1 (count-if #'(lambda (x) (equal x a)) lst)) (collecting a into r)))
    r)) 
 
==> del-dup
 
(del-dup '(1 (2 2 3) 4 (3 2 3) (8 9) 5 1 (8 9) (2 2 3)))
 
==> (4 (3 2 3) 5)

(defun dump-top-level-duplicates (w
                                  &optional ac
                                  &aux (a (car w)) (d (cdr w)))
  (cond ((null w) (reverse ac))
        ((member a d :test #'equalp) (dump-top-level-duplicates
                                      (remove a d :test #'equalp)
                                      ac))
        (t (dump-top-level-duplicates d (cons a ac)))))
 
> (dump-top-level-duplicates '(1 (2 2 3) 4 (3 2 3) (8 9) 5 1 (8 9) (2 2 3)))
(4 (3 2 3) 5)

(defun dump-top-level-duplicates (w)
  (loop for a in w
        when (= (count a w :test #'equalp) 1)
        collect a)) 
 
> (dump-top-level-duplicates '(1 (2 2 3) 4 (3 2 3) (8 9) 5 1 (8 9) (2 2 3)))
(4 (3 2 3) 5)

> (f '(1 (2 2 3) 4 (3 2 3 5 (8 9)) (8 9) 5 1 (8 9) (2 2 3) (2 2 3 (3 2 3 5 (8 9)))))
...

(defun dump-top-level-duplicates (w)
  (cond ((null w) nil)
        ((member (car w) (cdr w) :test #'equalp)
         (dump-top-level-duplicates (remove (car w) (cdr w)
                                            :test #'equalp)))
        ((cons (car w) (dump-top-level-duplicates (cdr w))))))
 
> (dump-top-level-duplicates '(1 (2 2 3) 4 (3 2 3 5 (8 9)) (8 9) 5 1 (8 9) (2 2 3)))
(4 (3 2 3 5 (8 9)) 5)

;; racket-lang.org
(define (foo lst)
  (let ((m null))
    (let loop ((lst lst))
      (cond [(null? lst) null]
            [(list? (car lst)) (cons (loop (car lst)) (loop (cdr lst)))]
            [(member (car lst) m) (loop (cdr lst))]
            [else (begin 
                    (set! m (cons (car lst) m))
                    (cons (car lst) (loop (cdr lst))))]))))
 
(foo '(1 (2 2 3) 4 (3 2 3 5 (8 9)) (8 9) 5 1 (8 9) (2 2 3)))
;'(1 (2 3) 4 (5 (8 9)) () () ())

(defun dump-top-level-duplicates (w)
  (loop for a in w
        if (= (count a w :test #'equalp) 1)
        collect a)) 
 
> (dump-top-level-duplicates '(1 (2 2 3) 4 (3 2 3) (8 9) 5 1 (8 9) (2 2 3)))
(4 (3 2 3) 5)