@KevinCruijssen Ah, yes, that is a good idea to include that in the docs as well

@Kaldo Hmm, I'll look into this

I'll research a little bit to add some more matrix manipulation commands

@Adnan Maybe a builtin for is_positive? 0› works as well of course, but not sure if it's used enough to justify a 1-byte builtin (if there are any left in v2).

@KevinCruijssen I currently have d which checks against the regex /^\d+$/, which sort of works as an is_positive function.

It just doesn't work for floats, is that okay?

@Adnan Thanks ! While we're on the subject of enhancements, do you think that a single-function filter command would make sense ?

like € for ε ?

@Kaldo That would make sense

I'll add it to the todo-list

Thanks : -)

And I think that Kevin is refering to the following challenge

no float values here so I think this would be ok

BTW, I saw that the rewrite was done in Elexir instead of python, any reason why ?

Well, I can adjust the d-command such that floats work as well

@Kaldo Mostly because of the streams that elixir uses

oh ok

It allows us to have and generate infinite lists

For example, ∞ will now push [1, 2, 3, ..., ∞]

I enjoyed looking at the 05AB1E source code to figure out how things worked, I guess you're forcing me to learn Elexir : D (and this is a very good thing btw : D)

hmm interesting

Yeah, I'm not sure if it is too readable, but here is where all of the functions are defined: github.com/Adriandmen/05AB1E/blob/rewrite/lib/interp/…

ty !

@Adnan Never used Elixer, but that source code looks surprisingly readable. :D

@KevinCruijssen Yeah, it is a lot better than the python source code hahaha

lol Kevin pronounces it as Elixer, Kaldo as Elexir but it's Elixir

hahahahahaha

Hehe ;)

I guess the name is just prone to Errors :P

Irrors you mean? ;p

Perhaps I actually meant Issues :P

I won't forget it anymore now. Two i's

@Adnan How many commands are still unimplemented out of curiosity?

it didn't bother me but I found it really amusing tbh

give or take*

you mean no-op 1-byters or the total number of commands that need to be implemented for the rewrite?

Second. Total commands that have yet to be implemented in Elixir

Everything that isn't ticked off here and here

Are there enough single bytes to cover all our suggestions?

Not sure yet

I think there may not be enough room for all of them. In that case, you/we're going to need to decide which are of more priority...

Oh, not too many left from the original commands. Just 10 from a quick count. Still a few new functions left, though.

The one-byters that are currently free are Γ, E, Ž, Ú, ñ, ó

And I'm pretty sure @Mr.Xcoder is right. We only had four left before you started the re-write

I have cleared up some commands that aren't used frequently

👍

Not sure if you want to keep the constants as they were before but IMO žv, žw and žx are not particularly useful

I might have missed some of the suggestions, but I think four single-byte suggestions were made thus far? ≥; ≤; filter-by similar to €; loop in [1,n] range.

I think there are also a few 1-byters that see very few uses and could be moved to 2-byters

Some other suggestions like replace / insert / matrix manipulation doesn't necessary have to be 1-byters probably.

like w for example

There are also new insert, every Nth element, etc.

@Mr.Xcoder That doesn't matter because we have more than enough space for new constants, so they won't be interfering with each other

@Kaldo yeah I agree, that is not used a lot

AH ok

@Kaldo Good point. You've all used 05AB1E more than me, but perhaps we should all name a few 1-byters we've barely used to see which could be moved to 2-byters if necessary?

That seems like a good idea to me

@Adnan Is it possible to make €'s behaviour more extensible to binary/ternary functions (at least binary, though)?

I'm not sure what you mean, could you give an example?

One second please

@Adnan Example: Make something like "//"s€ýÀ» work in place of ε"//"ý}À»

In this particular case it doesn't save bytes but I do see cases where it can

From a quick look at the current command list, @ and § look like good candidates for 2 byters

Looking at all commands I realize I haven't used a lot of them. XD More than 25 for sure..

As for ó (floored), doesn't ï (truncated) give the same result?

I found a better example: here (āεI¥ô}ʒË}нн) to ¥sā€ôʒË}нн

And that particular answer would also benefit from a one-byte filter

What's the use of Ƶ (Convert the next char from base 255 to base 10 and add 101) btw?

I think that's related to the dictionary / integer compression

Not sure though

@Mr.Xcoder That's going to be very difficult to implement, since € is not bound to the same stack

Also, I think δ should achieve the same thing (although that is broken in the current version of 05AB1E)

@Kaldo Good point, I'll make them 2-byters

That's why I asked if it is possible. I new it was going to be particularly hard. But in case you want and do manage to implement it, the same would also apply to the potential 1-byte filter

@KevinCruijssen Yeah, that is also why I removed ó. I'm not even sure why I added it in the first place

Does 05AB1E have a flatten by only one level command?

I don't think so

Should I add that as a 1-byte command?

Hmm, both 1 and 2 bytes would be fine for me

Is that like €`?

Ah yeah

then don't add it

I forgot about that trick

alright

The commands I think could be made 2 bytes: @™šª×Þ´

Actually × could be kept... I have never actually used it but it's ok

Þ has actually been changed to cycle

Are Y and V used often? I've seen X and U used a few times, and X and Y for their default values 1 and 2 respectively of course. I personally use © and ® more often than U and X tbh.

@KevinCruijssen I think those commands are pretty commonly used

I can try and scrape all the existing answers with the SE data explorer and check which one-byters are least used

Hmm, that would be interesting to see as well.

@KevinCruijssen I think those are used in the most complex answers

^

I'd like to see challenges which require more complex solutions in merely all languages, but I'd especially enjoy such answers in languages like 05AB1E

Maybe it's time to nominate 05AB1E for Language of the Month?

I think that it's difficult to design a challenge that requires a complex answser that is still doable with stack-based languages

I think any challenge can theoretically be solved in 05AB1E, since the global array can basically be used as an extensible stream of variables

Of course, any challenge that doesn't require low-level stuff or access to system properties / internet etc.

you're probably right

technically 05AB1E has access to the internet :D

good luck trying to parse the answer though

There are loads of commands I personally haven't used yet, but here are some I personally think could be 2-byters (take it with a grain of salt, though): wÞ@. And here some of which I'm unsure how they work: Ƶçü. And here one that can be removed entirely ó (dupe of ï).

@Mr.Xcoder You should try some of the unanswered challenges in 05AB1E. ;)

I don't think Þ is really usefull

ç returns the char for the decimal value a in the ASCII table

@Mr.Xcoder Hmm, perhaps, but isn't 05AB1E one of the most used languages on PPCG?

I actually think getting the digits of a string is more useful than the letters (á), but maybe I'm mistaken. I haven't used either yet.

@Kaldo which command are you referring to?

@Adnan Push stringified float(a)

yeah, that one does not exists anymore in the rewrite

@KevinCruijssen ü can be usefull

it applies the next command to pairs in the list a

@Kaldo Ah, so that's how it loops. Yes, that's indeed pretty useful. Thinking back, it might actually save bytes on an answer I posted last week.. ;)

the first example I can think of would be sort of a reverse pascal triangle

@Mr.Xcoder I've got three Revival badges thus far (all with Java of course.. these unanswered challenges are usually pretty complex). You could do some unanswered challenges in 05AB1E. I wish you good luck, though, you'll probably need it. ;)

Hmm, should we also look at 2-byters that should become 1-byters perhaps (if any)?

@KevinCruijssen I was going to say "prefixes/suffixes" but the 2-byter prefix is a duplicate of the 1-byter one

That might be a good idea

@Adnan LoTM will soon run out of nominations, and I don't think that a language which is a bit more active during LoTM would cause harm, as things need some spicing up

@KevinCruijssen I'm not sure I have the time and patience to try them now, but perhaps I will let you know if I think any of them looks tackle-able.

@Adnan another thing, do you think that it would be a good idea to switch the k command (index of b in a) from "first index" to "list of indexes" ?

I clearly remember a few challenges where I wanted to retrieve the positions of a given value in a list

you could still retrieve the first value with a two-byter: kн

I'd say we need two separate commands, and that k should be kept in place. We should strive to preserve at least a decent amount of backwards-compatibility IMO

@Mr.Xcoder "We should strive to preserve at least a decent amount of backwards-compatibility IMO" Is "decent amount of backward-compatibility" good enough ?

To me it's either fully backward-compatible

or it's not

and you have to review your existing algorithms to make them compatible with the rewrite

IDK, but either way kн would not behave just like the current k does.

that is correct

but have you really used this function before ?

For example would return [] instead

is the -1 return really that useful ?

@Kaldo I think so

considering that there isn't AFAIK a 1byter that checks if a value equals -1

Maybe you are right, I'm not sure though.

Let's just wait and see Adnan's opinion

this is of course a tiny argument in the grand scheme of things

but if we ran out of 1-byter

I'm especially interested in the SE data explorer scraping

I'm really curious about the usage statistics of each function

If I had more experience with the stackexchange API I would have tried it myself to get the load of @Adnan a bit. Unless he can make such an overview in a blink of an eye of course, then I'll leave it to him. ;)

In the meantime :P, CMC Retrieve all the indices of a value in a list

@KevinCruijssen Hmm, looks like you're indeed using the k function to its full extent. We would indeed need two different commands : -)

@Mr.Xcoder Can we choose between 0 and 1 indexed ?

Sure

4 bytes

For now I have 4 bytes too but I think less is possible

I unfortunately use 1-indexing, which is not native to 05ab1e

another 4 bytes

I have another 4 byter with 0-indexing now

Actually cross that out 3 bytes

nice

Although you cannot use it within a program

I'll let you think a bit more (and give @Kevin the chance to try too) before I'll reveal

@KevinCruijssen This is what my script and parser give: gist.github.com/Adriandmen/1202dfb0bd82c2ab7f3cdf65842645ac

@Adnan Thanks. And although it may not be 100% accurate, it's a nice overview to see which commands are used more often than others.

@Kaldo Perhaps as a different command

since k is used commonly in its current form

Yep looks like it

My 3-byte solution

nice

nice

I was looking at loops as well

couldn't figure out how to test equality and print if true

in 3 bytes

You can also move Q at the very beginning

@Adnan Left strip/Right strip aren't used much

maybe they could be more usefull as unary commands ?

because right now if a doesn't start/end with b the command does nothing

left-strip would take the first char and remove the head until it's no longer equal to char

@Adnan Another suggestion perhaps that I remember wanting to use a few times before. Let's say you have a list [1,2,3,4,5,6] and a list with truthy/falsey values [0,0,1,0,1,0], could we have a command to only keep the values of the first list, where they are truthy (1) in the second list? Can be a 2-byter, but it seems like a useful thing to have added.

@KevinCruijssen Ï

@Kaldo Woops.. >.> lol

This is awkward..

Thanks tho

@Kaldo well, if they aren't used that much right now, I don't think making them unary would make a big difference

I probably will make them 2-byte commands though

Makes sense

@Mr.Xcoder Nice 3-byter! I guess you'll probably need 4 bytes if you want those as a list to re-use I assume?

I think if you want them as a list you do need 4 bytes

@Kaldo What were your 4-byters?

@Mr.Xcoder first and second

Same ones as mine :)

: -)

if only the order the Ï arguments was reversed...

True...

However, we are lucky that ā doesn't pop

Also, I think 05AB1E lacks one major thing: Function / Block reusability. e.g. If it were possible to define blocks / functions in 05AB1E, this challenge could be solved way more easily.

Do you see any opportunity to include such a thing in the rewrite, @Adnan?

I'm not quite sure how that would work

since operands are interpreted one at a time

In that scenario blocks would need to be delimited by something