Wsrtjtyk

I am building a function is Lisp ta reverses the first and last element of a list. I get that a list has a car and a cdr hence why there is a dot in my output. Is there a way to remove the dot?

(defun my-butlast (list)

  (loop for l on list

      while (cdr l)

      collect (car l)))



(defun f-l-swap(list)

  (append (last list)(cdr (my-butlast list))(car list))

 )



(write(f-l-swap '(A B C D E)))



OUTPUT:

(E B C D . A)

append expects arguments to be lists. In your case (car list) is an atom. You have to change it to list if you want to stick with append. Ie:

(defun f-l-swap (list)

  (append (last list)

          (cdr (my-butlast list))

          (list (car list))))

A list is a chain of cons pairs. eg. (1 2 3) is the visualization of (1 . (2 . (3 . ()))). In the event the last cdr is not () you have what we call a dotted list since then there is no simplified visualization of the last part. It has to be printed with a dot.

You have (E . (B . (C . (D . A)))) and want to have (E . (B . (C . (D . (A . ()))))). Do you see the difference? (car list) is not a list but one elment and that is why you get a dotted list.

Here are more sensible implementations of append and butlast:

(defun my-append (a b)

  (if (null a)

      b

      (cons (car a) (my-append (cdr a) b))))

That only supports 2 arguments, but the idea for more is that it continues until you have consed all the previous lists and only have one left, which verbatim becomes the tail. Here is how that might look:

(defun my-append2 (x &rest xs)

  (labels ((helper (x xs)

             (cond ((null xs) x)

                   ((null x) (helper (car xs) (cdr xs)))

                   (t (cons (car x) (helper (cdr x) xs))))))

    (helper x xs)))

Here is butlast

(defun my-butlast (xs)

  (if (null (cdr xs))

      '()

      (cons (car xs) (my-butlast (cdr xs)))))

Now, one should really do it with higher order functions or loop, but then you get the facts hidden how lists work. The code above shows you have they work.