# . : ->

[rd at sanger.ac.uk]

Given data in ace file format:

FOO f
tag a b
tag c d

I would expect

FROM
  ff = CLASS FOO,		// line 1
  dd = ff->tag[2]		// line 2

would get the two pairs (f,a) and (f,d)

ff->tag->tag2

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[2] 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

FOO f
tag a b
tag c d tag3 e

where tag3 is in a submodel, then

  ee = ff.tag[2][tag3]

would access e?  This is sort of natural.  A bit like associative
array dereferencing in perl, which are the foundation of GDB's
tag:value system.

Richard