can anyone think of a good reason NOT to have this feature?
class Object
def copy
Marshal::load(Marshal::dump(self))
end
end
i include this is nearly all of my own code and i know others do the same
quite often - why no method which does this?
-a
···
–
EMAIL :: Ara [dot] T [dot] Howard [at] noaa [dot] gov
PHONE :: 303.497.6469
ADDRESS :: E/GC2 325 Broadway, Boulder, CO 80305-3328
URL :: Solar-Terrestrial Physics Data | NCEI
TRY :: for l in ruby perl;do $l -e “print "\x3a\x2d\x29\x0a"”;done
===============================================================================
Ara.T.Howard wrote:
can anyone think of a good reason NOT to have this feature?
class Object
def copy
Marshal::load(Marshal::dump(self))
end
end
i include this is nearly all of my own code and i know others do the same
quite often - why no method which does this?
In the past I used the very same piece of code for deep copy.
Somewhere I changed my mind from liking it… to not liking it.
I consider it kludgy to deepcopynig with help of serialize,
and its inefficient compared to custom #clone method.
Sorry.
···
–
Simon Strandgaard
i see your point… perhaps an initial impl as in above, or even
class Object
def copy opts = {‘levels’=>42}
Marshal::load(Marshal::dump(self))
end
end
where opts might later affect the semantics of #copy…
i guess i’m more interested in the interface of copying: it would be nice
to be able to write code using
obj.copy
and nicer still if the impl got faster/better under the hood. it may not be
the best but, if “everyone’s doing it”… 
i understand the ‘inefficient’ bit above, but what exactly do you have in mind
by ‘scheme’? other that ‘how deep’ i can’t think of other things that might
affect a deep copy?
-a
···
On Mon, 17 May 2004, Yukihiro Matsumoto wrote:
Hi,
In message “Object#copy [rcr?]” > on 04/05/17, “Ara.T.Howard” Ara.T.Howard@noaa.gov writes:
can anyone think of a good reason NOT to have this feature?
class Object
def copy
Marshal::load(Marshal::dump(self))
end
end
I think deep copy should be implemented independently from
marshaling, which is inefficient and limited scheme for deep copy.
The only problem is that it’s difficult to implement.
matz.
–
EMAIL :: Ara [dot] T [dot] Howard [at] noaa [dot] gov
PHONE :: 303.497.6469
ADDRESS :: E/GC2 325 Broadway, Boulder, CO 80305-3328
URL :: Solar-Terrestrial Physics Data | NCEI
“640K ought to be enough for anybody.” - Bill Gates, 1981
===============================================================================
you are right of course: i’ve written many a custom #clone methods and, for
that matter, many custom #dump methods as well - all in the name of speed. i
simply feel that the lack of a builtin method to copy objects is one of
the very few things, like the lack of a detructor hook (Object#destroy ?),
that consistently suprises people and gives the feel of something obviously
‘missing’ from ruby. the impl is really quite moot - i’m simply advocating
something uniform in terms of interface and Object#copy seems like quite a
reasonable one.
-a
···
On Mon, 17 May 2004, Simon Strandgaard wrote:
Ara.T.Howard wrote:
can anyone think of a good reason NOT to have this feature?
class Object
def copy
Marshal::load(Marshal::dump(self))
end
end
i include this is nearly all of my own code and i know others do the same
quite often - why no method which does this?
In the past I used the very same piece of code for deep copy.
Somewhere I changed my mind from liking it… to not liking it.
I consider it kludgy to deepcopynig with help of serialize,
and its inefficient compared to custom #clone method.
Sorry.
–
Simon Strandgaard
–
EMAIL :: Ara [dot] T [dot] Howard [at] noaa [dot] gov
PHONE :: 303.497.6469
ADDRESS :: E/GC2 325 Broadway, Boulder, CO 80305-3328
URL :: Solar-Terrestrial Physics Data | NCEI
“640K ought to be enough for anybody.” - Bill Gates, 1981
===============================================================================