IRCBrowse

2023/01/05

2023-01-05 00:03:43 +0100sayola(~sayola@dslb-002-201-085-035.002.201.pools.vodafone-ip.de) (Ping timeout: 260 seconds)
2023-01-05 00:05:46 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 272 seconds)
2023-01-05 00:05:49 +0100djanatyn(~djanatyn@vps-7f49a6b0.vps.ovh.ca) (Ping timeout: 260 seconds)
2023-01-05 00:10:38 +0100Guest84(~Guest84@apn-31-2-59-127.dynamic.gprs.plus.pl)
2023-01-05 00:11:38 +0100Guest84(~Guest84@apn-31-2-59-127.dynamic.gprs.plus.pl) (Quit: Client closed)
2023-01-05 00:13:58 +0100biberu(~biberu@user/biberu) (Read error: Connection reset by peer)
2023-01-05 00:13:59 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-05 00:16:05 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 00:20:57 +0100biberu(~biberu@user/biberu)
2023-01-05 00:25:04 +0100nasrudin__(~nasrudin_@174.78.11.32) (Ping timeout: 260 seconds)
2023-01-05 00:25:22 +0100nasrudin__(~nasrudin_@81.171.62.7)
2023-01-05 00:26:40 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 272 seconds)
2023-01-05 00:27:24 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 00:29:16 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi)
2023-01-05 00:37:32 +0100cheater(~Username@user/cheater) (Ping timeout: 246 seconds)
2023-01-05 00:38:08 +0100Maeda(~Maeda@91-161-10-149.subs.proxad.net) (Ping timeout: 260 seconds)
2023-01-05 00:39:50 +0100Maeda(~Maeda@91-161-10-149.subs.proxad.net)
2023-01-05 00:44:07 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-01-05 00:46:03 +0100 <jean-paul[m]> The test suite is for bindings to a C library and I discovered that the C library segfaults on some inputs, so this is how a segfault in the test process is presented. :/
2023-01-05 00:48:07 +0100 <monochrom> Alternatively, QuickCheck had pure Haskell in mind, didn't know you would stress-test C code.
2023-01-05 00:48:57 +0100cheater(~Username@user/cheater)
2023-01-05 00:51:40 +0100epolanski(uid312403@id-312403.helmsley.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-05 00:52:53 +0100 <maerwald[m]> jean-paul.: use try
2023-01-05 00:53:03 +0100romesrf(~romes@192.22.63.94.rev.vodafone.pt)
2023-01-05 00:56:04 +0100titibandit(7efad7d72e@jabberfr.org) (Disconnected: Hibernating too long)
2023-01-05 00:56:50 +0100 <jean-paul[m]> maerwald: To catch a SIGSEGV? :)
2023-01-05 00:57:01 +0100 <jean-paul[m]> Cool beans
2023-01-05 00:57:25 +0100nasrudin__(~nasrudin_@81.171.62.7) (Ping timeout: 252 seconds)
2023-01-05 00:58:31 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Remote host closed the connection)
2023-01-05 01:00:03 +0100chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2023-01-05 01:01:25 +0100chexum(~quassel@gateway/tor-sasl/chexum)
2023-01-05 01:05:31 +0100koolazer(~koo@user/koolazer)
2023-01-05 01:11:09 +0100nasrudin__(~nasrudin_@174.78.11.128)
2023-01-05 01:12:33 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-01-05 01:12:33 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-01-05 01:12:33 +0100wroathe(~wroathe@user/wroathe)
2023-01-05 01:13:16 +0100gmg(~user@user/gehmehgeh) (Remote host closed the connection)
2023-01-05 01:14:24 +0100gmg(~user@user/gehmehgeh)
2023-01-05 01:15:25 +0100Blightmain(~Blightmai@203.29.154.219)
2023-01-05 01:15:27 +0100Blightmain_(~Blightmai@203.29.154.219)
2023-01-05 01:15:35 +0100Blightmain_(~Blightmai@203.29.154.219) ()
2023-01-05 01:17:26 +0100xff0x(~xff0x@p3326132-ipngn2103sapodori.hokkaido.ocn.ne.jp)
2023-01-05 01:25:38 +0100 <jackdk> what if you ran all the FFI stuff in a subprocess? Use quickcheck to generate your test cases and then bad C code doesn't crash your whole program. I remember a conference talk where someone did this to wordpress, booting up and destroying either vms or containers
2023-01-05 01:28:04 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-05 01:33:05 +0100cheater_(~Username@user/cheater)
2023-01-05 01:35:29 +0100cheater(~Username@user/cheater) (Ping timeout: 255 seconds)
2023-01-05 01:35:30 +0100cheater_cheater
2023-01-05 01:38:10 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 268 seconds)
2023-01-05 01:38:12 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Quit: ZNC 1.8.2 - https://znc.in)
2023-01-05 01:40:09 +0100 <maerwald[m]> jean-paul.: oh, I misread 😄
2023-01-05 01:41:57 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-05 01:42:32 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-01-05 01:46:20 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-01-05 01:46:45 +0100acidjnk(~acidjnk@p200300d6e7137a34b1a3218fa39d995d.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-01-05 01:49:46 +0100freeside(~mengwong@103.252.202.159)
2023-01-05 01:54:37 +0100unit73e(~emanuel@2001:818:e8dd:7c00:656:e5ff:fe72:9d36) (Ping timeout: 252 seconds)
2023-01-05 02:01:44 +0100fizbin(~fizbin@user/fizbin)
2023-01-05 02:03:52 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-05 02:09:11 +0100king_gs(~Thunderbi@2806:103e:29:45ac:af0:afaf:29e7:dd60)
2023-01-05 02:10:18 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-01-05 02:11:38 +0100agumonkey(~user@2a01:e0a:8f9:d3e0:171e:d6c3:c5ae:d894)
2023-01-05 02:12:23 +0100cheater_(~Username@user/cheater)
2023-01-05 02:15:10 +0100cheater(~Username@user/cheater) (Ping timeout: 265 seconds)
2023-01-05 02:15:18 +0100cheater_cheater
2023-01-05 02:15:47 +0100nasrudin__(~nasrudin_@174.78.11.128) (Ping timeout: 268 seconds)
2023-01-05 02:16:25 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-01-05 02:16:32 +0100nasrudin__(~nasrudin_@174.78.11.128)
2023-01-05 02:18:18 +0100tremon(~tremon@83-85-213-108.cable.dynamic.v4.ziggo.nl) (Quit: getting boxed in)
2023-01-05 02:18:44 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) (Quit: Leaving.)
2023-01-05 02:25:38 +0100 <dgpratt[m]> @undo do { s <- [1..10]; let t = s * s; return (s, t) }
2023-01-05 02:25:38 +0100 <lambdabot> <unknown>.hs:1:49:Parse error: }
2023-01-05 02:26:12 +0100 <dgpratt[m]> clearly doing something stupid, can someone point out what?
2023-01-05 02:26:49 +0100 <jackdk> @undo do { s <- [1..10]; let t = s * s; return (s, t); }
2023-01-05 02:26:49 +0100 <lambdabot> <unknown>.hs:1:48:Parse error: ;
2023-01-05 02:27:30 +0100 <geekosaur> let introduces layout, so needs its own braces
2023-01-05 02:27:52 +0100 <geekosaur> @undo do { s <- [1..10]; let {t = s * s}; return (s, t); }
2023-01-05 02:27:52 +0100 <lambdabot> [1 .. 10] >>= \ s -> let { t = s * s} in return (s, t)
2023-01-05 02:28:00 +0100 <jackdk> Neat, I did not know that.
2023-01-05 02:28:46 +0100 <dgpratt[m]> geekosaur: I think you've been answering all my queries of late, thanks again :)
2023-01-05 02:28:54 +0100razetime(~Thunderbi@49.207.222.244)
2023-01-05 02:30:02 +0100jmorris(uid537181@id-537181.uxbridge.irccloud.com)
2023-01-05 02:36:00 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-01-05 02:43:28 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 272 seconds)
2023-01-05 02:48:16 +0100alt-romes(~romes@192.22.63.94.rev.vodafone.pt)
2023-01-05 02:50:56 +0100romesrf(~romes@192.22.63.94.rev.vodafone.pt) (Ping timeout: 268 seconds)
2023-01-05 02:53:36 +0100alt-romes(~romes@192.22.63.94.rev.vodafone.pt) (Ping timeout: 272 seconds)
2023-01-05 02:57:11 +0100Kaipei(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net) (Ping timeout: 260 seconds)
2023-01-05 02:57:32 +0100enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) (Quit: enoq)
2023-01-05 03:03:09 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Remote host closed the connection)
2023-01-05 03:04:39 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-01-05 03:11:20 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Ping timeout: 272 seconds)
2023-01-05 03:13:10 +0100king_gs(~Thunderbi@2806:103e:29:45ac:af0:afaf:29e7:dd60) (Remote host closed the connection)
2023-01-05 03:13:29 +0100king_gs(~Thunderbi@2806:103e:29:45ac:af0:afaf:29e7:dd60)
2023-01-05 03:14:12 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 03:15:36 +0100nasrudin__(~nasrudin_@174.78.11.128) (Ping timeout: 252 seconds)
2023-01-05 03:16:17 +0100cyphase(~cyphase@user/cyphase) (Ping timeout: 256 seconds)
2023-01-05 03:16:38 +0100nasrudin__(~nasrudin_@174.78.11.128)
2023-01-05 03:16:50 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-01-05 03:17:42 +0100cyphase(~cyphase@user/cyphase)
2023-01-05 03:18:41 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 268 seconds)
2023-01-05 03:19:17 +0100alt-romes(~romes@192.22.63.94.rev.vodafone.pt)
2023-01-05 03:20:58 +0100agumonkey(~user@2a01:e0a:8f9:d3e0:171e:d6c3:c5ae:d894) (Ping timeout: 252 seconds)
2023-01-05 03:28:38 +0100alt-romes(~romes@192.22.63.94.rev.vodafone.pt) (Ping timeout: 265 seconds)
2023-01-05 03:32:53 +0100dsrt^(~dsrt@76.145.190.81)
2023-01-05 03:42:00 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-01-05 03:43:17 +0100xff0x(~xff0x@p3326132-ipngn2103sapodori.hokkaido.ocn.ne.jp) (Ping timeout: 255 seconds)
2023-01-05 03:46:16 +0100justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 252 seconds)
2023-01-05 03:46:40 +0100justsomeguy(~justsomeg@user/justsomeguy)
2023-01-05 03:47:42 +0100alt-romes(~romes@192.22.63.94.rev.vodafone.pt)
2023-01-05 03:47:58 +0100masterbuilder(~master@user/masterbuilder)
2023-01-05 03:52:30 +0100alt-romes(~romes@192.22.63.94.rev.vodafone.pt) (Ping timeout: 272 seconds)
2023-01-05 03:52:44 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 260 seconds)
2023-01-05 03:54:40 +0100werneta(~werneta@137.79.238.79)
2023-01-05 04:02:55 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-01-05 04:02:55 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-01-05 04:02:55 +0100finn_elijaFinnElija
2023-01-05 04:05:10 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 272 seconds)
2023-01-05 04:06:48 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 04:12:48 +0100td_(~td@83.135.9.7) (Ping timeout: 252 seconds)
2023-01-05 04:14:07 +0100instantaphex(~jb@c-73-171-252-84.hsd1.fl.comcast.net)
2023-01-05 04:14:30 +0100td_(~td@83.135.9.50)
2023-01-05 04:16:39 +0100nasrudin__(~nasrudin_@174.78.11.128) (Ping timeout: 268 seconds)
2023-01-05 04:16:45 +0100freeside(~mengwong@103.252.202.159)
2023-01-05 04:17:14 +0100nasrudin__(~nasrudin_@174.78.11.128)
2023-01-05 04:19:04 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-05 04:19:06 +0100werneta(~werneta@137.79.238.79) (Ping timeout: 272 seconds)
2023-01-05 04:20:17 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-01-05 04:24:32 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 252 seconds)
2023-01-05 04:33:18 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 268 seconds)
2023-01-05 04:47:31 +0100king_gs(~Thunderbi@2806:103e:29:45ac:af0:afaf:29e7:dd60) (Ping timeout: 256 seconds)
2023-01-05 04:49:32 +0100chiselfuse(~chiselfus@user/chiselfuse) (Ping timeout: 255 seconds)
2023-01-05 04:50:08 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-01-05 04:54:47 +0100beefbambi(~beefbambi@183.82.24.253) (Read error: Connection reset by peer)
2023-01-05 04:55:34 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 04:55:48 +0100beefbambi(~beefbambi@2401:4900:230d:f57c:538c:d7cc:50c0:e377)
2023-01-05 04:56:43 +0100beefbambi(~beefbambi@2401:4900:230d:f57c:538c:d7cc:50c0:e377) (Read error: Connection reset by peer)
2023-01-05 04:57:10 +0100nasrudin__(~nasrudin_@174.78.11.128) (Ping timeout: 252 seconds)
2023-01-05 04:57:16 +0100beefbambi(~beefbambi@183.82.24.253)
2023-01-05 05:04:58 +0100 <mizlan> with the way ghc builds, should i be able to copy the executable from dist-newstyle/ to say, /usr/local/bin and have it work from there?
2023-01-05 05:06:30 +0100 <c_wraith> yes.
2023-01-05 05:07:00 +0100 <glguy> mizlan: the place that would go wrong would be if the executable came with cabal-managed data files (which is uncommon)
2023-01-05 05:07:32 +0100 <c_wraith> even then, it should still have the right paths - it just might not have the right permissions
2023-01-05 05:07:55 +0100Oranos(~Oranos@2603-8000-a343-c600-0000-0000-0000-0001.res6.spectrum.com)
2023-01-05 05:07:56 +0100 <glguy> The paths would be pointing into dist-newstyle?
2023-01-05 05:08:55 +0100 <glguy> instead of copying out of dist-newstyle, it seems like it'd be better to "cabal install --prefix..."
2023-01-05 05:09:37 +0100 <mizlan> I am using zsh and it says 'zsh: killed'
2023-01-05 05:09:47 +0100 <mizlan> i'll try cabal install with a prefix, thanks
2023-01-05 05:10:00 +0100 <c_wraith> does your current user have permission to write to /usr/local/bin?
2023-01-05 05:11:51 +0100 <mizlan> Yep, it has permission to write, but I think the problem might be permission to execute
2023-01-05 05:12:02 +0100 <mizlan> I just tried `sudo my-cmd` and it worked
2023-01-05 05:12:47 +0100 <mizlan> oh wait: nvm
2023-01-05 05:13:18 +0100cheater_(~Username@user/cheater)
2023-01-05 05:13:35 +0100 <mizlan> seems like cabal install is ignoring --prefix, but .cabal/bin is fine for me :]
2023-01-05 05:16:14 +0100cheater(~Username@user/cheater) (Ping timeout: 252 seconds)
2023-01-05 05:16:24 +0100cheater_cheater
2023-01-05 05:19:10 +0100caryhartline(~caryhartl@2600:1700:2d0:8d30:4c56:2515:e4a9:736c) (Quit: caryhartline)
2023-01-05 05:19:49 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 256 seconds)
2023-01-05 05:20:02 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Ping timeout: 246 seconds)
2023-01-05 05:20:35 +0100ddellacosta(~ddellacos@143.244.47.85) (Ping timeout: 260 seconds)
2023-01-05 05:25:18 +0100 <sclv> patch in the next version of cabal will make new-install start ignoring prefix
2023-01-05 05:26:40 +0100v0id_ptr(~adrift@user/ptr-frac7al/x-0038398)
2023-01-05 05:36:12 +0100ystael(~ystael@user/ystael) (Ping timeout: 268 seconds)
2023-01-05 05:40:10 +0100beefbambi(~beefbambi@183.82.24.253) (Ping timeout: 272 seconds)
2023-01-05 05:41:07 +0100willbradley(~willbradl@71-211-142-215.hlrn.qwest.net)
2023-01-05 05:42:15 +0100willbradleywbbradley
2023-01-05 05:42:54 +0100beefbambi(~beefbambi@2401:4900:230d:f57c:538c:d7cc:50c0:e377)
2023-01-05 05:54:55 +0100mbuf(~Shakthi@49.204.130.110)
2023-01-05 05:55:53 +0100Blightmain(~Blightmai@203.29.154.219) (Quit: Leaving)
2023-01-05 05:56:05 +0100wbbradley(~willbradl@71-211-142-215.hlrn.qwest.net) ()
2023-01-05 05:56:24 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2023-01-05 05:57:17 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-01-05 06:01:16 +0100ephaptic(~ephaptic@user/ephaptic)
2023-01-05 06:04:46 +0100talismanick(~talismani@76.133.152.122)
2023-01-05 06:05:22 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-01-05 06:11:21 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) (Ping timeout: 268 seconds)
2023-01-05 06:20:41 +0100 <sclv> stop ignoring i meant, lol
2023-01-05 06:23:12 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net)
2023-01-05 06:23:42 +0100instantaphex(~jb@c-73-171-252-84.hsd1.fl.comcast.net) (Ping timeout: 252 seconds)
2023-01-05 06:26:43 +0100Vajb(~Vajb@2001:999:405:5eb2:8d39:b832:a9ee:9bdf) (Read error: Connection reset by peer)
2023-01-05 06:26:43 +0100 <sm> let's start ignoring troublesome features, that's the way :)
2023-01-05 06:27:05 +0100Vajb(~Vajb@hag-jnsbng11-58c3a5-27.dhcp.inet.fi)
2023-01-05 06:29:34 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 272 seconds)
2023-01-05 06:31:23 +0100Vajb(~Vajb@hag-jnsbng11-58c3a5-27.dhcp.inet.fi) (Read error: Connection reset by peer)
2023-01-05 06:33:18 +0100Vajb(~Vajb@2001:999:405:5eb2:8d39:b832:a9ee:9bdf)
2023-01-05 06:34:01 +0100Me-me(~me-me@user/me-me) (Remote host closed the connection)
2023-01-05 06:35:07 +0100ephaptic(~ephaptic@user/ephaptic) (Quit: WeeChat 3.7.1)
2023-01-05 06:37:38 +0100Me-me(~me-me@2602:ff16:3:0:1:dc:beef:d00d)
2023-01-05 06:37:42 +0100Me-me(~me-me@2602:ff16:3:0:1:dc:beef:d00d) (Changing host)
2023-01-05 06:37:42 +0100Me-me(~me-me@user/me-me)
2023-01-05 06:39:05 +0100kuttenbrunzer(~kuttenbru@2a02:8108:8b80:1d48:b9dc:1d8d:8491:7136)
2023-01-05 06:39:48 +0100jmorris(uid537181@id-537181.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-05 06:42:34 +0100freeside(~mengwong@103.252.202.159)
2023-01-05 06:50:42 +0100Oranos(~Oranos@2603-8000-a343-c600-0000-0000-0000-0001.res6.spectrum.com) (Quit: Oranos)
2023-01-05 06:56:50 +0100alt-romes(~romes@192.22.63.94.rev.vodafone.pt)
2023-01-05 07:04:31 +0100alt-romes(~romes@192.22.63.94.rev.vodafone.pt) (Ping timeout: 260 seconds)
2023-01-05 07:07:35 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Quit: Leaving)
2023-01-05 07:13:18 +0100hrberg(~quassel@171.79-160-161.customer.lyse.net) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-01-05 07:13:37 +0100hrberg(~quassel@171.79-160-161.customer.lyse.net)
2023-01-05 07:19:36 +0100thongpv(~thongpv87@123.31.184.215)
2023-01-05 07:21:05 +0100thongpv87(~thongpv87@2402:9d80:3ba:1697:bf26:42c7:945d:2a94) (Ping timeout: 255 seconds)
2023-01-05 07:35:06 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2023-01-05 07:35:34 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-01-05 07:44:58 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-01-05 07:50:43 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-05 07:50:46 +0100alt-romes(~romes@192.22.63.94.rev.vodafone.pt)
2023-01-05 07:55:58 +0100alt-romes(~romes@192.22.63.94.rev.vodafone.pt) (Ping timeout: 252 seconds)
2023-01-05 07:57:09 +0100titibandit(7efad7d72e@2a00:c70:1:178:170:40:189:1)
2023-01-05 08:00:13 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 08:04:24 +0100kuttenbrunzer(~kuttenbru@2a02:8108:8b80:1d48:b9dc:1d8d:8491:7136) (Quit: Leaving)
2023-01-05 08:04:49 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 268 seconds)
2023-01-05 08:13:49 +0100trev(~trev@user/trev)
2023-01-05 08:15:17 +0100thegeekinside(~thegeekin@189.217.82.244) (Read error: Connection reset by peer)
2023-01-05 08:25:10 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-01-05 08:26:44 +0100pragma-(~chaos@user/pragmatic-chaos)
2023-01-05 08:27:22 +0100jinsun(~jinsun@user/jinsun) (Ping timeout: 272 seconds)
2023-01-05 08:29:51 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-05 08:30:34 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 08:37:30 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) (Ping timeout: 272 seconds)
2023-01-05 08:44:54 +0100myme(~myme@40.51-175-185.customer.lyse.net) (Ping timeout: 268 seconds)
2023-01-05 08:52:49 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-05 09:00:50 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:fabd:1d4c:3d9a:76e1)
2023-01-05 09:04:14 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 260 seconds)
2023-01-05 09:07:14 +0100kuttenbrunzer(~kuttenbru@2a02:8108:8b80:1d48:e097:e52d:638e:1121)
2023-01-05 09:07:58 +0100mc47(~mc47@xmonad/TheMC47)
2023-01-05 09:14:21 +0100chele(~chele@user/chele)
2023-01-05 09:19:01 +0100zeenk(~zeenk@2a02:2f04:a110:ac00::7fe)
2023-01-05 09:23:48 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-05 09:26:13 +0100cheater_(~Username@user/cheater)
2023-01-05 09:28:41 +0100cheater(~Username@user/cheater) (Ping timeout: 268 seconds)
2023-01-05 09:28:49 +0100cheater_cheater
2023-01-05 09:29:50 +0100nschoe(~q@141.101.51.197)
2023-01-05 09:36:24 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 272 seconds)
2023-01-05 09:39:59 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7)
2023-01-05 09:40:39 +0100Teacup(~teacup@user/teacup) (Remote host closed the connection)
2023-01-05 09:40:48 +0100Teacup(~teacup@user/teacup)
2023-01-05 09:40:59 +0100nut(~nut@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2023-01-05 09:43:46 +0100acidjnk(~acidjnk@p200300d6e7137a34b1a3218fa39d995d.dip0.t-ipconnect.de)
2023-01-05 09:48:21 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-01-05 09:50:20 +0100alt-romes(~romes@192.22.63.94.rev.vodafone.pt)
2023-01-05 10:00:11 +0100kadoban(~kadoban@user/kadoban) (Quit: You have been kicked for being idle)
2023-01-05 10:05:37 +0100avicenzi(~avicenzi@2a00:ca8:a1f:b004::c32)
2023-01-05 10:06:11 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 10:07:57 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2023-01-05 10:10:43 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-05 10:11:44 +0100shriekingnoise(~shrieking@186.137.175.87) (Quit: Quit)
2023-01-05 10:12:06 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-01-05 10:14:30 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-05 10:21:33 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9552:b93e:dc75:3765) (Remote host closed the connection)
2023-01-05 10:23:29 +0100alt-romes(~romes@192.22.63.94.rev.vodafone.pt) (Ping timeout: 246 seconds)
2023-01-05 10:24:13 +0100 <Inst> i'm curious, are there any tutorials on how to do things in IO, i.e, what idioms, how to manage the monad stacks (when they appear), and so on?
2023-01-05 10:27:02 +0100gmg(~user@user/gehmehgeh) (Ping timeout: 255 seconds)
2023-01-05 10:27:46 +0100gmg(~user@user/gehmehgeh)
2023-01-05 10:28:12 +0100boxscape_(~boxscape_@213.52.37.155)
2023-01-05 10:33:25 +0100titibandit2(~titibandi@2001-4dd1-5719-1-8737-c319-efc8-cbf0.ipv6dyn.netcologne.de)
2023-01-05 10:35:35 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Ping timeout: 255 seconds)
2023-01-05 10:36:38 +0100elevenkb(~elevenkb@105.226.98.103)
2023-01-05 10:38:06 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-01-05 10:39:18 +0100Kaipei(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net)
2023-01-05 10:41:48 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2023-01-05 10:45:11 +0100mechap1(~mechap@user/mechap)
2023-01-05 10:45:56 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.7.1)
2023-01-05 10:48:33 +0100 <boxscape_> does hackage support RST READMEs? Or only markdown?
2023-01-05 10:48:33 +0100elevenkb(~elevenkb@105.226.98.103) (Quit: Client closed)
2023-01-05 10:48:39 +0100mechap(~mechap@user/mechap) (Ping timeout: 260 seconds)
2023-01-05 10:48:51 +0100hueso(~root@user/hueso) (Read error: Connection reset by peer)
2023-01-05 10:49:20 +0100hueso(~root@user/hueso)
2023-01-05 10:49:45 +0100titibandit2(~titibandi@2001-4dd1-5719-1-8737-c319-efc8-cbf0.ipv6dyn.netcologne.de) (Quit: Leaving.)
2023-01-05 10:49:59 +0100 <boxscape_> (trying to figure out if there's any advantage to me writing my README in RST, but I can save myself from figuring that out if it's not supported to begin with)
2023-01-05 10:53:15 +0100 <boxscape_> ...actually not sure if this is a haddock question or a hackage question
2023-01-05 10:55:17 +0100alt-romes(~romes@192.22.63.94.rev.vodafone.pt)
2023-01-05 10:58:07 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 10:59:35 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-05 11:00:52 +0100cheater_(~Username@user/cheater)
2023-01-05 11:02:25 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-05 11:03:33 +0100 <jackdk> boxscape_: https://github.com/haskell/hackage-server/blob/6c8689a779b688b3e6b927614c90318936d5bb3f/src/Distri… I suspect not
2023-01-05 11:03:47 +0100 <boxscape_> jackdk ah, thanks!
2023-01-05 11:04:17 +0100cheater(~Username@user/cheater) (Ping timeout: 252 seconds)
2023-01-05 11:04:19 +0100cheater_cheater
2023-01-05 11:04:26 +0100razetime(~Thunderbi@49.207.222.244) (Ping timeout: 272 seconds)
2023-01-05 11:04:50 +0100 <jackdk> https://github.com/haskell/hackage-server/blob/0a2ffe8e5c5e0293a5bd5b0840f6ece80357926d/src/Distri… I'm really confident that it's markdown only now
2023-01-05 11:05:04 +0100 <jackdk> unless you like your RST unrendered
2023-01-05 11:05:38 +0100 <boxscape_> or HTML I guess? judging by your first link
2023-01-05 11:06:33 +0100 <jackdk> I guess that will determine that there is a readme and probably stuff the contents of the html inside that <pre>, which is not very nice to look at =/
2023-01-05 11:06:34 +0100teo(~teo@user/teo)
2023-01-05 11:07:05 +0100 <boxscape_> ah right. Yeah, that wouldn't be pretty
2023-01-05 11:07:37 +0100__monty__(~toonn@user/toonn)
2023-01-05 11:09:26 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-05 11:09:28 +0100random-jellyfish(~random-je@user/random-jellyfish)
2023-01-05 11:16:18 +0100thongpv87(~thongpv87@2001:ee0:54a5:98a0:cf79:600e:5b28:fb67)
2023-01-05 11:16:26 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 11:16:37 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-01-05 11:17:29 +0100paulpaul1076(~textual@95-29-5-111.broadband.corbina.ru) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-01-05 11:19:41 +0100thongpv(~thongpv87@123.31.184.215) (Ping timeout: 268 seconds)
2023-01-05 11:21:59 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9552:b93e:dc75:3765)
2023-01-05 11:24:39 +0100cheater_(~Username@user/cheater)
2023-01-05 11:25:54 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2023-01-05 11:26:47 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9552:b93e:dc75:3765) (Ping timeout: 260 seconds)
2023-01-05 11:27:45 +0100cheater(~Username@user/cheater) (Ping timeout: 252 seconds)
2023-01-05 11:27:46 +0100cheater_cheater
2023-01-05 11:28:21 +0100mechap(~mechap@user/mechap)
2023-01-05 11:29:08 +0100mechap(~mechap@user/mechap) (Client Quit)
2023-01-05 11:34:24 +0100 <jackdk> Lens question: I'm aware of `instance Eq e => Ixed (e -> a)` in package `lens`. Is there a more general version of this that lets me run a function `a -> a` when `e` satisfies some predicate? I'm looking at service overrides in Amazonka, and wondering if there's something easier to work with than the `Dual (Endo Service)` monoid that's currently there.
2023-01-05 11:35:04 +0100cheater(~Username@user/cheater) (Read error: Connection reset by peer)
2023-01-05 11:35:45 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-01-05 11:35:47 +0100 <jackdk> Context: `Service` is a record which contains (among other things) an `abbrev :: Text` which is something like `"s3"`, `"iam"`, `"ec2"`, etc. So adding an override for EC2 calls a helper function which checks the abbrev and applies your override only if it matches.
2023-01-05 11:36:04 +0100kuttenbrunzer(~kuttenbru@2a02:8108:8b80:1d48:e097:e52d:638e:1121) (Quit: Leaving)
2023-01-05 11:36:50 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 252 seconds)
2023-01-05 11:37:16 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-01-05 11:38:20 +0100panovia(~user@user/siracusa) (Quit: Bye!)
2023-01-05 11:38:31 +0100Lord_of_Life_Lord_of_Life
2023-01-05 11:39:23 +0100cheater(~Username@user/cheater)
2023-01-05 11:43:22 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-01-05 11:46:28 +0100paulpaul1076(~textual@95-29-5-111.broadband.corbina.ru)
2023-01-05 11:49:10 +0100 <[exa]> jackdk: that sounds a bit more like filter (the function doesn't need the index right?)
2023-01-05 11:49:53 +0100 <jackdk> yeah it's not really lensy, more like `applyP :: (a -> Bool) -> (a -> a) -> (a -> a)`
2023-01-05 11:53:29 +0100elevenkb(~elevenkb@105.226.98.103)
2023-01-05 11:54:23 +0100 <[exa]> hm let's conjure the type, it would be something like `ixs :: Ixed m => (Index m -> Bool) -> Traversal' m (IxValue m)`, right?
2023-01-05 11:56:15 +0100king_gs(~Thunderbi@187.201.110.169)
2023-01-05 11:56:31 +0100 <jackdk> I think the use of Ixed may be a red herring actually
2023-01-05 11:57:12 +0100 <[exa]> hm yeah this form requires a bit stronger property than Ixed gives (like, a materialized finite index domain)
2023-01-05 12:00:15 +0100jumper149(~jumper149@base.felixspringer.xyz)
2023-01-05 12:01:20 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 260 seconds)
2023-01-05 12:02:27 +0100 <[exa]> but you can probably go with iix (or withIndex or so) and filter on _1
2023-01-05 12:05:44 +0100 <[exa]> actually, `filteredBy` might be just that
2023-01-05 12:06:59 +0100 <[exa]> and yeah well, after crawling sufficient hoogle, `ifiltered` appears.
2023-01-05 12:09:58 +0100boxscape_(~boxscape_@213.52.37.155) (Ping timeout: 260 seconds)
2023-01-05 12:18:32 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 272 seconds)
2023-01-05 12:18:34 +0100gensyst(gensyst@user/gensyst)
2023-01-05 12:19:20 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 265 seconds)
2023-01-05 12:19:23 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-05 12:20:16 +0100 <gensyst> At one place I have a toggle :: Bool that someone else can choose. Elsewhere I currently have both trueCollections :: TrueDataStructure and falseCollections :: FalseDataStructure. Currently if they chose False, the TrueDataStructure just stays empty while I only accumulate the FalseDataStructure. And vice versa.
2023-01-05 12:20:22 +0100 <gensyst> This is painful if/case code.
2023-01-05 12:21:04 +0100 <gensyst> Is there no way to... offload some of this pain to compiler?
2023-01-05 12:21:42 +0100 <gensyst> TemplateHaskell or something? Dependent types? What is this thing? Hmmmmmmm.
2023-01-05 12:22:03 +0100 <Rembane> gensyst: partition perhaps?
2023-01-05 12:22:03 +0100sylvo(~sylvo@203.29.154.219)
2023-01-05 12:22:05 +0100 <Rembane> :t partition
2023-01-05 12:22:06 +0100 <lambdabot> (a -> Bool) -> [a] -> ([a], [a])
2023-01-05 12:23:05 +0100sylvo_(~sylvo@2001:8004:5170:2af5:830a:1332:d7d4:ebde)
2023-01-05 12:23:07 +0100cheater(~Username@user/cheater) (Ping timeout: 256 seconds)
2023-01-05 12:23:26 +0100merijn(~merijn@86.86.29.250)
2023-01-05 12:25:07 +0100king_gs(~Thunderbi@187.201.110.169) (Read error: Connection reset by peer)
2023-01-05 12:25:45 +0100king_gs(~Thunderbi@2806:103e:29:45ac:af0:afaf:29e7:dd60)
2023-01-05 12:26:49 +0100 <gensyst> The issue is that I'm bothering with both if only one was wanted
2023-01-05 12:26:53 +0100sylvo(~sylvo@203.29.154.219) (Ping timeout: 260 seconds)
2023-01-05 12:27:09 +0100 <gensyst> but which was wanted it known at runtime hmmmmmm.
2023-01-05 12:28:09 +0100 <Rembane> gensyst: You can have a function that takes what is wanted as an argument
2023-01-05 12:28:11 +0100 <gensyst> what I'm trying to say: Of course I need to code the logic for both. However, I want to guard against (at compile time) I'm messing with the FalseDataStructure when the guy chose True.
2023-01-05 12:29:13 +0100random-jellyfish(~random-je@user/random-jellyfish) (Quit: Client closed)
2023-01-05 12:29:18 +0100 <mauke> I don't get it
2023-01-05 12:30:22 +0100 <Rembane> gensyst: Do you have a concrete example of this? Like some code where you can point to the place where things go bad?
2023-01-05 12:32:43 +0100merijn(~merijn@86.86.29.250) (Ping timeout: 260 seconds)
2023-01-05 12:35:00 +0100mmhat(~mmh@p200300f1c7123c9eee086bfffe095315.dip0.t-ipconnect.de)
2023-01-05 12:36:06 +0100cheater(~Username@user/cheater)
2023-01-05 12:40:10 +0100 <ncf> what you're saying looks like the type of your data structure depends on the value of toggle
2023-01-05 12:40:23 +0100 <ncf> so i guess dependent types is the thing to look for? maybe singletons?
2023-01-05 12:40:50 +0100 <Rembane> Or a sum type with the data needed in two different branches of the sum type.
2023-01-05 12:42:40 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 12:43:36 +0100 <gensyst> mauke, Rembane https://paste.tomsmeding.com/DxI2ZTj6
2023-01-05 12:43:36 +0100 <gensyst> Which path (case/if) gets taken depends on the runtime choice.
2023-01-05 12:43:36 +0100 <gensyst> This is not ideal because why am I bothering with Cats&Dogs if the guy chose horses? If my code is correct, I'm leaving Cats&Dogs alone (empty) at runtime, but it would be cool if I could just know this at compile time by somehow "connecting" the settings type and the state types.
2023-01-05 12:43:48 +0100mmhat(~mmh@p200300f1c7123c9eee086bfffe095315.dip0.t-ipconnect.de) (Quit: WeeChat 3.7.1)
2023-01-05 12:45:04 +0100 <chreekat> Sum type is the answer :) don't carry around all data, just carry around the data you need
2023-01-05 12:46:33 +0100 <chreekat> Make your State be `State = DogState DogData | CatState CatData | ...`
2023-01-05 12:47:03 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-05 12:48:31 +0100random-jellyfish(~random-je@user/random-jellyfish)
2023-01-05 12:48:41 +0100xff0x(~xff0x@p3326132-ipngn2103sapodori.hokkaido.ocn.ne.jp)
2023-01-05 12:50:38 +0100random-jellyfish(~random-je@user/random-jellyfish) (Client Quit)
2023-01-05 12:51:45 +0100alt-romes(~romes@192.22.63.94.rev.vodafone.pt) (Quit: WeeChat 3.7.1)
2023-01-05 12:51:53 +0100 <gensyst> chreekat, hmmmmm ok!
2023-01-05 12:51:55 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-05 12:51:59 +0100 <gensyst> that might work.....
2023-01-05 12:52:15 +0100random-jellyfish(~random-je@user/random-jellyfish)
2023-01-05 12:53:06 +0100 <gensyst> chreekat, but can we do better? Can we end up with something like processData @Cat which will check at compile time I'm not messing with Dogs&Horses at all (even in certain case branches)?
2023-01-05 12:53:29 +0100 <gensyst> Maybe I'm way off base in my thinking
2023-01-05 12:54:51 +0100 <chreekat> It's possible in a few ways, but only go that route if you're more interested in Fun Math Puzzles than you are in writing useful software :)
2023-01-05 12:55:39 +0100 <gensyst> hmm ok
2023-01-05 12:55:53 +0100cheater(~Username@user/cheater) (Ping timeout: 255 seconds)
2023-01-05 12:58:48 +0100 <chreekat> (switching away from a product type that has lots of "undefined" entries improves the clarity and safety of the code a ton. Moving beyond that to GADTs or type classes or phantom types or .... requires more justification because it's no longer helping clarity)
2023-01-05 12:59:45 +0100 <[Leary]> gensyst: You may want your separate `Settings` and `State` types to be in sync, in which case you could make them GADTs and have them share a DataKind type parameter specifying the case you're in. That would also support what you're asking about, and it's relatively straightforward.
2023-01-05 13:00:26 +0100 <jackdk> That seems promising; I've cooked up something hairy with dependent-sum, but I think a simple GADT would do
2023-01-05 13:00:32 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 13:00:56 +0100 <jackdk> https://www.irccloud.com/pastebin/OmivBcRe/PetsDependentSum.hs
2023-01-05 13:03:38 +0100 <gensyst> jackdk, how would processData look?
2023-01-05 13:04:33 +0100rburkholder(~blurb@96.45.2.121)
2023-01-05 13:05:06 +0100 <jackdk> `processData :: DSum Pets PetData -> IO (DSum Pets PetData)` I guess; `processData (pet :=> state) = case pet of Cats -> ...;` etc. In each alternative of the case, GHC will know what type you actually have.
2023-01-05 13:06:11 +0100 <gensyst> [Leary], is jackdk's solution what you had in mind?
2023-01-05 13:06:27 +0100 <jackdk> Probably not, because it's rather hairy
2023-01-05 13:08:52 +0100 <jackdk> Don't trust me, I'm going to bed. https://www.irccloud.com/pastebin/KL6njlbt/PetGADTs.hs
2023-01-05 13:11:26 +0100 <gensyst> lol
2023-01-05 13:11:34 +0100 <[Leary]> Mine would use jackdk's `Pet`, `Pets` and `PetState` without `Some` or `DSum`, with `processData :: Setting p -> PetState p -> IO (PetState p)`.
2023-01-05 13:12:08 +0100 <jackdk> Yeah you don't need `Some`, that's true.
2023-01-05 13:12:44 +0100 <gensyst> Is this stuff possible in other langs like Rust? (keep two separate things in sync like this)
2023-01-05 13:15:20 +0100cheater(~Username@user/cheater)
2023-01-05 13:15:21 +0100mestre(~mestre@191.177.185.178)
2023-01-05 13:32:43 +0100random-jellyfish(~random-je@user/random-jellyfish) (Quit: Client closed)
2023-01-05 13:35:39 +0100thongpv(~thongpv87@2402:9d80:3ca:5321:90ac:c773:b44c:7ddf)
2023-01-05 13:37:21 +0100thongpv87(~thongpv87@2001:ee0:54a5:98a0:cf79:600e:5b28:fb67) (Ping timeout: 256 seconds)
2023-01-05 13:48:40 +0100gaff(~gaff@49.207.203.30)
2023-01-05 13:48:58 +0100myme(~myme@40.51-175-185.customer.lyse.net)
2023-01-05 13:49:40 +0100 <gaff> is there a way to test (quickcheck) interior modules of a library without exposing those modules to users of that library?
2023-01-05 13:49:47 +0100boxscape_(~boxscape_@213.52.37.155)
2023-01-05 13:50:13 +0100 <boxscape_> Does anyone happen to know about a good real-world use of mutable array code I can find on hackage or github?
2023-01-05 13:50:14 +0100 <gaff> interior = internal, by the way
2023-01-05 13:50:29 +0100 <merijn> gaff: No and yes
2023-01-05 13:50:48 +0100 <merijn> gaff: No in the sense that you can't really access internal from quickcheck without exporting them
2023-01-05 13:50:59 +0100 <gaff> i see
2023-01-05 13:51:00 +0100 <merijn> gaff: Yes in the sense that cabal now supports internal libraries!
2023-01-05 13:51:12 +0100 <gaff> which cabal version is that?
2023-01-05 13:51:29 +0100 <gaff> i use cabal 3.4
2023-01-05 13:51:31 +0100 <merijn> gaff: So if you *really* care, you can make an internal library that exports everything and then have tests use that and a public library that re-exports a safe subset of the internal library
2023-01-05 13:51:45 +0100 <merijn> I think since 3.0?
2023-01-05 13:51:45 +0100 <boxscape_> actually probably any reasonably complex use-case of ST would do, whether it involves arrays or not
2023-01-05 13:51:56 +0100 <boxscape_> real-world use case, that is
2023-01-05 13:52:20 +0100 <gaff> merijn: but that wouldn't work if the tests are in a seperate directory
2023-01-05 13:52:53 +0100 <merijn> gaff: oh, 2.0 even
2023-01-05 13:52:55 +0100 <merijn> gaff: https://cabal.readthedocs.io/en/stable/cabal-package.html#sublibs
2023-01-05 13:53:02 +0100 <gaff> ah you mean have 2 libraries?
2023-01-05 13:53:36 +0100 <merijn> gaff: Yes, "internal" which has all the code then "public" (re-exporting the public bits of internal) and quickcheck depending on the internal one
2023-01-05 13:55:30 +0100 <gaff> ok, thanks. this `Internal` & `Public` -- are these required keywords for cabal?
2023-01-05 13:57:42 +0100CiaoSen(~Jura@p200300c9572e35002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-01-05 13:58:30 +0100 <merijn> no, cabal can actually handle multiple public libraries in one package now
2023-01-05 13:58:38 +0100 <merijn> However, Hackage can not (yet, at least)
2023-01-05 13:58:57 +0100 <gaff> i ask because in your link, Foo.Internal is an exposed module, yet users of the package can not see it. how is that possible?
2023-01-05 14:00:14 +0100 <gaff> because `foo-internal` is not the main library?
2023-01-05 14:02:19 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-05 14:02:22 +0100 <merijn> gaff: exposed-module says which modules of a library are visible, but visibility controls which *libraries* are visible outside a package: https://cabal.readthedocs.io/en/stable/cabal-package.html#pkg-field-library-visibility
2023-01-05 14:06:31 +0100 <gaff> merijn: ok, thanks. so in the first link you gave, visibility field (which is missing) should be private for `foo-internal`?
2023-01-05 14:06:38 +0100 <eldritchcookie[4> can i mix unicode syntax with non unicode? or would i need to add formater to replace the normal ascii text with the unicode version?
2023-01-05 14:06:49 +0100 <merijn> gaff: Yeah
2023-01-05 14:06:54 +0100 <gaff> ah got it
2023-01-05 14:07:03 +0100 <merijn> eldritchcookie[4: I think you can always use non-unicode syntax
2023-01-05 14:07:18 +0100 <merijn> eldritchcookie[4: You mean stuff like using ∀ instead of forall, yeah?
2023-01-05 14:07:26 +0100 <gaff> cabal documentation can certainly be improved!
2023-01-05 14:07:57 +0100 <gaff> merijn: thanks a bunch
2023-01-05 14:07:59 +0100CiaoSen(~Jura@p200300c9572e35002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-01-05 14:08:52 +0100 <eldritchcookie[4> yes merijin
2023-01-05 14:09:32 +0100 <merijn> eldritchcookie[4: Pretty sure (but haven't check) that you can always use non-unicode syntax, it's just unicode syntax that needs an opt in, but should be trivial to check
2023-01-05 14:09:47 +0100gaff(~gaff@49.207.203.30) ()
2023-01-05 14:10:01 +0100 <boxscape_> > let f :: a → a -> a; f a b = b in f 1 2
2023-01-05 14:10:03 +0100 <lambdabot> 2
2023-01-05 14:10:05 +0100 <boxscape_> works
2023-01-05 14:15:05 +0100 <boxscape_> if anyone happens to have a concrete example where they were annoyed about how monadic Haskell code was more verbose than code in an imperative language would be, hit me up
2023-01-05 14:16:51 +0100sylvo_(~sylvo@2001:8004:5170:2af5:830a:1332:d7d4:ebde) (Quit: Leaving)
2023-01-05 14:16:51 +0100 <eldritchcookie[4> i find that hard i was only annoyed by verbosity only once and it was with haskell gi-gtk but have you seen the c code equivalent?
2023-01-05 14:17:22 +0100 <boxscape_> hm I have not
2023-01-05 14:18:22 +0100 <eldritchcookie[4> just calling one function is like 10 lines
2023-01-05 14:18:43 +0100 <boxscape_> I see :/
2023-01-05 14:18:45 +0100 <merijn> eldritchcookie[4: pretty sure that's indeed a gtk problem :p
2023-01-05 14:19:11 +0100 <boxscape_> low-level bindings in general *are* probably something where Haskell code using them is unusually verbose
2023-01-05 14:19:59 +0100 <merijn> but you can usually build higher level abstractions fairly easily
2023-01-05 14:20:02 +0100 <boxscape_> right
2023-01-05 14:21:23 +0100 <Inst> text based browsers aren't a hard project, right?
2023-01-05 14:21:32 +0100 <eldritchcookie[4> i have to say i had difficulty making higher level bindings to gi-gtk and given that the one higher level binding is still only for gtk 3 instead of gtk 4 i assume other people think the same
2023-01-05 14:21:35 +0100 <Inst> actually, forget it
2023-01-05 14:21:52 +0100 <merijn> Inst: Famous last words xD
2023-01-05 14:22:16 +0100 <geekosaur> you had be when you said "browser"
2023-01-05 14:22:21 +0100 <geekosaur> *me
2023-01-05 14:22:41 +0100 <Inst> i'm currently trying to write a shitty Haskell book inspired by The C Programming Language
2023-01-05 14:22:45 +0100 <Inst> I introduce IO first, then traverse
2023-01-05 14:23:14 +0100 <Inst> it goes way further, because most of the text is just commented code
2023-01-05 14:23:43 +0100 <boxscape_> eldritchcookie[4 I know nothing about it but have you seen https://github.com/owickstrom/gi-gtk-declarative ?
2023-01-05 14:23:44 +0100razetime(~Thunderbi@49.207.222.244)
2023-01-05 14:24:19 +0100Profpatsch(~Profpatsc@static.88-198-193-255.clients.your-server.de) (Quit: WeeChat 3.7.1)
2023-01-05 14:24:24 +0100 <Inst> it works because for the first 3 sections, it's refactoring of the same program multiple times
2023-01-05 14:24:30 +0100 <Inst> under different idioms, with different concepts
2023-01-05 14:25:06 +0100 <Inst> for the 4th section, it's trying to TyDD a journal keeper, then add encryption
2023-01-05 14:25:52 +0100 <Inst> will want to illustrate typeclasses via a pretty printer, or at least that's what I'm told, and once that's done, teach MTL
2023-01-05 14:25:57 +0100 <Inst> via perhaps a browser
2023-01-05 14:26:17 +0100ub(~Thunderbi@p548c9ce5.dip0.t-ipconnect.de)
2023-01-05 14:26:55 +0100 <geekosaur> a very simple browser that probably won't be able to render real websites is easy-ish
2023-01-05 14:27:02 +0100 <merijn> or run the JS :p
2023-01-05 14:27:16 +0100 <geekosaur> real sites have javascri[t and an incomprehensible mess trying to pass itself off as htkml
2023-01-05 14:27:27 +0100 <merijn> Inst: That doesn't sound like you need a browser?
2023-01-05 14:27:34 +0100 <merijn> That sounds like you just want a terminal UI
2023-01-05 14:27:55 +0100 <Inst> i sort of want an excuse to introduce FTP
2023-01-05 14:28:03 +0100 <Inst> bleh, thanks for humoring me, I probably won't finish this project either
2023-01-05 14:28:27 +0100 <Inst> erm, not FTP, but HTTP requests via library
2023-01-05 14:30:06 +0100 <Inst> (and yes, this is all in the first chapter. Trying to remedy the "we have no idea how to do effects in haskell!" problem)
2023-01-05 14:33:12 +0100 <boxscape_> hmm I don't know if it's a good idea but have you considered going with a more modern effect-handling library than mtl
2023-01-05 14:33:53 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 14:34:03 +0100troydm(~troydm@user/troydm) (Ping timeout: 260 seconds)
2023-01-05 14:34:07 +0100 <merijn> I'm not sure there's any effect-handling library I'd recommend :p
2023-01-05 14:34:33 +0100xff0x(~xff0x@p3326132-ipngn2103sapodori.hokkaido.ocn.ne.jp) (Ping timeout: 268 seconds)
2023-01-05 14:34:42 +0100v0id_ptr(~adrift@user/ptr-frac7al/x-0038398) (Ping timeout: 272 seconds)
2023-01-05 14:35:11 +0100 <boxscape_> that's fair. I recently tried out fused-effects because of its low dependency footprint and found it fairly nice to use
2023-01-05 14:35:34 +0100fizbin(~fizbin@user/fizbin) (Ping timeout: 260 seconds)
2023-01-05 14:35:48 +0100king_gs(~Thunderbi@2806:103e:29:45ac:af0:afaf:29e7:dd60) (Ping timeout: 260 seconds)
2023-01-05 14:36:11 +0100mei(~mei@user/mei) (Quit: mei)
2023-01-05 14:38:57 +0100 <boxscape_> especially because I have differently type Writers that become active at different points, which I think would be quite a bit harder to achieve with mtl
2023-01-05 14:41:04 +0100 <merijn> mtl classes are bad anyway
2023-01-05 14:41:28 +0100 <merijn> Main use for it is "slightly reduced boilerplate over using transformers directly"
2023-01-05 14:42:13 +0100 <Inst> also, question, are there any texts on how to design a custom effects system over IO?
2023-01-05 14:42:15 +0100 <boxscape_> isn't the main idea that you can put in different implementations for testing and production? Or is that what you're referring to?
2023-01-05 14:42:27 +0100 <Inst> monad trans is over any monad, but here I just want a monad transformer over IO only
2023-01-05 14:42:52 +0100 <Inst> so i can, somehow, limit the ability to do disk writs, network access, etc
2023-01-05 14:44:01 +0100 <geekosaur> sounds like you want RIO
2023-01-05 14:44:03 +0100 <merijn> boxscape_: the mtl-style classes idea is good. But the actual mtl classes are bad in that they're overly generic which means they're bad in external APIs
2023-01-05 14:44:19 +0100 <boxscape_> ah, I see
2023-01-05 14:44:40 +0100 <merijn> since you can only have one Writer/Reader/State/whatever
2023-01-05 14:44:44 +0100 <boxscape_> right
2023-01-05 14:45:19 +0100 <merijn> So exposing the actual classes is bad, meaning the main use is using the classes inside your own code to avoid tedious lifting and exposing some custom class that's more tightly scoped
2023-01-05 14:48:01 +0100crazazy(~user@130.89.171.62)
2023-01-05 14:48:02 +0100mei(~mei@user/mei)
2023-01-05 14:48:05 +0100 <Inst> looking up RIO now, thanks
2023-01-05 14:48:41 +0100 <Inst> also, why isn't default overloaded, or at least modified so it works for all 3 classes of literals (list, string, number)?
2023-01-05 14:48:53 +0100 <boxscape_> geekosaur Inst isn't RIO kind of the opposite though? I.e. the explicitly don't limit what you can do, you're always in Reader + IO
2023-01-05 14:49:17 +0100 <Inst> i was thinking it was that way, i.e, ReaderT pattern
2023-01-05 14:49:29 +0100 <geekosaur> think you may have the wrong RIO in mind, it's not Reader, it's a restricted IO context
2023-01-05 14:49:36 +0100 <boxscape_> oh
2023-01-05 14:49:47 +0100 <boxscape_> I was thinking of https://hackage.haskell.org/package/rio
2023-01-05 14:50:06 +0100 <geekosaur> no, I think this is part of MonadBaseControl and friends
2023-01-05 14:50:11 +0100 <boxscape_> I see
2023-01-05 14:51:00 +0100 <geekosaur> and the RIP level controls what I/O higher levels of the stack are allowed to perform
2023-01-05 14:51:03 +0100 <Inst> hmmm
2023-01-05 14:51:04 +0100 <Inst> https://www.reddit.com/r/haskell/comments/hqdjem/can_you_restrict_the_range_of_side_effects_that/
2023-01-05 14:51:05 +0100 <geekosaur> *RIO
2023-01-05 14:51:45 +0100 <boxscape_> Inst: with something like fused-effects you would define a Network effect and then an IO Carrier for that effect, not sure how exactly that would be done with mtl though
2023-01-05 14:52:37 +0100 <Inst> effect systems are almost ready, or at least, no longer purely alpha, since, and honestly I don't fully understand it, lexilambda / alexisking fixed the performance problem by enabling first-class support for delimited continuation-based effects
2023-01-05 14:53:31 +0100cods(~fred@82-65-232-44.subs.proxad.net) (Ping timeout: 265 seconds)
2023-01-05 14:53:44 +0100cods(~fred@82-65-232-44.subs.proxad.net)
2023-01-05 14:53:46 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-01-05 14:55:48 +0100cheater_(~Username@user/cheater)
2023-01-05 14:58:40 +0100cheater(~Username@user/cheater) (Ping timeout: 260 seconds)
2023-01-05 14:58:43 +0100cheater_cheater
2023-01-05 15:00:14 +0100Kuttenbrunzer(~Kuttenbru@2a02:8108:8b80:1d48::c0f7)
2023-01-05 15:04:37 +0100festive_kurbus(~festive_k@user/kurbus)
2023-01-05 15:05:11 +0100acidjnk(~acidjnk@p200300d6e7137a34b1a3218fa39d995d.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2023-01-05 15:06:04 +0100acidjnk(~acidjnk@p200300d6e7137a8505fc654aa94777dc.dip0.t-ipconnect.de)
2023-01-05 15:11:33 +0100jakalx(~jakalx@base.jakalx.net) ()
2023-01-05 15:12:38 +0100fizbin(~fizbin@user/fizbin)
2023-01-05 15:17:35 +0100thegeekinside(~thegeekin@189.217.82.244)
2023-01-05 15:18:42 +0100festive_kurbus(~festive_k@user/kurbus) (Quit: Client closed)
2023-01-05 15:23:09 +0100jakalx(~jakalx@base.jakalx.net)
2023-01-05 15:27:38 +0100ystael(~ystael@user/ystael)
2023-01-05 15:28:10 +0100 <Guest5476> Current del.conts inplementation isn't fast and ofc it can be slower, that freemonads if you use continuations too much. The most benefit you will get of them of you will use stack capture rarely. Basically, they are needed only for a complex effects like NonDet/Coroutine, all other stuff should be implemented as "ReaderT Handlers IO" to be fast (like in "cleff"/"effectful").
2023-01-05 15:29:35 +0100 <Guest5476> You can read about why it is not fast here: https://gitlab.haskell.org/ghc/ghc/-/merge_requests/7942
2023-01-05 15:33:27 +0100gensyst(gensyst@user/gensyst) (Quit: Leaving)
2023-01-05 15:37:30 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 265 seconds)
2023-01-05 15:37:44 +0100 <boxscape_> oh, hadn't heard about cleff yet
2023-01-05 15:39:07 +0100beefbambi(~beefbambi@2401:4900:230d:f57c:538c:d7cc:50c0:e377) (Read error: Connection reset by peer)
2023-01-05 15:40:40 +0100cheater_(~Username@user/cheater)
2023-01-05 15:41:40 +0100beefbambi(~beefbambi@183.82.26.190)
2023-01-05 15:43:27 +0100cheater(~Username@user/cheater) (Ping timeout: 260 seconds)
2023-01-05 15:43:35 +0100cheater_cheater
2023-01-05 15:46:15 +0100jinsun(~jinsun@user/jinsun)
2023-01-05 15:48:36 +0100pie_(~pie_bnc@user/pie/x-2818909) ()
2023-01-05 15:51:18 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-01-05 15:51:19 +0100beefbambi(~beefbambi@183.82.26.190) (Read error: Connection reset by peer)
2023-01-05 15:51:34 +0100beefbambi(~beefbambi@2401:4900:230d:f57c:538c:d7cc:50c0:e377)
2023-01-05 15:51:50 +0100king_gs(~Thunderbi@187.201.110.169)
2023-01-05 15:52:00 +0100beefbambi(~beefbambi@2401:4900:230d:f57c:538c:d7cc:50c0:e377) (Read error: Connection reset by peer)
2023-01-05 15:52:04 +0100pie_(~pie_bnc@user/pie/x-2818909)
2023-01-05 15:52:15 +0100pie_(~pie_bnc@user/pie/x-2818909) (Client Quit)
2023-01-05 15:52:19 +0100beefbambi(~beefbambi@183.82.26.190)
2023-01-05 15:52:54 +0100cheater_(~Username@user/cheater)
2023-01-05 15:53:01 +0100jinsun(~jinsun@user/jinsun) (Read error: Connection reset by peer)
2023-01-05 15:53:05 +0100festive_kurbus(~festive_k@user/kurbus)
2023-01-05 15:53:16 +0100jinsun(~jinsun@user/jinsun)
2023-01-05 15:56:20 +0100cheater(~Username@user/cheater) (Ping timeout: 255 seconds)
2023-01-05 15:56:31 +0100cheater_cheater
2023-01-05 15:57:58 +0100Lycurgus(~juan@user/Lycurgus)
2023-01-05 16:00:50 +0100beefbambi(~beefbambi@183.82.26.190) (Ping timeout: 246 seconds)
2023-01-05 16:01:12 +0100beefbambi(~beefbambi@2401:4900:230d:f57c:538c:d7cc:50c0:e377)
2023-01-05 16:03:47 +0100mestre(~mestre@191.177.185.178) (Quit: Lost terminal)
2023-01-05 16:06:27 +0100pie_(~pie_bnc@user/pie/x-2818909)
2023-01-05 16:09:29 +0100mikoto-chan(~mikoto-ch@85-76-38-223-nat.elisa-mobile.fi)
2023-01-05 16:11:09 +0100 <Inst> thinking, quickly, are there HOF useful for IO code?
2023-01-05 16:11:16 +0100 <Inst> well, i mean, there's traverse
2023-01-05 16:11:27 +0100 <Rembane> Yes!
2023-01-05 16:11:30 +0100igghibu(~igghibu@91.193.5.10)
2023-01-05 16:12:24 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-01-05 16:12:39 +0100 <Inst> one of the formulations i have that are probably wrong right now
2023-01-05 16:12:46 +0100 <Inst> functional programming is for manipulating data
2023-01-05 16:12:51 +0100 <Inst> transforming data, etc
2023-01-05 16:13:17 +0100 <Rembane> Or creating a series of instructions that are then executed.
2023-01-05 16:13:19 +0100 <Inst> imperative programming is for control flow, i.e, getting data from the outside world and pushing data into the outside world
2023-01-05 16:13:27 +0100 <Inst> yup, which is the essence of the IO monad, no, Rembane?
2023-01-05 16:13:38 +0100 <Rembane> Inst: Indeed
2023-01-05 16:13:50 +0100festive_kurbus(~festive_k@user/kurbus) (Quit: Client closed)
2023-01-05 16:13:53 +0100MajorBiscuit(~MajorBisc@83.22.42.172.ipv4.supernova.orange.pl)
2023-01-05 16:14:02 +0100 <Inst> but does it have to be that way? I.e, are there more aggressive transformations I can do to create IO actions with FP?
2023-01-05 16:15:15 +0100 <Rembane> You can usually move many things away from the IO-monad and have them evaluated in pure functions, but that usually means that your programs get more of a batch-feeling.
2023-01-05 16:15:21 +0100 <Rembane> *batch-processing-feeling
2023-01-05 16:16:42 +0100 <Inst> is that a bad thing?
2023-01-05 16:18:25 +0100 <Rembane> Not really IMO.
2023-01-05 16:18:56 +0100 <Inst> and afaik FRP, I don't really understand it, but FRP should be able to combine IO code together elegantly
2023-01-05 16:18:58 +0100 <Rembane> But that means that when you make a monad transformer stack, you put Identity at the bottom instead of IO and you need a bit more code to handle that.
2023-01-05 16:19:23 +0100mikoto-chan(~mikoto-ch@85-76-38-223-nat.elisa-mobile.fi) (Ping timeout: 268 seconds)
2023-01-05 16:19:45 +0100 <Inst> well monads / monad transformers aren't pure by some definition of pure
2023-01-05 16:19:49 +0100 <Rembane> I haven't understood how FRP works, so someone else here can probably talk more about that.
2023-01-05 16:19:55 +0100 <Rembane> Which definition?
2023-01-05 16:20:19 +0100 <Inst> if monads are considered to have the property of defining some effect, code working within monads are all impure
2023-01-05 16:20:36 +0100 <Inst> of course, by other definitions, even IO is pure
2023-01-05 16:20:41 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 16:20:44 +0100 <Inst> since it just creates a script, as opposed to actually being a script
2023-01-05 16:21:33 +0100 <Rembane> I'm of the opinion that IO isn't pure regardless of where it shows up, while the other monads are pure.
2023-01-05 16:23:35 +0100king_gs(~Thunderbi@187.201.110.169) (Ping timeout: 246 seconds)
2023-01-05 16:23:55 +0100 <c_wraith> I'm of the opinion that IO isn't green, too.
2023-01-05 16:24:42 +0100 <Rembane> It's a sweet moon though
2023-01-05 16:24:52 +0100 <c_wraith> purity is a property of functions. IO values aren't functions
2023-01-05 16:25:14 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-05 16:25:54 +0100 <Guest5476> @type IO
2023-01-05 16:25:55 +0100 <lambdabot> error: Data constructor not in scope: IO
2023-01-05 16:26:20 +0100 <Guest5476> sadly :(
2023-01-05 16:26:21 +0100 <boxscape_> %:kind IO
2023-01-05 16:26:24 +0100 <boxscape_> % :kind IO
2023-01-05 16:26:24 +0100 <yahb2> IO :: * -> *
2023-01-05 16:26:38 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9552:b93e:dc75:3765)
2023-01-05 16:26:40 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:fabd:1d4c:3d9a:76e1) (Quit: WeeChat 2.8)
2023-01-05 16:27:21 +0100 <mauke> IO is pure because it always returns the same type for the same argument
2023-01-05 16:27:26 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-01-05 16:27:37 +0100 <boxscape_> good point
2023-01-05 16:27:44 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-01-05 16:27:48 +0100 <merijn> Rembane: Your opinion is objectively wrong, so there's that
2023-01-05 16:27:52 +0100 <merijn> :p
2023-01-05 16:27:59 +0100 <c_wraith> you mean functions that return IO values always return the same IO value for given arguments?
2023-01-05 16:28:04 +0100 <Rembane> merijn: That IO is a sweet moon or the other one? :)
2023-01-05 16:28:10 +0100 <Guest5476> Ok, answer to the "@type IO" should be something like "(State# RealWorld# -> (# a, State# RealWorld# #)) -> IO a"
2023-01-05 16:28:10 +0100Sgeo(~Sgeo@user/sgeo)
2023-01-05 16:28:12 +0100 <boxscape_> c_wraith no the type constructor is pure
2023-01-05 16:28:12 +0100 <c_wraith> Functions and IO are just different things.
2023-01-05 16:28:20 +0100 <c_wraith> boxscape_: ah, good point
2023-01-05 16:29:04 +0100 <mauke> @src IO
2023-01-05 16:29:04 +0100 <lambdabot> Source not found. And you call yourself a Rocket Scientist!
2023-01-05 16:29:04 +0100 <merijn> Guest5476: The constructor for IO is generally never in scope
2023-01-05 16:29:06 +0100 <c_wraith> Guest5476: that's sort of an answer to the wrong question. It's not what IO is, it's how one particular compiler chooses to represent it internally
2023-01-05 16:29:35 +0100 <Inst> have you met morrow, btw?
2023-01-05 16:30:22 +0100 <Inst> looking at state# realwolrd# -> (# a, state# realworld# #), I can't help but thing about some meme he posted about how ST, IO, STM, and a bunch of other thing have the same underlying representation
2023-01-05 16:30:31 +0100 <Guest5476> the definition of purity isn't clear for me. I prefer the term "referential transparency`, which is well defined
2023-01-05 16:30:55 +0100 <merijn> Inst: The implementation of IO and ST are both implemented using the same ST#, yeah
2023-01-05 16:30:59 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9552:b93e:dc75:3765) (Ping timeout: 255 seconds)
2023-01-05 16:31:24 +0100 <merijn> Inst: The (very readable) paper "Lazy Functional State Threads" covers that as well as the trick that makes ST safe
2023-01-05 16:31:59 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Ping timeout: 255 seconds)
2023-01-05 16:32:27 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net)
2023-01-05 16:33:47 +0100 <Inst> taken from morrow
2023-01-05 16:33:48 +0100 <Inst> https://cdn.discordapp.com/attachments/505367988166197268/1057249769745035314/image.png
2023-01-05 16:34:50 +0100 <Inst> https://www.microsoft.com/en-us/research/wp-content/uploads/1994/06/lazy-functional-state-threads.…
2023-01-05 16:36:18 +0100L29Ah(~L29Ah@wikipedia/L29Ah) ()
2023-01-05 16:36:27 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-01-05 16:37:54 +0100 <Guest5476> c_wraith: yes, but IO monad is not a source of impurity in ghc/haskell, the source are rts builtins and ffi functions. IO monad in fact makes them reference transparent by this hack with World -> (a, World). I.e. task of IO monad is to make impure actions reference transparent in the type interface layer.
2023-01-05 16:38:18 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 16:38:45 +0100 <Inst> so, curious, is IORef impure?
2023-01-05 16:38:53 +0100 <c_wraith> Guest5476: yes, but that's implementation. Semantics are totally different.
2023-01-05 16:39:00 +0100 <c_wraith> Inst: IORefs aren't functions
2023-01-05 16:39:11 +0100 <Inst> IORef are values
2023-01-05 16:39:19 +0100 <c_wraith> Is the number 5 pure?
2023-01-05 16:39:40 +0100 <Inst> is newIORef impure?
2023-01-05 16:39:46 +0100 <merijn> Inst: No
2023-01-05 16:39:51 +0100 <c_wraith> no, it returns the same IO value every time
2023-01-05 16:40:43 +0100 <merijn> Inst: Purity is a property of functions and IO (and it's effects) are not directly observable inside pure functions, so the fact that effects happen at runtime is irrelevant to purity
2023-01-05 16:41:01 +0100king_gs(~Thunderbi@187.201.110.169)
2023-01-05 16:41:16 +0100 <Inst> that's the "everything in Haskell is pure" argument
2023-01-05 16:41:30 +0100 <byorgey> Also, 'purity' is not an absolute concept, it depends on your frame of reference.
2023-01-05 16:41:36 +0100 <c_wraith> not everything in Haskell is pure. unsafePerformIO is very not pure.
2023-01-05 16:41:39 +0100 <Inst> ah, i see what you mean, the RTS is actually the element creating effects, so it's impure
2023-01-05 16:42:52 +0100 <oak-> <Rembane> "I haven't understood how FRP..." <- My recommendation is, take reflex-frp and start building something. The learning curve might be steep, but then suddenly there might be a moment of enlightenment
2023-01-05 16:43:53 +0100 <Inst> i was under the impression that reflex is basically arcana, and that newbies are better off with threepenny-gui?
2023-01-05 16:44:05 +0100mikoto-chan(~mikoto-ch@2001:999:784:1eb1:d8d9:bc17:d29e:4a68)
2023-01-05 16:44:26 +0100 <merijn> tbh, I think all the FRP frameworks are bad for understanding FRP
2023-01-05 16:44:36 +0100 <merijn> although there's also some confusion in the question of "how FRP works"
2023-01-05 16:44:52 +0100 <c_wraith> Notably, unsafePerformIO is a function. (Or at least its type claims it is. Mathematicians might disagree.) As such, the question "is this pure?" actually is answerable.
2023-01-05 16:44:55 +0100acidjnk(~acidjnk@p200300d6e7137a8505fc654aa94777dc.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-01-05 16:45:01 +0100 <merijn> FRP is an idea/model on how to describe semantics of something. The implementation is, mostly, irrelevant to that
2023-01-05 16:45:11 +0100 <Guest5476> Does reflex-frp better than reactive-banana? For example, if I want to use it with sdl2
2023-01-05 16:45:28 +0100elevenkb(~elevenkb@105.226.98.103) (Quit: Client closed)
2023-01-05 16:45:29 +0100 <merijn> I think it helps to understand FRP first before you worry about understanding the implementations people have made
2023-01-05 16:46:18 +0100 <Guest5476> all real-world frp implementations are very painful
2023-01-05 16:46:20 +0100 <merijn> Else you get these weird confusions like all the javascript "FRP" libraries that are really just "event loops" and have nothing remotely resembling FRP
2023-01-05 16:46:41 +0100 <merijn> Guest5476: Mostly, yes, because we haven't quite figured out how to make a nice *and* efficient implementation of the idea
2023-01-05 16:47:46 +0100 <Inst> what happened with Elm, anyways?
2023-01-05 16:48:10 +0100 <Inst> the language creator supposedly started as an FRP maker, then Elm did event handlers instead
2023-01-05 16:48:11 +0100 <geekosaur> apparently reflex-frp will become a lot nicer if Arrow is gutted and rewritten
2023-01-05 16:49:06 +0100 <Guest5476> elm uses TEA (The Elm Archtecture), which is simpler that FRP, but a little cringe
2023-01-05 16:49:16 +0100 <Guest5476> *than
2023-01-05 16:51:40 +0100razetime(~Thunderbi@49.207.222.244) (Ping timeout: 252 seconds)
2023-01-05 16:54:16 +0100cheater_(~Username@user/cheater)
2023-01-05 16:54:18 +0100 <Guest5476> I am one of "telegram-bot-simple" contributors and you can see TEA in that library. Basic idea is that you define input parser, that will return some Action (user-defined ADT) and handler, that will produce some action for each constructor of ADT. Handler can return new action and in this way you can create complex action sequences.
2023-01-05 16:54:55 +0100 <merijn> Right, but that's just an event loop and nothing remotely resembling FRP :p
2023-01-05 16:58:00 +0100 <Guest5476> Yes, and it's not as flexible as FRP and you need to write boilerplate to use it.
2023-01-05 16:58:13 +0100cheater(~Username@user/cheater) (Ping timeout: 265 seconds)
2023-01-05 16:58:23 +0100cheater_cheater
2023-01-05 16:59:00 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-05 17:00:05 +0100unclechu(~unclechu@2001:470:69fc:105::354) (Quit: You have been kicked for being idle)
2023-01-05 17:00:07 +0100king_gs(~Thunderbi@187.201.110.169) (Read error: Connection reset by peer)
2023-01-05 17:01:08 +0100random-jellyfish(~random-je@user/random-jellyfish)
2023-01-05 17:01:20 +0100king_gs(~Thunderbi@2806:103e:29:45ac:af0:afaf:29e7:dd60)
2023-01-05 17:07:21 +0100boxscape_(~boxscape_@213.52.37.155) (Quit: Client closed)
2023-01-05 17:07:53 +0100king_gs(~Thunderbi@2806:103e:29:45ac:af0:afaf:29e7:dd60) (Ping timeout: 265 seconds)
2023-01-05 17:11:37 +0100mikoto-chan(~mikoto-ch@2001:999:784:1eb1:d8d9:bc17:d29e:4a68) (Quit: WeeChat 3.6)
2023-01-05 17:18:10 +0100ddellacosta(~ddellacos@143.244.47.100)
2023-01-05 17:20:40 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.7.1)
2023-01-05 17:21:22 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9552:b93e:dc75:3765)
2023-01-05 17:24:50 +0100igghibu(~igghibu@91.193.5.10) (Quit: igghibu)
2023-01-05 17:25:05 +0100jumper149(~jumper149@base.felixspringer.xyz) (Quit: WeeChat 3.7.1)
2023-01-05 17:25:13 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 252 seconds)
2023-01-05 17:32:30 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-01-05 17:33:36 +0100tremon(~tremon@83-85-213-108.cable.dynamic.v4.ziggo.nl)
2023-01-05 17:35:08 +0100Luj3(~Luj@2a01:e0a:5f9:9681:b50a:fe5:ba94:4ae) (Quit: The Lounge - https://thelounge.chat)
2023-01-05 17:36:16 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9552:b93e:dc75:3765) (Remote host closed the connection)
2023-01-05 17:37:08 +0100Luj3(~Luj@2a01:e0a:5f9:9681:df7f:d915:e87b:faad)
2023-01-05 17:37:18 +0100 <Guest5476> @run [1.0, 3.0 .. 6.0]
2023-01-05 17:37:21 +0100 <lambdabot> [1.0,3.0,5.0,7.0]
2023-01-05 17:37:30 +0100mikoto-chan(~mikoto-ch@2001:999:584:6e91:67d8:6456:f9ef:4fd5)
2023-01-05 17:37:37 +0100 <Guest5476> @run [1, 3 .. 6]
2023-01-05 17:37:39 +0100 <lambdabot> [1,3,5]
2023-01-05 17:38:57 +0100 <Guest5476> "base" is broken at all, let's rename it into "cringe"
2023-01-05 17:39:05 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-05 17:41:02 +0100Nixkernal(~Nixkernal@2a02:1210:2e5f:d500:2909:4436:bf83:e030)
2023-01-05 17:41:06 +0100 <[exa]> > [1.0, 1.1 .. 2.1] -- <-- Guest5476
2023-01-05 17:41:06 +0100 <geekosaur> that, sadly, is specced by the Report. they give some justification or other for it
2023-01-05 17:41:08 +0100 <lambdabot> [1.0,1.1,1.2000000000000002,1.3000000000000003,1.4000000000000004,1.50000000...
2023-01-05 17:41:24 +0100 <[exa]> Guest5476: floats are broken, not base.
2023-01-05 17:41:57 +0100 <[exa]> (unfortunately the actual reason didn't display...)
2023-01-05 17:42:08 +0100 <[exa]> > [1.0, 1.1 .. 1.4]
2023-01-05 17:42:11 +0100 <lambdabot> [1.0,1.1,1.2000000000000002,1.3000000000000003,1.4000000000000004]
2023-01-05 17:42:14 +0100 <[exa]> here we go
2023-01-05 17:42:46 +0100festive_kurbus(~festive_k@user/kurbus)
2023-01-05 17:42:51 +0100 <[exa]> main takeaway: never use floats for anything that should be precise
2023-01-05 17:44:13 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9552:b93e:dc75:3765)
2023-01-05 17:45:04 +0100 <Guest5476> geekosaur: where is it in the Report? I don't see here nothing about floats: https://www.haskell.org/definition/haskell2010.pdf
2023-01-05 17:46:34 +0100slack1256(~slack1256@186.11.41.156)
2023-01-05 17:46:34 +0100troydm(~troydm@user/troydm)
2023-01-05 17:46:56 +0100 <int-e> Guest5476: look for the Enum class?
2023-01-05 17:47:15 +0100johnjaye(~pi@173.209.64.74) (Ping timeout: 256 seconds)
2023-01-05 17:47:41 +0100 <int-e> Guest5476: page 80, end of section 6.3.4
2023-01-05 17:47:44 +0100 <geekosaur> For Float and Double, the semantics of the enumFrom family is given by the rules for Int above, except that the list terminates when the elements become greater than e3 + i∕2 for positive increment i, or when they become less than e3 + i∕2 for negative i. https://www.haskell.org/onlinereport/haskell2010/haskellch6.html#x13-1270006.3
2023-01-05 17:49:13 +0100 <geekosaur> I guess it doesn't give the justification, but [exa] demonstrated it
2023-01-05 17:49:49 +0100 <[exa]> like, it might be better
2023-01-05 17:49:56 +0100 <int-e> > last $ [1, 1.1 .. 2.1]
2023-01-05 17:49:58 +0100 <lambdabot> 2.100000000000001
2023-01-05 17:50:13 +0100gaff(~gaff@49.207.203.30)
2023-01-05 17:50:42 +0100 <[exa]> but people would need to carefully compute the epsilons and epsilon accumulation, which brings in more dark magic for patching a use that's wrong in the first place
2023-01-05 17:50:50 +0100cheater(~Username@user/cheater) (Read error: Connection reset by peer)
2023-01-05 17:50:54 +0100 <Guest5476> ok, thanks for the explanation.
2023-01-05 17:51:20 +0100 <int-e> You could argue that the enum instance for floats is bogus. And the Num instance too... and the Eq instance... but at that point you'll make floats useless in Haskell.
2023-01-05 17:51:21 +0100 <[exa]> yw :] this surfaces quite often tbh, it's not intuitive at all at the first sight :D
2023-01-05 17:51:35 +0100cheater(~Username@user/cheater)
2023-01-05 17:52:24 +0100johnjaye(~pi@173.209.64.74)
2023-01-05 17:52:40 +0100 <eldritchcookie[4> is there something like template haskell but interactive?
2023-01-05 17:52:45 +0100 <int-e> > toEnum (fromEnum pi) :: Double
2023-01-05 17:52:47 +0100 <lambdabot> 3.0
2023-01-05 17:53:00 +0100 <int-e> toEnum . fromEnum is the identity, so pi is 3... ;-)
2023-01-05 17:53:30 +0100 <[exa]> eldritchcookie[4: I wish. :]
2023-01-05 17:53:31 +0100 <int-e> eldritchcookie[4: emacs?
2023-01-05 17:54:41 +0100 <int-e> (I'm not sure what kind of interaction you want here)
2023-01-05 17:55:56 +0100trev(~trev@user/trev)
2023-01-05 17:56:54 +0100phma(~phma@host-67-44-208-58.hnremote.net) (Read error: Connection reset by peer)
2023-01-05 17:58:11 +0100phma(phma@2001:5b0:2143:df48:fe85:bab7:d4d6:2e21)
2023-01-05 17:58:20 +0100 <eldritchcookie[4> you know that vim has commands like delete line or repeat last command? i wanted something similar but that operates on a AST and is aware of code information like a statement's type
2023-01-05 17:58:57 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-05 18:01:30 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9552:b93e:dc75:3765) (Remote host closed the connection)
2023-01-05 18:03:30 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9552:b93e:dc75:3765)
2023-01-05 18:03:34 +0100 <ddellacosta> eldritchcookie[4: maybe possible with HLS somehow, but no idea specifically what you'd need to get that working
2023-01-05 18:05:33 +0100 <Inst> curious, how powerful is implicit parameters?
2023-01-05 18:05:47 +0100 <Inst> i was asking a while back about being able to use hSpec etc to test into closures
2023-01-05 18:06:03 +0100 <Inst> implicit parameters isn't powerful enough to do that, right?
2023-01-05 18:06:43 +0100acidjnk(~acidjnk@p200300d6e7137a857c27d2eace8e6a0b.dip0.t-ipconnect.de)
2023-01-05 18:07:21 +0100 <eldritchcookie[4> about as powerful as the reader monad
2023-01-05 18:08:00 +0100Kuttenbrunzer(~Kuttenbru@2a02:8108:8b80:1d48::c0f7) (Quit: Where is it)
2023-01-05 18:09:18 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 18:10:29 +0100kee(~~kee@user/wizzwizz4) (Read error: Connection reset by peer)
2023-01-05 18:11:11 +0100kee(~~kee@user/wizzwizz4)
2023-01-05 18:13:36 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9552:b93e:dc75:3765) (Remote host closed the connection)
2023-01-05 18:14:05 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 268 seconds)
2023-01-05 18:14:10 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 252 seconds)
2023-01-05 18:14:13 +0100king_gs(~Thunderbi@187.201.110.169)
2023-01-05 18:16:04 +0100random-jellyfish(~random-je@user/random-jellyfish) (Quit: Client closed)
2023-01-05 18:16:22 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 272 seconds)
2023-01-05 18:17:37 +0100chele(~chele@user/chele) (Remote host closed the connection)
2023-01-05 18:20:20 +0100 <Inst> apparently tons of people hate implicit parameters because it screws with semantics in instancing
2023-01-05 18:20:48 +0100 <Inst> and my question a while back about default declarations for overloaded strings is that we actually do support that
2023-01-05 18:20:56 +0100 <Inst> we only don't support default declarations for overloadedlists
2023-01-05 18:24:18 +0100marinelli(~marinelli@gateway/tor-sasl/marinelli)
2023-01-05 18:24:34 +0100teo(~teo@user/teo) (Ping timeout: 268 seconds)
2023-01-05 18:26:43 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 18:27:01 +0100marinelli(~marinelli@gateway/tor-sasl/marinelli) (Client Quit)
2023-01-05 18:27:05 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-05 18:28:03 +0100freeside(~mengwong@103.252.202.159)
2023-01-05 18:28:16 +0100johnjaye(~pi@173.209.64.74) (Ping timeout: 268 seconds)
2023-01-05 18:31:04 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9552:b93e:dc75:3765)
2023-01-05 18:32:34 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340)
2023-01-05 18:33:02 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds)
2023-01-05 18:33:16 +0100jero98772(~jero98772@190.158.28.44)
2023-01-05 18:33:25 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-01-05 18:34:33 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-01-05 18:36:06 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2023-01-05 18:36:40 +0100johnjaye(~pi@173.209.64.74)
2023-01-05 18:41:59 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9552:b93e:dc75:3765) (Remote host closed the connection)
2023-01-05 18:43:30 +0100nschoe(~q@141.101.51.197) (Quit: Switching off)
2023-01-05 18:45:00 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 260 seconds)
2023-01-05 18:46:13 +0100sibnull[m](~sibnullma@2001:470:69fc:105::1:1291)
2023-01-05 18:49:20 +0100festive_kurbus(~festive_k@user/kurbus) (Quit: Client closed)
2023-01-05 18:49:40 +0100festive_kurbus(~festive_k@user/kurbus)
2023-01-05 18:49:49 +0100Luj3(~Luj@2a01:e0a:5f9:9681:df7f:d915:e87b:faad) (Quit: The Lounge - https://thelounge.chat)
2023-01-05 18:50:41 +0100Luj3(~Luj@2a01:e0a:5f9:9681:df7f:d915:e87b:faad)
2023-01-05 18:51:56 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) ()
2023-01-05 18:54:07 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 256 seconds)
2023-01-05 18:54:24 +0100caryhartline(~caryhartl@2600:1700:2d0:8d30:54e9:67d:a342:e67)
2023-01-05 19:00:58 +0100freeside(~mengwong@103.252.202.159)
2023-01-05 19:02:22 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-05 19:02:59 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-05 19:03:10 +0100 <eldritchcookie[4> how can i make a program like vim that can both be used graphically and from the terminal?
2023-01-05 19:05:43 +0100 <Guest5476> you have to provide two different interfaces, like haskell library with all logic and two executables: graphic one and brick tui one. Haskell library can be public, so anyone will have access to it
2023-01-05 19:05:50 +0100 <geekosaur> I don't know how you do this from Wayland but for X11 you can check for `"DISPLAY"` in the environment and switch to graphical mode
2023-01-05 19:06:21 +0100 <geekosaur> and yes, you have to include the logic for both, or use internal subbprograms one of which is text only and the other GUI
2023-01-05 19:06:39 +0100 <mauke> isn't vim the console version and gvim the graphical version?
2023-01-05 19:07:36 +0100 <geekosaur> vim is even trickier as it can use `"WINDOWID"` to detect it's running in a terminal emulator and switch on things like smart paste
2023-01-05 19:07:44 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 268 seconds)
2023-01-05 19:07:58 +0100crazazy`(~user@130.89.173.127)
2023-01-05 19:08:00 +0100 <geekosaur> and mouse awareness
2023-01-05 19:10:07 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-01-05 19:10:12 +0100crazazy(~user@130.89.171.62) (Ping timeout: 272 seconds)
2023-01-05 19:12:46 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2023-01-05 19:14:38 +0100king_gs(~Thunderbi@187.201.110.169) (Ping timeout: 272 seconds)
2023-01-05 19:15:46 +0100MajorBiscuit(~MajorBisc@83.22.42.172.ipv4.supernova.orange.pl) (Ping timeout: 268 seconds)
2023-01-05 19:17:42 +0100asivitz(uid178348@id-178348.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-05 19:21:01 +0100gaff(~gaff@49.207.203.30) (Remote host closed the connection)
2023-01-05 19:21:21 +0100king_gs(~Thunderbi@187.201.110.169)
2023-01-05 19:26:15 +0100thongpv(~thongpv87@2402:9d80:3ca:5321:90ac:c773:b44c:7ddf) (Ping timeout: 252 seconds)
2023-01-05 19:27:52 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-05 19:31:09 +0100crazazy``(~user@130.89.171.62)
2023-01-05 19:32:33 +0100mbuf(~Shakthi@49.204.130.110) (Quit: Leaving)
2023-01-05 19:33:11 +0100crazazy`(~user@130.89.173.127) (Ping timeout: 264 seconds)
2023-01-05 19:34:21 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Ping timeout: 256 seconds)
2023-01-05 19:37:57 +0100econo(uid147250@user/econo)
2023-01-05 19:40:04 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 260 seconds)
2023-01-05 19:41:00 +0100mikoto-chan(~mikoto-ch@2001:999:584:6e91:67d8:6456:f9ef:4fd5) (Ping timeout: 260 seconds)
2023-01-05 19:41:47 +0100mikoto-chan(~mikoto-ch@2001:999:600:eb36:4d7:2a51:6d5f:b1e5)
2023-01-05 19:42:10 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-05 19:43:55 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-05 19:49:58 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-05 19:52:07 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-05 19:52:34 +0100elevenkb(~elevenkb@105.226.98.103)
2023-01-05 19:55:16 +0100slac47838(~slack1256@186.11.41.156)
2023-01-05 19:57:32 +0100slack1256(~slack1256@186.11.41.156) (Ping timeout: 255 seconds)
2023-01-05 19:58:30 +0100slac47838(~slack1256@186.11.41.156) (Remote host closed the connection)
2023-01-05 19:59:31 +0100 <monochrom> My evil hypothetical solution is to just write for the graphics version then use mplayer's ascii-art driver for the "text" version >:D
2023-01-05 20:00:21 +0100king_gs(~Thunderbi@187.201.110.169) (Read error: Connection reset by peer)
2023-01-05 20:00:46 +0100 <monochrom> But otherwise yeah you are writing two applications, not one application that works both ways.
2023-01-05 20:01:22 +0100 <c_wraith> hopefully you can share most of the logic between them
2023-01-05 20:01:28 +0100 <c_wraith> ... hopefully
2023-01-05 20:01:51 +0100king_gs(~Thunderbi@2806:103e:29:45ac:af0:afaf:29e7:dd60)
2023-01-05 20:02:03 +0100 <monochrom> We know how abstraction boundaries become extremely leaky and messy in practice :)
2023-01-05 20:02:26 +0100 <geekosaur> with great care you can get it so much (but not all) of the event loop and the display logic are the differences
2023-01-05 20:02:53 +0100 <geekosaur> but there are tradeoffs there and it'll feel clunky in one or the other or even both
2023-01-05 20:03:59 +0100 <monochrom> Netscape and/or Mozilla devs spent a lot of effort over a long time figuring out their abstraction layers for decoupling from Windows vs X vs Mac etc.
2023-01-05 20:04:48 +0100 <monochrom> I mean, they were successful eventually, but it was not obvious at all and there were failures and lessons and trying again.
2023-01-05 20:05:47 +0100kenaryn(~aurele@89-88-44-27.abo.bbox.fr)
2023-01-05 20:06:13 +0100 <monochrom> OTOH given that everyone expected a web browser project to be a long-term project, it was worth the effort.
2023-01-05 20:08:06 +0100kenaryn(~aurele@89-88-44-27.abo.bbox.fr) (Client Quit)
2023-01-05 20:08:17 +0100 <monochrom> Whereas for a smaller or shorter-term project, you are not actually certain that one logic over two backends is really less effort than two logics, considering the effort in discovering where to even draw the boundaries.
2023-01-05 20:08:24 +0100kenaryn(~aurele@89-88-44-27.abo.bbox.fr)
2023-01-05 20:08:36 +0100kenaryn(~aurele@89-88-44-27.abo.bbox.fr) (Client Quit)
2023-01-05 20:11:00 +0100kenaryn(~aurele@89-88-44-27.abo.bbox.fr)
2023-01-05 20:11:33 +0100king_gs(~Thunderbi@2806:103e:29:45ac:af0:afaf:29e7:dd60) (Ping timeout: 265 seconds)
2023-01-05 20:12:46 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt)
2023-01-05 20:14:44 +0100 <monochrom> OK on second thought, use reactive functional programming or tangible values, then it is very clear cut. :D
2023-01-05 20:17:09 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-05 20:18:02 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 268 seconds)
2023-01-05 20:19:49 +0100king_gs(~Thunderbi@187.201.110.169)
2023-01-05 20:23:10 +0100festive_kurbus(~festive_k@user/kurbus) (Quit: Client closed)
2023-01-05 20:23:25 +0100mikoto-chan(~mikoto-ch@2001:999:600:eb36:4d7:2a51:6d5f:b1e5) (Ping timeout: 252 seconds)
2023-01-05 20:28:53 +0100nasrudin__(~nasrudin_@wsip-174-64-239-10.sd.sd.cox.net)
2023-01-05 20:29:30 +0100nasrudin__(~nasrudin_@wsip-174-64-239-10.sd.sd.cox.net) (Client Quit)
2023-01-05 20:30:18 +0100freeside(~mengwong@103.252.202.159)
2023-01-05 20:32:39 +0100king_gs(~Thunderbi@187.201.110.169) (Ping timeout: 255 seconds)
2023-01-05 20:34:25 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 252 seconds)
2023-01-05 20:36:29 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-01-05 20:40:56 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7) (Quit: Leaving)
2023-01-05 20:41:41 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-01-05 20:45:03 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 260 seconds)
2023-01-05 20:45:35 +0100festive_kurbus(~festive_k@user/kurbus)
2023-01-05 20:50:49 +0100 <[exa]> honestly, ssh ssh.chat >>>>> reactive web apps
2023-01-05 20:53:26 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-05 20:54:30 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Ping timeout: 260 seconds)
2023-01-05 20:56:11 +0100waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se)
2023-01-05 20:56:21 +0100MajorBiscuit(~MajorBisc@83.22.42.172.ipv4.supernova.orange.pl)
2023-01-05 21:03:45 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-05 21:04:07 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 252 seconds)
2023-01-05 21:05:23 +0100 <monochrom> Interesting. Heh.
2023-01-05 21:11:31 +0100paulpaul1076(~textual@95-29-5-111.broadband.corbina.ru) (Remote host closed the connection)
2023-01-05 21:11:41 +0100crazazy``(~user@130.89.171.62) (Ping timeout: 268 seconds)
2023-01-05 21:12:41 +0100crazazy``(~user@2001:67c:2564:331:99e0:8a41:5e7b:7545)
2023-01-05 21:13:50 +0100panovia(~user@user/siracusa)
2023-01-05 21:15:42 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6169:588f:5c00:bfd8)
2023-01-05 21:18:39 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Quit: ChaiTRex)
2023-01-05 21:19:07 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi)
2023-01-05 21:20:25 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-05 21:23:22 +0100 <[exa]> y we no brick apps over ssh
2023-01-05 21:25:22 +0100 <monochrom> I have a hunch that the kind of people who like ssh are also the kind of people who like line-wise interactions.
2023-01-05 21:27:19 +0100 <[exa]> more like, dislike https and CAs. :D
2023-01-05 21:31:55 +0100 <Inst> hmmm, wondering, is there an active discipline of declarative Haskell?
2023-01-05 21:33:59 +0100ralu1(~ralu@static.211.245.203.116.clients.your-server.de)
2023-01-05 21:36:30 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 272 seconds)
2023-01-05 21:36:40 +0100festive_kurbus(~festive_k@user/kurbus) (Quit: Client closed)
2023-01-05 21:37:59 +0100avicenzi(~avicenzi@2a00:ca8:a1f:b004::c32) (Ping timeout: 264 seconds)
2023-01-05 21:38:01 +0100beefbambi(~beefbambi@2401:4900:230d:f57c:538c:d7cc:50c0:e377) (Read error: Connection reset by peer)
2023-01-05 21:39:47 +0100beefbambi(~beefbambi@183.82.178.13)
2023-01-05 21:41:45 +0100beefbambi(~beefbambi@183.82.178.13) (Read error: Connection reset by peer)
2023-01-05 21:41:56 +0100beefbambi(~beefbambi@183.82.178.13)
2023-01-05 21:43:13 +0100 <[exa]> Inst: "discipline"?
2023-01-05 21:43:13 +0100beefbambi(~beefbambi@183.82.178.13) (Read error: Connection reset by peer)
2023-01-05 21:43:22 +0100beefbambi(~beefbambi@183.82.178.13)
2023-01-05 21:43:34 +0100 <Inst> one of my fascinations with Haskell is the ability to define arbitrary sentences as correct code
2023-01-05 21:43:44 +0100 <Inst> specify, then define, is sort of a Haskell superpower
2023-01-05 21:48:15 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6169:588f:5c00:bfd8) (Remote host closed the connection)
2023-01-05 21:48:18 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-01-05 21:49:19 +0100 <monochrom> In this case, discipline = area of research
2023-01-05 21:50:02 +0100 <monochrom> or perhaps area of study, or perhaps area of practice, area of work, etc.
2023-01-05 21:50:10 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-05 21:50:38 +0100 <monochrom> But I have my question that has been bothering me forever. But it's English, not Haskell. and : etc :: or : ???
2023-01-05 21:51:10 +0100beefbambi(~beefbambi@183.82.178.13) (Read error: Connection reset by peer)
2023-01-05 21:51:27 +0100beefbambi(~beefbambi@183.82.178.13)
2023-01-05 21:52:59 +0100 <mauke> yada yada yada
2023-01-05 21:53:12 +0100unit73e(~emanuel@2001:818:e8dd:7c00:656:e5ff:fe72:9d36)
2023-01-05 21:54:04 +0100 <darkling> Not sure I get the question.
2023-01-05 21:54:37 +0100 <mauke> what is to "or" as "etc" is to "and"?
2023-01-05 21:55:15 +0100 <darkling> I kind of got that, but it doesn't make sense. What kind of relationship between "etc" and "and" do you mean?
2023-01-05 21:55:22 +0100 <darkling> (Well, it doesn't make sense to me)
2023-01-05 21:55:51 +0100MajorBiscuit(~MajorBisc@83.22.42.172.ipv4.supernova.orange.pl) (Ping timeout: 260 seconds)
2023-01-05 21:55:57 +0100 <monochrom> etc is Latin for "and so on"
2023-01-05 21:56:16 +0100 <mauke> et cetera = "and [the] other/remaining [things]"
2023-01-05 21:57:15 +0100 <darkling> Yes, I know that too.
2023-01-05 21:57:20 +0100 <monochrom> Perhaps I'm pompous, because "or something" is an existing solution, just not in Latin. :)
2023-01-05 21:57:37 +0100 <geekosaur> I don't think "vel cetera" was a construct
2023-01-05 21:57:39 +0100MajorBiscuit(~MajorBisc@c-001-005-049.client.tudelft.eduvpn.nl)
2023-01-05 21:58:12 +0100 <darkling> If I wanted a disjunctive list by example, I think I'd probably write "A or B or ..."
2023-01-05 21:58:22 +0100 <darkling> (Literal ellipsis)
2023-01-05 21:58:27 +0100 <geekosaur> tbh I'd just abuse "etc." there
2023-01-05 21:58:34 +0100 <geekosaur> not like we're actually speaking Latin
2023-01-05 21:59:06 +0100 <darkling> Not sure that "A or B etc" or "A or B or etc" would sit well with me.
2023-01-05 21:59:08 +0100 <geekosaur> ("or etc.")
2023-01-05 21:59:10 +0100 <mauke> I'd just use "velc." Who's going to stop me?
2023-01-05 21:59:20 +0100 <darkling> mauke: Your copy editors. ;)
2023-01-05 21:59:29 +0100 <geekosaur> everyone who has no idea what you're on about 🙂
2023-01-05 21:59:33 +0100 <monochrom> vlc :)
2023-01-05 22:00:23 +0100 <mauke> pfft, anyone who had Latin in school should know what I mean
2023-01-05 22:01:00 +0100 <geekosaur> I am quite certain I was the only one in my school who learned any Latin, and I had to dig for someone to teach it to me
2023-01-05 22:01:42 +0100 <darkling> I had it for 3 years. The only reason I did the third year was because it was a choice between Latin and history, and history lost.
2023-01-05 22:01:50 +0100 <mauke> obviously you went to the wrong school. my first foreign language was Latin (followed by English two years later) :-)
2023-01-05 22:02:00 +0100 <geekosaur> (and ended up dropping it as I couldn't handle that, half day at CWRU, and getting ready for graduation all at the same time)
2023-01-05 22:02:26 +0100 <geekosaur> our only options at that level were Spanish and French, sadly
2023-01-05 22:02:27 +0100 <monochrom> I didn't have Latin in school, but I sought out Latin for "or" and found "vel" (and one other). I did this because in LaTeX I didn't know that \land and \lor existed, so I made my own \et = \wedge and \vel = \vee.
2023-01-05 22:03:57 +0100 <monochrom> Eh Spanish or French would be "close enough" >:D
2023-01-05 22:04:41 +0100 <mauke> I'd prefer Spanish *or* French
2023-01-05 22:04:44 +0100 <monochrom> I mean, which language does "Latin" America speak?! >:D
2023-01-05 22:05:19 +0100ralu1(~ralu@static.211.245.203.116.clients.your-server.de) (Remote host closed the connection)
2023-01-05 22:05:28 +0100 <geekosaur> IMy French is a bit rusty but I can still read it okay. Sadly I should probably have gone with Spanish, it'd have been more practically useful
2023-01-05 22:05:56 +0100 <monochrom> "I want to learn Haskell but my school only offers Purescript." "That will have to do." >:)
2023-01-05 22:06:16 +0100ralu1(~ralu@static.211.245.203.116.clients.your-server.de)
2023-01-05 22:06:24 +0100 <monochrom> Or maybe I mean Typescript. Whichever one is worse.
2023-01-05 22:06:53 +0100 <geekosaur> typescript is havascript with types. purescript is the one that tries to be haskell
2023-01-05 22:06:59 +0100 <mauke> which one was the one with malicious scoping? coffeescript?
2023-01-05 22:07:00 +0100 <geekosaur> *javascript
2023-01-05 22:08:29 +0100 <geekosaur> https://gist.github.com/showell/1512100 ?
2023-01-05 22:08:54 +0100 <ggVGc> confusing... there's a monokrome in #vim
2023-01-05 22:09:08 +0100 <geekosaur> anyway I thought it was lisp (and to some extent python) that had malicious scoping 😈
2023-01-05 22:09:29 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-01-05 22:10:32 +0100ralu1(~ralu@static.211.245.203.116.clients.your-server.de) (Remote host closed the connection)
2023-01-05 22:10:56 +0100 <mauke> python is merely broken. coffeescript is actively malicious
2023-01-05 22:11:21 +0100ralu1(~ralu@static.211.245.203.116.clients.your-server.de)
2023-01-05 22:11:23 +0100MajorBiscuit(~MajorBisc@c-001-005-049.client.tudelft.eduvpn.nl) (Ping timeout: 260 seconds)
2023-01-05 22:11:46 +0100 <mauke> heh, I like how the rules 1-6 are partial (in that they don't cover all possibilities)
2023-01-05 22:14:30 +0100beefbambi(~beefbambi@183.82.178.13) (Read error: Connection reset by peer)
2023-01-05 22:15:08 +0100beefbambi(~beefbambi@183.82.178.13)
2023-01-05 22:16:41 +0100kris7t(~kris7t@marussy.com)
2023-01-05 22:18:12 +0100MajorBiscuit(~MajorBisc@83.22.42.172.ipv4.supernova.orange.pl)
2023-01-05 22:19:31 +0100beefbambi(~beefbambi@183.82.178.13) (Ping timeout: 268 seconds)
2023-01-05 22:19:43 +0100beefbambi(~beefbambi@2401:4900:230d:f57c:538c:d7cc:50c0:e377)
2023-01-05 22:20:45 +0100iteratee(~kyle@162.218.222.107) (Read error: Connection reset by peer)
2023-01-05 22:21:16 +0100beefbambi(~beefbambi@2401:4900:230d:f57c:538c:d7cc:50c0:e377) (Read error: Connection reset by peer)
2023-01-05 22:25:23 +0100iteratee(~kyle@162.218.222.107)
2023-01-05 22:28:09 +0100zeenk(~zeenk@2a02:2f04:a110:ac00::7fe) (Quit: Konversation terminated!)
2023-01-05 22:28:16 +0100crazazy``(~user@2001:67c:2564:331:99e0:8a41:5e7b:7545) (Ping timeout: 252 seconds)
2023-01-05 22:28:29 +0100crazazy``(~user@130.89.171.62)
2023-01-05 22:30:00 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-05 22:30:49 +0100jakalx(~jakalx@base.jakalx.net) ()
2023-01-05 22:33:09 +0100 <unit73e> geekosaur, no contest. the javascript with types pisses me off more than javascript because it's just as poorly designed.
2023-01-05 22:33:36 +0100 <unit73e> optionals that can be undefined is enough for me
2023-01-05 22:34:46 +0100beefbambi(~beefbambi@183.82.178.13)
2023-01-05 22:35:17 +0100 <unit73e> fake haskell any day
2023-01-05 22:37:02 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 265 seconds)
2023-01-05 22:37:23 +0100jakalx(~jakalx@base.jakalx.net)
2023-01-05 22:48:45 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6169:588f:5c00:bfd8)
2023-01-05 22:49:37 +0100freeside(~mengwong@103.252.202.159)
2023-01-05 22:52:11 +0100Kaipei(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net) (Remote host closed the connection)
2023-01-05 22:52:35 +0100Kaipei(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net)
2023-01-05 22:54:40 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6169:588f:5c00:bfd8) (Ping timeout: 260 seconds)
2023-01-05 23:01:05 +0100Guest43(~Guest43@185-182-71-15.net.techloq.com)
2023-01-05 23:01:18 +0100 <Guest43> hi
2023-01-05 23:02:32 +0100 <geekosaur> hello
2023-01-05 23:03:00 +0100 <Guest43> what up
2023-01-05 23:03:27 +0100 <Jadesheit[m]> hello
2023-01-05 23:04:02 +0100 <Guest43> hi
2023-01-05 23:04:12 +0100 <Guest43> what do you enjoy
2023-01-05 23:05:02 +0100Guest43(~Guest43@185-182-71-15.net.techloq.com) (Quit: Client closed)
2023-01-05 23:05:16 +0100 <eldritchcookie[4> metaprogramming
2023-01-05 23:05:16 +0100 <monochrom> Don't answer to answer, just don't answer. :)
2023-01-05 23:09:43 +0100elevenkb(~elevenkb@105.226.98.103) (Ping timeout: 260 seconds)
2023-01-05 23:12:45 +0100Nixkernal(~Nixkernal@2a02:1210:2e5f:d500:2909:4436:bf83:e030) (Quit: Leaving)
2023-01-05 23:13:15 +0100wootehfoot(~wootehfoo@user/wootehfoot)
2023-01-05 23:13:27 +0100king_gs(~Thunderbi@187.201.110.169)
2023-01-05 23:19:00 +0100 <monochrom> Oh! I should try symlinking $HOME/.ghcup/tmp to /tmp :)
2023-01-05 23:22:18 +0100cheater_(~Username@user/cheater)
2023-01-05 23:24:37 +0100cheater_(~Username@user/cheater) (Read error: Connection reset by peer)
2023-01-05 23:24:58 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-01-05 23:25:19 +0100cheater_(~Username@user/cheater)
2023-01-05 23:25:26 +0100cheater(~Username@user/cheater) (Ping timeout: 272 seconds)
2023-01-05 23:25:35 +0100cheater_cheater
2023-01-05 23:26:45 +0100nut(~nut@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Ping timeout: 260 seconds)
2023-01-05 23:27:40 +0100MajorBiscuit(~MajorBisc@83.22.42.172.ipv4.supernova.orange.pl) (Ping timeout: 252 seconds)
2023-01-05 23:30:19 +0100waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se) (Quit: WeeChat 3.7.1)
2023-01-05 23:31:57 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340)
2023-01-05 23:32:46 +0100nut(~nut@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2023-01-05 23:32:47 +0100king_gs(~Thunderbi@187.201.110.169) (Read error: Connection reset by peer)
2023-01-05 23:32:54 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-05 23:34:17 +0100king_gs(~Thunderbi@2806:103e:29:45ac:af0:afaf:29e7:dd60)
2023-01-05 23:44:38 +0100MajorBiscuit(~MajorBisc@83.22.42.172.ipv4.supernova.orange.pl)
2023-01-05 23:48:07 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Read error: Connection reset by peer)
2023-01-05 23:48:30 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-01-05 23:50:52 +0100unit73e(~emanuel@2001:818:e8dd:7c00:656:e5ff:fe72:9d36) (Remote host closed the connection)
2023-01-05 23:54:16 +0100 <maerwald> monochrom: too many bug reports about users running out of space on a 2GB /tmp dir
2023-01-05 23:54:37 +0100ubert(~Thunderbi@p200300ecdf264e0ec4eebb70ae26d25f.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-01-05 23:54:37 +0100ububert
2023-01-05 23:54:41 +0100ubert1(~Thunderbi@p200300ecdf264e37a5f7a1f818911c73.dip0.t-ipconnect.de)
2023-01-05 23:55:32 +0100 <monochrom> Yeah I understand.
2023-01-05 23:56:23 +0100 <monochrom> But then I go on to run out of space on my home directory. (Or more honestly, since you know I'm doing it in /usr/local, my /usr/local directory.)
2023-01-05 23:58:03 +0100 <monochrom> In my case I have 3 partitions: /, /home, /usr/local. So if tmp and final destination are on different partitions, I am doing better. If they are on the same partition, I am doing worse.
2023-01-05 23:58:25 +0100 <monochrom> But I reckon that this is highly unusual.
2023-01-05 23:59:04 +0100MajorBiscuit(~MajorBisc@83.22.42.172.ipv4.supernova.orange.pl) (Ping timeout: 260 seconds)
2023-01-05 23:59:28 +0100 <maerwald> monochrom: I hope `ghcup nuke` does not misbehave when you do wild symlinks, but not following symlinks on destructive operations is the standard, so it should be fine