So your question gets simplified to the question what is supposed
to be the result of (list) which is obviously the empty list.

ciao,
Jochen

e.g. (using Dylan syntax, sorry, it's more familiar, especiall the #rest
part at the end)

   let (a, b, c, d) = values(1, 2);

c and d get #f.  In CL they'll get nil.  For the same reason, x will get
#f/nil:

  let x = values();

But if you do...

  let (#rest z) = values();

... then z is an empty sequence.

-- Bruce

--
           /|_     .-----------------------.                        
         ,'  .\  / | No to Imperialist war |                        
     ,--'    _,'   | Wage class war!       |                        
    /       /      `-----------------------'                        
   (   -.  |                              
   |     ) |                              
  (`-.  '--.)                              
   `. )----'                              

Actually it came about because of something different I was doing:
(use-package "REGEXP")
(setf s "abcdef")
(setf reg-exp-match (multiple-value-list (match 'ghi" s)))
(if (not (nul reg-exp-match))
     (princ (subseq s (match-begin (car reg-exp-match))
                                (match-end   (car reg-exp-match)))))

where the princ crashes because (car reg-exp-match) is nil.
Actually it turns out that reg-exp-match is (nil).

That is completely correct behaviour:

- (values-list nil) produces 0 values, but since the right-hand side
  of the setf form will require exactly 1 value, that value is
  defaulted to nil, so x gets set to nil.
- (multiple-value-list nil) must return (nil), since evaluating nil
  yields exactly 1 value, namely nil, which is then returned.

To test what you wanted to test, you can do:

(multiple-value-list (values-list nil))

which yields nil, as expected.

You should be aware that multiple values deteriorate to 1 value in all
contexts other than those which are specified to handle
multiple-values specially, like e.g. m-v-bind, m-v-call, m-v-list, but
also progn, etc.

Regs, Pierre.

--

 The most likely way for the world to be destroyed, most experts agree,
 is by accident. That's where we come in; we're computer professionals.
 We cause accidents.                           -- Nathaniel Borenstein