Lisp collect random items if they are even

Coming from other programming languages, I recently found lisp and am amazed. Reading through the loop macro, I wanted to generate a list with random numbers with a condition (let's just pretend the numbers should be even). So I came up with this:

(defun some-test (range)
  (loop repeat range
        with item = (random 1000)
        if (evenp item)
        collect item))

However, this gives me the same random number range times. What am I doing wrong here? Apparently, item is only evaluated once and not in every iteration.

with evaluates the expression before the loop starts.
If you want to compute an intermediate value on each iteration, you need to replace it with for:

(defun some-test (range)
  (loop for item = (random 1000)
        repeat range
        if (evenp item)
        collect item))

Running (some-test 5) then returns up to 5 even numbers, for example:

CL-USER> (some-test 5)
(758 750 300)
CL-USER> (some-test 5)
(954)

As a bonus, here is a way of collecting exactly N values satisfying a test in a list. This is done as a higher-order function that accepts a size parameter, as well as two functions, generate and test:

(defun generate-list (size generate test)
  (when (> size 0)
    (loop for val = (funcall generate)
          if (funcall test val)
            collect val
            and count 1 into total
          until (= total size))))

LOOP as described in the standard has certain restrictions that are maybe not apparent at first, namely that it is not possible to mix all kinds of clauses in its body in any order, there are different sections of clauses that must appear in sequence. This is summarized nicely in LOOPS for Black Belts - Putting It All Together. Typically the termination test of the loop must appear after the iteration clauses, making it cumbersome to test for a limit of zero at the beginning of the loop. I choose to exclude this case outside of loop with when, which returns NIL anyway when the condition is not met.

Alternatively, I can use an initially clause so that everything is contained in the loop body:

(defun generate-list (size generate test)
  (loop
    :initially
       (assert (>= size 0) (size) "Invalid size ~a" size)
       (when (= size 0)
         (return nil))
    :for val = (funcall generate)
    :if (funcall test val)
      :collect val
      :and :count 1 :into total
    :until (= total size)))

For example:

(defun make-dice (limit)
  (lambda ()
    (random limit)))

(generate-list 10 (make-dice 1000) #'evenp)
=> (714 728 964 510 898 404 560 850 48 508)