If you believe that a shallow copy is the right default choice in sharp
  contrast to the very deep copy described above, consider an object that
  points to itself with one of its slots.  A shallow copy would not make
  the "clones" independent at all, they would be like Siamese twins, and
  you would likely wreak havoc if you believed they _were_ independent.

  In the Common Lisp world, we do not generally believe in functions that
  work "most of the time", but look for the border conditions that make it
  necessary to point out when it works and when it does not.  A general
  "copy constructor" is not well-defined enough to make this possible.

  Besides, there is so much going on in CLOS objects that even if you
  succeed in making a copy, you may have broken many significant other
  things that depended on object identity in ways the object may not know
  about.  See also the desire to compare two objects for anything other
  than object identity.  Those who say it can be done are simply wrong,
  because the information necessary to accomplish this seemingly simple
  task is not specified by the language.  It is in the _intent_ of the
  programmer, not the _expression_ of that intent.  Until we find a way to
  write down the intent directly, we can only deal with expressions of
  intent in our programming languages.

  In other words, the PhD-level answer is "create a language such that it
  can automatically construct a copy constructor that always does the right
  thing".  It is simpler to write the code for your own copying function.

Longer answer:
Partly because it isn't clear what you mean by "thereafter
independent".  If the filler of a slot were an object, should that
object be recursively copied?  If so, then you get into problems with
circular object graphs.  If not, then a change to the internal state of
that filler would be reflected in the internal state of the filler of
the copy as well.  That might not be independent enough for you.  What
about if two slots point to the same filler?  Should they be copied?

Basically the problem is that the meaning of a copy requires knowledge
of the semantics of the data structure which are not captured in the
programming language.  It is thus nearly impossible to get right in
general.

The above is a concise summary of some of the arguments in the Lisp
community about why there is no such utility.  Kent Pitman has a more
detailed and well-reasoned (published) response to this issue.

******

Notwithstanding those arguments, an shallow instance copy would IMHO be
useful in enough simple cases to be worth adding to the standard....

(defclass fifo ()
  ((queue :initform '())
   (queue-tail :initform nil)))

(hint: in order to work, the copier has to ensure that if the QUEUE
slot is non-NIL then QUEUE-TAIL must be the last cons in QUEUE).

class FIFO[G]

creation
   make ..

feature
   queue : LIST [G];
   tail : G

invariant
tail_constraint: tail = queue.item(count);

or the like

If I do a deep-clone all assertions have to be fullfilled for the
constraints too.

So If I have a
a : FIFO[FOO];
b : FIFO[FOO];

I got a full copy with
b := a.deep_clone;

So I can be sure that the constraint tail = queue.item(count) will
hold.

BTW I do think that one of the next addings to Common Lisp should be
features for Design by Contract. I know that there is a package for
it, anyway that should be standardized. Tools should be used to extrac
a) the documentation (as it is done nicely in Common Lisp)
b) the contracts (which are lacking in Common Lisp)

Being itself semantically meaningless, I can't imagine there could
possibly be a correct application of it unless in a universe where
the programmer had total world knowledge of the representation of all
objects that could be run through his programmer and was merely saying
"deep copy will in this limited case coincidentally and without damage
satisfy the need for a semantically meaningful copy".  In the presence
of no such total world knowledge and total representational knowledge,
I just don't see how it can ever be meaningful/right.

Please read:

This seems to place an unreasonable burden on the programmer of the
initial application.  Suppose the queue is the queue to enter Buckingham
palace and cannot be cloned?  Suppose it's one of several (but not an infinite
number of) queues that can be cloned in a finite-world model?  Suppose there
is a complex inter-relationship where there can be only one of someting per
n of something else but when something is cloned, the matter around it
rearranges to keep things in balance?  How much of this does the person
who doesn't realize "clone" will be done have to preprogram to have a correct
library and how much do they do as a burden of writing clone?  I claim that
correct code should explicitly offer a method to clone something if it wants
to and the absence of something that says you've done it correctly should
mean you don't know how; making the default the other way around leads
you with a big burden of proof.  Further, I also claim that a correct copying
requires knowing the purpose for which you are copying.  The same object
has multiple (even multiple "deep") copy meanings--do I descend leaves?
their leaves?  The answer comes from the reason for the copy.

In one limit case the constraint can be an arbitrary predicate on the
object: your proposed deep-copy function now has to somehow
automagically ensure that the copy satisfies this same predicate.  In
finite time, too.

In another limit case the constraint may be that the object
corresponds with various real-world objects: copying it would
logically require copying them too.  That may be hard.

Obviously there are useful cases where these hairy constraints are not
needed, and your system will work there.  This is OK as far as it
goes, but it is *not* a general deep-copy: there *is no useful notion*
of a general deep copy.  This is what we are trying to say.

This is number 2 in Bradshaw's list of computer science cretinisms:
using abstractions which don't exist.

(defmethod append ((q fifo) element)
  (setf (cdr (queue-tail q)) (cons element nil))
  (setf (queue-tail q) (cdr queue-tail q)))

You just cache the last item.

PS: for the record, I have read OOSC 2nd. Edition and I do not
consider it the towering master piece you seem to make of it. It's a
useful debating trick though. "Go read this 1000+ page book and then
we'll talk further"

As an alternative, you can say (and maybe that is the case in Eiffel)
that le language (or language library) gives you the "deep_copy"
operation and that its use on the Queue above will raise an error
somewhere (either at compile time or at run time: I just do not know).

The bottom line does not change.  Deep Copy is too tricky to be
defined correctly in a completely general term.

Cheers

    (defgeneric enqueue (object queue)
      ;; return OBJECT
      )
    (defgeneric dequeue (queue)
      ;; return ob and t or nil and nil
      )
    (defgeneric queue-empty-p (queue)
      ;; t/nil
      )

    (defclass queue ()
      ((queue :initform '())
       (queue-tail :initform '())))

    (defmethod enqueue (object (queue queue))
      (with-slots (queue queue-tail) queue
        (if (null queue)
            (setf queue (list object)
                  queue-tail queue)
          (setf (cdr queue-tail) (list object)
                queue-tail (cdr queue-tail))))
      object)

    (defmethod dequeue ((queue queue))
      (with-slots (queue queue-tail) queue
        (if (null queue)
            (values nil nil)
          (values
           (prog1 (car queue)
             (setf queue (cdr queue))
             ;; not stricly needed
             (when (null queue)
               (setf queue-tail '())))
           t))))

    (defmethod queue-empty-p ((queue queue))
      (null (slot-value queue 'queue)))

It would be interesting to see an automatically generated `deep-copy'
for this.  My code to copy queues would be this:

    (defgeneric copy-queue (queue))

    (defmethod copy-queue ((queue queue))
      (let ((new (make-instance (class-of queue))))
        (setf (slot-value new 'queue)
              (copy-list (slot-value queue 'queue))
              (slot-value new 'queue-tail)
              (last (slot-value new 'queue)))
        new))

Note that the underlying list is only shallowly copied: one could
argue that this is not therefore a deep copy: so be it, but it's the
copy you *want* in almost all cases.

indexing
        description: "Objects that ..."
        author: ""
        date: "$Date: 1999/01/12 01:57:05 $"
        revision: "$Revision: 1.3 $"

class
        MY_QUEUE [G]

creation
        make

feature -- Initialization

        make is
                        -- Initialize
                do
                        !!store.make

                ensure
                        store_valid : store /= Void;
                end

feature -- Access
    queue (new_item : G) is
            -- put item at front
        do
            store.put_front (new_item);
        ensure
            item_put_at_front: store.first = new_item;
        end;

    item : G is
        require
            not_empty: not empty;
        do
            Result := store.last;
        ensure
            Result = store.last;
        end;

    remove is
            -- remove the last element
        require
            not_empty : not empty;
        do
            store.finish;
            store.remove;
        ensure
            removed: store.count = old store.count -1;
        end;

    empty : BOOLEAN is
        do
            Result := store.empty;
        end;

feature {NONE} -- Implementation
    store : TWO_WAY_LIST [G]

invariant
        item_constraint: not empty implies item.is_equal(store.last);

end -- class MY_QUEUE

class QUEUE_TEST

creation
    make

feature
    a : MY_QUEUE[ARRAY[INTEGER]];
    b : MY_QUEUE[ARRAY[INTEGER]];
    c : like a;

    make is
        do
            !!a.make;
            a.queue(<<1,2>>);
            print_item (a.item);
            a.queue(<<3,4>>);
            print_item(a.item);

            b := a.clone(a);
            print_queue (b, "-------------------%Nb= ");
            make_a;
            b := a.clone(a);
            a.remove;
            print_queue(a, "a= ");
            make_a;
            b := a.clone(a);
            a.remove;
            print_queue(b, "b= ");
            make_a;
            b := a.deep_clone(a);
            a.remove;
            print_queue(b, "b=");
        end;

    make_a is
        do
            !!a.make;
            a.queue(<<1, 2>>);
            a.queue(<<3,4>>);
        end;

    print_queue (queue : like a; msg: STRING) is
        do
            io.put_string(msg);
            io.new_line;
            from
            until queue.empty
            loop
                print_item(queue.item);
                queue.remove;
            end
         end;

    print_item (arr_i: ARRAY[INTEGER]) is
        local
            i : INTEGER;
        do
            from i := arr_i.lower;
            until i > arr_i.upper
            loop
                io.put_string("arr(");
                io.put_integer(i);
                io.put_string(") = ");
                io.put_integer(arr_i.item(i));
                if i < arr_i.upper then
                    io.put_string(",");
                end;
                i := i + 1;
            end;
            io.new_line;
        end;
end -- class QUEUE_TEST

output is:
-------------------
b=
arr(1) = 1,arr(2) = 2
arr(1) = 3,arr(2) = 4
a=
arr(1) = 3,arr(2) = 4
b=
arr(1) = 3,arr(2) = 4
b=
arr(1) = 1,arr(2) = 2
arr(1) = 3,arr(2) = 4

you see that shallow copy simply does not work here, but a deep
copy.

deep_copy is defined in Eiffel and it will not raise an error, because
all constraints must hold for a copy too.

If I have some object which represents a queue of other objects, then
a useful (I get to define useful here) copy of this object should be a
queue of the same, identical objects, *not* a queue of copies of those
objects.  Given the implementation of a queue I gave this requires an
interesting combination of copy-preserving-sharing (for the underlying
list of items and the tail pointer) with no copy of the members of the
list.

I would like to see a system that can express - in some declarative
way such as a constraint language - this notion of copying a queue.

I don't have any more time to deal with this kind of thing.

In article <87zo9m4lgf....@frown.here>,
Friedrich Dominicus  <fr...@q-software-solutions.com> wrote:

Then just don't complain about lisp, and write a

(defgeneric deep-copy (object))
(defmethod deep-copy ((object queue))
  ...)

etc.

Kind regards,