Re: Operation can be dispatching in only one type

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

Dmitry A. Kazakov schrieb:
> On Tue, 01 Dec 2009 13:13:29 +0100, Georg Bauhaus wrote:
> 
>> Then we could rely on the language: compilers will detect
>> uninitialized variables provided these do not have a pragma/keyword/...
>> to say that uninitialized is what the programmer wants.
>> Some fancy means to tell the compiler that this variable
>> does indeed have a good first value like pragma Import.
>>
>>    X : [constant] Car; -- default init,
> 
> The error is here!
>>                        -- undefined,
>>                        -- junk bits. Doesn't matter
>>    --  *no* pragma Import (Ada, X);
>>
>> begin
>>
>>    Spare := X.Tire (5); -- would become illegal,
> 
> Not here!

Why? Nothing needs to have happened in between the X's
declaration and the first reference made to it.


> -------------------------
> Anyway, you cannot do that because:
> 
>    if HALT (P) then
>      X := Z;
>    end if;
>    Y := X;  -- Is this legal?


(HALT is a run-time issue that has no impact here.)
While this snippet would not be legal as is (on purpose!),
Ada's case coverage rules can make the programmer write a
legal program easily: write an else branch!
The compiler can then decide that a value will be assigned
in either branch.

If nothing is to be assigned this can only be for
the reason that the variable is imported, or has a
value already.
In the former case an unchecked conversion involving only
the variable will do; syntactic sugar might be nice to have.

  if HALT (P) then
      X := Z;
  else
      !X;
  end if;

One might even omit the else branch without loss
when Ada forces saying that the variable is imported.


>> Does the phrase "first value" make sense?
> 
> An object shall not have invalid values. All values are valid if the
> language is typed. Enforcing user-defined construction including
> prohibition of certain kinds of construction (e.g. per default constructor)
> is a different story.
> 

If you feed this to a Java compiler you will see how it is done.
The Java compiler will not accept a reference to a variable's
component when the variable may not have been initialized.


import java.math.BigInteger;

public class Dummy
{

    enum TireColor {
        Black, White
    };

    class Tire
    {
        TireColor rim_color;
    }

    public static void main(String[] args)
    {
        Tire spare;
        TireColor its_color;
        final BigInteger P; // some program's number

        P = BigInteger.valueOf(Long.parseLong(args[0]));

        if (HALT(P)) {
            spare = new Tire();
        }
        // this line not accepted by a Java compiler:
        its_color = spare.rim_color;  //  <-----

    }

    static boolean HALT(BigInteger gn)
    {
        // dummy
        if (gn.equals(BigInteger.ZERO))
            return true;
        return HALT(gn.add(BigInteger.ONE));
    }
}