Partial evaluation in imperative languages.

I think for partial evaluation to be useful in an imperative language
there must be language constructs to support it. I am experimenting
with this notion and we have the following.


frozen variable-list;
    The following variables are frozen, they have reached their final state.


pure
    In a function declaration this means the function may be regarded as
referentially transparent no matter what it looks like. This allows a
square root function with an error message to be treated as transparent.
You would rather see the message at compile time anyway.


impure
    In a function declaration it means the function may not be regarded
as referentially transparent. For example a delay function.


mac
    Do this now regardless. mac date; is the compile date. On a function
it means this is run at compile time. On a variable makes this a compile
time variable.


run
    Defer as far as possible, do at run time. May be put on a function
but may be overridden at compile time. This is the default for variables.


I regard strong typing as partial evaluation of the type system in
such a way that no errors may occur at run time. But there are many
times we don't want errors at run time. I don't ever want to hear "Is
there a programmer aboard the aircraft? I'm getting the message 'zero
divide error'"


I believe partial evaluation can be used to detect the possibility of
inappropriate error messages such as 'zero divide error' in a
navigation program or word processor. Using it that way would require
massive labor but there are systems where this is a good idea.
--

Return to the comp.compilers page.
Search the comp.compilers archives again.