IRCBrowse

2023/03/07

2023-03-07 00:00:27 +0100shapr(~user@68.54.166.125)
2023-03-07 00:02:26 +0100rustisafungus(~segfaultf@12.172.217.142) (Ping timeout: 268 seconds)
2023-03-07 00:04:43 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-03-07 00:18:23 +0100shapr(~user@68.54.166.125) (Ping timeout: 248 seconds)
2023-03-07 00:18:32 +0100ystael_(~ystael@user/ystael) (Read error: Connection reset by peer)
2023-03-07 00:20:18 +0100mechap_(~mechap@user/mechap)
2023-03-07 00:20:40 +0100ystael(~ystael@user/ystael)
2023-03-07 00:22:05 +0100codaraxis(~codaraxis@user/codaraxis)
2023-03-07 00:23:30 +0100mechap(~mechap@user/mechap) (Ping timeout: 255 seconds)
2023-03-07 00:24:24 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-03-07 00:25:28 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-03-07 00:36:04 +0100ctyjr(~ctyjr@95.107.235.112)
2023-03-07 00:38:15 +0100npm_i_kurbus(~npm_i_kur@user/kurbus) (Quit: Client closed)
2023-03-07 00:38:48 +0100phileasfogg(~phileasfo@user/phileasfogg) (Quit: "It's the only way, then they can all forget me. I got too big, Dorium, too noisy. Time to step back into the shadows.")
2023-03-07 00:39:08 +0100ctyjr(~ctyjr@95.107.235.112) (Client Quit)
2023-03-07 00:39:33 +0100ctyjr(~ctyjr@95.107.235.112)
2023-03-07 00:39:59 +0100ctyjr(~ctyjr@95.107.235.112) (Client Quit)
2023-03-07 00:43:11 +0100Albina_Pavlovna(~Albina_Pa@cpe-66-65-40-132.nyc.res.rr.com) (Quit: bb)
2023-03-07 00:44:30 +0100jmorris(uid537181@id-537181.uxbridge.irccloud.com)
2023-03-07 00:44:32 +0100gurkenglas(~gurkengla@dynamic-046-114-156-015.46.114.pool.telefonica.de) (Ping timeout: 248 seconds)
2023-03-07 00:44:40 +0100phileasfogg(~phileasfo@user/phileasfogg)
2023-03-07 00:46:42 +0100Midjak(~Midjak@82.66.147.146) (Quit: This computer has gone to sleep)
2023-03-07 00:46:48 +0100lxi(~quassel@2a02:2f08:4d1c:400:c33f:394a:2177:e1a0)
2023-03-07 00:51:34 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi)
2023-03-07 00:58:07 +0100zeenk(~zeenk@2a02:2f04:a20d:f900::7fe) (Quit: Konversation terminated!)
2023-03-07 01:07:57 +0100mauke_(~mauke@user/mauke)
2023-03-07 01:09:04 +0100mauke(~mauke@user/mauke) (Ping timeout: 248 seconds)
2023-03-07 01:09:04 +0100mauke_mauke
2023-03-07 01:12:34 +0100meinside(uid24933@id-24933.helmsley.irccloud.com)
2023-03-07 01:13:04 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-03-07 01:17:24 +0100segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-03-07 01:17:35 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 248 seconds)
2023-03-07 01:20:45 +0100son0p(~ff@181.136.122.143)
2023-03-07 01:21:10 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-07 01:22:15 +0100enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) (Quit: enoq)
2023-03-07 01:34:24 +0100TonyStone(~TonyStone@cpe-74-76-57-186.nycap.res.rr.com)
2023-03-07 01:48:11 +0100segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 248 seconds)
2023-03-07 01:50:43 +0100caryhartline(~caryhartl@cpe-76-187-114-220.tx.res.rr.com) (Quit: caryhartline)
2023-03-07 01:53:52 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds)
2023-03-07 02:06:11 +0100tusko(~yeurt@user/tusko) (Ping timeout: 255 seconds)
2023-03-07 02:08:27 +0100tusko(~yeurt@user/tusko)
2023-03-07 02:09:17 +0100TonyStone(~TonyStone@cpe-74-76-57-186.nycap.res.rr.com) (Quit: Leaving)
2023-03-07 02:10:59 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-03-07 02:14:18 +0100zaquest(~notzaques@5.130.79.72)
2023-03-07 02:16:30 +0100segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-03-07 02:16:48 +0100ix(~ix@213.205.192.69)
2023-03-07 02:17:07 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-03-07 02:18:13 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) (Quit: Leaving.)
2023-03-07 02:18:36 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-03-07 02:18:36 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-03-07 02:18:36 +0100wroathe(~wroathe@user/wroathe)
2023-03-07 02:22:51 +0100ix(~ix@213.205.192.69) (Ping timeout: 248 seconds)
2023-03-07 02:24:42 +0100 <segfaultfizzbuzz> what is ' in 'Normal here? https://github.com/awakesecurity/gRPC-haskell/blob/master/examples/echo/echo-hs/EchoServer.hs
2023-03-07 02:25:37 +0100 <geekosaur> it indicates a promoted type
2023-03-07 02:25:39 +0100 <monochrom> You can write Normal without ' in that context.
2023-03-07 02:25:48 +0100 <geekosaur> see the DataKinds extension
2023-03-07 02:25:53 +0100 <segfaultfizzbuzz> geekosaur: promoted? ok
2023-03-07 02:26:45 +0100 <monochrom> Yeah please consult the GHC user's guide on DataKinds.
2023-03-07 02:26:57 +0100 <monochrom> Better than any blog.
2023-03-07 02:35:35 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-03-07 02:36:43 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-03-07 02:40:49 +0100wroathe(~wroathe@user/wroathe) (Quit: leaving)
2023-03-07 02:41:04 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-03-07 02:41:04 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-03-07 02:41:04 +0100wroathe(~wroathe@user/wroathe)
2023-03-07 02:43:05 +0100erisco_(~erisco@d24-141-66-165.home.cgocable.net)
2023-03-07 02:44:37 +0100erisco(~erisco@d24-141-66-165.home.cgocable.net) (Ping timeout: 252 seconds)
2023-03-07 02:44:37 +0100erisco_erisco
2023-03-07 02:44:45 +0100thegeekinside(~thegeekin@189.141.115.134) (Remote host closed the connection)
2023-03-07 02:48:58 +0100vglfr(~vglfr@145.224.100.65) (Ping timeout: 252 seconds)
2023-03-07 02:51:10 +0100jle`(~jle`@cpe-23-240-75-236.socal.res.rr.com) (Ping timeout: 252 seconds)
2023-03-07 02:53:10 +0100jle`(~jle`@cpe-23-240-75-236.socal.res.rr.com)
2023-03-07 02:55:49 +0100Umeaboy(~Umeaboy@94-255-145-133.cust.bredband2.com)
2023-03-07 02:55:52 +0100 <Umeaboy> Hi!
2023-03-07 02:57:02 +0100 <Umeaboy> Is it possible to use a custom install path for ghc in the happy spec file if I've used homebrew to install ghc?
2023-03-07 02:57:33 +0100 <Umeaboy> I can't get rpmbuild to see ghc if I use the result of whereis ghc
2023-03-07 02:59:40 +0100xff0x(~xff0x@ai098135.d.east.v6connect.net) (Ping timeout: 265 seconds)
2023-03-07 03:12:01 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com)
2023-03-07 03:17:26 +0100thegeekinside(~thegeekin@189.141.115.134)
2023-03-07 03:23:30 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-03-07 03:24:42 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 268 seconds)
2023-03-07 03:24:48 +0100Lord_of_Life_Lord_of_Life
2023-03-07 03:27:19 +0100gdown(~gavin@h69-11-148-35.kndrid.broadband.dynamic.tds.net)
2023-03-07 03:29:57 +0100talismanick(~talismani@2601:200:c000:f7a0::5321)
2023-03-07 03:36:00 +0100fryguybob(~fryguybob@cpe-24-94-51-210.stny.res.rr.com) (Quit: leaving)
2023-03-07 03:38:54 +0100rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-07-174-95-68-142.dsl.bell.ca)
2023-03-07 03:42:10 +0100Umeaboy(~Umeaboy@94-255-145-133.cust.bredband2.com) (Quit: Leaving)
2023-03-07 03:43:10 +0100adanwan(~adanwan@gateway/tor-sasl/adanwan) (Quit: _)
2023-03-07 03:43:14 +0100thegeekinside(~thegeekin@189.141.115.134) (Remote host closed the connection)
2023-03-07 03:43:29 +0100adanwan(~adanwan@gateway/tor-sasl/adanwan)
2023-03-07 03:44:49 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-03-07 03:50:18 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-07 03:54:32 +0100fnurglewitz(uid263868@id-263868.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-03-07 03:56:20 +0100gmg(~user@user/gehmehgeh) (Remote host closed the connection)
2023-03-07 03:56:55 +0100ix(~ix@213.205.192.69)
2023-03-07 03:57:05 +0100gmg(~user@user/gehmehgeh)
2023-03-07 04:04:55 +0100jero98772(~jero98772@2800:484:1d80:d8ce:efcc:cbb3:7f2a:6dff) (Remote host closed the connection)
2023-03-07 04:05:58 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-03-07 04:05:58 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-03-07 04:05:58 +0100finn_elijaFinnElija
2023-03-07 04:08:14 +0100razetime(~Thunderbi@43.254.111.18)
2023-03-07 04:11:20 +0100wroathe(~wroathe@user/wroathe) (Quit: leaving)
2023-03-07 04:13:17 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-03-07 04:13:17 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-03-07 04:13:17 +0100wroathe(~wroathe@user/wroathe)
2023-03-07 04:13:59 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-03-07 04:14:02 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 268 seconds)
2023-03-07 04:19:48 +0100gastus_(~gastus@5.83.191.63)
2023-03-07 04:23:17 +0100gastus(~gastus@185.6.123.188) (Ping timeout: 268 seconds)
2023-03-07 04:23:55 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds)
2023-03-07 04:29:10 +0100TonyStone(~TonyStone@cpe-74-76-57-186.nycap.res.rr.com)
2023-03-07 04:29:35 +0100TonyStone(~TonyStone@cpe-74-76-57-186.nycap.res.rr.com) (Remote host closed the connection)
2023-03-07 04:31:18 +0100td_(~td@i53870927.versanet.de) (Ping timeout: 268 seconds)
2023-03-07 04:32:50 +0100td_(~td@i53870905.versanet.de)
2023-03-07 04:35:37 +0100rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-07-174-95-68-142.dsl.bell.ca) (Ping timeout: 268 seconds)
2023-03-07 04:42:37 +0100ix(~ix@213.205.192.69) (Read error: Connection reset by peer)
2023-03-07 04:44:39 +0100[_](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-03-07 04:45:17 +0100cassaundra(~cassaundr@user/cassaundra) (Quit: leaving)
2023-03-07 04:47:53 +0100ix(~ix@213.205.192.69)
2023-03-07 04:49:51 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 248 seconds)
2023-03-07 04:51:44 +0100cassaundra(~cassaundr@c-73-25-18-25.hsd1.or.comcast.net)
2023-03-07 04:51:45 +0100cassaundra(~cassaundr@c-73-25-18-25.hsd1.or.comcast.net) (Client Quit)
2023-03-07 04:52:32 +0100cheater(~Username@user/cheater)
2023-03-07 04:56:38 +0100cassaundra(~cassaundr@c-73-25-18-25.hsd1.or.comcast.net)
2023-03-07 04:56:38 +0100cassaundra(~cassaundr@c-73-25-18-25.hsd1.or.comcast.net) (Client Quit)
2023-03-07 04:57:13 +0100gdown(~gavin@h69-11-148-35.kndrid.broadband.dynamic.tds.net) (Remote host closed the connection)
2023-03-07 04:59:16 +0100notzmv(~zmv@user/notzmv)
2023-03-07 05:05:33 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-03-07 05:05:58 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-03-07 05:11:05 +0100_xor(~xor@72.49.195.228)
2023-03-07 05:16:05 +0100npm_i_kurbus(~npm_i_kur@user/kurbus)
2023-03-07 05:20:13 +0100mbuf(~Shakthi@49.207.178.186)
2023-03-07 05:21:54 +0100cassaundra(~cassaundr@user/cassaundra)
2023-03-07 05:22:22 +0100segfaultfizzbuzz(~segfaultf@12.172.217.142) (Quit: segfaultfizzbuzz)
2023-03-07 05:22:22 +0100meinside(uid24933@id-24933.helmsley.irccloud.com) (Quit: Connection closed for inactivity)
2023-03-07 05:22:39 +0100cassaundra(~cassaundr@user/cassaundra) (Client Quit)
2023-03-07 05:27:25 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 252 seconds)
2023-03-07 05:31:11 +0100cassiopea(~cassiopea@user/cassiopea)
2023-03-07 05:42:07 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 248 seconds)
2023-03-07 05:47:59 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 248 seconds)
2023-03-07 05:51:38 +0100rettahcay(~kaushikv@223.178.86.127)
2023-03-07 05:52:01 +0100rettahcay(~kaushikv@223.178.86.127) ()
2023-03-07 05:54:24 +0100polyphem_(~rod@2a02:810d:840:8754:224e:f6ff:fe5e:bc17) (Ping timeout: 248 seconds)
2023-03-07 05:57:20 +0100thegeekinside(~thegeekin@189.141.115.134)
2023-03-07 05:57:47 +0100ix(~ix@213.205.192.69) (Ping timeout: 248 seconds)
2023-03-07 06:10:35 +0100lbseale(~quassel@user/ep1ctetus) (Ping timeout: 268 seconds)
2023-03-07 06:11:22 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-03-07 06:14:18 +0100jmorris(uid537181@id-537181.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-03-07 06:18:36 +0100razetime(~Thunderbi@43.254.111.18) (Ping timeout: 268 seconds)
2023-03-07 06:20:20 +0100npm_i_kurbus(~npm_i_kur@user/kurbus) (Quit: Client closed)
2023-03-07 06:20:35 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-07 06:31:02 +0100razetime(~Thunderbi@43.254.111.18)
2023-03-07 06:32:30 +0100npm_i_kurbus(~npm_i_kur@user/kurbus)
2023-03-07 06:34:54 +0100jwiegley(~jwiegley@76-234-69-149.lightspeed.frokca.sbcglobal.net) (Quit: ZNC - http://znc.in)
2023-03-07 06:34:54 +0100johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net) (Quit: ZNC - http://znc.in)
2023-03-07 06:38:15 +0100freeside(~mengwong@103.252.202.85) (Ping timeout: 260 seconds)
2023-03-07 06:41:15 +0100freeside(~mengwong@103.252.202.85)
2023-03-07 06:42:13 +0100Square2(~Square4@user/square)
2023-03-07 06:42:59 +0100ix(~ix@213.205.192.69)
2023-03-07 06:55:23 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds)
2023-03-07 06:58:23 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com)
2023-03-07 07:01:04 +0100npm_i_kurbus(~npm_i_kur@user/kurbus) (Quit: Client closed)
2023-03-07 07:03:36 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-03-07 07:04:09 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com)
2023-03-07 07:11:23 +0100kenran(~user@user/kenran)
2023-03-07 07:12:42 +0100kenran(~user@user/kenran) (Remote host closed the connection)
2023-03-07 07:13:44 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-03-07 07:16:00 +0100razetime(~Thunderbi@43.254.111.18) (Ping timeout: 248 seconds)
2023-03-07 07:18:39 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Ping timeout: 248 seconds)
2023-03-07 07:26:45 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67)
2023-03-07 07:29:05 +0100trev(~trev@user/trev)
2023-03-07 07:38:16 +0100rettahcay(~kaushikv@223.178.86.127)
2023-03-07 07:38:46 +0100cheater_(~Username@user/cheater)
2023-03-07 07:40:59 +0100johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net)
2023-03-07 07:41:29 +0100jwiegley(~jwiegley@76-234-69-149.lightspeed.frokca.sbcglobal.net)
2023-03-07 07:41:37 +0100cheater(~Username@user/cheater) (Ping timeout: 252 seconds)
2023-03-07 07:41:41 +0100cheater_cheater
2023-03-07 07:52:29 +0100notzmv(~zmv@user/notzmv)
2023-03-07 07:54:24 +0100rettahcay(~kaushikv@223.178.86.127) ()
2023-03-07 07:55:07 +0100thegeekinside(~thegeekin@189.141.115.134) (Ping timeout: 248 seconds)
2023-03-07 07:59:11 +0100shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 248 seconds)
2023-03-07 07:59:22 +0100michalz(~michalz@185.246.204.126)
2023-03-07 08:08:27 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 248 seconds)
2023-03-07 08:10:37 +0100notzmv(~zmv@user/notzmv)
2023-03-07 08:10:54 +0100jakalx(~jakalx@base.jakalx.net) ()
2023-03-07 08:17:10 +0100bliminse(~bliminse@user/bliminse) (Quit: leaving)
2023-03-07 08:20:03 +0100jakalx(~jakalx@base.jakalx.net)
2023-03-07 08:21:15 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-03-07 08:24:52 +0100cheater_(~Username@user/cheater)
2023-03-07 08:26:35 +0100cheater(~Username@user/cheater) (Ping timeout: 248 seconds)
2023-03-07 08:26:38 +0100cheater_cheater
2023-03-07 08:31:33 +0100razetime(~Thunderbi@117.193.1.99)
2023-03-07 08:36:07 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:cdff:bbec:88eb:b8a)
2023-03-07 08:37:52 +0100Square3(~Square4@user/square)
2023-03-07 08:39:44 +0100Square2(~Square4@user/square) (Ping timeout: 248 seconds)
2023-03-07 08:48:30 +0100bliminse(~bliminse@user/bliminse)
2023-03-07 08:50:19 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67) (Quit: Leaving)
2023-03-07 08:50:45 +0100monochrom(trebla@216.138.220.146) (Ping timeout: 255 seconds)
2023-03-07 08:51:13 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-07 08:54:13 +0100mncheck(~mncheck@193.224.205.254)
2023-03-07 08:55:55 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds)
2023-03-07 08:56:46 +0100meinside(uid24933@id-24933.helmsley.irccloud.com)
2023-03-07 08:57:47 +0100monochrom(trebla@216.138.220.146)
2023-03-07 08:59:57 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-03-07 09:02:14 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-03-07 09:06:48 +0100MajorBiscuit(~MajorBisc@2001:1c00:2408:a400:67e:5371:52a7:9b9a)
2023-03-07 09:09:32 +0100hugo-(znc@verdigris.lysator.liu.se) (Ping timeout: 255 seconds)
2023-03-07 09:12:59 +0100MajorBiscuit(~MajorBisc@2001:1c00:2408:a400:67e:5371:52a7:9b9a) (Ping timeout: 248 seconds)
2023-03-07 09:13:21 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-03-07 09:14:38 +0100codaraxis__(~codaraxis@user/codaraxis)
2023-03-07 09:14:38 +0100lottaquestions(~nick@2607:fa49:503e:7100:29d5:6a23:249a:7ab4) (Remote host closed the connection)
2023-03-07 09:15:01 +0100MajorBiscuit(~MajorBisc@c-001-030-044.client.tudelft.eduvpn.nl)
2023-03-07 09:15:04 +0100lottaquestions(~nick@2607:fa49:503e:7100:dbe0:8110:91f3:4f25)
2023-03-07 09:15:08 +0100hugo(znc@verdigris.lysator.liu.se)
2023-03-07 09:16:05 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-03-07 09:17:48 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-03-07 09:18:08 +0100codaraxis(~codaraxis@user/codaraxis) (Ping timeout: 248 seconds)
2023-03-07 09:19:58 +0100ft(~ft@p3e9bc443.dip0.t-ipconnect.de) (Quit: leaving)
2023-03-07 09:30:40 +0100ubert1(~Thunderbi@p200300ecdf0c57b39b0cedad49907c5f.dip0.t-ipconnect.de)
2023-03-07 09:30:41 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-07 09:33:48 +0100Midjak(~Midjak@82.66.147.146)
2023-03-07 09:37:04 +0100 <Philonous> I'm trying to write a bug report for the network package, but I'd like to figure out some details to include, where would be a good place to ask Linux network API related questions?
2023-03-07 09:38:21 +0100hugo(znc@verdigris.lysator.liu.se) (Ping timeout: 256 seconds)
2023-03-07 09:38:43 +0100vglfr(~vglfr@145.224.100.65)
2023-03-07 09:43:24 +0100gurkenglas(~gurkengla@dynamic-046-114-156-015.46.114.pool.telefonica.de)
2023-03-07 09:46:12 +0100Inst(~Inst@2601:6c4:4081:54f0:a86f:4b5c:43f7:99bc)
2023-03-07 09:46:22 +0100 <Inst> I don't get why there's not more people talking about Streamly, it's a great fucking library
2023-03-07 09:46:31 +0100 <Inst> 67% of C performance
2023-03-07 09:46:46 +0100 <Inst> let me reboot and trial on debian instead of WSL, might be able to get better performance that way
2023-03-07 09:48:42 +0100Inst(~Inst@2601:6c4:4081:54f0:a86f:4b5c:43f7:99bc) (Read error: Connection reset by peer)
2023-03-07 09:49:29 +0100hugo(znc@verdigris.lysator.liu.se)
2023-03-07 09:50:00 +0100cfricke(~cfricke@user/cfricke)
2023-03-07 09:57:47 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-03-07 10:02:42 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:ed80:eb1e:1340:95af)
2023-03-07 10:07:05 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:ed80:eb1e:1340:95af) (Ping timeout: 260 seconds)
2023-03-07 10:14:03 +0100razetime(~Thunderbi@117.193.1.99) (Quit: See You Space Cowboy)
2023-03-07 10:17:23 +0100cheater_(~Username@user/cheater)
2023-03-07 10:19:28 +0100cheater(~Username@user/cheater) (Ping timeout: 248 seconds)
2023-03-07 10:19:38 +0100cheater_cheater
2023-03-07 10:28:06 +0100chomwitt(~chomwitt@2a02:587:7a18:6d00:1ac0:4dff:fedb:a3f1)
2023-03-07 10:28:40 +0100Eihel(~Eihel@wikipedia/eihel)
2023-03-07 10:29:30 +0100Eihel(~Eihel@wikipedia/eihel) ()
2023-03-07 10:31:22 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-03-07 10:31:55 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds)
2023-03-07 10:32:26 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-03-07 10:34:56 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2023-03-07 10:37:47 +0100ix(~ix@213.205.192.69) (Ping timeout: 248 seconds)
2023-03-07 10:39:23 +0100gurkenglas(~gurkengla@dynamic-046-114-156-015.46.114.pool.telefonica.de) (Ping timeout: 248 seconds)
2023-03-07 10:40:38 +0100ix(~ix@213.205.192.69)
2023-03-07 10:46:18 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-07 11:03:54 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559)
2023-03-07 11:06:42 +0100mncheck(~mncheck@193.224.205.254) (Remote host closed the connection)
2023-03-07 11:08:25 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559) (Ping timeout: 252 seconds)
2023-03-07 11:12:16 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 248 seconds)
2023-03-07 11:12:59 +0100cheater(~Username@user/cheater) (Ping timeout: 248 seconds)
2023-03-07 11:20:15 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 248 seconds)
2023-03-07 11:22:16 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-03-07 11:22:20 +0100codaraxis__(~codaraxis@user/codaraxis) (Quit: Leaving)
2023-03-07 11:32:44 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-03-07 11:35:41 +0100ix(~ix@213.205.192.69) (Read error: Connection reset by peer)
2023-03-07 11:35:49 +0100Inst(~Inst@2601:6c4:4081:54f0:c4dc:214a:b41a:859d)
2023-03-07 11:35:51 +0100 <Inst> ugh
2023-03-07 11:36:24 +0100 <Inst> streamly is great and all, but i rebuilt as per settings, and their WC is still 33% slower than wc
2023-03-07 11:39:06 +0100jumper149(~jumper149@base.felixspringer.xyz)
2023-03-07 11:41:05 +0100ix(~ix@213.205.192.69)
2023-03-07 11:41:46 +0100 <jumper149> Are there two different `(->)`s? Because if I ask ghci, it tells me `:k (->)` is `Type -> Type -> Type`. But kind signatures disagree with this. For example `:k Const` is `Type -> k -> Type` and also `:k Eq` is `Type -> Constraint`. `k` and `Constraints` are clearly not `Type`, right?
2023-03-07 11:42:52 +0100 <merijn> jumper149: Yes
2023-03-07 11:43:08 +0100 <merijn> There is "->" at the type level and "->" at the kind level
2023-03-07 11:43:27 +0100 <merijn> Although, I suppose GHC now also has TypeInType lunacy making them "the same but different"
2023-03-07 11:43:39 +0100 <jumper149> merijn: So `->` at kind level would have kind `a -> b -> c` then, I guess?
2023-03-07 11:44:22 +0100evanmeek(~user@91.217.139.207)
2023-03-07 11:44:49 +0100 <merijn> jumper149: Where 'a, b, and c' are some kind with sort BOX, yes :p
2023-03-07 11:45:05 +0100 <merijn> Unless you believe in TypeInType heresy, then I dunno what it should be
2023-03-07 11:45:14 +0100the_proffesor(~theproffe@user/theproffesor) (Ping timeout: 255 seconds)
2023-03-07 11:47:44 +0100 <jumper149> I'm not sure, what "sort" and "BOX" are. Afaiu: Values have types, while types have kinds and kinds have kinds. Is that not correct?
2023-03-07 11:48:07 +0100 <jumper149> Compared to dependent types where: Values have types and types have types.
2023-03-07 11:51:10 +0100 <tomsmeding> rather, in dependent types, values have types, types have kinds, kinds have sorts, sorts have ... : an infinite stack
2023-03-07 11:51:17 +0100 <tomsmeding> in sound dependent types, that is
2023-03-07 11:51:53 +0100 <tomsmeding> in GHC haskell with TypeInType (which has been the case since ghc 6 or so), values have types, and types have types: the stack stops one level earlier
2023-03-07 11:52:09 +0100 <tomsmeding> but in practice it's very useful to distinguish between types and kinds, yielding what you wrote
2023-03-07 11:52:23 +0100 <tomsmeding> % :k Type
2023-03-07 11:52:23 +0100 <yahb2> <interactive>:1:1: error: ; Not in scope: type constructor or class ‘Type’
2023-03-07 11:52:26 +0100 <tomsmeding> % :k Data.Kind.Type
2023-03-07 11:52:26 +0100 <yahb2> Data.Kind.Type :: *
2023-03-07 11:52:33 +0100 <tomsmeding> % :set -XNoStarIsType
2023-03-07 11:52:33 +0100 <yahb2> <no output>
2023-03-07 11:52:35 +0100 <tomsmeding> % :k Data.Kind.Type
2023-03-07 11:52:35 +0100 <yahb2> Data.Kind.Type :: Type
2023-03-07 11:52:43 +0100cheater(~Username@user/cheater)
2023-03-07 11:53:35 +0100 <merijn> jumper149: In the "classical" type theory GHC are based on, the values have types, types have kinds, and kinds have sorts (and the only existing sort within GHC was BOX, so every kind has sort BOX)
2023-03-07 11:53:41 +0100 <merijn> tomsmeding: TypeInType is 8.x
2023-03-07 11:53:50 +0100 <tomsmeding> ah
2023-03-07 11:53:55 +0100 <tomsmeding> what happened before
2023-03-07 11:54:01 +0100 <Inst> now types trigger russell's paradox
2023-03-07 11:54:04 +0100 <merijn> GHC 6 was, like, over a decade ago
2023-03-07 11:54:17 +0100 <tomsmeding> was type-level ghc haskell just not expressive enough to observe the equality of sorts and kinds or something?
2023-03-07 11:54:19 +0100 <merijn> Although I guess TypeInType is also a few years old by now
2023-03-07 11:54:31 +0100 <tomsmeding> because I find it unlikely that ghc had a full infinite universe stack
2023-03-07 11:54:32 +0100 <merijn> tomsmeding: There was no other sort thatn BOX
2023-03-07 11:54:49 +0100 <Inst> was there datakinds at the time?
2023-03-07 11:55:02 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2023-03-07 11:55:09 +0100 <tomsmeding> datakinds is since 7.4.1 according to the ghc user guide
2023-03-07 11:55:22 +0100 <merijn> DataKinds isn't really affected by this
2023-03-07 11:55:55 +0100 <Inst> you'd imagine that with user-definable types and kinds, you'd naturally end up with sorts
2023-03-07 11:55:56 +0100cheater_(~Username@user/cheater)
2023-03-07 11:56:05 +0100 <Inst> also, does MVar or TVar go better with streamly?
2023-03-07 11:56:33 +0100 <merijn> Inst: Why would you naturally end up with sorts?
2023-03-07 11:56:50 +0100 <merijn> GHC has never been able to represent kinds not in BOX, so you couldn't write them anyway
2023-03-07 11:56:58 +0100 <Inst> well, probably datakinds isn't powerful enough, but you might be interested in giving...
2023-03-07 11:56:59 +0100 <Inst> ah
2023-03-07 11:57:55 +0100cheater(~Username@user/cheater) (Ping timeout: 260 seconds)
2023-03-07 11:57:58 +0100cheater__(~Username@user/cheater)
2023-03-07 11:57:59 +0100cheater__cheater
2023-03-07 11:59:43 +0100evanmeek(~user@91.217.139.207) (Remote host closed the connection)
2023-03-07 12:00:44 +0100 <jumper149> tomsmeding: Isn't there a problem with the infinite stack for dependent types? What type/kind/sort does `(->)` have here.
2023-03-07 12:00:59 +0100cheater_(~Username@user/cheater) (Ping timeout: 248 seconds)
2023-03-07 12:02:17 +0100 <tomsmeding> jumper149: in dependent types?
2023-03-07 12:02:21 +0100 <jumper149> Yes
2023-03-07 12:03:39 +0100 <tomsmeding> in Agda, (->) is a special thing https://agda.readthedocs.io/en/v2.6.3/language/function-types.html
2023-03-07 12:03:40 +0100 <jumper149> Maybe that question doesn't make sense, but intuitively I would have said "the type of `(->)` is `Type -> Type -> Type`"
2023-03-07 12:04:27 +0100 <jumper149> I have mostly experience with Idris, where I actually think "types have types" is true. There was some note about unsoundness somewhere.
2023-03-07 12:06:29 +0100 <ncf> idris, like agda, has an infinite hierarchy of universes
2023-03-07 12:06:47 +0100xff0x(~xff0x@2405:6580:b080:900:c9db:48d9:400c:36fe)
2023-03-07 12:07:03 +0100 <jumper149> https://idris2.readthedocs.io/en/latest/faq/faq.html#does-idris-have-universe-polymorphism-what-is…
2023-03-07 12:07:08 +0100 <tomsmeding> can't find the definition of (->) or pi-types or similar for idris in 2mins of casual searching
2023-03-07 12:08:35 +0100 <tomsmeding> and I'm not sure asking for "the type of Π" makes sense in such a system
2023-03-07 12:09:10 +0100 <tomsmeding> like you have to go outside of a logical system to prove that system's soundness, usually
2023-03-07 12:09:42 +0100 <jumper149> tomsmeding: I'm not sure either.
2023-03-07 12:09:59 +0100 <jumper149> Is it even possible to prove "soundness" for something like Idris or Agda?
2023-03-07 12:10:15 +0100 <tomsmeding> a non-dependent function arrow would be typeable, though: (->) : forall (n m : Level). forall (a : Set n). forall (b : Set m). a -> b -> Set (max n m)
2023-03-07 12:10:17 +0100 <tomsmeding> or something
2023-03-07 12:10:20 +0100 <tomsmeding> probably got that wrong
2023-03-07 12:10:26 +0100 <tomsmeding> also that definition uses (->) itself, so what gives?
2023-03-07 12:10:46 +0100 <tomsmeding> jumper149: would that not be the soundness of type theory, basically?
2023-03-07 12:11:06 +0100 <tomsmeding> which is just a logic
2023-03-07 12:11:23 +0100 <jumper149> tomsmeding: That violates the 2nd incompleteness theorem, doesn't it?
2023-03-07 12:11:23 +0100 <tomsmeding> asking for the soundness of that is similar to asking for the soundness of ZF set theory or something
2023-03-07 12:12:21 +0100 <tomsmeding> jumper149: that's what I was referring to, yeah -- proving the soundness of the system within itself is not possible
2023-03-07 12:12:34 +0100 <tomsmeding> not quite the same as giving types to things though
2023-03-07 12:13:22 +0100 <ncf> tomsmeding: that would be (->) : Set n -> Set m -> Set (max n m)
2023-03-07 12:13:34 +0100 <tomsmeding> eliding the foralls, yes
2023-03-07 12:13:41 +0100 <tomsmeding> oh no
2023-03-07 12:13:45 +0100 <ncf> no, what you wrote is different
2023-03-07 12:13:47 +0100 <tomsmeding> it is
2023-03-07 12:13:59 +0100 <tomsmeding> yeah you're right
2023-03-07 12:14:12 +0100 <jumper149> (a : Set n) -> (b : Set m) -> (c : Set (max n m)0
2023-03-07 12:14:25 +0100 <tomsmeding> can't bind the result to a name :p
2023-03-07 12:14:28 +0100 <tomsmeding> but yes
2023-03-07 12:14:49 +0100 <jumper149> Syntax issue :D
2023-03-07 12:15:29 +0100 <ncf> Π could also be given a type: Π : (A : Set n) → (B : A → Set m) → Set (max n m)
2023-03-07 12:15:49 +0100 <tomsmeding> hm yeah
2023-03-07 12:16:01 +0100 <tomsmeding> with the same issue that you're now using Π in the type of Π
2023-03-07 12:16:04 +0100 <ncf> of course, usually Π is taken as primitive so that does not literally make sense, but you can always ask for the type of λ A B. Π A B
2023-03-07 12:16:32 +0100 <jumper149> tomsmeding: A recursive definition would still be a definition though, right?
2023-03-07 12:16:57 +0100 <tomsmeding> I... guess? Though in most systems, the type of a thing cannot contain that thing itself :p
2023-03-07 12:17:05 +0100 <tomsmeding> that gives paradoxes very quickly I think
2023-03-07 12:17:16 +0100ccapndave(~ccapndave@xcpe-62-167-164-99.cgn.res.adslplus.ch)
2023-03-07 12:17:17 +0100 <tomsmeding> % data A (a :: A ()) = MkA
2023-03-07 12:17:17 +0100 <yahb2> <interactive>:26:16: error: ; Illegal kind: ‘()’ Perhaps you intended to use DataKinds
2023-03-07 12:17:25 +0100 <tomsmeding> % :set -XDataKinds -XKindSignatures
2023-03-07 12:17:25 +0100 <yahb2> <no output>
2023-03-07 12:17:28 +0100 <tomsmeding> % data A (a :: A ()) = MkA
2023-03-07 12:17:28 +0100 <yahb2> <interactive>:30:14: error: ; • Type constructor ‘A’ cannot be used here ; (it is defined and used in the same recursive group) ; • In the kind ‘A ()’ ; In the data type decla...
2023-03-07 12:17:47 +0100 <tomsmeding> not that haskell is sounds as a proof system anyway
2023-03-07 12:17:50 +0100 <tomsmeding> *sound
2023-03-07 12:18:21 +0100 <jumper149> ... bringing us back to russels paradox I guess
2023-03-07 12:18:46 +0100 <ncf> maybe a better way to see this would be to define Π_n, the Π type former for the universe level n. then you'd have Π_n : (A : Set n) → (B : A → Set n) → Set n, where the Π's involved in that type are Π_(n+1)
2023-03-07 12:18:57 +0100 <ncf> so there's no actual recursion, more of a "microcosm principle"
2023-03-07 12:19:18 +0100 <tomsmeding> you'd want to allow either A or B to yield something smaller than n though
2023-03-07 12:19:36 +0100 <ncf> you can always lift values from Set n to Set m provided n <= m
2023-03-07 12:19:50 +0100 <tomsmeding> agda doesn't like that I believe, but yes with some handwaving in any case
2023-03-07 12:20:02 +0100 <tomsmeding> iirc idris has that as an axiom indeed
2023-03-07 12:21:04 +0100 <ncf> there's a --cumulativity flag, but even without it you can do things like https://agda.github.io/agda-stdlib/Level.html
2023-03-07 12:22:26 +0100 <tomsmeding> TIL
2023-03-07 12:24:13 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-03-07 12:24:29 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-03-07 12:24:31 +0100 <tomsmeding> (for lurkers: https://agda.readthedocs.io/en/v2.6.3/language/cumulativity.html )
2023-03-07 12:26:09 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-03-07 12:26:42 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-03-07 12:27:29 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-03-07 12:32:03 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-03-07 12:34:22 +0100cheater(~Username@user/cheater) (Read error: Connection reset by peer)
2023-03-07 12:35:08 +0100cheater(~Username@user/cheater)
2023-03-07 12:36:11 +0100xff0x(~xff0x@2405:6580:b080:900:c9db:48d9:400c:36fe) (Ping timeout: 248 seconds)
2023-03-07 12:36:37 +0100cfricke(~cfricke@user/cfricke) (Ping timeout: 268 seconds)
2023-03-07 12:38:02 +0100xff0x(~xff0x@ai098135.d.east.v6connect.net)
2023-03-07 12:42:41 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-03-07 12:51:21 +0100Square2(~Square4@user/square)
2023-03-07 12:52:30 +0100__monty__(~toonn@user/toonn)
2023-03-07 12:53:51 +0100Square3(~Square4@user/square) (Ping timeout: 256 seconds)
2023-03-07 12:54:37 +0100pikipiki(~pikipiki@2a00:8a60:c000:1:3c66:5b32:c285:a7b7)
2023-03-07 13:01:24 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-03-07 13:05:29 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559)
2023-03-07 13:06:34 +0100meinside(uid24933@id-24933.helmsley.irccloud.com) (Quit: Connection closed for inactivity)
2023-03-07 13:06:35 +0100pikipiki(~pikipiki@2a00:8a60:c000:1:3c66:5b32:c285:a7b7) (Read error: Connection reset by peer)
2023-03-07 13:07:20 +0100zephyr__(~irfan@182.69.86.253)
2023-03-07 13:08:04 +0100pikipiki(~pikipiki@2a00:8a60:c000:1:3c66:5b32:c285:a7b7)
2023-03-07 13:10:15 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559) (Ping timeout: 260 seconds)
2023-03-07 13:10:15 +0100pikipiki(~pikipiki@2a00:8a60:c000:1:3c66:5b32:c285:a7b7) (Read error: Connection reset by peer)
2023-03-07 13:11:08 +0100pikipiki(~pikipiki@2a00:8a60:c000:1:3c66:5b32:c285:a7b7)
2023-03-07 13:13:31 +0100pikipiki(~pikipiki@2a00:8a60:c000:1:3c66:5b32:c285:a7b7) (Read error: Connection reset by peer)
2023-03-07 13:13:50 +0100pikipiki(~pikipiki@dynamic-046-114-105-147.46.114.pool.telefonica.de)
2023-03-07 13:13:52 +0100pikipiki(~pikipiki@dynamic-046-114-105-147.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-03-07 13:13:59 +0100pikipiki(~pikipiki@2a00:8a60:c000:1:3c66:5b32:c285:a7b7)
2023-03-07 13:17:36 +0100Inst_(~Inst@2601:6c4:4081:54f0:4d94:d8d8:7d2b:a18e)
2023-03-07 13:18:42 +0100cfricke(~cfricke@user/cfricke)
2023-03-07 13:19:10 +0100ccapndave(~ccapndave@xcpe-62-167-164-99.cgn.res.adslplus.ch) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-03-07 13:21:31 +0100Inst(~Inst@2601:6c4:4081:54f0:c4dc:214a:b41a:859d) (Ping timeout: 248 seconds)
2023-03-07 13:22:30 +0100Inst_(~Inst@2601:6c4:4081:54f0:4d94:d8d8:7d2b:a18e) (Ping timeout: 260 seconds)
2023-03-07 13:25:19 +0100ccapndave(~ccapndave@xcpe-62-167-164-99.cgn.res.adslplus.ch)
2023-03-07 13:27:42 +0100pikipiki(~pikipiki@2a00:8a60:c000:1:3c66:5b32:c285:a7b7) (Quit: Quit)
2023-03-07 13:27:55 +0100zephyr__(~irfan@182.69.86.253) (Quit: leaving)
2023-03-07 13:28:43 +0100npm_i_kurbus(~npm_i_kur@user/kurbus)
2023-03-07 13:29:27 +0100lyle(~lyle@104.246.145.237)
2023-03-07 13:34:39 +0100mechap(~mechap@user/mechap)
2023-03-07 13:37:52 +0100mechap_(~mechap@user/mechap) (Ping timeout: 248 seconds)
2023-03-07 13:45:57 +0100ix(~ix@213.205.192.69) (Ping timeout: 255 seconds)
2023-03-07 13:53:35 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 255 seconds)
2023-03-07 13:54:25 +0100Inst(~Inst@2601:6c4:4081:54f0:a1f8:4ef8:3abb:c29)
2023-03-07 13:54:35 +0100 <Inst> also
2023-03-07 13:54:47 +0100 <Inst> why does the :: Eq a => [a] -> a exist?
2023-03-07 13:55:09 +0100 <Inst> https://hackage.haskell.org/package/base-4.18.0.0/docs/GHC-Exts.html#v:the
2023-03-07 13:56:07 +0100 <hellwolf[m]> ^^
2023-03-07 13:56:08 +0100 <sm> yes Guest31, it's a useful prototyping/pseudo-code/type-annotating language
2023-03-07 13:56:10 +0100 <Clinton[m]> Using servant, I've got a type like the following, but more complex:... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/f957189b01a55c43ed3532ac48be10aee38f…>)
2023-03-07 13:56:10 +0100 <jean-paul[m]> alloca() in C might overflow the stack. Can the alloca functions in Foreign.Marshal.Alloc? From the docs it sounds like no, but only by implication, not explicit statement.
2023-03-07 13:56:10 +0100 <Jade[m]1> ¯\_(ツ)_/¯ might have some use-cases
2023-03-07 13:57:22 +0100 <Jade[m]1> could imagine something like the . map (rem 2)
2023-03-07 13:57:46 +0100 <Jade[m]1> * could imagine something like the . map (`rem` 2)
2023-03-07 13:58:15 +0100 <Jade[m]1> But it does seem bad because it's partial
2023-03-07 13:58:17 +0100 <Jade[m]1> s/partial/not total/
2023-03-07 13:58:43 +0100 <Jade[m]1> would have preferred something like `(Eq a, Foldable t) => t a -> Maybe a`
2023-03-07 14:00:05 +0100 <fbytez> Whats the difference between `pure` and `return`?
2023-03-07 14:00:51 +0100 <int-e> history, `return` was there first
2023-03-07 14:01:25 +0100 <fbytez> So they can be used interchangeably?
2023-03-07 14:01:31 +0100 <merijn> fbytez: For lawful instances of pure/monad there should be no difference, yes
2023-03-07 14:01:40 +0100 <merijn> applicative/monad, I mean
2023-03-07 14:01:52 +0100 <int-e> `return` lives in the Monad class; `pure` lives in Applicative. First there was only Monad, then for some time, both classes existed side by side; now Applicative is a superclass of Monad and pure = return is one of the laws involved in that.
2023-03-07 14:04:55 +0100 <fbytez> So, Applicative is like a "superset" of Monad in which `pure` can be used but `return` can not?
2023-03-07 14:04:55 +0100 <Jade[m]1> always use pure over return - the latter is deprecated and should be implemented like return = pure
2023-03-07 14:05:53 +0100 <fbytez> I think 'pure' is a nicer word to use, given the meaning of 'return' in most other languages.
2023-03-07 14:05:57 +0100 <Jade[m]1> it's a supercöass
2023-03-07 14:06:03 +0100 <Jade[m]1> * it's a superclass
2023-03-07 14:06:20 +0100 <Jade[m]1> and yes
2023-03-07 14:06:51 +0100 <merijn> fbytez: For some interpretations of superset, Applicative is a superset of Monad, yes
2023-03-07 14:07:30 +0100 <merijn> (there's two perspectives, the operations allowed by Monad are a superset of those allowed by Applicative, but "things that are Applicative" is a superset of "things that are Monad")
2023-03-07 14:07:36 +0100 <fbytez> I said 'superset' for my own clarity as I'm very new and am uncertain about type classes.
2023-03-07 14:08:20 +0100 <merijn> fbytez: Just meaning you can think in terms of "sub-/superset of operations" and "sub-/superset of things that are instances" and those have inverted answers ;)
2023-03-07 14:09:10 +0100 <fbytez> Yes, right, that's very clear. Thanks.
2023-03-07 14:12:12 +0100vglfr(~vglfr@145.224.100.65) (Ping timeout: 268 seconds)
2023-03-07 14:12:44 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-03-07 14:13:31 +0100vglfr(~vglfr@145.224.100.240)
2023-03-07 14:18:45 +0100npm_i_kurbus(~npm_i_kur@user/kurbus) (Quit: Client closed)
2023-03-07 14:18:53 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-03-07 14:19:25 +0100L29Ah(~L29Ah@wikipedia/L29Ah) ()
2023-03-07 14:19:30 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-03-07 14:20:11 +0100 <fbytez> Would it be fair to consider Haskell "safer" than Rust due to it's runtime and IO Monad?
2023-03-07 14:20:39 +0100L29Ah(~L29Ah@wikipedia/L29Ah)
2023-03-07 14:20:46 +0100 <fbytez> Perhaps it's age too.
2023-03-07 14:21:15 +0100 <fbytez> s/it's/its/g
2023-03-07 14:23:18 +0100 <int-e> nah
2023-03-07 14:28:11 +0100 <fbytez> Why so? On par? Worse?
2023-03-07 14:31:12 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-03-07 14:31:36 +0100gurkenglas(~gurkengla@dynamic-046-114-176-216.46.114.pool.telefonica.de)
2023-03-07 14:33:31 +0100fnurglewitz(uid263868@id-263868.lymington.irccloud.com)
2023-03-07 14:38:51 +0100 <Cale> Haskell code that's allowed to use IO can do basically anything. There might be some reason to consider it safer overall, but those aren't exactly reasons on their own.
2023-03-07 14:41:33 +0100 <merijn> Hold on
2023-03-07 14:41:41 +0100 <merijn> all these answers are nonsensical
2023-03-07 14:41:49 +0100 <merijn> because you have not defined "safe"/"safer"
2023-03-07 14:41:59 +0100 <Cale> Yeah, also true.
2023-03-07 14:42:08 +0100 <merijn> Things are safe *with respect to some model of faults/correctness*
2023-03-07 14:42:26 +0100 <merijn> It's why type safe is so misused by many people
2023-03-07 14:42:42 +0100 <Cale> But even without getting into the details of what we mean, older languages are not generally speaking "safer" for any reasonable definition of the word.
2023-03-07 14:42:46 +0100 <mauke> the "monad" part is irrelevant. IO is safe (or not) regardless of whether it implements the Monad interface
2023-03-07 14:42:47 +0100 <merijn> "type-safety" = "well-typed code can't go wrong...with respect to our language's safety model"
2023-03-07 14:43:08 +0100 <Cale> There might be some libraries one would trust more for being battle-tested, but the relative rarity of Haskell users counterbalances that a good bit. Though, when it comes to Rust specifically, it's hard to say. I wouldn't fully trust crypto libraries written in either language.
2023-03-07 14:43:10 +0100 <mauke> also, I can segfault in Haskell, so :shrug:
2023-03-07 14:43:18 +0100 <merijn> Cale: I mean, Rust is also allowed to do anything, so
2023-03-07 14:43:26 +0100 <Cale> merijn: Of course
2023-03-07 14:43:44 +0100jero98772(~jero98772@2800:484:1d80:d8ce:efcc:cbb3:7f2a:6dff)
2023-03-07 14:43:56 +0100 <merijn> I would say neither is really considerably safer than the other
2023-03-07 14:43:59 +0100 <Cale> The provided reasons were "its runtime", "IO monad" and "age".
2023-03-07 14:44:25 +0100 <Cale> Some Haskell code might be safer than Rust code for *avoiding* use of the IO monad.
2023-03-07 14:45:04 +0100 <dminuoso> 14:43:08 Cale | There might be some libraries one would trust more for being battle-tested, but the relative rarity of Haskell users counterbalances that a good bit. Though, when it comes to Rust specifically, it's hard to say. I wouldn't fully trust crypto libraries written in either language.
2023-03-07 14:45:05 +0100 <mauke> (none of those prevent me from casting a random number to a pointer and writing to arbitrary memory)
2023-03-07 14:45:27 +0100 <dminuoso> Cale: I think there's a misconception in that statement. Being memory safe does not imply you can trust a crypto library.
2023-03-07 14:45:52 +0100 <Cale> dminuoso: I wasn't implying that
2023-03-07 14:45:56 +0100 <fbytez> mauke, in Haskell? You can do that?
2023-03-07 14:46:01 +0100 <merijn> fbytez: Sure
2023-03-07 14:46:03 +0100 <merijn> Easily
2023-03-07 14:46:07 +0100 <dminuoso> Cale: Fair.
2023-03-07 14:46:10 +0100 <merijn> In, like 8 different ways :p
2023-03-07 14:46:27 +0100 <Cale> I was implying that one might expect that older libraries are more trustworthy, because of a longer period of time available to find bugs.
2023-03-07 14:46:32 +0100 <mauke> fbytez: https://hackage.haskell.org/package/base-4.18.0.0/docs/Foreign-Ptr.html
2023-03-07 14:46:34 +0100 <merijn> % unsafeCoerce True :: Int -- I wonder if unsafeCoerce is allowed?
2023-03-07 14:46:34 +0100 <yahb2> <interactive>:32:1: error: ; Variable not in scope: unsafeCoerce :: Bool -> Int
2023-03-07 14:46:48 +0100 <merijn> % import Unsafe.Coerce
2023-03-07 14:46:48 +0100 <yahb2> <no output>
2023-03-07 14:47:02 +0100 <merijn> % unsafeCoerce True :: Int
2023-03-07 14:47:02 +0100 <yahb2> -576460203687845904
2023-03-07 14:47:04 +0100 <merijn> Nice
2023-03-07 14:47:05 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-03-07 14:47:16 +0100 <lyxia> would you expect readFile :: FilePath -> IO Text to do newline conversion? I know the one in text does, but there's a proposal to have a locale independent variant and I'm wondering whether the lack of newline conversion could lead to bad surprises.
2023-03-07 14:47:36 +0100 <merijn> lyxia: Almost all languages except C do that
2023-03-07 14:47:40 +0100 <mauke> depends on whether I am a C programmer
2023-03-07 14:47:42 +0100 <merijn> So, I kinda would
2023-03-07 14:47:48 +0100 <mauke> uh, C started it
2023-03-07 14:47:52 +0100 <mauke> C definitely does it
2023-03-07 14:48:04 +0100 <merijn> Oh, then almost everything does :p
2023-03-07 14:48:22 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-03-07 14:48:48 +0100 <merijn> fbytez: Haskell's reputation for safety and safety getting in the way of "getting things done" is mostly exaggeration by people who don't really know Haskell
2023-03-07 14:49:05 +0100 <merijn> fbytez: GHC will gleefully hand you like a dozen different unsafe tools to do whatever you want
2023-03-07 14:49:18 +0100 <mauke> C started out as a systems language for unix (for creating/porting unix, really), and initially its '\n' (newline) character was simply char 10 and treated literally
2023-03-07 14:49:48 +0100 <mauke> when C got ported to other systems with other text conventions, people got creative
2023-03-07 14:49:52 +0100lxi(~quassel@2a02:2f08:4d1c:400:c33f:394a:2177:e1a0) (Ping timeout: 248 seconds)
2023-03-07 14:49:58 +0100 <Cale> lyxia: I would expect it to do whatever newline conversion was set up by the NewlineMode
2023-03-07 14:50:06 +0100 <merijn> fbytez: Except unlike most other languages, most of those tools are pretty obviously unsafe and labelled as such and they WILL blow up in your face if you don't know what you're doing, unlike C where lots of unsafe things often "seem" to work without blowing up
2023-03-07 14:50:07 +0100 <Cale> https://downloads.haskell.org/ghc/latest/docs/libraries/base-4.17.0.0/System-IO.html#v:hSetNewline…
2023-03-07 14:50:19 +0100 <lyxia> Cale: readFile doesn't take a handle
2023-03-07 14:50:46 +0100 <Cale> True, so you just get the default
2023-03-07 14:50:48 +0100 <lyxia> but yeah that makes sense for the other functions that do
2023-03-07 14:50:49 +0100 <merijn> lyxia: Either way, I consider readFile mostly a cute toy for quick and dirty prototypes/hacks and not a serious tool to begin with
2023-03-07 14:50:53 +0100 <mauke> some systems simply use a different end-of-line marker (e.g. classic MacOS used char 13, DOS and later Windows used a combination of 13 10)
2023-03-07 14:50:59 +0100 <dminuoso> merijn: I dont know what you mean. I _read_ Haskell every day, and it never unsafely performs IO. But I may have an incomplete view on patterns.
2023-03-07 14:51:05 +0100 <mauke> only on Windows it is treated as a line *separator*
2023-03-07 14:51:26 +0100 <merijn> dminuoso: hmm?
2023-03-07 14:51:26 +0100 <dminuoso> merijn: My latest rage is improper IsString instances.
2023-03-07 14:51:35 +0100 <dminuoso> Like `IsString IPv4` and some such
2023-03-07 14:51:36 +0100 <mauke> but other systems have an entirely different concept of files
2023-03-07 14:51:46 +0100 <merijn> dminuoso: Tell them to use validated-literals ;)
2023-03-07 14:51:50 +0100 <dminuoso> Nah
2023-03-07 14:51:52 +0100 <mauke> like, record-oriented files with structure, not just a random string of bytes
2023-03-07 14:51:57 +0100 <merijn> Which reminds me...I need to update for GHC 9.6 and new template-haskell
2023-03-07 14:51:59 +0100 <dminuoso> merijn: I ended up writing my own IP library
2023-03-07 14:52:10 +0100 <dminuoso> `ipv4 127 0 0 01` is just as good as writing "127.0.0.1"
2023-03-07 14:52:19 +0100 <Cale> . o O ( IsString Integer that parses Roman numerals )
2023-03-07 14:52:27 +0100 <dminuoso> haha
2023-03-07 14:52:31 +0100 <merijn> dminuoso: I've argued that IsString (and the other OverloadedX extensions) should work like validated-literals
2023-03-07 14:52:53 +0100 <mauke> on those systems, a "text file" may be represented as, say, a sequence of 256 byte records, each of which stores a line of text
2023-03-07 14:53:03 +0100 <merijn> But that idea was met with skepticism and useless. Until people 7 years later decided it should work more like that
2023-03-07 14:53:09 +0100 <merijn> So, my take away is that I'm a visionary
2023-03-07 14:53:23 +0100 <merijn> And my words should be heeded like those of a prophet
2023-03-07 14:54:02 +0100 <mauke> so the C library abstracts files as follows: files can be opened in either "text mode" (the default) or "binary mode" (the "b" flag in fopen())
2023-03-07 14:54:37 +0100 <mauke> in binary mode, bytes read and written are intended to go to disk as literally as possible
2023-03-07 14:54:51 +0100 <mauke> ftell() and fseek() operate in byte offsets
2023-03-07 14:55:27 +0100 <mauke> in text mode, the special '\n' character (whose value is implementation defined) indicates a virtual "end of line" and is translated to/from whatever on-disk representation the platform uses
2023-03-07 14:56:09 +0100 <mauke> also, ftell() returns not byte offsets, but "file position cookies" whose value is meaningless except as argument to subsequent fseek() calls
2023-03-07 14:56:09 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 255 seconds)
2023-03-07 14:57:08 +0100 <mauke> on unix systems, no distinction is made between text/binary files. '\n' is 10 and nothing is translated
2023-03-07 14:57:27 +0100 <mauke> on classic MacOS, '\n' is 13, but everything else is as with unix
2023-03-07 14:57:57 +0100 <mauke> (this does mean that if you write e.g. an HTTP library, you have to be careful to terminate your lines with "\015\012", not "\r\n")
2023-03-07 14:58:02 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-03-07 14:58:42 +0100 <mauke> on windows, '\n' is 10, but text files translate it to a CR-LF pair (13, 10) when writing
2023-03-07 14:59:41 +0100 <mauke> TL;DR: C's "portable newline abstraction" is '\n', and anyone who uses std::endl is doing it wrong
2023-03-07 14:59:52 +0100cheater_(~Username@user/cheater)
2023-03-07 15:00:32 +0100 <fbytez> So what is `std::endl` doing?
2023-03-07 15:00:52 +0100 <fbytez> From C++, right?
2023-03-07 15:02:15 +0100 <mauke> handle << std::endl is defined to be equivalent to handle << '\n' << std::flush
2023-03-07 15:02:19 +0100cheater(~Username@user/cheater) (Ping timeout: 248 seconds)
2023-03-07 15:02:26 +0100cheater_cheater
2023-03-07 15:02:36 +0100 <mauke> that is, it writes a single '\n' character and then flushes the stream
2023-03-07 15:03:01 +0100 <mauke> which is non-obvious enough that you should simply use std::flush explicitly
2023-03-07 15:03:08 +0100 <mauke> (in cases where you really need it, that is)
2023-03-07 15:04:21 +0100 <lyxia> Cale: does "default" also mean "follow the locale"?
2023-03-07 15:04:45 +0100 <merijn> lyxia: imo yes
2023-03-07 15:05:57 +0100 <mauke> in Haskell there is the additional wrinkle that Char is specified as Unicode
2023-03-07 15:06:11 +0100thegeekinside(~thegeekin@189.141.115.134)
2023-03-07 15:06:30 +0100 <mauke> so e.g. '\123' does not mean "character 123 in the platform charset" (whatever that is), it explicitly means '{'
2023-03-07 15:06:31 +0100 <Cale> The default is nativeNewlineMode which does nothing on unix-like systems, but on Windows, translates \r\n to \n and back.
2023-03-07 15:06:54 +0100 <mauke> and '\n' is defined as '\LF', which is defined as '\10'
2023-03-07 15:07:00 +0100 <lyxia> I meant my last question more broadly, not just regarding newlines
2023-03-07 15:07:05 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559)
2023-03-07 15:07:34 +0100 <mauke> so I would assume that on EBCDIC systems a Haskell implementation would have to do full translation of every character read/written
2023-03-07 15:07:44 +0100 <Cale> Text encoding otherwise follows the locale, but I don't know if there's information in the locale about how newlines are to be translated.
2023-03-07 15:07:53 +0100 <lyxia> I think the motivation behind that proposal (not mine) is that some people disagree that locales are a reliable default.
2023-03-07 15:09:16 +0100 <mauke> so in the words of MS Outlook: J
2023-03-07 15:09:22 +0100 <merijn> lyxia: Yes, these people are stupid
2023-03-07 15:09:35 +0100superbil(~superbil@1-34-176-171.hinet-ip.hinet.net) (Ping timeout: 268 seconds)
2023-03-07 15:09:38 +0100 <lyxia> merijn: I knew you would say that
2023-03-07 15:09:44 +0100 <merijn> There's a bunch of "anti-locale" radicalists in the Haskell community which argue "oh, everything should only work on UTF-8"
2023-03-07 15:10:16 +0100 <merijn> But I fundamentally oppose the idea that Haskell programs should "stop working" when I run them on an otherwise properly configured machine with reasonable settings
2023-03-07 15:10:53 +0100 <merijn> All my machines use utf-8 locales, but I don't see any good justification for "all Haskell programs should just break when someone has a machine set to use a utf-16 or other encoding locale"
2023-03-07 15:11:04 +0100 <merijn> That just seems an insane point to argue in favour of
2023-03-07 15:11:12 +0100superbil(~superbil@1-34-176-171.hinet-ip.hinet.net)
2023-03-07 15:11:39 +0100 <merijn> Should most people be using utf-8 locales? Probably. Is that a reason to break compatibility with 40+ years of unix expectations?
2023-03-07 15:11:42 +0100 <mauke> oh, I guess I'm somewhat of a radicalist, then?
2023-03-07 15:11:47 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559) (Ping timeout: 255 seconds)
2023-03-07 15:12:04 +0100 <mauke> depends on how far you want to go with locales
2023-03-07 15:13:28 +0100 <merijn> mauke: There are some people who argue that all the file operations should disregard the locales encoding and ONLY do utf-8 always.
2023-03-07 15:14:23 +0100 <int-e> ...well, in the absence of file metadata specifying the encoding...
2023-03-07 15:14:39 +0100 <lyxia> int-e: ... you read the locale?
2023-03-07 15:14:41 +0100 <mauke> merijn: that's certainly a tempting option
2023-03-07 15:14:43 +0100 <merijn> int-e: In the absence of file metadata "following the locale" is the only sensible option
2023-03-07 15:15:02 +0100 <merijn> Because if you assume the systems is properly configured, that will be the right encoding
2023-03-07 15:15:06 +0100 <int-e> I mean, what's the alternative, should scp/sftp/rsync recode files according to the locales?
2023-03-07 15:15:13 +0100 <merijn> And if the system is NOT properly configured, then you're shit outta luck anyway
2023-03-07 15:15:26 +0100 <mauke> merijn: how is it sensible to follow the system locale in this one aspect if everything else is ignored?
2023-03-07 15:15:36 +0100 <merijn> int-e: If files don't follow the locale AND you don't know what they are from metadata, you'r fucked anyway
2023-03-07 15:16:09 +0100 <mauke> for example, the show instance for numbers does not respect the locale and assumes US/UK conventions
2023-03-07 15:16:09 +0100 <merijn> int-e: And if you know the encoding from metadata and it differs from the locale, there's already functions for accessing them
2023-03-07 15:16:28 +0100 <merijn> mauke: Show specifically follows the Haskell syntax conventions
2023-03-07 15:16:33 +0100 <merijn> (which happen to be US/UK)
2023-03-07 15:16:34 +0100 <int-e> I think that there's no right default for text files in non-UTF-8 locales.
2023-03-07 15:16:43 +0100 <int-e> Either way will cause trouble.
2023-03-07 15:16:57 +0100 <merijn> int-e: the default is "what the system is configured to produce/expect"
2023-03-07 15:16:59 +0100superbil(~superbil@1-34-176-171.hinet-ip.hinet.net) (Ping timeout: 268 seconds)
2023-03-07 15:17:01 +0100 <mauke> merijn: yes
2023-03-07 15:17:22 +0100 <merijn> int-e: If the locale is configured to something non-UTF8, how is that less valid than the locale being configured to utf-8?
2023-03-07 15:17:29 +0100 <int-e> merijn: or the default is what is most portable across systems
2023-03-07 15:17:31 +0100int-eshrugs
2023-03-07 15:17:42 +0100 <int-e> I said what I said and I believe it.
2023-03-07 15:18:11 +0100 <merijn> int-e: it already falls back to utf8 for unknown locales as of recently
2023-03-07 15:18:31 +0100 <mauke> from a practical standpoint, it is better to have simple and deterministic behavior
2023-03-07 15:18:35 +0100 <merijn> int-e: If a locale is set, why would you disbelief it is set correctly?
2023-03-07 15:19:00 +0100 <mauke> the alternative is to include encoding tables for every character set under the sun
2023-03-07 15:19:12 +0100 <merijn> mauke: Why?
2023-03-07 15:19:19 +0100 <int-e> merijn: Well, if it's not UTF-8 I'll stare at it in disbelief and wonder how the user survives.
2023-03-07 15:19:26 +0100 <mauke> merijn: why which one?
2023-03-07 15:19:46 +0100 <merijn> mauke: Why would you have to include encoding tables for everything? Can just produce an error for unknown
2023-03-07 15:19:53 +0100 <int-e> (my sole locale setting is LC_CTYPE=en_US.UTF-8, been doing that for about 20 years, because all other charsets cause way too much friction.)
2023-03-07 15:20:05 +0100 <merijn> int-e: Any form of utf-X seems reasonable and I don't know if something else might be reasonable for Asia
2023-03-07 15:20:15 +0100 <mauke> merijn: OK, which ones do you include by default, then? :-)
2023-03-07 15:20:41 +0100 <merijn> mauke: Certainly all the UTF ones, whatever the standard old windows one was. aka the ones we already include anyway
2023-03-07 15:20:54 +0100vglfr(~vglfr@145.224.100.240) (Ping timeout: 255 seconds)
2023-03-07 15:21:03 +0100 <mauke> there is no single "the standard" one for windows
2023-03-07 15:21:14 +0100 <mauke> it was all country specific
2023-03-07 15:21:43 +0100 <mauke> merijn: UTF-7? UTF-EBCDIC?
2023-03-07 15:21:53 +0100vglfr(~vglfr@145.224.100.65)
2023-03-07 15:22:05 +0100 <mauke> (the latter is A Thing and Perl uses it)
2023-03-07 15:22:15 +0100 <merijn> int-e: I don't know what people in Asia use, but who am I to say UTF-16 is "wrong" if you're dealing with exclusively SEA texts
2023-03-07 15:22:18 +0100 <int-e> merijn: I really think that in an ideal world (not the one we live in, obviously), text files should carry their encoding as metadata. Tying it to a global locale in a world where we download stuff all the time is ridiculous.
2023-03-07 15:22:57 +0100 <merijn> int-e: Of course it is ridiculous, but we gotta work with what we have
2023-03-07 15:23:03 +0100 <int-e> The locale is kind of like a broken clock; maybe it's right more than twice a day even but it'll still be wrong *a lot*.
2023-03-07 15:23:31 +0100 <merijn> And what we have is that all commandline tools assume the locale is correct and consume/produce that encoding
2023-03-07 15:23:51 +0100 <merijn> int-e: Assuming utf-8 for everything has the same odds of being wrong for stuff downloaded in some arbitrary encoding
2023-03-07 15:25:01 +0100 <mauke> now I'm tempted to find out if you can configure a UTF-7 or UTF-EBCDIC locale for linux
2023-03-07 15:25:11 +0100 <mauke> and whether e.g. ls will respect it
2023-03-07 15:35:23 +0100 <mauke> ... it looks like typical command-line tools "cheat" by just assuming ASCII
2023-03-07 15:35:44 +0100 <merijn> ls is double fucked, of course
2023-03-07 15:35:48 +0100 <mauke> and all the supported system locales on Debian that I can see are ASCII extensions in some way
2023-03-07 15:35:57 +0100 <merijn> since on linux you can't assume everything about filenames either :p
2023-03-07 15:37:25 +0100 <mauke> even stuff like Big5 is based on a "lead byte" with the high bit set, so any single byte in the range 00-7F can just be "passed through"
2023-03-07 15:38:05 +0100 <merijn> at least there's one thing we can all agree on
2023-03-07 15:38:36 +0100 <merijn> Whoever at microsoft decided to insert a "unicode byte order mark" ahead of UTF8 text should be tried for crimes against humanity
2023-03-07 15:39:36 +0100 <lyxia> uhoh. How does base handle that?
2023-03-07 15:40:21 +0100 <mauke> also the MS guy who decided to call the single-byte vendor-specific charset "ANSI"
2023-03-07 15:40:23 +0100 <merijn> Well, from spending 3 hours debugging my girlfriend's first Haskell program I can tell you that aeson breaks horribly on it
2023-03-07 15:40:39 +0100 <mauke> and the MS guy who decided to call UTF-16LE "UNICODE"
2023-03-07 15:40:43 +0100 <merijn> Because apparently excel inserts said byte order mark when saving utf-8 CSV
2023-03-07 15:40:56 +0100 <merijn> eh, not aeson
2023-03-07 15:40:58 +0100 <merijn> cassava
2023-03-07 15:41:02 +0100 <merijn> brainfart
2023-03-07 15:41:19 +0100 <mauke> even worse, you need that UTF-8 "BOM" in CSV files intended for Excel
2023-03-07 15:41:28 +0100 <mauke> otherwise it will probably get the Unicode wrong
2023-03-07 15:43:28 +0100ix(~ix@213.205.192.69)
2023-03-07 15:48:48 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-03-07 15:48:48 +0100ix(~ix@213.205.192.69) (Ping timeout: 255 seconds)
2023-03-07 15:51:33 +0100ix(~ix@213.205.192.69)
2023-03-07 16:00:50 +0100superbil(~superbil@1-34-176-171.hinet-ip.hinet.net)
2023-03-07 16:02:32 +0100chexum_(~quassel@gateway/tor-sasl/chexum)
2023-03-07 16:04:05 +0100chexum(~quassel@gateway/tor-sasl/chexum) (Ping timeout: 255 seconds)
2023-03-07 16:07:39 +0100 <lyxia> I was on the fence at first but merijn you've changed my mind a bunch towards your side.
2023-03-07 16:08:37 +0100 <merijn> \o/
2023-03-07 16:08:48 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 246 seconds)
2023-03-07 16:09:01 +0100 <lyxia> I'm always skeptical when an issue boils down to "learn to configure your system" because we all know users don't learn
2023-03-07 16:09:04 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-03-07 16:10:41 +0100 <merijn> lyxia: Well, in the past GHC would default to ASCII only on systems with a broken locale (and then fail on unicode input), but recent GHC (everything in the 9.x series and maybe some earlier ones, iirc) default to UTF-8 instead of ascii when that happens
2023-03-07 16:11:20 +0100 <merijn> So I would concede that accepting ascii only in case of failure is "probably the wrong default", but that has already been fixed :p
2023-03-07 16:18:29 +0100Sciencentistguy4(~sciencent@hacksoc/ordinary-member)
2023-03-07 16:19:17 +0100pdw(~user@215.156.62.185.bridgefibre.net)
2023-03-07 16:19:24 +0100Sciencentistguy(~sciencent@hacksoc/ordinary-member) (Ping timeout: 255 seconds)
2023-03-07 16:19:24 +0100Sciencentistguy4Sciencentistguy
2023-03-07 16:20:28 +0100 <pdw> Hello all. I've created a trivial project with the 'hashable' package (1.4.2.0) in its build-depends, and it fails to build on Windows using an integer-simple GHC 8.10.7 release.
2023-03-07 16:20:30 +0100 <pdw> Searching has taught me that package flags are thing, so I've run 'cabal configure --constraint="hashable -integer-gmp"' and rebuilt, but that hasn't helped. Should that have worked, or am I missing something?
2023-03-07 16:22:20 +0100 <tdammers> Age-old conflict between "don't be annoying" and "don't guess". Failing when the encoding cannot be reliably determined is sound, but also annoying; picking a best-guess encoding may be wrong, but is likely correct and won't annoy the user too much even when it's not.
2023-03-07 16:22:27 +0100 <tdammers> See also XHTML Strict.
2023-03-07 16:23:56 +0100cheater_(~Username@user/cheater)
2023-03-07 16:23:56 +0100mrcsno_afk(~mrcsno@user/mrcsno) (Quit: WeeChat 3.5)
2023-03-07 16:26:36 +0100masterbuilder(~masterbui@user/masterbuilder) (Ping timeout: 255 seconds)
2023-03-07 16:26:44 +0100masterbuilder(~masterbui@user/masterbuilder)
2023-03-07 16:27:07 +0100cheater(~Username@user/cheater) (Ping timeout: 248 seconds)
2023-03-07 16:27:10 +0100cheater_cheater
2023-03-07 16:29:36 +0100ubert1(~Thunderbi@p200300ecdf0c57b39b0cedad49907c5f.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
2023-03-07 16:33:30 +0100barzo(~barzo@176.55.97.55)
2023-03-07 16:34:03 +0100masterbuilder(~masterbui@user/masterbuilder) (Ping timeout: 248 seconds)
2023-03-07 16:35:06 +0100barzo(~barzo@176.55.97.55) (Remote host closed the connection)
2023-03-07 16:36:09 +0100masterbuilder(~masterbui@user/masterbuilder)
2023-03-07 16:38:30 +0100jumper149(~jumper149@base.felixspringer.xyz) (WeeChat 3.8)
2023-03-07 16:38:55 +0100jumper149(~jumper149@base.felixspringer.xyz)
2023-03-07 16:39:05 +0100razetime(~Thunderbi@117.193.1.99)
2023-03-07 16:40:01 +0100razetime(~Thunderbi@117.193.1.99) (Client Quit)
2023-03-07 16:40:26 +0100L29Ah(~L29Ah@wikipedia/L29Ah) ()
2023-03-07 16:43:04 +0100mechap_(~mechap@user/mechap)
2023-03-07 16:44:27 +0100L29Ah(~L29Ah@wikipedia/L29Ah)
2023-03-07 16:44:43 +0100mechap(~mechap@user/mechap) (Ping timeout: 248 seconds)
2023-03-07 16:45:23 +0100Sgeo(~Sgeo@user/sgeo)
2023-03-07 16:50:16 +0100cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.8)
2023-03-07 16:51:07 +0100jumper149(~jumper149@base.felixspringer.xyz) (Quit: WeeChat 3.8)
2023-03-07 16:52:01 +0100Everything(~Everythin@46.185.124.65)
2023-03-07 16:59:20 +0100irrgit_(~irrgit@89.47.234.26)
2023-03-07 17:03:10 +0100irrgit__(~irrgit@146.70.27.242) (Ping timeout: 252 seconds)
2023-03-07 17:12:10 +0100 <AWizzArd> For newtype Cont a = Cont { unCont :: forall r. (a -> r) -> r } I have this fmap implementation: fmap f (Cont c) = Cont (\b -> c (b . f))
2023-03-07 17:12:14 +0100 <AWizzArd> Interestingly fmap f (Cont c) = Cont (\b -> b (c f)) also compiles.
2023-03-07 17:15:21 +0100vglfr(~vglfr@145.224.100.65) (Ping timeout: 268 seconds)
2023-03-07 17:15:49 +0100shapr(~user@68.54.166.125)
2023-03-07 17:16:11 +0100vglfr(~vglfr@145.224.100.240)
2023-03-07 17:16:30 +0100mbuf(~Shakthi@49.207.178.186) (Quit: Leaving)
2023-03-07 17:17:50 +0100 <Hecate> teo: would I be able to use your shortstraw tool to produce a trace for the compilation time of Flora? Or do you think it's too early to experiment with it?
2023-03-07 17:18:19 +0100Square2(~Square4@user/square) (Ping timeout: 248 seconds)
2023-03-07 17:20:01 +0100 <geekosaur> AWizzArd, monochrom pointed out that they're actually the same thing, last time you mentioned this
2023-03-07 17:20:27 +0100vglfr(~vglfr@145.224.100.240) (Ping timeout: 248 seconds)
2023-03-07 17:20:53 +0100cheater_(~Username@user/cheater)
2023-03-07 17:21:27 +0100vglfr(~vglfr@145.224.100.65)
2023-03-07 17:23:05 +0100 <geekosaur> Feb 28 00:01:27 <monochrom> AWizzArd: Something about parametricity or Yoneda's lemma says that they do the same thing, too!
2023-03-07 17:23:13 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:cdff:bbec:88eb:b8a) (Quit: WeeChat 2.8)
2023-03-07 17:23:49 +0100 <geekosaur> (if it's Yoneda, prepare to get your head twisted even harder than Cont does…)
2023-03-07 17:24:12 +0100cheater(~Username@user/cheater) (Ping timeout: 252 seconds)
2023-03-07 17:24:19 +0100cheater_cheater
2023-03-07 17:24:53 +0100 <int-e> Well, mostly the same... the second one is a bit lazier.
2023-03-07 17:26:47 +0100 <AWizzArd> geekosaur: I must have missed it.
2023-03-07 17:27:02 +0100 <AWizzArd> monochrom: belated thanks :-)
2023-03-07 17:27:06 +0100 <int-e> @free c :: (a -> r) -> r
2023-03-07 17:27:06 +0100 <lambdabot> g . h = k . f => g (c h) = c k
2023-03-07 17:27:28 +0100 <int-e> Hmm, dubious, what's happening to the `f` here?
2023-03-07 17:28:47 +0100irrgit_(~irrgit@89.47.234.26) (Read error: Connection reset by peer)
2023-03-07 17:29:07 +0100 <AWizzArd> To be honest, I can't see why those two are the same.
2023-03-07 17:29:08 +0100 <int-e> I guess it's a bug; it would work for g . h = k.
2023-03-07 17:29:08 +0100 <[Leary]> @free c :: (A -> r) -> r
2023-03-07 17:29:08 +0100 <lambdabot> f . c = c . (.) f
2023-03-07 17:30:14 +0100 <int-e> (Or, possibly, the fact that types are omitted in @free? f :: forall a. a -> a would restrict f sufficiently.)
2023-03-07 17:30:37 +0100 <int-e> [Leary]: yeah that's better
2023-03-07 17:31:32 +0100 <monochrom> AWizzArd: Let's say parametricity (free theorems). After a few steps, we conclude that if you give me a value (Cont c), then c id contains all the information. Equivalently, we can reverse engineer: c = \k -> k (c id)
2023-03-07 17:31:41 +0100 <[Leary]> @free c :: a
2023-03-07 17:31:41 +0100 <lambdabot> f c = c
2023-03-07 17:32:18 +0100 <[Leary]> I guess f is redundant when you have, in effect, `forall a. a`.
2023-03-07 17:32:27 +0100 <monochrom> A corollary I'll use is: if you give me two values (Cont c) and (Cont c'), and ask whether they're the same, then I can use: c=c' iff c id = c' id.
2023-03-07 17:32:56 +0100 <int-e> [Leary]: Oh, right.
2023-03-07 17:32:58 +0100 <monochrom> So now just check that (\b -> c (b . f)) id = (\b -> b (c f)) id.
2023-03-07 17:33:23 +0100ccapndave(~ccapndave@xcpe-62-167-164-99.cgn.res.adslplus.ch) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-03-07 17:35:35 +0100gentauro(~gentauro@user/gentauro) (Ping timeout: 246 seconds)
2023-03-07 17:42:16 +0100lyle(~lyle@104.246.145.237) (Quit: WeeChat 3.8)
2023-03-07 17:42:28 +0100mei(~mei@user/mei) (Remote host closed the connection)
2023-03-07 17:42:38 +0100gentauro(~gentauro@user/gentauro)
2023-03-07 17:46:50 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559)
2023-03-07 17:50:28 +0100sadmax(~user@64.130.91.66) (Ping timeout: 252 seconds)
2023-03-07 17:50:51 +0100mei(~mei@user/mei)
2023-03-07 17:52:24 +0100jtomas(~user@81.172.17.107.dyn.user.ono.com)
2023-03-07 17:57:33 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2023-03-07 17:59:54 +0100 <ncf> c (b . f) = b (c f) = b (f (c id))
2023-03-07 18:00:05 +0100 <ncf> we even have three possible definitions!
2023-03-07 18:02:07 +0100cheater(~Username@user/cheater) (Quit: Going offline, see ya! (www.adiirc.com))
2023-03-07 18:02:30 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-03-07 18:04:25 +0100mei(~mei@user/mei) (Quit: mei)
2023-03-07 18:05:59 +0100mei(~mei@user/mei)
2023-03-07 18:06:40 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Read error: Connection reset by peer)
2023-03-07 18:08:31 +0100jtomas(~user@81.172.17.107.dyn.user.ono.com) (Ping timeout: 246 seconds)
2023-03-07 18:09:48 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2023-03-07 18:11:06 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-03-07 18:11:16 +0100cheater(~Username@user/cheater)
2023-03-07 18:11:31 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559) (Remote host closed the connection)
2023-03-07 18:11:35 +0100hiredman(~hiredman@frontier1.downey.family)
2023-03-07 18:17:42 +0100polyphem_(~rod@2a02:810d:840:8754:da48:4c29:8382:1f9b)
2023-03-07 18:19:07 +0100Everything(~Everythin@46.185.124.65) (Quit: leaving)
2023-03-07 18:22:18 +0100azimut_(~azimut@gateway/tor-sasl/azimut)
2023-03-07 18:23:08 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-03-07 18:23:11 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559)
2023-03-07 18:25:24 +0100mei(~mei@user/mei) (Ping timeout: 255 seconds)
2023-03-07 18:25:39 +0100ix(~ix@213.205.192.69) (Ping timeout: 268 seconds)
2023-03-07 18:27:20 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-03-07 18:32:07 +0100cheater(~Username@user/cheater) (Quit: Going offline, see ya! (www.adiirc.com))
2023-03-07 18:33:39 +0100ix(~ix@213.205.192.69)
2023-03-07 18:34:32 +0100fnurglewitz(uid263868@id-263868.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-03-07 18:36:37 +0100econo(uid147250@user/econo)
2023-03-07 18:37:16 +0100ddellacosta(~ddellacos@146.70.166.10) (Quit: WeeChat 3.8)
2023-03-07 18:38:55 +0100ddellacosta(~ddellacos@146.70.166.10)
2023-03-07 18:43:12 +0100Fischmiep(~Fischmiep@user/Fischmiep)
2023-03-07 18:45:34 +0100mei(~mei@user/mei)
2023-03-07 18:46:20 +0100cheater(~Username@user/cheater)
2023-03-07 18:52:00 +0100gensyst(gensyst@user/gensyst)
2023-03-07 18:52:26 +0100 <gensyst> Hi, will stuff like this work for global variables? https://dpaste.com/4LKER738V I.e. can the global be dependent on something (in this case Int)?
2023-03-07 18:52:44 +0100 <dsal> gensyst: What are you doing? That seems like a terrible idea.
2023-03-07 18:52:44 +0100 <gensyst> so if I already grabbed a global for 3, will the next time I grab it for 3 be the exact same thing?
2023-03-07 18:52:55 +0100 <gensyst> dsal, i know it's a hack that i must remove soon
2023-03-07 18:53:00 +0100 <gensyst> just wondering if this will work for now
2023-03-07 18:53:08 +0100 <gensyst> soon(TM)
2023-03-07 18:54:04 +0100 <dsal> It's not really clear what you mean to do there. It's creating an IORef and then reading it each time.
2023-03-07 18:54:39 +0100 <gensyst> it's not the best example. imagine the Int in the IORef is a more complex object
2023-03-07 18:54:50 +0100 <dsal> If you wanted it to actually behave like a global variable, you'd only ever create one IORef and make it accessible.
2023-03-07 18:55:06 +0100 <dsal> It doesn't matter how complex it is. If you make it every time you access it, that's the same as not using IO at all.
2023-03-07 18:55:08 +0100 <gensyst> dsal, yes... i want one *for each int*
2023-03-07 18:55:35 +0100 <geekosaur> you can't have a parameter
2023-03-07 18:55:50 +0100 <geekosaur> it no longer behaves like a global if you do
2023-03-07 18:55:57 +0100 <gensyst> ok good to know lol
2023-03-07 18:56:06 +0100 <gensyst> gotta bite the bullet and fix this mess (should have been done ages ago)
2023-03-07 18:56:17 +0100 <dsal> You could have an IORef Map, but yeah, Doing It Right is a better idea.
2023-03-07 18:56:23 +0100 <gensyst> oh... i guess ic ould hack it with a Map?
2023-03-07 18:56:27 +0100 <gensyst> Map Int ComplexObject
2023-03-07 18:56:27 +0100MajorBiscuit(~MajorBisc@c-001-030-044.client.tudelft.eduvpn.nl) (Ping timeout: 248 seconds)
2023-03-07 18:56:55 +0100 <gensyst> no that won't help
2023-03-07 18:58:58 +0100cheater_(~Username@user/cheater)
2023-03-07 18:59:52 +0100 <monochrom> Map Int (IORef XXX)
2023-03-07 19:01:11 +0100 <monochrom> You were basically hoping that your _foo would be memoized. But that hope was misplaced.
2023-03-07 19:01:51 +0100cheater(~Username@user/cheater) (Ping timeout: 255 seconds)
2023-03-07 19:01:54 +0100cheater_cheater
2023-03-07 19:03:15 +0100mmhat(~mmh@p200300f1c7095e7aee086bfffe095315.dip0.t-ipconnect.de)
2023-03-07 19:03:27 +0100mmhat(~mmh@p200300f1c7095e7aee086bfffe095315.dip0.t-ipconnect.de) (Client Quit)
2023-03-07 19:05:26 +0100ddellacosta(~ddellacos@146.70.166.10) (Quit: WeeChat 3.8)
2023-03-07 19:05:43 +0100ddellacosta(~ddellacos@146.70.166.10)
2023-03-07 19:06:22 +0100segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-03-07 19:06:30 +0100 <segfaultfizzbuzz> is there a finite or infinite number of types?
2023-03-07 19:07:32 +0100 <ddellacosta> yes?
2023-03-07 19:08:12 +0100 <monochrom> Can you try constructing an infinite bunch of types?
2023-03-07 19:08:13 +0100 <segfaultfizzbuzz> well either the number of types which "exist" are either finite or infinite
2023-03-07 19:08:22 +0100 <mauke> every number is finite
2023-03-07 19:08:23 +0100 <segfaultfizzbuzz> a related question is, can an automated system "discover" a type?
2023-03-07 19:08:44 +0100 <monochrom> Can you name a language that does automatic type inference?
2023-03-07 19:09:05 +0100 <segfaultfizzbuzz> that is to say, are there things i can check about something (not sure what the thing is or how the checking works) which can "objectively" determine whether that thing is a type
2023-03-07 19:09:41 +0100 <monochrom> Can you name a compiler that says "syntax error" whenever you write an illegal type expression?
2023-03-07 19:09:55 +0100 <mauke> yes: const "syntax error"
2023-03-07 19:10:16 +0100 <segfaultfizzbuzz> monochrom: i mean type inference is common but you need to have uh, "source types" or something defined by a human which can be used to determine the "destination types"
2023-03-07 19:10:30 +0100 <monochrom> s/human/compiler/
2023-03-07 19:11:30 +0100 <segfaultfizzbuzz> let's say i have an infinite String --can a system "discover" types within the String and parse them automatically?
2023-03-07 19:12:15 +0100 <geekosaur> that's just a modified compiler
2023-03-07 19:12:38 +0100 <segfaultfizzbuzz> does "type" mean: "invariants which appear to always be true empirically, or which a human has mandated always be true"?
2023-03-07 19:12:44 +0100 <monochrom> for i=0 to oo { for j=i to oo { ask the compiler whether s[i..j] is a legal type expression } }
2023-03-07 19:13:09 +0100 <mauke> Have you ever had a dream that you, um, you had, your, you- you could, you’ll do, you- you wants, you, you could do so, you- you’ll do, you could- you, you want, you want him to do you so much you could do anything?
2023-03-07 19:13:29 +0100 <segfaultfizzbuzz> haha ok i guess i will stop. i'm trying to understand what a type is
2023-03-07 19:13:34 +0100 <monochrom> "type" means: The Haskell2010 Report says it's a type expression.
2023-03-07 19:14:47 +0100 <segfaultfizzbuzz> monochrom: i guess you are saying that a type is simply a tag exposed to the compiler and beyond that the compiler decides what i means...?
2023-03-07 19:14:54 +0100 <segfaultfizzbuzz> what it means
2023-03-07 19:14:58 +0100 <monochrom> No.
2023-03-07 19:15:17 +0100 <dsal> segfaultfizzbuzz: a String is a type alias for a list of characters. The only types you'll find within a String are either the List * or the Char (depending on how you look at it)
2023-03-07 19:15:36 +0100gurkenglas(~gurkengla@dynamic-046-114-176-216.46.114.pool.telefonica.de) (Ping timeout: 268 seconds)
2023-03-07 19:15:36 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559) (Remote host closed the connection)
2023-03-07 19:15:43 +0100ix(~ix@213.205.192.69) (Ping timeout: 252 seconds)
2023-03-07 19:15:52 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559)
2023-03-07 19:16:20 +0100 <dsal> I assume there's a practical limit to how many types you can have in a program compiled by GHC.
2023-03-07 19:16:50 +0100 <segfaultfizzbuzz> i will try one last time... an alien lands and can only see your RAM, and thinks you are lying about the types your data has. how does the alien verify that some stuff in RAM has a certain type?
2023-03-07 19:17:08 +0100 <mauke> what does that even mean?
2023-03-07 19:17:17 +0100 <geekosaur> dsal, I believe that limit is set by available memory
2023-03-07 19:17:52 +0100 <segfaultfizzbuzz> data Pet = Cat | Dog | None
2023-03-07 19:18:07 +0100 <segfaultfizzbuzz> i have observed twenty people, and all people i have observed have a pet cat, a pet dog, or no pet
2023-03-07 19:18:09 +0100 <mauke> types are assigned to expressions in the source code
2023-03-07 19:18:24 +0100 <segfaultfizzbuzz> and therefore i have created a type which allows me to specify the "pet type"
2023-03-07 19:18:39 +0100 <segfaultfizzbuzz> however empirically, this is a "wrong type" because if i learn about more people
2023-03-07 19:18:42 +0100 <geekosaur> my mom had a pet turtle. how does your alien deal with that?
2023-03-07 19:18:47 +0100 <segfaultfizzbuzz> i will discover that there also are pet turtles, pet parrots, etc
2023-03-07 19:19:06 +0100 <segfaultfizzbuzz> geekosaur: the alien falsifies the type
2023-03-07 19:19:16 +0100 <segfaultfizzbuzz> so it is a "wrong" type, and the type is "empirically wrong"
2023-03-07 19:19:20 +0100 <mauke> ok, so you've modeled the problem wrong
2023-03-07 19:19:29 +0100 <mauke> "wrong"
2023-03-07 19:19:47 +0100 <segfaultfizzbuzz> so a human (me) defined a type (Pet) based on some empirical observation (20 people)
2023-03-07 19:19:49 +0100 <mauke> doesn't mean the type is wrong
2023-03-07 19:20:19 +0100 <segfaultfizzbuzz> at the very least the type would need to be data CorrectPet = Cat | Dog | None | Other
2023-03-07 19:20:41 +0100 <mauke> or I could classify parrots as Cat
2023-03-07 19:20:45 +0100 <segfaultfizzbuzz> lol
2023-03-07 19:21:37 +0100 <segfaultfizzbuzz> https://www.youtube.com/watch?v=B-eeNvUEGDk
2023-03-07 19:22:26 +0100 <segfaultfizzbuzz> anyway, the common assumption is that as the human (programmer) i am inputting this type information
2023-03-07 19:22:35 +0100 <geekosaur> unless the circumstances dictate that only cats and dogs are tracked, so None is the correct answer for other pets
2023-03-07 19:22:50 +0100 <geekosaur> (and yes, I can think of such circumstances)
2023-03-07 19:23:05 +0100 <geekosaur> (I'm not sure an alien would care about them though)
2023-03-07 19:23:10 +0100 <segfaultfizzbuzz> and in many circumstances (but not all) the type information comes from some kind of empirical situation
2023-03-07 19:23:18 +0100 <monochrom> No no, I wonder if polymorphic recursion (data X a = Nil | P (X [a])) allows unboundedly many types to exist in a program (grow with time) without needing unbounded memory because 1. compile just checks base cases and inductive cases, 2. type erasure, so not in the exe.
2023-03-07 19:23:37 +0100 <monochrom> s/compile/compiler/
2023-03-07 19:24:14 +0100 <segfaultfizzbuzz> put another way, how would i make a "unit test for types"
2023-03-07 19:24:39 +0100 <mauke> the type is just Pet
2023-03-07 19:24:45 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-03-07 19:24:56 +0100 <mauke> Cat is a data constructor
2023-03-07 19:25:14 +0100 <segfaultfizzbuzz> right
2023-03-07 19:26:02 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-03-07 19:26:40 +0100 <segfaultfizzbuzz> i will ask this another way: how many types are there on wikipedia, whether explicitly defined in a computer program or implicitly defined (such as listing a bunch of city names, the city name itself being a type)?
2023-03-07 19:27:07 +0100 <monochrom> I don't understand the question.
2023-03-07 19:27:24 +0100 <mauke> segfaultfizzbuzz: can you give me an example of an expression of type Los Angeles?
2023-03-07 19:27:40 +0100 <segfaultfizzbuzz> Los Angeles is not a type (i think?) but CityName is a type
2023-03-07 19:28:25 +0100 <segfaultfizzbuzz> CityName is not explicitly defined on wikipedia--we will suppose that there is no source code on wikipedia which defines a type system for information about cities
2023-03-07 19:28:48 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-03-07 19:29:06 +0100 <segfaultfizzbuzz> however hypothetically i might be able to feed wikipedia to a computer program, and that computer program could discover a CityName type, in principle
2023-03-07 19:30:00 +0100 <mauke> take a bucket of seawater. how many sets are there in that bucket?
2023-03-07 19:30:05 +0100 <segfaultfizzbuzz> lol
2023-03-07 19:30:06 +0100 <monochrom> You start with what you want types for, then that reason drives what you consider to be types.
2023-03-07 19:31:06 +0100 <segfaultfizzbuzz> so automated systems cannot discover types?
2023-03-07 19:31:10 +0100talismanick(~talismani@2601:200:c000:f7a0::5321) (Ping timeout: 260 seconds)
2023-03-07 19:31:26 +0100 <monochrom> I wouldn't say that.
2023-03-07 19:31:47 +0100 <segfaultfizzbuzz> that is to say, humans are uniquely priviledged in being capable of identifying types?
2023-03-07 19:32:25 +0100 <monochrom> I don't make the leap of faith from "you need to have a reason/purpose" to "you need to be human".
2023-03-07 19:32:36 +0100 <monochrom> or "you need to be non-machine" for that matter
2023-03-07 19:32:48 +0100 <mauke> can automated systems discover pet names? or are humans uniquely privileged in being capable of identifying pets' names?
2023-03-07 19:33:03 +0100 <segfaultfizzbuzz> ok, so then it seems that we agree that there should be, at the least, some heuristics, and maybe some rigid rules, for defining when we empirically encounter a type
2023-03-07 19:34:33 +0100 <monochrom> It is really no different if you s/types/programs/ or s/types/axioms/ or s/types/nouns/ or s/types/verbs/ or ...
2023-03-07 19:35:27 +0100 <mauke> or sets
2023-03-07 19:35:36 +0100 <mauke> which you empirically encounter in a bucket of seawater
2023-03-07 19:35:37 +0100jwiegley(~jwiegley@76-234-69-149.lightspeed.frokca.sbcglobal.net) (Quit: ZNC - http://znc.in)
2023-03-07 19:35:37 +0100johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net) (Quit: ZNC - http://znc.in)
2023-03-07 19:37:45 +0100 <segfaultfizzbuzz> lol
2023-03-07 19:39:30 +0100 <mauke> OO is the most natural way to write programs because the real world naturally decomposes into classes and subclasses of objects
2023-03-07 19:39:34 +0100 <segfaultfizzbuzz> a relevant quote might be: "walks like a type, quacks like a type, what are walk and quack?"
2023-03-07 19:40:55 +0100superbil(~superbil@1-34-176-171.hinet-ip.hinet.net) (Ping timeout: 268 seconds)
2023-03-07 19:41:03 +0100 <geekosaur> an AI could well define its own types. there's no guarantee they'd look like ours. because a type describes (part of) a problem domain, and the problem is specified by the specifier, whether that be human, alien, AI, whatever
2023-03-07 19:41:19 +0100superbil(~superbil@1-34-176-171.hinet-ip.hinet.net)
2023-03-07 19:41:32 +0100 <geekosaur> or even animals, although they're not generally solving as complex problems (we think)
2023-03-07 19:41:46 +0100swan(~swan@209.133.79.6)
2023-03-07 19:41:54 +0100swanSwan1000
2023-03-07 19:43:32 +0100zeenk(~zeenk@2a02:2f04:a20d:f900::7fe)
2023-03-07 19:44:03 +0100 <segfaultfizzbuzz> bbiab i will read the logs
2023-03-07 19:44:06 +0100segfaultfizzbuzz(~segfaultf@12.172.217.142) (Quit: segfaultfizzbuzz)
2023-03-07 19:48:55 +0100Inst(~Inst@2601:6c4:4081:54f0:a1f8:4ef8:3abb:c29) (Read error: Connection reset by peer)
2023-03-07 19:49:17 +0100Inst(~Inst@2601:6c4:4081:54f0:a1f8:4ef8:3abb:c29)
2023-03-07 19:51:54 +0100lbseale(~quassel@user/ep1ctetus)
2023-03-07 19:51:54 +0100lbseale(~quassel@user/ep1ctetus) (Client Quit)
2023-03-07 19:54:18 +0100lbseale(~quassel@user/ep1ctetus)
2023-03-07 19:55:21 +0100lbseale(~quassel@user/ep1ctetus) (Client Quit)
2023-03-07 19:56:29 +0100lbseale(~quassel@user/ep1ctetus)
2023-03-07 20:01:33 +0100gensyst(gensyst@user/gensyst) (Quit: Leaving)
2023-03-07 20:01:44 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-03-07 20:02:18 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-03-07 20:08:52 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559) (Remote host closed the connection)
2023-03-07 20:14:15 +0100lbseale(~quassel@user/ep1ctetus) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-03-07 20:15:24 +0100lbseale(~quassel@user/ep1ctetus)
2023-03-07 20:16:59 +0100polyphem_(~rod@2a02:810d:840:8754:da48:4c29:8382:1f9b) (Ping timeout: 248 seconds)
2023-03-07 20:17:59 +0100polyphem_(~rod@2a02:810d:840:8754:224e:f6ff:fe5e:bc17)
2023-03-07 20:20:53 +0100pdw(~user@215.156.62.185.bridgefibre.net) (Quit: ERC (IRC client for Emacs 26.3))
2023-03-07 20:26:23 +0100wootehfoot(~wootehfoo@user/wootehfoot)
2023-03-07 20:26:41 +0100 <krei-se> @geekosaur as far as i understood from d2l AI has no idea about types, its "just" complex n-dimensional functions.
2023-03-07 20:26:41 +0100 <lambdabot> Unknown command, try @list
2023-03-07 20:26:59 +0100 <krei-se> geekosaur: as far as i understood from d2l AI has no idea about types, its "just" complex n-dimensional functions.
2023-03-07 20:27:33 +0100 <geekosaur> segfaultfizzbuzz has some odd notions of how things work
2023-03-07 20:27:46 +0100 <krei-se> we all start somewhere
2023-03-07 20:29:52 +0100Swan1000(~swan@209.133.79.6) (Quit: Client closed)
2023-03-07 20:30:19 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds)
2023-03-07 20:31:42 +0100 <geekosaur> in any case, my point still stands: what constitutes a type is not determined by the reader but by the writer
2023-03-07 20:34:03 +0100 <krei-se> i see. So if you take a stand from a self-learning solution-finder like an AI you would take the types you find in a specific domain and work from there into composable functions?
2023-03-07 20:36:45 +0100 <stefan-_> geekosaur, it could also be determined by a community, i.e. a "shared conceptualization" (-> ontology)
2023-03-07 20:41:15 +0100CiaoSen(~Jura@p200300c9570e91002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-03-07 20:42:43 +0100ft(~ft@p3e9bc443.dip0.t-ipconnect.de)
2023-03-07 20:43:22 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559)
2023-03-07 20:45:17 +0100 <geekosaur> stefan-_, absolutely. consider that "Leslie" changed from a male name to a female one in the West recently enough that there are still males around with that name
2023-03-07 20:50:19 +0100gok(~gok@c-71-205-240-222.hsd1.co.comcast.net)
2023-03-07 20:50:26 +0100Lycurgus(~juan@user/Lycurgus)
2023-03-07 20:51:52 +0100mastarija(~mastarija@188.252.198.44)
2023-03-07 20:52:32 +0100 <mastarija> Is there a lens like `last` that focuses on the last element of a list / structure?
2023-03-07 20:54:08 +0100son0p(~ff@181.136.122.143) (Ping timeout: 248 seconds)
2023-03-07 20:55:39 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-03-07 20:56:24 +0100 <mastarija> Is there a nice way to focus on the last element of a list using lenses?
2023-03-07 20:56:47 +0100 <mastarija> I could use `ix (length xs - 1)` but that seems like wasted effort
2023-03-07 20:56:51 +0100 <lyxia> https://hackage.haskell.org/package/lens-5.2.1/docs/Control-Lens-Lens.html#v:last1
2023-03-07 20:56:56 +0100 <lyxia> https://hackage.haskell.org/package/lens-5.2.1/docs/Control-Lens-Fold.html#v:lastOf
2023-03-07 20:57:02 +0100codaraxis(~codaraxis@user/codaraxis)
2023-03-07 20:57:17 +0100 <mastarija> thx lyxia , don't know how I've missed those
2023-03-07 20:57:18 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-07 20:57:31 +0100chomwitt(~chomwitt@2a02:587:7a18:6d00:1ac0:4dff:fedb:a3f1) (Ping timeout: 248 seconds)
2023-03-07 21:00:05 +0100dsrt^(~dsrt@c-24-30-76-89.hsd1.ga.comcast.net)
2023-03-07 21:00:19 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-03-07 21:01:48 +0100 <mastarija> On second thought, how do I use this? `xs & last1 .~ 10` doesn't appear to be working
2023-03-07 21:03:26 +0100 <mauke> what type is xs?
2023-03-07 21:03:56 +0100 <dminuoso> @let import qualified Data.NonEmpty as NE
2023-03-07 21:03:57 +0100 <lambdabot> /sandbox/tmp/.L.hs:109:1: error:
2023-03-07 21:03:57 +0100 <lambdabot> Could not find module ‘Data.NonEmpty’
2023-03-07 21:03:57 +0100 <lambdabot> Use -v (or `:set -v` in ghci) to see a list of the files searched for.
2023-03-07 21:04:01 +0100 <dminuoso> @let import qualified Data.List.NonEmpty as NE
2023-03-07 21:04:03 +0100 <lambdabot> Defined.
2023-03-07 21:04:16 +0100 <dminuoso> > 1 :| [2,3,4] & last1 .~ 10
2023-03-07 21:04:17 +0100 <lambdabot> 1 :| [2,3,10]
2023-03-07 21:04:26 +0100ormaaj(~ormaaj@user/ormaaj) (Quit: Reconnecting)
2023-03-07 21:04:42 +0100ormaaj(~ormaaj@user/ormaaj)
2023-03-07 21:05:01 +0100 <mauke> > liftA2 (:|) head tail [1,2,3,4] & last1 .~ 10
2023-03-07 21:05:04 +0100 <lambdabot> 1 :| [2,3,10]
2023-03-07 21:05:27 +0100 <dminuoso> :t NE.fromList
2023-03-07 21:05:29 +0100 <lambdabot> [a] -> NonEmpty a
2023-03-07 21:05:40 +0100 <dminuoso> That's probably a bit easier on the eyes
2023-03-07 21:06:45 +0100 <mauke> yes, but it doesn't show a call stack on error
2023-03-07 21:06:58 +0100 <mastarija> dminuoso: it's just a list of something
2023-03-07 21:07:00 +0100 <dminuoso> fromList :: HasCallStack => [a] -> NonEmpty a
2023-03-07 21:07:02 +0100 <mauke> plus (:|) looks like a monkey
2023-03-07 21:07:07 +0100 <dminuoso> mauke: Looks like it does, to me
2023-03-07 21:07:34 +0100 <mauke> https://hackage.haskell.org/package/base-4.16.3.0/docs/src/Data.List.NonEmpty.html#fromList
2023-03-07 21:07:45 +0100 <dminuoso> Oh.
2023-03-07 21:07:56 +0100 <dminuoso> That's 4.16.3
2023-03-07 21:08:14 +0100 <mastarija> Does `last1` not work on simple list `[a]`?
2023-03-07 21:08:16 +0100 <dminuoso> Guess that changed in 9.6
2023-03-07 21:08:23 +0100 <dminuoso> mastarija: Correct, observe the type signature
2023-03-07 21:08:29 +0100 <dminuoso> last1 :: Traversable1 t => Lens' (t a) a
2023-03-07 21:08:35 +0100 <mastarija> Aha...
2023-03-07 21:08:39 +0100 <dminuoso> It requires `t` (your [a]) to satisfy Traversable1
2023-03-07 21:08:44 +0100 <mastarija> `Traversable1`, not `Traversable`
2023-03-07 21:08:47 +0100 <dminuoso> Right.
2023-03-07 21:09:07 +0100 <dminuoso> mastarija: Hence going through NonEmpty in the examples above
2023-03-07 21:09:07 +0100 <mastarija> I mean, can't we have `last` that will simply do nothing on empty list?
2023-03-07 21:09:30 +0100 <dminuoso> Well you could have an (affine) traversal, but not a lens.
2023-03-07 21:10:43 +0100 <mastarija> Is there such a utility?
2023-03-07 21:12:14 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559) (Remote host closed the connection)
2023-03-07 21:21:48 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 255 seconds)
2023-03-07 21:24:00 +0100Albina_Pavlovna(~Albina_Pa@cpe-66-65-40-132.nyc.res.rr.com)
2023-03-07 21:29:37 +0100 <ncf> last1 maybe
2023-03-07 21:29:47 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-03-07 21:30:21 +0100 <ncf> hmm that's a lens
2023-03-07 21:30:56 +0100wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2023-03-07 21:31:19 +0100pavonia(~user@user/siracusa)
2023-03-07 21:31:37 +0100 <geekosaur> :t lastOf
2023-03-07 21:31:38 +0100 <lambdabot> Getting (Rightmost a) s a -> s -> Maybe a
2023-03-07 21:32:10 +0100 <ncf> i guess such a traversal would be non-trivial to implement
2023-03-07 21:32:39 +0100 <ncf> in terms of Traversable at least
2023-03-07 21:35:35 +0100pwntips(~user@24-113-98-114.wavecable.com) (Ping timeout: 268 seconds)
2023-03-07 21:36:12 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-03-07 21:38:26 +0100 <ncf> hm. maybe something like \ f -> fmap getReverse . taking 1 f . Reverse
2023-03-07 21:38:45 +0100hgolden_(~hgolden@cpe-172-251-233-141.socal.res.rr.com) (Remote host closed the connection)
2023-03-07 21:39:44 +0100zeenk(~zeenk@2a02:2f04:a20d:f900::7fe) (Quit: Konversation terminated!)
2023-03-07 21:42:30 +0100 <ncf> @let lastT f = fmap getReverse . taking 1 traverse f . Reverse
2023-03-07 21:42:31 +0100 <lambdabot> /sandbox/tmp/.L.hs:167:1: error: [-Woverlapping-patterns, -Werror=overlappin...
2023-03-07 21:42:31 +0100 <lambdabot> Pattern match is redundant
2023-03-07 21:42:31 +0100 <lambdabot> In an equation for ‘lastT’: lastT f = ...
2023-03-07 21:42:42 +0100 <ncf> (i defined that in PM)
2023-03-07 21:42:46 +0100 <ncf> > "hi" & lastT %~ succ
2023-03-07 21:42:48 +0100 <lambdabot> "hj"
2023-03-07 21:42:49 +0100 <ncf> > "" & lastT %~ succ
2023-03-07 21:42:50 +0100 <lambdabot> ""
2023-03-07 21:48:34 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-07 21:48:58 +0100mei(~mei@user/mei) (Remote host closed the connection)
2023-03-07 21:51:22 +0100mei(~mei@user/mei)
2023-03-07 21:52:59 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds)
2023-03-07 21:54:43 +0100stef204(~stef204@user/stef204)
2023-03-07 21:58:02 +0100talismanick(~talismani@campus-107-253.ucdavis.edu)
2023-03-07 21:59:14 +0100stef204(~stef204@user/stef204) (Client Quit)
2023-03-07 22:01:34 +0100a_coll(~acoll@45.92.120.189)
2023-03-07 22:03:55 +0100NiceBird(~NiceBird@185.133.111.196)
2023-03-07 22:04:48 +0100juri__juri_
2023-03-07 22:06:04 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-07 22:12:43 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559)
2023-03-07 22:14:00 +0100thegeekinside(~thegeekin@189.141.115.134) (Ping timeout: 255 seconds)
2023-03-07 22:14:19 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds)
2023-03-07 22:16:59 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:182e:ca34:e210:1559) (Ping timeout: 248 seconds)
2023-03-07 22:22:49 +0100lambdabot(~lambdabot@haskell/bot/lambdabot) (Remote host closed the connection)
2023-03-07 22:25:03 +0100zeenk(~zeenk@2a02:2f04:a20d:f900::7fe)
2023-03-07 22:26:15 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com)
2023-03-07 22:30:57 +0100gok(~gok@c-71-205-240-222.hsd1.co.comcast.net) (Quit: Client closed)
2023-03-07 22:35:30 +0100talismanick(~talismani@campus-107-253.ucdavis.edu) (Ping timeout: 260 seconds)
2023-03-07 22:37:11 +0100Lumia(~Lumia@user/Lumia)
2023-03-07 22:37:51 +0100_xor(~xor@72.49.195.228) (Ping timeout: 255 seconds)
2023-03-07 22:39:05 +0100_xor(~xor@72.49.195.228)
2023-03-07 22:40:09 +0100Albina_Pavlovna(~Albina_Pa@cpe-66-65-40-132.nyc.res.rr.com) (Quit: ZZZzzz…)
2023-03-07 22:40:39 +0100Albina_Pavlovna(~Albina_Pa@cpe-66-65-40-132.nyc.res.rr.com)
2023-03-07 22:44:26 +0100shapr(~user@68.54.166.125) (Remote host closed the connection)
2023-03-07 22:46:37 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-07 22:50:46 +0100CiaoSen(~Jura@p200300c9570e91002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-03-07 22:54:38 +0100johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net)
2023-03-07 22:55:08 +0100jwiegley(~jwiegley@76-234-69-149.lightspeed.frokca.sbcglobal.net)
2023-03-07 22:56:03 +0100thegeekinside(~thegeekin@189.141.115.134)
2023-03-07 23:04:14 +0100son0p(~ff@181.136.122.143)
2023-03-07 23:04:40 +0100segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-03-07 23:05:47 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-03-07 23:06:41 +0100Albina_Pavlovna(~Albina_Pa@cpe-66-65-40-132.nyc.res.rr.com) (Quit: ZZZzzz…)
2023-03-07 23:10:11 +0100Albina_Pavlovna(~Albina_Pa@cpe-66-65-40-132.nyc.res.rr.com)
2023-03-07 23:11:14 +0100dolio(~dolio@130.44.134.54) (Quit: ZNC 1.8.2 - https://znc.in)
2023-03-07 23:12:21 +0100 <mastarija> what's the difference between an `IndexedTraversal` and something like `Index m -> Traversal' m (IxValue m)`?
2023-03-07 23:17:34 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi)
2023-03-07 23:19:41 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-03-07 23:20:00 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-03-07 23:20:10 +0100dolio(~dolio@130.44.134.54)
2023-03-07 23:20:11 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-03-07 23:20:25 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 268 seconds)
2023-03-07 23:21:04 +0100janus(janus@anubis.0x90.dk)
2023-03-07 23:21:41 +0100 <janus> I found documentation of the _ccall_ FFI old GHC's use! https://web.archive.org/web/20020625130011/http://www.ki.informatik.uni-frankfurt.de/doc/html/ghc-…
2023-03-07 23:23:06 +0100michalz(~michalz@185.246.204.126) (Remote host closed the connection)
2023-03-07 23:23:41 +0100lambdabot(~lambdabot@silicon.int-e.eu)
2023-03-07 23:23:41 +0100lambdabot(~lambdabot@silicon.int-e.eu) (Changing host)
2023-03-07 23:23:41 +0100lambdabot(~lambdabot@haskell/bot/lambdabot)
2023-03-07 23:27:19 +0100mrcsno(~mrcsno@user/mrcsno)
2023-03-07 23:29:40 +0100segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 268 seconds)
2023-03-07 23:30:06 +0100 <monochrom> 2.10 that's old
2023-03-07 23:31:02 +0100 <monochrom> And casm...
2023-03-07 23:32:08 +0100pwntips(~user@24-113-98-114.wavecable.com)
2023-03-07 23:37:39 +0100 <janus> trying to bootstrap and I have made some progress getting GHC 0.29 to compile on NHC98
2023-03-07 23:37:52 +0100 <janus> but GHC 3 needs GHC 2.10 to compile and I don't know where to get the sources
2023-03-07 23:38:21 +0100 <janus> I wrote an sysadmin at the University of Glasgow an email, asking if they have backups of their ftp server
2023-03-07 23:38:52 +0100 <janus> If somebody has it, please let me know...
2023-03-07 23:41:07 +0100 <janus> Also wrote the University of Warsaw since this listing suggests they had it backed up: https://www.ftpstatus.com/site_directories.php?name=ftp.mimuw.edu.pl
2023-03-07 23:41:33 +0100 <janus> if they mirrored it at the University of Warsaw, surely enough people mirrored it, there must be a copy somewhere
2023-03-07 23:42:26 +0100 <janus> Also discovered that there is an even older release than 0.29 available at discmaster! 0.16 http://discmaster.textfiles.com/browse/951/LANGUAGE%20OS.iso/haskell/glasgow/ghc-src.lha
2023-03-07 23:43:23 +0100 <janus> the sources of 0.29 suggest that it was supposed to work with multiple compilers though, so not sure 0.16 buys us a lot since it looks like it is only supposed to compile on HBC
2023-03-07 23:43:59 +0100 <janus> but it is good to know that we actually have a release of GHC that isn't self-hosting
2023-03-07 23:44:47 +0100 <janus> the University of Warsaw also has a backup of Chalmers, so maybe the LML compiler can be recovered? Then HBC could be compiled https://github.com/haskell-implementations/hbc
2023-03-07 23:45:42 +0100 <mauke> janus: https://github.com/ghc/ghc/tree/6df3befbd269355a600a16c69468025cd2c793aa ?
2023-03-07 23:46:22 +0100 <janus> oh cool, of course! thanks mauke
2023-03-07 23:47:05 +0100 <janus> will post your link at https://gitlab.haskell.org/ghc/homepage/-/issues/8
2023-03-07 23:47:20 +0100 <janus> do you want credit?
2023-03-07 23:48:41 +0100 <mauke> ... credit for clicking around on github? :-)
2023-03-07 23:48:50 +0100 <janus> sure sure, credit is cheap :P
2023-03-07 23:49:05 +0100 <mauke> ok then :-)
2023-03-07 23:49:47 +0100 <mauke> note that the commit is approximate; I was just looking for something that updated the ghc/ANNOUNCE file to 2.10
2023-03-07 23:50:14 +0100NiceBird(~NiceBird@185.133.111.196) (Quit: Leaving)
2023-03-07 23:50:30 +0100 <janus> yeah, makes sense
2023-03-07 23:53:18 +0100 <Hecate> what are the rules for bootstrapping? Do you always have to start from C?
2023-03-07 23:53:42 +0100 <Hecate> okay nevermind I realised my question was stupid right after pressing Enter.
2023-03-07 23:54:27 +0100 <mauke> it's too bad old releases aren't tagged properly
2023-03-07 23:55:47 +0100 <mauke> with perl I can just checkout "perl-2.001" from 1988 or whatever
2023-03-07 23:56:03 +0100 <janus> Hecate: i would be pretty happy if i could just get, let's say the ghc 8.6.5 binary (that ancient for me already :P) without using any binary GHC build
2023-03-07 23:56:11 +0100Lumia(~Lumia@user/Lumia) (Ping timeout: 248 seconds)
2023-03-07 23:56:56 +0100 <janus> Hecate: so I don't actually remember what I did to get NHC compiled, maybe it used some binary artifact that shipped with the distribution. but bootstrapping NHC is a separate effort in my eyes
2023-03-07 23:58:18 +0100 <janus> it should all compose anyway
2023-03-07 23:58:20 +0100Albina_Pavlovna(~Albina_Pa@cpe-66-65-40-132.nyc.res.rr.com) (Ping timeout: 260 seconds)
2023-03-07 23:58:34 +0100Midjak(~Midjak@82.66.147.146) (Quit: This computer has gone to sleep)
2023-03-07 23:58:58 +0100Albina_Pavlovna(~Albina_Pa@cpe-66-65-40-132.nyc.res.rr.com)