Comment by Jtsummers
3 months ago
> all functions statically allocate enough space for their locals.
Would you still have distinct activation records per call or forfeit the ability to have reentrant functions and recursion?
That's one of the main reasons to move to dynamic (as in a call stack) allocation of your activation records versus a single static allocation per function.
In this hypothetical language I'm assuming that recursion is unsupported and that if threading is supported at all, then each thread has its own copy of every function's locals (or at least every function that can be called concurrently; structured concurrency might be leveraged to prove that some functions don't need to be reentrant, or maybe you just chuck a mutex in each function prologue and YOLO). However, while enforcing that basic recursion is forbidden isn't too difficult (you make the language statically-typed, all names lexically-scoped, and don't support forward declarations), it does probably(?) mean that you also lose first-class functions and function pointers, although I haven't thought deeply about that.
I think lambdas or function pointers can be possible if they assume all of the scope of where they are called rather than where they are declared, that would prevent them from allowing recursion through forward declarations.
It would be awkward to work with since you'd have to be aware of all of the eventual caller scopes rather than your current local scope when defining it.
I suppose it would be like macros instead of true functions.