Locals word set for float stack?

[SirWumpus]

Was looking at the Forth 2019 draft of the Locals words set and was curious about locals for floats. In a mix data float stack Locals would work without change, in a separate data and float stacks system, the Locals word set would only apply to the data stack.

Curious as how to apply Locals for both data and float stacks (mixed or separate). Should {: ... :} introduce a delimiter, :f: to separate data from floats, eg. {: a b :f: x y :}?

[ruv]

In Gforth, float local variables are defined using a preceded type specifier f: as {: a b f: x f: y :} (see the manual).

I dislike the space between a type specifier and a variable name because it makes readability worse.

I would prefer a syntax like this: {: a b f:x f:y :}. Probably, a better way is to use the standard data type symbols. If a data type symbol is absent, then x (unspecified cell) is implied.

For example: {: n:a u:b xt:func r:x r:y :} a b func x y f+ f.

[forthy42]

When we implemented this in Gforth about 30 years ago or so, it was easier to parse that way. Nowadays, the locals defining recognizer is just a recognizer stack (new-locals-rec and locals-types), so parsing {: r:x xt:func :} is not difficult (and could even be added later as user-written extension).

There are at least two possibilities

• Fortran-Style, as written in the Standard stack effects: Some characters as first letter(s) of a variable define its type, so all r* are floats, all xt* are functions
• As you proposed, use a colon to specify that the character actually is a type selector (more obvious than Fortran-style), but no space is needed
• I often would rather like state-full switching stacks, e.g. {: a b |f: x y :}, where everything after |f: then is floating point, and you could have {f: x y :} for all floating point local declarations. There's not much point in readability when you mix the different variable types; usually, they cluster neatly or you have either all integer or all floating point locals

[ruv]

I often would rather like state-full switching stacks, e.g. {: a b |f: x y :}, where everything after |f: then is floating point, and you could have {f: x y :} for all floating point local declarations.

I also thought about a separate declaration for float locals. The only argument for not separating floats is that this approach does not apply to strings, double-cell integer, execution tokens, etc. And if we support double-cell integers and strings, why not to support floats in the same way. Otherwise I don't have objections for placing all float variable declarations into a separate group.

[ruv]

I'm just not sure abut xt:func. What if we want to specify the xt data type for a stack parameter, and want the corresponding local variable to return that parameter (i.e. without execution it). Do we instead have to only use ['] func or a special syntax like xt:func, 'func (or Gforth's `func)?

[forthy42]

Am 30. August 2024 15:55:10 MESZ schrieb ruv ***@***.***>:

I'm just not sure abut `xt:func`. What if we want to specify the _xt_ data type for a stack parameter, and want the corresponding local variable to return that parameter (i.e. without execution it). Do we instead have to only use `['] func` or a special syntax like `xt:func`, `'func` (or Gforth's ``` `func```)?

Use `action-of`; we treat xt: locals like deferred words. -- Bernd Paysan "If you want it done right, you have to do it yourself" net2o id: ***@***.***}1GWr!+0qqp_Cn176t4(dQ* https://net2o.de/