Given data in ace file format:
tag a b
tag c d
I would expect
ff = CLASS FOO, // line 1
dd = ff->tag // line 2
would get the two pairs (f,a) and (f,d)
would get whatever is after tag2 inside objects a and c, not something
in f at all.
I think -> should definitely dereference a pointer. It is also
natural to use . for this. NB ff is a KEY, i.e. an object pointer.
Line 1 gives it no context of being in an object. You can not move
right. So ff#tag is meaningless.
In order to eliminate #, we need to have imagine another node in each
object where the '#' symbol is in the model. This gives the
pseudo-object-id that is dereferenced. One problem is that there is
no NAME or CLASS of this pseudo-object-id. If we do not imagine this
extra node, we can have ambiguous queries. In fact the difference
between # and . in our original proposal is exactly what is needed to
disambiguate: do you go into the object referred to by this KEY (.),
or do you move right in the same object (#).
In fact, you could have the syntax [tag] to mean #tag, i.e. stay in
the same object, e.g. given
tag a b
tag c d tag3 e
where tag3 is in a submodel, then
ee = ff.tag[tag3]
would access e? This is sort of natural. A bit like associative
array dereferencing in perl, which are the foundation of GDB's