What should evaluating an empty block (`EVAL []`) do?

Development Semantics
21

Since I'm trying to rig up the Big Alien Proposal (and the .WORD to select members proposal), I'm forced to spend some "quality time" with Rebmake. I'm actually happy to say I'm thrilled at how much clearer the once foreign-to-me-looking code is.

But I found at least one possible reason why EVAL of empty block (or branch) might should be NOTHING by default. (and NIHIL if you give it a EVAL/VANISH refinement or similar)

Devil's Advocacy: eval [] as NOTHING :imp:

Sometimes you write a switch or case statement, and there's nothing in the case:

switch x [
   'foo [
       ... do a bunch of stuff ...
   ]
   'bar [
       ; comment about how this is handled elsewhere
   ]
   'baz [
       ... do a bunch of other stuff ...
   ]
]

So what I'm seeing here is a situation where a branch produced, well, nothing.

I'm imagining someone coming along to a multi-page SWITCH or CASE (like the ones in Rebmake) and deciding to take the result of the branch and use it. And if they don't realize one of the branches was meaningless, then if we give them back VOID it can wreak havoc.

VOID opts out of lots of stuff. Luckily with VOID-in-NULL-out it can't propagate too far, but even one level of propagation can be confusing.

Despite This Wrinkle, I Still Think VOID Wins

Let's say you're writing something like this:

compose [a b (either condition ['c] [print "skipping"]) d e]

You have a branch that is running, and doing something... but you want it to effectively disappear. But if you don't do something about the NOTHING coming back from PRINT, COMPOSE will choke on trying to put the non-void antiform it in the slot.

One way to deal with this is:

compose [a b (either condition ['c] [print "skipping" void]) d e]

Generally speaking you're going to want a comma there, especially if it was something more unfamiliar than PRINT, to emphasize it isn't an argument:

compose [a b (either condition ['c] [print "skipping", void]) d e]

And sure... you could do that. :confused: But I think the rhythm is measurably better with:

compose [a b (either condition ['c] [elide print "skipping"]) d e]

Well there you go. A proven use for the "unsafe" behavior.

(I like finding such cases so at least we know the decisions about these things aren't being made at random.)