@Adám thanks, that's a good alternative and does essentially achieve what I was after

@TomCockram What are you replying to? (You can hover over a message and then click the revealed ↳ on the right to insert a special tag that not only pings the message author, but also indicates which message you're replying to.)

@Adám I appear to have lost the ability to edit messages

@TomCockram You can only edit them for a few minutes.

@Adám Ah, that's annoying. But I was replying to your message about searching for TODO comments

OK, cool. One benefit of this approach is that you can have multiple "series".

What do you mean by "series"?

You could have ⍝//TODO and ⍝//NEXT and ⍝//FIXME and ⍝//SLOW. Each one would be found separately.

Oh I see, yes that would be useful if you set the different ones you're going to use from the start. Otherwise you might end up with so many different ones that you're not sure what to search!

@TomCockram Then search for "⍝//" or use a regular expression to handle multiple variations.

@Adám - I noticed the feed from the wiki; is the fact that all the "articles" are being reported with dates of 01 Jan 0001 a bug?

@JeffZeitlin Well, it is certainly wrong, but that was a spurious initial slew of old articles when I enabled the feed. Let's see what happens when it detects actual new articles. Should be coming shortly…

Is there a built-in that takes two arguments (representing real and imaginary) and generates a complex from them? You can't do that using "straight up" J-notation unless the two numbers are constants.

@JeffZeitlin Did you try APLcart?

/me chuckles. I need to get into the habit of remembering to ask there...

@JeffZeitlin Which IDE do you use?

For APL? I just use the default UI for Dyalog on whichever OS I'm on - I have both Windows and Linux Mint (uses the Dyalog-for-Ubuntu).

@JeffZeitlin Windows IDE: Options>Configure>Help/DMX>Use online help for non-Dyalog topics>URL:"https://aplcart.info?q=%s". RIDE: Edit>Preferences>Menu>after the &Help line, insert &APLcart =https://aplcart.info lines up with the other entries.

Hmmm... It would appear to be inadvisable to create a function J←(⊣ׯ12○⊢)

@JeffZeitlin Why?

OK, now it's not inadvisable. When it was inadvisable, (1+2) J (3+4) went into an infinite loop. After shutting down the terp and restarting it, it doesn't go into an infinite loop, but instead does what I wanted it to. Of course, I wanted it to do the wrong thing; I really want J←(⊣+¯11○⊢)

@JeffZeitlin A better name for ⊣ׯ12○⊢ might be A (for angle) or something.

Actually, that one should be CIS :) As in r CIS θ

Ideally, I'd want ⌾ and ∠ as primitives.

And if you pass J as defined two equal-length vectors, it does the right thing.

⌾ and ∠ doing what, respectively?

⌾←⊣+¯11○⊢ ⋄ ∠←⊣ׯ12○⊢

(that was something I always wished I could do in APL - find a symbol that wasn't already used, and define a function with that symbol as name)

@JeffZeitlin And what would happen if a newer release of that APL added that symbol as a primitive?

@Adám - That was one of the concerns, yes. Although at the time I originally thought of it, it didn't seem likely that it would actually happen.

@JeffZeitlin Why not. I'd e.g. add ⍥, but now Dyalog is adding that. In fact, the best candidates for addition to the core language are probably those that would be most popular to add.

@JeffZeitlin ngn/apl lets you do that: Try it online!

You can do it to a good extent in both ngn/apl and Adám's Extended Dyalog

(I really need to get and install the Extended Dyalog...)

There's obvious danger for production code, but Dyalog already has ⎕ML they're trying to be rid of

I think APL would benefit from users being allowed to extend the core language in a more natural way, the convention could be that any symbolically defined functions should go at the very start of your whole app and you're a fool otherwise

It would also allow people to experiment with proposed language features in the way they would actually be used - including the aesthetic aspect

I actually like the idea of having ⎕ML - but if I evaluate it honestly, it's really the user's responsibility to "correct" code to match a newer 'terp.

For example, now that I've finally found myself wanting ⍤ (atop) here and there, I actually thing ⍤ is an ugly symbol for it

@RichardPark If they could extend it, they should be able to redefine it too, no?

yes

but it's so obvious how risky that is

The problem with redefining is how to access the original definition.

if I can write a program - I can write a program to delete all files on the filesystem, why wouldn't I just write that every time I need to make an application?

@RichardPark Yeah. This is already an issue for programming languages with reserved words. It is hard to add words later if you don't allow overshadowing keywords. So some language pre-reserve words for the future. Thank goodness for APL's reserved ⎕ and : prefix characters for built-in things.

The advantage to redefining is that one can extend functionality in (putatively) logical ways.

@JeffZeitlin Extended uses backtick ` to access the original meaning.

Given the nature of APL and its similarities to natural language, the ability to redefine and extend symbols would be good and probably outweigh the risks

Once again, a crazy fool would go around redefining built-ins for their production app

but I'm here in 17.1 making _O_←{(⍵⍵ ⍺)⍺⍺ ⍵⍵ ⍵} and I←⌷⍤0 99

@JeffZeitlin Sure, but case-in-point on the dangers. In Extended, I extended the ≠ with an (I think) very logical monadic form, but now in 18.0 Dyalog is making monadic ≠ be something entirely unrelated to dyadic ≠. Now what do I do with Extended once 18.0 comes out?

If more people played with the language like you do, there would have been a lobby to have monadic ≠ work as you had done it

But they don't, so a different decision was made for a different reason

So now you get unique mask in 18.0, and have to either choose another symbol for your extended, or forego that functionality having a primitive

It's not that bad

@RichardPark Those are both so obviously fundamental that they should have been added to the language decades ago… Oh.

Well yeah except we need to make our own new APL with the best logic of J, fewer anomolies, but keeping symbols (because unicode)

if people want restricted high performance ascii line noise they can use k

@RichardPark That's not what I meant. What happens to existing Extended code that uses monadic ≠. If I don't change ≠ according to Dyalog 18.0, it won't be Extended Dyalog anymore, it'll be a side branch with incompatibility.

Yep

this is why you have versioning

what do I do with my k3 code now that k7 is out? boo hoo

@RichardPark Incompatible parallel versions of a single language is bad. See Python.

python is large so they have to do phasing

@RichardPark Those don't claim to be the same language.

APL would be the same if we had the user base

oh right

languages change over time

@RichardPark APL prouds itself of half a century's backwards compatibility. Look, Dyalog didn't even dare making a braking change to 3 1 4[2] like IBM did.

once the changes are difficult to make cross-compatible, we rename or sub-divide e.g. Middle English, Modern English

APL can pride itself on having the same user base for 50 years, but no additional users

Odd: In APL2, 'a' 'b' 'c' isn't exactly the same as 'abc' ⍨

that is weird

is this related to the collapsing towers thing I've heard about?

@RichardPark I don't know what that is, but here is my APL2 session transcript:

      'abc'[2]
b
      'a' 'b' 'c'≡'abc'
1
      'a' 'b' 'c'[2]
RANK ERROR
      'a' 'b' 'c'[2]
              ^

/me spocks.; What was IBM's breaking change?

@JeffZeitlin 3 1 4[2] used to give 1 (and still does in Dyalog APL), but IBM broke that.

ah right, their binding strengths differ depending on whether you're indexing or applying a function?

@Adám - Let me guess: Same issue as you just illustrated with 'a' 'b' 'c' vs 'abc' - IBM now gives a RANK ERROR

@JeffZeitlin Yes.

@RichardPark The binding strengths were changed. Stranding used to be stronger than indexing.

If I were using the (admittedly simplistic, but oft-claimed) assumption that APL is evaluated strictly right-to-left, I'd expect IBM's behavior. But there are sufficient counterexamples to that simplistic assumption that it shouldn't be assumed.

@JeffZeitlin Would you then expect 1 2+3 to give 1 5?

@Adám Actually yes, common beginner's mistake because they are told APL is right-to-left and then stranding pops up like woah - also problematic because there's no stranding primitive for some convenient (f¦g) trains

That's one of the counterexamples. It's not strictly rtl; there is binding strength to account for. It's just complicated to articulate that to a beginner.

which is why I prefer to use it without even questioning it from the beginning like going 1 2 3 + 4 5 6 which has 2 reasonable results intuitively

It ends up being something that you learn through experience, rather than someone telling you "stranding in vectors binds tighter than indexing"

yeah exactly

lots of language learning is like that

in Japanese they have a phrase narau yori nareru which is often translated to "practice makes perfect" but literally means "rather than learn/be taught, get used to"

And the literal translation is quite accurate when it comes to a lot of language learning - both natural and programming.

I think was also one of the key points from the Liceo Scientifico talk from Dyalog '19 (youtube.com/watch?v=vvKdflXGT1o) - summed up in the phrase "teach without teaching" from the Japanese puzzle guy

This wouldn't have been an issue if we didn't have stranding. Iverson was actually against the introduction of stranding. His original notation didn't have it. Used proper array notation instead.

And a common phrase around here is "I know what the docs say. Deal with it."

What did he consider "proper array notation"?

Ah good point regarding custom symbol assignments - can I reassign " "

←1,2,3,4

Oh, ICK!

,←1 2 3 4

@JeffZeitlin I disagree. APLers are much more likely to criticise minute language warts than other programmers dealing with all sorts of wats and WTFs in their languages.

@RichardPark Can I reassign ←? ←←-∘1

@Adám - Oh, no - I meant "here" in my office in NYC, not "here" in the APL Orchard.

@JeffZeitlin Oh, gotya.

oops didn't mean to delete - @Adám the dream is dying before my very eyes

Hmmm. Assignment binds more tightly than ⌷-indexing.

And you can't commute assignment.

@JeffZeitlin ⌷? What do you mean?

Z←⍳3⋄2⌷Z←5 doesn't do the same thing as Z←⍳3⋄Z[2]←5

(Yes, that's a squad, not a quad.)

And I couldn't "cheat" with 5←⍨2⌷Z

Although (2⌷Z)←5 does work.

@JeffZeitlin Right, because in this case, ← acts more like a monadic operator, and you can't use ⍨ on that. Compare to x∘,¨y where you can't write y¨⍨x∘,

(2⌷Z)←5 is essentially Z(2∘⌷)←5

Meaning the ← takes a selection function as operand.

Anyhow, the right way to view ← in current APL is as its own syntax. Not a function or operator.

Oh, I didn't actually expect commuting the assignment to work; I was just making sure I tried everything. Parenthesizing the 2⌷Z seemed to be a waste as compared to Z[2].

@JeffZeitlin Sure, for that particular operation, but how about changing the second to last element?

⋄ Z←⍳7 ⋄ (2⌷⌽Z)←'x' ⋄ Z

@Adám
1 2 3 4 5 x 7

Good point. Not every language allows negative indexing like PowerShell does.

@JeffZeitlin OK, the diagonal then:

⋄ Z←3 4⍴⍳12 ⋄ (1 1⍉Z)←'x' ⋄ Z

@Adám
x  2 3  4
5  x 7  8
9 10 x 12

I could probably do the vector case with a computation involving ⍴Z, but it would be more complicated, and let's not even think about what I'd have to do to select one or more ... yeah, that.

The first 7 in ravel order, except for the first three:

"...select one or more elements of a rank > 1 array where the selection is non-contiguous and/or not parallel to one of the axes.

⋄ Z←3 4⍴⍳12 ⋄ (3↓7⍴Z)←'x' ⋄ Z

@Adám
1  2  3  x
x  x  x  8
9 10 11 12

What's the link to your Extended APL stuff, again - I need to grab it and play with it at home.

Never mind; found it by clicking on it at TIO. github.com/abrudz/dyalog-apl-extended