IRCBrowse

2023/01/07

2023-01-07 00:02:53 +0100Guest62(~Guest62@240f:a1:8a75:1:6d29:acad:cc8d:29c7)
2023-01-07 00:04:08 +0100Guest62(~Guest62@240f:a1:8a75:1:6d29:acad:cc8d:29c7) (Client Quit)
2023-01-07 00:05:30 +0100biberu(~biberu@user/biberu)
2023-01-07 00:05:34 +0100qy(~ix@2a02:8010:674f:0:d65d:64ff:fe52:5efe)
2023-01-07 00:11:16 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Quit: Lost terminal)
2023-01-07 00:13:17 +0100qy(~ix@2a02:8010:674f:0:d65d:64ff:fe52:5efe) (Quit: WeeChat 3.7.1)
2023-01-07 00:17:59 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 260 seconds)
2023-01-07 00:21:41 +0100den_jc(~lds@5.153.183.142) (Quit: Konversation terminated!)
2023-01-07 00:24:36 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-01-07 00:26:28 +0100Guest9971(~finn@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Ping timeout: 268 seconds)
2023-01-07 00:30:02 +0100freeside(~mengwong@103.252.202.159)
2023-01-07 00:30:03 +0100mncheck(~mncheck@193.224.205.254) (Ping timeout: 256 seconds)
2023-01-07 00:31:45 +0100farmfrmjakestate(~farmfrmja@user/farmfrmjakestate) (Ping timeout: 260 seconds)
2023-01-07 00:33:16 +0100 <Inst> well, the actual question was supposed to be, can IO be thought of as a form of metaprogramming?
2023-01-07 00:33:31 +0100 <Inst> I also saw an acquaintance's really weird looking IO code, I wouldn't go out and say it's bad
2023-01-07 00:33:40 +0100 <Inst> but it was incredibly clunky
2023-01-07 00:34:29 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 268 seconds)
2023-01-07 00:34:49 +0100 <Inst> https://ericnormand.me/podcast/is-haskell-the-best-procedural-language
2023-01-07 00:38:45 +0100acidjnk(~acidjnk@p54ad56b7.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2023-01-07 00:40:21 +0100mei(~mei@user/mei) (Remote host closed the connection)
2023-01-07 00:40:47 +0100mei(~mei@user/mei)
2023-01-07 00:41:39 +0100shriekingnoise(~shrieking@186.137.175.87) (Quit: Quit)
2023-01-07 00:42:58 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-01-07 00:46:29 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-01-07 00:49:09 +0100freeside(~mengwong@103.252.202.159)
2023-01-07 00:50:38 +0100Guest7253(~Guest72@240f:a1:8a75:1:6d29:acad:cc8d:29c7)
2023-01-07 00:53:18 +0100CoolMa7(~CoolMa7@2a02:8109:9d40:14ea:a80e:cf4d:c449:3c51) (Quit: Textual IRC Client: www.textualapp.com)
2023-01-07 00:54:19 +0100ddellacosta(~ddellacos@143.244.47.85)
2023-01-07 00:56:17 +0100Guest7253(~Guest72@240f:a1:8a75:1:6d29:acad:cc8d:29c7) (Quit: Client closed)
2023-01-07 00:56:53 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.7.1)
2023-01-07 01:02:01 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-01-07 01:03:08 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-07 01:07:46 +0100ix(~ix@2a02:8010:674f:0:d65d:64ff:fe52:5efe)
2023-01-07 01:07:50 +0100ix(~ix@2a02:8010:674f:0:d65d:64ff:fe52:5efe) (Client Quit)
2023-01-07 01:09:59 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67)
2023-01-07 01:10:35 +0100Guest72(~Guest72@240f:a1:8a75:1:6d29:acad:cc8d:29c7)
2023-01-07 01:10:50 +0100Guest72(~Guest72@240f:a1:8a75:1:6d29:acad:cc8d:29c7) (Client Quit)
2023-01-07 01:12:46 +0100justsomeguy(~justsomeg@user/justsomeguy)
2023-01-07 01:13:35 +0100xff0x(~xff0x@p3326132-ipngn2103sapodori.hokkaido.ocn.ne.jp)
2023-01-07 01:20:41 +0100titibandit1(~titibandi@xdsl-87-78-235-220.nc.de)
2023-01-07 01:21:56 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-01-07 01:27:24 +0100hyperbolic-dg(~quassel@i577AA562.versanet.de) (Quit: https://quassel-irc.org - Komfortabler Chat. Überall.)
2023-01-07 01:29:26 +0100johnjaye(~pi@173.209.64.74) (Ping timeout: 252 seconds)
2023-01-07 01:31:20 +0100johnjaye(~pi@173.209.64.74)
2023-01-07 01:31:23 +0100L29Ah(~L29Ah@wikipedia/L29Ah)
2023-01-07 01:36:32 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-01-07 01:36:32 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-01-07 01:36:32 +0100wroathe(~wroathe@user/wroathe)
2023-01-07 01:37:07 +0100titibandit1(~titibandi@xdsl-87-78-235-220.nc.de) (Remote host closed the connection)
2023-01-07 01:50:40 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 272 seconds)
2023-01-07 01:51:47 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) (Quit: Leaving.)
2023-01-07 02:00:22 +0100caryhartline(~caryhartl@107.140.218.181) (Quit: caryhartline)
2023-01-07 02:04:10 +0100freeside(~mengwong@103.252.202.159)
2023-01-07 02:04:34 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-01-07 02:06:08 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-07 02:07:08 +0100bontaq(~user@ool-45779fe5.dyn.optonline.net) (Ping timeout: 272 seconds)
2023-01-07 02:10:23 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-01-07 02:11:08 +0100fizbin(~fizbin@user/fizbin) (Ping timeout: 246 seconds)
2023-01-07 02:11:41 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-01-07 02:11:47 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:cc20:d690:f22b:cb00) (Remote host closed the connection)
2023-01-07 02:12:02 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 02:12:03 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:cc20:d690:f22b:cb00)
2023-01-07 02:14:35 +0100justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 264 seconds)
2023-01-07 02:16:30 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-01-07 02:19:04 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-07 02:27:55 +0100bilegeek(~bilegeek@2600:1008:b02b:c49d:317:e6bb:7c61:3a0a)
2023-01-07 02:29:56 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 252 seconds)
2023-01-07 02:31:46 +0100melonai(~mel@rnrd.eu)
2023-01-07 02:31:54 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-01-07 02:33:10 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-07 02:33:14 +0100mechap(~mechap@user/mechap) (Ping timeout: 246 seconds)
2023-01-07 02:35:16 +0100mechap(~mechap@user/mechap)
2023-01-07 02:38:22 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2023-01-07 02:38:55 +0100xff0x(~xff0x@p3326132-ipngn2103sapodori.hokkaido.ocn.ne.jp) (Ping timeout: 260 seconds)
2023-01-07 02:39:52 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-07 02:45:08 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 272 seconds)
2023-01-07 02:49:32 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 268 seconds)
2023-01-07 02:50:41 +0100razetime(~Thunderbi@49.207.222.244)
2023-01-07 02:55:09 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 02:55:54 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Ping timeout: 272 seconds)
2023-01-07 02:56:04 +0100 <Inst> is there any research on sequenceA_ + list based metaprogramming in Haskell?
2023-01-07 02:58:01 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-01-07 02:58:01 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-01-07 02:58:02 +0100wroathe(~wroathe@user/wroathe)
2023-01-07 03:01:13 +0100Neuromancer(~Neuromanc@user/neuromancer) (Quit: Going offline, see ya! (www.adiirc.com))
2023-01-07 03:08:25 +0100wroathe(~wroathe@user/wroathe) (Quit: leaving)
2023-01-07 03:15:29 +0100azimut_(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-01-07 03:20:55 +0100bilegeek(~bilegeek@2600:1008:b02b:c49d:317:e6bb:7c61:3a0a) (Ping timeout: 260 seconds)
2023-01-07 03:23:00 +0100bilegeek(~bilegeek@2600:1008:b02b:c49d:317:e6bb:7c61:3a0a)
2023-01-07 03:32:49 +0100son0p(~ff@2604:3d08:5b7f:5540:98a9:2169:15a1:4c7f)
2023-01-07 03:36:03 +0100tremon(~tremon@83-85-213-108.cable.dynamic.v4.ziggo.nl) (Quit: getting boxed in)
2023-01-07 03:37:05 +0100 <mauke> :t sequenceA_
2023-01-07 03:37:06 +0100 <lambdabot> (Foldable t, Applicative f) => t (f a) -> f ()
2023-01-07 03:41:19 +0100teddyc(theodorc@cassarossa.samfundet.no) (Ping timeout: 260 seconds)
2023-01-07 03:47:04 +0100ix(~ix@2a02:8010:674f:1:2641:8cff:fe93:cdb2)
2023-01-07 03:49:20 +0100boxscape_(~boxscape_@81.191.27.107)
2023-01-07 03:49:57 +0100 <boxscape_> oof. Usually you can write `withFrozenCallStack $ error $ "foo"`, but *not* `withFrozenCallStack . error $ "foo"`. (you'd get a type error).
2023-01-07 03:50:06 +0100 <boxscape_> but with impredicative types you *can* write it
2023-01-07 03:50:14 +0100 <boxscape_> But if you do, it doesn't actually freeze the callstack
2023-01-07 03:50:26 +0100 <boxscape_> took me a minute to figure out what happened there
2023-01-07 03:54:38 +0100ix(~ix@2a02:8010:674f:1:2641:8cff:fe93:cdb2) (Quit: WeeChat 3.7.1)
2023-01-07 03:56:15 +0100fizbin(~fizbin@user/fizbin)
2023-01-07 03:57:04 +0100ix(~ix@2a02:8010:674f:1:2641:8cff:fe93:cdb2)
2023-01-07 03:57:11 +0100ciarltb^(~ciarltb@76.145.190.81) (Remote host closed the connection)
2023-01-07 03:59:51 +0100AlexNoo(~AlexNoo@178.34.150.228) (Read error: Connection reset by peer)
2023-01-07 04:02:03 +0100AlexZenon(~alzenon@178.34.150.228) (Ping timeout: 252 seconds)
2023-01-07 04:02:05 +0100Alex_test(~al_test@178.34.150.228) (Ping timeout: 246 seconds)
2023-01-07 04:06:12 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 272 seconds)
2023-01-07 04:08:00 +0100ix(~ix@2a02:8010:674f:1:2641:8cff:fe93:cdb2) (Quit: WeeChat 3.7.1)
2023-01-07 04:10:38 +0100td_(~td@83.135.9.2) (Ping timeout: 272 seconds)
2023-01-07 04:11:17 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-01-07 04:12:00 +0100td_(~td@83.135.9.51)
2023-01-07 04:13:27 +0100v0id_ptr(~adrift@user/ptr-frac7al/x-0038398)
2023-01-07 04:13:54 +0100bilegeek(~bilegeek@2600:1008:b02b:c49d:317:e6bb:7c61:3a0a) (Quit: Leaving)
2023-01-07 04:22:29 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-01-07 04:24:09 +0100fizbin(~fizbin@user/fizbin) (Ping timeout: 260 seconds)
2023-01-07 04:31:39 +0100ix(~ix@2a02:8010:674f:1:2641:8cff:fe93:cdb2)
2023-01-07 04:33:33 +0100ix(~ix@2a02:8010:674f:1:2641:8cff:fe93:cdb2) (Client Quit)
2023-01-07 04:35:46 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 04:45:09 +0100ddellacosta(~ddellacos@143.244.47.85) (Ping timeout: 260 seconds)
2023-01-07 04:50:18 +0100AlexNoo(~AlexNoo@178.34.160.114)
2023-01-07 04:51:19 +0100Alex_test(~al_test@178.34.160.114)
2023-01-07 04:51:39 +0100ix(~ix@2a02:8010:674f:1:2641:8cff:fe93:cdb2)
2023-01-07 04:51:49 +0100AlexZenon(~alzenon@178.34.160.114)
2023-01-07 04:57:01 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Ping timeout: 252 seconds)
2023-01-07 04:59:37 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-01-07 04:59:37 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-01-07 04:59:37 +0100finn_elijaFinnElija
2023-01-07 05:03:21 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 268 seconds)
2023-01-07 05:08:54 +0100AlexNoo(~AlexNoo@178.34.160.114) (Read error: Connection reset by peer)
2023-01-07 05:12:34 +0100Alex_test(~al_test@178.34.160.114) (Ping timeout: 260 seconds)
2023-01-07 05:12:42 +0100AlexZenon(~alzenon@178.34.160.114) (Ping timeout: 272 seconds)
2023-01-07 05:15:52 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 272 seconds)
2023-01-07 05:23:03 +0100AlexNoo(~AlexNoo@178.34.160.38)
2023-01-07 05:23:50 +0100Alex_test(~al_test@178.34.160.38)
2023-01-07 05:24:41 +0100AlexZenon(~alzenon@178.34.160.38)
2023-01-07 05:26:10 +0100justsomeguy(~justsomeg@user/justsomeguy)
2023-01-07 05:27:21 +0100freeside(~mengwong@103.252.202.159)
2023-01-07 05:34:55 +0100ix(~ix@2a02:8010:674f:1:2641:8cff:fe93:cdb2) (Quit: WeeChat 3.7.1)
2023-01-07 05:38:18 +0100libertyprime(~libertypr@203.96.203.167)
2023-01-07 05:38:51 +0100AlexNoo(~AlexNoo@178.34.160.38) (Read error: Connection reset by peer)
2023-01-07 05:39:59 +0100razetime(~Thunderbi@49.207.222.244) (Remote host closed the connection)
2023-01-07 05:40:47 +0100Alex_test(~al_test@178.34.160.38) (Ping timeout: 246 seconds)
2023-01-07 05:42:35 +0100Kaipei(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net) (Ping timeout: 246 seconds)
2023-01-07 05:42:40 +0100AlexZenon(~alzenon@178.34.160.38) (Ping timeout: 252 seconds)
2023-01-07 05:49:44 +0100wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2023-01-07 05:55:06 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67) (Quit: Leaving)
2023-01-07 06:03:37 +0100rnat(uid73555@id-73555.lymington.irccloud.com)
2023-01-07 06:06:05 +0100ix(~ix@2a02:8010:674f:1:2641:8cff:fe93:cdb2)
2023-01-07 06:09:18 +0100FiorTheDog(~Srain@2601:640:8a00:584:8158:bce4:e149:ce4)
2023-01-07 06:10:10 +0100ix(~ix@2a02:8010:674f:1:2641:8cff:fe93:cdb2) (Client Quit)
2023-01-07 06:12:04 +0100FiorTheDog(~Srain@2601:640:8a00:584:8158:bce4:e149:ce4) (Leave.)
2023-01-07 06:24:53 +0100AlexNoo(~AlexNoo@178.34.160.164)
2023-01-07 06:26:03 +0100Alex_test(~al_test@178.34.160.164)
2023-01-07 06:29:27 +0100AlexZenon(~alzenon@178.34.160.164)
2023-01-07 06:31:14 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 272 seconds)
2023-01-07 06:38:09 +0100ix(~ix@2a02:8010:674f:1:2641:8cff:fe93:cdb2)
2023-01-07 06:43:11 +0100freeside(~mengwong@103.252.202.159)
2023-01-07 06:44:47 +0100ix(~ix@2a02:8010:674f:1:2641:8cff:fe93:cdb2) (Quit: WeeChat 3.7.1)
2023-01-07 06:48:20 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 272 seconds)
2023-01-07 06:56:06 +0100freeside(~mengwong@103.252.202.159)
2023-01-07 07:06:04 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) (Ping timeout: 268 seconds)
2023-01-07 07:13:53 +0100jinsun(~jinsun@user/jinsun) (Ping timeout: 255 seconds)
2023-01-07 07:14:27 +0100ix(~ix@2a02:8010:674f:0:d65d:64ff:fe52:5efe)
2023-01-07 07:16:24 +0100jinsun(~jinsun@user/jinsun)
2023-01-07 07:19:14 +0100ix(~ix@2a02:8010:674f:0:d65d:64ff:fe52:5efe) (Ping timeout: 252 seconds)
2023-01-07 07:19:38 +0100ix(~ix@2a02:8010:674f:0:d65d:64ff:fe52:5efe)
2023-01-07 07:20:54 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-07 07:21:58 +0100 <freeside> so, I'm lacking a word for a thing. If I have a 1 dimensional array I use Data.Vector. If I have a 2 dimensional array I use Data.Matrix. If I need to go to 3 or more dimensions, I need ...
2023-01-07 07:22:15 +0100 <freeside> i'm looking at https://github.com/achirkin/easytensor
2023-01-07 07:23:27 +0100 <boxscape_> you've found your answer then? Tensor is the word I'd use
2023-01-07 07:23:53 +0100 <freeside> ok, just making sure. There seem to be a bunch of libraries for tensors, is there a generally accepted choice?
2023-01-07 07:24:16 +0100 <boxscape_> I can't help you there but hopefully someone else can
2023-01-07 07:25:16 +0100 <freeside> thank you, grateful. I was two class instances deep into writing my own Collection k a when I was like, surely I do not need to reinvent this wheel.
2023-01-07 07:25:58 +0100 <freeside> i just want to fmap (+1) over an data structure of arbitrary dimension, is that too much for a girl to ask?
2023-01-07 07:26:31 +0100 <boxscape_> yeah that sounds like a reasonable request :D
2023-01-07 07:26:52 +0100razetime(~Thunderbi@49.207.222.244)
2023-01-07 07:28:52 +0100Ram-Z(~Ram-Z@li1814-254.members.linode.com) (Ping timeout: 272 seconds)
2023-01-07 07:32:35 +0100v0id_ptr(~adrift@user/ptr-frac7al/x-0038398) (Ping timeout: 268 seconds)
2023-01-07 07:35:57 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-01-07 07:42:41 +0100Ram-Z(~Ram-Z@li1814-254.members.linode.com)
2023-01-07 07:43:34 +0100abhixec(~abhinav@c-67-169-139-16.hsd1.ca.comcast.net)
2023-01-07 07:43:39 +0100Lycurgus(~juan@user/Lycurgus)
2023-01-07 07:46:55 +0100justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 260 seconds)
2023-01-07 07:47:50 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 246 seconds)
2023-01-07 07:49:21 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-01-07 07:54:03 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 07:54:56 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-01-07 07:56:00 +0100trev(~trev@user/trev)
2023-01-07 07:58:29 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 268 seconds)
2023-01-07 08:00:40 +0100echoreply(~echoreply@45.32.163.16) (Quit: WeeChat 2.8)
2023-01-07 08:07:23 +0100Xeroine(~Xeroine@user/xeroine) (Ping timeout: 264 seconds)
2023-01-07 08:09:30 +0100Xeroine(~Xeroine@user/xeroine)
2023-01-07 08:12:17 +0100rnat(uid73555@id-73555.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-07 08:12:48 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 08:14:38 +0100 <davean> freeside: you can also just make Vectors of Vectors.
2023-01-07 08:15:04 +0100 <davean> The rest is an inteface problem :-p
2023-01-07 08:16:02 +0100Guest9971(~finn@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2023-01-07 08:16:11 +0100 <davean> But yah, there are a bunch of half solutions
2023-01-07 08:17:26 +0100 <davean> Or over complicated ones for not really that goal
2023-01-07 08:17:29 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-07 08:17:32 +0100 <davean> its an area we could really improve on
2023-01-07 08:18:10 +0100 <freeside> mmm, i see
2023-01-07 08:20:07 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 08:20:31 +0100 <Logio> If you're not looking to do (multi)linear algebra, then you should look at arrays instead of tensors, IMO
2023-01-07 08:21:08 +0100 <davean> Like Repa is SUPER complicated
2023-01-07 08:21:22 +0100 <davean> (and focuses on parallelism)
2023-01-07 08:22:26 +0100 <freeside> okay. i'm basically trying to organize relatively simple tabular data, the way people use spreadsheets to do 80% of what SQL databases are used for
2023-01-07 08:23:24 +0100 <freeside> my first attempt was a Map k (Map j a) which is OK but when i realized i needed a transpose function i thought i'd shop around for wheels that had already been invented
2023-01-07 08:24:21 +0100 <Logio> if you wan't transposes, it's doesn't sound like simple tabular data?
2023-01-07 08:24:28 +0100 <freeside> i'd be ok with a Data.Matrix, I just need some overhead to maintain column/row header titles for ease of access
2023-01-07 08:24:40 +0100 <freeside> sometimes you need to add the columns, sometimes you need to add the rows, is all
2023-01-07 08:26:07 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Remote host closed the connection)
2023-01-07 08:26:29 +0100 <Logio> then something like easytensor is probably what you want
2023-01-07 08:26:51 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 08:27:00 +0100daveanhands Logio an OLAP Cube
2023-01-07 08:27:01 +0100caryhartline(~caryhartl@2600:1700:2d0:8d30:6884:b2dc:6ddb:78f2)
2023-01-07 08:29:00 +0100 <Logio> davean: first time I've heard of OLAP, I guess I should consider myself lucky for that
2023-01-07 08:29:56 +0100 <Logio> OTOH I've done quite a bit of work on hyperspectral datacubes (also implemented pretty much the equivalent of easytensor (or xarray in Python) for those in Matlab
2023-01-07 08:30:53 +0100 <Logio> compared to anything like those I'd say Repa is much less complicated :)
2023-01-07 08:32:43 +0100 <Logio> for the complicated cases you basically want an in-memory relational database
2023-01-07 08:36:00 +0100 <[Leary]> freeside: You might be interested in https://github.com/mixphix/deep-map
2023-01-07 08:36:12 +0100 <freeside> for my minilanguage, I'm instantiating my Exprs into Foldable, Ord, Eq, Semigroup, Num so as to be able to evaluate sentences like "given seven categories of net income, reduce net incomes, pro rata, of those categories which have positive net incomes, by the negative net incomes, leaving the previously negative net incomes at 0 after the reduction."
2023-01-07 08:36:43 +0100 <freeside> this stuff is terribly tedious and reduces to a bunch of filters and fmaps and sums and so on, i just need to lift those ideas into a DSL
2023-01-07 08:38:05 +0100 <freeside> in the columns, i have things like "income", "expenses", "extraordinary income", "extraordinary expenses", and then in the rows I have "due to employment" "due to rent" "due to agricultural activity" and so on
2023-01-07 08:38:51 +0100 <freeside> DeepMap looks very close to what I would want
2023-01-07 08:41:03 +0100 <freeside> i will extra-deps it into my stack.yaml
2023-01-07 08:43:37 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-01-07 08:43:40 +0100hrberg(~quassel@171.79-160-161.customer.lyse.net) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-01-07 08:43:57 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-01-07 08:44:14 +0100acidjnk(~acidjnk@p200300d6e715c42934bb1e2b0605c41b.dip0.t-ipconnect.de)
2023-01-07 08:45:28 +0100hrberg(~quassel@171.79-160-161.customer.lyse.net)
2023-01-07 08:45:40 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-07 08:52:19 +0100igghibu(~igghibu@178.249.211.75)
2023-01-07 08:55:02 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-01-07 08:56:22 +0100 <razetime> where can I learn more advanced concepts of haskell beyond basic tutorials?
2023-01-07 08:56:46 +0100 <razetime> i found only 3 links on the wiki here: https://wiki.haskell.org/Learning_Haskell#Advanced_tutorials
2023-01-07 08:58:36 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-01-07 09:01:30 +0100 <freeside> https://wiki.haskell.org/Learning_Haskell#Material_for_self-study says "If you want to dig deeper, see Books and tutorials.
2023-01-07 09:01:42 +0100 <freeside> you could look at If you want to dig deeper, see Books and tutorials.
2023-01-07 09:01:58 +0100 <freeside> sorry, i meant to paste If you want to dig deeper, see Books and tutorials.
2023-01-07 09:02:01 +0100 <freeside> asdfaser
2023-01-07 09:02:17 +0100 <freeside> my paste is borked, sorry. https://blog.ocharles.org.uk/pages/2014-12-01-24-days-of-ghc-extensions.html
2023-01-07 09:02:29 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-07 09:08:10 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-01-07 09:09:23 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:cc20:d690:f22b:cb00) (Remote host closed the connection)
2023-01-07 09:11:07 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-07 09:12:00 +0100 <freeside> https://aphyr.com/posts/342-typing-the-technical-interview
2023-01-07 09:14:36 +0100 <jackdk> razetime: http://jackkelly.name/wiki/haskell.html is my curated list
2023-01-07 09:21:19 +0100caryhartline(~caryhartl@2600:1700:2d0:8d30:6884:b2dc:6ddb:78f2) (Quit: caryhartline)
2023-01-07 09:26:36 +0100mei_(~mei@user/mei)
2023-01-07 09:28:42 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-01-07 09:29:16 +0100mei(~mei@user/mei) (Ping timeout: 252 seconds)
2023-01-07 09:29:20 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-01-07 09:32:26 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-07 09:36:49 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Ping timeout: 252 seconds)
2023-01-07 09:37:05 +0100moet(~moet@mobile-166-171-251-105.mycingular.net)
2023-01-07 09:38:20 +0100Guest9971(~finn@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Ping timeout: 255 seconds)
2023-01-07 09:38:38 +0100 <moet> Any idea where the Monoid constraint comes from in this applicative oneliner? https://paste.tomsmeding.com/3S0jgbym
2023-01-07 09:40:17 +0100Vajb(~Vajb@2001:999:405:5eb2:8d39:b832:a9ee:9bdf) (Read error: Connection reset by peer)
2023-01-07 09:40:34 +0100freemanX(~user@14.100.44.229)
2023-01-07 09:41:09 +0100Vajb(~Vajb@hag-jnsbng11-58c3a5-27.dhcp.inet.fi)
2023-01-07 09:41:56 +0100trev(~trev@user/trev) (Read error: Connection reset by peer)
2023-01-07 09:42:12 +0100trev(~trev@user/trev)
2023-01-07 09:42:38 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-07 09:42:54 +0100 <[Leary]> % :t pure @((,) _)
2023-01-07 09:42:54 +0100 <yahb2> pure @((,) _) :: Monoid w => a -> (w, a)
2023-01-07 09:43:12 +0100 <[Leary]> You can't write pure without it.
2023-01-07 09:44:47 +0100 <freeside> https://hackage.haskell.org/package/base-4.17.0.0/docs/src/GHC.Base.html#line-469
2023-01-07 09:45:49 +0100 <moet> Ah, its on the instance head. weird.
2023-01-07 09:46:09 +0100 <razetime> jackdk: thanks a lot
2023-01-07 09:46:21 +0100 <moet> `pure x = (mempty, x)`
2023-01-07 09:46:25 +0100 <moet> thanks [Leary] freeside
2023-01-07 09:48:50 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 09:49:31 +0100bilegeek(~bilegeek@103.sub-174-208-234.myvzw.com)
2023-01-07 09:51:29 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Ping timeout: 252 seconds)
2023-01-07 09:52:51 +0100Umeaboy(~Umeaboy@94-255-145-133.cust.bredband2.com)
2023-01-07 09:52:54 +0100 <Umeaboy> Hi!
2023-01-07 09:53:08 +0100 <boxscape_> hi
2023-01-07 09:53:41 +0100 <Umeaboy> Why is the README.md telling users to run build source-dist when it isn't working inside the hadrian folder?
2023-01-07 09:53:48 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 268 seconds)
2023-01-07 09:53:49 +0100 <Umeaboy> Is the documentation a bit outdated?
2023-01-07 09:54:11 +0100 <Umeaboy> I'm trying to get a grip of it so that I can build and port it to Mageia.
2023-01-07 09:54:34 +0100 <Umeaboy> I have completed the first stage.
2023-01-07 09:54:40 +0100Vajb(~Vajb@hag-jnsbng11-58c3a5-27.dhcp.inet.fi) (Read error: Connection reset by peer)
2023-01-07 09:54:40 +0100 <Umeaboy> That went fine.
2023-01-07 09:54:52 +0100 <boxscape_> you're talking about building ghc? You might get better answers in #ghc
2023-01-07 09:54:52 +0100 <Umeaboy> I'm reading what to do next.
2023-01-07 09:54:57 +0100 <Umeaboy> OK.
2023-01-07 09:54:59 +0100 <Umeaboy> Sorry.
2023-01-07 09:55:01 +0100 <Umeaboy> :)
2023-01-07 09:55:12 +0100 <boxscape_> no worries
2023-01-07 09:55:59 +0100 <boxscape_> (though this isn't the most active time of day for either channel)
2023-01-07 09:56:06 +0100sammelweis(~quassel@c-68-48-18-140.hsd1.mi.comcast.net)
2023-01-07 09:57:06 +0100notzmv(~zmv@user/notzmv)
2023-01-07 09:57:31 +0100Vajb(~Vajb@2001:999:405:5eb2:8d39:b832:a9ee:9bdf)
2023-01-07 09:59:26 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:cc20:d690:f22b:cb00)
2023-01-07 10:00:37 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-07 10:01:00 +0100trev(~trev@user/trev)
2023-01-07 10:07:43 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 10:10:42 +0100kee(~~kee@user/wizzwizz4) (Read error: Connection reset by peer)
2023-01-07 10:11:25 +0100kee(~~kee@user/wizzwizz4)
2023-01-07 10:17:41 +0100moet(~moet@mobile-166-171-251-105.mycingular.net) (Quit: leaving)
2023-01-07 10:18:58 +0100sammelweis(~quassel@c-68-48-18-140.hsd1.mi.comcast.net) (Quit: No Ping reply in 180 seconds.)
2023-01-07 10:20:15 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-07 10:20:31 +0100igghibu(~igghibu@178.249.211.75) (Quit: igghibu)
2023-01-07 10:22:04 +0100acidjnk(~acidjnk@p200300d6e715c42934bb1e2b0605c41b.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-01-07 10:27:18 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-01-07 10:27:33 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-07 10:28:15 +0100jakalx(~jakalx@base.jakalx.net) ()
2023-01-07 10:32:21 +0100vhs(~vhs@78-66-105-254-no600.tbcn.telia.com)
2023-01-07 10:32:26 +0100vhsconnect(~vhs@78-66-105-254-no600.tbcn.telia.com)
2023-01-07 10:34:27 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-07 10:37:10 +0100jakalx(~jakalx@base.jakalx.net)
2023-01-07 10:41:16 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 252 seconds)
2023-01-07 10:41:54 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-01-07 10:47:45 +0100sammelweis(~quassel@c-68-48-18-140.hsd1.mi.comcast.net)
2023-01-07 10:50:59 +0100sammelweis(~quassel@c-68-48-18-140.hsd1.mi.comcast.net) (Client Quit)
2023-01-07 10:52:03 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi)
2023-01-07 10:53:48 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-07 10:54:08 +0100trev(~trev@user/trev)
2023-01-07 10:59:01 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-07 10:59:21 +0100trev(~trev@user/trev)
2023-01-07 11:03:18 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-07 11:03:36 +0100trev(~trev@user/trev)
2023-01-07 11:04:41 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2023-01-07 11:05:31 +0100Speedbird(~Speedbird@94.230.79.152)
2023-01-07 11:06:17 +0100acidjnk(~acidjnk@p200300d6e715c429e462ed5ea333447e.dip0.t-ipconnect.de)
2023-01-07 11:09:15 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 248 seconds)
2023-01-07 11:12:23 +0100thongpv87(~thongpv87@2402:9d80:389:9e3a:648f:1ca5:2c13:2a3a) (Ping timeout: 255 seconds)
2023-01-07 11:12:31 +0100sammelweis(~quassel@c-68-48-18-140.hsd1.mi.comcast.net)
2023-01-07 11:19:18 +0100 <Inst> wait, is 2-tuple just an primitive writer monad in the same way that reader is based on the function monad?
2023-01-07 11:20:43 +0100 <boxscape_> exactly
2023-01-07 11:21:05 +0100bilegeek(~bilegeek@103.sub-174-208-234.myvzw.com) (Quit: Leaving)
2023-01-07 11:21:18 +0100 <Inst> huh, that's interesting, so effcetvily every time you output a tuple, you output a writer monad
2023-01-07 11:22:10 +0100 <boxscape_> I don't know if I would call it "outputting a writer monad" but that's basically correct
2023-01-07 11:24:26 +0100thongpv87(~thongpv87@2402:9d80:389:9e3a:2c87:afe4:cc1d:eda4)
2023-01-07 11:24:29 +0100 <Inst> i have a hate-on for monad trans
2023-01-07 11:24:52 +0100 <boxscape_> why?
2023-01-07 11:25:18 +0100 <Inst> performance, complexity
2023-01-07 11:25:36 +0100 <boxscape_> I see
2023-01-07 11:25:52 +0100 <[exa]> performance and complexity....as in, too good?
2023-01-07 11:25:53 +0100 <Inst> i'm wondering how valid it is to use writer monad via the tuple interface, although writer monad is known for space leaks, so the unadjusted tuple monad is likely to be worse
2023-01-07 11:26:22 +0100 <Inst> https://github.com/haskell-effectful/effectful/blob/master/benchmarks/README.md
2023-01-07 11:27:09 +0100 <Inst> but since you can skip the monad and just use the function monad and tuple monad instead of writer monad, that's a big improvement
2023-01-07 11:27:15 +0100 <Inst> writer monad and reader monad
2023-01-07 11:29:22 +0100 <[exa]> where's the source code for that benchmark?
2023-01-07 11:29:49 +0100Kaipei(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net)
2023-01-07 11:29:57 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-07 11:30:14 +0100trev(~trev@user/trev)
2023-01-07 11:30:23 +0100 <Inst> no clue, but lexi lambda was the same way, but her eff library i heard was abandoned
2023-01-07 11:30:43 +0100 <Inst> https://www.youtube.com/watch?v=0jI-AlWEwYI
2023-01-07 11:31:44 +0100 <[exa]> anyway yeah that's the result I'd basically expect, it's pretty much okay (modulo the capability of ghc to optimize out some type hay) but don't do deep monad stacks
2023-01-07 11:31:55 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:cc20:d690:f22b:cb00) (Remote host closed the connection)
2023-01-07 11:32:18 +0100 <boxscape_> hmm I'm using a fused-effects deep monad stack right now, maybe I should rethink that
2023-01-07 11:32:36 +0100 <[exa]> the point of transformers is that they're super powerful for relatively low code overhead (at least compared to the type magicks in eff and others)
2023-01-07 11:33:11 +0100 <Inst> kmett confessed to passing an IORef around with implicit parameters as a hack to get a cheaper RWST
2023-01-07 11:33:13 +0100 <Guest5476> Inst: her library is not compatiable with current list of delim.cont primops, so there should be performed some work to make it up to date
2023-01-07 11:33:24 +0100 <[exa]> I'd say if there's ever another hs compiler, transformers will be easily portable; not sure about eff
2023-01-07 11:34:29 +0100 <[exa]> I can't see why people consider the "passing IORef around" as cheating or hacking. it's a normal way to help the compiler to produce a good runtime representation
2023-01-07 11:34:44 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-07 11:34:46 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-01-07 11:35:02 +0100trev(~trev@user/trev)
2023-01-07 11:35:24 +0100 <Inst> as far as i understand, there's basically two schools, one that hates monad transformers, i.e, professionals who write in straight IO and pure code, or readerT pattern, and people who like monad trans
2023-01-07 11:35:44 +0100 <boxscape_> I guess because it means you end up using IO for something that, semantically, doesn't need it?
2023-01-07 11:36:02 +0100 <[exa]> like, ofcourse ghc would ideally be able to magically realize it by itself, but you don't help it a lot by throwing in the insensitive amount of data structure mess
2023-01-07 11:36:04 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-07 11:36:17 +0100 <[exa]> did anyone already try doing zippers on effects?
2023-01-07 11:36:21 +0100trev(~trev@user/trev)
2023-01-07 11:36:33 +0100 <Inst> i deeloped a hatred on monad trans when someone helped me build a cheap ed clone
2023-01-07 11:36:36 +0100 <[exa]> boxscape_: yeah IO hurts, might have been ST or so
2023-01-07 11:36:49 +0100 <Inst> because there was way too much monad trans wrapping IO
2023-01-07 11:36:51 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-01-07 11:37:08 +0100 <[exa]> Inst: why hate? no one pushes you to use that. :D
2023-01-07 11:37:31 +0100 <freeside> oh hey, that reminds me. My code wants to output to two streams, analogous to STDOUT and STDERR, except the plan is to buffer things up and dump all output at the end in a structured form -- basically org-mode header blocks vs #+begin_example / #+end_example, with a "table of contents" and so on. What approach should I take -- Writer { a::[String], b::[String] } ?
2023-01-07 11:37:52 +0100 <[exa]> Inst: anyway, it's super useful for many purposes where saving programmer time balances out the computer time, the latter is much cheaper
2023-01-07 11:38:02 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 268 seconds)
2023-01-07 11:38:05 +0100 <Inst> it's my fault anyways, because i asked to learn monad trans because there was so much code using it
2023-01-07 11:38:12 +0100 <Inst> and arguably using reader / writer monad is more dishonest than monad trans
2023-01-07 11:38:20 +0100 <Inst> erm, function / tuple monad is more dishonest than monad trans
2023-01-07 11:38:27 +0100 <[exa]> it's not, it's your choice
2023-01-07 11:38:31 +0100 <Inst> readerT / writerT at least shows up in the type system
2023-01-07 11:39:00 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-07 11:39:06 +0100 <[exa]> the Writer over the (,) is literally just a tag that helps you to communicate this to other programmers. "Hey this is not an actual tuple tuple, I'm using it to write a log instead"
2023-01-07 11:39:16 +0100trev(~trev@user/trev)
2023-01-07 11:39:37 +0100Lord_of_Life_Lord_of_Life
2023-01-07 11:39:40 +0100 <[exa]> +- some helpful side gains, like you can make the writer strict to avoid accumulation of thunkery
2023-01-07 11:40:09 +0100 <Inst> there's still some old stuff, like why snoyman stuck to readerT because all the monad transformer monads had issues
2023-01-07 11:40:24 +0100 <Inst> writer T was supposed to still be space leaking, same with state
2023-01-07 11:40:42 +0100 <boxscape_> WriterT is fine with the CPS implementation
2023-01-07 11:40:42 +0100 <[exa]> people make choices, that's normal. :D
2023-01-07 11:40:50 +0100iqubic(~avi@2601:602:9502:c70:3dee:aba8:ea3d:300b) (Ping timeout: 260 seconds)
2023-01-07 11:40:55 +0100 <Inst> ah, nice to hear
2023-01-07 11:41:03 +0100 <boxscape_> transformers has Lazy, Strict, and CPS Writer, the only one that should be used is CPS though, afaik
2023-01-07 11:41:15 +0100 <boxscape_> (as in, the "transformers" package)
2023-01-07 11:42:11 +0100 <Inst> i hope by the time i catually know what i'm doing, someone will have a mature and performant algebraic effects system up and i don't have to bother with monad trans ever again
2023-01-07 11:42:11 +0100 <boxscape_> I guess there could be some use-cases for Lazy Writers
2023-01-07 11:43:16 +0100 <boxscape_> honestly I'm fairly happy with most effects systems that exist. But I don't usually do performance-critical things
2023-01-07 11:43:17 +0100 <[exa]> CPS writer is basically the same as state? (w -> a,w ?)
2023-01-07 11:43:44 +0100 <boxscape_> I don't know, I just read people saying that I should use CPS over strict and follow their advice :)
2023-01-07 11:43:52 +0100libertyprime(~libertypr@203.96.203.167) (Quit: leaving)
2023-01-07 11:44:06 +0100 <[exa]> like, yeah, it makes sense
2023-01-07 11:44:37 +0100razetime(~Thunderbi@49.207.222.244) (Remote host closed the connection)
2023-01-07 11:44:55 +0100 <Inst> well, trying to keep haskell performance is nice, as an advertisement, at least, because juspay doubled their resource efficiency when they switched from purescript / node.js to haskell
2023-01-07 11:45:00 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7)
2023-01-07 11:45:04 +0100 <Inst> and now juspay is paying haskell foundation
2023-01-07 11:45:15 +0100 <[exa]> \o/
2023-01-07 11:45:20 +0100 <Inst> on monad tier
2023-01-07 11:45:26 +0100 <boxscape_> do they use GHCJS?
2023-01-07 11:45:48 +0100 <boxscape_> or did they use purescript for backend stuff?
2023-01-07 11:46:58 +0100 <Inst> no clue, i thought they went native
2023-01-07 11:46:59 +0100 <Inst> https://skillsmatter.com/skillscasts/17411-how-we-migrated-65k-lines-of-javascript-code-to-haskell…
2023-01-07 11:47:13 +0100 <Inst> they transpiled their purescript to haskell
2023-01-07 11:47:21 +0100 <Inst> https://blog.monadfix.com/nau-introduction
2023-01-07 11:48:10 +0100 <boxscape_> hmm I see
2023-01-07 11:48:11 +0100 <[exa]> oh noes it wants a login
2023-01-07 11:49:31 +0100 <[exa]> Inst: they say they have a few pain points, if you watched the cast can you pls summarize?
2023-01-07 11:50:28 +0100 <Inst> should be direct access
2023-01-07 11:50:30 +0100titibandit1(~titibandi@xdsl-87-78-235-220.nc.de)
2023-01-07 11:50:33 +0100 <Inst> https://www.youtube.com/watch?v=nRLOtbjEtyE
2023-01-07 11:50:41 +0100 <boxscape_> nice
2023-01-07 11:51:10 +0100 <boxscape_> tbh I never even considered that people might be using purescript for non-frontend code
2023-01-07 11:52:09 +0100 <Inst> i think it was purescript, not sure, could have been straight functional JS
2023-01-07 11:52:12 +0100 <freeside> as someone who needs to translate between Haskell and Purescript, it pains me that Purescript syntax is almost but not quite Haskell syntax
2023-01-07 11:53:41 +0100 <boxscape_> Inst: well, since the transpiler is for purescript, it would make sense
2023-01-07 11:53:44 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 11:55:04 +0100vhs(~vhs@78-66-105-254-no600.tbcn.telia.com) (Remote host closed the connection)
2023-01-07 11:55:04 +0100vhsconnect(~vhs@78-66-105-254-no600.tbcn.telia.com) (Remote host closed the connection)
2023-01-07 11:56:07 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-07 11:56:17 +0100Speedbird(~Speedbird@94.230.79.152) (Quit: Client closed)
2023-01-07 11:56:21 +0100 <DigitalKiwi> purescript_node.js
2023-01-07 11:56:23 +0100trev(~trev@user/trev)
2023-01-07 11:58:13 +0100 <Inst> complaints about... [exa], initial learning curve, compilation time, pure functions throwing exceptions
2023-01-07 11:58:16 +0100 <Inst> from the slide
2023-01-07 11:59:14 +0100 <DigitalKiwi> they complained about you [exa]? 15 minutes of shame
2023-01-07 11:59:41 +0100 <freeside> seems unnecessarily personal
2023-01-07 12:00:18 +0100fizbin(~fizbin@user/fizbin)
2023-01-07 12:01:13 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-07 12:01:33 +0100 <DigitalKiwi> freeside: do you like the row types though
2023-01-07 12:01:45 +0100trev(~trev@user/trev)
2023-01-07 12:02:02 +0100 <DigitalKiwi> the only feature i know about in purescript lol
2023-01-07 12:03:44 +0100 <Inst> exa, typo
2023-01-07 12:05:22 +0100 <[exa]> Inst: ah thanks
2023-01-07 12:05:45 +0100 <[exa]> anyway yeah folks, pls remove me from ghc10, I'm not a good addition to the language
2023-01-07 12:05:55 +0100thongpv87(~thongpv87@2402:9d80:389:9e3a:2c87:afe4:cc1d:eda4) (Ping timeout: 256 seconds)
2023-01-07 12:07:32 +0100titibandit1(~titibandi@xdsl-87-78-235-220.nc.de) (Ping timeout: 246 seconds)
2023-01-07 12:09:10 +0100axeman(~quassel@2a02:8109:a3c0:ed8:9392:cd42:dc8a:7cd9)
2023-01-07 12:09:22 +0100 <boxscape_> That will have to go through the official proposal process
2023-01-07 12:09:32 +0100 <freeside> digitalkiwi: with the presence of row types, i was expecting JSON parsing to be easier, and for there to be easier integration between records and json.
2023-01-07 12:13:08 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-07 12:13:54 +0100trev(~trev@user/trev)
2023-01-07 12:18:37 +0100shriekingnoise(~shrieking@186.137.175.87) (Quit: Quit)
2023-01-07 12:18:49 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-07 12:19:14 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-01-07 12:22:11 +0100titibandit1(~titibandi@xdsl-87-78-235-220.nc.de)
2023-01-07 12:22:32 +0100mbuf(~Shakthi@49.204.114.1)
2023-01-07 12:27:41 +0100xff0x(~xff0x@2405:6580:b080:900:c792:9a92:2632:4781)
2023-01-07 12:32:25 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:cc20:d690:f22b:cb00)
2023-01-07 12:36:31 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-07 12:36:57 +0100trev(~trev@user/trev)
2023-01-07 12:37:00 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:cc20:d690:f22b:cb00) (Ping timeout: 255 seconds)
2023-01-07 12:38:20 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-01-07 12:41:51 +0100 <freeside> say, how do i discover the fixity of (,) ?
2023-01-07 12:43:03 +0100dextaa(~DV@user/dextaa) (Read error: Connection reset by peer)
2023-01-07 12:43:07 +0100 <Heffalump> freeside: I think it has the weakest possible binding
2023-01-07 12:43:07 +0100axeman(~quassel@2a02:8109:a3c0:ed8:9392:cd42:dc8a:7cd9) (Ping timeout: 260 seconds)
2023-01-07 12:43:25 +0100dextaa(~DV@user/dextaa)
2023-01-07 12:46:20 +0100 <Inst> :i?
2023-01-07 12:46:43 +0100 <Inst> wow, it's not listed
2023-01-07 12:48:04 +0100 <freeside> probably because it's doing double duty as a tuple constructor and list separator
2023-01-07 12:48:23 +0100 <freeside> it's a floor wax and a dessert topping!
2023-01-07 12:49:26 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2023-01-07 12:50:01 +0100zmt00(~zmt00@user/zmt00) (Ping timeout: 252 seconds)
2023-01-07 12:53:28 +0100axeman(~quassel@2a02:8109:a3c0:ed8:ce56:f99d:50c4:44c8)
2023-01-07 12:57:29 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-07 12:57:35 +0100acidjnk(~acidjnk@p200300d6e715c429e462ed5ea333447e.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-01-07 13:00:01 +0100jakalx(~jakalx@base.jakalx.net)
2023-01-07 13:03:40 +0100fizbin(~fizbin@user/fizbin) (Ping timeout: 260 seconds)
2023-01-07 13:05:30 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2023-01-07 13:10:54 +0100sammelweis(~quassel@c-68-48-18-140.hsd1.mi.comcast.net) (Quit: No Ping reply in 180 seconds.)
2023-01-07 13:14:12 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-01-07 13:15:23 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-01-07 13:16:35 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-01-07 13:20:55 +0100mei(~mei@user/mei)
2023-01-07 13:21:27 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-07 13:21:43 +0100tremon(~tremon@83-85-213-108.cable.dynamic.v4.ziggo.nl)
2023-01-07 13:23:08 +0100panovia(~user@user/siracusa) (Quit: Bye!)
2023-01-07 13:23:50 +0100mei_(~mei@user/mei) (Ping timeout: 246 seconds)
2023-01-07 13:24:41 +0100axeman(~quassel@2a02:8109:a3c0:ed8:ce56:f99d:50c4:44c8) (Ping timeout: 256 seconds)
2023-01-07 13:25:19 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.7.1)
2023-01-07 13:32:20 +0100CiaoSen(~Jura@p200300c9572e35002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-01-07 13:33:47 +0100fizbin(~fizbin@user/fizbin)
2023-01-07 13:34:52 +0100 <lyxia> fixity doesn't make sense for "," because the outer brackets make it unambiguous to parse.
2023-01-07 13:36:13 +0100img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2023-01-07 13:36:46 +0100 <lyxia> and for reference the grammar of Haskell is in the report https://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-360003.8
2023-01-07 13:38:35 +0100 <boxscape_> so "cabal --upload" will only upload a package candidate by default, right?
2023-01-07 13:38:57 +0100 <boxscape_> err, "cabal upload"
2023-01-07 13:39:20 +0100 <ncf> infixl 0 `comma`; comma = (,)
2023-01-07 13:39:22 +0100 <ncf> :^)
2023-01-07 13:39:23 +0100img(~img@user/img)
2023-01-07 13:41:53 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-01-07 13:43:43 +0100img(~img@user/img) (Client Quit)
2023-01-07 13:44:11 +0100img(~img@user/img)
2023-01-07 13:44:56 +0100 <freeside> thank you lyxia, i did look for it in the report ... for some time
2023-01-07 13:45:14 +0100img(~img@user/img) (Client Quit)
2023-01-07 13:45:52 +0100 <boxscape_> hmm reading a blog post that seems to imply that it does not upload a candidate, but it's from 2020
2023-01-07 13:46:32 +0100 <int-e> ncf: infixl, why left?
2023-01-07 13:46:34 +0100 <lyxia> boxscape_: it does candidates by default
2023-01-07 13:46:39 +0100 <boxscape_> ok, thanks
2023-01-07 13:47:20 +0100 <ncf> int-e: no reason. i guess right is more common.
2023-01-07 13:47:43 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 13:48:06 +0100img(~img@user/img)
2023-01-07 13:48:16 +0100 <int-e> ncf: I'd prefer `infix`... well, hypothetically. I prefer (,) of course :)
2023-01-07 13:49:51 +0100 <ncf> agda's comma is infixr, for what it's worth
2023-01-07 13:50:32 +0100 <ncf> i guess in general it should have the same associativity as ×
2023-01-07 13:50:33 +0100 <boxscape_> hackage gives me a 403 error if I try to upload a package candidate 🤔
2023-01-07 13:50:42 +0100 <ncf> so that a , b , c : A × B × C
2023-01-07 13:51:24 +0100 <ncf> boxscape_: don't they need to activate your account or something like that first?
2023-01-07 13:51:31 +0100 <boxscape_> ah, maybe
2023-01-07 13:51:59 +0100razetime(~Thunderbi@49.207.222.244)
2023-01-07 13:52:13 +0100 <ncf> see the red box in https://hackage.haskell.org/users/register-request
2023-01-07 13:52:32 +0100 <boxscape_> -.- how did I miss that
2023-01-07 13:52:34 +0100 <boxscape_> thanks
2023-01-07 13:53:10 +0100 <int-e> ncf: ah, that's a different context though if you don't have proper triples.
2023-01-07 13:56:47 +0100fizbin(~fizbin@user/fizbin) (Ping timeout: 252 seconds)
2023-01-07 13:59:07 +0100acidjnk(~acidjnk@p200300d6e715c429707e98a68aa77666.dip0.t-ipconnect.de)
2023-01-07 14:01:07 +0100thongpv87(~thongpv87@2402:9d80:34d:fde9:8a11:e98e:b8b0:cf04)
2023-01-07 14:06:16 +0100__monty__(~toonn@user/toonn)
2023-01-07 14:11:45 +0100 <boxscape_> Oh, I just figured out how I missed it. I didn't read it carefully i
2023-01-07 14:11:56 +0100 <boxscape_> enough and thought the "Request account" button already includes a request for activation
2023-01-07 14:12:23 +0100 <boxscape_> I'll suggest to change it to "create account"
2023-01-07 14:14:39 +0100 <MangoIV[m]> Hi, I want to write something like the following function:... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/e744cf824ed41da718c8c11df880426e45a3…>)
2023-01-07 14:15:00 +0100 <MangoIV[m]> * Hi, I want to write something like the following function:... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/2bd9c606eea22fe6c83e0ce3560791d3a728…>)
2023-01-07 14:15:05 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-01-07 14:15:41 +0100 <MangoIV[m]> (I'm using the type names used by generics-sop because I thought those would be most familiar)
2023-01-07 14:17:29 +0100 <mauke> why is the `=>` inside of the parentheses?
2023-01-07 14:17:45 +0100__monty__(~toonn@user/toonn)
2023-01-07 14:18:20 +0100califax(~califax@user/califx) (Ping timeout: 255 seconds)
2023-01-07 14:19:01 +0100califax(~califax@user/califx)
2023-01-07 14:19:04 +0100Xeroine(~Xeroine@user/xeroine) (Read error: Connection reset by peer)
2023-01-07 14:19:19 +0100 <MangoIV[m]> because the statement of the function is that "if I have some List for that All Top holds then I can always remove that constraint", if you move it outwards then it's merely id.
2023-01-07 14:20:03 +0100Xeroine(~Xeroine@user/xeroine)
2023-01-07 14:20:38 +0100 <int-e> You have to provide evidence for `All Top xs` in order to evaluate that (All Top xs => NP f xs) value.
2023-01-07 14:20:59 +0100 <MangoIV[m]> isn't matching on Nil evidence enough? why not?
2023-01-07 14:21:17 +0100 <int-e> there's nothing to match
2023-01-07 14:21:30 +0100 <boxscape_> in other words, it has to be evaluated e
2023-01-07 14:21:33 +0100 <boxscape_> before you can match on it
2023-01-07 14:21:35 +0100 <boxscape_> I suppsoe
2023-01-07 14:21:46 +0100 <int-e> operationally, the NP f xs value that you get may depend on the All Top xs dictionary (if that's a class).
2023-01-07 14:22:37 +0100 <mauke> All and Top are both classes
2023-01-07 14:22:54 +0100 <boxscape_> oh I would have expected All to be a type family
2023-01-07 14:22:58 +0100 <MangoIV[m]> ok, I get that reasoning, but I do not get why it doesn't work, can somebody please try to explain what I'm misunderstanding? I think that matching on '[] should provide GHC with the ability to reduce the type family and getting a dictionary for () should be possible
2023-01-07 14:23:23 +0100 <MangoIV[m]> All is indeed a type family
2023-01-07 14:23:23 +0100 <MangoIV[m]> although in generics-sop it's a type class synonym for a type family
2023-01-07 14:23:23 +0100 <MangoIV[m]> to get partial application
2023-01-07 14:23:34 +0100 <MangoIV[m]> as do not need that, in my case it is a type family
2023-01-07 14:23:35 +0100 <boxscape_> ah
2023-01-07 14:24:14 +0100 <mauke> `class (AllF c xs, SListI xs) => All (c :: k -> Constraint) (xs :: [k])`
2023-01-07 14:24:53 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67)
2023-01-07 14:25:32 +0100 <MangoIV[m]> (that's not how I implement it, for simplicity sake, this is the first line:... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/1cf5f5be679a60501a9d48794f376362970f…>)
2023-01-07 14:26:24 +0100 <int-e> Conceptually, I guess you want NP f xs -> All Top xs, so wiggling CPS style that would be NP f xs -> (All Top xs => r) -> r
2023-01-07 14:27:30 +0100 <MangoIV[m]> I think it should be the other way around, no? I want to subsume the constraint
2023-01-07 14:27:34 +0100 <MangoIV[m]> not add it
2023-01-07 14:29:13 +0100 <MangoIV[m]> lemme check whether it helps me, though, thank you
2023-01-07 14:30:21 +0100 <int-e> I don't understand how your function is supposed to work. `All Top xs => NP f xs` doesn't give you a value until you provide the `All Top xs` evidence. Crucially, you have no `xs` to pattern match against.
2023-01-07 14:30:50 +0100 <int-e> (types are erased at runtime)
2023-01-07 14:31:29 +0100 <MangoIV[m]> why? I think matching on HNil gives me evidence?
2023-01-07 14:31:34 +0100 <MangoIV[m]> that's why it's a GADT?
2023-01-07 14:31:44 +0100 <int-e> Where's the value to pattern match?
2023-01-07 14:31:53 +0100 <MangoIV[m]> the NP?
2023-01-07 14:32:28 +0100 <int-e> There is no NP. You only have `All Top xs => NP f xs` which isn't a value... what I just wrote above.
2023-01-07 14:32:32 +0100 <MangoIV[m]> <MangoIV[m]> "ok, I get that reasoning, but..." <- hence my question here; i don't understand why GHC forgets the evidence provideded by the match on HNil
2023-01-07 14:32:44 +0100 <int-e> There's no match!
2023-01-07 14:33:10 +0100 <MangoIV[m]> > <@mangoiv.:matrix.org> Hi, I want to write something like the following function:... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/af198fc750c8c8ac65e47988508a1fcefe3f…>)
2023-01-07 14:33:13 +0100 <lambdabot> <hint>:1:1: error: parse error on input ‘<@’
2023-01-07 14:33:32 +0100 <mauke> no, you don't
2023-01-07 14:33:50 +0100 <int-e> you write `dischargeAllTop Nil = Nil` but that becomes `dischargeAllTop x = case x of Nil -> Nil`, and in order to evaluate that, you need to evaluate x.
2023-01-07 14:33:50 +0100 <mauke> you don't have a value to match on yet (because trying to get that value leads to a type error)
2023-01-07 14:34:12 +0100 <int-e> And in order to evaluate x, you need to provide the `All Top xs` evidence.
2023-01-07 14:34:21 +0100 <mauke> also, wouldn't you need something like withDict pureAll ...?
2023-01-07 14:34:42 +0100 <mauke> I'm looking at https://hackage.haskell.org/package/sop-core-0.5.0.2/docs/Data-SOP-Dict.html
2023-01-07 14:35:11 +0100 <int-e> So unless you can conjure `All Top xs` for *any* type xs, this isn't going to work.
2023-01-07 14:35:38 +0100 <mauke> what a coincidence :-) `pureAll :: SListI xs => Dict (All Top) xs`
2023-01-07 14:35:43 +0100acidjnk(~acidjnk@p200300d6e715c429707e98a68aa77666.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2023-01-07 14:36:00 +0100 <int-e> Note the `SListI xs =>` constraint there.
2023-01-07 14:36:06 +0100 <int-e> That makes all the difference.
2023-01-07 14:36:31 +0100 <MangoIV[m]> that's a pity
2023-01-07 14:36:32 +0100 <MangoIV[m]> int-e: the reason why I'm doing this is to prove that... so the reason is that _to match on Nil_ I first have to know my proposition but I can only know it by matching on Nil
2023-01-07 14:36:34 +0100 <mauke> yeah, I guess that says xs must be a type list
2023-01-07 14:36:41 +0100kris7t(~kris7t@marussy.com) (Remote host closed the connection)
2023-01-07 14:37:22 +0100alfonsox(~quassel@103.87.57.65)
2023-01-07 14:37:30 +0100kris7t(~kris7t@marussy.com)
2023-01-07 14:37:47 +0100 <boxscape_> kind of reminds of trying to prove Peirce's law in a constructive context, not sure if it's related though
2023-01-07 14:37:51 +0100 <mauke> oh, it gets weirder. type SListI = All Top :-(
2023-01-07 14:39:04 +0100 <MangoIV[m]> yeah, it looks like `All Top xs => All c xs` so that gives you All Top xs => All Top xs in case c ~ Top
2023-01-07 14:39:16 +0100 <MangoIV[m]> I guess that's the trick that generics-sop uses
2023-01-07 14:39:22 +0100 <MangoIV[m]> to get around that problem
2023-01-07 14:43:10 +0100kris7t(~kris7t@marussy.com) ()
2023-01-07 14:48:32 +0100zmt00(~zmt00@user/zmt00)
2023-01-07 14:48:37 +0100acidjnk(~acidjnk@p200300d6e715c429707e98a68aa77666.dip0.t-ipconnect.de)
2023-01-07 14:52:12 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 272 seconds)
2023-01-07 14:56:25 +0100 <MangoIV[m]> ok; so apparently using that you can then create a singleton that witnesses the list spine, which you can then use to get the necessary dicts in scope
2023-01-07 14:59:40 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Quit: beteigeuze)
2023-01-07 15:00:06 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-01-07 15:01:40 +0100 <int-e> Right, singletons are largely about getting values (which aren't erased at runtime) for type evidence.
2023-01-07 15:07:34 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-01-07 15:07:35 +0100[_](~itchyjunk@user/itchyjunk/x-7353470)
2023-01-07 15:10:06 +0100[_](~itchyjunk@user/itchyjunk/x-7353470) (Client Quit)
2023-01-07 15:10:07 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 260 seconds)
2023-01-07 15:12:02 +0100freeside(~mengwong@103.252.202.159)
2023-01-07 15:13:44 +0100biberu\(~biberu@user/biberu)
2023-01-07 15:14:29 +0100biberu(~biberu@user/biberu) (Ping timeout: 246 seconds)
2023-01-07 15:15:18 +0100biberu\biberu
2023-01-07 15:16:53 +0100CiaoSen(~Jura@p200300c9572e35002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-01-07 15:17:44 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds)
2023-01-07 15:19:23 +0100acidjnk(~acidjnk@p200300d6e715c429707e98a68aa77666.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-01-07 15:21:27 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-01-07 15:23:37 +0100 <Inst> hey [exa], if you want to humor me because I'm really sick
2023-01-07 15:23:52 +0100 <Inst> it's possible to stuff a group of IO () values into a list
2023-01-07 15:23:58 +0100 <Inst> can't Eq it, of course
2023-01-07 15:24:07 +0100 <Inst> then you can sequence the list to run it
2023-01-07 15:24:27 +0100 <Inst> but you can also reverse, take, index, etc
2023-01-07 15:24:40 +0100 <[exa]> yeah that's true
2023-01-07 15:24:41 +0100 <Inst> this isn't real Haskell, but it sounds like there's probably something fun you can do with it
2023-01-07 15:24:54 +0100 <[exa]> how come it's not real haskell?
2023-01-07 15:25:01 +0100 <Inst> we have template Haskell for this
2023-01-07 15:25:17 +0100 <Inst> someone complained because after I built a blackjack calculator with 10 lines of IO and 2000 lines of calculation and combinators
2023-01-07 15:25:25 +0100 <Inst> I claimed IO was like a scripting language in Haskell
2023-01-07 15:25:38 +0100 <Inst> correctly, it's closer to a eDSL
2023-01-07 15:25:48 +0100 <Inst> they countered that that intuition is like a monad burrito tutorial
2023-01-07 15:25:52 +0100 <Inst> because it disguises that IO is a value
2023-01-07 15:25:56 +0100 <Inst> that IO types are values
2023-01-07 15:26:25 +0100 <Inst> evidently, the sequenceA_ is fun to get an intuition for IO as a value; i.e, limited metaprogramming based on IO
2023-01-07 15:26:30 +0100 <Inst> erm, IO values in a list
2023-01-07 15:27:05 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7) (Quit: Leaving)
2023-01-07 15:27:13 +0100 <[exa]> burritos are crutches for those of feeble faith. :D
2023-01-07 15:27:38 +0100 <Inst> any metaprogramming exercise ideas?
2023-01-07 15:28:06 +0100 <[exa]> it's literally an eDSL, it's special just because it computes a (the!) value that the ghc kinda requires from you
2023-01-07 15:28:28 +0100 <[exa]> > sequence $ reverse [print 5, print 6]
2023-01-07 15:28:30 +0100 <lambdabot> <IO [()]>
2023-01-07 15:28:46 +0100 <[exa]> (it prints 6 then 5 but lambdabot ain't friends with IO)
2023-01-07 15:28:58 +0100 <Inst> but everyone i talked to claimed that the notion of treating IO as a scripting language was bad
2023-01-07 15:29:37 +0100 <[exa]> how is this a scripting language?
2023-01-07 15:29:54 +0100 <Inst> I guess I was thinking of it as an analogy to Py + Numpy
2023-01-07 15:29:56 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 15:30:00 +0100 <Inst> since that was what happened with my blackjack calculator
2023-01-07 15:30:03 +0100 <Inst> tiny main, huge program
2023-01-07 15:30:38 +0100 <[exa]> tbh, that may be okay. The calculator doesn't need much IO interaction between reading the task and spewing out the result, so why have IO ops?
2023-01-07 15:31:45 +0100 <[exa]> if there are obvious stages or sequentiality in the calculation, there might be monads that make the whole thing simpler (State that holds known evaluations, etc...)
2023-01-07 15:32:08 +0100 <[exa]> maybe they were referring to the situation when you implement and interpret the eDSL yourself?
2023-01-07 15:32:25 +0100 <Inst> ehhh, I used it to produce a log, which is being fed to a Servant server, which is being held up because a friend is being tasked to help develop the JS interface for it
2023-01-07 15:33:06 +0100Guest|34(~Guest|34@158.181.134.236)
2023-01-07 15:33:11 +0100 <[exa]> yeah at that point you might love having a magic offloader for log entries that should be spewed out, so that you don't need to carry them manually
2023-01-07 15:33:15 +0100 <Inst> anyways, if you can think up any cool ideas for IO-list metaprogramming, let me know
2023-01-07 15:33:17 +0100Guest|34(~Guest|34@158.181.134.236) (Client Quit)
2023-01-07 15:33:31 +0100 <[exa]> metaprogramming as in real templatehaskell, or in eDSLs?
2023-01-07 15:33:35 +0100 <Inst> it seems fun, if a bit superfluous, but the idea is
2023-01-07 15:33:44 +0100biberu\(~biberu@user/biberu)
2023-01-07 15:33:46 +0100 <Inst> i mean the idea of manipulating an IO () list via sequence
2023-01-07 15:34:05 +0100alfonsox(~quassel@103.87.57.65) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-01-07 15:34:18 +0100 <Inst> it seems, to begin with, way more accessible than template haskell, and also helps solidify the idea of an IO Value, as opposed to IO being syntax
2023-01-07 15:34:28 +0100 <Inst> I have no idea how hardcore imperative people think
2023-01-07 15:34:34 +0100 <[exa]> ah, hah. I once did some kind of a program that was supposed to do multiple simple actions in one "transaction", the actions were selected by the user on a commandline
2023-01-07 15:34:45 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-07 15:34:48 +0100 <[exa]> so I had literal `M.Map String (IO ())`
2023-01-07 15:34:59 +0100biberu(~biberu@user/biberu) (Ping timeout: 260 seconds)
2023-01-07 15:35:19 +0100biberu\biberu
2023-01-07 15:35:28 +0100 <[exa]> then you open the transaction, traverse the argument list, run the list of IO actions that you find with sequence, close the transaction
2023-01-07 15:35:32 +0100 <[exa]> it was luvly.
2023-01-07 15:36:29 +0100 <[exa]> (in something like C++ you would have `std::map<std::string, some_function_pointer>` or so)
2023-01-07 15:37:09 +0100CiaoSen(~Jura@p200300c9572e35002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-01-07 15:38:49 +0100fizbin(~fizbin@user/fizbin)
2023-01-07 15:40:04 +0100 <Inst> it's more like tokens + transform, no?
2023-01-07 15:42:42 +0100 <[exa]> yeah, it was very roughly like: getArgs >>= sequence . map (myHandlers M.!)
2023-01-07 15:43:01 +0100 <[exa]> not sure if that even typechecks but I guess you get the idea
2023-01-07 15:43:29 +0100 <[exa]> anyway, the design space of various embeddings/metaprogrammings is pretty wide
2023-01-07 15:43:38 +0100 <[exa]> lemme google 1 thing
2023-01-07 15:46:10 +0100acidjnk(~acidjnk@p200300d6e715c42998a7643da4cfbc51.dip0.t-ipconnect.de)
2023-01-07 15:47:35 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 15:48:59 +0100mechap(~mechap@user/mechap) (Ping timeout: 260 seconds)
2023-01-07 15:50:13 +0100 <[exa]> there are various encodings of the programs (eDSLs and alike); you may choose between initial and final representation, and tagged and tagless encoding
2023-01-07 15:50:38 +0100mechap(~mechap@user/mechap)
2023-01-07 15:51:18 +0100Guest49(~Guest49@2409:4064:613:746a:ac10:4c65:5042:bba1)
2023-01-07 15:53:25 +0100Guest49(~Guest49@2409:4064:613:746a:ac10:4c65:5042:bba1) (Client Quit)
2023-01-07 15:55:25 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-07 15:55:48 +0100 <[exa]> Inst: anyway this is probably a good reading https://serokell.io/blog/introduction-tagless-final (I can't find the post I wanted but this should do)
2023-01-07 15:56:58 +0100titibandit1(~titibandi@xdsl-87-78-235-220.nc.de) (Remote host closed the connection)
2023-01-07 15:57:23 +0100 <[exa]> for your use case it might be nice for systematizing what is and isn't useful for various kinds of program manipulation out there
2023-01-07 15:59:54 +0100 <Inst> reading
2023-01-07 16:00:23 +0100 <Inst> tbh i'm trying to write a book for fun (it's so bad I'm now ashamed to show it) and I just need exercise ideas
2023-01-07 16:00:31 +0100 <Inst> I was more thinking of
2023-01-07 16:00:32 +0100 <Inst> https://blog.jle.im/entry/first-class-statements.html
2023-01-07 16:00:53 +0100fizbin(~fizbin@user/fizbin) (Ping timeout: 260 seconds)
2023-01-07 16:01:01 +0100 <Jadesheit[m]> Isn't the only function that can typecheck `a -> a` the identity function? (apart from sketchy coercion)
2023-01-07 16:01:39 +0100 <Jadesheit[m]> * typecheck `forall a, * a., * a -> a`
2023-01-07 16:03:16 +0100 <Inst> id.id
2023-01-07 16:03:52 +0100 <Jadesheit[m]> that's identically equal to the identity function
2023-01-07 16:04:56 +0100 <Inst> \s\identity function\identity function and derivatives of\
2023-01-07 16:05:02 +0100 <Jadesheit[m]> `id . id` can be expanded as `\x -> id (id x)`, `\x -> id x` which is just `id`
2023-01-07 16:06:20 +0100stiell_(~stiell@gateway/tor-sasl/stiell) (Ping timeout: 255 seconds)
2023-01-07 16:07:07 +0100Yurez23(~Yurez23@46.36.117.226)
2023-01-07 16:07:18 +0100 <[exa]> Jadesheit[m]: given some mathematically optimistic conditions about evaluation and lack of `seq`, the only 2 possible implementations of `a->a` are truly `id` and an `undefined` somehow constrained to return the same type as `a`
2023-01-07 16:08:07 +0100tremon(~tremon@83-85-213-108.cable.dynamic.v4.ziggo.nl) (Ping timeout: 268 seconds)
2023-01-07 16:11:04 +0100 <[exa]> Inst: ha, well, for exercises... implement any of the base languages (forth/lisp/prolog/ML/shell), revelant exercises will spawn magically
2023-01-07 16:12:07 +0100 <Guest5476> I can write a function with a -> a type, that will have special treatment to Bool values, using realyUnsafePtrEquality
2023-01-07 16:12:33 +0100 <[exa]> Guest5476: yeah but well, you know, pls don't. :D
2023-01-07 16:12:41 +0100 <Guest5476> I will call it "realyUnsafeId"
2023-01-07 16:12:58 +0100stiell_(~stiell@gateway/tor-sasl/stiell)
2023-01-07 16:14:05 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2023-01-07 16:15:43 +0100freemanX(~user@14.100.44.229) (Ping timeout: 252 seconds)
2023-01-07 16:17:41 +0100 <Guest5476> BTW, it sounds like a good examination for data sharing knowledge
2023-01-07 16:20:39 +0100tremon(~tremon@83-85-213-108.cable.dynamic.v4.ziggo.nl)
2023-01-07 16:20:44 +0100jakalx(~jakalx@base.jakalx.net)
2023-01-07 16:25:20 +0100Yurez23(~Yurez23@46.36.117.226) (Quit: Client closed)
2023-01-07 16:30:48 +0100Yurez23(~Yurez23@46.36.117.226)
2023-01-07 16:34:45 +0100phma(phma@2001:5b0:210d:e648:536c:bd68:b90b:47da) (Read error: Connection reset by peer)
2023-01-07 16:35:13 +0100phma(~phma@host-67-44-208-26.hnremote.net)
2023-01-07 16:35:42 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-01-07 16:36:22 +0100mc47(~mc47@xmonad/TheMC47)
2023-01-07 16:40:17 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Quit: Leaving)
2023-01-07 16:42:11 +0100geekosaur(~geekosaur@xmonad/geekosaur)
2023-01-07 16:43:21 +0100ddellacosta(~ddellacos@89.45.224.178)
2023-01-07 16:43:37 +0100Yurez23(~Yurez23@46.36.117.226) (Quit: Client closed)
2023-01-07 16:45:27 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-01-07 16:46:39 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-01-07 16:46:53 +0100califax_(~califax@user/califx)
2023-01-07 16:48:09 +0100califax_califax
2023-01-07 16:49:22 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 272 seconds)
2023-01-07 16:50:27 +0100axeman(~quassel@2a02:8109:a3c0:ed8:53bb:6cbb:d8cb:4271)
2023-01-07 16:50:29 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-01-07 16:51:53 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Client Quit)
2023-01-07 16:54:18 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-01-07 16:58:01 +0100hsw(~hsw@2001-b030-2303-0104-0172-0025-0012-0132.hinet-ip6.hinet.net) (Remote host closed the connection)
2023-01-07 16:58:20 +0100hsw(~hsw@2001-b030-2303-0104-0172-0025-0012-0132.hinet-ip6.hinet.net)
2023-01-07 16:59:24 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-01-07 17:01:57 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 17:15:34 +0100 <MangoIV[m]> <MangoIV[m]> "I guess that's the trick that..." <- just for who cares: it's easier to get around this problem by just using... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/e07ae38cdae1e6aad4afbee459fc4bd7e312…>)
2023-01-07 17:17:51 +0100 <dgpratt[m]> feeling dumb, how do I generalize this function `f n = [[n0, n1, n2 ] | n0 <- [0..n], n1 <- [n0..n], n2 <- [n1..n]]` such that the number of iterations / elements in the inner list is based on a numeric argument?
2023-01-07 17:18:49 +0100 <freeside> recurse or traverse
2023-01-07 17:23:37 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340)
2023-01-07 17:24:06 +0100 <freeside> myfunction depth nLow nHigh ... and somewhere you will want concat, or concatMap ...
2023-01-07 17:26:23 +0100acidjnk(~acidjnk@p200300d6e715c42998a7643da4cfbc51.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-01-07 17:30:03 +0100 <mauke> let gen 0 _ = [[]]; gen k (lo, hi) = [ n : suf | n <- [lo .. hi], suf <- gen (k-1) (n, hi) ] in gen 3 (0, 3)
2023-01-07 17:30:24 +0100 <mauke> > let gen 0 _ = [[]]; gen k (lo, hi) = [ n : suf | n <- [lo .. hi], suf <- gen (k-1) (n, hi) ] in gen 3 (0, 3)
2023-01-07 17:30:25 +0100 <lambdabot> [[0,0,0],[0,0,1],[0,0,2],[0,0,3],[0,1,1],[0,1,2],[0,1,3],[0,2,2],[0,2,3],[0,...
2023-01-07 17:31:20 +0100 <mauke> > let gen 0 _ = [[]]; gen k (lo, hi) = [ n : suf | n <- [lo .. hi], suf <- gen (k-1) (n, hi) ] in gen 4 (0, 1)
2023-01-07 17:31:23 +0100 <lambdabot> [[0,0,0,0],[0,0,0,1],[0,0,1,1],[0,1,1,1],[1,1,1,1]]
2023-01-07 17:31:59 +0100 <mauke> :t let gen 0 _ = [[]]; gen k (lo, hi) = [ n : suf | n <- [lo .. hi], suf <- gen (k-1) (n, hi) ] in gen
2023-01-07 17:32:01 +0100 <lambdabot> (Eq t, Num t, Enum a) => t -> (a, a) -> [[a]]
2023-01-07 17:32:22 +0100 <mauke> good enough
2023-01-07 17:32:34 +0100 <stefan-_> I am working on AoC day 17 with a field type of `[Word8]` (bit-based operations), it turns out that drop, foldl+reverse and (++) take about 95% of the time
2023-01-07 17:32:50 +0100 <stefan-_> are there better alternatives than a list of Word8?
2023-01-07 17:33:43 +0100 <carbolymer> ByteString?
2023-01-07 17:33:43 +0100 <freeside> data.vector
2023-01-07 17:34:37 +0100 <freeside> looking at the puzzle, why not data.matrix
2023-01-07 17:37:08 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:cc20:d690:f22b:cb00)
2023-01-07 17:37:43 +0100 <dgpratt[m]> that appears to be exactly what I was trying to do, thanks mauke
2023-01-07 17:39:18 +0100 <stefan-_> freeside, part 2 requires a field height of 10^12, I guess I will run into space problems with Data.Matrix
2023-01-07 17:39:21 +0100 <dgpratt[m]> wish I could have figured that out myself, but I'll settle for knowing how to do it now :)
2023-01-07 17:39:27 +0100 <stefan-_> (probably also with [Word8])
2023-01-07 17:41:04 +0100 <byorgey> stefan-_: for part 2 you want to find a way to do it that doesn't require actually simulating/storing the entire thing.
2023-01-07 17:41:34 +0100 <byorgey> stefan-_: you might also consider a Set (Int,Int)
2023-01-07 17:41:42 +0100 <stefan-_> byorgey, there is a cycle after n*m steps, but I couldnt figure out how to make use of this information yet
2023-01-07 17:41:47 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:cc20:d690:f22b:cb00) (Ping timeout: 260 seconds)
2023-01-07 17:41:53 +0100 <stefan-_> byorgey, that was my first try
2023-01-07 17:41:54 +0100 <byorgey> stefan-_: yes, that's on the right track
2023-01-07 17:43:09 +0100 <byorgey> stefan-_: your first try was Set (Int,Int)? And it was too slow?
2023-01-07 17:43:47 +0100 <stefan-_> byorgey, it is currently twice as fast as the [Word8]-based solution, I just wanted to give [Word8] a try
2023-01-07 17:44:44 +0100 <byorgey> ah, I see. Yes, lists have a lot of overhead. They are great when used as a control structure, i.e. for loop, but not so good as a data structure
2023-01-07 17:44:58 +0100 <stefan-_> also it might be possible to prune the lower parts of the field, which are no longer reachable
2023-01-07 17:46:02 +0100 <byorgey> I don't do any pruning and my solution using Set (Int,Int) is quite fast (0.05s).
2023-01-07 17:49:20 +0100epolanski(uid312403@id-312403.helmsley.irccloud.com)
2023-01-07 17:49:33 +0100 <stefan-_> ok, then maybe I should put a bit more thought into the cycle structure
2023-01-07 17:49:49 +0100 <stefan-_> thanks for the help byorgey, freeside and carbolymer
2023-01-07 17:52:22 +0100 <kjlid[m]> So I'm using Data.Time.Format.ISO8601.iso8601Show to print a date but I currently get it in the format 2023-01-07T17:41:11.600203379+01:00 but I want it in the format 2023-01-07T17:51:34+01:00. How do I get rid of the milliseconds? Maybe it's just me but the documentation at https://hackage.haskell.org/package/time-1.12.2/docs/Data-Time-Format-ISO8601.html isn't completely obvious
2023-01-07 17:52:40 +0100 <kjlid[m]> s/milliseconds/decimals/
2023-01-07 17:53:33 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2023-01-07 17:54:07 +0100kora9(~kora@user/Kora9) (Quit: WeeChat 3.5)
2023-01-07 17:57:08 +0100jakalx(~jakalx@base.jakalx.net)
2023-01-07 17:59:43 +0100 <sm> aside: seriously, what the hell good is a "standard" you have to "buy"
2023-01-07 17:59:44 +0100 <sm> https://www.iso.org/obp/ui/#iso:std:iso:8601:ed-3:v1:en
2023-01-07 17:59:56 +0100 <sm> good morning all !
2023-01-07 18:00:30 +0100 <darkling> People have been asking that question for *years*.
2023-01-07 18:00:56 +0100 <sm> CHF187 to read it ?
2023-01-07 18:01:30 +0100 <c_wraith> It's way worse in some other fields. You have to pay thousands to get a copy of the legal requirements for construction in a lot of places.
2023-01-07 18:01:55 +0100 <sm> in that case, https://hackage.haskell.org/package/time-1.12.2/docs/Data-Time-Format-ISO8601.html delegating to it for documentation is a serious bug
2023-01-07 18:02:12 +0100 <freeside> http://blog.archive.org/2022/10/19/2022-internet-archive-hero-award-carl-malamud/
2023-01-07 18:02:51 +0100 <freeside> fortunatley ISO8601 is well enough explained elsewhere, e.g. https://en.wikipedia.org/wiki/ISO_8601
2023-01-07 18:04:38 +0100 <darkling> I've had to look at a bunch of geospatial standards recently. Fortunately, they're dual-published, so I suspect the OGC gets all the traffic to their version of the text, and the ISO gets a whole load of nope.
2023-01-07 18:04:49 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2023-01-07 18:05:12 +0100 <kjlid[m]> The C standard is CHF 208
2023-01-07 18:06:02 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 252 seconds)
2023-01-07 18:06:18 +0100 <sm> kjlid: I would avoid that module, unless you're willing to trial and error each of its formats, and make your own format instead using the codes at https://hackage.haskell.org/package/time-1.12.2/docs/Data-Time-Format.html
2023-01-07 18:06:19 +0100 <dolio> You can get old versions of that, at least.
2023-01-07 18:06:20 +0100 <kjlid[m]> Aww okay
2023-01-07 18:06:42 +0100 <dolio> For free, that is.
2023-01-07 18:07:00 +0100 <geekosaur> nobody reads it anyway 😈
2023-01-07 18:07:10 +0100 <dolio> I read it. :)
2023-01-07 18:07:19 +0100 <sm> I tried to read it just now
2023-01-07 18:08:42 +0100 <kjlid[m]> But you're too cheap to cough up a measly CHF187 to figure out how to format dates?
2023-01-07 18:09:41 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 18:10:08 +0100 <kjlid[m]> I wonder if the writer of this documentation actually paid up and figured everyone would do the same
2023-01-07 18:10:22 +0100 <freeside> https://www.amazon.com/Calendrical-Calculations-Ultimate-Edward-Reingold/dp/1107683165/ is a lot cheaper than the last time i looked
2023-01-07 18:10:30 +0100 <pragma-> "This standard has been withdrawn."
2023-01-07 18:10:41 +0100 <razetime> how do i apply a function to each element in a tuple?
2023-01-07 18:10:48 +0100 <pragma-> If y'all pay for a withdrawn standard, that's going to be even funnier.
2023-01-07 18:11:46 +0100 <c_wraith> razetime: there's no general tool for that. mostly because different sizes of tuple are completely unrelated types
2023-01-07 18:12:03 +0100 <razetime> i see. so it just needs to be pattern matched
2023-01-07 18:12:18 +0100 <c_wraith> :t bimap -- razetime: but if you're working with pairs, this exists
2023-01-07 18:12:20 +0100 <lambdabot> Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
2023-01-07 18:13:30 +0100 <ncf> if you've got lenses handy, `over each`
2023-01-07 18:13:45 +0100acidjnk(~acidjnk@p200300d6e715c403c13dad5c816a3096.dip0.t-ipconnect.de)
2023-01-07 18:13:55 +0100mbuf(~Shakthi@49.204.114.1) (Quit: Leaving)
2023-01-07 18:13:59 +0100 <c_wraith> ncf: I don't recommend that in general, because it requires every tuple element have the same type. That's not how tuples are usually used
2023-01-07 18:14:40 +0100 <ncf> fair
2023-01-07 18:14:58 +0100smimagines traffic lights that blink in special codes, you have to be a subscriber to know what they mean
2023-01-07 18:17:59 +0100jinsun__(~jinsun@user/jinsun)
2023-01-07 18:17:59 +0100jinsun(~jinsun@user/jinsun) (Killed (tantalum.libera.chat (Nickname regained by services)))
2023-01-07 18:17:59 +0100jinsun__jinsun
2023-01-07 18:18:51 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 268 seconds)
2023-01-07 18:19:48 +0100freeside(~mengwong@103.252.202.159)
2023-01-07 18:21:13 +0100 <darkling> sm: Don't give them ideas... :(
2023-01-07 18:22:23 +0100 <sm> traffic lights don't build themselves you know! We've got to fund them somehow
2023-01-07 18:22:26 +0100 <kjlid[m]> Oooh, I like it. Add microtransactions to traffic
2023-01-07 18:22:56 +0100 <[exa]> "pls show me how not to die on this crossroads" just for $1.35 *ka-ching*
2023-01-07 18:23:38 +0100 <darkling> How many brands of traffic light would you have to license in order to be able to use the self-drive on your car?
2023-01-07 18:23:44 +0100 <hpc> kjlid[m]: that's just toll roads :P
2023-01-07 18:23:49 +0100 <darkling> (Cost/month, of course)
2023-01-07 18:24:33 +0100 <[exa]> darkling: no problem there, self-driving can be cashed for separately
2023-01-07 18:25:12 +0100 <razetime> c_wraith: bimap is useful, thanks
2023-01-07 18:25:26 +0100 <razetime> well, until i decided to use a tuple of 4 values
2023-01-07 18:25:43 +0100 <[exa]> quadrimap!
2023-01-07 18:27:31 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 260 seconds)
2023-01-07 18:29:00 +0100freeside(~mengwong@103.252.202.159)
2023-01-07 18:30:08 +0100igghibu(~igghibu@178.249.211.75)
2023-01-07 18:33:15 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 252 seconds)
2023-01-07 18:36:13 +0100titibandit1(~titibandi@xdsl-87-78-235-220.nc.de)
2023-01-07 18:36:47 +0100 <MangoIV[m]> hcmap
2023-01-07 18:38:30 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Read error: Connection reset by peer)
2023-01-07 18:39:03 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-01-07 18:40:04 +0100titibandit1(~titibandi@xdsl-87-78-235-220.nc.de) (Remote host closed the connection)
2023-01-07 18:40:31 +0100 <mauke> :t bimap
2023-01-07 18:40:33 +0100 <lambdabot> Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
2023-01-07 18:41:18 +0100 <mauke> :t uncurry bimap . uncurry bimap
2023-01-07 18:41:20 +0100 <lambdabot> error:
2023-01-07 18:41:20 +0100 <lambdabot> • Couldn't match type ‘p0 a c -> p0 b d’
2023-01-07 18:41:20 +0100 <lambdabot> with ‘(a1 -> b1, c1 -> d1)’
2023-01-07 18:41:39 +0100 <mauke> oh, duh
2023-01-07 18:41:59 +0100gdd(~gdd@2001:470:1f13:187:31f4:d139:4ea3:c0fd) (Ping timeout: 246 seconds)
2023-01-07 18:42:54 +0100gdd(~gdd@2001:470:1f13:187:e8a5:fbff:fe29:42f5)
2023-01-07 18:44:44 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net)
2023-01-07 18:47:49 +0100freeside(~mengwong@103.252.202.159)
2023-01-07 18:55:44 +0100Profpatsch(~Profpatsc@static.88-198-193-255.clients.your-server.de)
2023-01-07 18:56:07 +0100 <Profpatsch> I saw a “Generalization of the difference list trick” thing somewher, either with Monoid or with Category
2023-01-07 18:56:55 +0100axeman(~quassel@2a02:8109:a3c0:ed8:53bb:6cbb:d8cb:4271) (Ping timeout: 260 seconds)
2023-01-07 18:57:08 +0100 <dolio> It's related to Cayley's theorem/the Yoneda lemma.
2023-01-07 18:57:21 +0100freemanX(~user@14.100.44.229)
2023-01-07 19:00:06 +0100 <Profpatsch> dolio: can you remember which module it was in?
2023-01-07 19:00:18 +0100 <razetime> is there an online editor for haskell which lets you load your program into ghci?
2023-01-07 19:00:28 +0100 <dolio> Probably Data.Monoid. Endo.
2023-01-07 19:00:35 +0100 <ncf> https://hackage.haskell.org/package/profunctors-5.6.2/docs/Data-Profunctor-Ran.html#t:Codensity
2023-01-07 19:00:44 +0100 <[exa]> razetime: see topic :]
2023-01-07 19:00:58 +0100 <[exa]> also repl.it had something if you need more complicated setups
2023-01-07 19:01:11 +0100 <ncf> or https://hackage.haskell.org/package/kan-extensions-5.2.5/docs/Control-Monad-Codensity.html
2023-01-07 19:02:02 +0100 <razetime> replit looks more like it, i need to load the file in the interpreter to test functions
2023-01-07 19:02:23 +0100 <Profpatsch> dolio: Aaaah, thank you, you are right, it’s in Data.Semigroup
2023-01-07 19:02:49 +0100 <geekosaur> tbh if I'm at that point, I'd go with local ghci. can install packages as well, which you generally can't with online setups
2023-01-07 19:03:01 +0100 <Inst> question
2023-01-07 19:03:08 +0100 <ncf> oh, *that* generalisation
2023-01-07 19:03:09 +0100 <Inst> is there an "IO problem" in Haskell?
2023-01-07 19:03:48 +0100 <ncf> what's an IO problem
2023-01-07 19:04:04 +0100 <Inst> that is to say, Haskell has a separation between pure and impure code, manifested by either the IO layer or monadic code
2023-01-07 19:04:14 +0100 <Inst> consequently, you have questions like:
2023-01-07 19:04:24 +0100 <Inst> "how much of my code should be pure and how much should be impure?"
2023-01-07 19:04:30 +0100 <Inst> "if i have to have impure code, how should I structure it?"
2023-01-07 19:04:50 +0100 <geekosaur> Inst, usually that's not a problem except to newcomers, instead it encourages separatingt your logic cleanly
2023-01-07 19:05:24 +0100enthropy(~enthropy@66.7.90.250)
2023-01-07 19:05:45 +0100 <Inst> the way I understand it is that all the effects systems are sort of a response to what I'd call the IO problem
2023-01-07 19:06:11 +0100 <dolio> What is the IO problem?
2023-01-07 19:06:21 +0100 <geekosaur> the way I understand it is effects systems are a response to a perceived problem with mtl
2023-01-07 19:06:30 +0100 <geekosaur> not with IO as such
2023-01-07 19:06:35 +0100 <Inst> i'm including MTL as an effects system
2023-01-07 19:07:05 +0100 <monochrom> There is no "IO problem". Let's end the pointless "discussion" and move on.
2023-01-07 19:07:15 +0100 <geekosaur> ^
2023-01-07 19:07:24 +0100Plebbu(~user@52.124.39.58)
2023-01-07 19:07:25 +0100 <Inst> okay, fine
2023-01-07 19:07:28 +0100 <ncf> oh man can we have the same monochrom in #categorytheory
2023-01-07 19:07:28 +0100 <geekosaur> I explained what's up with IO earlier
2023-01-07 19:07:42 +0100 <Inst> it's considered solved in Haskell
2023-01-07 19:07:49 +0100 <geekosaur> once you learn code structuring, IO is a friend, not a problem
2023-01-07 19:07:54 +0100 <dolio> I think the seeds of MTL might predate IO as a monad.
2023-01-07 19:08:11 +0100 <dolio> I assume Wadler's original monads paper has examples that aren't IO.
2023-01-07 19:08:14 +0100 <Inst> i default to doing all computations in as much pure code as possible
2023-01-07 19:08:25 +0100 <geekosaur> and what you learn with it will also benefit you in other languages
2023-01-07 19:08:34 +0100 <monochrom> ncf: I tried! Years ago I already predicted that heinz is a crackpot and suggested you guys to ban or at least ignore. Since then they have only become worse.
2023-01-07 19:08:38 +0100 <Inst> but sometimes i wonder if that's the best solution, especially since i prefer IO / pure isntead of monad trans
2023-01-07 19:09:07 +0100 <ncf> i don't even know who the mods are in that channel
2023-01-07 19:09:32 +0100 <ncf> apparently "tapas" is the founder... but they're not even in the channel
2023-01-07 19:09:47 +0100 <Inst> oh, i know who that is, you can find her on FP discord
2023-01-07 19:09:48 +0100 <ncf> sorry, wildly off-topic
2023-01-07 19:10:20 +0100 <Inst> geekosaur: as i've said before, I've reached 200:1 pure to IO ratios
2023-01-07 19:10:34 +0100 <Inst> but some programs you need more code in IO
2023-01-07 19:11:02 +0100 <Profpatsch> Inst: Isn’t that a moot discussion
2023-01-07 19:11:22 +0100 <Profpatsch> the same best practices apply whether you are writing Haskell or elisp or javascript
2023-01-07 19:12:09 +0100 <Inst> it's just weird when you're doing haskell and you have more than 50% of your code in IO
2023-01-07 19:12:24 +0100 <Profpatsch> No
2023-01-07 19:12:33 +0100 <Profpatsch> That’s the only code that does anything
2023-01-07 19:12:51 +0100 <Profpatsch> The rest is up to what you want to *do*
2023-01-07 19:12:53 +0100 <dolio> I write a lot of non-IO code that does stuff.
2023-01-07 19:13:06 +0100 <Profpatsch> if all you want to do is run a then b than c, that’s IO
2023-01-07 19:13:11 +0100 <Profpatsch> *then
2023-01-07 19:13:33 +0100 <Profpatsch> If you want to test shit or run it in a different way, then you should probably factor it out
2023-01-07 19:13:40 +0100 <Profpatsch> that’s all there is to it
2023-01-07 19:14:00 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-01-07 19:14:35 +0100 <Profpatsch> (Haskell provides a *lot* better mechanisms to factor stuff out than other languages do, which is its main advantage)
2023-01-07 19:14:40 +0100 <Inst> hmmmm, i just guess with more IO intensive code, I need more practice moving stuff out, like changing conditions to be based on a <$> isntead of a >>=, etc
2023-01-07 19:15:01 +0100 <Inst> and being better at isolating the stuff that actually calls IO
2023-01-07 19:15:21 +0100 <Profpatsch> Inst: floating out pure’s is a very simple refactor which will come naturally after a while
2023-01-07 19:15:46 +0100 <Profpatsch> writing left-to-right Haskell helps with that, but that’s just my opinion
2023-01-07 19:17:35 +0100 <ncf> what's a left-to-right haskell
2023-01-07 19:18:00 +0100 <Profpatsch> writing left to right, top to bottem
2023-01-07 19:18:03 +0100 <Profpatsch> *bottom
2023-01-07 19:18:25 +0100 <ncf> that's how most text editors work
2023-01-07 19:18:35 +0100 <monochrom> I guess it means "h >>> g >>> f" instead of "f . g . h"
2023-01-07 19:18:48 +0100 <Profpatsch> getLine <&> Text.pack <&> Text.split " " & traverse putStrLn
2023-01-07 19:19:10 +0100 <ncf> ah, diagrammatic order
2023-01-07 19:19:11 +0100 <ncf> i like that
2023-01-07 19:19:21 +0100 <Profpatsch> the last one should be a >>= instead of &
2023-01-07 19:19:37 +0100 <Inst> maybe could I get code review here?
2023-01-07 19:19:38 +0100 <Inst> https://github.com/liamzee/Dicewarist/blob/master/app/Dicewarist.hs
2023-01-07 19:21:05 +0100 <Profpatsch> But can be applied to pure code as well, e.g. myMap & Map.toList <&> Json.parse <&> eitherToValidationList & sequence & \case { Failure errs -> error errs; Success a -> pure a }
2023-01-07 19:21:32 +0100 <Profpatsch> (ofc this would go on a bunch of lines instead but for the sake of brevity)
2023-01-07 19:29:33 +0100 <enthropy> writing code for dear-imgui makes me want static variables. IE. an IORef defined where it's used but one that keeps the old value across iterations of mainLoop. Since template haskell now supports -XImplicitParams it seems like I could have $(ref "x" mempty) expand out to "?x_unique_number", and then I can generate the first part of  main = do x_1
2023-01-07 19:29:34 +0100 <enthropy> <- newIORef mempty; let ?x_1 = x_1 in mainLoop. Or does such a thing already exist?
2023-01-07 19:30:43 +0100razetime(~Thunderbi@49.207.222.244) (Remote host closed the connection)
2023-01-07 19:33:31 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-01-07 19:34:11 +0100 <enthropy> is it correct that the unsafePerformIO newIORef trick only works at top-level?
2023-01-07 19:35:54 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Quit: WeeChat 3.7.1)
2023-01-07 19:37:16 +0100 <monochrom> I don't know about "only", but I know about "simplest to predict".
2023-01-07 19:38:31 +0100 <monochrom> A reassuring thought being that base itself needs a few of those too, so you know that GHC cannot mishandle them.
2023-01-07 19:38:39 +0100 <geekosaur> I'd say "only necessary"
2023-01-07 19:39:13 +0100 <geekosaur> because anywhere else you have control over it already
2023-01-07 19:39:47 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340)
2023-01-07 19:49:31 +0100CiaoSen(~Jura@p200300c9572e35002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-01-07 19:52:27 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 248 seconds)
2023-01-07 19:57:35 +0100mc47(~mc47@xmonad/TheMC47) (Quit: Leaving)
2023-01-07 19:58:15 +0100mc47(~mc47@xmonad/TheMC47)
2023-01-07 20:06:16 +0100mei(~mei@user/mei) (Quit: mei)
2023-01-07 20:06:52 +0100jinsunGuest3215
2023-01-07 20:06:52 +0100jinsun__(~jinsun@user/jinsun)
2023-01-07 20:06:52 +0100Guest3215(~jinsun@user/jinsun) (Killed (molybdenum.libera.chat (Nickname regained by services)))
2023-01-07 20:06:52 +0100jinsun__jinsun
2023-01-07 20:10:57 +0100freeside(~mengwong@103.252.202.159)
2023-01-07 20:15:50 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 272 seconds)
2023-01-07 20:16:44 +0100freeside(~mengwong@103.252.202.159)
2023-01-07 20:19:48 +0100cameron_(~quassel@050-089-109-059.res.spectrum.com)
2023-01-07 20:21:25 +0100jinsun(~jinsun@user/jinsun) (Read error: Connection reset by peer)
2023-01-07 20:21:26 +0100Plebbu(~user@52.124.39.58) (Quit: ERC 5.4 (IRC client for GNU Emacs 28.2.50))
2023-01-07 20:21:39 +0100jinsun(~jinsun@user/jinsun)
2023-01-07 20:23:54 +0100Kaipei(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net) (Ping timeout: 252 seconds)
2023-01-07 20:23:56 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-01-07 20:26:14 +0100phma(~phma@host-67-44-208-26.hnremote.net) (Read error: Connection reset by peer)
2023-01-07 20:27:02 +0100wroathe(~wroathe@50.205.197.50)
2023-01-07 20:27:02 +0100wroathe(~wroathe@50.205.197.50) (Changing host)
2023-01-07 20:27:02 +0100wroathe(~wroathe@user/wroathe)
2023-01-07 20:27:21 +0100phma(phma@2001:5b0:210d:7648:cd95:5ae2:112e:6872)
2023-01-07 20:27:58 +0100econo(uid147250@user/econo)
2023-01-07 20:28:03 +0100lbseale(~quassel@user/ep1ctetus) (Ping timeout: 260 seconds)
2023-01-07 20:29:48 +0100freemanX(~user@14.100.44.229) (Remote host closed the connection)
2023-01-07 20:30:32 +0100Benzi-Junior(~BenziJuni@dsl-149-66-52.hive.is)
2023-01-07 20:30:35 +0100foul_owl(~kerry@157.97.134.61) (Ping timeout: 252 seconds)
2023-01-07 20:30:54 +0100 <Benzi-Junior> What does (..) mean in imoprt ?
2023-01-07 20:31:20 +0100cameron_scoopahdoopah
2023-01-07 20:32:29 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 260 seconds)
2023-01-07 20:32:31 +0100 <enthropy> I wrote the implicitparams/template haskell option https://gist.github.com/aavogt/2312f92289b1bcf65cd506b365949a56 but I don't see the mistake in my generated code that ghc is pointing out
2023-01-07 20:32:53 +0100 <Benzi-Junior> i.e. "import Types (MTL (..))"
2023-01-07 20:32:54 +0100 <boxscape_> Benzi-Junior if you have `import Data.Maybe (Maybe(..))` it means import Maybe and all its constructors, i.e. Nothing and Just
2023-01-07 20:35:46 +0100Kaipei(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net)
2023-01-07 20:36:19 +0100 <Benzi-Junior> boxscape_, ahh that makes sense
2023-01-07 20:37:07 +0100wroathe(~wroathe@50.205.197.50)
2023-01-07 20:37:07 +0100wroathe(~wroathe@50.205.197.50) (Changing host)
2023-01-07 20:37:07 +0100wroathe(~wroathe@user/wroathe)
2023-01-07 20:39:20 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:cc20:d690:f22b:cb00)
2023-01-07 20:40:37 +0100 <Benzi-Junior> also in the line "data TL = TL {}" what is the significance of "{}"
2023-01-07 20:41:00 +0100 <Benzi-Junior> I mean it seems to me to be a constructor with 0 named fields
2023-01-07 20:41:27 +0100 <boxscape_> that is correct
2023-01-07 20:41:42 +0100 <boxscape_> it's the same as `data TL  = TL`
2023-01-07 20:42:13 +0100 <Benzi-Junior> ok I guess that means Im expected to fill it in
2023-01-07 20:42:18 +0100fizbin(~fizbin@user/fizbin)
2023-01-07 20:42:48 +0100 <boxscape_> hm, could be, depends on what the task is I suppose
2023-01-07 20:43:24 +0100 <Benzi-Junior> I hate doing programming tests, I never know what parts I should be changing and which ones are just setup
2023-01-07 20:43:55 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:cc20:d690:f22b:cb00) (Ping timeout: 260 seconds)
2023-01-07 20:43:56 +0100 <boxscape_> hm sounds like what you hate is poorly designed programming tests :P
2023-01-07 20:45:17 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:cc20:d690:f22b:cb00)
2023-01-07 20:45:56 +0100boxscape_(~boxscape_@81.191.27.107) (Quit: Connection closed)
2023-01-07 20:46:36 +0100foul_owl(~kerry@193.29.61.203)
2023-01-07 20:47:16 +0100gmg(~user@user/gehmehgeh)
2023-01-07 20:48:51 +0100epolanski(uid312403@id-312403.helmsley.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-07 20:49:57 +0100boxscape_(~boxscape_@81.191.27.107)
2023-01-07 20:51:18 +0100fizbin(~fizbin@user/fizbin) (Ping timeout: 272 seconds)
2023-01-07 20:55:09 +0100Sgeo(~Sgeo@user/sgeo)
2023-01-07 20:57:11 +0100ddellacosta(~ddellacos@89.45.224.178) (Ping timeout: 264 seconds)
2023-01-07 20:57:50 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-01-07 21:00:31 +0100califax(~califax@user/califx)
2023-01-07 21:02:24 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-01-07 21:02:37 +0100iqubic(~avi@2601:602:9502:c70:8f59:bc2:c041:8ab2)
2023-01-07 21:03:22 +0100califax(~califax@user/califx)
2023-01-07 21:04:04 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2023-01-07 21:04:54 +0100jakalx(~jakalx@base.jakalx.net)
2023-01-07 21:05:14 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-01-07 21:06:53 +0100CiaoSen(~Jura@p200300c9572e35002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-01-07 21:10:06 +0100 <enthropy> I solved my problem above and updated the gist. The issue is the same as: `(\e -> let ?x = "" in e) ?x` doesn't work like `let ?x = "" in ?x` does.
2023-01-07 21:12:01 +0100acidjnk(~acidjnk@p200300d6e715c403c13dad5c816a3096.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-01-07 21:16:14 +0100cyphase(~cyphase@user/cyphase) (Ping timeout: 260 seconds)
2023-01-07 21:16:27 +0100Guest9971(~finn@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2023-01-07 21:18:34 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-07 21:20:02 +0100cyphase(~cyphase@user/cyphase)
2023-01-07 21:20:12 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 21:21:42 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 272 seconds)
2023-01-07 21:22:34 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-07 21:23:37 +0100hueso(~root@user/hueso) (Quit: hueso)
2023-01-07 21:23:54 +0100acidjnk(~acidjnk@p200300d6e715c403c13dad5c816a3096.dip0.t-ipconnect.de)
2023-01-07 21:25:22 +0100justsomeguy(~justsomeg@user/justsomeguy)
2023-01-07 21:33:10 +0100caef^(~caef@76.145.190.81)
2023-01-07 21:33:12 +0100freeside(~mengwong@103.252.202.159)
2023-01-07 21:35:03 +0100enthropy(~enthropy@66.7.90.250) (Quit: Client closed)
2023-01-07 21:41:37 +0100briandaed(~briandaed@185.234.210.211.r.toneticgroup.pl)
2023-01-07 21:55:24 +0100panovia(~user@user/siracusa)
2023-01-07 21:59:17 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-01-07 22:01:56 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 265 seconds)
2023-01-07 22:07:26 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-07 22:08:49 +0100echoreply(~echoreply@45.32.163.16)
2023-01-07 22:15:39 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2023-01-07 22:16:08 +0100wroathe(~wroathe@50.205.197.50)
2023-01-07 22:16:08 +0100wroathe(~wroathe@50.205.197.50) (Changing host)
2023-01-07 22:16:08 +0100wroathe(~wroathe@user/wroathe)
2023-01-07 22:20:35 +0100AlexNoo_(~AlexNoo@178.34.160.164)
2023-01-07 22:20:35 +0100Alex_test(~al_test@178.34.160.164) (Ping timeout: 268 seconds)
2023-01-07 22:21:02 +0100Alex_test(~al_test@178.34.160.164)
2023-01-07 22:21:12 +0100AlexNoo(~AlexNoo@178.34.160.164) (Ping timeout: 268 seconds)
2023-01-07 22:21:21 +0100fizbin(~fizbin@user/fizbin)
2023-01-07 22:21:23 +0100AlexNoo_AlexNoo
2023-01-07 22:21:52 +0100AlexZenon(~alzenon@178.34.160.164) (Ping timeout: 272 seconds)
2023-01-07 22:22:37 +0100briandaed(~briandaed@185.234.210.211.r.toneticgroup.pl) (Remote host closed the connection)
2023-01-07 22:22:44 +0100AlexZenon(~alzenon@178.34.160.164)
2023-01-07 22:23:42 +0100esph(~weechat@user/esph)
2023-01-07 22:25:37 +0100justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 265 seconds)
2023-01-07 22:25:40 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 272 seconds)
2023-01-07 22:27:49 +0100lbseale(~quassel@user/ep1ctetus)
2023-01-07 22:28:29 +0100fizbin(~fizbin@user/fizbin) (Ping timeout: 246 seconds)
2023-01-07 22:29:04 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2023-01-07 22:37:51 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2023-01-07 22:38:47 +0100Lycurgus(~juan@user/Lycurgus)
2023-01-07 22:40:49 +0100hueso(~root@user/hueso)
2023-01-07 22:45:06 +0100wroathe_(~wroathe@50.205.197.50)
2023-01-07 22:45:38 +0100wroathe(~wroathe@user/wroathe) (Killed (NickServ (GHOST command used by wroathe_!~wroathe@50.205.197.50)))
2023-01-07 22:45:47 +0100wroathe_wroathe
2023-01-07 22:45:59 +0100wroathe(~wroathe@50.205.197.50) (Changing host)
2023-01-07 22:45:59 +0100wroathe(~wroathe@user/wroathe)
2023-01-07 22:50:55 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 22:53:35 +0100gmg(~user@user/gehmehgeh) (Ping timeout: 255 seconds)
2023-01-07 22:53:54 +0100mechap(~mechap@user/mechap) (Ping timeout: 268 seconds)
2023-01-07 22:55:02 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 246 seconds)
2023-01-07 22:55:23 +0100mechap(~mechap@user/mechap)
2023-01-07 23:01:23 +0100gmg(~user@user/gehmehgeh)
2023-01-07 23:02:02 +0100talismanick(~talismani@2601:644:9380:5c00::43de) (Ping timeout: 255 seconds)
2023-01-07 23:02:18 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 23:06:32 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:cc20:d690:f22b:cb00) (Remote host closed the connection)
2023-01-07 23:06:50 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 268 seconds)
2023-01-07 23:08:18 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:cc20:d690:f22b:cb00)
2023-01-07 23:08:21 +0100phma(phma@2001:5b0:210d:7648:cd95:5ae2:112e:6872) (Read error: Connection reset by peer)
2023-01-07 23:09:02 +0100phma(~phma@host-67-44-208-226.hnremote.net)
2023-01-07 23:12:02 +0100gmg(~user@user/gehmehgeh) (Ping timeout: 255 seconds)
2023-01-07 23:14:20 +0100justsomeguy(~justsomeg@user/justsomeguy)
2023-01-07 23:14:43 +0100boxscape_(~boxscape_@81.191.27.107) (Quit: Connection closed)
2023-01-07 23:14:50 +0100L29Ah(~L29Ah@wikipedia/L29Ah) ()
2023-01-07 23:15:08 +0100L29Ah(~L29Ah@wikipedia/L29Ah)
2023-01-07 23:15:24 +0100 <justsomeguy> Hi Haskell. I'm thinking of switching to GHCi as my interactive command-line shell, in order to learn by immersion. If you've tried this before -- how did it go?
2023-01-07 23:16:18 +0100 <geekosaur> you probably want to look into
2023-01-07 23:16:23 +0100 <geekosaur> @hackage turtle
2023-01-07 23:16:24 +0100 <lambdabot> https://hackage.haskell.org/package/turtle
2023-01-07 23:19:49 +0100 <justsomeguy> Oh, this is fun. :)
2023-01-07 23:21:23 +0100justsomeguysips coffee while stack compiles 21 new packages...
2023-01-07 23:23:14 +0100 <sm> beats punching in hex codes, eh ??
2023-01-07 23:24:20 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-07 23:24:36 +0100 <DigitalKiwi> there's also shelly, shh, and HSH
2023-01-07 23:24:58 +0100 <dolio> Yeah, I wouldn't use ghci as a shell. It's really not built for that.
2023-01-07 23:25:21 +0100 <DigitalKiwi> https://gist.github.com/Kiwi/ffc08bffb15798dc4b1ec2a1c47c6191#file-program-cabal-hs
2023-01-07 23:26:33 +0100 <justsomeguy> It's really just a way to force myself to interact with Haskell for learning purposes. I like learning this way. I learned the linux cli by switching to text mode and getting rid of my other OS. I also had python as my interactive prompt for a few months.
2023-01-07 23:27:14 +0100 <dolio> It's probably worse than python. But the latter also sounds terrible to me.
2023-01-07 23:27:52 +0100 <dolio> I use ghci any time I have, like, random calculations to do, though.
2023-01-07 23:28:12 +0100 <[exa]> justsomeguy: force a hobby project into haskell, that helps. ghci isn't much of a productivity tool AFAIK, more like introspection/quickhacking/debugging
2023-01-07 23:29:53 +0100 <DigitalKiwi> shellcheck is the closest i get to using haskell for my shell
2023-01-07 23:30:23 +0100 <justsomeguy> You can even use it in your shell ^_^ https://github.com/HenrikBengtsson/shellcheck-repl
2023-01-07 23:30:24 +0100igghibu(~igghibu@178.249.211.75) (Quit: igghibu)
2023-01-07 23:30:25 +0100 <Jadesheit[m]> dolio: yup same
2023-01-07 23:31:30 +0100 <DigitalKiwi> somehow i always end up stuck on the second step of the atrocious/marvelous bash one liners -> bash script -> haskell rewrite pipeline
2023-01-07 23:32:01 +0100 <DigitalKiwi> dolio: yup i have ghci on my phone for that lol
2023-01-07 23:32:33 +0100 <DigitalKiwi> https://github.com/t184256/nix-on-droid
2023-01-07 23:33:04 +0100 <justsomeguy> To be honest I have way too many 30+ line bash scripts. I try to rewrite them a function at a time, but I'm just not that good at proper programming yet.
2023-01-07 23:34:09 +0100 <dolio> Anyhow, you can do it. I just don't think you're going to enjoy writing `putStrLn =<< readCreateProcess (shell "ls") ""` instead of `ls`. And I'm not sure it'll actually teach much useful, either.
2023-01-07 23:35:20 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 272 seconds)
2023-01-07 23:35:51 +0100 <DigitalKiwi> https://github.com/luke-clifton/shh
2023-01-07 23:36:44 +0100 <DigitalKiwi> lol HSH https://wiki.github.com/jgoerzen/hsh
2023-01-07 23:39:31 +0100 <DigitalKiwi> https://github.com/jekor/redo this is a fun project/video series
2023-01-07 23:39:32 +0100Guest6780(~finn@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2023-01-07 23:39:51 +0100 <DigitalKiwi> https://www.youtube.com/watch?v=zZ_nI9E9g0I&list=PLxj9UAX4Em-Ij4TKwKvo-SLp-Zbv-hB4B
2023-01-07 23:42:17 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-01-07 23:43:39 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-01-07 23:44:17 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-01-07 23:45:12 +0100haritz(~hrtz@user/haritz) (Ping timeout: 252 seconds)
2023-01-07 23:45:14 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-01-07 23:45:39 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-01-07 23:46:53 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-01-07 23:47:49 +0100 <DigitalKiwi> github be like never send that request again me be like i'm going to get everyone i know to send it
2023-01-07 23:48:56 +0100cheater_(~Username@user/cheater)
2023-01-07 23:50:10 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-01-07 23:51:51 +0100cheater(~Username@user/cheater) (Ping timeout: 268 seconds)
2023-01-07 23:52:00 +0100cheater_cheater
2023-01-07 23:58:20 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)