"first" is doing more than expected

[DanielAjoy]

is there a way to get the first item of this quotation?

(a b c)

I was expecting the following to work, giving me 'a

(a b c) first

Instead I get

(!) (1,14) [a]: Undefined symbol 'a'

[h3rald]

Uhm... well, it behaves correctly: in this case the first item of a quotation is a symbol and it's not quoted, so when it's placed on the stack it is evaluated immediately...

[DanielAjoy]

If it behaves correctly then what is the mechanism to extract items from a quotation for later manipulation?

In Joy I'm allowed to manipulate the content of quotations to make other quotations:

[sign b c] first [swap] cons [swap] swap concat .
[swap sign swap]

Later I can use the [swap sign swap] quotation as input to map for example.

[h3rald]

This would work:

(a b c) quote-map first

[DanielAjoy]

It does seem to me like first is doing more than it should because now, by running first on a quotation you could be doing all sorts of things:

let's put some piece of code on the stack:

[clear-stack a b]

now let's try to use a word that usually means inspect, or extract:

[clear-stack a b] first

oops! Inadvertently, I executed code I might have not intended to run.

[h3rald]

Well, yes, you have a point but then this would also affect the behavior of other similar operators like get and last.

What I don't like is that although that's probably what you want, it would mean adding a quotation that isn't there. If I understand correctly, the following:

(a b c) first 

And the following:

('a 'b 'c) first 

Would both return (a).

I mean it's probably what you want 99% of the times, but I am not sure if it would be better to change the current behavior or add additional symbols to retrieve quoted symbols (in case of symbols) like:

• quote-first
• quote-last
• quote-get

Thoughts? There could also be other places where this may happen as well...

[DanielAjoy]

Why does min need to auto-apply the symbol atop the stack? I'm a novice with stack programming languages, so I'm just starting to learn how these things are done myself.

It seems that Joy does not have a problem with having bare symbols in the stack.

[cos] first .
cos

[cos] first string.
false

[cos] first leaf .
true

But you can't do much with them, other than use them to assemble lists/quotations.

https://wodan58.github.io/j09imp.html

A factor can be a single token such as an atom or one of the three constants: integer constant, character constant or string constant....
The other atomic factors are either built in or defined. All built in atomic factors are either operators or combinators. Most defined atomic factors are likely also to be operators or combinators, but it is possible to define atomic symbols which are literals.

The operation "i" is what applies quotations:

0 [cos] i .
1

But "i" cannot apply raw symbols

[cos] first 0 swap i.
run time error: quotation as top parameter needed for i

I see that you already have no problem having raw symbols on the stack: true and false

$ (true a) first
 true

$ (true a) first (("says true") ("says false") if) cons puts apply
(true ("says true") ("says false") if)
 ("says true")

Though I also notice that mins apply works differently than joys "i"

joy

[true A] first [false and] i .
false

min

$ (true a) first (false and) apply
(!) (1,25) [and]: Insufficient items on the stack
(1,25) in symbol: and
(1,32) in symbol: apply

[h3rald]

Interesting discussion going on here, I am really pleased to discuss these things with someone else interested in concatenative programming.

First let me say that it has been a few years since I looked at Joy. It was the primary inspiration for min, but I haven't really used it for anything serious and I don't aim at being "compatible" with it really. Similar yes, but there are quite a few differences.

In min symbols are applied immediately as they are pushed on the stack. As a matter of fact, "pushed on the stack" it can be considered a synonym for "executed" when talking about symbols, that's how the interpreter works.

A more interesting question for me would be why in joy symbols are not immediately applied when pushed on the stack: quotations are used to prevent execution and "meta programming" in Joy already, I guess min takes it a bit further. It's not "bad" really, it's just different but I found it quite a useful feature.

As for true and false... they are not symbols actually, they are actually Boolean literals, and they are parsed as such by the min parser.

Finally, I think min's dequote behaves more like you are expecting: it pushes each element of the quotation on the stack. On the other hand, apply interprets the whole quotation in a new scope (and a new stack) and pushes the result to the main stack, hence the error in that case.

[DanielAjoy]

I was favoring Joy's way of allowing bare symbols to appear in the stack because that way I can ask if what's there is a symbol, a number, a string, or what.

The thing is I wanted to recreate something I did in another language (Logo). This is what I tried to do:

"tabla" receives a list of two lists and apply a quotation to each pair of their cartesian product. Think of it as a table which has the first list as row headers and the second list as column headers:

show tabla [list] list [1 2] [0 30 45 60]
[[[1 0] [1 30] [1 45] [1 60]]
 [[2 0] [2 30] [2 45] [2 60]]]

show tabla [sum] list [1 2] [0 30 45 60]
[[1 31 46 61]
 [2 32 47 62]]

But the lists content can be symbols, so I can build a table of pieces of code:

show tabla [list] list [sin cos tan] [0 30 45 60]
[[[sin 0] [sin 30] [sin 45] [sin 60]] 
 [[cos 0] [cos 30] [cos 45] [cos 60]] 
 [[tan 0] [tan 30] [tan 45] [tan 60]]]

which I can then run:

show tabla [run list] list [sin cos tan] [0 30 45 60]
[[0 0.5 0.707106781186547 0.866025403784439]
 [1 0.866025403784439 0.707106781186548 0.5]
 [0 0.577350269189626 1 1.73205080756888]]

In min, I ran into problems when I tried to build the code for each cells because first behaves differently when what it extracts is a symbol, or a number.

To tell you the truth, I haven't been able to port this to Joy either, yet.

[h3rald]

Although at this stage changing how the interpreter works would be too much, I do understand there's something missing: min needs a way to analyze the contents of a quotation without pushing items on the stack.

At present there's no way of doing that except by using quote-map which is not great and probably inefficient as well, so I was thinking of adding a get-raw symbol which retrieves a value from a quotation (like get l) but this value is a dictionary containing information about the selected value:

(1 a "test") 1 get-raw
# pushes the following dict on the stack:
# {"sym" :type a :val "a" :str}

Now... that would allow you to do quite a few interesting things. The only thing I don't like is that it is currently not possible to set a key of a dictionary to a symbol (probably for the same reasons) so the dictionary returned by raw-get would be a bit special for its val key.

Thoughts?

[h3rald]

Actually no, there is a way but only when the dictionary is created:

There should probably be a way to assign a key to a symbol afterwards too... mmmm...

[DanielAjoy]

Finally, I think min's dequote behaves more like you are expecting

I see, thanks.

[h3rald]

Moved to fixed because the get-raw symbol was added, addressing the problem at least partially.