IRCBrowse

2023/04/28

2023-04-28 00:00:12 +0200 <monochrom> Is "Devokies" a cross between Dvorak and wookiees? >:)
2023-04-28 00:00:24 +0200 <ncf> in fact that's how Comparison's contramap is defined https://hackage.haskell.org/package/base-4.18.0.0/docs/src/Data.Functor.Contravariant.html#line-254
2023-04-28 00:01:10 +0200 <monochrom> "Dvorak's Symphony no. 10: Symphony for Wookiees"
2023-04-28 00:01:32 +0200 <jade[m]> I have yet to read up on what all the prefixed classes mean, like Pro-, Contra-, etc
2023-04-28 00:01:48 +0200 <jade[m]> as well as Bi- though I'm not that uncertain about what it means
2023-04-28 00:02:21 +0200 <geekosaur> and then you run into zygohistomorphic prepromorphisms and your head explodes
2023-04-28 00:02:46 +0200 <jade[m]> mhm
2023-04-28 00:03:31 +0200 <geekosaur> (it's more a meme than something useful 🙂 )
2023-04-28 00:03:50 +0200 <somerandomnick> profunctors are like arrows, but no1 uses arrows anymore 😭
2023-04-28 00:03:59 +0200 <jade[m]> I assumed, but this is part of why I love math
2023-04-28 00:04:08 +0200 <Rembane> It's a good head explosion though
2023-04-28 00:04:25 +0200 <jade[m]> somerandomnick: also gotta read up on that even though I have a rough idea on what it means
2023-04-28 00:04:52 +0200 <somerandomnick> (->) is an arrow
2023-04-28 00:04:54 +0200 <jade[m]> I have not yet seen applications for stuff like that besides type-theoretical stuff
2023-04-28 00:05:05 +0200 <somerandomnick> but ofc monadic notation is so much more convenient.. i get it
2023-04-28 00:05:05 +0200 <jade[m]> somerandomnick: I'm aware
2023-04-28 00:05:09 +0200elain4(~textual@2601:5c0:8200:990:e188:657f:cc6c:2c3) (Quit: Textual IRC Client: www.textualapp.com)
2023-04-28 00:05:18 +0200thegeekinside(~thegeekin@189.180.38.222) (Ping timeout: 255 seconds)
2023-04-28 00:06:11 +0200 <jade[m]> iirc an arrow is just a morphism between categories
2023-04-28 00:06:21 +0200 <jade[m]> unless that's completely wrong
2023-04-28 00:06:27 +0200 <jade[m]> which it probably is
2023-04-28 00:06:29 +0200nick4(~nick@98.186.193.170) (Read error: Connection reset by peer)
2023-04-28 00:06:38 +0200 <jade[m]> I should read up on category theory
2023-04-28 00:06:57 +0200 <int-e> arrow = morphism
2023-04-28 00:07:30 +0200 <jade[m]> ah
2023-04-28 00:07:32 +0200 <monochrom> The Arrow class is pretty different from category theory morphisms.
2023-04-28 00:07:51 +0200nick4(~nick@98.186.193.170)
2023-04-28 00:08:12 +0200 <jade[m]> I was recently disappointed to learn that hask apparently isn't a "real" category
2023-04-28 00:08:16 +0200 <int-e> I'm case-sensitive.
2023-04-28 00:08:26 +0200 <jade[m]> not that I know what it implies, just thought it was interesting
2023-04-28 00:08:27 +0200 <monochrom> One thing is there is always a conversion from (A->B) to (MyArrow A B), which doesn't hold for arbitrary categories.
2023-04-28 00:09:02 +0200 <monochrom> Another is that &&& and *** do something that is at least cartesian-closed categories, probably more.
2023-04-28 00:09:07 +0200 <somerandomnick> the arrow also didnt bring more composability, as they also fall back on transformers
2023-04-28 00:09:13 +0200 <somerandomnick> +class
2023-04-28 00:10:05 +0200 <ncf> i don't think Arrow requires closure?
2023-04-28 00:10:06 +0200 <monochrom> Hask can be a real category, if someone wrote it up.
2023-04-28 00:10:12 +0200 <somerandomnick> Hask is a category alright
2023-04-28 00:10:33 +0200 <ncf> unless it just inherits it from Hask
2023-04-28 00:10:48 +0200 <monochrom> Then again, I could be a real programmer, if I worked myself up for it. >:)
2023-04-28 00:11:23 +0200 <int-e> The `arr` function is a particular natural transformation.
2023-04-28 00:11:27 +0200 <ncf> i guess it's not clear what this should even mean
2023-04-28 00:12:11 +0200 <jade[m]> monochrom: is it so much work or are people just not interested in it
2023-04-28 00:12:33 +0200 <int-e> err
2023-04-28 00:12:37 +0200 <monochrom> Economics says the two are equivalent. >:)
2023-04-28 00:12:49 +0200 <int-e> never mind, there is no underlying functor
2023-04-28 00:13:27 +0200 <somerandomnick> int-e: its all about `fmap`
2023-04-28 00:13:29 +0200 <int-e> Arrow is weird :-P
2023-04-28 00:13:38 +0200 <monochrom> But there is a third factor. Whatever you write up, someone will disagree with part of it.
2023-04-28 00:13:44 +0200 <int-e> somerandomnick: yeah, that was just wrong.
2023-04-28 00:13:50 +0200 <somerandomnick> arrow class wont help you make Hask a category
2023-04-28 00:14:37 +0200 <int-e> It can embed some non-Hask categories into Haskell.
2023-04-28 00:15:41 +0200 <jade[m]> what I heard the issue was is seq in combination with bottom and composition
2023-04-28 00:15:50 +0200 <monochrom> But take consolation in the fact that we still haven't written up either a denotational or an operation semantics of Haskell2010. >:)
2023-04-28 00:15:51 +0200Kuttenbrunzer(~Kuttenbru@2a02:8108:8b80:1d48::28da) (Quit: Where is it)
2023-04-28 00:16:01 +0200 <ncf> presumably if you view k as a profunctor then arr :: (a -> b) -> a `k` b should be a dinatural transformation between (->) and k
2023-04-28 00:16:15 +0200 <jade[m]> https://math.andrej.com/2016/08/06/hask-is-not-a-category/
2023-04-28 00:16:16 +0200 <ncf> this probably makes sense even if you don't
2023-04-28 00:16:31 +0200 <jade[m]> this is what I read, I understood maybe 15%
2023-04-28 00:17:30 +0200 <monochrom> You only need these: "Until someone actually does some work, there is no Hask!" "I have not seen a complete construction of such a category yet."
2023-04-28 00:17:51 +0200 <jade[m]> mhm
2023-04-28 00:18:19 +0200 <int-e> `seq` is also weird
2023-04-28 00:18:24 +0200 <somerandomnick> "I told my compiler to evaluate undefined, Hask is not a category"
2023-04-28 00:18:25 +0200 <monochrom> The rest just justifies why writing up the full rigorous technical details matters.
2023-04-28 00:18:27 +0200 <somerandomnick> im so mad.
2023-04-28 00:18:40 +0200thegeekinside(~thegeekin@189.180.38.222)
2023-04-28 00:18:58 +0200 <geekosaur> and in the end nobody cares because "fast and loose reasoning is morally correct" 🙂
2023-04-28 00:19:33 +0200 <geekosaur> (oleg vs. andrej in the mathmatch of the century, anyone?)
2023-04-28 00:19:46 +0200 <int-e> talk about getting to the bottom of the issue
2023-04-28 00:19:48 +0200sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-04-28 00:19:59 +0200sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-04-28 00:20:29 +0200 <monochrom> But even then you can guess from daily experience that if people on the Internet can even fight each other over "4+2/2" then the full rigorous technical details always matter. :)
2023-04-28 00:20:49 +0200 <int-e> It's an important point... in contexts where you absolutely cannot change semantics. Like, inside a compiler.
2023-04-28 00:23:17 +0200 <int-e> "It" being basically the fact that eta-reduction can be unsound in the presence of `seq` and bottoms.
2023-04-28 00:27:08 +0200 <mauke> monochrom: apparently derived Eq instances have no semantics in Haskell2010 :-)
2023-04-28 00:27:17 +0200 <mauke> so that's cool
2023-04-28 00:35:56 +0200coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-04-28 00:36:52 +0200Me-me(~Me-me@user/me-me)
2023-04-28 00:39:28 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-196c-66e3-323f-365c.rev.sfr.net) (Remote host closed the connection)
2023-04-28 00:39:28 +0200Guest42(~Guest42@95.91.231.168) (Quit: Connection closed)
2023-04-28 00:39:28 +0200Guest75(~Guest75@95.91.231.168) (Quit: Connection closed)
2023-04-28 00:40:02 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-04-28 00:50:10 +0200jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-04-28 00:50:39 +0200jpds(~jpds@gateway/tor-sasl/jpds)
2023-04-28 01:05:02 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)
2023-04-28 01:07:27 +0200drdo(~drdo@bl14-14-164.dsl.telepac.pt) (Ping timeout: 258 seconds)
2023-04-28 01:09:12 +0200nick4(~nick@98.186.193.170) (Ping timeout: 255 seconds)
2023-04-28 01:09:17 +0200nick3(~nick@98.186.193.170)
2023-04-28 01:13:19 +0200jargon(~jargon@184.101.73.92)
2023-04-28 01:18:30 +0200Wstfgl0(~me-me@2602:ff16:3:0:1:dc:beef:d00d) (Ping timeout: 250 seconds)
2023-04-28 01:18:34 +0200tremon(~tremon@83.80.159.219) (Quit: getting boxed in)
2023-04-28 01:23:42 +0200acidjnk(~acidjnk@p200300d6e715c4337c794ccf8cdd483c.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-04-28 01:26:54 +0200Wstfgl0(~me-me@2602:ff16:3:0:1:dc:beef:d00d)
2023-04-28 01:28:11 +0200bratwurst(~dfadsva@2604:3d09:207f:f650::9c24) (Ping timeout: 248 seconds)
2023-04-28 01:31:31 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 276 seconds)
2023-04-28 01:32:05 +0200juri_(~juri@217.138.194.165)
2023-04-28 01:36:11 +0200Wstfgl0(~me-me@2602:ff16:3:0:1:dc:beef:d00d) (Read error: Connection reset by peer)
2023-04-28 01:38:29 +0200Wstfgl0(~me-me@2602:ff16:3:0:1:dc:beef:d00d)
2023-04-28 01:39:05 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2023-04-28 01:40:44 +0200segfaultfizzbuzz(~segfaultf@23.93.74.212)
2023-04-28 01:41:17 +0200mauke_(~mauke@user/mauke)
2023-04-28 01:41:44 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Quit: Leaving.)
2023-04-28 01:42:58 +0200mauke(~mauke@user/mauke) (Ping timeout: 254 seconds)
2023-04-28 01:42:58 +0200mauke_mauke
2023-04-28 01:47:31 +0200barcisz(~barcisz@79.191.75.215.ipv4.supernova.orange.pl) (Quit: Connection closed)
2023-04-28 01:48:31 +0200hochata(~user@user/hochata) (Ping timeout: 240 seconds)
2023-04-28 01:52:01 +0200Wstfgl0(~me-me@2602:ff16:3:0:1:dc:beef:d00d) (Ping timeout: 240 seconds)
2023-04-28 01:56:29 +0200 <Axman6> mauke: which semantics would you like them to have?
2023-04-28 01:58:56 +0200 <mauke> that two values are == iff they have the same constructor and their fields (if any) are all == in order
2023-04-28 01:59:19 +0200 <Axman6> is that what we want for Set?
2023-04-28 01:59:42 +0200 <Axman6> uh, I guess we're just talking about derived
2023-04-28 02:01:00 +0200 <Axman6> ok yeah it does surprise me that isn't there
2023-04-28 02:01:45 +0200Sauvin(~sauvin@user/Sauvin) (Ping timeout: 240 seconds)
2023-04-28 02:02:07 +0200Square2(~Square4@user/square)
2023-04-28 02:02:16 +0200Square(~Square4@user/square) (Remote host closed the connection)
2023-04-28 02:02:36 +0200offtherock(~blurb@96.45.2.121)
2023-04-28 02:02:49 +0200bilegeek_(~bilegeek@225.sub-174-208-233.myvzw.com) (Write error: Broken pipe)
2023-04-28 02:02:51 +0200bilegeek(~bilegeek@225.sub-174-208-233.myvzw.com)
2023-04-28 02:03:27 +0200 <mauke> it's a bit like discovering that int main(void) { int x = 0; return x; } has undefined behavior in C
2023-04-28 02:03:33 +0200rburkholder(~blurb@96.45.2.121) (Remote host closed the connection)
2023-04-28 02:07:49 +0200nick4(~nick@98.186.193.170)
2023-04-28 02:08:40 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-04-28 02:08:40 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-04-28 02:08:40 +0200wroathe(~wroathe@user/wroathe)
2023-04-28 02:09:01 +0200accord(uid568320@id-568320.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-04-28 02:09:02 +0200justsomeguy(~justsomeg@user/justsomeguy) (Quit: WeeChat 3.6)
2023-04-28 02:09:12 +0200Sauvin(~sauvin@user/Sauvin)
2023-04-28 02:09:25 +0200nick3(~nick@98.186.193.170) (Ping timeout: 240 seconds)
2023-04-28 02:10:24 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 253 seconds)
2023-04-28 02:11:33 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2023-04-28 02:17:40 +0200 <oddline> mauke: what's the UB there? I'd believe it - C has UB in the oddest places - but I just can't see where it would be?
2023-04-28 02:17:55 +0200Wauchope(~Wauchope@cpc86639-seve26-2-0-cust168.13-3.cable.virginm.net) (Remote host closed the connection)
2023-04-28 02:19:13 +0200 <mauke> no sequence point between the initialization of x and the read from x in return
2023-04-28 02:21:21 +0200bratwurst(~dfadsva@2604:3d09:207f:f650::9c24)
2023-04-28 02:21:22 +0200sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-04-28 02:22:38 +0200sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-04-28 02:23:27 +0200segfaultfizzbuzz(~segfaultf@23.93.74.212) (Ping timeout: 255 seconds)
2023-04-28 02:23:35 +0200 <int-e> mauke: Isn't the end of an initializer a sequence point?
2023-04-28 02:24:29 +0200 <mauke> if you can find something in the C standard that says so, I would sleep much better
2023-04-28 02:24:59 +0200 <mauke> the end of a statement is a sequence point, but declarations aren't statements
2023-04-28 02:25:15 +0200 <mauke> there is a sequence point at the end of each initializer expression, but 0 has no side effects anyway
2023-04-28 02:25:49 +0200Wstfgl0(~me-me@2602:ff16:3:0:1:dc:beef:d00d)
2023-04-28 02:36:01 +0200 <int-e> mauke: There's a concept of a "full expression"; an initializer is a full expression; the operand of the `return` statement is another full expression; there's a sequence point between those. Section 6.8 in the N2310 draft (also the N3096 draft), and I would be surprised if the official standard didn't have it.
2023-04-28 02:36:38 +0200zfnmxt(~zfnmxt@user/zfnmxt)
2023-04-28 02:36:40 +0200 <int-e> (And there's an appendix summarizing sequence points but I expect you'd say that that's not normative.)
2023-04-28 02:38:16 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:6cda:c72d:6503:1251)
2023-04-28 02:38:45 +0200 <int-e> (The appendix is still useful because it also talks about full expressions.)
2023-04-28 02:40:07 +0200 <Clinton[m]> Does anyone have any thoughts on this design question? https://stackoverflow.com/questions/76125393/how-to-model-a-mutable-key-value-map-in-a-monad-trans…
2023-04-28 02:42:51 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:6cda:c72d:6503:1251) (Ping timeout: 248 seconds)
2023-04-28 02:43:14 +0200 <int-e> mauke: IIUC that means that even int x = 0, y = x; is just fine. (compound literals are excluded from that rule though, I didn't quote it in full. So a[2] = {0, a[0]}; is UB)
2023-04-28 02:43:28 +0200 <int-e> mauke: err, int a[2] = ...
2023-04-28 02:44:12 +0200 <mauke> <mauke> there is a sequence point at the end of each initializer expression, but 0 has no side effects anyway
2023-04-28 02:44:33 +0200zeenk(~zeenk@2a02:2f04:a20f:5200::7fe) (Quit: Konversation terminated!)
2023-04-28 02:53:49 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-04-28 02:56:06 +0200 <zfnmxt> I need a simple library to solve a system of linear diophantine equations (so a linear equation with integer solutions/coefficients). Importantly, I don't want it to depend on any external solver, so no IO-based solvers. Does anyone have any recommendations?
2023-04-28 02:59:29 +0200 <Axman6> Well my first suggestion was going to be SBT but i guess that's out
2023-04-28 03:00:01 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 240 seconds)
2023-04-28 03:00:22 +0200 <Axman6> what's you reason for not wanting IO?
2023-04-28 03:01:01 +0200 <zfnmxt> Just annoying to deal with and I don't want that dependency.
2023-04-28 03:03:01 +0200 <zfnmxt> I'm guessing you meant SBV, not SBT, right?
2023-04-28 03:04:14 +0200nitrix(~nitrix@user/nitrix) (Quit: ZNC 1.8.2 - https://znc.in)
2023-04-28 03:04:37 +0200 <int-e> mauke: So we also need to unpack "initial value". Which at first glance is clear enough... the initial value of x is 0. x is never modified, so reading it returns 0. The language around that has actually been improved in the 3096 draft, which removes the conflicting statement that all declared variables have an undefined intial value, even when there's an initializer. I'm puzzled though what this...
2023-04-28 03:04:38 +0200 <Axman6> uh, probably
2023-04-28 03:04:43 +0200 <int-e> ...says about int x = x; now though.
2023-04-28 03:05:08 +0200 <int-e> mauke: Anyway, I'll admit that this is harder to figure out than I thought.
2023-04-28 03:05:29 +0200 <jackdk> assemble the equations into matrix-vector form and reduce to row echelon form?
2023-04-28 03:06:43 +0200 <jackdk> https://hackage.haskell.org/package/matrix-0.3.6.1/docs/Data-Matrix.html#v:rref , for example?
2023-04-28 03:07:38 +0200 <jackdk> https://hackage.haskell.org/package/hmatrix or possibly the tools in here?
2023-04-28 03:08:42 +0200 <zfnmxt> jackdk: Yeah, I thought I might have to do something like that. Just wanted to avoid the work if it's already been done 🙃
2023-04-28 03:09:00 +0200nick2(~nick@98.186.193.170)
2023-04-28 03:10:28 +0200 <zfnmxt> I think you have to use a special version of row echelon form where you don't require the leading entries to be 1. So there are annoying complications like that. But thanks, guess I'll probably end up doing that.
2023-04-28 03:10:42 +0200nick4(~nick@98.186.193.170) (Ping timeout: 255 seconds)
2023-04-28 03:10:50 +0200nitrix(~nitrix@user/nitrix)
2023-04-28 03:11:05 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-04-28 03:13:35 +0200 <jackdk> I'm not sure; that's just dividing each row by the leading value. And is it not always possible to go from row echelon to reduced row echelon?
2023-04-28 03:13:37 +0200bratwurst(~dfadsva@2604:3d09:207f:f650::9c24) (Quit: Leaving)
2023-04-28 03:15:26 +0200Wstfgl0(~me-me@2602:ff16:3:0:1:dc:beef:d00d) (Ping timeout: 246 seconds)
2023-04-28 03:17:04 +0200 <int-e> mauke: I'll stop now, but so far I have not found anything to suggest that `int x = x;` is "undefined behavior" as defined by the standard; instead it seems to unfold to "the initial value of x is the initial value of x".
2023-04-28 03:17:40 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-04-28 03:22:51 +0200Wstfgl0(~me-me@2602:ff16:3:0:1:dc:beef:d00d)
2023-04-28 03:26:38 +0200 <mauke> int-e: from what I recall, in C99 all automatic variables are created (with indeterminate values) on entry to their containing block. their initializers run when their declaration is executed
2023-04-28 03:26:52 +0200 <mauke> in that model, int x = x; has UB because it reads an indeterminate value
2023-04-28 03:30:11 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-04-28 03:34:25 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 240 seconds)
2023-04-28 03:35:29 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)
2023-04-28 03:43:19 +0200shriekingnoise(~shrieking@186.137.175.87)
2023-04-28 03:45:02 +0200sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-04-28 03:48:46 +0200sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-04-28 03:56:03 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-04-28 04:00:00 +0200xff0x(~xff0x@ai098135.d.east.v6connect.net) (Ping timeout: 248 seconds)
2023-04-28 04:00:32 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 248 seconds)
2023-04-28 04:01:40 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 276 seconds)
2023-04-28 04:08:55 +0200nick3(~nick@98.186.193.170)
2023-04-28 04:09:47 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl) (Ping timeout: 248 seconds)
2023-04-28 04:10:14 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-04-28 04:11:00 +0200nick2(~nick@98.186.193.170) (Ping timeout: 255 seconds)
2023-04-28 04:20:12 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-04-28 04:20:12 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-04-28 04:20:12 +0200wroathe(~wroathe@user/wroathe)
2023-04-28 04:28:20 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-04-28 04:29:39 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-04-28 04:32:08 +0200gmg(~user@user/gehmehgeh) (Ping timeout: 240 seconds)
2023-04-28 04:32:38 +0200gmg(~user@user/gehmehgeh)
2023-04-28 04:36:10 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:6cda:c72d:6503:1251)
2023-04-28 04:46:34 +0200nate1(~nate@98.45.169.16)
2023-04-28 04:50:22 +0200xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-04-28 04:53:10 +0200sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-04-28 04:54:16 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 258 seconds)
2023-04-28 04:54:27 +0200sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-04-28 04:55:08 +0200td_(~td@i53870923.versanet.de) (Ping timeout: 251 seconds)
2023-04-28 04:55:20 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 240 seconds)
2023-04-28 04:55:33 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 255 seconds)
2023-04-28 04:56:05 +0200td_(~td@i5387093d.versanet.de)
2023-04-28 04:57:59 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-04-28 05:06:06 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)
2023-04-28 05:08:03 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-04-28 05:08:32 +0200nick4(~nick@98.186.193.170)
2023-04-28 05:10:01 +0200jero98772(~jero98772@2800:484:1d84:9000::2) (Remote host closed the connection)
2023-04-28 05:11:16 +0200nick3(~nick@98.186.193.170) (Ping timeout: 252 seconds)
2023-04-28 05:13:45 +0200nick4(~nick@98.186.193.170) (Ping timeout: 240 seconds)
2023-04-28 05:39:05 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2023-04-28 05:49:06 +0200nate1(~nate@98.45.169.16) (Ping timeout: 254 seconds)
2023-04-28 06:00:23 +0200razetime(~quassel@43.254.111.18)
2023-04-28 06:01:07 +0200bilegeek(~bilegeek@225.sub-174-208-233.myvzw.com) (Quit: Leaving)
2023-04-28 06:03:36 +0200bilegeek(~bilegeek@225.sub-174-208-233.myvzw.com)
2023-04-28 06:04:30 +0200euandreh(~Thunderbi@189.6.18.7) (Ping timeout: 260 seconds)
2023-04-28 06:06:10 +0200bilegeek(~bilegeek@225.sub-174-208-233.myvzw.com) (Client Quit)
2023-04-28 06:12:15 +0200mtjm(~mutantmel@2604:a880:2:d0::208b:d001) (Remote host closed the connection)
2023-04-28 06:13:06 +0200mtjm(~mutantmel@2604:a880:2:d0::208b:d001)
2023-04-28 06:15:45 +0200razetime(~quassel@43.254.111.18) (Ping timeout: 240 seconds)
2023-04-28 06:15:50 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-04-28 06:20:19 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-04-28 06:21:03 +0200michalz(~michalz@185.246.207.222)
2023-04-28 06:21:03 +0200thegeekinside(~thegeekin@189.180.38.222) (Ping timeout: 255 seconds)
2023-04-28 06:32:32 +0200chiselfuse(~chiselfus@user/chiselfuse) (Ping timeout: 240 seconds)
2023-04-28 06:34:44 +0200 <segfaultfizzbuzz> https://www.ebay.com/itm/115639811711 ha
2023-04-28 06:35:04 +0200chiselfuse(~chiselfus@user/chiselfuse)
2023-04-28 06:35:07 +0200 <segfaultfizzbuzz> in the most hostile view of the world can these things have malware on them
2023-04-28 06:35:48 +0200 <segfaultfizzbuzz> used cpus, that is (amd, intel etc)
2023-04-28 06:42:32 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2023-04-28 06:45:04 +0200Bocaneri(~sauvin@user/Sauvin)
2023-04-28 06:45:20 +0200ddellacosta(~ddellacos@static-198-44-136-216.cust.tzulo.com) (Ping timeout: 248 seconds)
2023-04-28 06:45:27 +0200BocaneriGuest2961
2023-04-28 06:46:46 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 276 seconds)
2023-04-28 06:47:36 +0200Sauvin(~sauvin@user/Sauvin) (Ping timeout: 255 seconds)
2023-04-28 06:48:57 +0200mokee(~mokee@37.228.215.215)
2023-04-28 06:50:31 +0200mokee(~mokee@37.228.215.215) (Client Quit)
2023-04-28 06:51:19 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 276 seconds)
2023-04-28 06:51:23 +0200mokee(~mokee@37.228.215.215)
2023-04-28 06:52:57 +0200mokee(~mokee@37.228.215.215) (Client Quit)
2023-04-28 06:53:16 +0200mokee(~mokee@37.228.215.215)
2023-04-28 06:54:33 +0200Guest2961Sauvin
2023-04-28 07:00:37 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-04-28 07:04:01 +0200elkcl(~elkcl@broadband-37-110-27-252.ip.moscow.rt.ru) (Ping timeout: 252 seconds)
2023-04-28 07:05:34 +0200ddellaco1(~ddellacos@146.70.165.230)
2023-04-28 07:15:43 +0200fun-safe-math(~fun-safe-@c-24-22-94-205.hsd1.or.comcast.net)
2023-04-28 07:20:17 +0200jonathan_(~jonathan@h-176-10-144-60.NA.cust.bahnhof.se)
2023-04-28 07:24:15 +0200razetime(~quassel@43.254.111.18)
2023-04-28 07:36:10 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)
2023-04-28 07:36:22 +0200thegeekinside(~thegeekin@189.180.38.222)
2023-04-28 07:41:43 +0200harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67)
2023-04-28 07:42:03 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl) (Ping timeout: 248 seconds)
2023-04-28 07:45:04 +0200lightandlight(sid135476@id-135476.helmsley.irccloud.com) (Read error: Connection reset by peer)
2023-04-28 07:45:04 +0200lexi-lambda(sid92601@2a03:5180:f:4::1:69b9) (Read error: Connection reset by peer)
2023-04-28 07:45:04 +0200tnks(sid412124@id-412124.helmsley.irccloud.com) (Read error: Connection reset by peer)
2023-04-28 07:45:05 +0200hongminhee(sid295@id-295.tinside.irccloud.com) (Read error: Connection reset by peer)
2023-04-28 07:45:05 +0200sclv(sid39734@haskell/developer/sclv) (Read error: Connection reset by peer)
2023-04-28 07:45:05 +0200chessai(sid225296@id-225296.lymington.irccloud.com) (Read error: Connection reset by peer)
2023-04-28 07:45:05 +0200iphy(sid67735@id-67735.lymington.irccloud.com) (Read error: Connection reset by peer)
2023-04-28 07:45:06 +0200AndreasK(sid320732@id-320732.uxbridge.irccloud.com) (Read error: Connection reset by peer)
2023-04-28 07:45:06 +0200aristid(sid1599@id-1599.uxbridge.irccloud.com) (Read error: Connection reset by peer)
2023-04-28 07:45:06 +0200lally(sid388228@id-388228.uxbridge.irccloud.com) (Read error: Connection reset by peer)
2023-04-28 07:45:06 +0200caasih(sid13241@id-13241.ilkley.irccloud.com) (Read error: Connection reset by peer)
2023-04-28 07:45:11 +0200dmj`(sid72307@id-72307.hampstead.irccloud.com) (Ping timeout: 264 seconds)
2023-04-28 07:45:14 +0200aristid(sid1599@id-1599.uxbridge.irccloud.com)
2023-04-28 07:45:14 +0200AndreasK(sid320732@id-320732.uxbridge.irccloud.com)
2023-04-28 07:45:14 +0200pepeiborra(sid443799@id-443799.ilkley.irccloud.com) (Read error: Connection reset by peer)
2023-04-28 07:45:16 +0200totbwf(sid402332@id-402332.uxbridge.irccloud.com) (Ping timeout: 252 seconds)
2023-04-28 07:45:16 +0200snek(sid280155@id-280155.lymington.irccloud.com) (Ping timeout: 252 seconds)
2023-04-28 07:45:16 +0200b20n(sid115913@id-115913.uxbridge.irccloud.com) (Ping timeout: 252 seconds)
2023-04-28 07:45:16 +0200Firedancer(sid336191@id-336191.hampstead.irccloud.com) (Ping timeout: 252 seconds)
2023-04-28 07:45:16 +0200ysh____(sid6017@id-6017.ilkley.irccloud.com) (Ping timeout: 252 seconds)
2023-04-28 07:45:19 +0200glowcoil(sid3405@id-3405.tinside.irccloud.com) (Ping timeout: 265 seconds)
2023-04-28 07:45:20 +0200chessai(sid225296@id-225296.lymington.irccloud.com)
2023-04-28 07:45:20 +0200lexi-lambda(sid92601@id-92601.hampstead.irccloud.com)
2023-04-28 07:45:20 +0200hongminhee(sid295@id-295.tinside.irccloud.com)
2023-04-28 07:45:20 +0200tnks(sid412124@id-412124.helmsley.irccloud.com)
2023-04-28 07:45:21 +0200sclv(sid39734@haskell/developer/sclv)
2023-04-28 07:45:21 +0200iphy(sid67735@id-67735.lymington.irccloud.com)
2023-04-28 07:45:21 +0200caasih(sid13241@id-13241.ilkley.irccloud.com)
2023-04-28 07:45:21 +0200lally(sid388228@id-388228.uxbridge.irccloud.com)
2023-04-28 07:45:21 +0200lightandlight(sid135476@id-135476.helmsley.irccloud.com)
2023-04-28 07:45:29 +0200pepeiborra(sid443799@id-443799.ilkley.irccloud.com)
2023-04-28 07:46:21 +0200glowcoil(sid3405@id-3405.tinside.irccloud.com)
2023-04-28 07:46:23 +0200snek(sid280155@id-280155.lymington.irccloud.com)
2023-04-28 07:46:44 +0200dmj`(sid72307@id-72307.hampstead.irccloud.com)
2023-04-28 07:48:25 +0200b20n(sid115913@id-115913.uxbridge.irccloud.com)
2023-04-28 07:48:25 +0200ysh____(sid6017@id-6017.ilkley.irccloud.com)
2023-04-28 07:48:25 +0200Firedancer(sid336191@id-336191.hampstead.irccloud.com)
2023-04-28 07:48:26 +0200totbwf(sid402332@id-402332.uxbridge.irccloud.com)
2023-04-28 07:49:46 +0200trev(~trev@user/trev)
2023-04-28 07:50:32 +0200tcard(~tcard@2400:4051:5801:7500:cf17:befc:ff82:5303) (Quit: Leaving)
2023-04-28 07:52:55 +0200tcard(~tcard@2400:4051:5801:7500:cf17:befc:ff82:5303)
2023-04-28 07:53:44 +0200slack1256(~slack1256@186.11.11.208)
2023-04-28 07:56:08 +0200 <slack1256> I got a GUI program for a pomodoro timer. I need to emit the /ding/ sound when the timers is up. Other packages call mplayer directly over a mp3. To avoid runtime dependencies, is there a package that offers a more direct alternative?
2023-04-28 07:57:16 +0200akegalj(~akegalj@199-128.dsl.iskon.hr)
2023-04-28 07:58:54 +0200 <slack1256> nvm, SDL-mixer is what I want.
2023-04-28 08:14:16 +0200fun-safe-math(~fun-safe-@c-24-22-94-205.hsd1.or.comcast.net) (Quit: Leaving)
2023-04-28 08:17:25 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 240 seconds)
2023-04-28 08:19:23 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-04-28 08:23:04 +0200akegalj(~akegalj@199-128.dsl.iskon.hr) (Quit: leaving)
2023-04-28 08:29:44 +0200mncheckm(~mncheck@193.224.205.254)
2023-04-28 08:33:07 +0200jinsl(~jinsl@123.117.251.25) (Ping timeout: 252 seconds)
2023-04-28 08:33:59 +0200jinsl(~jinsl@123.117.251.25)
2023-04-28 08:35:36 +0200johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net) (Quit: ZNC - http://znc.in)
2023-04-28 08:36:05 +0200johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net)
2023-04-28 08:36:18 +0200echoreply(~echoreply@45.32.163.16) (Quit: WeeChat 2.8)
2023-04-28 08:37:12 +0200echoreply(~echoreply@45.32.163.16)
2023-04-28 08:38:27 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Quit: segfaultfizzbuzz)
2023-04-28 08:39:47 +0200johnw`(~user@76-234-69-149.lightspeed.frokca.sbcglobal.net)
2023-04-28 08:40:20 +0200johnw`(~user@76-234-69-149.lightspeed.frokca.sbcglobal.net) (Remote host closed the connection)
2023-04-28 08:40:49 +0200slack1256(~slack1256@186.11.11.208) (Ping timeout: 252 seconds)
2023-04-28 08:45:01 +0200coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-04-28 08:45:30 +0200czy(~user@host-140-25.ilcub310.champaign.il.us.clients.pavlovmedia.net)
2023-04-28 08:47:07 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:29a4:629e:d3d5:2aa)
2023-04-28 08:48:33 +0200ft(~ft@p4fc2a88b.dip0.t-ipconnect.de) (Quit: leaving)
2023-04-28 09:00:19 +0200phma(~phma@67.44.208.163) (Read error: Connection reset by peer)
2023-04-28 09:01:03 +0200phma(phma@2001:5b0:211c:9778:71a0:7bbd:aef8:6f85)
2023-04-28 09:01:31 +0200sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Ping timeout: 248 seconds)
2023-04-28 09:01:56 +0200ubert(~Thunderbi@2003:ec:df15:58f9:1a2f:1ab6:a43c:6560)
2023-04-28 09:03:59 +0200ubert(~Thunderbi@2003:ec:df15:58f9:1a2f:1ab6:a43c:6560) (Client Quit)
2023-04-28 09:04:48 +0200 <geekosaur> @tell slack1256 only if you're already using SDL. if not, I just invoke paplay instead of mplayer or something else heavy (https://github.com/geekosaur/xmonad.hs/blob/skkukuk/xmonad.hs#L306-L307)
2023-04-28 09:04:48 +0200 <lambdabot> Consider it noted.
2023-04-28 09:06:42 +0200 <geekosaur> @tell slack1256 but portable really isn't a thing here aside from SDL_mixer. different command on Macs and Windows and maybe under different Linux audio systems…
2023-04-28 09:06:42 +0200 <lambdabot> Consider it noted.
2023-04-28 09:08:14 +0200vpan(~0@212.117.1.172)
2023-04-28 09:09:42 +0200crvs(~crvs@212.37.18.202)
2023-04-28 09:12:59 +0200euandreh(~Thunderbi@189.6.18.7)
2023-04-28 09:15:37 +0200razetime(~quassel@43.254.111.18) (Ping timeout: 276 seconds)
2023-04-28 09:16:44 +0200acidjnk(~acidjnk@p200300d6e715c4095c08899fd7601df9.dip0.t-ipconnect.de)
2023-04-28 09:22:09 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-04-28 09:26:17 +0200cfricke(~cfricke@user/cfricke)
2023-04-28 09:37:02 +0200czy(~user@host-140-25.ilcub310.champaign.il.us.clients.pavlovmedia.net) (Remote host closed the connection)
2023-04-28 09:38:29 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)
2023-04-28 09:38:40 +0200razetime(~quassel@43.254.111.18)
2023-04-28 09:39:58 +0200harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67) (Quit: Leaving)
2023-04-28 09:40:31 +0200thegeekinside(~thegeekin@189.180.38.222) (Ping timeout: 240 seconds)
2023-04-28 09:46:11 +0200nate1(~nate@98.45.169.16)
2023-04-28 09:49:38 +0200zeenk(~zeenk@2a02:2f04:a20f:5200::7fe)
2023-04-28 09:50:56 +0200nate1(~nate@98.45.169.16) (Ping timeout: 248 seconds)
2023-04-28 09:55:38 +0200kalj(~kalj@h-158-174-207-174.NA.cust.bahnhof.se)
2023-04-28 09:56:13 +0200razetime(~quassel@43.254.111.18) (Remote host closed the connection)
2023-04-28 09:56:40 +0200monoidal(~monoidal@2a01cb0801ce4b0086d567e14f5ca343.ipv6.abo.wanadoo.fr)
2023-04-28 09:56:42 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-04-28 09:57:51 +0200kalj(~kalj@h-158-174-207-174.NA.cust.bahnhof.se) (Client Quit)
2023-04-28 10:01:31 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-04-28 10:07:36 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:6cda:c72d:6503:1251) (Remote host closed the connection)
2023-04-28 10:08:11 +0200chanceyan(~chanceyan@user/chanceyan)
2023-04-28 10:08:21 +0200chanceyan(~chanceyan@user/chanceyan) (Client Quit)
2023-04-28 10:08:56 +0200chanceyan(~chanceyan@user/chanceyan)
2023-04-28 10:10:36 +0200 <DigitalKiwi> hi210.0
2023-04-28 10:12:47 +0200 <geekosaur> gesundheit!
2023-04-28 10:19:49 +0200barcisz(~barcisz@79.191.75.215.ipv4.supernova.orange.pl)
2023-04-28 10:20:29 +0200chanceyan(~chanceyan@user/chanceyan) (Quit: chanceyan)
2023-04-28 10:20:59 +0200jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 248 seconds)
2023-04-28 10:30:53 +0200mokee(~mokee@37.228.215.215) (Quit: Lost terminal)
2023-04-28 10:33:53 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-04-28 10:43:11 +0200chele(~chele@user/chele)
2023-04-28 10:47:15 +0200c0c0(~coco@212-51-146-137.fiber7.init7.net)
2023-04-28 10:49:11 +0200coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-04-28 10:50:14 +0200mokee(~mokee@37.228.215.215)
2023-04-28 10:51:19 +0200econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2023-04-28 10:51:20 +0200Guest45678(~Guest4567@p200300cf072e68ea6b29732cbdb21e80.dip0.t-ipconnect.de)
2023-04-28 10:51:30 +0200coot(~coot@213.134.170.228)
2023-04-28 10:52:11 +0200coot(~coot@213.134.170.228) (Remote host closed the connection)
2023-04-28 10:53:10 +0200acidjnk_new(~acidjnk@p200300d6e715c409096287d884e9e013.dip0.t-ipconnect.de)
2023-04-28 10:53:59 +0200acidjnk(~acidjnk@p200300d6e715c4095c08899fd7601df9.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-04-28 10:59:24 +0200 <DigitalKiwi> c vfrd
2023-04-28 11:00:03 +0200ac1(~aloiscoch@2001:470:69fc:105::65) (Quit: You have been kicked for being idle)
2023-04-28 11:00:03 +0200kadenwolff[m](~kadenwolf@2001:470:69fc:105::1:d97f) (Quit: You have been kicked for being idle)
2023-04-28 11:00:08 +0200flo[m]1(~flosansps@2001:470:69fc:105::1:c22d) (Quit: You have been kicked for being idle)
2023-04-28 11:08:06 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:6cda:c72d:6503:1251)
2023-04-28 11:12:32 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:6cda:c72d:6503:1251) (Ping timeout: 246 seconds)
2023-04-28 11:17:49 +0200gawen(~gawen@user/gawen) (Quit: cya)
2023-04-28 11:19:09 +0200gawen(~gawen@user/gawen)
2023-04-28 11:19:10 +0200mokee(~mokee@37.228.215.215) (Quit: off)
2023-04-28 11:20:44 +0200mokee(~mokee@37.228.215.215)
2023-04-28 11:28:14 +0200mokee(~mokee@37.228.215.215) (Quit: off)
2023-04-28 11:28:32 +0200mokee(~mokee@37.228.215.215)
2023-04-28 11:33:03 +0200Guest45678(~Guest4567@p200300cf072e68ea6b29732cbdb21e80.dip0.t-ipconnect.de) (Quit: Client closed)
2023-04-28 11:33:05 +0200mokee(~mokee@37.228.215.215) (Client Quit)
2023-04-28 11:33:22 +0200mokee(~mokee@37.228.215.215)
2023-04-28 11:46:45 +0200monoidal(~monoidal@2a01cb0801ce4b0086d567e14f5ca343.ipv6.abo.wanadoo.fr) (Quit: Client closed)
2023-04-28 11:48:30 +0200tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2023-04-28 11:49:37 +0200monoidal(~monoidal@2a01cb0801ce4b0086d567e14f5ca343.ipv6.abo.wanadoo.fr)
2023-04-28 11:52:11 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-196c-66e3-323f-365c.rev.sfr.net)
2023-04-28 11:53:33 +0200kuribas(~user@ptr-17d51em5uqcvks54820.18120a2.ip6.access.telenet.be)
2023-04-28 11:56:57 +0200barcisz(~barcisz@79.191.75.215.ipv4.supernova.orange.pl) (Quit: Connection closed)
2023-04-28 11:57:43 +0200barcisz(~barcisz@79.191.75.215.ipv4.supernova.orange.pl)
2023-04-28 12:00:10 +0200monoidal(~monoidal@2a01cb0801ce4b0086d567e14f5ca343.ipv6.abo.wanadoo.fr) (Quit: Client closed)
2023-04-28 12:00:11 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-196c-66e3-323f-365c.rev.sfr.net) (Remote host closed the connection)
2023-04-28 12:00:30 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-196c-66e3-323f-365c.rev.sfr.net)
2023-04-28 12:01:30 +0200andreas303(andreas303@is.drunk.and.ready-to.party) (Ping timeout: 260 seconds)
2023-04-28 12:01:41 +0200Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) (Quit: The Lounge - https://thelounge.chat)
2023-04-28 12:02:15 +0200Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net)
2023-04-28 12:03:06 +0200Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) (Client Quit)
2023-04-28 12:06:20 +0200mokee(~mokee@37.228.215.215) (Quit: off)
2023-04-28 12:07:03 +0200Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net)
2023-04-28 12:08:27 +0200xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 255 seconds)
2023-04-28 12:11:32 +0200L29Ah(~L29Ah@wikipedia/L29Ah)
2023-04-28 12:13:33 +0200barcisz(~barcisz@79.191.75.215.ipv4.supernova.orange.pl) (Quit: Connection closed)
2023-04-28 12:14:53 +0200gurkenglas(~gurkengla@dynamic-046-114-180-206.46.114.pool.telefonica.de)
2023-04-28 12:15:38 +0200Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) (Read error: Connection reset by peer)
2023-04-28 12:20:14 +0200Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net)
2023-04-28 12:20:49 +0200mokee(~mokee@37.228.215.215)
2023-04-28 12:22:34 +0200mokee(~mokee@37.228.215.215) (Client Quit)
2023-04-28 12:29:52 +0200Vajb(~Vajb@2001:999:40c:13d9:8e03:c3a5:f9c8:cadc) (Ping timeout: 248 seconds)
2023-04-28 12:30:22 +0200Vajb(~Vajb@2001:999:705:9eb4:3be1:37ee:6d1b:ae10)
2023-04-28 12:34:09 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-196c-66e3-323f-365c.rev.sfr.net) (Remote host closed the connection)
2023-04-28 12:39:02 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-04-28 12:39:45 +0200mc47(~mc47@xmonad/TheMC47)
2023-04-28 12:40:00 +0200cheater(~Username@user/cheater) (Quit: Going offline, see ya! (www.adiirc.com))
2023-04-28 12:40:32 +0200__monty__(~toonn@user/toonn)
2023-04-28 12:42:25 +0200Guest45678(~Guest4567@p200300cf072e68ea6b29732cbdb21e80.dip0.t-ipconnect.de)
2023-04-28 12:42:35 +0200cheater(~Username@user/cheater)
2023-04-28 12:42:57 +0200robobub(uid248673@2a03:5180:f:5::3:cb61) (Quit: Connection closed for inactivity)
2023-04-28 12:47:10 +0200cheater(~Username@user/cheater) (Client Quit)
2023-04-28 12:51:52 +0200cheater(~Username@user/cheater)
2023-04-28 12:53:41 +0200cheater(~Username@user/cheater) (Client Quit)
2023-04-28 12:54:23 +0200crvs(~crvs@212.37.18.202) (Ping timeout: 246 seconds)
2023-04-28 13:01:39 +0200Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) (Quit: The Lounge - https://thelounge.chat)
2023-04-28 13:02:08 +0200Guest45678(~Guest4567@p200300cf072e68ea6b29732cbdb21e80.dip0.t-ipconnect.de) (Quit: Client closed)
2023-04-28 13:02:13 +0200gemmaro(~user@240f:74:d1f0:1:ba1:e787:c9e:b1dc)
2023-04-28 13:04:19 +0200Typedfern(~Typedfern@60.red-83-37-32.dynamicip.rima-tde.net) (Remote host closed the connection)
2023-04-28 13:04:19 +0200typedfern_(~Typedfern@60.red-83-37-32.dynamicip.rima-tde.net) (Remote host closed the connection)
2023-04-28 13:09:46 +0200crvs(~crvs@212.37.18.202)
2023-04-28 13:14:24 +0200 <jade[m]> Is it sensible to rewrite... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/76d672b7c22a943f38d43ee430d8d17c9426…>)
2023-04-28 13:17:27 +0200 <kaol> foldMap may be a less surprising choice.
2023-04-28 13:17:50 +0200 <ncf> i think it's clarifying
2023-04-28 13:19:14 +0200 <mauke> :t maybe (pure ())
2023-04-28 13:19:15 +0200 <lambdabot> Applicative f => (a -> f ()) -> Maybe a -> f ()
2023-04-28 13:20:13 +0200 <jade[m]> that may also work
2023-04-28 13:20:18 +0200 <jade[m]> thank you
2023-04-28 13:20:54 +0200 <mauke> @let purée x = pure x
2023-04-28 13:20:55 +0200 <lambdabot> Defined.
2023-04-28 13:21:28 +0200 <mauke> :t maybe . purée
2023-04-28 13:21:29 +0200 <lambdabot> Applicative f => a1 -> (a2 -> f a1) -> Maybe a2 -> f a1
2023-04-28 13:21:58 +0200Guest67(~Guest67@ext-1-005.eduroam.chalmers.se)
2023-04-28 13:23:05 +0200Guest67(~Guest67@ext-1-005.eduroam.chalmers.se) (Client Quit)
2023-04-28 13:28:32 +0200 <[Leary]> Looks like a clear and proper use of `for_` to me. Also, the argument order also matters a lot here; the joy is in being able to write `for_ foo \bar -> do ...`, which is awkward with `maybe` / `traverse_` / `foldMap`.
2023-04-28 13:29:24 +0200Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net)
2023-04-28 13:30:02 +0200 <hpc> mauke: @let dice = randomIO? :D
2023-04-28 13:31:46 +0200 <jade[m]> god, I love when and unless
2023-04-28 13:32:47 +0200 <hpc> guard is pretty nice too
2023-04-28 13:36:30 +0200 <jade[m]> yup
2023-04-28 13:39:18 +0200barcisz(~barcisz@79.191.75.215.ipv4.supernova.orange.pl)
2023-04-28 13:41:41 +0200 <jade[m]> I don't know why I'm so hung up in the aesthetics of code ....... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/12c33ab470945bdf271adef23f82b88ccecf…>)
2023-04-28 13:41:46 +0200monoidal(~monoidal@2a01cb0801ce4b009fd62379833425c7.ipv6.abo.wanadoo.fr)
2023-04-28 13:43:53 +0200barcisz28(~barcisz@public-gprs527309.centertel.pl)
2023-04-28 13:43:55 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-04-28 13:44:29 +0200 <mauke> I like the first one
2023-04-28 13:45:24 +0200 <[Leary]> You use `whenM` so that you don't have to make this decision. Otherwise the first one. It's the most clear and obvious, and you get to give you condition a nice name.
2023-04-28 13:47:12 +0200barcisz(~barcisz@79.191.75.215.ipv4.supernova.orange.pl) (Ping timeout: 248 seconds)
2023-04-28 13:47:40 +0200nate1(~nate@98.45.169.16)
2023-04-28 13:48:06 +0200 <jade[m]> ok now
2023-04-28 13:48:33 +0200 <jade[m]> ```
2023-04-28 13:48:33 +0200 <jade[m]> foo >>= (`when` $ do)
2023-04-28 13:49:06 +0200 <jade[m]> * ```... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/179a2e13baf22051eefca4c6337d83df65b3…>)
2023-04-28 13:49:07 +0200 <jade[m]> haha
2023-04-28 13:49:10 +0200 <jade[m]> * ```... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/20106cf1a969a0e55082fa6bdb52167931bd…>)
2023-04-28 13:49:10 +0200Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) (Read error: Connection reset by peer)
2023-04-28 13:49:22 +0200 <jade[m]> [Leary]: I'll probably use this one
2023-04-28 13:50:14 +0200 <[Leary]> I can only pray that you jest.
2023-04-28 13:51:13 +0200 <[Leary]> Also, since we're talking about aesthetics, you mus'n't forget your BlockArguments. They make everything better.
2023-04-28 13:51:26 +0200Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net)
2023-04-28 13:52:25 +0200barcisz2888(~barcisz@79.191.75.215.ipv4.supernova.orange.pl)
2023-04-28 13:52:29 +0200nate1(~nate@98.45.169.16) (Ping timeout: 246 seconds)
2023-04-28 13:56:01 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-04-28 13:56:29 +0200barcisz28(~barcisz@public-gprs527309.centertel.pl) (Ping timeout: 265 seconds)
2023-04-28 13:59:42 +0200skiwould prefer it if Matrix users would try not to "correct" messages, in channels bridged to IRC, such as this one
2023-04-28 14:00:01 +0200 <ski> (also not sending multi-line messages would make things simpler)
2023-04-28 14:00:26 +0200 <ski> jade[m] : fwiw, the brackets in `(Just x) -> f x' are redundant
2023-04-28 14:01:23 +0200 <ski> (and i think `for_' on `Maybe' is fine)
2023-04-28 14:02:17 +0200 <hpc> ski: eh, it's basically just an automatic pastebin i think
2023-04-28 14:02:28 +0200 <hpc> (agreed about message editing though)
2023-04-28 14:02:43 +0200monoidal(~monoidal@2a01cb0801ce4b009fd62379833425c7.ipv6.abo.wanadoo.fr) (Quit: Client closed)
2023-04-28 14:04:04 +0200gemmaro(~user@240f:74:d1f0:1:ba1:e787:c9e:b1dc) (Remote host closed the connection)
2023-04-28 14:04:15 +0200 <ski> except that people often send rather short, often incomplete, multi-line messages, a bit opposed to how people more intentionally often tend to use pastebins
2023-04-28 14:05:07 +0200 <ski> for such short things, i'd prefer seeing one long single message, or a few somewhat shorter messages in succession, neither of them requiring an external link lookup
2023-04-28 14:06:26 +0200 <yushyin> i usually ignore links without any context, thus if the multiline message starts with 'Hi .... (full message at <...>)' i tend to ignore it
2023-04-28 14:06:27 +0200 <ski> (still, the editing is the more annoying aspect, true)
2023-04-28 14:06:46 +0200 <ski> yea, good point
2023-04-28 14:07:04 +0200Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) (Quit: The Lounge - https://thelounge.chat)
2023-04-28 14:08:29 +0200 <ski> (fwiw, i also think up to around ten lines of code pasted into a channel is fine ..)
2023-04-28 14:09:56 +0200 <yushyin> for me personally the soft limit on this is 3 lines, the hard limit is 5 lines
2023-04-28 14:10:58 +0200Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net)
2023-04-28 14:11:48 +0200 <ski> sometimes i do enter multiple lines in succession, with indentation and all. but i don't paste them, i type them as-is, into the IRC client
2023-04-28 14:12:34 +0200jpds1(~jpds@gateway/tor-sasl/jpds)
2023-04-28 14:14:32 +0200jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 240 seconds)
2023-04-28 14:17:03 +0200 <somerandomnick> I want to point my matterbridge at matrix instead of IRC. what is the endpoint for that
2023-04-28 14:17:38 +0200 <somerandomnick> @where matrix
2023-04-28 14:17:38 +0200 <lambdabot> I know nothing about matrix.
2023-04-28 14:21:44 +0200ubert(~Thunderbi@2a02:8109:abc0:6434:2f3a:6587:811:db87)
2023-04-28 14:23:09 +0200titibandit(~titibandi@user/titibandit)
2023-04-28 14:23:44 +0200 <__monty__> somerandomnick: Is `#haskell:libera.chat` what you're looking for?
2023-04-28 14:24:56 +0200Guest42100(~Guest42@95.91.231.168)
2023-04-28 14:26:15 +0200barcisz2888(~barcisz@79.191.75.215.ipv4.supernova.orange.pl) (Quit: Connection closed)
2023-04-28 14:26:31 +0200Typedfern(~Typedfern@60.red-83-37-32.dynamicip.rima-tde.net)
2023-04-28 14:26:36 +0200barcisz2888(~barcisz@79.191.75.215.ipv4.supernova.orange.pl)
2023-04-28 14:29:43 +0200somerandomnick(~somerando@217.160.36.77) (Remote host closed the connection)
2023-04-28 14:30:32 +0200xff0x(~xff0x@ai098135.d.east.v6connect.net)
2023-04-28 14:31:55 +0200Inst_(~Inst@2601:6c4:4081:54f0:e436:a84f:8a3c:7b5) (Ping timeout: 250 seconds)
2023-04-28 14:35:02 +0200 <dminuoso> It finally occured to me why JSON is so popular.
2023-04-28 14:35:12 +0200bontaq(~user@ool-45779b84.dyn.optonline.net)
2023-04-28 14:35:34 +0200 <dminuoso> Deep inside programmers long for ADTs in languages with fairly poor or unergonomic ways to make simple sum or product types.
2023-04-28 14:36:49 +0200 <yushyin> lol
2023-04-28 14:38:48 +0200somerandomnick(~somerando@217.160.36.77)
2023-04-28 14:39:08 +0200somerandomnick[m(~somerando@2001:470:69fc:105::3:4f2e)
2023-04-28 14:39:44 +0200somerandomnick(~somerando@217.160.36.77) (Remote host closed the connection)
2023-04-28 14:41:40 +0200 <lortabac> I don't get it. JSON is more or less serialized JavaScript values. Where are the ADT's?
2023-04-28 14:42:26 +0200 <somerandomnick[m> @ping
2023-04-28 14:42:26 +0200 <lambdabot> pong
2023-04-28 14:43:03 +0200 <dminuoso> lortabac: Oh you can encode ADTs with it just fine.
2023-04-28 14:43:05 +0200 <lortabac> (I do agree that all programmers unconsciously long for sum types, but what's the relation with JSON?)
2023-04-28 14:44:07 +0200 <dminuoso> Oh I was just staring at another JSON configuration file, and it occured to me that the reason its used widely, is because JSON is usually directly mapped to types that embody untyped/unbounded ADTs.
2023-04-28 14:44:16 +0200acidjnk_new(~acidjnk@p200300d6e715c409096287d884e9e013.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
2023-04-28 14:45:09 +0200 <dminuoso> But you're right, this isnt about JSON necessarily - though its syntax is generally very closely mirrored in many modern languages with attribute sets, lists, etc
2023-04-28 14:45:13 +0200 <lortabac> I think you are inverting cause and effect, JSON is popular because it's just JavaScript, it doesn't require you to learn a new syntax
2023-04-28 14:46:22 +0200 <lortabac> and that kind of "ADT" encoding is very common in the JS world
2023-04-28 14:46:31 +0200 <somerandomnick[m> [discord] <s​rn777> @ping
2023-04-28 14:50:12 +0200 <somerandomnick[m> @ping
2023-04-28 14:50:12 +0200 <lambdabot> pong
2023-04-28 14:50:27 +0200 <ski> you're bridging Discord, now ?
2023-04-28 14:51:16 +0200 <somerandomnick[m> im on discord, yes. going over matrix.org is very slow tho
2023-04-28 14:52:25 +0200 <ski> personally, i'd prefer not bridging this channel to Discord
2023-04-28 14:52:35 +0200 <yushyin> ^
2023-04-28 14:53:12 +0200 <somerandomnick[m> its a private server. just me and my different personas talking to you
2023-04-28 14:53:20 +0200 <yushyin> it's also against discord's TOS
2023-04-28 14:53:42 +0200 <ski> Discord still keeps complete logs, and mines it for data
2023-04-28 14:53:52 +0200gemmaro(~user@240f:74:d1f0:1:ba1:e787:c9e:b1dc)
2023-04-28 14:54:08 +0200 <probie> They can already scrape https://ircbrowse.tomsmeding.com/browse/lchaskell if they want that
2023-04-28 14:55:21 +0200 <somerandomnick[m> this is a public chat
2023-04-28 14:55:23 +0200 <ski> i doubt they'll go to the trouble to automatically identify and scrape third-party logs
2023-04-28 14:55:24 +0200vpan(~0@212.117.1.172) (Quit: Leaving.)
2023-04-28 14:55:33 +0200 <somerandomnick[m> i choose matterbridge as my client to matrix chat
2023-04-28 14:56:18 +0200kalj(~kalj@h-158-174-207-174.NA.cust.bahnhof.se)
2023-04-28 14:56:33 +0200 <somerandomnick[m> hajimemashite
2023-04-28 14:58:48 +0200 <merijn> Anyone know if there's a more accessible version of "What Every Computer Scientist Should Know About Floating-Point Arithmetic"? I don't actually care about all the theorems and proofs, I just want some useful guidance on how to improve my accracy >.>
2023-04-28 14:59:05 +0200 <ski> @where floating-point
2023-04-28 14:59:05 +0200 <lambdabot> "What Every Programmer Should Know About Floating-Point Arithmetic" at <http://floating-point-gui.de/> and "What Every Computer Scientist Should Know About Floating-Point Arithmetic" by David
2023-04-28 14:59:05 +0200 <lambdabot> Goldberg in 1991 at <http://docs.sun.com/source/806-3568/ncg_goldberg.html> and <http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.102.244>
2023-04-28 15:00:01 +0200 <merijn> ski: did you just link the exact thing I mentioned *not* wanting? :p
2023-04-28 15:00:07 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 276 seconds)
2023-04-28 15:00:38 +0200 <ski> the first link might be applicable ?
2023-04-28 15:00:38 +0200 <merijn> ski: I'm reading that one right now, but it's too much theorem and proof and not enough actionable advice
2023-04-28 15:01:54 +0200 <merijn> ski: I mean, not really? That first link is like "explaining first year programmers why 0.1+0.2 is not 0.3". My questions are more: given a whole bunch of FP math, how do I minimise the introduce FP error
2023-04-28 15:02:54 +0200 <dminuoso> probie: Legally that's a different thing.
2023-04-28 15:02:58 +0200 <merijn> Like, I know how IEEE-754 representation works and why problems occur. I just don't know actionable advise for *minimising* my error over large computations
2023-04-28 15:04:58 +0200 <kuribas> merijn: There is software that can help with that
2023-04-28 15:05:29 +0200 <kuribas> it was in schema I believe...
2023-04-28 15:05:46 +0200 <merijn> Herbie?
2023-04-28 15:05:58 +0200 <ski> hmm .. sounds like you want a practical intro to numerical analysis concepts like numerical stability, well-conditioning, &c. ?
2023-04-28 15:06:17 +0200 <kuribas> merijn: yeah
2023-04-28 15:06:33 +0200 <probie> The textbook my university chose for "High Performance Scientific Computing" used to have a reasonable chapter on this, but the name of it escapes me
2023-04-28 15:06:36 +0200 <merijn> kuribas: I was looking at that too, but I need to gather approximate input ranges first
2023-04-28 15:06:36 +0200 <kuribas> merijn: also the beginning of Numerical Methods for scientists and engineers is good
2023-04-28 15:06:55 +0200 <kuribas> mostly basic stuff though.
2023-04-28 15:07:51 +0200 <merijn> I have some fairly basic stuff which has some number ranges which making my spidey-sense tingle
2023-04-28 15:10:57 +0200phma(phma@2001:5b0:211c:9778:71a0:7bbd:aef8:6f85) (Read error: Connection reset by peer)
2023-04-28 15:11:05 +0200 <merijn> ski: Possibly, I could probably use a decent intro in numerical stuff anyway, but it's hard to find good text books :p
2023-04-28 15:11:42 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:6cda:c72d:6503:1251)
2023-04-28 15:11:50 +0200phma(phma@2001:5b0:2143:d3b8:7a30:9fcb:3105:385a)
2023-04-28 15:12:29 +0200 <kuribas> merijn: https://www.amazon.com/Numerical-Methods-Scientists-Engineers-Mathematics/dp/0486652416
2023-04-28 15:13:35 +0200Guest42100(~Guest42@95.91.231.168) (Quit: Connection closed)
2023-04-28 15:15:07 +0200Guest4233(~Guest42@95.91.231.168)
2023-04-28 15:16:05 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:6cda:c72d:6503:1251) (Ping timeout: 246 seconds)
2023-04-28 15:16:08 +0200 <merijn> That is...surprisingly cheap :p
2023-04-28 15:16:31 +0200Guest4233(~Guest42@95.91.231.168) (Client Quit)
2023-04-28 15:17:25 +0200jpds1jpds
2023-04-28 15:19:03 +0200 <merijn> Anyway, it seems like the magical keyword I need is "Kahan summation" :p
2023-04-28 15:20:41 +0200andreas303(andreas303@is.drunk.and.ready-to.party)
2023-04-28 15:20:51 +0200Square2Square
2023-04-28 15:26:24 +0200 <probie> merijn: oh man, that brings back traumatic memories
2023-04-28 15:26:42 +0200ft(~ft@p4fc2a88b.dip0.t-ipconnect.de)
2023-04-28 15:27:06 +0200jero98772(~jero98772@2800:484:1d84:9000::2)
2023-04-28 15:27:39 +0200 <merijn> "Ah, cool, I see you're using your personal development budget to learn about numerical methods and stochastic differential equations! Which project are you using this?"
2023-04-28 15:27:59 +0200 <merijn> 'I'm optimising math about a videogame...' >.>
2023-04-28 15:36:20 +0200 <lortabac> merijn: do you know the math-functions package?
2023-04-28 15:36:30 +0200 <lortabac> @hackage math-functions
2023-04-28 15:36:30 +0200 <lambdabot> https://hackage.haskell.org/package/math-functions
2023-04-28 15:36:44 +0200 <somerandomnick[m> what game
2023-04-28 15:37:23 +0200 <probie> Something you may want to consider is that your CPU can likely do two fp adds and two fp muls at the same time, so for peak performance try and balance adds and multiplications so none of those execution units are sitting idle
2023-04-28 15:38:58 +0200 <merijn> lortabac: No, and also this code isn't Haskell :p But since my problem is (essentially) language agnostic and I get higher quality answers here, that's my default :p
2023-04-28 15:41:16 +0200 <lortabac> maybe it's still useful to read the code, probably quicker than reading a whole book :P
2023-04-28 15:47:09 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:29a4:629e:d3d5:2aa) (Quit: WeeChat 2.8)
2023-04-28 15:47:55 +0200ubert(~Thunderbi@2a02:8109:abc0:6434:2f3a:6587:811:db87) (Ping timeout: 248 seconds)
2023-04-28 15:51:57 +0200ubert(~Thunderbi@ip4d17361f.dynamic.kabel-deutschland.de)
2023-04-28 15:52:43 +0200vjoki(~vjoki@2a00:d880:3:1::fea1:9ae) (Quit: ...)
2023-04-28 15:53:27 +0200vjoki(~vjoki@2a00:d880:3:1::fea1:9ae)
2023-04-28 15:54:14 +0200ManofLetters[m](~manoflett@2001:470:69fc:105::3be) (Ping timeout: 246 seconds)
2023-04-28 15:54:14 +0200naine[m](~naine-env@2001:470:69fc:105::3:2e57) (Ping timeout: 246 seconds)
2023-04-28 15:54:14 +0200maralorn(~maralorn@2001:470:69fc:105::251) (Ping timeout: 246 seconds)
2023-04-28 15:54:35 +0200polykernel[m](~polykerne@user/polykernel) (Ping timeout: 246 seconds)
2023-04-28 15:54:35 +0200Clinton[m](~clintonme@2001:470:69fc:105::2:31d4) (Ping timeout: 246 seconds)
2023-04-28 15:54:56 +0200luffy[m]1(~luffyinte@2001:470:69fc:105::3:4cd5) (Ping timeout: 246 seconds)
2023-04-28 15:54:56 +0200tiagsmm[m](~tiagsmmma@2001:470:69fc:105::3:4002) (Ping timeout: 246 seconds)
2023-04-28 15:54:56 +0200joyfulmantis[m](~joyfulman@2001:470:69fc:105::3:400a) (Ping timeout: 246 seconds)
2023-04-28 15:54:56 +0200teo(~teo@user/teo) (Ping timeout: 246 seconds)
2023-04-28 15:54:56 +0200oak-(~oak-@2001:470:69fc:105::fcd) (Ping timeout: 246 seconds)
2023-04-28 15:54:56 +0200sm(~sm@plaintextaccounting/sm) (Ping timeout: 246 seconds)
2023-04-28 15:55:08 +0200Me-me(~Me-me@user/me-me) (Quit: Something has gone terribly, terribly wrong, that being that I'm not here any more.)
2023-04-28 15:58:19 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-04-28 16:01:03 +0200thegeekinside(~thegeekin@189.180.38.222)
2023-04-28 16:05:19 +0200General(~General@net-37-179-166-221.cust.vodafonedsl.it)
2023-04-28 16:06:57 +0200ManofLetters[m](~manoflett@2001:470:69fc:105::3be)
2023-04-28 16:08:40 +0200naine[m](~naine-env@2001:470:69fc:105::3:2e57)
2023-04-28 16:08:54 +0200maralorn(~maralorn@2001:470:69fc:105::251)
2023-04-28 16:09:26 +0200dumarrr^(~dumarrr@c-76-105-96-13.hsd1.ga.comcast.net) (Remote host closed the connection)
2023-04-28 16:10:03 +0200polykernel[m](~polykerne@user/polykernel)
2023-04-28 16:10:17 +0200Clinton[m](~clintonme@2001:470:69fc:105::2:31d4)
2023-04-28 16:11:37 +0200oak-(~oak-@2001:470:69fc:105::fcd)
2023-04-28 16:11:44 +0200joyfulmantis[m](~joyfulman@2001:470:69fc:105::3:400a)
2023-04-28 16:13:04 +0200tiagsmm[m](~tiagsmmma@2001:470:69fc:105::3:4002)
2023-04-28 16:14:05 +0200sm(~sm@plaintextaccounting/sm)
2023-04-28 16:14:19 +0200teo(~teo@user/teo)
2023-04-28 16:15:38 +0200kalj(~kalj@h-158-174-207-174.NA.cust.bahnhof.se) (Ping timeout: 245 seconds)
2023-04-28 16:18:30 +0200wootehfoot(~wootehfoo@user/wootehfoot)
2023-04-28 16:23:22 +0200gurkenglas(~gurkengla@dynamic-046-114-180-206.46.114.pool.telefonica.de) (Ping timeout: 252 seconds)
2023-04-28 16:25:37 +0200cheater(~Username@user/cheater)
2023-04-28 16:28:40 +0200jero98772(~jero98772@2800:484:1d84:9000::2) (Ping timeout: 260 seconds)
2023-04-28 16:38:19 +0200zaquest(~notzaques@5.130.79.72)
2023-04-28 16:41:08 +0200jero98772(~jero98772@2800:484:1d84:9000::2)
2023-04-28 16:43:12 +0200mokee(~mokee@37.228.215.215)
2023-04-28 16:49:46 +0200mokee(~mokee@37.228.215.215) (Quit: off)
2023-04-28 16:50:06 +0200mokee(~mokee@37.228.215.215)
2023-04-28 16:50:25 +0200dostoyevsky2(~sck@user/dostoyevsky2)
2023-04-28 16:51:09 +0200jinsl-(~jinsl@2408:8207:2557:88e0:211:32ff:fec8:6aea)
2023-04-28 16:51:18 +0200cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.8)
2023-04-28 16:51:19 +0200mokee(~mokee@37.228.215.215) (Client Quit)
2023-04-28 16:51:25 +0200jinsl(~jinsl@123.117.251.25) (Ping timeout: 252 seconds)
2023-04-28 16:51:28 +0200 <dostoyevsky2> https://github.com/ButlerOS/haskell-butler <- are there any particular distributed features in Haskell that made this virtual/distributed OS possible?
2023-04-28 16:51:32 +0200luffy[m]1(~luffyinte@2001:470:69fc:105::3:4cd5)
2023-04-28 16:52:17 +0200Sgeo(~Sgeo@user/sgeo)
2023-04-28 16:57:19 +0200acidjnk_new(~acidjnk@p200300d6e715c468b4bf77e5a0595f20.dip0.t-ipconnect.de)
2023-04-28 16:58:04 +0200 <geekosaur> I'm not sure I'd say it has more features; I would say it'd be a lot harder to make mistakes using them. See for example why almost nobody uses STM outside of Haskell
2023-04-28 17:00:00 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:6cda:c72d:6503:1251)
2023-04-28 17:00:59 +0200 <ski> (expressiveness vs. "reasonability")
2023-04-28 17:05:44 +0200oats(~thomas@user/oats) (Quit: until later, my friends)
2023-04-28 17:07:51 +0200 <monochrom> implementor's freedom vs reasoner's freedom
2023-04-28 17:08:12 +0200 <monochrom> "My freedom is your slavery." :)
2023-04-28 17:08:31 +0200 <ski> rights vs. duties
2023-04-28 17:08:43 +0200 <monochrom> Yeah
2023-04-28 17:08:57 +0200 <monochrom> Programming is a dialectic class struggle between the implementor and the user.
2023-04-28 17:11:56 +0200General(~General@net-37-179-166-221.cust.vodafonedsl.it) (Ping timeout: 246 seconds)
2023-04-28 17:22:01 +0200jinsl-(~jinsl@2408:8207:2557:88e0:211:32ff:fec8:6aea) (Quit: ZNC - https://znc.in)
2023-04-28 17:26:13 +0200gurkenglas(~gurkengla@dynamic-046-114-180-206.46.114.pool.telefonica.de)
2023-04-28 17:26:52 +0200jinsl(~jinsl@123.120.170.97)
2023-04-28 17:27:45 +0200econo(uid147250@user/econo)
2023-04-28 17:30:29 +0200 <ncf> typeclass struggle
2023-04-28 17:34:43 +0200dostoyevsky2(~sck@user/dostoyevsky2) ()
2023-04-28 17:35:43 +0200pavonia(~user@user/siracusa) (Quit: Bye!)
2023-04-28 17:38:15 +0200jero98772(~jero98772@2800:484:1d84:9000::2) (Ping timeout: 250 seconds)
2023-04-28 17:39:02 +0200AlexZenon(~alzenon@178.34.150.15) (Ping timeout: 252 seconds)
2023-04-28 17:39:46 +0200Alex_test(~al_test@178.34.150.15) (Ping timeout: 252 seconds)
2023-04-28 17:44:16 +0200ubert(~Thunderbi@ip4d17361f.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2023-04-28 17:44:35 +0200AlexZenon(~alzenon@178.34.150.15)
2023-04-28 17:45:02 +0200Alex_test(~al_test@178.34.150.15)
2023-04-28 17:45:08 +0200Sgeo_(~Sgeo@user/sgeo)
2023-04-28 17:47:17 +0200Sgeo(~Sgeo@user/sgeo) (Ping timeout: 246 seconds)
2023-04-28 17:49:13 +0200nate1(~nate@98.45.169.16)
2023-04-28 17:49:46 +0200crvs(~crvs@212.37.18.202) (Read error: Connection reset by peer)
2023-04-28 17:51:12 +0200jero98772(~jero98772@2800:484:1d84:9000::2)
2023-04-28 17:53:56 +0200nate1(~nate@98.45.169.16) (Ping timeout: 246 seconds)
2023-04-28 17:53:57 +0200extor(~extor@ns3018124.ip-149-202-82.eu) (Remote host closed the connection)
2023-04-28 17:57:20 +0200chele(~chele@user/chele) (Remote host closed the connection)
2023-04-28 17:57:54 +0200General(~General@net-37-179-166-221.cust.vodafonedsl.it)
2023-04-28 17:58:14 +0200titibandit(~titibandi@user/titibandit) (Remote host closed the connection)
2023-04-28 17:58:47 +0200ddellaco1(~ddellacos@146.70.165.230) (Quit: WeeChat 3.8)
2023-04-28 18:00:07 +0200AndreiDuma[m](~andreidum@2001:470:69fc:105::3:390f) (Quit: You have been kicked for being idle)
2023-04-28 18:25:09 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-04-28 18:30:53 +0200ddellacosta(~ddellacos@146.70.165.230)
2023-04-28 18:36:54 +0200Joao003(~Joao003@2804:840:8309:0:60f9:6293:872c:15aa)
2023-04-28 18:37:09 +0200 <Joao003> Does someone actually use (<$)
2023-04-28 18:38:11 +0200 <ski> i imagine it's used with parsers, e.g.
2023-04-28 18:41:19 +0200 <Joao003> e.g. what?
2023-04-28 18:42:13 +0200 <[exa]> I use it for parsing stuff like: EmptyParens <$ string "()"
2023-04-28 18:43:04 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 276 seconds)
2023-04-28 18:43:11 +0200 <Joao003> (<$>) only maps over the last type variable
2023-04-28 18:43:25 +0200 <Joao003> That's why it maps over the entirety of a list
2023-04-28 18:44:01 +0200General(~General@net-37-179-166-221.cust.vodafonedsl.it) (Quit: Leaving)
2023-04-28 18:44:53 +0200 <Joao003> > fmap (*2) [1..3]
2023-04-28 18:44:54 +0200 <lambdabot> [2,4,6]
2023-04-28 18:45:53 +0200 <yushyin> usually in parser combinator code, you will see (<$) and ($>)
2023-04-28 18:46:23 +0200 <Joao003> ($>) is flip (<$)?
2023-04-28 18:46:49 +0200 <Joao003> Yes it is
2023-04-28 18:47:48 +0200 <Joao003> Is (<&>) actually used somewhere?
2023-04-28 18:48:11 +0200jero98772(~jero98772@2800:484:1d84:9000::2) (Ping timeout: 246 seconds)
2023-04-28 18:50:24 +0200 <lyxia> it can be quite neat to avoid parentheses around the lambda
2023-04-28 18:54:17 +0200 <sm> I used it yesterday in a chain of function calls that turned monadic half way through
2023-04-28 18:54:35 +0200smsent a code block: https://libera.ems.host/_matrix/media/v3/download/libera.chat/34a09009167c4901b192d49a3dfcde535f6d…
2023-04-28 18:54:36 +0200tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2023-04-28 18:59:43 +0200jero98772(~jero98772@2800:484:1d84:9000::2)
2023-04-28 19:04:12 +0200zeenk(~zeenk@2a02:2f04:a20f:5200::7fe) (Quit: Konversation terminated!)
2023-04-28 19:07:28 +0200kuribas(~user@ptr-17d51em5uqcvks54820.18120a2.ip6.access.telenet.be) (Remote host closed the connection)
2023-04-28 19:08:28 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-9891-d6f4-c1fa-3e8e.rev.sfr.net)
2023-04-28 19:17:19 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-9891-d6f4-c1fa-3e8e.rev.sfr.net) (Remote host closed the connection)
2023-04-28 19:17:37 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-9891-d6f4-c1fa-3e8e.rev.sfr.net)
2023-04-28 19:18:24 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-9891-d6f4-c1fa-3e8e.rev.sfr.net) (Remote host closed the connection)
2023-04-28 19:18:47 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-9891-d6f4-c1fa-3e8e.rev.sfr.net)
2023-04-28 19:19:20 +0200 <Joao003> lyxia: Example?
2023-04-28 19:24:18 +0200fbytez(~uid@2001:bc8:2117:100::) (Changing host)
2023-04-28 19:24:18 +0200fbytez(~uid@user/fbytez)
2023-04-28 19:29:35 +0200 <probie> Look at the example sm sent. One of my previous workplaces had a very lens-focused style that made similar use of <&> to sm and often had code which looked like `res <- foo ^. someLens & doMonadicThing <&> mapResult`.
2023-04-28 19:29:46 +0200 <ddellacosta> lol I just went looking for some examples of where I use it in one of my projects and realized I'm not sure I like most of my uses of it...but in any case Joao003 here's one place I think it's passable, at least: https://github.com/ddellacosta/automation-service/blob/119d948f3476f25fac6cd756a6e5701a2dc9fd39/sr…
2023-04-28 19:30:44 +0200 <ddellacosta> I think there I just wanted to keep the liftIO with the nextRunning call, but as others point out it tends to be about making a bit of code feel more natural, which is somewhat subjective
2023-04-28 19:30:45 +0200 <Joao003> <&> = flip (<$>)? Probably yes
2023-04-28 19:30:58 +0200 <ddellacosta> yeah I just think of it as reversing (<$>)
2023-04-28 19:32:49 +0200 <Joao003> ($) = flip (&), so logically (<$>) = flip (<&>)
2023-04-28 19:36:11 +0200 <sm> is it my imagination or does <$> have different precedence from $. I kept trying to use it and having to switch to `fmap (...) $` instead
2023-04-28 19:38:53 +0200 <probie> sm: not your imagination at all. ($) is infixr 0 and and (<$>) is infixl 4
2023-04-28 19:38:53 +0200 <xerox> sm: if you do :info ($) and :info (<$>) in ghci you can see it
2023-04-28 19:39:38 +0200 <sm> thanks! I realised that afterward but asking humans is helpful sometimes
2023-04-28 19:39:52 +0200 <probie> (&) and (<&>) are both infixl 1 so are easier to use together
2023-04-28 19:40:12 +0200 <somerandomnick[m> sm: the flesh is weak, only the machine is eternal
2023-04-28 19:40:24 +0200 <xerox> glad to be a rubber ducky
2023-04-28 19:41:21 +0200 <sm> I guess it's for a reason, but a pity that <$> breaks with $ in this aspect
2023-04-28 19:41:41 +0200 <sm> breaks consistency
2023-04-28 19:44:27 +0200 <jean-paul[m]> Anyone know of a tool for generating visualizations of type class hierarchies? I would like the reflex-dom hierarchy on my wall.
2023-04-28 19:44:40 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl) (Ping timeout: 260 seconds)
2023-04-28 19:45:47 +0200 <sm> A little real world context for new haskellers: the above code snippet looks simple now but was hard to discover, especially with HLS broken as usual. It took some time. Easier next time hopefully.
2023-04-28 19:55:58 +0200 <[exa]> jean-paul[m]: well as the first attempt you can try to throw it to dot and see
2023-04-28 19:57:15 +0200 <[exa]> jean-paul[m]: here https://www.graphviz.org/docs/layouts/dot/
2023-04-28 19:57:21 +0200 <jean-paul[m]> I don't know the name of the tool that spits out dot given a pile of haskell
2023-04-28 19:58:01 +0200 <jean-paul[m]> 🤔
2023-04-28 19:58:02 +0200 <jean-paul[m]> Do you mean "just type the graph source in yourself"?
2023-04-28 19:58:26 +0200 <jean-paul[m]> This would likely be a good learning experience but I'm not sure I can bring myself to do it.
2023-04-28 19:58:39 +0200 <[exa]> hm true that I kinda assumed
2023-04-28 19:59:06 +0200 <[exa]> afaik you might have luck sourcing the info from haddock
2023-04-28 19:59:07 +0200 <jean-paul[m]> I dunno how many edges there are but I'm gonna guess upwards of a hundred
2023-04-28 19:59:29 +0200 <geekosaur> do you want stack dot?
2023-04-28 20:00:05 +0200 <jean-paul[m]> Ah neat. I probably also want that, but that's not what I meant.
2023-04-28 20:00:09 +0200 <ddellacosta> ah yeah, I was trying to remember how I did that once at my last job. Must have been https://docs.haskellstack.org/en/stable/dependency_visualization/index.html
2023-04-28 20:00:59 +0200 <jean-paul[m]> I think want the nodes to be type classes and the edges to be "requires"
2023-04-28 20:01:46 +0200 <jean-paul[m]> Maybe I should ask ldlework how he made https://raw.githubusercontent.com/dustinlacewell/haskell-typeclass-atlas/master/atlas.png
2023-04-28 20:02:00 +0200 <ddellacosta> oh yeah this is not the typeclass hierarchy, whoops. But I swear I did that once. I had a convo about the output file with my coworkers
2023-04-28 20:05:29 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-9891-d6f4-c1fa-3e8e.rev.sfr.net) (Remote host closed the connection)
2023-04-28 20:05:52 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-9891-d6f4-c1fa-3e8e.rev.sfr.net)
2023-04-28 20:07:27 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-9891-d6f4-c1fa-3e8e.rev.sfr.net) (Remote host closed the connection)
2023-04-28 20:07:31 +0200 <jean-paul[m]> I guess it looks hand-crafted, https://github.com/dustinlacewell/haskell-typeclass-atlas/blob/master/atlas.plantuml
2023-04-28 20:07:42 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-9891-d6f4-c1fa-3e8e.rev.sfr.net)
2023-04-28 20:10:00 +0200 <ddellacosta> jean-paul[m]: aha, I think it must have been this: https://github.com/jonascarpay/calligraphy
2023-04-28 20:10:28 +0200 <ddellacosta> jean-paul[m]: lots of info here https://jonascarpay.com/posts/2022-04-26-calligraphy-tutorial.html
2023-04-28 20:10:48 +0200barcisz2888(~barcisz@79.191.75.215.ipv4.supernova.orange.pl) (Quit: Connection closed)
2023-04-28 20:11:07 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)
2023-04-28 20:11:09 +0200barcisz2888(~barcisz@79.191.75.215.ipv4.supernova.orange.pl)
2023-04-28 20:11:35 +0200Bocaneri(~sauvin@user/Sauvin)
2023-04-28 20:11:59 +0200BocaneriGuest8107
2023-04-28 20:12:28 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-9891-d6f4-c1fa-3e8e.rev.sfr.net) (Remote host closed the connection)
2023-04-28 20:13:36 +0200 <jean-paul[m]> nice, thanks
2023-04-28 20:14:43 +0200Sauvin(~sauvin@user/Sauvin) (Ping timeout: 276 seconds)
2023-04-28 20:14:55 +0200 <ddellacosta> sure thing, glad I found it again myself!
2023-04-28 20:19:49 +0200 <[exa]> wow lovely
2023-04-28 20:19:52 +0200 <[exa]> thanks guys :]
2023-04-28 20:20:22 +0200 <ddellacosta> yeah I remember it working pretty well
2023-04-28 20:21:08 +0200 <geekosaur> @where+ call-graph https://github.com/jonascarpay/calligraphy https://jonascarpay.com/posts/2022-04-26-calligraphy-tutorial.html
2023-04-28 20:21:08 +0200 <lambdabot> Okay.
2023-04-28 20:22:32 +0200jludwig(~justin@li657-110.members.linode.com) (Quit: ZNC - https://znc.in)
2023-04-28 20:24:15 +0200 <ddellacosta> nice
2023-04-28 20:33:16 +0200jade[m]uploaded an image: (215KiB) < https://libera.ems.host/_matrix/media/v3/download/matrix.org/aYSSIpMueCcDQSQhKsNWKYnp/image.png >
2023-04-28 20:33:25 +0200 <jade[m]> basically a graphics programmer
2023-04-28 20:38:04 +0200elkcl(~elkcl@broadband-37-110-27-252.ip.moscow.rt.ru)
2023-04-28 20:39:35 +0200 <[exa]> jade[m]: quality metal reminder, thx
2023-04-28 20:40:43 +0200 <eldritchcookie[m> does the socket library encrypt the messages?
2023-04-28 20:40:56 +0200 <eldritchcookie[m> is there any network library that does?
2023-04-28 20:41:32 +0200 <[exa]> eldritchcookie[m: socket does not encrypt anything by default, you want extra protocol over that such as TLS or SSL
2023-04-28 20:42:05 +0200 <Joao003> Did you know that the S combinator can be defined as \x y z -> uncurry x $ fmap y (z, z)?
2023-04-28 20:43:02 +0200 <mauke> I prefer ap
2023-04-28 20:45:54 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-04-28 20:45:54 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-04-28 20:45:54 +0200wroathe(~wroathe@user/wroathe)
2023-04-28 20:45:55 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl) (Ping timeout: 276 seconds)
2023-04-28 20:46:52 +0200 <probie> Joao003: Yes, but I also fail to see what's interesting about that definition (is it the first time you've seen the functor instance for (,)?)
2023-04-28 20:47:26 +0200 <Joao003> probie: I'm just testing out my knowledge of fmap.
2023-04-28 20:48:30 +0200 <probie> There's a functor instance on `(,) a`, so fmap applied the function to second element of the tuple, so you end up with `\x y z -> uncurry x (z, y z)` which becomes the canonical definition of S when uncurry in applied
2023-04-28 20:48:41 +0200 <probie> s/fmap applied/fmap applies/
2023-04-28 20:48:50 +0200 <probie> s/in applied/is applied/
2023-04-28 20:49:54 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-9891-d6f4-c1fa-3e8e.rev.sfr.net)
2023-04-28 20:50:41 +0200 <Joao003> `\x y z -> x z (y z)` is too vanilla for me, so I decided to use fmap.
2023-04-28 20:51:37 +0200 <mauke> > ap (f :: Expr -> Expr -> Expr) g x
2023-04-28 20:51:39 +0200 <lambdabot> f x (g x)
2023-04-28 20:52:20 +0200 <Joao003> :t ap
2023-04-28 20:52:21 +0200 <lambdabot> Monad m => m (a -> b) -> m a -> m b
2023-04-28 20:52:46 +0200 <eldritchcookie[m> why is it monad?
2023-04-28 20:52:48 +0200 <Joao003> Monads are Applicatives too, I guess.
2023-04-28 20:53:24 +0200 <eldritchcookie[m> i thought it was defined as ap = (<*>)
2023-04-28 20:53:25 +0200 <Joao003> @src Applicative
2023-04-28 20:53:25 +0200 <lambdabot> class Functor f => Applicative f where
2023-04-28 20:53:25 +0200 <lambdabot> pure :: a -> f a
2023-04-28 20:53:25 +0200 <lambdabot> (<*>) :: f (a -> b) -> f a -> f b
2023-04-28 20:53:40 +0200 <Joao003> @src ap
2023-04-28 20:53:40 +0200 <lambdabot> ap = liftM2 id
2023-04-28 20:53:45 +0200 <Joao003> liftM2 id
2023-04-28 20:53:49 +0200 <probie> `ap` predates the Applicative typeclass
2023-04-28 20:54:34 +0200 <Joao003> > ap (+) (*2) 3
2023-04-28 20:54:36 +0200 <lambdabot> 9
2023-04-28 20:54:42 +0200 <Joao003> That's S!
2023-04-28 20:54:53 +0200gurkenglas(~gurkengla@dynamic-046-114-180-206.46.114.pool.telefonica.de) (Ping timeout: 246 seconds)
2023-04-28 20:54:56 +0200pyook(~puke@user/puke) (Remote host closed the connection)
2023-04-28 20:54:56 +0200 <probie> > (+) <*> (*2) $ 3
2023-04-28 20:54:58 +0200 <lambdabot> 9
2023-04-28 20:54:59 +0200 <eldritchcookie[m> sure but isn't it planned to drop return from monad and make it applicative why not do the same thing here?
2023-04-28 20:55:18 +0200pyook(~puke@user/puke)
2023-04-28 20:55:36 +0200 <probie> :t return
2023-04-28 20:55:37 +0200 <lambdabot> Monad m => a -> m a
2023-04-28 20:55:43 +0200 <Joao003> > uncurry (+) $ fmap (*2) (3, 3)
2023-04-28 20:55:45 +0200 <lambdabot> 9
2023-04-28 20:56:15 +0200 <Joao003> @src liftM2
2023-04-28 20:56:15 +0200 <lambdabot> liftM2 f m1 m2 = do
2023-04-28 20:56:15 +0200 <lambdabot> x1 <- m1
2023-04-28 20:56:15 +0200 <lambdabot> x2 <- m2
2023-04-28 20:56:15 +0200 <lambdabot> return (f x1 x2)
2023-04-28 20:56:38 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 246 seconds)
2023-04-28 20:56:52 +0200 <mauke> @. undo src liftM2
2023-04-28 20:56:52 +0200 <Joao003> Does everyone here agree that the name `return` is misleading?
2023-04-28 20:56:52 +0200 <lambdabot> liftM2 f m1 m2 = m1 >>= \ x1 -> m2 >>= \ x2 -> return (f x1 x2)
2023-04-28 20:57:40 +0200 <probie> Changing the requirement from `Monad` to `Applicative` breaks "bad" code where the `Monad` and `Applicative` instances differ, but there is real code where that is the case
2023-04-28 20:58:07 +0200 <probie> which is why that change hasn't exactly been rushed through
2023-04-28 20:58:57 +0200 <Joao003> :t liftM2 id (+) (*2)
2023-04-28 20:58:58 +0200 <lambdabot> Num a2 => a2 -> a2
2023-04-28 20:59:49 +0200 <Joao003> Why are functions monads?
2023-04-28 21:00:11 +0200 <monochrom> Joao003: I need to share a logic joke with you.
2023-04-28 21:00:38 +0200 <monochrom> 4 logicians go to a bar. The server asks "so, is it beer for everyone?"
2023-04-28 21:00:46 +0200 <monochrom> 1st logician says "I don't know"
2023-04-28 21:00:50 +0200 <monochrom> 2nd logician says "I don't know"
2023-04-28 21:00:54 +0200 <monochrom> 3rd logician says "I don't know"
2023-04-28 21:01:04 +0200barcisz2888(~barcisz@79.191.75.215.ipv4.supernova.orange.pl) (Quit: Connection closed)
2023-04-28 21:01:05 +0200 <monochrom> 4th logician says "therefore yes!"
2023-04-28 21:01:11 +0200 <monochrom> Explain why. >:)
2023-04-28 21:01:21 +0200 <probie> Joao003: Because ((->) r) is the reader monad (sans newtype)
2023-04-28 21:01:26 +0200 <monochrom> And now to answer your question: I don't know.
2023-04-28 21:01:45 +0200 <jade[m]> Joao003: because we can provide an instance for `(->) r`
2023-04-28 21:01:47 +0200 <nitrix> monochrom, They would've said "No" if they didn't want one. Otherwise, they had to wait for everyone to answer to conclude that everyone wanted one.
2023-04-28 21:01:47 +0200 <yushyin> because you can define a lawful instance!
2023-04-28 21:02:03 +0200 <monochrom> (about the "return" question)
2023-04-28 21:02:08 +0200 <Joao003> I still don't understand
2023-04-28 21:02:12 +0200 <monochrom> Yeah nitrix :)
2023-04-28 21:02:59 +0200 <probie> Oh man, that reminds me of epistemic logic puzzles ("I don't know, I don't know, I don't know, now I know")
2023-04-28 21:03:06 +0200 <jean-paul[m]> monochrom: it's because the lion eats the zebra right?
2023-04-28 21:04:47 +0200 <monochrom> It was a cartoon/comic from Spiked Math, if you know that it once existed. It pokes fun on those induction logic puzzles "there is an island of 100 logicians..."
2023-04-28 21:04:56 +0200chexum(~quassel@gateway/tor-sasl/chexum) (Ping timeout: 240 seconds)
2023-04-28 21:04:56 +0200 <jade[m]> `(->) r` is simply a type which takes values "from" r to something else, so we can write a monad instance... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/cf4058b7b7ecd463c00893fc0d81d9cd7958…>)
2023-04-28 21:05:08 +0200 <jade[m]> just because it works
2023-04-28 21:05:35 +0200chexum(~quassel@gateway/tor-sasl/chexum)
2023-04-28 21:05:36 +0200 <monochrom> Yeah probie exactly. :)
2023-04-28 21:06:33 +0200 <jade[m]> return is trivially const (simply return = pure from the applicative instance as it should be)
2023-04-28 21:06:51 +0200 <jade[m]> and from there you can verify all laws apply
2023-04-28 21:06:55 +0200 <jade[m]> which they do
2023-04-28 21:06:58 +0200 <jade[m]> @Joao003
2023-04-28 21:06:58 +0200 <lambdabot> Unknown command, try @list
2023-04-28 21:07:12 +0200 <jade[m]> shush
2023-04-28 21:07:21 +0200tremon(~tremon@83.80.159.219)
2023-04-28 21:08:13 +0200 <Joao003> (->) r is of type a -> r -> a?
2023-04-28 21:08:55 +0200 <jade[m]> no, `(->) r a` is the same as `r -> a`
2023-04-28 21:09:10 +0200 <jade[m]> are you familiar about how value level infix functions are desugared?
2023-04-28 21:09:34 +0200 <monochrom> "(->) r" is already a type.
2023-04-28 21:09:48 +0200 <jade[m]> `(->) r` is simply `(->)` applied to one argument, namely the left side
2023-04-28 21:09:52 +0200 <monochrom> Just like you don't ask "Int is of type what?"
2023-04-28 21:09:55 +0200 <jade[m]> as a splice you could write it as `(r ->)`
2023-04-28 21:10:21 +0200 <jade[m]> monochrom: of kind `* -> *`, as `Monad` expects
2023-04-28 21:10:21 +0200 <Joao003> You can't do splices in types IIRC
2023-04-28 21:10:40 +0200 <monochrom> I don't know what "splice" means.
2023-04-28 21:10:56 +0200 <jade[m]> I wouldn't know, I just thought it could help
2023-04-28 21:11:02 +0200 <jade[m]> monochrom: `(+1)` for example
2023-04-28 21:11:04 +0200 <probie> Probably what the report would refer to as a section
2023-04-28 21:11:06 +0200 <monochrom> But Haskell totally accepts "instance Foo ((->) r)" as long as Foo is defined accordingly.
2023-04-28 21:11:13 +0200 <jade[m]> partially applying an infiy operator
2023-04-28 21:11:25 +0200 <jade[m]> probie: that's the word, my bad
2023-04-28 21:11:38 +0200 <monochrom> Whatever mental model you have now that doesn't accept "instance Foo ((->) r)", you need to throw it away.
2023-04-28 21:12:02 +0200 <monochrom> Along the same line, "instance Functor (Either e)" is totally fine.
2023-04-28 21:12:46 +0200 <monochrom> Indeed, perhaps you figure out "instance Functor (Either e)" and "instance Functor ((->) r)" first.
2023-04-28 21:13:51 +0200 <monochrom> And perhaps you just need to know that so-called "X -> Y" is syntax sugar for (->) X Y
2023-04-28 21:14:08 +0200 <monochrom> so now it's really analogous to Either A B.
2023-04-28 21:14:29 +0200 <monochrom> Actually, ((->) X) Y and (Either A) B.
2023-04-28 21:14:39 +0200 <jade[m]> think of it as `Monad` expecting a type with one 'parameter' (`* -> *`) like `Maybe`.
2023-04-28 21:14:39 +0200 <jade[m]> `(->)` expects two 'parameters' (`* -> * -> *`), so partially applying it to a generic `r` gives you a kind `* -> *`
2023-04-28 21:15:22 +0200 <Joao003> (->) is a typeclass I think
2023-04-28 21:15:27 +0200 <monochrom> No.
2023-04-28 21:15:49 +0200 <mauke> (->) is a type constructor (of 2 (type) arguments)
2023-04-28 21:15:59 +0200 <mauke> Int takes no arguments
2023-04-28 21:15:59 +0200 <monochrom> It would be like saying "Int and Either are typeclasses". No.
2023-04-28 21:16:01 +0200 <mauke> Maybe takes one
2023-04-28 21:16:30 +0200 <Joao003> mauke: So what is the type of (->)???
2023-04-28 21:16:46 +0200 <jade[m]> it does not have a type
2023-04-28 21:16:47 +0200 <monochrom> (->) is already a type.
2023-04-28 21:16:48 +0200 <ncf> :k (->)
2023-04-28 21:16:49 +0200 <lambdabot> * -> * -> *
2023-04-28 21:16:57 +0200 <monochrom> Again, you don't ask "what's the type of Int".
2023-04-28 21:16:57 +0200 <jade[m]> it only has a kind
2023-04-28 21:17:36 +0200 <Joao003> So why is it not on Hoogle if it's a type!?
2023-04-28 21:18:02 +0200 <jade[m]> that's more or less a good question, it probably should be
2023-04-28 21:18:08 +0200 <monochrom> Because Hoogle is neither complete nor final?
2023-04-28 21:18:12 +0200 <jade[m]> but it doesn't have classic documentation afaik
2023-04-28 21:18:21 +0200 <ncf> because it's built in, it's not defined anywhere
2023-04-28 21:18:27 +0200 <jade[m]> yep
2023-04-28 21:18:37 +0200 <jade[m]> though you can think of it as being
2023-04-28 21:18:40 +0200 <monochrom> It's doc is in the Haskell2010 Report
2023-04-28 21:18:50 +0200 <Joao003> (->) is the core of the language, LOL
2023-04-28 21:18:54 +0200 <jade[m]> it's nothing "special" special
2023-04-28 21:20:02 +0200 <Joao003> Type constructors are of type (->)
2023-04-28 21:20:08 +0200 <mauke> no
2023-04-28 21:20:11 +0200 <jade[m]> no
2023-04-28 21:20:24 +0200 <jade[m]> `(->)` *is* a type constructor
2023-04-28 21:20:32 +0200 <mauke> that's a different -> (for now)
2023-04-28 21:20:32 +0200 <jade[m]> it constructs types from other types
2023-04-28 21:21:05 +0200 <Joao003> Type operator? (+) is of type (->) Int ((->) Int Int)
2023-04-28 21:21:26 +0200 <jade[m]> yes, actually
2023-04-28 21:21:28 +0200 <monochrom> (+) is not a type operator.
2023-04-28 21:21:32 +0200 <jade[m]> not quite
2023-04-28 21:21:35 +0200 <jade[m]> take Num
2023-04-28 21:21:35 +0200 <Joao003> (->) is
2023-04-28 21:21:44 +0200 <jade[m]> monochrom: I think they mean the right thing
2023-04-28 21:22:02 +0200 <jade[m]> but plus is not ideal because it itself is part of a typeclass
2023-04-28 21:22:03 +0200 <jade[m]> so you'd need a constraint
2023-04-28 21:22:05 +0200 <Joao003> I was just saying that the function (+) is of type (->) Int ((-> Int Int)
2023-04-28 21:22:08 +0200 <monochrom> No, I think by now no one knows what they mean. Not even themselves.
2023-04-28 21:22:09 +0200 <Joao003> I was just saying that the function (+) is of type (->) Int ((->) Int Int)
2023-04-28 21:22:14 +0200 <Joao003> Sorry!
2023-04-28 21:22:23 +0200 <mauke> that's correct
2023-04-28 21:22:24 +0200 <jade[m]> monochrom: oh come on, don't be so mean
2023-04-28 21:22:28 +0200 <jade[m]> they are getting there
2023-04-28 21:22:49 +0200 <mauke> really, we're just playing with syntax here
2023-04-28 21:23:23 +0200 <monochrom> No. Firstly, we need to be on the same page. Secondly, that page cannot use the same word for two conflicting things.
2023-04-28 21:23:24 +0200 <Joao003> WHY CAN TYPES TAKE OTHER TYPES
2023-04-28 21:23:37 +0200 <Joao003> THIS IS BECOMING TYPE FUNCTIONS
2023-04-28 21:23:40 +0200 <mauke> :t Left 42 :: Int `Either` String
2023-04-28 21:23:41 +0200 <lambdabot> Either Int String
2023-04-28 21:23:50 +0200 <monochrom> Either that, or we need not talk to each other at all.
2023-04-28 21:23:51 +0200 <jade[m]> because `(->)` is a type-level function from types to types
2023-04-28 21:24:09 +0200 <mauke> Joao003: that's just what parameterized types are
2023-04-28 21:24:16 +0200 <probie> Joao003: the "type" of a type is called a kind
2023-04-28 21:24:41 +0200 <probie> something like Maybe is of kind * -> * (i.e it takes one type, and returns a new type)
2023-04-28 21:24:45 +0200 <jade[m]> now, do we have something like the "type" of kinds? /j
2023-04-28 21:24:53 +0200 <mauke> sorta
2023-04-28 21:25:05 +0200Square(~Square4@user/square) (Ping timeout: 240 seconds)
2023-04-28 21:25:10 +0200 <Joao003> Response to a joke? Satisfactory
2023-04-28 21:25:37 +0200 <eldritchcookie[m> if i rember correctly kinds and types are unified
2023-04-28 21:26:05 +0200 <eldritchcookie[m> so we have Int :: Type but Type is a Type
2023-04-28 21:26:51 +0200 <mauke> https://i.imgur.com/JcspoU2.jpg infinite power
2023-04-28 21:26:56 +0200 <Joao003> Either doesn't need to be it's own type, since we can have a pair of values with a boolean to determine if it's Left or Right
2023-04-28 21:27:12 +0200 <Joao003> s/it's own/its own/
2023-04-28 21:27:21 +0200 <jade[m]> what
2023-04-28 21:27:22 +0200 <eldritchcookie[m> wow
2023-04-28 21:27:29 +0200 <mauke> a + a = 2 * a
2023-04-28 21:27:33 +0200 <mauke> that's just basic algebra
2023-04-28 21:27:34 +0200 <monochrom> "called it".
2023-04-28 21:28:26 +0200 <jade[m]> without trying to be mean, it sort of feels like we're talking to chatGPT
2023-04-28 21:28:57 +0200 <Joao003> Similarly for Maybe, we can have a value with a boolean to determine if it's Just or Nothing
2023-04-28 21:29:23 +0200 <jade[m]> I don't understand what you are trying to say
2023-04-28 21:29:24 +0200 <mauke> Joao003: how do you deal with Void, which has no values?
2023-04-28 21:29:42 +0200 <Joao003> Simple: []
2023-04-28 21:29:47 +0200 <mauke> wat
2023-04-28 21:29:51 +0200 <jade[m]> what
2023-04-28 21:29:56 +0200 <mauke> [] is not of type Void
2023-04-28 21:30:03 +0200 <Joao003> Wait
2023-04-28 21:30:10 +0200 <Joao003> Void needs to be a builtin
2023-04-28 21:30:16 +0200 <jade[m]> no
2023-04-28 21:30:19 +0200 <mauke> Nothing :: Maybe Void -- is ok
2023-04-28 21:30:23 +0200 <jade[m]> data Void
2023-04-28 21:30:25 +0200 <jade[m]> right there
2023-04-28 21:30:26 +0200 <mauke> but you can't have (False, ???)
2023-04-28 21:31:07 +0200 <jade[m]> bottom ;)
2023-04-28 21:31:23 +0200 <mauke> or in Haskell 98: newtype Void = MkVoid Void
2023-04-28 21:31:24 +0200 <jade[m]> something something inhabitant of every type something something
2023-04-28 21:31:54 +0200 <jade[m]> mauke: wait, that's hilarious
2023-04-28 21:32:14 +0200 <jade[m]> but can you not have MkVoid undefined just fine?
2023-04-28 21:32:17 +0200 <Joao003> ... Why do we have tuples of three, tuples of four, and etc? Can't we just use lists?
2023-04-28 21:32:31 +0200pavonia(~user@user/siracusa)
2023-04-28 21:32:41 +0200 <geekosaur> you can't (easily) have a list whose items have different types
2023-04-28 21:32:41 +0200 <jade[m]> they are statically sized and also every element is uniquely typed
2023-04-28 21:33:01 +0200 <Joao003> Ok, pairs of pairs of pairs of pairs...
2023-04-28 21:33:12 +0200 <jade[m]> jade[m]: this suspicious is growing ever stronger
2023-04-28 21:33:13 +0200 <mauke> jade[m]: fix MkVoid == undefined
2023-04-28 21:33:17 +0200 <geekosaur> some of the other haskell-like languages do that
2023-04-28 21:33:22 +0200 <jade[m]> s/suspicious/suspicion/, s/is//
2023-04-28 21:35:03 +0200 <monochrom> I prefer "newtype D = MkD (D -> D)" :)
2023-04-28 21:35:05 +0200 <Joao003> Wait... Can we make a Turing-Complete language just from () and (,)?
2023-04-28 21:35:11 +0200 <Joao003> And functions?
2023-04-28 21:35:37 +0200 <jade[m]> the lambda calculus is turning complete
2023-04-28 21:36:18 +0200 <Joao003> How many types can we represent just using () and (,)?
2023-04-28 21:36:41 +0200 <jade[m]> infinitely many, given an infinite amount of input types
2023-04-28 21:36:57 +0200 <Joao003> True is ((),()) and False is ((),((),()))
2023-04-28 21:37:03 +0200 <geekosaur> the original turing tarpit 🙃
2023-04-28 21:37:08 +0200 <jade[m]> what are you doing
2023-04-28 21:37:11 +0200 <jade[m]> oh, I see
2023-04-28 21:37:28 +0200 <jade[m]> I don't get what you are doing
2023-04-28 21:37:30 +0200 <Joao003> Trying to make functioning types from only () and (,)
2023-04-28 21:37:46 +0200 <jade[m]> but why
2023-04-28 21:37:52 +0200 <Joao003> For fun :D
2023-04-28 21:37:52 +0200 <eldritchcookie[m> True isn't a type
2023-04-28 21:37:58 +0200wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2023-04-28 21:38:14 +0200 <Joao003> eldritchcookie[m: Bool is, that's why I made True AND False
2023-04-28 21:38:27 +0200 <jade[m]> what
2023-04-28 21:38:28 +0200 <geekosaur> but those are different types
2023-04-28 21:38:46 +0200 <geekosaur> this is not Smalltalk
2023-04-28 21:39:28 +0200 <Joao003> Ints could be represented by a sign then bits
2023-04-28 21:40:00 +0200 <geekosaur> being the pragmatic type, I have to ask: why?
2023-04-28 21:41:11 +0200 <eldritchcookie[m> which library and cryptographic algorithm do you guys recommend for confirming identity?
2023-04-28 21:41:20 +0200 <geekosaur> I'd just end up writing a preprocessor to turn something sane-ish into this language, kinda like I did with MS-BASIC back in the day
2023-04-28 21:41:24 +0200 <jade[m]> geekosaur: to be fair, that was probably what people asked when Alonzo Church created the lambda calculus
2023-04-28 21:41:35 +0200 <monochrom> ssh and openssl :)
2023-04-28 21:41:48 +0200gurkenglas(~gurkengla@dynamic-046-114-180-206.46.114.pool.telefonica.de)
2023-04-28 21:41:59 +0200 <monochrom> OK, I just mean I use them for myself. I don't know what to recommend.
2023-04-28 21:42:28 +0200 <monochrom> But I'm going to go out on a limb and say this unpopular opinion: cryptonite etc are fine.
2023-04-28 21:42:45 +0200 <monochrom> Yes yes yes vulnerable to timing attacks etc
2023-04-28 21:43:15 +0200 <monochrom> Will you users actually have a chance to try timing attacks?
2023-04-28 21:43:22 +0200 <geekosaur> tbh we don't know that it is, we just also don't know that it isn't
2023-04-28 21:43:24 +0200 <somerandomnick[m> Networking and Cryptographic Library by Bernstein
2023-04-28 21:43:51 +0200 <somerandomnick[m> marshal into C if necessary.. best crypto lib ever NaCl
2023-04-28 21:43:52 +0200 <eldritchcookie[m> i am more worried that i will have to change the implementation due to quantum computers in the not so distant future
2023-04-28 21:44:46 +0200 <geekosaur> and I've always wondered if use on a vps would be safe-ish because of herd immunity
2023-04-28 21:44:55 +0200 <somerandomnick[m> https://pqcrypto.org/
2023-04-28 21:45:23 +0200 <somerandomnick[m> well then all discrete log based is dead
2023-04-28 21:45:46 +0200 <geekosaur> (that is, how does the attacker ensure that they're getting your side channels?)
2023-04-28 21:45:55 +0200barcisz(~barcisz@79.191.75.215.ipv4.supernova.orange.pl)
2023-04-28 21:46:01 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)
2023-04-28 21:46:52 +0200 <monochrom> Yeah. It's why I think that scaremongering about timing attacks is getting old.
2023-04-28 21:46:59 +0200Guest4277(~Guest42@ip5f5be7a8.dynamic.kabel-deutschland.de)
2023-04-28 21:49:21 +0200 <monochrom> Well I guess I should be grateful for the progress implied. E.g., we no longer scaremonger about low hanging fruits like SQL injection.
2023-04-28 21:50:24 +0200daveanlooks at monochrom and wonders if there is still remote crashes in cryptonite
2023-04-28 21:50:59 +0200nate1(~nate@98.45.169.16)
2023-04-28 21:51:01 +0200 <[exa]> lol.
2023-04-28 21:51:42 +0200 <monochrom> Well if it crashes, that's a critique I can get on board.
2023-04-28 21:51:50 +0200 <davean> also, some of its timing attacks are REALLY easy - like its encoding being expodential in time
2023-04-28 21:52:12 +0200 <monochrom> OK fair if it's that bad.
2023-04-28 21:52:34 +0200 <davean> Not sure how you'd exploit that one mind you since thats the base64 IIRC
2023-04-28 21:52:41 +0200 <davean> but like, we're talking REALLY BAD
2023-04-28 21:53:00 +0200 <davean> not like as bad as you tihnk code might be, but like worse than you thought someone could write that code
2023-04-28 21:53:43 +0200 <davean> yandere: Its the base64 in memory, right?
2023-04-28 21:55:44 +0200nate1(~nate@98.45.169.16) (Ping timeout: 248 seconds)
2023-04-28 21:55:46 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-9891-d6f4-c1fa-3e8e.rev.sfr.net) (Remote host closed the connection)
2023-04-28 21:57:47 +0200Sciencentistguy0(~sciencent@hacksoc/ordinary-member)
2023-04-28 21:58:26 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-9891-d6f4-c1fa-3e8e.rev.sfr.net)
2023-04-28 22:00:01 +0200Sciencentistguy(~sciencent@hacksoc/ordinary-member) (Ping timeout: 276 seconds)
2023-04-28 22:00:01 +0200Sciencentistguy0Sciencentistguy
2023-04-28 22:04:40 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-9891-d6f4-c1fa-3e8e.rev.sfr.net) (Remote host closed the connection)
2023-04-28 22:08:10 +0200alexherbo2(~alexherbo@211.190.65.81.rev.sfr.net)
2023-04-28 22:08:45 +0200alexherbo2(~alexherbo@211.190.65.81.rev.sfr.net) (Remote host closed the connection)
2023-04-28 22:08:50 +0200jpds1(~jpds@gateway/tor-sasl/jpds)
2023-04-28 22:08:56 +0200jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 240 seconds)
2023-04-28 22:09:04 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-85e1-23ae-ea70-6ae4.rev.sfr.net)
2023-04-28 22:13:45 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-85e1-23ae-ea70-6ae4.rev.sfr.net) (Remote host closed the connection)
2023-04-28 22:14:07 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-85e1-23ae-ea70-6ae4.rev.sfr.net)
2023-04-28 22:19:14 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl) (Ping timeout: 246 seconds)
2023-04-28 22:20:18 +0200vgtw(~vgtw@user/vgtw) (Quit: ZNC - https://znc.in)
2023-04-28 22:23:11 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-85e1-23ae-ea70-6ae4.rev.sfr.net) (Remote host closed the connection)
2023-04-28 22:26:20 +0200 <yandere> I don't even benchmark against vincent's base64 anymore because i couldn't see the pixels for the benchmarks of the other b64 libraries
2023-04-28 22:26:27 +0200 <yandere> or any of his stuff, really
2023-04-28 22:27:06 +0200 <yandere> I'm begging the community to please rewrite most of his libraries
2023-04-28 22:27:58 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2023-04-28 22:28:20 +0200 <somerandomnick[m> is that the guy who wrote basement
2023-04-28 22:28:31 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-04-28 22:32:03 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-04-28 22:34:47 +0200jpds1jpds
2023-04-28 22:37:05 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 246 seconds)
2023-04-28 22:38:34 +0200Bocaneri(~sauvin@user/Sauvin)
2023-04-28 22:38:46 +0200zeenk(~zeenk@2a02:2f04:a20f:5200::7fe)
2023-04-28 22:38:58 +0200BocaneriGuest4154
2023-04-28 22:39:36 +0200 <davean> yandere: may favorite part is when someone accesses primitives explicitely marked as unsafe and doesn't follow the invariants!
2023-04-28 22:40:45 +0200Guest8107(~sauvin@user/Sauvin) (Ping timeout: 240 seconds)
2023-04-28 22:41:36 +0200 <davean> On remote data!
2023-04-28 22:45:23 +0200 <somerandomnick[m> no. the type system was supposed to save me. if your choice is to rewrite cryptographic code in haskell, then why not introduce smth like a SafeInt where comparison, addition, etc. are all constant time
2023-04-28 22:45:27 +0200Sgeo_(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-04-28 22:46:17 +0200 <davean> somerandomnick[m: Huh? How does that apply? Who said we didn't already have that?
2023-04-28 22:46:33 +0200 <somerandomnick[m> OR marshal into C then you get bug fixes from "upstream"
2023-04-28 22:47:56 +0200 <somerandomnick[m> SafeInt exists?
2023-04-28 22:48:43 +0200 <davean> Well the properties you described describe Int
2023-04-28 22:49:50 +0200 <somerandomnick[m> oh snap
2023-04-28 22:49:50 +0200heraldo(~heraldo@user/heraldo)
2023-04-28 22:50:06 +0200 <somerandomnick[m> Int in GHC is timing-resistant?
2023-04-28 22:50:18 +0200 <davean> Inherently ...
2023-04-28 22:50:33 +0200 <jade[m]> isn't it in all languages?
2023-04-28 22:50:34 +0200 <davean> as are Int32, Int64, etc for the obvious reasons
2023-04-28 22:50:35 +0200rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-04-174-88-193-177.dsl.bell.ca)
2023-04-28 22:50:48 +0200 <davean> jade[m]: Almost. Some don't HAVE an "Int" exactly, like python but almost all
2023-04-28 22:50:56 +0200elkcl(~elkcl@broadband-37-110-27-252.ip.moscow.rt.ru) (Remote host closed the connection)
2023-04-28 22:50:58 +0200jludwig(~justin@li657-110.members.linode.com)
2023-04-28 22:51:05 +0200 <jade[m]> I mean they all use the same mechanism basically
2023-04-28 22:51:10 +0200 <davean> exactly
2023-04-28 22:51:16 +0200 <jean-paul[m]> IntX being constant time doesn't magically save you.
2023-04-28 22:51:16 +0200 <somerandomnick[m> is it because compairing two machine words in some CPU is constant?
2023-04-28 22:51:18 +0200 <jade[m]> behind the scenes, in terms of cpu addition and shit
2023-04-28 22:51:30 +0200 <davean> Like python is an exception but there are only a few exceptions - JS is also an exception
2023-04-28 22:51:31 +0200elkcl(~elkcl@broadband-37-110-27-252.ip.moscow.rt.ru)
2023-04-28 22:51:33 +0200Guest4154Sauvin
2023-04-28 22:51:36 +0200 <somerandomnick[m> because I dont expect addition in any CPU to be constant time
2023-04-28 22:51:44 +0200 <davean> somerandomnick[m: It absolutely is
2023-04-28 22:51:45 +0200 <geekosaur> jade[m], you haven't seen PHP, have you?
2023-04-28 22:51:48 +0200 <somerandomnick[m> but that is also a cool idea
2023-04-28 22:52:02 +0200 <somerandomnick[m> davean: I think we disagree here
2023-04-28 22:52:07 +0200 <davean> somerandomnick[m: Infact, it so much is that a lot of CPUs run their addition at 2x clock speed
2023-04-28 22:52:23 +0200 <jade[m]> geekosaur: luckily not, I fear I'm too young for that
2023-04-28 22:52:28 +0200 <davean> No, Int addition on a CPU defiantely is fixed time
2023-04-28 22:52:34 +0200Sgeo(~Sgeo@user/sgeo)
2023-04-28 22:52:41 +0200 <geekosaur> and has been since early CPUs
2023-04-28 22:52:50 +0200 <geekosaur> unless you count very early bit-slice cpus
2023-04-28 22:52:54 +0200 <davean> You would have to do a LOT of work for it not to be
2023-04-28 22:52:58 +0200 <jean-paul[m]> Your application logic on top of Int addition to handle overflow is what's not constant time.
2023-04-28 22:53:16 +0200 <jean-paul[m]> Your naive ByteString comparisons are what's not constant time.
2023-04-28 22:53:31 +0200 <jade[m]> davean: for the same sized integers, right? it'll always be an and with a carry bit xor
2023-04-28 22:53:39 +0200 <jean-paul[m]> All of your early-terminating-depending-on-input algorithms are what's not constant time.
2023-04-28 22:53:57 +0200 <davean> jean-paul[m]: exactly.
2023-04-28 22:54:09 +0200 <davean> Just your standard triangle cascade
2023-04-28 22:54:45 +0200 <davean> JS isn't constant time because it uses Double, Double is VERY different
2023-04-28 22:55:08 +0200 <davean> Python isn't because A) it does a lot of sharing tricks, B) it falls through to an Interger (IIRC)
2023-04-28 22:55:15 +0200 <jade[m]> IEEE754 :3
2023-04-28 22:55:48 +0200 <davean> These are the basics though
2023-04-28 22:59:58 +0200elkcl(~elkcl@broadband-37-110-27-252.ip.moscow.rt.ru) (Remote host closed the connection)
2023-04-28 23:01:03 +0200kimiamania(~65804703@user/kimiamania) (Quit: PegeLinux)
2023-04-28 23:01:07 +0200mei(~mei@user/mei) (Ping timeout: 276 seconds)
2023-04-28 23:01:23 +0200kimiamania(~65804703@user/kimiamania)
2023-04-28 23:02:06 +0200 <somerandomnick[m> davean: I found this interesting post (yes I googled our disagreement)
2023-04-28 23:02:09 +0200 <somerandomnick[m> https://lwn.net/ml/linux-kernel/20230125012801.362496-1-ebiggers@kernel.org/
2023-04-28 23:02:16 +0200 <somerandomnick[m> he claims:
2023-04-28 23:02:23 +0200 <somerandomnick[m> According to documentation that Intel published recently [1], Intel CPUs... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/828995dd0c84901bef1f0a9f23e370e1679c…>)
2023-04-28 23:03:15 +0200 <geekosaur> bleh. I recall hearing about that
2023-04-28 23:03:26 +0200elkcl(~elkcl@broadband-37-110-27-252.ip.moscow.rt.ru)
2023-04-28 23:03:34 +0200 <geekosaur> I'm not sure you can do anything with it without full details of the microarchitecture though
2023-04-28 23:03:49 +0200 <geekosaur> which Intel protects heavily, it's trade secret if nothing else
2023-04-28 23:04:09 +0200jludwig(~justin@li657-110.members.linode.com) (Quit: ZNC - https://znc.in)
2023-04-28 23:13:57 +0200 <somerandomnick[m> you could run more additions. on pseudo random numbers. The Num instance of SafeInt would run those under the hood. then it is more noisy
2023-04-28 23:14:58 +0200 <somerandomnick[m> some numbers may be more noisy then others..
2023-04-28 23:17:52 +0200bontaq(~user@ool-45779b84.dyn.optonline.net) (Remote host closed the connection)
2023-04-28 23:22:45 +0200barcisz(~barcisz@79.191.75.215.ipv4.supernova.orange.pl) (Quit: Connection closed)
2023-04-28 23:26:44 +0200mei(~mei@user/mei)
2023-04-28 23:29:20 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 240 seconds)
2023-04-28 23:29:50 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-04-28 23:30:35 +0200michalz(~michalz@185.246.207.222) (Remote host closed the connection)
2023-04-28 23:30:40 +0200mncheckm(~mncheck@193.224.205.254) (Ping timeout: 248 seconds)
2023-04-28 23:43:52 +0200merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)
2023-04-28 23:45:59 +0200Joao003(~Joao003@2804:840:8309:0:60f9:6293:872c:15aa) (Quit: Leaving)
2023-04-28 23:47:36 +0200 <somerandomnick[m> stupid idea, I shall find the time safest instructions in arm64 and amd64 and build Num and Cmp operations on top of those primitives. Or fail loudly
2023-04-28 23:51:22 +0200 <geekosaur> which you have to do on x86_64 vfor multiple intel and amd chipsets, and on arm for a shitload of chipsets
2023-04-28 23:52:54 +0200 <somerandomnick[m> i forgor 💀
2023-04-28 23:53:22 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Quit: Lost terminal)