Building high level code from low level code

[tangaroa]

Consider that a class in c++ or java defines both an implementation and an interface.

Consider the similarities in these three examples:

// Example 1 
interface IFoo {
 // interface
 doStuff();

 // implementation not defined
}

// Example 2
class Foo {

 // implementation
 int x;
 string y;

 //interface
 doStuff(){...}
}

// Example 3
// implementation 
struct foo {
 int x;
 string y;
}

void foo_doStuff(); // interface

An ordinary compiler might be expected to convert lower-level code to a low-level implementation immediately upon reading it. The programmer has defined exactly how the code is to be implemented, and there is no apparent need for higher level considerations.

A hypothetical high-level compiler might first convert as much low level code as possible into a higher-level intermediary language.

• class Foo is automatically built from struct foo and is automatically populated by the foo_() functions that operate on a struct foo.
• interface IFoo is automatically built from the internal representation of class Foo
• This high level representation is saved to an object file and can be accessed by any programming language that can load libraries.

Additional thoughts:

• An autodoc tool can produce documentation from the resulting high-level objects, especially if the high level object includes comments or links back to the original source code.
• An IPC mechanism can send the object definition to the receiving side if the receiving side does not have the structure defined.
• The compiler can detect classes that are binary-compatible with one another and allow them to be casted without harm.

---

Also, it should be possible for a sufficiently smart compiler to recognize that some for-loops are examples of an iteration. These can be interpreted upwards to a high-level description of an iteration like foreach x in myArray{...} for which the developer has provided a low-level implementation for (i=0; i<length; i++){...}

I cannot think of any benefit to doing this, but it could potentially be done.