IRCBrowse

2023/01/17

2023-01-17 00:00:13 +0100chiselfu1e(~chiselfus@user/chiselfuse) (Remote host closed the connection)
2023-01-17 00:00:49 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-01-17 00:01:19 +0100TheCoffeMaker(~TheCoffeM@user/thecoffemaker)
2023-01-17 00:06:40 +0100 <monochrom> Do you mean like "foo ()" ?
2023-01-17 00:07:09 +0100mud(~mud@user/kadoban)
2023-01-17 00:07:24 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-17 00:11:34 +0100 <geekosaur> I think they mean the parse tree is lopsided toward the right
2023-01-17 00:14:33 +0100barzo(~hd@31.223.41.44)
2023-01-17 00:16:23 +0100p3n_(~p3n@217.198.124.246) (Ping timeout: 268 seconds)
2023-01-17 00:18:48 +0100biberu(~biberu@user/biberu) (Read error: Connection reset by peer)
2023-01-17 00:23:48 +0100 <__monty__> geekosaur: Thank you for trying that out.
2023-01-17 00:24:21 +0100biberu(~biberu@user/biberu)
2023-01-17 00:25:24 +0100 <__monty__> I'm a bit stumped. Checking with verbosity it seems like the path *is* being added to the call to GHC. So I don't understand why cabal says the module isn't found but doesn't say which directories it's looking in.
2023-01-17 00:26:23 +0100p3n(~p3n@2a00:19a0:3:7c:0:d9c6:7cf6:1)
2023-01-17 00:27:19 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Remote host closed the connection)
2023-01-17 00:27:20 +0100 <alexfmpe[m]> <geekosaur> "I think they mean the parse tree..." <- yeah, something like `(a, (b, (c, (d, e))))`
2023-01-17 00:27:39 +0100 <EvanR> right biased tree?
2023-01-17 00:28:34 +0100AlexNoo_(~AlexNoo@94.233.240.156)
2023-01-17 00:28:43 +0100Alex_test(~al_test@94.233.240.156) (Ping timeout: 252 seconds)
2023-01-17 00:29:04 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 00:29:24 +0100 <alexfmpe[m]> I guess? is that a commonly used term for this? googling that seems to give me some other 'biased' concept
2023-01-17 00:30:20 +0100AlexZenon(~alzenon@94.233.240.156) (Ping timeout: 272 seconds)
2023-01-17 00:30:55 +0100AlexNoo(~AlexNoo@94.233.240.156) (Ping timeout: 252 seconds)
2023-01-17 00:31:18 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-01-17 00:33:00 +0100 <geekosaur> I get multiple kinds of biasing for "right-biased tree" but the first hit sounds closeish: describes a balanced tree that becomes unbalanced in some direction on insertion of a new node
2023-01-17 00:33:19 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 260 seconds)
2023-01-17 00:34:47 +0100 <geekosaur> "right-biased parse tree" is no better, sadly
2023-01-17 00:36:03 +0100 <EvanR> a maximally unbalanced tree xD
2023-01-17 00:36:13 +0100chiselfuse(~chiselfus@user/chiselfuse) (Remote host closed the connection)
2023-01-17 00:36:22 +0100Alex_test(~al_test@94.233.240.156)
2023-01-17 00:36:54 +0100mizlan(~mizlan@2607:f010:2e9:21:a875:7a6d:b1bf:f503)
2023-01-17 00:36:59 +0100AlexZenon(~alzenon@94.233.240.156)
2023-01-17 00:40:49 +0100 <mauke> a tree cosplaying as a linked list
2023-01-17 00:41:15 +0100mizlan(~mizlan@2607:f010:2e9:21:a875:7a6d:b1bf:f503) (Ping timeout: 260 seconds)
2023-01-17 00:43:10 +0100jero98772(~jero98772@2800:484:1d80:d8ce:3490:26c5:1782:da8c)
2023-01-17 00:46:06 +0100mimmy__(~mimmy@86.48.14.201)
2023-01-17 00:46:47 +0100jmorris(uid537181@id-537181.uxbridge.irccloud.com)
2023-01-17 00:53:20 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 00:54:03 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-01-17 00:54:37 +0100abhixec(~abhinav@c-67-169-139-16.hsd1.ca.comcast.net)
2023-01-17 00:55:26 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-01-17 00:56:24 +0100cheater_(~Username@user/cheater)
2023-01-17 00:56:51 +0100tremon(~tremon@83-85-213-108.cable.dynamic.v4.ziggo.nl) (Quit: getting boxed in)
2023-01-17 00:58:11 +0100L29Ah(~L29Ah@wikipedia/L29Ah) (Read error: Connection reset by peer)
2023-01-17 00:58:24 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 260 seconds)
2023-01-17 00:59:11 +0100cheater(~Username@user/cheater) (Ping timeout: 252 seconds)
2023-01-17 00:59:20 +0100cheater_cheater
2023-01-17 01:01:42 +0100L29Ah(~L29Ah@wikipedia/L29Ah)
2023-01-17 01:06:54 +0100cheater(~Username@user/cheater) (Read error: Connection reset by peer)
2023-01-17 01:06:54 +0100L29Ah(~L29Ah@wikipedia/L29Ah) (Read error: Connection reset by peer)
2023-01-17 01:07:42 +0100cheater(~Username@user/cheater)
2023-01-17 01:08:45 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-01-17 01:10:29 +0100abhixec(~abhinav@c-67-169-139-16.hsd1.ca.comcast.net) (Read error: Connection reset by peer)
2023-01-17 01:13:59 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-01-17 01:13:59 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-01-17 01:13:59 +0100wroathe(~wroathe@user/wroathe)
2023-01-17 01:17:15 +0100cheater_(~Username@user/cheater)
2023-01-17 01:18:44 +0100 <carter> tomsmeding: hello!
2023-01-17 01:19:11 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-01-17 01:20:20 +0100cheater(~Username@user/cheater) (Ping timeout: 260 seconds)
2023-01-17 01:20:23 +0100cheater_cheater
2023-01-17 01:20:29 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-01-17 01:22:03 +0100Lycurgus(~juan@user/Lycurgus)
2023-01-17 01:25:27 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) (Quit: Leaving.)
2023-01-17 01:32:30 +0100chiselfuse(~chiselfus@user/chiselfuse) (Remote host closed the connection)
2023-01-17 01:33:05 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-01-17 01:36:11 +0100dcoutts_(~duncan@host86-153-247-191.range86-153.btcentralplus.com)
2023-01-17 01:36:38 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d14:f10:c58a:afef)
2023-01-17 01:38:06 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-17 01:38:38 +0100dcoutts(~duncan@host213-122-143-153.range213-122.btcentralplus.com) (Ping timeout: 246 seconds)
2023-01-17 01:40:50 +0100opticblast(~Thunderbi@75.104.70.12)
2023-01-17 01:43:10 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 272 seconds)
2023-01-17 01:45:00 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 01:45:48 +0100acidjnk(~acidjnk@p54ad56b7.dip0.t-ipconnect.de) (Ping timeout: 268 seconds)
2023-01-17 01:48:28 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-01-17 01:49:28 +0100tdrsrmaeo^(~tdrsrmaeo@76.145.190.81) (Remote host closed the connection)
2023-01-17 01:49:44 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 260 seconds)
2023-01-17 01:55:33 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2023-01-17 01:59:05 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-17 02:02:31 +0100opticblast(~Thunderbi@75.104.70.12) (Read error: Connection reset by peer)
2023-01-17 02:07:59 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 02:10:45 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-01-17 02:12:10 +0100thebinary(~thebinary@2400:1a00:b040:c75d:84c9:5a90:c46b:31e6)
2023-01-17 02:12:29 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 260 seconds)
2023-01-17 02:14:09 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2023-01-17 02:15:37 +0100cheater_(~Username@user/cheater)
2023-01-17 02:15:49 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-17 02:16:01 +0100cheater(~Username@user/cheater) (Ping timeout: 268 seconds)
2023-01-17 02:16:03 +0100cheater_cheater
2023-01-17 02:16:53 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-01-17 02:18:40 +0100xff0x_(~xff0x@2405:6580:b080:900:b37:9eab:7cc0:9b97) (Ping timeout: 260 seconds)
2023-01-17 02:19:39 +0100urdh(~urdh@user/urdh) (Ping timeout: 265 seconds)
2023-01-17 02:19:51 +0100manwithl-(~manwithlu@194.177.28.128) (Ping timeout: 252 seconds)
2023-01-17 02:20:04 +0100manwithluck(~manwithlu@194.177.28.128)
2023-01-17 02:21:34 +0100razetime(~Thunderbi@117.193.0.183)
2023-01-17 02:22:08 +0100L29Ah(~L29Ah@wikipedia/L29Ah)
2023-01-17 02:23:08 +0100troydm(~troydm@user/troydm)
2023-01-17 02:24:50 +0100cheater(~Username@user/cheater) (Ping timeout: 256 seconds)
2023-01-17 02:25:06 +0100opticblast(~Thunderbi@75.104.69.33)
2023-01-17 02:30:44 +0100mizlan(~mizlan@2607:f010:2e9:21:a875:7a6d:b1bf:f503)
2023-01-17 02:32:10 +0100thebinary(~thebinary@2400:1a00:b040:c75d:84c9:5a90:c46b:31e6) (Read error: Connection reset by peer)
2023-01-17 02:33:04 +0100cheater(~Username@user/cheater)
2023-01-17 02:33:49 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com)
2023-01-17 02:35:13 +0100mizlan(~mizlan@2607:f010:2e9:21:a875:7a6d:b1bf:f503) (Ping timeout: 252 seconds)
2023-01-17 02:36:22 +0100cheater_(~Username@user/cheater)
2023-01-17 02:38:14 +0100cheater__(~Username@user/cheater)
2023-01-17 02:39:00 +0100cheater(~Username@user/cheater) (Ping timeout: 256 seconds)
2023-01-17 02:40:33 +0100cheater(~Username@user/cheater)
2023-01-17 02:41:50 +0100cheater_(~Username@user/cheater) (Ping timeout: 256 seconds)
2023-01-17 02:42:37 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 02:42:55 +0100cheater__(~Username@user/cheater) (Ping timeout: 252 seconds)
2023-01-17 02:46:56 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 256 seconds)
2023-01-17 02:54:46 +0100Bocaneri(~sauvin@user/Sauvin)
2023-01-17 02:55:10 +0100BocaneriGuest9402
2023-01-17 02:56:40 +0100Sauvin(~sauvin@user/Sauvin) (Ping timeout: 252 seconds)
2023-01-17 03:04:38 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Ping timeout: 260 seconds)
2023-01-17 03:05:29 +0100Guest9402Sauvin
2023-01-17 03:07:11 +0100crns(~netcrns@user/crns) (Ping timeout: 260 seconds)
2023-01-17 03:08:24 +0100xff0x_(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-01-17 03:26:51 +0100meinside(uid24933@id-24933.helmsley.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-17 03:28:54 +0100opticblast(~Thunderbi@75.104.69.33) (Read error: Connection reset by peer)
2023-01-17 03:30:34 +0100talismanick(~talismani@2601:200:c181:4c40::1be2)
2023-01-17 03:37:04 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 260 seconds)
2023-01-17 03:39:46 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 03:41:20 +0100thebinary(~thebinary@2400:1a00:b040:c75d:84c9:5a90:c46b:31e6)
2023-01-17 03:42:22 +0100thebinary(~thebinary@2400:1a00:b040:c75d:84c9:5a90:c46b:31e6) (Read error: Connection reset by peer)
2023-01-17 03:45:18 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 256 seconds)
2023-01-17 03:55:30 +0100Xeroine(~Xeroine@user/xeroine) (Quit: ZNC 1.8.2+deb2+b1 - https://znc.in)
2023-01-17 03:55:49 +0100Xeroine(~Xeroine@user/xeroine)
2023-01-17 03:57:35 +0100elbear(~lucian@86.127.154.189)
2023-01-17 03:59:14 +0100thebinary(~thebinary@2400:1a00:b040:c75d:84c9:5a90:c46b:31e6)
2023-01-17 04:01:10 +0100thebinary(~thebinary@2400:1a00:b040:c75d:84c9:5a90:c46b:31e6) (Read error: Connection reset by peer)
2023-01-17 04:02:30 +0100elbear(~lucian@86.127.154.189) (Ping timeout: 272 seconds)
2023-01-17 04:07:24 +0100mimmy__(~mimmy@86.48.14.201) (Ping timeout: 256 seconds)
2023-01-17 04:11:20 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2023-01-17 04:13:00 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-01-17 04:14:57 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-01-17 04:14:57 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-01-17 04:14:57 +0100wroathe(~wroathe@user/wroathe)
2023-01-17 04:18:02 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-01-17 04:18:17 +0100jero98772(~jero98772@2800:484:1d80:d8ce:3490:26c5:1782:da8c) (Remote host closed the connection)
2023-01-17 04:21:03 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 260 seconds)
2023-01-17 04:21:11 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 04:23:13 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-01-17 04:26:40 +0100barzo(~hd@31.223.41.44) (Ping timeout: 256 seconds)
2023-01-17 04:27:50 +0100urdh(~urdh@user/urdh)
2023-01-17 04:28:53 +0100cheater_(~Username@user/cheater)
2023-01-17 04:29:30 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 256 seconds)
2023-01-17 04:29:48 +0100thebinary(~thebinary@2400:1a00:b040:c75d:84c9:5a90:c46b:31e6)
2023-01-17 04:30:28 +0100dsrt^(~dsrt@76.145.190.81)
2023-01-17 04:31:08 +0100Guest70(~Guest@2409:4073:404:ee41:d79b:dd65:22ac:944e)
2023-01-17 04:31:36 +0100thebinary(~thebinary@2400:1a00:b040:c75d:84c9:5a90:c46b:31e6) (Read error: Connection reset by peer)
2023-01-17 04:32:05 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 04:32:13 +0100sh1n(~sh1n@181.229.121.151) (Quit: zzz)
2023-01-17 04:32:14 +0100cheater(~Username@user/cheater) (Ping timeout: 246 seconds)
2023-01-17 04:32:18 +0100cheater_cheater
2023-01-17 04:32:35 +0100Guest7086(~Guest70@223.227.61.249)
2023-01-17 04:33:06 +0100Guest7086(~Guest70@223.227.61.249) (Client Quit)
2023-01-17 04:33:25 +0100Guest7086(~Guest7086@2409:4073:404:ee41:5af1:fc83:cbcf:c7ae)
2023-01-17 04:33:51 +0100Guest708688(~Guest7086@2409:4073:404:ee41:5af1:fc83:cbcf:c7ae)
2023-01-17 04:33:57 +0100crns(~netcrns@p4ff5e2bf.dip0.t-ipconnect.de)
2023-01-17 04:33:57 +0100crns(~netcrns@p4ff5e2bf.dip0.t-ipconnect.de) (Changing host)
2023-01-17 04:33:57 +0100crns(~netcrns@user/crns)
2023-01-17 04:34:48 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 272 seconds)
2023-01-17 04:35:03 +0100mimmy__(~mimmy@86.48.14.201)
2023-01-17 04:36:27 +0100Guest70868834(~Guest7086@2409:4073:404:ee41:5af1:fc83:cbcf:c7ae)
2023-01-17 04:36:48 +0100Guest70(~Guest@2409:4073:404:ee41:d79b:dd65:22ac:944e) (Ping timeout: 260 seconds)
2023-01-17 04:37:41 +0100mbuf(~Shakthi@49.204.120.232)
2023-01-17 04:37:41 +0100Guest7086(~Guest7086@2409:4073:404:ee41:5af1:fc83:cbcf:c7ae) (Client Quit)
2023-01-17 04:38:00 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 256 seconds)
2023-01-17 04:40:30 +0100mimmy__(~mimmy@86.48.14.201) (Ping timeout: 272 seconds)
2023-01-17 04:40:53 +0100Guest708688(~Guest7086@2409:4073:404:ee41:5af1:fc83:cbcf:c7ae) (Ping timeout: 260 seconds)
2023-01-17 04:41:17 +0100mimmy__(~mimmy@86.48.14.198)
2023-01-17 04:41:31 +0100Guest70868834(~Guest7086@2409:4073:404:ee41:5af1:fc83:cbcf:c7ae) (Quit: Client closed)
2023-01-17 04:45:16 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer)
2023-01-17 04:48:48 +0100Guest19(~Guest@2409:4073:404:ee41:5af1:fc83:cbcf:c7ae)
2023-01-17 04:49:58 +0100justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 265 seconds)
2023-01-17 04:51:27 +0100mizlan(~mizlan@2607:f010:2e9:21:a875:7a6d:b1bf:f503)
2023-01-17 04:52:19 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-01-17 04:52:19 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-01-17 04:52:19 +0100finn_elijaFinnElija
2023-01-17 04:55:44 +0100mizlan(~mizlan@2607:f010:2e9:21:a875:7a6d:b1bf:f503) (Ping timeout: 255 seconds)
2023-01-17 04:55:56 +0100razetime1(~Thunderbi@117.193.0.183)
2023-01-17 04:56:15 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 04:56:24 +0100td_(~td@83.135.9.45) (Ping timeout: 260 seconds)
2023-01-17 04:57:34 +0100razetime(~Thunderbi@117.193.0.183) (Ping timeout: 260 seconds)
2023-01-17 04:57:34 +0100razetime1razetime
2023-01-17 04:58:05 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 255 seconds)
2023-01-17 04:58:15 +0100td_(~td@83.135.9.4)
2023-01-17 05:03:37 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-01-17 05:05:43 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-17 05:07:06 +0100mimmy__(~mimmy@86.48.14.198) (Ping timeout: 272 seconds)
2023-01-17 05:14:43 +0100Guest19(~Guest@2409:4073:404:ee41:5af1:fc83:cbcf:c7ae) (Ping timeout: 260 seconds)
2023-01-17 05:23:03 +0100johnw(~johnw@2600:1700:cf00:db0:4874:7c64:7447:a5bd) (Quit: ZNC - http://znc.in)
2023-01-17 05:33:22 +0100mimmy__(~mimmy@37.19.212.48)
2023-01-17 05:36:20 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 255 seconds)
2023-01-17 05:36:52 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-01-17 05:38:28 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-17 05:39:24 +0100mimmy__(~mimmy@37.19.212.48) (Ping timeout: 272 seconds)
2023-01-17 05:41:50 +0100Guest94(~Guest@2409:4073:404:ee41:14cb:fb64:542b:938)
2023-01-17 05:43:10 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 256 seconds)
2023-01-17 05:46:35 +0100jmorris(uid537181@id-537181.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-17 05:49:35 +0100mizlan(~mizlan@2607:f010:2e9:21:a875:7a6d:b1bf:f503)
2023-01-17 05:51:28 +0100Guest94(~Guest@2409:4073:404:ee41:14cb:fb64:542b:938) (Ping timeout: 260 seconds)
2023-01-17 05:53:41 +0100mimmy__(~mimmy@86.48.14.202)
2023-01-17 05:56:12 +0100mizlan(~mizlan@2607:f010:2e9:21:a875:7a6d:b1bf:f503) (Ping timeout: 256 seconds)
2023-01-17 05:59:15 +0100mimmy__(~mimmy@86.48.14.202) (Ping timeout: 268 seconds)
2023-01-17 06:04:16 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Read error: Connection reset by peer)
2023-01-17 06:08:30 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 06:10:04 +0100iteratee(~kyle@162.218.222.107)
2023-01-17 06:10:23 +0100iteratee(~kyle@162.218.222.107) (Read error: Connection reset by peer)
2023-01-17 06:14:20 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) (Ping timeout: 256 seconds)
2023-01-17 06:15:04 +0100iteratee(~kyle@162.218.222.107)
2023-01-17 06:21:41 +0100piele(~piele@tbonesteak.creativeserver.net) (Ping timeout: 255 seconds)
2023-01-17 06:24:41 +0100bilegeek(~bilegeek@2600:1008:b05a:688d:3f3f:2fd5:db6:a724)
2023-01-17 06:28:19 +0100manwithluck(~manwithlu@194.177.28.128) (Quit: ZNC 1.8.2 - https://znc.in)
2023-01-17 06:29:39 +0100manwithluck(~manwithlu@194.177.28.128)
2023-01-17 06:30:31 +0100Sgeo_(~Sgeo@user/sgeo)
2023-01-17 06:30:35 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-01-17 06:32:08 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-01-17 06:32:25 +0100mizlan(~mizlan@2607:f010:2e9:21:a875:7a6d:b1bf:f503)
2023-01-17 06:34:05 +0100mimmy__(~mimmy@86.48.14.200)
2023-01-17 06:35:35 +0100bilegeek(~bilegeek@2600:1008:b05a:688d:3f3f:2fd5:db6:a724) (Read error: Connection reset by peer)
2023-01-17 06:35:48 +0100bilegeek(~bilegeek@2600:1008:b05a:688d:3f3f:2fd5:db6:a724)
2023-01-17 06:39:17 +0100bilegeek(~bilegeek@2600:1008:b05a:688d:3f3f:2fd5:db6:a724) (Client Quit)
2023-01-17 06:39:34 +0100mimmy__(~mimmy@86.48.14.200) (Ping timeout: 272 seconds)
2023-01-17 06:42:29 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow) (Quit: WeeChat 3.7.1)
2023-01-17 06:43:14 +0100mizlan(~mizlan@2607:f010:2e9:21:a875:7a6d:b1bf:f503) (Ping timeout: 256 seconds)
2023-01-17 06:44:56 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 256 seconds)
2023-01-17 06:51:05 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-01-17 06:51:10 +0100manwithluck(~manwithlu@194.177.28.128) (Ping timeout: 256 seconds)
2023-01-17 06:51:47 +0100manwithluck(~manwithlu@194.177.28.192)
2023-01-17 06:52:58 +0100johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net)
2023-01-17 06:54:17 +0100titibandit1(~titibandi@xdsl-81-173-160-143.nc.de)
2023-01-17 07:00:23 +0100caryhartline(~caryhartl@2600:1700:2d0:8d30:a4a8:25f2:538:8162) (Quit: caryhartline)
2023-01-17 07:04:36 +0100Lycurgus(~juan@user/Lycurgus)
2023-01-17 07:15:22 +0100elbear(~lucian@86.127.154.189)
2023-01-17 07:25:09 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-01-17 07:25:48 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-01-17 07:32:12 +0100use-value1(~Thunderbi@2a00:23c6:8a03:2f01:79a6:4fda:28eb:3ce6)
2023-01-17 07:33:58 +0100mizlan(~mizlan@2607:f010:2a7:1005:a0d7:fa40:4d30:af9f)
2023-01-17 07:34:51 +0100thegeekinside(~thegeekin@189.217.82.244) (Read error: Connection reset by peer)
2023-01-17 07:34:59 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:69f9:e48c:7103:7ff9) (Ping timeout: 264 seconds)
2023-01-17 07:34:59 +0100use-value1use-value
2023-01-17 07:38:12 +0100mizlan(~mizlan@2607:f010:2a7:1005:a0d7:fa40:4d30:af9f) (Ping timeout: 256 seconds)
2023-01-17 07:45:47 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:79a6:4fda:28eb:3ce6) (Ping timeout: 264 seconds)
2023-01-17 07:45:57 +0100use-value1(~Thunderbi@2a00:23c6:8a03:2f01:2428:84d7:7517:8523)
2023-01-17 07:46:14 +0100ub(~Thunderbi@p200300ecdf264e9fe5173bdb45e8ff9d.dip0.t-ipconnect.de)
2023-01-17 07:47:40 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 260 seconds)
2023-01-17 07:47:58 +0100ubert(~Thunderbi@146.70.116.146) (Ping timeout: 272 seconds)
2023-01-17 07:47:58 +0100ububert
2023-01-17 07:50:07 +0100gmg(~user@user/gehmehgeh)
2023-01-17 07:50:28 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:2428:84d7:7517:8523)
2023-01-17 07:50:44 +0100use-value1(~Thunderbi@2a00:23c6:8a03:2f01:2428:84d7:7517:8523) (Ping timeout: 265 seconds)
2023-01-17 07:57:28 +0100trev(~trev@user/trev)
2023-01-17 07:58:37 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Ping timeout: 252 seconds)
2023-01-17 08:05:44 +0100teddyc(theodorc@cassarossa.samfundet.no)
2023-01-17 08:06:10 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-01-17 08:06:32 +0100elbear(~lucian@86.127.154.189) (Ping timeout: 256 seconds)
2023-01-17 08:10:25 +0100 <Jadesheit[m]> hello
2023-01-17 08:16:00 +0100elbear(~lucian@86.127.154.189)
2023-01-17 08:22:34 +0100waleee(~waleee@h-176-10-137-138.na.cust.bahnhof.se)
2023-01-17 08:24:38 +0100barzo(~hd@31.223.41.44)
2023-01-17 08:28:21 +0100use-value1(~Thunderbi@2a00:23c6:8a03:2f01:4da1:8bf6:4505:40c5)
2023-01-17 08:30:51 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:2428:84d7:7517:8523) (Ping timeout: 265 seconds)
2023-01-17 08:30:51 +0100use-value1use-value
2023-01-17 08:32:20 +0100freeside(~mengwong@122.11.248.245)
2023-01-17 08:40:32 +0100shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 256 seconds)
2023-01-17 08:44:14 +0100mmhat(~mmh@p200300f1c7123c66ee086bfffe095315.dip0.t-ipconnect.de)
2023-01-17 08:44:19 +0100mmhat(~mmh@p200300f1c7123c66ee086bfffe095315.dip0.t-ipconnect.de) (Client Quit)
2023-01-17 08:45:41 +0100elbear(~lucian@86.127.154.189) (Ping timeout: 246 seconds)
2023-01-17 08:45:45 +0100troydm(~troydm@user/troydm) (Ping timeout: 268 seconds)
2023-01-17 08:47:38 +0100manwithluck(~manwithlu@194.177.28.192) (Read error: Connection reset by peer)
2023-01-17 08:49:05 +0100manwithluck(~manwithlu@194.177.28.192)
2023-01-17 08:53:34 +0100manwithluck(~manwithlu@194.177.28.192) (Ping timeout: 256 seconds)
2023-01-17 08:54:02 +0100use-value1(~Thunderbi@2a00:23c6:8a03:2f01:8cfd:de7b:dc70:e461)
2023-01-17 08:54:11 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:4da1:8bf6:4505:40c5) (Ping timeout: 264 seconds)
2023-01-17 08:54:12 +0100use-value1use-value
2023-01-17 08:57:41 +0100manwithluck(~manwithlu@194.177.28.157)
2023-01-17 08:58:59 +0100use-value1(~Thunderbi@2a00:23c6:8a03:2f01:b860:794c:a959:bba8)
2023-01-17 09:00:56 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:8cfd:de7b:dc70:e461) (Ping timeout: 256 seconds)
2023-01-17 09:00:56 +0100use-value1use-value
2023-01-17 09:01:27 +0100use-value1(~Thunderbi@2a00:23c6:8a03:2f01:c1c3:e297:674c:356d)
2023-01-17 09:01:56 +0100elbear(~lucian@86.127.154.189)
2023-01-17 09:05:12 +0100opticblast(~Thunderbi@secure-165.caltech.edu)
2023-01-17 09:05:43 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:b860:794c:a959:bba8) (Ping timeout: 260 seconds)
2023-01-17 09:05:44 +0100use-value1use-value
2023-01-17 09:06:25 +0100mimmy__(~mimmy@86.48.14.202)
2023-01-17 09:07:00 +0100manwithluck(~manwithlu@194.177.28.157) (Ping timeout: 260 seconds)
2023-01-17 09:07:08 +0100manwithl-(~manwithlu@194.177.28.192)
2023-01-17 09:08:43 +0100CiaoSen(~Jura@p200300c9570452002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-01-17 09:11:34 +0100mimmy__(~mimmy@86.48.14.202) (Ping timeout: 272 seconds)
2023-01-17 09:14:51 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-01-17 09:21:46 +0100gmg(~user@user/gehmehgeh) (Remote host closed the connection)
2023-01-17 09:24:53 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7)
2023-01-17 09:28:58 +0100mimmy__(~mimmy@86.48.14.202)
2023-01-17 09:31:51 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-17 09:33:35 +0100mimmy__(~mimmy@86.48.14.202) (Ping timeout: 246 seconds)
2023-01-17 09:34:33 +0100 <dminuoso> anatta: What part about QQs do you not like
2023-01-17 09:34:35 +0100Sgeo_(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-01-17 09:34:56 +0100CiaoSen(~Jura@p200300c9570452002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-01-17 09:35:19 +0100panovia(~user@user/siracusa)
2023-01-17 09:37:08 +0100elbear(~lucian@86.127.154.189) (Quit: leaving)
2023-01-17 09:39:47 +0100chiselfuse(~chiselfus@user/chiselfuse) (Ping timeout: 255 seconds)
2023-01-17 09:40:54 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-01-17 09:41:09 +0100acidjnk(~acidjnk@p200300d6e715c4203c380012bc2cb8d8.dip0.t-ipconnect.de)
2023-01-17 09:44:59 +0100jinsun__(~jinsun@user/jinsun)
2023-01-17 09:44:59 +0100jinsunGuest5150
2023-01-17 09:44:59 +0100jinsun__jinsun
2023-01-17 09:47:33 +0100Guest5150(~jinsun@user/jinsun) (Ping timeout: 252 seconds)
2023-01-17 09:47:44 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-01-17 09:51:19 +0100CiaoSen(~Jura@p200300c9570452002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-01-17 09:53:56 +0100avicenzi(~avicenzi@2a00:ca8:a1f:b004::c32)
2023-01-17 09:54:07 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 252 seconds)
2023-01-17 09:55:51 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-01-17 09:57:15 +0100cfricke(~cfricke@user/cfricke)
2023-01-17 10:01:50 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl)
2023-01-17 10:05:05 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Read error: Connection reset by peer)
2023-01-17 10:09:59 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl)
2023-01-17 10:11:52 +0100gtdg(~gtdg@nat-inria-interne-72-gw-01-lne.lille.inria.fr)
2023-01-17 10:16:41 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 255 seconds)
2023-01-17 10:17:33 +0100ec(~ec@gateway/tor-sasl/ec)
2023-01-17 10:23:42 +0100piele(~piele@tbonesteak.creativeserver.net)
2023-01-17 10:25:56 +0100barzo(~hd@31.223.41.44) (Ping timeout: 256 seconds)
2023-01-17 10:35:34 +0100waleee(~waleee@h-176-10-137-138.na.cust.bahnhof.se) (Ping timeout: 256 seconds)
2023-01-17 10:37:03 +0100titibandit1(~titibandi@xdsl-81-173-160-143.nc.de) (Remote host closed the connection)
2023-01-17 10:37:25 +0100talismanick(~talismani@2601:200:c181:4c40::1be2) (Ping timeout: 260 seconds)
2023-01-17 10:41:31 +0100__monty__(~toonn@user/toonn)
2023-01-17 10:42:22 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340)
2023-01-17 10:45:04 +0100boxscape_(~boxscape_@81.191.27.107)
2023-01-17 10:47:49 +0100[Leary](~Leary]@user/Leary/x-0910699) (Remote host closed the connection)
2023-01-17 10:48:26 +0100[Leary](~Leary]@user/Leary/x-0910699)
2023-01-17 10:48:32 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Ping timeout: 246 seconds)
2023-01-17 10:50:04 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340)
2023-01-17 10:54:06 +0100nschoe(~q@2a01:e0a:8e:a190:59bc:3e0d:1333:bdb1)
2023-01-17 11:06:58 +0100xff0x_(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 268 seconds)
2023-01-17 11:08:30 +0100enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7)
2023-01-17 11:11:21 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2023-01-17 11:15:30 +0100mizlan(~mizlan@2607:f010:2a7:1005:a0d7:fa40:4d30:af9f)
2023-01-17 11:19:09 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-01-17 11:20:00 +0100mizlan(~mizlan@2607:f010:2a7:1005:a0d7:fa40:4d30:af9f) (Ping timeout: 260 seconds)
2023-01-17 11:23:46 +0100ft(~ft@p4fc2a257.dip0.t-ipconnect.de) (Quit: leaving)
2023-01-17 11:35:19 +0100troydm(~troydm@user/troydm)
2023-01-17 11:42:03 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Ping timeout: 260 seconds)
2023-01-17 11:42:57 +0100 <anatta> dminuoso: Eh, it's not that I don't like it as much as it's me being bad and not understanding it.
2023-01-17 11:48:31 +0100cheater(~Username@user/cheater) (Ping timeout: 252 seconds)
2023-01-17 11:53:11 +0100 <dminuoso> anatta: A quasiquoter is really simple. It consists of potentially 4 functions `quoteExp :: String -> Q Exp`, `quotePat :: String -> Q Pat`, `quoteType :: String -> Q Type` and `quoteDec :: String -> Q [Dec]`. What this lets you do, is conjure up a function that takes an arbitrary string and - at compile time - turn it into a different kind of AST node (an expression, pattern, type or a list of
2023-01-17 11:53:13 +0100cheater(~Username@user/cheater)
2023-01-17 11:53:13 +0100 <dminuoso> declarations)
2023-01-17 11:53:27 +0100 <dminuoso> It's a very limited form of TemplateHaskell.
2023-01-17 11:54:17 +0100 <dminuoso> One perhaps motivating example might be a quasiquoter for IPv6 literals. Say you want to express `myIP :: IPv6; myIP = [ipv6| 12001:db8::fe1 |]`
2023-01-17 11:55:02 +0100xff0x_(~xff0x@ai084091.d.east.v6connect.net)
2023-01-17 11:55:04 +0100 <anatta> dminuoso: Yeah, I was experimenting some with it yesterday, but I didn't manage to get a mvp, just type errors
2023-01-17 11:55:11 +0100 <dminuoso> Where ipv6 has a suitable field quoteExp that knows how to turn the *string* "2001:db8::fe1" into some equivalent expression, say `ipv6FromWord16s 0x2001 0xdb8 0 0 0 0 0xfe1` or some such
2023-01-17 11:56:10 +0100 <anatta> I just tried to make a basic math reader, but I like the idea of being able to write in some DSL or whatever inside your haskell files
2023-01-17 11:56:39 +0100kuribas(~user@ptr-17d51enmqmkg8yow88s.18120a2.ip6.access.telenet.be)
2023-01-17 11:57:41 +0100 <kuribas> is haskell really a difficult language? I am looking at C# linq queries and F# computation expressions, and it just looks like ad-hoc syntax for supporting monads.
2023-01-17 11:58:04 +0100 <kuribas> isn't it just easier to have a language which supports these abstractions from the base (like haskell, idris, ...)
2023-01-17 11:59:24 +0100 <kuribas> [Leary]: re your comment on dhall union, indeed `::` solves the problem of using default values.
2023-01-17 12:00:38 +0100kuribas(~user@ptr-17d51enmqmkg8yow88s.18120a2.ip6.access.telenet.be) (Client Quit)
2023-01-17 12:00:52 +0100kuribas(~user@ptr-17d51enmqmkg8yow88s.18120a2.ip6.access.telenet.be)
2023-01-17 12:08:20 +0100int-index(~int-index@2a00:1370:8178:5994:30e6:1466:2eaa:dd53)
2023-01-17 12:08:40 +0100 <dminuoso> anatta: Consider a two step process then. Parse into some kind of ADT, and then a function turning an ADT into - say - an Expr.
2023-01-17 12:08:54 +0100 <dminuoso> The first part you can write outside of TH/QQ easily, and the second becomes easier
2023-01-17 12:09:54 +0100laalyn(~laalyn@c-73-241-126-7.hsd1.ca.comcast.net) (Quit: Client closed)
2023-01-17 12:11:06 +0100razetime(~Thunderbi@117.193.0.183) (Ping timeout: 268 seconds)
2023-01-17 12:14:24 +0100int-index28(~int-index@2a00:1370:8178:5994:87d0:2048:7511:2eba)
2023-01-17 12:14:27 +0100 <kuribas> http://fsprojects.github.io/SQLProvider/core/composable.html
2023-01-17 12:15:13 +0100int-index28(~int-index@2a00:1370:8178:5994:87d0:2048:7511:2eba) ()
2023-01-17 12:17:46 +0100freeside(~mengwong@122.11.248.245) (Ping timeout: 272 seconds)
2023-01-17 12:17:51 +0100razetime(~Thunderbi@117.193.0.183)
2023-01-17 12:18:13 +0100int-index(~int-index@2a00:1370:8178:5994:30e6:1466:2eaa:dd53) (Ping timeout: 260 seconds)
2023-01-17 12:18:36 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2023-01-17 12:19:12 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-17 12:20:09 +0100razetime(~Thunderbi@117.193.0.183) (Client Quit)
2023-01-17 12:20:18 +0100 <kuribas> This just looks like Monads, but with special syntax.
2023-01-17 12:20:27 +0100Joao003(~Joao003@2804:840:8311:d200:306d:6168:be07:23f0)
2023-01-17 12:20:52 +0100 <Joao003> hi i'm back
2023-01-17 12:22:31 +0100Axman6Guess who's back, back again...
2023-01-17 12:28:01 +0100 <kuribas> I mean, these composable just look like my database library, but my library is just build on top of haskell basic abstractions.
2023-01-17 12:28:12 +0100 <Joao003> finally i can see chat
2023-01-17 12:28:30 +0100ubert1(~Thunderbi@2a02:8109:abc0:6434:8e77:5003:7dc0:6c4e)
2023-01-17 12:28:33 +0100 <kuribas> these languages are supposed to be "simpler" than haskell.
2023-01-17 12:28:59 +0100 <kuribas> But in the end they just end up less composable, with more ad-hoc logic, right?
2023-01-17 12:30:16 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d14:f10:c58a:afef) (Remote host closed the connection)
2023-01-17 12:30:39 +0100razetime(~Thunderbi@117.193.0.183)
2023-01-17 12:31:11 +0100 <Joao003> look at this function i made
2023-01-17 12:31:41 +0100razetime(~Thunderbi@117.193.0.183) (Client Quit)
2023-01-17 12:32:02 +0100int-index(~Vladislav@2a00:1370:8178:5994:30e6:1466:2eaa:dd53)
2023-01-17 12:37:40 +0100 <kuribas> "F# computation expressions are the syntactic language mechanism that is used by features like sequence expressions and asynchronous workflows. The aim of F# computation expressions is to provide a single syntactic mechanism that provides convenient notation for writing a wide range of computations."
2023-01-17 12:38:18 +0100 <kuribas> so a complicated syntactical language, instead of just a light do notation sugar.
2023-01-17 12:38:22 +0100 <kuribas> How would that be easier?
2023-01-17 12:42:48 +0100 <dminuoso> kuribas: Regarding "looks like monads", do you know of MonadComprehensions and TransformListComp?
2023-01-17 12:43:28 +0100 <dminuoso> The latter in particular
2023-01-17 12:43:56 +0100 <dminuoso> https://www.microsoft.com/en-us/research/wp-content/uploads/2007/09/list-comp.pdf for some publication on this subjecft
2023-01-17 12:44:01 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-01-17 12:45:00 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-17 12:47:38 +0100califax(~califax@user/califx)
2023-01-17 12:47:40 +0100 <Unhammer> Is there a shorthand for referring to functions from "this module" when importing things of the same name from others?
2023-01-17 12:49:08 +0100 <Unhammer> E.g. in Admin.View.Samples.Index I have a data type with field userId, but I'm also importing a data type with field userId. Typically I want to refer to the imported one so I call that one with no module prefix, but the two times I want to refer to the one from "this" module I have to give the full module path v{Admin.View.Samples.Index.userId=…}
2023-01-17 12:49:39 +0100 <dminuoso> Unhammer: You can always qualify them with the module name of the current module
2023-01-17 12:49:45 +0100 <int-index> There is no shorthand
2023-01-17 12:50:09 +0100 <Unhammer> ok, maybe I should just put it in a FooTypes.hs or something
2023-01-17 12:50:34 +0100 <dminuoso> You can also supply custom qualifiers with `as` if that helps
2023-01-17 12:51:41 +0100 <mauke> how do you use as on the current module?
2023-01-17 12:51:48 +0100 <dminuoso> Unhammer: Potentially DuplicateRecordFields could help as well
2023-01-17 12:51:55 +0100 <dminuoso> mauke: ah mmm I dont think you can do that.
2023-01-17 12:52:27 +0100zaquest(~notzaques@5.130.79.72) (Remote host closed the connection)
2023-01-17 12:52:48 +0100 <kuribas> dminuoso: yes, but I never use them.
2023-01-17 12:53:12 +0100 <kuribas> dminuoso: it's mostly useful to show that list comprehension syntax is just monad syntax.
2023-01-17 12:54:04 +0100zaquest(~notzaques@5.130.79.72)
2023-01-17 13:03:30 +0100jinsun__(~jinsun@user/jinsun)
2023-01-17 13:03:30 +0100jinsunGuest5401
2023-01-17 13:03:30 +0100Guest5401(~jinsun@user/jinsun) (Killed (silver.libera.chat (Nickname regained by services)))
2023-01-17 13:03:30 +0100jinsun__jinsun
2023-01-17 13:04:48 +0100 <boxscape_> I really like using MonadComprehensions for things like `[ "config.json" | useConfig ] :: Maybe String`
2023-01-17 13:04:54 +0100ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2023-01-17 13:05:55 +0100ec(~ec@gateway/tor-sasl/ec)
2023-01-17 13:09:10 +0100 <boxscape_> kuribas fwiw list comprehensions and do blocks even use the same AST node in GHC
2023-01-17 13:11:21 +0100 <dminuoso> boxscape_: that's cute
2023-01-17 13:12:06 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-01-17 13:16:33 +0100acidjnk(~acidjnk@p200300d6e715c4203c380012bc2cb8d8.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-01-17 13:19:05 +0100poljar(~poljar@93-139-120-188.adsl.net.t-com.hr) (Remote host closed the connection)
2023-01-17 13:19:29 +0100poljar(~poljar@93-139-120-188.adsl.net.t-com.hr)
2023-01-17 13:20:06 +0100 <kuribas> boxscape_: what about the return?
2023-01-17 13:20:34 +0100 <boxscape_> kuribas the Node has a flag that keeps track of whether it's a do block, list comp, etc.
2023-01-17 13:20:40 +0100 <kuribas> [ x | x <- myEffect] => do x <- myEffect; pure x
2023-01-17 13:20:51 +0100 <boxscape_> ( https://hackage.haskell.org/package/ghc-9.4.4/docs/Language-Haskell-Syntax-Expr.html#v:HsDo )
2023-01-17 13:20:57 +0100 <kuribas> these an extra pure
2023-01-17 13:21:36 +0100 <boxscape_> the pure is inserted by the desugarer, which looks at the HsDoFlavour
2023-01-17 13:25:33 +0100 <merijn> boxscape_: I mean, you can just do: "config.json" <$ guard useConfig
2023-01-17 13:25:43 +0100 <merijn> boxscape_: And get something similarly cute without extensions :p
2023-01-17 13:26:00 +0100 <boxscape_> my files usually have 15 extensions anyway, so...
2023-01-17 13:27:20 +0100 <Joao003> i just installed haskell
2023-01-17 13:29:11 +0100 <Joao003> boxscape_: what did you say by 15 extensions?
2023-01-17 13:29:45 +0100 <int-index> boxscape_: GHC2021 should lower that amount somewhat
2023-01-17 13:29:50 +0100 <boxscape_> Joao003 the GHC compiler supports some features that are not part of the Haskell2010 standard, but to use them one has to enable corresponding extensions
2023-01-17 13:29:59 +0100 <boxscape_> int-index: that is true
2023-01-17 13:30:41 +0100 <Joao003> is it worth it installing haskell?
2023-01-17 13:30:45 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d14:f10:c58a:afef)
2023-01-17 13:31:12 +0100 <Joao003> i installed it through ghcup
2023-01-17 13:31:59 +0100 <boxscape_> If you want to learn or use Haskell then installing it is probably a good idea, yeah. And ghcup is a good way to do it
2023-01-17 13:32:04 +0100 <int-index> Joao003: as opposed to using an online compiler? if you're just toying around, then https://play-haskell.tomsmeding.com/ is a good option too
2023-01-17 13:32:15 +0100 <boxscape_> true
2023-01-17 13:32:34 +0100 <Joao003> nah what if i don't have access to the internet?
2023-01-17 13:32:43 +0100 <int-index> then having it locally is the way to go
2023-01-17 13:34:53 +0100 <Joao003> what's the most commonly used haskell function?
2023-01-17 13:35:06 +0100acidjnk(~acidjnk@p200300d6e715c420889663d2e7d74ba2.dip0.t-ipconnect.de)
2023-01-17 13:35:42 +0100 <Joao003> i love and hate using windows
2023-01-17 13:36:00 +0100 <Joao003> windows has a lot of cool functionality
2023-01-17 13:36:13 +0100 <Joao003> but it isn't as good for development as linux is
2023-01-17 13:36:30 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d14:f10:c58a:afef) (Ping timeout: 260 seconds)
2023-01-17 13:38:01 +0100 <mauke> oh no. am I being protontorpedo'd?
2023-01-17 13:39:39 +0100 <dminuoso> Joao003 | what's the most commonly used haskell function?
2023-01-17 13:39:44 +0100 <dminuoso> If I had to guess, its probably (.)
2023-01-17 13:39:52 +0100 <Joao003> yeah
2023-01-17 13:40:00 +0100 <Joao003> wait just found out something
2023-01-17 13:40:05 +0100 <Joao003> there's ,
2023-01-17 13:40:07 +0100 <dminuoso> (>>=) and (>>) are probably quite high (found after desugaring of do)
2023-01-17 13:40:08 +0100 <Joao003> but there's ,,
2023-01-17 13:40:11 +0100 <Joao003> ,,,
2023-01-17 13:40:13 +0100 <Joao003> ,,,,
2023-01-17 13:40:15 +0100 <Joao003> ,,,,,
2023-01-17 13:40:18 +0100 <Joao003> and so on
2023-01-17 13:40:25 +0100 <dminuoso> ($) would be high up as well
2023-01-17 13:40:40 +0100 <dminuoso> so in short, I expect (.), ($), (>>=) and (>>) to be in the top 10 list
2023-01-17 13:40:49 +0100 <Joao003> where would map go
2023-01-17 13:40:57 +0100 <dminuoso> map is not commonly used
2023-01-17 13:41:04 +0100 <Jadesheit[m]> map isn't all that high
2023-01-17 13:41:17 +0100 <dminuoso> fmap and its infix variant <$> however is used a lot more
2023-01-17 13:41:20 +0100 <Jadesheit[m]> and the problem is that map also isn't used in favor of `fmap` or `<$>`
2023-01-17 13:41:34 +0100 <Jadesheit[m]> * or `<$>` sometimes
2023-01-17 13:41:45 +0100 <dminuoso> I recently found <&> to be quite handy as well :)
2023-01-17 13:42:01 +0100 <dminuoso> In some styles of code it can be a lot easier to read
2023-01-17 13:42:11 +0100 <Joao003> no instance for showing the (,,,,,,,,,) (10-tuple)
2023-01-17 13:42:19 +0100 <Joao003> operator
2023-01-17 13:42:27 +0100 <Jadesheit[m]> interesting
2023-01-17 13:43:04 +0100 <Jadesheit[m]> Joao003: hm?
2023-01-17 13:43:12 +0100 <Jadesheit[m]> as soon as your tuple is bigger than three you should reconsider anyways
2023-01-17 13:43:17 +0100 <Joao003> yeah
2023-01-17 13:43:43 +0100 <int-index> tuples have Show instances up to length 15
2023-01-17 13:43:57 +0100 <Joao003> sorry operators dont have instances
2023-01-17 13:44:05 +0100gtdg(~gtdg@nat-inria-interne-72-gw-01-lne.lille.inria.fr) (Quit: Client closed)
2023-01-17 13:44:06 +0100 <dminuoso> Types do.
2023-01-17 13:44:38 +0100 <Jadesheit[m]> dminuoso: the flipped version of `<$>` should have been `>$<`
2023-01-17 13:44:40 +0100 <Jadesheit[m]> * been `>$<` /j
2023-01-17 13:44:43 +0100 <Joao003> lol
2023-01-17 13:44:56 +0100 <dminuoso> The term "operator" is only useful as a lexical/grammatical notion. In particular we call functions `operators` that are not composed of alphanumeric characters, and they can be used in infix position.
2023-01-17 13:45:05 +0100 <Joao003> yeah
2023-01-17 13:45:12 +0100 <boxscape_> is `elem` an operator
2023-01-17 13:45:17 +0100 <dminuoso> Jadesheit[m]: No, <&> is quite right
2023-01-17 13:45:23 +0100 <Joao003> to turn a function into a "operator" you can just type backticks around it
2023-01-17 13:45:29 +0100 <Joao003> for example `map`
2023-01-17 13:45:29 +0100 <dminuoso> Jadesheit[m]: ($) is to (&) as <$> is to <&>
2023-01-17 13:45:37 +0100 <Jadesheit[m]> dminuoso: haha yeah im joking
2023-01-17 13:45:38 +0100 <dminuoso> Jadesheit[m]: >$< is actually an infix contramap
2023-01-17 13:45:57 +0100 <dminuoso> So there's certainly merit to >$< being used a a kind of "flipped" thing of <$>
2023-01-17 13:46:28 +0100 <boxscape_> >&< doesn't exist though :(
2023-01-17 13:46:42 +0100 <boxscape_> (at least not findable in hoogle)
2023-01-17 13:47:07 +0100 <Joao003> hey
2023-01-17 13:47:11 +0100 <dminuoso> boxscape_: Its called >$$<
2023-01-17 13:47:14 +0100 <dminuoso> Confusingly.
2023-01-17 13:47:16 +0100 <Joao003> do you call [] an array or a list
2023-01-17 13:47:19 +0100 <dminuoso> Joao003: a list
2023-01-17 13:47:21 +0100 <boxscape_> ah
2023-01-17 13:47:27 +0100 <dminuoso> Joao003: we have a thing called Array that is something different
2023-01-17 13:47:31 +0100 <Joao003> oh
2023-01-17 13:47:32 +0100 <Jadesheit[m]> A list is also not the same as an array
2023-01-17 13:47:41 +0100 <Jadesheit[m]> think of a list as an iterator, not a storage ds
2023-01-17 13:47:48 +0100 <Joao003> oh
2023-01-17 13:47:53 +0100 <dminuoso> array in haskell usually refers to `Array` from the `array` package
2023-01-17 13:47:57 +0100 <dminuoso> tps://hackage.haskell.org/package/array-0.5.4.0/docs/Data-Array.html
2023-01-17 13:48:05 +0100 <Joao003> think of a list as a series of applications of (:)
2023-01-17 13:48:14 +0100 <int-index> there are also arrays from the `primitive` package
2023-01-17 13:48:31 +0100 <int-index> which don't have the Ix overabstraction nonsense
2023-01-17 13:48:36 +0100epolanski(uid312403@id-312403.helmsley.irccloud.com)
2023-01-17 13:48:36 +0100 <Jadesheit[m]> Joao003: that's how it works, yes
2023-01-17 13:48:43 +0100 <dminuoso> To be fair, the terms `list`, `array`, `sequence`, and so forth is extremely overloaded, and most languages tend to conflate their meaning with the semantics of particular implementations that share their names.
2023-01-17 13:48:59 +0100 <Jadesheit[m]> [1, 2, 3] desugars to 1 : (2 : (3 : []))
2023-01-17 13:48:59 +0100 <dminuoso> Similar story with `string` or `text`
2023-01-17 13:49:15 +0100 <dminuoso> (though `string` is probably the most ambiguous term of all of these)
2023-01-17 13:49:17 +0100 <Joao003> most of the things you know from lambda calculus carry over to any functional language
2023-01-17 13:49:27 +0100 <Jadesheit[m]> kind of?
2023-01-17 13:49:33 +0100 <Jadesheit[m]> I wouldn't say all
2023-01-17 13:49:43 +0100 <Joao003> i said "most"
2023-01-17 13:50:27 +0100 <Jadesheit[m]> I was referring to the language part, you said any functional language
2023-01-17 13:50:36 +0100 <Joao003> oh
2023-01-17 13:50:46 +0100 <Joao003> yeah almost
2023-01-17 13:50:46 +0100 <dminuoso> int-index: Mmm from the looks of it, the only difference is that the primitive version doesnt have bounds encoded inside. So I guess that explains the lack of Ix?
2023-01-17 13:50:50 +0100 <merijn> Depends how you define functional language :p
2023-01-17 13:51:23 +0100 <int-index> dminuoso: yes, the primitive version is simpler and it's also the data structure backing `vector`
2023-01-17 13:51:47 +0100 <Jadesheit[m]> merijn: yup
2023-01-17 13:51:52 +0100 <dminuoso> int-index: Ahh! I thought it was the `array` Array.
2023-01-17 13:51:58 +0100 <Joao003> also you said a thing about array desugarization so "hi" desugarizes into ['h','i'] and that desugarizes into 'h' : ('i' : [])
2023-01-17 13:52:14 +0100 <dminuoso> But given that `vector` doesnt even depend on that package, that assumption was just a wild guess.
2023-01-17 13:52:16 +0100 <Jadesheit[m]> list, not array
2023-01-17 13:52:17 +0100 <Jadesheit[m]> and yes
2023-01-17 13:52:32 +0100 <Joao003> since string is just [Char]
2023-01-17 13:52:36 +0100 <Jadesheit[m]> yes
2023-01-17 13:52:57 +0100 <Jadesheit[m]> Joao003: identically so, they are interchangeable
2023-01-17 13:53:03 +0100 <Joao003> yeah
2023-01-17 13:53:03 +0100 <dminuoso> Even the notion of what a "string" is can be tricky, as there's very different expectations.
2023-01-17 13:53:07 +0100 <Jadesheit[m]> * are interchangeable as by `type`
2023-01-17 13:53:11 +0100 <Joao003> data String = [Char]
2023-01-17 13:53:12 +0100 <Jadesheit[m]> * are interchangeable as by `type` they have the same runtime representation
2023-01-17 13:53:16 +0100 <boxscape_> int-index: I suppose it's not a coincidence that you prefer int indices over Ix
2023-01-17 13:53:25 +0100 <dminuoso> For instance, what would a `stringLength` function in an arbitrary language produce exactly?
2023-01-17 13:53:39 +0100 <Jadesheit[m]> Joao003: no, data creates a different runtime representation, it's `type String = [Char]`
2023-01-17 13:53:48 +0100 <Joao003> oh i didn't know that
2023-01-17 13:54:04 +0100 <boxscape_> (`data String = [Char]` would not be valid syntax)
2023-01-17 13:54:16 +0100 <Joao003> cool
2023-01-17 13:54:16 +0100 <Jadesheit[m]> that's why you use `newtype` over `data` for single constructor datatypes
2023-01-17 13:54:58 +0100 <Joao003> the lists are actually monads
2023-01-17 13:55:03 +0100 <Joao003> @src [] return
2023-01-17 13:55:03 +0100 <lambdabot> return x = [x]
2023-01-17 13:56:55 +0100 <zzz> @src [] pure
2023-01-17 13:56:55 +0100 <lambdabot> pure = return
2023-01-17 13:57:11 +0100 <zzz> shouldn't this be the other way around?
2023-01-17 13:57:35 +0100 <dminuoso> zzz: it doesnt matter which way you do it.
2023-01-17 13:57:55 +0100 <dminuoso> first, what lambdabot tells in terms of @src is just based on a simple text file its fed with
2023-01-17 13:58:01 +0100 <dminuoso> it doesnt represent actual source of base
2023-01-17 13:58:11 +0100 <hpc> @src sort
2023-01-17 13:58:11 +0100 <lambdabot> sort = sortBy compare
2023-01-17 13:58:17 +0100 <hpc> @src sortBy
2023-01-17 13:58:17 +0100 <lambdabot> -- The actual definition used by GHC is an optimised mergesort.
2023-01-17 13:58:17 +0100 <lambdabot> sortBy cmp = foldr (insertBy cmp) []
2023-01-17 13:58:23 +0100 <hpc> ^ for exapmle
2023-01-17 13:58:25 +0100 <dminuoso> second, defining applicative in terms of monad is a bit simpler mechanically, because you can always just write `instance Applicative F where (<*>) = ap; pure = return`
2023-01-17 13:58:28 +0100 <Joao003> @src map
2023-01-17 13:58:29 +0100 <lambdabot> map _ [] = []
2023-01-17 13:58:29 +0100 <lambdabot> map f (x:xs) = f x : map f xs
2023-01-17 13:58:38 +0100 <Joao003> exactly what i was expecting
2023-01-17 13:58:46 +0100 <Joao003> map on nil = nil
2023-01-17 13:59:14 +0100 <Joao003> and map on a list is applying the function on the head then consing with map f tail
2023-01-17 13:59:41 +0100 <zzz> dminuoso: but wouldn't we need then `instance Monad f => Applicative f where pure = return` ?
2023-01-17 13:59:56 +0100 <dminuoso> zzz: no
2023-01-17 14:00:10 +0100 <zzz> @info return
2023-01-17 14:00:10 +0100 <lambdabot> return
2023-01-17 14:00:19 +0100 <zzz> i'm confused
2023-01-17 14:00:27 +0100 <dminuoso> zzz: For a concrete type, you dont need constraints
2023-01-17 14:00:32 +0100 <dminuoso> Or rather
2023-01-17 14:00:34 +0100 <dminuoso> Heh
2023-01-17 14:00:36 +0100 <dminuoso> let me rephrase.
2023-01-17 14:00:40 +0100 <Joao003> return's name is weirdd
2023-01-17 14:00:47 +0100 <Joao003> and pure doesn't solve the problem
2023-01-17 14:00:49 +0100 <dminuoso> zzz: In principle one could have written such an instance, yes.
2023-01-17 14:00:51 +0100 <dminuoso> However!
2023-01-17 14:01:26 +0100 <dminuoso> zzz: note that the constraint in the instance is *not* used for instance selection.
2023-01-17 14:01:37 +0100 <dminuoso> That means, that instance claims there is an instance `Applicative f` for *ALL* choices of f.
2023-01-17 14:01:49 +0100 <dminuoso> Even if no `Monad f` exists
2023-01-17 14:01:52 +0100 <dminuoso> (for the purpose of instance selection)
2023-01-17 14:02:29 +0100 <dminuoso> Not sure what other considerations might play into this.
2023-01-17 14:04:34 +0100fizbin_(~fizbin@user/fizbin) (Ping timeout: 268 seconds)
2023-01-17 14:05:01 +0100 <Joao003> give me a formal definition of a monad
2023-01-17 14:05:14 +0100 <mauke> also, there is no @info command and it autocorrects to @undo
2023-01-17 14:05:28 +0100 <dminuoso> Joao003: [not a] monad is simply an abstract interface.
2023-01-17 14:05:39 +0100 <mauke> "A monad is a monoid in the category of endofunctors"
2023-01-17 14:05:55 +0100 <boxscape_> Joao003 do you mean Haskell's `Monad` or the category theoretical concept of a monad?
2023-01-17 14:05:57 +0100 <dminuoso> mauke: So is applicative.
2023-01-17 14:06:04 +0100 <Joao003> both
2023-01-17 14:06:13 +0100 <dminuoso> The category theory perspective is not going to help *shrugs*
2023-01-17 14:06:37 +0100 <Joao003> but i want it anyways
2023-01-17 14:06:48 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-01-17 14:06:53 +0100 <boxscape_> the formal definition of Haskell's `Monad` is `class Monad where return :: a -> m a; (>>=) :: m a -> (a -> m b) -> m b`
2023-01-17 14:07:34 +0100 <boxscape_> uhh I guess you might want to add an Applicative superclass constraint to that depending on which version of Haskell we're talking about
2023-01-17 14:08:10 +0100 <int-index> I prefer to think of it as a Functor+join
2023-01-17 14:08:22 +0100 <boxscape_> I do prefer that, too
2023-01-17 14:08:28 +0100 <Joao003> what is functor
2023-01-17 14:08:33 +0100 <Joao003> im gonna hoogle
2023-01-17 14:08:40 +0100 <Joao003> @hoogle Functor
2023-01-17 14:08:40 +0100 <lambdabot> Prelude class Functor f
2023-01-17 14:08:40 +0100 <lambdabot> Control.Monad class Functor f
2023-01-17 14:08:41 +0100 <lambdabot> Control.Monad.Instances class Functor f
2023-01-17 14:08:56 +0100 <Joao003> @src Functor
2023-01-17 14:08:56 +0100 <lambdabot> class Functor f where
2023-01-17 14:08:57 +0100 <lambdabot> fmap :: (a -> b) -> f a -> f b
2023-01-17 14:09:18 +0100 <Joao003> class functor where fmap :: (a -> b) -> f a -> f b
2023-01-17 14:09:38 +0100 <Joao003> @src join
2023-01-17 14:09:38 +0100 <lambdabot> join x = x >>= id
2023-01-17 14:10:00 +0100 <boxscape_> Joao003 join is easier to understand in terms of its type, `join :: m (m a) -> m a`
2023-01-17 14:10:22 +0100 <Joao003> yeah
2023-01-17 14:10:25 +0100 <boxscape_> it allows you to collapse two levels of the same monadic context into one
2023-01-17 14:10:29 +0100 <Jadesheit[m]> Some terms that I like to use are
2023-01-17 14:10:29 +0100 <Jadesheit[m]> Functor -> Mappable
2023-01-17 14:10:29 +0100 <Jadesheit[m]> Monad -> Flatmappable
2023-01-17 14:10:54 +0100 <Joao003> join takes a monad of monads and returns a monad, right?
2023-01-17 14:11:01 +0100 <boxscape_> % join [[1,2], [3,4]]
2023-01-17 14:11:01 +0100 <yahb2> [1,2,3,4]
2023-01-17 14:11:21 +0100 <Joao003> > join [[1,2], [3,4]]
2023-01-17 14:11:23 +0100thebinary(~thebinary@2400:1a00:b040:11cf:84c9:5a90:c46b:31e6)
2023-01-17 14:11:23 +0100 <lambdabot> [1,2,3,4]
2023-01-17 14:11:47 +0100 <boxscape_> Joao003 not quite, `m` is a monad, `m a` is a value in a monadic context. so `join` returns a value in a monadic context, not the monad itself
2023-01-17 14:11:56 +0100 <Jadesheit[m]> yes, it flattens it
2023-01-17 14:11:57 +0100 <Jadesheit[m]> not neccesarily plural though
2023-01-17 14:12:01 +0100 <Joao003> oh
2023-01-17 14:12:24 +0100 <Jadesheit[m]> > join $ Just (Just 2)
2023-01-17 14:12:26 +0100 <Jadesheit[m]> * > join $ Just (Just 2)
2023-01-17 14:12:26 +0100 <lambdabot> Just 2
2023-01-17 14:12:41 +0100 <Joao003> so what's happening when i pass a function like (,)
2023-01-17 14:12:49 +0100 <Joao003> > join (,) 1
2023-01-17 14:12:50 +0100 <lambdabot> (1,1)
2023-01-17 14:13:05 +0100 <Jadesheit[m]> a function `(->) r` is a monad
2023-01-17 14:13:16 +0100 <Jadesheit[m]> defined by `f >>= g = g (f x) x`
2023-01-17 14:13:25 +0100 <boxscape_> it represents a context where things expect a value of type `r` as input
2023-01-17 14:13:40 +0100 <boxscape_> :t (,)
2023-01-17 14:13:41 +0100 <lambdabot> a -> b -> (a, b)
2023-01-17 14:14:02 +0100 <zzz> > join (+) 7
2023-01-17 14:14:04 +0100 <lambdabot> 14
2023-01-17 14:14:10 +0100 <Joao003> (, >>= id) x = id (, x) x = , x x
2023-01-17 14:14:14 +0100 <Joao003> (, >>= id) x = id (, x) x = (,) x x
2023-01-17 14:14:16 +0100 <Jadesheit[m]> so `join = (>>= id)` means that `join f` is identically the same as `f x x`
2023-01-17 14:14:22 +0100 <Jadesheit[m]> yep exactly
2023-01-17 14:14:34 +0100 <Jadesheit[m]> put parantheses though
2023-01-17 14:14:51 +0100 <Jadesheit[m]> and flip the functions
2023-01-17 14:15:12 +0100 <Joao003> join id has no type
2023-01-17 14:15:17 +0100 <Jadesheit[m]> * as `(f x, * f x) x`
2023-01-17 14:15:23 +0100 <boxscape_> :t join id
2023-01-17 14:15:24 +0100 <lambdabot> error:
2023-01-17 14:15:24 +0100 <lambdabot> • Occurs check: cannot construct the infinite type: m ~ (->) (m a)
2023-01-17 14:15:24 +0100 <lambdabot> Expected type: m (m a)
2023-01-17 14:15:33 +0100son0p(~ff@181.136.122.143) (Remote host closed the connection)
2023-01-17 14:16:00 +0100thebinary(~thebinary@2400:1a00:b040:11cf:84c9:5a90:c46b:31e6) (Ping timeout: 256 seconds)
2023-01-17 14:16:20 +0100 <Jadesheit[m]> :t \f :: ((->) r)-> join
2023-01-17 14:16:21 +0100 <lambdabot> error: parse error on input ‘::’
2023-01-17 14:16:26 +0100 <Jadesheit[m]> does that even work
2023-01-17 14:16:40 +0100 <Jadesheit[m]> * :t (\f :: ((->) r))-> join
2023-01-17 14:16:45 +0100 <Jadesheit[m]> nope
2023-01-17 14:17:00 +0100 <Jadesheit[m]> * :t (\f :: ((->) r))-> join f
2023-01-17 14:17:04 +0100 <boxscape_> % :t join @((->) _)
2023-01-17 14:17:04 +0100 <yahb2> join @((->) _) :: Monad ((->) w) => (w -> (w -> a)) -> w -> a
2023-01-17 14:17:17 +0100 <Jadesheit[m]> ah yeah, that's what I tried
2023-01-17 14:18:43 +0100 <Jadesheit[m]> * I tried, thanks
2023-01-17 14:18:43 +0100 <Jadesheit[m]> the function monad is interesting
2023-01-17 14:18:59 +0100 <zzz> the function everything is interesting
2023-01-17 14:19:16 +0100 <zzz> wait until you see Arrow
2023-01-17 14:19:31 +0100 <Jadesheit[m]> ah yeah, I wanted to look into that
2023-01-17 14:19:37 +0100 <geekosaur> Jadesheit[m], editing IRC bot input is even more pointless than matrix editing in an IRC channel in general
2023-01-17 14:20:04 +0100 <zzz> matrix is a digrace to irc
2023-01-17 14:20:07 +0100 <Joao003> % map (+1) [1..3]
2023-01-17 14:20:07 +0100 <yahb2> [2,3,4]
2023-01-17 14:20:22 +0100 <Joao003> we have two haskell bots? lol
2023-01-17 14:20:58 +0100 <boxscape_> lambdabot is older and has more commands, yahb2 is more useful for some things because it just runs a ghci instance
2023-01-17 14:21:10 +0100 <Jadesheit[m]> geekosaur: haha ok thanks
2023-01-17 14:21:39 +0100 <Joao003> boxscape_: thanks
2023-01-17 14:26:01 +0100 <zzz> @pl (>>= id) a
2023-01-17 14:26:01 +0100 <lambdabot> join a
2023-01-17 14:26:30 +0100 <zzz> @pl (>>= id) a a
2023-01-17 14:26:30 +0100 <lambdabot> a a a
2023-01-17 14:27:28 +0100 <Joao003> @pl (negate >>= (*)) a
2023-01-17 14:27:28 +0100 <lambdabot> negate a * a
2023-01-17 14:27:44 +0100 <boxscape_> :t (>>= id) a a
2023-01-17 14:27:46 +0100 <lambdabot> error:
2023-01-17 14:27:46 +0100 <lambdabot> • Couldn't match expected type ‘Expr -> Expr -> t’
2023-01-17 14:27:46 +0100 <lambdabot> with actual type ‘Expr’
2023-01-17 14:27:53 +0100 <boxscape_> :t \a -> (>>= id) a a
2023-01-17 14:27:54 +0100 <lambdabot> error:
2023-01-17 14:27:54 +0100 <lambdabot> • Occurs check: cannot construct the infinite type:
2023-01-17 14:27:54 +0100 <lambdabot> m ~ (->) (m (m t))
2023-01-17 14:29:14 +0100 <Joao003> on ghci it says * Couldn't match type `m' with `(->) (m (m t))'
2023-01-17 14:30:13 +0100 <boxscape_> Joao003 it's using a different version of GHC
2023-01-17 14:30:20 +0100 <Joao003> oh
2023-01-17 14:31:01 +0100 <boxscape_> e.g. 9.4.4 results in the error you reported, but 8.10 in the one lambdabot did
2023-01-17 14:31:10 +0100 <Joao003> :t const 1 2
2023-01-17 14:31:11 +0100 <lambdabot> Num a => a
2023-01-17 14:31:29 +0100 <Joao003> oh
2023-01-17 14:32:11 +0100 <Joao003> i'm using 9.2.5 which is outdated but ok
2023-01-17 14:32:45 +0100 <boxscape_> 9.2.5 is the one ghcup recommends it seems
2023-01-17 14:33:27 +0100 <anatta> dminuoso: finally got my toy example to work (https://i.imgur.com/U7bRlVH.png)
2023-01-17 14:34:10 +0100 <dminuoso> anatta: Hooray!
2023-01-17 14:34:13 +0100 <Joao003> oh nice
2023-01-17 14:34:14 +0100 <anatta> it wasn't that difficult, I just had been a bit confused and not autoderived Data
2023-01-17 14:34:30 +0100 <Joao003> how many lines of code?
2023-01-17 14:34:42 +0100 <dminuoso> anatta: By the way, you can also place constructors into infix position.
2023-01-17 14:35:13 +0100 <anatta> Joao003: about 70 in Expr.hs
2023-01-17 14:35:18 +0100 <Joao003> oh
2023-01-17 14:35:23 +0100 <dminuoso> anatta: `data Expr = Expr `Plus` Expr | Con Int`
2023-01-17 14:35:33 +0100 <mauke> /plain > expr (5+3)
2023-01-17 14:35:34 +0100 <dminuoso> The added benefit is that the derived show instance will then place `Plus` into infix position as well.
2023-01-17 14:35:45 +0100 <dminuoso> Making it even more readable. :)
2023-01-17 14:35:52 +0100 <dminuoso> Unless you're a big fan of polish notation
2023-01-17 14:35:59 +0100 <mauke> > expr (5+3)
2023-01-17 14:36:01 +0100 <lambdabot> 5 + 3
2023-01-17 14:36:11 +0100 <Joao003> > expr (5+3)
2023-01-17 14:36:12 +0100 <lambdabot> 5 + 3
2023-01-17 14:36:47 +0100 <Joao003> i made a function that duplicates each item of an array
2023-01-17 14:36:50 +0100 <anatta> dminuoso: I hadn't even considered you could do that, lol
2023-01-17 14:36:50 +0100 <Joao003> list*
2023-01-17 14:37:05 +0100 <anatta> but it's a good suggestion
2023-01-17 14:37:46 +0100 <anatta> Joao003: nice
2023-01-17 14:37:51 +0100 <Joao003> look
2023-01-17 14:38:16 +0100 <Joao003> @let double_items = (uncurry ((.) concat . (zipWith (\x y -> [x, y])))) . (ap (,) id)
2023-01-17 14:38:17 +0100 <lambdabot> Defined.
2023-01-17 14:38:28 +0100 <Joao003> > double_items [1, 2, 3]
2023-01-17 14:38:30 +0100 <lambdabot> [1,1,2,2,3,3]
2023-01-17 14:38:35 +0100 <dminuoso> anatta: yeah, and you can even use `infixr/infixl` declarations with it.
2023-01-17 14:38:40 +0100 <mauke> concatMap (\x -> [x, x]) [1,2,3]
2023-01-17 14:38:53 +0100 <Joao003> didn't know that existed
2023-01-17 14:39:03 +0100 <dminuoso> anatta: Further, you can also use operator constructors like :+ which could be even more readable
2023-01-17 14:39:14 +0100 <dminuoso> % data Expr = Expr :+ Expr | Con Int
2023-01-17 14:39:14 +0100 <yahb2> <no output>
2023-01-17 14:39:22 +0100 <Joao003> > concatMap (\x -> [x,x]) [1,2,3]
2023-01-17 14:39:23 +0100 <lambdabot> [1,1,2,2,3,3]
2023-01-17 14:39:41 +0100 <mauke> > [ x' | x <- [1, 2, 3], x' <- [x, x] ]
2023-01-17 14:39:42 +0100 <lambdabot> [1,1,2,2,3,3]
2023-01-17 14:39:45 +0100 <dminuoso> anatta: note that they have to start with a colon then, but the rest is up to you
2023-01-17 14:40:03 +0100 <boxscape_> (well, the rest has to be symbols rather than letters or numbers)
2023-01-17 14:40:14 +0100 <anatta> dminuoso: I've seen that, but never really experimented with making my own operators
2023-01-17 14:40:18 +0100 <Joao003> (ap (,) id) in my example can be replaced with (join (,))
2023-01-17 14:40:28 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-17 14:40:39 +0100 <dminuoso> Yeah fair, it's just some hopefully interesting facts. I dont personally like using these.
2023-01-17 14:41:56 +0100 <Joao003> > ((uncurry ((.) concat . (zipWith (\x y -> [x, y])))) . (join (,))) "Hello, World!"
2023-01-17 14:41:59 +0100 <lambdabot> "HHeelllloo,, WWoorrlldd!!"
2023-01-17 14:42:39 +0100 <anatta> dminuoso: well, you can't know what features I've seen before and what features are new to me, so I appreciate it ;)
2023-01-17 14:43:04 +0100 <mauke> :t concatMap (replicate 2)
2023-01-17 14:43:05 +0100 <lambdabot> Foldable t => t b -> [b]
2023-01-17 14:43:34 +0100 <Joao003> > replicate 3 "test"
2023-01-17 14:43:35 +0100 <lambdabot> ["test","test","test"]
2023-01-17 14:44:29 +0100 <Joao003> > (concat . map) (replicate 3) "test"
2023-01-17 14:44:31 +0100 <lambdabot> error:
2023-01-17 14:44:31 +0100 <lambdabot> • Couldn't match expected type ‘[Char] -> t’
2023-01-17 14:44:31 +0100 <lambdabot> with actual type ‘[[a0]]’
2023-01-17 14:44:45 +0100 <Joao003> > concatMap (replicate 3) "test"
2023-01-17 14:44:47 +0100 <lambdabot> "ttteeesssttt"
2023-01-17 14:45:19 +0100 <Joao003> @let multChars = replicate >>= concatMap
2023-01-17 14:45:20 +0100 <lambdabot> /sandbox/tmp/.L.hs:158:27: error:
2023-01-17 14:45:20 +0100 <lambdabot> • Couldn't match type ‘t0 a’ with ‘Int’
2023-01-17 14:45:20 +0100 <lambdabot> Expected type: (a -> [a]) -> Int -> [a]
2023-01-17 14:45:45 +0100 <anatta> > foldr (\x acc -> x : x : acc) [] "test"
2023-01-17 14:45:45 +0100 <Joao003> :t (>>=)
2023-01-17 14:45:47 +0100 <lambdabot> Monad m => m a -> (a -> m b) -> m b
2023-01-17 14:45:47 +0100 <lambdabot> "tteesstt"
2023-01-17 14:46:06 +0100 <Joao003> @src (>>=)
2023-01-17 14:46:06 +0100 <lambdabot> Source not found. Maybe if you used more than just two fingers...
2023-01-17 14:46:11 +0100Cybro(~Cybro@user/Cybro)
2023-01-17 14:46:35 +0100 <Joao003> > (replicate >>= concatMap) 2 "test"
2023-01-17 14:46:37 +0100 <lambdabot> error:
2023-01-17 14:46:37 +0100 <lambdabot> • Couldn't match type ‘[a0]’ with ‘[Char] -> t’
2023-01-17 14:46:37 +0100 <lambdabot> Expected type: Int -> [Char] -> t
2023-01-17 14:46:45 +0100 <Joao003> th
2023-01-17 14:46:59 +0100 <dminuoso> anatta: the one place where I like these, is for displaying how a list type can be made from hand easily
2023-01-17 14:47:12 +0100 <Joao003> > (concatMap >>= replicate) 2 "test"
2023-01-17 14:47:13 +0100 <lambdabot> error:
2023-01-17 14:47:13 +0100 <lambdabot> • Couldn't match type ‘t0 a0 -> [b0]’ with ‘Int’
2023-01-17 14:47:13 +0100 <lambdabot> Expected type: (a0 -> [b0]) -> Int
2023-01-17 14:47:28 +0100 <Cybro> I'm trying to make "filter" using only foldr (and lambdas). I'm having trouble converting a unary predicate into a binary function that foldr can use. Can anyone help?
2023-01-17 14:47:29 +0100 <dminuoso> % data MyList a = a :| MyList | Nil
2023-01-17 14:47:29 +0100 <yahb2> <interactive>:80:22: error: ; • Expecting one more argument to ‘MyList’ ; Expected a type, but ‘MyList’ has kind ‘* -> *’ ; • In the type ‘MyList’ ; In the definition of data co...
2023-01-17 14:47:32 +0100 <dminuoso> % data MyList a = a :| MyList a | Nil
2023-01-17 14:47:32 +0100 <yahb2> <no output>
2023-01-17 14:47:39 +0100 <anatta> > concat . map (replicate 3) $ "test"
2023-01-17 14:47:41 +0100 <lambdabot> "ttteeesssttt"
2023-01-17 14:47:41 +0100 <dminuoso> % infixr 5 :|
2023-01-17 14:47:41 +0100 <yahb2> <interactive>:84:10: error: ; The fixity signature for ‘:|’ lacks an accompanying binding ; (The fixity signature must be given where ‘:|’ is declared)
2023-01-17 14:47:48 +0100 <anatta> is what you want Joao003
2023-01-17 14:47:50 +0100 <anatta> I think
2023-01-17 14:47:51 +0100 <dminuoso> Gah, well its ghcid. But you get the idea.
2023-01-17 14:48:18 +0100 <__monty__> geekosaur: About yesterday's issue, I think I've found an MRE, seems like a legitimate cabal-install bug, https://github.com/haskell/cabal/issues/8687
2023-01-17 14:48:23 +0100 <Joao003> > concatMap (replicate 2) "test"
2023-01-17 14:48:25 +0100 <lambdabot> "tteesstt"
2023-01-17 14:48:28 +0100 <mauke> Cybro: the other argument is the rest of the results
2023-01-17 14:48:31 +0100 <geekosaur> interesting
2023-01-17 14:48:34 +0100 <dminuoso> % data MyList a = a :| MyList a | Nil; infixr 5 :|
2023-01-17 14:48:34 +0100 <yahb2> <no output>
2023-01-17 14:48:39 +0100 <Joao003> this is in the shape of >>=
2023-01-17 14:48:43 +0100 <anatta> dminuoso: yeah, having prefixed cons gets a bit cluttered
2023-01-17 14:49:10 +0100 <dminuoso> % data MyList a = a :| MyList a | Nil deriving Show; infixr 5 :|
2023-01-17 14:49:10 +0100 <yahb2> <no output>
2023-01-17 14:49:10 +0100 <Joao003> :t (replicate >>= concatMap)
2023-01-17 14:49:11 +0100 <lambdabot> error:
2023-01-17 14:49:11 +0100 <lambdabot> • Couldn't match type ‘t0 a’ with ‘Int’
2023-01-17 14:49:11 +0100 <lambdabot> Expected type: (a -> [a]) -> Int -> [a]
2023-01-17 14:49:15 +0100 <dminuoso> % 1 :| 2 :| 3 :| Nil
2023-01-17 14:49:15 +0100 <yahb2> 1 :| (2 :| (3 :| Nil))
2023-01-17 14:49:17 +0100 <Joao003> but it doesn't work
2023-01-17 14:49:30 +0100 <mauke> :t (=<<) . replicate
2023-01-17 14:49:31 +0100 <lambdabot> Int -> [b] -> [b]
2023-01-17 14:49:33 +0100 <dminuoso> A bit sad there's not enough machinery to elide these redundant parens there
2023-01-17 14:49:51 +0100 <Joao003> :t (replicate =<< concatMap)
2023-01-17 14:49:52 +0100 <lambdabot> error:
2023-01-17 14:49:52 +0100 <lambdabot> • Couldn't match type ‘t0 a -> [b]’ with ‘Int’
2023-01-17 14:49:52 +0100 <lambdabot> Expected type: (a -> [b]) -> Int
2023-01-17 14:50:05 +0100 <Joao003> :t (concatMap =<< replicate)
2023-01-17 14:50:06 +0100 <lambdabot> error:
2023-01-17 14:50:06 +0100 <lambdabot> • Couldn't match type ‘Int’ with ‘t a’
2023-01-17 14:50:06 +0100 <lambdabot> Expected type: t a -> a -> [a]
2023-01-17 14:50:10 +0100 <Joao003> WHY
2023-01-17 14:50:23 +0100 <mauke> wtf are you doing
2023-01-17 14:50:28 +0100 <mauke> > ((=<<) . replicate) 2 "test"
2023-01-17 14:50:30 +0100 <lambdabot> "tteesstt"
2023-01-17 14:50:35 +0100 <Joao003> forgetting what >>= is for
2023-01-17 14:50:44 +0100 <Joao003> :t =<<
2023-01-17 14:50:46 +0100 <lambdabot> error: parse error on input ‘=<<’
2023-01-17 14:50:50 +0100 <Joao003> :t (=<<)
2023-01-17 14:50:52 +0100 <lambdabot> Monad m => (a -> m b) -> m a -> m b
2023-01-17 14:50:57 +0100 <boxscape_> > replicate 2 =<< "test"
2023-01-17 14:51:00 +0100 <lambdabot> "tteesstt"
2023-01-17 14:51:03 +0100 <Cybro> mauke, what I have currently is filter p xs = foldr p [] xs which doesn't match the typedef for filter
2023-01-17 14:51:14 +0100 <Joao003> > (=<<) == (flip >>=)
2023-01-17 14:51:16 +0100 <lambdabot> error:
2023-01-17 14:51:16 +0100 <lambdabot> • Occurs check: cannot construct the infinite type:
2023-01-17 14:51:16 +0100 <lambdabot> b1 ~ (a0 -> b0 -> c0) -> b1
2023-01-17 14:51:19 +0100 <Joao003> > (=<<) == (flip (>>=))
2023-01-17 14:51:21 +0100 <lambdabot> error:
2023-01-17 14:51:21 +0100 <lambdabot> • Ambiguous type variable ‘m0’ arising from a use of ‘=<<’
2023-01-17 14:51:21 +0100 <lambdabot> prevents the constraint ‘(Monad m0)’ from being solved.
2023-01-17 14:51:41 +0100 <boxscape_> you will not be able to compare functions with (==)
2023-01-17 14:51:52 +0100 <Joao003> (=<<) is just (flip (>>=))
2023-01-17 14:51:56 +0100 <boxscape_> yes
2023-01-17 14:52:07 +0100 <Joao003> @src (=<<)
2023-01-17 14:52:07 +0100 <lambdabot> f =<< x = x >>= f
2023-01-17 14:52:12 +0100 <Joao003> lol
2023-01-17 14:52:14 +0100 <boxscape_> nice
2023-01-17 14:52:25 +0100 <mauke> Cybro: yeah, you need to pass a slightly different function to `foldr`
2023-01-17 14:52:25 +0100 <mauke> one that uses p internally
2023-01-17 14:52:30 +0100 <Joao003> do a 180 rotation and ur done
2023-01-17 14:53:38 +0100 <Joao003> @src Either
2023-01-17 14:53:38 +0100 <lambdabot> Source not found. I don't think I can be your friend on Facebook anymore.
2023-01-17 14:53:42 +0100 <Joao003> @src either
2023-01-17 14:53:42 +0100 <lambdabot> either f _ (Left x) = f x
2023-01-17 14:53:42 +0100 <lambdabot> either _ g (Right y) = g y
2023-01-17 14:53:51 +0100razetime(~Thunderbi@117.193.0.183)
2023-01-17 14:54:06 +0100 <anatta> Joao003: often you want to apply a function outside some context on something inside a context instead, and then you typically use <$>
2023-01-17 14:54:15 +0100 <Joao003> i understand
2023-01-17 14:54:17 +0100 <anatta> or <*> if the function is already inside the context
2023-01-17 14:54:39 +0100 <Joao003> :t (<$>)
2023-01-17 14:54:40 +0100 <lambdabot> Functor f => (a -> b) -> f a -> f b
2023-01-17 14:54:55 +0100 <anatta> > (+1) <$> [1..3]
2023-01-17 14:54:57 +0100 <lambdabot> [2,3,4]
2023-01-17 14:55:02 +0100 <Joao003> fmap?
2023-01-17 14:55:05 +0100 <anatta> yes
2023-01-17 14:55:13 +0100 <Joao003> > fmap (+1) [1..3]
2023-01-17 14:55:14 +0100 <anatta> > [(+1)] <*> [1..3]
2023-01-17 14:55:15 +0100 <lambdabot> [2,3,4]
2023-01-17 14:55:16 +0100 <lambdabot> [2,3,4]
2023-01-17 14:55:40 +0100 <Joao003> > [(+1), (+2)] <*> [1..3]
2023-01-17 14:55:41 +0100kurbus(~kurbus@user/kurbus)
2023-01-17 14:55:42 +0100 <lambdabot> [2,3,4,3,4,5]
2023-01-17 14:55:46 +0100 <Joao003> oh nice
2023-01-17 14:56:04 +0100 <Joao003> @src (<$>)
2023-01-17 14:56:04 +0100 <lambdabot> f <$> a = fmap f a
2023-01-17 14:56:09 +0100 <Joao003> nice
2023-01-17 14:56:48 +0100 <Joao003> :t (<*>)
2023-01-17 14:56:49 +0100 <lambdabot> Applicative f => f (a -> b) -> f a -> f b
2023-01-17 14:56:53 +0100mimmy__(~mimmy@37.19.212.48)
2023-01-17 14:57:19 +0100 <anatta> it's kind of like ap
2023-01-17 14:57:25 +0100 <Joao003> :t ap
2023-01-17 14:57:26 +0100 <lambdabot> Monad m => m (a -> b) -> m a -> m b
2023-01-17 14:57:37 +0100 <Joao003> ap for applicatives
2023-01-17 14:57:56 +0100justsomeguy(~justsomeg@user/justsomeguy)
2023-01-17 14:58:02 +0100 <Joao003> ap is just liftM right
2023-01-17 14:58:29 +0100 <Joao003> @src ap
2023-01-17 14:58:29 +0100 <lambdabot> ap = liftM2 id
2023-01-17 14:58:34 +0100 <Joao003> liftM2
2023-01-17 14:58:39 +0100 <Joao003> on id
2023-01-17 14:58:58 +0100 <Cybro> mauke, I'm thinking of using a lambda for that. Would my accumulator need to be the rest of the list?
2023-01-17 14:59:03 +0100 <Joao003> :t ($)
2023-01-17 14:59:04 +0100 <lambdabot> (a -> b) -> a -> b
2023-01-17 14:59:16 +0100 <Joao003> ($) just calls a function
2023-01-17 14:59:22 +0100 <Joao003> :t (*)
2023-01-17 14:59:23 +0100 <lambdabot> Num a => a -> a -> a
2023-01-17 14:59:26 +0100 <Joao003> oh no
2023-01-17 15:01:47 +0100 <boxscape_> If the non-applicative version of <$> is $, the non-applicative version of <*> is... I think also just $
2023-01-17 15:02:01 +0100 <Joao003> > [(+1), (+2)] <*> [1..5]
2023-01-17 15:02:03 +0100 <lambdabot> [2,3,4,5,6,3,4,5,6,7]
2023-01-17 15:02:14 +0100 <Joao003> > [(+1), (+2)] $ [1..5]
2023-01-17 15:02:15 +0100 <lambdabot> error:
2023-01-17 15:02:15 +0100 <lambdabot> • Couldn't match expected type ‘[a1] -> t’
2023-01-17 15:02:15 +0100 <lambdabot> with actual type ‘[a0 -> a0]’
2023-01-17 15:02:18 +0100 <Joao003> nope
2023-01-17 15:02:40 +0100 <boxscape_> non-applicative meaning applied to values that aren't in an applicative context
2023-01-17 15:02:45 +0100 <boxscape_> % (+1) $ 1
2023-01-17 15:02:45 +0100 <anatta> I mean you wouldn't be able to use $ in place of <$> either
2023-01-17 15:02:45 +0100 <yahb2> 2
2023-01-17 15:02:48 +0100 <Joao003> > [(+1), (+2)] <$> [1,2,3]
2023-01-17 15:02:50 +0100 <lambdabot> error:
2023-01-17 15:02:50 +0100 <lambdabot> • Couldn't match expected type ‘a1 -> b’
2023-01-17 15:02:50 +0100 <lambdabot> with actual type ‘[a0 -> a0]’
2023-01-17 15:03:12 +0100 <Joao003> <*> for monads is ap
2023-01-17 15:03:33 +0100 <Joao003> > [(+1), (+2)] `ap` [1..5]
2023-01-17 15:03:35 +0100 <lambdabot> [2,3,4,5,6,3,4,5,6,7]
2023-01-17 15:04:16 +0100justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 252 seconds)
2023-01-17 15:04:39 +0100 <Joao003> if u do it right you could do something like apl's outer product
2023-01-17 15:08:53 +0100 <boxscape_> > map (zipWith (+) [1..5] . repeat) [1..5]
2023-01-17 15:08:54 +0100 <lambdabot> [[2,3,4,5,6],[3,4,5,6,7],[4,5,6,7,8],[5,6,7,8,9],[6,7,8,9,10]]
2023-01-17 15:09:10 +0100 <merijn> That feeling where, to switch to a faster compiler you have to do a billion compiles to fix compatibility using the old compiler >.>
2023-01-17 15:09:18 +0100 <Cybro> Is there a nicer way to write "\x acc -> if p x then x : acc else acc"?
2023-01-17 15:10:10 +0100 <merijn> not really, tbh
2023-01-17 15:10:23 +0100 <boxscape_> some people define `applyWhen` so that you can have `\x acc -> applyWhen (p x) (x : ) acc`
2023-01-17 15:11:26 +0100gtdg(~gtdg@nat-inria-interne-72-gw-01-lne.lille.inria.fr)
2023-01-17 15:11:41 +0100gtdg(~gtdg@nat-inria-interne-72-gw-01-lne.lille.inria.fr) (Changing host)
2023-01-17 15:11:41 +0100gtdg(~gtdg@user/gtdg)
2023-01-17 15:13:01 +0100 <Joao003> :t repeat
2023-01-17 15:13:02 +0100 <lambdabot> a -> [a]
2023-01-17 15:13:10 +0100 <Joao003> @src repeat
2023-01-17 15:13:10 +0100 <lambdabot> repeat x = xs where xs = x : xs
2023-01-17 15:13:16 +0100 <Franciman> :t foldr
2023-01-17 15:13:18 +0100 <lambdabot> Foldable t => (a -> b -> b) -> b -> t a -> b
2023-01-17 15:13:29 +0100 <Joao003> > repeat 1
2023-01-17 15:13:31 +0100 <lambdabot> [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1...
2023-01-17 15:13:35 +0100 <Joao003> oh my god
2023-01-17 15:14:15 +0100 <anatta> > cycle [1, 2]
2023-01-17 15:14:17 +0100 <lambdabot> [1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2...
2023-01-17 15:14:25 +0100 <Joao003> repeat [1,2,3]
2023-01-17 15:14:26 +0100 <boxscape_> > cycle []
2023-01-17 15:14:28 +0100 <lambdabot> *Exception: Prelude.cycle: empty list
2023-01-17 15:14:36 +0100 <Joao003> > repeat [1,2,3]
2023-01-17 15:14:37 +0100 <merijn> > let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in fibs
2023-01-17 15:14:38 +0100 <lambdabot> [[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,...
2023-01-17 15:14:39 +0100 <lambdabot> [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,...
2023-01-17 15:14:48 +0100 <merijn> > let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in fibs !! 10000
2023-01-17 15:14:50 +0100 <lambdabot> 3364476487643178326662161200510754331030214846068006390656476997468008144216...
2023-01-17 15:14:53 +0100 <boxscape_> hmm not sure if [] or bottom is more reasonable for cycle []
2023-01-17 15:15:07 +0100 <merijn> 10,000th Fibonacci number ;)
2023-01-17 15:19:11 +0100ddellacosta(~ddellacos@89.45.224.240) (Ping timeout: 268 seconds)
2023-01-17 15:19:27 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-17 15:20:44 +0100 <kuribas> you need to use matrix multiplication...
2023-01-17 15:21:48 +0100int-index-r(~Vladislav@2a00:1370:8178:5994:87d0:2048:7511:2eba)
2023-01-17 15:22:11 +0100 <Jadesheit[m]> fibs = 0 : scanr (+) 1 fibs
2023-01-17 15:22:40 +0100 <Jadesheit[m]> wait no, im stupid
2023-01-17 15:23:15 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 260 seconds)
2023-01-17 15:23:19 +0100 <Joao003> @let palindrome x = x : t where reverse (x : t) == (x : t)
2023-01-17 15:23:19 +0100 <lambdabot> Parse failed: Parse error: EOF
2023-01-17 15:23:21 +0100 <Jadesheit[m]> needs to be scanl
2023-01-17 15:24:18 +0100 <Joao003> > reverse "wow" == "wow"
2023-01-17 15:24:20 +0100 <lambdabot> True
2023-01-17 15:25:14 +0100thegeekinside(~thegeekin@189.217.82.244)
2023-01-17 15:25:29 +0100 <Joao003> > map (zipWith (*) [1..5] . repeat) [1..5]
2023-01-17 15:25:31 +0100 <lambdabot> [[1,2,3,4,5],[2,4,6,8,10],[3,6,9,12,15],[4,8,12,16,20],[5,10,15,20,25]]
2023-01-17 15:25:33 +0100int-index(~Vladislav@2a00:1370:8178:5994:30e6:1466:2eaa:dd53) (Ping timeout: 265 seconds)
2023-01-17 15:26:22 +0100 <Joao003> @let outerProduct f x = map (zipWith f x . repeat)
2023-01-17 15:26:24 +0100 <lambdabot> Defined.
2023-01-17 15:26:30 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2023-01-17 15:26:51 +0100 <Joao003> > join (outerProduct (*)) [1..5]
2023-01-17 15:26:52 +0100 <anatta> but can you prove that (reverse . reverse l) == l for all l ;)
2023-01-17 15:26:53 +0100 <lambdabot> [[1,2,3,4,5],[2,4,6,8,10],[3,6,9,12,15],[4,8,12,16,20],[5,10,15,20,25]]
2023-01-17 15:27:52 +0100 <Joao003> @pl \f x -> map (zipWith f x . repeat)
2023-01-17 15:27:52 +0100 <lambdabot> (map .) . flip flip repeat . ((.) .) . zipWith
2023-01-17 15:27:57 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-17 15:27:58 +0100 <Joao003> oh my god
2023-01-17 15:28:17 +0100 <boxscape_> @unpl (map .) . flip flip repeat . ((.) .) . zipWith
2023-01-17 15:28:17 +0100 <lambdabot> (\ x x0 -> map (\ x2 -> zipWith x x0 (repeat x2)))
2023-01-17 15:28:43 +0100 <Joao003> > ((map .) . flip flip repeat . ((.) .) . zipWith) (*) [1..5] [1..5]
2023-01-17 15:28:45 +0100 <lambdabot> [[1,2,3,4,5],[2,4,6,8,10],[3,6,9,12,15],[4,8,12,16,20],[5,10,15,20,25]]
2023-01-17 15:29:18 +0100piele(~piele@tbonesteak.creativeserver.net) (Quit: Ciao!)
2023-01-17 15:29:59 +0100 <Joao003> whatever that was
2023-01-17 15:30:22 +0100 <Joao003> :t (map .) . flip flip repeat . ((.) .) . zipWith
2023-01-17 15:30:23 +0100 <lambdabot> (a1 -> a2 -> c) -> [a1] -> [a2] -> [[c]]
2023-01-17 15:30:24 +0100 <geekosaur> friends don't let friends code pointfree 🙂
2023-01-17 15:30:32 +0100 <Joao003> exactly what i expected
2023-01-17 15:30:56 +0100 <Joao003> flip flip flip flip flip flip flip flip flip flip
2023-01-17 15:32:33 +0100 <geekosaur> "flippant and a bit dotty"
2023-01-17 15:33:00 +0100 <Joao003> "flippy and periodant"
2023-01-17 15:33:45 +0100 <anatta> Joao003: have you heard about our lord and savior (.) . (.)?
2023-01-17 15:34:07 +0100 <anatta> :t (.) . (.)
2023-01-17 15:34:07 +0100 <Joao003> you can point-free, or rather function-free in python
2023-01-17 15:34:08 +0100 <lambdabot> (b -> c) -> (a1 -> a2 -> b) -> a1 -> a2 -> c
2023-01-17 15:34:29 +0100 <Joao003> :t . ((.) .) .
2023-01-17 15:34:30 +0100 <anatta> it's like composition with functions of different arity
2023-01-17 15:34:30 +0100 <lambdabot> error: parse error on input ‘.’
2023-01-17 15:34:36 +0100 <Joao003> :t . ((.) .)
2023-01-17 15:34:38 +0100 <lambdabot> error: parse error on input ‘.’
2023-01-17 15:34:40 +0100 <dminuoso> If you're extra brave you can also use
2023-01-17 15:34:45 +0100 <dminuoso> % :t fmap fmap fmap
2023-01-17 15:34:45 +0100 <yahb2> fmap fmap fmap ; :: (Functor f1, Functor f2) => (a -> b) -> f1 (f2 a) -> f1 (f2 b)
2023-01-17 15:35:12 +0100 <dminuoso> % :t [fmap fmap fmap, (.) . (.)]
2023-01-17 15:35:12 +0100 <yahb2> [fmap fmap fmap, (.) . (.)] ; :: [(a1 -> b) -> (a2 -> a3 -> a1) -> a2 -> a3 -> b]
2023-01-17 15:35:16 +0100 <Joao003> :t ap ap ap
2023-01-17 15:35:18 +0100 <lambdabot> error:
2023-01-17 15:35:18 +0100 <lambdabot> • Occurs check: cannot construct the infinite type:
2023-01-17 15:35:18 +0100 <lambdabot> m ~ (->) (m (m b))
2023-01-17 15:35:35 +0100 <boxscape_> similar to cddr and such we should have fffmap for (fmap . fmap . fmap). and tttraverse
2023-01-17 15:35:40 +0100 <anatta> don't break the type system :(
2023-01-17 15:35:43 +0100 <Joao003> :t (<*>) <*> (<*>)
2023-01-17 15:35:44 +0100 <lambdabot> error:
2023-01-17 15:35:44 +0100 <lambdabot> • Occurs check: cannot construct the infinite type:
2023-01-17 15:35:44 +0100 <lambdabot> f ~ (->) (f (f b))
2023-01-17 15:35:52 +0100thebinary(~thebinary@2400:1a00:b040:11cf:c948:e2cc:186e:ea47)
2023-01-17 15:36:00 +0100 <dminuoso> boxscape_: tttraverse reads like a very distasteful joke on stuttering people. :/
2023-01-17 15:36:05 +0100 <boxscape_> :(
2023-01-17 15:36:20 +0100thegeekinside(~thegeekin@189.217.82.244) (Remote host closed the connection)
2023-01-17 15:36:25 +0100 <Joao003> lambdabot correct your grammar cuz "Occurs check"? /s
2023-01-17 15:36:32 +0100thegeekinside(~thegeekin@189.217.82.244)
2023-01-17 15:37:06 +0100 <Joao003> try to get a non-existant src and lambdabot will make fun of you
2023-01-17 15:37:10 +0100 <Joao003> @src Monad
2023-01-17 15:37:10 +0100 <lambdabot> class Applicative m => Monad m where
2023-01-17 15:37:10 +0100 <lambdabot> -- Note: Applicative wasn't a superclass before GHC 7.10
2023-01-17 15:37:10 +0100 <lambdabot> (>>=) :: m a -> (a -> m b) -> m b
2023-01-17 15:37:10 +0100 <lambdabot> (>>) :: m a -> m b -> m b
2023-01-17 15:37:10 +0100 <lambdabot> return :: a -> m a
2023-01-17 15:37:12 +0100 <lambdabot> fail :: String -> m a
2023-01-17 15:37:16 +0100 <Joao003> @src (>>=)
2023-01-17 15:37:16 +0100 <lambdabot> Source not found.
2023-01-17 15:37:19 +0100 <anatta> Joao003: https://hackage.haskell.org/package/data-aviary-0.4.0/docs/Data-Aviary-Birds.html
2023-01-17 15:37:27 +0100 <anatta> all the birds
2023-01-17 15:38:09 +0100 <Joao003> > kite 1 2
2023-01-17 15:38:11 +0100 <lambdabot> error:
2023-01-17 15:38:11 +0100 <lambdabot> Variable not in scope: kite :: t0 -> t1 -> t
2023-01-17 15:38:42 +0100 <Joao003> > 1 `kite` 2
2023-01-17 15:38:44 +0100 <lambdabot> error:
2023-01-17 15:38:44 +0100 <lambdabot> Variable not in scope: kite :: t0 -> t1 -> t
2023-01-17 15:38:48 +0100 <Joao003> wth
2023-01-17 15:38:53 +0100 <Joao003> > kestrel 1 2
2023-01-17 15:38:55 +0100 <lambdabot> error:
2023-01-17 15:38:55 +0100 <lambdabot> Variable not in scope: kestrel :: t0 -> t1 -> t
2023-01-17 15:39:05 +0100 <geekosaur> they're not imported into lambdabot
2023-01-17 15:39:17 +0100 <Joao003> > import Data.Aviary.Birds
2023-01-17 15:39:19 +0100 <lambdabot> <hint>:1:1: error: parse error on input ‘import’
2023-01-17 15:39:30 +0100 <Joao003> @import Data.Aviary.Birds
2023-01-17 15:39:30 +0100 <lambdabot> Unknown command, try @list
2023-01-17 15:39:33 +0100 <Joao003> @list
2023-01-17 15:39:34 +0100 <lambdabot> What module? Try @listmodules for some ideas.
2023-01-17 15:39:42 +0100 <Joao003> @list Data.Aviary.Birds
2023-01-17 15:39:43 +0100 <lambdabot> No module "Data.Aviary.Birds" loaded
2023-01-17 15:39:43 +0100 <geekosaur> @let import Data.Aviary.Birds
2023-01-17 15:39:43 +0100 <lambdabot> /sandbox/tmp/.L.hs:68:1: error:
2023-01-17 15:39:43 +0100 <lambdabot> Could not find module ‘Data.Aviary.Birds’
2023-01-17 15:39:43 +0100 <lambdabot> Use -v (or `:set -v` in ghci) to see a list of the files searched for.
2023-01-17 15:39:56 +0100 <geekosaur> and it doesn;t have access to hackage
2023-01-17 15:39:56 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Quit: ZNC - https://znc.in)
2023-01-17 15:40:06 +0100 <anatta> you have to define them on your own
2023-01-17 15:40:12 +0100 <Joao003> oh no
2023-01-17 15:40:24 +0100 <Joao003> kite is just flip const
2023-01-17 15:40:36 +0100 <anatta> you can see the source on hackage
2023-01-17 15:40:47 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-17 15:40:53 +0100AlexNoo_AlexNoo
2023-01-17 15:41:03 +0100 <Joao003> identity is called idiot XD
2023-01-17 15:41:04 +0100thebinary(~thebinary@2400:1a00:b040:11cf:c948:e2cc:186e:ea47) (Read error: Connection reset by peer)
2023-01-17 15:41:35 +0100chiselfuse(~chiselfus@user/chiselfuse) (Ping timeout: 255 seconds)
2023-01-17 15:42:36 +0100 <Joao003> > on (*) (+1) 1 2
2023-01-17 15:42:38 +0100 <lambdabot> 6
2023-01-17 15:43:33 +0100 <Joao003> @pl \f g a b -> f (g a) (g b)
2023-01-17 15:43:33 +0100 <lambdabot> join . ((flip . ((.) .)) .) . (.)
2023-01-17 15:43:38 +0100 <Joao003> ah yes
2023-01-17 15:43:48 +0100 <Joao003> pointless on
2023-01-17 15:43:54 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-01-17 15:44:29 +0100 <Joao003> > (join . ((flip . ((.) .)) .) . (.)) (*) (+1) 1 2
2023-01-17 15:44:32 +0100 <lambdabot> 6
2023-01-17 15:44:48 +0100 <Joao003> lesson learned: never code pointfree
2023-01-17 15:45:20 +0100thebinary(~thebinary@2400:1a00:b040:11cf:c948:e2cc:186e:ea47)
2023-01-17 15:46:21 +0100 <Joao003> :t \f -> (\x -> f x x) (\x -> f x x)
2023-01-17 15:46:22 +0100 <lambdabot> error:
2023-01-17 15:46:22 +0100 <lambdabot> • Occurs check: cannot construct the infinite type: t ~ t -> t1
2023-01-17 15:46:22 +0100 <lambdabot> • In the first argument of ‘\ x -> f x x’, namely ‘(\ x -> f x x)’
2023-01-17 15:46:29 +0100 <anatta> sometimes pointfree is nice, but it's not great to write pointfree just for the sake of writing pointfree code
2023-01-17 15:46:34 +0100 <Joao003> yeah
2023-01-17 15:46:35 +0100 <thebinary> Could not find module ‘System.Environment’
2023-01-17 15:47:22 +0100piele(~piele@tbonesteak.creativeserver.net)
2023-01-17 15:47:45 +0100 <thebinary> `import System.Environment (getArgs)` returns the above error. What should be done?
2023-01-17 15:47:58 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:53c1:5ba:8f53:5689)
2023-01-17 15:48:19 +0100 <merijn> thebinary: How are you compiling?
2023-01-17 15:48:41 +0100 <merijn> Looks like you're missing a dependency on base, which is kinda odd
2023-01-17 15:48:45 +0100 <Joao003> @hoogle fix
2023-01-17 15:48:46 +0100 <lambdabot> Data.Function fix :: (a -> a) -> a
2023-01-17 15:48:46 +0100 <thebinary> merijn: ghc --make InteractWith.hs
2023-01-17 15:48:46 +0100 <lambdabot> Control.Monad.Fix fix :: (a -> a) -> a
2023-01-17 15:48:46 +0100 <lambdabot> Protolude fix :: () => (a -> a) -> a
2023-01-17 15:49:03 +0100 <Cybro> I'm trying to make group using filter, my current lambda is "\x sublist -> if x == head sublist then x:sublist else [x]" but it's incorrect, does anyone know what would make it work?
2023-01-17 15:49:17 +0100 <merijn> thebinary: I dunno who told you to use --make, but that flag has been redundant for well over a decade :p
2023-01-17 15:49:45 +0100 <merijn> mm, I'd think ghc automatically includes base when compiling
2023-01-17 15:49:52 +0100 <thebinary> merijn: i am new to haskell. Was learning using real world haskell book
2023-01-17 15:50:02 +0100 <merijn> thebinary: Can you pastebin the entire error
2023-01-17 15:50:05 +0100 <merijn> @paste
2023-01-17 15:50:05 +0100 <lambdabot> A pastebin: https://paste.debian.net/
2023-01-17 15:50:06 +0100 <anatta> rwh is like 10+ years old
2023-01-17 15:50:11 +0100 <anatta> afaik
2023-01-17 15:50:13 +0100kurbus(~kurbus@user/kurbus) (Quit: Client closed)
2023-01-17 15:50:23 +0100 <[exa]> Cybro: you may generate all contiguous subsequences (map inits . tails?) and then filter out the OK ones...but that's still going to be quite horrible
2023-01-17 15:50:24 +0100 <merijn> anatta: Yeah, although --make was redundant when it came out too :p
2023-01-17 15:50:40 +0100merijnhas a sneaking suspicion to be confirmed by full error
2023-01-17 15:50:43 +0100 <razetime> how do people pattern match on free monads?
2023-01-17 15:50:43 +0100 <razetime> 1234 val <- case ext of
2023-01-17 15:50:43 +0100 <razetime> F (I.ExtOpError _) -> error "interpreter error"
2023-01-17 15:50:43 +0100 <razetime> F (I.ExtOpTrace w v _) -> pure $ putDocLn $ pretty w <> ":" <+> unAnnotate v
2023-01-17 15:50:43 +0100 <razetime> F (I.ExtOpBreak {}) -> error "break"
2023-01-17 15:50:43 +0100 <razetime> ext is of type F ExtOp Value
2023-01-17 15:50:55 +0100 <merijn> razetime: Painfully? ;)
2023-01-17 15:51:03 +0100 <Joao003> @pl \f -> (\x -> f (x x)) (\x -> f (x x))
2023-01-17 15:51:03 +0100 <anatta> mechap: I'll take your word for it, it was long before I got into haskell
2023-01-17 15:51:03 +0100 <lambdabot> ap (. join id) (. join id)
2023-01-17 15:51:06 +0100 <anatta> eh
2023-01-17 15:51:08 +0100 <[exa]> Cybro: the "shape" of what `filter` does doesn't really match the "shape" that you want from `group`.... Maybe better try with `foldr`
2023-01-17 15:51:15 +0100 <merijn> razetime: You might want to look into the PatternSynonyms extension to get some less painfull patterns
2023-01-17 15:51:16 +0100 <anatta> not mechap, merijn
2023-01-17 15:51:34 +0100 <thebinary> merijn: https://paste.tomsmeding.com/URSXgXrd
2023-01-17 15:51:49 +0100 <merijn> thebinary: Oh, lemme take a *wild* guess
2023-01-17 15:51:51 +0100 <razetime> i'd like to know what the patterns are in the first place..
2023-01-17 15:51:54 +0100 <merijn> thebinary: You use Arch
2023-01-17 15:52:12 +0100 <razetime> currently i'm getting an error i don't understand
2023-01-17 15:52:19 +0100 <merijn> Did I guess right? :D
2023-01-17 15:52:23 +0100 <thebinary> merijn: i am trying within termux
2023-01-17 15:52:31 +0100 <razetime> • Couldn't match expected type: (I.Value -> r0)
2023-01-17 15:52:31 +0100 <razetime> -> (I.ExtOp r0 -> r0) -> r0
2023-01-17 15:52:31 +0100 <razetime> with actual type: I.ExtOp a0
2023-01-17 15:52:31 +0100 <razetime> • In the pattern: I.ExtOpError _
2023-01-17 15:52:31 +0100 <razetime> In the pattern: F (I.ExtOpError _)
2023-01-17 15:52:31 +0100Vajb(~Vajb@2001:999:78d:d7:457c:7773:573e:6903) (Ping timeout: 260 seconds)
2023-01-17 15:52:32 +0100 <razetime> In a case alternative:
2023-01-17 15:52:32 +0100 <razetime> F (I.ExtOpError _) -> error "interpreter error"
2023-01-17 15:52:54 +0100 <merijn> thebinary: Basically, what that error is saying is that your GHC install is broken
2023-01-17 15:52:55 +0100 <[exa]> razetime: please use pastebing, code gets horribly borked in IRC and it just kills everyone's screen with conversation
2023-01-17 15:52:56 +0100 <thebinary> merijn: Linux localhost 4.14.113-24230781 #1 SMP PREEMPT Wed Oct 5 10:02:10 KST 2022 aarch64 Android
2023-01-17 15:52:59 +0100 <[exa]> *pastebin
2023-01-17 15:53:00 +0100 <razetime> i see.
2023-01-17 15:53:04 +0100beefyran(~beefyran@2601:406:100:830:ad1c:493f:e8fc:867)
2023-01-17 15:53:11 +0100 <merijn> thebinary: "Could not find module ‘Prelude’ There are files missing in the ‘base-4.14.3.0’ package,"
2023-01-17 15:53:27 +0100 <razetime> https://paste.tomsmeding.com/5MJ3rG7P this is the error
2023-01-17 15:53:27 +0100 <anatta> It amuses me that the part you focused on was "System.Environment is not there"
2023-01-17 15:53:35 +0100 <anatta> and not "Prelude is missing"
2023-01-17 15:53:40 +0100 <merijn> thebinary: base and prelude are part of GHC, if those thing are missing files, something is very, *very* broken
2023-01-17 15:54:02 +0100Cybro(~Cybro@user/Cybro) (Ping timeout: 256 seconds)
2023-01-17 15:54:03 +0100 <merijn> thebinary: Arch notably ships a GHC that's broken in it's packages, hence that's my first thought
2023-01-17 15:54:31 +0100 <merijn> thebinary: But in short, the answer is: Nothing is wrong with your code (well, maybe there is, but at least it's not causing this error ;))
2023-01-17 15:54:43 +0100 <geekosaur[m]> Or you are using Arch packages and need -dynamic
2023-01-17 15:54:45 +0100 <merijn> But something is very, very wrong with your GHC install
2023-01-17 15:54:46 +0100 <Joao003> if u have missing Prelude you have trash
2023-01-17 15:55:03 +0100 <merijn> thebinary: You can try doing "ghc -dynamic InteractWith.hs"
2023-01-17 15:55:13 +0100 <thebinary> anatta: apologies i missed the first part of the error and focused on the end part of the error report
2023-01-17 15:55:14 +0100 <Joao003> what is this square with 4 circles character
2023-01-17 15:55:15 +0100 <merijn> If that works, you probably have an Arch based GHC package
2023-01-17 15:55:28 +0100 <anatta> thebinary: no worries, we've all been there
2023-01-17 15:55:34 +0100Cybro(~Cybro@user/Cybro)
2023-01-17 15:56:02 +0100 <anatta> thebinary: one time I clicked something in VSCode making it "import Prelude (whatever)"
2023-01-17 15:56:11 +0100 <anatta> took me ages to debug
2023-01-17 15:56:12 +0100 <thebinary> merijn: thanks a lot. The -dynamic did the trick
2023-01-17 15:56:50 +0100 <merijn> thebinary: Arch by default ships only dynamic versions of the base libraries, but GHC (by default) links statically, so it looks for the static libs and doesn't find them and errors out cryptically
2023-01-17 15:56:59 +0100 <[exa]> razetime: the error actually corresponds to what I'd expect from the definition of F
2023-01-17 15:57:16 +0100 <merijn> thebinary: I dunno how you installed GHC, but you'd want something like ghc-static package to fix that
2023-01-17 15:57:21 +0100 <geekosaur[m]> Joao003: a Unicode character your client doesn't render
2023-01-17 15:57:41 +0100 <Joao003> in this case hexchat
2023-01-17 15:57:53 +0100 <[exa]> razetime: in particular you probably don't want to patternmatch on the F, but supply the puring/rolling functions to that and let it evaluate itself
2023-01-17 15:57:57 +0100 <thebinary> merijn: thanks a lot. It quite explains to me the cause as well.
2023-01-17 15:58:01 +0100 <geekosaur[m]> Or remove the Arch packages and use ghcup
2023-01-17 15:58:04 +0100 <merijn> geekosaur[m]: I'm seing inverted colour Q in front of dynamic, and I've seen that a few times, so I'm curious what unicode character you have in front of -dynamic
2023-01-17 15:58:10 +0100 <merijn> (or ghcup in that last one)
2023-01-17 15:58:25 +0100 <[exa]> razetime: I'd say that the patternmatches will be in the functions... see runF here: https://hackage.haskell.org/package/free-5.1.10/docs/Control-Monad-Free-Church.html#t:F
2023-01-17 15:58:35 +0100 <merijn> geekosaur[m]: termux seems to be some android device thingy, so unsure if that's an option
2023-01-17 15:58:51 +0100 <geekosaur[m]> The bridge translates code markup to control Q
2023-01-17 15:59:40 +0100 <thebinary> merijn: i found ghc-libs-static in the termux packages. Installing it. Will try again and let u know
2023-01-17 16:00:07 +0100 <geekosaur[m]> I wrote a script to translate it to something sensible but then you lose tab highlighting
2023-01-17 16:00:39 +0100 <razetime> [exa]: hm, so i need to create a functions for RunF to retrieve the value..
2023-01-17 16:00:42 +0100 <razetime> makes sense
2023-01-17 16:02:20 +0100 <thebinary> merijn: installing "ghc-libs-static" termux pkg also solved the issue. Thanks.
2023-01-17 16:04:30 +0100 <Joao003> how do you pronounce haskell
2023-01-17 16:04:38 +0100Sgeo(~Sgeo@user/sgeo)
2023-01-17 16:04:52 +0100 <Joao003> bye
2023-01-17 16:04:54 +0100Joao003(~Joao003@2804:840:8311:d200:306d:6168:be07:23f0) (Quit: Leaving)
2023-01-17 16:06:20 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-01-17 16:06:59 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-17 16:07:30 +0100 <Jadesheit[m]> has-cal
2023-01-17 16:07:31 +0100cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.7.1)
2023-01-17 16:07:39 +0100Cybro(~Cybro@user/Cybro) (Remote host closed the connection)
2023-01-17 16:07:48 +0100 <Jadesheit[m]> * has-cal/kel
2023-01-17 16:07:55 +0100Cybro(~Cybro@user/Cybro)
2023-01-17 16:09:02 +0100mimmy_(~mimmy@2607:fea8:6c0:e30:19f0:e06a:636a:c450)
2023-01-17 16:10:28 +0100cheater(~Username@user/cheater) (Ping timeout: 256 seconds)
2023-01-17 16:10:49 +0100 <dminuoso> /ˈhæskəl/
2023-01-17 16:11:07 +0100cheater(~Username@user/cheater)
2023-01-17 16:11:40 +0100mimmy__(~mimmy@37.19.212.48) (Ping timeout: 260 seconds)
2023-01-17 16:13:38 +0100mimmy_(~mimmy@2607:fea8:6c0:e30:19f0:e06a:636a:c450) (Ping timeout: 246 seconds)
2023-01-17 16:15:22 +0100mimmy_(~mimmy@45.14.195.75)
2023-01-17 16:16:40 +0100 <anatta> what dminuoso said, or /'haskəl/ depending on what language I'm speaking
2023-01-17 16:17:16 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-01-17 16:18:16 +0100kurbus(~kurbus@user/kurbus)
2023-01-17 16:18:42 +0100thebinary(~thebinary@2400:1a00:b040:11cf:c948:e2cc:186e:ea47) (Read error: Connection reset by peer)
2023-01-17 16:18:47 +0100 <cheater> hi
2023-01-17 16:18:53 +0100 <cheater> anyone know, on replit, how to import a package?
2023-01-17 16:19:11 +0100notzmv(~zmv@user/notzmv)
2023-01-17 16:20:45 +0100 <[exa]> razetime: yes that's the idea AFAIK, you can only 'roll' it. These can also very easily be just almost-`id`'s if you just want to retrieve the structure
2023-01-17 16:20:53 +0100laalyn(~laalyn@c-73-241-126-7.hsd1.ca.comcast.net)
2023-01-17 16:21:00 +0100 <[exa]> but the usual idea there is that you somehow interpret it right at the spot
2023-01-17 16:21:03 +0100 <razetime> interesting. I figured a way out with RunF
2023-01-17 16:21:09 +0100 <[exa]> \o/
2023-01-17 16:21:41 +0100thebinary(~thebinary@2400:1a00:b040:11cf:c948:e2cc:186e:ea47)
2023-01-17 16:23:10 +0100kurbus(~kurbus@user/kurbus) (Quit: Client closed)
2023-01-17 16:23:28 +0100CiaoSen(~Jura@p200300c9570452002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-01-17 16:24:18 +0100thebinary(~thebinary@2400:1a00:b040:11cf:c948:e2cc:186e:ea47) (Read error: Connection reset by peer)
2023-01-17 16:25:37 +0100CiaoSen(~Jura@p200300c95723a5002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-01-17 16:27:16 +0100son0p(~ff@181.136.122.143)
2023-01-17 16:29:14 +0100kurbus(~kurbus@user/kurbus)
2023-01-17 16:29:39 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-01-17 16:31:55 +0100gdd(~gdd@2001:470:1f13:187:e8a5:fbff:fe29:42f5) (Ping timeout: 248 seconds)
2023-01-17 16:34:26 +0100 <cheater> i'm glad we have nix now instead of cabal, cabal never worked. https://imgur.com/a/6uLDoSC
2023-01-17 16:35:39 +0100 <[exa]> great that the syntax is made perfectly clear with these just 43534 pairs of parentheses of all types!
2023-01-17 16:36:01 +0100 <merijn> cheater: Nix is great!
2023-01-17 16:36:07 +0100 <merijn> For keeping yourself employed as Nix engineer
2023-01-17 16:36:17 +0100 <cheater> sigh
2023-01-17 16:36:17 +0100 <merijn> Since no one can replace your infra without breaking everything xD
2023-01-17 16:39:02 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 16:39:39 +0100xyh(~xyh@2409:8a7a:a8a:3840:235a:9ae0:d084:eed)
2023-01-17 16:41:32 +0100 <cheater> sigh
2023-01-17 16:41:38 +0100mimmy_(~mimmy@45.14.195.75) (Ping timeout: 256 seconds)
2023-01-17 16:41:47 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-01-17 16:41:47 +0100chiselfuse(~chiselfus@user/chiselfuse) (Write error: Connection reset by peer)
2023-01-17 16:41:47 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-01-17 16:41:48 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-01-17 16:42:24 +0100 <dminuoso> To be fair, merijn has rather strong feelings for a bunch of subjects.
2023-01-17 16:42:41 +0100mimmy_(~mimmy@176.100.43.29)
2023-01-17 16:42:42 +0100califax(~califax@user/califx)
2023-01-17 16:42:57 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-01-17 16:43:06 +0100 <merijn> dminuoso: Well, I got the impression that a link to a cryptic god knows how many line error on repl.it wasn't exactly a true appreciation post ;)
2023-01-17 16:43:18 +0100Sgeo(~Sgeo@user/sgeo)
2023-01-17 16:43:20 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 256 seconds)
2023-01-17 16:44:50 +0100jonathanx_(~jonathan@h-178-174-176-109.A357.priv.bahnhof.se)
2023-01-17 16:46:38 +0100 <dminuoso> merijn: honestly thats more of statement about the repl.it diagnostics.
2023-01-17 16:46:47 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-01-17 16:47:08 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-01-17 16:47:29 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-01-17 16:47:34 +0100jonathanx(~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) (Ping timeout: 272 seconds)
2023-01-17 16:47:52 +0100 <boxscape_> is there a way for me to see which version of a package cabal decided to use?
2023-01-17 16:48:00 +0100 <dminuoso> boxscape_: cabal-plan
2023-01-17 16:48:04 +0100 <boxscape_> thank you
2023-01-17 16:48:14 +0100xyh(~xyh@2409:8a7a:a8a:3840:235a:9ae0:d084:eed) (Quit: WeeChat 3.8)
2023-01-17 16:48:36 +0100mei(~mei@user/mei) (Remote host closed the connection)
2023-01-17 16:48:52 +0100Cybro(~Cybro@user/Cybro) (Remote host closed the connection)
2023-01-17 16:49:09 +0100Cybro(~Cybro@user/Cybro)
2023-01-17 16:49:41 +0100 <merijn> Technically also "cabal freeze", I guess
2023-01-17 16:50:04 +0100 <boxscape_> does that have the side effect of freezing it?
2023-01-17 16:50:12 +0100 <dminuoso> Yeah, unless you delete the freeze file again
2023-01-17 16:50:18 +0100 <merijn> boxscape_: It generates a freeze file, so yeah
2023-01-17 16:50:19 +0100 <dminuoso> cabal-plan is something you likely want to have/use anyway
2023-01-17 16:50:19 +0100 <boxscape_> I see
2023-01-17 16:50:26 +0100 <merijn> but you can just delete the freeze file when you're done
2023-01-17 16:50:30 +0100 <boxscape_> ok
2023-01-17 16:50:40 +0100 <dminuoso> cabal-plan can, for example, generate a dot file (it can even invoke things like dot2png for you), do transitive reduction
2023-01-17 16:50:42 +0100 <dminuoso> and other useful things
2023-01-17 16:50:47 +0100 <dminuoso> its a wonderful tool to have
2023-01-17 16:50:52 +0100mei(~mei@user/mei)
2023-01-17 16:51:20 +0100 <dminuoso> or diffs between two plans
2023-01-17 16:51:24 +0100 <boxscape_> sounds neat
2023-01-17 16:51:39 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 256 seconds)
2023-01-17 16:51:51 +0100 <dminuoso> for all intends and purposes, this thing ought to be part of cabal-install
2023-01-17 16:52:00 +0100 <dminuoso> some part of it made their way even, like `list-bin`
2023-01-17 16:54:33 +0100gdd(~gdd@2001:470:1f13:187:41fc:3586:85ea:bc08)
2023-01-17 16:54:56 +0100califax(~califax@user/califx) (Ping timeout: 255 seconds)
2023-01-17 16:55:37 +0100thebinary(~thebinary@2400:1a00:b040:11cf:c948:e2cc:186e:ea47)
2023-01-17 16:56:50 +0100califax(~califax@user/califx)
2023-01-17 16:56:56 +0100acidjnk(~acidjnk@p200300d6e715c420889663d2e7d74ba2.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-01-17 16:57:56 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-01-17 16:58:01 +0100thebinary(~thebinary@2400:1a00:b040:11cf:c948:e2cc:186e:ea47) (Read error: Connection reset by peer)
2023-01-17 16:58:11 +0100 <boxscape_> cabal tells me "conflict: pkg-config package vulkan-any, not found in the pkg-config database" for the version of vulkan I want to use (and had used on a different machine). But it *does* work with an older version. Is there a way for me to just tell cabal to ignore that error? Not sure if that would fix it, but seems like there's a chance
2023-01-17 16:58:14 +0100epolanski(uid312403@id-312403.helmsley.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-17 16:59:29 +0100 <boxscape_> oh, I fixed it
2023-01-17 16:59:51 +0100 <boxscape_> ChatGPT told me to run "sudo apt-get install pkg-config"
2023-01-17 17:00:52 +0100 <merijn> boxscape_: "just tell cabal to ignore the error" <- well, that's pretty counter productive :p
2023-01-17 17:01:25 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 17:01:35 +0100CiaoSen(~Jura@p200300c95723a5002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 255 seconds)
2023-01-17 17:01:51 +0100 <boxscape_> yeah, I just figured it was worth a shot :)
2023-01-17 17:02:03 +0100 <merijn> boxscape_: pkg-config dependencies list non-haskell library dependencies (to be resolved via pkg-config), so it's just cabal telling you a required dependency isn't found
2023-01-17 17:02:28 +0100 <boxscape_> well, the thing is that I do have vulkan installed
2023-01-17 17:02:41 +0100 <boxscape_> but apparently I needed to (re-?)install pkg-config
2023-01-17 17:03:00 +0100 <boxscape_> s/(re-?)//
2023-01-17 17:03:30 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net)
2023-01-17 17:05:15 +0100mimmy_(~mimmy@176.100.43.29) (Ping timeout: 268 seconds)
2023-01-17 17:05:48 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 260 seconds)
2023-01-17 17:07:26 +0100 <geekosaur[m]> Possibly the older version of the package didn't use pkg-config
2023-01-17 17:08:24 +0100 <boxscape_> hm seems plausible
2023-01-17 17:10:21 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 17:11:40 +0100jonathanx_(~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) (Ping timeout: 256 seconds)
2023-01-17 17:11:58 +0100thongpv(~thongpv87@2001:ee0:5577:f0d0:fe01:28c6:d263:9ebf)
2023-01-17 17:14:22 +0100jonathanx(~jonathan@h-178-174-176-109.A357.priv.bahnhof.se)
2023-01-17 17:15:08 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 260 seconds)
2023-01-17 17:15:33 +0100Feuermagier(~Feuermagi@user/feuermagier)
2023-01-17 17:15:56 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:53c1:5ba:8f53:5689) (Quit: WeeChat 2.8)
2023-01-17 17:18:04 +0100troydm(~troydm@user/troydm) (Ping timeout: 260 seconds)
2023-01-17 17:18:37 +0100acidjnk(~acidjnk@p200300d6e715c420889663d2e7d74ba2.dip0.t-ipconnect.de)
2023-01-17 17:26:47 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 255 seconds)
2023-01-17 17:30:44 +0100mbuf(~Shakthi@49.204.120.232) (Quit: Leaving)
2023-01-17 17:34:35 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 17:36:50 +0100mimmy_(~mimmy@176.100.43.31)
2023-01-17 17:36:59 +0100Cybro(~Cybro@user/Cybro) (Ping timeout: 256 seconds)
2023-01-17 17:37:20 +0100 <geekosaur[m]> pkg-config is nice when it works because it deals with dependencies and compilation and linking details, but has to be installed and the required packages have to know about it
2023-01-17 17:37:40 +0100Cybro(~Cybro@user/Cybro)
2023-01-17 17:39:03 +0100beefyran(~beefyran@2601:406:100:830:ad1c:493f:e8fc:867) ()
2023-01-17 17:39:11 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 264 seconds)
2023-01-17 17:41:58 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-01-17 17:43:23 +0100mimmy_(~mimmy@176.100.43.31) (Ping timeout: 264 seconds)
2023-01-17 17:44:01 +0100 <dminuoso> geekosaur[m]: pkg-config is one of 14 competing standards.
2023-01-17 17:44:26 +0100 <dminuoso> It's a bit sad there's no good all-encompassing solution to dealing with dependencies.
2023-01-17 17:44:45 +0100 <geekosaur[m]> Inevitably
2023-01-17 17:44:48 +0100 <dminuoso> From all the solutions, nix gets somewhat close, but only due to tedious effort by maintainers.
2023-01-17 17:45:10 +0100 <geekosaur[m]> Cue xkcd
2023-01-17 17:45:18 +0100 <dminuoso> :-)
2023-01-17 17:45:29 +0100 <dminuoso> geekosaur[m]: I was very careful with my phrasing of "14 competing standards"
2023-01-17 17:45:51 +0100Cybro(~Cybro@user/Cybro) (Quit: Leaving)
2023-01-17 17:45:56 +0100 <geekosaur[m]> I noticed
2023-01-17 17:46:47 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-01-17 17:47:11 +0100Joao003(~Joao003@2804:840:8311:d200:306d:6168:be07:23f0)
2023-01-17 17:47:18 +0100 <Joao003> hi again
2023-01-17 17:47:41 +0100epolanski(uid312403@id-312403.helmsley.irccloud.com)
2023-01-17 17:48:37 +0100 <boxscape_> I'm on Windows now and with the package I'm trying to build, cabal just hangs and does nothing. Is there a good way to debug this/has anyone experienced this?
2023-01-17 17:48:40 +0100mizlan(~mizlan@2607:f010:2a7:1005:a0d7:fa40:4d30:af9f)
2023-01-17 17:48:52 +0100 <dminuoso> boxscape_: what does it hang on?
2023-01-17 17:49:01 +0100Cybro(~Cybro@user/Cybro)
2023-01-17 17:49:04 +0100 <dminuoso> And does supplying -v3 add extra verbosity around the area you are stuck on?
2023-01-17 17:49:57 +0100 <boxscape_> dminuoso I think after downloading a dependency repo, last message is "Resolving deltas: 100% (3055/3055), done.". Worth noting also that cabal clean says permission denied and I have to do `rm -rf dist-newstyle`to clean. Will try -v3
2023-01-17 17:51:57 +0100 <boxscape_> hmm with -v3 the last message is ""C:\Program Files\Git\cmd\git.exe" "submodule" "deinit" "--force" "--all""
2023-01-17 17:52:41 +0100mizlan(~mizlan@2607:f010:2a7:1005:a0d7:fa40:4d30:af9f) (Ping timeout: 246 seconds)
2023-01-17 17:54:44 +0100 <Cybro> I'm trying to make a generator for lists of integers using arbitrary, how do I get arbitrary to generate lists?
2023-01-17 17:58:05 +0100gtdg(~gtdg@user/gtdg) (Quit: Client closed)
2023-01-17 17:59:58 +0100 <Cybro> Actually, how do I return a list. Using 'return' in Haskell since I'm using do notation
2023-01-17 18:00:34 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 18:02:34 +0100irrgit_(~irrgit@146.70.27.250)
2023-01-17 18:04:27 +0100raoul(~raoul@95.179.203.88) (Ping timeout: 268 seconds)
2023-01-17 18:04:52 +0100thebinary(~thebinary@36.252.26.191)
2023-01-17 18:04:56 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 256 seconds)
2023-01-17 18:05:24 +0100raoul(~raoul@95.179.203.88)
2023-01-17 18:06:04 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-01-17 18:06:18 +0100irrgit__(~irrgit@176.113.74.138) (Ping timeout: 268 seconds)
2023-01-17 18:09:09 +0100thebinary(~thebinary@36.252.26.191) (Ping timeout: 260 seconds)
2023-01-17 18:09:47 +0100chiselfuse(~chiselfus@user/chiselfuse) (Remote host closed the connection)
2023-01-17 18:11:52 +0100dtman34(~dtman34@2601:447:d000:93c9:8095:75ea:f23b:f5f5) (Quit: ZNC 1.8.2+deb2+b1 - https://znc.in)
2023-01-17 18:13:27 +0100mimmy_(~mimmy@176.100.43.36)
2023-01-17 18:15:20 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-01-17 18:16:14 +0100 <boxscape_> hm I think I'll just build cabal from source and see if I can figure out where it hangs
2023-01-17 18:16:20 +0100cheater__(~Username@user/cheater)
2023-01-17 18:18:28 +0100cheater(~Username@user/cheater) (Ping timeout: 252 seconds)
2023-01-17 18:18:32 +0100mimmy_(~mimmy@176.100.43.36) (Ping timeout: 256 seconds)
2023-01-17 18:18:35 +0100cheater__cheater
2023-01-17 18:18:53 +0100mei_(~mei@user/mei)
2023-01-17 18:18:53 +0100meiGuest4547
2023-01-17 18:18:53 +0100mei_mei
2023-01-17 18:19:51 +0100 <EvanR> Cybro, return has nothing to do with do notation. It's just a function. It does the same thing as pure
2023-01-17 18:19:53 +0100 <EvanR> :t pure
2023-01-17 18:19:54 +0100 <lambdabot> Applicative f => a -> f a
2023-01-17 18:19:59 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7) (Quit: Leaving)
2023-01-17 18:20:03 +0100 <EvanR> :t return
2023-01-17 18:20:05 +0100 <lambdabot> Monad m => a -> m a
2023-01-17 18:20:07 +0100Guest4547(~mei@user/mei) (Ping timeout: 252 seconds)
2023-01-17 18:20:37 +0100hgolden(~hgolden@cpe-172-251-233-141.socal.res.rr.com) (Remote host closed the connection)
2023-01-17 18:21:22 +0100avicenzi(~avicenzi@2a00:ca8:a1f:b004::c32) (Ping timeout: 256 seconds)
2023-01-17 18:21:55 +0100 <Cybro> EvanR, can arbitrary be used to generate a list of integers?
2023-01-17 18:22:02 +0100 <EvanR> yes
2023-01-17 18:22:10 +0100ubert1(~Thunderbi@2a02:8109:abc0:6434:8e77:5003:7dc0:6c4e) (Remote host closed the connection)
2023-01-17 18:23:56 +0100 <Cybro> So if I want "ns <- arbitrary" how would I get ns to be a list?
2023-01-17 18:23:57 +0100 <EvanR> look at this thing in Test.QuickCheck.Arbitrary
2023-01-17 18:24:03 +0100 <EvanR> vector :: Arbitrary a => Int -> Gen [a]
2023-01-17 18:24:44 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d14:f10:c58a:afef)
2023-01-17 18:24:47 +0100 <monochrom> Oh heh so you have to think up a length afterall.
2023-01-17 18:25:09 +0100 <EvanR> there's probably many ways to use Arbitrary
2023-01-17 18:25:17 +0100 <EvanR> to get a list
2023-01-17 18:26:03 +0100 <Cybro> What can the function "arbitrary" be used for specifically, not the "Arbitrary" class
2023-01-17 18:26:59 +0100 <ncf> :t listOf
2023-01-17 18:27:00 +0100 <anatta> arbitrary returns a generator
2023-01-17 18:27:01 +0100 <lambdabot> Gen a -> Gen [a]
2023-01-17 18:27:13 +0100hgolden(~hgolden@cpe-172-251-233-141.socal.res.rr.com)
2023-01-17 18:27:28 +0100 <ncf> there's even an Arbitrary a => Arbitrary [a] instance
2023-01-17 18:27:59 +0100 <Joao003> guys you can try it
2023-01-17 18:28:10 +0100 <Joao003> there are infinitely many tuple functions
2023-01-17 18:29:36 +0100cheater_(~Username@user/cheater)
2023-01-17 18:32:56 +0100cheater(~Username@user/cheater) (Ping timeout: 255 seconds)
2023-01-17 18:33:03 +0100cheater_cheater
2023-01-17 18:35:16 +0100razetime(~Thunderbi@117.193.0.183) (Remote host closed the connection)
2023-01-17 18:36:08 +0100Cybro(~Cybro@user/Cybro) (Quit: Leaving)
2023-01-17 18:36:32 +0100mizlan(~mizlan@169.150.203.53)
2023-01-17 18:37:20 +0100nschoe(~q@2a01:e0a:8e:a190:59bc:3e0d:1333:bdb1) (Quit: Switching off)
2023-01-17 18:37:50 +0100kuribas(~user@ptr-17d51enmqmkg8yow88s.18120a2.ip6.access.telenet.be) (Quit: ERC (IRC client for Emacs 27.1))
2023-01-17 18:39:03 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d14:f10:c58a:afef) (Remote host closed the connection)
2023-01-17 18:42:31 +0100dsrt^(~dsrt@76.145.190.81) (Remote host closed the connection)
2023-01-17 18:43:36 +0100 <EvanR> hmm... the number of tuple functions...
2023-01-17 18:47:04 +0100 <Joao003> :t (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
2023-01-17 18:47:06 +0100 <lambdabot> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> t26 -> t27 -> t28 -> t29 -> t30 -> (a, b, c, d, e, f, g, h, i, j, k,
2023-01-17 18:47:06 +0100 <lambdabot> l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30)
2023-01-17 18:47:51 +0100 <boxscape_> :t (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
2023-01-17 18:47:53 +0100 <lambdabot> error:
2023-01-17 18:47:53 +0100 <lambdabot> A 116-tuple is too large for GHC
2023-01-17 18:47:53 +0100 <lambdabot> (max size is 62)
2023-01-17 18:47:53 +0100 <boxscape_> not infinite
2023-01-17 18:48:23 +0100 <Joao003> but a computer with infinite memory could handle a infini-tuple
2023-01-17 18:48:31 +0100 <boxscape_> but not if it's running GHC
2023-01-17 18:48:50 +0100 <Joao003> edit ghc's code
2023-01-17 18:49:05 +0100 <geekosaur> that limit's there for a reason
2023-01-17 18:49:10 +0100 <c_wraith> if I was going to edit that part of ghc, I'd reduce the maximum tuple size to 2
2023-01-17 18:49:10 +0100 <Joao003> ik
2023-01-17 18:49:17 +0100 <Joao003> maybe 4
2023-01-17 18:49:26 +0100 <c_wraith> Beyond that, name your type
2023-01-17 18:49:28 +0100 <boxscape_> (importantly, a technical reason, not an aesthetic reason)
2023-01-17 18:49:36 +0100 <geekosaur> it used to dump core on 63-tuples and iirc nobody was able to track down why
2023-01-17 18:50:10 +0100 <boxscape_> I think Idris just handles (a,b,c) as (a, (b, c))? Which seems alright
2023-01-17 18:50:18 +0100 <Joao003> wondering if they would add uncurryn
2023-01-17 18:50:22 +0100 <Joao003> and curryn
2023-01-17 18:50:29 +0100 <c_wraith> boxscape_: Idris is strict, so it's fine there
2023-01-17 18:50:32 +0100 <boxscape_> ah
2023-01-17 18:50:45 +0100 <boxscape_> just make Haskell tuples strict :)
2023-01-17 18:51:07 +0100 <int-e> can Idris flatten the representation of such a tuple to avoid those extra indirections?
2023-01-17 18:51:12 +0100 <boxscape_> not sure
2023-01-17 18:51:36 +0100 <Joao003> it wouldn't be able to handle the type a ~ a -> (a, b)
2023-01-17 18:51:38 +0100 <anatta> I know there are weirdos who call it a tupple and not a two-ple, but it's clearly immoral to have tuples of sizes other than two
2023-01-17 18:51:44 +0100 <int-e> I rather suspect Haskell's designers made this choice for efficiency rather than out of concern for laziness.
2023-01-17 18:52:02 +0100 <Joao003> three-ple?
2023-01-17 18:52:08 +0100 <boxscape_> thruple
2023-01-17 18:52:32 +0100 <boxscape_> oh apparently that's already taken for relationships
2023-01-17 18:52:33 +0100 <Joao003> three-ple sounds like three pole
2023-01-17 18:53:05 +0100 <int-e> mmm triple
2023-01-17 18:53:14 +0100 <c_wraith> int-e: really? Given that the same solution addresses both, I'd expect that both were considered
2023-01-17 18:53:16 +0100 <Joao003> sixty-two-ple
2023-01-17 18:53:40 +0100 <glguy> temple
2023-01-17 18:53:41 +0100 <int-e> c_wraith: Obviously I wasn't there :P
2023-01-17 18:54:09 +0100 <c_wraith> int-e: that's not 100% obvious. Lots of people were! Maybe you were one of them!
2023-01-17 18:54:26 +0100 <int-e> Fine. I still wasn't there though.
2023-01-17 18:54:37 +0100 <Joao003> Is there a whole chapter on documentation about type signatures lol
2023-01-17 18:54:53 +0100 <glguy> int-e: we'll never know
2023-01-17 18:54:58 +0100 <int-e> I learned about Haskell in 2001 or so.
2023-01-17 18:55:17 +0100titibandit1(~titibandi@xdsl-81-173-160-143.nc.de)
2023-01-17 18:55:22 +0100 <c_wraith> I keep meaning to write a few blog posts about types in Haskell as documentation, and how they say a lot more than types in most languages.
2023-01-17 18:56:03 +0100 <geekosaur> given the number of packages that think the types are all the documentation they need, I''m not sure such blogging is necessary 🙂
2023-01-17 18:56:40 +0100enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) (Quit: enoq)
2023-01-17 18:57:01 +0100 <int-e> Also if Haskell didn't have those larger tuples built in, people would define them, and then we'd have dozens of incompatible versions of anonymous tuples.
2023-01-17 18:57:23 +0100 <Joao003> true
2023-01-17 18:58:35 +0100 <Joao003> imagine if there was also an infinite family of compose operators each composing more functions together
2023-01-17 18:59:07 +0100 <Joao003> wait
2023-01-17 18:59:54 +0100 <Joao003> 62-ples could be the max size because 62 is the sum of the number of decimal digits, and the number of lowercase and uppercase letters
2023-01-17 19:00:05 +0100 <Joao003> 10+26+26=62
2023-01-17 19:00:26 +0100 <anatta> @let comp = foldr (.) id
2023-01-17 19:00:28 +0100 <lambdabot> Defined.
2023-01-17 19:00:46 +0100 <anatta> now you can chain how many functions you want
2023-01-17 19:00:56 +0100 <Joao003> > comp [(+1), (+1), (+1)] 1
2023-01-17 19:00:58 +0100 <lambdabot> 4
2023-01-17 19:01:06 +0100 <c_wraith> geekosaur: I dunno. Given the fact that I can *use* a lot of libraries that other people complain have no documentation, it's quite likely the people complaining are missing some information.
2023-01-17 19:01:52 +0100 <Joao003> @let cons = foldr (:) []
2023-01-17 19:01:53 +0100 <lambdabot> Defined.
2023-01-17 19:02:03 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-17 19:02:04 +0100 <Joao003> now you can cons how many items you want
2023-01-17 19:02:18 +0100 <Joao003> > cons [1, 2, 3, []]
2023-01-17 19:02:19 +0100 <lambdabot> error:
2023-01-17 19:02:19 +0100 <lambdabot> Ambiguous occurrence ‘cons’
2023-01-17 19:02:19 +0100 <lambdabot> It could refer to
2023-01-17 19:02:25 +0100 <Joao003> > L.cons [1, 2, 3, []]
2023-01-17 19:02:27 +0100 <lambdabot> error:
2023-01-17 19:02:27 +0100 <lambdabot> • No instance for (Num [()]) arising from a use of ‘e_1123’
2023-01-17 19:02:27 +0100 <lambdabot> • In the expression: e_1123
2023-01-17 19:02:51 +0100 <glguy> > L.cons [1, 2, 3]
2023-01-17 19:02:52 +0100 <Joao003> > L.cons [1, 2, 3]
2023-01-17 19:02:53 +0100 <lambdabot> [1,2,3]
2023-01-17 19:02:54 +0100 <lambdabot> [1,2,3]
2023-01-17 19:03:06 +0100 <anatta> more useful to
2023-01-17 19:03:18 +0100 <anatta> @let cons' = foldr (:)
2023-01-17 19:03:19 +0100 <lambdabot> Defined.
2023-01-17 19:03:20 +0100 <Joao003> wait this is just identity
2023-01-17 19:03:36 +0100 <boxscape_> is there some amazing debugging functionality I can use to figure out where a program is hanging or do I have to printf my way to the answer?
2023-01-17 19:05:06 +0100 <Joao003> @let range x = takeWhile (<=x) [1..]
2023-01-17 19:05:08 +0100 <lambdabot> Defined.
2023-01-17 19:05:16 +0100 <Joao003> > range 10
2023-01-17 19:05:18 +0100 <lambdabot> error:
2023-01-17 19:05:18 +0100 <lambdabot> Ambiguous occurrence ‘range’
2023-01-17 19:05:18 +0100 <lambdabot> It could refer to
2023-01-17 19:05:22 +0100 <Joao003> > L.range 10
2023-01-17 19:05:24 +0100 <lambdabot> [1,2,3,4,5,6,7,8,9,10]
2023-01-17 19:05:50 +0100 <c_wraith> boxscape_: ghci has a debugger, but I've never used it...
2023-01-17 19:05:53 +0100 <anatta> boxscape_: Debug.Trace
2023-01-17 19:06:09 +0100 <glguy> Joao003: lambdabot works in a /query window
2023-01-17 19:06:09 +0100 <boxscape_> hmm I will take your suggestions into consideration
2023-01-17 19:06:15 +0100 <anatta> that's the one people don't want you to know about
2023-01-17 19:06:16 +0100 <Joao003> ik
2023-01-17 19:06:24 +0100 <boxscape_> debug.trace is certainly better than printf
2023-01-17 19:06:46 +0100thebinary(~thebinary@2400:1a00:b040:c48c:c948:e2cc:186e:ea47)
2023-01-17 19:07:12 +0100thebinary(~thebinary@2400:1a00:b040:c48c:c948:e2cc:186e:ea47) (Read error: Connection reset by peer)
2023-01-17 19:08:21 +0100marinelli(~marinelli@gateway/tor-sasl/marinelli)
2023-01-17 19:08:52 +0100marinelli(~marinelli@gateway/tor-sasl/marinelli) (Quit: marinelli)
2023-01-17 19:10:03 +0100 <Joao003> glguy: #haskell-offtopic exists
2023-01-17 19:10:05 +0100Sauvin(~sauvin@user/Sauvin) (Remote host closed the connection)
2023-01-17 19:10:39 +0100Sauvin(~sauvin@user/Sauvin)
2023-01-17 19:12:10 +0100wootehfoot(~wootehfoo@user/wootehfoot)
2023-01-17 19:12:37 +0100Kuttenbrunzer(~Kuttenbru@2a02:8108:8b80:1d48::c00)
2023-01-17 19:13:03 +0100wootehfoot(~wootehfoo@user/wootehfoot) (Max SendQ exceeded)
2023-01-17 19:13:30 +0100wootehfoot(~wootehfoo@user/wootehfoot)
2023-01-17 19:13:39 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-17 19:14:55 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2023-01-17 19:16:47 +0100 <boxscape_> oh maybe I can use profiling functionality to see where it hangs...
2023-01-17 19:17:18 +0100tng(~tng@4133220a.cst.lightpath.net)
2023-01-17 19:18:13 +0100 <tng> Hi, im new to haskell, is this syntatically correct?
2023-01-17 19:18:13 +0100 <tng> sumNums numLst =
2023-01-17 19:18:14 +0100 <tng>  numLst == []
2023-01-17 19:18:14 +0100 <tng>   | True = 0
2023-01-17 19:18:15 +0100 <tng>   | False = (head numLst) + sumNums (tail numLst)
2023-01-17 19:18:26 +0100 <tng> I get this error
2023-01-17 19:18:26 +0100 <tng> Command exited with code 1.
2023-01-17 19:18:27 +0100 <tng> GHC output
2023-01-17 19:18:27 +0100 <tng> input.hs:17:3: warning: [-Wtabs]
2023-01-17 19:18:28 +0100 <tng>     Tab character found here, and in five further locations.
2023-01-17 19:18:28 +0100 <tng>     Please use spaces instead.
2023-01-17 19:18:29 +0100 <tng>    |
2023-01-17 19:18:29 +0100 <tng> 17 |
2023-01-17 19:18:30 +0100 <tng>    | ^^^^^^
2023-01-17 19:18:30 +0100 <tng> input.hs:20:17: error: parse error on input ‘|’
2023-01-17 19:18:31 +0100 <tng>    |
2023-01-17 19:18:31 +0100 <tng> 20 | | True = 0
2023-01-17 19:18:32 +0100 <tng>    | ^
2023-01-17 19:18:39 +0100 <glguy> tng: please don't paste directly into chat
2023-01-17 19:18:46 +0100 <tng> oh sorry
2023-01-17 19:18:50 +0100 <boxscape_> tng: you can use e.g. https://paste.tomsmeding.com/
2023-01-17 19:18:55 +0100 <glguy> the syntax for what you're doing for if then else isn't quite right
2023-01-17 19:18:58 +0100titibandit1(~titibandi@xdsl-81-173-160-143.nc.de) (Quit: Leaving.)
2023-01-17 19:19:19 +0100kurbus(~kurbus@user/kurbus) (Quit: Client closed)
2023-01-17 19:19:22 +0100 <glguy> you'll need to either use a case numLst == [] of ... or if null numList then, but better would be pattern matching on numList
2023-01-17 19:19:34 +0100 <glguy> sumNums [] = ...; sumNums (x:xs) = ...
2023-01-17 19:19:56 +0100 <tng> https://paste.tomsmeding.com/NJKdfRaJ
2023-01-17 19:19:56 +0100 <Joao003> sumNums [] = 0
2023-01-17 19:20:28 +0100 <Joao003> sumNums (h : t) = h + sumNums t
2023-01-17 19:22:53 +0100 <tng> glguy sorry i dont follow. I just learned the pattern matching with pipe | char. And it's complaining not able to parse that. Could you please explain by | char?
2023-01-17 19:23:08 +0100 <tng> im not worrying about checking the empty list for now
2023-01-17 19:23:21 +0100cstm[m](~cstmmatri@2001:470:69fc:105::2:f76f)
2023-01-17 19:23:42 +0100mimmy_(~mimmy@176.100.43.30)
2023-01-17 19:23:48 +0100 <glguy> tng: You could use a "guard" with the | syntax, but then it goes on the thing you're defining, so that'd be: sumNums numList | null numList = ... | otherwise = ...
2023-01-17 19:24:04 +0100 <glguy> you don't provide a separate expression to case on, like you had with "numList == []"
2023-01-17 19:24:16 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 256 seconds)
2023-01-17 19:24:26 +0100 <glguy> each guard expression needs to be a boolean, the first one that evaluates to True gets picked
2023-01-17 19:25:06 +0100 <Joao003> tng: have you learned about folds?
2023-01-17 19:25:12 +0100 <tng> oh interesting, that's why. Thank you
2023-01-17 19:25:36 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-17 19:25:37 +0100 <tng> hi Joao003, yes I know fold, reduce
2023-01-17 19:25:40 +0100finsternis(~X@23.226.237.192) (Read error: Connection reset by peer)
2023-01-17 19:26:30 +0100 <tng> glguy I came from f# so that tripped me up a bit. glguy Joao003 thank you for your help
2023-01-17 19:27:10 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Ping timeout: 272 seconds)
2023-01-17 19:28:22 +0100 <Joao003> and i came from python.
2023-01-17 19:29:22 +0100 <Joao003> > sum [1, 2, 3]
2023-01-17 19:29:24 +0100 <lambdabot> 6
2023-01-17 19:29:32 +0100 <Joao003> list sum builtin
2023-01-17 19:30:49 +0100kurbus(~kurbus@user/kurbus)
2023-01-17 19:33:54 +0100 <Joao003> channel dead
2023-01-17 19:36:36 +0100cheater_(~Username@user/cheater)
2023-01-17 19:37:43 +0100notzmv(~zmv@user/notzmv)
2023-01-17 19:38:41 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-01-17 19:39:33 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d14:f10:c58a:afef)
2023-01-17 19:40:02 +0100cheater(~Username@user/cheater) (Ping timeout: 268 seconds)
2023-01-17 19:40:02 +0100cheater_cheater
2023-01-17 19:43:04 +0100econo(uid147250@user/econo)
2023-01-17 19:43:04 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Ping timeout: 260 seconds)
2023-01-17 19:44:16 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d14:f10:c58a:afef) (Ping timeout: 252 seconds)
2023-01-17 19:45:34 +0100jwiegley(~jwiegley@2600:1700:cf00:db0:3c2b:7b2b:9a29:78)
2023-01-17 19:46:44 +0100 <Jadesheit[m]> sometimes I like to make pointfree and ununderstandable just for fun
2023-01-17 19:46:46 +0100Kuttenbrunzer(~Kuttenbru@2a02:8108:8b80:1d48::c00) (Quit: Where is it)
2023-01-17 19:46:58 +0100 <Jadesheit[m]> `weight = nub >>= ((*) `on` length)`
2023-01-17 19:47:08 +0100 <Jadesheit[m]> s/`/``/, s/`/``/
2023-01-17 19:48:03 +0100mizlan(~mizlan@169.150.203.53) (Ping timeout: 268 seconds)
2023-01-17 19:48:39 +0100 <dminuoso> This reminds me slightly of Dijkstra: `The purpose of abstraction is not to be vague, but to create a new semantic level in which one can be absolutely precise`
2023-01-17 19:48:49 +0100 <dminuoso> And usual point-free notation does not attain that.
2023-01-17 19:48:54 +0100 <dminuoso> At least not in most examples.
2023-01-17 19:49:20 +0100 <dminuoso> This is in part why using things like Category *can* lead to incredibly compact and concise code, if it models the problem well enough
2023-01-17 19:49:37 +0100 <dminuoso> But eliding function arguments looks like just a shallow trick to make code more complicated in many examples
2023-01-17 19:50:59 +0100 <Joao003> the functions that @pl comes up with are just a mess of flips, composes and other builtins.
2023-01-17 19:53:07 +0100 <boxscape_> hm does +RTS -p only write to the .prof file once the program finishes?
2023-01-17 19:53:15 +0100 <boxscape_> because if I force-kill my program it has 0 bytes
2023-01-17 19:53:28 +0100 <geekosaur> I believe so, yes
2023-01-17 19:53:32 +0100 <boxscape_> hmmm
2023-01-17 19:53:32 +0100 <geekosaur> this has come up before
2023-01-17 19:53:50 +0100 <boxscape_> I suppose I can't use profiling to find out where cabal hangs, then, after all
2023-01-17 19:54:08 +0100 <geekosaur> eventlog?
2023-01-17 19:54:42 +0100 <boxscape_> I don't think I've heard of that
2023-01-17 19:54:48 +0100 <dminuoso> Joao003: Of course, its a completely mechanical substition algorithm.
2023-01-17 19:54:56 +0100 <dminuoso> It has no incentive or machinery to be smart about it
2023-01-17 19:55:02 +0100 <geekosaur> all the pieces may not be there though, but they're moving toward using eventlog for profiling in part to help with this
2023-01-17 19:55:16 +0100 <boxscape_> geekosaur I'll check it out, thanks
2023-01-17 19:55:27 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt)
2023-01-17 19:55:55 +0100 <geekosaur> https://downloads.haskell.org/ghc/9.4.1/docs/users_guide/runtime_control.html#event-log-output
2023-01-17 19:56:07 +0100 <boxscape_> thank you
2023-01-17 19:56:08 +0100 <geekosaur> which points to some other relevant stuff, notably +RTS -l
2023-01-17 19:56:10 +0100 <Jadesheit[m]> dminuoso: totally agree; I just like to do these as exercises, it helps me to learn functions and think more functionally
2023-01-17 19:56:46 +0100 <dminuoso> I have a hard time seeing how rewriting into point-free code realistically improves learning or haskell thinking
2023-01-17 19:56:49 +0100 <Joao003> Jadesheit[m]: ever used uncurry to make it pointfree
2023-01-17 19:56:54 +0100 <dminuoso> But who knows, people work differently.
2023-01-17 19:57:42 +0100 <geekosaur> all it does is help with the lambda calculus view
2023-01-17 19:57:49 +0100 <Joao003> > uncurry (+) (1, 2)
2023-01-17 19:57:51 +0100 <lambdabot> 3
2023-01-17 19:57:58 +0100 <dminuoso> Jadesheit[m]: Over the past few years Ive become to an important realization: Code is written only once, but read many times by humans. As such, writing code to me more understandable seems to be a more important goal to me.
2023-01-17 19:58:07 +0100 <geekosaur> well, and the compiler likes it better, but we generally make the compiler do the conversion instead of forcing programmers to do so
2023-01-17 19:58:13 +0100 <dminuoso> Which is also why I greatly dislike code formatters or even linters
2023-01-17 19:58:28 +0100 <Jadesheit[m]> yes I totally agree with all of these
2023-01-17 19:58:30 +0100 <geekosaur> Because of that
2023-01-17 19:59:10 +0100 <Jadesheit[m]> I guess it's just a personal thing; In the beginning I struggled with ($), but playing around with it helped me gain a very intuitive understanding of it
2023-01-17 19:59:38 +0100mizlan(~mizlan@89.46.114.142)
2023-01-17 19:59:40 +0100 <Jadesheit[m]> I guess here its the same, playing around with the language and seeing what I can do helps me gain an insight even when the specific thing isn't useful
2023-01-17 19:59:57 +0100 <Jadesheit[m]> I play around a lot more than write actual code with haskell
2023-01-17 20:00:26 +0100 <geekosaur> at some point you'll start gaining more by actually writing useful code with it
2023-01-17 20:00:55 +0100 <geekosaur> I'm gradually replacing most of my perl scripts with haskell, unless they're really heavy on the regexps
2023-01-17 20:02:30 +0100 <geekosaur> (https://paste.tomsmeding.com/360uMJkd being an example)
2023-01-17 20:02:43 +0100 <dminuoso> I wish Haskell had some out of box support for either reliable parsers/regex, and some easy-to-use http stuff
2023-01-17 20:02:49 +0100jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net)
2023-01-17 20:02:52 +0100 <dminuoso> Those would make a lot of scripts easy to port to Haskell
2023-01-17 20:03:51 +0100 <dminuoso> Especially HTTP is quite complicated, even the libraries calling themselves "simple" are still complicated, which is probably largely results of HTTP being really complicated. Haskell authors have a higher tendency to write a robust but hard to use API than easy to use but brittle APIs.
2023-01-17 20:03:56 +0100mizlan(~mizlan@89.46.114.142) (Ping timeout: 256 seconds)
2023-01-17 20:04:14 +0100ft(~ft@p4fc2a257.dip0.t-ipconnect.de)
2023-01-17 20:04:54 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d14:f10:c58a:afef)
2023-01-17 20:05:04 +0100 <dminuoso> Or even simple json support built into base.
2023-01-17 20:05:10 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 272 seconds)
2023-01-17 20:05:19 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt) (Ping timeout: 268 seconds)
2023-01-17 20:05:47 +0100 <dminuoso> Which if one is familiar with Haskell seems like a bizarre request, but if I just want to hack together a quick script to get some job done, these are things I likely want without creating a directory, initializing a cabal project, specifying dependencies, structuring modules..
2023-01-17 20:07:08 +0100 <boxscape_> dminuoso you can use something like `#!cabal --build-depends=...` at the top of the file
2023-01-17 20:07:10 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 268 seconds)
2023-01-17 20:07:11 +0100 <boxscape_> I think?
2023-01-17 20:07:38 +0100 <geekosaur> similar but not quite
2023-01-17 20:07:49 +0100 <boxscape_> yeah it's not quite right
2023-01-17 20:07:54 +0100 <geekosaur> ut yes, cabal supports scripts since one of the later 2.x versions iirc
2023-01-17 20:07:55 +0100 <boxscape_> I think I've actually only seen it done with slack
2023-01-17 20:08:03 +0100 <boxscape_> stack
2023-01-17 20:08:10 +0100 <int-index-r> I use nix to get a ghc package database with all the packages I need
2023-01-17 20:08:43 +0100 <dminuoso> nix is the anthesis of simple, though.
2023-01-17 20:08:50 +0100 <dminuoso> *antithesis
2023-01-17 20:10:06 +0100 <int-index-r> it does something that neither cabal or stack do: give me a ghc package database with all packages installed, so I get to use ghc/ghci as if everything I cared about was in the standard library
2023-01-17 20:10:15 +0100 <boxscape_> jesus
2023-01-17 20:10:16 +0100 <boxscape_> cabal is hanging while trying to install ghc-events, which I was going to use to figure out why cabal is hanging
2023-01-17 20:10:44 +0100mc47(~mc47@xmonad/TheMC47)
2023-01-17 20:11:54 +0100 <Joao003> lol
2023-01-17 20:12:00 +0100 <Joao003> replace your cabal
2023-01-17 20:13:21 +0100 <Joao003> paste your terminal here
2023-01-17 20:13:33 +0100 <Joao003> https://paste.tomsmeding.com
2023-01-17 20:14:07 +0100 <boxscape_> There is no output. It just hangs. With -v3 the last line is `"C:\Program Files\Git\cmd\git.exe" "fetch"`
2023-01-17 20:14:12 +0100 <Joao003> oh no
2023-01-17 20:14:23 +0100 <boxscape_> apparently it happens whenever trying to build a package that depends on a git repository
2023-01-17 20:14:28 +0100 <Joao003> try replacing your cabal
2023-01-17 20:14:31 +0100 <boxscape_> I have
2023-01-17 20:14:58 +0100 <Joao003> i guess it's trying to fetch nothing
2023-01-17 20:15:18 +0100 <Joao003> is your git at that folder
2023-01-17 20:15:21 +0100 <boxscape_> oh wait it's because I'm using cabal-install from the directory in which my hanging package is. Outside of that I actually can install ghc-events
2023-01-17 20:15:29 +0100 <Joao003> lol
2023-01-17 20:17:42 +0100 <Joao003> did it install now?
2023-01-17 20:17:57 +0100 <boxscape_> ghc-events did, yes
2023-01-17 20:18:11 +0100Guest61(~Guest61@84.218.13.11)
2023-01-17 20:18:30 +0100Guest61(~Guest61@84.218.13.11) (Client Quit)
2023-01-17 20:18:40 +0100 <Joao003> i want a challenge
2023-01-17 20:18:44 +0100 <Joao003> give me a builtin
2023-01-17 20:18:50 +0100 <Joao003> and i will guess the type
2023-01-17 20:19:06 +0100troydm(~troydm@user/troydm)
2023-01-17 20:19:11 +0100 <boxscape_> builtin meaning part of the base library?
2023-01-17 20:19:15 +0100 <Joao003> yeah
2023-01-17 20:19:21 +0100 <boxscape_> fix
2023-01-17 20:19:35 +0100Inst_(~Inst@2601:6c4:4081:54f0:ac9c:50:1323:7808)
2023-01-17 20:19:40 +0100gmg(~user@user/gehmehgeh)
2023-01-17 20:19:40 +0100 <Joao003> idk what fix does
2023-01-17 20:19:48 +0100 <Joao003> oh fixed point?
2023-01-17 20:19:51 +0100 <boxscape_> yes
2023-01-17 20:20:05 +0100 <boxscape_> it finds the least defined fixed point
2023-01-17 20:20:32 +0100 <Joao003> idk
2023-01-17 20:20:45 +0100 <boxscape_> % :t fix
2023-01-17 20:20:45 +0100 <yahb2> fix :: (a -> a) -> a
2023-01-17 20:20:52 +0100 <Joao003> oh
2023-01-17 20:21:00 +0100wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2023-01-17 20:21:00 +0100 <Joao003> another one
2023-01-17 20:21:03 +0100 <boxscape_> hm
2023-01-17 20:21:25 +0100 <Joao003> fix is the Y combinator?
2023-01-17 20:21:29 +0100 <anatta> Joao003: it iterates until it stops changing, basically
2023-01-17 20:21:31 +0100 <anatta> yes
2023-01-17 20:21:33 +0100 <Joao003> oh
2023-01-17 20:21:40 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 20:22:25 +0100 <boxscape_> you can try to guess the type of `for`, which is intended to emulate a for loop
2023-01-17 20:23:05 +0100 <Joao003> emulate what for loop? the c for loop or the python "for in"?
2023-01-17 20:23:11 +0100 <boxscape_> apparently I'm going for 3-letter words starting with f today
2023-01-17 20:23:14 +0100 <boxscape_> python
2023-01-17 20:23:40 +0100Inst(~Inst@2601:6c4:4081:54f0:ac48:655:9d0e:6fdc) (Ping timeout: 260 seconds)
2023-01-17 20:23:44 +0100 <dminuoso> boxscape_: I would say it doesnt just "emulate it", it generalizes it.
2023-01-17 20:23:52 +0100 <dminuoso> emulate sounds like a poor imitation.
2023-01-17 20:23:55 +0100 <anatta> there was this wordle clone where you had to guess a function based on the type or something
2023-01-17 20:23:55 +0100 <dminuoso> but `for` is so much more potent.
2023-01-17 20:23:59 +0100 <boxscape_> fair, I guess I'm saying that because it's not built in
2023-01-17 20:24:07 +0100 <anatta> maybe vice versa
2023-01-17 20:24:15 +0100 <Joao003> what wordle clone lol
2023-01-17 20:24:24 +0100 <anatta> I can't remember what it was called
2023-01-17 20:24:31 +0100 <Joao003> :(
2023-01-17 20:24:51 +0100 <dminuoso> boxscape_: Yeah, Haskell is quite unstructured. :)
2023-01-17 20:25:03 +0100 <dminuoso> its almost curious we have if-then-else at all
2023-01-17 20:25:23 +0100 <dminuoso> Next time I meet SPJ Ill ask him whether he can recall why that is.
2023-01-17 20:25:23 +0100 <Joao003> idk for's type
2023-01-17 20:25:30 +0100 <Joao003> % :t for
2023-01-17 20:25:30 +0100 <yahb2> <interactive>:1:1: error: ; • Variable not in scope: for ; • Perhaps you meant one of these: ; ‘or’ (imported from Prelude), ‘forM’ (imported from Control.Monad)
2023-01-17 20:25:31 +0100 <boxscape_> It's because Miranda had it, I would assume
2023-01-17 20:25:43 +0100 <boxscape_> (I don't know if Miranda had it, but I'm assuming that, too)
2023-01-17 20:25:44 +0100 <Joao003> :t for
2023-01-17 20:25:46 +0100 <lambdabot> (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
2023-01-17 20:25:50 +0100 <Joao003> wth
2023-01-17 20:26:10 +0100 <Joao003> now no 3 letter builtins starting with f
2023-01-17 20:26:14 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 260 seconds)
2023-01-17 20:26:24 +0100 <yushyin> anatta: https://type-signature.com/ this one?
2023-01-17 20:27:18 +0100 <anatta> yushyin: no, but it was similar enough that it might have been an earlier version
2023-01-17 20:27:48 +0100 <dminuoso> boxscape_: I checked the Miranda Systems Manual, I dont think if-then-else was in it
2023-01-17 20:27:50 +0100 <dminuoso> https://www.cs.kent.ac.uk/people/staff/dat/miranda/manual/7.html
2023-01-17 20:27:56 +0100 <boxscape_> oh, huh
2023-01-17 20:28:21 +0100 <dminuoso> A simple expression is one of the following: [identifier] [literal] [operator] [`show` or `readvals`] [a list] [a tuple] [any expression enclosed in parnethesis]
2023-01-17 20:29:26 +0100 <boxscape_> "An  expression  is  either  simple,  or  a  function  application, or an operator expression, or an operator"
2023-01-17 20:29:26 +0100jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) (Read error: Connection reset by peer)
2023-01-17 20:29:38 +0100 <boxscape_> s/^/And
2023-01-17 20:30:41 +0100 <dminuoso> Yup
2023-01-17 20:30:42 +0100jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net)
2023-01-17 20:30:49 +0100 <Joao003> Thanks https://type-signature.com for teaching me that lefts and rights exist
2023-01-17 20:30:57 +0100 <boxscape_> apparently Miranda use "if" for guards, and they are the other way around https://www.cs.kent.ac.uk/people/staff/dat/miranda/Overview.html
2023-01-17 20:31:23 +0100 <dminuoso> boxscape_: which seems much more aligned with mathematics honestly
2023-01-17 20:31:27 +0100 <boxscape_> true
2023-01-17 20:31:47 +0100 <dminuoso> I've seen this quite literally in some publications
2023-01-17 20:31:55 +0100 <geekosaur> yeh, haskell guards always make me think of (cond)
2023-01-17 20:32:13 +0100 <geekosaur> whereas I see the mathy way quite a lot
2023-01-17 20:32:23 +0100 <dminuoso> geekosaur: wdym by (cond)?
2023-01-17 20:32:30 +0100 <geekosaur> the lisp construct
2023-01-17 20:32:31 +0100 <monochrom> boxscape_: w00t Perl-style "stmt if cond" :)
2023-01-17 20:33:05 +0100 <geekosaur> (cond (boolexp stmts) (boolexp stmts) [(t stmts)])
2023-01-17 20:33:25 +0100 <monochrom> Or more likely inspired by math's by-case notation.
2023-01-17 20:33:47 +0100 <monochrom> err, actually s/by-case/piece-wise/
2023-01-17 20:33:48 +0100 <dminuoso> The suffix condition does seem a bit nicer to read for small compact code
2023-01-17 20:34:00 +0100 <dminuoso> a prefix condition lends itself much nicer for non-trivial cases
2023-01-17 20:34:09 +0100 <boxscape_> yeah
2023-01-17 20:34:17 +0100 <dminuoso> and I guess an additional benefit of the prefix condition is that it looks more similar to case-of as well
2023-01-17 20:34:42 +0100 <boxscape_> I do like having the patterns and conditions written close together, since they're kind of similar
2023-01-17 20:35:44 +0100 <monochrom> Evil invention: Revisionist Haskell in which all pattern matching must be pattern guards >:)
2023-01-17 20:35:55 +0100 <dminuoso> Mmm I tend to like indenting the defining clause with the condition for both functions and case-of even https://gist.github.com/dminuoso/bd4284e4e7e68cc7ca4f5b566d89b416
2023-01-17 20:35:55 +0100 <boxscape_> or all guards must be view patterns
2023-01-17 20:36:27 +0100 <dminuoso> (but this depends a bit on context and the length of the defining expression
2023-01-17 20:37:07 +0100 <dminuoso> on that note, is there a good name for `whattocallthis` in `case scruntinee of pattern -> whattocallthis`?
2023-01-17 20:37:14 +0100 <dminuoso> Is that a clause?
2023-01-17 20:37:35 +0100 <boxscape_> I think <pattern -> whattocallthis> is a clause? not sure
2023-01-17 20:37:42 +0100 <monochrom> I sometimes say "body" but I don't know whether it is standard.
2023-01-17 20:37:59 +0100 <monochrom> And some other times I say "branch".
2023-01-17 20:38:23 +0100 <Joao003> <pattern -> statement>?
2023-01-17 20:38:27 +0100 <monochrom> "branch" is standard in "if <cond> then <branch> else <branch>"
2023-01-17 20:38:32 +0100 <dminuoso> statement is definitely off, as its not a statement but an expression
2023-01-17 20:38:46 +0100 <Joao003> <pttrn -> stmt>
2023-01-17 20:38:52 +0100 <Joao003> <pttrn -> expr>
2023-01-17 20:39:02 +0100 <boxscape_> it is not a statement, since those are the lines in a do block
2023-01-17 20:39:17 +0100 <Joao003> i don't use do blocks
2023-01-17 20:39:22 +0100 <dminuoso> *do expression
2023-01-17 20:39:25 +0100 <dminuoso> :-P
2023-01-17 20:39:31 +0100 <Joao003> :D
2023-01-17 20:39:54 +0100 <dminuoso> monochrom: mmm body isnt too terrible, I dont like branch though as to me that includes the pattern
2023-01-17 20:40:05 +0100 <dminuoso> that is the entirety of `pat -> expr` would be the branch
2023-01-17 20:40:05 +0100 <boxscape_> I suppose <pattern -> whattocallthis> is called "alternative" in the standard, so from that point of view it would make sense to call whattocallthis a clause, but I don't know if anyone does
2023-01-17 20:40:09 +0100 <monochrom> Ah, right.
2023-01-17 20:40:43 +0100 <Joao003> guys use :þ instead of :P
2023-01-17 20:41:15 +0100 <geekosaur> I think I'm the only one who does that
2023-01-17 20:41:23 +0100Sauvin(~sauvin@user/Sauvin) (Remote host closed the connection)
2023-01-17 20:41:26 +0100 <darkling> I've been known to.
2023-01-17 20:41:31 +0100 <dminuoso> The haskell report seems to use `body` as well
2023-01-17 20:41:33 +0100 <geekosaur> sadly whether it looks right depends on the font on the receiving system
2023-01-17 20:41:40 +0100 <Joao003> pattern -> whattocallthis lol
2023-01-17 20:41:40 +0100 <dminuoso> 3.13 Case Expressions [...] `A case expression must have at least one alternative and each alternative must have at least one body.`
2023-01-17 20:41:50 +0100 <dminuoso> `Each body must have the same type, and the type of the whole expression is that type.`
2023-01-17 20:42:02 +0100 <boxscape_> ah
2023-01-17 20:42:11 +0100 <monochrom> :)
2023-01-17 20:42:13 +0100 <dminuoso> monochrom: So you win this round!
2023-01-17 20:42:17 +0100 <dminuoso> But you also lost.
2023-01-17 20:42:19 +0100 <dminuoso> What does that make you?
2023-01-17 20:42:30 +0100 <monochrom> "win some, lose some" :)
2023-01-17 20:42:33 +0100 <geekosaur> real life 😈
2023-01-17 20:42:50 +0100 <monochrom> "is it half empty or half full?" :)
2023-01-17 20:43:00 +0100 <Joao003> some = some, tie
2023-01-17 20:43:06 +0100Sauvin(~sauvin@user/Sauvin)
2023-01-17 20:43:11 +0100 <dminuoso> Oh gosh, what decides that evil color of that emoji geekosaur? Is that my font? Is it my terminal?
2023-01-17 20:43:21 +0100 <monochrom> (xckd be like "no no no, don't do that, half vacuum is a very bad idea...")
2023-01-17 20:43:57 +0100 <boxscape_> should be font I think
2023-01-17 20:44:03 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow)
2023-01-17 20:44:05 +0100 <monochrom> I think the exact unicode codepoint specifies colour too.
2023-01-17 20:44:11 +0100witcher_(~witcher@static.74.224.203.116.clients.your-server.de)
2023-01-17 20:44:23 +0100 <geekosaur> font, I believe
2023-01-17 20:44:25 +0100 <dminuoso> Mmm, my browser renders it with a different color
2023-01-17 20:44:37 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d14:f10:c58a:afef) (Remote host closed the connection)
2023-01-17 20:44:43 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-17 20:44:48 +0100 <Joao003> hexchat renders as monochrome
2023-01-17 20:45:15 +0100 <geekosaur> in my terminal it's black and white, in my hexchat it's magenta
2023-01-17 20:45:39 +0100 <monochrom> My hexchat shows magenta too.
2023-01-17 20:45:44 +0100 <geekosaur> font is Source Code Variable 10
2023-01-17 20:45:57 +0100 <geekosaur> I don't know what fallback font it uses
2023-01-17 20:46:15 +0100 <Joao003> i can make hexchat opaque
2023-01-17 20:46:20 +0100 <monochrom> No way Source Code Variable 10 covers emojis. Definitely fallback font.
2023-01-17 20:47:16 +0100 <geekosaur> probably specified by ubuntu in one of the global fontconfig files
2023-01-17 20:47:40 +0100witcher(dd5f7b3c87@2604:bf00:561:2000::296) (Remote host closed the connection)
2023-01-17 20:47:40 +0100witcher_witcher
2023-01-17 20:47:51 +0100 <Joao003> font is consolas 10
2023-01-17 20:48:33 +0100 <Joao003> make me guess a function by its type
2023-01-17 20:48:59 +0100 <monochrom> Many web browsers (including both Firefox and Chrome) also do its own fallback font thing out of distrust of random Linux distros. So web browsers can show different glyphs/fonts than other programs.
2023-01-17 20:49:31 +0100 <dminuoso> mmm, xfd is properly broken for me, refuses to open the font
2023-01-17 20:50:17 +0100 <Joao003> ^
2023-01-17 20:50:43 +0100 <dminuoso> ah now it does, but the next button doesnt work
2023-01-17 20:50:46 +0100dminuososuspects foul play
2023-01-17 20:50:58 +0100 <Joao003> wth is that suspects foul play thing
2023-01-17 20:50:58 +0100kee(~~kee@user/wizzwizz4) (Ping timeout: 260 seconds)
2023-01-17 20:51:57 +0100 <dminuoso> Even the quit button doesnt work
2023-01-17 20:51:59 +0100 <dminuoso> Mmm
2023-01-17 20:52:26 +0100 <Joao003> forcefully end the process
2023-01-17 20:52:38 +0100 <dminuoso> Thats not the issue, Im rather worried this tool doesnt work at all\
2023-01-17 20:52:38 +0100witcher(~witcher@static.74.224.203.116.clients.your-server.de) (Remote host closed the connection)
2023-01-17 20:52:43 +0100 <Joao003> :/
2023-01-17 20:52:47 +0100witcher(~witcher@static.74.224.203.116.clients.your-server.de)
2023-01-17 20:52:58 +0100 <Joao003> what tool
2023-01-17 20:54:01 +0100kee(~~kee@user/wizzwizz4)
2023-01-17 20:58:44 +0100 <Joao003> chat died
2023-01-17 20:59:00 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 272 seconds)
2023-01-17 20:59:08 +0100tng(~tng@4133220a.cst.lightpath.net) (Ping timeout: 260 seconds)
2023-01-17 20:59:17 +0100Joao003(~Joao003@2804:840:8311:d200:306d:6168:be07:23f0) (Quit: Leaving)
2023-01-17 20:59:21 +0100 <yushyin> ...
2023-01-17 20:59:53 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-17 21:00:43 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d14:f10:c58a:afef)
2023-01-17 21:02:35 +0100kurbus(~kurbus@user/kurbus) (Quit: Client closed)
2023-01-17 21:04:09 +0100remedan(~remedan@octo.cafe) (Ping timeout: 260 seconds)
2023-01-17 21:07:20 +0100thebinary(~thebinary@2400:1a00:b040:c48c:c948:e2cc:186e:ea47)
2023-01-17 21:07:24 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 256 seconds)
2023-01-17 21:08:37 +0100thebinary(~thebinary@2400:1a00:b040:c48c:c948:e2cc:186e:ea47) (Client Quit)
2023-01-17 21:09:18 +0100Sauvin(~sauvin@user/Sauvin) (Remote host closed the connection)
2023-01-17 21:10:03 +0100Sauvin(~sauvin@user/Sauvin)
2023-01-17 21:12:56 +0100opticblast(~Thunderbi@secure-165.caltech.edu) (Ping timeout: 272 seconds)
2023-01-17 21:15:05 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-17 21:21:04 +0100siers69(~ij@user/ij) (Ping timeout: 252 seconds)
2023-01-17 21:21:56 +0100 <boxscape_> When cabal says [110 of 132], but then doesn't build anything after that, is it because the interface file of module 110 didn't change?
2023-01-17 21:22:24 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340)
2023-01-17 21:25:40 +0100int-index-rint-index
2023-01-17 21:31:19 +0100Joao003(~Joao003@2804:840:8311:d200:306d:6168:be07:23f0)
2023-01-17 21:32:18 +0100 <Joao003> let's start some chat shall we
2023-01-17 21:32:57 +0100 <Joao003> guys?
2023-01-17 21:33:12 +0100Sauvin(~sauvin@user/Sauvin) (Ping timeout: 272 seconds)
2023-01-17 21:33:39 +0100 <Joao003> guys?
2023-01-17 21:33:53 +0100 <Joao003> no one is gonna chat>
2023-01-17 21:33:54 +0100 <Joao003> ?
2023-01-17 21:34:47 +0100 <yushyin> Joao003: if you have a haskell-specific question, just ask? for chitchat join #haskell-offtopic
2023-01-17 21:35:58 +0100 <geekosaur> this channel is relatively non-busy right now but we can also have 3-4 different discussions going on at the same time and chit-chat just gets in the way
2023-01-17 21:36:25 +0100titibandit1(~titibandi@xdsl-81-173-160-143.nc.de)
2023-01-17 21:36:25 +0100 <geekosaur> so #haskell-offtopic for that, and we sometimes redirect some stuff to #haskell-in-depth
2023-01-17 21:37:56 +0100 <geekosaur> boxscape_, depends on the package. it's not unusual a small change in xmonad-contrib leads to it rebuilding only 6 or 7 modules based on dependencies
2023-01-17 21:39:17 +0100 <boxscape_> hm I think that makes sense? I didn't consider initially that it has to flatten a dependency graph into a one-dimensional list
2023-01-17 21:39:23 +0100 <geekosaur> so it just means nothing else was affected by a dependency possibly including the modules it did rebuild
2023-01-17 21:39:32 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 272 seconds)
2023-01-17 21:39:35 +0100Sauvin(~sauvin@user/Sauvin)
2023-01-17 21:39:49 +0100 <boxscape_> right, okay
2023-01-17 21:40:22 +0100Sauvin(~sauvin@user/Sauvin) (Remote host closed the connection)
2023-01-17 21:40:46 +0100Sauvin(~sauvin@user/Sauvin)
2023-01-17 21:40:50 +0100 <Joao003> if i want to return an useless value, what's the best option?
2023-01-17 21:41:00 +0100 <boxscape_> ()
2023-01-17 21:42:02 +0100 <Joao003> what does "IO a" in a type signature mean?
2023-01-17 21:42:42 +0100fizbin_(~fizbin@user/fizbin)
2023-01-17 21:42:53 +0100 <xerox> Joao003: it means a value that is an IO action that when sequenced produces a result of type 'a'
2023-01-17 21:43:03 +0100nehsou^(~nehsou@76.145.190.81)
2023-01-17 21:43:52 +0100 <Joao003> what do you mean by that?
2023-01-17 21:44:23 +0100 <[exa]> Joao003: "a program that causes side effects and produces some `a`"
2023-01-17 21:45:29 +0100son0p(~ff@181.136.122.143) (Remote host closed the connection)
2023-01-17 21:45:35 +0100 <Joao003> example?
2023-01-17 21:46:40 +0100 <[exa]> you can't have an actual good example because `a` is a type variable (except for ugly nonsense like `return undefined`)
2023-01-17 21:46:53 +0100 <[exa]> but for example `print 5` is of type `IO ()`
2023-01-17 21:47:09 +0100 <xerox> :t (>>=)
2023-01-17 21:47:10 +0100 <lambdabot> Monad m => m a -> (a -> m b) -> m b
2023-01-17 21:47:11 +0100 <anatta> myIOprogram = getLine >>= \ ans -> print ans >> pure ans
2023-01-17 21:47:11 +0100fizbin_(~fizbin@user/fizbin) (Ping timeout: 260 seconds)
2023-01-17 21:47:22 +0100 <xerox> substitute IO for m in there
2023-01-17 21:47:48 +0100 <Joao003> "IO ()" means that it is a program that makes I/O operations and produces "()"
2023-01-17 21:47:50 +0100 <Joao003> right?
2023-01-17 21:48:12 +0100 <int-index> [exa]: it could also be an infinite loop or something that throws an exception
2023-01-17 21:48:24 +0100 <[exa]> +1 true ^
2023-01-17 21:48:35 +0100 <Joao003> "a program which produces nothing"
2023-01-17 21:48:40 +0100 <[exa]> Joao003: the "a program that makes IO operations" is handwavy but it's basically it
2023-01-17 21:49:07 +0100 <anatta> IO a means a set of instructions that when evaluated at runtime *might* return a :p
2023-01-17 21:49:21 +0100 <Joao003> :t fileWrite
2023-01-17 21:49:23 +0100 <lambdabot> error: Variable not in scope: fileWrite
2023-01-17 21:49:25 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-01-17 21:49:36 +0100 <int-index> :t writeFile
2023-01-17 21:49:38 +0100 <lambdabot> FilePath -> String -> IO ()
2023-01-17 21:50:03 +0100 <int-index> :t readLn
2023-01-17 21:50:05 +0100 <lambdabot> Read a => IO a
2023-01-17 21:50:08 +0100 <Joao003> given a file path and a string, it makes side effects and produces nothing
2023-01-17 21:50:18 +0100 <anatta> I think we used to indicate it as turnstile_t or something
2023-01-17 21:50:20 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-01-17 21:50:23 +0100 <anatta> "may return t"
2023-01-17 21:51:10 +0100 <anatta> to be fair, I'm not sure it's the same notation for haskell
2023-01-17 21:51:19 +0100 <Joao003> simple: "IO a" causes side effects and may return a
2023-01-17 21:51:27 +0100califax(~califax@user/califx)
2023-01-17 21:51:31 +0100 <anatta> it may cause side effects
2023-01-17 21:51:33 +0100 <anatta> and may return a
2023-01-17 21:51:47 +0100 <monochrom> Now that I think of it, you have already seen the IO types and what they mean and why they show up, from previous discussions these past few days.
2023-01-17 21:51:53 +0100 <anatta> you don't get a lot of guarantees
2023-01-17 21:51:57 +0100 <Joao003> like readln
2023-01-17 21:52:00 +0100 <anatta> and that's kind of the point
2023-01-17 21:52:02 +0100 <Joao003> takes a read of type a
2023-01-17 21:52:05 +0100remedan(~remedan@144.76.104.133)
2023-01-17 21:52:13 +0100 <Joao003> and makes side effects which may return a
2023-01-17 21:52:26 +0100pagnol(~user@213-205-209-87.ftth.glasoperator.nl)
2023-01-17 21:52:35 +0100 <anatta> IO means that your code is allowed to interface with the impure and nasty real world
2023-01-17 21:52:46 +0100 <anatta> so you can't really say for sure what's going to happen
2023-01-17 21:52:56 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-17 21:52:58 +0100 <Joao003> "causes side effects"
2023-01-17 21:54:16 +0100 <Joao003> :t readFile
2023-01-17 21:54:17 +0100 <lambdabot> FilePath -> IO String
2023-01-17 21:54:43 +0100talismanick(~talismani@campus-102-199.ucdavis.edu)
2023-01-17 21:54:52 +0100 <Joao003> takes a FilePath, causes side effects and may return a value of type String
2023-01-17 21:55:19 +0100 <anatta> maybe
2023-01-17 21:55:21 +0100 <monochrom> For the sake of one last time, my http://www.vex.net/~trebla/haskell/IO.xhtml teaches IO.
2023-01-17 21:55:28 +0100 <anatta> like
2023-01-17 21:56:10 +0100 <anatta> not sure how the bot works, but lets try this
2023-01-17 21:56:15 +0100 <anatta> @let f :: IO Integer; f = pure 5
2023-01-17 21:56:17 +0100 <lambdabot> Defined.
2023-01-17 21:56:26 +0100 <anatta> not a lot of side effects going on
2023-01-17 21:56:31 +0100 <Joao003> > f
2023-01-17 21:56:33 +0100 <lambdabot> error:
2023-01-17 21:56:33 +0100 <lambdabot> Ambiguous occurrence ‘f’
2023-01-17 21:56:33 +0100 <lambdabot> It could refer to
2023-01-17 21:56:53 +0100 <monochrom> lambdabot won't execute IO actions. But yahb2 can. Try: % putStrLn "hello"
2023-01-17 21:56:54 +0100 <Joao003> let's undefine for the sake of it
2023-01-17 21:57:19 +0100 <Joao003> % putStrLn "hello"
2023-01-17 21:57:19 +0100 <yahb2> hello
2023-01-17 21:57:55 +0100 <anatta> monochrom: yeah, but that's a side effect =) I just wanted to show that even though IO actions may produce side effects, it's not guaranteed that they will
2023-01-17 21:58:10 +0100 <monochrom> You can show that with yahb2 too :)
2023-01-17 21:58:22 +0100 <Joao003> % pure 5
2023-01-17 21:58:22 +0100 <yahb2> 5
2023-01-17 21:58:23 +0100 <anatta> so you can do
2023-01-17 21:58:24 +0100 <monochrom> And perhaps it's even more convincing that way.
2023-01-17 21:58:46 +0100 <anatta> % f :: IO Integer; f = pure 5
2023-01-17 21:58:46 +0100 <yahb2> <no output>
2023-01-17 21:58:53 +0100 <anatta> % f
2023-01-17 21:58:53 +0100 <yahb2> 5
2023-01-17 21:58:57 +0100 <anatta> nice
2023-01-17 21:59:45 +0100 <Joao003> % g :: IO String; g = pure "test"
2023-01-17 21:59:45 +0100 <yahb2> <no output>
2023-01-17 21:59:50 +0100 <Joao003> % g
2023-01-17 21:59:50 +0100 <yahb2> "test"
2023-01-17 22:01:21 +0100titibandit1(~titibandi@xdsl-81-173-160-143.nc.de) (Remote host closed the connection)
2023-01-17 22:02:40 +0100 <anatta> I tend to think of IO as an identifier that my code interfaces with impure aspects of the system
2023-01-17 22:03:24 +0100 <anatta> personally I find it not really helpful to think of it as "a set of instructions that when evaluated..." or some other definition of what it actually is
2023-01-17 22:03:51 +0100 <anatta> for me the most helpful way of looking at it is just as a warning
2023-01-17 22:04:19 +0100 <anatta> but ymmv
2023-01-17 22:05:29 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d14:f10:c58a:afef) (Remote host closed the connection)
2023-01-17 22:06:26 +0100mimmy_(~mimmy@176.100.43.30) (Quit: WeeChat 3.8)
2023-01-17 22:13:19 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Ping timeout: 252 seconds)
2023-01-17 22:19:08 +0100finsternis(~X@23.226.237.192)
2023-01-17 22:20:31 +0100waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se)
2023-01-17 22:21:04 +0100int-index(~Vladislav@2a00:1370:8178:5994:87d0:2048:7511:2eba) (Quit: Konversation terminated!)
2023-01-17 22:22:53 +0100 <EvanR> anatta, a version of IO that literally does that would act the same way
2023-01-17 22:23:24 +0100 <EvanR> and helps solidify the idea that IO actions don't really do anything on their own, so you are free to pass them around and store them in containers
2023-01-17 22:24:15 +0100 <anatta> true, that's a good point
2023-01-17 22:24:16 +0100 <Joao003> IO is probably a Monad
2023-01-17 22:24:21 +0100 <anatta> IO is a monad
2023-01-17 22:24:40 +0100 <Joao003> It wraps a value
2023-01-17 22:24:47 +0100 <EvanR> noooo
2023-01-17 22:24:52 +0100 <EvanR> not the burrito story
2023-01-17 22:25:01 +0100 <Joao003> Every monad wraps a value
2023-01-17 22:25:06 +0100 <EvanR> are you sure
2023-01-17 22:25:19 +0100 <Rembane> They could be many or zero
2023-01-17 22:25:27 +0100 <Joao003> true
2023-01-17 22:25:32 +0100 <Joao003> guys
2023-01-17 22:25:37 +0100 <Joao003> how often do you use ($)
2023-01-17 22:26:21 +0100 <cstm[m]> > Every monad wraps a value
2023-01-17 22:26:21 +0100 <cstm[m]> Not true - some wrap a function.
2023-01-17 22:26:23 +0100 <lambdabot> error:
2023-01-17 22:26:24 +0100 <lambdabot> Data constructor not in scope: Every :: t0 -> t1 -> Expr -> t2 -> terror...
2023-01-17 22:26:30 +0100 <Joao003> lol
2023-01-17 22:26:42 +0100 <cstm[m]> * > Every monad wraps a value
2023-01-17 22:26:42 +0100 <cstm[m]> Not true - some wrap a function.
2023-01-17 22:26:51 +0100 <anatta> I use $ a lot
2023-01-17 22:26:55 +0100 <Joao003> look at this
2023-01-17 22:27:05 +0100codaraxis(~codaraxis@user/codaraxis)
2023-01-17 22:27:08 +0100 <Rembane> Joao003: Once every line, before it I use .
2023-01-17 22:27:15 +0100 <anatta> mostly in e.g: f . g . h $ val
2023-01-17 22:27:26 +0100 <Joao003> % zipWith ($) (map (+) [1..3]) [1..3]
2023-01-17 22:27:26 +0100 <yahb2> [2,4,6]
2023-01-17 22:27:35 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-01-17 22:28:07 +0100 <Joao003> % map ($ 1) (map (+) [1..3])
2023-01-17 22:28:07 +0100 <yahb2> [2,3,4]
2023-01-17 22:28:26 +0100mei(~mei@user/mei) (Killed (cadmium.libera.chat (Nickname regained by services)))
2023-01-17 22:28:29 +0100 <__monty__> % zipWith (+) [1..3] [1..3]
2023-01-17 22:28:29 +0100 <yahb2> [2,4,6]
2023-01-17 22:28:31 +0100mei(~mei@user/mei)
2023-01-17 22:29:05 +0100 <EvanR> every monad has to have an operation that accepts an a
2023-01-17 22:29:10 +0100gmg(~user@user/gehmehgeh) (Remote host closed the connection)
2023-01-17 22:29:17 +0100 <EvanR> what it does with that a is another story
2023-01-17 22:29:18 +0100 <cstm[m]> > <@cstm:matrix.org> > Every monad wraps a value
2023-01-17 22:29:20 +0100 <lambdabot> <hint>:1:1: error: parse error on input ‘<@’
2023-01-17 22:29:21 +0100 <cstm[m]> >
2023-01-17 22:29:21 +0100 <cstm[m]> > Not true - some wrap a function.
2023-01-17 22:29:21 +0100 <cstm[m]> And some wrap a Monad - for example Monad Transformers.
2023-01-17 22:29:23 +0100 <lambdabot> <hint>:1:33: error:
2023-01-17 22:29:23 +0100 <lambdabot> parse error (possibly incorrect indentation or mismatched brackets)
2023-01-17 22:29:23 +0100 <lambdabot> <no location info>: error: not an expression: ‘’
2023-01-17 22:29:26 +0100 <Joao003> % zipWith ($) [(== 0), even, odd] [1, 2, 3]
2023-01-17 22:29:26 +0100 <yahb2> [False,True,True]
2023-01-17 22:29:33 +0100gmg(~user@user/gehmehgeh)
2023-01-17 22:29:40 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2023-01-17 22:29:41 +0100 <EvanR> a monad transformer isn't a monad in the same sense as Monad
2023-01-17 22:30:12 +0100 <cstm[m]> A monad transformer is a monad because the monad laws apply - it's not a debate really.
2023-01-17 22:30:24 +0100 <EvanR> it can't be a Monad, wrong kind
2023-01-17 22:30:38 +0100 <Joao003> how often do you use (<*>)
2023-01-17 22:30:39 +0100 <EvanR> :k Maybe
2023-01-17 22:30:40 +0100 <lambdabot> * -> *
2023-01-17 22:30:43 +0100 <EvanR> :k StateT
2023-01-17 22:30:45 +0100 <lambdabot> * -> (* -> *) -> * -> *
2023-01-17 22:31:01 +0100 <EvanR> :k StateT Int
2023-01-17 22:31:02 +0100 <Joao003> @help k
2023-01-17 22:31:02 +0100 <lambdabot> help <command>. Ask for help for <command>. Try 'list' for all commands
2023-01-17 22:31:03 +0100 <lambdabot> (* -> *) -> * -> *
2023-01-17 22:31:03 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-17 22:31:06 +0100 <Joao003> @help :k
2023-01-17 22:31:06 +0100 <lambdabot> help <command>. Ask for help for <command>. Try 'list' for all commands
2023-01-17 22:31:24 +0100 <Joao003> :k Either Int
2023-01-17 22:31:25 +0100 <lambdabot> * -> *
2023-01-17 22:31:29 +0100 <EvanR> it gives the kind of some type
2023-01-17 22:31:29 +0100 <Joao003> :k Either
2023-01-17 22:31:31 +0100 <lambdabot> * -> * -> *
2023-01-17 22:31:33 +0100 <Joao003> oh
2023-01-17 22:31:49 +0100 <Joao003> :t Left
2023-01-17 22:31:50 +0100 <lambdabot> a -> Either a b
2023-01-17 22:31:54 +0100 <EvanR> :k Char
2023-01-17 22:31:55 +0100 <lambdabot> *
2023-01-17 22:32:01 +0100 <Joao003> :t Either
2023-01-17 22:32:02 +0100 <lambdabot> error:
2023-01-17 22:32:02 +0100 <lambdabot> • Data constructor not in scope: Either
2023-01-17 22:32:02 +0100 <lambdabot> • Perhaps you meant variable ‘either’ (imported from Data.Either)
2023-01-17 22:32:15 +0100 <Joao003> :k Either a
2023-01-17 22:32:16 +0100 <lambdabot> error: Not in scope: type variable ‘a’
2023-01-17 22:32:23 +0100 <EvanR> :t is for value expressions
2023-01-17 22:32:37 +0100 <EvanR> :k Either Char
2023-01-17 22:32:38 +0100gawen(~gawen@user/gawen) (Quit: cya)
2023-01-17 22:32:38 +0100 <lambdabot> * -> *
2023-01-17 22:32:54 +0100 <Joao003> how often do you use (<*>)
2023-01-17 22:33:03 +0100 <anatta> fairly often
2023-01-17 22:33:17 +0100 <Rembane> Always
2023-01-17 22:33:31 +0100 <Joao003> give me an example
2023-01-17 22:33:32 +0100 <anatta> in many cases you want to do something like f <$> m a <*> m b
2023-01-17 22:33:36 +0100 <Joao003> :t (<*>)
2023-01-17 22:33:37 +0100 <lambdabot> Applicative f => f (a -> b) -> f a -> f b
2023-01-17 22:33:56 +0100 <cstm[m]> :k (Monad m) => forall a . StateT () m
2023-01-17 22:33:56 +0100 <Joao003> :t (<$>)
2023-01-17 22:33:57 +0100 <lambdabot> error: Not in scope: type variable ‘m’
2023-01-17 22:33:57 +0100 <lambdabot> Functor f => (a -> b) -> f a -> f b
2023-01-17 22:33:58 +0100gawen(~gawen@user/gawen)
2023-01-17 22:34:03 +0100 <EvanR> f <$> m a <*> m b is heavily crossing the streams
2023-01-17 22:34:14 +0100 <Joao003> <$> is <*> for functors
2023-01-17 22:34:20 +0100 <Joao003> @src fmap
2023-01-17 22:34:20 +0100 <lambdabot> Source not found. I feel much better now.
2023-01-17 22:34:27 +0100 <cstm[m]> * :k forall m a . (Monad m) => StateT () m
2023-01-17 22:34:38 +0100Joao003(~Joao003@2804:840:8311:d200:306d:6168:be07:23f0) (Quit: Leaving)
2023-01-17 22:34:38 +0100 <anatta> > (+) <$> Just 3 <*> Just 5
2023-01-17 22:34:40 +0100 <lambdabot> Just 8
2023-01-17 22:35:24 +0100 <anatta> first you move the function inside with <$>
2023-01-17 22:35:34 +0100 <geekosaur> they left
2023-01-17 22:35:40 +0100 <anatta> lol
2023-01-17 22:35:46 +0100 <EvanR> Employee <$> readID <*> readName <*> readProductivity
2023-01-17 22:36:07 +0100 <EvanR> it's the thought that counts
2023-01-17 22:37:41 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-01-17 22:38:04 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 256 seconds)
2023-01-17 22:40:26 +0100Lord_of_Life_Lord_of_Life
2023-01-17 22:41:58 +0100barzo(~hd@31.223.41.44)
2023-01-17 22:47:08 +0100talismanick(~talismani@campus-102-199.ucdavis.edu) (Ping timeout: 256 seconds)
2023-01-17 22:48:26 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2023-01-17 22:52:43 +0100mechap(~mechap@user/mechap) (Quit: WeeChat 3.8)
2023-01-17 23:06:15 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1812:9885:2ce4:4618)
2023-01-17 23:07:41 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-01-17 23:08:14 +0100epolanski(uid312403@id-312403.helmsley.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-17 23:08:29 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-17 23:09:48 +0100zmt01(~zmt00@user/zmt00) (Read error: Connection reset by peer)
2023-01-17 23:10:58 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1812:9885:2ce4:4618) (Ping timeout: 260 seconds)
2023-01-17 23:13:09 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-01-17 23:13:57 +0100laalyn(~laalyn@c-73-241-126-7.hsd1.ca.comcast.net) (Quit: Client closed)
2023-01-17 23:15:37 +0100ratapaca(~ratapaca@98.40.240.33)
2023-01-17 23:18:14 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow) (Quit: WeeChat 3.7.1)
2023-01-17 23:22:35 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow)
2023-01-17 23:23:00 +0100gmg(~user@user/gehmehgeh) (Quit: Leaving)
2023-01-17 23:24:15 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg)
2023-01-17 23:26:03 +0100fizbin_(~fizbin@user/fizbin)
2023-01-17 23:28:49 +0100freeside(~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 268 seconds)
2023-01-17 23:31:09 +0100ratapaca(~ratapaca@98.40.240.33) (Quit: Leaving)
2023-01-17 23:31:23 +0100califax(~califax@user/califx) (Ping timeout: 255 seconds)
2023-01-17 23:32:28 +0100acidjnk(~acidjnk@p200300d6e715c420889663d2e7d74ba2.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-01-17 23:33:30 +0100zzzzwro
2023-01-17 23:33:41 +0100califax(~califax@user/califx)
2023-01-17 23:35:31 +0100Guest|7(~Guest|7@ip2-197.halifax.rwth-aachen.de)
2023-01-17 23:36:20 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:c1c3:e297:674c:356d) (Remote host closed the connection)
2023-01-17 23:36:24 +0100cheater(~Username@user/cheater) (Ping timeout: 260 seconds)
2023-01-17 23:36:29 +0100ub(~Thunderbi@p200300ecdf264e0169c651b6116f6648.dip0.t-ipconnect.de)
2023-01-17 23:36:39 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:c1c3:e297:674c:356d)
2023-01-17 23:36:46 +0100Midjak(~Midjak@82.66.147.146) (Quit: This computer has gone to sleep)
2023-01-17 23:37:00 +0100ubert(~Thunderbi@p200300ecdf264e9fe5173bdb45e8ff9d.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-01-17 23:37:00 +0100ububert
2023-01-17 23:37:34 +0100fizbin_(~fizbin@user/fizbin) (Ping timeout: 260 seconds)
2023-01-17 23:37:40 +0100cheater(~Username@user/cheater)
2023-01-17 23:43:44 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-01-17 23:50:46 +0100mechap(~mechap@user/mechap)
2023-01-17 23:56:26 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-01-17 23:58:58 +0100zer0bitz_(~zer0bitz@dsl-hkibng32-54f843-214.dhcp.inet.fi) (Read error: Connection reset by peer)