value-flavoured approach (was: value-flavoured structures)

On 2024-10-05 19:52, Anton Ertl wrote:

Ruvim <ruvim.pinka@gmail.com> writes:

What advantages do you see in *using* the to-based setters?

 Over using SET-... words?

I've compared the use of a to-based setter ("to foo") versus a separate setter ("set-foo") in programs. (NB: not creating them, but only using)
I do not see any advantage of "to foo" over "set-foo" at the *source code* level.
And I asked about advantages in this context. Do you see any advantages in using (i.e., not declaration/creation) at the source code level?

 1) It's a popular and convenient mechanism.

Agreed. But this says about knowledge and tools, not about using already defined setters in the source code.

 2) I can find out the setter from looking at the central word:

A separate setter for a word "foo" can be checked using only standard words as follows:
   "set-foo" find-name .

 ``vf .hm
\ output:
opt:     $7F43EB229B98
to:      $7F43EB229BE0
extra:   $7F43EB229B60

int:    noop
comp:   default-name>comp
string: named>string
link:   named>link  ok

 Ok, $7F43EB229BE0 is not very informative, but I can still make use of
that:
 $7F43EB229BE0 xt-locate
struct-val.fs:88
...
cell      ' aligned   ' @   !a-table   wrap+value: value:   ( u1 "name" -- u2 ) \ gforth-experimental
...
 

[...]

For example, it could be a defining word "val" that is used as "val x"
and creates the getter "x" and the setter "set-x".

[...]

   \ Let's redefine the setter "set-x"
   : set-x ( u -- )
     dup 10 u> abort" too big value for x"
     set-x
   ;
>
   t{ 4 set-x x -> 4 }t
   t{ 11 ' set-x catch 2drop  x -> 4 }t
>
>
Could you show how to implement that in Gforth when the to-based setter
"to x" is used?

 : to-x ( u xt -- )
   >r dup 10 u> abort" too big value for x" r> >body ! ;
 to-table: x-table to-x
' >body x-table to-class: x-to
0 value x
' x-to set-to
 4 to x x . \ prints "4"
11 to x
 The last line produces the following error:
 *the terminal*:13:7: error: too big value for x
11 to >>>x<<<
 

Thank you! As I see it, this interface is quite cumbersome for the specified problem, because it forces us to use two intermediate data objects: "to-table" and "to-class".

NB: the solution must not change the original "x", it must redefine "x".
The difference is that the new definition *can* be in a different word
list, in which case both definitions (old and new) can be used depending
on the context.

 Let's see.  To make it easier to see what is going on I use a
different name for the redefined word.
 0 value y
synonym z y
' x-to set-to
 4 to y
z . \ prints 4
11 to y
z . \ prints 11
11 to z \ aborts with "error: too big value for x"
 For a bounds-checking TO I find this requirement strange, however.

Yes, for a bounds-checking TO you probably will define checking at once, or redefine the word at once in the same word list.
But in some other cases I need to have access to both old and new words, so I wanted to see what a Gforth-specific solution for a to-based setter looks like.
--
Ruvim