Lisp &rest parameters and recursive calls

Question

I have the following Common Lisp Function:

(defun test(A &rest indexes)
  (if (null (first indexes))
      A
    (test (nth (+ 1 (first indexes)) A) (rest indexes))
  )
)

As far as I know &rest parameters are treated as a list in the function body but since

(rest indexes) also returns a list I'm stuck with nested Lists as parameters.

For example (test '("a" "b" "c" ("d" "e")) 3 1 6 7)

would cause indexes to be ((1 6 7)) at the second call.

Is there any way to pass my list without having this problem?

Answer 1

rest is a accessor function that is paired together with first to give you the first element and the rest of the list. rest is the same as cdr.

&rest is a lambda list keyword that slurps the remaining arguments in the variable name that follows it.

You are really looking for apply. Imagine I make a function that can take 0 or more numeric parameters and add them together:

(defun add (&rest numbers)
  (apply #'+ numbers))

Apply can take more than two arguments. The first is the function to call and all but the last are extra arguments that are put in front of the last arguments element. You are guaranteed the implementation supports 50 arguments or upto the number of arguments a function can take in that particular implementation supports above 50.

(apply #'+ 1 2 '(3 4 5)) ; ==> 15

Now recursing by &rest and apply makes inefficient code so you should use higher order functions, loop macro, or make a helper:

;; higher order function
(defun fetch-indexes (a &rest indexes)
  (mapcar (lambda (i) (nth i a)) indexes))

;; loop macro
(defun fetch-indexes (a &rest indexes)
  (loop :for i :in indexes
        :collect (nth i a)))

;; helper function
(defun fetch-indexes (a &rest indexes)
  (labels ((helper (indexes)
             (if (endp indexes)
                 '()
                 (cons (nth (first indexes) a)
                       (helper (rest indexes))))))
    (helper indexes)))

;; test (works the same with all)
(fetch-indexes '(a b c d) 2 3 0 1)
; ==> (c d a b)

Using apply in recursion should be avoided, but I'll show how it's done.

(defun fetch-indexes (a &rest indexes)
  (if (endp indexes)
      '()
      (cons (nth (first indexes) a)
            (apply #'fetch-indexes a (rest indexes)))))

In your example you have nested lists. In order for that to work you would need to flatten it as well. I haven't done that so these supports one proper list of elements.