Re: Gnat 2013 is out!

["Randy Brukardt" <randy@rrsoftware.com>]

"Georg Bauhaus" <rm.dash-bauhaus@futureapps.de> wrote in message 
news:51b6c424$0$6633$9b4e6d93@newsspool2.arcor-online.net...
...
> Second, concerning the constraints that need to be supplied,
> is there *any* way in Ada that allows them to be stated
> "really simply"?

If you need constraints, that is not an appropriate use of this feature. 
It's really for discarding error codes from non-Ada APIs, and those should 
be some discrete type (either integer or enumeration). The base type is good 
enough for those cases.

It would be usable for some composites, but not all. But that's OK, the 
entire point is to have a simple shorthand for a discarded parameter. If it 
gets at all complex, it no longer has much benefit in readability (I'd much 
rather see an explicit declaration rather than some strange magic syntax). 
And discarding of composite parameters is slightly suspicious.

> If the dummy syntax is for expressions of substitutes of a regular
> declaration, how can a dummy expression be so much more simple
> than a dummy declaration?

The syntax I proposed was "<>". That's it, there is no declaration, 
constraint, range, or any of that. It's readable, can easily be read to mean 
"discard" in this case, and it doesn't look much like a legal parameter 
expression.

If it gets much more complex than that, then it simply isn't worth it. 
Compare what I write today:

   declare
        Dummy : Code_Type; -- Not used in the following
   begin
        Some_Call (Param_A, Param_B, Dummy);
   end;

That's 5 lines, 8 extra tokens for the Dummy declaration. That's a very 
small amount of writing to save, so whatever replaces it had better be very 
small or there is no point:

        Some_Call (Param_A, Param_B, <>);

qualifies. The more complex suggestions I have seen simply don't simplify 
enough to justify the complexity.

> About the only thing I can imagine towards simplified syntax
> is inference of type *and* range constraints, with the help
> of context (the subprograms' declarations). Is that double
> inference part of Ada right now?

There is (or should be) no need to constraints on dummy temporaries that are 
going to be discarded anyway. Why would anyone want something discarded to 
be range checked (thus introducing a point of failure)? If you need that, 
that's *not* a discarded dummy.

Since you don't *want* constraints on dummies, there is no need to infer 
them. Just use the base type of the parameter, and be done with it. If there 
is any ambiguity, or you can't have an object of the base type, then you'll 
have to write those 8 extra tokens. How awful. :-)

But I think you've convinced me this feature isn't worth the work. It just 
doesn't save enough, and the slippery slope of people trying to expand it 
(so it saves nothing in either dimension) completely kills any value. And 
that's before anyone does a detailed semantic analysis on it, which often 
kills apparently good ideas anyway.

                                               Randy.