Re: Reconsidering assignment

[Maciej Sobczak <see.my.homepage@gmail.com>]

On 11 Cze, 20:57, "Randy Brukardt" <r...@rrsoftware.com> wrote:

> > >    X : Integer := 1 + 1;

> > It's a compile-time expression with the value 2.
> > Not very complex. ;-)
>
> Sorry, Dmitry is right; you seem to have missed his point. In order for this
> to be "a compile-time expression", you need complex preference rules in your
> type system. (That is, that "compile-time expressions" are preferred over
> types that would cause some other kind of expression.)

Hm... indeed, that must be the case - there must be some logic to
allow the compiler to actually figure out that it is a compile-time
expression. Granted, such a logic might be a good candidate for the
optimizer (who wants function calls where the result can be immedately
available), but at the same time this is easiest to do when the type
system itself is very minimal.

I think there is time for some conclusions.
The major points I've learned in these discussions:

- Constraint_Error cannot be easily excluded with the use of legality
rules that are applied only locally. What I mean here is the rules
that can be checked only based on the static properties of names that
the compiler encounters in each expression (a type system, basically),
without information flow analysis and such.
- Unconstrained types in Ada can be used to "parameterize" whole
subprograms, even though these subprograms don't need to be proper
generics. Interestingly, no "implicit instantiation" is needed here
neither.

Thanks to all contributors and to Dmitry in particular.


Still (heck, that doesn't seem to be the end of discussion :-) ), the
earlier idea of expressing restrictions for subprogram parameters
looks interesting to me. The point is that subprogram overloading
operates on each parameter in isolation, whereas such restrictions
could add the possibility of selecting more convoluted subsets of the
whole relation. This is similar to treating the whole set of
parameters as a single record type and then constraining this single
record type for the purpose of overloading.
If the restriction is based on run-time properties of parameters, then
it doesn't provide anything that cannot be achieved with explicit if/
else at the beginning of the subprogram.
Consider:

procedure P(X, Y : Real) with X*X + Y*Y <= 1;
procedure P(X, Y : Real);

The idea was to have some assistance from the language for the proper
selection of overloaded P (one is for arguments that fall withing the
unit circle, and the other is for the rest). Here it doesn't give
anything fundamentally new, this can be achieved with if/else in a
single procedure.
On the other hand, restrictions for compile-time properties might be
more useful and can be for example an interesting optimization tool.
In C++ such effects are achieved with so called type traits and
(partial) template specializations. I wouldn't mind having this in
Ada.

--
Maciej Sobczak
http://www.msobczak.com/