So in regards to file structure planning, I've got a somewhat preliminary plan

Problem is that it's on papwe

*paper

I'll upload a picture later

!!/run ka13ȯ 9ɾ v↔

!!/info

well in any case

I think you can get what I want this to do, I'm just unsure why it doesnt work

right

so what do we do with commands.py? split it up?

between different arities?

Hey where is the bot?

@math do you mean for the rewrite?

Speaking of which, we still need to decide on file structure, code style guide (including things like variable name rules, function overload rules etc) and other things like if people really do want to switch to interpretation

@lyxal yes

Well, I think keeping it as a single file is fine

@lyxal I thought so too. After the cleanup it was split up.

@math oh

Wait

No it isn't

no?

No

Commands.py is still all one file

oh my bad. I meant the helper function files

Oh.

Then I don't knoe

*know

!!/lol u good there my epic bro?

@hyper-neutrino ^

How can he be good if he ain't here

@math ^

!!/ why u bad my epic bro

@lyxal nice

recent?

yeah

yesterday actually

I got my trusty pen and notebook and just sketched out a kind of plan

it's by no means definitive/what we'll actually do

but just a way I thought might work

when I say notebook, I actually mean physical paper

I have a whole notebook filled with vyxal notes

and I'm filling a second currently

@Underslash I don't really understand what you're trying to do here, but I'm prbly just being big dumb.

same here

lol I just realized I still have that JS hyperping thing that Razetime made in my bookmarks

I did too until I deleted it recently lol

@Underslash what do you expect it to do?

@hyper-neutrino where bot?

"websocket closed unexpectedly"

oh

h..how?

w..who?

w..why?

@VyxalBot lol u good my epic gamer?

@lyxal I am doing wonderfully.

phew

@lyxal no clue sometimes things just die

@VyxalBot we missed you

@VyxalBot ༼ つ ◕_◕ ༽つ

oooh that's a good idea

!!/hug

to show some love for vyxalbot

will add after i am done breakfast

I too enjoy the act of breakfast

breakfast over code though

don't rush

and make sure to do all that you normally would

!!/night

!!/'night

@lyxal o/

i have fulfilled the needs of my mortal vessel

hyper-neutrino pushed a commit to VyxalBotSE/master: 2 space indent => 4 space indent

!!/pull

@hyper-neutrino pulling new changes; I will restart in a few seconds if any updates are available

!!/status

@hyper-neutrino I am doing you.

aw fuck i can't believe you've done this

@VyxalBot ugh space indentation

heinous

hyper-neutrino pushed a commit to VyxalBotSE/master: add !!/hug

!!/pull

@hyper-neutrino pulling new changes; I will restart in a few seconds if any updates are available

!!/hug

@hyper-neutrino ༼ つ ◕_◕ ༽つ

AMiller42 opened issue #195 in Vyxal/Vyxal: Two-char strings do be breaking parsing again

!!/run »‛ab»

@AaronMiller (output was empty)

frick

petition to rewrite the parser too /hj

@hyper-neutrino I just discovered yet another parsing fun fact: The thing that let's you put strings inside diagraphs also does a similar thing for SCCs:

!!/run `₴This is an ASCII string surrounded by non-ASCII that will say the name of the language: ŀ

@AaronMiller This is an ASCII string surrounded by non-ASCII that will say the name of the language: Vyxal

ah

very nice

I bet I could make another cop using that

what are your thoughts on rewriting the parser

might be unnecessary but i feel like it may not be a bad idea to take all of the weird things now and just do a rewrite and get rid of them for good

i feel like the current parsing method is unnecessarily complicated but tbh i haven't taken that good of a look at it

another proposal: have better documentation for elements.txt; specifically, i propose storing it as a JSON/whatever file and having elements.txt and elements.md be generated from that by github actions or whatever

also also storing elements, modifiers, transformers when they exist, and structures in categories

this may or may not be related to vyxapedia :p

@hyper-neutrino I guess the options are: Fix the parser as new problems are inevitably found, but for now it works great; or Rewrite the parser, which will probably take some time and effort but could save a lot of trouble later on.

@hyper-neutrino Also, I think this sounds like a reasonable idea, though I have no knowledge of whether this will be better for us or not, although it would definitely be better for Vyxapedia.

@hyper-neutrino Good idea, I don't think we need elements.txt at all

it'd make automatic scanning of documentation into vyxapedia perfect, whereas right now i would need to be careful about how i parse and if people don't stick to perfect conventions it might break everything when they commit

@AaronMiller What does y'all think of these ideas?

!!/hyperping

@AaronMiller @Ausername @PyGamer0 @hyper-neutrino @lyxal @math @pxeger @user ^

@AaronMiller TBH vyxal doesn't seem that hard to lex or parse (i don't recall vyxal having a lexer file but i think its parser is more of a lexer) and I would be happy to rewrite the parser because right now it seems that the way various things like digraphs and syntactical components are consistently broken or behaving strangely

I have no idea what a lexer is vs a parser

lexer i.e. tokenizer transforms code into tokens

parser transforms tokens into a parse tree or whatever structure

ah

@hyper-neutrino Are you saying that k`BuzzFizz`F is strange or broken behavior? Clearly it's a feature, not a bug. /s

!!/run k`BuzzFizz`F

@AaronMiller FizzBuzz

i mean it could be a feature but like

even then it should be coded to specifically do that

@hyper-neutrino Tokenizing can also make Vylight easier maybe

good point

@hyper-neutrino @lyxal

the procedure I believe would make sense is:

and thus there should be three files, one for each of these (plus any interfacing code, whether that is a direct run file or the online interpreter server or both)

and then at the execution phase there should be adequately divided files for the token to python code map, the built-in function implementations, utility functions for each category of task, etc

@hyper-neutrino Alternatively, parse tree is turned into bytecode or directly interpreted

But this looks like a good procedure

that works too

making a direct interpreter is likely what I'd do but idk if transpiling is more or less efficient when it comes to runtime

@hyper-neutrino Meh, I don't think we need to worry too much about runtime

true

It's like when people use Python for machine learning stuff - the interpreted language on top is slow, but the stuff at the core is fast. Here, Vyxal is the "high-level" language wrapping around Python

yeah that is a good point

well, we'll see. i don't see a good reason to necessarily not use transpilation

and this way pxeger can also transpile it into bytecode instead using the same approach

@hyper-neutrino Harder to debug and refactor for the most part

hm. i could argue either way but yeah that's a very good point

Maybe not debug, but refactor, certainly

well, I expected it to vectorize over the top of the stack (which was a range) and use that range variable as the second part of the argument to the combination

@Underslash Why do you want to do that? Is there a certain challenge that you're trying to answer?

it was for a challenge but I wouldn't have been able to submit it anyways cause vyxal cannot do file writing

i think i might just be confused on how vectorize works

Vectorization works pretty much the same as a map lambda. In this case, the ↔ command is vectorizing over the range, but it is using the current number in the range as both arguments.

For example, compare these two programs:

!!/run 3ɾ v↔

@AaronMiller ⟨⟨⟨1⟩⟩|⟨⟨2|2⟩⟩|⟨⟨3|3|3⟩⟩⟩

!!/run 1 1↔ 2 2↔ 3 3↔ W

@AaronMiller ⟨⟨⟨1⟩⟩|⟨⟨2|2⟩⟩|⟨⟨3|3|3⟩⟩⟩

oh

thats kinda weird ngl

is that really helpful anywhere?

Vectorization is most useful with monads, since with dyads both arguments will be the same. Basically, if you have a map lambda with only one command in it, you can just replace it with vectorization.

I feel like there's a command that does what you're looking for, but I can't quite remember, so give me a minute to check.

ok

Hmm, I'm not seeing anything to map over multiple arguments. However, looking back at what you were saying, is this what you're going for?

!!/run 9ɾ ƛ ka13ȯ ↔;

[@AaronMiller: 58681987]
⟨⟨⟨`n`⟩|⟨`o`⟩|⟨`p`⟩|⟨`q`⟩|⟨`r`⟩|⟨`s`⟩|⟨`t`⟩|⟨`u`⟩|⟨`v`⟩|⟨`w`⟩|⟨`x`⟩|⟨`y`⟩|⟨`z`⟩⟩|⟨⟨`n`|`n`⟩|⟨`n`|`o`⟩|⟨`n`|`p`⟩|⟨`n`|`q`⟩|⟨`n`|`r`⟩|⟨`n`|`s`⟩|⟨`n`|`t`⟩|⟨`n`|`u`⟩|⟨`n`|`v`⟩|⟨`n`|`w`⟩|⟨`n`|`x`⟩|⟨`n`|`y`⟩|⟨`n`|`z`⟩|⟨`o`|`n`⟩|⟨`o`|`o`⟩|⟨`o`|`p`⟩|⟨`o`|`q`⟩|⟨`o`|`r`⟩|⟨`o`|`s`⟩|⟨`o`|`t`⟩|⟨`o`|`u`⟩|⟨`o`|`v`⟩|⟨`o`|`w`⟩|⟨`o`|`x`⟩|⟨`o`|`y`⟩|⟨`o`|`z`⟩|⟨`p`|`n`⟩|⟨`p`|`o`⟩|⟨`p`|`p`⟩|⟨`p`|`q`⟩|⟨`p`|`r`⟩|⟨`p`|`s`⟩|⟨`p`|`t`⟩|⟨`p`|`u`⟩|⟨`p`|`v`⟩|⟨`p`|`w`⟩|⟨`p`|`x`⟩|⟨`p`|`y`⟩|⟨`p`|`z`⟩|⟨`q`|`n`⟩|⟨`q`|`o`⟩|⟨`q`|`p`⟩|⟨`q`|`q`⟩|⟨`q`|`r`⟩|⟨`q`|`s`⟩|⟨`q`|`t`⟩|⟨`q`|`u`⟩|⟨`q`|`v`⟩|⟨`q`|`w`⟩|…

yeah, and ik I can do it that way

i just figured vectorize would be different

thanks for looking tho

np

Some commands do kind of work that way, though. For example, +, when given two lists a and b, does a[0] + b[0], a[1] + b[1], etc.

!!/run ⟨1|2|3|4⟩ ⟨5|6|7|8⟩ +

@AaronMiller ⟨6|8|10|12⟩

well, I wish there was a "vectorize of sorts" that basically would try to vectorize the first list it encountered in the input but still keep the order

ex: with list a and number b, "a b v+" would vectorize over a, and do a[0] + b, a[1] + b etc

i think that's covered by transformers which i guess should probably be discussed before the rewrite

@Underslash And again, some commands do that

!!/run ⟨1|2|3|4|5|6|7|8|9⟩ 2 +

@AaronMiller ⟨3|4|5|6|7|8|9|10|11⟩

yeah, but when commands dont it becomes a real hassle

and sometimes they cant because of overloading

@Underslash Wait, v+ doesn't do that already?

I feel like it should

well + already works like that right, so wouldn't the vectorize not really do something

for transformers it would make sense to have a vectorize both sides, foreach left, and foreach right

those are " € Ɱ in jelly respectively

@Underslash In this case, vectorizing + over a list will just double each thing in the list, since it is getting added to itself.

!!/run ⟨1|2|3|4|5|6|7|8|9⟩ v+

@AaronMiller ⟨2|4|6|8|10|12|14|16|18⟩

@hyper-neutrino +1

@AaronMiller remember, the bot is running an older version of the parser

If you were testing it out using the one currently on main, you'd see less issues

The two string bugs are fixed there

Issue #195 (Vyxal/Vyxal) was closed by Lyxal