IRCBrowse

2026/02/24

2026-02-24 00:04:22 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 00:06:46 +0100tromp(~textual@2001:1c00:3487:1b00:1a7:fa86:12e2:7e3d) (Quit: My iMac has gone to sleep. ZZZzzz…)
2026-02-24 00:08:39 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 245 seconds)
2026-02-24 00:11:25 +0100Anarchos(~Anarchos@91-161-254-16.subs.proxad.net) (Quit: Vision[]: i've been blurred!)
2026-02-24 00:13:32 +0100peterbecich(~Thunderbi@71.84.33.135) (Quit: peterbecich)
2026-02-24 00:18:08 +0100 <Leary> geekosaur: I got two of them revised eariler, but now the refined invocation looks like this: <https://gist.github.com/LSLeary/52377ecaa9e9090c7e26b91945f6d587>. I'm not sure I have it in me. <.<
2026-02-24 00:19:44 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 00:21:26 +0100dutchie(~dutchie@user/dutchie) (Server closed connection)
2026-02-24 00:21:39 +0100dutchie(~dutchie@user/dutchie) dutchie
2026-02-24 00:22:49 +0100Googulator(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu) (Quit: Client closed)
2026-02-24 00:23:06 +0100Googulator(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu)
2026-02-24 00:24:00 +0100v0id_7(~v0id_7@user/v0id-7:62772) (Quit: whatever u sick fcks)
2026-02-24 00:24:19 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-24 00:29:13 +0100_________(~nobody@user/noodly) (Ping timeout: 248 seconds)
2026-02-24 00:30:35 +0100 <geekosaur> mm, maybe the right thing to do in that case is put the correct base bound in the cabal file and maintainer-revision it down on Hackage until the coast is clear
2026-02-24 00:31:28 +0100machinedgod(~machinedg@d172-219-48-230.abhsia.telus.net) machinedgod
2026-02-24 00:33:54 +0100jtnuttall(~jeremy@user/jeremyn) (Ping timeout: 268 seconds)
2026-02-24 00:35:07 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 00:36:21 +0100_________(~nobody@user/noodly) _________
2026-02-24 00:37:37 +0100BNC-37(~BNC-37@2a02:8109:9f07:de00:1016:a08e:bc74:c664)
2026-02-24 00:39:11 +0100BNC-37(~BNC-37@2a02:8109:9f07:de00:1016:a08e:bc74:c664) (Client Quit)
2026-02-24 00:39:40 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 255 seconds)
2026-02-24 00:40:39 +0100gmg(~user@user/gehmehgeh) (Remote host closed the connection)
2026-02-24 00:40:40 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2026-02-24 00:41:02 +0100ChaiTRex(~ChaiTRex@user/chaitrex) ChaiTRex
2026-02-24 00:41:31 +0100gmg(~user@user/gehmehgeh) gehmehgeh
2026-02-24 00:44:14 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2026-02-24 00:44:34 +0100ChaiTRex(~ChaiTRex@user/chaitrex) ChaiTRex
2026-02-24 00:45:16 +0100Alex_delenda_est(~al_test@178.34.151.130) (Ping timeout: 256 seconds)
2026-02-24 00:45:45 +0100AlexZenon(~alzenon@178.34.151.130) (Ping timeout: 248 seconds)
2026-02-24 00:46:18 +0100Googulator(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu) (Quit: Client closed)
2026-02-24 00:46:28 +0100AlexNoo(~AlexNoo@178.34.151.130) (Ping timeout: 268 seconds)
2026-02-24 00:46:33 +0100Googulator(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu)
2026-02-24 00:50:29 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 00:51:22 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine)
2026-02-24 00:51:44 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) Lord_of_Life
2026-02-24 00:57:20 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 268 seconds)
2026-02-24 01:05:57 +0100bryanv(~quassel@2603:c028:4503:7500:45b7:933:ab17:bc10) (Server closed connection)
2026-02-24 01:06:10 +0100bryanv(~quassel@2603:c028:4503:7500:45b7:933:ab17:bc10)
2026-02-24 01:06:51 +0100humasect(~humasect@dyn-192-249-132-90.nexicom.net) (Quit: Leaving...)
2026-02-24 01:08:31 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 01:13:36 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 268 seconds)
2026-02-24 01:19:37 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2026-02-24 01:19:57 +0100ChaiTRex(~ChaiTRex@user/chaitrex) ChaiTRex
2026-02-24 01:23:53 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 01:28:21 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 255 seconds)
2026-02-24 01:31:17 +0100Raito_Bezarius(~Raito@libera/contributor/wireguard.tunneler.raito-bezarius) (Server closed connection)
2026-02-24 01:31:59 +0100Raito_Bezarius(~Raito@libera/contributor/wireguard.tunneler.raito-bezarius) Raito_Bezarius
2026-02-24 01:33:17 +0100fgaz(1ff9197ed6@2a03:6000:1812:100::11ea) (Server closed connection)
2026-02-24 01:33:24 +0100fgaz(1ff9197ed6@2a03:6000:1812:100::11ea) fgaz
2026-02-24 01:38:27 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 01:41:14 +0100ljdarj(~Thunderbi@user/ljdarj) (Ping timeout: 252 seconds)
2026-02-24 01:43:12 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 255 seconds)
2026-02-24 01:48:08 +0100Square3(~Square@user/square) Square
2026-02-24 01:48:57 +0100arandombit(~arandombi@user/arandombit) arandombit
2026-02-24 01:51:17 +0100orcus(~orcus@user/brprice) (Server closed connection)
2026-02-24 01:51:26 +0100jtnuttall(~jeremy@user/jeremyn) jeremyn
2026-02-24 01:51:36 +0100orcus(~orcus@user/brprice) brprice
2026-02-24 01:53:49 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 01:53:57 +0100haasn(sid579015@id-579015.hampstead.irccloud.com) (Server closed connection)
2026-02-24 01:54:21 +0100haasn(sid579015@id-579015.hampstead.irccloud.com) haasn
2026-02-24 01:55:17 +0100edm(sid147314@id-147314.hampstead.irccloud.com) (Server closed connection)
2026-02-24 01:55:40 +0100edm(sid147314@id-147314.hampstead.irccloud.com)
2026-02-24 01:56:09 +0100xff0x(~xff0x@2405:6580:b080:900:c463:24ea:8f04:8fed) (Ping timeout: 248 seconds)
2026-02-24 01:58:23 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 268 seconds)
2026-02-24 02:09:12 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 02:13:39 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 245 seconds)
2026-02-24 02:16:37 +0100Tuplanolla(~Tuplanoll@88-114-89-88.elisa-laajakaista.fi) (Quit: Leaving.)
2026-02-24 02:17:11 +0100Googulator(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu) (Quit: Client closed)
2026-02-24 02:17:18 +0100Googulator51(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu)
2026-02-24 02:18:10 +0100emmanuelux(~em@user/emmanuelux) (Read error: Connection reset by peer)
2026-02-24 02:20:27 +0100Googulator17(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu)
2026-02-24 02:20:27 +0100Googulator51(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu) (Client Quit)
2026-02-24 02:24:35 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 02:28:10 +0100Googulator17(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu) (Quit: Client closed)
2026-02-24 02:28:18 +0100Googulator17(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu)
2026-02-24 02:31:21 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 255 seconds)
2026-02-24 02:32:20 +0100califax(~califax@user/califx) (Remote host closed the connection)
2026-02-24 02:36:34 +0100califax(~califax@user/califx) califx
2026-02-24 02:42:37 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 02:44:06 +0100nonzen(~nonzen@user/nonzen) (Server closed connection)
2026-02-24 02:44:22 +0100nonzen(~nonzen@user/nonzen) nonzen
2026-02-24 02:47:07 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-24 02:49:33 +0100xff0x(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp)
2026-02-24 02:51:25 +0100paddymahoney(~paddymaho@pool-99-250-10-137.cpe.net.cable.rogers.com) (Ping timeout: 268 seconds)
2026-02-24 02:52:03 +0100jtnuttall(~jeremy@user/jeremyn) (Ping timeout: 255 seconds)
2026-02-24 02:55:17 +0100paddymahoney(~paddymaho@pool-99-250-10-137.cpe.net.cable.rogers.com)
2026-02-24 02:57:59 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 02:59:37 +0100peterbecich(~Thunderbi@71.84.33.135) peterbecich
2026-02-24 03:01:54 +0100arandombit(~arandombi@user/arandombit) (Ping timeout: 268 seconds)
2026-02-24 03:02:24 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 256 seconds)
2026-02-24 03:08:06 +0100JSharp(sid4580@user/JSharp) (Server closed connection)
2026-02-24 03:08:25 +0100JSharp(sid4580@user/JSharp) JSharp
2026-02-24 03:10:06 +0100unlucy(sid572875@user/unlucy) (Server closed connection)
2026-02-24 03:10:35 +0100unlucy(sid572875@user/unlucy) unlucy
2026-02-24 03:13:22 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 03:17:56 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 268 seconds)
2026-02-24 03:21:54 +0100weary-traveler(~user@user/user363627) user363627
2026-02-24 03:28:45 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 03:31:07 +0100stef204(~stef204@user/stef204) (Quit: WeeChat 4.2.1)
2026-02-24 03:33:13 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 248 seconds)
2026-02-24 03:33:43 +0100jtnuttall(~jeremy@user/jeremyn) jeremyn
2026-02-24 03:34:06 +0100piele(~piele@eiseth.creativeserver.net) (Server closed connection)
2026-02-24 03:34:18 +0100piele(~piele@eiseth.creativeserver.net)
2026-02-24 03:36:00 +0100bjorkintosh(~bjork@user/bjorkintosh) bjorkintosh
2026-02-24 03:36:01 +0100bjorkintosh(~bjork@user/bjorkintosh) (Leaving)
2026-02-24 03:44:06 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 03:46:37 +0100hook54321(sid149355@user/hook54321) (Server closed connection)
2026-02-24 03:47:53 +0100hook54321(sid149355@user/hook54321) hook54321
2026-02-24 03:48:46 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 268 seconds)
2026-02-24 03:48:53 +0100Googulator17(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu) (Quit: Client closed)
2026-02-24 03:49:08 +0100Googulator17(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu)
2026-02-24 03:51:53 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 03:55:40 +0100peterbecich(~Thunderbi@71.84.33.135) (Ping timeout: 256 seconds)
2026-02-24 03:56:43 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-24 04:07:10 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 04:14:03 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 268 seconds)
2026-02-24 04:16:31 +0100Googulator17(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu) (Quit: Client closed)
2026-02-24 04:16:46 +0100Googulator17(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu)
2026-02-24 04:21:26 +0100Logio(em@kapsi.fi) (Server closed connection)
2026-02-24 04:21:36 +0100Logio(em@kapsi.fi) Logio
2026-02-24 04:21:46 +0100arandombit(~arandombi@user/arandombit) arandombit
2026-02-24 04:25:06 +0100 <Leary> Upper bounds aside, `cabal check` doesn't seem to care about lower bounds. Does that mean I can give up on the archaeology necessary to find them?
2026-02-24 04:25:12 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 04:27:37 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine)
2026-02-24 04:27:49 +0100humasect(~humasect@dyn-192-249-132-90.nexicom.net) humasect
2026-02-24 04:28:08 +0100haskell-noob(~haskell-n@50.35.80.129) (Quit: Client closed)
2026-02-24 04:28:36 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) Lord_of_Life
2026-02-24 04:29:40 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 256 seconds)
2026-02-24 04:34:26 +0100 <monochrom> I usually do. I set my lower bounds to be what I happen to have when I start the project. Then I don't change them until someone wants it changed.
2026-02-24 04:39:28 +0100 <Leary> Well, in that case you're setting them conservatively. I was more wondering about the opposite strategy of omitting them entirely.
2026-02-24 04:40:33 +0100werneta(~werneta@71.83.160.242) werneta
2026-02-24 04:40:34 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 04:40:40 +0100xff0x_(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp)
2026-02-24 04:41:00 +0100arandombit(~arandombi@user/arandombit) (Ping timeout: 256 seconds)
2026-02-24 04:41:24 +0100machinedgod(~machinedg@d172-219-48-230.abhsia.telus.net) (Ping timeout: 255 seconds)
2026-02-24 04:42:45 +0100xff0x(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp) (Ping timeout: 255 seconds)
2026-02-24 04:44:13 +0100peterbecich(~Thunderbi@71.84.33.135) peterbecich
2026-02-24 04:44:59 +0100xff0x_xff0x
2026-02-24 04:45:00 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 255 seconds)
2026-02-24 04:45:11 +0100 <monochrom> Then one day you will run into something like this recent example: https://discourse.haskell.org/t/breaking-changes-in-time-1-15-ghc-9-14/13711
2026-02-24 04:45:53 +0100 <monochrom> (time-1.15 adds new pattern synonyms that name-clashes with someone's existing code that assumes <=1.14)
2026-02-24 04:47:26 +0100APic(apic@apic.name) (Server closed connection)
2026-02-24 04:47:26 +0100 <monochrom> So if you set a lower bound like <=1.14 or 1.13, the worst that can happen is cabal downloads and builds an appropriate version of time. If you don't set a lower bound, now you have to set a lower bound.
2026-02-24 04:47:38 +0100APic(apic@apic.name) APic
2026-02-24 04:55:56 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 04:59:57 +0100yahb2(~yahb2@user/tomsmeding/bot/yahb2) (Server closed connection)
2026-02-24 05:00:19 +0100yahb2(~yahb2@user/tomsmeding/bot/yahb2) yahb2
2026-02-24 05:00:19 +0100ChanServ+v yahb2
2026-02-24 05:00:20 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds)
2026-02-24 05:08:53 +0100 <Leary> In that particular case, I think the actual issue is importing without concern for namespace pollution. Also, that's an upper bound?
2026-02-24 05:09:15 +0100 <Leary> Reflecting things a bit, your point seems to be that an older version of a dependency (than is implicitly assumed) may be used to build the package, causing it to fail.
2026-02-24 05:09:40 +0100 <Leary> But the alternative of refusing to build what would have succeeded doesn't really seem better; either way the bound is wrong and you're relying on intrepid explorers to eventually correct it.
2026-02-24 05:09:55 +0100arahael(~wetfoot@user/arahael) (Ping timeout: 265 seconds)
2026-02-24 05:11:17 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 05:16:03 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 255 seconds)
2026-02-24 05:17:42 +0100ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2026-02-24 05:18:07 +0100ec(~ec@gateway/tor-sasl/ec) ec
2026-02-24 05:18:18 +0100 <monochrom> Oh oops yeah that's an upper bound.
2026-02-24 05:20:06 +0100eL_Bart0-(eL_Bart02@dietunichtguten.org) (Server closed connection)
2026-02-24 05:20:19 +0100eL_Bart0(eL_Bart02@dietunichtguten.org)
2026-02-24 05:20:33 +0100lbseale(~quassel@user/ep1ctetus) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2026-02-24 05:21:17 +0100lbseale(~quassel@user/ep1ctetus) ep1ctetus
2026-02-24 05:23:56 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com) lisbeths
2026-02-24 05:26:39 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 05:31:21 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 255 seconds)
2026-02-24 05:32:27 +0100 <geekosaur> ithis is a long-running argument, and there are no real solutions because you can't reliably infer upper or lower bounds; you or someone else must experiment or actively test
2026-02-24 05:32:46 +0100eso(a0662dfd5e@2a03:6000:1812:100::1266) (Server closed connection)
2026-02-24 05:32:49 +0100 <geekosaur> and leaving either off forces others to do it for you by their tripping over it
2026-02-24 05:32:54 +0100eso(a0662dfd5e@2a03:6000:1812:100::1266) jeso
2026-02-24 05:42:01 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 05:42:51 +0100Athas(athas@2a01:7c8:aaac:1cf:acb7:4f2b:6164:21c9) (Quit: ZNC 1.9.1 - https://znc.in)
2026-02-24 05:43:03 +0100Athas(athas@2a01:7c8:aaac:1cf:10a0:cce8:21cf:53aa)
2026-02-24 05:43:37 +0100michalz(~michalz@185.246.207.221)
2026-02-24 05:46:46 +0100doyougnu(~doyougnu@38.175.72.111) (Server closed connection)
2026-02-24 05:47:32 +0100doyougnu(~doyougnu@38.175.72.111) doyougnu
2026-02-24 05:49:04 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 265 seconds)
2026-02-24 05:52:48 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 05:57:27 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 255 seconds)
2026-02-24 05:58:16 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Ping timeout: 252 seconds)
2026-02-24 05:58:48 +0100ChaiTRex(~ChaiTRex@user/chaitrex) ChaiTRex
2026-02-24 06:07:42 +0100defragger(~random@i5C742DFE.versanet.de) (Ping timeout: 256 seconds)
2026-02-24 06:08:11 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 06:13:04 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 268 seconds)
2026-02-24 06:19:12 +0100Googulator17(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu) (Quit: Client closed)
2026-02-24 06:19:28 +0100Googulator17(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu)
2026-02-24 06:23:33 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 06:28:27 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 272 seconds)
2026-02-24 06:28:57 +0100jtnuttall(~jeremy@user/jeremyn) (Ping timeout: 255 seconds)
2026-02-24 06:29:34 +0100lol__(~lol@2603:3016:1e01:b940:4d29:e35:f98e:367a)
2026-02-24 06:34:00 +0100lol_(~lol@2603:3016:1e01:b940:9441:c46b:69b3:7076) (Ping timeout: 264 seconds)
2026-02-24 06:38:55 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 06:40:31 +0100emaczen(~user@user/emaczen) (Ping timeout: 264 seconds)
2026-02-24 06:43:31 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-24 06:50:57 +0100Square2(~Square4@user/square) Square
2026-02-24 06:53:45 +0100Square3(~Square@user/square) (Ping timeout: 248 seconds)
2026-02-24 06:53:48 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 06:58:31 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-24 07:03:04 +0100p3n_(~p3n@217.198.124.246) (Quit: ZNC 1.10.1 - https://znc.in)
2026-02-24 07:03:34 +0100p3n(~p3n@2a00:19a0:3:7c:0:d9c6:7cf6:1) p3n
2026-02-24 07:05:55 +0100peterbecich(~Thunderbi@71.84.33.135) (Ping timeout: 265 seconds)
2026-02-24 07:09:11 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 07:13:39 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 245 seconds)
2026-02-24 07:17:29 +0100takuan(~takuan@d8D86B9E9.access.telenet.be)
2026-02-24 07:24:33 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 07:26:09 +0100Googulator17(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu) (Quit: Client closed)
2026-02-24 07:26:15 +0100Googulator33(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu)
2026-02-24 07:29:56 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds)
2026-02-24 07:38:10 +0100haritz(~hrtz@user/haritz) (Quit: ZNC 1.8.2+deb3.1+deb12u1 - https://znc.in)
2026-02-24 07:40:35 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 07:44:34 +0100Googulator33(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu) (Quit: Client closed)
2026-02-24 07:44:35 +0100Googulator78(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu)
2026-02-24 07:45:19 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-24 07:51:41 +0100marinelli(~weechat@gateway/tor-sasl/marinelli) (Quit: marinelli)
2026-02-24 07:54:48 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 07:59:21 +0100jmcantrell(~weechat@user/jmcantrell) (Ping timeout: 248 seconds)
2026-02-24 07:59:24 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 255 seconds)
2026-02-24 08:00:47 +0100peterbecich(~Thunderbi@71.84.33.135) peterbecich
2026-02-24 08:08:15 +0100 <gentauro> adding this to a file works -> `{-# OPTIONS_GHC -Wall -Werror -fpackage-trust #-}`. However, this does not: `{-# OPTIONS_GHC -Wall -Werror -fpackage-trust -trust=base #-}`.
2026-02-24 08:08:39 +0100gentauroerror msg: "Unknown flag in {-# OPTIONS_GHC #-} pragma: -trust=base".
2026-02-24 08:09:08 +0100 <gentauro> anybody know how to pass trusted packages in the `OPTIONS_GHC` pragma?
2026-02-24 08:10:10 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 08:11:36 +0100 <gentauro> there seem to be `GHC` cli flags for that -> https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/safe_haskell.html#package-trust
2026-02-24 08:11:51 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2026-02-24 08:11:53 +0100 <gentauro> however, they don't work with `runghc` :-\
2026-02-24 08:15:10 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 268 seconds)
2026-02-24 08:20:09 +0100 <gentauro> Is there built-in logic in Haskell such as in F# `Enum.GetValues(typeof<tags>)` where you can get a sequence of the values for an (enum) datatype? For example for `data FooBarEnum = Foo | Bar deriving (Eq, Show)`.
2026-02-24 08:20:29 +0100gentaurowhich would result in [ Foo, Bar ]
2026-02-24 08:21:44 +0100 <Leary> @let data FooBarEnum = Foo | Bar deriving (Eq, Show, Enum)
2026-02-24 08:21:46 +0100 <lambdabot> Defined.
2026-02-24 08:21:56 +0100 <Leary> > [minBound .. maxBound] :: [FooBarEnum]
2026-02-24 08:21:57 +0100 <lambdabot> No instance for ‘Bounded FooBarEnum’
2026-02-24 08:21:57 +0100 <lambdabot> arising from a use of ‘minBound’
2026-02-24 08:21:58 +0100 <lambdabot> In the expression: minBound
2026-02-24 08:22:24 +0100 <Leary> Ah, Forgot to derive `Bounded`. Well, you get the idea.
2026-02-24 08:23:04 +0100 <Leary> > [minBound .. maxBound] :: [FooBarEnum]
2026-02-24 08:23:05 +0100 <lambdabot> [Foo,Bar]
2026-02-24 08:24:47 +0100marinelli(~weechat@gateway/tor-sasl/marinelli) marinelli
2026-02-24 08:25:32 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 08:27:01 +0100 <gentauro> Leary: now that was nifty <3
2026-02-24 08:27:32 +0100 <gentauro> many thx
2026-02-24 08:29:04 +0100img(~img@user/img) (Quit: ZNC 1.10.1 - https://znc.in)
2026-02-24 08:29:48 +0100wickedjargon(~user@2605:8d80:5430:dc79:6396:7e42:d4e3:36f9) wickedjargon
2026-02-24 08:30:20 +0100img(~img@user/img) img
2026-02-24 08:30:52 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 276 seconds)
2026-02-24 08:36:31 +0100Enrico63(~Enrico63@host-79-19-156-232.retail.telecomitalia.it) Enrico63
2026-02-24 08:37:13 +0100tzh(~tzh@c-76-115-131-146.hsd1.or.comcast.net) (Quit: zzz)
2026-02-24 08:40:54 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 08:44:04 +0100Enrico63(~Enrico63@host-79-19-156-232.retail.telecomitalia.it) (Quit: Client closed)
2026-02-24 08:47:54 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 265 seconds)
2026-02-24 08:52:41 +0100jj(~apropos@node-1w7jr9pqogh9vahu1mvneock5.ipv6.telus.net) (Ping timeout: 248 seconds)
2026-02-24 08:55:47 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 08:56:33 +0100jj(~apropos@node-1w7jr9pqogh9vahu1mvneock5.ipv6.telus.net) omentic
2026-02-24 09:00:09 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 248 seconds)
2026-02-24 09:02:09 +0100chele(~chele@user/chele) chele
2026-02-24 09:06:23 +0100wickedjargon(~user@2605:8d80:5430:dc79:6396:7e42:d4e3:36f9) (Read error: Connection reset by peer)
2026-02-24 09:11:10 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 09:11:18 +0100lbseale(~quassel@user/ep1ctetus) (Ping timeout: 256 seconds)
2026-02-24 09:15:00 +0100peterbecich(~Thunderbi@71.84.33.135) (Ping timeout: 255 seconds)
2026-02-24 09:15:32 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds)
2026-02-24 09:18:04 +0100Pozyomka(~pyon@user/pyon) (Ping timeout: 268 seconds)
2026-02-24 09:27:27 +0100tromp(~textual@2001:1c00:3487:1b00:7955:9591:6018:7ef9)
2026-02-24 09:28:15 +0100AlexNoo(~AlexNoo@178.34.163.162)
2026-02-24 09:28:59 +0100AlexNoo_(~AlexNoo@178.34.163.162)
2026-02-24 09:29:43 +0100AlexNoo__(~AlexNoo@178.34.163.162)
2026-02-24 09:33:06 +0100AlexNoo(~AlexNoo@178.34.163.162) (Ping timeout: 268 seconds)
2026-02-24 09:33:41 +0100AlexNoo(~AlexNoo@178.34.163.162)
2026-02-24 09:33:43 +0100AlexNoo_(~AlexNoo@178.34.163.162) (Ping timeout: 268 seconds)
2026-02-24 09:34:20 +0100AlexNoo__(~AlexNoo@178.34.163.162) (Ping timeout: 268 seconds)
2026-02-24 09:37:54 +0100__monty__(~toonn@user/toonn) toonn
2026-02-24 09:50:43 +0100srk(~sorki@user/srk) (Ping timeout: 264 seconds)
2026-02-24 09:51:37 +0100emmanuelux(~em@user/emmanuelux) emmanuelux
2026-02-24 09:52:16 +0100srk(~sorki@user/srk) srk
2026-02-24 09:52:36 +0100merijn(~merijn@77.242.116.146) merijn
2026-02-24 10:06:08 +0100lxsameer(~lxsameer@Serene/lxsameer) lxsameer
2026-02-24 10:07:46 +0100emmanuelux(~em@user/emmanuelux) (Quit: bye)
2026-02-24 10:13:07 +0100Alex_delenda_est(~al_test@178.34.163.162)
2026-02-24 10:14:02 +0100AlexZenon(~alzenon@178.34.163.162)
2026-02-24 10:15:47 +0100Alex_test_(~al_test@178.34.163.162)
2026-02-24 10:15:54 +0100jreicher(~joelr@user/jreicher) (Quit: brb)
2026-02-24 10:17:33 +0100Alex_delenda_est(~al_test@178.34.163.162) (Ping timeout: 255 seconds)
2026-02-24 10:18:24 +0100jreicher(~joelr@user/jreicher) jreicher
2026-02-24 10:20:15 +0100Alex_test_(~al_test@178.34.163.162) (Ping timeout: 255 seconds)
2026-02-24 10:25:44 +0100Alex_delenda_est(~al_test@178.34.163.162)
2026-02-24 10:27:08 +0100sp1ff(~user@2601:1c2:4701:7850::8cd) (Ping timeout: 268 seconds)
2026-02-24 10:31:27 +0100 <dminuoso> % :t minBound
2026-02-24 10:31:27 +0100 <yahb2> minBound :: Bounded a => a
2026-02-24 10:31:58 +0100 <dminuoso> Curious, why is Ord not a superclass of Bounded?
2026-02-24 10:32:19 +0100 <dminuoso> What does `minimum/maximum` even mean in the absence of an ordering?
2026-02-24 10:32:50 +0100Enrico63(~Enrico63@host-79-19-156-232.retail.telecomitalia.it) Enrico63
2026-02-24 10:33:40 +0100 <tomsmeding> perhaps it makes sense that an Enum has a first and a last value for enumeration, but while it has an ordering compatible with that Enum instance, that ordering makes no semantical sense and is hence not defined?
2026-02-24 10:33:53 +0100 <tomsmeding> but then you could argue that you should give that Ord instance anyway
2026-02-24 10:34:47 +0100 <humasect> it says right in the first sentence https://hackage-content.haskell.org/package/base-4.22.0.0/docs/Data-Bounded.html
2026-02-24 10:35:05 +0100 <tomsmeding> lol, dminuoso ^
2026-02-24 10:35:24 +0100tomsmedingshould have thought of that
2026-02-24 10:35:32 +0100 <dminuoso> humasect: Yes, and its not much of an explanation.
2026-02-24 10:35:43 +0100 <dminuoso> It reads nonsensical to me.
2026-02-24 10:35:48 +0100 <humasect> perhaps look into its meaning, disassemble it to understanding
2026-02-24 10:35:50 +0100 <tomsmeding> dminuoso: not every ordering is total
2026-02-24 10:35:54 +0100 <dminuoso> Oh.
2026-02-24 10:35:54 +0100 <tomsmeding> partial orders are a thing
2026-02-24 10:35:55 +0100 <humasect> how to learn ?
2026-02-24 10:36:09 +0100sp1ff(~user@c-24-20-218-28.hsd1.wa.comcast.net) sp1ff
2026-02-24 10:36:22 +0100 <dminuoso> tomsmeding: Is there a notion of `minimum` in a partially ordered set, then?
2026-02-24 10:36:30 +0100 <dminuoso> Im not even sure what that would mean.
2026-02-24 10:36:32 +0100 <__monty__> tomsmeding: But Bounded doesn't deal with just any partial order.
2026-02-24 10:36:43 +0100 <tomsmeding> dminuoso: yes, a lower bound :) https://en.wikipedia.org/wiki/Lattice_(order)
2026-02-24 10:36:44 +0100 <__monty__> It's restricted to partial orders that have a single lower and upper bound.
2026-02-24 10:37:15 +0100 <tomsmeding> sure, but even those need not have a total ordering
2026-02-24 10:37:27 +0100 <tomsmeding> perhaps "lower bound" is not the technically correct term here
2026-02-24 10:37:38 +0100 <tomsmeding> (but then, it's probably "minimum", which would not have helped dminuoso)
2026-02-24 10:38:17 +0100 <tomsmeding> dminuoso: all subset of a given set S are partially ordered by inclusion, and they have a unique minimum ({}) and maximum (S), but they are not totally ordered
2026-02-24 10:38:47 +0100 <dminuoso> tomsmeding: Okay so what you're saying is that Bounded is just synonmous for Lattice?
2026-02-24 10:38:55 +0100 <tomsmeding> perhaps?
2026-02-24 10:39:16 +0100 <tomsmeding> well, a bounded lattice
2026-02-24 10:39:46 +0100 <dminuoso> tomsmeding: Aren't all lattices bounded by their suprema?
2026-02-24 10:40:04 +0100 <dminuoso> Ohh wait.
2026-02-24 10:40:06 +0100 <dminuoso> I see.
2026-02-24 10:40:07 +0100 <tomsmeding> according to the wikipedia definition that I'm currently reading, a plain "lattice" requires joins and meets of _two_ elements
2026-02-24 10:40:10 +0100 <tomsmeding> and thus finite sets
2026-02-24 10:40:27 +0100 <tomsmeding> a _complete lattice_ additionally requires suprema and infima of larger sets
2026-02-24 10:40:38 +0100 <tomsmeding> thus all complete lattices are bounded, but not all bounded lattices are complete? Perhaps?
2026-02-24 10:40:55 +0100dminuosowonders why lattices are called lattices
2026-02-24 10:41:19 +0100 <tomsmeding> because of this picture I always assumed https://commons.wikimedia.org/wiki/File:Pow3nonlattice.svg
2026-02-24 10:41:39 +0100 <jreicher> dminuoso: hasse diagrams
2026-02-24 10:41:51 +0100xff0x(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp) (Ping timeout: 255 seconds)
2026-02-24 10:42:06 +0100 <jreicher> https://en.wikipedia.org/wiki/Hasse_diagram
2026-02-24 10:42:21 +0100 <tomsmeding> which that picture is an example of
2026-02-24 10:42:40 +0100 <Leary> It's a bounded partial order with minimal and maximal elements---that doesn't imply unique suprema or infima.
2026-02-24 10:42:51 +0100Enrico63(~Enrico63@host-79-19-156-232.retail.telecomitalia.it) (Quit: Client closed)
2026-02-24 10:43:09 +0100 <tomsmeding> fair! Even pairs need not have unique joins or meets
2026-02-24 10:43:48 +0100 <dminuoso> Leary: Are you saying that Bounded does not have uniqueness requirements?
2026-02-24 10:44:16 +0100 <tomsmeding> dminuoso: even if there is a maximal element of the entire set, that does not necessarily mean there is a _unique_ smallest upper bound of any subset of the set
2026-02-24 10:44:31 +0100 <__monty__> dminuoso: I think they're talking about lattices.
2026-02-24 10:44:33 +0100 <tomsmeding> "lattice" implies that such upper bounds (and lower bounds) are unique
2026-02-24 10:44:57 +0100 <tomsmeding> so Bounded is not a "bounded lattice", it's a "partial order with minimal and maximal elements"
2026-02-24 10:45:07 +0100 <tomsmeding> which... we knew 10 minutes ago already
2026-02-24 10:45:08 +0100 <dminuoso> tomsmeding: Trying to understand what "maximal element of the entire set" would mean, if it was not a unique smallest supremum of any subset of the set.
2026-02-24 10:45:20 +0100 <tomsmeding> welcome to math where there are unintuitive counterexamples
2026-02-24 10:45:27 +0100 <dminuoso> Oh hold on.
2026-02-24 10:45:35 +0100 <dminuoso> The favourite person in a group could work I suppose.
2026-02-24 10:46:10 +0100 <jreicher> tomsmeding: clopen is my favourite
2026-02-24 10:46:44 +0100 <dminuoso> Hold on what I just said makes no sense.
2026-02-24 10:46:52 +0100 <jreicher> dminuoso: are you wondering what the difference between lattice and having max and min is?
2026-02-24 10:47:06 +0100 <dminuoso> The uniqueness is not of any subset, but a *pair* of elements.
2026-02-24 10:47:11 +0100 <jreicher> Yes
2026-02-24 10:47:18 +0100 <jreicher> (But I'm still not sure what the initial question was)
2026-02-24 10:47:24 +0100 <tomsmeding> (which are, in particular, subsets)
2026-02-24 10:47:29 +0100 <tomsmeding> jreicher: I think yes
2026-02-24 10:47:46 +0100 <tomsmeding> do you have an example of a bounded partial order that is not a lattice?
2026-02-24 10:47:51 +0100fp(~Thunderbi@wireless-86-50-141-0.open.aalto.fi) fp
2026-02-24 10:47:53 +0100 <tomsmeding> (I don't)
2026-02-24 10:48:02 +0100 <Leary> dminuoso: Maximal means nothing else is bigger than it, though perhaps the /greatest/ element is a better notion for a bound, in which case its bigger than everything.
2026-02-24 10:48:22 +0100 <int-e> I'm confused; Bounded just defined two points called minBound and maxBound? So it would work for partial orders too (and thus, lattices)
2026-02-24 10:48:44 +0100 <tomsmeding> int-e: the original original question was why Bounded does not have Ord as a superclass, which had answer "partial orders are a thing"
2026-02-24 10:48:45 +0100 <Leary> tomsmeding: You can just contrive a small finite partial order on paper.
2026-02-24 10:48:58 +0100 <Leary> It's not hard to make a counterexample.
2026-02-24 10:49:03 +0100 <int-e> tomsmeding: Ah. I see, lack of context strikes again.
2026-02-24 10:49:08 +0100 <tomsmeding> int-e: then we thought "but is Bounded then a bounded lattice?", to which the answer is no, as no unique joins/meets are required
2026-02-24 10:49:16 +0100 <tomsmeding> now we want an example of that :p
2026-02-24 10:49:54 +0100 <jreicher> tomsmeding: by "bounded" do we just mean the entire set (rather than any pair) as an infimum and supremum?
2026-02-24 10:49:59 +0100 <tomsmeding> yes
2026-02-24 10:50:02 +0100 <tomsmeding> or at least, I do
2026-02-24 10:50:11 +0100 <__monty__> dminuoso: If you're looking for any example of it whatsoever I think the one tomsmeding mentioned is the easiest. Take any set with more than one element and all subsets of that set, the partial order relation is subset-of, the minBound would be the empty set, the maxBound the set you started with, some pairs of subsets won't satisfy the subset-of relation in either order. So this can implement Bounded
2026-02-24 10:50:17 +0100 <__monty__> but not Ord.
2026-02-24 10:50:30 +0100 <jreicher> Then just "duplicate" a meet or join. It will no longer be a lattice.
2026-02-24 10:50:48 +0100 <tomsmeding> __monty__: yes, we figured that out, but we're already at the next question: that thing is clearly a lattice, but we want a not-lattice that is nevertheless a bounded partial order
2026-02-24 10:51:04 +0100 <int-e> Is it okay if it's? 0 < 1,2 < 3,4 < 5 has minimal and maximal elements but 3,4 have no infimum and 1,2 have no supremum
2026-02-24 10:51:29 +0100 <tomsmeding> but there's no unique maximum
2026-02-24 10:51:30 +0100 <__monty__> tomsmeding: The conversation has moved on but I'm not sure it's not leaving dminuoso behind ; )
2026-02-24 10:51:42 +0100 <tomsmeding> ah :p
2026-02-24 10:51:43 +0100 <int-e> tomsmeding: 5 is the unique maximal element here
2026-02-24 10:51:47 +0100 <Leary> tomsmeding: https://gist.github.com/LSLeary/c52be6739f5815d13a6774d46dcbde75
2026-02-24 10:51:53 +0100 <tomsmeding> int-e: no, because 2 !< 5
2026-02-24 10:52:00 +0100 <int-e> tomsmeding: it's transitive
2026-02-24 10:52:07 +0100 <tomsmeding> oh notation
2026-02-24 10:52:14 +0100 <tomsmeding> yes
2026-02-24 10:52:27 +0100 <tomsmeding> yes perfect
2026-02-24 10:52:36 +0100 <jreicher> I think int-e and I are thinking the same. 0 is one end and 5 is the other. The join of 1 and 2 is not unique
2026-02-24 10:52:37 +0100tomsmedingcloses the image editor
2026-02-24 10:52:41 +0100 <int-e> tomsmeding: sorry, I'm trying to cast a Hesse diagram in ASCII here
2026-02-24 10:52:51 +0100 <int-e> the translation is a bit lossy ;)
2026-02-24 10:52:55 +0100 <jreicher> int-e: have I understood you correctly?
2026-02-24 10:53:18 +0100 <tomsmeding> Leary: that notation in your gist is a bit ambiguous, what do the /\ on line 4 mean :p
2026-02-24 10:53:19 +0100 <int-e> Hasse diagram, meh.
2026-02-24 10:54:13 +0100 <dminuoso> Leary: Did you mean it like https://paste.tomsmeding.com/ayvscggm ?
2026-02-24 10:54:34 +0100 <__monty__> I'm also interested in kind of the reverse question, are there structures that can implement Ord but not Bounded? Something like a cyclical ordering? I suppose only if we put the "laws" of the class aside.
2026-02-24 10:54:43 +0100 <dminuoso> Or well, maybe without that x even
2026-02-24 10:54:51 +0100 <merijn> __monty__: Clearly we need a PartialOrd superclass of Ord that implement "a -> a -> Maybe Ordering"
2026-02-24 10:54:53 +0100 <dminuoso> Not sure if it makes it less or more ambiguous
2026-02-24 10:54:55 +0100 <tomsmeding> dminuoso: the x must be a crossing of lines without a node, yes
2026-02-24 10:55:11 +0100 <tomsmeding> __monty__: Integer?
2026-02-24 10:56:14 +0100 <jreicher> __monty__: if the order is transitive and antisymmetric it can't be cyclical
2026-02-24 10:56:24 +0100 <Leary> tomsmeding: Cross connections. Bit hard in slapdash asci. I revised it with an X if that's clearer.
2026-02-24 10:56:52 +0100 <tomsmeding> yes, which is also what dminuoso made of it
2026-02-24 10:57:21 +0100 <__monty__> tomsmeding: Oh, obviously, darn, less interesting than I thought.
2026-02-24 10:59:28 +0100 <int-e> tomsmeding: here is what it looks like properly: https://int-e.eu/~bf3/tmp/hapo.png
2026-02-24 11:01:03 +0100 <__monty__> TIL, min and max can return a value that is distinct from their arguments, as long as it is == to one of their arguments.
2026-02-24 11:01:25 +0100 <__monty__> I assume that's for some sort of canonicalization?
2026-02-24 11:01:58 +0100 <tomsmeding> int-e: yes
2026-02-24 11:02:13 +0100 <Leary> __monty__: `==` values aren't supposed to be distinguishable in the first place.
2026-02-24 11:02:35 +0100tomsmedinghas a meeting -> afk
2026-02-24 11:08:00 +0100xdminsy(~xdminsy@112.10.231.192) xdminsy
2026-02-24 11:08:16 +0100 <__monty__> Leary: But things like Arg exist and they exist because they are useful, I assume.
2026-02-24 11:08:35 +0100morj(~morj@user/morj) morj
2026-02-24 11:11:25 +0100 <Leary> It's occasionally pragmatic to break the law, yes. `Arg` actually wouldn't be useful if people always remembered to write `fooBy` instead of just `foo :: Ord a => ...`.
2026-02-24 11:11:52 +0100 <Leary> At least, not useful enough to justify its existence.
2026-02-24 11:13:02 +0100petrichor(~jez@user/petrichor) petrichor
2026-02-24 11:13:29 +0100xdminsy(~xdminsy@112.10.231.192) (Quit: Konversation terminated!)
2026-02-24 11:16:01 +0100morj_away(~morj@user/morj) morj
2026-02-24 11:16:37 +0100morj(~morj@user/morj) (Ping timeout: 272 seconds)
2026-02-24 11:17:10 +0100 <int-e> `fooBy` is awful when you have data structures with invariants (consider an implementation of containers that implements Data.Map using Data.Set with `Arg k v` elements)
2026-02-24 11:18:20 +0100 <int-e> (So it's not just programmer laziness.)
2026-02-24 11:20:38 +0100morj_away(~morj@user/morj) (Client Quit)
2026-02-24 11:20:56 +0100int-eponders extending this argument to saying that type classes are useles; people could just pass around the right operations explicitly. :-P
2026-02-24 11:21:57 +0100 <Leary> Even in such a case, `Arg` should be handrolled in the guts of containers, not exposed from base.
2026-02-24 11:23:43 +0100 <Leary> Re the extended argument, it's really about typeclasses with laws being used to implement operations that /don't require/ those laws and are useful in their absence; the typeclass method merely being a default choice.
2026-02-24 11:26:50 +0100divlamir(~divlamir@user/divlamir) (Read error: Connection reset by peer)
2026-02-24 11:27:05 +0100divlamir(~divlamir@user/divlamir) divlamir
2026-02-24 11:29:22 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 252 seconds)
2026-02-24 11:31:16 +0100hsw(~hsw@106.104.102.45) (Remote host closed the connection)
2026-02-24 11:31:37 +0100ec(~ec@gateway/tor-sasl/ec) ec
2026-02-24 11:32:21 +0100hsw(~hsw@106.104.102.45) hsw
2026-02-24 11:49:08 +0100mange(~mange@user/mange) mange
2026-02-24 11:53:35 +0100Enrico63(~Enrico63@host-79-19-156-232.retail.telecomitalia.it) Enrico63
2026-02-24 11:57:55 +0100humasect(~humasect@dyn-192-249-132-90.nexicom.net) (Quit: Leaving...)
2026-02-24 11:59:31 +0100infinity0(~infinity0@pwned.gg) (Ping timeout: 276 seconds)
2026-02-24 12:07:22 +0100lxsameer(~lxsameer@Serene/lxsameer) (Quit: WeeChat 4.8.1)
2026-02-24 12:10:10 +0100tromp(~textual@2001:1c00:3487:1b00:7955:9591:6018:7ef9) (Quit: My iMac has gone to sleep. ZZZzzz…)
2026-02-24 12:12:42 +0100Frostillicus(~Frostilli@pool-71-174-119-69.bstnma.fios.verizon.net)
2026-02-24 12:14:03 +0100fp(~Thunderbi@wireless-86-50-141-0.open.aalto.fi) (Ping timeout: 268 seconds)
2026-02-24 12:14:06 +0100xdminsy(~xdminsy@112.10.231.192) xdminsy
2026-02-24 12:16:47 +0100xdminsy(~xdminsy@112.10.231.192) (Client Quit)
2026-02-24 12:17:08 +0100xdminsy(~xdminsy@112.10.231.192) xdminsy
2026-02-24 12:17:21 +0100xdminsy(~xdminsy@112.10.231.192) (Client Quit)
2026-02-24 12:17:43 +0100Frostillicus(~Frostilli@pool-71-174-119-69.bstnma.fios.verizon.net) (Ping timeout: 264 seconds)
2026-02-24 12:17:52 +0100xdminsy(~xdminsy@112.10.231.192) xdminsy
2026-02-24 12:19:33 +0100infinity0(~infinity0@pwned.gg) infinity0
2026-02-24 12:19:40 +0100terrorjack(~terrorjac@2a01:4f8:271:2d98::2) (Quit: The Lounge - https://thelounge.chat)
2026-02-24 12:26:37 +0100wickedjargon(~user@2605:8d80:5430:ec04:8f71:3db2:1c1a:13ef) wickedjargon
2026-02-24 12:34:05 +0100fp(~Thunderbi@130.233.70.214) fp
2026-02-24 12:36:53 +0100wickedjargon(~user@2605:8d80:5430:ec04:8f71:3db2:1c1a:13ef) (Remote host closed the connection)
2026-02-24 12:38:45 +0100wickedjargon(~user@2605:8d80:5430:ec04:8f71:3db2:1c1a:13ef) wickedjargon
2026-02-24 12:40:22 +0100Pozyomka(~pyon@user/pyon) pyon
2026-02-24 12:47:32 +0100xdminsy(~xdminsy@112.10.231.192) (Quit: Konversation terminated!)
2026-02-24 12:52:54 +0100humasect(~humasect@dyn-192-249-132-90.nexicom.net) humasect
2026-02-24 12:54:53 +0100 <gentauro> tomsmeding: have you road the functional pearl from Alejandro Russo on how to use `lattices` to secure apps?
2026-02-24 12:54:58 +0100 <gentauro> it's a pretty good one !!!
2026-02-24 12:55:50 +0100gentauroI actually live coded an implementation for a Spanish audience (HackMadrid / HaskellMAD). Nobody understood anything xD
2026-02-24 12:58:10 +0100gentaurofor Spanish speaking peeps -> https://www.youtube.com/watch?v=iU5dfVRREUo&t=7806s (02:10:06 - 03:11:59)
2026-02-24 13:02:13 +0100gentauromerijn and tomsmeding perhaps that talk will provide "some" endorsment for Hackage? xD
2026-02-24 13:08:01 +0100smalltalkman(uid545680@id-545680.hampstead.irccloud.com) smalltalkman
2026-02-24 13:08:35 +0100mange(~mange@user/mange) (Quit: Zzz...)
2026-02-24 13:08:53 +0100CiaoSen(~Jura@2a02:8071:64e1:da0:5a47:caff:fe78:33db) CiaoSen
2026-02-24 13:21:19 +0100Enrico63(~Enrico63@host-79-19-156-232.retail.telecomitalia.it) (Quit: Client closed)
2026-02-24 13:30:32 +0100haritz(~hrtz@2a01:4b00:bc2e:7000:d5af:a266:ca31:5ef8)
2026-02-24 13:30:32 +0100haritz(~hrtz@2a01:4b00:bc2e:7000:d5af:a266:ca31:5ef8) (Changing host)
2026-02-24 13:30:32 +0100haritz(~hrtz@user/haritz) haritz
2026-02-24 13:45:05 +0100SlackCoder(~SlackCode@64-94-63-8.ip.weststar.net.ky) SlackCoder
2026-02-24 13:45:58 +0100Taneb(~username@host-87-11-133-28.retail.telecomitalia.it) Taneb
2026-02-24 13:46:25 +0100SlackCoder(~SlackCode@64-94-63-8.ip.weststar.net.ky) (Client Quit)
2026-02-24 13:49:08 +0100humasect(~humasect@dyn-192-249-132-90.nexicom.net) (Quit: Leaving...)
2026-02-24 13:56:10 +0100wickedjargon(~user@2605:8d80:5430:ec04:8f71:3db2:1c1a:13ef) (Remote host closed the connection)
2026-02-24 13:58:45 +0100AlexNoo(~AlexNoo@178.34.163.162) (Quit: Leaving)
2026-02-24 13:59:15 +0100Alex_delenda_est(~al_test@178.34.163.162) (Quit: ;-)
2026-02-24 13:59:40 +0100AlexZenon(~alzenon@178.34.163.162) (Quit: ;-)
2026-02-24 14:06:31 +0100qqq(~qqq@185.54.22.240)
2026-02-24 14:17:39 +0100Frostillicus(~Frostilli@pool-71-174-119-69.bstnma.fios.verizon.net)
2026-02-24 14:20:39 +0100AlexNoo(~AlexNoo@178.34.163.162)
2026-02-24 14:21:53 +0100fp(~Thunderbi@130.233.70.214) (Ping timeout: 265 seconds)
2026-02-24 14:22:27 +0100AlexZenon(~alzenon@178.34.163.162)
2026-02-24 14:22:44 +0100xff0x(~xff0x@ai083101.d.east.v6connect.net)
2026-02-24 14:26:51 +0100AlexZenon(~alzenon@178.34.163.162) (Ping timeout: 255 seconds)
2026-02-24 14:26:58 +0100ljdarj(~Thunderbi@user/ljdarj) ljdarj
2026-02-24 14:31:28 +0100AlexZenon(~alzenon@178.34.163.162)
2026-02-24 14:34:37 +0100Alex_test_(~al_test@178.34.163.162)
2026-02-24 14:38:06 +0100AlexZenon(~alzenon@178.34.163.162) (Ping timeout: 255 seconds)
2026-02-24 14:38:33 +0100fp(~Thunderbi@130.233.70.214) fp
2026-02-24 14:41:18 +0100Alex_test_Alex_delenda_est
2026-02-24 14:43:32 +0100AlexZenon(~alzenon@178.34.163.162)
2026-02-24 14:43:53 +0100lbseale(~quassel@user/ep1ctetus) ep1ctetus
2026-02-24 14:44:24 +0100troydm(~troydm@user/troydm) troydm
2026-02-24 14:44:54 +0100chenjf(~chenjf@68.64.178.54)
2026-02-24 14:50:20 +0100lbseale(~quassel@user/ep1ctetus) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2026-02-24 14:51:04 +0100lbseale(~quassel@user/ep1ctetus) ep1ctetus
2026-02-24 14:56:00 +0100machinedgod(~machinedg@d172-219-48-230.abhsia.telus.net) machinedgod
2026-02-24 15:01:45 +0100castan(~castan@2a02:2f0f:8210:d800:f4b5:9670:6ef1:55e)
2026-02-24 15:02:13 +0100castan(~castan@2a02:2f0f:8210:d800:f4b5:9670:6ef1:55e) (Client Quit)
2026-02-24 15:04:58 +0100 <tomsmeding> gentauro: I'm pretty sure I have not read that pearl
2026-02-24 15:05:34 +0100Googulator78Googulator
2026-02-24 15:07:32 +0100philopsos1(~caecilius@user/philopsos) philopsos
2026-02-24 15:20:00 +0100philopsos1(~caecilius@user/philopsos) (Read error: error:0A000139:SSL routines::record layer failure)
2026-02-24 15:26:15 +0100chenjf(~chenjf@68.64.178.54) (Ping timeout: 255 seconds)
2026-02-24 15:29:37 +0100califax(~califax@user/califx) (Remote host closed the connection)
2026-02-24 15:29:53 +0100califax(~califax@user/califx) califx
2026-02-24 15:33:06 +0100Frostillicus(~Frostilli@pool-71-174-119-69.bstnma.fios.verizon.net) (Quit: Frostillicus)
2026-02-24 15:35:13 +0100philopsos1(~caecilius@user/philopsos) philopsos
2026-02-24 15:40:43 +0100comerijn(~merijn@77.242.116.146) merijn
2026-02-24 15:43:21 +0100merijn(~merijn@77.242.116.146) (Ping timeout: 255 seconds)
2026-02-24 15:46:03 +0100philopsos1(~caecilius@user/philopsos) (Ping timeout: 255 seconds)
2026-02-24 15:49:56 +0100misterfish(~misterfis@84.53.85.146) misterfish
2026-02-24 15:52:25 +0100tromp(~textual@2001:1c00:3487:1b00:7955:9591:6018:7ef9)
2026-02-24 15:59:10 +0100CiaoSen(~Jura@2a02:8071:64e1:da0:5a47:caff:fe78:33db) (Quit: CiaoSen)
2026-02-24 16:02:08 +0100rekahsoft(~rekahsoft@bras-base-orllon1103w-grc-20-76-67-111-168.dsl.bell.ca) rekahsoft
2026-02-24 16:03:53 +0100GdeVolpiano(~GdeVolpia@user/GdeVolpiano) GdeVolpiano
2026-02-24 16:04:33 +0100GdeVolpi1(~GdeVolpia@user/GdeVolpiano) (Read error: Connection reset by peer)
2026-02-24 16:06:38 +0100Taneb(~username@host-87-11-133-28.retail.telecomitalia.it) (Remote host closed the connection)
2026-02-24 16:15:17 +0100chenjf(~chenjf@68.64.178.54)
2026-02-24 16:16:04 +0100jtnuttall(~jeremy@user/jeremyn) jeremyn
2026-02-24 16:17:08 +0100 <gentauro> tomsmeding: let me see if I can find it (Chalmers moved their stuff when they made the new website)
2026-02-24 16:18:18 +0100 <gentauro> tomsmeding: there you go -> https://www.cse.chalmers.se/~russo/publications_files/pearl-russo.pdf
2026-02-24 16:20:35 +0100rainbyte(~rainbyte@186.22.19.214) (Remote host closed the connection)
2026-02-24 16:20:38 +0100 <tomsmeding> thanks, will have a look :)
2026-02-24 16:20:47 +0100rainbyte(~rainbyte@186.22.19.214) rainbyte
2026-02-24 16:22:05 +0100 <gentauro> tomsmeding: there is also the ICFP 2015 Vancouver: https://www.youtube.com/watch?v=K6Uf61U0fvo (but it's recorded with a toaster …) :-\
2026-02-24 16:22:42 +0100gentauroless than 19 min, if you ears can handle the toaster A/V
2026-02-24 16:24:14 +0100fp(~Thunderbi@130.233.70.214) (Ping timeout: 256 seconds)
2026-02-24 16:30:50 +0100tromp(~textual@2001:1c00:3487:1b00:7955:9591:6018:7ef9) (Quit: My iMac has gone to sleep. ZZZzzz…)
2026-02-24 16:31:30 +0100comerijn(~merijn@77.242.116.146) (Ping timeout: 255 seconds)
2026-02-24 16:33:06 +0100merijn(~merijn@77.242.116.146) merijn
2026-02-24 16:40:03 +0100merijn(~merijn@77.242.116.146) (Ping timeout: 255 seconds)
2026-02-24 16:40:17 +0100emaczen(~user@user/emaczen) emaczen
2026-02-24 16:44:41 +0100merijn(~merijn@77.242.116.146) merijn
2026-02-24 16:46:48 +0100chenjf(~chenjf@68.64.178.54) (Ping timeout: 255 seconds)
2026-02-24 16:52:51 +0100CiaoSen(~Jura@2a02:8071:64e1:da0:5a47:caff:fe78:33db) CiaoSen
2026-02-24 16:52:55 +0100traxex(traxex@user/traxex) (Ping timeout: 272 seconds)
2026-02-24 16:54:40 +0100CiaoSen(~Jura@2a02:8071:64e1:da0:5a47:caff:fe78:33db) (Client Quit)
2026-02-24 16:54:52 +0100CiaoSen(~Jura@2a02:8071:64e1:da0:5a47:caff:fe78:33db) CiaoSen
2026-02-24 16:54:53 +0100CiaoSen(~Jura@2a02:8071:64e1:da0:5a47:caff:fe78:33db) (Client Quit)
2026-02-24 17:07:00 +0100_d0t(~{-d0t-}@user/-d0t-/x-7915216) (Ping timeout: 264 seconds)
2026-02-24 17:10:49 +0100califax_(~califax@user/califx) califx
2026-02-24 17:10:54 +0100califax(~califax@user/califx) (Quit: ZNC 1.10.1 - https://znc.in)
2026-02-24 17:11:17 +0100Square2(~Square4@user/square) (Ping timeout: 268 seconds)
2026-02-24 17:12:07 +0100califax_califax
2026-02-24 17:13:14 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2026-02-24 17:16:56 +0100paddymahoney(~paddymaho@pool-99-250-10-137.cpe.net.cable.rogers.com) (Ping timeout: 256 seconds)
2026-02-24 17:19:16 +0100misterfish(~misterfis@84.53.85.146) (Ping timeout: 265 seconds)
2026-02-24 17:22:18 +0100_d0t(~{-d0t-}@user/-d0t-/x-7915216) {-d0t-}
2026-02-24 17:34:16 +0100petrichor(~jez@user/petrichor) (Quit: ZNC 1.10.1 - https://znc.in)
2026-02-24 17:37:54 +0100philopsos1(~caecilius@user/philopsos) philopsos
2026-02-24 17:40:48 +0100jtnuttall(~jeremy@user/jeremyn) (Ping timeout: 255 seconds)
2026-02-24 17:42:57 +0100jmcantrell_(~weechat@user/jmcantrell) jmcantrell
2026-02-24 17:45:06 +0100jmcantrell_jmcantrell
2026-02-24 17:48:19 +0100Googulator(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu) (Quit: Client closed)
2026-02-24 17:48:33 +0100Googulator(~Googulato@2a01-036d-0106-499d-1c5a-0e4b-5795-d7e3.pool6.digikabel.hu)
2026-02-24 17:52:59 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2026-02-24 17:54:20 +0100tromp(~textual@2001:1c00:3487:1b00:7955:9591:6018:7ef9)
2026-02-24 18:00:55 +0100Milan_Vanca(~milan@user/Milan-Vanca:32634) Milan_Vanca
2026-02-24 18:00:59 +0100lbseale(~quassel@user/ep1ctetus) (Quit: No Ping reply in 180 seconds.)
2026-02-24 18:02:14 +0100lbseale(~quassel@user/ep1ctetus) ep1ctetus
2026-02-24 18:04:12 +0100 <Milan_Vanca> Hello guyz.. Stupid quesiton incoming! We can nicely nest "case of" fn a b c = case a of.. case b of... Lovely but sadly I can't pattern match and need guards. Which I don't know how to nest. I don't want to duplicate e1 && e2 && e3 when only e4 changes.
2026-02-24 18:05:29 +0100lxsameer(~lxsameer@Serene/lxsameer) lxsameer
2026-02-24 18:09:39 +0100 <ncf> guards don't do anything that let and case can't
2026-02-24 18:10:10 +0100 <ncf> if you really want a RHS equivalent of guards there is MultiWayIf https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/multiway_if.html
2026-02-24 18:18:56 +0100 <Milan_Vanca> So is there other way how to rewrite this more nicely? https://paste.tomsmeding.com/NokCDmVI
2026-02-24 18:20:48 +0100 <Milan_Vanca> Imagine I want to have another otherwise with under counter path.
2026-02-24 18:20:50 +0100petrichor(~jez@user/petrichor) petrichor
2026-02-24 18:21:07 +0100 <Milan_Vanca> I probably need whole new function for it
2026-02-24 18:23:45 +0100bggd_(~bgg@2a01:e0a:fd5:f510:ad7c:fa54:e40d:9544) (Remote host closed the connection)
2026-02-24 18:24:54 +0100merijn(~merijn@77.242.116.146) (Ping timeout: 255 seconds)
2026-02-24 18:25:36 +0100euphores(~SASL_euph@user/euphores) euphores
2026-02-24 18:26:42 +0100cipherrot(~jez@user/petrichor) petrichor
2026-02-24 18:27:24 +0100petrichor(~jez@user/petrichor) (Ping timeout: 245 seconds)
2026-02-24 18:32:27 +0100 <Milan_Vanca> I think I can do this https://paste.tomsmeding.com/FfemQcpX but this case of is ugly?
2026-02-24 18:32:45 +0100Pozyomka(~pyon@user/pyon) (Quit: brb)
2026-02-24 18:33:10 +0100Pozyomka(~pyon@user/pyon) pyon
2026-02-24 18:34:55 +0100weary-traveler(~user@user/user363627) (Remote host closed the connection)
2026-02-24 18:35:44 +0100ljdarj(~Thunderbi@user/ljdarj) (Ping timeout: 245 seconds)
2026-02-24 18:36:14 +0100 <ncf> i don't see a reason not to use an if statement there
2026-02-24 18:36:23 +0100 <ncf> well, an if expression
2026-02-24 18:37:29 +0100 <Milan_Vanca> What about now? https://paste.tomsmeding.com/ptnApMeq
2026-02-24 18:38:28 +0100 <Milan_Vanca> Like I can do it with if but it does not look like nicer solution.
2026-02-24 18:39:13 +0100 <Milan_Vanca> If I had only 2 then I would use an if expression which is perfect solution for that case
2026-02-24 18:40:27 +0100 <ncf> i mean that's fine, if you have a lot of those you might want to define a list or a map like [(methodGet, counterGet), (methodPut, counterPut), ...] and then do a lookup into that
2026-02-24 18:42:16 +0100 <Milan_Vanca> Hmm map with lookup sounds interesting too.
2026-02-24 18:45:34 +0100wickedjargon(~user@2605:8d80:5431:6cb2:b646:a30f:510c:87ce) wickedjargon
2026-02-24 18:48:57 +0100wickedja`(~user@2605:8d80:5431:6cb2:b646:a30f:510c:87ce)
2026-02-24 18:51:47 +0100wickedjargon(~user@2605:8d80:5431:6cb2:b646:a30f:510c:87ce) (Remote host closed the connection)
2026-02-24 18:51:54 +0100wickedja`(~user@2605:8d80:5431:6cb2:b646:a30f:510c:87ce) (Remote host closed the connection)
2026-02-24 18:52:37 +0100wickedjargon(~user@2605:8d80:5431:6cb2:b646:a30f:510c:87ce) wickedjargon
2026-02-24 18:52:51 +0100tromp(~textual@2001:1c00:3487:1b00:7955:9591:6018:7ef9) (Quit: My iMac has gone to sleep. ZZZzzz…)
2026-02-24 18:56:01 +0100tromp(~textual@2001:1c00:3487:1b00:7955:9591:6018:7ef9)
2026-02-24 18:56:45 +0100cipherrot(~jez@user/petrichor) (Quit: ZNC 1.10.1 - https://znc.in)
2026-02-24 18:58:21 +0100petrichor(~jez@user/petrichor) petrichor
2026-02-24 19:04:02 +0100philopsos1(~caecilius@user/philopsos) (Ping timeout: 256 seconds)
2026-02-24 19:05:29 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com) lisbeths
2026-02-24 19:08:45 +0100 <haskellbridge> <loonycyborg> Milan_Vanca: not sure if it applies to your situation but you can do deep nesting in the pattern too, so if you just want to look deeper in a nested structure you can fold nested "case" into a single case.
2026-02-24 19:11:34 +0100glguy(glguy@libera/staff/glguy) (*.net *.split)
2026-02-24 19:11:39 +0100glguy(glguy@libera/staff/glguy) glguy
2026-02-24 19:13:03 +0100traxex(traxex@user/traxex) traxex
2026-02-24 19:15:19 +0100rainbyte(~rainbyte@186.22.19.214) (Remote host closed the connection)
2026-02-24 19:15:23 +0100 <Milan_Vanca> loonycyborg: Do you mean something like (v1, (Just v2), _) ?
2026-02-24 19:15:28 +0100rainbyte_(~rainbyte@186.22.19.214) rainbyte
2026-02-24 19:15:45 +0100 <haskellbridge> <loonycyborg> yep
2026-02-24 19:18:04 +0100 <Milan_Vanca> Yeah :) This is nice.. and If I wanted to modify v2 I could use lenses for that. Is that correct?
2026-02-24 19:18:41 +0100 <EvanR> that is one way
2026-02-24 19:20:46 +0100 <EvanR> you can also write an update function f g (v1, Just x, v3) = (v1, Just (g x), v3)
2026-02-24 19:21:39 +0100 <Milan_Vanca> Little more verbose but one does not need another lib.
2026-02-24 19:21:40 +0100 <EvanR> for a one off case, this takes a lot less support
2026-02-24 19:26:32 +0100GdeVolpiano(~GdeVolpia@user/GdeVolpiano) (Quit: WeeChat 4.7.2)
2026-02-24 19:26:52 +0100GdeVolpiano(~GdeVolpia@user/GdeVolpiano) GdeVolpiano
2026-02-24 19:32:35 +0100tremon(~tremon@83.80.159.219) tremon
2026-02-24 19:32:59 +0100T_S_____(sid501726@id-501726.uxbridge.irccloud.com) (Server closed connection)
2026-02-24 19:33:08 +0100T_S_____(sid501726@id-501726.uxbridge.irccloud.com)
2026-02-24 19:39:09 +0100paddymahoney(~paddymaho@pool-99-250-10-137.cpe.net.cable.rogers.com)
2026-02-24 19:41:50 +0100humasect(~humasect@dyn-192-249-132-90.nexicom.net) humasect
2026-02-24 19:46:15 +0100tzh(~tzh@c-76-115-131-146.hsd1.or.comcast.net) tzh
2026-02-24 19:48:09 +0100paddymahoney(~paddymaho@pool-99-250-10-137.cpe.net.cable.rogers.com) (Ping timeout: 248 seconds)
2026-02-24 19:48:45 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 19:50:42 +0100euphores(~SASL_euph@user/euphores) (Quit: Leaving.)
2026-02-24 19:52:12 +0100morj_away(~morj@user/morj) morj
2026-02-24 19:52:59 +0100exarkun(~exarkun@user/exarkun) (Server closed connection)
2026-02-24 19:53:24 +0100target_i(~target_i@user/target-i/x-6023099) target_i
2026-02-24 19:54:20 +0100exarkun(~exarkun@user/exarkun) exarkun
2026-02-24 19:55:48 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 255 seconds)
2026-02-24 19:58:03 +0100target_i(~target_i@user/target-i/x-6023099) (Ping timeout: 255 seconds)
2026-02-24 19:58:44 +0100target_i(~target_i@user/target-i/x-6023099) target_i
2026-02-24 20:02:45 +0100Sgeo(~Sgeo@user/sgeo) Sgeo
2026-02-24 20:03:45 +0100paddymahoney(~paddymaho@pool-99-250-10-137.cpe.net.cable.rogers.com)
2026-02-24 20:04:44 +0100euphores(~SASL_euph@user/euphores) euphores
2026-02-24 20:06:48 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 20:08:14 +0100wickedjargon(~user@2605:8d80:5431:6cb2:b646:a30f:510c:87ce) (Ping timeout: 245 seconds)
2026-02-24 20:11:44 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 268 seconds)
2026-02-24 20:15:39 +0100aristid(sid1599@id-1599.uxbridge.irccloud.com) (Server closed connection)
2026-02-24 20:15:47 +0100aristid(sid1599@id-1599.uxbridge.irccloud.com)
2026-02-24 20:17:24 +0100paddymahoney(~paddymaho@pool-99-250-10-137.cpe.net.cable.rogers.com) (Ping timeout: 255 seconds)
2026-02-24 20:18:59 +0100disconnect3d(~disconnec@user/disconnect3d) (Server closed connection)
2026-02-24 20:21:55 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 20:25:49 +0100arandombit(~arandombi@2a02:2455:8656:7100:eca0:756e:c98c:4e3f)
2026-02-24 20:25:49 +0100arandombit(~arandombi@2a02:2455:8656:7100:eca0:756e:c98c:4e3f) (Changing host)
2026-02-24 20:25:49 +0100arandombit(~arandombi@user/arandombit) arandombit
2026-02-24 20:25:56 +0100wickedjargon(~user@2605:8d80:5431:6cb2:b646:a30f:510c:87ce) wickedjargon
2026-02-24 20:26:48 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 265 seconds)
2026-02-24 20:29:08 +0100disconnect3d(~disconnec@user/disconnect3d) disconnect3d
2026-02-24 20:34:28 +0100paddymahoney(~paddymaho@pool-99-250-10-137.cpe.net.cable.rogers.com)
2026-02-24 20:35:51 +0100paddymahoney(~paddymaho@pool-99-250-10-137.cpe.net.cable.rogers.com) (Remote host closed the connection)
2026-02-24 20:36:58 +0100humasect(~humasect@dyn-192-249-132-90.nexicom.net) (Quit: Leaving...)
2026-02-24 20:37:17 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 20:39:21 +0100Psychotic1(~Psychotic@2600:1007:b0a8:2a87:b8ca:d0cd:23e3:1e08)
2026-02-24 20:41:42 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 255 seconds)
2026-02-24 20:43:11 +0100machinedgod(~machinedg@d172-219-48-230.abhsia.telus.net) (Ping timeout: 268 seconds)
2026-02-24 20:47:10 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 256 seconds)
2026-02-24 20:49:50 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) Lord_of_Life
2026-02-24 20:52:40 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 20:52:48 +0100paddymahoney(~paddymaho@pool-99-250-10-137.cpe.net.cable.rogers.com)
2026-02-24 20:54:19 +0100andjjj23(~irc@107.170.228.47) (Server closed connection)
2026-02-24 20:54:37 +0100andjjj23(~irc@107.170.228.47) andjjj23
2026-02-24 20:57:22 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 268 seconds)
2026-02-24 20:59:54 +0100arandombit(~arandombi@user/arandombit) (Ping timeout: 245 seconds)
2026-02-24 21:07:40 +0100petrichor(~jez@user/petrichor) (Quit: ZNC 1.10.1 - https://znc.in)
2026-02-24 21:08:03 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 21:12:24 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 245 seconds)
2026-02-24 21:13:25 +0100humasect(~humasect@dyn-192-249-132-90.nexicom.net) humasect
2026-02-24 21:14:33 +0100arandombit(~arandombi@2a02:2455:8656:7100:eca0:756e:c98c:4e3f)
2026-02-24 21:14:33 +0100arandombit(~arandombi@2a02:2455:8656:7100:eca0:756e:c98c:4e3f) (Changing host)
2026-02-24 21:14:33 +0100arandombit(~arandombi@user/arandombit) arandombit
2026-02-24 21:16:29 +0100ljdarj(~Thunderbi@user/ljdarj) ljdarj
2026-02-24 21:18:49 +0100Psychotic1(~Psychotic@2600:1007:b0a8:2a87:b8ca:d0cd:23e3:1e08) (Ping timeout: 248 seconds)
2026-02-24 21:18:56 +0100nonzen(~nonzen@user/nonzen) (Quit: Gone)
2026-02-24 21:19:01 +0100sajith(~sajith@user/sajith) (Quit: Gone)
2026-02-24 21:19:06 +0100nonzen_(~nonzen@user/nonzen) nonzen
2026-02-24 21:19:40 +0100sajith(~sajith@user/sajith) sajith
2026-02-24 21:20:26 +0100gmg(~user@user/gehmehgeh) (Ping timeout: 252 seconds)
2026-02-24 21:20:28 +0100dtman34(~dtman34@c-73-242-68-179.hsd1.mn.comcast.net) (Ping timeout: 276 seconds)
2026-02-24 21:21:39 +0100eugenrh(~eugenrh@user/eugenrh) (Server closed connection)
2026-02-24 21:21:57 +0100eugenrh(~eugenrh@user/eugenrh) eugenrh
2026-02-24 21:22:25 +0100wickedjargon(~user@2605:8d80:5431:6cb2:b646:a30f:510c:87ce) (Ping timeout: 276 seconds)
2026-02-24 21:22:39 +0100gmg(~user@user/gehmehgeh) gehmehgeh
2026-02-24 21:23:26 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 21:30:09 +0100chele(~chele@user/chele) (Remote host closed the connection)
2026-02-24 21:30:17 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 268 seconds)
2026-02-24 21:32:19 +0100xacktm(xacktm@user/xacktm) (Server closed connection)
2026-02-24 21:32:29 +0100dtman34(~dtman34@2601:447:d183:2302:b0c5:8965:1c3f:d560) dtman34
2026-02-24 21:32:32 +0100michalz(~michalz@185.246.207.221) (Remote host closed the connection)
2026-02-24 21:32:34 +0100xacktm(bnc4free@user/xacktm) xacktm
2026-02-24 21:34:06 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2026-02-24 21:41:28 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 21:46:06 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 256 seconds)
2026-02-24 21:47:05 +0100op_4(~tslil@user/op-4/x-9116473) (Ping timeout: 264 seconds)
2026-02-24 21:47:05 +0100srk(~sorki@user/srk) (Ping timeout: 248 seconds)
2026-02-24 21:47:18 +0100srk-(~sorki@user/srk) srk
2026-02-24 21:49:54 +0100prdak(~Thunderbi@user/prdak) prdak
2026-02-24 21:49:59 +0100srk-srk
2026-02-24 21:50:00 +0100op_4(~tslil@user/op-4/x-9116473) op_4
2026-02-24 21:55:33 +0100petrichor(~jez@user/petrichor) petrichor
2026-02-24 21:56:50 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 22:01:21 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 255 seconds)
2026-02-24 22:04:04 +0100ljdarj(~Thunderbi@user/ljdarj) (Ping timeout: 245 seconds)
2026-02-24 22:04:18 +0100 <lantti> is there a faster way to print a list of Int, separated by spaces, than "putStrLn (unwords $ map show ints)"?
2026-02-24 22:05:14 +0100 <Rembane> lantti: Faster as in time from first character to last character?
2026-02-24 22:05:27 +0100 <Rembane> ...minimizing that time that is
2026-02-24 22:05:31 +0100 <lantti> yes
2026-02-24 22:06:06 +0100 <Rembane> Converting it to a chunked bytestring could be faster, but I haven't compared.
2026-02-24 22:06:34 +0100aka_dude(~aka_dude@192.71.166.120)
2026-02-24 22:06:39 +0100 <lantti> I'm doing an algorithms course where I have to choice to do it in C, Rust or Haskell and I chose Haskell, but in my current task just printing the result takes me to the limit on acceptable time use
2026-02-24 22:06:49 +0100 <newmind> depending on the length of ints, maybe with a builder, but i doubt for any reasonable length outputs there is that much difference to be had here
2026-02-24 22:07:33 +0100aka_dude(~aka_dude@192.71.166.120) (Client Quit)
2026-02-24 22:07:38 +0100 <dolio> You could try `mapM_` with something. But I'd be surprised if it were a lot faster.
2026-02-24 22:07:44 +0100 <newmind> so, since haskell is a lazy language... how are you calculating ints?
2026-02-24 22:07:45 +0100 <lantti> although on a positive note, I did pass already. I'm just trying to improve my result from barely passing to something better
2026-02-24 22:07:54 +0100 <Rembane> lantti: How many ints do you print?
2026-02-24 22:08:08 +0100 <lantti> 10^6
2026-02-24 22:08:20 +0100 <mauke> :t shows
2026-02-24 22:08:22 +0100 <lambdabot> Show a => a -> ShowS
2026-02-24 22:08:52 +0100 <EvanR> :t mapM_ print
2026-02-24 22:08:53 +0100 <lambdabot> (Foldable t, Show a) => t a -> IO ()
2026-02-24 22:08:59 +0100 <mauke> that's not space separated
2026-02-24 22:09:18 +0100 <dolio> Yeah, you need the space analogue of print.
2026-02-24 22:09:28 +0100 <tomsmeding> lantti: are you allowed to use dependencies, like 'text' or 'bytestring'?
2026-02-24 22:09:59 +0100 <dolio> Is there a show-to-text/bytestring that doesn't run through show?
2026-02-24 22:10:17 +0100 <dolio> Other than the one I stopped maintaining like 10 years ago?
2026-02-24 22:10:48 +0100 <tomsmeding> well, for a start I'd be curious how `T.putStrLn (T.intercalate " " (map T.show ints))` performs, despite still using Prelude.show
2026-02-24 22:11:00 +0100 <mauke> :t let f [] = "\n"; f (x : xs) = shows x (' ' : f xs) in f
2026-02-24 22:11:03 +0100 <lambdabot> Show a => [a] -> [Char]
2026-02-24 22:11:13 +0100 <tomsmeding> dolio: https://hackage-content.haskell.org/package/text-2.1.4/docs/Data-Text-Lazy-Builder-Int.html ?
2026-02-24 22:11:34 +0100 <dolio> Oh, nice.
2026-02-24 22:11:48 +0100 <mauke> > let f [] = "\n"; f (x : xs) = shows x (' ' : f xs) in f [1,2,3]
2026-02-24 22:11:49 +0100 <lambdabot> "1 2 3 \n"
2026-02-24 22:11:51 +0100 <dolio> Also, is printing actually the bottleneck?
2026-02-24 22:12:13 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 22:12:24 +0100 <tomsmeding> right, possibly laziness makes it look like it is, even if it actually isn't
2026-02-24 22:12:36 +0100 <EvanR> isn't builder in appropriate here since we already have a lazy list of the things to print, in order
2026-02-24 22:12:45 +0100 <EvanR> just print them in order
2026-02-24 22:12:51 +0100 <tomsmeding> well, putStrLn takes an MVar on stdout
2026-02-24 22:13:04 +0100 <tomsmeding> taking an MVar for outputting like 5 bytes may not be optimal
2026-02-24 22:13:16 +0100 <EvanR> facepalm
2026-02-24 22:13:29 +0100 <tomsmeding> writing everything in a big buffer and then sending that buffer into stdout may be quite a bit faster
2026-02-24 22:13:41 +0100 <EvanR> this sounds so backwards
2026-02-24 22:13:58 +0100 <EvanR> kind of like buffering your own buffer before it gets to the OS buffers, which are then buffered
2026-02-24 22:14:09 +0100 <lantti> I'm currently trying to figure out how the profiling works, so I can get a better idea of the bottlenecks
2026-02-24 22:14:20 +0100 <tomsmeding> EvanR: output is already buffered, the actual write(2) call in the kernel is only called when stdout is flushed, which, if you don't write newlines, happens only every 4096 bytes or so
2026-02-24 22:14:47 +0100 <dolio> It's already effectively building a 'buffer' as a lazy list of characters. Builder is just generally a better one.
2026-02-24 22:15:08 +0100 <tomsmeding> EvanR: also, a Text Builder produces a _lazy_ text, so that doesn't actually create a whole separate buffering step
2026-02-24 22:15:33 +0100 <dolio> I think you can directly put a builder, too.
2026-02-24 22:15:35 +0100 <EvanR> a lazy text itself is already a lazy list
2026-02-24 22:15:35 +0100 <tomsmeding> or, well, it does, but then it (kind of) synchronises with the one in the RTS so they kinda merge
2026-02-24 22:15:46 +0100 <EvanR> then a builder to make a straight lazy list is not helping
2026-02-24 22:16:31 +0100 <tomsmeding> dolio: doesn't seem like you can, but toLazyText should be fine
2026-02-24 22:16:39 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 255 seconds)
2026-02-24 22:16:49 +0100 <EvanR> builder is often recommended in case people are trying to form a big sequence from pieces other than just tacking onto the end
2026-02-24 22:16:54 +0100 <dolio> Oh. I guess it's just bytestring builders.
2026-02-24 22:17:10 +0100 <tomsmeding> EvanR: which i why I recommended `T.intercalate` first
2026-02-24 22:17:20 +0100 <tomsmeding> but that doesn't have the nice Int serialiser
2026-02-24 22:17:41 +0100 <newmind> lantti: what's the actual time you're getting? just to see how reasonable it is
2026-02-24 22:18:02 +0100aka_dude(~aka_dude@2a03:f80:30:f490::1)
2026-02-24 22:18:19 +0100morj_away(~morj@user/morj) (Quit: Konversation terminated!)
2026-02-24 22:19:01 +0100aka_dude(~aka_dude@2a03:f80:30:f490::1) (Remote host closed the connection)
2026-02-24 22:19:21 +0100 <tomsmeding> further tip: benchmark your code but setting `ints = replicate 100000 123456789` or something, just to double-check it's actually the printing that's slow, not the computation preceding it
2026-02-24 22:20:01 +0100 <newmind> that was my second suggestion, replacing ints with [1..100000] or something
2026-02-24 22:20:32 +0100 <EvanR> .oO( replace the printing with just evaluating the ints in sequence )
2026-02-24 22:20:42 +0100 <tomsmeding> that's the dual version :p
2026-02-24 22:23:22 +0100 <mauke> :t mapM_ evaluate
2026-02-24 22:23:24 +0100 <lambdabot> Foldable t => t b -> IO ()
2026-02-24 22:24:47 +0100 <EvanR> hopefully evaluate doesn't first take an MVar before evaluating xD
2026-02-24 22:25:04 +0100 <EvanR> requiring us to do artifically additional buffering wtf
2026-02-24 22:25:35 +0100 <lantti> I can't figure out the profiling under stack right now, but unix time command for the 10000000 Ints case gives 0.8s
2026-02-24 22:25:39 +0100cbarrett(sid192934@id-192934.helmsley.irccloud.com) (Server closed connection)
2026-02-24 22:25:51 +0100cbarrett(sid192934@id-192934.helmsley.irccloud.com) cbarrett
2026-02-24 22:25:54 +0100 <EvanR> 10^7 ints
2026-02-24 22:26:07 +0100 <lantti> oops, 1000000
2026-02-24 22:26:32 +0100 <EvanR> are they particularly uniform ints or like up to 3 digits or
2026-02-24 22:27:17 +0100 <lantti> the whole task is that one: https://cses.fi/alon/task/1092/
2026-02-24 22:27:55 +0100 <lantti> so basically two runs of consecutive ints with one exception
2026-02-24 22:28:09 +0100 <lantti> in each run
2026-02-24 22:29:33 +0100 <EvanR> ok it doesn't seem to be trying to print out literally 10^6 ints but the program is more complex than that
2026-02-24 22:30:17 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 22:30:24 +0100 <haskellbridge> <ijouw> Is there a good way to define a more general Ord class that avoids troubles with functions using Ordered argumens like nubOn?
2026-02-24 22:31:02 +0100 <EvanR> :t nubOn
2026-02-24 22:31:20 +0100 <EvanR> @botsnack
2026-02-24 22:31:31 +0100 <lambdabot> :)
2026-02-24 22:31:32 +0100 <lambdabot> error: [GHC-88464] Variable not in scope: nubOn
2026-02-24 22:31:52 +0100aka_dude(~aka_dude@192.71.166.120)
2026-02-24 22:32:26 +0100 <haskellbridge> <ijouw> i meant this: nubOrdOn :: Ord b => (a -> b) -> [a] -> [a]
2026-02-24 22:32:29 +0100jreicher(~joelr@user/jreicher) (Ping timeout: 252 seconds)
2026-02-24 22:32:40 +0100 <EvanR> what is the trouble?
2026-02-24 22:32:41 +0100 <haskellbridge> <ijouw> Filters duplicates by sorting
2026-02-24 22:32:50 +0100 <lantti> It does need to print out 10^6 ints in the case n = 10^6. But thanks for the tips, i'll try some out and see if that makes a difference.
2026-02-24 22:33:09 +0100jreicher(~joelr@user/jreicher) jreicher
2026-02-24 22:33:46 +0100 <EvanR> yeah but it has to print a lot more than that in that case, so someone trying to replicate your running time is going to undershoot by a lot
2026-02-24 22:34:07 +0100 <tomsmeding> EvanR: yes, "YES" and 2 more ints
2026-02-24 22:34:07 +0100 <haskellbridge> <ijouw> It obviously does not work on MyOrd a => [a], and specifying MyOrd a, Ord a => [a] makes MyOrd seem pointless
2026-02-24 22:34:21 +0100 <EvanR> oh it's only 2 lines
2026-02-24 22:34:25 +0100 <EvanR> not N
2026-02-24 22:34:57 +0100 <EvanR> MyOrd ?
2026-02-24 22:35:02 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 268 seconds)
2026-02-24 22:35:11 +0100 <EvanR> you want it to work on a variable class?
2026-02-24 22:35:41 +0100 <EvanR> if you're trying to define an alternate Ord instance, that's what newtypes are for, then you use Ord
2026-02-24 22:36:26 +0100 <haskellbridge> <ijouw> I want to use type families to allow the return type to be wrapped for DSL stuff
2026-02-24 22:36:58 +0100 <tomsmeding> it kind of sounds like you'll need to be a bit more specific here
2026-02-24 22:37:42 +0100 <EvanR> maybe you need ways to lift library functions like nubOrdOn into your DSL
2026-02-24 22:43:02 +0100Arsen(16abab341f@gentoo/developer/managarm.dev.Arsen) Arsen
2026-02-24 22:45:40 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 22:45:47 +0100 <haskellbridge> <ijouw> I want this https://hackage-content.haskell.org/package/Boolean-0.2.4/docs/Data-Boolean.html#t:OrdB and then define a function nubOrd' :: (OrdB a, BooleanOf a ~ Bool) => [a] -> [a] ; (maybe i should just not reimplement everything...)
2026-02-24 22:46:06 +0100 <monochrom> I am unconvinced that (putStrLn . unwords . map show) is too slow. It's only 0.05 seconds on my laptop if you redirect to a file (which is the right thing to do if you're simulating an online autotester; if you let it go to a terminal, then the bottleneck is the terminal)
2026-02-24 22:47:07 +0100 <newmind> .o( but it does say a lot about haskell as a language/ecosystem that we're discussing it )
2026-02-24 22:47:33 +0100 <EvanR> it?
2026-02-24 22:47:58 +0100 <newmind> why something as simple as "print out this list of numbers" might be slow
2026-02-24 22:48:16 +0100 <monochrom> No, it says a lot about people having double standards.
2026-02-24 22:48:19 +0100Guest81(~Guest81@52.144.37.132)
2026-02-24 22:48:20 +0100 <EvanR> people mistake what's slow all the time, that's a haskell thing
2026-02-24 22:49:28 +0100 <EvanR> this problem that separates a million integers into two sets that adds up to the same thing
2026-02-24 22:49:38 +0100 <EvanR> printing it out doesn't sound like the crunchy part
2026-02-24 22:50:10 +0100 <mauke> printing is slow in C, too
2026-02-24 22:50:15 +0100 <monochrom> After compiling with -O, the IO monad doesn't exist in the machine code.
2026-02-24 22:50:21 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 265 seconds)
2026-02-24 22:50:28 +0100 <EvanR> i was going to say C is the one where you are sometimes trying to deduce how slow printing is
2026-02-24 22:50:29 +0100 <tomsmeding> (that's a claim)
2026-02-24 22:50:36 +0100 <tomsmeding> maybe in this tight loop that's true
2026-02-24 22:50:44 +0100 <mauke> back when I did SPOJ, I got significant time improvements by bypassing stdio
2026-02-24 22:50:48 +0100 <lantti> I suspected the printing because I realized there is an analytic solution to the actual problem and generating the lists is just some math operations and [1..xyz]
2026-02-24 22:51:08 +0100 <lantti> I'm in the process of re-evaluating that assumption :)
2026-02-24 22:51:20 +0100 <Guest81> I am reading "learn you a Haskell ..." and I am using interactive on the haskell.org homepage. But when I input a simple equality such as "a = [1,2,3]" is get a parse error. What am I doing wrong?
2026-02-24 22:51:40 +0100 <Rembane> Guest81: Try a let a = [1,2,3]
2026-02-24 22:51:55 +0100 <tomsmeding> that "Try it!" prompt on haskell.org is not a proper haskell interpreter
2026-02-24 22:52:02 +0100 <EvanR> a = [1,2,3] ought to work in ghci and at top level?
2026-02-24 22:52:08 +0100 <tomsmeding> it doesn't there
2026-02-24 22:52:20 +0100 <Guest81> no go: let a = [1,2,3]
2026-02-24 22:52:21 +0100 <Guest81> <no location info>: not an expression: ‘let a = [1,2,3]’
2026-02-24 22:52:32 +0100 <EvanR> "interesting"
2026-02-24 22:52:47 +0100 <monochrom> "a = [1,2,3]" works for me.
2026-02-24 22:53:06 +0100 <tomsmeding> there's https://play.haskell.org if you want to upgrade to writing a full program (which doesn't have to be complicated!); otherwise, either install ghci, or there may be some other online repl
2026-02-24 22:53:12 +0100 <monochrom> "let a = [1,2,3]" also works for me.
2026-02-24 22:53:23 +0100 <tomsmeding> monochrom: we're talking about the "Try it!" thing on haskell.org, which is stupid and broken
2026-02-24 22:53:35 +0100 <monochrom> Oh that. Sorry!
2026-02-24 22:53:51 +0100 <monochrom> "let a = [1,2,3] in length a"
2026-02-24 22:54:07 +0100 <tomsmeding> ah yes, that does work Guest81 ^
2026-02-24 22:54:18 +0100 <monochrom> But play.haskell.org is better.
2026-02-24 22:54:19 +0100astra(sid289983@user/amish) (Server closed connection)
2026-02-24 22:54:20 +0100 <tomsmeding> apparently it accepts only full expressions
2026-02-24 22:54:31 +0100 <tomsmeding> play.haskell.org is not a repl, though :)
2026-02-24 22:54:32 +0100prdak(~Thunderbi@user/prdak) (Ping timeout: 268 seconds)
2026-02-24 22:54:33 +0100astra(sid289983@id-289983.hampstead.irccloud.com)
2026-02-24 22:54:51 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2026-02-24 22:55:00 +0100 <monochrom> Who writes 1000 lines of code on a REPL anyway? Be realistic.
2026-02-24 22:55:02 +0100 <geekosaur> probably just hint
2026-02-24 22:55:10 +0100 <Guest81> OK so basically "Try it!" is not a true interpreter.
2026-02-24 22:55:12 +0100ChaiTRex(~ChaiTRex@user/chaitrex) ChaiTRex
2026-02-24 22:55:35 +0100 <tomsmeding> it is an interpreter, but not ghci
2026-02-24 22:55:46 +0100 <mauke> a = [1,2,3] is not an expression
2026-02-24 22:55:48 +0100 <tomsmeding> ghci does quite a bit more than just an interpreter for basic expressions, and "learn you a haskell" assumes ghci
2026-02-24 22:56:55 +0100 <Guest81> So i need ghci. Thanks all.
2026-02-24 22:57:07 +0100 <tomsmeding> that's probably easiest, yes (use ghcup)
2026-02-24 22:57:44 +0100 <EvanR> repl is overrated, you want to load a file anyway. Then reload
2026-02-24 22:58:31 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Client Quit)
2026-02-24 22:59:39 +0100philderbeast(~philderbe@57-134-39-54.resi.cgocable.ca)
2026-02-24 22:59:44 +0100Guest81(~Guest81@52.144.37.132) ()
2026-02-24 23:00:27 +0100ChaiTRex(~ChaiTRex@user/chaitrex) ChaiTRex
2026-02-24 23:01:02 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 23:01:40 +0100Milan_Vanca(~milan@user/Milan-Vanca:32634) (Quit: WeeChat 4.7.2)
2026-02-24 23:02:15 +0100humasect(~humasect@dyn-192-249-132-90.nexicom.net) (Quit: Leaving...)
2026-02-24 23:03:14 +0100philderbeast(~philderbe@57-134-39-54.resi.cgocable.ca) (Client Quit)
2026-02-24 23:03:59 +0100 <haskellbridge> <ijouw> Isn't the two sets algorithm discussed above easy to compute? The question is whether the sum [1..n] is even (solvable in constant time) (or am I missing something?). Printing could indeed be slowest part.
2026-02-24 23:04:21 +0100takuan(~takuan@d8D86B9E9.access.telenet.be) (Ping timeout: 255 seconds)
2026-02-24 23:04:25 +0100 <tomsmeding> ijouw: do you have a proof that if sum [1..n] is even, there is such a splitting?
2026-02-24 23:04:32 +0100peterbecich(~Thunderbi@71.84.33.135) peterbecich
2026-02-24 23:04:35 +0100target_i(~target_i@user/target-i/x-6023099) (Quit: leaving)
2026-02-24 23:04:44 +0100 <tomsmeding> (there is, but figuring out what the splitting is, requires a little trick)
2026-02-24 23:04:47 +0100 <haskellbridge> <ijouw> Working on it
2026-02-24 23:08:07 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-24 23:10:01 +0100abiss27(~abiss27@user/abiss) abiss
2026-02-24 23:11:53 +0100petrichor(~jez@user/petrichor) (Ping timeout: 248 seconds)
2026-02-24 23:12:45 +0100 <mauke> ah, I see it
2026-02-24 23:13:01 +0100 <mauke> 1 + 2 = 3
2026-02-24 23:15:12 +0100 <mauke> nvm, I'm blind
2026-02-24 23:17:05 +0100 <mauke> hah, no. I was wrong about being wrong. I just did it backwards :-)
2026-02-24 23:17:36 +0100 <newmind> mauke: did you get nerdsniped there?
2026-02-24 23:17:39 +0100gmc(sid58314@id-58314.ilkley.irccloud.com) (Server closed connection)
2026-02-24 23:17:50 +0100gmc(sid58314@id-58314.ilkley.irccloud.com) gmc
2026-02-24 23:19:06 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-24 23:19:31 +0100petrichor(~jez@user/petrichor) petrichor
2026-02-24 23:19:53 +0100tremon(~tremon@83.80.159.219) (Quit: getting boxed in)
2026-02-24 23:21:16 +0100 <tomsmeding> lantti: I'm not sure what you did, but it can probably be done more efficiently; this is haskell with `putStrLn . unwords . map show` https://tomsmeding.com/ss/get/tomsmeding/RnFf4z
2026-02-24 23:23:02 +0100 <tomsmeding> (I figured out a way to compute what numbers to print in constant time; then I just have to print all those numbers)
2026-02-24 23:23:28 +0100 <tomsmeding> it's a fun problem :)
2026-02-24 23:24:08 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 268 seconds)
2026-02-24 23:24:58 +0100 <tomsmeding> and I'm not sure where even that 0.30s comes from; it takes less than 1ms on that input on my machine
2026-02-24 23:25:35 +0100peterbecich(~Thunderbi@71.84.33.135) (Ping timeout: 245 seconds)
2026-02-24 23:25:48 +0100 <geekosaur> `sum [1..n]` isn't there a number theory approach for that?
2026-02-24 23:26:22 +0100 <haskellbridge> <ijouw> yes, it is (n*(n+1))/2
2026-02-24 23:26:41 +0100 <tomsmeding> it seems printing is actually rather slow on that judge server! On roughly 260000 I take 0.08s, on roughly 653000 I take 0.21s, and on 1000000 I take 0.30s
2026-02-24 23:27:25 +0100 <tomsmeding> and I can assure you that I am actually doing work that should take <10us plus `putStrLn . unwords . map show` on a lazy list of Int
2026-02-24 23:28:21 +0100 <tomsmeding> (I'm not sure if it's responsible to post my solution publically for people to scrutinise)
2026-02-24 23:28:43 +0100terrorjack(~terrorjac@2a01:4f8:271:2d98::2) terrorjack
2026-02-24 23:29:56 +0100 <lantti> tomsmeding: I already passed so you won't boost my grade with it
2026-02-24 23:30:21 +0100 <lantti> of course I don't know if any other students are reading this
2026-02-24 23:31:07 +0100 <tomsmeding> lantti: do you determine what numbers to print in constant time?
2026-02-24 23:31:19 +0100 <tomsmeding> or is there a little loop or something involved
2026-02-24 23:31:32 +0100 <lantti> yes, but I still generate a list of them. eliminating that list now...
2026-02-24 23:31:33 +0100 <tomsmeding> (and how do your judge times compare to mine?)
2026-02-24 23:31:42 +0100prdak(~Thunderbi@user/prdak) prdak
2026-02-24 23:31:48 +0100 <lantti> yes, to the constant time
2026-02-24 23:31:55 +0100 <tomsmeding> interesting
2026-02-24 23:32:41 +0100arandombit(~arandombi@user/arandombit) (Ping timeout: 248 seconds)
2026-02-24 23:32:50 +0100 <lantti> I also use a delete on one of the lists to remove that one int that needs to move to the other set
2026-02-24 23:33:12 +0100 <lantti> all that can still go away if i make a loop instead of a list
2026-02-24 23:33:30 +0100 <lantti> but that might work against me as well, lets see
2026-02-24 23:33:39 +0100kawzeg(kawzeg@2a01:4f9:c013:cfbf::1) (Server closed connection)
2026-02-24 23:33:57 +0100kawzeg(kawzeg@2a01:4f9:c013:cfbf::1) kawzeg
2026-02-24 23:34:27 +0100arahael(~wetfoot@user/arahael) arahael
2026-02-24 23:34:59 +0100machinedgod(~machinedg@d172-219-48-230.abhsia.telus.net) machinedgod
2026-02-24 23:36:19 +0100prdak(~Thunderbi@user/prdak) (Ping timeout: 264 seconds)
2026-02-24 23:36:26 +0100pavonia(~user@user/siracusa) siracusa
2026-02-24 23:36:59 +0100 <tomsmeding> turns out my lists weren't actually lazy when printed -- I was materialising them with 'length'. If I don't do that, my worst-case time on the judge server goes from 0.30s to 0.21s
2026-02-24 23:38:13 +0100tromp(~textual@2001:1c00:3487:1b00:7955:9591:6018:7ef9) (Quit: My iMac has gone to sleep. ZZZzzz…)
2026-02-24 23:38:37 +0100 <tomsmeding> (that server is really slow...)
2026-02-24 23:39:15 +0100 <mauke> you guys are using lists?