В конце списка добавить все его элементы, располагая их в обратном порядке

(defun mirror (list)
  (append list (reverse list)))

(defun reverse (list)
  (reverse-iter list nil))
 
(defun reverse-iter (list result)
  (if (null list)
      result
      (reverse-iter (cdr list)
                    (cons (car list) result))))
 
(defun append (xs ys)
  (cond ((null xs) ys)
        ((null ys) xs)
        (t (cons (car xs)
                 (append (cdr xs) ys)))))

(defun mirror (list)
  (mirror-rec list nil))
 
(defun mirror-rec (list reflection)
  (if (null list)
      reflection
    (let ((head (car list))
          (tail (cdr list)))
      (cons head (mirror-rec tail (cons head reflection))))))

(defun ff (lst &optional r1 r2)
  (cond ((null lst) (append r2 r1))
        (t (ff (cdr lst) (cons (car lst) r1) (append r2 (list (car lst)))))))
      
==> ff
 
(ff '(1 2 3))
 
==> (1 2 3 3 2 1)

(defun -reverse (w)
  (cond ((null w) nil)
        ((-append (-reverse (cdr w)) (list (car w))))))
 
(defun -append (w v)
  (cond ((null w) v) 
        ((cons (car w) (-append (cdr w) v)))))
 
(defun append-reverse (w)
  (-append w (-reverse w)))
 
> (append-reverse '(1 2 3))
(1 2 3 3 2 1)

(defun -reverse (w)
  (when w(-append (-reverse (cdr w)) (list (car w)))))
 
(defun -append (w v)
  (if (null w) v (cons (car w) (-append (cdr w) v))))
 
(defun append-reverse (w)
  (-append w (-reverse w)))
 
> (append-reverse '(1 2 3))
(1 2 3 3 2 1)

(defun -append (w v)
  (if (null w) v (cons (car w) (-append (cdr w) v))))
 
(defun append-reverse (w &optional (v w) acc)
  (cond ((null w) (-append v acc))
        ((append-reverse (cdr w) v (cons (car w) acc)))))
 
> (append-reverse '(1 2 3))
(1 2 3 3 2 1)

(defun -append (w v)
  (if (null w) v (cons (car w) (-append (cdr w) v))))
 
(defun append-reverse (w &optional (v w) acc)
  (if (null w) (-append v acc) (append-reverse (cdr w) v (cons (car w) acc))))
 
> (append-reverse '(1 2 3))
(1 2 3 3 2 1)

(defun task (lst)
   (let ((a lst)
         (b nil))
        (dolist (i lst (append a b))
          (setq b (cons i b)))))
 
==> task
 
(task '(1 2 3))
 
==> (1 2 3 3 2 1)

(defun task (lst)
  (reduce #'(lambda (x y) (append y (list x))) lst :initial-value lst :from-end t))
 
==> task
 
(task '(1 2 3 4))
 
==> (1 2 3 4 4 3 2 1)

(defun task (lst)
  (append lst (iter (for i in lst) (collecting i at start))))
 
==> task
 
(task '(1 2 3 4))
 
==> (1 2 3 4 4 3 2 1)

(defun mirror (lst)
   (labels ((ap (x y)
                (cond ((null x) y)
                      (t (cons (car x) (ap (cdr x) y)))))
              (rv (x)
                (cond ((null x) nil)
                      (t (ap (rv (cdr x)) (list (car x)))))))
   (ap lst (rv lst))))     
 
==> mirror
 
(mirror '(1 2 3))
 
==> (1 2 3 3 2 1)