Why Don't Splices Preserve Their List Type?

The first concept of representing splices out of isotopes was actually to make them as antiform BLOCK!.

You'd get an antiform block regardless of the input to SPREAD:

>> spread [d e]
== \~[d e]~\  ; antiform (splice!)

>> spread '(d e)
== \~[d e]~\  ; antiform (splice!)

>> spread @[d e]
== \~[d e]~\  ; antiform (splice!)

From the perspective of things like APPEND, it doesn't matter:

>> append [a b c] spread [d e]
== [a b c d e]

>> append [a b c] spread '(d e)
== [a b c d e]

>> append [a b c] spread @[d e]
== [a b c d e]

Canonization of Splices Is Important

By canonizing splices to just one type, we recover the other list antiforms for other meanings that have nothing to do with splicing. That subtlety would be lost if people had to think of every list type as being a splice.

It also helps you realize information is being thrown away. Not only is the subclass of list forgotten, but any binding is removed too (!)

But which canon list form should it take?

BLOCK! Came To Be The Best Choice

Up until 2026, GROUP! was used. The idea was that since the input to SPREAD will typically be a BLOCK!, people would learn the type is not preserved quickly:

old-ren-c>> spread [a b c]
== \~(a b c)~\  ; antiform (splice!)

It was also seen as a benefit that parentheses look softer and more permeable. (This semiotic permeability exists in other places where brackets and parentheses are juxtaposed... for instance in interval notation, where [10, 20) means "the numbers from 10 to 20 without including 20")

But the fact that splices are unevaluative tipped the scales to preferring block. Also, PACK!s are "more permeable" in the sense that they have evaluative decay... and a single-item pack often seems like a synonym for GROUP! as it drops a lift level for the result under non-meta assignment:

>> foo: pack [1000 + 20]
== \~('1020)~\  ; antiform (pack!)

>> foo
== 1020

This has an especially interesting angle that heavy voids look like () as well:

>> ()
== \~,~\  ; antiform (ghost!) "void"

>> 10 + 20 ()
== \~()~\  ; antiform (pack!) "heavy void"

It became clear that SPLICE! needed to be a block antiform.

1 Like