USER(2): (arglist 'excl:fasl-write)
(COMPILER::DATA STREAM &OPTIONAL COMPILER::*FASL-CIRCLE* *COMPILE-VERBOSE*)
T
USER(3): (setq l '(1 2 3))
(1 2 3)
USER(4): (nconc l l)
(1 2 3 1 2 3 1 2 3 1 ...)
USER(5): (excl:fasl-write l "x.fasl" t t)
;;; Writing fasl file x.fasl
;;; Fasl write complete
T
USER(6): #'excl:fasl-read
#<Function FASL-READ>
USER(7): (arglist 'excl:fasl-read
)
(COMPILER::FILE)
T
USER(8): (excl:fasl-read "x.fasl")
((1 2 3 1 2 3 1 2 3 1 ...))
USER(9): (first *)
(1 2 3 1 2 3 1 2 3 1 ...)
USER(10): (eql * l)
NIL
USER(11): (list-length **)
NIL

Maybe thats sufficient for your problem?

"however, stipulating certain rules on the structure of the objects
may be within reason."

Bye now,

If there are many different data structures which cannot be deep
copied, I'm okay with that. I can stipulate that these objects
contain no such structures (checking that they indeed don't is
another issue).

Non sequitur. This doesn't follow from anything, nor does
anything follow from this. Please keep your crazy rants to
yourself.

I'll repeat once more the things you need to write a copier (actually
I notice I forgot to give one of them):

        a notion of equality of objects

        a method of saying if you've seen an object equal in the above
        sense to the one you are looking at now

        a method of knowing which slots of an object you need to
        descend into to copy it.  This depends on the semantics of the
        slots as well as their content (this is the one I failed to
        mention).

If your notion of equality is EQL or something similar, then the first
two things are done very well by a hashtable, if it is more general
then you need to write some hashtable-type thing.

`Knowing which slots' is application-dependent, but you can do stuff
with the MOP to find them.  I'd tend to do it with something like a
map-interesting-slots generic function with progn method combination
which I'd use to define the new interesting slots when I defined a new
class.

Most of the reason I posted my question to the group was
to make sure I wasn't reinventing the wheel. That, and my
"copier" was originally intended to produce a plain text
rendition of the object that followed certain formatting
rules. Therein, I supported a set of basic primitives
(boolean, integer, float, string), sequences (array,
list, vector), and finally any standard-object. To
understand how to correctly serialize boolean as "false"
on my plain text serialization, I ended up having to
have a look-aside table of metadata, which turned out
to be necessary in any case (I forget why, but something
to do with the types of sequence elements upon internal
ization).

If this is just a case of doing what I did before, but
with adding an objref and then using some kind of
hashtable or something, I'm fine with that. I was
hoping there was an implementation already out there...

  this is just great.  of course I did that, and that's _why_ I criticize
  you for not doing it UP FRONT.  perhaps you do ont know what "UP FRONT"
  means?  well, it means you do it at the very start of your request for
  help.  sort of like "I use XLISP, and have this problem" instead of just
  asking people to guess based on the lack of intelligibility of the
  problem as stated in the environments smart people use.

  please go back to C++, both communities would benefit from that.

If you know what you are doing (see above) writing a completely
general graph copier is pretty straightforward.  For example, one of
the aspects of our application is that graphs are first class objects
- any kind of graph can be defined (with edge semantics specified and
enforced, information propagation provided, etc., etc., etc.) and they
can be freely manipulated.  I wrote a completely general graph copier
in about a page of code.

/Jon

/Jon

I'm not quite sure why in the part I cut out you felt a
need to describe the wonders of lisp to me. Do you get a
lot of hostile-to-lisp posters here? I am someone who is
voluntarily learning to use lisp, and as is I suspect
of many first time users, I've found it so flexible and
useful that most of my questions involve where its
limitations lie.

When I say that something can be done in some other language
with some particular mechanism, this isn't some sort of
snide comment on the capabilities of lisp, but rather me
pointing out that if an approach works in one language,
there ought to be a way, no matter how labyrinthine, to
achieve it in another.

  thank you.  I think this sums up your position admirably.

I suspect that you need to look inward and not outward to
solve the problem that you need to work on. Usenet won't
offer your ego what it's looking for, no matter how hard
you look for it.

Good luck to you,

  just because you cannot fathom the theoretical implications of your
  questions does not mean that those who do don't solve practical problems.
  think about this.  please.

  and, incidentally, if I have "made" you feel like an idiot, why not just
  do something that would put such impressions to _shame_ instead of going
  out of your way to _prove_ that you really _are_ hopelessly lost?

| I suspect that you need to look inward and not outward to solve the
| problem that you need to work on. Usenet won't offer your ego what it's
| looking for, no matter how hard you look for it.

  I'm sure you and your shrink have worked something out that works for you
  (although by the looks of it, you have some ways to go), but just like he
  or she should have told you that you shouldn't give other people your
  medication, you also shouldn't believe that your personal problems apply
  to other people.

  but I'll give you this: you are indeed courageous.  I know of few other
  people who would expose themselves the way you do.  here's a hint: you
  really don't need to -- nobody cares about _you_, personally, and it's an
  affront to your audience, _any_ audience, to think they do.

  if I can stop you, that's good enough for me, because I don't start the
  kind of insane drivel you seem to enjoy starting.  but have you asked
  yourself your own question, lately?  I don't appreciate your line of
  psychologizing crap, but now that you get it back in your face, I see
  that you are a lot more sensitive to the matter than I am, which is good,
  because you may realize that if you plan to win any games that way, you
  won't do it here, and you're clearly the kind of moron who needs to be
  hurt to stop to think.  will _that_ make you stick to your issues,
  whatever they may be, or will you smear more of your personality all over
  the place with yet more moronic psychologizing and irrelevant personal
  attacks?  it's your call, "Courageous".

Automatic deep copy is actually a pretty common operation in
dynamic distributed object systems and persistent object stores,
and a number of systems do a very good job implementing it
almost completely automatically.  Even CL compilers end up
having to be able to perform some pretty general deep copies.

Tom.

Take a step back.

  let me know when your advice has worked for you.  make an effort to show
  that you can listen to anything but your own voice while you're at it.