Re: Reconsidering assignment

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

On 7 Cze, 09:10, Stefan Lucks <l...@th.informatik.uni-mannheim.de>
wrote:

> > 1. Integer and its subtypes (like Positive).
> > An Integer object has some value - and only that. Any subtype of
> > Integer is defined within the same space, which means that this only
> > thing that Integer has is also subject for the constraint check. In
> > other words, *every* modification of the Integer (or subtype of)
> > object is potentially violating the constraint.
>
> Yes, that is what subtypes are for. And if a subprogram delivers you a
> value in the types range, but outside the subtype's range, a
> Constraint_Error is IMHO the right thing.

Yes, but my motivation was to exclude it if the code looks "innocent":

function Make_Integer return Integer;
function Make_Positive return Positive;

declare
  I : Integer;
  P : Positive;
begin
  I := Make_Positive; -- OK, looks "innocent", cannot raise
  P := Make_Integer; -- should be error ("innocent" lies)
  P := (Positive)Make_Integer; -- OK, beware potential errors
end;

> > 2. String.

> The difference is that the exceptions are raised
> inside the subprogram

But the rules will then apply inside this subprogram.
The rule is simple: "innocent" code should not lie.

> so the caller would need the details of the
> subprograms implementation to predict if an exception will be raised.

In other words, the call-site looks innocent, even though the body of
subprogram contains evil code raising exceptions.

function Innocent_Looking return Positive is
begin
  return (Positive)Make_Integer;
end;

declare
  P : Positive;
begin
  P := Innocent_Looking; -- ?
end;

This is good point. Maybe introducing exception specifications to
subprogram signatures would help (like in Java).
Things get interesting...

> I like your suggestion, but i would prefer a simpler syntax. Use some
> attribute Type in this case. Thus, I would prefer
>
> procedure Swap (X: in out String; Y: in out X'Type);

I don't like it because it introduces artificial assymetry in code (it
looks like there is a restriction on Y only, whereas in fact the
restriction binds both parameters).
But the idea is OK.

> > procedure Safe_Swap(X, Y : in out String) with X'Length = Y'Length;
>
> (BTW, your clause ensures that the lengths of the two strings are
> identical, the semantic of X'Type would even ensure X'First = Y'First and
> X'Last = Y'Last ...

Yes, except that these additional restrictions might not be needed in
a given context. But I think it would be good to have this possibility
as well, see also Ray's variant with X'Subtype = Y'Subtype.

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