defun with a list as argument

Question

I'm trying to pick up Lisp as my new language, and I'm having some issues working out how to have parts of a function work on each element of the list passed to it.

For the purpose of learning how to get around this, I am trying to write a fairly basic form of division does not croak when one of the elements of the list are 0 (but instead just returns 0)

(defun divtest (elements)
  (dolist (x elements)
    (if (zerop x) 0 () )
  (/ elements)))))

I try to run this as:

(divtest '(20 2 5))

Which yields:

*** - /: (20 2 5) is not a number

The point of failure seems to be rooted in the fact that i am not "extracting" the elements in the list before passing them to the function (in this case, neither / nor dolist works as intended, as x never evaluates to 0). If I'm right, can someone tell me how to perform this "extraction"?

---

Note: This question is related to one that I've asked earlier, but as I'm unclear about which part of the previous answer actually allowed it to work as intended with this specific problem i decided to go further into the basics

Answer 1

/ takes as arguments one or more numbers, but in your code you're passing it a list - clearly this will not work. The function apply is your friend here - (apply #'foo a b (list c d e)) is equivalent to (foo a b c d e). Note the the arguments to apply between the function to use and the final list are optional, so (apply #'/ '(20 2 5)) is equivalent to (/ 20 2 5).

Also, your attempt at removing zeros will not work. dolist is evaluating its body for each item in the argument list elements, but you're not actually doing anything to change the content of elements (the result of evaluating dolist s body is not reassigned to the source element as you seem to expect).

The functions remove-if (and its destructive counterpart, delete-if) are what you are looking for. The following shows how to use it (it takes lots of optional arguments, which you don't need to worry about for this purpose).

(defun divtest (elements)
  (apply #'/ (remove-if #'zerop elements)))

Also note that this won't behave correctly if the elements list has zero as its first element (assuming I understand what the function's meant to do). So you might instead want something like

(defun divtest (elements)
  (apply #'/ (first elements) (remove-if #'zerop (rest elements))))

See the Hyperspec for more details.

Answer 2

Or you can write it like this

(defun divtest (elements)
  (if (member 0 elements)
      0
      (apply #'/ elements)))

Answer 3

(block exit
  (reduce #'/ '(1 2 3 0 5)
          :key (lambda (x)
                 (if (zerop x)
                     (return-from exit 0)
                   x))))

Answer 4

Try (apply / elements) in place of (/ elements). I think(?) that should work in most dialects of Lisp.