ok imma guess - the amount of strings/objects/dfns in a given compiled thing is limited to 256. i'm guessing i didn't check that one of those overflowed
@user721719 Perfect question for the 19th Byte chatroom, the general codegolf/programming/maths challenge/puzzle room for this site :) If you haven't already!
almost nothing works, but hey, it's at least trying.. ¯\\_(ツ)_/¯ https://dzaima.github.io/paste/#0vVNNaxNBGL7vr3jJxV2S4u5260GhsDEJxoOFih@nlHUzaVc3s2F2IglhoQeJGhEtpESEEigKCQi5CHqpwubov5hf0J/gO5ONtqUV9dCwu7yTmXk@3nlmHTbLlZwt@vv4rOW0e3FAt6FN66QRUFKHR@0g5CsBBdHf0@52Kfc6ZcYidh38qB3W6RUOjyOcJk8J6/IduZlH4IGECQmQTouROA4i@mdkuOiXzrR1JVEM9uycVoqaXkAzBXciCOqE8oB3YYnaiBjoeViB@chA1Go2L/pvoXd8sP8m/SzGEzGeJmcoa/hqbrFiopwp5LWz9D2xe4ggCDFNxPvnuEzCTKyCXVhFuALWTmGtcA1rfHJatdkKSRPJPY7mM8EuY163ih3obLT5RqMYYTficscnLbnoBhgx9/wnyoOqOPN8ohVvZ6qwBUtdtXNk/XgHttj9voqvIz4O8Dxt59KEgCUGX/Pi9dgUg0NwIHc6LKVARQXjQHwO6RfYIYx…
@all What might people think of an operator that binds a function to its argument before everything else, sort of like curry, except it's immediately evaluated
Essentially, it'd be when you have something of the form (f a) func (g b) or something similar: One could do f→a func g b, or f→a func g→b for symmetry
With → being whatever the binding operator is, of course
Just because I've noticed that almost every time I want to use parentheses, it's only to surround a function/primitive to one argument. Just about every single time, I think!
@dzaima Yes, except with binding priority. So as to eliminate the need for parenthesis
full preprocessed source: https://dzaima.github.io/paste/#0rVtbbxzHlX7vX1HJS7oROjsz2c2DYi8wFw45lEjKJGVLfmGazaY4YU/PqLuHksAdwAEMxaKsxM7GsBFsol3HRkggQF6CJA@xAyiP@Rf8BfkJqXOpW/cMRbHXD4mmu@qrU@ec@s6lmu12v3Hx5OOTixdn//z1p2dCXLw4FxfPPhAXz3928f4X8tW37@TD9L6YpvvxwTCN98XedJgUbwxT8a1vz7x25/rzvwvzu9ef/wbM711//t8/A4DlGgB/BoD@9QEunj0BhJUaCB/@ChBWayB8dAoIgzoIHwLCWp1d/A4QbtZBOAOEW9dHePl7AFi/PsB/wfyN689/C@Zv1lDB0/8FhNt1EL4EhLevj/AmzN@6/vz/hPnbdXbwFSDs1EH4P0C4UwfhC0B4pwbC6W8B4d06CCjD3RoIXyEt3KtzJL8BhPfqaPK5ROjUCFEXTz4BhE4dhP8GhG4dhE8BoVeHYL8GhBqR6uL5U0CoEar@DebXCVTPnwFCnUD1/BeAUCdQnf4cEOoEqlP0pzqB6vRjQLhVBw…
Anyway, doesn't make that big a difference, just a possible aesthetic difference that can highlight symmetries like with f→a func g→b more elegantly than cluttering it up with 4 parentheses
Anyway, just an idea for someone's dialect like dzaima/ngn/Extended, or even BQN. Especially since I think one could use → without new glyphs. I don't think it overlaps with the syntax for branching
@AviF.S. Adam and I went through all possible combinators with some restrictions like not calling a function on its own output. We feel that ∘⍤⍥⍛⍨ are all the useful ones.
@AviF.S. It's pretty hard to justify an extra level of precedence in my opinion. I think the way BQN does it with reverse compose that dzaima pointed out is pretty good for the case you mentioned.
I am thinking a little about some kind of syntax to let you apply a function on the right to a value on the left (a bit like shell pipes), because that lets you straighten out control flow. Even that is kind of a long shot. I think it's likely to leave gaps.
@Marshall To avoid doubt about operators, we were considering "combinator" in the very strict sense of an operator that treats its operands like total black boxes and calls them on arguments, so Under wouldn't qualify. There may be other useful things like that out there to be found, but then it's probably more okay to use non-circle-based symbols for them.
and the modified reference and its parser: https://dzaima.github.io/paste/#0pVZbTxtHFH73r5jMi2251KD2oQ9QibSOhJSgFhr1AaXusjuuR92Ls7tOilxLjlS59mKTkAYZRSCKC6qR8ohKHxIjmUf@xfkF@Qk9c/H6ElMeYq28s@fyncucc2agfUhMw7YJd0lYZGQt98198pSHRZJmv5BsyQiL2dDLhkUeZAvcZglAhXLAlMxa7h41PYtRkvJ84m0@4V45IHe/XSXscZk/MWzmhkE6IVAI1F8QOgbIsj4rMJ@5Jvt087FLEwmodXNry@u5QY9Q33hKoXZJUYYm1pa/R@1MAs3Jd6KSIEQSz6C9g2vXcFggLcBpRJfvUmj0oXWAgAZyC3mz6Cv7dzJzV52rC9iuQ@M1tCJoNaDxNzR6gze/LkHzT2ieLH4JzVNoHkOzC9FfEHURUsA121DfhfofUN@D1jtoN7PQ3ob2S4ieQ7QL0QuIXkIjgvYFRK8omnVGZq8PrvcHPeHRs7eD8x8F1xpxobEP0b9wdACdbWj1YacJr3@H9hF0/oFoXwjLIHio5…
@AviF.S. Well, a constant passed as an operand automatically becomes a constant function, so you have x c⊸F y is (c˜ x) F y is c F y. And ⊸ copies a monadic argument to both sides (the monadic version isn't exactly like reverse compose), so c⊸F x is x c⊸F x or c F x.
@AviF.S. It's one less thing to learn when starting the language, and keeps the syntax simpler. It means that definitions for those operators can be written in the language, and you can name the operators or pass them around as values.
@Marshall Oh? I thought combinators also had a higher precedence...
Also, to argue that it's one less thing to learn, seems odd when no one is requiring anyone to learn it unless they choose. No one argues against adding libraries to a language because it's more to learn, I don't think
@dzaima Isn't that what everyone said when trains were first introduced? And isn't that what people said when ⍤ was added even though atop already existed?
Meaning in most cases it only saves one character, replacing two parens with another, like the →?
@AviF.S. trains can actually save huge amounts of ⍺s & ⍵s & dfns & parenthesis & logic, and the cost of adding ⍤ is way less than that of adding trains, so it can be "way less useful"
→ will only ever save 2 parenthesis at most, and nothing in many cases, but it's new syntax
@AviF.S. It's about the utility you're getting versus the complication added to the language. Operators have higher precedence as a group, so there's some extra syntactic weight spread across a lot of useful functionality. It's definitely okay to design a language that has a lot of special syntax, but I am trying to make BQN very simple.
@dzaima also i'd really like to make it not store all those intermediate byte[]s as now i can parse a line without needing to parse the contents (due to using this before the actual "smart parser"), but that might be too much for the couple of hours i'll have
@Marshall Understood! With the emphasis you're placing on simplicity, to the extent of replacing 'ifs' with ternary and not impl. other explicit control structures, it makes perfect sense! Was more thinking in Extended/dzaima it might have a place. Not just since it's more elegant, but also for golfing
@ngn Aww, why'd you delete your grammar policing?!
I don't know where I'd read about the industry stuff, but I'd been left under the impression that it was more specialized and better/necessary in some cases. But not that it was a language anyone would prefer for general use
@AviF.S. vague - not at all. "simpler" in kolmogorov's sense - it has a short description in the language you speak. the source of the k interpreter is much much smaller than the source of the dyalog interpreter, and it has fewer moving parts that might break.
@AviF.S. i'm not sure what "expressive" means but probably not. apl uses a lot more codepoints from unicode (or "classic" encoding, or whatever), so it can pack more stuff in fewer bytes. but if you cosider a k character as 6 bits (verbs + 8 chars which is the max num of locals), k is the more expressive one
tl;dw the more code you accept as valid that does different things from other code, the more expressive your language is. Information density, essentially
@Moonchild Not exactly accurate but I like to think of it as how closely the code maps to the way you think
Found this online, which is roughly how I understand it: "capable of concisely expressing understandable solutions to problems in a suitable target domain."
@ngn Less interested in the technical counting of characters and more in how easy/concise it is to read/write. And once you have an idea, how much effort it takes to express it in K vs. APL/J. Aka how closely the code resembles your actual intuition
Eg. (2∘+⍣3) 0 is shorter than 2 multiplied by 3 but the latter is more expressive, the way I would use the word
@all Might a Wiki page be added comparing all the APL-like languages? There's very little info comparing and contrasting them online, and one SE question which isn't very helpful
@ngn All I notice is that K has a greatly reduced set of (ASCII) primitives-- I suppose there's the simplicity. And that it has triadic/tetradic versions of some. I also read somewhere that user-defined funcs don't work the same way, but don't see that on the wiki
Is there anything more elegant/expressive/interesting in K than J? Or is it simply the simplicity of the language, and its speed, that so appeals?
@Adám I'd say no because I guess the entries are mainly for Dyalog APL, while the Wiki may have information for other impls that can be confusing to the user
progress; no clue what that arrow finds so interesting in the letter D in _AAD1_ https://dzaima.github.io/paste/#03VXLSsNAFN3fr7i4asBFJ1ofWQhT20LEFz53lphMJbSdyCRFpBRcSEGk4ELBTXHjooLgF6jQT8kX@AnOTVsfRUSlC@lMuMPMfZ7DnckCbuQLE2bcvNJfZgJs6QZKCTfi6iDMKxUoC0s16UZ@IDE@u0XXqVSEh9VAOp5Pm2PgvJDGuHmH9Zf21R3G56dkyRpx66Z7D/hh7JH4hT12H8hhAY0wctwyMOtnzt2HwdwjoUOYFqz7bjluXtghV8o5xiLnOVZE5DsFhnpn066OSXyGfFUvyNdIx7e11Nk6OlmSNLuklXTQiE@eKaz3ueoB0iEoo5q9eDBlwaBsDSvho5NKkXxpXz5SocZbpddGnQ4bdNpI3ONWG5ftFXsrn8MoQFmr7guFFVGKMDgUypEeKhHWKhH8BQL@YsD0uADJJECWhoCwt4o7BvJFjSNtDPCSRveQXp4wgQSjaxiY6fNqfs8r@4JXInXTqQr0RMm…
@dzaima in the process of doing this, and my worst fear - the reference parser executes, but somehow something manages to break actually evaluating the parsed reference
@Moonchild watched it. interesting. so that's an attempt to define formally what it means for a feature F added to a given language L to be "expressive", but i don't see how that could be used to compare the "expressiveness" of two languages as different as k and apl.
btw, aplers like to describe k as a "reduced instruction set apl", and this phrase has been used publicly by k people too, but i think it's misleading. k is far out in the direction of lisp compared to apl&j (which are very close together), and has innovative features of its own.
@AviF.S. "easy to read/write", "effort it takes to express it", "intuition" - those are subjective. they depend on the background, habits, and skills of the programmer (and maybe the problem domain), rather than the language itself
@AviF.S. elegant/expressive/interesting - yes, there is. for example, one of the things i find most beautiful are the symmetries between k's / and \ in all their overloads
@ngn if i currently didn't have 11 errors, i'd test (i doubt it'd be enough)
(also i can't deduplicate constants as they're also used as a way to reference to tokens so error messages could point to the source)
@dzaima (with this refactoring i'm doing though, i'll be able to somewhat rely less on that by just storing a token array besides the bytecode array, with a 1:1 correspondence)
@dzaima if you don't actively remove complexity from your code, you'll be crushed under its weight, it will get increasingly more difficult to make any changes, and this will be just another failed apl-like language impl on the pile of history :)
@ngn i'll start removing stuff when i'm sure what needs to be removed. this whole folder could be removed with nothing lost, but i'm still keeping it around in case builtins are changed
@dzaima and currently most things in the compiler are completely up for being changed (i.e. what i'm supposed to be doing now, but 2+2 still gives 0 code)
@dzaima (as i think currently most things in the compiler are relatively needed and can't be simplified much without losing refactorability/my view on simplicity)
@dzaima yay reference compiles again!
@ngn reference doesn't have >128 constants. ¯\_(ツ)_/¯
@dzaima i guess all constants would have to to be number literals, which are few there. All built-ins are replaced with variables, which definitely were >256
it's not that hard to implement though, and shouldn't really hurt anything
now it really likes to point at numbers as the currently executed thing.. https://dzaima.github.io/paste/#03VXNSgMxEL7nKQZPXfDQrNafPRRSbWHFP7TqbWXdTWVpm5XsFpFS8CAFkYIHC16KFw8tCD6BCn2UfQIfwczWqi2lVPFQmiwTkplMvu9jkk3DXjY3p0f1pvpSc8QUji8ld0ImT4OslL40oFARTuj5AqLrR3DsUom7UPaF7Xo4uSCM5ZIQ1TtQfW81OxDdXGEkrUWNh@4TgR/NQvOLeOg@44Y0aEFoO0VCjck2d5/73UKjUugG2fWcYlS/NQMmpX0Bx4yt02MAdpijoGYmzqoQ56fAttUAbAd97EBZdVpbHRYfmtlQTlyoRZdvmNYdRN1nOkTlv3ovH1kwSB@2ohXr0U4k0L637l4QqPaF9F6r4mINV2vx9qjRgk1zy8xn1yH0QVTKJ1xCiRdC8M@4tIULkgeVUkgmp2BZ1je@yRpZnAkWqZjFxhAL@gW3rQFbUySSWp8selT1qOEVYj4jEFp/qw@y9KmpPl5TOkJTFHTfLn…
bytecode of the preprocessed reference because why not: https://dzaima.github.io/paste#07X1JciNJkuA9X4GJ29zczHytQ4uAACEtMtJdLdXLHEewRjBIAiRIRkbUC@YDLVGXmTPj1H/op8wL5gkDW1XNXNXdQDC6UnoyD5FOh9uupvvyN5P/ulpvJ3@a/vcP2//xcNw@HA/rD7@sD5vtH36ZFItJUUz0f/PF388nxemN9G/@Zfqnv5t8WN5sxIfT66uJ@@8fr//p721DAQ2FbShww89sQwkNpW0occNfd1xDBQ3VL3o49@bU8I8w4unDEj4sT29a39Uf/0HO7YglHvELO2IFHVW2YYUbLu@5hjU0rG3DOmrIbk4DDRvbsMENN2zDFhq2tmGLG67Yhh007GzDDjdc0w1Pmz/Fm@@2Qvgv3evtrnCvZ/i16/T0eo5f7@zX6Xk18LeY22bXxMELvRz0@qMfWxT4tduJwgP6P/zzP/7t5L9IYtw@3IgIxD/umK0REg@4sfM4tVbRBWFbl0Tr0@sq2sHwuo4WZ19Pfaf/9CflZh6B0S07dksP0hGDF…
@RGS in what other way would you store a program that's not compiled to machine code (doing so in the case of APL would be mostly pointless) but still needs to be evaluated with high performance?
@RGS these are different slots - here they're kind of "renaming" variables to consecutive numbers to not need a hashmap to get/set variables (dzaima/BQN doesn't do this at the moment)
@RGS (an AST might be an alternative, but 1) then the objects would probably be scattered around the memory resulting in way higher cache usage, 2) it'd use the regular stack which might be worse than a manual stack or something similar; and probably a couple more performance problems)
@RGS also, bytecode is stored compactly in memory. if i used a tree-walker instead of bytecode compiler+vm, the interpreter would have to "chase pointers" a lot more which is slow due to the way ram works
i did for a while consider the tree walker/AST approach though, mostly due to me knowing that trains are evaluated incredibly fast in dzaima/APL (at least compared to its dfns)
@dzaima dzaima/BQN trains still are interpreted the same way as in dzaima/APL btw, which is pretty much a tree walker
@ngn ah so "whitnified" does refer to the name of a person, thanks. It just resembled the word "white" too much and I wanted to be sure it referred to a person, and not to "whitespace" :)
ah, i was forcefully merging multiple pointer messages in one. fixed (still pointing at numbers though due to me backtracking to try to get _some_ pointer in case there's no other choice): https://dzaima.github.io/paste#03VbNattAEL7PUww5WdCDV637o0NgHdug0LSlcZr0IqFK6yJsr8JKJg3G0EMxLcWlhwZyMb70YEOhT9AW8ij7BHmE7mqtmDbGmP5A8MjMsrPa2fm@nfFoG5/WG1u2HJ6pX2ULXB4mQrAwo@JlWhciEQ62ejzM4oSjfPcZw6DTYRF2Ex5EsZ6cwjZaaRaEbSAOUNoooxzOsH85PpuhfP9G7yIDOZpcfAE0cvG1eDytEMF24EkctuXwo5tSIYJT9CmtER@RPmsQVDNXz/qY@ydIH6kB6WO9Rg@UVqdN1WH5odVdtagNA/n6h3YbFQevkEVMf/sYf@sxUYiHcNuBAqaiId81LZW0vhx/@qZ9WFfIzq2@Ng60dZA7kKMx…
@ngn even i don't know the hex codes of my bytecode (and might rearrange them at any point)
and i see no reason to restrict bytecode readability only to people who know the internals of the interpreter. Knowing how stacks and bytecode usually works should, and can be mostly enough
@dzaima and even if i did, reading roughly human readable words would still probably be easier than having to parse a stream of hexadecimal digits
(and with named constants for the bytecode instructions, the only desynchronization that can occur (provided don't rename the constants without renaming the corresponding name in the disassembler (easy to do as i can just jump to the usages from the variable)) is forgetting adding an instruction to the decompiler when its added to the compiler/interpreter, which is clearly noticable and still not that hard to remember to do (i've done it once i'll say though))
@dzaima i don't doubt that the issues will become bigger/more probable later on, but at the moment, while developing the basics, being able to visibly view the bytecode is a really useful thing
i even considered adding a thing that references which lines are the things each instruction will pop, but that's a bit too much required synchronization even for me
@dzaima and in that "later on" when the the bytecode formatter may be more broken, it'll be less important so it all works out in the end
ಠ_ಠ i had that token-per-bytecode thing, but the object responsible for temporarily holding a byte[] + Token didn't actually store the token anywhere.. Now with that fixed: https://dzaima.github.io/paste/#01VbNattAEL7PUww5WdCDV637o0NgHdug0LSldZr0YqFK6yJsS2ElkwZjyKGYhOLSQwO5GF96sKHQJ2gLeZR9gjxCd7WWf1JXBAoNnhWz7Cw7@823M7vaxpfV2pYpBhfyK22BHXoR58xLKH8XVzmPuIXNbuglQRSiOP@KnttuMx87Uej6gRqcwDYaceJ6LSAWUForohhMsXc9upii@PhBrSJ9MRxffQPUcvU9aw2lEMG04EXgtcTgsx1Tzt0TdCitEAeRvq4RlCNbjXqY@idIn8kO6XM1R/ellrtN5GbppuVdOakMfXH6S7n1s41zZIHpX5v2dzsmMmkg3LcgC1PSkK6aFApKX4@@/FA@jHlkl0ZPGfvK2k8diOEIn9p7dr1awSTCsNt…
@ngn Marshall is planning to do something like that. And I 1) can't be bothered to, and 2) don't (didn't) have a way to bootstrap with features i'd like
Having dzaima/BQN for bootstrapping will be nice, and I will also probably add a backend for dzaima's bytecode so I can work on the compiler without worrying about the runtime.
Shoot! I forgot to save my last session! Is there any way to recuperate all then fns from it, or at least see last session's REPL? It's sometimes right above, but it's not consistent and this time it's a much older session that's above...
@ngn Of course it's all subjective and depends on the person's experience/mode of thinking. But I'm curious about it from your experience. Whether it's easier for you to translate your ideas into K than other APL-like langs.
Also, as you say, I have read about it being inspired, in part, by Scheme, but am not clear on how. Do you mind enlightening where Lisp comes in?
@Adám The point is I didn't remember to do any such thing. I just stopped coding and I suppose at some point I may have turned off/quit all or something. I don't quite remember
@Adám you merged my PR, so why does GitHub say my branch is 7 commits ahead, 1 behind Dyalog:master..? I understand the 1 behind is the commit of merging my PR. So why am I still 7 ahead..?
wait so now if I write another notebook, I'll be many more commits ahead of Dyalog:master, won't I? so if I want to keep contributing what is the git way of doing it..?
@AviF.S. do i have to choose 1? :) generally i prefer k over apl, except for tasks involving linear algebra, unicode, or closures. i think golfing is more fun in apl because there are more primitives to combine in creative ways. as for j, i can't get past its syntax which is bizarre even by array language standards, but it does have a wealth of built-in types and operations which is sometimes exactly what you need.
@AviF.S. functions as first-class values, m-expressions, homoiconicity
unfortunately no closures, no hygienic (or any other) macros, no call/cc (deliberate design choices)
@RGS IANAGW, but I think what you are doing when adding a notebook would be considered a new "feature", so the correct way is to branch off master, make your changes, PR, then discard that branch, then create a new branch off master for the next feature.
AutoSave←{ ⍝ every ⍵ minutes - call with AutoSave&n
⍝ optional ⍺: filename (default is autosave.dws in temporary directory given by 739⌶0)
⍺←'/autosave.dws',⍨739⌶0
∇ ⎕DL 60×⍵⊣0 #.⎕SAVE ⍺
}
That's odd. If you're using a nonstandard (e.g. laptop) keyboard, you may need to hold the Fn key to access the Pause/Break key, but I think most keyboards have it.
@Adám @RichardPark @past-ngn @past-Marshall Quick Feature Idea: If you call F1 on an error message, it'll take you to its documentation
My goodness gracious! That's wonderful, thanks a bunch!! Also, stylistic point: If you're worried about confusing the reader, it's convenient to call such niladic functions with ⍬. The extra nice thing about it is you don't even need a space! Eg. `⎕←callMeNow⍬`
