IRCBrowse

2021/01/04

2021-01-04 00:00:04 +0100 <Squarism> I have a heard time coming to grips with this. Why cant it work. Isnt it sufficient to say what constraints a result will have ? https://paste.ofcode.org/LGUmsU5w5f7YUBvYdpYCXX
2021-01-04 00:00:10 +0100 <Squarism> hard*
2021-01-04 00:00:12 +0100 <b4er> But the mystery is: How can you replace one for the other?
2021-01-04 00:01:16 +0100muku79(~dh@2001:16b8:a024:6200:b4dc:df80:172c:8f7) (Quit: Leaving)
2021-01-04 00:01:24 +0100tomboy64(~tomboy64@gateway/tor-sasl/tomboy64) (Remote host closed the connection)
2021-01-04 00:01:27 +0100 <b4er> With the (<$>) version, you're gonna need to evaluate the thing later. That's where the exception will take place.
2021-01-04 00:01:51 +0100tomboy64(~tomboy64@gateway/tor-sasl/tomboy64)
2021-01-04 00:03:04 +0100wagle(~wagle@quassel.wagle.io) (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.)
2021-01-04 00:03:13 +0100christo(~chris@81.96.113.213) (Ping timeout: 264 seconds)
2021-01-04 00:03:55 +0100wagle(~wagle@quassel.wagle.io)
2021-01-04 00:05:49 +0100knupfer1(~Thunderbi@200116b824c7460035b9e5cffea3d054.dip.versatel-1u1.de)
2021-01-04 00:06:38 +0100knupfer1(~Thunderbi@200116b824c7460035b9e5cffea3d054.dip.versatel-1u1.de) (Client Quit)
2021-01-04 00:07:33 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de)
2021-01-04 00:08:11 +0100halbGefressen(~halbGefre@2a02:810d:f40:2a9c:40b2:2308:84bd:8b9b)
2021-01-04 00:08:24 +0100solonarv(~solonarv@astrasbourg-653-1-252-231.w92-161.abo.wanadoo.fr) (Quit: Lost terminal)
2021-01-04 00:08:27 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 00:08:37 +0100dhil(~dhil@78.156.97.38) (Ping timeout: 264 seconds)
2021-01-04 00:09:25 +0100knupfer(~Thunderbi@mue-88-130-61-217.dsl.tropolys.de) (Ping timeout: 240 seconds)
2021-01-04 00:10:20 +0100 <b4er> Squarism, say if have `Foo (Bar ())` then how can `unpack (..) = (?? :: Bar Char)` ?
2021-01-04 00:10:35 +0100 <b4er> s/Bar/Baz
2021-01-04 00:11:19 +0100 <b4er> The class `Bar` uses universal quantification but the type Foo uses existential quantification.
2021-01-04 00:12:30 +0100 <Squarism> b4er, Hmm, i guess i need to rewire my brain a bit.
2021-01-04 00:13:50 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-01-04 00:14:12 +0100 <b4er> If you have a `Foo` defined that way, once you destruct it you must use it as an Eq and/or Show at once. That's the only thing you can do with it really
2021-01-04 00:14:34 +0100greylica(~greylica@139.28.218.148)
2021-01-04 00:16:05 +0100dirediresalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt) (Remote host closed the connection)
2021-01-04 00:19:02 +0100 <Squarism> b4er, thanks. I guess I could get it back if i throw in Typeable and do dirty casts right?
2021-01-04 00:20:11 +0100 <b4er> Isn't that what Dynamic do?
2021-01-04 00:21:44 +0100 <Squarism> Maybe, i never used that
2021-01-04 00:22:14 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr) (Ping timeout: 264 seconds)
2021-01-04 00:24:58 +0100dfeuer(~dfeuer@pool-108-18-223-60.washdc.fios.verizon.net)
2021-01-04 00:25:35 +0100neiluj_(~jco@91-167-203-101.subs.proxad.net) (Quit: leaving)
2021-01-04 00:25:42 +0100halbGefressen(~halbGefre@2a02:810d:f40:2a9c:40b2:2308:84bd:8b9b) (Quit: halbGefressen)
2021-01-04 00:25:50 +0100neiluj(~jco@91-167-203-101.subs.proxad.net)
2021-01-04 00:25:56 +0100neiluj(~jco@91-167-203-101.subs.proxad.net) (Changing host)
2021-01-04 00:25:56 +0100neiluj(~jco@unaffiliated/neiluj)
2021-01-04 00:27:14 +0100Gurkenglas(~Gurkengla@unaffiliated/gurkenglas) (Ping timeout: 260 seconds)
2021-01-04 00:27:20 +0100ransom(~c4264035@8.47.12.52)
2021-01-04 00:27:51 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89)
2021-01-04 00:28:46 +0100mouseghost(~draco@wikipedia/desperek) (Quit: mew wew)
2021-01-04 00:28:55 +0100djellemah(~djellemah@2601:5c2:100:96c:e008:b638:39fe:6a54)
2021-01-04 00:32:16 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de) (Quit: Leaving)
2021-01-04 00:34:36 +0100neiluj_(~jco@91-167-203-101.subs.proxad.net)
2021-01-04 00:36:06 +0100christo(~chris@81.96.113.213)
2021-01-04 00:37:10 +0100neiluj(~jco@unaffiliated/neiluj) (Ping timeout: 246 seconds)
2021-01-04 00:38:17 +0100neiluj_(~jco@91-167-203-101.subs.proxad.net) (Client Quit)
2021-01-04 00:38:31 +0100neiluj(~jco@91-167-203-101.subs.proxad.net)
2021-01-04 00:38:31 +0100neiluj(~jco@91-167-203-101.subs.proxad.net) (Changing host)
2021-01-04 00:38:31 +0100neiluj(~jco@unaffiliated/neiluj)
2021-01-04 00:38:49 +0100BaneAliens(~BaneAlien@cpe-75-82-164-119.socal.res.rr.com) ("WeeChat 1.7")
2021-01-04 00:38:50 +0100xff0x(~fox@2001:1a81:523c:2500:528d:7247:c11a:c6c7) (Quit: xff0x)
2021-01-04 00:38:57 +0100xff0x(~fox@2001:1a81:523c:2500:528d:7247:c11a:c6c7)
2021-01-04 00:40:40 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 00:47:14 +0100jakob_(~textual@p200300f49f0872003869e83adafdf05c.dip0.t-ipconnect.de) (Quit: My Laptop has gone to sleep. ZZZzzz…)
2021-01-04 00:47:49 +0100jakob_(~textual@p200300f49f0872003869e83adafdf05c.dip0.t-ipconnect.de)
2021-01-04 00:47:51 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com)
2021-01-04 00:48:00 +0100jakob_(~textual@p200300f49f0872003869e83adafdf05c.dip0.t-ipconnect.de) (Client Quit)
2021-01-04 00:48:33 +0100jakob_(~textual@p200300f49f0872003869e83adafdf05c.dip0.t-ipconnect.de)
2021-01-04 00:48:46 +0100jakob_(~textual@p200300f49f0872003869e83adafdf05c.dip0.t-ipconnect.de) (Client Quit)
2021-01-04 00:48:59 +0100 <ezzieyguywuf> y'all use any alternative prelude's?
2021-01-04 00:49:10 +0100 <ezzieyguywuf> I think my haskell-fu may be evolved enough to start considering this
2021-01-04 00:49:15 +0100jakob_(~textual@p200300f49f0872003869e83adafdf05c.dip0.t-ipconnect.de)
2021-01-04 00:49:32 +0100jakob_(~textual@p200300f49f0872003869e83adafdf05c.dip0.t-ipconnect.de) (Client Quit)
2021-01-04 00:50:01 +0100jakob_(~textual@p200300f49f0872003869e83adafdf05c.dip0.t-ipconnect.de)
2021-01-04 00:50:20 +0100jakob_(~textual@p200300f49f0872003869e83adafdf05c.dip0.t-ipconnect.de) (Client Quit)
2021-01-04 00:51:28 +0100 <sm[m]> You have levelled up! You have acquired the skill: Use Alternative Prelude. Would you like to try some alternative preludes now ? Yes / No
2021-01-04 00:52:26 +0100 <b4er> Maybe
2021-01-04 00:52:34 +0100 <aldum> Just
2021-01-04 00:53:07 +0100 <dsal> I just assume alternative preludes are more trouble than they're worth.
2021-01-04 00:53:23 +0100 <ezzieyguywuf> sm[m]: lol.
2021-01-04 00:53:38 +0100 <b4er> It's a good question though, I've been wondering about this too.. there seem to be quite a few ones, so I always end up using none
2021-01-04 00:53:47 +0100geowiesnot(~user@87-89-181-157.abo.bbox.fr)
2021-01-04 00:54:25 +0100 <b4er> Well, I don't go as far as using NoImplicitPrelude
2021-01-04 00:54:34 +0100 <ezzieyguywuf> I just came across relude, while working on some packaging stuff for gentoo
2021-01-04 00:54:35 +0100unlink2(~unlink2@p200300ebcf259600e4593ff5d42812d3.dip0.t-ipconnect.de) (Remote host closed the connection)
2021-01-04 00:54:45 +0100 <ezzieyguywuf> seems nice, but I dunno if it's woth the effort
2021-01-04 00:54:50 +0100 <sm[m]> Sooner or later somebody's going to break down and try it (and let us know)
2021-01-04 00:54:55 +0100 <ezzieyguywuf> lol
2021-01-04 00:54:58 +0100unlink2(~unlink2@p200300ebcf259600e4593ff5d42812d3.dip0.t-ipconnect.de)
2021-01-04 00:55:42 +0100 <sm[m]> It seems like the easiest way is work on one of the big projects that use one
2021-01-04 00:56:43 +0100 <sm[m]> I think that includes cardano and some fp complete stuff
2021-01-04 00:58:57 +0100dandart(~Thunderbi@home.dandart.co.uk) (Ping timeout: 256 seconds)
2021-01-04 00:59:22 +0100 <sm[m]> or: be doing a string of relatively easy projects and use a different prelude for each
2021-01-04 01:00:06 +0100atk(~Arch-TK@ircpuzzles/staff/Arch-TK) (Quit: Well this is unexpected.)
2021-01-04 01:00:27 +0100atk(~Arch-TK@ircpuzzles/staff/Arch-TK)
2021-01-04 01:00:43 +0100ezrakilt_(~ezrakilty@75-172-99-84.tukw.qwest.net) (Remote host closed the connection)
2021-01-04 01:02:58 +0100stef204(~stef204@unaffiliated/stef-204/x-384198)
2021-01-04 01:04:46 +0100 <b4er> I will never understand how they got Wadler to join them..
2021-01-04 01:05:37 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de) (Ping timeout: 264 seconds)
2021-01-04 01:05:39 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89) (Quit: Connection closed)
2021-01-04 01:07:51 +0100 <MarcelineVQ> "We'll pay you to do research" "okay"
2021-01-04 01:09:21 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89)
2021-01-04 01:09:46 +0100 <b4er> But, presumably, he doesn't need more money and now he's affiliated with a company that very much looks like a scam
2021-01-04 01:09:57 +0100GuerrillaMonkey(~Jeanne-Ka@static-198-54-134-170.cust.tzulo.com) (Quit: Leaving)
2021-01-04 01:12:15 +0100 <b4er> And his focus of work is/was not really cryptography or BlOcKcHaIn TeChNolOgY, so it always strikes me as really odd
2021-01-04 01:13:11 +0100 <MarcelineVQ> What makes it look like a scam to you?
2021-01-04 01:15:04 +0100 <b4er> Idk, it's very biased but the first time I heard of them was at ZuriHac talking to some of them and the vibe I got
2021-01-04 01:15:34 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 272 seconds)
2021-01-04 01:16:21 +0100 <b4er> First impression really sucked, then there's the way they market themselves. The area they work in is not necessarily helping either
2021-01-04 01:17:10 +0100 <b4er> Or the fact that they feel the need to legitimize themselves by trying to be affiliated with universities and/or Wadler
2021-01-04 01:17:32 +0100 <MarcelineVQ> Is that how they feel? :>
2021-01-04 01:17:41 +0100 <b4er> It's really difficult to put into words, but I know I'm not the only one that I know
2021-01-04 01:18:02 +0100 <b4er> MarcelineVQ, pretty sure yeah
2021-01-04 01:20:08 +0100stef204(~stef204@unaffiliated/stef-204/x-384198) (Quit: WeeChat 3.0)
2021-01-04 01:20:51 +0100 <b4er> Heck, they felt the need to put a video online defending themselves for not being a scam. No legitimate business would do that, if someone thinks ACME is a scam then ACME would not respond to it
2021-01-04 01:21:09 +0100 <DigitalKiwi> b4er: are you stephen diehl
2021-01-04 01:21:57 +0100jedws(~jedws@121.209.189.201)
2021-01-04 01:22:03 +0100 <b4er> DigitalKiwi, are you Hoskinson?
2021-01-04 01:22:04 +0100 <MarcelineVQ> That reminiscent of 'No innocent person would have to defend themselves.' which is a bit of a scary line
2021-01-04 01:24:58 +0100 <b4er> Wdym?
2021-01-04 01:26:03 +0100 <DigitalKiwi> if you're a witch you float but if you're not a witch you drown
2021-01-04 01:26:29 +0100 <DigitalKiwi> but the more you say you're not a witch the more they think you're a witch...and then you drown
2021-01-04 01:28:33 +0100abhixec(~abhixec@c-67-169-139-16.hsd1.ca.comcast.net) (Read error: Connection reset by peer)
2021-01-04 01:30:30 +0100Lurkki(54f048f5@esm-84-240-72-245.netplaza.fi) (Ping timeout: 245 seconds)
2021-01-04 01:30:38 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:143:c475:d20e:3db4:7e5b)
2021-01-04 01:33:34 +0100 <b4er> I know it's not right to judge them based on that video, but that video just reinforced what I already was thinking
2021-01-04 01:34:46 +0100dandels(~dandels@unaffiliated/dandels)
2021-01-04 01:35:11 +0100 <b4er> Maybe they are not a scam but fact is, their marketing strategy is very offputting and I've never heard of anyone that uses Cardano
2021-01-04 01:35:58 +0100 <dmwit> So I'm using postgresql-simple. I have a table made via `create table foo ( foo real[] );`. If I `insert into foo(foo) values array[null]` I get an error (column "foo" is of type real[] but expression is of type text[]), which is kind of a shame because that's the syntax postgresql-simple generates.
2021-01-04 01:36:50 +0100 <dmwit> What can I do about it?
2021-01-04 01:37:14 +0100sparsity(5eae2591@gateway/web/cgi-irc/kiwiirc.com/ip.94.174.37.145)
2021-01-04 01:37:47 +0100renzhi(~renzhi@2607:fa49:653f:ba00::e0e5)
2021-01-04 01:38:51 +0100abhixec(~abhixec@c-67-169-139-16.hsd1.ca.comcast.net)
2021-01-04 01:39:01 +0100 <shachaf> I guess you gotta use postgresql-complex.
2021-01-04 01:39:54 +0100 <dmwit> (Specifically, that's what it generates for `execute "insert into foo(foo) values (?)" (Only (PGArray [Nothing :: Maybe Double]))`.)
2021-01-04 01:41:24 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89) (Quit: Connection closed)
2021-01-04 01:41:26 +0100alx741(~alx741@181.196.69.173) (Ping timeout: 256 seconds)
2021-01-04 01:43:39 +0100zaquest(~notzaques@5.128.210.178) (Quit: Leaving)
2021-01-04 01:43:39 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 01:44:57 +0100zaquest(~notzaques@5.128.210.178)
2021-01-04 01:45:09 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89)
2021-01-04 01:46:16 +0100machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-01-04 01:47:37 +0100 <sm[m]> b4er: you need to research them more
2021-01-04 01:48:24 +0100 <boxscape> hmm just spent half an hour manually writing singletons for a GADT type because SIngletons' template haskell stuff couldn't do it, before realizing I actually just need singletons for lists :)
2021-01-04 01:48:36 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-01-04 01:53:51 +0100alx741(~alx741@181.196.69.158)
2021-01-04 01:54:01 +0100 <b4er> sm[m], in the sense that Cardano is actually being used?
2021-01-04 01:56:14 +0100 <dolio> Well, at the very least, one of their "we aren't a scam" videos was made due to specific accusations that they are a scam. So your criteria don't seem very good in that sense.
2021-01-04 01:57:02 +0100 <sm[m]> b4er: in the sense that it's a very interesting project with good goals, people and technology, and a large global decentralised proof of stake network running, much excellent informative free content online, good community etc. etc. But it's early days, don't expect to buy coffee with it
2021-01-04 01:57:12 +0100 <dolio> I.E. anything accused of being a scam is not allowed to defend itself, because that would confirm it's a scam.
2021-01-04 01:57:24 +0100 <sm[m]> I think if you research it properly you might change your mind
2021-01-04 01:58:16 +0100 <sm[m]> the cryptocurrency world is weird and there is some culture shock
2021-01-04 01:58:20 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com) (Quit: Lost terminal)
2021-01-04 01:59:09 +0100 <sm[m]> simply look at the people involved and you should know there's something interesting here
2021-01-04 02:00:50 +0100 <DigitalKiwi> i mean a lot of the people i look at there are not interesting in a good way
2021-01-04 02:01:37 +0100 <sm[m]> ok forget my last line, but I would suggest taking a real look
2021-01-04 02:02:06 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr) (Quit: Konversation terminated!)
2021-01-04 02:02:26 +0100 <DigitalKiwi> https://www.btc-exchange.com/register <-- yikes
2021-01-04 02:02:49 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr)
2021-01-04 02:04:39 +0100 <DigitalKiwi> the further you go in the process and the more you read about the companies...lol
2021-01-04 02:05:20 +0100 <DigitalKiwi> https://play.google.com/store/apps/details?id=com.mistertango&showAllReviews=true
2021-01-04 02:05:34 +0100 <b4er> dolio, that is one criteria and it's the last one too. It just striked me as odd, usually companies don't let themselves drag down to such a level of discussion
2021-01-04 02:05:51 +0100 <b4er> DigitalKiwi, what?
2021-01-04 02:06:09 +0100 <DigitalKiwi> https://www.lb.lt/en/news/mistertango-uab-fined-eu245-thousand-for-non-compliance-with-aml-require…
2021-01-04 02:06:41 +0100 <DigitalKiwi> https://insidebitcoins.com/news/co-owner-of-defunct-crypto-exchange-bitmarket-dead
2021-01-04 02:07:14 +0100 <sm[m]> b4er: it's the cryptocurrency world, which is like a wild west information warfare zone (exaggerating slightly). Scam accusations are the norm
2021-01-04 02:07:26 +0100sgibber2018(~arch-gibb@208.85.237.144)
2021-01-04 02:07:45 +0100Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi) (Quit: Leaving.)
2021-01-04 02:08:30 +0100 <maerwald> The tech can be used for whatever... it is neutral. The question you might rightfully ask is who's funding those efforts and why.
2021-01-04 02:08:36 +0100 <sm[m]> I mean, it's even the norm here in #haskell
2021-01-04 02:09:12 +0100 <DigitalKiwi> https://twitter.com/smdiehl/status/1288822169645002754
2021-01-04 02:09:28 +0100 <maerwald> DigitalKiwi: Stephen himself works in fintech :)
2021-01-04 02:10:08 +0100 <DigitalKiwi> well him being morally hypocritical doesn't make him wrong :P
2021-01-04 02:10:42 +0100 <b4er> DigitalKiwi, what does MisterTango/Secure Nordic Payments have to do with all this now?
2021-01-04 02:11:02 +0100CMCDragonkai1(~Thunderbi@124.19.3.250)
2021-01-04 02:11:17 +0100 <DigitalKiwi> 00:59 sm[m]: simply look at the people involved and you should know there's something interesting here
2021-01-04 02:11:17 +0100 <DigitalKiwi> 01:00 DigitalKiwi: i mean a lot of the people i look at there are not interesting in a good way
2021-01-04 02:11:32 +0100 <glguy> #haskell is more for discussing Haskell than the merits of cryptocurrency or related companies
2021-01-04 02:11:47 +0100 <DigitalKiwi> i think i took that more generally than it was meant to be
2021-01-04 02:12:13 +0100 <glguy> even if a crypto-blockchain-company happens to use Haskell
2021-01-04 02:12:33 +0100shwouchk(uid154201@gateway/web/irccloud.com/x-zkcmqjwttckpbsnh)
2021-01-04 02:12:46 +0100 <maerwald> glguy: and funds the haskell foundation and GHC
2021-01-04 02:12:50 +0100 <sm[m]> DigitalKiwi: to be clear, I did mean people (humans)
2021-01-04 02:12:58 +0100 <glguy> maerwald, right
2021-01-04 02:13:08 +0100 <DigitalKiwi> "people involved" = cardano, while i thought "people involved (in crypto in general)"
2021-01-04 02:13:50 +0100 <maerwald> glguy: so maybe it isn't that OT ;) ...if you look at the tech people involved, there are many great haskellers caring about haskell.
2021-01-04 02:13:53 +0100 <sm[m]> DigitalKiwi: and I was talking about cardano, yes :)
2021-01-04 02:14:07 +0100 <DigitalKiwi> i'm a bit slow on the uptake sometimes
2021-01-04 02:15:02 +0100 <glguy> maerwald, still off topic for here, but probably interesting to discuss somewhere
2021-01-04 02:15:13 +0100 <sm[m]> it would be a great shame if haskellers did not look at and learn from the cardano project because "they're all a scam"
2021-01-04 02:15:19 +0100 <b4er> Just take the wad of cash but don't ask where it comes from is the norm
2021-01-04 02:15:41 +0100elliott_(~elliott@pool-108-51-101-42.washdc.fios.verizon.net)
2021-01-04 02:15:55 +0100 <sm[m]> it's a very interesting large-scale actively maintained real-world haskell project and there aren't many of those
2021-01-04 02:16:44 +0100o1lo01ol_(~o1lo01ol1@bl11-140-216.dsl.telepac.pt)
2021-01-04 02:16:47 +0100 <maerwald> sm[m]: did you mention it's fully open source?
2021-01-04 02:16:54 +0100madjestic(~Android@86-88-72-244.fixed.kpn.net) (Ping timeout: 260 seconds)
2021-01-04 02:17:04 +0100 <sm[m]> I had too many adjectives so did not
2021-01-04 02:17:11 +0100 <DigitalKiwi> i don't think even if he's right and everything comes crashing down that anyone's going to associate it with haskell like he's afraid...
2021-01-04 02:17:20 +0100 <b4er> They didn't, but they also didn't mention it's for-profit
2021-01-04 02:17:25 +0100 <DigitalKiwi> then again people think nix is haskell
2021-01-04 02:17:55 +0100 <DigitalKiwi> https://twitter.com/grhmc/status/1342834483003846656
2021-01-04 02:18:00 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:71cc:d94:dfc3:ae9b)
2021-01-04 02:18:34 +0100 <DigitalKiwi> hey don't a the crypto companies use nix for their haskell :P
2021-01-04 02:19:27 +0100 <maerwald> DigitalKiwi: interesting point... no one does that indeed (and I know nix is used in some oil companies in russia, I think)
2021-01-04 02:19:43 +0100 <maerwald> :D
2021-01-04 02:19:46 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 02:20:22 +0100o1lo01ol1o(~o1lo01ol1@176.78.51.169) (Ping timeout: 265 seconds)
2021-01-04 02:20:26 +0100 <b4er> Do these oil companies also place themselves close to nix the same way Cardano does to Haskell?
2021-01-04 02:20:38 +0100 <DigitalKiwi> i just wanted to scream at them "It's a LAMBDA"
2021-01-04 02:20:56 +0100 <MarcelineVQ> upper case or lower case?
2021-01-04 02:21:32 +0100 <DigitalKiwi> https://upload.wikimedia.org/wikipedia/commons/9/9d/SICP_cover.jpg look at these posers using the haskell logo
2021-01-04 02:23:58 +0100 <DigitalKiwi> maybe the cardano people are different than the oil people and cardano isn't so bad afterall
2021-01-04 02:24:57 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr) (Remote host closed the connection)
2021-01-04 02:25:36 +0100 <sm[m]> hey, what have y'all got against oil shell !
2021-01-04 02:25:40 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr)
2021-01-04 02:26:27 +0100Jeanne-Kamikaze(~Jeanne-Ka@static-198-54-134-138.cust.tzulo.com)
2021-01-04 02:27:12 +0100 <DigitalKiwi> i hate wildlife
2021-01-04 02:27:34 +0100 <DigitalKiwi> so shell is alright by me :)
2021-01-04 02:27:59 +0100 <sm[m]> https://www.oilshell.org not shell.com (DigitalKiwi :)
2021-01-04 02:28:27 +0100 <DigitalKiwi> oh the thing i've only ever heard one person talk about lol
2021-01-04 02:28:38 +0100 <DigitalKiwi> and only once
2021-01-04 02:28:52 +0100 <DigitalKiwi> not like me that talks about nix/haskell all of the time to everyone >.>
2021-01-04 02:30:01 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr) (Client Quit)
2021-01-04 02:31:06 +0100 <Axman6> IMO, if you believe a company who wants to give you money is corrupt, then you should attempt to take as much of their money as possible - money does not (necessarily) equal influence, we can turn corrupt dollars into non-corrupt Haskell infrastructure and development
2021-01-04 02:31:25 +0100dandels(~dandels@unaffiliated/dandels) (Ping timeout: 264 seconds)
2021-01-04 02:32:23 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr)
2021-01-04 02:33:14 +0100 <DigitalKiwi> i'm pretty sure i use tools that wouldn't exist without the crypto companies but wouldn't it be nice if they did
2021-01-04 02:33:33 +0100 <sm[m]> not sure about that Axman6 , taking the mafia's money seems to end up badly in the movies
2021-01-04 02:34:03 +0100 <maerwald> I'm sure the haskell foundation said they won't accept Mafia money :D
2021-01-04 02:34:07 +0100columbarius1(~columbari@i5E86B379.versanet.de) (Ping timeout: 260 seconds)
2021-01-04 02:34:27 +0100madjestic(~Android@86-88-72-244.fixed.kpn.net)
2021-01-04 02:34:35 +0100 <sm[m]> did they though
2021-01-04 02:34:40 +0100 <DigitalKiwi> if anyone wants to try and corrupt me i dare ya
2021-01-04 02:34:46 +0100 <maerwald> Yes, they ruled out certain industries from funding
2021-01-04 02:34:49 +0100 <sm[m]> oh it's a slow time here in #haskell :)
2021-01-04 02:35:52 +0100 <DigitalKiwi> yeah so slow an op even came by and chatted for a bit ;D
2021-01-04 02:35:59 +0100columbarius1(~columbari@mue-88-130-54-155.dsl.tropolys.de)
2021-01-04 02:39:06 +0100 <DigitalKiwi> sm[m]: lol i still haven't written tito in haskell yet :( but i did finally make a macos kvm so i could maintain my nixpkgs for darwin a year after i said i was going to so there's hope
2021-01-04 02:40:00 +0100 <maerwald> how do you legally make a macos kvm
2021-01-04 02:40:01 +0100 <sm[m]> DigitalKiwi: tito.. remind me ?
2021-01-04 02:40:26 +0100 <DigitalKiwi> https://mostlyabsurd.com/files/tito
2021-01-04 02:40:58 +0100 <DigitalKiwi> i have a macbook pro
2021-01-04 02:41:03 +0100 <Axman6> I thought it was astounding that there were people suggesting we shouldn't accept funding from Galois, while they arte technically a "military contractor", it's not like they are building anything which kills people, and more than Intel makes CPUs which kill people, and theiur R&D has lead to society's improved ability to make people's lives more private and secure. The black and whiteness of the thinking just blew me away
2021-01-04 02:41:21 +0100 <DigitalKiwi> not that i care about what apple says lol
2021-01-04 02:41:22 +0100 <sm[m]> DigitalKiwi: ah yes! thanks
2021-01-04 02:42:28 +0100 <sm[m]> Axman6 I must nitpick: how do you know what such companies are building
2021-01-04 02:42:35 +0100 <sm[m]> s/such//
2021-01-04 02:43:03 +0100shatriff_(~vitaliish@176-52-216-242.irishtelecom.com) (Remote host closed the connection)
2021-01-04 02:43:15 +0100shatriff(~vitaliish@176-52-216-242.irishtelecom.com)
2021-01-04 02:43:39 +0100 <Axman6> that's true I guess, though many military contractors are all to happy to tell you how leathal their arms are (in less direct language, but it's clear that an artillary shell isn't designed to build houses)
2021-01-04 02:43:44 +0100 <DigitalKiwi> "i make sure the rockets don't crash on innocent civilians! i'm not bad!" -- someone who writes flight control software
2021-01-04 02:43:48 +0100shatriff(~vitaliish@176-52-216-242.irishtelecom.com) (Remote host closed the connection)
2021-01-04 02:44:21 +0100shatriff(~vitaliish@176-52-216-242.irishtelecom.com)
2021-01-04 02:44:27 +0100 <Axman6> at what point do yuo become responsible though?
2021-01-04 02:44:49 +0100 <DigitalKiwi> maerwald: and to answer your question a different way; easily https://github.com/adisbladis/macOS-Simple-KVM
2021-01-04 02:44:51 +0100 <sm[m]> it's at least a good question to be asking
2021-01-04 02:45:09 +0100 <DigitalKiwi> i spent hours trying to find this one twitter thread a few months ago :(
2021-01-04 02:45:10 +0100 <b4er> The key is you distribute the workload among different people/companies such that no one is responsible
2021-01-04 02:46:16 +0100 <Axman6> someone makes the decision to shoot a gun at a person or a dear, it's not the gun's fault, or the manufacturer's (and don't mistake me got a gun nut, I'm Australian and wish we had stricter laws)
2021-01-04 02:46:23 +0100 <b4er> In case the media/public needs a responsible person just fire the CEO and you're good, maybe say "We're sorry!"
2021-01-04 02:46:26 +0100 <DigitalKiwi> teacher rephrased a lot of the things that were probably not explained at being so nefarious whent hey were built to see if people would still want to work on them
2021-01-04 02:47:28 +0100ThoaiOnline(79c81878@nv.tho.ai)
2021-01-04 02:48:00 +0100 <DigitalKiwi> would you have written the software that did the census if you knew how it would be used?
2021-01-04 02:48:17 +0100 <Axman6> the Australian census?
2021-01-04 02:48:20 +0100 <DigitalKiwi> https://en.wikipedia.org/wiki/IBM_and_the_Holocaust
2021-01-04 02:49:01 +0100 <ThoaiOnline> yes, at least i can introduce a bug into it :D
2021-01-04 02:49:08 +0100abhixec(~abhixec@c-67-169-139-16.hsd1.ca.comcast.net) (Read error: Connection reset by peer)
2021-01-04 02:49:49 +0100abhixec(~abhixec@c-67-169-139-16.hsd1.ca.comcast.net)
2021-01-04 02:50:14 +0100 <DigitalKiwi> and people did too yea
2021-01-04 02:50:56 +0100 <Axman6> If youIf you meant the Australian one, hell yes I would, I wouldn't have fucked up the infrastyructure as badly as IBM did :)
2021-01-04 02:51:09 +0100 <DigitalKiwi> a lot of people are like "well i might as well be the one that gets paid because someone else will do it if i don't" and don't stop to think well maybe we shouldn't let them do it either
2021-01-04 02:52:20 +0100steven3(~steven@172.92.142.109)
2021-01-04 02:53:03 +0100tomboy64(~tomboy64@gateway/tor-sasl/tomboy64) (Ping timeout: 240 seconds)
2021-01-04 02:54:14 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-01-04 02:54:36 +0100s00pcan(~chris@075-133-056-178.res.spectrum.com) (Ping timeout: 240 seconds)
2021-01-04 02:56:23 +0100ThoaiOnline_(~ThoaiOnli@2403-5800-4200-e00-144c-eb3c-31a1-4f15.ip6.aussiebb.net)
2021-01-04 02:56:42 +0100s00pcan(~chris@107.181.165.217)
2021-01-04 02:56:49 +0100 <maerwald> I think a lot of ppl don't think twice before they make large accusations, because opinion on the internet is cheap and you're not New York Times, having to make your case legally sound.
2021-01-04 02:57:13 +0100elliott_(~elliott@pool-108-51-101-42.washdc.fios.verizon.net) (Ping timeout: 264 seconds)
2021-01-04 02:57:28 +0100ThoaiOnline23(79c81878@nv.tho.ai)
2021-01-04 02:57:32 +0100 <steven3> hello, I was trying to do a simple transformation from within a do block and I can't get it to type check, can someone take a look? Here's the minimal example https://gist.github.com/stevenfontanella/8ff3c45db26c6de58c0ee891bcfeda4c
2021-01-04 02:57:47 +0100 <steven3> I must be missing something relatively simple, but I thought what I did there usually should work
2021-01-04 02:58:37 +0100 <steven3> (ignoring that I probably shouldn't be using fromRight at all :))
2021-01-04 02:59:04 +0100ThoaiOnline_(~ThoaiOnli@2403-5800-4200-e00-144c-eb3c-31a1-4f15.ip6.aussiebb.net) ()
2021-01-04 02:59:29 +0100 <Axman6> :t fromRight
2021-01-04 02:59:30 +0100 <lambdabot> b -> Either a b -> b
2021-01-04 02:59:32 +0100renzhi(~renzhi@2607:fa49:653f:ba00::e0e5) (Ping timeout: 268 seconds)
2021-01-04 02:59:32 +0100 <steven3> hmm actually maybe I need either error id
2021-01-04 02:59:41 +0100 <steven3> yeah looks like I assumed the wrong type
2021-01-04 02:59:42 +0100 <Axman6> thar's ya prarblem
2021-01-04 02:59:47 +0100ThoaiOnline_(~ThoaiOnli@2403-5800-4200-e00-144c-eb3c-31a1-4f15.ip6.aussiebb.net)
2021-01-04 03:00:02 +0100 <Axman6> @hoogle Either a b -> b
2021-01-04 03:00:04 +0100 <lambdabot> Data.Either.Combinators fromRight' :: Either a b -> b
2021-01-04 03:00:04 +0100 <lambdabot> Data.Either.Utils fromRight :: Either a b -> b
2021-01-04 03:00:04 +0100 <lambdabot> Data.Strict.Either fromRight :: Either a b -> b
2021-01-04 03:00:13 +0100 <Axman6> @hoogle+
2021-01-04 03:00:13 +0100 <lambdabot> Data.Either.Unwrap fromRight :: Either a b -> b
2021-01-04 03:00:13 +0100 <lambdabot> Rebase.Prelude fromRight' :: () => Either a b -> b
2021-01-04 03:00:13 +0100 <lambdabot> Network.Haskoin.Util fromRight :: Either a b -> b
2021-01-04 03:00:17 +0100ThoaiOnline_(~ThoaiOnli@2403-5800-4200-e00-144c-eb3c-31a1-4f15.ip6.aussiebb.net) (Client Quit)
2021-01-04 03:00:30 +0100 <steven3> thanks Axman6
2021-01-04 03:00:34 +0100ThoaiOnline_(~ThoaiOnli@2403-5800-4200-e00-144c-eb3c-31a1-4f15.ip6.aussiebb.net)
2021-01-04 03:05:02 +0100ThoaiOnline_(~ThoaiOnli@2403-5800-4200-e00-144c-eb3c-31a1-4f15.ip6.aussiebb.net) (Ping timeout: 260 seconds)
2021-01-04 03:06:31 +0100quinn(~quinn@c-73-223-224-163.hsd1.ca.comcast.net) (Quit: ZNC 1.8.1 - https://znc.in)
2021-01-04 03:06:41 +0100tomboy64(~tomboy64@gateway/tor-sasl/tomboy64)
2021-01-04 03:07:20 +0100ThoaiOnline23(79c81878@nv.tho.ai) (Remote host closed the connection)
2021-01-04 03:07:40 +0100paintcan(~user@cpe-69-206-241-99.nyc.res.rr.com) (Remote host closed the connection)
2021-01-04 03:13:06 +0100acidjnk_new(~acidjnk@p200300d0c704e739101f4cb6fc9280ae.dip0.t-ipconnect.de) (Ping timeout: 268 seconds)
2021-01-04 03:14:54 +0100ThoaiOnlineGuest90236
2021-01-04 03:14:54 +0100Guest90236(79c81878@nv.tho.ai) (Killed (moon.freenode.net (Nickname regained by services)))
2021-01-04 03:15:20 +0100quinn(~quinn@c-73-223-224-163.hsd1.ca.comcast.net)
2021-01-04 03:15:35 +0100ThoaiOnline(~ThoaiOnli@2403-5800-4200-e00-144c-eb3c-31a1-4f15.ip6.aussiebb.net)
2021-01-04 03:18:25 +0100abhixec(~abhixec@c-67-169-139-16.hsd1.ca.comcast.net) (Quit: brb restarting)
2021-01-04 03:20:29 +0100DataComputist(~lumeng@static-50-43-26-251.bvtn.or.frontiernet.net) (Quit: Leaving...)
2021-01-04 03:21:49 +0100Wuzzy(~Wuzzy@p5790e976.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2021-01-04 03:23:02 +0100notzmv(~user@unaffiliated/zmv) (Remote host closed the connection)
2021-01-04 03:24:13 +0100Tario(~Tario@201.192.165.173) (Ping timeout: 264 seconds)
2021-01-04 03:24:32 +0100abhixec(~abhixec@c-67-169-139-16.hsd1.ca.comcast.net)
2021-01-04 03:25:24 +0100geowiesnot(~user@87-89-181-157.abo.bbox.fr) (Ping timeout: 272 seconds)
2021-01-04 03:25:24 +0100m0rphism(~m0rphism@HSI-KBW-085-216-104-059.hsi.kabelbw.de) (Ping timeout: 272 seconds)
2021-01-04 03:27:19 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 03:28:44 +0100jedws(~jedws@121.209.189.201) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 03:32:11 +0100elliott_(~elliott@pool-108-51-101-42.washdc.fios.verizon.net)
2021-01-04 03:32:50 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 268 seconds)
2021-01-04 03:34:51 +0100Tario(~Tario@201.192.165.173)
2021-01-04 03:38:07 +0100lawid(~quassel@dslb-084-059-133-104.084.059.pools.vodafone-ip.de) (Ping timeout: 246 seconds)
2021-01-04 03:39:02 +0100lawid(~quassel@dslb-090-186-127-244.090.186.pools.vodafone-ip.de)
2021-01-04 03:39:21 +0100olligobber(~olligobbe@unaffiliated/olligobber)
2021-01-04 03:41:34 +0100benjamingr__(uid23465@gateway/web/irccloud.com/x-jmrkejpitddinbuk) (Quit: Connection closed for inactivity)
2021-01-04 03:42:28 +0100notzmv(~user@unaffiliated/zmv)
2021-01-04 03:44:00 +0100b4er_(~b4er@91.193.4.138)
2021-01-04 03:44:23 +0100xff0x(~fox@2001:1a81:523c:2500:528d:7247:c11a:c6c7) (Ping timeout: 260 seconds)
2021-01-04 03:45:11 +0100b4er(~b4er@91.193.4.138) (Read error: Connection reset by peer)
2021-01-04 03:46:08 +0100xff0x(~fox@2001:1a81:5271:e800:9600:6dbe:32ee:1f82)
2021-01-04 03:46:24 +0100b4er_b4er
2021-01-04 03:49:04 +0100abhixec(~abhixec@c-67-169-139-16.hsd1.ca.comcast.net) (Remote host closed the connection)
2021-01-04 03:50:37 +0100CMCDragonkai1(~Thunderbi@124.19.3.250) (Ping timeout: 264 seconds)
2021-01-04 03:51:04 +0100sparsity(5eae2591@gateway/web/cgi-irc/kiwiirc.com/ip.94.174.37.145) (Quit: Connection closed)
2021-01-04 03:51:42 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr) (Quit: Konversation terminated!)
2021-01-04 03:52:05 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr)
2021-01-04 03:52:06 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr) (Client Quit)
2021-01-04 03:52:39 +0100Stanley00(~stanley00@unaffiliated/stanley00)
2021-01-04 03:54:16 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr)
2021-01-04 03:58:25 +0100quinn(~quinn@c-73-223-224-163.hsd1.ca.comcast.net) (Quit: ZNC 1.8.1 - https://znc.in)
2021-01-04 04:00:17 +0100jmchael(~jmchael@81.174.205.210) (Ping timeout: 256 seconds)
2021-01-04 04:00:52 +0100s00pcan(~chris@107.181.165.217) (Ping timeout: 246 seconds)
2021-01-04 04:02:57 +0100wei2912(~wei2912@unaffiliated/wei2912)
2021-01-04 04:03:00 +0100s00pcan(~chris@075-133-056-178.res.spectrum.com)
2021-01-04 04:03:46 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Quit: leaving)
2021-01-04 04:03:47 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 04:04:56 +0100cads(~cads@ip-64-72-99-232.lasvegas.net) (Ping timeout: 240 seconds)
2021-01-04 04:05:04 +0100cads2(~cads@ip-64-72-99-232.lasvegas.net) (Ping timeout: 246 seconds)
2021-01-04 04:05:05 +0100quinn(~quinn@c-73-223-224-163.hsd1.ca.comcast.net)
2021-01-04 04:06:18 +0100notzmv(~user@unaffiliated/zmv) (Read error: No route to host)
2021-01-04 04:06:27 +0100madjestic(~Android@86-88-72-244.fixed.kpn.net) (Ping timeout: 272 seconds)
2021-01-04 04:06:52 +0100guest14(~user@49.5.6.87)
2021-01-04 04:07:39 +0100xirhtogal(~lagothrix@unaffiliated/lagothrix)
2021-01-04 04:07:39 +0100lagothrix(~lagothrix@unaffiliated/lagothrix) (Killed (barjavel.freenode.net (Nickname regained by services)))
2021-01-04 04:07:39 +0100xirhtogallagothrix
2021-01-04 04:07:48 +0100 <guest14> why use read in parsec would show something like "Prelude.read: no parse" https://paste.ubuntu.com/p/8W5NcDrS6J/
2021-01-04 04:10:09 +0100 <dsal> Parsec doesn't do that
2021-01-04 04:10:18 +0100notzmv(~user@unaffiliated/zmv)
2021-01-04 04:10:45 +0100 <dsal> You're using `read`, which gives that error.
2021-01-04 04:11:17 +0100larryba(~bc812391@217.29.117.252) (Quit: http://www.okay.uz/ (Session timeout))
2021-01-04 04:12:31 +0100 <guest14> dsal: but this work https://paste.ubuntu.com/p/s55ywJJfgC/
2021-01-04 04:13:09 +0100 <dsal> Maybe, got you should not use read. It's partial and confusing you.
2021-01-04 04:13:38 +0100 <dsal> I don't know the parsec api well. Megaparsec has `decimal` to parse numbers. Much less confusing.
2021-01-04 04:13:39 +0100 <guest14> dsal: https://paste.ubuntu.com/p/9983fQH8rb/
2021-01-04 04:13:39 +0100 <xsperry> guest14, on fail read returns error, instead of Parsec.Error, so it doesn't play well with Parsec, and shouldn't be used if it can fail
2021-01-04 04:14:50 +0100 <guest14> xsperry: which should use to digit?
2021-01-04 04:15:00 +0100b4er_(~b4er@2a02:aa16:3a80:1900:5f0f:a23e:4628:9051)
2021-01-04 04:15:15 +0100 <dsal> guest14: is parsec required?
2021-01-04 04:15:34 +0100b4er(~b4er@91.193.4.138) (Ping timeout: 246 seconds)
2021-01-04 04:15:36 +0100 <xsperry> guest14 just ensure that it can't fail, or use readMaybe if it can
2021-01-04 04:15:42 +0100 <guest14> dsal: yes
2021-01-04 04:16:16 +0100 <dsal> readMaybe isn't much better, it'll just not fail.
2021-01-04 04:16:40 +0100Stanley|00(~stanley00@unaffiliated/stanley00)
2021-01-04 04:16:48 +0100 <guest14> xsperry: dsal the weird things is why the first link fail, and the second link success
2021-01-04 04:16:58 +0100 <guest14> https://paste.ubuntu.com/p/8W5NcDrS6J/
2021-01-04 04:17:03 +0100 <guest14> https://paste.ubuntu.com/p/9983fQH8rb/
2021-01-04 04:17:33 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com)
2021-01-04 04:17:39 +0100 <dsal> Sometimes doing the wrong thing works. That it's confusing you is why it's not a good way to do it.
2021-01-04 04:18:58 +0100Stanley|00(~stanley00@unaffiliated/stanley00) (Read error: Connection reset by peer)
2021-01-04 04:19:25 +0100Stanley00(~stanley00@unaffiliated/stanley00) (Ping timeout: 264 seconds)
2021-01-04 04:19:28 +0100Stanley|00(~stanley00@unaffiliated/stanley00)
2021-01-04 04:19:55 +0100 <xsperry> AFAICS the only way `do l <- many digit; return (read l)` can fail is if the input contained too many digits for Int
2021-01-04 04:20:20 +0100 <glguy> xsperry, many can return 0 digits
2021-01-04 04:20:32 +0100 <glguy> > read "" :: Int
2021-01-04 04:20:33 +0100 <lambdabot> *Exception: Prelude.read: no parse
2021-01-04 04:20:35 +0100 <xsperry> indeed, use many1
2021-01-04 04:20:41 +0100 <dsal> many and some are confusing names
2021-01-04 04:21:11 +0100 <dsal> > read "parse" :: Int
2021-01-04 04:21:13 +0100 <lambdabot> *Exception: Prelude.read: no parse
2021-01-04 04:21:44 +0100 <xsperry> that would have failed at `many digit'
2021-01-04 04:22:03 +0100 <dsal> many1 is some, afaik
2021-01-04 04:22:21 +0100 <guest14> many is 0 or more than 0
2021-01-04 04:22:28 +0100 <guest14> many1 is 1 or more than 1
2021-01-04 04:22:48 +0100 <dsal> some is 1 or more. many is 0 or more
2021-01-04 04:23:01 +0100b4er_(~b4er@2a02:aa16:3a80:1900:5f0f:a23e:4628:9051) (Read error: Connection reset by peer)
2021-01-04 04:23:13 +0100 <guest14> I change many to many1, and it works now
2021-01-04 04:23:14 +0100 <dsal> Oh, parsec defines its own
2021-01-04 04:23:15 +0100b4er(~b4er@91.193.4.106)
2021-01-04 04:23:18 +0100b4er_(~b4er@91.193.4.106)
2021-01-04 04:23:28 +0100 <dsal> guest14: it's still incorrect, just less incorrect
2021-01-04 04:23:38 +0100b4er__(~b4er@91.193.4.106)
2021-01-04 04:23:51 +0100 <guest14> dsal: what's the right way?
2021-01-04 04:24:31 +0100 <dsal> guest14: not using read, failing properly in the case where it can't produce the type you want
2021-01-04 04:25:01 +0100urodna(~urodna@unaffiliated/urodna) (Quit: urodna)
2021-01-04 04:25:36 +0100hiroaki(~hiroaki@ip4d16b6b9.dynamic.kabel-deutschland.de)
2021-01-04 04:26:01 +0100 <guest14> https://hackage.haskell.org/package/parsers-0.12.10/docs/Text-Parser-Token.html#v:decimal ?
2021-01-04 04:26:19 +0100 <dsal> guest14: e.g., see what megaparsec does here: https://hackage.haskell.org/package/megaparsec-9.0.1/docs/Text-Megaparsec-Char-Lexer.html
2021-01-04 04:28:57 +0100Stanley|00(~stanley00@unaffiliated/stanley00) (Read error: Connection reset by peer)
2021-01-04 04:29:27 +0100Stanley00(~stanley00@unaffiliated/stanley00)
2021-01-04 04:30:28 +0100 <jle`> i wonder if there's a nice way turn a list like [1,2,3,4,5,6,7,8] into ((1<>2)<>(3<>4))<>((5<>6)<>(7<>8)) in constant-time
2021-01-04 04:30:43 +0100drbean(~drbean@TC210-63-209-184.static.apol.com.tw)
2021-01-04 04:31:09 +0100 <jle`> er
2021-01-04 04:31:12 +0100 <jle`> constnat-space
2021-01-04 04:31:22 +0100 <jle`> probably not
2021-01-04 04:37:02 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89) (Quit: Connection closed)
2021-01-04 04:37:28 +0100abhixec(~abhixec@c-67-169-139-16.hsd1.ca.comcast.net)
2021-01-04 04:37:44 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net) (Quit: leaving)
2021-01-04 04:37:58 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 246 seconds)
2021-01-04 04:38:08 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89)
2021-01-04 04:38:43 +0100 <guest14> cabal or stack, which one you guys prefer?
2021-01-04 04:39:00 +0100 <dsal> Fight!
2021-01-04 04:39:15 +0100 <guest14> there're cabal v1 v2 v3, if there's v4?
2021-01-04 04:39:35 +0100 <guest14> stack put everything on AWS, that sucks
2021-01-04 04:40:17 +0100 <dsal> What's wrong with aws?
2021-01-04 04:40:34 +0100 <guest14> aws is blocked on some countries
2021-01-04 04:41:02 +0100 <arahael> I liked stack, but then cabal picked up most of the functionality I actually wanted.
2021-01-04 04:41:14 +0100 <arahael> So if I was choosing today... I think I'd just do cabal.
2021-01-04 04:41:59 +0100 <dsal> I've not managed to get a cabal workflow that works for me. I also use nix, so pretty much all the things.
2021-01-04 04:42:07 +0100shwouchk(uid154201@gateway/web/irccloud.com/x-zkcmqjwttckpbsnh) (Quit: Connection closed for inactivity)
2021-01-04 04:42:15 +0100 <guest14> pacman is the greatest package manager I ever use, but it's not friendly to haskell
2021-01-04 04:42:32 +0100 <guest14> nix or guix are too hard to config?
2021-01-04 04:42:44 +0100 <dsal> Sorry to hear that. You'll find nix someday :)
2021-01-04 04:43:13 +0100Tario(~Tario@201.192.165.173) (Ping timeout: 246 seconds)
2021-01-04 04:43:16 +0100 <guest14> pacman is really awesome, apt sucks
2021-01-04 04:44:15 +0100 <dsal> ok
2021-01-04 04:45:47 +0100dyeplexer(~lol@unaffiliated/terpin)
2021-01-04 04:45:49 +0100EnoGalaxy(~cyphermag@c-24-143-96-65.customer.broadstripe.net)
2021-01-04 04:45:53 +0100Tario(~Tario@201.192.165.173)
2021-01-04 04:45:55 +0100Tario(~Tario@201.192.165.173) (Read error: Connection reset by peer)
2021-01-04 04:45:58 +0100EnoGalaxy(~cyphermag@c-24-143-96-65.customer.broadstripe.net) ()
2021-01-04 04:48:46 +0100ThoaiOnline1(~ThoaiOnli@nv.tho.ai)
2021-01-04 04:48:54 +0100andi-(~andi-@NixOS/user/andi-) (Remote host closed the connection)
2021-01-04 04:49:11 +0100Tario(~Tario@201.192.165.173)
2021-01-04 04:49:14 +0100 <maerwald> guest14: pacman doesn't have much in terms of features, so its implementation isn't very complex
2021-01-04 04:50:26 +0100ThoaiOnline(~ThoaiOnli@2403-5800-4200-e00-144c-eb3c-31a1-4f15.ip6.aussiebb.net) (Ping timeout: 264 seconds)
2021-01-04 04:52:17 +0100abhixec(~abhixec@c-67-169-139-16.hsd1.ca.comcast.net) (Read error: Connection reset by peer)
2021-01-04 04:53:32 +0100shinobi(~shinobi@c-24-147-48-162.hsd1.ma.comcast.net) (Ping timeout: 260 seconds)
2021-01-04 04:53:54 +0100andi-(~andi-@NixOS/user/andi-)
2021-01-04 04:54:24 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89) (Quit: Ping timeout (120 seconds))
2021-01-04 04:54:35 +0100b4er_(~b4er@91.193.4.106) (Quit: bye!)
2021-01-04 04:54:40 +0100b4er(~b4er@91.193.4.106) (Quit: bye!)
2021-01-04 04:54:44 +0100b4er__(~b4er@91.193.4.106) (Quit: bye!)
2021-01-04 04:54:46 +0100theDon(~td@94.134.91.73) (Ping timeout: 246 seconds)
2021-01-04 04:54:57 +0100b4er(~b4er@91.193.4.106)
2021-01-04 04:55:01 +0100jmchael(~jmchael@81.174.205.210)
2021-01-04 04:56:50 +0100theDon(~td@94.134.91.22)
2021-01-04 04:57:37 +0100abhixec(~abhixec@c-67-169-139-16.hsd1.ca.comcast.net)
2021-01-04 04:57:40 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr)
2021-01-04 04:57:54 +0100 <guest14> maerwald: and apt is more complex than pacman?
2021-01-04 04:58:16 +0100 <maerwald> not much, no
2021-01-04 04:59:20 +0100 <dsal> guest14: you started this by saying your packaging system isn't good for Haskell. Not selling it very well here.
2021-01-04 04:59:29 +0100 <guest14> I tried `proxychains stack install parsers` but got ""/home/john/.stack/build-plan/lts-16.27.yaml" (Response {responseStatus = Status {statusCode = 404, statusMessage = "Not Found"},"
2021-01-04 05:00:10 +0100 <guest14> it means proxychains won't work to stack?
2021-01-04 05:00:11 +0100 <dsal> That's probably not what you wanted to do in the first place.
2021-01-04 05:02:54 +0100 <guest14> https://hackage.haskell.org/package/parsers-0.12.10/docs/Text-Parser-Token.html#v:decimal
2021-01-04 05:03:12 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2021-01-04 05:03:16 +0100 <guest14> this package called `parsers` right?
2021-01-04 05:03:49 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2021-01-04 05:04:35 +0100 <dsal> Yes, but you put it in your package.yaml and just build, you don't do a global install.
2021-01-04 05:04:56 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89)
2021-01-04 05:05:24 +0100 <dsal> But if you're reading for something new, try megaparsec. It's much more feature rich and has good error messages.
2021-01-04 05:05:31 +0100 <guest14> ok
2021-01-04 05:05:38 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89) (Client Quit)
2021-01-04 05:05:50 +0100Tops2(~Tobias@dyndsl-095-033-092-191.ewe-ip-backbone.de) (Read error: Connection reset by peer)
2021-01-04 05:06:40 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89)
2021-01-04 05:09:01 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 05:09:37 +0100 <jle`> hm...would like to write a function that turns [1,2,3,4,5,6,7,8,9] into (1<>(2<>3)) <> ( (4<>(5<>6)) <> (7<>(8<>9)) )
2021-01-04 05:09:48 +0100 <boxscape> Getting a thing tight now where upon saving a file ghcid reloads a dozen times in a row quickly instead of once, has anyone experienced that?
2021-01-04 05:11:12 +0100jedws(~jedws@121.209.189.201)
2021-01-04 05:11:20 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 05:12:12 +0100 <dsal> jle`: isn't that effectively `fold`?
2021-01-04 05:12:16 +0100petersen(~petersen@redhat/juhp) (Ping timeout: 246 seconds)
2021-01-04 05:12:42 +0100 <jle`> oh yeah i shouldn't have used <>
2021-01-04 05:12:47 +0100 <jle`> pretend it isn't associative heh
2021-01-04 05:12:58 +0100 <dsal> Ah, makes more sense
2021-01-04 05:13:02 +0100 <jle`> arbitrary non-associative operation :)
2021-01-04 05:13:09 +0100 <b4er> Or `mconcat`? But the order of evaluation is different
2021-01-04 05:13:10 +0100Varis(~Tadas@unaffiliated/varis)
2021-01-04 05:13:44 +0100 <MarcelineVQ> \\n xs -> mconcat $ mconcat <$> chunksOf n xs
2021-01-04 05:13:52 +0100 <jle`> ah the idea is that it'd be recursive
2021-01-04 05:13:58 +0100Stanley|00(~stanley00@unaffiliated/stanley00)
2021-01-04 05:14:02 +0100 <jle`> so the next step would be even more parenthesesy
2021-01-04 05:14:23 +0100Stanley00(~stanley00@unaffiliated/stanley00) (Disconnected by services)
2021-01-04 05:15:16 +0100 <jle`> so it'd be chunks of 1,2,4,8,16,etc.
2021-01-04 05:15:33 +0100 <MarcelineVQ> scanChunksOf :>
2021-01-04 05:15:39 +0100 <jle`> er, i guess 3, 6, 12, etc. in that case
2021-01-04 05:15:48 +0100Jeanne-Kamikaze(~Jeanne-Ka@static-198-54-134-138.cust.tzulo.com) (Remote host closed the connection)
2021-01-04 05:16:50 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-01-04 05:19:05 +0100Wuzzy(~Wuzzy@p5790e09a.dip0.t-ipconnect.de)
2021-01-04 05:20:18 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com)
2021-01-04 05:21:03 +0100Feuermagier(~Feuermagi@213.178.26.41)
2021-01-04 05:22:36 +0100jmchael(~jmchael@81.174.205.210) (Ping timeout: 268 seconds)
2021-01-04 05:28:04 +0100 <jle`> i cant do it :(
2021-01-04 05:28:13 +0100 <jle`> recursion make brain hurt
2021-01-04 05:28:23 +0100 <boxscape> use a for loop :)
2021-01-04 05:28:38 +0100jollygood2(~bc812391@217.29.117.252)
2021-01-04 05:29:10 +0100 <jle`> would still need recursively nested for loops i think ;_;
2021-01-04 05:29:21 +0100 <boxscape> :(
2021-01-04 05:29:54 +0100Sheilong(uid293653@gateway/web/irccloud.com/x-zwenbxsjaehrjmmn) ()
2021-01-04 05:30:07 +0100elliott_(~elliott@pool-108-51-101-42.washdc.fios.verizon.net) (Quit: WeeChat 3.0)
2021-01-04 05:30:52 +0100steven3(~steven@172.92.142.109) (Quit: WeeChat 2.8)
2021-01-04 05:32:09 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-01-04 05:32:59 +0100adamwespiser(~adamwespi@209.6.43.158) (Remote host closed the connection)
2021-01-04 05:33:26 +0100adamwespiser(~adamwespi@209.6.43.158)
2021-01-04 05:35:34 +0100elliott_(~elliott@pool-108-51-101-42.washdc.fios.verizon.net)
2021-01-04 05:35:37 +0100elliott_(~elliott@pool-108-51-101-42.washdc.fios.verizon.net) (Client Quit)
2021-01-04 05:35:39 +0100CMCDragonkai1(~Thunderbi@124.19.3.250)
2021-01-04 05:38:43 +0100adamwespiser(~adamwespi@209.6.43.158) (Ping timeout: 260 seconds)
2021-01-04 05:41:16 +0100Jesin(~Jesin@pool-72-66-101-18.washdc.fios.verizon.net) (Read error: Connection reset by peer)
2021-01-04 05:41:57 +0100Jesin(~Jesin@pool-72-66-101-18.washdc.fios.verizon.net)
2021-01-04 05:42:15 +0100jollygood2(~bc812391@217.29.117.252) (Quit: quit)
2021-01-04 05:44:59 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 05:45:27 +0100larryba(~bc812391@199.204.85.195)
2021-01-04 05:46:53 +0100sgibber2018(~arch-gibb@208.85.237.144) (Ping timeout: 256 seconds)
2021-01-04 05:46:54 +0100 <guest14> how to remote spaces "[\"a\", \"b e\"]" that only inside a list?
2021-01-04 05:47:08 +0100 <guest14> but don't change spaces in string
2021-01-04 05:47:29 +0100 <guest14> "[\"a\", \"b e\"]" to "[\"a\",\"b e\"]"
2021-01-04 05:47:59 +0100 <boxscape> % "[\"a\", \"b e\"]" == "[\"a\",\"b e\"]"
2021-01-04 05:47:59 +0100 <yahb> boxscape: False
2021-01-04 05:48:11 +0100 <boxscape> hmm I'm still trying to find the difference
2021-01-04 05:48:13 +0100 <jle`> hm i think i did it
2021-01-04 05:48:19 +0100 <boxscape> nice
2021-01-04 05:48:21 +0100 <larryba> hi. what's the proper way of debugging haskell program for using more memory when it should? not using seq when I should have, etc
2021-01-04 05:48:45 +0100 <boxscape> ah there's a space after the comma, I see
2021-01-04 05:48:50 +0100 <koz_> larryba: http://neilmitchell.blogspot.com/2015/09/detecting-space-leaks.html
2021-01-04 05:49:07 +0100 <larryba> thanks
2021-01-04 05:54:49 +0100darjeeling_(~darjeelin@115.215.41.150) (Ping timeout: 264 seconds)
2021-01-04 05:56:43 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 05:58:59 +0100 <dsal> guest14: You'll need to know whether you're "in a string" and then use that to decide what to do when you encounter a space.
2021-01-04 06:00:07 +0100jcowan(sid325434@gateway/web/irccloud.com/x-xccxiqbedbcrqfvq)
2021-01-04 06:00:53 +0100CMCDragonkai1(~Thunderbi@124.19.3.250) (Quit: CMCDragonkai1)
2021-01-04 06:03:22 +0100dfeuer(~dfeuer@pool-108-18-223-60.washdc.fios.verizon.net) (Ping timeout: 246 seconds)
2021-01-04 06:03:31 +0100 <xsperry> guest14, you could parse that into [String], then display it without a space
2021-01-04 06:04:45 +0100 <dsal> Yeah, there's a bit of an XY problem here. If there's a particular grammar you want to parse and a particular way you want to emit that grammar, that's probably a better way to think of it. i.e, I like xsperry's suggestion.
2021-01-04 06:07:42 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com)
2021-01-04 06:08:55 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com) (Client Quit)
2021-01-04 06:09:53 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com)
2021-01-04 06:10:32 +0100tomku(~tomku@unaffiliated/tomku) (Ping timeout: 260 seconds)
2021-01-04 06:11:23 +0100adamwespiser(~adamwespi@209.6.43.158)
2021-01-04 06:11:35 +0100tomku(~tomku@unaffiliated/tomku)
2021-01-04 06:12:01 +0100darjeeling_(~darjeelin@115.215.41.150)
2021-01-04 06:13:31 +0100Tario(~Tario@201.192.165.173) (Ping timeout: 246 seconds)
2021-01-04 06:14:04 +0100p-core(~Thunderbi@koleje-wifi-0045.koleje.cuni.cz) (Quit: p-core)
2021-01-04 06:14:19 +0100p-core(~Thunderbi@koleje-wifi-0045.koleje.cuni.cz)
2021-01-04 06:14:44 +0100Wuzzy(~Wuzzy@p5790e09a.dip0.t-ipconnect.de) (Remote host closed the connection)
2021-01-04 06:16:58 +0100 <jle`> what's that trick for perfectly balanced trees with an irregular data type?
2021-01-04 06:17:50 +0100 <jle`> non-regular data type
2021-01-04 06:18:18 +0100adamwespiser(~adamwespi@209.6.43.158) (Ping timeout: 272 seconds)
2021-01-04 06:19:32 +0100djellemah(~djellemah@2601:5c2:100:96c:e008:b638:39fe:6a54) (Ping timeout: 260 seconds)
2021-01-04 06:19:34 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-01-04 06:21:41 +0100 <ThoaiOnline1> hi fam, what's the most mature ide-integrated haskell debugger nowadays?
2021-01-04 06:23:21 +0100 <dsal> What a weird combination of words.
2021-01-04 06:24:07 +0100 <dsal> I've never used a debugger in haskell, though I did have to write something to work with traces to figure out a strange concurrency issue once.
2021-01-04 06:26:58 +0100 <Axman6> jle`: foo [] = mempty; foo [a] = a; foo (x:y:xs) = foo (x<>y:foo xs)?
2021-01-04 06:27:25 +0100 <Axman6> % let foo [] = mempty; foo [a] = a; foo (x:y:xs) = foo (x<>y:foo xs) in foo a b c d e :: Expr
2021-01-04 06:27:25 +0100 <yahb> Axman6: ; <interactive>:161:88: error:; Not in scope: type constructor or class `Expr'; Perhaps you meant one of these: `ExpQ' (imported from Language.Haskell.TH), `Exp' (imported from Language.Haskell.TH)
2021-01-04 06:27:32 +0100 <Axman6> > let foo [] = mempty; foo [a] = a; foo (x:y:xs) = foo (x<>y:foo xs) in foo a b c d e :: Expr
2021-01-04 06:27:34 +0100 <lambdabot> error:
2021-01-04 06:27:34 +0100 <lambdabot> • Occurs check: cannot construct the infinite type: a ~ [a]
2021-01-04 06:27:35 +0100 <lambdabot> • In the expression: foo (x <> y : foo xs)
2021-01-04 06:28:13 +0100 <Axman6> oh right
2021-01-04 06:29:27 +0100 <Axman6> > let foo [] = mempty; foo [a] = a; foo xs = foo (go xs) where go (x:y:ys) = x<>y : go ys; go ys = ys in foo [a, b, c, d, e] :: Expr
2021-01-04 06:29:29 +0100 <lambdabot> ((a <> b) <> c <> d) <> e
2021-01-04 06:29:52 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 06:30:26 +0100 <jle`> hm, i wonder how that associates
2021-01-04 06:30:47 +0100 <Axman6> I'm sure if you're nice it it it will associate with you :)
2021-01-04 06:31:06 +0100 <Axman6> You're good people jle`, you'll be alright
2021-01-04 06:31:32 +0100 <jle`> :)
2021-01-04 06:35:05 +0100cads2(~cads@ip-64-72-99-232.lasvegas.net)
2021-01-04 06:35:12 +0100cads(~cads@ip-64-72-99-232.lasvegas.net)
2021-01-04 06:41:07 +0100petersen(~petersen@redhat/juhp)
2021-01-04 06:41:48 +0100dansho(~dansho@ec2-3-112-18-114.ap-northeast-1.compute.amazonaws.com)
2021-01-04 06:46:12 +0100larryba(~bc812391@199.204.85.195) (Quit: CGI:IRC)
2021-01-04 06:46:28 +0100adamwespiser(~adamwespi@209.6.43.158)
2021-01-04 06:46:47 +0100 <ThoaiOnline1> @dsal - i understand the "if it compiles it probably works" sentiment but once in a bluemoon, something catastrophic is bound to happen
2021-01-04 06:46:47 +0100 <lambdabot> Maybe you meant: keal eval
2021-01-04 06:47:16 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:71cc:d94:dfc3:ae9b) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 06:47:44 +0100ThoaiOnline1ThoaiOnline
2021-01-04 06:48:25 +0100 <dsal> ThoaiOnline1: no, it's true... I've written bugs that compile more than once. I just don't use debuggers.
2021-01-04 06:48:50 +0100 <ThoaiOnline> ah ok
2021-01-04 06:49:03 +0100larryba(~bc812391@217.29.117.252)
2021-01-04 06:49:03 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 06:49:42 +0100jedws(~jedws@121.209.189.201) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 06:50:05 +0100xsperry(~as@unaffiliated/xsperry) (Remote host closed the connection)
2021-01-04 06:51:54 +0100xsperry(~as@unaffiliated/xsperry)
2021-01-04 06:52:58 +0100adamwespiser(~adamwespi@209.6.43.158) (Ping timeout: 265 seconds)
2021-01-04 06:53:43 +0100tama00(~tama@unaffiliated/tama00)
2021-01-04 06:54:07 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 246 seconds)
2021-01-04 06:55:03 +0100andreas303(~andreas@gateway/tor-sasl/andreas303) (Ping timeout: 240 seconds)
2021-01-04 06:56:25 +0100dfeuer(~dfeuer@pool-108-18-223-60.washdc.fios.verizon.net)
2021-01-04 07:00:00 +0100andreas303(~andreas@gateway/tor-sasl/andreas303)
2021-01-04 07:00:42 +0100 <maerwald> whoever started "if it compiles it probably works" was either a troll or an academic, running well defined code, not real world stuff :p
2021-01-04 07:02:47 +0100 <b4er> It probably once said "if it *still* compiles *after this refactor* it probably works *the same as before*"
2021-01-04 07:03:22 +0100 <maerwald> how's that any better? :D
2021-01-04 07:04:00 +0100 <maerwald> you can reorder a sequence of IO actions arbitrarily and it will probably compile :D
2021-01-04 07:04:39 +0100 <koz_> Also, infinite loops compile just fine. :P
2021-01-04 07:04:46 +0100 <koz_> Especially when you least want them to.
2021-01-04 07:04:52 +0100 <b4er> Of course but when you refactor something you're usually not reordering statements?
2021-01-04 07:04:52 +0100 <larryba> presumably it assumes an actual programmer doing reasonable changes, and not a monkey randomly reording lines in the code
2021-01-04 07:05:04 +0100 <maerwald> b4er: not?
2021-01-04 07:05:27 +0100 <b4er> Idk, not like that I'd assume
2021-01-04 07:05:28 +0100 <maerwald> larryba: on a sufficiently large codebase, we're all monkeys
2021-01-04 07:05:28 +0100 <boxscape> koz_ just wait until someone implements a totality checker :P
2021-01-04 07:05:49 +0100 <b4er> You also just took that statement and made it look like I said this is true 100%
2021-01-04 07:05:51 +0100 <koz_> boxscape: Yes, I too have written Idris.
2021-01-04 07:07:10 +0100 <b4er> larryba, and in such a case it's a reasonable statement (nota bene it still reads with a "probably")
2021-01-04 07:07:33 +0100 <maerwald> it's never a reasonable statement
2021-01-04 07:07:50 +0100 <maerwald> it's something you should never say, believe or prefix even with "probably"
2021-01-04 07:07:55 +0100 <maerwald> forget it was ever said
2021-01-04 07:09:06 +0100 <maerwald> it makes your code worse, thinking like that
2021-01-04 07:09:56 +0100edwtjo(~edwtjo@h-7-145.A213.priv.bahnhof.se)
2021-01-04 07:09:56 +0100edwtjo(~edwtjo@h-7-145.A213.priv.bahnhof.se) (Changing host)
2021-01-04 07:09:56 +0100edwtjo(~edwtjo@fsf/member/edwtjo)
2021-01-04 07:10:25 +0100dansho(~dansho@ec2-3-112-18-114.ap-northeast-1.compute.amazonaws.com) (Ping timeout: 264 seconds)
2021-01-04 07:10:31 +0100 <b4er> So once I have working code I cannot change it with trivial modifications like generalizing functions because it makes my code worse?
2021-01-04 07:10:44 +0100electricityZZZZ(~electrici@108-216-157-17.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 256 seconds)
2021-01-04 07:11:38 +0100 <b4er> Pretty sure that's exactly how a lot of great things in the Haskell ecosystem got born
2021-01-04 07:11:40 +0100Vulfe(~vulfe@2600:1702:31b0:34e0:b1ad:809d:33ad:d747) (Remote host closed the connection)
2021-01-04 07:12:05 +0100 <larryba> it is a reasonable statement from my experience. certainly far more reasonable for haskell than for most other languages. I recently made major refactoring to 10k lines of code base, spent nearly an hour fixing errors compiler gave me on auto-pilot, and it just worked when it finally compiled
2021-01-04 07:17:49 +0100plutoniix(~q@node-uje.pool-125-24.dynamic.totinternet.net)
2021-01-04 07:19:16 +0100 <maerwald> I made a 2 LOC change to a 34k LOC codebase and it broke hell.
2021-01-04 07:19:29 +0100 <maerwald> and it wasn't even IO code.
2021-01-04 07:19:38 +0100 <maerwald> (it was lens)
2021-01-04 07:21:36 +0100 <Axman6> there are techniques which can increase the liklihood that the "if it compiles, it works" will be true - using sum types alone gets you much closer if you can represent only valid values
2021-01-04 07:22:21 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 07:23:25 +0100 <Axman6> I've run into several instances in our codebase where refactoring to only allow valid values had significantly simplied the implementation and made it much more certain the code is correct
2021-01-04 07:23:45 +0100 <MarcelineVQ> aka 'correct by construction'
2021-01-04 07:23:51 +0100 <Axman6> yeah
2021-01-04 07:24:09 +0100 <Axman6> GADTs can also be used to get you even further
2021-01-04 07:26:33 +0100 <koz_> I actually used some type-level shenanigans to allow better error messages at Real Job For Real Money recently.
2021-01-04 07:26:56 +0100 <koz_> (and they're the best kind of type-level shenanigans in that nobody but me needs to understand why they work to use them)
2021-01-04 07:27:01 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:143:c475:d20e:3db4:7e5b) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 07:30:28 +0100jedws(~jedws@121.209.189.201)
2021-01-04 07:31:02 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Quit: leaving)
2021-01-04 07:31:46 +0100dfeuer(~dfeuer@pool-108-18-223-60.washdc.fios.verizon.net) (Ping timeout: 272 seconds)
2021-01-04 07:32:41 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2021-01-04 07:34:43 +0100andreas303(~andreas@gateway/tor-sasl/andreas303) (Ping timeout: 240 seconds)
2021-01-04 07:35:01 +0100Rudd0(~Rudd0@185.189.115.103) (Ping timeout: 264 seconds)
2021-01-04 07:36:03 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 240 seconds)
2021-01-04 07:37:19 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2021-01-04 07:38:22 +0100andreas303(~andreas@gateway/tor-sasl/andreas303)
2021-01-04 07:38:24 +0100tomboy64(~tomboy64@gateway/tor-sasl/tomboy64) (Ping timeout: 240 seconds)
2021-01-04 07:39:04 +0100 <dsal> In my experience, "it compiles" after just about any refactoring is much more likely to give me desirable results than just about anything else.
2021-01-04 07:39:25 +0100 <dsal> tests are compiler enhancements.
2021-01-04 07:40:16 +0100Jesin(~Jesin@pool-72-66-101-18.washdc.fios.verizon.net) (Read error: Connection reset by peer)
2021-01-04 07:40:42 +0100tomboy64(~tomboy64@gateway/tor-sasl/tomboy64)
2021-01-04 07:40:50 +0100 <jle`> yay i solved my recursion problem thing, it was a real pain
2021-01-04 07:40:58 +0100 <jle`> i'm never writing any recursion again
2021-01-04 07:41:01 +0100 <jle`> recursion, not even once
2021-01-04 07:41:20 +0100 <koz_> jle`: This.
2021-01-04 07:41:22 +0100 <dsal> I thought recursion was solved with schemes.
2021-01-04 07:41:25 +0100dansho(~dansho@ec2-3-112-18-114.ap-northeast-1.compute.amazonaws.com)
2021-01-04 07:42:10 +0100 <dsal> recursion-schemes is hard to understand with all the parentheses and call/cc and stuff.
2021-01-04 07:43:33 +0100Anthaas(~Anthaas@unaffiliated/anthaas) (Ping timeout: 256 seconds)
2021-01-04 07:44:16 +0100Goldio(uid478328@gateway/web/irccloud.com/x-xntekinrreveajvt)
2021-01-04 07:45:04 +0100Anthaas(~Anthaas@unaffiliated/anthaas)
2021-01-04 07:47:21 +0100sgibber2018(~arch-gibb@208.85.237.144)
2021-01-04 07:48:54 +0100da39a3ee5e6b4b0d(~da39a3ee5@49.228.238.173)
2021-01-04 07:56:25 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-01-04 08:00:38 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr) (Ping timeout: 265 seconds)
2021-01-04 08:01:37 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2021-01-04 08:02:39 +0100rekahsoft(~rekahsoft@cpe0008a20f982f-cm64777d666260.cpe.net.cable.rogers.com)
2021-01-04 08:04:07 +0100rekahsoft(~rekahsoft@cpe0008a20f982f-cm64777d666260.cpe.net.cable.rogers.com) (Remote host closed the connection)
2021-01-04 08:04:28 +0100rekahsoft(~rekahsoft@cpe0008a20f982f-cm64777d666260.cpe.net.cable.rogers.com)
2021-01-04 08:07:31 +0100plutoniix(~q@node-uje.pool-125-24.dynamic.totinternet.net) (Quit: Leaving)
2021-01-04 08:10:13 +0100cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net) (Quit: Goodbye)
2021-01-04 08:14:17 +0100Deide(~Deide@217.155.19.23)
2021-01-04 08:15:27 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89) (Quit: Ping timeout (120 seconds))
2021-01-04 08:23:54 +0100rekahsoft(~rekahsoft@cpe0008a20f982f-cm64777d666260.cpe.net.cable.rogers.com) (Ping timeout: 268 seconds)
2021-01-04 08:26:31 +0100ransom(~c4264035@8.47.12.52) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 08:29:23 +0100CMCDragonkai1(~Thunderbi@124.19.3.250)
2021-01-04 08:29:54 +0100Gurkenglas(~Gurkengla@unaffiliated/gurkenglas)
2021-01-04 08:30:17 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 08:31:35 +0100ezrakilty(~ezrakilty@75-172-99-84.tukw.qwest.net)
2021-01-04 08:35:26 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-01-04 08:36:08 +0100 <glguy> It's pretty easy to make your code more confusing by fitting it into some existing "recursion scheme"
2021-01-04 08:37:34 +0100 <glguy> I've definitely made code less clear and felt fancy doing it using foldr
2021-01-04 08:38:59 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2021-01-04 08:39:09 +0100 <dminuoso> To quote Dijkstra: The purpose of abstraction is not to be vague, but to create a new semantic level in which one can be absolutely precise.
2021-01-04 08:39:29 +0100 <dminuoso> If you cannot find a precise description using recursion schemes, they're a bad fit.
2021-01-04 08:41:37 +0100drbean(~drbean@TC210-63-209-184.static.apol.com.tw) (Ping timeout: 264 seconds)
2021-01-04 08:41:42 +0100ezrakilty(~ezrakilty@75-172-99-84.tukw.qwest.net) (Remote host closed the connection)
2021-01-04 08:41:43 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh)
2021-01-04 08:42:16 +0100_ht(~quassel@82-169-194-8.biz.kpn.net)
2021-01-04 08:45:08 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 08:49:46 +0100adamwespiser(~adamwespi@209.6.43.158)
2021-01-04 08:54:26 +0100adamwespiser(~adamwespi@209.6.43.158) (Ping timeout: 256 seconds)
2021-01-04 08:57:30 +0100jedws(~jedws@121.209.189.201) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 08:59:04 +0100spopejoy(~stuart@ool-44c5f8c9.dyn.optonline.net) (Quit: spopejoy)
2021-01-04 09:01:36 +0100machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Ping timeout: 240 seconds)
2021-01-04 09:02:16 +0100dandels(~dandels@unaffiliated/dandels)
2021-01-04 09:03:53 +0100 <tdammers> recursion is great when the problem at hand naturally fits the pattern, and when that happens, working with a language that makes recursion cheap and feasible is a godsent
2021-01-04 09:05:04 +0100 <ThoaiOnline> believe it or not, after a full week of deep dive, i was dreaming is haskell last night. **** just got real.
2021-01-04 09:09:56 +0100 <jle`> ThoaiOnline: whoa
2021-01-04 09:12:26 +0100 <dminuoso> **** is the generalisation of Applicative's<*>.
2021-01-04 09:12:49 +0100 <koz_> Before, **** was clearly merely Integral.
2021-01-04 09:15:25 +0100 <ThoaiOnline> perhaps we're actually onto something https://hoogle.haskell.org/?hoogle=****&scope=set%3Astackage
2021-01-04 09:15:40 +0100jespada(~jespada@90.254.245.49)
2021-01-04 09:17:05 +0100edwtjo(~edwtjo@fsf/member/edwtjo) (Ping timeout: 240 seconds)
2021-01-04 09:17:10 +0100 <ThoaiOnline> the fact that anyone can invent operators at will is both super convenient and frightening
2021-01-04 09:17:54 +0100 <dminuoso> ThoaiOnline: In Agda you can create arbitrary post and even mixfix operators!
2021-01-04 09:18:02 +0100 <dminuoso> Imagine the fun writing a parser for such a language.
2021-01-04 09:18:53 +0100edwtjo(~edwtjo@fsf/member/edwtjo)
2021-01-04 09:20:30 +0100 <koz_> Wow, that same package defines +++!
2021-01-04 09:20:51 +0100 <koz_> It's good to know that profunctorial generalizations of Applicative exist.
2021-01-04 09:21:33 +0100dansho(~dansho@ec2-3-112-18-114.ap-northeast-1.compute.amazonaws.com) (Ping timeout: 260 seconds)
2021-01-04 09:26:24 +0100rmk236(~lcampos@2a02:908:3616:b100:ad41:f5e6:8b3a:bfc3)
2021-01-04 09:29:01 +0100ph88(~ph88@ip5f5af6cd.dynamic.kabel-deutschland.de)
2021-01-04 09:30:36 +0100adamwespiser(~adamwespi@209.6.43.158)
2021-01-04 09:35:37 +0100adamwespiser(~adamwespi@209.6.43.158) (Ping timeout: 264 seconds)
2021-01-04 09:35:45 +0100cfricke(~cfricke@unaffiliated/cfricke)
2021-01-04 09:36:15 +0100danso(~dan@23-233-111-39.cpe.pppoe.ca) (Quit: WeeChat 3.0)
2021-01-04 09:36:26 +0100madjestic(~Android@86-88-72-244.fixed.kpn.net)
2021-01-04 09:38:22 +0100thc202(~thc202@unaffiliated/thc202)
2021-01-04 09:41:52 +0100Sgeo(~Sgeo@ool-18b98aa4.dyn.optonline.net) (Read error: Connection reset by peer)
2021-01-04 09:44:58 +0100da39a3ee5e6b4b0d(~da39a3ee5@49.228.238.173) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 09:48:23 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Ping timeout: 240 seconds)
2021-01-04 09:48:49 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-01-04 09:49:03 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh) (Ping timeout: 240 seconds)
2021-01-04 09:49:04 +0100philopsos(~caecilius@gateway/tor-sasl/caecilius) (Ping timeout: 240 seconds)
2021-01-04 09:51:22 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2021-01-04 09:51:23 +0100philopsos(~caecilius@gateway/tor-sasl/caecilius)
2021-01-04 09:53:43 +0100Goldio(uid478328@gateway/web/irccloud.com/x-xntekinrreveajvt) (Quit: Connection closed for inactivity)
2021-01-04 09:56:58 +0100kuribas(~user@ptr-25vy0i8khwxhgges4vi.18120a2.ip6.access.telenet.be)
2021-01-04 10:00:07 +0100boistordu(boistordum@gateway/shell/matrix.org/x-dtootmkcjgdppcmk) (Quit: Idle for 30+ days)
2021-01-04 10:00:36 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh)
2021-01-04 10:01:34 +0100shatriff(~vitaliish@176-52-216-242.irishtelecom.com) (Remote host closed the connection)
2021-01-04 10:01:36 +0100 <idnar> how do I use -ddump-stg with cabal?
2021-01-04 10:02:55 +0100shatriff(~vitaliish@176-52-216-242.irishtelecom.com)
2021-01-04 10:03:24 +0100shatriff(~vitaliish@176-52-216-242.irishtelecom.com) (Remote host closed the connection)
2021-01-04 10:03:41 +0100shatriff(~vitaliish@176-52-216-242.irishtelecom.com)
2021-01-04 10:04:12 +0100shatriff(~vitaliish@176-52-216-242.irishtelecom.com) (Remote host closed the connection)
2021-01-04 10:04:30 +0100shatriff(~vitaliish@176-52-216-242.irishtelecom.com)
2021-01-04 10:05:01 +0100shatriff(~vitaliish@176-52-216-242.irishtelecom.com) (Remote host closed the connection)
2021-01-04 10:05:20 +0100shatriff(~vitaliish@176-52-216-242.irishtelecom.com)
2021-01-04 10:05:49 +0100shatriff(~vitaliish@176-52-216-242.irishtelecom.com) (Remote host closed the connection)
2021-01-04 10:05:51 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de)
2021-01-04 10:06:10 +0100jedws(~jedws@121.209.189.201)
2021-01-04 10:14:03 +0100philopsos(~caecilius@gateway/tor-sasl/caecilius) (Ping timeout: 240 seconds)
2021-01-04 10:14:17 +0100b4er(~b4er@91.193.4.106) (Ping timeout: 268 seconds)
2021-01-04 10:15:40 +0100philopsos(~caecilius@gateway/tor-sasl/caecilius)
2021-01-04 10:16:58 +0100jedws(~jedws@121.209.189.201) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 10:17:47 +0100b3zib3z
2021-01-04 10:18:42 +0100jedws(~jedws@121.209.189.201)
2021-01-04 10:19:16 +0100b3z(~b3z@vmd41962.contaboserver.net) ()
2021-01-04 10:19:32 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 10:20:46 +0100hnOsmium0001(uid453710@gateway/web/irccloud.com/x-ifctsrxnkcmchcxm) (Quit: Connection closed for inactivity)
2021-01-04 10:22:22 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Remote host closed the connection)
2021-01-04 10:24:33 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-01-04 10:24:52 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2021-01-04 10:28:14 +0100heatsink(~heatsink@2600:1700:bef1:5e10:9188:afb8:416b:5229) (Remote host closed the connection)
2021-01-04 10:29:30 +0100SzBB(~SzBB@244-13-138-91.dyn.cable.fcom.ch)
2021-01-04 10:40:47 +0100pthariensflame(~pthariens@2600:6c52:7280:100:74b9:5eb6:fa0d:d4f0)
2021-01-04 10:40:59 +0100pthariensflame(~pthariens@2600:6c52:7280:100:74b9:5eb6:fa0d:d4f0) (Client Quit)
2021-01-04 10:41:22 +0100kjak(~kjak@pool-108-45-56-21.washdc.fios.verizon.net) (Ping timeout: 258 seconds)
2021-01-04 10:44:06 +0100DavidEichmann(~david@98.27.93.209.dyn.plus.net)
2021-01-04 10:46:19 +0100 <dminuoso> idnar: You can set ghc-options (either via cli flag or cabal.project/cabal.project.local), or via {-# OPTIONS_GHC -ddump-stg #-} for any module you want it.
2021-01-04 10:46:36 +0100 <dminuoso> In addition you might find -ddump-to-file and -ddump-file-prefix of interest.
2021-01-04 10:47:01 +0100o1lo01ol_(~o1lo01ol1@bl11-140-216.dsl.telepac.pt) (Remote host closed the connection)
2021-01-04 10:49:40 +0100 <idnar> dminuoso: ah yes, I forgot OPTIONS_GHC
2021-01-04 10:50:43 +0100 <idnar> now to see if I can make any sense of this
2021-01-04 10:50:48 +0100Franciman(~francesco@host-87-17-26-221.retail.telecomitalia.it)
2021-01-04 10:51:10 +0100kritzefitz(~kritzefit@fw-front.credativ.com)
2021-01-04 10:51:49 +0100SzBB(~SzBB@244-13-138-91.dyn.cable.fcom.ch) (Quit: Leaving)
2021-01-04 10:53:51 +0100shatriff(~vitaliish@80.233.34.229)
2021-01-04 10:54:00 +0100CMCDragonkai1(~Thunderbi@124.19.3.250) (Quit: CMCDragonkai1)
2021-01-04 10:54:05 +0100michalz(~user@185.246.204.78)
2021-01-04 10:54:17 +0100jedws(~jedws@121.209.189.201) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 10:54:28 +0100 <idnar> !! 80 MB?!
2021-01-04 10:55:26 +0100jedws(~jedws@121.209.189.201)
2021-01-04 10:55:47 +0100 <ThoaiOnline> @idnar hey hey it's static compilation we're talking about here :P
2021-01-04 10:55:47 +0100 <lambdabot> Unknown command, try @list
2021-01-04 10:58:11 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 11:00:37 +0100m0rphism(~m0rphism@HSI-KBW-085-216-104-059.hsi.kabelbw.de)
2021-01-04 11:02:03 +0100fendor(~fendor@178.115.130.71.wireless.dyn.drei.com)
2021-01-04 11:04:27 +0100Rudd0(~Rudd0@185.189.115.103)
2021-01-04 11:04:37 +0100tomboy64(~tomboy64@gateway/tor-sasl/tomboy64) (Remote host closed the connection)
2021-01-04 11:05:06 +0100tomboy64(~tomboy64@gateway/tor-sasl/tomboy64)
2021-01-04 11:05:33 +0100hiroaki(~hiroaki@ip4d16b6b9.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2021-01-04 11:06:08 +0100hiroaki(~hiroaki@ip4d16b6b9.dynamic.kabel-deutschland.de)
2021-01-04 11:08:51 +0100LKoen(~LKoen@174.175.9.109.rev.sfr.net)
2021-01-04 11:10:39 +0100dandels(~dandels@unaffiliated/dandels) (Ping timeout: 260 seconds)
2021-01-04 11:12:13 +0100urdh(~urdh@unaffiliated/urdh) (Quit: Boom!)
2021-01-04 11:14:12 +0100rnat2(uid73555@gateway/web/irccloud.com/x-ealqzpltkozxdmaa)
2021-01-04 11:16:15 +0100dhil(~dhil@78.156.97.38)
2021-01-04 11:25:25 +0100Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi)
2021-01-04 11:28:35 +0100Guest82752(~textual@2603-7000-3040-0000-0072-420e-44f4-4dab.res6.spectrum.com) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 11:28:35 +0100heatsink(~heatsink@2600:1700:bef1:5e10:9188:afb8:416b:5229)
2021-01-04 11:30:42 +0100Alleria(~textual@2603-7000-3040-0000-0072-420e-44f4-4dab.res6.spectrum.com)
2021-01-04 11:31:06 +0100AlleriaGuest59377
2021-01-04 11:31:56 +0100adamwespiser(~adamwespi@209.6.43.158)
2021-01-04 11:32:19 +0100dandels(~dandels@unaffiliated/dandels)
2021-01-04 11:33:05 +0100acidjnk_new(~acidjnk@p200300d0c704e789dd5e2676b6b00ca1.dip0.t-ipconnect.de)
2021-01-04 11:33:07 +0100heatsink(~heatsink@2600:1700:bef1:5e10:9188:afb8:416b:5229) (Ping timeout: 260 seconds)
2021-01-04 11:33:13 +0100Guest59377(~textual@2603-7000-3040-0000-0072-420e-44f4-4dab.res6.spectrum.com) (Client Quit)
2021-01-04 11:33:15 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:143:71ff:303a:4980:438c)
2021-01-04 11:34:15 +0100cheater(~user@unaffiliated/cheater) (Ping timeout: 256 seconds)
2021-01-04 11:36:17 +0100 <idnar> oh okay it's _fully_ inlined things like `showDuration d = (showRational 2 . toSeconds) d <> "s"` and the code wraps to a billion lines because it's indented so far
2021-01-04 11:36:54 +0100adamwespiser(~adamwespi@209.6.43.158) (Ping timeout: 260 seconds)
2021-01-04 11:43:30 +0100ezrakilty(~ezrakilty@75-172-99-84.tukw.qwest.net)
2021-01-04 11:46:23 +0100greylica(~greylica@139.28.218.148) (Remote host closed the connection)
2021-01-04 11:47:46 +0100ezrakilty(~ezrakilty@75-172-99-84.tukw.qwest.net) (Ping timeout: 246 seconds)
2021-01-04 11:48:41 +0100jedws(~jedws@121.209.189.201) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 11:49:46 +0100Alleria__(~textual@mskresolve-a.mskcc.org)
2021-01-04 11:54:13 +0100 <idnar> -dppr-cols=250
2021-01-04 11:54:25 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de) (Ping timeout: 246 seconds)
2021-01-04 12:00:09 +0100adamwespiser(~adamwespi@209.6.43.158)
2021-01-04 12:02:31 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2021-01-04 12:03:04 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2021-01-04 12:03:23 +0100__monty__(~toonn@unaffiliated/toonn)
2021-01-04 12:06:06 +0100b4er(~b4er@91.193.4.122)
2021-01-04 12:06:43 +0100pdurbin1(~pdurbin@217.146.82.202)
2021-01-04 12:12:49 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2021-01-04 12:13:02 +0100cfricke(~cfricke@unaffiliated/cfricke) (Quit: WeeChat 3.0)
2021-01-04 12:13:31 +0100christo(~chris@81.96.113.213)
2021-01-04 12:15:47 +0100wei2912(~wei2912@unaffiliated/wei2912) (Remote host closed the connection)
2021-01-04 12:17:01 +0100dandels(~dandels@unaffiliated/dandels) (Ping timeout: 264 seconds)
2021-01-04 12:18:13 +0100christo(~chris@81.96.113.213) (Ping timeout: 264 seconds)
2021-01-04 12:20:31 +0100davve_(davve@bsd.douchedata.com) (Quit: leaving)
2021-01-04 12:23:09 +0100larryba(~bc812391@217.29.117.252) (Quit: http://www.okay.uz/ (Session timeout))
2021-01-04 12:29:32 +0100dandels(~dandels@unaffiliated/dandels)
2021-01-04 12:29:51 +0100heatsink(~heatsink@2600:1700:bef1:5e10:f4f0:b09:41bd:e3e)
2021-01-04 12:31:58 +0100urdh(~urdh@unaffiliated/urdh)
2021-01-04 12:33:49 +0100shatriff(~vitaliish@80.233.34.229) (Ping timeout: 264 seconds)
2021-01-04 12:34:50 +0100heatsink(~heatsink@2600:1700:bef1:5e10:f4f0:b09:41bd:e3e) (Ping timeout: 264 seconds)
2021-01-04 12:36:35 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:143:71ff:303a:4980:438c) (Read error: Connection reset by peer)
2021-01-04 12:41:23 +0100cfricke(~cfricke@unaffiliated/cfricke)
2021-01-04 12:43:34 +0100 <kuribas> why isn't ReaderT a profunctor?
2021-01-04 12:43:43 +0100jedws(~jedws@121.209.189.201)
2021-01-04 12:44:05 +0100 <kuribas> https://hackage.haskell.org/package/profunctors-5.6.1/docs/Data-Profunctor.html
2021-01-04 12:46:24 +0100 <Taneb> kuribas: type arguments are in the wrong order
2021-01-04 12:46:36 +0100 <kuribas> ah right...
2021-01-04 12:46:41 +0100 <kuribas> :i ReaderT
2021-01-04 12:46:49 +0100 <kuribas> :k ReaderT
2021-01-04 12:46:51 +0100 <lambdabot> * -> (* -> *) -> * -> *
2021-01-04 12:47:35 +0100 <Taneb> kuribas: there's Star which is very similar with the arguments in the right oder
2021-01-04 12:48:13 +0100 <Taneb> But ReaderT wants the m parameter second-to-last so it can have a MonadTrans instance
2021-01-04 12:51:23 +0100bitmagie(~Thunderbi@200116b806b5fe00740e531bf47a925c.dip.versatel-1u1.de)
2021-01-04 12:53:19 +0100ph88(~ph88@ip5f5af6cd.dynamic.kabel-deutschland.de) (Ping timeout: 260 seconds)
2021-01-04 12:53:28 +0100Sheilong(uid293653@gateway/web/irccloud.com/x-qgpagvfhytqrdzbx)
2021-01-04 12:54:43 +0100dandels(~dandels@unaffiliated/dandels) (Ping timeout: 256 seconds)
2021-01-04 13:01:35 +0100drbean(~drbean@TC210-63-209-175.static.apol.com.tw)
2021-01-04 13:01:43 +0100rmk236(~lcampos@2a02:908:3616:b100:ad41:f5e6:8b3a:bfc3) (Quit: Leaving.)
2021-01-04 13:05:15 +0100Entertainment(~entertain@104.246.132.210)
2021-01-04 13:08:00 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2021-01-04 13:08:41 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2021-01-04 13:09:51 +0100jedws(~jedws@121.209.189.201) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 13:10:55 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2021-01-04 13:11:19 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2021-01-04 13:12:47 +0100Tario(~Tario@201.192.165.173)
2021-01-04 13:13:02 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:12e2:f4f0:d2c0:3ecf:a408)
2021-01-04 13:14:53 +0100acidjnk_new(~acidjnk@p200300d0c704e789dd5e2676b6b00ca1.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2021-01-04 13:16:37 +0100xff0x(~fox@2001:1a81:5271:e800:9600:6dbe:32ee:1f82) (Ping timeout: 258 seconds)
2021-01-04 13:17:21 +0100xff0x(~fox@2001:1a81:5271:e800:63d8:c69:6df1:58cb)
2021-01-04 13:23:03 +0100jedws(~jedws@121.209.189.201)
2021-01-04 13:24:25 +0100ph88(~ph88@2a02:8109:9e00:7e5c:107a:c84:877e:fc08)
2021-01-04 13:26:05 +0100Stanley|00(~stanley00@unaffiliated/stanley00) ()
2021-01-04 13:29:37 +0100tama00(~tama@unaffiliated/tama00) (Ping timeout: 264 seconds)
2021-01-04 13:36:44 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl)
2021-01-04 13:40:07 +0100geekosaur(ac3a3ed6@172.58.62.214)
2021-01-04 13:41:01 +0100cmcma20(~cmcma20@l37-192-2-125.novotelecom.ru)
2021-01-04 13:43:55 +0100 <cmcma20> hi! what is the preferred method to share code snippets in this channel?
2021-01-04 13:44:18 +0100 <hpc> according to the topic, gist
2021-01-04 13:44:30 +0100 <hpc> if you don't want to log into github, there's various other paste sites
2021-01-04 13:44:46 +0100urdh(~urdh@unaffiliated/urdh) (Quit: Boom!)
2021-01-04 13:44:46 +0100 <hpc> just pick one that you like
2021-01-04 13:44:59 +0100 <cmcma20> lpaste is dead so I'm quite confused. thx for your suggestions, gonna just use github
2021-01-04 13:46:46 +0100Major_Biscuit(~Major_Bis@93-21-124.netrun.cytanet.com.cy)
2021-01-04 13:47:53 +0100 <pjb> cmcma20: I like termbin: http://termbin.com you can use it with: cat foo.hs | nc termbin.com 9999 | tr -d '\000'
2021-01-04 13:49:12 +0100bitmagie(~Thunderbi@200116b806b5fe00740e531bf47a925c.dip.versatel-1u1.de) (Quit: bitmagie)
2021-01-04 13:50:18 +0100urdh(~urdh@unaffiliated/urdh)
2021-01-04 13:50:26 +0100 <ski> @paste
2021-01-04 13:50:27 +0100 <lambdabot> A pastebin: https://paste.debian.net/
2021-01-04 13:50:33 +0100 <ski> @where paste
2021-01-04 13:50:33 +0100 <lambdabot> Help us help you: please paste full code, input and/or output at eg https://paste.tomsmeding.com
2021-01-04 13:50:41 +0100 <ski> cmcma20 ^
2021-01-04 13:51:41 +0100 <pjb> cmcma20: there are also things like https://codeshare.io and others that let you share and compile code in the web, for collaborative debugging and development.
2021-01-04 13:52:00 +0100 <ski> kuribas : `Kleisli' ?
2021-01-04 13:52:24 +0100 <kuribas> ski: what about Kleisli?
2021-01-04 13:52:46 +0100 <cmcma20> thanks a lot! "@where paste" was enlightening
2021-01-04 13:52:51 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de)
2021-01-04 13:53:07 +0100 <ski> newtype ReaderT r m a = ReaderT (r -> m a)
2021-01-04 13:53:08 +0100 <ski> newtype Kleisli m a b = Kleisli (a -> m b)
2021-01-04 13:53:09 +0100 <pjb> cmcma20: For example https://www.jdoodle.com/execute-haskell-online/
2021-01-04 13:53:23 +0100 <kuribas> :t Kleisli
2021-01-04 13:53:25 +0100 <lambdabot> (a -> m b) -> Kleisli m a b
2021-01-04 13:54:39 +0100 <ski> @type dimap
2021-01-04 13:54:40 +0100 <lambdabot> Profunctor p => (a -> b) -> (c -> d) -> p b c -> p a d
2021-01-04 13:54:42 +0100 <ski> @type dimap :: Monad m => (a1 -> a0) -> (b0 -> b1) -> (Kleisli m a0 b0 -> Kleisli m a1 b1)
2021-01-04 13:54:43 +0100 <lambdabot> Monad m => (a1 -> a0) -> (b0 -> b1) -> Kleisli m a0 b0 -> Kleisli m a1 b1
2021-01-04 13:57:27 +0100 <kuribas> @type dimap @_ @_ @_ @_ Kleisli
2021-01-04 13:57:28 +0100 <lambdabot> error:
2021-01-04 13:57:28 +0100 <lambdabot> Pattern syntax in expression context: dimap@_
2021-01-04 13:57:28 +0100 <lambdabot> Did you mean to enable TypeApplications?
2021-01-04 13:57:37 +0100 <kuribas> ye
2021-01-04 13:57:40 +0100 <kuribas> yes
2021-01-04 13:58:55 +0100 <ski> % :t dimap @_ @_ @_ @_ Kleisli
2021-01-04 13:58:56 +0100 <yahb> ski: Profunctor _1 => (_2 -> d) -> _1 (Kleisli m a b) _2 -> _1 (a -> m b) d
2021-01-04 13:59:38 +0100kjak(~kjak@pool-108-45-56-21.washdc.fios.verizon.net)
2021-01-04 14:02:09 +0100 <cmcma20> I'm trying to master fused-effects but it's not going well. This paste should explain a bit: https://paste.tomsmeding.com/thKjEyrP
2021-01-04 14:03:17 +0100 <kuribas> % :t dimap @_ @_ @_ @_ @_ Kleisli
2021-01-04 14:03:17 +0100 <yahb> kuribas: Profunctor _1 => (_2 -> _3) -> _1 (Kleisli m a b) _2 -> _1 (a -> m b) _3
2021-01-04 14:03:26 +0100 <kuribas> looks wrong still...
2021-01-04 14:03:57 +0100 <cmcma20> Using Reader with concrete types is OK, but I can't properly use Reader with parameterized types.
2021-01-04 14:04:14 +0100 <kuribas> why not?
2021-01-04 14:04:56 +0100mouseghost(~draco@wikipedia/desperek)
2021-01-04 14:05:00 +0100bitmagie(~Thunderbi@200116b806b5fe00740e531bf47a925c.dip.versatel-1u1.de)
2021-01-04 14:05:12 +0100 <ski> @type \f g -> runKleisli . dimap f g . Kleisli
2021-01-04 14:05:14 +0100 <lambdabot> Monad m => (a -> b1) -> (c -> b2) -> (b1 -> m c) -> a -> m b2
2021-01-04 14:05:17 +0100 <cmcma20> I can't understand why GHC emits a warning about overlapping instances for Control.Effect.Sum.Member (Reader (LangStatic env0 cmd0)) (Reader (LangStatic () Exp) Control.Effect.Sum.:+: fused-effects-1.1.1.0:Control.Effect.Lift.Internal.Lift IO
2021-01-04 14:05:45 +0100 <ski> kuribas : not sure what you intended to get, there ..
2021-01-04 14:05:54 +0100 <tomsmeding> cmcma20: what if you use TypeApplications and write (usage @() @Exp) instead of just 'usage' in main?
2021-01-04 14:06:03 +0100 <cmcma20> It looks plain wrong because LangStatic env0 cmd0 is more general so it can't be a subeffect of a more concrete LangStatic () Exp
2021-01-04 14:06:13 +0100 <tomsmeding> not saying that's a good and nice solution, just exploring the problem
2021-01-04 14:06:31 +0100 <kuribas> ski: dimap specialized to Kleisli :)
2021-01-04 14:06:43 +0100philopsos(~caecilius@gateway/tor-sasl/caecilius) (Ping timeout: 240 seconds)
2021-01-04 14:06:49 +0100bitmagie(~Thunderbi@200116b806b5fe00740e531bf47a925c.dip.versatel-1u1.de) (Client Quit)
2021-01-04 14:07:10 +0100 <ski> i guess you mean specialized to `Kleisli m'
2021-01-04 14:07:24 +0100 <cmcma20> tomsmeding: astonishingly simple solution
2021-01-04 14:07:35 +0100 <merijn> cmcma20: Quite brittle too ;)
2021-01-04 14:07:48 +0100 <tomsmeding> ghc is telling you it can't figure out what instance to use, because that depends on the instantiation of the env and cmd type variables
2021-01-04 14:08:02 +0100 <tomsmeding> with that visible type application, you tell it what they are :p
2021-01-04 14:08:07 +0100justanotheruser(~justanoth@unaffiliated/justanotheruser) (Ping timeout: 272 seconds)
2021-01-04 14:08:12 +0100 <kuribas> :t dimap @_ @_ @_ @_ (Kleisli m a b)
2021-01-04 14:08:14 +0100 <lambdabot> error:
2021-01-04 14:08:14 +0100 <lambdabot> Pattern syntax in expression context: dimap@_
2021-01-04 14:08:14 +0100 <lambdabot> Did you mean to enable TypeApplications?
2021-01-04 14:08:23 +0100 <kuribas> % :t dimap @_ @_ @_ @_ (Kleisli m a b)
2021-01-04 14:08:23 +0100 <yahb> kuribas: ; <interactive>:1:20: warning: [-Wdeferred-type-errors]; * Couldn't match expected type `t0 -> t1 -> _3 -> _2' with actual type `Kleisli m0 a0 b0'; * The function `Kleisli' is applied to three arguments,; but its type `(a0 -> m0 b0) -> Kleisli m0 a0 b0' has only one; In the fifth argument of `dimap', namely `(Kleisli m a b)'; In the expression: dimap @_ @_ @_ @_ (Kleisli m a b)
2021-01-04 14:08:25 +0100 <ski> @type dimap `asTypeIn` \dimap f g -> runKleisli . dimap f g . Kleisli
2021-01-04 14:08:26 +0100 <lambdabot> Monad m => (a -> b1) -> (c -> b2) -> Kleisli m b1 c -> Kleisli m a b2
2021-01-04 14:08:29 +0100 <tomsmeding> but I have no idea about fused-effects, so someone else will have to say how you properly fix this cmcma20
2021-01-04 14:08:42 +0100 <kuribas> % :t dimap @_ @_ @_ @_ @(Kleisli m a b)
2021-01-04 14:08:42 +0100 <yahb> kuribas: ; <interactive>:1:29: error: Not in scope: type variable `m'; <interactive>:1:31: error: Not in scope: type variable `a'; <interactive>:1:33: error: Not in scope: type variable `b'
2021-01-04 14:09:01 +0100 <cmcma20> tomsmeding: But why can't it figure it out if one of the variants is strictly more specific?
2021-01-04 14:09:28 +0100 <cmcma20> I guess my intuition about instance resolution is flawed
2021-01-04 14:09:58 +0100 <merijn> cmcma20: Ok, simple example why it can't do that
2021-01-04 14:10:36 +0100 <merijn> cmcma20: Consider library A and B, one provides typeclass that's parameterised over some variable, one that has more specific instances
2021-01-04 14:11:07 +0100 <tomsmeding> general algorithm for instance resolution is: look only at the right-hand sides of the => of instance declarations, and find all that match. If there are multiple, abort. If there is exactly one, add the left-hand side of the => to the set of constraints to solve, and continue
2021-01-04 14:11:28 +0100 <merijn> cmcma20: Now library C depends on B (and it's instance) and my executable depends on A and C, there's no guarantee those two instances are always in scope despite being in the same executable
2021-01-04 14:11:53 +0100 <kuribas> % :t dimap @(Kleisli _)
2021-01-04 14:11:54 +0100 <yahb> kuribas: Monad _ => (a -> b) -> (c -> d) -> Kleisli _ b c -> Kleisli _ a d
2021-01-04 14:12:02 +0100 <kuribas> ski: success :)
2021-01-04 14:12:06 +0100 <merijn> cmcma20: Basically, given "instance Foo (Bar a)" it's impossible for GHC to prove that "instance Foo (Bar X)" doesn't exist *somewhere*
2021-01-04 14:12:09 +0100 <kuribas> % :t dimap @(Kleisli m)
2021-01-04 14:12:10 +0100 <yahb> kuribas: ; <interactive>:1:17: error: Not in scope: type variable `m'
2021-01-04 14:12:20 +0100 <kuribas> % :t dimap @(Kleisli _m)
2021-01-04 14:12:21 +0100 <ski> type-lambda would be handy :)
2021-01-04 14:12:21 +0100 <yahb> kuribas: ; <interactive>:1:17: error: Not in scope: type variable `_m'
2021-01-04 14:12:27 +0100 <kuribas> ski: yeah
2021-01-04 14:12:42 +0100 <merijn> cmcma20: So the sanest thing to do is "when you see instance for 'Bar a', disallow any other instances for 'Bar'"
2021-01-04 14:13:18 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d)
2021-01-04 14:13:35 +0100rmk236(~lcampos@ip-37-201-210-153.hsi13.unitymediagroup.de)
2021-01-04 14:13:57 +0100 <cmcma20> merijn tomsmeding : thank you, the fog has cleared up a bit
2021-01-04 14:14:25 +0100 <tomsmeding> being pinged by the pastebin sometimes shows me interesting questions :)
2021-01-04 14:14:30 +0100st8less(~st8less@2603:a060:11fd:0:7893:a633:39db:c3dc)
2021-01-04 14:16:06 +0100LKoen(~LKoen@174.175.9.109.rev.sfr.net) (Remote host closed the connection)
2021-01-04 14:19:25 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de) (Ping timeout: 264 seconds)
2021-01-04 14:19:46 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:12e2:f4f0:d2c0:3ecf:a408) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 14:20:11 +0100LKoen(~LKoen@174.175.9.109.rev.sfr.net)
2021-01-04 14:22:01 +0100brisbin(~patrick@pool-173-49-158-4.phlapa.fios.verizon.net)
2021-01-04 14:22:25 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2021-01-04 14:22:41 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2021-01-04 14:25:38 +0100usr25(~usr25@unaffiliated/usr25)
2021-01-04 14:29:00 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de)
2021-01-04 14:29:27 +0100pdurbin1(~pdurbin@217.146.82.202) (Remote host closed the connection)
2021-01-04 14:31:23 +0100heatsink(~heatsink@2600:1700:bef1:5e10:f4f0:b09:41bd:e3e)
2021-01-04 14:32:11 +0100st8less(~st8less@2603:a060:11fd:0:7893:a633:39db:c3dc) (Ping timeout: 272 seconds)
2021-01-04 14:32:20 +0100fionnan(~fionnan@109.255.20.201) (Ping timeout: 256 seconds)
2021-01-04 14:33:45 +0100st8less(~st8less@inet-167-224-197-181.isp.ozarksgo.net)
2021-01-04 14:33:54 +0100Deide(~Deide@217.155.19.23) (Read error: Connection reset by peer)
2021-01-04 14:34:09 +0100Deide(~Deide@217.155.19.23)
2021-01-04 14:36:17 +0100heatsink(~heatsink@2600:1700:bef1:5e10:f4f0:b09:41bd:e3e) (Ping timeout: 260 seconds)
2021-01-04 14:36:49 +0100rmk236(~lcampos@ip-37-201-210-153.hsi13.unitymediagroup.de) (Ping timeout: 246 seconds)
2021-01-04 14:39:58 +0100rmk236(~lcampos@2a02:908:3616:b100:ad41:f5e6:8b3a:bfc3)
2021-01-04 14:47:55 +0100usr25(~usr25@unaffiliated/usr25) (Quit: Leaving)
2021-01-04 14:48:32 +0100drbean(~drbean@TC210-63-209-175.static.apol.com.tw) (Ping timeout: 260 seconds)
2021-01-04 14:49:11 +0100langseth1(~langseth@84.39.116.180)
2021-01-04 14:51:03 +0100nh(~NextHendr@unaffiliated/nexthendrix) ("Leaving")
2021-01-04 14:51:16 +0100urodna(~urodna@unaffiliated/urodna)
2021-01-04 14:52:05 +0100p3n(~p3n@2a00:19a0:3:7c:0:d9c6:7cf6:1)
2021-01-04 14:57:51 +0100usr25(~usr25@unaffiliated/usr25)
2021-01-04 14:59:59 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:d98a:f1dc:914b:1b92)
2021-01-04 15:00:58 +0100machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-01-04 15:01:52 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2021-01-04 15:03:11 +0100ThoaiOnline(~ThoaiOnli@nv.tho.ai) (Quit: Leaving.)
2021-01-04 15:03:12 +0100cheater(~user@unaffiliated/cheater)
2021-01-04 15:03:58 +0100argento(~argent0@168.227.97.29)
2021-01-04 15:04:22 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de) (Quit: mputz)
2021-01-04 15:04:54 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de)
2021-01-04 15:05:05 +0100LKoen_(~LKoen@174.175.9.109.rev.sfr.net)
2021-01-04 15:05:40 +0100Major_Biscuit(~Major_Bis@93-21-124.netrun.cytanet.com.cy) (Read error: Connection reset by peer)
2021-01-04 15:06:00 +0100 <kuribas> % :t dimap @(Kleisli _) @_
2021-01-04 15:06:00 +0100 <yahb> kuribas: Monad _1 => (_2 -> b) -> (c -> d) -> Kleisli _1 b c -> Kleisli _1 _2 d
2021-01-04 15:06:09 +0100carthia(~carthia@gateway/tor-sasl/carthia)
2021-01-04 15:06:10 +0100djellemah(~djellemah@2601:5c2:100:96c:e008:b638:39fe:6a54)
2021-01-04 15:07:25 +0100LKoen(~LKoen@174.175.9.109.rev.sfr.net) (Ping timeout: 240 seconds)
2021-01-04 15:08:02 +0100sgibber2018(~arch-gibb@208.85.237.144) (Quit: WeeChat 3.0)
2021-01-04 15:08:10 +0100knupfer(~Thunderbi@dynamic-046-114-150-158.46.114.pool.telefonica.de)
2021-01-04 15:08:30 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net)
2021-01-04 15:13:11 +0100jmchael(~jmchael@81.174.205.210)
2021-01-04 15:13:24 +0100 <kuribas> I sometimes read about the "puzzle factor", meaning that writing haskell and functional language is like solving a puzzle. It's all cute and fun, but in the end doesn't have any benefit.
2021-01-04 15:13:49 +0100 <kuribas> Isn't the benefit that when the puzzle is solved, your program is "mostly" correct?
2021-01-04 15:14:37 +0100 <kuribas> like lenses, it took a while to "solve the puzzle", and get to the representation we have now, but now we reap the benefits.
2021-01-04 15:19:35 +0100 <kuribas> Also the fact that you can rewrite code without needing deep insights, just using equaltional reasoning.
2021-01-04 15:19:48 +0100 <kuribas> Just like solving an algebra problem.
2021-01-04 15:20:57 +0100ulidtko(~ulidtko@194.54.80.38)
2021-01-04 15:20:58 +0100ulidtko|k(~ulidtko@194.54.80.38)
2021-01-04 15:21:06 +0100ulidtko(~ulidtko@194.54.80.38) (Remote host closed the connection)
2021-01-04 15:21:15 +0100ulidtko|kulidtko
2021-01-04 15:21:25 +0100nfd(~nfd9001@c-67-183-38-33.hsd1.wa.comcast.net) (Ping timeout: 240 seconds)
2021-01-04 15:21:31 +0100 <merijn> kuribas: I saw a good argument that explains things some time ago
2021-01-04 15:21:51 +0100 <kuribas> link?
2021-01-04 15:22:53 +0100 <merijn> kuribas: The essay basically argued, there's two programmer streams: the mathematicians and the tinkerers. The former basically want to "think hard, then write obviously correct solution", the latter wants to incrementally built on top of "stuff we have and understand". This leads to very different ways of working
2021-01-04 15:23:17 +0100 <merijn> i.e. the former likes static types, "correct by construction" and nice property preserving abstractions
2021-01-04 15:23:23 +0100 <kuribas> merijn: that sounds like tdammers :-)
2021-01-04 15:23:56 +0100 <merijn> the latter group likes "simple" code they can understand, tying it together, and testing at every stage that things work, so they like TDD and repls, etc.
2021-01-04 15:24:30 +0100 <kuribas> merijn: I like to tinker on types, and build on top of types I have and understand :)
2021-01-04 15:24:32 +0100 <merijn> kuribas: The latter see no value in "this abstraction preservers all my properties, so I don't have to think"
2021-01-04 15:24:41 +0100 <kuribas> ah right
2021-01-04 15:24:47 +0100 <merijn> kuribas: In which case the machinery to build such abstractions is worthless
2021-01-04 15:25:11 +0100 <kuribas> but thinking in terms of abstractions is also something you learn
2021-01-04 15:25:24 +0100 <merijn> That's all massive oversimplifications, of course :p
2021-01-04 15:26:30 +0100cfricke(~cfricke@unaffiliated/cfricke) (Quit: WeeChat 3.0)
2021-01-04 15:31:15 +0100notzmv(~user@unaffiliated/zmv) (Remote host closed the connection)
2021-01-04 15:31:34 +0100justanotheruser(~justanoth@unaffiliated/justanotheruser)
2021-01-04 15:33:25 +0100cads2(~cads@ip-64-72-99-232.lasvegas.net) (Ping timeout: 240 seconds)
2021-01-04 15:33:31 +0100cads(~cads@ip-64-72-99-232.lasvegas.net) (Ping timeout: 246 seconds)
2021-01-04 15:35:40 +0100 <dminuoso> merijn: Mmm, while I do not know the assay you are referring to, the summary sparks disagreement with me.
2021-01-04 15:36:01 +0100 <merijn> dminuoso: I'm not quite happy with my summary
2021-01-04 15:36:10 +0100 <merijn> but also to lazy to invest in making a better one
2021-01-04 15:36:16 +0100 <dminuoso> What's the assay?
2021-01-04 15:36:28 +0100notzmv(~user@unaffiliated/zmv)
2021-01-04 15:36:38 +0100 <merijn> dminuoso: I can't recall, that was like a week and a half ago
2021-01-04 15:39:17 +0100Sgeo(~Sgeo@ool-18b98aa4.dyn.optonline.net)
2021-01-04 15:39:49 +0100darjeeling_(~darjeelin@115.215.41.150) (Ping timeout: 264 seconds)
2021-01-04 15:41:07 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:12e2:f4f0:d2c0:3ecf:a408)
2021-01-04 15:43:46 +0100Tops2(~Tobias@dyndsl-095-033-022-235.ewe-ip-backbone.de)
2021-01-04 15:44:32 +0100elvishjerricco(sid237756@NixOS/user/ElvishJerricco) (Ping timeout: 260 seconds)
2021-01-04 15:44:46 +0100geekosaur(ac3a3ed6@172.58.62.214) (Remote host closed the connection)
2021-01-04 15:45:12 +0100orcus-(~orcus@unaffiliated/orcus)
2021-01-04 15:45:29 +0100Major_Biscuit(~Major_Bis@93-21-124.netrun.cytanet.com.cy)
2021-01-04 15:45:42 +0100rnat2(uid73555@gateway/web/irccloud.com/x-ealqzpltkozxdmaa) (Ping timeout: 260 seconds)
2021-01-04 15:45:42 +0100Kronic(uid480486@gateway/web/irccloud.com/x-rjhpihcgimfhbndr) (Ping timeout: 260 seconds)
2021-01-04 15:45:42 +0100d0liver(sid363046@gateway/web/irccloud.com/x-aesspnxmupkvbzzz) (Ping timeout: 260 seconds)
2021-01-04 15:46:02 +0100elvishjerricco(sid237756@NixOS/user/ElvishJerricco)
2021-01-04 15:46:13 +0100recon_-_(~quassel@2602:febc:0:b6::6ca2)
2021-01-04 15:46:17 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:12e2:f4f0:d2c0:3ecf:a408) (Ping timeout: 260 seconds)
2021-01-04 15:46:17 +0100recon_-(~quassel@2602:febc:0:b6::6ca2) (Ping timeout: 260 seconds)
2021-01-04 15:46:17 +0100sw1nn(~sw1nn@2a00:23c6:2385:3a00:535:b5d7:a67c:1f0) (Ping timeout: 260 seconds)
2021-01-04 15:46:17 +0100orcus(~orcus@unaffiliated/orcus) (Ping timeout: 260 seconds)
2021-01-04 15:47:00 +0100 <dminuoso> merijn: Unless you are Feynman, the "think really hard" solution doesn't scale well. Once you hit a problem that exceeds your mental capability, you're stuck, and the method is not teachable either.
2021-01-04 15:47:06 +0100d0liver(sid363046@gateway/web/irccloud.com/x-tttmhfenawofeixc)
2021-01-04 15:47:10 +0100rnat2(uid73555@gateway/web/irccloud.com/x-zbnoeruhkwpvwygt)
2021-01-04 15:47:14 +0100Kronic(sid480486@gateway/web/irccloud.com/x-yefsgwxmddskyzbm)
2021-01-04 15:47:19 +0100 <merijn> dminuoso: That's not what I meant anyway
2021-01-04 15:47:37 +0100 <merijn> dminuoso: I wasn't referring to Feynman method, but more "formalise and mechanise"
2021-01-04 15:47:47 +0100 <dminuoso> I understand, my point is just that I think there's a wealth of people on the side of "writing correct solutions" and "likes static types" without being able to hold a problem in their mind.
2021-01-04 15:47:48 +0100 <merijn> and implement later
2021-01-04 15:47:54 +0100sw1nn(~sw1nn@2a00:23c6:2385:3a00:8a08:ba4e:209b:1d11)
2021-01-04 15:48:16 +0100 <merijn> As opposed implementing right away and adjusting existing code as you go
2021-01-04 15:48:20 +0100 <dminuoso> Fair enough
2021-01-04 15:48:52 +0100pera(~pera@unaffiliated/pera)
2021-01-04 15:48:52 +0100stree(~stree@50-108-115-238.adr01.mskg.mi.frontiernet.net)
2021-01-04 15:48:57 +0100 <dminuoso> merijn: I was just getting at this line
2021-01-04 15:49:03 +0100 <dminuoso> `the latter group likes "simple" code they can understand, tying it together, and testing at every stage that things work,`
2021-01-04 15:49:09 +0100gxt(~gxt@gateway/tor-sasl/gxt) (Quit: WeeChat 3.0)
2021-01-04 15:49:16 +0100 <dminuoso> As far as I understand, that's precisely how folks like Edward work. :p
2021-01-04 15:49:51 +0100 <dminuoso> That was all
2021-01-04 15:50:03 +0100carlomagno(~cararell@148.87.23.13)
2021-01-04 15:50:08 +0100 <merijn> dminuoso: Well, "simple" was in quotes for a reason :p
2021-01-04 15:52:06 +0100LKoen_(~LKoen@174.175.9.109.rev.sfr.net) (Remote host closed the connection)
2021-01-04 15:52:23 +0100 <merijn> hmm
2021-01-04 15:52:42 +0100cfricke(~cfricke@unaffiliated/cfricke)
2021-01-04 15:53:00 +0100darjeeling_(~darjeelin@122.245.218.97)
2021-01-04 15:53:13 +0100zangi(~azure@103.154.230.250)
2021-01-04 15:53:15 +0100 <merijn> Is there a nice existing IO memoisation somewhere? i.e. I have "Key -> IO Val" and wanna store it so that I only bother doing the lookup once, caching it in a Map (or something)
2021-01-04 15:54:18 +0100knupfer(~Thunderbi@dynamic-046-114-150-158.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2021-01-04 15:54:21 +0100cfricke(~cfricke@unaffiliated/cfricke) (Client Quit)
2021-01-04 15:55:18 +0100 <dminuoso> merijn: Mm, how is that IO related? Wouldn't just e.g. MemoTrie be enough here?
2021-01-04 15:55:21 +0100gxt(~gxt@gateway/tor-sasl/gxt)
2021-01-04 15:55:32 +0100 <zangi> can anyone explain what's so bad about thunks?
2021-01-04 15:55:35 +0100 <dminuoso> Or would that cache the result of IO?
2021-01-04 15:55:43 +0100 <dminuoso> zangi: Nothing. Why do you think they are bad?
2021-01-04 15:55:47 +0100 <merijn> dminuoso: Basically, doing database lookups, but no point in querying the database a million times for the same key
2021-01-04 15:56:28 +0100 <dminuoso> merijn: Is this, by any chance, in the same program where you do your fancy conduit/async machinery?
2021-01-04 15:56:34 +0100 <merijn> Yes
2021-01-04 15:56:42 +0100 <dminuoso> You seem to be heading into haxl territory...
2021-01-04 15:56:56 +0100 <merijn> Naah, that's way overcomplicated for my needs
2021-01-04 15:57:13 +0100 <merijn> dminuoso: All my existing conduit/queries are basically sequential streams over result sets
2021-01-04 15:57:34 +0100 <zangi> dminuoso: like there exists foldl' that avoids uncollected thunks (if I understand it correctly)
2021-01-04 15:57:42 +0100 <dminuoso> Ah, those conduit/queries are what would be using this caching `Key -> IO Val`?
2021-01-04 15:58:04 +0100 <merijn> dminuoso: I'm "just" writing some import logic so I can import data from other databases, so I need to map keys from the input database to the new key in the current database to translate
2021-01-04 15:58:08 +0100 <dminuoso> zangi: I see. So a thunk itself is not bad, it's a name for an implementation artifact that GHC does to implement lazyness.
2021-01-04 15:58:49 +0100 <merijn> dminuoso: So I get like a million rows of input, with (say several tens) foreign keys in each row I need to translate
2021-01-04 15:58:59 +0100shinobi(~shinobi@c-24-147-48-162.hsd1.ma.comcast.net)
2021-01-04 15:59:02 +0100 <dminuoso> zangi: Note the word "lazyness". If we know, for a fact, that we will need a value, then wrapping it in a thunk (which costs memory and extra CPU time for the indirection) is wasteful
2021-01-04 15:59:10 +0100 <merijn> dminuoso: No point in looking up the new foreign key a million times if I have only several tens of unique values
2021-01-04 15:59:53 +0100 <merijn> I suppose I can just look all of them up ahead of time, come to think of it
2021-01-04 16:02:50 +0100 <dminuoso> zangi: foldl' f z0 xs = foldr f' id xs z0 where f' x k z = k $! f z x
2021-01-04 16:02:54 +0100 <dminuoso> This is the default definition.
2021-01-04 16:03:53 +0100rnat2(uid73555@gateway/web/irccloud.com/x-zbnoeruhkwpvwygt) (Quit: Connection closed for inactivity)
2021-01-04 16:04:20 +0100dhouthoo(~dhouthoo@ptr-eitgbj2w0uu6delkbrh.18120a2.ip6.access.telenet.be)
2021-01-04 16:04:54 +0100 <__monty__> zangi has probably just learned about the inefficiency of foldl, without the prime?
2021-01-04 16:06:41 +0100 <merijn> dminuoso: Eh, fuck it, I'll just do the dumb lookup for every row and DM anyone complaining about performance issue my bank details where they can pay me :p
2021-01-04 16:06:45 +0100evanjs(~evanjs@075-129-098-007.res.spectrum.com) (Ping timeout: 256 seconds)
2021-01-04 16:07:21 +0100eacameron(uid256985@gateway/web/irccloud.com/x-ibwftunwaaouzfew)
2021-01-04 16:07:31 +0100 <dminuoso> merijn: In my large project I just pre-load all data according to the lookup schemes I want, and keep them around in large sets and maps. :P
2021-01-04 16:07:44 +0100 <dminuoso> But my problem domain can be easily held in memory, so..
2021-01-04 16:08:35 +0100 <dminuoso> zangi: You can find some visualizations and explanations here: https://wiki.haskell.org/Foldr_Foldl_Foldl%27
2021-01-04 16:09:06 +0100evanjs(~evanjs@075-129-098-007.res.spectrum.com)
2021-01-04 16:09:15 +0100 <merijn> dminuoso: This is mainly for importing missing results from older databases into newer databases, so since it's a one time import I'm just gonna consider it not worth optimising :p
2021-01-04 16:10:06 +0100pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net) (Read error: Connection reset by peer)
2021-01-04 16:10:27 +0100pfurla_(~pfurla@ool-182ed2e2.dyn.optonline.net)
2021-01-04 16:10:32 +0100 <zangi> ?src foldl'
2021-01-04 16:10:32 +0100 <lambdabot> foldl' f a [] = a
2021-01-04 16:10:33 +0100 <lambdabot> foldl' f a (x:xs) = let a' = f a x in a' `seq` foldl' f a' xs
2021-01-04 16:10:48 +0100p3n(~p3n@2a00:19a0:3:7c:0:d9c6:7cf6:1) (Remote host closed the connection)
2021-01-04 16:11:04 +0100 <dminuoso> Note that lambdabot's src command is just a lookup in a text file that is sometimes inaccurate or just not updated.
2021-01-04 16:11:09 +0100 <dminuoso> But, the definition works just as well.
2021-01-04 16:11:31 +0100 <dminuoso> It's probably better for the purpose of explaining.
2021-01-04 16:11:49 +0100 <merijn> zangi: Basically, consider this: "When computing the sum of a list, what's more efficient: keeping a single strict Int in memory or keeping a few tens/hundreds of MB of lazy computation in memory that will eventually produce an Int?"
2021-01-04 16:12:03 +0100son0p(~son0p@181.136.122.143)
2021-01-04 16:12:03 +0100gxt(~gxt@gateway/tor-sasl/gxt) (Ping timeout: 240 seconds)
2021-01-04 16:12:21 +0100 <dminuoso> This sort of consideration is the price of "lazy by default". :)
2021-01-04 16:12:29 +0100 <kuribas> merijn: if it's open source, let someone else provide a PR :-)
2021-01-04 16:12:57 +0100 <merijn> kuribas: It's science, like 3 people will probably use it and then this will still be a rare subcommand :p
2021-01-04 16:13:34 +0100 <dminuoso> https://xkcd.com/1205/
2021-01-04 16:14:04 +0100 <merijn> dminuoso: I fundamentally disagree with the flawed assumption underlying that chart :p
2021-01-04 16:14:16 +0100 <zangi> merijn: so is it basically just performance issue?
2021-01-04 16:14:21 +0100 <merijn> zangi: Yes
2021-01-04 16:14:25 +0100 <dminuoso> merijn: You fundamentally disagree with about 80% of the things in this world.
2021-01-04 16:14:33 +0100 <merijn> dminuoso: True :p
2021-01-04 16:14:49 +0100 <merijn> dminuoso: But the value of automating things is more than just "net time saved"
2021-01-04 16:15:09 +0100gxt(~gxt@gateway/tor-sasl/gxt)
2021-01-04 16:15:45 +0100 <merijn> dminuoso: You gotta account for the fact that "interactive speeds" accommodate a different way of working/using than slow speeds do, even if the net savings don't actually save time. Not to mention the reduced frustration, distraction, and interruptiong of routine
2021-01-04 16:16:19 +0100pavonia(~user@unaffiliated/siracusa) (Quit: Bye!)
2021-01-04 16:17:41 +0100 <kuribas> yes, and often when something becomes easier and faster to use, you also will use it more.
2021-01-04 16:17:59 +0100 <kuribas> I often hear "there is no point in optimizing this, we don't use it often".
2021-01-04 16:18:07 +0100 <merijn> dminuoso: A 5s process can interrupt your flow and ruin productivity. Automating that away has bigger impact beyond just the 5s saved
2021-01-04 16:18:10 +0100 <kuribas> but then we don't use it often because it's slow or cumbersome.
2021-01-04 16:18:36 +0100 <kuribas> merijn: imagine every key press took 5 seconds :)
2021-01-04 16:19:01 +0100 <merijn> kuribas: I've worked over SSH from an ICE train...
2021-01-04 16:19:10 +0100 <merijn> I don't have to imagine :p
2021-01-04 16:19:15 +0100 <dminuoso> merijn: And yet, the net time lost can be quantified.
2021-01-04 16:19:28 +0100 <dminuoso> This is the usual opposing sides of "developer"
2021-01-04 16:19:36 +0100 <merijn> dminuoso: Can it?
2021-01-04 16:19:36 +0100 <dminuoso> and the management guy who just looks at the numbers
2021-01-04 16:19:40 +0100 <dminuoso> Sure, it can.
2021-01-04 16:20:06 +0100 <merijn> I mean *theoretically*, sure. But practically?
2021-01-04 16:20:39 +0100Franciman(~francesco@host-87-17-26-221.retail.telecomitalia.it) (Quit: Leaving)
2021-01-04 16:21:15 +0100 <dminuoso> If we assume you're doing a set of tasks, we can simply measure how long it takes you. An interruption would have a measurable delay on this process.
2021-01-04 16:21:39 +0100 <dminuoso> We just need a clone of you.. can you send me a sample of your DNA?
2021-01-04 16:23:13 +0100fendor_(~fendor@178.115.131.182.wireless.dyn.drei.com)
2021-01-04 16:23:44 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh) (Quit: Leaving)
2021-01-04 16:23:53 +0100Vulfe(~vulfe@2600:1702:31b0:34e0:54f0:e9d4:232a:a299)
2021-01-04 16:25:39 +0100fendor(~fendor@178.115.130.71.wireless.dyn.drei.com) (Ping timeout: 260 seconds)
2021-01-04 16:27:00 +0100 <merijn> hmm, anyone know if it's possible to request all fields that are foreign keys in persistent?
2021-01-04 16:27:47 +0100madjestic(~Android@86-88-72-244.fixed.kpn.net) (Ping timeout: 256 seconds)
2021-01-04 16:29:59 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d) (Ping timeout: 272 seconds)
2021-01-04 16:30:38 +0100madjest15(~Android@89-200-3-179.mobile.kpn.net)
2021-01-04 16:30:49 +0100quinn(~quinn@c-73-223-224-163.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2021-01-04 16:33:02 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2021-01-04 16:33:49 +0100argento(~argent0@168.227.97.29) (Ping timeout: 264 seconds)
2021-01-04 16:33:58 +0100quinn(~quinn@c-73-223-224-163.hsd1.ca.comcast.net)
2021-01-04 16:34:23 +0100hekkaidekapus}(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 240 seconds)
2021-01-04 16:34:52 +0100hekkaidekapus}(~tchouri@gateway/tor-sasl/hekkaidekapus)
2021-01-04 16:35:49 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:12e2:f4f0:d2c0:3ecf:a408)
2021-01-04 16:35:51 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:12e2:f4f0:d2c0:3ecf:a408) (Client Quit)
2021-01-04 16:35:52 +0100hekkaidekapus}(~tchouri@gateway/tor-sasl/hekkaidekapus) (Remote host closed the connection)
2021-01-04 16:36:14 +0100hekkaidekapus}(~tchouri@gateway/tor-sasl/hekkaidekapus)
2021-01-04 16:37:11 +0100argento(~argent0@168.227.97.29)
2021-01-04 16:37:42 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 272 seconds)
2021-01-04 16:38:19 +0100argento(~argent0@168.227.97.29) (Client Quit)
2021-01-04 16:38:37 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:12e2:f4f0:d2c0:3ecf:a408)
2021-01-04 16:41:51 +0100 <kritzefitz> I was recently digging in the rts source code to find out that Haskell functions called from C are run in a new thread that is bound to the OS thread the call came from. Is that last part (about the thread being bound) documented/guaranteed somewhere?
2021-01-04 16:43:24 +0100robotmay(~beepboop@2001:8b0:7af0:2580:80b7:418d:2e2d:4473) (Ping timeout: 268 seconds)
2021-01-04 16:45:02 +0100cfricke(~cfricke@unaffiliated/cfricke)
2021-01-04 16:45:07 +0100cfricke(~cfricke@unaffiliated/cfricke) (Client Quit)
2021-01-04 16:45:44 +0100 <dminuoso> kritzefitz: It is described by the original paper https://simonmar.github.io/bib/papers/conc-ffi.pdf
2021-01-04 16:45:48 +0100 <dminuoso> See 3.4 Callbacks
2021-01-04 16:46:08 +0100cfricke(~cfricke@unaffiliated/cfricke)
2021-01-04 16:46:19 +0100 <yushyin> https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/ffi-chap.html#foreign-imports-and-…
2021-01-04 16:46:21 +0100 <tdammers> kuribas: it sounds a bit like me, but my hypothesized dichotomy is between "inductive" and "empirical" programmers. they align with the "mathematicians" and "tinkerers" somewhat, and I might even use the same names, but it's not so much about up-front proof vs. iterative evolution (you can iterate in an inductive / logical paradigm too), it's about how you assert correctness: "correct by construction" vs.
2021-01-04 16:46:23 +0100 <tdammers> "correct by sufficiently large sample of observably correct behavior"
2021-01-04 16:46:36 +0100robotmay(~beepboop@2001:8b0:7af0:2580:695c:2c43:c9f4:f004)
2021-01-04 16:47:10 +0100Wuzzy(~Wuzzy@p5790e09a.dip0.t-ipconnect.de)
2021-01-04 16:49:43 +0100 <kritzefitz> dminuoso, thanks, that explains the problem I have perfectly.
2021-01-04 16:50:25 +0100 <kritzefitz> yushyin, I think that's related, but if that section describes the case I asked about, I don't see where.
2021-01-04 16:50:56 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:12e2:f4f0:d2c0:3ecf:a408) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 16:51:31 +0100spopejoy(~stuart@ool-44c5f8c9.dyn.optonline.net)
2021-01-04 16:52:03 +0100 <yushyin> kritzefitz: I also hoped for a bit more detailed information on that page ^^
2021-01-04 16:52:53 +0100 <dminuoso> merijn: I had a brilliant idea! For a long time, I've been really annoyed by the lack of a sleek and neat config file library in Haskell
2021-01-04 16:52:56 +0100 <dminuoso> And then it hit me like a train.
2021-01-04 16:53:07 +0100 <merijn> dminuoso: SQLite!
2021-01-04 16:53:08 +0100 <dminuoso> optparse-applicative on a file!
2021-01-04 16:53:11 +0100zangi(~azure@103.154.230.250) (Read error: Connection reset by peer)
2021-01-04 16:53:11 +0100 <merijn> Ah
2021-01-04 16:53:12 +0100 <merijn> :p
2021-01-04 16:54:15 +0100 <glguy> dminuoso: sounds like you should look at my config-schema stuff then
2021-01-04 16:54:48 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com)
2021-01-04 16:55:13 +0100 <kuribas> tdammers: right
2021-01-04 16:57:22 +0100 <merijn> Is it possible to only export some methods of a typeclass?
2021-01-04 16:58:12 +0100 <ski> i think so
2021-01-04 16:58:19 +0100 <Taneb> I believe array does that
2021-01-04 16:58:25 +0100 <dminuoso> merijn: the same way as with records and fields
2021-01-04 16:58:41 +0100 <merijn> But then you can't implement it outside that module, I guess?
2021-01-04 16:58:48 +0100 <ski> module Foo (C (m))
2021-01-04 16:58:49 +0100usr25(~usr25@unaffiliated/usr25) (Read error: Connection reset by peer)
2021-01-04 16:59:08 +0100 <ski> right
2021-01-04 16:59:15 +0100adamwespiser(~adamwespi@209.6.43.158) (Remote host closed the connection)
2021-01-04 16:59:32 +0100 <ski> so better have default implementations, in case you want the user to be able to make instances
2021-01-04 16:59:33 +0100adamwespiser(~adamwespi@209.6.43.158)
2021-01-04 17:00:06 +0100andreabedini[m](andreabedi@gateway/shell/matrix.org/x-hjtxhxhwobrdxypa) (Quit: Idle for 30+ days)
2021-01-04 17:00:10 +0100adamwespiser(~adamwespi@209.6.43.158) (Remote host closed the connection)
2021-01-04 17:00:14 +0100lawid(~quassel@dslb-090-186-127-244.090.186.pools.vodafone-ip.de) (Quit: lawid)
2021-01-04 17:00:36 +0100adamwespiser(~adamwespi@209.6.43.158)
2021-01-04 17:00:38 +0100cfricke(~cfricke@unaffiliated/cfricke) (Ping timeout: 260 seconds)
2021-01-04 17:02:08 +0100 <merijn> I guess that can work
2021-01-04 17:02:22 +0100lawid(~quassel@dslb-090-186-127-244.090.186.pools.vodafone-ip.de)
2021-01-04 17:02:57 +0100hnOsmium0001(uid453710@gateway/web/irccloud.com/x-flibwgaldygamqxl)
2021-01-04 17:04:11 +0100madjest15(~Android@89-200-3-179.mobile.kpn.net) (Read error: Connection reset by peer)
2021-01-04 17:04:50 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d)
2021-01-04 17:05:02 +0100abhixec(~abhixec@c-67-169-139-16.hsd1.ca.comcast.net) (Quit: leaving)
2021-01-04 17:05:36 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 17:11:13 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d) (Ping timeout: 258 seconds)
2021-01-04 17:11:20 +0100 <merijn> You know, this mtl-style tagless final stuff is really starting to grow on me
2021-01-04 17:11:32 +0100 <merijn> (not mtl itself, those classes are still junk)
2021-01-04 17:11:35 +0100adamwesp_(~adamwespi@107.181.19.30)
2021-01-04 17:12:37 +0100Sheilong(uid293653@gateway/web/irccloud.com/x-qgpagvfhytqrdzbx) (Quit: Connection closed for inactivity)
2021-01-04 17:14:45 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com)
2021-01-04 17:15:13 +0100adamwespiser(~adamwespi@209.6.43.158) (Ping timeout: 264 seconds)
2021-01-04 17:15:19 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:12e2:f4f0:d2c0:3ecf:a408)
2021-01-04 17:16:51 +0100rmk236(~lcampos@2a02:908:3616:b100:ad41:f5e6:8b3a:bfc3) (Ping timeout: 272 seconds)
2021-01-04 17:17:20 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr) (Quit: Konversation terminated!)
2021-01-04 17:17:28 +0100michalz(~user@185.246.204.78) (Remote host closed the connection)
2021-01-04 17:18:18 +0100rmk236(~lcampos@2a02:908:3616:b100:ad41:f5e6:8b3a:bfc3)
2021-01-04 17:18:57 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d)
2021-01-04 17:19:00 +0100carlomagno(~cararell@148.87.23.13) (Remote host closed the connection)
2021-01-04 17:20:48 +0100zyeri(zyeri@tilde.team/users/zyeri) (Quit: ZNC 1.8.1 - https://znc.in)
2021-01-04 17:20:57 +0100danso(~dan@23-233-111-39.cpe.pppoe.ca)
2021-01-04 17:21:05 +0100carlomagno(~cararell@148.87.23.13)
2021-01-04 17:21:33 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr)
2021-01-04 17:23:23 +0100koluacik(~koluacik@134.122.28.77)
2021-01-04 17:23:31 +0100xff0x(~fox@2001:1a81:5271:e800:63d8:c69:6df1:58cb) (Quit: xff0x)
2021-01-04 17:23:39 +0100xff0x(~fox@2001:1a81:5271:e800:63d8:c69:6df1:58cb)
2021-01-04 17:24:11 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr) (Remote host closed the connection)
2021-01-04 17:26:33 +0100zyeri(zyeri@gateway/shell/tilde.team/x-grfsriuxevraoxmh)
2021-01-04 17:26:33 +0100zyeri(zyeri@gateway/shell/tilde.team/x-grfsriuxevraoxmh) (Changing host)
2021-01-04 17:26:33 +0100zyeri(zyeri@tilde.team/users/zyeri)
2021-01-04 17:27:55 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr)
2021-01-04 17:28:01 +0100heatsink(~heatsink@2600:1700:bef1:5e10:f187:6a02:e58f:90ce)
2021-01-04 17:31:14 +0100fendor_fendor
2021-01-04 17:31:34 +0100pera(~pera@unaffiliated/pera) (Ping timeout: 260 seconds)
2021-01-04 17:31:37 +0100matryoshka(~matryoshk@184.75.223.227) (Quit: ZNC 1.8.2 - https://znc.in)
2021-01-04 17:31:47 +0100twopoint718(~cjw@fsf/member/twopoint718)
2021-01-04 17:31:54 +0100matryoshka(~matryoshk@184.75.223.227)
2021-01-04 17:32:04 +0100pera(~pera@unaffiliated/pera)
2021-01-04 17:43:31 +0100 <kuribas> tdammers: statistically correct is still useful for haskell though. In the words of Knuth: "I have only proved it correct, not tried it."
2021-01-04 17:44:39 +0100 <kritzefitz> yushyin, (maybe dminuoso), I just noticed that Control.Concurrent included with the current master of GHC explains this. So apparently I was just asking a few versions too early.
2021-01-04 17:45:55 +0100 <tdammers> kuribas: yes, of course, but this isn't about QA, it's about the development process
2021-01-04 17:46:38 +0100jb55(~jb55@gateway/tor-sasl/jb55) (Remote host closed the connection)
2021-01-04 17:48:42 +0100electricityZZZZ(~electrici@108-216-157-17.lightspeed.sntcca.sbcglobal.net)
2021-01-04 17:48:44 +0100Neo--(~neo@BSN-176-188-17.dynamic.siol.net)
2021-01-04 17:49:40 +0100justsomeguy(~justsomeg@unaffiliated/--/x-3805311)
2021-01-04 17:49:51 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:12e2:f4f0:d2c0:3ecf:a408) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 17:50:25 +0100neiluj(~jco@unaffiliated/neiluj) (Ping timeout: 240 seconds)
2021-01-04 17:50:30 +0100ransom(~c4264035@8.47.12.52)
2021-01-04 17:51:42 +0100hekkaidekapus[(~tchouri@gateway/tor-sasl/hekkaidekapus)
2021-01-04 17:53:14 +0100geekosaur(42d52137@66.213.33.55)
2021-01-04 17:53:15 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com)
2021-01-04 17:53:23 +0100hekkaidekapus}(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 240 seconds)
2021-01-04 17:53:45 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:12e2:f4f0:d2c0:3ecf:a408)
2021-01-04 17:53:52 +0100son0p(~son0p@181.136.122.143) (Quit: Lost terminal)
2021-01-04 17:53:53 +0100jb55(~jb55@gateway/tor-sasl/jb55)
2021-01-04 18:01:32 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:12e2:f4f0:d2c0:3ecf:a408) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 18:02:42 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2021-01-04 18:03:13 +0100 <kritzefitz> Actually, the current base on hackage also has it. I was just reading it wrong.
2021-01-04 18:03:49 +0100Alleria__(~textual@mskresolve-a.mskcc.org) (Ping timeout: 264 seconds)
2021-01-04 18:04:44 +0100kritzefitz(~kritzefit@fw-front.credativ.com) (Remote host closed the connection)
2021-01-04 18:05:19 +0100dandels(~dandels@unaffiliated/dandels)
2021-01-04 18:06:16 +0100heatsink(~heatsink@2600:1700:bef1:5e10:f187:6a02:e58f:90ce) (Remote host closed the connection)
2021-01-04 18:07:51 +0100twopoint718(~cjw@fsf/member/twopoint718) (Quit: Textual IRC Client: www.textualapp.com)
2021-01-04 18:11:51 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl)
2021-01-04 18:13:57 +0100kritzefitz(~kritzefit@212.86.56.80)
2021-01-04 18:14:36 +0100christo(~chris@81.96.113.213)
2021-01-04 18:15:01 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-01-04 18:15:14 +0100quinn(~quinn@c-73-223-224-163.hsd1.ca.comcast.net) (Ping timeout: 272 seconds)
2021-01-04 18:17:39 +0100Kaiepi(~Kaiepi@47.54.252.148) (Ping timeout: 260 seconds)
2021-01-04 18:18:40 +0100madjestic(~Android@86-88-72-244.fixed.kpn.net)
2021-01-04 18:21:10 +0100cfricke(~cfricke@unaffiliated/cfricke)
2021-01-04 18:21:21 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr)
2021-01-04 18:22:02 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d) (Ping timeout: 260 seconds)
2021-01-04 18:22:50 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2021-01-04 18:28:22 +0100matryoshka(~matryoshk@184.75.223.227) (Quit: ZNC 1.8.2 - https://znc.in)
2021-01-04 18:28:41 +0100matryoshka(~matryoshk@184.75.223.227)
2021-01-04 18:30:16 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr) (Ping timeout: 246 seconds)
2021-01-04 18:32:23 +0100teardown_(~user@gateway/tor-sasl/mrush) (Ping timeout: 240 seconds)
2021-01-04 18:33:12 +0100cads2(~cads@ip-64-72-99-232.lasvegas.net)
2021-01-04 18:33:12 +0100cads(~cads@ip-64-72-99-232.lasvegas.net)
2021-01-04 18:33:16 +0100fresheyeball(~isaac@c-71-237-105-37.hsd1.co.comcast.net)
2021-01-04 18:33:20 +0100 <fresheyeball> http://ix.io/2KQY
2021-01-04 18:33:22 +0100 <fresheyeball> Why?!
2021-01-04 18:33:29 +0100sakirious(~sakirious@c-71-197-191-137.hsd1.wa.comcast.net) (Read error: Connection reset by peer)
2021-01-04 18:33:36 +0100 <fresheyeball> Is it possible to get type families and qualified constraints to play nice?
2021-01-04 18:33:38 +0100sakirious(~sakirious@c-71-197-191-137.hsd1.wa.comcast.net)
2021-01-04 18:34:26 +0100 <fresheyeball> http://ix.io/2KQZ for context
2021-01-04 18:34:45 +0100zfnmxt_(~zfnmxt@unaffiliated/zfnmxt) (Quit: Bye!)
2021-01-04 18:36:18 +0100halbGefressen(~halbGefre@2a02:810d:f40:2a9c:40b2:2308:84bd:8b9b)
2021-01-04 18:38:33 +0100heatsink(~heatsink@2600:1700:bef1:5e10:f187:6a02:e58f:90ce)
2021-01-04 18:38:40 +0100 <halbGefressen> Say I have a data Tree a = Leaf | Node (Tree a) a (Tree a). If I want to use currying on the right node with the second constructor, I can write `Node left val` instead of (\x -> Node x val right). Can I somehow shift the arguments around easily to achieve similar brevity?
2021-01-04 18:39:23 +0100 <dmwit> Nope.
2021-01-04 18:39:52 +0100 <halbGefressen> :(
2021-01-04 18:40:02 +0100 <dmwit> It's not that bad in the end.
2021-01-04 18:40:19 +0100 <halbGefressen> I know, but my OCD kinda doesn't like lambdas :)
2021-01-04 18:40:28 +0100 <dmwit> You have to have *some* syntax for saying which argument you're leaving out. In terms of possible syntaxes, lambdas are pretty lightweight and very general.
2021-01-04 18:41:03 +0100 <dmwit> You can imagine many others, of course. All with tradeoffs.
2021-01-04 18:41:22 +0100 <halbGefressen> Yeah, using a lambda would be the easiest solution, but I thought "perhaps Haskell has something for that as well" and didnt find it. Thanks!
2021-01-04 18:41:39 +0100 <halbGefressen> something like flip3 or so
2021-01-04 18:42:03 +0100 <halbGefressen> oh wait a second
2021-01-04 18:42:10 +0100fafufafufafu(b2e91980@178.233.25.128)
2021-01-04 18:42:36 +0100zfnmxt(~zfnmxt@unaffiliated/zfnmxt)
2021-01-04 18:42:55 +0100matryoshka(~matryoshk@184.75.223.227) (Quit: ZNC 1.8.2 - https://znc.in)
2021-01-04 18:43:13 +0100matryoshka(~matryoshk@184.75.223.227)
2021-01-04 18:43:52 +0100 <dsal> @pl \x -> Node x val right
2021-01-04 18:43:52 +0100 <lambdabot> flip (flip Node val) right
2021-01-04 18:44:28 +0100 <kuribas> halbGefressen: short doesn't mean readable
2021-01-04 18:44:34 +0100 <kuribas> lambdas are fine
2021-01-04 18:44:39 +0100 <dmwit> > (length "\\x -> Node x val right", length "flip (flip Node val) right")
2021-01-04 18:44:41 +0100 <lambdabot> (22,26)
2021-01-04 18:44:41 +0100 <dolio> It's not even shorter.
2021-01-04 18:44:43 +0100 <dsal> Look ma, no lambda
2021-01-04 18:44:50 +0100 <dolio> It's just less clear and longer.
2021-01-04 18:44:54 +0100 <dmwit> ^
2021-01-04 18:45:18 +0100 <dmwit> (I was aware of and considered this kind of possibility before I answered "Nope." above.)
2021-01-04 18:45:19 +0100 <Melanie> sometimes there's no point in going point-free
2021-01-04 18:45:32 +0100 <halbGefressen> then it just becomes point-less...
2021-01-04 18:45:38 +0100 <dsal> It's a good demonstration, though.
2021-01-04 18:45:47 +0100 <xsperry> halbGefressen, you might consider changing the order of Node constructor, if that is the most common way you want to partially apply it
2021-01-04 18:45:55 +0100 <dsal> If you want to avoid a lambda for some reason, you *can*, but also, maybe don't do that.
2021-01-04 18:46:01 +0100 <halbGefressen> wait, I can reduce that to flip (`Node` val) right
2021-01-04 18:46:04 +0100 <dsal> Or just have a helper function that does the thing that you want.
2021-01-04 18:46:09 +0100rmk236(~lcampos@2a02:908:3616:b100:ad41:f5e6:8b3a:bfc3) (Quit: Leaving.)
2021-01-04 18:47:48 +0100dfeuer(~dfeuer@pool-108-18-223-60.washdc.fios.verizon.net)
2021-01-04 18:48:05 +0100 <dolio> The solution is to fix whatever mental block is causing you to think lambda expressions are always bad.
2021-01-04 18:48:10 +0100 <dolio> Because they are not.
2021-01-04 18:50:34 +0100dandels(~dandels@unaffiliated/dandels) (Ping timeout: 246 seconds)
2021-01-04 18:51:46 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr) (Quit: Konversation terminated!)
2021-01-04 18:52:07 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr)
2021-01-04 18:52:10 +0100koluacik(~koluacik@134.122.28.77) ()
2021-01-04 18:52:25 +0100 <dolio> That's why, if you ask me, it makes no sense when people complain about redundancies in Haskell syntax. The different syntaxes for achieving the same thing can be better or worse in different situations, so paring things down to only a single way to do any given thing forces you to write less clear code in various situations.
2021-01-04 18:52:32 +0100DataComputist(~lumeng@static-50-43-26-251.bvtn.or.frontiernet.net)
2021-01-04 18:52:42 +0100koluacik(~koluacik@134.122.28.77)
2021-01-04 18:52:48 +0100matryoshka(~matryoshk@184.75.223.227) (Quit: ZNC 1.8.2 - https://znc.in)
2021-01-04 18:53:03 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809)
2021-01-04 18:53:12 +0100 <dsal> I rarely use flip. It sometimes adds brevity, but rarely clarity.
2021-01-04 18:53:54 +0100 <Kronic> why would anyone say lambdas are bad?
2021-01-04 18:54:19 +0100 <monochrom> I know two religious camps, from opposite directions, that hate lambda.
2021-01-04 18:54:51 +0100 <monochrom> One is the pointfree religion. The other is the meaningful-name religion
2021-01-04 18:54:52 +0100matryoshka`(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809)
2021-01-04 18:54:55 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809) (Read error: Connection reset by peer)
2021-01-04 18:55:31 +0100 <Kronic> The way I look at it is much the same way I look at documentation. You don't document everything that is a maintenance problem. The same way, you don't name absolutely everything because sometimes using a lambda or point free is nicer. IT;
2021-01-04 18:55:39 +0100Sheilong(uid293653@gateway/web/irccloud.com/x-qwdszzkqmmrcolkn)
2021-01-04 18:55:47 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 18:55:59 +0100 <Kronic> It is almost certainly not always -- sorry, I sent that message too early there, new keyboard.
2021-01-04 18:56:10 +0100Alleria(~textual@mskresolve-a.mskcc.org)
2021-01-04 18:56:34 +0100matryoshka`(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809) (Client Quit)
2021-01-04 18:56:34 +0100AlleriaGuest73365
2021-01-04 18:56:53 +0100matryoshka(~matryoshk@184.75.223.227)
2021-01-04 18:57:37 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d)
2021-01-04 18:57:38 +0100 <monochrom> I have spoken to OOP people who, even in OOP, found "o1.m1(o2.m2(), o3.m3())" alien because their ideal is "meaningfulname2 = o2.m2(); meaningfulname3 = o3.m3(); o1.m1(meaningfulname2, meaningfulname3)"
2021-01-04 18:58:04 +0100 <fresheyeball> anyone intereseted in my problem?
2021-01-04 18:58:22 +0100matryoshka`(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809)
2021-01-04 18:58:27 +0100 <monochrom> Basically rolling back the most important innovation of Backus in Fortran, that you no longer write three-address instructions.
2021-01-04 18:58:28 +0100matryoshka(~matryoshk@184.75.223.227) (Read error: Connection reset by peer)
2021-01-04 18:58:48 +0100Franciman(~francesco@host-87-17-26-221.retail.telecomitalia.it)
2021-01-04 18:59:00 +0100 <fresheyeball> like why is a qualified constraint illegal in a type family?
2021-01-04 18:59:01 +0100 <merijn> hmm, so is there a "traverse for (micro)lenses"?
2021-01-04 18:59:25 +0100 <kuribas> merijn: id ?
2021-01-04 18:59:26 +0100 <fresheyeball> is there a logical reason for this? Or just GHC can't do it right now?
2021-01-04 18:59:51 +0100 <dolio> Where is that in the code you linked?
2021-01-04 18:59:53 +0100 <merijn> kuribas: hmm?
2021-01-04 19:00:10 +0100matryoshka`(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809) (Client Quit)
2021-01-04 19:00:23 +0100 <kuribas> did you mean traverseOf? https://hackage.haskell.org/package/microlens-0.4.12.0/docs/Lens-Micro.html#v:traverseOf
2021-01-04 19:00:28 +0100 <kuribas> which is just id
2021-01-04 19:00:33 +0100matryoshka(~matryoshk@184.75.223.227)
2021-01-04 19:00:44 +0100 <merijn> Ah, yes
2021-01-04 19:01:32 +0100 <Kronic> monochrom: those people are kinda weird. I mean, I get it. At some point though repeating information becomes a problem I would say, to each their own though.
2021-01-04 19:02:09 +0100spopejoy(~stuart@ool-44c5f8c9.dyn.optonline.net) (Quit: spopejoy)
2021-01-04 19:02:37 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d) (Ping timeout: 272 seconds)
2021-01-04 19:04:40 +0100dyeplexer(~lol@unaffiliated/terpin) (Remote host closed the connection)
2021-01-04 19:05:46 +0100mizlan(~michaella@c-67-169-7-31.hsd1.ca.comcast.net)
2021-01-04 19:05:48 +0100 <kuribas> monochrom: so thisAddsTwoAndMultipliesByThree x = (x+1)*2, instead of (*1).inc ?
2021-01-04 19:06:23 +0100 <kuribas> meaningful names are great, if they are really meaningful
2021-01-04 19:09:32 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com)
2021-01-04 19:10:08 +0100 <merijn> Is there, like, an Endo version for monadic functions?
2021-01-04 19:10:10 +0100Major_Biscuit(~Major_Bis@93-21-124.netrun.cytanet.com.cy) (Ping timeout: 246 seconds)
2021-01-04 19:10:44 +0100crblmr(~carbolyme@matrix.dropacid.net) (Ping timeout: 260 seconds)
2021-01-04 19:12:02 +0100hyperisco(~hyperisco@d192-186-117-226.static.comm.cgocable.net)
2021-01-04 19:12:32 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net) (Read error: Connection reset by peer)
2021-01-04 19:12:38 +0100nineonin_(~nineonine@S01061cabc0b095f3.vf.shawcable.net)
2021-01-04 19:12:40 +0100crblmr(~carbolyme@matrix.dropacid.net)
2021-01-04 19:13:12 +0100gues72874(~username@62-34-117-205.abo.bbox.fr)
2021-01-04 19:13:28 +0100Kaiepi(~Kaiepi@47.54.252.148)
2021-01-04 19:13:55 +0100 <Melanie> merijn: monadic functions, like (m a -> m a) or (a -> m a)?
2021-01-04 19:14:02 +0100 <merijn> Melanie: The latter
2021-01-04 19:14:35 +0100 <Melanie> that sounds like a fixed point to me
2021-01-04 19:15:12 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2021-01-04 19:15:22 +0100 <merijn> Not really? I basically just need "foldl (>=>) return . map foo" that I was hoping to handle with a single foldMap
2021-01-04 19:15:58 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2021-01-04 19:16:38 +0100LKoen(~LKoen@174.175.9.109.rev.sfr.net)
2021-01-04 19:16:52 +0100justsomeguy(~justsomeg@unaffiliated/--/x-3805311) ()
2021-01-04 19:17:05 +0100 <Melanie> :t foldl (>=>) return
2021-01-04 19:17:07 +0100 <lambdabot> (Foldable t, Monad m) => t (b -> m b) -> b -> m b
2021-01-04 19:19:24 +0100nineonin_(~nineonine@S01061cabc0b095f3.vf.shawcable.net) (Read error: Connection reset by peer)
2021-01-04 19:19:28 +0100 <Melanie> i don't think you'll get a monoid like Endo because of the types, but maybe Kleisli? https://hackage.haskell.org/package/base-4.14.1.0/docs/Control-Arrow.html#t:Kleisli
2021-01-04 19:19:30 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net)
2021-01-04 19:20:29 +0100 <Melanie> you could probably put a monoid instance on Kleisli m a a
2021-01-04 19:21:10 +0100gues72874(~username@62-34-117-205.abo.bbox.fr) (Ping timeout: 265 seconds)
2021-01-04 19:21:41 +0100 <merijn> Melanie: Yeah, but then I'm probably better off writing out the fold instead :)
2021-01-04 19:22:07 +0100 <Melanie> ¯\_(ツ)_/¯
2021-01-04 19:23:09 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d)
2021-01-04 19:23:38 +0100matryoshka(~matryoshk@184.75.223.227) (Quit: ZNC 1.8.2 - https://znc.in)
2021-01-04 19:23:52 +0100matryoshka(~matryoshk@184.75.223.227)
2021-01-04 19:24:28 +0100howdoi(uid224@gateway/web/irccloud.com/x-rxnglkkhuozkyxip)
2021-01-04 19:32:08 +0100cfricke(~cfricke@unaffiliated/cfricke) (Quit: WeeChat 3.0)
2021-01-04 19:33:04 +0100 <Melanie> maybe you could use (Applicative f, Monoid a) => Monoid (Ap f a)
2021-01-04 19:33:18 +0100 <Melanie> with Data.Monoid.Ap
2021-01-04 19:33:40 +0100 <Melanie> ah, sorry, that's not the function composition you'd need
2021-01-04 19:34:15 +0100geekosaur(42d52137@66.213.33.55) (Ping timeout: 245 seconds)
2021-01-04 19:34:35 +0100bitmapper(uid464869@gateway/web/irccloud.com/x-cjvrvhgujfjiqkfn) (Quit: Connection closed for inactivity)
2021-01-04 19:34:35 +0100Tario(~Tario@201.192.165.173) (Read error: Connection reset by peer)
2021-01-04 19:38:37 +0100zfnmxt(~zfnmxt@unaffiliated/zfnmxt) (Quit: Bye!)
2021-01-04 19:39:14 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr)
2021-01-04 19:43:08 +0100zfnmxt(~zfnmxt@unaffiliated/zfnmxt)
2021-01-04 19:44:00 +0100mizlan(~michaella@c-67-169-7-31.hsd1.ca.comcast.net) (Quit: leaving)
2021-01-04 19:45:16 +0100texasmynsted(~texasmyns@99.96.221.112) (Ping timeout: 240 seconds)
2021-01-04 19:45:44 +0100kritzefitz(~kritzefit@212.86.56.80) (Ping timeout: 260 seconds)
2021-01-04 19:47:38 +0100cgadski(~cgadski@a95-95-106-208.cpe.netcabo.pt)
2021-01-04 19:48:02 +0100 <cgadski> symbols generated by Template Haskell are picked up and used in autocompletion by e.g. the Haskell Language Server, right?
2021-01-04 19:49:47 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net) (Remote host closed the connection)
2021-01-04 19:50:25 +0100nineonine(~nineonine@50.216.62.2)
2021-01-04 19:51:46 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr) (Quit: Konversation terminated!)
2021-01-04 19:52:08 +0100zebrag(~inkbottle@aaubervilliers-654-1-100-102.w86-212.abo.wanadoo.fr)
2021-01-04 19:52:16 +0100geekosaur(42d52137@66.213.33.55)
2021-01-04 19:55:00 +0100Lord_of_Life(~Lord@unaffiliated/lord-of-life/x-0885362) (Ping timeout: 265 seconds)
2021-01-04 19:55:33 +0100Lord_of_Life(~Lord@unaffiliated/lord-of-life/x-0885362)
2021-01-04 19:55:59 +0100bitmagie(~Thunderbi@200116b806b5fe0008aee93e467ed0bc.dip.versatel-1u1.de)
2021-01-04 19:56:57 +0100bitmagie(~Thunderbi@200116b806b5fe0008aee93e467ed0bc.dip.versatel-1u1.de) (Client Quit)
2021-01-04 19:58:11 +0100neiluj(~jco@91-167-203-101.subs.proxad.net)
2021-01-04 20:00:49 +0100quinn(~quinn@c-73-223-224-163.hsd1.ca.comcast.net)
2021-01-04 20:02:26 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d) (Ping timeout: 264 seconds)
2021-01-04 20:02:28 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2021-01-04 20:02:29 +0100andreas303(~andreas@gateway/tor-sasl/andreas303) (Remote host closed the connection)
2021-01-04 20:02:51 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2021-01-04 20:03:29 +0100berberman(~berberman@unaffiliated/berberman)
2021-01-04 20:03:47 +0100berberman_(~berberman@unaffiliated/berberman) (Ping timeout: 260 seconds)
2021-01-04 20:04:30 +0100matryoshka(~matryoshk@184.75.223.227) (Quit: ZNC 1.8.2 - https://znc.in)
2021-01-04 20:04:48 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809)
2021-01-04 20:06:29 +0100cfricke(~cfricke@unaffiliated/cfricke)
2021-01-04 20:08:16 +0100cfricke(~cfricke@unaffiliated/cfricke) (Client Quit)
2021-01-04 20:08:38 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809) (Client Quit)
2021-01-04 20:08:58 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809)
2021-01-04 20:09:00 +0100heatsink(~heatsink@2600:1700:bef1:5e10:f187:6a02:e58f:90ce) (Remote host closed the connection)
2021-01-04 20:09:25 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com) (Ping timeout: 240 seconds)
2021-01-04 20:09:45 +0100b4er(~b4er@91.193.4.122) (Ping timeout: 240 seconds)
2021-01-04 20:10:00 +0100andreas303(~andreas@gateway/tor-sasl/andreas303)
2021-01-04 20:11:27 +0100Tario(~Tario@201.192.165.173)
2021-01-04 20:13:10 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809) (Client Quit)
2021-01-04 20:13:29 +0100matryoshka(~matryoshk@184.75.223.227)
2021-01-04 20:14:25 +0100notzmv(~user@unaffiliated/zmv) (Remote host closed the connection)
2021-01-04 20:15:23 +0100notzmv(~user@unaffiliated/zmv)
2021-01-04 20:17:20 +0100nineonine(~nineonine@50.216.62.2) (Remote host closed the connection)
2021-01-04 20:17:52 +0100nineonine(~nineonine@50.216.62.2)
2021-01-04 20:18:55 +0100matryoshka(~matryoshk@184.75.223.227) (Quit: ZNC 1.8.2 - https://znc.in)
2021-01-04 20:19:14 +0100matryoshka(~matryoshk@184.75.223.227)
2021-01-04 20:19:20 +0100notzmv(~user@unaffiliated/zmv) (Remote host closed the connection)
2021-01-04 20:19:24 +0100chenshen(~chenshen@2620:10d:c090:400::5:418a)
2021-01-04 20:20:35 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com)
2021-01-04 20:20:53 +0100notzmv(~user@unaffiliated/zmv)
2021-01-04 20:23:22 +0100matryoshka(~matryoshk@184.75.223.227) (Client Quit)
2021-01-04 20:23:39 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809)
2021-01-04 20:27:20 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89)
2021-01-04 20:27:52 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809) (Client Quit)
2021-01-04 20:28:12 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809)
2021-01-04 20:30:09 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809) (Client Quit)
2021-01-04 20:30:29 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809)
2021-01-04 20:30:58 +0100zfnmxt(~zfnmxt@unaffiliated/zfnmxt) (Quit: Bye!)
2021-01-04 20:33:21 +0100zfnmxt(~zfnmxt@unaffiliated/zfnmxt)
2021-01-04 20:33:38 +0100bitmapper(uid464869@gateway/web/irccloud.com/x-naqbxzlsevlmbjnm)
2021-01-04 20:33:48 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809) (Client Quit)
2021-01-04 20:34:27 +0100 <shinobi> Learn You a Haskell states that let expressions are, in fact, expressions. If where expressions are not expressions, what are they?
2021-01-04 20:34:56 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com) (Ping timeout: 240 seconds)
2021-01-04 20:35:04 +0100cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net)
2021-01-04 20:35:10 +0100 <geekosaur> clauses associated with declarations
2021-01-04 20:35:11 +0100 <sm[m]> syntactic sugar
2021-01-04 20:35:11 +0100 <merijn> shinobi: Well, they're not where *expressions*, they're where blocks :p
2021-01-04 20:35:22 +0100 <monochrom> They are part of a definition.
2021-01-04 20:35:34 +0100 <merijn> Which are, part of a binding's definition
2021-01-04 20:35:50 +0100 <merijn> sm[m]: Arguably so are let expressions :p
2021-01-04 20:36:11 +0100 <monochrom> You simply don't treat it in isolation.
2021-01-04 20:36:29 +0100 <monochrom> "let x=1 in x" can stand alone. "where x=1" cannot stand alone.
2021-01-04 20:36:37 +0100 <monochrom> Well, "let x=1" cannot, either.
2021-01-04 20:36:59 +0100 <merijn> That's do notation, though, not a let expression
2021-01-04 20:37:33 +0100 <boxscape> merijn what would let expressions be syntactic sugar for in that view?
2021-01-04 20:37:37 +0100 <monochrom> do or do not, "let x=1" cannot stand alone.
2021-01-04 20:37:45 +0100 <merijn> boxscape: Lambdas
2021-01-04 20:37:58 +0100 <boxscape> don't lambdas work differently with type inference in hindley-milner?
2021-01-04 20:38:07 +0100 <monochrom> No, let-generalization stops you from translating let to lambda.
2021-01-04 20:38:20 +0100 <monochrom> and recursion stops you, too.
2021-01-04 20:38:37 +0100 <merijn> I guess then we get to the question "what is sugar?"
2021-01-04 20:39:03 +0100 <monochrom> This is why I don't bring up sugar.
2021-01-04 20:39:08 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com)
2021-01-04 20:39:12 +0100 <monochrom> Apart from desugared grape juice.
2021-01-04 20:40:06 +0100 <monochrom> I don't draw a line "these are syntax sugars" unless there is a really high pedagogical value.
2021-01-04 20:40:18 +0100kritzefitz(~kritzefit@212.86.56.80)
2021-01-04 20:40:38 +0100 <shinobi> I take it that I should just take it for what it is, that being let is local and can stand alone; where has a greater scope but cannot stand alone.
2021-01-04 20:40:44 +0100 <monochrom> Such as forcing stubborn minds to finally accept that [1,2,3,4] matches the pattern x:xs with x=1, xs=[2,3,4].
2021-01-04 20:41:38 +0100 <boxscape> shinobi let can have the same scope as where if you put it on a high enough level, i.e., directly after the = in a function definition
2021-01-04 20:41:52 +0100 <monochrom> Such as forcing cargo-culters (they cargo-cult do-notation) to understand using >>=
2021-01-04 20:42:54 +0100 <boxscape> shinobi ... though I suppose to be fair things defined in such a let expression wouldn't be available to a where block associated with that function definition, so maybe you're right after all that where has a larger scope :)
2021-01-04 20:43:06 +0100 <shinobi> boxscape: Is there an preferred approach or is this a matter of style
2021-01-04 20:43:22 +0100 <boxscape> shinobi matter of style I would say, I tend to use where a lot
2021-01-04 20:44:29 +0100 <shinobi> Then there are guards. These seem very close to the case statement. Is there a rule of thumb as to when to use guards vs case .. of ?
2021-01-04 20:44:53 +0100 <boxscape> case allows you to pattern match, (vanilla) guards allow you to check boolean conditions - they are for different use cases
2021-01-04 20:44:54 +0100 <monochrom> They are mostly uninterchangeable.
2021-01-04 20:45:05 +0100nineonine(~nineonine@50.216.62.2) (Ping timeout: 240 seconds)
2021-01-04 20:45:32 +0100 <ski> > case () of () | 2 > 3 -> "foo" | otherwise -> "bar"
2021-01-04 20:45:34 +0100 <lambdabot> "bar"
2021-01-04 20:46:03 +0100texasmynsted(~texasmyns@99.96.221.112)
2021-01-04 20:46:21 +0100nineonine(~nineonine@50.216.62.2)
2021-01-04 20:47:28 +0100cads(~cads@ip-64-72-99-232.lasvegas.net) (Ping timeout: 246 seconds)
2021-01-04 20:48:07 +0100zmagii_(~zmagii@unaffiliated/zmagii) (Quit: ZNC 1.7.5+deb4 - https://znc.in)
2021-01-04 20:48:09 +0100cads2(~cads@ip-64-72-99-232.lasvegas.net) (Ping timeout: 260 seconds)
2021-01-04 20:51:45 +0100 <__monty__> shinobi: I usually stick to pattern matching and guards but use case expressions if it avoids duplication.
2021-01-04 20:53:22 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809)
2021-01-04 20:53:45 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89) (Quit: Connection closed)
2021-01-04 20:53:58 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89)
2021-01-04 20:54:49 +0100 <merijn> shinobi: I would say that "where where possible" is by far the preferred style
2021-01-04 20:54:54 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809) (Client Quit)
2021-01-04 20:55:15 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809)
2021-01-04 20:55:27 +0100 <merijn> monochrom: Pattern guard disagree ;)
2021-01-04 20:57:42 +0100nineonin_(~nineonine@50.216.62.2)
2021-01-04 20:57:42 +0100nineonine(~nineonine@50.216.62.2) (Remote host closed the connection)
2021-01-04 20:58:29 +0100texasmynsted(~texasmyns@99.96.221.112) (Read error: Connection timed out)
2021-01-04 20:58:57 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com) (Ping timeout: 260 seconds)
2021-01-04 20:59:15 +0100pavonia(~user@unaffiliated/siracusa)
2021-01-04 20:59:31 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809) (Client Quit)
2021-01-04 20:59:32 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com)
2021-01-04 20:59:48 +0100ph88(~ph88@2a02:8109:9e00:7e5c:107a:c84:877e:fc08) (Ping timeout: 260 seconds)
2021-01-04 20:59:53 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809)
2021-01-04 21:00:02 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d)
2021-01-04 21:00:19 +0100texasmynsted(~texasmyns@99.96.221.112)
2021-01-04 21:00:29 +0100zmagii(~zmagii@unaffiliated/zmagii)
2021-01-04 21:01:12 +0100jedws(~jedws@121.209.189.201) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 21:03:50 +0100matryoshka(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809) (Client Quit)
2021-01-04 21:04:07 +0100matryoshka(~matryoshk@184.75.223.227)
2021-01-04 21:04:25 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com) (Ping timeout: 264 seconds)
2021-01-04 21:04:27 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d) (Ping timeout: 260 seconds)
2021-01-04 21:04:45 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com)
2021-01-04 21:05:19 +0100 <ephemient> I use -XLambdaCase relatively often… almost always on the RHS of a >>=
2021-01-04 21:05:26 +0100heatsink(~heatsink@2600:1700:bef1:5e10:f187:6a02:e58f:90ce)
2021-01-04 21:05:33 +0100fascher-(~fascher@105.112.46.41)
2021-01-04 21:05:37 +0100nineonin_(~nineonine@50.216.62.2) (Ping timeout: 264 seconds)
2021-01-04 21:05:50 +0100matryoshka`(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809)
2021-01-04 21:05:54 +0100 <ephemient> otherwise I don't think I use case much
2021-01-04 21:05:56 +0100matryoshka(~matryoshk@184.75.223.227) (Read error: Connection reset by peer)
2021-01-04 21:06:58 +0100plopls(69702e29@105.112.46.41)
2021-01-04 21:07:50 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net)
2021-01-04 21:09:16 +0100 <ephemient> I suppose every pattern match/guard can be desugared to case .. of, and every case expression could be turned into a local binding with pattern matches/guards
2021-01-04 21:09:25 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com) (Ping timeout: 256 seconds)
2021-01-04 21:09:48 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com)
2021-01-04 21:11:51 +0100 <ephemient> e.g. `x = case () of () | 2 > 3 -> "foo" | otherwise -> "bar"` == `x | 2 > 3 = "foo" | otherwise = "bar"`
2021-01-04 21:13:00 +0100geekosaur(42d52137@66.213.33.55) (Ping timeout: 245 seconds)
2021-01-04 21:14:26 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com) (Ping timeout: 256 seconds)
2021-01-04 21:14:47 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com)
2021-01-04 21:15:14 +0100 <ski> (possibly after parameterizing on nonlocals)
2021-01-04 21:16:32 +0100Franciman(~francesco@host-87-17-26-221.retail.telecomitalia.it) (Quit: Leaving)
2021-01-04 21:17:24 +0100plopls(69702e29@105.112.46.41) (Remote host closed the connection)
2021-01-04 21:18:00 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net) (Read error: Connection reset by peer)
2021-01-04 21:18:30 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net)
2021-01-04 21:19:26 +0100fascher-(~fascher@105.112.46.41) (Remote host closed the connection)
2021-01-04 21:22:58 +0100fascher(~fascher@105.112.46.41)
2021-01-04 21:24:05 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com) (Ping timeout: 256 seconds)
2021-01-04 21:24:50 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com)
2021-01-04 21:26:23 +0100 <fascher> is there any discord server for haskell ?
2021-01-04 21:26:50 +0100 <Uniaika> fascher: there is a general FP Discord
2021-01-04 21:26:59 +0100 <Uniaika> and topos's own one
2021-01-04 21:27:24 +0100 <fascher> ok. can you give me an invite to both?
2021-01-04 21:27:27 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d)
2021-01-04 21:27:32 +0100 <topos> mine is for the cool kids
2021-01-04 21:27:35 +0100 <topos> you have to be a cool kid to get in
2021-01-04 21:27:39 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net) (Ping timeout: 272 seconds)
2021-01-04 21:28:00 +0100 <fascher> what are the requirements to being a cool kid?
2021-01-04 21:28:27 +0100 <fascher> :D
2021-01-04 21:29:16 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com) (Ping timeout: 240 seconds)
2021-01-04 21:29:31 +0100ski. o O ( "Team Chat" <https://xkcd.com/1782/> )
2021-01-04 21:29:39 +0100Faker(69702e29@105.112.46.41)
2021-01-04 21:29:45 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com)
2021-01-04 21:30:37 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net)
2021-01-04 21:32:38 +0100fascher(~fascher@105.112.46.41) (Remote host closed the connection)
2021-01-04 21:32:52 +0100fascher(~fascher@105.112.46.41)
2021-01-04 21:34:36 +0100 <shinobi> In chapter 9 (page 197) the askForNumber function contains IO Actions that will be executed at some point. However, this function calls itself recursively and doesn't seem to return. When are those IO actions executed?
2021-01-04 21:34:46 +0100geekosaur(42d52137@66.213.33.55)
2021-01-04 21:35:13 +0100ClaudiusMaximus(~claude@unaffiliated/claudiusmaximus) (Quit: ->)
2021-01-04 21:35:44 +0100 <boxscape> (link to the html page that contains it http://learnyouahaskell.com/input-and-output )
2021-01-04 21:35:46 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 246 seconds)
2021-01-04 21:36:23 +0100 <monochrom> Have you run it and made empirical observations?
2021-01-04 21:37:09 +0100 <sm[m]> Discord pfff, Matrix is cool now
2021-01-04 21:37:16 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 21:37:36 +0100 <Uniaika> fascher: https://discord.gg/V7GCEkYD
2021-01-04 21:38:10 +0100 <Uniaika> fascher: rules are simple: be kind, don't be an arse, don't ask for non-FP coding help, read the wikipedia page on FP (at least the first paragraph), and read the rules
2021-01-04 21:38:37 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com) (Ping timeout: 260 seconds)
2021-01-04 21:39:03 +0100 <boxscape> % forever
2021-01-04 21:39:03 +0100 <yahb> boxscape: ; <interactive>:175:1: error:; * No instance for (Show (f0 a0 -> f0 b0)) arising from a use of `print'; (maybe you haven't applied a function to enough arguments?); * In a stmt of an interactive GHCi command: print it
2021-01-04 21:39:06 +0100 <boxscape> % :t forever
2021-01-04 21:39:06 +0100 <yahb> boxscape: Applicative f => f a -> f b
2021-01-04 21:39:19 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net) (Remote host closed the connection)
2021-01-04 21:39:40 +0100geekosaur(42d52137@66.213.33.55) (Ping timeout: 245 seconds)
2021-01-04 21:39:43 +0100 <boxscape> shinobi this function is perhaps simpler to understand but has the same principle: It takes an IO action (or other action) and executes it forever, calling itself but never returning
2021-01-04 21:39:59 +0100nineonine(~nineonine@50.216.62.2)
2021-01-04 21:40:16 +0100 <boxscape> % forever $ putChar 'c'
2021-01-04 21:40:23 +0100 <yahb> boxscape: cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
2021-01-04 21:40:30 +0100 <boxscape> @src forever
2021-01-04 21:40:30 +0100 <lambdabot> forever a = let a' = a >> a' in a'
2021-01-04 21:41:15 +0100 <boxscape> okay so actually it doesn't call itself in this @src but you could implement it as `forever a = a >> forever a`
2021-01-04 21:41:21 +0100 <fascher> @Uniaika Thanks
2021-01-04 21:41:21 +0100 <lambdabot> Unknown command, try @list
2021-01-04 21:41:59 +0100 <ski> forever act = loop
2021-01-04 21:42:01 +0100 <ski> where
2021-01-04 21:42:06 +0100 <ski> loop = do act
2021-01-04 21:42:11 +0100 <ski> loop
2021-01-04 21:42:34 +0100 <monochrom> a' calls itself
2021-01-04 21:43:04 +0100 <shinobi> monochrom: My system doesn't seem to find System.Random :/
2021-01-04 21:43:23 +0100 <monochrom> Yeah it has been splitted off of GHC.
2021-01-04 21:43:41 +0100 <boxscape> you need the "random" package
2021-01-04 21:43:41 +0100 <monochrom> In LYAH's time, it came with GHC. Not any more.
2021-01-04 21:44:22 +0100 <monochrom> On the bright side, today's random package (version 1.2 or above) uses an actually good generator.
2021-01-04 21:45:17 +0100 <shinobi> I thought the whole point was to separate pure and unpure. If IO actions get input from the user in my pure functions, what's the point?
2021-01-04 21:45:26 +0100Faker(69702e29@105.112.46.41) (Remote host closed the connection)
2021-01-04 21:45:32 +0100 <shinobi> I thought it had to return to main before it was executed.
2021-01-04 21:46:11 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d) (Ping timeout: 268 seconds)
2021-01-04 21:46:19 +0100geekosaur(42d52137@66.213.33.55)
2021-01-04 21:46:37 +0100 <boxscape> shinobi askForInput is not a pure function, which you can tell by the IO in its result type
2021-01-04 21:46:51 +0100 <monochrom> For toy programs that are merely 10 lines long, yes you can use a monolithic organization (i.e. no organization at all).
2021-01-04 21:46:52 +0100 <boxscape> erm
2021-01-04 21:46:56 +0100 <boxscape> askForNumber, I mean
2021-01-04 21:46:59 +0100 <ski> it is a pure, effectful, operation
2021-01-04 21:47:39 +0100 <monochrom> The fundamental dilemma of education is this.
2021-01-04 21:48:26 +0100 <monochrom> If I show you modularity by a 1000-line case study, it takes too long for me to describe, and it takes too long for you to digest, and above all, it has to contain 100 distractions.
2021-01-04 21:48:28 +0100 <ski> shinobi : what do you mean by "it had to return to main before it was executed"
2021-01-04 21:49:04 +0100 <monochrom> But if I show a 20-line toy example, it is so toy you wonder "why does it need a better organization".
2021-01-04 21:49:23 +0100madjestic(~Android@86-88-72-244.fixed.kpn.net) (Quit: -a- Connection Timed Out)
2021-01-04 21:49:37 +0100madjestic(~Android@86-88-72-244.fixed.kpn.net)
2021-01-04 21:49:37 +0100 <shinobi> I thought I read that IO actions do not get executed in pure functions. They have to return to main.
2021-01-04 21:49:42 +0100Major_Biscuit(~Major_Bis@93-21-124.netrun.cytanet.com.cy)
2021-01-04 21:49:53 +0100 <ski> all Haskell functions are pure
2021-01-04 21:49:55 +0100 <shinobi> monochrom: I thought the point of the IO action is to keep functions pure
2021-01-04 21:50:02 +0100 <shinobi> It is a sign of impurity?
2021-01-04 21:50:15 +0100 <shinobi> Then I don't understand Io
2021-01-04 21:50:40 +0100kyali(~kyali@APN-123-251-207-gprs.simobil.net)
2021-01-04 21:50:50 +0100 <monochrom> I think no one knows what "keep functions pure" means.
2021-01-04 21:50:59 +0100 <monochrom> including whoever says it
2021-01-04 21:51:07 +0100 <ski> the resulting value (an `IO'-action) of calling `askForNumber' (on a `StdGen') is being incorporated into `main', so that when `main' is executed, the former action will be executed, since it's a part of `main'
2021-01-04 21:51:45 +0100 <int-e> . o O ( Everything is pure up to the point where the devil takes an IO action and runs it... )
2021-01-04 21:51:49 +0100notzmv(~user@unaffiliated/zmv) (Remote host closed the connection)
2021-01-04 21:52:14 +0100 <monochrom> In my class, I don't even talk about "pure".
2021-01-04 21:52:34 +0100 <ski> if `main' had just contained `print (length [askForNumber gen])' as the last command (rather than `askForNumber gen'), then the I/O-effects described by `askForNumber' would not have been performed
2021-01-04 21:52:37 +0100notzmv(~user@unaffiliated/zmv)
2021-01-04 21:53:20 +0100nineonin_(~nineonine@50.216.62.2)
2021-01-04 21:53:36 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com)
2021-01-04 21:53:36 +0100nineonine(~nineonine@50.216.62.2) (Ping timeout: 256 seconds)
2021-01-04 21:54:27 +0100cgadski(~cgadski@a95-95-106-208.cpe.netcabo.pt) (Remote host closed the connection)
2021-01-04 21:54:40 +0100 <shinobi> ok. That makes sense
2021-01-04 21:57:17 +0100 <ski> `IO'-actions are only performed/run/executed, insofar as they're being made a part of the `main' action
2021-01-04 21:57:45 +0100 <merijn> shinobi: The point of *having* IO is that IO *is* pure
2021-01-04 21:57:57 +0100 <shinobi> ski: you just lost me
2021-01-04 21:57:59 +0100 <merijn> shinobi: But humans are messy inconsistent and sloppily use "impure" to mean "uses IO"
2021-01-04 21:58:04 +0100notzmv(~user@unaffiliated/zmv) (Remote host closed the connection)
2021-01-04 21:58:08 +0100mpereira(~mpereira@2a02:810d:f40:d96:60a3:298c:ae57:512d)
2021-01-04 21:58:36 +0100 <ski> (with some caveats. in the interactor, you can also enter actions, which will be (evaluated and) executed. also, if some action is part of a branch of the `main' big action that is not taken (or, say, an exception is raised (or an infinite loop occurs) before the action is reached), then that action won't be performed)
2021-01-04 21:58:43 +0100 <merijn> shinobi: All functions (including those returning IO) are pure, with a handful of exceptions (which all have "unsafe" in the name)
2021-01-04 21:59:25 +0100 <shinobi> So would all those functions return the same value if run with the same parameters?
2021-01-04 21:59:25 +0100 <ski> shinobi : you know how `do'-notation is desugared into calls of `(>>=)' (and `(>>)', and in some cases `fail') ?
2021-01-04 21:59:33 +0100 <ski> shinobi : yes
2021-01-04 21:59:34 +0100 <__monty__> There's a similar thing going on with "side-effects" where people call everything a side-effect even if it's outright an effect.
2021-01-04 21:59:37 +0100 <merijn> shinobi: They do, yes
2021-01-04 21:59:41 +0100 <Kronic> The way I understand it is that Haskell has kind of an internal system of logic which is unaffected by IO and the effects that happen with it
2021-01-04 21:59:49 +0100 <ski> @type readFile
2021-01-04 21:59:50 +0100 <lambdabot> FilePath -> IO String
2021-01-04 22:00:03 +0100 <Kronic> I'm a noob too, though, so, my understanding might be mislead, but I more than get around
2021-01-04 22:00:12 +0100 <merijn> shinobi: Consider this: 'putStrLn "foo"' isn't a function that "prints 'foo'" it's a function that returns an IO action "IO ()" which (when executed) will print foo
2021-01-04 22:00:27 +0100 <ski> `readFile "myFile"' always returns the same value, namely the same `IO'-action, the same *description* of input/output interactions to perform with the OS
2021-01-04 22:01:03 +0100 <merijn> shinobi: If I apply the the function putStrLn to two identical strings, what do I get? Two actions that do the exact same thing when executed.
2021-01-04 22:01:14 +0100texasmynsted(~texasmyns@99.96.221.112) (Remote host closed the connection)
2021-01-04 22:01:17 +0100 <merijn> something, something, glorious stereo ;)
2021-01-04 22:01:22 +0100 <shinobi> Right, but if the function is recursive and doesn't return, how does the IO action eventually get executed?
2021-01-04 22:01:28 +0100 <ski> the result of performing those interactions will commonly yield different `String's as results, even if the same `String' is passed to `readFile'. but the "instruction list" that is returned by `readFile' will still be the same, given the same file name
2021-01-04 22:01:40 +0100Lorra(~lorenzo@2001:a61:ba6:4501:e4b0:8d5e:9fde:f2ec)
2021-01-04 22:01:42 +0100 <ski> __monty__ : yea
2021-01-04 22:01:47 +0100 <__monty__> Kronic: Sounds more complicated than "Your pure program produces a sequence of instructions to be executed by the RTS."
2021-01-04 22:02:16 +0100skiplays a fugue in the background
2021-01-04 22:02:50 +0100 <ski> shinobi : if it doesn't compute an `IO'-action as result, then there's no action to perform/execute
2021-01-04 22:03:01 +0100 <Kronic> To me it doesn't but I kinda get how it works so I'm not sure I would like to argue :)
2021-01-04 22:03:24 +0100 <dolio> IO actions can be infinite objects, just like lists.
2021-01-04 22:03:25 +0100 <Kronic> Me being the more new of the two of us here, that is
2021-01-04 22:04:22 +0100 <__monty__> Kronic: Imo it's more complicated in the sense that you treat IO as a special case.
2021-01-04 22:04:27 +0100 <Kronic> shinobi, I hate to answer your question with a question, but what is your understanding of what a pure function is?
2021-01-04 22:04:39 +0100 <shinobi> So is this because IO is a functor? Is Haskell mapping over it to make a more complicated IO Action that gets return only to be executed in main later ?
2021-01-04 22:05:09 +0100guest9689(~username@62-34-117-205.abo.bbox.fr)
2021-01-04 22:05:27 +0100 <shinobi> Kronic: I believe a pure function to be a function that depends soley and completely on it's input parameters.
2021-01-04 22:05:33 +0100dhouthoo(~dhouthoo@ptr-eitgbj2w0uu6delkbrh.18120a2.ip6.access.telenet.be) (Quit: WeeChat 2.9)
2021-01-04 22:05:35 +0100 <shinobi> It may or may not be complete
2021-01-04 22:05:51 +0100 <shinobi> The goal is to have complete, pure functions
2021-01-04 22:06:16 +0100 <Kronic> Right, so if you take what you just said and look at what merijn said earlier
2021-01-04 22:06:46 +0100 <Kronic> The result or thing that is evaluated out of a function that results in IO is just the IO type with an empty tuple
2021-01-04 22:06:52 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2021-01-04 22:06:58 +0100 <ski> > (take 8 . (`execState` undefined)) (let loop = do loop; xs <- get; put (1 : map (2 *) xs) in loop)
2021-01-04 22:07:01 +0100 <lambdabot> [1,2,4,8,16,32,64,128]
2021-01-04 22:07:03 +0100 <Kronic> The fact that a file gets written to or is deleted or made or whatever does not really make a difference
2021-01-04 22:07:16 +0100 <__monty__> shinobi: The recursion doesn't happen until the action is executed. That's why askForNumber doesn't get stuck in a loop trying to return an IO action.
2021-01-04 22:07:32 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2021-01-04 22:07:57 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-01-04 22:07:58 +0100 <shinobi> So this just goes back to lazy execution ?
2021-01-04 22:07:58 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2021-01-04 22:08:15 +0100rcdilorenzo(~rcdiloren@cpe-76-182-87-188.nc.res.rr.com)
2021-01-04 22:09:12 +0100 <__monty__> Not quite, laziness only affects when the arguments to your function are evaluated.
2021-01-04 22:09:25 +0100Neo--(~neo@BSN-176-188-17.dynamic.siol.net) (Disconnected by services)
2021-01-04 22:09:27 +0100Neo---(~neo@BSN-143-24-54.dynamic.siol.net)
2021-01-04 22:09:52 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com)
2021-01-04 22:10:38 +0100rcdilorenzo(~rcdiloren@cpe-76-182-87-188.nc.res.rr.com) (Client Quit)
2021-01-04 22:10:55 +0100rcdilorenzo(~rcdiloren@cpe-76-182-87-188.nc.res.rr.com)
2021-01-04 22:12:25 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2021-01-04 22:13:30 +0100christo(~chris@81.96.113.213)
2021-01-04 22:14:48 +0100 <shinobi> ok, so the do in that example from the book, will make 1 IO action out of the whole thing that gets returned, including the call to askForNumber?
2021-01-04 22:15:28 +0100 <ski> `main' is one single `IO'-action, yes
2021-01-04 22:15:59 +0100 <ski> that will include the actions described by `askForNumber' as part of it
2021-01-04 22:16:08 +0100 <__monty__> And so is what askForNumber returns when applied to a StdGen.
2021-01-04 22:17:38 +0100 <gentauro> > :t distinct = map head . groupBy . sort
2021-01-04 22:17:41 +0100 <lambdabot> <hint>:1:1: error: <hint>:1:1: error: parse error on input ‘:’
2021-01-04 22:17:46 +0100christo(~chris@81.96.113.213) (Ping timeout: 246 seconds)
2021-01-04 22:17:46 +0100spopejoy(~stuart@ool-44c5f8c9.dyn.optonline.net)
2021-01-04 22:17:55 +0100 <ski> @type let distinct = map head . groupBy . sort in distinct
2021-01-04 22:17:57 +0100 <lambdabot> error:
2021-01-04 22:17:57 +0100 <lambdabot> • Couldn't match type ‘[a0] -> [[a0]]’ with ‘[[b1]]’
2021-01-04 22:17:57 +0100 <lambdabot> Expected type: [a1] -> [[b1]]
2021-01-04 22:18:09 +0100 <ski> @type let distinct f = map head . groupBy f . sort in distinct
2021-01-04 22:18:10 +0100 <lambdabot> Ord b => (b -> b -> Bool) -> [b] -> [b]
2021-01-04 22:18:33 +0100 <shinobi> I guess I was expecting the repeat call to askForNumber in main.
2021-01-04 22:18:49 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2021-01-04 22:19:11 +0100 <gentauro> @type let distinct = map head . group . sort
2021-01-04 22:19:13 +0100 <lambdabot> <no location info>: error:
2021-01-04 22:19:13 +0100 <lambdabot> not an expression: ‘let distinct = map head . group . sort’
2021-01-04 22:19:17 +0100kuribas(~user@ptr-25vy0i8khwxhgges4vi.18120a2.ip6.access.telenet.be) (Quit: ERC (IRC client for Emacs 26.3))
2021-01-04 22:19:19 +0100 <ski> shinobi : you could do it like that, too
2021-01-04 22:19:33 +0100 <gentauro> @type let distinct = map head . group . sort in distinct
2021-01-04 22:19:35 +0100 <lambdabot> Ord b => [b] -> [b]
2021-01-04 22:19:36 +0100 <gentauro> :)
2021-01-04 22:19:48 +0100 <ski> but then you'd need some indication back from `askForNumber', to determine whether to continue, or to stop
2021-01-04 22:19:51 +0100 <shinobi> ski: Is one way better than the other?
2021-01-04 22:19:53 +0100christo(~chris@81.96.113.213)
2021-01-04 22:20:03 +0100 <ski> (or, i guess, you could use `forever', and throw an exception when you want to stop ..)
2021-01-04 22:20:19 +0100 <ski> shinobi : depends on what you want to achieve/do ?
2021-01-04 22:20:28 +0100 <dolio> Or `exitSuccess`
2021-01-04 22:20:31 +0100 <ski> yea
2021-01-04 22:20:52 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl)
2021-01-04 22:20:54 +0100 <int-e> hmm `forever exitSuccess`
2021-01-04 22:21:48 +0100 <shinobi> Sounds like when I'm given no requirements but told it has to be done "right".
2021-01-04 22:22:18 +0100 <ski> % try System.Exit.exitSuccess :: IO (Either SomeException ())
2021-01-04 22:22:18 +0100 <yahb> ski: Left ExitSuccess
2021-01-04 22:23:41 +0100 <gentauro> @type let distinct = map head . group . sort in distinct -- Is this correctly assumed: map head O(n) + group O(n) + sort O(n lg n)?
2021-01-04 22:23:43 +0100 <lambdabot> Ord b => [b] -> [b]
2021-01-04 22:23:48 +0100 <gentauro> `map head O(n) + group O(n) + sort O(n lg n)`?
2021-01-04 22:23:51 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh)
2021-01-04 22:23:59 +0100 <dolio> Ah, they actually implemented exiting with exceptions.
2021-01-04 22:24:10 +0100 <ski> shinobi : as it is now, `askForNumber' expresses repeatedly asking the user for an input, until the reply is an empty line
2021-01-04 22:24:11 +0100 <Kronic> shinobi: Haskell isn't like other programming languages in many ways, but one of the main ways is that there is no silly creed on which on haskell devs swear to write good code. That results in there being many ways to skin a cat
2021-01-04 22:24:24 +0100 <gentauro> I read on stackoverflow that `nubBy` was quadratic
2021-01-04 22:25:02 +0100 <dolio> "Quadratic" gets you a C on the exam.
2021-01-04 22:25:33 +0100 <gentauro> at DIKU you got dumped. 3-strikes and they kicked you out of the CS-programme …
2021-01-04 22:25:36 +0100 <gentauro> :o
2021-01-04 22:25:38 +0100ohmysomuchuser(~nickednam@037008230157.dynamic-3-poz-k-1-2-0.vectranet.pl)
2021-01-04 22:25:51 +0100 <int-e> :t Data.Containers.ListUtils.nubOrd
2021-01-04 22:25:53 +0100 <lambdabot> Ord a => [a] -> [a]
2021-01-04 22:25:53 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh) (Remote host closed the connection)
2021-01-04 22:26:17 +0100tama00(~tama@unaffiliated/tama00)
2021-01-04 22:26:22 +0100 <dolio> What I mean is, doing an analysis and concluding that it's quadratic ...
2021-01-04 22:26:31 +0100crblmr(~carbolyme@matrix.dropacid.net) (Ping timeout: 246 seconds)
2021-01-04 22:26:54 +0100 <merijn> gentauro: Not really
2021-01-04 22:26:59 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net)
2021-01-04 22:27:09 +0100 <merijn> gentauro: Because you don't actually end up walking the entire list each time
2021-01-04 22:27:16 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh)
2021-01-04 22:27:19 +0100 <merijn> gentauro: Let's consider a simpler case first
2021-01-04 22:27:30 +0100 <merijn> gentauro: "map f . map g"
2021-01-04 22:27:49 +0100crblmr(~carbolyme@matrix.dropacid.net)
2021-01-04 22:27:54 +0100nineonin_(~nineonine@50.216.62.2) (Ping timeout: 260 seconds)
2021-01-04 22:28:02 +0100 <merijn> gentauro: In a strict language you'd "first map g, which is O(n), and then map f, which is also O(n)"
2021-01-04 22:29:01 +0100Melanie(~Melanie@192-0-134-138.cpe.teksavvy.com) (Ping timeout: 264 seconds)
2021-01-04 22:29:42 +0100 <gentauro> merijn: yes, we are still in O(n)
2021-01-04 22:29:46 +0100halbGefressen(~halbGefre@2a02:810d:f40:2a9c:40b2:2308:84bd:8b9b) (Ping timeout: 258 seconds)
2021-01-04 22:29:57 +0100 <merijn> But consider in Haskell: "map f (x:xs) = f x : map f xs" to get the first element out of the double map you pattern match "map f", which requires a list, which forces "map g" which can immediately return said first element without walking the list. Now you do the same for the 2nd element, etc. effectively you're only walking the list once and directly applying 'g' and then 'f' for each element. Of course
2021-01-04 22:30:02 +0100 <merijn> you do still have the overhead of allocating the "intermediate list cells"
2021-01-04 22:30:11 +0100thc202(~thc202@unaffiliated/thc202) (Quit: thc202)
2021-01-04 22:30:18 +0100 <merijn> But GHC's list fusion stuff can actually often eliminate those intermediate allocations
2021-01-04 22:31:25 +0100 <gentauro> merijn: I haven't looked into the `nubBy` code yet
2021-01-04 22:31:51 +0100 <gentauro> like I said, when I road `quadratic` I got worried. So that's why I aimed for my own `distinct` for lists
2021-01-04 22:31:54 +0100 <gentauro> :)
2021-01-04 22:32:27 +0100 <merijn> gentauro: nub is quadratic for the reason that, if all you have is Eq, the only way to filter is "pairwise compare *all* values"
2021-01-04 22:32:40 +0100 <merijn> Give a list of N elements that is N*(N-1) pairs to compare
2021-01-04 22:33:00 +0100 <dolio> Well, quadratic isn't strictly wrong, but a more detailed analysis would be O(n*k), where k is at worst n, but may be smaller.
2021-01-04 22:33:33 +0100 <int-e> gentauro: `nub` is lazy though. which is why I tried to point you to Data.Containers.ListUtils.nubOrd which is also lazy
2021-01-04 22:33:51 +0100spopejoy(~stuart@ool-44c5f8c9.dyn.optonline.net) (Quit: spopejoy)
2021-01-04 22:33:57 +0100 <int-e> though if you're going to consume all the elements anyway that will not matter much
2021-01-04 22:33:57 +0100usr25(~usr25@unaffiliated/usr25)
2021-01-04 22:34:24 +0100 <gentauro> int-e: it's using a `Data.Set`. That's `cheating` :P
2021-01-04 22:34:31 +0100_ht(~quassel@82-169-194-8.biz.kpn.net) (Remote host closed the connection)
2021-01-04 22:34:35 +0100 <int-e> gentauro: no it's not?
2021-01-04 22:34:40 +0100 <int-e> :)
2021-01-04 22:34:42 +0100 <gentauro> int-e: just kidding
2021-01-04 22:35:05 +0100 <int-e> FWIW, I have written the map head . group . sort things numerous times myself
2021-01-04 22:35:51 +0100 <gentauro> int-e: great minds think alike ;)
2021-01-04 22:35:51 +0100 <int-e> And still do because I can never remember nubOrd's module name.
2021-01-04 22:36:02 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net) (Read error: No route to host)
2021-01-04 22:36:14 +0100chenshen(~chenshen@2620:10d:c090:400::5:418a) (Quit: My MacBook Pro has gone to sleep. ZZZzzz…)
2021-01-04 22:36:16 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net)
2021-01-04 22:36:21 +0100 <monochrom> But dolio, on an exam, how much detail gets how many marks also depends on the context of the exam.
2021-01-04 22:36:45 +0100 <boxscape> hm strange that nubOrdOn exists but not nubOrdBy
2021-01-04 22:36:57 +0100fascher(~fascher@105.112.46.41) (Remote host closed the connection)
2021-01-04 22:37:00 +0100 <boxscape> oh I guess
2021-01-04 22:37:11 +0100 <boxscape> you would need an equality function that respects the Ord instance
2021-01-04 22:37:17 +0100 <boxscape> so fair enough
2021-01-04 22:37:33 +0100kritzefitz(~kritzefit@212.86.56.80) (Remote host closed the connection)
2021-01-04 22:37:44 +0100Deide(~Deide@217.155.19.23) (Quit: Seeee yaaaa)
2021-01-04 22:38:26 +0100 <monochrom> For most exams, the default is parameterized-by-input-size-only and worst-case. In that context, O(n*k) would be wrong.
2021-01-04 22:38:55 +0100b4er(~b4er@2a02:aa16:3a80:1900:5f0f:a23e:4628:9051)
2021-01-04 22:39:03 +0100 <gentauro> when I'm to lazy to write a function signature, I just do: `Foo :: Bool` and build the solution for GHC to tell me the correct signature for me to `copy/pasta` :)
2021-01-04 22:39:20 +0100 <dolio> This exam is for people who want to go beyond the average stack overflow user. :)
2021-01-04 22:40:06 +0100cgadski(~cgadski@a95-95-106-208.cpe.netcabo.pt)
2021-01-04 22:40:08 +0100olligobber(~olligobbe@unaffiliated/olligobber) (Remote host closed the connection)
2021-01-04 22:40:12 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89) (Quit: Connection closed)
2021-01-04 22:40:17 +0100 <monochrom> Hell, on my exams, "O" is already wrong, you have to say "Θ". :)
2021-01-04 22:40:27 +0100boxscape(4ff0ba59@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.89)
2021-01-04 22:40:39 +0100elliott_(~elliott@pool-108-51-101-42.washdc.fios.verizon.net)
2021-01-04 22:40:44 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-01-04 22:40:50 +0100 <boxscape> gentauro the thing ghc developers want you to do in that situation is to use _ instead of Bool
2021-01-04 22:41:12 +0100b4er(~b4er@2a02:aa16:3a80:1900:5f0f:a23e:4628:9051) (Client Quit)
2021-01-04 22:42:01 +0100 <gentauro> boxscape: good to know
2021-01-04 22:42:06 +0100 <dolio> Yeah, that's a good point.
2021-01-04 22:42:48 +0100 <dolio> Like, nub is O(exp(n)).
2021-01-04 22:43:00 +0100justsomeguy(~justsomeg@216.186.218.241)
2021-01-04 22:43:00 +0100justsomeguy(~justsomeg@216.186.218.241) (Changing host)
2021-01-04 22:43:00 +0100justsomeguy(~justsomeg@unaffiliated/--/x-3805311)
2021-01-04 22:43:10 +0100 <__monty__> monochrom: But Θ is average-case?
2021-01-04 22:44:01 +0100 <monochrom> QED
2021-01-04 22:44:16 +0100 <boxscape> Θ means the case your looking at is bounded above and below by a given function, not that you're looking at the average case
2021-01-04 22:44:29 +0100chenshen(~chenshen@2620:10d:c090:400::5:418a)
2021-01-04 22:44:51 +0100 <int-e> you're still looking at wors cases
2021-01-04 22:44:59 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net) (Remote host closed the connection)
2021-01-04 22:45:10 +0100 <monochrom> If there is still anyone who disbelieve my claim that "internet people wrongly think O is for worst case, Ω is for best case, Θ is for average case", you have one data point right theere.
2021-01-04 22:45:16 +0100 <int-e> (actually the worst/average/best case axis is independent)
2021-01-04 22:45:38 +0100nineonine(~nineonine@50.216.62.2)
2021-01-04 22:45:42 +0100 <boxscape> (s/your/you're)
2021-01-04 22:45:45 +0100guest9689(~username@62-34-117-205.abo.bbox.fr) (Ping timeout: 240 seconds)
2021-01-04 22:46:10 +0100 <monochrom> Answer: Please recall the definition of Θ. It doesn't even say the functions come from any algorithm's running time at all.
2021-01-04 22:46:11 +0100geekosaur(42d52137@66.213.33.55) (Remote host closed the connection)
2021-01-04 22:46:15 +0100 <int-e> But we have comparatively poor (or hard to use) tools for average case analysis, and best cases hardly matter, so worst case analysis is most popular.
2021-01-04 22:46:54 +0100 <int-e> monochrom: Try asking your students whether Theta(f) = O(f) - o(f)...
2021-01-04 22:47:13 +0100 <monochrom> The definition just says "if you have two functions out of the blue, here is how to compare them". The two functions can just come out of the blue, I feel like comparing n^2 with 2n^2+3 today, who says they have to be time or space or electricity or anything.
2021-01-04 22:48:00 +0100glguysays they have to be electricity
2021-01-04 22:48:01 +0100Major_Biscuit(~Major_Bis@93-21-124.netrun.cytanet.com.cy) (Ping timeout: 256 seconds)
2021-01-04 22:48:19 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2021-01-04 22:48:31 +0100 <boxscape> is EXPELECTRICITY equal to EXPTIME?
2021-01-04 22:48:39 +0100 <monochrom> hehe
2021-01-04 22:49:03 +0100neiluj(~jco@91-167-203-101.subs.proxad.net) (Changing host)
2021-01-04 22:49:03 +0100neiluj(~jco@unaffiliated/neiluj)
2021-01-04 22:49:16 +0100ech(~user@gateway/tor-sasl/ech) ()
2021-01-04 22:49:29 +0100 <monochrom> You need an 80+ platinum certified PSU for EXPELECTRICITY algorithms :)
2021-01-04 22:49:33 +0100 <ephemient> 1 bits are costlier than 0 bits (maybe)
2021-01-04 22:50:37 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-01-04 22:50:42 +0100nineonin_(~nineonine@S01061cabc0b095f3.vf.shawcable.net)
2021-01-04 22:51:03 +0100nineonin_(~nineonine@S01061cabc0b095f3.vf.shawcable.net) (Read error: Connection reset by peer)
2021-01-04 22:51:08 +0100 <ephemient> (sort of a joke, but side-channel attacks via measuring power consumption or heat dissipation do exist)
2021-01-04 22:51:27 +0100nineonin_(~nineonine@S01061cabc0b095f3.vf.shawcable.net)
2021-01-04 22:52:08 +0100nineonine(~nineonine@50.216.62.2) (Ping timeout: 256 seconds)
2021-01-04 22:52:33 +0100 <ephemient> e.g. https://platypusattack.com/
2021-01-04 22:54:33 +0100 <dolio> Is 0 actually cheaper, though? RAM probably has to refresh things regardless, for instance, because the 0s will drift toward 1 over time.
2021-01-04 23:00:06 +0100Varis(~Tadas@unaffiliated/varis) (Remote host closed the connection)
2021-01-04 23:00:11 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-01-04 23:02:07 +0100p-core(~Thunderbi@koleje-wifi-0045.koleje.cuni.cz) (Read error: Connection reset by peer)
2021-01-04 23:02:27 +0100p-core(~Thunderbi@koleje-wifi-0045.koleje.cuni.cz)
2021-01-04 23:04:51 +0100mouseghost(~draco@wikipedia/desperek) (Quit: mew wew)
2021-01-04 23:05:11 +0100 <ephemient> sure, DRAM needs periodic refresh so it costs a fair bit of power regardless of what it contains
2021-01-04 23:05:57 +0100 <ephemient> but multiply may be cheaper with 0 bits than 1 bits :)
2021-01-04 23:06:09 +0100 <dolio> Ah, I see.
2021-01-04 23:06:51 +0100spopejoy(~stuart@ool-44c5f8c9.dyn.optonline.net)
2021-01-04 23:07:28 +0100hyperisco(~hyperisco@d192-186-117-226.static.comm.cgocable.net) (Ping timeout: 246 seconds)
2021-01-04 23:08:09 +0100fafufafufafu(b2e91980@178.233.25.128) (Remote host closed the connection)
2021-01-04 23:09:21 +0100 <justsomeguy> I haven't finished reading it, but the paper “What Every Programmer Should Know About Memory” by Ulrich Drepper seems like a good exploration of this stuff.
2021-01-04 23:11:21 +0100nineonin_(~nineonine@S01061cabc0b095f3.vf.shawcable.net) (Remote host closed the connection)
2021-01-04 23:11:48 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2021-01-04 23:11:51 +0100notzmv(~user@unaffiliated/zmv)
2021-01-04 23:12:01 +0100nineonine(~nineonine@50.216.62.2)
2021-01-04 23:13:38 +0100Franciman(~francesco@host-87-17-26-221.retail.telecomitalia.it)
2021-01-04 23:15:51 +0100fendor(~fendor@178.115.131.182.wireless.dyn.drei.com) (Remote host closed the connection)
2021-01-04 23:16:42 +0100samsepi0l(~jh@2a02:908:2e30:a440:9b59:4b04:b912:5db)
2021-01-04 23:19:25 +0100 <monochrom> I might just opine "throw capacitors at the problem of how to frustrate EM-side-channel eavesdropping" :)
2021-01-04 23:20:02 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 23:20:18 +0100 <monochrom> Well, maybe s/EM/E/ . For M, one may have to Faraday-cage it.
2021-01-04 23:21:48 +0100notzmv(~user@unaffiliated/zmv) (Remote host closed the connection)
2021-01-04 23:22:37 +0100 <monochrom> Bah, sorry for sustaining the off-topic-ness. I'll go back to trying to start marking the type inference question!
2021-01-04 23:23:29 +0100 <monochrom> (I gave type inference homework for my students! My type inference notes is at http://www.vex.net/~trebla/haskell/type-inference.html )
2021-01-04 23:23:36 +0100notzmv(~user@unaffiliated/zmv)
2021-01-04 23:23:52 +0100chang(~textual@host-173-230-65-85.njjcmar.clients.pavlovmedia.com) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 23:24:02 +0100 <koz_> monochrom to students: Today's assignment - derive quick-look from first principles.
2021-01-04 23:24:10 +0100ph88(~ph88@2a02:8109:9e00:7e5c:107a:c84:877e:fc08)
2021-01-04 23:24:23 +0100 <monochrom> haha
2021-01-04 23:24:59 +0100 <monochrom> HRHFFP = higher-rank haskell from first principles
2021-01-04 23:25:03 +0100notzmv(~user@unaffiliated/zmv) (Remote host closed the connection)
2021-01-04 23:25:05 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-01-04 23:25:52 +0100notzmv(~user@unaffiliated/zmv)
2021-01-04 23:26:21 +0100samsepi0l(~jh@2a02:908:2e30:a440:9b59:4b04:b912:5db) (Quit: Konversation terminated!)
2021-01-04 23:27:21 +0100langseth1(~langseth@84.39.116.180) (Remote host closed the connection)
2021-01-04 23:29:15 +0100ph88(~ph88@2a02:8109:9e00:7e5c:107a:c84:877e:fc08) (Ping timeout: 272 seconds)
2021-01-04 23:30:30 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:d98a:f1dc:914b:1b92) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-01-04 23:30:38 +0100fendor(~fendor@178.115.131.182.wireless.dyn.drei.com)
2021-01-04 23:31:19 +0100notzmv(~user@unaffiliated/zmv) (Remote host closed the connection)
2021-01-04 23:32:50 +0100 <dolio> I'm not sure there's a "first principles" for quick look.
2021-01-04 23:34:22 +0100CMCDragonkai1(~Thunderbi@120.17.149.179)
2021-01-04 23:37:02 +0100todda7(~torstein@ppp-2-84-17-53.home.otenet.gr) (Ping timeout: 260 seconds)
2021-01-04 23:39:52 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2021-01-04 23:44:40 +0100petersen(~petersen@redhat/juhp) (Ping timeout: 256 seconds)
2021-01-04 23:46:42 +0100delinka(~delinka@217.146.82.202)
2021-01-04 23:48:02 +0100natechan(~natechan@108-233-125-227.lightspeed.sntcca.sbcglobal.net) (Quit: WeeChat 2.9)
2021-01-04 23:52:55 +0100ADG1089__(~aditya@122.163.234.142)
2021-01-04 23:53:09 +0100philopsos(~caecilius@gateway/tor-sasl/caecilius)
2021-01-04 23:54:13 +0100natechan(~natechan@108-233-125-227.lightspeed.sntcca.sbcglobal.net)
2021-01-04 23:54:35 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-01-04 23:56:26 +0100matryoshka`(~matryoshk@2606:6080:1002:8:3285:30e:de43:8809) (Ping timeout: 264 seconds)
2021-01-04 23:56:54 +0100guest14(~user@49.5.6.87) (Read error: Connection reset by peer)
2021-01-04 23:57:03 +0100guest14(~user@49.5.6.87)
2021-01-04 23:57:03 +0100jb55(~jb55@gateway/tor-sasl/jb55) (Ping timeout: 240 seconds)
2021-01-04 23:58:20 +0100jb55(~jb55@gateway/tor-sasl/jb55)
2021-01-04 23:58:53 +0100spopejoy(~stuart@ool-44c5f8c9.dyn.optonline.net) (Quit: spopejoy)
2021-01-04 23:59:54 +0100fendor(~fendor@178.115.131.182.wireless.dyn.drei.com) (Remote host closed the connection)