Just a thought, it would be really cool if you could put lambdas in lambdas. For instance, in the challenge @Razetime linked earlier, it would be useful if you could do something like bƛÞTṘƛ⌊¬ to reverse and negate the characters. Not sure how difficult that would be to implement, though.

@AaronMiller you can

lambda's should already be nestable

Hmm... I can't seem to get it to work. Am I doing something wrong?

okay so the issue was that the function that was generating lambda signatures was using time.time()

the problem with that is that it was calling it too often

as in, it would compile so quick that int(time.time()) always returned the same at runtime

but now it uses a different system

@AaronMiller

Cool, we can use nested lambdas to shorten that reverse and invert answer by 1 byte!

You might have noticed a new button on the site

that's to clear all the fields

also, the executing animation is different too

The clear button doesn't clear flags or the keyboard search

I'll have to change that

Here's a template for the most recent challenge about applying a function at indicies

@AaronMiller ah. translate. nice idea, but I was thinking of vectorizing with not.sad that it doesn't work.

† is vectorising not over a list

f flattens into a list of characters

@Lyxal vectorize on individual cells?

yep

it's the same as v¬

@Razetime does bR⌊ƛf†BC work?

@Lyxal that didn;t work last i checked

@Lyxal lol no

@Razetime Try it Online!

@Lyxal i need a deep vectorize

[[[[[0]]]]] -> [[[[[1]]]]]

like double vectorise?

like this

@Razetime like this?

;)

yep like that

@Razetime like this?

...

Fun fact: when neither argument is a function, R does vectorised reverse

neat

now

we need to beat 6 bytes

Which is more helpful: integer to binary gives a string or integer to binary gives a list of bits?

very hard to figure out really

List of bits it is

Just 4 github stars until vyxal passes stax on github

Okay so here's a little something I think might be interesting to know (just in case it isn't clear)

When you call a function or lambda, it gets its arguments from popping from the main stack, placing them into a separate stack

In other words, except for getting the initial arguments, functions/lambdas have no interaction with the main stack

The main stack here is the stack used at the most outer layer of program (outside of all functions)

Functions/lambdas start with their arguments already on their stack

And if implicit input is needed, the original argument passed is used. STDIN is not used for implicit input (it can however still be accessed using ?)

To explicitly push the argument(s) passed to the function, you can use n

@Lyxal beat osabie, stax has like one active golfer