Re: Operation can be dispatching in only one type

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Mon, 30 Nov 2009 15:43:21 -0500, Robert A Duff wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
> 
>> The word assignment for most people is associated with state change,
>> assuming that there was some state before. So
>>
>>    X : T := F (Y);
>>
>> looks equivalent to
>>
>>    X : T;
>> begin
>>    X := F (Y);
>>
>> But they are not.
> 
> Right.  I think they should be equivalent.  My solution is to use
> two different symbols for (initial) assignment and (subsequent)
> reassignment.

But they cannot be, otherwise the semantics of ":=" would depend on the
things done before:

    X : T;
begin
    X := F (Y); -- Initialization

    X : T;
begin
    X := Z;
    X := F (Y); -- [Re]assignment

This is unacceptable, because it is untyped. The semantics of ":=" must be
solely defined by the types and, maybe, be the context (declarative vs.
imperative (as it is now). I don't like even the second part.

>>... I would prefer proper constructors, e.g.
>>
>>    X : T (Y); -- Y is a constraint of T, parameter of the constructor
>>
>> I don't like functions returning limited objects.
> 
> I know you don't, but I don't understand why.

Because they cannot return anything, so a "return statement" is invented
together with an infinite chain of other unholy things bending and twisting
otherwise clear and established notions.

> Using named functions as constructors has a big advantage -- you can
> have more than one, and you can give them meaningful names.
> 
> For example:
> 
>     X : Sequence := Empty_Seq;
>     Y : Sequence := Singleton_Seq (Item => 123);
>     Z : Sequence := Make_Sequence (Length => 123);
> 
> With discriminants, what does the 123 mean?  You have to pick one.

No problem:

   X : Sequence;
   Y : Sequence (Item => 123);
   Z : Sequence (Length => 123);

In my imaginary world public discriminant (as well as a public record
component) is only an interface, therefore it is no problem for a type have
any collection of public discriminant sets. They are just like other
operations, you could overload them if necessary.

>> But there also are two other forms of standard assignments. Depending on
>> whether the left part is available:
>>
>>    procedure ":=" (Left : in out T; Right : T);
>>
>> and
>>
>>    function ":=" (Right : T) return T;
>>
>> Ada uses the second form, but obviously there are important cases where the
>> first form is preferable (and conversely).
>>
>> And further, there are three variants per each concerning dispatch:
>>
>>    procedure ":=" (Left : in out T; Right : T);  -- Full MD
>>    procedure ":=" (Left : in out T; Right : T'Class);  -- Target-controlled
>>    procedure ":=" (Left : in out T'Class; Right : T);  -- Source-controlled
>>
>> It would be difficult to sort this out! (:-))
> 
> Yeah, I'm not sure what the right answer is.

I think that assignment should be considered a plain primitive procedure
with no special treatment. Initialization has in my view nothing to do with
it. The language should visually separate both.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de