64 lines
3.8 KiB
Plaintext
64 lines
3.8 KiB
Plaintext
|
%p
|
|||
|
|
Writing Soml helped a lot to separate the levels, or phases of the ruby compilation process. Helped
|
|||
|
|
me that is, to plan the ruby compiler.
|
|||
|
|
%p
|
|||
|
|
But off course i had not written the ruby compiler, i have only
|
|||
|
|
%a{:href => "https://dancinglightning.gitbooks.io/the-object-machine/content/object/dynamic_types.html"} planned
|
|||
|
|
how the dynamic nature could be implemented, using soml. In very short summary, the plan was to
|
|||
|
|
extend somls feature with esoteric multi-return features and use that to jump around different
|
|||
|
|
implementation when types change.
|
|||
|
|
%h2#the-benefit-of-communication The benefit of communication
|
|||
|
|
%p
|
|||
|
|
But first a thanks. When i was in the US, i talked to quite a few people about my plans. Everything
|
|||
|
|
helped, but special thanks goes to Caleb for pointing out two issues.
|
|||
|
|
%p
|
|||
|
|
The simpler one is that what i had named Layout, is usually called Type. I have changed the code
|
|||
|
|
and docs now and must admit it is a better name.
|
|||
|
|
%p
|
|||
|
|
The other thing Caleb was right about is that Soml is what is called an intermediate representation.
|
|||
|
|
This rubbed a little, especially since i had just moved away from a purely intermediate
|
|||
|
|
representation to an intermediate language. But still, we’ll see below that the language is not
|
|||
|
|
enough to solve the dynamic issues. I have already created an equivalent intermediate
|
|||
|
|
representation (to the soml ast) and will probably let go of the language completely, in time.
|
|||
|
|
%p
|
|||
|
|
So thanks to Caleb, and a thumbs up for anyone else reading, to
|
|||
|
|
%strong make contact
|
|||
|
|
%h2#the-hierarchy-of-languages The hierarchy of languages
|
|||
|
|
%p
|
|||
|
|
It seemed like such a good idea. Just like third level languages are compiled down to second (ie c
|
|||
|
|
to assembler), and second is compiled to first (ie assembler to binary), so fourth level would
|
|||
|
|
get compiled down to third. Such a nice clean world, very appealing.
|
|||
|
|
%p
|
|||
|
|
Until i started working on the details. Specifically how the type (of almost anything) would change
|
|||
|
|
in a statically typed language. And in short, I ran into yet another wall.
|
|||
|
|
%p
|
|||
|
|
So back it is to using an intermediate representation. Alas, at least it is a working one, so down
|
|||
|
|
from there to executable, it is know to work.
|
|||
|
|
%h2#cross-function-jumps Cross function jumps
|
|||
|
|
%p
|
|||
|
|
Let’s call a method something akin to what ruby has. It’s bound to a type, has a name and arguments.
|
|||
|
|
But both return types and argument types are not specified. Then function could be a specific
|
|||
|
|
implementation of that method, specific to a certain set of types for the arguments. The return type
|
|||
|
|
%br/
|
|||
|
|
is still not fixed.
|
|||
|
|
%p
|
|||
|
|
A compiler can generate all possible functions for a method as the set of basic types is small. Or
|
|||
|
|
it could be a little cleverer and generate stubs and generate the actual functions on demand, as
|
|||
|
|
probably only a fraction of the theoretical possibilities will be needed.
|
|||
|
|
%p
|
|||
|
|
Now, if we have an assignment, say to an argument, from a method call, the type of the variable
|
|||
|
|
may have to change according to the return type.
|
|||
|
|
So the return will be to different addresses (think of it as an if) and so in each branch,
|
|||
|
|
code can be inserted to change the type. But that makes the rest of the function behave wrongly as
|
|||
|
|
it assumes the type before the change.
|
|||
|
|
%p
|
|||
|
|
And this is where the cross function jumps come. Which is also the reason this can not be expressed
|
|||
|
|
in a language. The code then needs to jump to the same place, in a different function.
|
|||
|
|
%p
|
|||
|
|
The function can be pre-compiled or compiled on demand at that point. All that matters is that the
|
|||
|
|
logic of the function being jumped to is the same as where the jump comes from. And this is
|
|||
|
|
guaranteed by the fact that both function are generated from the same (untyped ruby) source code.
|
|||
|
|
%h2#next-steps Next steps
|
|||
|
|
%p So what’s left to do here: There is the little matter of implementing this plan.
|
|||
|
|
%p Maybe it leads to another wall, maybe this is it. Fingers crossed.
|