Object#copy [rcr?]
 

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 :: http://www.ngdc.noaa.gov/stp/
| TRY :: for l in ruby perl;do $l -e "print \"\x3a\x2d\x29\x0a\"";done
================================================== =============================

Re: Object#copy [rcr?]
 

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

Re: Object#copy [rcr?]
 

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.

Re: Object#copy [rcr?]
 

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.

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
--
================================================== =============================
| EMAIL :: Ara [dot] T [dot] Howard [at] noaa [dot] gov
| PHONE :: 303.497.6469
| ADDRESS :: E/GC2 325 Broadway, Boulder, CO 80305-3328
| URL :: http://www.ngdc.noaa.gov/stp/
| "640K ought to be enough for anybody." - Bill Gates, 1981
================================================== =============================

Re: Object#copy [rcr?]
 

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


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
--
================================================== =============================
| EMAIL :: Ara [dot] T [dot] Howard [at] noaa [dot] gov
| PHONE :: 303.497.6469
| ADDRESS :: E/GC2 325 Broadway, Boulder, CO 80305-3328
| URL :: http://www.ngdc.noaa.gov/stp/
| "640K ought to be enough for anybody." - Bill Gates, 1981
================================================== =============================