R3-Alpha had what I had thought was a bizarre behavior:
r3-alpha>> get 5 + 5 == 10
If something wasn't a WORD! or PATH! it would fall through. Unless it was an OBJECT!, in which case it would get the values of the object vs. the OBJECT! itself.
Then it could SET a block, but it didn't symmetrically GET one...the BLOCK! was just one of the miscellaneous things that fell out:
r3-alpha>> set [x y] [10 20] == [10 20] r3-alpha>> reduce [x y] == [10 20] r3-alpha>> get [x y] == [x y] ; one of the as-is types, Red/Rebol2 error on this
I realized that if GET of a BLOCK! worked, then the GET of an OBJECT! behavior could just be get words of obj, which seemed more clear and generalized. So I changed GET of a BLOCK! to work symmetrically to set.
ren-c>> x: 10 ren-c>> y: 20 ren-c>> get [x y] == [10 20]
And then along came GET-BLOCK! and SET-BLOCK!
The most sensible seeming behavior for :[...whatever...] would seem to be the same as get [...whatever...]. So at first I decided a shorthand for REDUCE was likely more useful. It seems you want to REDUCE blocks more often than you GET them (which is especially true since Redbol couldn't GET blocks at all).
But this raised a question: should GET of a BLOCK! reduce it? If R3-Alpha's odd behavior of letting you GET inert quantities was preserved you'd be almost there.
r3-alpha>> get 5 + 5 == 10 ; the weird behavior mentioned before >> get [x y 5 + 5] == [10 20 10] ; potential extension of this
On the surface this would seem to offer an advantage of a shorter word than REDUCE, along with a symmetry between GET-BLOCK! and GET of a BLOCK!. But the symmetries break down because you expect GET of a WORD! that looks up to a function to give you the function back by value and not apply it.
>> get 'add == #[action! ...] >> :add == #[action] >> get [add] ** Error: ADD is missing its value1 argument ; uh oh
This was the reason that GET-BLOCK! behavior was changed away from REDUCE. Which I forgot when writing up my idea last night.
Even if GET of a word looking up to an ACTION! gives an action directly, one could allow GET of a GROUP!:
>> get '(add 1 2) == 3 >> get [add (add 1 2)] == [#[action! ...] 3]
This could mean a GET-BLOCK! could be almost as powerful as REDUCE. It's just that REDUCE wouldn't need parentheses around function calls. But having something that's almost-reduce-but-not-quite might just be asking for trouble, and having the weird get 5 + 5 working could just be a slippery slope of luring people into misunderstandings.
I think it's kind of non-negotiable psychologically for GET of a BLOCK! to do the same thing as a GET-BLOCK!. Allowing that to be REDUCE seems to pack some power, but it would mess with things like:
set words of obj1 get words of obj2
If any of those words were functions, you'd wind up running them.