So, this is somewhat trivial. But what if you wanted a function that instead of RETURN ending the function, it just added to the results and moved on? We might call this a COLLECTOR.
Let's imagine that we like KEEP better than renaming to RETURN
collector: func [spec block] [return func spec compose [collect (block)]]
; ^-- Ren-C semantics for COMPOSE, BLOCK! only splices if ((...))
c: collector [x] [
keep x + 1
keep x + 2
keep x + 3
]
>> c 10
== [11 12 13]
>> c 20
== [21 22 23]
>> c 30
== [31 32 33]
1 Like
For the right perspective here, this is something different than using of so called coroutines where the co-routine gets halted or paused to transfer control to another coroutine that can either finish or pass control over again.
How I solve this thing is just collecting all stuff in a block and return that.
I somehow can imagine some use of this in gaming where this would run and go calculate (perhaps in a loop) until some trigger (timer) goes off and then a break follows that results in the function to return all collected values.
Yes, I am actually in the midst of trying to suss out what it takes to implement coroutines. I just documented this because I had been offering it as a contrast, e.g. what coroutines aren't.
Coroutines require suspending evaluative state and resuming it...which is a very deep idea fraught with technical peril. But, I am making slow and steady progress on it. It's not something that happens overnight.