Re: This can't be done in Ada...or?

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Duncan Sands <baldrick@free.fr> writes:

> > The compiler can optimize away everything inside the "if
> > Logging_Enabled".  But it can't optimize away the evaluation of the
> > parameters unless it can prove the absence of side effects.
> > For example:
> > 
> >     Trace.Error(..., "Bad value of X " & Debug_Info(X));
> > 
> > where Debug_Info is some user-defined function that produces useful
> > debug info about some complicated data structure called X.
> > It has no side effects, but the compiler doesn't know that, usually.
> 
> GNAT's pragma Pure_Function might help here.

Yes.

Note that Pure_Function has different semantics than Pure (besides the
fact that Pure_Function has finer granularity).  Pragma Pure has rules
that require the thing to actually *be* pure.  The only way to
circumvent those rules is with things like machine code inserts.
But Pure_Function has no such rules: if you lie, the compiler will
believe you, and your program might malfunction.

Robert Dewar objected to the rules for pragma Pure during Ada 9X -- he
thought it should be like Pure_Function in that regard.  That's because
(like all compile time rules) the rules are conservative.  You can't
write a memoizing function and declare it Pure, but you can declare it
Pure_Function.

>...  Is something like that
> planned for Ada 2005?

Somebody answered that, "no".  If I were designing the language, I would
allow Pure on procedures and functions as well as library packages.
I would require compile time checking.  Then I would add *another*
pragma to turn off the checking; this could be placed in the body.
Seems like the best of both worlds: Robert can have his pure memoizing
functions, but in cases where the compiler *can* check the rules,
the rules are checked.

- Bob