Re: Toad using many vocabularies

On 2024-11-01 19:08, Anthony Howe wrote:

On 2024-11-01 10:28, Ruvim wrote:

Such a syntax is used in SP-Forth/4 since 2001, in the form <voc>::<word> or <voc1>::<voc2>::<word>
>
Where <voc> is a word that returns wid, or a word that is created with `vocabulary`.
>
This syntax in SP-Forth probably came after C++ "::" operator, introduced in 1998.  The same operator was in C# from its initial release in 2000.

 >

The dot "." operator for accessing nested packages in Java was introduced in 1995.
>
In Forth, a dot is often used as part of plain names, so it was less suitable as a namespace separator.

 Yep.  Bad idea to use dot.

Do you mean to use dot in names or to use dot as a namespace separator in Forth?

Never liked `::`, found it visually distasteful.

Agreed. But there no very good choices, as you mentioned below ))

 Dare I suggest C's `->` which trumps others by decades.

BTW, as far as I understand, the `->` operator in C is not about namespaces, but about dereferencing a pointer and accessing a structure member.
So,  `ptr->field` is a shorthand for `(*ptr).field`
That is, `ptr` is not a namespace. The namespace (in which the name `field` is resolved) is inferred from the *data type* of `ptr`.

Or simply create a new one like `:>` or  `~` (oh I'll be stoned for this one). I would prefer a single character, but there are so few good choices.
 

At the moment, I like the XML namespaces syntax the best.
The idea is that we associate a long namespace identifier with a short prefix, which is only valid within its lexical scope.
The syntax is:  <prefix>:<name>
Since a prefix is ​​valid in a limited scope, it can be short without risk of conflicts/clashes. Typically, only a few sibling prefixes are used in a module.
So, a name is qualified by its namespace using only one short prefix, regardless how deep this namespace is nested.
Of course, there can be some predefined prefixes (which can still be shadowed).
For example, I want to use a module:
<https://github.com/ForthHub/fep-recognizer/blob/master/implementation/lib/string-match.fth>
There can be a special mapping `github` to treat modules from GitHub.
At an API level it could be like this:
   "github:ForthHub/fep-recognizer/implementation/lib/string-match.fth"
   "str" module:push-prefix
   "foobar" "foo" str:starts-with .  \ should print -1
   module:drop-prefix
Under the hood, the system should download the package "github:ForthHub/fep-recognizer" (if it hasn't already cached), then the module "implementation/lib/string-match.fth" from this package should be instantiated in memory it its own word list (if it hasn't already), then the prefix "str" is associated with the word list of this module.
The lexeme "str:starts-with" is processed by the recognizer of prefixes, which extracts the prefix "str", obtains the corresponding word list, finds "starts-with" in that word list, and returns the name token for the word and the name token translator, as `( nt tt-nt )`. The Forth text interpreter executes `tt-nt` (which is an xt) to perform the compilation semantics or interpretation semantics for the word according to the current state.
--
Ruvim