quotations and closures (was: Operator overloading?)

On 2024-07-27 22:16, minforth wrote:

On Sat, 27 Jul 2024 15:35:55 +0000, Anton Ertl wrote:

minforth@gmx.net (minforth) writes:

[[: ;]] define closures, but unlike gforth's more flexible
flat closures, they capture simply all upvalues (here local a).

>
Gforth's flag closures can be considered lower-level (they come out of
implementation ideas in the Scheme community) and are easier to
implement, but emulating closures that capture outer locals is more
cumbersome.

 In MF36 quotations already have read/write access to the locals of the
parent function.

I think, the standard quotation (that is defined via "[: ... ;]") shall return the same xt in different runs in run-time.
For example, the following word "foo":
   : foo ( -- xt ) [: bar ;] ;
is a constant, as it always returns the same xt.
Therefore, it's better to throw an exception if an external local variable is referenced in a standard quotation.
If a local variable can be referenced in a nested definition (and the funarg problem is solved), it's better to call that definition a "closure" rather than a "quotation".

So closures became a simple by-product through capturing
the parent's locals stack and injecting it at startup during closure
runtime. When the closure finishes, the captured stack is simply
updated.
 I don't know if this would be good enough for a Lisp/Scheme programmer,
but it works for my needs. And look Ma, no garbage collection. :-)
 

One other aspect is that in Gforth's closures the
programmer decides whether closures are allocated in the dictionary,
on the locals stack, on the heap, or elsewhere.

 In MF36 it is only the locals stack. AFAIU in other programming
languagues there are closures where the parent function can be seen as
constructor. IOW call the parent function twice and you get different
xts/addresses. From this perspective MF36 closures would perhaps only
qualify as 'half-closures'.

A related problem is known as the funarg problem [1].
I can guess, the upwards funarg problem is not solved in MF36.
Concerning the downwards funarg problem — is it solved for the cases when the enclosing function is called recursively (directly or indirectly)?
A dumb testcase:
   : t1 ( u xt -- u )
     {: k xt :}
     k 0= if 0 exit then
     k 1-  [[: k ;]]  dup >r recurse r> execute +
     xt if xt execute + then
   ;
   t{ 0 0 t1 -> 0 }t
   t{ 1 0 t1 -> 1 }t
   t{ 2 0 t1 -> 5 }t
   t{ 3 0 t1 -> 11 }t
[1] https://en.wikipedia.org/wiki/Funarg_problem
--
Ruvim