2021/10/05

2021-10-05 00:00:44 +0200w-spc-gir(~w-spc-gir@2601:646:9c00:594c:bc3a:4a61:1dc8:3137) (Read error: Connection reset by peer)
2021-10-05 00:05:48 +0200w-spc-gir(~w-spc-gir@2600:380:4710:c16:2c05:423d:6c6d:deb7)
2021-10-05 00:07:18 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:641d:d2f8:a9a1:be29) (Remote host closed the connection)
2021-10-05 00:10:19 +0200yielduck(~yielduck@176.120.238.10)
2021-10-05 00:14:07 +0200 <sm> Franciman: this is boring to read
2021-10-05 00:14:30 +0200 <Franciman> what did I do, now?
2021-10-05 00:14:58 +0200 <monochrom> Ugh please don't raise the dead horse!
2021-10-05 00:15:26 +0200 <Franciman> oh you refer to the previous statements
2021-10-05 00:15:43 +0200 <geekosaur> sounds like they were catching up n backscroll
2021-10-05 00:15:49 +0200 <geekosaur> people do that
2021-10-05 00:16:05 +0200 <Franciman> sorry if i am too stupid
2021-10-05 00:18:41 +0200gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2021-10-05 00:20:13 +0200w-spc-gir(~w-spc-gir@2600:380:4710:c16:2c05:423d:6c6d:deb7) (Read error: Connection reset by peer)
2021-10-05 00:20:55 +0200w-spc-gir(~w-spc-gir@2600:380:4710:c16:2c05:423d:6c6d:deb7)
2021-10-05 00:22:21 +0200w-spc-gir(~w-spc-gir@2600:380:4710:c16:2c05:423d:6c6d:deb7) (Read error: Connection reset by peer)
2021-10-05 00:22:52 +0200w-spc-gir(~w-spc-gir@2600:380:4710:c16:2c05:423d:6c6d:deb7)
2021-10-05 00:23:01 +0200jaitoon(~Jaitoon@2a02:c7f:a5f:1d00:28c3:d6d5:1a31:67d4)
2021-10-05 00:23:04 +0200abrantesasf(~abrantesa@2804:14d:b086:4b3c:2e56:dcff:fedb:62f)
2021-10-05 00:23:42 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-05 00:24:54 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-10-05 00:25:08 +0200gay(~AdminUser@77-120-141-90.kha.volia.net)
2021-10-05 00:25:12 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2021-10-05 00:25:26 +0200w-spc-gir(~w-spc-gir@2600:380:4710:c16:2c05:423d:6c6d:deb7) (Read error: Connection reset by peer)
2021-10-05 00:25:33 +0200 <sm> +1 for no circular imports, it seems to force a certain clarity of structure
2021-10-05 00:26:12 +0200ec(~ec@gateway/tor-sasl/ec)
2021-10-05 00:26:18 +0200 <dminuoso> sm: Would you say the same if we had no letrec?
2021-10-05 00:26:20 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:905e:1e0b:7428:a16f)
2021-10-05 00:26:23 +0200 <dminuoso> And no whererec?
2021-10-05 00:26:43 +0200 <Franciman> does Core have letrec too?
2021-10-05 00:26:55 +0200w-spc-gir(~w-spc-gir@2600:380:4710:c16:2c05:423d:6c6d:deb7)
2021-10-05 00:26:56 +0200 <monochrom> Yes.
2021-10-05 00:26:58 +0200 <Franciman> or is it desugared into a particular form?
2021-10-05 00:27:07 +0200 <monochrom> No.
2021-10-05 00:27:09 +0200 <Franciman> I see, and uhm
2021-10-05 00:27:20 +0200 <Franciman> I think I already asked this, but
2021-10-05 00:27:41 +0200 <Franciman> I don't remember actually. Is there a paper explaining how core is executed?
2021-10-05 00:27:43 +0200 <Franciman> in ghc
2021-10-05 00:27:49 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 245 seconds)
2021-10-05 00:28:05 +0200 <monochrom> https://github.com/takenobu-hs/haskell-ghc-illustrated
2021-10-05 00:29:13 +0200 <Franciman> ty very much
2021-10-05 00:29:28 +0200Tuplanolla(~Tuplanoll@91-159-69-50.elisa-laajakaista.fi) (Quit: Leaving.)
2021-10-05 00:30:16 +0200 <awpr> this isn't a direct answer, but here's an entire book devoted to explaining the whole field in detail, which gives a ton of background and intuition for GHC: https://www.microsoft.com/en-us/research/publication/the-implementation-of-functional-programming-…
2021-10-05 00:30:29 +0200 <awpr> obviously a lot of progress has been made since 1987 that's not in that book :)
2021-10-05 00:30:33 +0200 <geekosaur> https://gitlab.haskell.org/ghc/ghc/-/wikis/reading-list#code-generation-and-virtual-machine
2021-10-05 00:30:55 +0200 <geekosaur> stg instead of core, but stg is what core compiles to
2021-10-05 00:31:02 +0200 <Franciman> great ty
2021-10-05 00:31:12 +0200 <Franciman> I was interested in how recursion is treated
2021-10-05 00:31:22 +0200 <Franciman> in my language I just leverage haskell's laziness
2021-10-05 00:31:23 +0200 <Franciman> and use fix
2021-10-05 00:31:27 +0200 <dminuoso> sm: Personally I feel too constrained, the style of making dedicated Types modules just to avoid having to write boot hs files.. it's a constant source of annoyance to me.
2021-10-05 00:31:31 +0200gay(~AdminUser@77-120-141-90.kha.volia.net) (Ping timeout: 252 seconds)
2021-10-05 00:31:35 +0200 <Franciman> but I think this is a bit slow
2021-10-05 00:31:59 +0200 <geekosaur> stg doesn't know about recursion /per se/; it just jumps into machine code which might jump back to where things started
2021-10-05 00:32:09 +0200 <Franciman> knowing that a recursive call calls itself, maybe can be optimized away, instead of running a normal function call
2021-10-05 00:32:31 +0200 <geekosaur> there aren't really any "normal function calls" at the stg level
2021-10-05 00:32:38 +0200 <Franciman> they all jumps, right?
2021-10-05 00:32:42 +0200 <Franciman> jumps + push stack things
2021-10-05 00:32:46 +0200 <geekosaur> you could say everything is already a tail call
2021-10-05 00:32:54 +0200 <dminuoso> Franciman: This is a tricky proposition. Optimization recursive functions is difficult, since the bread-and-butter (at least for GHC) is inlining.
2021-10-05 00:33:24 +0200 <geekosaur> you might want to start with the original stg paper to see how and why things work
2021-10-05 00:33:52 +0200 <geekosaur> there have been some modifications and optimizations since then, but they won't make much sense without an understanding of the original
2021-10-05 00:33:58 +0200 <dminuoso> After/during the paper, you might also find this helpful https://hackage.haskell.org/package/stgi
2021-10-05 00:34:09 +0200 <monochrom> At a low level like this, there is no need to avoid self-references, in fact it is clearer to let self-references be self-references. And TCO is also pretty easy at this level.
2021-10-05 00:34:38 +0200 <Franciman> thanks for that, dminuoso
2021-10-05 00:34:53 +0200 <monochrom> Whereas, by contrast, for example, if you "compile" self-references to the Y combinator, you are making things worse for all purposes.
2021-10-05 00:35:21 +0200 <monochrom> Right? Machine codes aren't afraid of self-references.
2021-10-05 00:35:33 +0200 <Franciman> I feel a bit lost
2021-10-05 00:35:34 +0200 <dminuoso> monochrom: Reminds me of how recursion schemes tend to make a real dent in performance. :)
2021-10-05 00:35:39 +0200 <geekosaur> (said original stg paper being "the spineless tagless g-machine"_
2021-10-05 00:35:45 +0200w-spc-gir(~w-spc-gir@2600:380:4710:c16:2c05:423d:6c6d:deb7) (Read error: Connection reset by peer)
2021-10-05 00:35:48 +0200cjb(~cjb@user/cjb)
2021-10-05 00:36:09 +0200w-spc-gir(~w-spc-gir@2600:380:4710:c16:2c05:423d:6c6d:deb7)
2021-10-05 00:36:25 +0200 <geekosaur> and evaluation in haskell is more about graph reduction (the "g" in stg) than function calls
2021-10-05 00:36:43 +0200 <Franciman> because of laziness, I reckon
2021-10-05 00:36:48 +0200 <geekosaur> yes
2021-10-05 00:37:02 +0200 <geekosaur> this is basically how you have to implement laziness
2021-10-05 00:37:04 +0200 <awpr> (the SPJ book I linked gives a good intuition for how this sort of graph reduction works and what drives it, without some of the complexities of current Haskell)
2021-10-05 00:37:05 +0200w-spc-gir(~w-spc-gir@2600:380:4710:c16:2c05:423d:6c6d:deb7) (Read error: Connection reset by peer)
2021-10-05 00:37:31 +0200 <Franciman> thank you all for the interesting details you shared
2021-10-05 00:37:42 +0200 <Franciman> I am getting furiously mad, because my interpreter is slower than PHP lol
2021-10-05 00:37:49 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 245 seconds)
2021-10-05 00:37:52 +0200 <Franciman> so I was trying to understand how real functional languages do recursion
2021-10-05 00:38:15 +0200 <Franciman> what I implemented is a SECD machine
2021-10-05 00:38:39 +0200 <monochrom> "interpreter" vs "compiler" also makes a big difference.
2021-10-05 00:38:40 +0200w-spc-gir(~w-spc-gir@2601:646:9c00:594c:bc3a:4a61:1dc8:3137)
2021-10-05 00:39:04 +0200 <monochrom> I dare say that for recursion, compiling is easier.
2021-10-05 00:39:27 +0200 <monochrom> Way easier. ASM already supports it natively.
2021-10-05 00:39:48 +0200 <dminuoso> Franciman: In a way, Haskell was a test bed on how to make a lazy functional programming language. It took decades and the combined efforts of many dozens of people to make it fast.
2021-10-05 00:39:52 +0200 <monochrom> Both cyclic data and cyclic jumps and cyclic jsrs.
2021-10-05 00:40:46 +0200 <monochrom> But interpreter? My http://www.cs.utoronto.ca/~trebla/CSCC24-2021-Summer/09-semantics-1.html#letrec is my simplest attempt, and it is still not simple.
2021-10-05 00:41:19 +0200 <dminuoso> monochrom: Question: what is the distinction between a compiler and interpreter in Haskell?
2021-10-05 00:41:40 +0200 <dminuoso> Is the spineless tagless G machine not a conceptual interpreter?
2021-10-05 00:42:07 +0200 <Franciman> monochrom: if you use haskell's laziness you can get better than that
2021-10-05 00:42:24 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-05 00:42:24 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-05 00:42:24 +0200wroathe(~wroathe@user/wroathe)
2021-10-05 00:42:34 +0200 <Franciman> by creating this: https://github.com/Franciman/ellipse/blob/stable/src/Eval.hs#L78
2021-10-05 00:42:39 +0200 <Franciman> you can bind yourself
2021-10-05 00:42:43 +0200 <Franciman> when creating yourself
2021-10-05 00:42:52 +0200 <Franciman> thanks to laziness, so you don't have to do it at each app :)
2021-10-05 00:43:05 +0200 <monochrom> Oh, my previous version did that. Students had much trouble.
2021-10-05 00:43:34 +0200 <Franciman> a simpler way requires mutation
2021-10-05 00:43:47 +0200 <Franciman> you put a Loop argument as first bound value
2021-10-05 00:43:49 +0200 <Franciman> it means loop forever
2021-10-05 00:43:54 +0200 <Franciman> after evaluating the body
2021-10-05 00:43:58 +0200 <Franciman> you change that first argument to itself
2021-10-05 00:44:19 +0200 <Franciman> where itself is a pointer to the evaluated body, now
2021-10-05 00:44:20 +0200 <Franciman> ol
2021-10-05 00:44:28 +0200mastarija(~mastarija@31.217.25.149) (Quit: Leaving)
2021-10-05 00:44:37 +0200 <Franciman> that's the way I learnt in the little schemer
2021-10-05 00:44:40 +0200 <Franciman> i think
2021-10-05 00:45:34 +0200 <Franciman> +1 to dminuoso question
2021-10-05 00:45:53 +0200 <Franciman> dminuoso: my understanding was that after the STG you compile to Cmm
2021-10-05 00:45:59 +0200 <Franciman> and then to code
2021-10-05 00:46:04 +0200 <Franciman> that's the only additional step
2021-10-05 00:46:08 +0200 <monochrom> Yeah I think that there is a big difference but I have to think how to articulate it.
2021-10-05 00:46:28 +0200 <Franciman> what you compile is the evaluation process of the STG
2021-10-05 00:47:03 +0200 <geekosaur> I think that's not actually the question. dminuoso is asking is whether the code that implements the STG representation of the program is in some sense interpreted
2021-10-05 00:47:12 +0200 <geekosaur> and one can indeed argue for that virewpoint
2021-10-05 00:47:22 +0200 <geekosaur> it's interpreting a graph, by reducing it
2021-10-05 00:47:25 +0200 <awpr> to me a compiler is about translating a language to another (usually lower-level) one. if you suppose STG were interpreting bytecode, GHC would still be a compiler, it would just be compiling to an interpreted target
2021-10-05 00:47:29 +0200 <monochrom> Perhaps my answer is asking back "have you written an STG interpreter?"
2021-10-05 00:47:49 +0200w-spc-gir(~w-spc-gir@2601:646:9c00:594c:bc3a:4a61:1dc8:3137) (Read error: Connection reset by peer)
2021-10-05 00:48:08 +0200dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be) (Quit: WeeChat 3.2)
2021-10-05 00:48:32 +0200 <dminuoso> geekosaur: Indeed, that was my thought.
2021-10-05 00:49:17 +0200w-spc-gir(~w-spc-gir@2601:646:9c00:594c:bc3a:4a61:1dc8:3137)
2021-10-05 00:49:36 +0200 <dolio> Does that mean that a compiler that outputs x86 isn't a compiler, because you could make an x86 interpreter?
2021-10-05 00:50:04 +0200 <geekosaur> is javac a compiler?
2021-10-05 00:50:07 +0200 <shapr> ed wrote one of those once
2021-10-05 00:50:26 +0200 <geekosaur> for that matter, there's the reduceron. so is ghc a compiler?
2021-10-05 00:50:38 +0200 <awpr> dolio: is that responding to my comment? I was suggesting exactly the opposite, that a compiler is still a compiler regardless of whether its target is or can be interpreted
2021-10-05 00:50:46 +0200 <geekosaur> (kinda reverse logic there)
2021-10-05 00:51:18 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 00:51:20 +0200w-spc-gir(~w-spc-gir@2601:646:9c00:594c:bc3a:4a61:1dc8:3137) (Read error: Connection reset by peer)
2021-10-05 00:51:33 +0200 <Franciman> a compiler is something that can't say a program terminates every time it does
2021-10-05 00:51:37 +0200 <Franciman> while an interpreter can do it
2021-10-05 00:51:40 +0200 <dolio> awpr: I don't think so.
2021-10-05 00:51:41 +0200 <geekosaur> the question of "compiler or interpreter?" has become a lot more nuanced since the 90s
2021-10-05 00:51:47 +0200oxide(~lambda@user/oxide) (Quit: oxide)
2021-10-05 00:52:02 +0200 <Franciman> so compilers for dependent types are interpreters *game-over*
2021-10-05 00:52:08 +0200 <geekosaur> s/90s/early &/
2021-10-05 00:52:49 +0200bitmapper(~user@142.134.87.154)
2021-10-05 00:52:50 +0200 <awpr> total languages cannot have compilers?
2021-10-05 00:53:03 +0200 <Franciman> ahah right
2021-10-05 00:53:26 +0200 <awpr> it's an interesting litmus test though, for Turing-complete languages
2021-10-05 00:53:36 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-05 00:54:30 +0200 <Franciman> well a simpler answer is that a compiler produces code
2021-10-05 00:54:34 +0200 <dolio> Compilers for a dependently typed language probably need interpreters, but the interpreter might not even be using the same semantics per se as the compiler is using for translation.
2021-10-05 00:54:36 +0200 <Franciman> an interpreter does not do it necessarily
2021-10-05 00:54:36 +0200 <awpr> and it's also interesting that one of the harder things about a dependent type checker is that it has to include an interpreter (or be capable of executing its own compiled code)
2021-10-05 00:54:37 +0200vysn(~vysn@user/vysn) (Ping timeout: 252 seconds)
2021-10-05 00:54:59 +0200w-spc-gir(~w-spc-gir@2601:646:9c00:594c:bc3a:4a61:1dc8:3137)
2021-10-05 00:55:07 +0200 <awpr> yeah, compiler outputs another representation of the program, while an interpreter produces the results of executing the program
2021-10-05 00:55:35 +0200 <geekosaur> now let me complicate that one: is runhaskell an interpreter?
2021-10-05 00:55:41 +0200 <monochrom> OK I see. You have to accept self-references somewhere. But it looks like a human thinking in terms of ASM has no trouble accepting that self-referencing jmps or jsrs or data are first-class, whereas a human thinking in terms of "how to explain Haskell by Haskell" expect more on the line of "explain recursion in more basic terms".
2021-10-05 00:55:50 +0200 <geekosaur> how about ctcr? (a tracer for C)
2021-10-05 00:56:10 +0200 <sm[i]> sorry, didn't see replies (dminuoso), the libera->matrix bridge is acting up
2021-10-05 00:56:29 +0200 <awpr> hmm. I guess it might be useful to separate "interpreter" into two contexts: as an implementation strategy, and as a use-case
2021-10-05 00:56:48 +0200 <geekosaur> for that matter, what is the answer if template haskell is involved?
2021-10-05 00:56:50 +0200 <awpr> runhaskell is an interpreter-shaped program, but it's not implemented by an interpreter (probably)
2021-10-05 00:57:10 +0200 <monochrom> My PhD supervisor was right again. You can't solve this problem, you can only transform it to someone else's problem. :)
2021-10-05 00:57:18 +0200 <sm[i]> (wow yes, #haskell:libera.chat on matrix has major delay right now)
2021-10-05 00:57:18 +0200 <geekosaur> it sort-of is, but even interpreted ghc haskell is compiled (to bytecode)
2021-10-05 00:57:35 +0200 <dminuoso> sm[i]: Dont worry, it was just seconds apart.
2021-10-05 00:57:40 +0200 <geekosaur> yeh, someone in #ghc was complaining of that earlier as well
2021-10-05 00:57:42 +0200w-spc-gir(~w-spc-gir@2601:646:9c00:594c:bc3a:4a61:1dc8:3137) (Read error: Connection reset by peer)
2021-10-05 00:57:42 +0200 <dminuoso> A lot of seconds, but still seconds.
2021-10-05 00:57:48 +0200 <sm[i]> :)
2021-10-05 00:57:49 +0200ec(~ec@gateway/tor-sasl/ec)
2021-10-05 00:57:50 +0200 <monochrom> There was a Casio calculator that implemented C by interpretation. :)
2021-10-05 00:57:50 +0200 <Franciman> well it is ieasier to avoid this dicotomy
2021-10-05 00:57:58 +0200 <Franciman> and have a spectrum as classification
2021-10-05 00:58:04 +0200 <Franciman> with interpreter and compiler on the two sides
2021-10-05 00:58:10 +0200 <Franciman> or maybe not even
2021-10-05 00:58:32 +0200 <geekosaur> ctcr, for the record, added tracing calls to a C program, compiled the result, and ran it
2021-10-05 00:59:04 +0200 <geekosaur> no interpretation involved as normally intended, but the user never sees the intervening steps
2021-10-05 00:59:21 +0200w-spc-gir(~w-spc-gir@2601:646:9c00:594c:bc3a:4a61:1dc8:3137)
2021-10-05 00:59:46 +0200 <geekosaur> and you still have javac as an edge case
2021-10-05 01:00:16 +0200 <dolio> Is it an edge case?
2021-10-05 01:00:26 +0200 <Franciman> if you put it that way, every modern compiler has some interpretation in it
2021-10-05 01:00:28 +0200 <awpr> yeah, giving up on rigid classifications seems like the only reasonable answer. "is runhaskell an interpreter?" "a little bit", "is rustc-on-wasm an interpreter?" "barely", "is python an interpreter?" "mostly"
2021-10-05 01:00:29 +0200 <Franciman> for example constant folding
2021-10-05 01:00:42 +0200 <Franciman> and to a more extreme extent, even type inference is a form of interpretation
2021-10-05 01:00:44 +0200w-spc-gir(~w-spc-gir@2601:646:9c00:594c:bc3a:4a61:1dc8:3137) (Read error: Connection reset by peer)
2021-10-05 01:00:51 +0200 <dolio> Does it not count as a compiler because the semantics of class files so closely match Java's surface syntax? :þ
2021-10-05 01:01:12 +0200 <awpr> dolio: it's an automatic code formatter
2021-10-05 01:01:13 +0200 <monochrom> haha
2021-10-05 01:01:23 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:905e:1e0b:7428:a16f) (Remote host closed the connection)
2021-10-05 01:02:00 +0200kayprish(~kayprish@46.240.130.158) (Remote host closed the connection)
2021-10-05 01:02:13 +0200w-spc-gir(~w-spc-gir@2601:646:9c00:594c:bc3a:4a61:1dc8:3137)
2021-10-05 01:02:33 +0200 <monochrom> And JIT code optimizations disqualify jre from being an interpreter. (Who writes interpreters that do code optimizations?)
2021-10-05 01:02:47 +0200 <monochrom> Conclusion: javac is an interpreter, jre is a compiler. >:)
2021-10-05 01:03:20 +0200 <geekosaur> I think raku's interpreter does JIT optimizations
2021-10-05 01:03:45 +0200max22-(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr) (Remote host closed the connection)
2021-10-05 01:03:46 +0200 <monochrom> Yeah I was just joking.
2021-10-05 01:03:47 +0200zzzyin
2021-10-05 01:06:19 +0200 <geekosaur> >> it's an automatic code formatter
2021-10-05 01:06:54 +0200 <geekosaur> I'm half tempted to claim haskell is too, since core is so relatively close to surface syntax and stg is very close to core
2021-10-05 01:06:55 +0200bitmapper(~user@142.134.87.154) (Remote host closed the connection)
2021-10-05 01:07:35 +0200 <monochrom> It is not worse than "all of them are desugarers" :)
2021-10-05 01:07:52 +0200 <dolio> Core is just an intermediate step, and it does many transforms on it.
2021-10-05 01:08:10 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 268 seconds)
2021-10-05 01:08:10 +0200 <awpr> AMD Ryzen 7 5800X is an interpreter implemented in hardware
2021-10-05 01:08:35 +0200 <awpr> or I guess it's more of a JIT compiler implemented in hardware
2021-10-05 01:08:44 +0200w-spc-gir(~w-spc-gir@2601:646:9c00:594c:bc3a:4a61:1dc8:3137) (Read error: Connection reset by peer)
2021-10-05 01:09:16 +0200 <geekosaur> so are most modern CPUs
2021-10-05 01:09:20 +0200 <monochrom> My university names its compiler course "language processors" to recognize the fact that you can have anything between a compiler and an interpreter.
2021-10-05 01:09:45 +0200 <awpr> geekosaur: yeah, I just picked the first one that came to mind
2021-10-05 01:10:06 +0200 <monochrom> And perhaps in pratice the fact that the most useful thing one learns is just going to be the parsing part.
2021-10-05 01:11:01 +0200 <monochrom> Right? How to generate asm code is very niche. But everyone wants to reinvent a markup language or a config language, so learning how to parse is of general interest.
2021-10-05 01:16:27 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2021-10-05 01:16:39 +0200sm2n_(~sm2n@user/sm2n)
2021-10-05 01:16:50 +0200sm2n(~sm2n@user/sm2n) (Ping timeout: 260 seconds)
2021-10-05 01:23:51 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Read error: Connection reset by peer)
2021-10-05 01:24:06 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-10-05 01:24:36 +0200sprout(~quassel@2a02:a467:ccd6:1:7da6:2d3:65ff:ac76) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2021-10-05 01:25:40 +0200spruit11(~quassel@2a02:a467:ccd6:1:7da6:2d3:65ff:ac76)
2021-10-05 01:25:56 +0200spruit11(~quassel@2a02:a467:ccd6:1:7da6:2d3:65ff:ac76) (Client Quit)
2021-10-05 01:26:08 +0200yinzzz
2021-10-05 01:26:50 +0200acidjnk_new(~acidjnk@p200300d0c703cb915d8b88e7bc3fb8e2.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2021-10-05 01:26:56 +0200sprout(~quassel@2a02:a467:ccd6:1:7da6:2d3:65ff:ac76)
2021-10-05 01:27:27 +0200emf_(~emf@2620:10d:c090:400::5:9346)
2021-10-05 01:30:25 +0200Eoco(~ian@x-160-94-179-157.acm.umn.edu) (Quit: WeeChat 2.3)
2021-10-05 01:30:50 +0200emf(~emf@2620:10d:c090:400::5:103e) (Ping timeout: 260 seconds)
2021-10-05 01:31:21 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 01:33:57 +0200 <dminuoso> awpr: Using different terms is only helpful if there's particularly different semantics attached to them, such that we can draw conclusions or insights from that.
2021-10-05 01:34:09 +0200 <dminuoso> Using different terms out of some, arbitrary, classification, is not.
2021-10-05 01:34:48 +0200emf_(~emf@2620:10d:c090:400::5:9346) (Quit: emf_)
2021-10-05 01:35:53 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Quit: WeeChat 3.3)
2021-10-05 01:36:07 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd)
2021-10-05 01:37:47 +0200fresheyeball(~fresheyeb@c-76-25-93-164.hsd1.co.comcast.net)
2021-10-05 01:39:37 +0200 <monochrom> Ah, speaking of names and terms...
2021-10-05 01:40:24 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-05 01:41:30 +0200 <monochrom> Our university course that covered greedy algorithms and dynamic programming, and then on to NP-hardness and uncomputability, was called "effective and efficient computing". (That was a long time ago. Now the course is split into one "algorithm design" for those algorithm techniques, and one "theory" course for the negative results.)
2021-10-05 01:42:10 +0200 <nshepperd> the possible and the practical
2021-10-05 01:42:34 +0200 <monochrom> So one day my related to a prof about my thoughts on that name: since it actually spends much more time on the bad news of NP-hardness and uncomputability, I secretly call it "ineffective and inefficient computing".
2021-10-05 01:43:20 +0200 <awpr> nah that name's already registered to the Python course
2021-10-05 01:43:30 +0200 <monochrom> The prof related back that among the profs they had an even better insider joke: "defective and deficient computing".
2021-10-05 01:44:33 +0200ec(~ec@gateway/tor-sasl/ec)
2021-10-05 01:45:04 +0200 <awpr> (tongue-in-cheek joke for its own sake, I know good results can be achieved with Python)
2021-10-05 01:45:35 +0200 <monochrom> :)
2021-10-05 01:48:21 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:905e:1e0b:7428:a16f)
2021-10-05 01:48:21 +0200dajoer(~david@user/gvx)
2021-10-05 01:52:09 +0200fresheyeball(~fresheyeb@c-76-25-93-164.hsd1.co.comcast.net) (Quit: WeeChat 2.9)
2021-10-05 01:52:30 +0200fresheyeball(~fresheyeb@c-76-25-93-164.hsd1.co.comcast.net)
2021-10-05 01:56:05 +0200abrantesasf(~abrantesa@2804:14d:b086:4b3c:2e56:dcff:fedb:62f) (Quit: Leaving)
2021-10-05 01:56:35 +0200 <monochrom> Well, the Python course, the course itself, would still get that kind of bad vibe.
2021-10-05 01:57:50 +0200 <monochrom> And it is not really about Python. It is about the 1st-year programming course, doesn't matter which language. A lot of students are going to write severely broken code that makes you feel that computing is hopeless.
2021-10-05 02:00:12 +0200d34df00d(~d34df00d@2600:1700:8c60:3a10::48)
2021-10-05 02:00:14 +0200nfd(~nfd@user/nfd) (Ping timeout: 250 seconds)
2021-10-05 02:00:39 +0200 <d34df00d> Hi!
2021-10-05 02:01:31 +0200 <hpc> it's a nice preparation for the hopelessness of actual computing :D
2021-10-05 02:02:00 +0200 <monochrom> heh
2021-10-05 02:02:06 +0200 <d34df00d> I'm trying to forbid the optimizer from inlining some `foreign import`ed effectful code. I'm trying to do that by wrapping that code into Control.Monad.Primitive.primitive with some explicit token passing, but it doesn't really work.
2021-10-05 02:03:11 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Remote host closed the connection)
2021-10-05 02:03:57 +0200 <monochrom> I would want to suggest NOINLINE, but I haven't tried that, and you probably have done and found ineffectiveness.
2021-10-05 02:04:16 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-10-05 02:04:22 +0200 <d34df00d> So, I'm trying to define a function, say, `rdtsc :: PrimMonad m => Unit -> m Word64` where `data Unit = Unit`, so that I'll get two distinct readings of rdtsc when doing `foo = r1 <- rdtsc; r2 <- rdtsc :: IO ()`
2021-10-05 02:04:47 +0200 <d34df00d> Dang, apparently my last message didn't come through.
2021-10-05 02:04:51 +0200 <d34df00d> So, I'm trying to define a function, say, `rdtsc :: PrimMonad m => Unit -> m Word64` where `data Unit = Unit`, so that I'll get two distinct readings of rdtsc when doing `foo = r1 <- rdtsc; r2 <- rdtsc :: IO ()`
2021-10-05 02:05:51 +0200gay(~quassel@77-120-141-90.kha.volia.net)
2021-10-05 02:05:59 +0200 <monochrom> Wait, "r1 <- rdtsc"? "r1 <- rdtsc Unit"?
2021-10-05 02:06:22 +0200 <d34df00d> monochrom: yep!
2021-10-05 02:06:29 +0200 <d34df00d> Sorry about that, that part was off the top of my head.
2021-10-05 02:06:41 +0200abrantesasf(~abrantesa@187.36.170.211)
2021-10-05 02:07:23 +0200sagax(~sagax_nb@user/sagax) (Remote host closed the connection)
2021-10-05 02:07:53 +0200 <d34df00d> Right now the code for rdtsc is as follows: https://paste.tomsmeding.com/zbwVV2kc
2021-10-05 02:08:23 +0200 <d34df00d> unbox and rebox just peel of and add the corresponding constructor respectively (and for Unit it's defined as mapping to 0#)
2021-10-05 02:08:50 +0200 <d34df00d> Sorry abou the names, that comes from TH and is actually a result of -ddump-splices
2021-10-05 02:09:28 +0200 <d34df00d> And, well, I get same readings of rdtsc like this, even though -ddump-simpl shows that there are two calls to rdtsc.
2021-10-05 02:10:30 +0200 <d34df00d> Curiously, if I change Unit to Int (and even if I call rdtsc as rdtsc 0, which is operationally the same), the readings actually become different.
2021-10-05 02:10:31 +0200 <dolio> It sounds like `Int# -> Word#` is the wrong type for the foreign import.
2021-10-05 02:10:33 +0200 <d34df00d> So dunno what's going on.
2021-10-05 02:11:17 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Ping timeout: 246 seconds)
2021-10-05 02:11:18 +0200 <gay> I can't implement arithmetic parser by using parsec, on input "123" it says "unexpected eof", "1+1" -> "unexpected "+"", "1 - 1" -> "unexpected " "": https://paste.tomsmeding.com/TxKF9aVQ
2021-10-05 02:11:18 +0200gay(~quassel@77-120-141-90.kha.volia.net) (Quit: No Ping reply in 180 seconds.)
2021-10-05 02:11:36 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-05 02:12:54 +0200gay(~quassel@77-120-141-90.kha.volia.net)
2021-10-05 02:13:03 +0200 <gay> I tried inserting whiteSpace and eof in code, but that didn't change the result
2021-10-05 02:13:16 +0200 <monochrom> I would double-check with the GHC devs whether "foreign import prim" is suitable for talking to I/O devices.
2021-10-05 02:13:22 +0200 <d34df00d> dolio: why?
2021-10-05 02:13:51 +0200 <dolio> Because it's not a pure function.
2021-10-05 02:14:09 +0200ec(~ec@gateway/tor-sasl/ec)
2021-10-05 02:14:28 +0200 <d34df00d> monochrom: it says it's internal and designed for primops, but it seems to be doing arbitrary assembly just fine, as long as it follows the calling convention.
2021-10-05 02:14:41 +0200 <d34df00d> Maybe it's not designed for that really, but these symptoms would be funny.
2021-10-05 02:14:54 +0200 <d34df00d> dolio: yep, but it's foreign import prim
2021-10-05 02:17:11 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.3)
2021-10-05 02:17:12 +0200 <monochrom> I would also trust more the output of -ddump-opt-cmm than -ddump-simpl. -ddump-simpl is at the wrong level of assurance.
2021-10-05 02:17:32 +0200 <monochrom> In fact -ddump-asm would have the final say on the matter.
2021-10-05 02:18:08 +0200 <nshepperd> i doubt the optimiser cares whether it's prim or not
2021-10-05 02:18:17 +0200 <monochrom> Just that I am not very good at reading asm unless I have the help of opt-cmm.
2021-10-05 02:18:59 +0200 <d34df00d> Yep, -ddump-simpl shows the function is called twice even in the case where it's being optimized away to a single call.
2021-10-05 02:19:04 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 245 seconds)
2021-10-05 02:19:07 +0200 <d34df00d> So that definitely looks wrong.
2021-10-05 02:20:08 +0200 <d34df00d> Aha, interesting.
2021-10-05 02:20:40 +0200 <d34df00d> So if I'm wrapping this prim stuff into a function that takes Int, the optimizer leaves my rdtsc as Int -> m Word64 (for the PrimMonad m and all that).
2021-10-05 02:20:47 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 02:21:09 +0200 <d34df00d> But if I'm passing a singleton type, like this Unit thing, then the optimizer turns my rdtsc into just m Word64
2021-10-05 02:21:32 +0200 <nshepperd> shouldn't you declare the type as State# s -> (# Word#, State# s #) or something
2021-10-05 02:21:34 +0200 <monochrom> gay: Does "float lexer" expect "123.0"?
2021-10-05 02:21:47 +0200 <d34df00d> nshepperd: that's what's being passed to `primitive`
2021-10-05 02:21:50 +0200 <nshepperd> or even just IO Word
2021-10-05 02:22:03 +0200 <nshepperd> i mean declare the foreign import as that
2021-10-05 02:22:06 +0200 <d34df00d> Note primitive (\token -> (# token, ... #))
2021-10-05 02:23:05 +0200 <d34df00d> I think it'll mess up calling convention.
2021-10-05 02:23:20 +0200 <d34df00d> import prim is not as smart as importing C functions, where it does the right thing when seeing IO
2021-10-05 02:23:27 +0200 <d34df00d> (at least that's my understanding)
2021-10-05 02:23:56 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd)
2021-10-05 02:24:32 +0200 <monochrom> "has_side_effects" "default = False"
2021-10-05 02:24:39 +0200mestre(~mestre@191.177.175.57)
2021-10-05 02:24:55 +0200 <monochrom> Does your rdtsc_unlifted use the default? Have you overridden it?
2021-10-05 02:25:25 +0200 <nshepperd> i see
2021-10-05 02:26:09 +0200myShoggoth(~myShoggot@97-120-70-214.ptld.qwest.net) (Ping timeout: 245 seconds)
2021-10-05 02:26:40 +0200 <monochrom> (What's that? Answer: I started from the GHC user's guide's section on foreign import prim, which has a link to the GHC developers wiki page, which has that.)
2021-10-05 02:28:16 +0200 <d34df00d> monochrom: it looks like that's an option for a primops definition.
2021-10-05 02:28:34 +0200 <d34df00d> I even tried to stick it somehow into the foreign import declaration, but to no avail.
2021-10-05 02:28:52 +0200 <monochrom> The benefit of talking to the GHC people is that, once you have explained your use case, they can quickly resolve "can it work?" and "what to watch out for".
2021-10-05 02:29:15 +0200 <monochrom> So I see no reason why one would repel that idea.
2021-10-05 02:34:08 +0200 <d34df00d> Oh! That's a good idea.
2021-10-05 02:34:15 +0200 <d34df00d> I'm forgetting there's a separate channel for ghc stuff.
2021-10-05 02:39:26 +0200emf(~emf@2620:10d:c090:400::5:addd)
2021-10-05 02:41:50 +0200 <dolio> That code is essentially just wrapping your declared-pure function in `pure`.
2021-10-05 02:45:03 +0200 <dolio> Actual IO operations with effects don't just take the token and pass the same one back, the primop they wrap receives the token and gives one back. Otherwise GHC can see through it and know that the primop doesn't appear to depend on the token, and could be reordered or deduplicated or what have you.
2021-10-05 02:47:20 +0200 <geekosaur> see also accursedUnutterablePerformIO
2021-10-05 02:48:30 +0200 <clever> geekosaur: you dare utter its name! :O
2021-10-05 02:49:31 +0200 <monochrom> voldemortPerformsIO
2021-10-05 02:49:42 +0200 <clever> :D
2021-10-05 02:50:10 +0200emf(~emf@2620:10d:c090:400::5:addd) (Ping timeout: 260 seconds)
2021-10-05 02:50:21 +0200 <gay> monochrom: yeah https://www.stackage.org/haddock/lts-18.12/parsec-3.1.14.0/src/Text-Parsec-Token.html#makeTokenPar… :(
2021-10-05 02:51:34 +0200ksqsf(~user@222.195.85.112) (Ping timeout: 245 seconds)
2021-10-05 02:51:53 +0200abrantesasf(~abrantesa@187.36.170.211) (Remote host closed the connection)
2021-10-05 02:52:41 +0200 <d34df00d> dolio: do you by any chance know if there's a way to replicate this behaviour?
2021-10-05 02:52:53 +0200abrantesasf(~abrantesa@187.36.170.211)
2021-10-05 02:53:26 +0200Psybur(~Psybur@mobile-166-170-32-197.mycingular.net) (Remote host closed the connection)
2021-10-05 02:54:01 +0200 <gay> great, this one works: term = parens lexer expr <|> try (float lexer) <|> fromIntegral <$> integer lexer
2021-10-05 02:54:10 +0200 <gay> thanks monochrom :)
2021-10-05 02:55:48 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-05 02:57:25 +0200 <monochrom> :)
2021-10-05 02:58:06 +0200Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de) (Ping timeout: 260 seconds)
2021-10-05 02:58:16 +0200mestre(~mestre@191.177.175.57) (Quit: leaving)
2021-10-05 02:59:05 +0200 <dolio> It seems like the obvious thing to try is to add the token arguments to the prim op.
2021-10-05 02:59:19 +0200ec(~ec@gateway/tor-sasl/ec)
2021-10-05 03:02:03 +0200 <monochrom> gay: Actually I wonder if you like naturalOrFloat. It looks like you have already handled unary minus separately, you probably don't mind naturalOrFloat doing just the non-negative part.
2021-10-05 03:02:38 +0200ksqsf(~user@2001:da8:d800:611:48f7:6c8c:3aee:c81a)
2021-10-05 03:07:48 +0200ksqsf(~user@2001:da8:d800:611:48f7:6c8c:3aee:c81a) (Ping timeout: 268 seconds)
2021-10-05 03:08:49 +0200 <gay> monochrom: sure, thanks: term = parens lexer expr <|> either fromIntegral id <$> naturalOrFloat lexer
2021-10-05 03:08:52 +0200abrantesasf(~abrantesa@187.36.170.211) (Remote host closed the connection)
2021-10-05 03:09:34 +0200abrantesasf(~abrantesa@187.36.170.211)
2021-10-05 03:09:43 +0200 <gay> still the parser is not correct, on "12*-1" it returns 12.0
2021-10-05 03:11:08 +0200Guest372(~xxx@47.245.54.240) (Remote host closed the connection)
2021-10-05 03:11:29 +0200abrantesasf(~abrantesa@187.36.170.211) (Remote host closed the connection)
2021-10-05 03:12:14 +0200Guest372(~xxx@47.245.54.240)
2021-10-05 03:12:24 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2021-10-05 03:12:27 +0200 <monochrom> Oh, that one you need "12* -1"
2021-10-05 03:12:37 +0200abrantesasf(~abrantesa@187.36.170.211)
2021-10-05 03:13:15 +0200 <monochrom> If you have *- it is first tokenized as one single operator called *-, and then "eh, my table of operators doesn't have that one"
2021-10-05 03:13:31 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2021-10-05 03:13:58 +0200xff0x(~xff0x@2001:1a81:52ac:b800:6148:6b8d:b98a:69f7) (Ping timeout: 260 seconds)
2021-10-05 03:15:33 +0200xff0x(~xff0x@2001:1a81:52e7:9700:e420:3d19:92c1:3ab6)
2021-10-05 03:19:30 +0200ksqsf(~user@222.195.85.112)
2021-10-05 03:20:55 +0200gentauro(~gentauro@user/gentauro) (Ping timeout: 252 seconds)
2021-10-05 03:22:16 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 03:24:24 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-05 03:27:29 +0200doyougnu(~user@c-73-25-202-122.hsd1.or.comcast.net) (Remote host closed the connection)
2021-10-05 03:27:54 +0200gentauro(~gentauro@user/gentauro)
2021-10-05 03:28:34 +0200ec(~ec@gateway/tor-sasl/ec)
2021-10-05 03:30:48 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 250 seconds)
2021-10-05 03:40:24 +0200abrantesasf(~abrantesa@187.36.170.211) (Remote host closed the connection)
2021-10-05 03:44:07 +0200xiongxin(~quassel@113.116.33.66)
2021-10-05 03:52:21 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-05 03:53:45 +0200alzgh(~alzgh@user/alzgh) (Remote host closed the connection)
2021-10-05 03:54:35 +0200infinity0(~infinity0@occupy.ecodis.net) (Ping timeout: 260 seconds)
2021-10-05 03:54:39 +0200 <gay> monochrom: with random tests on codewars it's impossible to come to correct answer when surrounding operators by whitespace (like " - - - " is gonna tell unexpected "-")
2021-10-05 03:55:46 +0200ec(~ec@gateway/tor-sasl/ec)
2021-10-05 03:56:19 +0200infinity0(~infinity0@occupy.ecodis.net)
2021-10-05 04:00:04 +0200geranim0(~geranim0@modemcable242.171-178-173.mc.videotron.ca) (Ping timeout: 252 seconds)
2021-10-05 04:01:49 +0200vicfred(~vicfred@user/vicfred) (Quit: Leaving)
2021-10-05 04:02:41 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2021-10-05 04:03:38 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-05 04:03:38 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-05 04:03:38 +0200wroathe(~wroathe@user/wroathe)
2021-10-05 04:05:23 +0200gay_(~quassel@77-120-141-90.kha.volia.net)
2021-10-05 04:05:44 +0200gay(~quassel@77-120-141-90.kha.volia.net) (Ping timeout: 245 seconds)
2021-10-05 04:05:52 +0200gay_gay
2021-10-05 04:06:08 +0200ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2021-10-05 04:07:30 +0200ec(~ec@gateway/tor-sasl/ec)
2021-10-05 04:08:53 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-10-05 04:10:01 +0200yielduck(~yielduck@176.120.238.10) (Ping timeout: 256 seconds)
2021-10-05 04:22:15 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-05 04:26:04 +0200ec(~ec@gateway/tor-sasl/ec)
2021-10-05 04:29:10 +0200justsomeguy(~justsomeg@user/justsomeguy)
2021-10-05 04:30:12 +0200gay(~quassel@77-120-141-90.kha.volia.net) (Remote host closed the connection)
2021-10-05 04:32:24 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 245 seconds)
2021-10-05 04:33:32 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-05 04:33:32 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-05 04:33:32 +0200wroathe(~wroathe@user/wroathe)
2021-10-05 04:38:30 +0200myShoggoth(~myShoggot@97-120-70-214.ptld.qwest.net)
2021-10-05 04:44:28 +0200myShoggoth(~myShoggot@97-120-70-214.ptld.qwest.net) (Ping timeout: 250 seconds)
2021-10-05 04:46:57 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-05 04:48:22 +0200ksqsf(~user@222.195.85.112) (Ping timeout: 252 seconds)
2021-10-05 04:51:14 +0200alx741(~alx741@186.178.109.65) (Quit: alx741)
2021-10-05 04:51:22 +0200myShoggoth(~myShoggot@97-120-70-214.ptld.qwest.net)
2021-10-05 04:55:43 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2021-10-05 04:57:40 +0200td_(~td@94.134.91.189) (Ping timeout: 252 seconds)
2021-10-05 04:57:53 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 246 seconds)
2021-10-05 04:59:28 +0200td_(~td@muedsl-82-207-238-165.citykom.de)
2021-10-05 04:59:52 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2021-10-05 05:02:07 +0200ksqsf(~user@2001:da8:d800:611:dc1c:d1e3:58d8:b859)
2021-10-05 05:06:19 +0200ksqsf`(~user@2001:da8:d800:611:5ca9:3d11:a6cc:5e0c)
2021-10-05 05:08:36 +0200justsomeguy(~justsomeg@user/justsomeguy) (Quit: WeeChat 3.2)
2021-10-05 05:08:43 +0200ksqsf(~user@2001:da8:d800:611:dc1c:d1e3:58d8:b859) (Ping timeout: 252 seconds)
2021-10-05 05:11:16 +0200ksqsf``(~user@2001:da8:d800:611:f834:f441:3a32:fbaf)
2021-10-05 05:11:45 +0200ksqsf`(~user@2001:da8:d800:611:5ca9:3d11:a6cc:5e0c) (Ping timeout: 268 seconds)
2021-10-05 05:11:58 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-05 05:11:58 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-05 05:11:58 +0200wroathe(~wroathe@user/wroathe)
2021-10-05 05:12:56 +0200 <juhp> Is there any tool to get haskell projects git easily? eg via hackage/.cabal
2021-10-05 05:13:44 +0200 <juhp> well I am guess the .cabal data is exposed via Cabal... but hoping someone has already done this...
2021-10-05 05:14:05 +0200 <juhp> guessing *
2021-10-05 05:14:45 +0200 <juhp> something like `cabal clone <package>`
2021-10-05 05:15:30 +0200 <int-e> this? cabal get --help
2021-10-05 05:15:45 +0200 <int-e> (there's -s)
2021-10-05 05:16:25 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2021-10-05 05:16:48 +0200ksqsf```(~user@2001:da8:d800:611:f11f:c17c:9d0c:758e)
2021-10-05 05:17:18 +0200ksqsf``(~user@2001:da8:d800:611:f834:f441:3a32:fbaf) (Ping timeout: 268 seconds)
2021-10-05 05:17:38 +0200 <juhp> ah yes indeed thanks! actually found it too, grepping the cabal-install source
2021-10-05 05:18:42 +0200 <monochrom> Yikes haha. I would "cabal --help".
2021-10-05 05:19:20 +0200 <monochrom> OK I guess maybe "cabal --help" doesn't make it obvious.
2021-10-05 05:19:25 +0200 <juhp> nod
2021-10-05 05:19:56 +0200 <juhp> Sadly the package I wanted doesn't define it's repo in .cabal, but this is good, thanks int-e :)
2021-10-05 05:20:55 +0200 <juhp> I had actually already tried cabal unpack/get --help, but was only looking for "git"... 8-)
2021-10-05 05:21:29 +0200ksqsf````(~user@2001:da8:d800:611:748e:8e1c:f663:766e)
2021-10-05 05:21:59 +0200hendursaga(~weechat@user/hendursaga) (Remote host closed the connection)
2021-10-05 05:22:35 +0200hendursaga(~weechat@user/hendursaga)
2021-10-05 05:23:17 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2021-10-05 05:23:28 +0200ksqsf```(~user@2001:da8:d800:611:f11f:c17c:9d0c:758e) (Ping timeout: 268 seconds)
2021-10-05 05:24:37 +0200 <int-e> monochrom: cabal --help mentions repositories at least... but it's a bit overwhelmning
2021-10-05 05:24:58 +0200 <int-e> (I did actually start there)
2021-10-05 05:27:10 +0200ksqsf````(~user@2001:da8:d800:611:748e:8e1c:f663:766e) (Ping timeout: 268 seconds)
2021-10-05 05:27:10 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Ping timeout: 268 seconds)
2021-10-05 05:28:01 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 05:28:18 +0200ksqsf````(~user@222.195.85.112)
2021-10-05 05:29:32 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Ping timeout: 250 seconds)
2021-10-05 05:39:15 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2021-10-05 05:39:59 +0200 <juhp> So it does
2021-10-05 05:42:05 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2021-10-05 05:46:59 +0200ksqsf````(~user@222.195.85.112) (Ping timeout: 245 seconds)
2021-10-05 05:47:04 +0200vysn(~vysn@user/vysn)
2021-10-05 05:48:02 +0200zebrag(~chris@user/zebrag) (Quit: Konversation terminated!)
2021-10-05 05:50:27 +0200ec(~ec@gateway/tor-sasl/ec)
2021-10-05 05:55:17 +0200rekahsoft(~rekahsoft@cpe0008a20f982f-cm64777d666260.cpe.net.cable.rogers.com)
2021-10-05 05:55:43 +0200ksqsf````(~user@2001:da8:d800:611:5169:401b:afaa:2ee7)
2021-10-05 05:55:45 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-05 05:55:45 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-05 05:55:45 +0200wroathe(~wroathe@user/wroathe)
2021-10-05 05:55:54 +0200lbseale_(~lbseale@user/ep1ctetus) (Read error: Connection reset by peer)
2021-10-05 05:57:40 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-10-05 06:00:25 +0200ksqsf````(~user@2001:da8:d800:611:5169:401b:afaa:2ee7) (Ping timeout: 252 seconds)
2021-10-05 06:02:19 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 268 seconds)
2021-10-05 06:04:17 +0200_ht(~quassel@82-169-194-8.biz.kpn.net)
2021-10-05 06:05:22 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2021-10-05 06:07:03 +0200cigsender(~bi_functo@192-0-134-138.cpe.teksavvy.com) (Quit: Lost terminal)
2021-10-05 06:10:12 +0200bitmapper(~bitmapper@142.134.87.154)
2021-10-05 06:12:05 +0200bitmapper(~bitmapper@142.134.87.154) (Remote host closed the connection)
2021-10-05 06:12:33 +0200slowButPresent(~slowButPr@user/slowbutpresent) (Quit: leaving)
2021-10-05 06:13:40 +0200bitmapper(~bitmapper@142.134.87.154)
2021-10-05 06:16:55 +0200infinity0(~infinity0@occupy.ecodis.net) (Ping timeout: 252 seconds)
2021-10-05 06:17:07 +0200infinity0(~infinity0@occupy.ecodis.net)
2021-10-05 06:17:49 +0200shapr(~user@pool-100-36-247-68.washdc.fios.verizon.net) (Ping timeout: 245 seconds)
2021-10-05 06:19:35 +0200rekahsoft(~rekahsoft@cpe0008a20f982f-cm64777d666260.cpe.net.cable.rogers.com) (Ping timeout: 268 seconds)
2021-10-05 06:21:56 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-05 06:21:56 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-05 06:21:56 +0200wroathe(~wroathe@user/wroathe)
2021-10-05 06:26:05 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 246 seconds)
2021-10-05 06:27:59 +0200mbuf(~Shakthi@122.162.133.48)
2021-10-05 06:29:47 +0200sm2n_(~sm2n@user/sm2n) (Read error: Connection reset by peer)
2021-10-05 06:30:12 +0200ksqsf````(~user@2001:da8:d800:611:f96c:dc2a:6bc6:fe1d)
2021-10-05 06:30:38 +0200sm2n_(~sm2n@user/sm2n)
2021-10-05 06:34:50 +0200Athas(athas@2a01:7c8:aaac:1cf:e73c:6e45:62dc:617a) (Quit: ZNC 1.8.2 - https://znc.in)
2021-10-05 06:35:00 +0200Athas(athas@sigkill.dk)
2021-10-05 06:36:43 +0200ksqsf````(~user@2001:da8:d800:611:f96c:dc2a:6bc6:fe1d) (Ping timeout: 252 seconds)
2021-10-05 06:39:57 +0200sleblanc(~sleblanc@user/sleblanc)
2021-10-05 06:45:30 +0200cjb54763(~cjb@user/cjb)
2021-10-05 06:45:30 +0200cjb54763(~cjb@user/cjb) (Client Quit)
2021-10-05 06:45:34 +0200phma(~phma@host-67-44-208-140.hnremote.net) (Read error: Connection reset by peer)
2021-10-05 06:46:29 +0200phma(~phma@host-67-44-208-158.hnremote.net)
2021-10-05 06:47:52 +0200cjb(~cjb@user/cjb) (Ping timeout: 260 seconds)
2021-10-05 06:50:02 +0200xiongxin(~quassel@113.116.33.66) (Quit: No Ping reply in 180 seconds.)
2021-10-05 06:51:18 +0200xiongxin(~quassel@113.116.33.66)
2021-10-05 06:57:37 +0200bitmapper(~bitmapper@142.134.87.154) (Ping timeout: 252 seconds)
2021-10-05 06:57:49 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 245 seconds)
2021-10-05 06:59:27 +0200endless(~endlessed@51.81.211.147)
2021-10-05 07:00:59 +0200 <endless> is there any reason to go with the '13 CIS194 over the 'slightly' newer '16 CIS164 for a Haskell beginner? I assume they're pretty much the same coursework but I always see the '13 one cited more
2021-10-05 07:02:24 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Ping timeout: 245 seconds)
2021-10-05 07:04:46 +0200myShoggoth(~myShoggot@97-120-70-214.ptld.qwest.net) (Ping timeout: 252 seconds)
2021-10-05 07:09:23 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 07:12:43 +0200chomwitt(~chomwitt@2a02:587:dc04:fc00:12c3:7bff:fe6d:d374)
2021-10-05 07:14:18 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2021-10-05 07:20:30 +0200_ht(~quassel@82-169-194-8.biz.kpn.net) (Remote host closed the connection)
2021-10-05 07:24:11 +0200Elissa21F(~KELEBEK@95.70.207.107)
2021-10-05 07:24:15 +0200Elissa21F(~KELEBEK@95.70.207.107) (K-Lined)
2021-10-05 07:28:18 +0200 <c_wraith> endless: I haven't looked at them both, but I've heard that people who have thinkg '13 was presented a bit better.
2021-10-05 07:32:11 +0200quasisyntaxed(~user@2804:1b2:83:4cd5:4823:3e85:f547:9207) (Remote host closed the connection)
2021-10-05 07:37:23 +0200raym(~raym@user/raym) (Quit: kernel update, rebooting...)
2021-10-05 07:40:30 +0200michalz(~michalz@185.246.204.93)
2021-10-05 07:46:15 +0200pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net)
2021-10-05 07:49:53 +0200pfurla_(~pfurla@ool-182ed2e2.dyn.optonline.net) (Ping timeout: 264 seconds)
2021-10-05 07:53:10 +0200xiongxin(~quassel@113.116.33.66) (Ping timeout: 252 seconds)
2021-10-05 07:53:19 +0200chomwitt(~chomwitt@2a02:587:dc04:fc00:12c3:7bff:fe6d:d374) (Ping timeout: 268 seconds)
2021-10-05 07:54:28 +0200rembo10(~rembo10@65.108.80.86) (Quit: ZNC 1.8.2 - https://znc.in)
2021-10-05 07:56:21 +0200rembo10(~rembo10@remulis.com)
2021-10-05 07:58:27 +0200notzmv(~zmv@user/notzmv) (Ping timeout: 240 seconds)
2021-10-05 07:58:37 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 07:59:10 +0200_xor(~xor@74.215.232.67) (Ping timeout: 252 seconds)
2021-10-05 08:00:40 +0200ubert(~Thunderbi@178.115.39.222.wireless.dyn.drei.com)
2021-10-05 08:03:24 +0200Times_(~Times@180.248.30.254)
2021-10-05 08:03:52 +0200 <Times_> https://www.bitchute.com/video/rUr0pnlyWRpD/
2021-10-05 08:09:25 +0200ubert1(~Thunderbi@178.115.39.222.wireless.dyn.drei.com)
2021-10-05 08:11:07 +0200jakalx(~jakalx@base.jakalx.net) ()
2021-10-05 08:12:36 +0200 <dminuoso> endless: I find the differences are miniscule in terms of quality.
2021-10-05 08:12:58 +0200zmt00(~zmt00@user/zmt00) (Ping timeout: 252 seconds)
2021-10-05 08:13:06 +0200 <dminuoso> I personally preferred the newer version by Joachim Breitner, but Brent Yorgeys course is great too.
2021-10-05 08:13:24 +0200 <dminuoso> I think this one is highly subjective
2021-10-05 08:13:44 +0200jakalx(~jakalx@base.jakalx.net)
2021-10-05 08:14:24 +0200Times_(~Times@180.248.30.254) (Remote host closed the connection)
2021-10-05 08:15:44 +0200timCF(~timCF@m91-129-108-244.cust.tele2.ee) (Ping timeout: 245 seconds)
2021-10-05 08:20:04 +0200pippijn(~pippijn@ra.xinutec.org) (Ping timeout: 252 seconds)
2021-10-05 08:22:47 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:3ebf:673e:c737:b48)
2021-10-05 08:26:50 +0200pippijn(~pippijn@ra.xinutec.org)
2021-10-05 08:30:59 +0200neurocyte013288(~neurocyte@45.10.63.237)
2021-10-05 08:30:59 +0200neurocyte013288(~neurocyte@45.10.63.237) (Changing host)
2021-10-05 08:30:59 +0200neurocyte013288(~neurocyte@user/neurocyte)
2021-10-05 08:31:17 +0200xiongxin(~quassel@113.116.35.70)
2021-10-05 08:32:46 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-10-05 08:44:11 +0200chomwitt(~chomwitt@ppp-2-85-111-14.home.otenet.gr)
2021-10-05 08:47:20 +0200 <Franciman> awpr: a simpler line of division between compiler and interpreter could be: a compiler won't execute IO actions of your program
2021-10-05 08:49:00 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2021-10-05 08:49:19 +0200gehmehgeh(~user@user/gehmehgeh)
2021-10-05 09:00:02 +0200Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de)
2021-10-05 09:00:37 +0200cfricke(~cfricke@user/cfricke)
2021-10-05 09:04:38 +0200cfricke(~cfricke@user/cfricke) (Ping timeout: 246 seconds)
2021-10-05 09:06:22 +0200cfricke(~cfricke@user/cfricke)
2021-10-05 09:11:49 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 252 seconds)
2021-10-05 09:13:12 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 09:13:18 +0200noctux(~noctux@user/noctux) (Read error: Connection reset by peer)
2021-10-05 09:13:25 +0200noctux(~noctux@user/noctux)
2021-10-05 09:15:19 +0200Maxdamantus(~Maxdamant@user/maxdamantus) (Ping timeout: 245 seconds)
2021-10-05 09:16:28 +0200Maxdamantus(~Maxdamant@user/maxdamantus)
2021-10-05 09:17:21 +0200chele(~chele@user/chele)
2021-10-05 09:17:23 +0200 <lortabac> is there a benchmark of Haskell parser libraries somewhere?
2021-10-05 09:17:45 +0200 <lortabac> I would like to know how slower Earley is compared to megaparsec
2021-10-05 09:17:49 +0200dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be)
2021-10-05 09:20:53 +0200Techcable_(~Techcable@168.235.93.147) (Quit: ZNC - https://znc.in)
2021-10-05 09:22:45 +0200VoidNoir0(~VoidNoir0@72.80.203.52) (Quit: Ping timeout (120 seconds))
2021-10-05 09:23:18 +0200Techcable(~Techcable@168.235.93.147)
2021-10-05 09:23:55 +0200max22-(~maxime@2a01cb0883359800777e1cc5db01489a.ipv6.abo.wanadoo.fr)
2021-10-05 09:27:53 +0200bontaq(~user@ool-45779fe5.dyn.optonline.net)
2021-10-05 09:29:36 +0200xff0x(~xff0x@2001:1a81:52e7:9700:e420:3d19:92c1:3ab6) (Ping timeout: 250 seconds)
2021-10-05 09:30:35 +0200xff0x(~xff0x@2001:1a81:52e7:9700:61a3:64f7:247a:92b0)
2021-10-05 09:30:40 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 09:32:33 +0200_xor(~xor@72.49.199.147)
2021-10-05 09:36:10 +0200 <[exa]> lortabac: I'd say that it depends so much on the parsed language that no one really cared systematically. There were some comparisons linked from megaparsec but I guess these don't include earley
2021-10-05 09:37:32 +0200ub(~Thunderbi@178.115.35.209.wireless.dyn.drei.com)
2021-10-05 09:38:13 +0200ubert1(~Thunderbi@178.115.39.222.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-10-05 09:38:35 +0200max22-(~maxime@2a01cb0883359800777e1cc5db01489a.ipv6.abo.wanadoo.fr) (Ping timeout: 246 seconds)
2021-10-05 09:38:36 +0200 <[exa]> honestly I wouldn't expect it to be faster than mega/atto parsecs unless you parse something that works brutally bad with descent parsers
2021-10-05 09:38:39 +0200ubert(~Thunderbi@178.115.39.222.wireless.dyn.drei.com) (Ping timeout: 245 seconds)
2021-10-05 09:38:40 +0200ububert
2021-10-05 09:39:36 +0200 <[exa]> oh man but Earley package _is_ nice.
2021-10-05 09:43:36 +0200charukiewicz(~quassel@108.210.196.136) (Quit: No Ping reply in 180 seconds.)
2021-10-05 09:44:59 +0200charukiewicz(~quassel@2600:1702:a90:2750::43)
2021-10-05 09:48:21 +0200shriekingnoise(~shrieking@186.137.144.80) (Quit: Quit)
2021-10-05 09:51:42 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 250 seconds)
2021-10-05 09:58:41 +0200acidjnk_new(~acidjnk@pd9e0b933.dip0.t-ipconnect.de)
2021-10-05 09:59:22 +0200econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2021-10-05 10:00:13 +0200xff0x(~xff0x@2001:1a81:52e7:9700:61a3:64f7:247a:92b0) (Ping timeout: 252 seconds)
2021-10-05 10:00:46 +0200xff0x(~xff0x@2001:1a81:52e7:9700:28e9:b1f6:45e5:1183)
2021-10-05 10:01:52 +0200vjoki(~vjoki@2a00:d880:3:1::fea1:9ae) (Ping timeout: 252 seconds)
2021-10-05 10:03:14 +0200rkrishnan(~user@2402:e280:215c:2cd:9500:c2fe:49e8:e5f7)
2021-10-05 10:06:01 +0200hendursa1(~weechat@user/hendursaga)
2021-10-05 10:06:15 +0200vjoki(~vjoki@2a00:d880:3:1::fea1:9ae)
2021-10-05 10:08:44 +0200sagax(~sagax_nb@user/sagax)
2021-10-05 10:09:21 +0200hendursaga(~weechat@user/hendursaga) (Ping timeout: 276 seconds)
2021-10-05 10:12:39 +0200ByronJohnson(~bairyn@mail.digitalkingdom.org) (*.net *.split)
2021-10-05 10:12:39 +0200hgolden(~hgolden2@cpe-172-114-81-123.socal.res.rr.com) (*.net *.split)
2021-10-05 10:12:40 +0200rtjure(~rtjure@bras-79-132-17-74.comnet.bg) (*.net *.split)
2021-10-05 10:12:40 +0200dolio(~dolio@130.44.130.54) (*.net *.split)
2021-10-05 10:12:40 +0200jinsun(~quassel@user/jinsun) (*.net *.split)
2021-10-05 10:12:40 +0200jrm(~jrm@156.34.187.65) (*.net *.split)
2021-10-05 10:12:40 +0200p3n(~p3n@217.198.124.246) (*.net *.split)
2021-10-05 10:12:40 +0200poljar(~poljar@93-139-113-226.adsl.net.t-com.hr) (*.net *.split)
2021-10-05 10:12:40 +0200tcard(~tcard@p2307053-ipngn17101hodogaya.kanagawa.ocn.ne.jp) (*.net *.split)
2021-10-05 10:12:40 +0200TheCoffeMaker(~TheCoffeM@user/thecoffemaker) (*.net *.split)
2021-10-05 10:12:40 +0200terrorjack(~terrorjac@static.3.200.12.49.clients.your-server.de) (*.net *.split)
2021-10-05 10:12:40 +0200tdammers(~tdammers@77.109.72.177.res.static.edpnet.net) (*.net *.split)
2021-10-05 10:12:40 +0200justache(~justache@user/justache) (*.net *.split)
2021-10-05 10:12:40 +0200Nahra``(~user@static.161.95.99.88.clients.your-server.de) (*.net *.split)
2021-10-05 10:12:40 +0200do(~do@159.89.11.133) (*.net *.split)
2021-10-05 10:12:40 +0200gnyeki(~gnyeki@user/gnyeki) (*.net *.split)
2021-10-05 10:12:40 +0200AlexZenon(~alzenon@178.34.162.155) (*.net *.split)
2021-10-05 10:12:40 +0200mmarusea1ph2(~mihai@198.199.100.72) (*.net *.split)
2021-10-05 10:12:40 +0200CnnibisIndica(~herb@user/mesaboogie) (*.net *.split)
2021-10-05 10:12:40 +0200erisco(~erisco@d24-57-249-233.home.cgocable.net) (*.net *.split)
2021-10-05 10:12:40 +0200piele(~piele@tbonesteak.creativeserver.net) (*.net *.split)
2021-10-05 10:12:40 +0200Alex_test(~al_test@178.34.162.155) (*.net *.split)
2021-10-05 10:12:40 +0200tchakka_(~tchakkazu@static-47-180-28-65.lsan.ca.frontiernet.net) (*.net *.split)
2021-10-05 10:12:40 +0200cods(~fred@82-65-232-44.subs.proxad.net) (*.net *.split)
2021-10-05 10:12:40 +0200Jonno_FT1(~come@api.carswap.me) (*.net *.split)
2021-10-05 10:12:40 +0200m5zs7k(aquares@web10.mydevil.net) (*.net *.split)
2021-10-05 10:12:40 +0200dysfigured(~dfg@li490-89.members.linode.com) (*.net *.split)
2021-10-05 10:12:40 +0200martin02(~silas@141.84.69.76) (*.net *.split)
2021-10-05 10:12:40 +0200turlando(~turlando@user/turlando) (*.net *.split)
2021-10-05 10:12:40 +0200slep(~slep@cpc150002-brnt4-2-0-cust437.4-2.cable.virginm.net) (*.net *.split)
2021-10-05 10:12:41 +0200mniip(mniip@libera/staff/mniip) (*.net *.split)
2021-10-05 10:12:41 +0200tureba(~tureba@tureba.org) (*.net *.split)
2021-10-05 10:12:41 +0200sshine(~simon@hubris.eta.solutions) (*.net *.split)
2021-10-05 10:12:41 +0200elcaro(~anonymous@45.32.191.75) (*.net *.split)
2021-10-05 10:12:41 +0200samebchase(~thelounge@51.15.68.182) (*.net *.split)
2021-10-05 10:17:37 +0200allbery_b(~geekosaur@xmonad/geekosaur)
2021-10-05 10:17:37 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Killed (NickServ (GHOST command used by allbery_b)))
2021-10-05 10:17:40 +0200allbery_bgeekosaur
2021-10-05 10:18:57 +0200notzmv(~zmv@user/notzmv)
2021-10-05 10:19:05 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 10:20:16 +0200mniip(mniip@libera/staff/mniip)
2021-10-05 10:24:24 +0200ByronJohnson(~bairyn@mail.digitalkingdom.org)
2021-10-05 10:24:24 +0200hgolden(~hgolden2@cpe-172-114-81-123.socal.res.rr.com)
2021-10-05 10:24:24 +0200rtjure(~rtjure@bras-79-132-17-74.comnet.bg)
2021-10-05 10:24:24 +0200dolio(~dolio@130.44.130.54)
2021-10-05 10:24:24 +0200jinsun(~quassel@user/jinsun)
2021-10-05 10:24:24 +0200jrm(~jrm@156.34.187.65)
2021-10-05 10:24:24 +0200p3n(~p3n@217.198.124.246)
2021-10-05 10:24:24 +0200poljar(~poljar@93-139-113-226.adsl.net.t-com.hr)
2021-10-05 10:24:24 +0200tcard(~tcard@p2307053-ipngn17101hodogaya.kanagawa.ocn.ne.jp)
2021-10-05 10:24:24 +0200TheCoffeMaker(~TheCoffeM@user/thecoffemaker)
2021-10-05 10:24:24 +0200terrorjack(~terrorjac@static.3.200.12.49.clients.your-server.de)
2021-10-05 10:24:24 +0200tdammers(~tdammers@77.109.72.177.res.static.edpnet.net)
2021-10-05 10:24:24 +0200justache(~justache@user/justache)
2021-10-05 10:24:24 +0200Nahra``(~user@static.161.95.99.88.clients.your-server.de)
2021-10-05 10:24:24 +0200do(~do@159.89.11.133)
2021-10-05 10:24:24 +0200gnyeki(~gnyeki@user/gnyeki)
2021-10-05 10:24:24 +0200AlexZenon(~alzenon@178.34.162.155)
2021-10-05 10:24:24 +0200mmarusea1ph2(~mihai@198.199.100.72)
2021-10-05 10:24:24 +0200CnnibisIndica(~herb@user/mesaboogie)
2021-10-05 10:24:24 +0200erisco(~erisco@d24-57-249-233.home.cgocable.net)
2021-10-05 10:24:24 +0200piele(~piele@tbonesteak.creativeserver.net)
2021-10-05 10:24:24 +0200Alex_test(~al_test@178.34.162.155)
2021-10-05 10:24:24 +0200tchakka_(~tchakkazu@static-47-180-28-65.lsan.ca.frontiernet.net)
2021-10-05 10:24:24 +0200cods(~fred@82-65-232-44.subs.proxad.net)
2021-10-05 10:24:24 +0200Jonno_FT1(~come@api.carswap.me)
2021-10-05 10:24:24 +0200m5zs7k(aquares@web10.mydevil.net)
2021-10-05 10:24:24 +0200dysfigured(~dfg@li490-89.members.linode.com)
2021-10-05 10:24:24 +0200martin02(~silas@141.84.69.76)
2021-10-05 10:24:24 +0200turlando(~turlando@user/turlando)
2021-10-05 10:24:24 +0200slep(~slep@cpc150002-brnt4-2-0-cust437.4-2.cable.virginm.net)
2021-10-05 10:24:24 +0200tureba(~tureba@tureba.org)
2021-10-05 10:24:24 +0200sshine(~simon@hubris.eta.solutions)
2021-10-05 10:24:24 +0200elcaro(~anonymous@45.32.191.75)
2021-10-05 10:24:24 +0200samebchase(~thelounge@51.15.68.182)
2021-10-05 10:24:25 +0200d34df00d(~d34df00d@2600:1700:8c60:3a10::48) (Excess Flood)
2021-10-05 10:25:21 +0200justache(~justache@user/justache) (Max SendQ exceeded)
2021-10-05 10:25:30 +0200terrorjack(~terrorjac@static.3.200.12.49.clients.your-server.de) (Max SendQ exceeded)
2021-10-05 10:26:17 +0200justache(~justache@user/justache)
2021-10-05 10:26:36 +0200terrorjack(~terrorjac@static.3.200.12.49.clients.your-server.de)
2021-10-05 10:30:17 +0200hnOsmium0001(uid453710@id-453710.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-10-05 10:33:18 +0200tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2021-10-05 10:34:26 +0200Everything(~Everythin@37.115.210.35)
2021-10-05 10:36:23 +0200betelgeuse(~betelgeus@94-225-47-8.access.telenet.be) (Quit: The Lounge - https://thelounge.chat)
2021-10-05 10:39:49 +0200Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de) (Ping timeout: 252 seconds)
2021-10-05 10:42:28 +0200 <hololeap> I'm a little surprised more Applicatives don't just throw in `deriving (Semigroup,Monoid) via Ap MyApplicative` for convenience
2021-10-05 10:51:53 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-10-05 10:51:56 +0200xiongxin(~quassel@113.116.35.70) (Ping timeout: 250 seconds)
2021-10-05 10:53:26 +0200cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.2.1)
2021-10-05 10:53:38 +0200cfricke(~cfricke@user/cfricke)
2021-10-05 10:54:11 +0200max22-(~maxime@2a01cb08833598008bbf230aeaa6be66.ipv6.abo.wanadoo.fr)
2021-10-05 10:56:39 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:905e:1e0b:7428:a16f) (Remote host closed the connection)
2021-10-05 10:59:29 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 245 seconds)
2021-10-05 11:00:10 +0200xff0x(~xff0x@2001:1a81:52e7:9700:28e9:b1f6:45e5:1183) (Ping timeout: 252 seconds)
2021-10-05 11:00:58 +0200xff0x(~xff0x@2001:1a81:52e7:9700:93c6:a799:3451:f8cc)
2021-10-05 11:03:06 +0200azeem(~azeem@2a00:801:2d3:fa49:9002:1b34:5306:e795) (Read error: Connection reset by peer)
2021-10-05 11:06:02 +0200azeem(~azeem@emp-183-4.eduroam.uu.se)
2021-10-05 11:11:24 +0200mc47(~mc47@xmonad/TheMC47)
2021-10-05 11:13:44 +0200mestre(~mestre@191.177.175.57)
2021-10-05 11:17:05 +0200kuribas(~user@ptr-25vy0i6xitwnblcgfls.18120a2.ip6.access.telenet.be)
2021-10-05 11:24:48 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-10-05 11:25:36 +0200unmanbearpig(~unmanbear@user/unmanbearpig)
2021-10-05 11:28:55 +0200FragByte(~christian@user/fragbyte) (Quit: Quit)
2021-10-05 11:30:42 +0200FragByte(~christian@user/fragbyte)
2021-10-05 11:31:11 +0200chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2021-10-05 11:31:21 +0200chexum(~quassel@gateway/tor-sasl/chexum)
2021-10-05 11:48:34 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 252 seconds)
2021-10-05 11:49:49 +0200__monty__(~toonn@user/toonn)
2021-10-05 11:50:26 +0200xff0x(~xff0x@2001:1a81:52e7:9700:93c6:a799:3451:f8cc) (Ping timeout: 250 seconds)
2021-10-05 11:57:37 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81d:7133:81c9:b91d)
2021-10-05 11:58:27 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 11:59:32 +0200hexfive(~eric@50.35.83.177)
2021-10-05 12:01:09 +0200chomwitt(~chomwitt@ppp-2-85-111-14.home.otenet.gr) (Ping timeout: 245 seconds)
2021-10-05 12:01:44 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81d:7133:81c9:b91d) (Ping timeout: 246 seconds)
2021-10-05 12:02:53 +0200hexfive(~eric@50.35.83.177) (Client Quit)
2021-10-05 12:09:51 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 268 seconds)
2021-10-05 12:12:47 +0200xff0x(~xff0x@2001:1a81:52e7:9700:5d5e:8dcc:4bf7:bd5f)
2021-10-05 12:18:26 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 12:21:28 +0200akegalj(~akegalj@93-136-79-174.adsl.net.t-com.hr)
2021-10-05 12:22:21 +0200alzgh(~alzgh@user/alzgh)
2021-10-05 12:27:04 +0200terrorjack(~terrorjac@static.3.200.12.49.clients.your-server.de) (Quit: The Lounge - https://thelounge.chat)
2021-10-05 12:27:37 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2021-10-05 12:27:57 +0200__monty__(~toonn@user/toonn)
2021-10-05 12:28:07 +0200terrorjack(~terrorjac@static.3.200.12.49.clients.your-server.de)
2021-10-05 12:29:29 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-10-05 12:30:41 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 12:35:44 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-10-05 12:36:43 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 12:40:42 +0200darkstarx(~darkstard@2601:1c2:300:c8a0::f2b6) (Ping timeout: 250 seconds)
2021-10-05 12:41:47 +0200darkstardevx(~darkstard@c-24-21-53-33.hsd1.or.comcast.net)
2021-10-05 12:41:59 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-10-05 12:42:27 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 12:44:05 +0200acidjnk_new(~acidjnk@pd9e0b933.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2021-10-05 12:47:24 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-10-05 12:47:48 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 12:52:49 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-10-05 12:53:30 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 12:57:10 +0200enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7)
2021-10-05 12:58:39 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-10-05 12:58:43 +0200CiaoSen(~Jura@p200300c9571e34002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2021-10-05 12:59:13 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 12:59:24 +0200OscarH(~OscarH@90.201.86.195) (Ping timeout: 268 seconds)
2021-10-05 13:00:44 +0200alx741(~alx741@186.178.109.65)
2021-10-05 13:02:37 +0200OscarH(~OscarH@2a02:c7f:a0da:ae00:ba27:ebff:fe84:d2f4)
2021-10-05 13:04:29 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-10-05 13:05:12 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 13:06:00 +0200cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.2.1)
2021-10-05 13:06:06 +0200DNH(~DNH@2a02:8108:1100:16d8:d1f8:65da:debb:16ba)
2021-10-05 13:06:25 +0200OscarH_(~OscarH@90.201.86.195)
2021-10-05 13:07:13 +0200OscarH(~OscarH@2a02:c7f:a0da:ae00:ba27:ebff:fe84:d2f4) (Ping timeout: 252 seconds)
2021-10-05 13:10:19 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-10-05 13:10:54 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 13:11:28 +0200AlexNoo_(~AlexNoo@94.233.240.2)
2021-10-05 13:12:43 +0200chomwitt(~chomwitt@94.66.61.137)
2021-10-05 13:12:57 +0200geranim0(~geranim0@modemcable242.171-178-173.mc.videotron.ca)
2021-10-05 13:13:46 +0200AlexZenon(~alzenon@178.34.162.155) (Ping timeout: 252 seconds)
2021-10-05 13:13:46 +0200Alex_test(~al_test@178.34.162.155) (Ping timeout: 252 seconds)
2021-10-05 13:15:02 +0200AlexNoo(~AlexNoo@178.34.162.155) (Ping timeout: 260 seconds)
2021-10-05 13:16:09 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-10-05 13:16:55 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 13:18:31 +0200AlexNoo_AlexNoo
2021-10-05 13:19:25 +0200Alex_test(~al_test@94.233.240.2)
2021-10-05 13:19:50 +0200AlexZenon(~alzenon@94.233.240.2)
2021-10-05 13:21:59 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-10-05 13:22:36 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 13:27:30 +0200timCF(~timCF@254-149-20-81.sta.estpak.ee)
2021-10-05 13:27:49 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-10-05 13:28:31 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 13:29:12 +0200timCF(~timCF@254-149-20-81.sta.estpak.ee) (Client Quit)
2021-10-05 13:36:33 +0200xiongxin(~quassel@113.116.35.70)
2021-10-05 13:38:30 +0200Cajun(~Cajun@user/cajun) (Quit: Client closed)
2021-10-05 13:39:11 +0200Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de)
2021-10-05 13:42:43 +0200hrnz(~ethical@vegan.im.it) (Quit: das ist mir zu bld hier; bb)
2021-10-05 13:43:06 +0200hrnz(~ethical@vegan.im.it)
2021-10-05 13:46:33 +0200Cajun(~Cajun@user/cajun)
2021-10-05 13:46:51 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-10-05 13:47:27 +0200goepsilongo(~chacho@2603-7000-ab00-62ed-e8e0-40c9-c788-8ef8.res6.spectrum.com)
2021-10-05 13:49:50 +0200jokleinn(~jokleinn@user/jokleinn)
2021-10-05 13:52:04 +0200rond_(~rond_@2a02:a31a:a23c:f480:2fd7:e087:5546:a438)
2021-10-05 13:53:30 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Quit: WeeChat 3.3)
2021-10-05 13:55:18 +0200max22-(~maxime@2a01cb08833598008bbf230aeaa6be66.ipv6.abo.wanadoo.fr) (Ping timeout: 268 seconds)
2021-10-05 13:55:31 +0200jaitoon(~Jaitoon@2a02:c7f:a5f:1d00:28c3:d6d5:1a31:67d4) (Quit: Leaving)
2021-10-05 13:56:40 +0200cfricke(~cfricke@user/cfricke)
2021-10-05 13:58:06 +0200Cajun(~Cajun@user/cajun) (Quit: Client closed)
2021-10-05 14:08:52 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 268 seconds)
2021-10-05 14:15:16 +0200slowButPresent(~slowButPr@user/slowbutpresent)
2021-10-05 14:24:57 +0200phma(~phma@host-67-44-208-158.hnremote.net) (Read error: Connection reset by peer)
2021-10-05 14:25:22 +0200phma(~phma@host-67-44-208-158.hnremote.net)
2021-10-05 14:27:06 +0200alzgh(~alzgh@user/alzgh) (Remote host closed the connection)
2021-10-05 14:27:22 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 14:27:26 +0200alzgh(~alzgh@user/alzgh)
2021-10-05 14:28:23 +0200hiruji`(~hiruji@2606:6080:1002:8:3285:30e:de43:8809) (Quit: ZNC 1.8.2 - https://znc.in)
2021-10-05 14:29:22 +0200doyougnu(~user@c-73-25-202-122.hsd1.or.comcast.net)
2021-10-05 14:29:58 +0200hiruji(~hiruji@user/hiruji)
2021-10-05 14:31:38 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 250 seconds)
2021-10-05 14:31:53 +0200lbseale(~lbseale@user/ep1ctetus)
2021-10-05 14:32:04 +0200xiongxin(~quassel@113.116.35.70) (Ping timeout: 250 seconds)
2021-10-05 14:32:54 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-10-05 14:34:29 +0200chomwitt(~chomwitt@94.66.61.137) (Ping timeout: 245 seconds)
2021-10-05 14:34:32 +0200xiongxin(~quassel@113.116.35.70)
2021-10-05 14:39:24 +0200jespada(~jespada@2803:9800:9842:7a62:2d4b:7b80:ce15:fc84)
2021-10-05 14:40:45 +0200pavonia(~user@user/siracusa) (Quit: Bye!)
2021-10-05 14:42:23 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 14:54:48 +0200Psybur(~Psybur@mobile-166-170-32-197.mycingular.net)
2021-10-05 14:57:43 +0200wonko(~wjc@62.115.229.50)
2021-10-05 14:59:40 +0200mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2021-10-05 14:59:57 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81d:7133:81c9:b91d)
2021-10-05 15:00:03 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 268 seconds)
2021-10-05 15:00:56 +0200jokleinn(~jokleinn@user/jokleinn) (Ping timeout: 246 seconds)
2021-10-05 15:01:12 +0200chomwitt(~chomwitt@94.66.61.137)
2021-10-05 15:03:09 +0200ubert(~Thunderbi@178.115.35.209.wireless.dyn.drei.com) (Quit: ubert)
2021-10-05 15:04:34 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81d:7133:81c9:b91d) (Ping timeout: 250 seconds)
2021-10-05 15:07:00 +0200ubert(~Thunderbi@178.115.35.209.wireless.dyn.drei.com)
2021-10-05 15:07:23 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 15:10:42 +0200yielduck(~yielduck@176.120.238.10)
2021-10-05 15:15:28 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 268 seconds)
2021-10-05 15:21:05 +0200 <kuribas> is there a DayOfMonth -> Month -> Year -> Day function?
2021-10-05 15:21:07 +0200 <kuribas> in time?
2021-10-05 15:21:46 +0200 <kuribas> only pattern YearDay :: Year -> DayOfYear -> Day
2021-10-05 15:21:50 +0200 <kuribas> which isn't that useful
2021-10-05 15:22:05 +0200 <Hecate> why… would you create a Day with a DayOfMonth/Mont/Year?
2021-10-05 15:22:30 +0200jokleinn(~jokleinn@user/jokleinn)
2021-10-05 15:22:45 +0200 <kuribas> ah, it's in Data.Time.Calendar
2021-10-05 15:23:09 +0200 <kuribas> Hecate: because that's how everyone describes a day?
2021-10-05 15:24:59 +0200akegalj(~akegalj@93-136-79-174.adsl.net.t-com.hr) (Quit: leaving)
2021-10-05 15:25:09 +0200 <Hecate> kuribas: ah, my bad, I had forgotten the ISO8601 instance for Day :-)
2021-10-05 15:26:47 +0200 <kuribas> nice elipsis
2021-10-05 15:27:10 +0200 <Hecate> … <- I like this one as well
2021-10-05 15:28:07 +0200 <sshine> kuribas, fromGregorian?
2021-10-05 15:28:12 +0200 <kuribas> yes
2021-10-05 15:28:25 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2021-10-05 15:28:38 +0200 <sshine> oh, fromGregorianValid is nice.
2021-10-05 15:28:42 +0200 <tomsmeding>
2021-10-05 15:29:25 +0200 <tomsmeding> okay so why is there a VERTICAL ELLIPSIS ⋮ and a PRESENTATION FORM FOR VERTICAL HORIZONTAL ELLIPSIS ︙
2021-10-05 15:29:28 +0200 <sshine> (╯°□°)╯︵ ⋮
2021-10-05 15:29:37 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd)
2021-10-05 15:29:43 +0200 <tomsmeding> also the name of that second one is odd
2021-10-05 15:29:51 +0200 <tomsmeding> what is a vertical horizontal ellipsis
2021-10-05 15:30:06 +0200 <sshine> it's a verizontal ellipsis.
2021-10-05 15:30:11 +0200 <tomsmeding> yes
2021-10-05 15:30:22 +0200 <tomsmeding> luckily I'm not a customer of them
2021-10-05 15:30:27 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-05 15:31:13 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 15:31:47 +0200ec(~ec@gateway/tor-sasl/ec)
2021-10-05 15:36:02 +0200 <robbert-vdh> tomsmeding: How about a quadruple ellipsis: ᠁
2021-10-05 15:36:22 +0200rond_(~rond_@2a02:a31a:a23c:f480:2fd7:e087:5546:a438) (Quit: Client closed)
2021-10-05 15:37:22 +0200CiaoSen(~Jura@p200300c9571e34002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2021-10-05 15:41:56 +0200 <Hecate> hmm
2021-10-05 15:42:05 +0200 <Hecate> in French the "horizontal" part doesn't exist, for the second character
2021-10-05 15:42:18 +0200 <tomsmeding> robbert-vdh: hmm I don't have a font that has that apparently
2021-10-05 15:44:04 +0200Everything(~Everythin@37.115.210.35) (Ping timeout: 245 seconds)
2021-10-05 15:44:10 +0200 <tomsmeding> robbert-vdh: further reading http://www.unicode.org/L2/L2019/19132-mwg3-10-mong-punct-marks-r2.pdf
2021-10-05 15:45:02 +0200 <robbert-vdh> tomsmeding: It's also kinda broken for me (Konsole, screen-256color, Jetbrains Mono, and who knows what fallback fonts). It's a single unicode character, but it seems to take up two spaces. And selecting it will hide the last two dots.
2021-10-05 15:45:54 +0200 <tomsmeding> robbert-vdh: I have that with basically all two-space characters; my terminal is probably less capable. It's probably just a two-space character but wcwidth() reports 1 or 0 or something
2021-10-05 15:46:15 +0200rond_(~rond_@2a02:a31a:a23c:f480:2fd7:e087:5546:a438)
2021-10-05 15:48:19 +0200chomwitt(~chomwitt@94.66.61.137) (Ping timeout: 252 seconds)
2021-10-05 15:51:19 +0200sqrt2_(~ben@tunnel330957-pt.tunnel.tserv6.fra1.ipv6.he.net) (Quit: ZNC - http://znc.in)
2021-10-05 15:51:30 +0200sqrt2(~ben@80-108-18-7.cable.dynamic.surfer.at)
2021-10-05 15:52:40 +0200Aleksejs(~Aleksejs@haskell.lv) (Ping timeout: 260 seconds)
2021-10-05 15:52:50 +0200Aleksejs(~Aleksejs@haskell.lv)
2021-10-05 15:54:25 +0200dkeohane2(~dkeohane@ec2-18-189-29-140.us-east-2.compute.amazonaws.com) (Ping timeout: 260 seconds)
2021-10-05 15:56:15 +0200dkeohane2(~dkeohane@ec2-18-189-29-140.us-east-2.compute.amazonaws.com)
2021-10-05 15:56:55 +0200fuzzypixelz14(~fuzzypixe@eth-west-pareq2-46-193-4-100.wb.wifirst.net)
2021-10-05 15:58:22 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2021-10-05 15:58:23 +0200fuzzypixelz14fuzzypixelz
2021-10-05 15:58:49 +0200sbmsr(~pi@2600:1700:63d0:4830:7dbf:92d8:fd42:235d) (Ping timeout: 252 seconds)
2021-10-05 16:01:37 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-05 16:01:37 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-05 16:01:37 +0200wroathe(~wroathe@user/wroathe)
2021-10-05 16:02:31 +0200 <tdammers> it's probably a zerpital ellipsis
2021-10-05 16:02:36 +0200 <tdammers> https://www.smbc-comics.com/comic/lines
2021-10-05 16:03:35 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-10-05 16:05:40 +0200xsperry(~xs@user/xsperry) (Remote host closed the connection)
2021-10-05 16:06:02 +0200xsperry(~xs@cpe-188-129-101-182.dynamic.amis.hr)
2021-10-05 16:06:02 +0200xsperry(~xs@cpe-188-129-101-182.dynamic.amis.hr) (Changing host)
2021-10-05 16:06:02 +0200xsperry(~xs@user/xsperry)
2021-10-05 16:13:13 +0200max22-(~maxime@2a01cb088335980036d4a1972afb126b.ipv6.abo.wanadoo.fr)
2021-10-05 16:16:40 +0200Sgeo(~Sgeo@user/sgeo)
2021-10-05 16:24:34 +0200chomwitt(~chomwitt@94.66.61.137)
2021-10-05 16:30:09 +0200ub(~Thunderbi@178.115.35.209.wireless.dyn.drei.com)
2021-10-05 16:31:28 +0200yinghua(~yinghua@181.228.40.183)
2021-10-05 16:32:08 +0200azimut_(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2021-10-05 16:32:26 +0200Digit(~user@user/digit) (Read error: Connection reset by peer)
2021-10-05 16:32:30 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2021-10-05 16:32:59 +0200jess(~jess@libera/staff/jess) ()
2021-10-05 16:38:39 +0200ub(~Thunderbi@178.115.35.209.wireless.dyn.drei.com) (Ping timeout: 245 seconds)
2021-10-05 16:41:50 +0200shriekingnoise(~shrieking@186.137.144.80)
2021-10-05 16:45:35 +0200mortemeur(~mortemeur@pool-173-76-107-201.bstnma.fios.verizon.net)
2021-10-05 16:46:59 +0200lbseale(~lbseale@user/ep1ctetus) (Ping timeout: 245 seconds)
2021-10-05 16:50:51 +0200Everything(~Everythin@37.115.210.35)
2021-10-05 16:51:13 +0200ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2021-10-05 16:51:35 +0200ChaiTRex(~ChaiTRex@user/chaitrex)
2021-10-05 16:52:43 +0200sleblanc(~sleblanc@user/sleblanc) (Ping timeout: 252 seconds)
2021-10-05 16:57:14 +0200myShoggoth(~myShoggot@97-120-70-214.ptld.qwest.net)
2021-10-05 16:58:27 +0200vysn(~vysn@user/vysn) (Ping timeout: 268 seconds)
2021-10-05 16:59:01 +0200shapr(~user@pool-100-36-247-68.washdc.fios.verizon.net)
2021-10-05 16:59:42 +0200ub(~Thunderbi@178.115.35.209.wireless.dyn.drei.com)
2021-10-05 17:01:49 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81d:7133:81c9:b91d)
2021-10-05 17:03:54 +0200alzgh(~alzgh@user/alzgh) (Remote host closed the connection)
2021-10-05 17:04:06 +0200alzgh(~alzgh@user/alzgh)
2021-10-05 17:05:32 +0200rond_(~rond_@2a02:a31a:a23c:f480:2fd7:e087:5546:a438) (Quit: Client closed)
2021-10-05 17:06:03 +0200hnOsmium0001(uid453710@id-453710.hampstead.irccloud.com)
2021-10-05 17:06:14 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81d:7133:81c9:b91d) (Ping timeout: 246 seconds)
2021-10-05 17:06:55 +0200zmt00(~zmt00@user/zmt00)
2021-10-05 17:08:08 +0200chisui(~chisui@200116b868200e005b083d1d747ea99e.dip.versatel-1u1.de)
2021-10-05 17:08:18 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81d:7133:81c9:b91d)
2021-10-05 17:11:58 +0200img_(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2021-10-05 17:13:16 +0200xiongxin(~quassel@113.116.35.70) (Ping timeout: 250 seconds)
2021-10-05 17:13:20 +0200img(~img@user/img)
2021-10-05 17:13:42 +0200xiongxin(~quassel@113.116.33.66)
2021-10-05 17:23:07 +0200azeem(~azeem@emp-183-4.eduroam.uu.se) (Read error: Connection reset by peer)
2021-10-05 17:23:44 +0200ub(~Thunderbi@178.115.35.209.wireless.dyn.drei.com) (Ping timeout: 246 seconds)
2021-10-05 17:24:04 +0200ubert(~Thunderbi@178.115.35.209.wireless.dyn.drei.com) (Ping timeout: 245 seconds)
2021-10-05 17:25:20 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:3ebf:673e:c737:b48) (Quit: WeeChat 2.8)
2021-10-05 17:25:36 +0200azeem(~azeem@2a00:801:23d:c203:2f8f:c97c:ce0f:f54f)
2021-10-05 17:28:16 +0200mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be)
2021-10-05 17:28:17 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-10-05 17:30:23 +0200berberman_(~berberman@user/berberman)
2021-10-05 17:30:46 +0200berberman(~berberman@user/berberman) (Ping timeout: 252 seconds)
2021-10-05 17:32:49 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 245 seconds)
2021-10-05 17:33:11 +0200df_df
2021-10-05 17:33:36 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2021-10-05 17:33:43 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 17:35:48 +0200jokleinn(~jokleinn@user/jokleinn) (Ping timeout: 250 seconds)
2021-10-05 17:37:09 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Quit: leaving)
2021-10-05 17:37:20 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2021-10-05 17:38:55 +0200xff0x(~xff0x@2001:1a81:52e7:9700:5d5e:8dcc:4bf7:bd5f) (Ping timeout: 252 seconds)
2021-10-05 17:39:04 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Remote host closed the connection)
2021-10-05 17:39:20 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81d:7133:81c9:b91d) (Remote host closed the connection)
2021-10-05 17:39:49 +0200xff0x(~xff0x@2001:1a81:52e7:9700:89ea:128b:cbad:e425)
2021-10-05 17:40:35 +0200enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) (Quit: enoq)
2021-10-05 17:43:48 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-10-05 17:44:53 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81d:7133:81c9:b91d)
2021-10-05 17:47:39 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Quit: WeeChat 3.3)
2021-10-05 17:48:15 +0200ec(~ec@gateway/tor-sasl/ec) (Quit: ec)
2021-10-05 17:50:13 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-05 17:50:13 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-05 17:50:13 +0200wroathe(~wroathe@user/wroathe)
2021-10-05 17:50:19 +0200vladomiro(~vladomiro@2806:266:485:8e3a:21a:73ff:fe1a:3ecb)
2021-10-05 17:52:21 +0200paddymahoney(~paddymaho@cpe9050ca207f83-cm9050ca207f80.cpe.net.cable.rogers.com) (Remote host closed the connection)
2021-10-05 17:53:23 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Remote host closed the connection)
2021-10-05 17:53:29 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 264 seconds)
2021-10-05 17:53:29 +0200mestre(~mestre@191.177.175.57) (Quit: Lost terminal)
2021-10-05 17:54:30 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-10-05 17:54:49 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2021-10-05 17:56:15 +0200vladomiro(~vladomiro@2806:266:485:8e3a:21a:73ff:fe1a:3ecb) (Quit: Leaving)
2021-10-05 17:58:40 +0200lbseale(~lbseale@user/ep1ctetus)
2021-10-05 17:59:05 +0200 <Hecate> hi lbseale :) sorry that your PR took so long to be reviewed
2021-10-05 17:59:16 +0200rkrishnan(~user@2402:e280:215c:2cd:9500:c2fe:49e8:e5f7) (Ping timeout: 252 seconds)
2021-10-05 17:59:25 +0200lbseale_(~lbseale@user/ep1ctetus)
2021-10-05 17:59:38 +0200xiongxin(~quassel@113.116.33.66) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2021-10-05 18:00:52 +0200rtjure(~rtjure@bras-79-132-17-74.comnet.bg) (Ping timeout: 252 seconds)
2021-10-05 18:01:38 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer)
2021-10-05 18:02:03 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 18:02:36 +0200_ht(~quassel@82-169-194-8.biz.kpn.net)
2021-10-05 18:02:49 +0200lbseale(~lbseale@user/ep1ctetus) (Ping timeout: 245 seconds)
2021-10-05 18:03:45 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 18:04:11 +0200ec(~ec@gateway/tor-sasl/ec)
2021-10-05 18:04:33 +0200zaquest(~notzaques@5.128.210.178) (Remote host closed the connection)
2021-10-05 18:05:31 +0200chisui(~chisui@200116b868200e005b083d1d747ea99e.dip.versatel-1u1.de) (Quit: Client closed)
2021-10-05 18:06:09 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 245 seconds)
2021-10-05 18:08:14 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-10-05 18:08:53 +0200dibblego(~dibblego@haskell/developer/dibblego) (Read error: Connection reset by peer)
2021-10-05 18:09:07 +0200dibblego(~dibblego@122-199-1-30.ip4.superloop.com)
2021-10-05 18:09:07 +0200dibblego(~dibblego@122-199-1-30.ip4.superloop.com) (Changing host)
2021-10-05 18:09:07 +0200dibblego(~dibblego@haskell/developer/dibblego)
2021-10-05 18:14:07 +0200 <maerwald> https://devtut.github.io/haskell/ oy
2021-10-05 18:14:27 +0200dajoer(~david@user/gvx) (Quit: leaving)
2021-10-05 18:14:42 +0200tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2021-10-05 18:14:49 +0200 <Hecate> yeah I recall
2021-10-05 18:14:53 +0200 <Hecate> scrapping StackOverflow
2021-10-05 18:15:20 +0200 <maerwald> not bad
2021-10-05 18:20:53 +0200fresheyeball(~fresheyeb@c-76-25-93-164.hsd1.co.comcast.net) (Quit: WeeChat 2.9)
2021-10-05 18:23:06 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 18:25:14 +0200 <monochrom> Ugh why is Type Classes after all the sections that assume you know type classes such as Overloaded Literals, Foldable, Traversable, Free Monads?
2021-10-05 18:25:49 +0200CiaoSen(~Jura@p200300c9571e34002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2021-10-05 18:27:41 +0200 <monochrom> And Partial Application (which also explains sectioning, e.g., (++ "ing")) is like 10 sections after "Fibonacci, Using Lazy Evaluation" in which there is (fib !!).
2021-10-05 18:30:56 +0200 <Hecate> monochrom: can I borrow you when Haskell School "basics" lessons are done? :)
2021-10-05 18:32:27 +0200 <monochrom> eeeek... What does "borrow" mean?
2021-10-05 18:32:55 +0200 <[exa]> he goes to your rightful owner and asks nicely? :D
2021-10-05 18:33:40 +0200 <[exa]> *hecate
2021-10-05 18:34:10 +0200 <monochrom> Anyway I want to like that tutorial, it has the best diagram that motivates "fib = 0 : 1 : zipWith (+) ...". But ordering is even more important than raw content in pedagogy (and in giving talks, for that matter).
2021-10-05 18:35:11 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-10-05 18:35:52 +0200Hanicef(~gustaf@81-229-9-108-no92.tbcn.telia.com)
2021-10-05 18:35:56 +0200fresheyeball(~fresheyeb@c-76-25-93-164.hsd1.co.comcast.net)
2021-10-05 18:36:01 +0200fresheyeball(~fresheyeb@c-76-25-93-164.hsd1.co.comcast.net) (Client Quit)
2021-10-05 18:36:08 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-10-05 18:37:01 +0200 <monochrom> Storytelling in general. (Special cases being pedagogy and giving talks.)
2021-10-05 18:38:38 +0200Null_A(~null_a@2601:645:8700:2290:e8ac:2b75:e714:d893)
2021-10-05 18:39:24 +0200 <monochrom> For an offtopic example, it is now well understood that the movie Passengers fails because it tells you the pivotal plot point right at the beginning, not in the middle when it belongs. That's all. Wrong order alone ruins it, right order alone would fix it.
2021-10-05 18:43:36 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 18:45:55 +0200 <Hecate> monochrom: I promise to give you back afterwards :P
2021-10-05 18:45:58 +0200 <Hecate> like [exa] said
2021-10-05 18:47:00 +0200 <[exa]> monochrom: thinking about the storytelling in programming, it's kinda inconvenient that goedel&pals spoiled the story right in 1930's
2021-10-05 18:48:30 +0200 <dolio> Gödel is overhyped.
2021-10-05 18:49:09 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-05 18:49:09 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-05 18:49:09 +0200wroathe(~wroathe@user/wroathe)
2021-10-05 18:54:27 +0200fuzzypixelz(~fuzzypixe@eth-west-pareq2-46-193-4-100.wb.wifirst.net) (Quit: Client closed)
2021-10-05 18:56:08 +0200mc47(~mc47@xmonad/TheMC47)
2021-10-05 18:58:30 +0200hgolden(~hgolden2@cpe-172-114-81-123.socal.res.rr.com) (Quit: Konversation terminated!)
2021-10-05 19:03:15 +0200emf(~emf@162.218.217.186)
2021-10-05 19:04:40 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-10-05 19:04:45 +0200hendursa1(~weechat@user/hendursaga) (Remote host closed the connection)
2021-10-05 19:04:46 +0200Null_A(~null_a@2601:645:8700:2290:e8ac:2b75:e714:d893) (Remote host closed the connection)
2021-10-05 19:05:15 +0200hendursa1(~weechat@user/hendursaga)
2021-10-05 19:06:27 +0200mbuf(~Shakthi@122.162.133.48) (Quit: Leaving)
2021-10-05 19:07:30 +0200emf_(~emf@2620:10d:c090:400::5:5481)
2021-10-05 19:07:49 +0200emf(~emf@162.218.217.186) (Ping timeout: 245 seconds)
2021-10-05 19:10:53 +0200pavonia(~user@user/siracusa)
2021-10-05 19:15:54 +0200 <monochrom> Nah Gödel showed how to use prime powers to represent arrays, cool coding trick >:)
2021-10-05 19:16:04 +0200 <monochrom> arrays and strings
2021-10-05 19:16:49 +0200 <monochrom> Data.Text-use-Gödel-numbering Proposal >:)
2021-10-05 19:17:21 +0200 <dolio> I guess. The problem with that is that many mathematicians are stuck in the mindset that they should do that, instead of broadening their horizons on induction and stuff. :)
2021-10-05 19:17:55 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-10-05 19:18:17 +0200 <monochrom> Yeah, it pains my heart that the incompleteness proof is 70% setting up that machinery.
2021-10-05 19:18:34 +0200 <monochrom> OK, it was fair in 1930. But today?
2021-10-05 19:19:50 +0200 <monochrom> OK, so what I have in mind is the poor philosophy students who have to pick up that much number theory and getting really lost for the trees missing the forest, when they try to learn the incompleteness theorem.
2021-10-05 19:20:25 +0200 <dolio> Yeah.
2021-10-05 19:20:29 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 264 seconds)
2021-10-05 19:21:15 +0200hgolden(~hgolden2@cpe-172-114-81-123.socal.res.rr.com)
2021-10-05 19:23:15 +0200Guest372(~xxx@47.245.54.240) (Remote host closed the connection)
2021-10-05 19:24:22 +0200Guest372(~xxx@47.245.54.240)
2021-10-05 19:24:39 +0200econo(uid147250@user/econo)
2021-10-05 19:27:49 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 245 seconds)
2021-10-05 19:30:01 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2021-10-05 19:30:37 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-10-05 19:33:46 +0200 <dolio> It's probably not Gödel's (and other people of that era) fault that people are stuck in their methodology, but a lot of modern stuff seems to suffer from not analyzing why they might have made certain decisions.
2021-10-05 19:34:20 +0200 <dolio> Like, encoding everything as natural numbers might make it easier to analyze certain aspects of the system, but it doesn't make for a good system to use, necessarily.
2021-10-05 19:36:16 +0200 <dolio> But you see that attitude a lot, still. If you have two ways of constructing the same thing, one must be declared redundant and eliminated, even if the two different ways are each good in different situations.
2021-10-05 19:38:54 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 19:39:31 +0200Null_A(~null_a@2601:645:8700:2290:e8ac:2b75:e714:d893)
2021-10-05 19:43:54 +0200 <sclv> andrej likes to point out that “ast” is a perfectly good godel code
2021-10-05 19:45:58 +0200mortemeur(~mortemeur@pool-173-76-107-201.bstnma.fios.verizon.net) (Ping timeout: 252 seconds)
2021-10-05 19:47:01 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-05 19:47:01 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-05 19:47:01 +0200wroathe(~wroathe@user/wroathe)
2021-10-05 19:48:29 +0200 <[exa]> you need actual number theory for godel numerals?
2021-10-05 19:48:42 +0200 <[exa]> like, you need long integers and divisibility but that should be it, right?
2021-10-05 19:48:51 +0200snekism(~user@88.160.31.174)
2021-10-05 19:48:57 +0200cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.3)
2021-10-05 19:50:02 +0200 <geekosaur> that's not how I read it; I read it as philo students get forced to learn number theory because they're presented with the actual number theoretical proof of gödel's theorem instead of a reasonable summary
2021-10-05 19:50:10 +0200 <geekosaur> (is that where GEB came from?)
2021-10-05 19:50:27 +0200 <monochrom> You need the Chinese Remainder Theorem at some point.
2021-10-05 19:51:13 +0200 <monochrom> Now, consider the talent of the student who themselves chose to enter a philosophy major program.
2021-10-05 19:51:20 +0200 <monochrom> s/student/students/
2021-10-05 19:51:23 +0200 <[exa]> yeah there it hits the wall
2021-10-05 19:51:58 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2021-10-05 19:52:59 +0200 <monochrom> I mean, if I changed subject and talk about confirmation bias, I would say "now, consider the talent of the students who themselves chose to enter computer programming courses". :)
2021-10-05 19:53:12 +0200 <[exa]> I was usually explaining an alternate way with encoding a long string of 1's and 0's using primes (which is straightforward since most of them know at least some totally basic prime factoring) to build some intuition, and then point out that it can be done in an alternative way that's a bit more practical for actually writing the functions that run the program
2021-10-05 19:53:45 +0200justsomeguy(~justsomeg@user/justsomeguy)
2021-10-05 19:54:56 +0200 <dolio> That 'optimization' is probably silly, because it's still not practical.
2021-10-05 19:55:37 +0200 <[exa]> well if someone wanted to write out the math that computes it, the CRT encoding is a bit less ugly than strings encoding :D
2021-10-05 20:05:03 +0200jushur(~human@user/jushur) (Quit: brb)
2021-10-05 20:06:25 +0200jushur(~human@user/jushur)
2021-10-05 20:12:19 +0200hendursa1(~weechat@user/hendursaga) (Quit: hendursa1)
2021-10-05 20:12:47 +0200hendursaga(~weechat@user/hendursaga)
2021-10-05 20:14:46 +0200jlamothe_(~jlamothe@104.158.48.100) (Ping timeout: 268 seconds)
2021-10-05 20:15:58 +0200Null_A(~null_a@2601:645:8700:2290:e8ac:2b75:e714:d893) (Remote host closed the connection)
2021-10-05 20:16:20 +0200snekism(~user@88.160.31.174) (Remote host closed the connection)
2021-10-05 20:16:52 +0200mei(~mei@user/mei)
2021-10-05 20:21:20 +0200Guest20(~Guest20@eth-west-pareq2-46-193-4-100.wb.wifirst.net)
2021-10-05 20:22:32 +0200Hanicef(~gustaf@81-229-9-108-no92.tbcn.telia.com) (Quit: leaving)
2021-10-05 20:25:12 +0200tfeb(~tfb@88.98.95.237)
2021-10-05 20:27:30 +0200Tuplanolla(~Tuplanoll@91-159-69-50.elisa-laajakaista.fi)
2021-10-05 20:29:39 +0200DNH(~DNH@2a02:8108:1100:16d8:d1f8:65da:debb:16ba) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-10-05 20:30:00 +0200dunj3_dunj3
2021-10-05 20:37:05 +0200zaquest(~notzaques@5.128.210.178)
2021-10-05 20:38:17 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81d:7133:81c9:b91d) (Remote host closed the connection)
2021-10-05 20:41:49 +0200 <zzz> tomsmeding: after HOURS of banging my head against the wall i finally figured out that i had a typo in my Hspec... here's my final solution, thanks for the mapAccumL suggestion: https://www.codewars.com/kata/reviews/55075a7d5e7c2cce6e000009/groups/615c9b69163e8b0001048c69
2021-10-05 20:42:24 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 245 seconds)
2021-10-05 20:46:21 +0200kuribas(~user@ptr-25vy0i6xitwnblcgfls.18120a2.ip6.access.telenet.be) (Remote host closed the connection)
2021-10-05 20:50:17 +0200vysn(~vysn@user/vysn)
2021-10-05 20:51:01 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 20:51:09 +0200funsafe(~funsafe@2601:1c1:4200:e53:2875:5507:42e4:4e14) (Ping timeout: 268 seconds)
2021-10-05 20:54:04 +0200 <tomsmeding> zzz: this was mine :) https://www.codewars.com/kata/reviews/55075a7d5e7c2cce6e000009/groups/615b39abbf844600014b9445
2021-10-05 20:54:20 +0200DNH(~DNH@2a02:8108:1100:16d8:d1f8:65da:debb:16ba)
2021-10-05 20:55:54 +0200 <tomsmeding> zzz: is there a particular reason you chose to use a lazy map?
2021-10-05 20:57:15 +0200 <zzz> not really no. actually i noticed a strict map is a bit faster
2021-10-05 20:57:33 +0200DNH(~DNH@2a02:8108:1100:16d8:d1f8:65da:debb:16ba) (Client Quit)
2021-10-05 20:57:39 +0200 <tomsmeding> zzz: aren't you technically missing a map insert in the Left case of the 'either'?
2021-10-05 20:58:47 +0200 <zzz> well, i thought that some computations will be faster than a lookup on a large map
2021-10-05 20:58:56 +0200 <tomsmeding> makes sense
2021-10-05 20:59:07 +0200 <zzz> but yeah i could have optimized it for the other case
2021-10-05 20:59:23 +0200 <tomsmeding> yeah your decision is probably not a bad one
2021-10-05 21:00:30 +0200 <zzz> it would depend on the input. in any case it's trivial to adapt it because i isolated my memo function. so intead of (m,) we just need to write (memo . (m,))
2021-10-05 21:00:47 +0200 <tomsmeding> yeah that's quite nice
2021-10-05 21:00:59 +0200tfeb(~tfb@88.98.95.237) (Quit: died)
2021-10-05 21:01:19 +0200dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be) (Quit: WeeChat 3.2)
2021-10-05 21:01:23 +0200 <Guest20> this is taken straight from my file: https://paste.tomsmeding.com/QFR9yNsG
2021-10-05 21:01:34 +0200 <Guest20> hlint and ghc are driving me mad
2021-10-05 21:02:00 +0200 <Guest20> Why do I need 3 extra identations?
2021-10-05 21:02:16 +0200 <Rembane> Guest20: Turn off hlint. It's not worth going mad over those suggestions.
2021-10-05 21:02:48 +0200 <zzz> i like that yours is very readable
2021-10-05 21:03:13 +0200 <tomsmeding> zzz: main difference in that sense, I think, is that I used lots of 'case' whereas you used eliminators
2021-10-05 21:03:14 +0200 <Guest20> If I move it to the left I get "parse error on input Just`
2021-10-05 21:03:19 +0200 <geekosaur> because if you indent only to the first variable defined after the "where" then it's taken as a new variable definition, and if you indent not even that far then it ends the "where"
2021-10-05 21:04:01 +0200 <geekosaur> and this is ghc being lenient, I think (NondecreasingIndenation) or you'[d have to indent past the "case"
2021-10-05 21:04:31 +0200jess(~jess@libera/staff/jess)
2021-10-05 21:04:52 +0200 <zzz> tomsmeding: i think i'm allergic to case expressions
2021-10-05 21:05:02 +0200 <geekosaur> think of haskell beingt like python, indentation matters a lot
2021-10-05 21:05:04 +0200 <tomsmeding> they are nice and readable :)
2021-10-05 21:05:22 +0200 <zzz> so are pattern guards ;)
2021-10-05 21:05:36 +0200 <geekosaur> if it really bothers you then you can use brackets and then indent however you want
2021-10-05 21:05:42 +0200 <geekosaur> er, braces
2021-10-05 21:05:58 +0200 <tomsmeding> zzz: yeah true, the outer Just y match could be a pattern guard in my solution
2021-10-05 21:06:34 +0200 <Guest20> geekosaur: I get it now, I think I want to always add a newline after where then
2021-10-05 21:07:48 +0200ChaiTRex(~ChaiTRex@user/chaitrex) (Ping timeout: 276 seconds)
2021-10-05 21:08:13 +0200 <c_wraith> I'm not quite sure why people don't like layout-based semantics. do they enjoy confusing others by misrepresenting their code's structure visually?
2021-10-05 21:09:09 +0200ChaiTRex(~ChaiTRex@user/chaitrex)
2021-10-05 21:09:10 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-05 21:09:10 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-05 21:09:10 +0200wroathe(~wroathe@user/wroathe)
2021-10-05 21:09:16 +0200 <geekosaur> same, although I do prefer NondecreasingIndentation to the standard
2021-10-05 21:09:37 +0200funsafe(~funsafe@2601:1c1:4200:e53:2875:5507:42e4:4e14)
2021-10-05 21:09:42 +0200 <zzz> tomsmeding: is your `cont` short for continuation?
2021-10-05 21:09:43 +0200 <geekosaur> mostly because I don't like getting too close to the edge of the line either
2021-10-05 21:09:53 +0200 <tomsmeding> zzz: yeah
2021-10-05 21:10:21 +0200 <Guest20> another question: I can't seem to define a Show instrance for a type synonym
2021-10-05 21:10:30 +0200 <tomsmeding> FlexibleInstances
2021-10-05 21:10:32 +0200 <geekosaur> type synonyms are not distinct
2021-10-05 21:10:37 +0200 <tomsmeding> also that
2021-10-05 21:10:40 +0200 <c_wraith> instances belong to types, not synonyms.
2021-10-05 21:10:57 +0200 <tomsmeding> if you want an actually new type, use newtype
2021-10-05 21:11:00 +0200 <monochrom> layout: https://twitter.com/HisCursedness/status/788690145822306304
2021-10-05 21:11:02 +0200 <geekosaur> you can enable FlexibleInstances to do it, but it still won't let you define a different instance for the synonym than for the original type
2021-10-05 21:11:29 +0200 <c_wraith> honestly, you shouldn't use type synonyms while you're still learning the basics.
2021-10-05 21:11:33 +0200 <monochrom> I actually gave that on an exam. To pretty-print code in that format. >:)
2021-10-05 21:11:34 +0200 <Guest20> yes I do realize they're not types x) I really didn't want a constructor so I will try FlexibleInstances
2021-10-05 21:11:52 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81d:7133:81c9:b91d)
2021-10-05 21:11:59 +0200 <c_wraith> I'm confused why so many introductions to Haskell put them up front as if they're useful
2021-10-05 21:12:14 +0200 <monochrom> c_wraith: I agree, but other teachers like Hutton like to introduce type synonyms when teaching the basics.
2021-10-05 21:12:21 +0200 <monochrom> Yeah :)
2021-10-05 21:12:26 +0200 <zzz> c_wraith: from someone with a design background, there are problems with the way we use vertical alignment in layout mode
2021-10-05 21:12:47 +0200 <geekosaur> mostly because they want to distinguish data, type, and newtype early
2021-10-05 21:12:54 +0200 <monochrom> Well, I can understand the "self-documenting type sig" angle.
2021-10-05 21:12:56 +0200 <geekosaur> which can be a ood thing
2021-10-05 21:13:00 +0200 <geekosaur> *good
2021-10-05 21:13:10 +0200 <monochrom> No, they don't teach newtype that early.
2021-10-05 21:13:21 +0200 <monochrom> In fact they don't teach ADT that early either.
2021-10-05 21:13:28 +0200 <c_wraith> I mean, I guess the existence of String forces teaching about type aliases early
2021-10-05 21:13:39 +0200 <Guest20> well in my case I have a `Maybe Text` in four data definitions and I have a Show instance for each of those types where the code for showing Maybe Text is gonna be ... well repeated 3 times
2021-10-05 21:13:47 +0200 <c_wraith> but that should come with a warning "don't do this"
2021-10-05 21:13:51 +0200 <Guest20> s/3/4
2021-10-05 21:14:06 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 21:14:09 +0200 <tomsmeding> Guest20: write a top-level function?
2021-10-05 21:14:23 +0200 <monochrom> At the stage you just have Int, String, Bool, Float, they already go like "type Celsius = Float; type Fahrenheit = Float; convert :: Celsius -> Fahrenheit"
2021-10-05 21:14:56 +0200 <tomsmeding> luckily the class at my uni doesn't do that
2021-10-05 21:15:06 +0200 <Guest20> tomsmeding: Fair enough. I came here to check if I was misunderstanding things
2021-10-05 21:15:10 +0200 <tomsmeding> (though they do use Hutton's book; haven't opened the book yet)
2021-10-05 21:15:20 +0200 <monochrom> Hell, even by the time of State monad, they still don't always use newtype.
2021-10-05 21:16:38 +0200 <monochrom> Me, if some student asks me "what's type Foo = Int", I just say "just like C typedef", and never bring it up again.
2021-10-05 21:16:42 +0200acidjnk_new(~acidjnk@p200300d0c703cb83c18eec9e6894a9d9.dip0.t-ipconnect.de)
2021-10-05 21:17:04 +0200 <monochrom> And that's right, only if some student asks me.
2021-10-05 21:18:05 +0200Eoco(~ian@x-160-94-179-157.acm.umn.edu)
2021-10-05 21:19:07 +0200 <Guest20> enabling FlexibleInstances gives me "Overlapping instances arising from use of $dmShowList". I guess the top-level function isn't so bad after all
2021-10-05 21:20:01 +0200 <Guest20> and it breaks any other data type driving Show _and_ containing a Maybe Text
2021-10-05 21:20:19 +0200 <tomsmeding> Guest20: writing 'type T = Maybe Text' and then writing 'instance Show T where ...' is literally the same as writing 'instance Show (Maybe Text) where'
2021-10-05 21:20:34 +0200 <tomsmeding> becausse T = Maybe Text :p
2021-10-05 21:20:57 +0200 <geekosaur> isn't that going to be overlapping anyway?
2021-10-05 21:21:05 +0200 <tomsmeding> should be
2021-10-05 21:21:40 +0200Guest71(~Guest71@a79-169-181-190.cpe.netcabo.pt)
2021-10-05 21:22:42 +0200Null_A(~null_a@c-98-210-133-39.hsd1.ca.comcast.net)
2021-10-05 21:23:04 +0200mcglk(~mcglk@131.191.49.120) (Read error: Connection reset by peer)
2021-10-05 21:23:15 +0200 <Guest71> hi guys, is it possible to multiply each element of a list by its index without using recursion? thx in advance
2021-10-05 21:23:25 +0200 <monochrom> Totally overlaps with Prelude's "instance Show a => Show (Maybe a)"
2021-10-05 21:24:01 +0200 <tomsmeding> Guest71: how would you multiply each element of a list by something else without using recursion?
2021-10-05 21:24:02 +0200 <c_wraith> Guest71: define "using recursion". the answer might be yes or no, depending
2021-10-05 21:24:10 +0200 <sprout> Guest71: depends what you mean without recursion
2021-10-05 21:24:10 +0200 <Guest20> TIL type synonyms are just macros
2021-10-05 21:24:24 +0200 <c_wraith> you really should avoid using them
2021-10-05 21:24:29 +0200 <monochrom> Do you know zip or zipWith? Do you know how to use zip to convert [x,y,z] to [(x,0), (y,1), (z,2)] ?
2021-10-05 21:24:31 +0200 <sprout> you can just make another (infinite) lazy list of indexes and zip
2021-10-05 21:24:52 +0200mcglk(~mcglk@131.191.49.120)
2021-10-05 21:25:13 +0200 <Guest20> c_wraith: I sure will :^) that instance overlapping really left a sour taste in my mouth
2021-10-05 21:25:27 +0200 <monochrom> To be sympathetic, I think most beginners don't know what "define" means. :)
2021-10-05 21:25:40 +0200 <monochrom> or at least most 1st-year students.
2021-10-05 21:25:45 +0200 <Guest20> let me have a go at it
2021-10-05 21:25:51 +0200 <c_wraith> lists are a recursive data type. you can't do anything with all of a list without using recursion somewhere.
2021-10-05 21:26:28 +0200 <monochrom> You know what, that applies to all of computing.
2021-10-05 21:26:35 +0200 <c_wraith> the only question is whether you write it, or use a tool that encapsulates it for you
2021-10-05 21:27:06 +0200jtomas(~jtomas@95.red-88-11-64.dynamicip.rima-tde.net)
2021-10-05 21:27:13 +0200 <Guest20> #define X Y means when the compiler preprocessor reads you code it literally replaces every occurence X with Y so it's as if you never wrote any Xs but only Ys
2021-10-05 21:27:39 +0200 <c_wraith> Guest20: I think conversations got a bit crossed.
2021-10-05 21:28:07 +0200 <monochrom> I think that was intentional. Someone was like "challenge accepted!" :)
2021-10-05 21:28:30 +0200 <Guest20> well I'm a 2nd year student :^)
2021-10-05 21:28:34 +0200 <c_wraith> I mean, you're right. it's just not what was intended. :)
2021-10-05 21:29:48 +0200 <c_wraith> I do remember having my mind blown when a math professor said that there was fundamentally no way of expressing a sum without using recursion.
2021-10-05 21:30:03 +0200 <monochrom> :)
2021-10-05 21:30:08 +0200 <c_wraith> because I was like "you can just write it with a big sigma"
2021-10-05 21:30:30 +0200 <c_wraith> only later did I realize I was just hiding the recursion, not removing it
2021-10-05 21:30:47 +0200 <monochrom> Well, that point was drove home to me for the nth time when last night someone asks "how does an FPL implementation implements recursion?"
2021-10-05 21:31:42 +0200 <monochrom> So, for example, GHC translates Haskell's letrec to, drum rolls, STG's letrec!
2021-10-05 21:32:34 +0200 <monochrom> And beyond that, either a cyclic thunk or a cyclic piece of code.
2021-10-05 21:32:47 +0200 <monochrom> or perhaps s/thunk/closure/
2021-10-05 21:33:06 +0200 <Guest20> STG?
2021-10-05 21:33:22 +0200 <geekosaur> the underlying engine that evaluates ghc-generated code
2021-10-05 21:33:27 +0200 <monochrom> STG is an intermediate level language that GHC uses internally.
2021-10-05 21:33:38 +0200 <geekosaur> "spineless tagless g(raph-reduction) machine
2021-10-05 21:34:08 +0200 <Guest20> and letrec is a language feature?
2021-10-05 21:34:32 +0200 <monochrom> It just means the language supports recursive definitions syntactically.
2021-10-05 21:34:54 +0200 <monochrom> You are allowed to write "f x = f (x+1)" and the computer will "do the right thing".
2021-10-05 21:34:58 +0200 <Guest71> lets say i want to transform [1,2,3] in [1,4,9] (each element multiplied with its position) how can i do that with a list comprehension? [y ...? | y <- xs]
2021-10-05 21:35:12 +0200 <Guest71> is it possible?
2021-10-05 21:35:54 +0200 <monochrom> The irony being if a compiler is just translating recursion syntax to yet another recursion syntax, it still doesn't explained recursive in more primitive terms.
2021-10-05 21:36:46 +0200 <Hecate> % zipWith (*) [1,2,3] [1..]
2021-10-05 21:36:46 +0200 <yahb> Hecate: [1,4,9]
2021-10-05 21:36:50 +0200 <Hecate> Guest71: ^
2021-10-05 21:36:55 +0200DNH(~DNH@2a02:8108:1100:16d8:d1f8:65da:debb:16ba)
2021-10-05 21:37:09 +0200 <monochrom> In Haskell, you write "let f x = f (x+1) ...". You call it "let", but in Scheme circles, it's called "letrec".
2021-10-05 21:37:11 +0200 <Guest71> ohhh
2021-10-05 21:37:43 +0200 <monochrom> So in our circle, sometimes we also say "letrec" if we want the emphasis on supporting recursion.
2021-10-05 21:37:51 +0200 <Guest71> and for a list that i dont know its size it would be % zipWith (*) [1,2,3] [1.. length xs] right?
2021-10-05 21:38:04 +0200 <geekosaur> [1..] will produce a list as long as is needed
2021-10-05 21:38:30 +0200 <geekosaur> zipWit will stop as soon as one of the lists you're zipping does, while [1..] will keep going forever if allowed ot
2021-10-05 21:38:32 +0200 <Hecate> Guest71: no need, 'zip' (or zipWith) will stop taking from the second list as soon as it finishes with the first :)
2021-10-05 21:39:46 +0200 <Guest20> monochrom: I see, where can I read more about how recursion is supported internally?
2021-10-05 21:40:15 +0200 <Guest20> % [0..]
2021-10-05 21:40:17 +0200 <monochrom> I don't know, apart from reading generally any textbooks on compilers and/or interpreters.
2021-10-05 21:40:20 +0200 <yahb> Guest20: [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,1
2021-10-05 21:40:47 +0200 <Guest71> thx :)
2021-10-05 21:40:49 +0200 <monochrom> But I think what I said amounts to "just let the CPU worry about it".
2021-10-05 21:40:53 +0200 <Guest20> it's programmed to stop at 126 ... right?
2021-10-05 21:41:13 +0200 <Guest20> I wonder how this was implemented
2021-10-05 21:41:23 +0200 <Hecate> Guest20: datacenters are burning right now to give you more integers
2021-10-05 21:41:28 +0200 <geekosaur> no, the bot has a line length limit and chops the output off
2021-10-05 21:41:32 +0200emf(~emf@2620:10d:c090:400::5:5481)
2021-10-05 21:41:46 +0200 <geekosaur> otherwise it'd keep going forever (or at least until interrupted)
2021-10-05 21:42:07 +0200 <Guest20> monochrom: so I don't necessarily need to read ghc-specific literature
2021-10-05 21:42:09 +0200 <monochrom> You know that you can test your "stop at 126" hypothesis by trying [126...]
2021-10-05 21:42:34 +0200 <geekosaur> the neat part of Haskell is this is handled automatically so if something only requests (say) 50 numbers it'll stop there
2021-10-05 21:42:37 +0200 <monochrom> That depends on whether you want to be GHC-specific or not.
2021-10-05 21:42:55 +0200 <geekosaur> you can think of evaluation of a recursive expression as turning a crank each time a new value is needed
2021-10-05 21:43:04 +0200 <Guest20> monochrom: I was thinking along the lines of lists of 126 elements :^)
2021-10-05 21:43:16 +0200 <geekosaur> if the crank never gets turned, the expression stops producing values
2021-10-05 21:43:18 +0200 <monochrom> repeat 0
2021-10-05 21:44:07 +0200 <monochrom> See? Programmers firstly can't phrase their hypotheses properly, secondly can't test them.
2021-10-05 21:44:26 +0200 <Guest20> well you got me!
2021-10-05 21:44:27 +0200 <geekosaur> each crank can be connected to another crank, so for example the bot turns a crank based on the length of the current output line and that turns a crank of the infinite [0..] expression
2021-10-05 21:44:35 +0200 <monochrom> And you say you expect programmers to properly test their code?
2021-10-05 21:44:38 +0200emf_(~emf@2620:10d:c090:400::5:5481) (Ping timeout: 260 seconds)
2021-10-05 21:44:54 +0200 <monochrom> That's a talent reserved for those who have gone into actual scientific careers.
2021-10-05 21:44:55 +0200mei(~mei@user/mei) (Read error: Connection reset by peer)
2021-10-05 21:44:59 +0200DNH(~DNH@2a02:8108:1100:16d8:d1f8:65da:debb:16ba) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-10-05 21:45:42 +0200mei(~mei@user/mei)
2021-10-05 21:45:52 +0200 <monochrom> See also what I said about confirmation bias 2 hours ago.
2021-10-05 21:47:52 +0200 <tomsmeding> monochrom: you say you can't do much without recursion. I have lots of C code that does lots of useful (perhaps) stuff without using recursion anywhere.
2021-10-05 21:47:59 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 246 seconds)
2021-10-05 21:48:15 +0200 <monochrom> It gets compiled to recursion at the asm level.
2021-10-05 21:48:27 +0200 <tomsmeding> the fact that STG has lots of recursion in it doesn't mean that "all of computing" has it :p
2021-10-05 21:48:38 +0200 <monochrom> Or how about we agree to s/recursion/self-reference/
2021-10-05 21:48:40 +0200 <tomsmeding> what does recursion even _mean_ on the asm level?
2021-10-05 21:48:41 +0200 <dolio> The example above even started printing 127, and stopped in the middle. :)
2021-10-05 21:48:43 +0200 <geekosaur> any for, do, while loop is ultimately recursion at some level
2021-10-05 21:50:50 +0200 <monochrom> Alternatively you can try to explain looping in more primitive terms.
2021-10-05 21:51:35 +0200geranim0(~geranim0@modemcable242.171-178-173.mc.videotron.ca) (Quit: Leaving)
2021-10-05 21:51:52 +0200geranim0(~geranim0@modemcable242.171-178-173.mc.videotron.ca)
2021-10-05 21:52:31 +0200pgib(~textual@173.38.117.88)
2021-10-05 21:53:01 +0200 <tomsmeding> I feel like it's not really productive to call a compute-cmp-jnz loop in assembly "recursion". But maybe that's my operational mind speaking :)
2021-10-05 21:53:33 +0200 <monochrom> Sure, that's why <monochrom> Or how about we agree to s/recursion/self-reference/
2021-10-05 21:53:49 +0200 <monochrom> Seriously I think "recursion" means "self referencing" no more no less.
2021-10-05 21:54:06 +0200 <monochrom> But seems like more people agree to the wording "self reference".
2021-10-05 21:54:16 +0200tomsmedingunderstood "recursion" to mean "self-execution", more or less
2021-10-05 21:54:37 +0200 <tomsmeding> but right, I guess you can say that a loop references itself
2021-10-05 21:54:45 +0200 <monochrom> You have "mylabel: ... 10 instructions later ... jmp/jsr mylabel" that's a self-reference, a cycle, a cyclic graph.
2021-10-05 21:55:34 +0200 <geekosaur> tail recursion does the same thing at asm level, so where's the difference?
2021-10-05 21:55:41 +0200 <tomsmeding> but then what about a language where a loop looks like this: while (\(i, x) -> i < 10) (\(i, x) -> (i + 1, f x)) (0, input) -- computes (iterate f input !! 10)
2021-10-05 21:55:49 +0200 <tomsmeding> where is self-reference here?
2021-10-05 21:55:59 +0200 <monochrom> Just like if you have data "myaddress: .... 10 words later DWORD myaddress" that's cyclic data, a cyclic graph.
2021-10-05 21:56:18 +0200 <tomsmeding> okay yeah, in a suitable sense :p
2021-10-05 21:56:31 +0200 <geekosaur> tomsmeding, hidden inside the "while" which produces bopth the initial label and the jmp at the end
2021-10-05 21:56:38 +0200 <tomsmeding> yeah true
2021-10-05 21:56:53 +0200 <monochrom> So-called "code" "mylabel: ... 10 instructions later ... jmp/jsr mylabel" is still some special kind of data in the eyes of the CPU. The CPU's job is to interpret that data.
2021-10-05 21:56:55 +0200mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be) (Ping timeout: 268 seconds)
2021-10-05 21:57:05 +0200 <geekosaur> haskell hides it one way, C another
2021-10-05 21:59:23 +0200mikoto-chan(~mikoto-ch@83.137.2.247)
2021-10-05 21:59:25 +0200 <monochrom> The one question that can stumble me is this. (I pose this to my students too. Well, I position it as food for thought.)
2021-10-05 21:59:58 +0200 <monochrom> You take an FPL interpreter like mine at http://www.cs.utoronto.ca/~trebla/CSCC24-2021-Summer/09-semantics-1.html
2021-10-05 22:01:07 +0200 <monochrom> And you ban the recursive construct there. In Expr, delete the Rec case. In Value, delete the VRecClosure case.
2021-10-05 22:01:36 +0200 <monochrom> And you find that the section on recursion (#rec) still works.
2021-10-05 22:01:54 +0200 <tomsmeding> yeah the classical y combinator
2021-10-05 22:01:55 +0200 <monochrom> You can still do factorial. You can still do non-termination. WTF?
2021-10-05 22:02:05 +0200 <monochrom> "Where is the recursion?"
2021-10-05 22:02:30 +0200 <tomsmeding> in the interpreter?
2021-10-05 22:03:02 +0200 <tomsmeding> like, interp probably calls itself to interpret subexpressions
2021-10-05 22:03:51 +0200 <monochrom> That is an obvious answer on the surface, but needs much more justification if you're careful. How is the interpreter exceeding primitive recursion (which terminates)?
2021-10-05 22:04:33 +0200 <tomsmeding> who spoke about primitive recursion? :p
2021-10-05 22:04:53 +0200_ht(~quassel@82-169-194-8.biz.kpn.net) (Remote host closed the connection)
2021-10-05 22:05:33 +0200juhp(~juhp@128.106.188.220) (Ping timeout: 268 seconds)
2021-10-05 22:05:48 +0200 <monochrom> I do. Because primitive recursion is a boring kind of recursive that doesn't constitute any interesting food for thought because it can't do non-termination, it can't even do Ackermann.
2021-10-05 22:06:02 +0200Null_A(~null_a@c-98-210-133-39.hsd1.ca.comcast.net) (Remote host closed the connection)
2021-10-05 22:06:34 +0200 <tomsmeding> like, I don't see why I have to show that the interpreter can exceed primitive recursion, when there is no a priori evidence that it couldn't
2021-10-05 22:06:37 +0200 <monochrom> And a lot of people who want total languages bet their hopes on primitive recursion.
2021-10-05 22:07:02 +0200 <monochrom> The interpreter's code looks like primitive recursion. That's why.
2021-10-05 22:07:03 +0200 <tomsmeding> now, if you're used to simply-typed lambda calculus, then this is different, but yeah :p
2021-10-05 22:07:09 +0200 <dolio> Only those stodgy mathematicians who reduce everything to natural numbers think primtiive recursion can't do Ackermann. :þ
2021-10-05 22:07:23 +0200 <monochrom> Ugh hahaha
2021-10-05 22:07:29 +0200 <maerwald> happy/alex seem to depend on data files that are in the cabal store, making it impossible to provide static binaries or clean up the store after them?
2021-10-05 22:07:55 +0200juhp(~juhp@128.106.188.220)
2021-10-05 22:08:07 +0200 <geekosaur> maerwald, I think that's a known screw case that is hard to do right
2021-10-05 22:08:58 +0200mei(~mei@user/mei) (Ping timeout: 252 seconds)
2021-10-05 22:09:00 +0200 <geekosaur> data files in general can't be handled well, unless there's specific buy-in from the app (that is, it contains them and generates them when needed or uses them from the wired-in data)
2021-10-05 22:09:52 +0200 <maerwald> if it's static data it can just include it in the binary
2021-10-05 22:10:08 +0200 <Franciman> maerwald: did you try the Earley package?
2021-10-05 22:10:33 +0200 <maerwald> no
2021-10-05 22:10:44 +0200 <Franciman> maybe it can help you avoid using happy/alex
2021-10-05 22:11:00 +0200 <maerwald> no, it's about docker images that use/compile GHC
2021-10-05 22:11:15 +0200 <maerwald> which needs alex/happy
2021-10-05 22:11:27 +0200 <maerwald> and then is dragging a store of several hundred MBs with it
2021-10-05 22:13:05 +0200 <monochrom> Here is the angle that I like and I would like you to consider. The Value type is able to represent "V = Integer + Bool + (V -> V)", or at least a larger enough subset of (V->V) that matters.
2021-10-05 22:13:49 +0200 <monochrom> The denotational people have concluded that "V = ... + (V->V)" is where untyped lambda calculus got all its unrestricted recursive power.
2021-10-05 22:14:21 +0200 <monochrom> (And it costed them a lot to prove that such a V exists in the first place.)
2021-10-05 22:15:59 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 246 seconds)
2021-10-05 22:16:01 +0200hatds(~hatds@c-107-4-136-72.hsd1.mn.comcast.net)
2021-10-05 22:16:19 +0200 <monochrom> Or put it in another way, if your code syntax doesn't support any kind of recursion or looping, but your data syntax supports "V = V -> ???", roughly speaking recursive data at covariant positions, you've restored recursion.
2021-10-05 22:16:25 +0200 <tomsmeding> I'd need to consider that in more detail to see how exactly this is different from the simply-typed lambda calculus case. (Presumably your "large enough subset")
2021-10-05 22:17:13 +0200neurocyte013288(~neurocyte@user/neurocyte) (Quit: The Lounge - https://thelounge.chat)
2021-10-05 22:17:27 +0200 <tomsmeding> this feels a lot like Chomsky's claim that all languages should have recursion as a common ingredient
2021-10-05 22:17:39 +0200 <tomsmeding> and then you have that weird amazonian language that actually doesn't (or so it seems)
2021-10-05 22:18:03 +0200 <tomsmeding> (Piraha, in case you want to look up)
2021-10-05 22:20:11 +0200 <tomsmeding> I guess the reason why I don't feel convinced by this thing that you need self-reference to do useful computation, is that it's a philosophical argument, I think. I don't see actual practical use of that argument in my life. And I engage in philosophy only very selectively :p
2021-10-05 22:20:59 +0200 <Franciman> fwiw there are some arguing the opposite, i.e. that inductive data types + coinductive data types + higher order functions in a total language are enough
2021-10-05 22:21:14 +0200 <tomsmeding> But I'm probably missing something. In any case it's bedtime for me; monochrom: tomorrow I'll check the logs :)
2021-10-05 22:21:18 +0200 <Franciman> only thing that gets funky is that you can't write a self interpreter in a total language
2021-10-05 22:21:28 +0200 <Franciman> but you can write a compiler, at least :)
2021-10-05 22:22:10 +0200 <dolio> You can write a self-interpreter for some notion of "interpreter", though.
2021-10-05 22:22:43 +0200danso(~danso@23-233-111-52.cpe.pppoe.ca) (Quit: WeeChat 3.2)
2021-10-05 22:23:00 +0200 <Franciman> uh dolio could you expand a bit?
2021-10-05 22:23:20 +0200 <Franciman> are saying that you can like, convert the source code in python and run it?
2021-10-05 22:23:28 +0200 <dolio> https://popl16.sigplan.org/details/POPL-2016-papers/52/Breaking-Through-the-Normalization-Barrier-…
2021-10-05 22:23:35 +0200 <Franciman> ty
2021-10-05 22:23:52 +0200 <hatds> I'm trying to make a "package1.tar.gz" produced by "cabal sdist all" available as a "local repo" to package2, so that package2 can depend on package1 in an offline manner and without using ghc's notion of global/user package dbs. I've found this: https://cabal.readthedocs.io/en/latest/installing-packages.html#local-no-index-repositories but I don't even know if I'm doing it right: I put those two lines in both the "package1.project"
2021-10-05 22:23:53 +0200 <hatds> file and "package2.project" file. Does that sound right? "cabal build" now gives the error: "/C:/ghc/cabal/local-repo\noindex.timestamp: openFile: invalid argument (Invalid argument)"
2021-10-05 22:24:34 +0200 <dolio> It's not the sort of interpreter like for Python.
2021-10-05 22:25:02 +0200 <Franciman> this is rad
2021-10-05 22:25:17 +0200 <dolio> It's an interpreter from internally represented 'source code' to a semantic interpretation.
2021-10-05 22:25:52 +0200 <sclv> hatds: looks line a path / file separator issue
2021-10-05 22:26:05 +0200 <monochrom> Here is something that points toward the significance of "V = V->V". (\x -> x x) is allowed in untyped. What would you do to give it a type? You first run into "occurs check, infinite type: a ~ a->a". Eh? This means if you're allowed to define your own recursive type inspired by "a ~ a->a" and add wrappers/unwrappers to make "(\x -> x x)" go through, you're good to go.
2021-10-05 22:26:25 +0200 <dolio> So, like, you represent lambda terms and then 'interpret' them into functions in the language you're using to represent the lambda terms.
2021-10-05 22:26:46 +0200lavaman(~lavaman@98.38.249.169)
2021-10-05 22:27:10 +0200 <sclv> hatds: but you can just add an explicit reference to project1’s cabal file in project2
2021-10-05 22:27:24 +0200 <dolio> But not reducing the lambda terms to a normal form or something.
2021-10-05 22:27:53 +0200 <hatds> sclv: if I switch the path separators to a blackslash (or pair of blackslashes) I get a parse error
2021-10-05 22:28:55 +0200 <hatds> sclv: I was doing that, but that doesn't work if I want old versions of package1 lying around. I'd have to manually rollback the project folder every time it was needed
2021-10-05 22:28:55 +0200 <sclv> the feature might not work well in certain windows configs, its pretty obscure
2021-10-05 22:29:06 +0200Null_A(~null_a@2601:645:8700:2290:e8ac:2b75:e714:d893)
2021-10-05 22:29:53 +0200Null_A(~null_a@2601:645:8700:2290:e8ac:2b75:e714:d893) (Remote host closed the connection)
2021-10-05 22:30:03 +0200 <sclv> running with high verbosity could give some hints
2021-10-05 22:30:07 +0200Null_A(~null_a@2601:645:8700:2290:e8ac:2b75:e714:d893)
2021-10-05 22:30:12 +0200 <hatds> good idea
2021-10-05 22:31:17 +0200 <hatds> it just says Reading available packages of my-local-repository...
2021-10-05 22:31:28 +0200 <hatds> and then the error
2021-10-05 22:31:35 +0200 <hatds> so it is finding the directory OK
2021-10-05 22:31:46 +0200maerwald[m](~maerwaldm@user/maerwald)
2021-10-05 22:32:01 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 252 seconds)
2021-10-05 22:32:12 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-05 22:33:09 +0200 <hatds> how is cabal supposed to create the .cache or whatever in these local-repos? Do I have to do a command while inside package1? Does package1 need to know where the local-repo so cabal can put it there, or can I just copy/paste the result of cabal sdist?
2021-10-05 22:38:02 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81d:7133:81c9:b91d) (Remote host closed the connection)
2021-10-05 22:40:11 +0200 <Guest20> I have two directories of text files, say TestInputs and TestOutputs. they are rather sizable. I want to integrate these tests into HSpec but I'm not sure if I need to do it by hand
2021-10-05 22:40:44 +0200jtomas(~jtomas@95.red-88-11-64.dynamicip.rima-tde.net) (Ping timeout: 245 seconds)
2021-10-05 22:40:49 +0200 <Guest20> can I for example have the "it" description be the file name?
2021-10-05 22:41:04 +0200justachejustHaunt
2021-10-05 22:41:50 +0200lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-10-05 22:42:07 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2021-10-05 22:44:35 +0200DNH(~DNH@2a02:8108:1100:16d8:d1f8:65da:debb:16ba)
2021-10-05 22:44:52 +0200ec(~ec@gateway/tor-sasl/ec) (Quit: ec)
2021-10-05 22:45:20 +0200Skyfire(~pyon@user/pyon) (Quit: WeeChat 3.3)
2021-10-05 22:45:41 +0200Skyfire(~pyon@user/pyon)
2021-10-05 22:45:49 +0200 <Guest20> basically I have no idea how to write a Spec.hs given input/output files
2021-10-05 22:46:06 +0200 <Guest20> I need to "loop" over them
2021-10-05 22:50:24 +0200michalz(~michalz@185.246.204.93) (Remote host closed the connection)
2021-10-05 22:50:47 +0200rekahsoft(~rekahsoft@2605:8d80:6e1:e79b:d89:2184:8ba7:bd43)
2021-10-05 22:51:51 +0200Guest71(~Guest71@a79-169-181-190.cpe.netcabo.pt) (Quit: Client closed)
2021-10-05 22:53:01 +0200olibiera(~olibiera@a79-169-181-190.cpe.netcabo.pt)
2021-10-05 22:53:26 +0200olibiera(~olibiera@a79-169-181-190.cpe.netcabo.pt) (Client Quit)
2021-10-05 23:00:19 +0200wonko(~wjc@62.115.229.50) (Ping timeout: 245 seconds)
2021-10-05 23:01:54 +0200gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2021-10-05 23:02:53 +0200 <dsal> Are you doing some kind of golden tests?
2021-10-05 23:04:25 +0200DNH(~DNH@2a02:8108:1100:16d8:d1f8:65da:debb:16ba) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-10-05 23:05:44 +0200mikoto-chan(~mikoto-ch@83.137.2.247) (Ping timeout: 245 seconds)
2021-10-05 23:12:36 +0200infinity0(~infinity0@occupy.ecodis.net) (Remote host closed the connection)
2021-10-05 23:12:49 +0200Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de) (Ping timeout: 245 seconds)
2021-10-05 23:13:12 +0200infinity0(~infinity0@occupy.ecodis.net)
2021-10-05 23:13:40 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-05 23:13:40 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-05 23:13:40 +0200wroathe(~wroathe@user/wroathe)
2021-10-05 23:16:39 +0200mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2021-10-05 23:19:45 +0200Pickchea(~private@user/pickchea)
2021-10-05 23:21:51 +0200Guest__(~private@185.31.55.18.dyn.kraftcom.at)
2021-10-05 23:21:59 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 245 seconds)
2021-10-05 23:23:51 +0200ubert(~Thunderbi@178.115.35.209.wireless.dyn.drei.com)
2021-10-05 23:24:27 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81d:7133:81c9:b91d)
2021-10-05 23:25:10 +0200Cajun(~Cajun@user/cajun)
2021-10-05 23:25:14 +0200olibiera(~olibiera@a79-169-181-190.cpe.netcabo.pt)
2021-10-05 23:25:29 +0200hatds(~hatds@c-107-4-136-72.hsd1.mn.comcast.net) (Quit: Leaving)
2021-10-05 23:26:43 +0200 <olibiera> hi guys, im having trouble figuring out why i cant compile this piece of code, any help would be amazing
2021-10-05 23:26:46 +0200 <olibiera> palavras :: [String]
2021-10-05 23:26:47 +0200 <olibiera> palavras = [x ++ y ++ z ++ m ++ n| x <- [a,e,i,o,u], y <- [a..z], z <- [a,e,i,o,u], m <- [a,e,i,o,u], n <- [a..z], z /= m]
2021-10-05 23:27:55 +0200 <geekosaur> for one, it looks like you missed some '' around a bunch of Char literals?
2021-10-05 23:28:08 +0200 <geekosaur> > ['a'..'z']
2021-10-05 23:28:09 +0200 <lambdabot> "abcdefghijklmnopqrstuvwxyz"
2021-10-05 23:28:23 +0200 <olibiera> oh
2021-10-05 23:28:36 +0200 <olibiera> so thats it thx
2021-10-05 23:29:09 +0200Guest__(~private@185.31.55.18.dyn.kraftcom.at) (Quit: Leaving)
2021-10-05 23:29:13 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2021-10-05 23:30:31 +0200 <monochrom> Looks like you want [x,y,z,m,n] rather than the ++ chain.
2021-10-05 23:31:03 +0200 <geekosaur> that too, it'll be a type mismatch otherwise
2021-10-05 23:31:21 +0200 <geekosaur> > 'x' ++ 'y' -- this mismatch
2021-10-05 23:31:22 +0200 <lambdabot> error:
2021-10-05 23:31:22 +0200 <lambdabot> • Couldn't match expected type ‘[a]’ with actual type ‘Char’
2021-10-05 23:31:22 +0200 <lambdabot> • In the first argument of ‘(++)’, namely ‘'x'’
2021-10-05 23:32:46 +0200 <xsperry> you could also store ['a'..'z'] and ['a','e','i','o','u'] in a variable, instead of repeating them multiple times
2021-10-05 23:32:52 +0200 <dsal> > let vowels = "aeiou"; letters = ['a' .. 'z'] in [[x,y,z,m,n] | x <- vowels, y <- letters, z <- vowels, m <- letters, n <- letters, z /= m]
2021-10-05 23:32:53 +0200 <lambdabot> ["aaaba","aaabb","aaabc","aaabd","aaabe","aaabf","aaabg","aaabh","aaabi","aa...
2021-10-05 23:33:39 +0200chomwitt(~chomwitt@94.66.61.137) (Ping timeout: 245 seconds)
2021-10-05 23:38:28 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-05 23:38:28 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-05 23:38:28 +0200wroathe(~wroathe@user/wroathe)
2021-10-05 23:39:39 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81d:7133:81c9:b91d) (Remote host closed the connection)
2021-10-05 23:43:16 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 250 seconds)
2021-10-05 23:43:45 +0200 <olibiera> how can u tag someone in the chat?
2021-10-05 23:44:37 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-05 23:45:07 +0200 <olibiera> ok nvm, dsal thx again for the help
2021-10-05 23:45:59 +0200 <[exa]> olibiera: tag like this here
2021-10-05 23:48:37 +0200acidjnk_new(~acidjnk@p200300d0c703cb83c18eec9e6894a9d9.dip0.t-ipconnect.de) (Remote host closed the connection)
2021-10-05 23:49:00 +0200acidjnk_new(~acidjnk@p200300d0c703cb83c18eec9e6894a9d9.dip0.t-ipconnect.de)
2021-10-05 23:52:19 +0200 <monochrom> No formal tagging system.
2021-10-05 23:52:58 +0200_abrantesasf_(~abrantesa@187.36.170.211)
2021-10-05 23:53:37 +0200 <geekosaur> many clients will notice names in the middle of a line, even
2021-10-05 23:53:38 +0200_abrantesasf_(~abrantesa@187.36.170.211) (Remote host closed the connection)
2021-10-05 23:53:47 +0200olibiera(~olibiera@a79-169-181-190.cpe.netcabo.pt) (Quit: Client closed)
2021-10-05 23:54:31 +0200abrantesasf(~abrantesa@187.36.170.211)
2021-10-05 23:56:49 +0200 <awpr> my hobby: configuring IRC clients to notify me when my nick is a subsequence of any message
2021-10-05 23:57:22 +0200 <Franciman> saw plotkin
2021-10-05 23:57:40 +0200 <Franciman> oh i fail'd
2021-10-05 23:58:42 +0200 <Franciman> I saw probably a good paper saying laziness helps with modularitya
2021-10-05 23:59:09 +0200DNH(~DNH@2a02:8108:1100:16d8:d1f8:65da:debb:16ba)
2021-10-05 23:59:38 +0200 <awpr> don't even need "probably" -- "sAW" "PapeR"