Is assignment of array elements with let not supported?

[programandala-net]

It seems that assignment of array elements with the let function is not supported:

$> let 'a array .of: 3 0

$> print a
0 0 0

$> a\1: 100 ; assignment with the infix `:` alias works fine

$> print a
0 100 0

$> let 'a\1 101 ; but it seems `let` interprets `\` as its second parameter
=> 101

$> print a
\
=> 1

There's no difference when the index is a literal in brackets:

$> let 'a array .of: 3 0

$> let 'a\[1] 101
=> 101

$> print a
\
=> [1]

Or when it's a variable:

$> let 'a array .of: 3 0

$> let 'zx 2

$> let 'a\[zx] 200
=> 200

$> print a
\
=> [zx]

Is it a by-design limitation of the \ notation or a bug?

[drkameleon]

Basically, the \ notation is for paths.

• x\y is a :path value, meaning get the Y key (which is a value!) from X
• the equivalent as a setter would be a :pathLabel, e.g. x\y: ... set the Y key of X to whatever is on the right-hand side.

Now, a few asterisks:

• the left-most part of a path must be a normal id (= :word). In the above case, it's x (which is fine). In you example, this 'a is a literal, and paths don't work with literals (yet?)
• now, regarding the path items that follow: these are values. The values themselves. ⚠️ So, if you want to get e.g. the Nth element of an array, you would actually have to specify that you want the element at the index of N value... (in a few words, we'd have to calculate this N first). So...? We put it into brackets. (as a matter of fact, this behaves as any normal :block value, only it's executed before hand.

And, since I think some things can be explained far more clearly via code, here we go... 🎸

Paths + Blocks

Paths + Dictionaries

[programandala-net]

Thank you very much for your detailed answer.

I prefer the prefix functions over the infix symbols, because I find the resulting
expressions simpler to read, from right to left, without parens, rather than a
mix of prefix and infix subexpressions with parens. I think my Forth background
has something to do with this preference of mine.

For the sake of regularity, I also prefer let over : to assign meaning to words,
and I simply expected let 'myarray\[item] value would work too.

the equivalent as a setter would be a :pathLabel, e.g. x\y: ... set the Y key
of X to whatever is on the right-hand side.

I think I was confused about the relation between let and :, and, in
general, the "original" prefix functions and their infix alternative symbols.

It's clear let requires a single quote in let 'id value because its first
parameter must be an id name, while in let id value id would be executed
before let, returning its value.

But I supposed : was always replaceable, being just a kind of syntactic sugar
for the "actual" let. That would explain why id needs no single quote in
id: value: id is found after (i.e. to the left of) :, which can get
it in advance and "convert" the whole into let 'id value, kind of a
macro.

But it seems things are not that simple as I supposed.