REMOVE-EACH is a somewhat problematic operation, in that it is doing a low-level manipulation of an array's contents...and you don't want to expose any intermediate states that aren't valid.
The efficiency of it is questionable...e.g. if you have an array that is 1,000 items long and you remove half of them, your array will now have 500 unused slots. Also, each time you remove an item you have to slide the rest of the array down...otherwise you leave an array which may have outstanding references in a potentially invalid state.
Ren-C went to some extremes to try and make REMOVE-EACH "rigorous". But it seems that it might be better to just write something like
remove-each: func [
{Removes values for each block that returns true.}
return: "Number of removed series items, or null if BREAK"
[<opt> integer!]
'vars "Word or block of words to set each time (local)"
[blank! word! block!]
data "The series to traverse (modified)" ; should BLANK! opt-out?
[<blank> any-series!]
body "Block to evaluate (return TRUE to remove)"
[<const> block!] ; !! Should support ACTION!
][
if empty? :body [body: [void]] ; GROUP!s vaporize when empty, address it
let mp: either block? vars [:map-each/splice] [:map-each]
let new-data: mp (vars) data compose/deep [
if not (as group! body) [get/any '(vars)]
]
if null? new-data [return null] ; BREAK
let diff: (length of data) - (length of new-data)
swap-contents data new-data
return diff
]
This hinges on the SWAP-CONTENTS low-level operation (better name sought), which would simply take the guts of the new series and swap it out with the old series. Code for this already exists.
What this means is that any code which accessed the original array during the removal process would see it as the pre-modified form. Which is basically what the Ren-C bulletproofing did, just much more awkwardly. :-/
REMOVE-EACH isn't all that terribly common, and the acrobatics required to make it safe aren't really a good use of time...especially to port here in stackless. It's better to invest more into making MAP-EACH stackless and rigorous, and spending time on more important problems.