The Meaningful and the Unmeaningful

Dear readers of comp.compilers,


      Does anyone among you know of any language, compiler,
formal or informal specification of either of the above,
preliminary or full-grown research about that,
or pointer to any of these,
      that would allow to describe in an object-per-object basis,
what side effects are to be considered meaningful,
and what side effects are to be considered unmeaningful,
in the way it is constructed,
so that unmeaningful parts could be arbitrarily optimized away,
while the meaningful part is guaranteed to remain intact ?




      For instance, a pattern matcher subroutine typically includes
lots of redundant checks that are only cause of loss of performance
(and perhaps failure, if some resource like memory is overflown);
but among the possible exceptions it may raise,
the ones that mean that the unification failed
should surely not be discarded !
      Likewise, when optimizing a program that includes some kind of
logging and scheduling, forms evaluating to constant result,
that include side-effects to maintain management meta-data,
should most likely not be kept for the sake of these side-effects,
or worse, optimized away with the side-effects being kept !
      I could also describe the integer type of my programs in terms
of a "Type Nat = O of Nat| S of Nat->Nat" and expect the implementation
to use system integers where a bound is known to the considered value,
or arbitrarily sized decimal integers when not is known,
or whatever fits best in some given procedure
(not forcibly any canonical representation -- a shifted bit could do,
a xor-ed value, too), without my having to explicitly rewrite my programs.
      In most cases, also, I wouldn't care if the GC is real-time or not,
or if there is GC at all , if the architecture is 32-bit or 21-bit,
sequential, parallel or distributed , etc , as long as the result
returned (if any) by running the program is guaranteed to match
my constructive or declarative specifications.


      I could give tons of examples for the above concept,
but I'm sure you could continue better than me.




      More generally, the language/compiler/whatever I'm looking for
would allow to describe computing objects by
* the way by which can be constructed and modified
  (a signature of constructors),
* the way they can be meaningfully observed and destructed
  (signature of destructors)
* a cost function (unformal but formally hintable),
  that compiling heuristics should minimize
  while optimizing the implementation
  of an object verifying the above semantics.


      Note that the constructors and destructors should express
logical/formal as well as computable/effective properties of computations,
so that this any specification should be expressible in this language.
      Anything not specified among meaningful destructors would be considered
as unmeaningful, and could be arbitrarily rewritten, recombined, or discarded,
as long as meaningful semantics are conserved,
so as to minimize the object "cost".




      Well, all that is a lot, especially since I'd like this programming frame
to be reflective; that is, able to describe and implement itself efficiently.
      Surely all this is just too much. Anyway, any pointer, comment,
or redirection to a more fit discussion group, are gladly welcome.
      Cheers,


-- , , _ v ~ ^ --
-- Fare -- rideau@clipper.ens.fr -- Francois-Rene Rideau -- +)ang-Vu Ban --
-- ' / . --
--

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