Using challenges to learn, for elimnation sort I have (⊢(/⍨)⊢=⌈\) or dfn {⍵/⍨⍵=⌈\⍵}. How to improve?

@Jonah That's as good as it gets while staying reasonable.

@Jonah oh, I'm dumb, I had ⊢(⌿⍨)⊢≥⌈⍀, that ≥ has no reason to be there

Would removing stranding be too radical a choice for TinyAPL?

@RubenVerg Depends on how far you take it? It comes down to how you define your precedence table for token justaposition. BQN just disallows it altogether while J is kind of in the middle with stranding only working for number literals.

aplwiki.com/wiki/Strand_notation

I feel like removing stranding might make parsing way easier

I'm not a Parsec master :)

@RubenVerg No. Source:

> Strands delenda est!

— Roger Hui.

@B.Wilson BQN just makes it explicit, to which Roger said:

> I mean: if you are going to kill strands kill them stone cold dead. Don't give them a lingering death.

@RubenVerg AFAIU, that's kind of the whole reason BQN removes stranding. Michael wants a phrase to be locally parseable. Without context, you can't parse a b c in APL. Is it monadic function application (fun fun arr), dyadic application (arr fun arr), stranding (arr arr arr), or a fork (fun fun fun)?

@B.Wilson (Again, BQN doesn't remove stranding, but whatever…) BQN still wouldn't be parseable without the strict. naming convention.

right, abut the naming convention I'm quite sure I'll do that, in my small tests it seems to make parsing way less compilcated

@Adám I know you're referring to ‿, but in terms of parsing complications the salient part of strand notation is that just uses juxtaposition.

You're right, of course, that adding ‿ doesn't magically fix the ambiguities, but it's one of the necessary changes to achieve that goal.

@Adám What if we decide to be unreasonable? :) Also, do the judges tend to prefer tacit or dfn or it depends?

@Adám suggestions for caesar salad (a⌷⍤0 1⍨27|⊣+⊢⍳⍨a←' ',⎕A⍨)? I'm not loving my manual specification of 0 1 rank on index there....

⊃0~⍨×⍤- looks ok for "4. Like A Version"?

@Adám why did roger hate strands?

@Jonah ∊⊢⊆⍨⊢≥⌈⍀ Otherwise equivalent tacit and dfns are considered equivalent, possibly unless one type is much neater. E.g. ⌽⍷⍥⌽ is definitely neater than {⌽(⌽⍺)⍷(⌽⍵)} and so too there are dfns that are much neater than any tacit alternative.

@Jonah Right, the plan is to add ⊇ which would be that (and more). Do you not agree that {a[27|⍺+⍵⍳⍨a←' ',⎕A]} is better?

@Jonah Yes, that's excellent.

@Adám I do agree! Didn't realize I could do that. Remember J only has { and no [...], and I'm doing a lot of analogizing with that, while learning the differences, which are interesting.

Btw some interesting thoughts on this in the section "A Selected History" in this post by Dan Bron: stackoverflow.com/a/36186974/438615

@Jonah Right, and in 20.0, we should be able to write {a⊇⍨27|⍺+⍵⍳⍨a←' ',⎕A} which is still better than the tacit version, imo.

@Jonah That's a smart use of the ~0 operator. I had used replicate / to manually do that for the problem.

@Jonah Hugely complicates the language, plus requires separation between operands and arguments.

@Adám Right.

@mitchelljohnstone Thanks

It seems that in APL "rearrange axes" is part of mix, via the index operator (eg, ↑[0.5]), whereas in J it's viewed as an extension of transpose. Is it fair to say that this too represents a new insight analogous to the one mentioned by Dan Bron re: indexing -- in this case that transpose is just a specific case of axes rearrangement?

@Jonah APL has (always had) dyadic transpose for rearranging axes. I never use that mixing abomination.

Ah, so is it just a piece of historical cruft, or is there a good reason it exists?

@Adám isn't that just find under reverse?

Yes, under still a model, but pattern spotting again

@Jonah I actually don't know. Dyadic transpose preceeds mix with axes by decades. Maybe it is more efficient to directly construct the result array rather than transposing after the mix. Maybe it was just seen as a necessary thing to be able to tell mix where the new axes should go. Note that the original NARS spec that introduced nested arrays, didn't include mix at all.

@Silas Yes, it is, but this was for problems.tryapl.org which checks solutions and doesn't have under.

Ah, hadn't realised quest problem

Right. @Jonah When you want feedback on a problem, it'd be really nice if you could link to it, as I have a hard time remembering which of the 100 problems was in which of the 10 years.

@Adám Np. But I am looking at the downloaded pdf... can you show me where I find the URL versions, then I'll start linking to them.

problems.tryapl.org

Oh, wait, you're doing this year's problems. They'll be added to the site shortly.

Ok until then I can add a quick recap

Well, technically speaking, you can link, like Caesar Salad, but even just including "2023-3" would be enough.

@Adám One more for now.... this feels labored... ((+/,+/⍤~)(≤⌿⍤↑ ⌊⍥≢ ↑¨ ,⍥⊂)) for Risky Business

In particular, it seems there should be some way to tacitly mix a left and right arg without enclosing them first.

@Jonah Why mix them at all?