« first day (1249 days earlier)      last day (828 days later) » 

1:53 AM
I can see that.
 
 
1 hour later…
3:14 AM
@Marshall "Cooking BQN" :)
I approve
 
 
7 hours later…
ngn
10:42 AM
@Marshall the most significant factor for that would be the availability of jobs
 
11:14 AM
@RGS Happy Birthday, RGS!!! πŸŽ‚
Parabéns pra você!
 
ngn
@AviF.S. @RGS (age happybirthdaywishes)+←1
 
@ngn Amazing!!
 
RGS
@ngn and would you say there will be any?
@AviF.S. hehe nice
thanks Avi & ngn!
 
@RGS Haha, thanks. I tried. The 'pra você' was unnecessary, I know, but I stole the first line from the song...
Super interesting, though! Thanks to doing that bit of research, I found out that Portuguese doesn't use inverted punctuation at the start of a sentence, like Spanish. So thanks for providing me that educational rabbit hole!
 
RGS
@AviF.S. no problem! :P Portuguese being similar to Spanish is a subjective thing.
 
11:28 AM
I can only imagine that it must drive you guys crazy that people are constantly thinking that because they know Spain/Spanish, they must know you... or well enough, anyway... because "how different can they really be?!" :p
@RGS Haha, you exactly predicted my next remark!
 
RGS
For one, Brazilian Portuguese has nothing to do with Spanish, so only European Portuguese could be similar
 
@RGS β₯ I'm still guilty of figuring that they must be close enough...
Given that Latin America is almost entirely Spanish speaking and they're just about surrounded...
 
ngn
@RGS it's not for me to say, it depends on what marshall does with his langauge, but generally apl and apl-like languages are a very hard sell
 
RGS
But Portuguese people do have the tendency to be able to understand Spanish, although Spanish people cannot understand Portuguese... (also, I think @Adám won't appreciate us going off-topic :/ but we can talk about this in an appropriate place :) )
 
@RGS (for ROs its always possible to move the messages to a different room at a later time)
 
@ngn huh, it hasn't frozen in 20 days
 
RGS
@ngn really? But is it not one of those things that is hard to sell, but when you sell it, you sell it for a nice amount of money? :P
 
ngn
@RGS maybe, like art
 
RGS
@ngn yes. Interesting
 
ngn
@dzaima the gods mods must have intervened
 
12:08 PM
@RGS I do want BQN to succeed but I hope you realize my prediction was just a bacon joke...
 
ngn
@Marshall in that case the most important factor would be the availability of lettuce and tomato :)
 
RGS
12:24 PM
@ngn +← 1
 
got past the hurdle of the absolute tokenizing mess i got myself into. Now to actually do the pattern matching headers..
 
RGS
I have also come to appreciate pancakes πŸ₯ž with scrambled eggs and bacon πŸ₯“
 
@dzaima strangely enough the thing i'm most afraid of is stupid stuff like (w ((f ((_𝕣_)) g)) x): :p
@dzaima w (f (_𝕣_ g)) x:?
 
@dzaima Wondering if I should remove pattern matching from operator headers, and just force them to have a single header. Operator headers are pretty complicated and if you want pattern matching you can do it inside the returned function with a second pair of braces.
@dzaima The grammar as written doesn't allow extra parens except around the arguments.
 
@Marshall so not even w (f _𝕣_ g) x:?
 
12:30 PM
@dzaima No, but I could add it of course.
 
@Marshall i'm hoping to mostly be able to get away with a single impl for everything
also at least having the 2 separate monadic/dyadic headers for operators would be very useful, given that you can't really have a ⊘ for operators
 
@dzaima But that's actually easier to write with nested braces, since you don't have to repeat the operands: {F _𝕣_ G x:monadic ; w F _𝕣_ G x:dyadic} versus {F _𝕣_ G:{π•Šx:monadic ; wπ•Šx:dyadic}}.
 
@Marshall i guess i'm still not fully bought in the immediate operators
 
@dzaima Oh, also looks like I'm only allowing function identifiers to be used for operands.
 
12:45 PM
to check, F: is 𝕨 F 𝕩:, π•Š: is invalid, 4: is π•Š 4:; F _𝕣_ G: is equal to 𝕨 F _𝕣_ G 𝕩: (what is F_𝕣_G?)
also why the switch to 𝕣 for recursive operators? imo it'd make more sense for π•Š to always be recursive self, and 𝕣 added for derived operators
 
@dzaima All those are right. F_𝕣_G is an invalid token since it contains 𝕣 but isn't one of the three allowed forms. I'm thinking I should switch to paired symbols like «π•£» to avoid this sort of awkwardness.
 
1:01 PM
and 2+2: (or (2+2):) are invalid? so is ⟨1,2⟩: (or ⟨a,b⟩:)?
 
@dzaima No, those are all right. The rule for single arguments only excludes lone identifiers because they could be labels for value blocks.
 
@Marshall so valHead is underdefined (or are those meant to be handled by FuncHead?)
 
@dzaima It seems cleaner to have π•Š always have the same data type (function). I think there was some reason why the system you're describing, which I originally said I would use, worked really poorly in some situation, but I can't remember it now.
@dzaima Those are instances of FuncHead with the function omitted. The header for a value block has to be a simple label since there are no inputs to match. The only purpose of the label is so you can jump out with .
 
@Marshall ah, brVal is the immediate {2+2} case
 
@dzaima Yes.
 
1:22 PM
 
Sorcery.
 
@dzaima hm the difference between 2+2: and 2 F 2: is quite big despite being the same syntactically
i propose requiring parenthesis around arbitrary expression constants, so all constants would be one token
 
1:39 PM
@dzaima Checked the grammar again and I misspoke about 2+2: being valid. It has to be something "atomic", like (2+2):.
 
@Marshall ah, so ^^ was already true. ¯\_(ツ)_/¯
 
Marshall writing BNF is more reliable than Marshall answering chat questions.
 
so the "header type" can be gotten from just the types of the separate "atoms" of the header
 
Yes, that does work.
Within argument expressions you can have some confusing stuff like ⟨2+2,a,⟨b,c⟩,Fn x⟩. Which lowercase names are intended to be assigned isn't clear. You can force a name to be used as a value and not assigned by parenthesizing it; maybe that should be a requirement since the alternative is that you have to check whether the name exists in the current scope.
 
@Marshall i thought the idea was headers just could never access any variables
dynamically changing header conditions would be weird, unless you fully think of them as weird conditionals
 
1:48 PM
@dzaima It would be determined by lexical scope, so it's not dynamic.
 
@Marshall "dynamic" as in the header condition isn't always the same, and cannot be gotten in compile-time
 
@dzaima Okay, the header syntax is constant but the values might change.
 
(i.e. the 2+2 would have to be evaluated for every call of the function unless there's some side-effectlessness checker)
 
I was thinking that the expressions in the header should be evaluated when the function is created, which allows you to write whatever code you want there.
Although the fact that it's inside braces but is evaluated in the outer scope is confusing.
 
also, is {𝕨 F _m 𝕩: F-⊒} different from {F _m: F-⊒}/{𝔽-⊒}?
 
1:54 PM
@dzaima Yes. Sort of a good thing since you can control the number of application layers in the header?
 
@Marshall another question - {F _m: 𝕩}?
(i.e. no args means immediate mode)
 
@dzaima That's allowed and requires arguments before evaluating.
 
@Marshall so even with headers you may need to check for whether 𝕨𝕩 exist
 
@dzaima Yes. Also you could have something awful like {F _𝕣_ G x:F x ; F _𝕣_ G:F∘G}. If I allow multiple operator headers you would check every header/body to see whether the operator as a whole requires arguments. But this is really messy, which is why I was thinking to not allow multiple headers for operators.
 
@dzaima so that's not strictly true, depending on what you call part of the header type
 
2:04 PM
@Marshall Also {F _𝕣:F 3 ; 𝕨+𝕩} looks like it is pattern matching on the operand but really it's just a monad/dyad split.
 
@Marshall what? i thought the monad/dyad splitting logic only dealt with header-less trailing bodies (and {F: F 3 ; 𝕨+𝕩} would have the same issue anyways)
(in my interpretation {F _𝕣:F 3 ; 𝕨+𝕩} would always call F 3 and 𝕨+𝕩 is unreachable)
 
@dzaima That probably makes more sense. I would say {F _𝕣:F 3 ; 𝕨+𝕩} should be an error since there are two full-domain cases.
 
@Marshall which goes back to this
though i guess fully overlapping is more important than partially overlapping
(and detecting full overlap in general is hard)
 
2:23 PM
@dzaima (and would need to be done on every instance of function creation, due to on-the-spot calculated constants possibly clashing)
@dzaima also 2: and v:, while again being equal syntactically, mean very different things
a bit more; god there are many cases
this may not be a viable strategy..
https://dzaima.github.io/paste/#0tZLBTsJAEIbvPsVvD7QNpohHmt6UxEPlIC8wwC40trvYbi0ovoB3j76jj@CUphRMJUHjpZnOfrP7z/wTSTjZM4IAfRcvZ8BYPwgFQgCTeXNhnEvX53TEnFkvRUnaZDOLXg/9Abrj0fUIcsAMoCsEtrR9yPonsf3taZQkYhaRKZOS4kxU6e1HhsE8DIowUHkcV/lVyBxVcSZiyX/14SsElx@KkrWo4TEt1KLFpHmrlNW@mvKtc4cQqcyQmgotcUeJ4HG5Lswi1QWUKHC/VoZWN2mqU4e6FpQ2oDjWhZiBsqqPSEHmamoirbAQNBOpdQFyDzp1nPp2PvEUx3t9tz9n3aoniqNZc2cV8MV786rMvvrZbEwXlIJMOXyvHJu/AycN2K/BSQlOdmD7ngx5U3ZTJHMesCnYbLiYw5I6uaP/2bZJ43Wr08fdQTPlg@rRkkl0Oly2DbdFeumJx5x1Odbnx/ub5brflxzHzCZ08Yvt@vsOnVr3BQ#Java
 
2:50 PM
There's also this: {F x:⟨⟩F x ; G:π•¨βˆΎπ•©}. Valid, but it's strange since you would think a case's label refers to the specific case, but it actually refers to the function as a whole.
 
@Marshall i don't think that's that bad of a usage
 
@dzaima It's not bad, just weird. Other forms of pattern matching typically don't have this confusion.
 
3:10 PM
Another operator-specific puzzle: should {𝔽;𝔾} be allowed? Does it apply the functions to the arguments or ignore the arguments?
 
@Marshall by my interpretation, that'd be a monad/dyad split of 2 immediate combinators
(pretty much the definition of ⊘)
if {𝔽} is immediate, i see no reason for another block after it changing the immediate-ness
 
@dzaima What about:
_c_←{‒↩1β‹„𝔽;‒↩2β‹„𝔾}
F←-_c_+
‒↩2 F 1
‒↩F 1
Information about how many arguments it has needs to time travel.
 
@Marshall oh right. My personal approach would be no immediate operators with β‰₯2 bodies
@Marshall not even time travel could save that
@dzaima (really i'd be fine with no immediate operators at all, but ¯\_(ツ)_/¯)
@dzaima (so {𝔽;𝔾} would error)
@dzaima i guess that'd block valid things like {⟨a⟩_m: - ; ⟨a,b⟩_m: ÷} but that's fine for the time being
is there really any problem other than two trailing no-header immediate?
 
@dzaima Some things get a lot harder without immediate operators. Say _o←{π•—βŠ‘βŸ¨βŒ½,⍉,βŒ½βˆ˜β‰βŸ©} β‹„ (n _o)⁼ x. I've done something like that for encoding/decoding various file formats in J but couldn't in APL.
@dzaima I haven't allowed pattern matching for operands at all. Use a function, like {_m:{⟨a⟩: - ; ⟨a,b⟩: ÷}𝕗}.
 
3:28 PM
@Marshall well i will (it'd be somewhat more effort to not anyways) at least in the 1st impl
 
@dzaima I think it's workable if you say any multi-body operator takes arguments. I still think the syntax is worse though. I would always prefer {F _𝕣_ G:{π•Šx:monadic ; wπ•Šx:dyadic}} to {𝔽_𝕣_𝔾x:monadic ; w𝔽_𝕣_𝔾x:dyadic}. It's much clearer about where π•Š comes from too.
 
4:14 PM
unrelated to APL, took me a while to understand this
 
5:09 PM
@dzaima Haha, but that looks like it's your own code, no?
 
@AviF.S. it's my own code, but due to the condition for the throw being wrong, though it wasn't able to tell me it's wrong, IDEA was able to conclude that ce==true
 
@dzaima Wow! Quite impressive
 
@AviF.S. exactly
 
:)
 
5:57 PM
grabs an apple
 
6:50 PM
most (?) of non-immediate headers done
(is "immediate" just a term i came up with?)
 
 
2 hours later…
RGS
9:23 PM
@dzaima I would've used "trivial" but "immediate" is a proper word afaik
 
@RGS i don't think "trivial" describes what's happening (the body is evaluated at deriving time rather than call time is the difference, nothing like it in APL)
 
RGS
9:41 PM
@dzaima I meant "trivial" instead of "immediate", so I'd actually say "most of non-trivial headers done"
Or did I misunderstand the intent of your message?
 
@RGS "immediate" is a term i seem to have made for operators which don't use 𝕨/𝕩 in their bodies and so act differently (see this), and for which I've not yet implemented headers
 
RGS
Ah I see, so I totally misunderstood :)
 

« first day (1249 days earlier)      last day (828 days later) »