API: accessors to methods vs higher level methods

[ruv]

Recognizer v4 API proposes to use accessors on a descriptor.

An accessor fetches from a descriptor the xt of an action that can be performed on a token. There are words like RECTYPE>COMP ( td -- xt-compiler ), RECTYPE>INT ( td -- xt-interpreter ), etc.

But it is simpler to use the words that do the corresponding actions instead using of the accessor. Some possible actions:

• interpret-token ( i*x token{k*x} td -- j*x )
• compile-token ( i*x token{k*x} td -- j*x )
• translate-token ( i*x token{k*x} td -- j*x )
• postpone-token ( token{k*x} td -- )
• reproduce-token ( token{k*x} td -- )
• drop-token ( token{k*x} td -- )

NB: the most of them are not demanded by programs, and so shouldn't be standardized.

Rationale

In the most cases a user/program needs just to perform the target actions. Getting an xt and then executing it has an excessive step without any profit.

E.g.

• rectype>int execute vs interpret-token
• rectype>comp execute vs compile-token

Perhaps an implementation of POSTPONE can be slightly better optimized if it relies on accessors. But POSTPONE is a standard word and its implementation may use the carnal knowledge. So, this reason isn't enough to standardize accessors.

NB: the run-time semantics compiled by reproduce-token can be to reproduce either the token, or the token and its descriptor, and what is better is needed to be analyzed.

In comparison with other actions, reproduce-token and drop-token are not connected to the source lexeme semantics.