Could SIGIL! Carry A Binding?

[hostilefork]

@bradrn

(Not sure how happy I am with bindings on sigils, though. That feels like it may open up the same can of worms as bindings on strings do.)

It wouldn't be the case that sigils would get bound too often, since they have evaluator behavior which is not driven by binding.

>> @ x
== x  ; bound

>> $ first [x]
== x  ; bound

In neither case did the @ or the $ become bound.

@hostilefork

But there's a catch... today's WORD! doesn't retain the environment it's bound to the way lists do, it binds specifically to the thing it looks up at the moment of binding. Hence if you bind in an environment where a variable isn't defined the word remains unbound even if the symbol becomes defined later in that environment.

This is actually the big question, because I'm starting to think that words should retain the whole binding environment the way lists do. In which case it would be no particular problem to let SIGIL! do that too.

That has some unfortunate-seeming implications for performance--that words don't have a way to memorize the exact thing they look up to, to quickly fetch that same value every time.

But living in a mostly-unbound world, that's kind of already the case. I think it is probably a change that has to be made.

@hostilefork

Basically this means getting THE-SIGIL!, VAR-SIGIL!, META-SIGIL!, etc.

>> $
== $  ; bound

>> @@
== @@  ; bound

I'll point out that this would mean killing the SIGIL! for quoted and quasiforms, as @' and $~~ are clearly illegal-looking things.

This is probably for the best. Those sigils don't make sense.

>> quotes of first [']
== 0

>> sigil of first [~abc~]
== ~~

Only non-quoted, non-quasi (and non-antiform types) should respond to SIGIL OF.

However, this means these patterns may be repurposed...!