In theory, we could allow process nodes everywhere.
We just need to define who will claim ownership and whether this leads to readable patches.
For example, a static operation could just call
MyProcessNode.Create
on that process node instance call the node fragments like Update
and finally dispose of it before returning.
Copy&pasting a patch from a process patch into an static operation region would now change the lifetime, but that's probably exactly what the user wanted to express(?)
With delegates we could just say:
Those typically don't grab the state, they don't claim ownership and leave it to the surrounding patch to manage the lifetime of the process nodes within the delegate region. Or it could be as in the operation region. Fast creation and destruction, making it threadsafe but more costly. We'd need to start an argument and proposals should clarify the details.
It would be nice if proposals also cover the loop ownership issue, where currently ownership is managed per slice, not per loop. This sounds related to the topic above. Can we have a default ownership, and opt-out of it? Where would we adjust stuff like this? Per process node?
Why would we want that feature? Seriously?
Everybody always wanted to just use these easy-to-use process nodes at any place. It is just painful if language features contradict each other. You want to be able to combine the skills that you learned, not choose between this or that way of expression. It's painful.
In theory, we could allow process nodes everywhere. We just need to define who will claim ownership and whether this leads to readable patches.
For example, a static operation could just call
MyProcessNode.CreateUpdateCopy&pasting a patch from a process patch into an static operation region would now change the lifetime, but that's probably exactly what the user wanted to express(?)
With delegates we could just say: Those typically don't grab the state, they don't claim ownership and leave it to the surrounding patch to manage the lifetime of the process nodes within the delegate region. Or it could be as in the operation region. Fast creation and destruction, making it threadsafe but more costly. We'd need to start an argument and proposals should clarify the details.
It would be nice if proposals also cover the loop ownership issue, where currently ownership is managed per slice, not per loop. This sounds related to the topic above. Can we have a default ownership, and opt-out of it? Where would we adjust stuff like this? Per process node?
Why would we want that feature? Seriously? Everybody always wanted to just use these easy-to-use process nodes at any place. It is just painful if language features contradict each other. You want to be able to combine the skills that you learned, not choose between this or that way of expression. It's painful.