In the past I've suggested the idea that TUPLE! run on the basic same schematic as paths.
a.b.c ; a TUPLE! a/b/c ; a PATH!
While decimal numbers like 10.20 have proven controversial to switch to be TUPLE! (e.g. by pushing DECIMAL! to use the 10,20 international format), they should be able to hold everything else PATH!s can today (which includes BLOCK! and GROUP!).
PATH!s have also become more interesting in terms of ways to augment a single WORD!...subsuming REFINEMENT! and also allowing forms that have a BLANK! in the second spot, rendering with a terminal slash:
/a ; now a PATH! (with a BLANK! in the first spot) a/ ; also a PATH! (with BLANK! in the second spot) /a/ ; this works too (3-element PATH! with blanks in first and last spots)
Then of course, these would apply to TUPLE!s as well, giving you fun new tuple variations:
.a a. .a.
This gave me an interesting idea about how to define the behaviors, which could also solve longstanding concerns in the system:
What if TUPLE!s evaluated exactly as today's GET-PATH!s would, never executing functions?
This would let you bulletproof your code a bit better when picking things out of objects that you expect to be values. You'd use dots. Terminal dots could be useful too...as a slightly more subtle way to ask a WORD! not to execute than to use a GET-WORD!.
append block data.
You could read that out as "append block, data...PERIOD." Do not call data, it is not a function. This would mean :my-object/field/subfield could look much cleaner as my-object.field.subfield (no terminal dot needed since the last internal split is a dot).
I'd suggest then that ending with a slash means that you guarantee the thing you are calling is a function.
append block data/
If you don't want to specify you leave it off, as today.
My proposal would be that only terminal slashes act this way...for compatibility. It would be your choice to use a slash internally to a path for polymorphism (as there is no other polymorphic option).
With this, you could then write:
If you were in the practice of only using / when calling functions then this would unambiguously suggest to you that method must be a function. Again--this would not be enforced.
I think this would really help decipher expressions like a/b/c/d/e/f if they were written as a.b.c/d/e/f or a.b/c/d/e/f or a.b.c.d.e/f (or a.b.c.d.e.f/ or a.b.c.d.e.f. if you wanted to be more explicit about whether the end of the chain results in a function call or value).
There are some bigger implications here about having another way of indicating suppression or execution with the terminals. I've often worried about the ambiguity of whether GET-WORD! meant suppressing execution or tolerating undefined values...which we had made an interim resolution to say that it only suppressed execution, and GET/ANY was necessary to get voids (as in Rebol2). But this throws in new possibilities so that should probably be rethought.