Re: True faiths ( was Re: The true faith )

[kaz@accton.shaw.ca (Kaz Kylheku)]

In article <3C4BE556.7040707@mail.com>, Hyman Rosen wrote:
>Richard Riehle wrote:
>
>> Hyman Rosen wrote:
>>>Richard Riehle wrote:
>>>>        procedure Copy_Deep       (Source : in T; Target : in out T);
>>>>        procedure Copy_Shallow  (Source : in T; Target : in out T);
>>>>
>>>I dislike the notion of providing these methods as external interfaces
>>>to a type. It seems wrong to me for a client to have to know what kind
>>>of copy to use - that's the type's business to know.
>> 
>> Well I don't like having an assignment statement that behaves in an
>> unpredictable way when I use it.
>
>
>I think we can agree on this with unbridled enthusiasm :-)
>
>> So I prefer having the copy semantics spelled out as clearly as possible.
>
> > This clarity assures me that, when I call a method, it will behave as
> > I expected.
>
>But the user of a type generally isn't concerned with its innards.

That is false.

>Why would you take a simple concept like copying or assignment and
>burden it with implementation details? If you were writing a sort
>method for a conatiner, wouldn't you just call it "sort" rather than
>"merge_sort' or "bubble_sort"?

The semantics of copying an object are not transparent to the user in
a way that choice of sorting algorithm is transparent.

All sorting algorithms which ensure the same postconditions are
effectively equivalent except for performance.

Different ways of copying an object do not ensure the same postconditions.
They are semantically different, in a way that may matter critically
to the caller.

Here is a slightly better analogy: do you want a stable sort or can you
live with an unstable one?  The difference is visible to the caller.
If a stable sort is essential, but an unstable one is invoked, that
is a mistake.

There can be lots of other variations: what comparison function is
used for the elements? Each function leads to a different sort. There
are effectively as many sort operations as there are ways to compare
the elements.

Usually, we arrange for the caller to be able to specify the computation,
so we can offer all of these sorts behind one interface.  The function
sorts, but the caller specifies *how*.  It's the same thing with object
replication. We can copy in various ways, the caller specifies *how*.