phantomics: I don't think there's any standard on number alignment when formatting. Even if ISO does specify, it doesn't have complex numbers, so it wouldn't be relevant here.
In Dyalog and J, complex numbers can only have floating point components, so the decimal points you're seeing wouldn't be a misrepresentation.
<phantomics> Got it, in April as in CL complexes can have either rational or float components
<phantomics> Then the other confusing thing in other APLs is how floats are rendered without decimal points when they're close to a rounded integer value, like 10.0
<phantomics> Also are all the floats in Dyalog double?
Yeah, Dyalog semantically only has IEEE doubles (well, and 128-bit decimal floats if you set ⎕FR).
So I guess the answer is that yes the extra decimals you showed are only there for alignment, but Dyalog's free to format numbers however it wants because it doesn't have to describe the type.
<moon-child> right; why align with zeroes instead of spaces?
<phantomics> It's standard in other APLs
<phantomics> Marshall: sounds good
<phantomics> I think aligning with zeroes is preferred because when there are spaces, there's a risk that the column could be read as multiple columns at a glance
<phantomics> Normative APLs don't put any spaces inside the representation of a number, that way you can always tell that a printed column is one column
<moon-child> don't you run the same risk by doing '3 J' instead of '3.0J'?
The spaces could also be frustrating since you can no longer copy-paste the number effectively. I'm inclined to say that's worse than bad alignment would be.
<phantomics> Thing is, if I print with decimals like this: 3.0J008 , then if you pasted that the reader would read the number as a complex float
<phantomics> In Dyalog and others that only have complex floats, it's not an issue, but in April you can have complex integers and ratios
<moon-child> I don't know how closely you're trying to keep april to cl semantics, but I think that the integer/float distinction should be transparent to the user
<phantomics> Marshall: exactly right, if you're coercing between types all the time there's a lot of potential for unpredictable strangeness
<phantomics> If programmers are going to get deep into math they need to have some appreciation for the difference between ints and floats and how they work
<moon-child> using floats in the first place has potential for unpredictable strangeness. (To whomever it was I was arguing with about floats in here a couple of months ago: I've changed my mind :)
<moon-child> @Marshall curious, what problems did that cause?
<phantomics> Yes, so it should be clear when you are and aren't using them, and the language shouldn't randomly cast you into float-world
<moon-child> It'll do that anyway with division, trig, pow/log, ...
<moon-child> bbiab
<phantomics> In CL/April division gives you rationals: ÷⍳5 => 1 1r2 1r3 1r4 1r5
<phantomics> You're right about ○, *, ⍟, etc. but those functions are clear gateways into float-world
moon-child: I can't actually figure out how it worked now (since integers pretty readily get turned into floats), but there have been a few forum posts where the issue was just that a value had a type the programmer didn't expect.
<phantomics> Yeah, when both args are whole you get an integer in CL/April
<phantomics> moon-child: the function inverter ⍣¯x is sort of a simple example of that, I've learned a bunch from building it
<phantomics> I'm curious as to how Dyalog's inverter is able to invert a stored function when it has no access to the syntax tree
<phantomics> I haven't fully built out the functionality, but how I'm going to deal with it is to automatically invert every defined function (if possible) and store its inverted form along with it, that way when you ask for the inverse of a variable-referenced function, it'll just fetch the stored inverse and throw an error if the inversion wasn't possible
phantomics: Dyalog only inverts tacit code (or dfn idioms, but those are stored as a single token), so it can just walk through the function's representation.
<phantomics> My experiments have shown there's a lot of potential for confusion in inverting an arbitrary defn, but it should be possible with a ton of constraints
<phantomics> In April's case that's just another code-generating closure
<phantomics> By the way, a while back you posted an operation that would be impossible with operators as macros, could you remind me of that?
<phantomics> I've reworked the operators a bit; now they're fundamentally implemented with macros, but most of them now generate a call to a runtime function that does the operation
I just added some functionality to BQN's JS VM to expose the function representation. It also uses closures for trains and derived functions. The idea is just to create another function such as ()=>[3,f,g,h] inside the closure, then assign it as a property to the returned function. That requires Javascript's ability to add properties to anything though.
<phantomics> given +o-, the o cannot be a function, it could be a value though. I'd have to create a form that would check for it to be either a value or an operator at runtime and then work accordingly
That lambda should cost nothing to create at runtime because the closure has to keep the values it uses around anyway, but in JS I find it's not much different from just creating the value. I don't know if this is because JS is good or bad at optimizing.
<phantomics> That's an ambiguous case, you're right
<phantomics> Strand assignment is handled by a special case in the April compiler, I could parse the defns differently if a strand assignment is made
<phantomics> So F←f g h would be a single train assignment still
<phantomics> Btw moon-child April lets you use k-style n-argument functions: a←{[x;y;z] x+y×z} ⋄ a[4;5;6]
<moon-child> or you could allow destructuring of trains. Which would allow for in-userspace introspection
<moon-child> phantomics: can you call regular function that way, as in +[5;6]?
<phantomics> No, only works with defns that have axes at the start
<phantomics> Train destructuring: you mean like treating a train as a vector of functions that you could reference elements of? You could call the entire train or just call functions within it?
<moon-child> I wasn't thinking to treat it as a vector in general, just to allow destructuring it in general in strand assignment
<moon-child> so you F<-f g h <> (nf ng nh) <- F would result in something useful
<phantomics> Right
<phantomics> Vector modeling of trains could work, though, it would be really interesting
<moon-child> the problem is that then your previous example of a b c: 4 5 6 <-> (a 4) (b 5) (c 6) doesn't work
Also probably worth checking out BQN's inverse ("Undo") specification at mlochbaum.github.io/BQN/spec/inferred.html. It's fairly strict so you might want to treat things more loosely, but I don't know of any APL that actually documents what inverse is supposed to mean.
<phantomics> a b c: 4 5 6 would work if you rule that the functions to the left of : aren't composed into a train by default; : would be a special compiler form so such a provision could be made in that particular case
<phantomics> Marshall: thanks, I noticed that negative power is sparsely documented where available, Dyalog lists the composing operators that work with it but not the lexical functions
<phantomics> The use case I see for it is when you want to do something like process rows in a matrix with a series of different functions, could be great for image manipulation, signal processing etc.
<phantomics> If v is a vector of functions, then do v:⍤1⊢matrix
<phantomics> Here's how to do it: a b c:¨4 5 6
<phantomics> That calls each function on each value
I definitely agree the functionality is useful. In BQN you can call the left argument on the right with {𝕎𝕩} and I use that a fair amount (github.com/mlochbaum/BQN/blob/master/src/cjs.bqn#L13). I just think it shouldn't use special syntax.
Another option, which I've advocated in J, is to have a special form to enclose a function, and another to get it out or call it or something (although I guess in a Dyalog-like language you could just use First, since functions can return functions).
<moon-child> phantomics: it matches lisp, too, as essentially a limited form of quoting
<phantomics> Right
<moon-child> @Marshall imo tie is generally not great to use in j
<phantomics> Implementing an APL with first-class functions is way easier in Lisp that emulating standard APLs
<moon-child> (I don't like quoting either, though. My solution involves a form of precedence, which I naturally expect most apl people to have a distaste for)
Tie makes an array that represents the function, which then has to be detected when it's passed to various operators.
I think enclosing could probably be nicer syntactically if there were dedicated support for it, but it wouldn't be as nice as capitalization, which is still a lot worse than function syntax in typical languages.
Although if you can apply a function with capitalization and juxtaposition or brackets that's kind of the best of both worlds.
Except that you have to be okay with two different ways to write the same thing that don't look very similar.
<moon-child> most languages that let you use separators in numbers disallow having more than one in sequence (so 3_5 is ok but 3_____5 isn't). That always seemed kind of arbitrary
<phantomics> Nice, I'll add the underscore feature into April too
<phantomics> It'll allow any number, before parsing the underscores will just be removed
<phantomics> Underscores are now usable within April: (april "1__000_000__000_000+5") => 1000000000005
<phantomics> And printed for alignment: (april-f "⍪12.2J44 3J8 19r13J5r2")
<phantomics> (april-f "⍪12.2J44 3J8 19r13J5r2")
<phantomics> 12.20J44.0
<phantomics> 3___J_8
<phantomics> 19r13J_5r2
<phantomics> The leading zeroes have been replaced with crosshairs, which I like better since the leading zeroes can make numbers look bigger at a glance than they are
@Razetime For future problems, I have a utility function you can use here that will fetch your input, store it, and return it same as ⊃⎕NGET 'input.txt' 1. Make sure to ]load HttpCommand first.
You can get your cookie from Chrome dev tools or something similar.
<phantomics> In an Emacs instance with Slime running and connected to an inferior-lisp, I can evaluate April expressions like this: (slime-interactive-eval "(april:april \"1+1 2 3\")")
But it's pretty ridiculous. It runs hexl as a dummy process, just so that it has a binary to attach to. hexl works becuase it's shipped together with emacs, and it never outputs anything.
When playing AoC, I think I've found a discrepancy/bug in the Dyalog jupyter kernel. I get the wrong result in jupyter but the correct result in the interpreter for:
@xpqz I forget - I'm not sure we actually version it - frankly it doesn't seem like a Jupyter bug, looking at the commits I can't see anything that would indicate fixing of a bug like this
@xpqz Is that when you do ]version in a jupyter notebook?
@xpqz Well it's the same version as your terp - I think my advice for now is install latest kernel from github and see if it helps, I'll ask colleagues
@RikedyP My participants (foreign language students and teachers) have never heard about APL and most of them have never coded. I used it as an example of a powerful tool of thought and an alternative programming language that one could really like. It is really trendy now in universities in TW to offer to all students computational thinking training. Now at least they know that APL exists and know they can start learning it with tryAPL.
@brgal That is very cool, thank you. In particular: on your linkedin post it seems they had tryapl open - did they get much of a chance to try it during your session?
@xpqz OK, I think we can conclude that the long numeric vector doesn't actually originate with the data. Try updating everything (there should be a new version of 18.0 available later today).
rak's solution matches the whole line with ⎕s, expecting a rigid input format, and then uses groups to extract the interesting parts, then forms an apl expression as a string and ⍎-s it
@xpqz s=∊l is a vec of bool vecs for the occurrences of the desired letters. p q⊃¨¨⊂ picks the pairs of positions, ↑ mixes the result as a 2×n bool matrix. the rest is your trick with ≠ and a +/ to count the valid passwords.
@dzaima (to be fair, the code is intentionally unAPLy, but that's because it has to be)
BQN does a pretty good job at making writing imperative code hell (but i guess that's partly the intention, and much of the problem is inherited from APL)
I'm still working on my Lisp project at the moment, but I'm thinking of some things to do for KAP. I was wondering how Dyalog deals with binary data (byte streams basically)
@Marshall {𝕊⋄body}, no? (it's not shorter than both java and JS, the only 2 langs i really care about, and in JS i often take a single unused argument anyways, at which point it's shorter)
@Marshall the problem isn't that i have to write something to get a lambda, it's that it's conditionally needed, and removing and adding 𝕩s changes that condition
@Marshall afaict that acronym mostly exists for closures and because JS's var is stupid. There are a lot of acronyms for mostly useless things everywhere
@Marshall i'd expect that quite often immediate blocks for closures would contain no-arg functions. (and personally i'd prefer syntax for intentionally-closured group of variables over maybe-has-side-effects)
@dzaima (immediate blocks for closures would definitely contain side-effect-ful functions. So the only case when the current syntax is shorter is when using them just for hiding variables from the surrounding function)
bqn-in-erlang update, since ive had some time last cpl nights to work on it.
much better understanding of atoms/values/functions. stdlib is mostly working (can construct 1-2 modifiers out of fns). vm is stepping thru sections, stepping thru bytecodes + arguments, going to the right case is working. stack manipulation is partial. getting the right opcodes and arguments seem to be working. ive started using javascript debugger.
few outstanding questions: - currently im keeping the stack as a mutable value in the process dictionary (memory local to the process running it). Will the vm ever n…
"I've somehow never hear of APL before seeing your comment. Felt like I was having a stroke when I started reading it. And then the feeling somehow got worse reading the explanation."
