Applying Sigils Using CHAIN! (@:var) => (pin var)

[hostilefork]

@hostilefork

@bradrn

Or @:x could get the value of :x, then apply @ to it. (Note that these should probably be unordered, as I mentioned earlier.) Of course, they’re useful in dialects too.

That could be cool.

>> word: 'foo

>> @:word
== @foo

So I think this actually has to be something different... namely, the sought-after "Sigil Composition"

Since only one Sigil can be applied on an Element at a time, we could use this to have more than one. Then, you get the behavior of what the Sigil would have done if it were on the item.

Let's say you wanted to get a bound meta-WORD!:

>> $:^foo
== ^foo  ; bound

Without this you'd have to do something like use the isolated $ Sigil ("BIND HERE") with a quoted item:

>> $ '^foo
== ^foo  ; bound

Admittedly it's not much more typing in that case. But the point isn't the typing... the point is being able to represent both notions on a single Element, where if you do one PICK out of a block you can get back a single entity that conveys both ideas.

As discussed, this is important in places like FOR-EACH variables. Each Sigil means something different, e.g. @ means "reuse the variable, don't create a new one", and ^ means "lift the variable". What if you need both?

let foo
for-each [@:^foo] [a b c] [...]
assert [foo = the 'c]  ; visible outside loop

@hostilefork

@bradrn

If anything, I’m now leaning even more in the direction that combining sigils should be possible, because I can see obvious interpretations of those combinations.

there's some combination of I don't know how to do it along with I think the result would wind up being ugly and complicated ... whereas I mostly know where the current path is going and am largely at peace with it.

So @bradrn was correct. But... I believe I was too: I did not disagree on the need for multiple intents, I just downplayed its importance... saying I simply didn't see a way to do it outside of using structure via BLOCK!, which would work in the cases it came up.

But CHAIN! answered many of the issues. It's like using BLOCK!, in that it has a defined structure. But unlike BLOCK! that needs [ and a ] at a sparse point to decorate, it only needs : to stick a Sigil on, at the location of the Sigil.

It has the property I was maintaining needed to be true, that a value has only one answer for its Sigil. As such:

>> type of first [@:^foo]
== ~{pinned!}~  ; antiform (datatype)

It's a PINNED!, and its locus of control in the evaluator comes from what PINNED! does, e.g.

>> @:^foo
== @:^foo  ; bound

@hostilefork

I've biased the system to error on applying Sigils to things that already have them, because I think that's too permissive, and leads to misunderstandings:

>> x: @foo

>> lift x
** Error...

I don't know if it's a great idea to become too casual about it, but:

>> x: @foo

>> lift x
== ^:@foo

My instincts would be that it should require a refinement, you changed the fundamental type... lift:multi ?

(I bias things for safety first, usually... because it's easier to relax them later than it is to add the restriction later.)