I was looking at a bug in my port of a Topaz Expression Parser example
I did a PROBE of an intermediate result and got:
>> parse-expression [1 / k !]
&[object! [
left: 1
op: '/
right: &[object! [
argument: 'k
op: '!
]]
]]
== [divide 1 factorial k]
"That sure is ugly", I thought.
Such a shame that we couldn't use FENCE! for this.
>> parse-expression [1 / k !]
{
left: 1
op: '/
right: {
argument: 'k
op: '!
}
}
== [divide 1 factorial k]
But as I've already explained... FENCE! is a list type. It has to obey the rules of lists. Those rules are pretty much laid out, it's how BLOCK!s and GROUP!s work and it has to be symmetric.
But Y'know Who Doesn't Follow Rules? 
\~antiforms~\
>> parse-expression [1 / k !]
\~{
left: 1
op: '/
right: ~{
argument: 'k
op: '!
}~
}~\ ; antiform (object!)
== [divide 1 factorial k]
OBJECT! could be the stable antiform of FENCE!
There's no expectation of being able to do series operations on an antiform...
So the actual substrate could change in the antiformization process, to a key-value store.
All it needs is the ability to round trip back. And with lifted representations, we have that tool.
You could make objects from quasiform fences, but I wouldn't get too excited because it would be like how making PACK! by hand is a bit convoluted, there's no evaluation... just a purely mechanical transform...
>> obj: ~{a: '1020 b: ~null~}~
== \~{a: '1020 b: ~null~}~\ ; antiform (object!)
No binding added (so no evaluation), etc. No commas. You wouldn't expect to be making these by hand, only by mechanistic processes.
This would mean pushing things around a bit regarding DATATYPE! and FAILURE!. I think FAILURE! could work in the same ways as a hot potato, getting its instability and undecayability by being a FENCE! in a PACK!.
Hot potatoes might even merge with ERROR!, something like ~({veto})~ instead of ~(veto)~ ... in which case they'd just be special cheap ERROR! cases.
Crazy, But How Realistic Is This?
The challenge here is that if we say a FENCE! is what an object truly "is", then that doesn't leave a lot of wiggle room for meta-magical properties. Where would information about inheritance fit in? It seems rather rigid to say that an object is nothing more than a projection of a list.
So maybe that suggests this is more basic, e.g. a MAP! (I still kind of want to call this DICTIONARY! or somesuch, because map is a verb to me in programming, not a noun).
Some have suggested that maps are "what the people want", generally... that being restricted to word keys isn't all it's cracked up to be in the Rebol world.
That might be more realistic. Although it starts looking not-so-nice, because then the keys and the values would be lifted.
You could be winding up with something that looks more like:
>> parse-expression [1 / k !]
\~{
'left 1
'op '/
'right ~{
'argument 'k
'op '!
}~
}~\ ; antiform (dictionary!)
== [divide 1 factorial k]
Anyway it was just an inkling of a thought I had from the rendering, and realizing that an antiform fence could be free from any particular rules while in the antiform state... so long as it could be transformed back.
I'm not dismissing this direction of thought out of hand... will let it rattle around for a bit.