I hope I mentioned it that I was aware of higher costs---the reason
why I still put forward 0d arrays has to do with expressing intent,
see below.

(In fact, assuming 64 bits of header and, in a 64-bit architecture,
64 bits per reference, a simple array with room for a single element
would occupy as much storage as a cons cell.  But this is just
hypothetical.)

But, before worrying about storage, I worry about a clear expression
of my intent to use something as a singleton reference.

(1) Using a cons is most efficient but is one of those `cancer of the
    semicolon' cases:

    (let ((ref (cons foo nil)))  ;the cdr will not be used
      ...)                       ^^^^^^^^^^^^^^^^^^^^^^^^^

(2) Using a structure makes for a program where adding a second slot
    is an easy change to the program: a structure with just one slot
    still sort of implies that a second slot might appear some day,
    and I don't want that.  For the same reason, I want a _zero_
    dimensional array, not a vector of length 1: (AREF REF) means
    there is just this one, period, while (AREF REF 0) again sort of
    implies that one day we might see (AREF REF 1) etc.

(3) Of course I could say

    (defstruct ref obj)  ;thou shalt have just this slot

    but on the other hand sometimes I (perhaps others too) prefer
    idioms to Doing the Right Thing by introducing abstractions
    for each and every purpose and thus cluttering the program
    with defining forms and the concept space with datatypes,
    accessors, etc.  (For the same reason I am not very keen on
    wrapping calls to CONS and FIRST in calls to MAKE-REF and REF.)

Anyway, this exercise is not worth more than the proverbial two cents
since even if `efficient singleton references' makes it to a wish
list it would have very nice(1) priority...

I also remember the case of Algol-68, which among other things tried
to Get references Right, I believe.

Vassil Nikolov <vniko...@poboxes.com> www.poboxes.com/vnikolov
(You may want to cc your posting to me if I _have_ to see it.)
   LEGEMANVALEMFVTVTVM  (Ancient Roman programmers' adage.)