Re: Redefining := (was: The "()" operator revisited.)

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

On Fri, 16 Jan 2004 15:37:27 -0600, "Randy Brukardt"
<randy@rrsoftware.com> wrote:

>"Jeffrey Carter" <spam@spam.com> wrote in message
>news:ltHNb.11315$1e.3373@newsread2.news.pas.earthlink.net...
>> Robert A Duff wrote:
>>
>> > It has to do with mutable record types (defaulted discrims).
>> > That's unfortunate; if you want to redefine ":=" for a non-mutable
>> > type, it's pretty annoying to be told you can't do that because
>> > mutable types exist in the language.
>
>Bob's comment is a bit misleading. The problem is that since mutable types
>exist in the language, you can't redefine ":=" for any types. That occurs
>because of composition issues. You want user-defined ":=" to compose, such
>that a larger type containing a component of a type using user-defined ":="
>uses the user-defined ":=". Now, consider:
>
>     type Something ...
>     procedure ":=" (Target : out Something; Source : in Something);
>
>     type Mutable (B : Boolean := False) is record
>          case B is
>                  when True =>
>                          S : Something;
>                  when False =>
>                          C : Character;
>          end case;
>    end record;
>
>    A_True : Mutable(True);
>    A_False : Mutable(False);
>
>    Obj : Mutable;
>
>    Obj := A_True; -- ??
>
>How does the predefined ":=" for Mutable work? It needs to call the
>user-defined ":=" for component S. But in this example, what do you pass for
>the LHS? It doesn't have a component S!

Of course, Mutable.":=" is kind of "multiple dispatching". There are
four variants of it:

case LHS.B is
   when True =>
      case RHS.B is
         when True =>
            call to ":=" on Something;
         when False =>
            finalize Character;
            call copy-constructor on Something
      end case;
   when False =>
      case RHS.B is
         when True =>
            finalize Something;
            call copy-constructor on Character
         when False =>
            call to ":=" on Character;
      end case;
end case;

Provided we had proper constructors of course! (:-))

Assignment can always be consistently generated out of assignments of
components and destructors/copy-constructors. The reverse is wrong, as
your example clearly shows. Even more obvious example:

X : constant Something := Initial;
   -- should the user-defined ":=" be called here? (:-))
   -- If, yes then what would be LHS?

--
Regards,
Dmitry A. Kazakov
www.dmitry-kazakov.de