((Doubled Groups)) as a Dialecting Tool

[hostilefork]

In trying to get COMPOSE to lose /ONLY, there was a time when it looked for doubled groups.

>> block: [a b c]

>> compose [(block) ((block))]
== [a b c [a b c]]

I liked it, and I said:

@hostilefork

As a higher-level tool, it should cater to the higher-level needs...and that's not splicing unless you ask. I really believe this is the better behavior for people who are writing and reading the code.

But I found concerns:

@hostilefork

One qualm I have about this is the visual difficulty of telling if something is a double-group if you are composing more than one item.

>> compose [a b ((some code
         that goes on and on and) oh it ended there (maybe you start
         another group and
     eventually end)) d e]

That's not a splicing case because it's not a double group, but it kind of looks like one.

To be fair: it's hardly the only case where if you jump to conclusions on reading a few characters that you'll have problems because the code keeps going and may invalidate the assumptions you made by looking at those few characters. But it still wasn't perfect.

...and as it turned out, it was another one of those "close but no cigar" cases of wanting to mark the intent of splice specially, but using a mechanism that's not as good as splice isotopes!.

I think that doubled-up-groups are a neat example of a dialecting concept, where you might want to give that significance. It would certainly belong in the dialecting handbook (if we had one).

But in the COMPOSE case, we have a better option... compose [... (spread block) ...] (or another operator of your choice that produces block isotopes). And it's more fitting for the core, because it doesn't have the weakness mentioned above.

---

Not that it would be hard to write again, but here's the C code for detecting doubled groups!

INLINE bool Is_Any_Doubled_Group(NoQuote(const Cell*) group) {
    assert(Any_Group_Kind(Cell_Heart(group)));
    const Cell* tail;
    const Cell* inner = Cell_Array_At(&tail, group);
    if (inner + 1 != tail)  // should be exactly one item
        return false;
    return Is_Group(inner);  // if true, it's a ((...)) GROUP!
}