I'd quite like some OOP. Having looked at the intepreter source, i realise you can't do any indirection (without hacking the stack frame, anyway !). I also appreciate that significant language changes to the compiler are non trivial.
My suggestion is for a simple but useful extension which is purely syntactic. I have actually written code like this to encapsulate libraries and so on.
type myclass
<members>
endtype
function myclass_initialise(this ref as myclass,...)
function myclass_update(this ref as myclass...)
demo as myclass
myclass_initialise(demo,...)
It would seem that dot operators aren't extensively used. My suggestion is a syntactic shim that converts
demo.initialise(<parameters>
into
myclass_initialise(demo,<parameters>
So types automatically become a sort of quasi class that you can use straight off.
Now there are obviously huge problems with this. You can't inherit, there's no polymorphism and so on. You can work round some if not all of that to a degree. But I think it would add something to AppGameKit Basic Tier 1 in terms of encapsulation and readability. without large amounts of work and complex changes to the compiler - I haven't obviously seen the compiler source, but all it would need to do is to change the parsing to allow a '.' or other character to appear in the name, detect that, and then do the syntactic switch by looking at the type of the entity before the seperator.
(For simplicity, it probably wouldn't be worth changing the actual definition part)
There wouldn't seem to be any issues with old code, which would work as normal, as the dot character isn't allowed in function identifiers anyway.