Let's say in APL language, I have a 2D array of shape 10x3. I cannot figure it out how to:
replace all the occurrence of some specific numbers (e.g. 1, 2, 3, 4) in the entire array with 0, 10, 100, 1000 respectively. So I want to map 1 to 0, 2 to 10, 3 to 100 and 4 to 1000 in the entire array.
@EliasMårtenson It is a normal dyadic operator. The array to the immediate right is the right operand, and the rest (from the next function and onwards) is the right argument.
Totally unrelated to the discussion at hands but I have come to appreciate the expression (1+÷)⍣≡ 1 a LOT. I just find it very elegant. And I even surprised a mathematician friend of mine, who for some reason wasn't aware that the golden ratio is a fixed point of f(x) = 1 + (1÷x)
@Adám it's my go-to resource :) but even reading "At: apply X∘f to modify positions identified by Boolean mask (g Y) in Y" leads to a great deal of head scratching each time for me, although I eventually get it right. Your answer to the ^above SO question does help a lot for me.
@EliasMårtenson The only APL I know of with line continuation is NARS2000, and it doesn't seem to be a specific byte, but rather something handled by the IDE. It is indicated by a user-definable symbol on the continuing line rather than at the end of the continued line. I have proposed using a trailing backtick ` as line continuation character. I think PowerShell uses that too.
I was going to look for the first time +← 1 was used in this room as the APL version of +1 but the search functionality is terrible and ignores the ← altogether. Is there a workaround for this?
@Adám "on Linux, default is the Windows key" ahaha
@Adám - PowerShell does indeed use the backtick as a continuation character; it also allows a pipe | to end the line and the cmdlet/script that you're piping to start the next line.
It will be much easier to implement a continuation character at the end of the line rather than one at the beginning of the next line, due to the way the tokeniser works.
@Adám 'a' doesn't make much sense, since it only accepts a single character. I guess 'a could be used, but I already use that syntax for general quoting.
@EliasMårtenson Also, as mentioned above @ is a really powerful operator in some APLs (though I would have made it even more powerful if I had had my say).
You can, for example, quote the symbol foo using 'foo, which returns the raw symbol instead of evaluating it as a variable. It's the same idea as in Lisp.
@Adám Yes. That is correct. I find the inconsistency in APL where 'a' is a character, but '' and 'aa' are both vectors so ugly I couldn't force myself to implement it. GNU APL already uses "a" to represent the 1-element vector, so all I did was take the GNU APL syntax for strings and get rid of the single-quoted version.
Also, in light of Unicode, the standard APL way of handling it is dangerous. Where 'ä' might be a character or a two-element vecotor depending on whether ä is the single character or a followed by a combining character.
@Adám that too is annoying and stupid, but, unlike with characters, there's not much that could be done without resorting to a separate strand separator as in BQN (or just throwing out stranding in general)
@Adám That would be ,1 just like APL. I agree it's not entirly consistent, but at least it's pretty clear. Much more so than trying to make sense of the concept of a "character" in a Unicode world. BQN does it differently, and in a very interesting way. I preferred to go with mostly-APL-compatible though.
@dzaima @ can take a list of indices of major cells rather than a list of indices of scalars, so you might think that it can take a mask of major cells rather than a mask of scalars too, but it can't.
@dzaima Yup. Iverson was against stranding from the outset. It wasn't in Iverson's notation, only in the first APL implementation.
Also, I decided to use " for strings because if someone wants to translate APL code to KAP, they would have to change the string/character syntax, and that would hopefully avoid mistakes.
@Adám to manipulate them APLily, you'd have to often temporarily convert them to vectors of characters, which would probably quickly turn into a divide of functions taking charvecs & strings in contexts of string manipulation. Otherwise, it'd be like k's symbols, no?
@dzaima (or you could of course create a copy of every built-in to work on strings instead of arrays, but that's not good for quite obvious reasons)
The challenge
Write a function that takes two positive integers n and k as arguments and returns the number of the last person remaining out of n after counting out each k-th person.
This is a code-golf challenge, so the shortest code wins.
The problem
n people (numbered from 1 to n) are standing...
@dzaima I was thinking that + could merge strings and then we just need to be able to split them. $ could do that, and +/⍥1 would be its inverse. Then most operations could be done ⍢$. But then again, how often do you really need to manipulate the value of strings using primitives?
@Adám depends on the use-case. For things dealing with actual text (i.e. website, database), probably ±never, for text generation or parsing (e.g. HTML, SVG), probably always
@dzaima For text generation, it'd probably mostly be concatenation, which would be +. For manipulation, you'd use ⍢$ and for lookups and comparisons etc. you'd use ⍥$.
@Adám using ⍢$ and ⍥$ literally everywhere is annoying though, i'd assume most would switch to chararrs throughout all manipulations and stringify only on the final output
@Jonah Here's the last time it was requested that I know of. Roger is opposed, but he doesn't develop J any more. It's now supported in Dyalog 18.0 (⍸⍣¯1) and BQN.
@Razetime I have a basic train. I am no code golf genius and from what I've seen you are smart, so I'm sure you can get smth similar to (or better than) what I have
@Razetime notice that f∘h is a train :) in my case, f is actually f⍣g so my solution is of the form f⍣g∘h (-- not saying this is the best or only way to go about it!)
yeah go ahead, I can try to help if you have any questions... and there's plenty of capable ppl here to back me up :P
@dzaima (maybe @EliasMårtenson?) Think I've figured out a decent module system for BQN. It can be extended to a full namespace system (probably even OOP as well), but can also be statically expanded into list creation and assignment by the compiler so it doesn't require any runtime support.
⇐ is the "namespace export" character, and a block that contains it at the top level returns a namespace. It can be used in place of ← definition like a⇐3, or alone like a‿b‿c⇐ as a complete statement. In the second case the exported variables have to be declared elsewhere. I think it should also be allowed at the beginning of a header, which mostly be redundant but guards against removing the last export and having the block's behavior change wildly.
In the restricted version I'm defining now, ⇐ can only be used in immediate blocks, and at the top level in a file (which behaves just like an immediate block). This means it's always evaluated exactly once—you can't conditionally export a variable. Such a block or file import can only be used in a destructuring assignment, and not in any other way, so that the namespace can't leak out as a value.
@EliasMårtenson No, because of the restrictions I'm adding, but if these restrictions are lifted then they would be first class. This frees implementations to choose to support just the basics and avoid the implementation costs, or have full namespaces.
@EliasMårtenson Here's one that exports three values from a block.
The general form for the target destructuring assignment is like a list, except that each element can be followed by a : and a name. With a :, the thing on the left is the target used on the outside, and the name on the right matches the exported name. Without one, only a single name is allowed and it's used inside and outside. If there are no :s, using strand notation ‿ for the whole thing is fine but probably confusing.
But the target has to be some kind of list: you can't just assign the whole thing a name in the restricted version.
I guess a file import would be something like •Import "file.bqn" although it's a little weird because •Import wouldn't act like a true function (in the restricted version). It has to be called (that is, it can't be an operand, list element, etc.) and the result has to be used in destructuring assignment.
There should be some kind of mechanism to indicate whether a file import needs to be reevaluated or an old copy can be used. Either two different •Import functions, or a declaration in the file itself.
@Marshall right, it doesn't (but then it strays even further from commandline arguments which must be a vector of char vectors, so the two should probably be separated)
@dzaima If the compiler's being called again when you actually import the file, then you can tell it what names you want to get out so it can return a list of those values. The receiver just needs to destructure that list, which is the same regardless of where it comes from.
@dzaima Sounds like a limitation of what arguments the shell can pass rather than what BQN can handle.
@dzaima Isn't a comment at the top describing the arguments good enough? It could also say if you should pass in a dummy argument (I would use @) to keep state from getting corrupted.
@dzaima actually, the restricted version means that the •Import caller cannot mutate the state of the cached return (assuming the functions don't mutate themselves). Should the namespace be cloned for each invocation otherwise?
@Marshall what about a F←{b+↩1} being inserted in that?
@dzaima (Needs a function header for F) Variables are exported by value when the block finishes. If you want to export something that can be changed it needs to be an operation.
Or from the namespace perspective I guess it's more accurate to say that destructuring is what pulls out the values. Namespaces themselves should be mutable.
@Marshall makes sense - so a namespace is really a (mutable?) dictionary, completely separate from the closure
(heh, ⟨a:b ⋄ c0‿c1:c ⋄ d⟩ is equivalent to {a⇐b ⋄ c0‿c1⇐c ⋄ d⇐} with some assumptions about variable scoping, with the bonus of being able to evaluate things in the middle)
@dzaima I would say the namespace is exactly the closure except that only certain names are exposed. Mutation from the inside works the same as a closure, but I don't know what the semantics would be for mutation from the outside.
The differences between a namespace block and a block that returns a dictionary are that the namespace is mutable and its keys have to be symbols. Symbols are definitely not a subset of strings because they are case- and underscore-invariant.
@dzaima But the unbonus of not being able to access previously-defined members.
@dzaima Changing the closure should change the namespace, but it can't change which names are exported, only their values. I don't know how changing the namespace should work.
@dzaima (but strings would be pretty weird as a superset of symbols)
@Marshall i mean, it has to be done if namespaces are first-class objects and you can access items by name arbitrarily (and you don't want overhead for each variable in each closure/namespace of the name)
@dzaima I meant whether it's the closure or the namespace that stores the table. I agree one of them has to with first-class namespaces, or even (performant) reusable scripts.
And ⍎ can't really act like a namespace because it also needs to expose the names in scopes above it.
On the other hand... with restricted namespaces it makes no sense to export variables from enclosing scopes because the namespace has to be destructured in the scope above it, which already has access to those variables. With general namespaces you might want to extend ⇐ to allow that though.
@Marshall i was considering making that a reply to that, but i guess it actually mostly answers that question. i was more wondering whether there'd be any common syntax or logic, or would they be kept entirely separate
(i was thinking of wanting a mutable hashmap-style object of arbitrary BQN object keys→values, but i guess "mutable" there is sort of not needed in practice (but does mean an implementation wanting any write efficiency over a keys→values pair must refcount))
also, both strong and weak interrupts give me the possibility of resuming function execution?
except that weak interrupt stops at the end of a statement and strong interrupt stops as soon as it cans (and then execution will have to repeat the statement I stopped at)?
Because I read their description and I thought the strong interrupt would just tear the function execution apart, but that is not what happened in RIDE when I tried it, so maybe I misunderstood
@RGS RIDE is erratic when it comes to interrupts (at least on the Mac). I find that if I'm sending output to the screen with ⎕← especially, no matter which interrupt you try, it keeps on uninterrupted.
@xpqz Ah, that's probably because the interrupt only affects the interpreter. If it has already sent output back to RIDE, it is V8 that needs the interrupt.
with {⎕←⍵}⍣{0}1 & a strong interrupt i get in a state where RIDE has stopped outputting, no interrupts do anything and the dyalog process is continuing using CPU
@xpqz I did read that neither weak nor strong interrupts can stop a primitive, so probably that ⎕← is trying to finish outputting everything before actually giving you back control of the ide
as i don't want to add another "section" to the compilable stuff, i'm currently thinking about a RETD (annoyingly my RETN already takes up "return namespace", maybe best to rename it?), which returns a namespace from local vars with indexes objs[N] (objs being the list of constants), but that wouldn't work on vms which don't know variable names
@Marshall and also a variable name list (for non-mine vms)
@dzaima i guess the alternative of having both the names and indexes in the constant isn't too bad
@dzaima I'd say just to make the name and mask fields for a block optional and generate them for namespace blocks and blocks that (deeply) contain ⍎. Any VM that supports a namespace creation instruction should be able to read those fields.
my already existing optional 5th per-block element (a list of per-body wanted arity for whenever headers need to be •compiled) makes that a bit of a mess, but i guess it's fine
@dzaima though i'd need to reorder it to allow for the variable name list to be optional
@dzaima oh but i still need the variable count even when the names aren't required
a strange thing is that the export mask should really be per-body, though it'd only be there for single-body cases
@dzaima though actually i guess nothing prevents it to be on 2 out of 3 headers of a modifier with first-class namespaces, other than that being a pretty stupid thing to do
@dzaima Kind of inconsistent that blocks are like a list-of-structs but bodies are more like a struct-of-lists. Maybe bodies could be moved to one big list with functions pointing into that?
A given block could even have two body lists, one for monadic and one dyadic (with ambivalent bodies in both).
@Marshall that ±had to be done to keep compatibility with what your compiler made, i would have probably made bodies be a list of structs too (which would be less array-y, but probably fine enough)
@dzaima It's really easy to rearrange things now with the dc.bqn layer, so if you decide to do that just let me know how the format changes and I'll pick it up.
now the question is do i kill that string constant thing and just use chararr object constants for VAR_ while at this
@dzaima (the answer is yes)
(btw i'd like for DGenFn to come back, i.e. query the argument to •Comp without evaluating; but i'm probably the only one needing it, so a local change works)
(i'm in the middle of like 3 refactorings but my (albeit very limited) tests still pass :D)
@dzaima (for some reason i just thought about that again - the try catch wrapping added 30-50ns per call, and i wrap each body evaluation in a try catch, potentially totaling a reasonable slowdown)
Let's say in APL language, I have a 2D array of shape 10x3. I cannot figure it out how to:
replace all the occurrence of some specific numbers (e.g. 1, 2, 3, 4) in the entire array with 0, 10, 100, 1000 respectively. So I want to map 1 to 0, 2 to 10, 3 to 100 and 4 to 1000 in the entire array.
