Inspired by shaped arrays library in Factor (which is apparently only half-working), I'm thinking of implementing a more APL-like array (and APL primitives on them).
Hopefully I can also make some kind of APL DSL on top of it.
@ngn Something I'd like to explore, is an APL-like language where primitive functions default to applying on minimal rank arguments, but you have (magic?) operators that can force them to work on higher ranks. I'm sure if it is even possible, but I'd love to find out.
I have a feeling that it can be done using something like J's model where scalar functions cannot penetrate boxes, and then do something like ⍢(⊂⍤k)
Then 1 2 3 × 4 5 6 would be normal multiplication, and 1 2 3(×⍤1)4 5 6 would be like current +.×.
Similarly 1 2 3 = 1 2 4 would give 1 1 0 but =⍤1 would be like ≡
The idea stems from the observation that there's more power in primitives that operator on "larger" arguments, and you can define others in terms of those, like = being ≡⍤0, however, it is also the "lesser" primitives that are used the most.
So instead of including the larger primitives and having to use ⍤ all over the place, one could include the lesser ones and use ⍤ when a larger "grasp" is needed.
That'd allow you to use haystack(⍳⍤1 1)needles for PDI (the default rank being 1 0).
@Marshall +/÷≢ would simply be row-averages, equivalent to the current +⌿⍤1÷≢⍤1. I've not thought much about user-defined functions, but I'd think the outer ⍤2 would force the function to see a matrix argument, and then ⌽⍵ would flip the last axis, i.e. the function would be equivalent to ⌽. Possibly user functions could have a header specifying their default rank.
Again, I'm not sure if this is at all viable, but if it is, then I have a feeling it'd make for a more natural way to express things.
@MortenKromberg I'm implementing it in Kap now (specifically needed in the context of SQL support). What syntax has been discussed for Dyalog? If possible, I'd like to use the same.
We're trying to make plans to take action on the "Linux SuperKey" issue that Dyalog APL has under Linux. One problem that has come up in discussions is that it appears that WayLand still has no equivalent for setxkbmap. So I have a couple of questions for the Linux hacks out there...
1) Is this something that WayLand is likely to add (I read some comments to the effect that this was due to the "immaturity" of WayLand. 2) How quickly do you expect WayLand to become widely used, so that this becomes a serious issue? 3) Is it important to have a dynamic way to change the keyboard (I think yes)?
<moon-child> I think that, in the long term, wayland is likely to support it. In the short-med term, wayland's lack of support is an acceptable reason not to support wayland, esp. since RIDE also lets you type apl glyphs with a backtick prefix instead
Thanks. As I understand it, you can set Wayland keyboards up to support APL, you just have to do it in configuration at startup, and cannot change it dynamically.
@MortenKromberg Interesting. I was thinking of having an operator: {finally}OP{somecode}. I could then use Kap's custom syntax feature to build on that to create essentially Java's syntax.
@EliasMårtenson That might work, but would be less attractive for "industrial" systems where you would like to see the :Finally actions in the body of the same function that is doing the work.
A lot of the code that really needs "finally" is ugly procedural stuff
I don't remember who asked but yes I am interested in APL. Thanks for asking, I'm interested in the brevity because I at the moment cannot use the keyboard very much. But I do have to admit that it is fun to learn apart from that aspect.
For now I've only spent approximately one hour just learning the basics from the APL wiki. I intend to solve the advent of code next and to learn the necessary material along the way.
@MortenKromberg True, but I don't expct a program to actually directly use the operator. Instead, they'd use the imperative syntax, something like try (..) finally {...}
@EliasMårtenson OK, we are not able to play that sort of game in Dyalog APL. I would also worry about the error reporting / debugging experience using "tricks" like that.
@EliasMårtenson Ain't gonna happen. It isn't a notation any more if it becomes too fluid. This is one of the hard dilemmas in APL language design: Are we trying to create a notation or a quote programming language unquote. Many of the things that computer scientists see as weaknesses in APL that we should "fix to make it better" would threaten the value of APL as a notation and tool of thought. IMHO, of course.
I obviously disagree, and which is partly why I decided to make my own implementation so that I can experiment with this. So far, not all of my experiments have been successful to say the least :-)
My own opinions on this aren't fixed of course, and they have changed significantly since I started reading a lot of what people on this channel have been saying.
@rak1507 I think the control structure notation in Dyalog is intentionally ugly. It looks to me as though it's done in that way so as to make a very clear separation between "APL" and "imperative"
I agree, my point was that they've already added several changes to make APL more of a 'programming language', so they probably could add more if they saw it to be useful enough
Which is very different from Kap where you can do stuff like: foo ⍉ if(x) {2 3} else {2 3 4} ⍴ ⍳100
@rak1507 I agree. They clearly have different priorities. I think their implementation of various features are very much driven by customers. Dyalog themselves might not want the object orientation for example, but customers demand it so they do it.
@EliasMårtenson fwiw personally I like a separation between data manipulation and control flow manipulation. But either way, allowing that makes sense, it's a question of if it's useful and how hard is it to squeeze into the syntax
as this would allow you to control the point where the final code is run.
@Dincio Heh, I used to use APL while standing in packed transit trains. I was able to balance my laptop on one hand, typing one glyph at a time with the other. So yes, that works.
@EliasMårtenson What Dyalog would look like if they didn't have to worry about customers? Easy: It wouldn't exist at all.
@EliasMårtenson Dyalog APL was created by a group of consultants who were worried that mainframe APL was going to die, and the business would disappear.
@EliasMårtenson My personal experience is that things that are not designed with a customer/user focus, tend to lose their way very quickly. This is the foundation of agile programming, as I understand it.
@EliasMårtenson I believe the control structure design was more or less adopted into Dyalog APL and APLX from APL*PLUS back in the day where they were the commercial juggernaut and we were the new kid on the block.
@MortenKromberg I see. I thought it was a Dyalog invention :-)
Speaking of mainframe APL. I wonder if it's possible to get hold of a copy of APL for MVS. I have an MVS 3.8j running in an emulator here, and getting APL on it would be cool (but probably very impossible)
Personally, I am very happy that the structured programming keywords and the OO keywords look completely different from regular APL. I think of them as the arrows in my control flow diagram, with the "notation blocks" in the rectangles. I think this is a very healthy situation.
When control structures were invented, there were fierce battles between the people who agree with that view, vs. the people who thought we should come up with squiggles to do control flow. I am SO happy that control flow is very, very obviously visually distinct from the "straight through" flowing notational blocks.
@EliasMårtenson One problem I do have with that it that it seems to me that it has "irregular" syntax compared to the rest of the language, with rules that I have to memorise. Is that correct? [next meeting in 3 mins...]
Unfortunately I do not have time to properly grok all the cool languages that y'all are working on.
Let's say I have the following (2D) matrix:
[[1, 2, 3, 4 ],
[5, 6, 7, 8 ],
[9, 10, 11, 12],
[13, 14, 15, 16]]
Rotate the matrix counterclockwise R times (not in 90 degree increments, just by 1 number each time),
1 2 3 4 2 3 4 8 3 4 8 12
5 6 7 8 -->...
@MortenKromberg That's the foundation of XP. Agile was (IMO) more about applying continuous improvement to the software development process, and an awareness that 'good practice' always depends on the people and the context. But the term has been hijacked by people who make more money if they pretend there's a static process.
@MortenKromberg It is irregular, in a way. The if/else structure is defined using the defsyntax form which does directly affect how the parser processes code.
But, with custom syntax, the initial symbol always defines how the parsing is to be done, and it's defined in a kind of limited BNF notation.
@EliasMårtenson Our control structures are of course also irregular, which is why I like the :keyword syntax which tells me clearly exactly where I am looking at normal APL notation, and where I am not. This is similar to the (wonderful) separation APL gives you between user-defined names and squiggles, making it totally clear what is part of the platform, and what is "my stuff".
@MartinJaniczek I see - the beginning is currently the best of it so far, and it's still under development, so I'd appreciate any feedback you have (can do it here or via github issues or whatever) if you do decide to look at the rest of it. I suspect most independent learners would get far enough that they feel alright with the basics and then would go off and figure out their own stuff, but it is also gonna be a complete course so it should feel complete by itself
@Adám I don't think they are reserved in general, only as extensions of :Access, right? I agree it might have been better to add a colon, but given the restricted use case it feels unnecessary.
@xpqz I've thought about bringing it to the level of Common Lisp macros (i.e. making the Kap runtime available during parsing). As I am adding more and more esoteric features to the defsyntax handler, I'm thinking that perhaps a fully-fledged macro-system would be better.
@EliasMårtenson No, but then axis is something the current thought police think should be deprecated. Also, the variant operator is not defined on user-defined functions.
@Adám There are no squiggles that make use of variant, but I do not believe there is anything preventing APL implementers in the Dyalog team from using it. APL users, on the other hand, have no way to make use of variant.
@xpqz Not at all. I don't believe in dictating thought. Notice how I defend use of tradfns etc. There are also cases where the ⍤ and ⍉ alternative to axis is too awkward compared to the simplicity of the operation, e.g. ,[⍳2]
@Adám Oh, I see. Wouldn't it be easy to supply this to user-defined functions as well. In a wasy similar to how GNU APL allows you to access the axis value through χ?
@rak1507 All the set operations could just have ben included as multi-set operations, as it is very simple to define the non-multi ones in terms of the multi-ones, using ⍤
Is there some "prior art" in APL (eg. in dfns -- which I looked at but didn't find it there) of parsing an expression string into a RPN notation and then evaluating it? Or some equivalent more-suited-to-APL approach?
@EliasMårtenson ISO has only scalar extension; Dyalog modifies it by changing scalar to singleton extension pretty much everywhere it appears. Maybe you could argue that this is a conforming extension to the spec, but really it was just needed for compatibility with other APLs (I don't know which).
I cannot find trains like that beautiful, I apologise. There is something about trains that grates so badly with decades of reading APL. I may get there eventually but my brain suffers a pipeline stall every time.
Single-element vector extension was kind of excusable when we only had ⍴. But multi-dimensional singleton extension as we have in Dyalog APL is insanity.
I recently got myself an Apple Pencil for my iPad. They offer free laser engraving, and I tried getting ⎕IO←0. But unfortunately they were seen as "illegal characters".
@RikedyP I totally missed your message. Yes that is how I worked with it. My "learning APL from zero" was that I learned the basics through it, then kinda started checking out various other operators/fns more and more as I got more confident with the language. Picking a real problem to work on helped guide my learning too. The workshop, at least the parts I got through, in combination with this channel, "bootstrapped" me enough to be self-sufficient.
FWIW I missed/ignored the videos. Some pages were a bit more rough (depended on the video more than others), but it was doable :) I enjoyed the "little bit of description then a lot of small problems to work through" approach.
Let's say I have the following (2D) matrix:
[[1, 2, 3, 4 ],
[5, 6, 7, 8 ],
[9, 10, 11, 12],
[13, 14, 15, 16]]
Rotate the matrix counterclockwise R times (not in 90 degree increments, just by 1 number each time),
1 2 3 4 2 3 4 8 3 4 8 12
5 6 7 8 -->...
