Dispatch a list message on the message in its head

[gitosaurus]

A message can now carry arguments:

['MOVE TO' player] -> vase

The head names the method; the whole list stays bound to message, so the
receiver reads its arguments with tail message and forwards them upward
with a bare message --> parent.

The feature is one fallback

Object::dispatch() asks the sent value for a message. If it hasn't got
one, it now asks the value's head. Every value that is not a pair has an
undefined head, so nothing that dispatched before dispatches differently:
['SHATTER' 3] -> vase reaches the default method exactly as it did when
the head named nothing.

['MOVE TO'] -> vase and 'MOVE TO' -> vase are the same send. There is
no separate argumentless case to write.

message deliberately stays the whole list rather than being rebound to
the head — that is what makes forwarding free.

Four things the feature turned up on the way

head and tail bound looser than every binary operator (precedence 2).
A prefix operator's precedence governs only what it swallows to its right,
so head tail message = UNDEFINED parsed as head tail (message = UNDEFINED)
and quietly asked whether the whole comparison had a head. They now bind at
12 with the other unary selectors — random, length, numeric, string —
which is where they always belonged. The parentheses intrptr.arch was
carrying only to work around this are gone, except at line 541 where they
still separate a send from its operand and earn their keep.

Oracle for that change: Gorreven and Starship compile to byte-identical
.acx across it, which proves all nineteen head/tail sites in the
library parse the same as before.

write rendered any list as nothing at all — the one way of being wrong
that leaves nothing behind to notice it by. PairValue::stringConversion
now returns the display form, so write, &, and a debug trace all show a
list the same way.

Operators that care about structure now ask about it rather than
inheriting whatever the new string form implied:

Expression	Before this branch	Now
length [1 2 3]	7 (printed width)	3 (elements)
length (1 @ 2)	8	2
[1 2] < [1 3]	lexicographic on text	UNDEFINED
[1 2 3] = "[1 2 3]"	TRUE	FALSE
[1 2 3] = [1 2 3]	TRUE	TRUE (unchanged)
2 within [1 2 3]	4	UNDEFINED
2 leftfrom [1 2 3]	"[1 "	UNDEFINED
"items " & [1 2 3]	"items [1 2 3]"	unchanged

The rule: coercion answers "how do you read as text?" A test is needed only
when an operator's meaning depends on what the value is made of. length
counts, orderings can't order, and text surgery has no business inside a
list — within in particular stays free for a membership meaning later.
= and ~= were already structural (isSameValueAs runs before any
conversion); all that changed is that a list stopped comparing equal to its
own printed form by accident.

length walks the spine, the way std::list::size once did. An improper
tail counts: (1 @ 2) holds two things.

length [] is UNDEFINED, not 0, and stays that way for now. An empty
list terminates as UndefinedValue, which is also what an attribute nobody
ever set reads as — so answering 0 would claim that a missing attribute
contains zero things. Common Lisp gets (length nil) = 0 because its nil
wears two hats, empty-list and false, both of them values; Archetype's
UNDEFINED wears a third, missing. The loss is narrow: while lst do and
lst = UNDEFINED are the idioms, and neither needs a count. If a distinct
empty-list value is ever worth its own type, it must be false in a
conditional, or while lst do would spin.

Testing

testListMessages_ in TestObject.cc covers dispatch with an argument, the
identity of ['MSG'] with a plain message, an unclaimed head and an
unconvertible head both reaching the default method, the reply value, and
--> forwarding with arguments intact. testListLiterals_ covers the
operator table above; testPairs_ covers the string form.

18/18 suites. Both golden checks pass, and every compiled game is
byte-identical to main.

Compatibility

No new tokens and no new enumerators, so .acx files and golden binaries
are untouched — but that cuts the wrong way for forward compatibility: an
old interpreter finds nothing to fail on and silently routes a list message
to the default method. Ship the interpreter before any game that uses one.

🤖 Generated with Claude Code

https://claude.ai/code/session_01AUmuc82NHf76PrRYjgLhq5