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

[Richard Riehle <richard@adaworks.com>]

Hyman Rosen wrote:

> Bob Bane wrote:
>
> > I was particularly impressed with his last paragraph in the second
> > article.  For some reason, he doesn't conclude that there's something
> > wrong with C++.  Can't imagine why...
>
> I can. The problem he's trying to solve is difficult; I don't see
> anything in its nature which wouldn't be equally difficult in Ada.

Dijkstra said something once, I believe it was in "A Discipline of
Computer Programming," about the inherent complexity of assignment
and the fact that most programmers did not understand how it actually
worked.  In the same article, he suggests that, "until a programmer
really understands assignment, he [sic] does not understand programming."

In C++ or Ada (or whatever) there is no need to write an assignment
operator unless the assignment between two objects is more complex
than predefined assignment.    One benefit of the limited type in Ada is
to highlight the dangers of assignment.   This is also why most complex
data structures in Ada are limited types.

I am not fond of the C++ idiom for tinkering with assignment, but it is
a reasonable model given the rest of the language design.   It is not clear

Ada 95 got it right either, but it feels safer to me.   I prefer Ada's
proscription against directly overloading the assignment operator.  The
contract is more clear to me if it is written as,

     package P is
        type T is [tagged] limited private;   -- no predefined methods on
limited type
        -- public explicit declaration of methods on T
        procedure Copy_Deep       (Source : in T; Target : in out T);
        procedure Copy_Shallow  (Source : in T; Target : in out T);
        -- pre-conditions on Copy_Deep and Copy_Shallow
              Invalid_Source : exception;
        -- post-conditions on Copy_Deep and Copy_Shallow
              Incomplete_Copy_Operation : exception;
    private
        -- private methods, if any
        -- full definition of T;
    end P;

This specification makes clear the contract and still eliminates any
possibility for stupid assignment between objects of the type.

Richard Riehle