@rak1507 don't think so lol

aw

Ɲ is basically `2\` except it also accepts monads

Welcome, @user! If you requested access a long time ago, sorry for the delay, I didn't check the requests in a while.

@Mr.Xcoder Hello! No, I just requested access yesterday.

Oh 😅, great then, turns out I was inspired to check today

So I was trying to find the nth root. What I came up with was *ð1÷, but not only is it longer than the 3 bytes it's supposed to be, it doesn't seem to be working. Is there a way to compose the right argument?

Actually, never mind, I was using the separator wrong. I tried again with a quick to make it 1÷\n*Ç, but that doesn't seem to work either.

@user Here's your answer

hmm that doesn't seem to be the exact solution though

@Razetime Well, at least now I know there's an atom for the inverse

yup lol

I'll add the reciprocal keyword

Thanks

Oh I just tried again, but with the arguments flipped, and got İ*@. The @ isn't very satisfying, though :(

you'll have to use that a bunch, sadly

it's like commute in apl

it's pretty much required due to the strict left to right associativity

You're almost there, though! Hint: Look for a quick that forces monads to behave in some way

Well, I got 4 bytes trying to translate ⊣*(÷⊢): ḷ*İ}. Is } the quick you were talking about. Or is it maybe {?

So apparently just **İ} works too. Guess I've still got a lot to learn about chaining rules

the little tables in the tutorial on the wiki are really helpful as a reference

@UnrelatedString I did look at those, but it was still confusing.

the key to understanding it is that it's just left to right chopping off patterns as it sees them

of course there's also the special rules about lccs and the triple dyad start, the latter being why ḷ*İ} works

So with *I}, does it take v to be the left argument first and then treat the rest as a monadic chain?

it treats the rest as a dyadic chain

Oh

so it matches *I} as dyad-dyad, and evaluates v * (λ İ} ρ)

Ah, it makes sense now

where λ İ} ρ comes out to ρ İ

and yeah the reason ḷ*İ} does the exact same thing is because the triple dyad rule initializes ν to λ ḷ ρ, but that's just λ

Ok, so the triple dyad makes it act like one of APL's fgh trains?

I guess so yeah

But only at the start of a chain

because in general two dyads in a dyadic chain are sort of... half of an APL fork

Half an APL fork?

or two thirds i guess

I'm kind of hung up on deciding which direction to talk about this in lmao

since APL is right to left and Jelly is left to right

but yeah conceptually three dyads at the start of a chain behave like a fork

So fg becomes ⍺ f (⍺ g ⍵) when f and g are dyadic?

yep

Alright, I think I'm starting to understand

Thanks so much!

yw

Wish there was an IDE that showed you how stuff was parsed, like regex101 does.

i think there is one called jelly balls or something

it's probably a bit out of date and i hear there's also some way it can completely freeze itself across refreshes but it should help visualize things

:56861985 Thanks, I'll check it out.