So I'll just restate that improving the runtime thing that is "OBJECTMAP!" is clearly on the agenda, but these source representation issues are related and important to get at too.
Clearly I am sympathetic that it would be nice if we could have a "this is an object" notation at source level.
To say "all you need is MAKE OBJECT! on BLOCK!" is like saying you don't need GROUP! (since you can DO a BLOCK!)
However, in "Rebol's JSON" I just suggested assuming all BLOCK! that start with SET-WORD! are objects, and then have some escape notation for the outliers.
There's a sense where recognizing BLOCK!-starting-with-SET-WORD! is an unsatisfying answer. But also a way in which you can choose to find it satisfying. It does have its upsides: Rebol is good at working with and composing blocks, they're inert and use the most pleasing bracket...
Maybe the operator that loads the above-proposed "Rebol JSON" is something easy to use. I propose it maybe being a symbol and done via its own array type. But maybe it's so foundational it should take the name MAKE (we never figured out what the difference of MAKE and TO are, really...)
I dunno, but let's look at having it take over MAKE as a placeholder for "really easy to ask for" (and potentially giving us MAKE-WORD!, MAKE-BLOCK!, etc. as easy named variants)
>> stuff: make [
name: "objects"
list: [[a: 10 b: 10 + 10] <gap> [a: 30 b: 20 + 20]]
]
== #objectmap![
name: "objects"
list: [
#objectmap![a: 10 b: 20]
<gap>
#objectmap![a: 30 b: 40]
]
]
I do think that it's worth pointing out generic quoting as a way to escape out of evaluation when you don't want it:
>> stuff: make [
name: "plain block"
list: '[[a: 10 b: 10 + 10] <gap> [a: 30 b: 20 + 20]]
]
== #objectmap![
name: "plain block"
list: [[a: 10 b: 10 + 10] <gap> [a: 30 b: 20 + 20]]
]
>> stuff: make [
name: "list with objects and blocks"
list: [[a: 10 b: 10 + 10] <gap> '[a: 30 b: 20 + 20]]
]
== #objectmap![
name: "list with objects and blocks"
list: [
#objectmap![a: 10 b: 20]
<gap>
[a: 30 b: 20 + 20]
]
]
And you still have full representational coverage...double quoting to give you a single-quoted block if that's what you meant:
>> stuff: make [
name: "quoted block"
list: ''[[a: 10 b: 10 + 10] <gap> [a: 30 b: 20 + 20]]
]
== #objectmap![
name: "quoted block"
list: '[[a: 10 b: 10 + 10] <gap> [a: 30 b: 20 + 20]]
]
That little twist of "quoted things are always that thing minus one quote level, but unquoted things can be more free in their meaning" is something that has shown to have a lot of interesting applications. And here we see it letting us say non-quoted blocks are subject to the "might represent an object" treatment.
I think it's cool.