<sigh>
Things evolved to where "stable isotopes" are legal as function arguments...and WORD! isotopes are stable. If they weren't, you'd have to use ^META arguments for ~null~, ~true~, and ~false~ isotopes (among other things, like splices)...which would create pain. Things like equality operators (for instance) would have to take their arguments as meta.
The weird "edge" that remains is simply isotopic void, a.k.a. "trash" or the ~ isotope. Despite being stable (e.g. storable in variables) it signifies an unfulfilled parameter. But unfulfilled parameters in FRAME! become null upon execution.
The weirdness is that you can't say if var = ~ [...] because the equality operator does not take meta parameters, hence it cannot receive a trash as an actual argument. To see if a variable is unset, you have to write if unset? 'var [...] or if trash? :var [...] and it reaches its conclusion through other mechanisms... or you can do a meta-comparison against the quasiform and take it one level up:
if ^var = '~ [...] ; quoted tilde evaluates to quasi void, not isotopic void
Can End be Implemented With another "Weird Edge"?
At first glance, I'm not particularly thrilled with special treatment for ordinary ~end~ when other word isotopes are legal in frames, but then again... they've shaped up to where ~null~ and ~true~ and ~false~ have baked in behavior. (It's made me wary of assigning a truthy or falsey status to any other isotopic words).
We could effectively say all word isotopes are reserved for system use, and let people who want weird error-triggering use stable isotopic tags or something of that sort instead:
>> widget: ~<main not called yet>~
>> widget
** Error: widget is isotopic tag: ~<main not called yet>~
~true~ and ~false~ and ~null~ could sneak by with non-meta forms, and the likes of ~end~ could be used in the meaning as above:
>> make frame! make varargs! [match integer!]
== make frame! [
test: &(integer)
value: ~end~
]
You'd get a frame that you can't actually invoke unless you turn those ~end~ into something else. Just as with none (isotopic ~) you would have the blind spot of functions needing meta-parameters to handle end, with workarounds like doing a meta-access of variables you wanted to compare:
if ^frame.value = '~end~ [...]
Or a specialized function which is tailored to do the test. Presuming ~end~ is still "get-friendly":
if end? frame.value [...]
So END? would have to take a ^META argument... and it should not be endable...unless you want:
>> (end?)
== ~true~ ; isotope... but you don't want this, you want an error!
All other word isotopes would be illegal in FRAME! un-meta'd...but only at the moment of execution. They'd be reserved for future use and meaning by the system.
If we're willing to go down this route, it may open up some interesting possibilities. Like ~trash~ isotopes could intentionally transform into trash arguments without having to make them meta:
unset: specialize :set [value: ~trash~]
If it were understood that "you shouldn't really trust word isotopes unless you meta them", you'd have a rigorous path (use a ^META parameter) as well as the path of convenience.
Hmmm. 