Evaluator Hooking ("RebindableSyntax")

As a sort of proof of the "words aren't what we want" aspect, I changed FENCE! to default to WRAP and not CONSTRUCT...

I can still easily imagine being in some context where you want it to act like construct!

Weird Invasive Thought... what about {}: construct/

It's wacky. How would you get the current hook? Trailing slash?

{}: construct/

assert [construct/ = {}/]

This "just use the symbols" idea could go arbitrarily nuts, I guess:

>> @: func [x [none? any-element?]] [print ["DUMPING:" mold reify x]

>> @(a b c)
DUMPING: (a b c)

>> @
DUMPING: ~()~

>> x
DUMPING: x

Where this concerns me a bit is just the accidental formation of reduced cases having this heavily consequential outcome.

But... eh? It's a little hard to reject once you see it.

>> {x: 10 y: 20}
== [x: 10 y: 20]  ; bound

>> {}: func [f] [print ["Length is" length of f]]

>> {x: 10 y: 20}
Length is 4

>> {}: construct/

>> {x: 10 y: 20}
== &[object! [
    x: 10
    y: 20
]]

I'm Kind of Smitten

>> foo: proc [x] [
       let (): proc [group] [print to block! group]
       ("seriously, folks...why not?")
       ("by the way, X is" x)
     ]

>> foo 1000 + 20
seriously, folks...why not?
by the way, X is 1020

>> (300 + 4)  ; alteration to () is only in scope of foo
== 304

It has what feels like are problems, because it's invading the base case of things that might be synthesized on accident.

But are they really problems, when measured against the "HOLY CRAP, that is POWER, and that is FLUENT" aspect?

(cc: @bradrn for vibe check. Amazing lexical initiative, or silly/broken?)

:thinking: