Proposal on latest-name

[ruv]

I prepared a proposal: New words: latest-name and latest-name-in (on forth-standard.org).

It suggests to standardize the following words:

LATEST-NAME-IN ( wid -- nt|0 )
Remove the word list identifier wid from the stack. If the corresponding word list is empty, then return 0; otherwise, return the name token nt for the definition whose name was placed most recently into this word list.

LATEST-NAME ( -- nt )
Return the name token nt for the definition whose name was placed most recently into the compilation word list, if such a definition exists. Otherwise, throw the exception code -80.

Feedback is welcome!

[MitchBradley]

I don't see any analysis of how existing widely-used systems do it.

[ruv]

A Forth system needs to know the most recent definition to implement immediate, does>, ;code.
Existing systems solve this problem in various ways. And different ways are allowed by the Standard due to corresponding ambiguous conditions.

One of the bad results of these ambiguous conditions is that a library cannot transparently programmatically create a nameless definition, or add an internal definition into its internal word list on the fly, since it affects the most resent definition in some systems (i.e., the internal definition becomes the most recent definition for the code that uses the library).

One of the directions in the Forth standardization process is reducing the number of ambiguous conditions. Therefore, we should try to avoid old ambiguous conditions in new interfaces if possible.

Just for illustration, the standard allows the following properties for the most recent definition in a Forth system:

• it can be named or nameless;
  • since "an ambiguous condition exists if the most recent definition does not have a name" 6.1.1710;
• it can be the most recent definition among all word lists, or in the compilation word list only;
  • since "an ambiguous condition exists if a program changes the compilation word list [...] before modification of the behavior of the most recently compiled definition with ;CODE, DOES>, or IMMEDIATE" 16.3.3;
• it can be a finished definition, definition for a local variable, or even unfinished colon definition (the current definition);
  • since the compilation word list formally contains only finished definitions, and it's allowed to detect the most resent definition within the compilation word list only, it is ambiguous to perform immediate when the current definition exists; additionally, "compiled definition" (from 16.3.3) cannot be the current definition.

All of these variants can be found in the wild.

In the same time, the proposed interface is very simple and does not contain any ambiguous conditions. Consequently, it does not matter how existing systems detect the most recent definition for their internal purposes.

Concerning the word list structure, I checked several systems:

• SwiftForth, VFX, Gforth, minForth, ikForth, spForth — a word list keeps information about the definition that was placed in it most recently;
• lxf/ntf 2017 — it seems, it doesn't keep this information.

An easy way to check it is to test whether traverse-wordlist do the first call of the callaback always with the latest nt in the word list.

: mb.latest-name-in  ( wid -- nt|0 )  0 [: nip false ;] rot traverse-wordlist ;
: f ( sd -- nt|0 ) get-current find-name-in  ;
: l ( -- nt|0 ) get-current mb.latest-name-in ;
t{ : foo ; "foo" f l = -> true }t  
t{ : bar ; "bar" f l = -> true }t  

[SirWumpus]

Is there some sort of "user story" for why this would be interesting?

[ruv]

Yes, I pointed out some user stories in the proposal, in the "Typical use" section. That and some other examples are as follows.

Programmatically create and use a vocabulary

One common use case is to create a vocabulary and set the compilation word list to this vocabulary at once.

: foo ( "name" -- ) ... vocabulary  also latest-name name> execute definitions ... ;

A standard compliant way is to juggle with the input buffer and search the word list. It's cumbersome. Some programs just rely on a system-specific method.

A concrete example is the following defining words, which serve to create a structure and it's fields in the structure's own vocabulary:

: struct: ( "name" -- wid.old 0 )
  get-current 0  vocabulary   also latest-name-xt execute definitions
;
: ;struct ( wid.old u.offset -- )
  "size" ['] constant execute-parsing
  previous set-current
;

Use the xt of the latest word

A use case, which is similar to the previous one on some extent, when you create a word and use it's xt for initializing.

: bar ( "name" -- ) create ... latest-name name>  set-table-current-slot  ... ;

A concrete example: a small DSL to define Final State Machines, fsl.f.

Initializing of a defer

There is some need for the capability to create a named definition and use it to initialize a deferred word, and don't repeat it's name. With repeating the name it is like:

defer foo
: foo1 ... ;  ' foo1 is foo

A more elegant way (without repeating the definition name):

defer foo
: foo1 ... ;  it is foo

To define it ( -- xt ), we need to obtain the latest definition in the compilation word list:

: it ( -- xt ) latest-name name> ;

Decorators

One more example of use latest-name is to create decorators.

NB: the idea of a special syntax for decoration is that you don't need to repeat the name of the word that is decorated.
If you need it — it's just a wrapper, which can be always implemented directly.

A decorator example:

\ A common helper to decorate the latest definition by decorator "name"
: [!] ( "name" -- )
  latest-name dup >r
  name>string ['] : execute-parsing
  r> ' execute
  postpone ;
;


\ A decorator
: make-pretty ( colon-sys nt -- colon-sys ) \ nt is the name token of the decorated word
  \ compile body of the new definition
  [: ." (I got decorated)" ;] compile,  name> compile,
;

\ The use of a decorator
: foo ." (I'm ordinary)" ;
[!] make-pretty

\ Test a decorated word
foo \ "(I got decorated)(I'm ordinary)"

---

Many other examples of use this feature can be found.