@CalebPaul Looks correct. (note that the arity of the first chain in the link is the same as that of the link itself)

What exactly does the G atom do? I don't really understand how it attempts to format z as a grid, and I don't know enough Python to read the contents of jelly.py

@BenRivers Perhaps an example will make it clearer. It basically joins each row with spaces, joins the resulting list of strings by newlines and then aligns (pads) shorter items in each row to the right.

Thanks! That sounds like a really useful feature!

@Dennis can this be considered a function so that the Y can be removed? it uses a command-line argument, which is allowed for a function, but it also uses the same argument as an implicit argument

@Mr.Xcoder @BenRivers it's only numbers which it aligns to the right

Yeah obviously...

@EriktheOutgolfer I don't think so. Using command-line arguments in a function submission is akin to require certain variables to be pre-defined, which isn't allowed.

huh, I thought there was a consensus which allows functions to use command-line arguments, but I don't think it was ever allowed to take the same argument in two different forms

I fail to see how that would be compatible with our consensus that functions must be reusable.

me too

hm, will comment that and tell him to thank you

I knew one could do something with dyadic links :P

@Dennis hmmm

yeah, looks like the first chain is still monadic and a leading ð is needed

looks like something you may want to fix

(leading µ doesn't change the arity at all, so why should it make it behave differently?)

@EriktheOutgolfer ø, µ, and ð determine the arity of the chain to their right, so this is entirely by design.

@Dennis sure

but the first chain isn't preceded by any of those

instead, the way the whole link is called determines its arity

and, when first called, the main (bottom) link doesn't even have such a way too, so the number of arguments determine its first chain's arity

The first chain doesn't specify an arity. It's popped by the Þ quick, which occurs in a dyadic chain (started by ð), so it assumed to be dyadic as well.

that feels wrong to me

and that's also not an explanation of what I've mentioned above

let's say we have chains (A)ð(B)

and then the link is called monadically

isn't chain (A) decided to be monadic too?

Yes.

But you don't have two chains; during parsing, Þ pops the first one and moves it into the second one. By the time the link is called, that has already happened, so it's way too late to affect its arity.

ah, so the popping behavior extends to that level

@Dennis ...which leads me to another thought; why does stuff like ×Þ error at all?

as a monadic chain, × is perfectly valid, so I'd like that behavior to also apply there

I don't understand.

When/how exactly does it error?

ah

hm, maybe I need to think of another example

when a quick expects a monadic link, giving it a dyadic link should act like ` is applied to it

that's really my suggestion

of course, for quicks like € where there is already a set behavior for dyadic links, it should keep that behavior

@Dennis for example, *} is an error, however it could be the function that returns its right argument raised to itself

currently, *`} does the job for 1 more byte

(I understand that this erroring may be something you regret about making Jelly, but now is something that would need a breaking change to accomplish)

The quicks are essentially a mess. There should be a function that takes an array of links, a quick, and returns a quicklink. Instead of this, each quick currently rolls its own, leading to inconsistencies like this one.

yeah, in the same sense, ` is a mistake too, as { could've been used

I think I had other plans for { and }, which is why they behave like this.

I think I meant 3+} to be equivalent to 3+$}, but never got to implement it.

don't worry about that, there's always time to implement it

and my suggestion is, as you like backwards-compatibility, and to keep your plans as-is, for { to do what I have suggested for } above (yes, the right argument for dyadic links)

I might get around implementing some of this