2025/05/18

2025-05-18 00:02:51 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 00:03:11 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 00:03:46 +0000jespada(~jespada@r179-25-150-22.dialup.adsl.anteldata.net.uy) (Ping timeout: 252 seconds)
2025-05-18 00:05:36 +0000acidjnk(~acidjnk@p200300d6e71c4f65f1ead88f57001215.dip0.t-ipconnect.de) (Ping timeout: 272 seconds)
2025-05-18 00:08:02 +0000sprotte24(~sprotte24@p200300d16f06fd00c9f6fa4fdf16930b.dip0.t-ipconnect.de) (Quit: Leaving)
2025-05-18 00:12:17 +0000Tuplanolla(~Tuplanoll@91-159-69-59.elisa-laajakaista.fi) (Quit: Leaving.)
2025-05-18 00:14:52 +0000craunts(~craunts@136.158.8.87)
2025-05-18 00:32:06 +0000Guest57(~Guest11@syn-024-165-041-231.res.spectrum.com) (Ping timeout: 240 seconds)
2025-05-18 00:32:59 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 00:33:20 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 00:34:00 +0000ljdarj(~Thunderbi@user/ljdarj) (Ping timeout: 276 seconds)
2025-05-18 00:35:57 +0000Guest11(~Guest11@syn-024-165-041-231.res.spectrum.com)
2025-05-18 00:47:06 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 00:47:28 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 00:53:27 +0000harveypwca(~harveypwc@2601:246:d080:f6e0:27d6:8cc7:eca9:c46c) (Quit: Leaving)
2025-05-18 00:55:37 +0000Square2(~Square@user/square) (Ping timeout: 265 seconds)
2025-05-18 00:59:48 +0000 <sm> watch = ["util", "exec", "--", "sh", "-c", """
2025-05-18 00:59:49 +0000 <sm> watchexec --wrap-process=session --no-vcs-ignore --ignore .jj/working_copy/working_copy.lock -c clear --bell "date; echo; jj --no-pager $@"
2025-05-18 00:59:49 +0000 <sm> """, ""]
2025-05-18 01:01:49 +0000end(~end@user/end/x-0094621) (Ping timeout: 252 seconds)
2025-05-18 01:02:10 +0000bcksl(~bcksl@user/bcksl) (Ping timeout: 260 seconds)
2025-05-18 01:02:47 +0000sus0(zero@user/zeromomentum) (Ping timeout: 252 seconds)
2025-05-18 01:05:41 +0000 <sm> I forgot a `--watch .jj` in there, more efficient
2025-05-18 01:06:05 +0000 <sm> now I can have an updating log, op log etc like in Martin's video
2025-05-18 01:09:59 +0000 <sm> and I can keep an eye on what other jj tools (like VJJ) are doing
2025-05-18 01:10:29 +0000peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) (Quit: peterbecich)
2025-05-18 01:11:11 +0000peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) peterbecich
2025-05-18 01:25:17 +0000craunts7(~craunts@136.158.8.87)
2025-05-18 01:25:22 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 01:25:44 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 01:26:11 +0000bcksl(~bcksl@user/bcksl) bcksl
2025-05-18 01:27:06 +0000craunts(~craunts@136.158.8.87) (Ping timeout: 252 seconds)
2025-05-18 01:27:07 +0000craunts7craunts
2025-05-18 01:27:10 +0000ttybitnik(~ttybitnik@user/wolper) (Quit: Fading out...)
2025-05-18 01:27:12 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp)
2025-05-18 01:31:14 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 01:31:35 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 01:35:21 +0000end(~end@user/end/x-0094621) end^
2025-05-18 01:36:21 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp) (Read error: Connection reset by peer)
2025-05-18 01:41:40 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp)
2025-05-18 01:44:55 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 01:45:16 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 01:46:09 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 276 seconds)
2025-05-18 01:48:30 +0000hiecaq(~hiecaq@user/hiecaq) hiecaq
2025-05-18 01:54:54 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp) (Read error: Connection reset by peer)
2025-05-18 01:58:03 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 02:01:25 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 02:01:46 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 02:05:03 +0000op_4(~tslil@user/op-4/x-9116473) (Remote host closed the connection)
2025-05-18 02:05:39 +0000op_4(~tslil@user/op-4/x-9116473) op_4
2025-05-18 02:05:47 +0000joeyadams(~textual@syn-162-154-010-038.res.spectrum.com)
2025-05-18 02:14:06 +0000manwithluck(~manwithlu@2a09:bac5:5082:2387::38a:10) (Ping timeout: 276 seconds)
2025-05-18 02:14:09 +0000td_(~td@i53870928.versanet.de) (Ping timeout: 245 seconds)
2025-05-18 02:16:02 +0000td_(~td@i5387091A.versanet.de) td_
2025-05-18 02:16:14 +0000 <ski> oh .. sorry, for some reason i missed the paste, Leary
2025-05-18 02:19:19 +0000 <Leary> No worries.
2025-05-18 02:24:02 +0000JuanDaugherty(~juan@user/JuanDaugherty) JuanDaugherty
2025-05-18 02:25:11 +0000gmg(~user@user/gehmehgeh) (Remote host closed the connection)
2025-05-18 02:29:14 +0000 <ski> i was reminded of `IVar's, but it doesn't look like what you're doing is that similar to that (except `Identified', slightly)
2025-05-18 02:31:30 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 02:31:52 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 02:40:33 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp)
2025-05-18 02:46:33 +0000peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) (Ping timeout: 252 seconds)
2025-05-18 02:54:47 +0000JuanDaugherty(~juan@user/JuanDaugherty) (Quit: praxis.meansofproduction.biz (juan@acm.org))
2025-05-18 02:55:49 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 02:56:09 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 03:00:32 +0000bitdex(~bitdex@gateway/tor-sasl/bitdex) (Read error: Connection reset by peer)
2025-05-18 03:00:32 +0000chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2025-05-18 03:00:32 +0000chiselfuse(~chiselfus@user/chiselfuse) (Remote host closed the connection)
2025-05-18 03:00:32 +0000califax(~califax@user/califx) (Remote host closed the connection)
2025-05-18 03:00:32 +0000ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2025-05-18 03:00:52 +0000califax(~califax@user/califx) califx
2025-05-18 03:00:55 +0000bitdex(~bitdex@gateway/tor-sasl/bitdex) bitdex
2025-05-18 03:00:58 +0000chexum(~quassel@gateway/tor-sasl/chexum) chexum
2025-05-18 03:01:02 +0000ChaiTRex(~ChaiTRex@user/chaitrex) ChaiTRex
2025-05-18 03:01:10 +0000chiselfuse(~chiselfus@user/chiselfuse) chiselfuse
2025-05-18 03:01:45 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 260 seconds)
2025-05-18 03:04:11 +0000Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 265 seconds)
2025-05-18 03:05:24 +0000ystael(~ystael@user/ystael) (Ping timeout: 245 seconds)
2025-05-18 03:13:32 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 03:16:21 +0000peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) peterbecich
2025-05-18 03:16:22 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp) (Read error: Connection reset by peer)
2025-05-18 03:19:56 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp)
2025-05-18 03:33:31 +0000aforemny(~aforemny@i59F4C598.versanet.de) aforemny
2025-05-18 03:33:35 +0000Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2025-05-18 03:35:14 +0000aforemny_(~aforemny@2001:9e8:6ce3:4b00:63e7:2449:7739:bbf2) (Ping timeout: 272 seconds)
2025-05-18 03:42:31 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479)
2025-05-18 03:43:08 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479) (Client Quit)
2025-05-18 03:47:26 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp) (Read error: Connection reset by peer)
2025-05-18 03:48:54 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 03:49:14 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 03:56:02 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 03:56:24 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 04:02:05 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 04:02:27 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 04:08:37 +0000poscat(~poscat@user/poscat) (Remote host closed the connection)
2025-05-18 04:11:39 +0000poscat(~poscat@user/poscat) poscat
2025-05-18 04:16:36 +0000j1n37-(~j1n37@user/j1n37) j1n37
2025-05-18 04:17:04 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds)
2025-05-18 04:17:35 +0000j1n37(~j1n37@user/j1n37) (Ping timeout: 260 seconds)
2025-05-18 04:17:52 +0000haskellbridge(~hackager@syn-096-028-224-255.res.spectrum.com) hackager
2025-05-18 04:17:52 +0000ChanServ+v haskellbridge
2025-05-18 04:21:53 +0000j1n37(~j1n37@user/j1n37) j1n37
2025-05-18 04:22:07 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 04:22:27 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 04:22:44 +0000haskellbridge(~hackager@syn-096-028-224-255.res.spectrum.com) (Ping timeout: 272 seconds)
2025-05-18 04:23:00 +0000j1n37-(~j1n37@user/j1n37) (Ping timeout: 252 seconds)
2025-05-18 04:23:42 +0000Guest11(~Guest11@syn-024-165-041-231.res.spectrum.com) (Ping timeout: 240 seconds)
2025-05-18 04:24:12 +0000haskellbridge(~hackager@syn-096-028-224-255.res.spectrum.com) hackager
2025-05-18 04:24:12 +0000ChanServ+v haskellbridge
2025-05-18 04:25:32 +0000 <geekosaur> network back, IP address changed so matrix-side may be a little flaky until the new one propagates
2025-05-18 04:28:53 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 04:30:20 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 04:30:42 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 04:36:26 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 04:36:47 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 04:42:14 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 04:42:34 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 04:45:24 +0000Nosrep(~Nosrep@user/nosrep) (Ping timeout: 245 seconds)
2025-05-18 04:48:59 +0000 <sm> hurrah!
2025-05-18 04:50:29 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 04:50:50 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 04:52:23 +0000Lord_of_Life(~Lord@user/lord-of-life/x-2819915) Lord_of_Life
2025-05-18 04:55:25 +0000Frostillicus(~Frostilli@71.174.119.69)
2025-05-18 04:56:19 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 04:56:40 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 05:00:10 +0000Frostillicus(~Frostilli@71.174.119.69) (Ping timeout: 260 seconds)
2025-05-18 05:01:05 +0000jmcantrell(~weechat@user/jmcantrell) (Quit: WeeChat 4.6.2)
2025-05-18 05:07:18 +0000joeyadams(~textual@syn-162-154-010-038.res.spectrum.com) (Quit: Textual IRC Client: www.textualapp.com)
2025-05-18 05:07:43 +0000robobub(uid248673@id-248673.uxbridge.irccloud.com) robobub
2025-05-18 05:14:40 +0000 <haskellbridge> <magic_rb> i seem to recall some people hosted these temporary file sharing services and those would work, they all skipped my mind though just now
2025-05-18 05:14:42 +0000 <haskellbridge> <sm> matrix ?
2025-05-18 05:14:42 +0000 <haskellbridge> <sm> or https://pub.microbin.eu ?
2025-05-18 05:14:42 +0000 <haskellbridge> <magic_rb> https://pub.microbin.eu/upload/zebra-eagle this works
2025-05-18 05:14:42 +0000 <haskellbridge> <sm> excellent pastebin
2025-05-18 05:14:42 +0000 <haskellbridge> <magic_rb> dmjio i was talking about the photo thing right, so that is how it looks now
2025-05-18 05:14:42 +0000 <haskellbridge> <magic_rb> you can tag photos, rename them, javascript free
2025-05-18 05:14:44 +0000 <haskellbridge> <magic_rb> and its stored in git+git-annex
2025-05-18 05:14:45 +0000 <haskellbridge> <magic_rb> https://paste.tomsmeding.com/fxesVbzl like that
2025-05-18 05:14:47 +0000 <haskellbridge> <magic_rb> the database is just a cache for the toml files and can be evicted at any point
2025-05-18 05:14:48 +0000 <haskellbridge> <sm> test
2025-05-18 05:21:25 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 05:21:46 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 05:25:51 +0000craunts(~craunts@136.158.8.87) (Quit: Ping timeout (120 seconds))
2025-05-18 05:26:06 +0000craunts(~craunts@136.158.8.87)
2025-05-18 05:33:02 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 272 seconds)
2025-05-18 05:36:44 +0000j1n37-(~j1n37@user/j1n37) j1n37
2025-05-18 05:36:50 +0000j1n37(~j1n37@user/j1n37) (Ping timeout: 272 seconds)
2025-05-18 05:38:19 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 05:38:41 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 05:44:22 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 05:44:44 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 05:45:39 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 05:50:26 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 05:50:52 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 05:52:28 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds)
2025-05-18 05:57:22 +0000euleritian(~euleritia@ip4d17f864.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2025-05-18 05:57:46 +0000euleritian(~euleritia@77.23.248.100)
2025-05-18 05:57:57 +0000euleritian(~euleritia@77.23.248.100) (Remote host closed the connection)
2025-05-18 06:00:21 +0000craunts(~craunts@136.158.8.87) (Ping timeout: 248 seconds)
2025-05-18 06:01:14 +0000euleritian(~euleritia@77.23.248.100)
2025-05-18 06:01:30 +0000wootehfoot(~wootehfoo@user/wootehfoot) wootehfoot
2025-05-18 06:02:26 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 06:02:49 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 06:03:52 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 06:09:42 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds)
2025-05-18 06:09:55 +0000euleritian(~euleritia@77.23.248.100) (Remote host closed the connection)
2025-05-18 06:10:19 +0000euleritian(~euleritia@ip4d17f864.dynamic.kabel-deutschland.de)
2025-05-18 06:16:30 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 06:16:57 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 06:20:36 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 06:25:25 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 06:25:47 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 06:26:14 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 272 seconds)
2025-05-18 06:36:39 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 06:37:56 +0000werneta(~werneta@syn-071-083-160-242.res.spectrum.com) werneta
2025-05-18 06:45:01 +0000j1n37(~j1n37@user/j1n37) j1n37
2025-05-18 06:45:11 +0000craunts(~craunts@136.158.8.87)
2025-05-18 06:45:24 +0000j1n37-(~j1n37@user/j1n37) (Ping timeout: 245 seconds)
2025-05-18 06:48:44 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 06:49:05 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 06:50:09 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479)
2025-05-18 06:51:16 +0000craunts(~craunts@136.158.8.87) (Read error: Connection reset by peer)
2025-05-18 06:51:38 +0000craunts(~craunts@136.158.8.87)
2025-05-18 06:52:06 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp)
2025-05-18 06:56:34 +0000craunts(~craunts@136.158.8.87) (Ping timeout: 252 seconds)
2025-05-18 07:00:00 +0000caconym7(~caconym@user/caconym) (Quit: bye)
2025-05-18 07:00:39 +0000caconym7(~caconym@user/caconym) caconym
2025-05-18 07:05:21 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp) (Ping timeout: 248 seconds)
2025-05-18 07:07:30 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp)
2025-05-18 07:08:49 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 07:09:10 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 07:13:43 +0000craunts(~craunts@136.158.8.87)
2025-05-18 07:14:36 +0000poscat(~poscat@user/poscat) (Remote host closed the connection)
2025-05-18 07:16:15 +0000poscat(~poscat@user/poscat) poscat
2025-05-18 07:17:38 +0000craunts(~craunts@136.158.8.87) (Client Quit)
2025-05-18 07:18:52 +0000peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) (Ping timeout: 276 seconds)
2025-05-18 07:23:06 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 07:23:28 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 07:29:50 +0000Frostillicus(~Frostilli@pool-71-174-119-69.bstnma.fios.verizon.net)
2025-05-18 07:31:59 +0000j1n37-(~j1n37@user/j1n37) j1n37
2025-05-18 07:32:03 +0000ljdarj(~Thunderbi@user/ljdarj) ljdarj
2025-05-18 07:32:36 +0000j1n37(~j1n37@user/j1n37) (Ping timeout: 276 seconds)
2025-05-18 07:36:35 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 07:36:58 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 07:37:15 +0000Digit(~user@user/digit) Digit
2025-05-18 07:41:03 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 276 seconds)
2025-05-18 07:44:54 +0000acidjnk(~acidjnk@p200300d6e71c4f033d258f2e8b70eea4.dip0.t-ipconnect.de) acidjnk
2025-05-18 07:47:09 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 07:47:32 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 07:50:56 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp) (Read error: Connection reset by peer)
2025-05-18 07:51:17 +0000ljdarj(~Thunderbi@user/ljdarj) (Ping timeout: 248 seconds)
2025-05-18 07:52:18 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 07:59:23 +0000weary-traveler(~user@user/user363627) (Remote host closed the connection)
2025-05-18 08:00:25 +0000sus0(zero@user/zeromomentum) zeromomentum
2025-05-18 08:02:29 +0000Tuplanolla(~Tuplanoll@91-159-69-59.elisa-laajakaista.fi) Tuplanolla
2025-05-18 08:03:59 +0000 <haskellbridge> <sm> what's Haskell's killer domain, for https://news.ycombinator.com/item?id=44018922 ?
2025-05-18 08:05:40 +0000Digit(~user@user/digit) (Ping timeout: 260 seconds)
2025-05-18 08:05:58 +0000 <haskellbridge> <sm> "high-assurance computing and prototyping/research"
2025-05-18 08:06:28 +0000 <Rembane> Also parsers and compilers
2025-05-18 08:06:32 +0000 <haskellbridge> <hellwolf> ecosystem of PL nerds
2025-05-18 08:06:57 +0000 <Rembane> And research in lazily evaluated programming languages
2025-05-18 08:09:37 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 08:09:59 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 08:17:08 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 08:17:29 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 08:18:17 +0000 <haskellbridge> <maerwald> High assurance computing?
2025-05-18 08:18:41 +0000 <haskellbridge> <maerwald> GHC and its RTS are underspecified black boxes
2025-05-18 08:19:39 +0000 <haskellbridge> <sm> better: "High assurance applications and prototyping/research"
2025-05-18 08:20:33 +0000 <haskellbridge> <sm> this is in context of the above article, where each language gets 4-6 words for a general audience
2025-05-18 08:21:37 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479) (Quit: My iMac has gone to sleep. ZZZzzz…)
2025-05-18 08:21:42 +0000 <haskellbridge> <sm> * 1-6
2025-05-18 08:23:53 +0000__monty__(~toonn@user/toonn) toonn
2025-05-18 08:26:51 +0000ljdarj(~Thunderbi@user/ljdarj) ljdarj
2025-05-18 08:29:55 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479)
2025-05-18 08:32:12 +0000tzh(~tzh@c-76-115-131-146.hsd1.or.comcast.net) (Quit: zzz)
2025-05-18 08:42:57 +0000JuanDaugherty(~juan@user/JuanDaugherty) JuanDaugherty
2025-05-18 08:42:58 +0000Frostillicus(~Frostilli@pool-71-174-119-69.bstnma.fios.verizon.net) (Ping timeout: 252 seconds)
2025-05-18 08:43:21 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 08:43:42 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 08:47:24 +0000Digit(~user@user/digit) Digit
2025-05-18 08:51:40 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 08:52:00 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 08:56:50 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp)
2025-05-18 09:02:04 +0000Frostillicus(~Frostilli@pool-71-174-119-69.bstnma.fios.verizon.net)
2025-05-18 09:03:24 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 09:03:45 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 09:04:31 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479) (Quit: My iMac has gone to sleep. ZZZzzz…)
2025-05-18 09:06:12 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479)
2025-05-18 09:08:07 +0000srazkvt(~sarah@user/srazkvt) srazkvt
2025-05-18 09:15:44 +0000gmg(~user@user/gehmehgeh) gehmehgeh
2025-05-18 09:17:45 +0000JuanDaugherty(~juan@user/JuanDaugherty) (Quit: praxis.meansofproduction.biz (juan@acm.org))
2025-05-18 09:19:54 +0000j1n37(~j1n37@user/j1n37) j1n37
2025-05-18 09:21:06 +0000j1n37-(~j1n37@user/j1n37) (Ping timeout: 252 seconds)
2025-05-18 09:23:44 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Read error: Connection reset by peer)
2025-05-18 09:24:05 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 09:29:21 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 09:29:43 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 09:36:40 +0000Frostillicus(~Frostilli@pool-71-174-119-69.bstnma.fios.verizon.net) (Ping timeout: 260 seconds)
2025-05-18 09:39:49 +0000Frostillicus(~Frostilli@pool-71-174-119-69.bstnma.fios.verizon.net)
2025-05-18 09:40:19 +0000lxsameer(~lxsameer@Serene/lxsameer) lxsameer
2025-05-18 09:44:11 +0000 <lxsameer> hey folks, how do you model a data type with one constructor, in such a way that every value of that type is a distinct value, so no two value are equal? the constructor does not take any input. it's literally `data X = X`
2025-05-18 09:45:38 +0000 <lxsameer> for example, in an implementation of this type in an imperative lang, they just left it to the memory manager to choose a distinct address for each new value
2025-05-18 09:45:50 +0000 <lxsameer> and compare elements of this type based on their address
2025-05-18 09:47:00 +0000 <tomsmeding> lxsameer: give it an Int field, don't export the constructor, and expose a smart constructor that increments a global IORef?
2025-05-18 09:47:14 +0000 <tomsmeding> obligatory warning: use atomicModifyIORef', and put NOINLINE on functions with unsafePerformIO
2025-05-18 09:47:19 +0000Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2025-05-18 09:47:47 +0000 <lxsameer> tomsmeding: thank you
2025-05-18 09:48:42 +0000j1n37-(~j1n37@user/j1n37) j1n37
2025-05-18 09:48:58 +0000econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2025-05-18 09:49:24 +0000j1n37(~j1n37@user/j1n37) (Ping timeout: 244 seconds)
2025-05-18 09:50:09 +0000Frostillicus(~Frostilli@pool-71-174-119-69.bstnma.fios.verizon.net) (Ping timeout: 248 seconds)
2025-05-18 09:50:37 +0000 <mauke> instance Eq X where _ == _ = False
2025-05-18 09:53:38 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 09:54:02 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 09:55:56 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds)
2025-05-18 10:02:30 +0000 <lxsameer> mauke: a value is still equal to itself
2025-05-18 10:04:11 +0000 <mauke> equal in what sense?
2025-05-18 10:04:34 +0000 <lxsameer> sameness
2025-05-18 10:09:22 +0000 <mauke> what does that mean
2025-05-18 10:10:01 +0000 <lxsameer> a = X; b = X; c = a; a /= b; a == c
2025-05-18 10:10:04 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 10:13:27 +0000 <mauke> oh, you *want* it to be equal
2025-05-18 10:13:43 +0000 <mauke> yeah, that's not a thing
2025-05-18 10:15:40 +0000turlando(~turlando@user/turlando) (Quit: No Ping reply in 180 seconds.)
2025-05-18 10:16:14 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 10:16:35 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 10:16:56 +0000turlando(~turlando@user/turlando) turlando
2025-05-18 10:20:38 +0000notzmv(~daniel@user/notzmv) (Ping timeout: 265 seconds)
2025-05-18 10:21:59 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 10:22:21 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 10:34:37 +0000ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2025-05-18 10:35:01 +0000ChaiTRex(~ChaiTRex@user/chaitrex) ChaiTRex
2025-05-18 10:35:23 +0000 <tomsmeding> the fact that you need ugliness like unsafePerformIO in my suggestion shows what you're asking for :p
2025-05-18 10:35:39 +0000 <lxsameer> ah haskell has a Unique type too
2025-05-18 10:35:46 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 10:36:08 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 10:36:13 +0000 <lxsameer> essentially it seems like the same thing that tomsmeding suggested
2025-05-18 10:36:28 +0000 <tomsmeding> yes, but you still need to write the unsafePerformIO yourself
2025-05-18 10:36:51 +0000 <tomsmeding> well here is indeed precisely what I suggested, lol https://hackage.haskell.org/package/ghc-internal-9.1201.0/docs/src/GHC.Internal.Data.Unique.html#U…
2025-05-18 10:37:04 +0000 <tomsmeding> except you probably need another unsafePerformIO around newUnique
2025-05-18 10:38:18 +0000 <tomsmeding> the comments below newUnique are interesting to read: apparently it was an MVar before, then it became STM, and then it became an IORef
2025-05-18 10:38:55 +0000 <tomsmeding> given current state of things in GHC Haskell, I would never even consider using something else than an IORef, but because these things harken from >12 years ago, perhaps the runtime behaved differently
2025-05-18 10:40:12 +0000wootehfoot(~wootehfoo@user/wootehfoot) (Ping timeout: 272 seconds)
2025-05-18 10:40:45 +0000 <Rembane> So things became less and less safe and faster and faster over time?
2025-05-18 10:40:56 +0000euleritian(~euleritia@ip4d17f864.dynamic.kabel-deutschland.de) (Ping timeout: 265 seconds)
2025-05-18 10:41:22 +0000euleritian(~euleritia@dynamic-176-006-136-230.176.6.pool.telefonica.de)
2025-05-18 10:44:18 +0000 <lxsameer> hmmmm but i think it's better to rethink the approach
2025-05-18 10:44:31 +0000wootehfoot(~wootehfoo@user/wootehfoot) wootehfoot
2025-05-18 10:46:08 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479) (Quit: My iMac has gone to sleep. ZZZzzz…)
2025-05-18 10:46:37 +0000euleritian(~euleritia@dynamic-176-006-136-230.176.6.pool.telefonica.de) (Read error: Connection reset by peer)
2025-05-18 10:46:55 +0000euleritian(~euleritia@ip4d17f864.dynamic.kabel-deutschland.de)
2025-05-18 10:48:43 +0000 <tomsmeding> Rembane: why less safe?
2025-05-18 10:49:27 +0000 <tomsmeding> the move from MVar to STM lost fairness; I would not call that "safety", but it's perhaps close enough. But STM -> IORef doesn't lose anything
2025-05-18 10:49:38 +0000 <Rembane> tomsmeding: Maybe I have misunderstood everything but I thought MVar was more safe than STM that was more safe than IORef, but I don't know why. So it might just be something I got wrong.
2025-05-18 10:49:41 +0000 <tomsmeding> (in this particular application)
2025-05-18 10:49:47 +0000 <Rembane> Got it!
2025-05-18 10:49:53 +0000 <lxsameer> tomsmeding: no, I'm trying to port a legacy code (which is in very old scheme) to haskell, what is happening there is not necessarily the right way to implement it in haskell
2025-05-18 10:50:08 +0000 <lxsameer> ah sorry, it wasn't for me
2025-05-18 10:50:41 +0000 <tomsmeding> Rembane: MVar is a mutable variable with guaranteed FIFO queueing; STM is optimistic concurrency that has various sources of overhead but avoids locking in the happy path of no contention
2025-05-18 10:50:43 +0000LainIwakura(~LainIwaku@user/LainIwakura) LainIwakura
2025-05-18 10:50:58 +0000 <tomsmeding> STM doesn't give any concurrency guarantees, just the observation that in practice it works really well
2025-05-18 10:51:07 +0000 <tomsmeding> IORef is just... a mutable thing
2025-05-18 10:51:22 +0000 <Rembane> tomsmeding: Maybe that's the point. Hm... because I've learned them in the context of concurrency.
2025-05-18 10:51:24 +0000 <tomsmeding> it seems to me that "obviously" atomicModifyIORef' is the fastest
2025-05-18 10:51:37 +0000 <tomsmeding> it does just an atomic update, whereas MVar and STM do a whole lot more
2025-05-18 10:51:45 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 10:52:07 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 10:52:20 +0000 <tomsmeding> lxsameer: I'm not saying you're doing the wrong thing, just indicating that what you're doing isn't very haskell-like, and the language complains by making you do ugly things. :)
2025-05-18 10:52:54 +0000tomsmedingworks almost daily with programs that use this particular ID generation trick, so I'm tainted too
2025-05-18 10:52:55 +0000 <lxsameer> tomsmeding: that's a good summary of it
2025-05-18 10:54:14 +0000 <tomsmeding> Rembane: I learned them in the context of concurrency too! Specifically, in the context of having to teach concurrency to bachelor students in a course that uses haskell :p
2025-05-18 10:54:26 +0000 <tomsmeding> (I knew them decently well before that, but more in detail now)
2025-05-18 10:54:43 +0000fp1(~Thunderbi@hof1.kyla.fi) fp
2025-05-18 10:55:01 +0000 <Rembane> tomsmeding: That's a really good trick to learn something! :D
2025-05-18 10:55:07 +0000 <tomsmeding> it is :)
2025-05-18 10:55:14 +0000 <tomsmeding> just a bit hard to pull off, sometimes
2025-05-18 10:55:34 +0000 <Rembane> Totally. "Hi there friends, of course you want to learn this complicated thing..."
2025-05-18 10:56:50 +0000 <tomsmeding> Rembane: in some senses, STM is safer than MVar: you get actual transactions that act like transactions, in that they're atomic; with MVars, you have to do the work yourself so that you don't get into deadlocks
2025-05-18 10:57:14 +0000 <tomsmeding> you can do the classical thing of having two MVars, A and B, and have thread 1 lock A and then B, and have thread 2 lock B and then A
2025-05-18 10:57:18 +0000 <tomsmeding> voilà, deadlock
2025-05-18 10:57:20 +0000 <Rembane> \œ/
2025-05-18 10:57:43 +0000 <Rembane> tomsmeding: It just struck me that it's such a luxury to have proper transactions outside of a database.
2025-05-18 10:57:47 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 10:58:07 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 10:58:21 +0000 <tomsmeding> on the other hand, MVar gives you fairness, whereas with STM, if you have very long transactions and multiple of those are trying to run concurrently, they can restart and restart and restart and never actually finish
2025-05-18 10:58:45 +0000 <tomsmeding> there is always a probability of one finishing and getting out of the livelock, but it can take a while in the absolute worst case
2025-05-18 10:59:10 +0000troydm(~troydm@user/troydm) (Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset)
2025-05-18 10:59:23 +0000 <tomsmeding> Rembane: it is absolutely a luxury, and it's almost impossible to do it with a sensible API in a non-pure langugae
2025-05-18 10:59:28 +0000 <tomsmeding> so haskell is blessed :)
2025-05-18 10:59:44 +0000 <Rembane> tomsmeding: It's so good. :D
2025-05-18 11:00:25 +0000zlqrvx(~zlqrvx@2001:8003:8c8b:e00:374a:bdcb:457c:d1e3)
2025-05-18 11:01:44 +0000jespada(~jespada@r167-61-146-44.dialup.adsl.anteldata.net.uy) jespada
2025-05-18 11:03:39 +0000euleritian(~euleritia@ip4d17f864.dynamic.kabel-deutschland.de) (Ping timeout: 265 seconds)
2025-05-18 11:05:22 +0000euleritian(~euleritia@dynamic-176-006-136-230.176.6.pool.telefonica.de)
2025-05-18 11:07:49 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 11:07:56 +0000LainIwakura(~LainIwaku@user/LainIwakura) (Quit: Client closed)
2025-05-18 11:08:11 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 11:13:54 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 260 seconds)
2025-05-18 11:25:21 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 11:30:47 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479)
2025-05-18 11:33:09 +0000lxsameer(~lxsameer@Serene/lxsameer) (Ping timeout: 260 seconds)
2025-05-18 11:50:41 +0000j1n37-(~j1n37@user/j1n37) (Ping timeout: 248 seconds)
2025-05-18 11:52:06 +0000j1n37(~j1n37@user/j1n37) j1n37
2025-05-18 11:59:10 +0000euleritian(~euleritia@dynamic-176-006-136-230.176.6.pool.telefonica.de) (Read error: Connection reset by peer)
2025-05-18 11:59:43 +0000euleritian(~euleritia@ip4d17f864.dynamic.kabel-deutschland.de)
2025-05-18 12:03:13 +0000euphores(~SASL_euph@user/euphores) (Quit: Leaving.)
2025-05-18 12:05:07 +0000rvalue(~rvalue@user/rvalue) (Ping timeout: 252 seconds)
2025-05-18 12:06:28 +0000rvalue-(~rvalue@user/rvalue) rvalue
2025-05-18 12:06:56 +0000rvalue-rvalue
2025-05-18 12:12:18 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479) (Quit: My iMac has gone to sleep. ZZZzzz…)
2025-05-18 12:15:10 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 12:15:32 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 12:18:11 +0000euphores(~SASL_euph@user/euphores) euphores
2025-05-18 12:28:06 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds)
2025-05-18 12:34:00 +0000jespada(~jespada@r167-61-146-44.dialup.adsl.anteldata.net.uy) (Ping timeout: 260 seconds)
2025-05-18 12:36:16 +0000euleritian(~euleritia@ip4d17f864.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2025-05-18 12:36:37 +0000euleritian(~euleritia@77.23.248.100)
2025-05-18 12:38:08 +0000Digitteknohippie(~user@user/digit) Digit
2025-05-18 12:39:09 +0000Digit(~user@user/digit) (Ping timeout: 245 seconds)
2025-05-18 12:39:21 +0000jespada(~jespada@r186-48-57-38.dialup.adsl.anteldata.net.uy) jespada
2025-05-18 12:40:19 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 12:46:25 +0000img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2025-05-18 12:47:44 +0000img(~img@user/img) img
2025-05-18 12:51:16 +0000euleritian(~euleritia@77.23.248.100) (Ping timeout: 244 seconds)
2025-05-18 12:51:36 +0000euleritian(~euleritia@dynamic-176-006-136-230.176.6.pool.telefonica.de)
2025-05-18 12:54:31 +0000euleritian(~euleritia@dynamic-176-006-136-230.176.6.pool.telefonica.de) (Read error: Connection reset by peer)
2025-05-18 12:54:50 +0000euleritian(~euleritia@77.23.248.100)
2025-05-18 13:04:20 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 13:04:43 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 13:07:20 +0000fp1(~Thunderbi@hof1.kyla.fi) (Ping timeout: 252 seconds)
2025-05-18 13:09:22 +0000lxsameer(~lxsameer@Serene/lxsameer) lxsameer
2025-05-18 13:11:23 +0000DigitteknohippieDigit
2025-05-18 13:11:43 +0000FragByte(~christian@user/fragbyte) (Quit: Quit)
2025-05-18 13:13:42 +0000FragByte(~christian@user/fragbyte) FragByte
2025-05-18 13:15:23 +0000euleritian(~euleritia@77.23.248.100) (Ping timeout: 252 seconds)
2025-05-18 13:16:14 +0000Square2(~Square@user/square) Square
2025-05-18 13:17:53 +0000euleritian(~euleritia@dynamic-176-006-136-230.176.6.pool.telefonica.de)
2025-05-18 13:19:03 +0000img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2025-05-18 13:20:22 +0000img(~img@user/img) img
2025-05-18 13:24:25 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 13:24:47 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 13:27:25 +0000wickedjargon(~user@2001:569:fc3c:d000:49fd:4f0f:5c90:505) (Remote host closed the connection)
2025-05-18 13:28:57 +0000ttybitnik(~ttybitnik@user/wolper) ttybitnik
2025-05-18 13:29:50 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479)
2025-05-18 13:32:28 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 13:32:51 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 13:34:06 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) (Quit: WeeChat 4.5.2)
2025-05-18 13:34:17 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) GdeVolpiano
2025-05-18 13:39:35 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) (Quit: WeeChat 4.5.2)
2025-05-18 13:39:44 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) GdeVolpiano
2025-05-18 13:40:54 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) (Client Quit)
2025-05-18 13:41:03 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) GdeVolpiano
2025-05-18 13:41:15 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) (Client Quit)
2025-05-18 13:42:16 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) GdeVolpiano
2025-05-18 13:43:40 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) (Client Quit)
2025-05-18 13:43:50 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) GdeVolpiano
2025-05-18 13:44:57 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) (Client Quit)
2025-05-18 13:45:19 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) GdeVolpiano
2025-05-18 13:45:44 +0000Guest45(~Guest45@2a00:9fe0:0:c::1:102a)
2025-05-18 13:46:02 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 244 seconds)
2025-05-18 13:51:15 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) (Quit: WeeChat 4.5.2)
2025-05-18 13:52:16 +0000Nosrep(~Nosrep@user/nosrep) Nosrep
2025-05-18 13:52:21 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) GdeVolpiano
2025-05-18 13:52:45 +0000acidjnk(~acidjnk@p200300d6e71c4f033d258f2e8b70eea4.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2025-05-18 13:53:55 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) (Client Quit)
2025-05-18 13:54:05 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) GdeVolpiano
2025-05-18 13:54:23 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) (Client Quit)
2025-05-18 13:54:34 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 13:54:55 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 13:55:02 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) GdeVolpiano
2025-05-18 13:55:24 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) (Client Quit)
2025-05-18 13:55:34 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) GdeVolpiano
2025-05-18 13:56:33 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) (Client Quit)
2025-05-18 13:56:54 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) GdeVolpiano
2025-05-18 13:57:15 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) (Client Quit)
2025-05-18 13:57:34 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 13:59:14 +0000pavonia(~user@user/siracusa) (Quit: Bye!)
2025-05-18 14:05:08 +0000tinjamin4(~tinjamin@banshee.h4x0r.space)
2025-05-18 14:10:49 +0000Digitteknohippie(~user@user/digit) Digit
2025-05-18 14:11:52 +0000Digit(~user@user/digit) (Ping timeout: 244 seconds)
2025-05-18 14:20:37 +0000lxsameer(~lxsameer@Serene/lxsameer) (Ping timeout: 248 seconds)
2025-05-18 14:25:24 +0000Digitteknohippie(~user@user/digit) (Ping timeout: 245 seconds)
2025-05-18 14:25:25 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 14:25:45 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 14:29:46 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 14:29:51 +0000gmg(~user@user/gehmehgeh) (Remote host closed the connection)
2025-05-18 14:30:11 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 14:33:59 +0000sajenim(~sajenim@user/sajenim) sajenim
2025-05-18 14:34:06 +0000 <sajenim> #join #kernel
2025-05-18 14:34:11 +0000 <sajenim> sorry
2025-05-18 14:42:49 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 14:43:14 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 14:46:45 +0000Digit(~user@user/digit) Digit
2025-05-18 14:53:54 +0000michalz(~michalz@185.246.207.221)
2025-05-18 14:58:21 +0000Digitdigitteknohippie
2025-05-18 14:58:44 +0000digitteknohippieDigit
2025-05-18 15:01:27 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 265 seconds)
2025-05-18 15:08:54 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 15:09:15 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 15:12:37 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 15:14:55 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 15:15:16 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 15:22:36 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp) (Read error: Connection reset by peer)
2025-05-18 15:22:58 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 15:23:21 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 15:28:44 +0000Guest45(~Guest45@2a00:9fe0:0:c::1:102a) (Quit: Client closed)
2025-05-18 15:35:01 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 15:35:22 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 15:43:09 +0000lxsameer(~lxsameer@Serene/lxsameer) lxsameer
2025-05-18 15:48:17 +0000hiecaq(~hiecaq@user/hiecaq) (Quit: ERC 5.6.0.30.1 (IRC client for GNU Emacs 30.0.92))
2025-05-18 15:50:07 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 15:50:29 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 15:51:12 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479) (Quit: My iMac has gone to sleep. ZZZzzz…)
2025-05-18 16:05:09 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 16:05:33 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 16:06:16 +0000lxsameer(~lxsameer@Serene/lxsameer) (Ping timeout: 252 seconds)
2025-05-18 16:07:36 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479)
2025-05-18 16:10:44 +0000euleritian(~euleritia@dynamic-176-006-136-230.176.6.pool.telefonica.de) (Read error: Connection reset by peer)
2025-05-18 16:11:01 +0000euleritian(~euleritia@ip4d17f864.dynamic.kabel-deutschland.de)
2025-05-18 16:17:34 +0000j1n37-(~j1n37@user/j1n37) j1n37
2025-05-18 16:17:54 +0000j1n37(~j1n37@user/j1n37) (Ping timeout: 245 seconds)
2025-05-18 16:22:05 +0000j1n37(~j1n37@user/j1n37) j1n37
2025-05-18 16:23:08 +0000j1n37-(~j1n37@user/j1n37) (Ping timeout: 252 seconds)
2025-05-18 16:27:17 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 16:27:38 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 16:31:11 +0000euleritian(~euleritia@ip4d17f864.dynamic.kabel-deutschland.de) (Ping timeout: 252 seconds)
2025-05-18 16:35:15 +0000srazkvt(~sarah@user/srazkvt) (Quit: Konversation terminated!)
2025-05-18 16:35:16 +0000euleritian(~euleritia@dynamic-176-006-136-230.176.6.pool.telefonica.de)
2025-05-18 16:39:18 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 16:39:41 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 16:45:09 +0000ljdarj1(~Thunderbi@user/ljdarj) ljdarj
2025-05-18 16:45:09 +0000Pozyomka(~pyon@user/pyon) (Ping timeout: 248 seconds)
2025-05-18 16:45:22 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 16:45:31 +0000euleritian(~euleritia@dynamic-176-006-136-230.176.6.pool.telefonica.de) (Read error: Connection reset by peer)
2025-05-18 16:45:43 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 16:46:26 +0000euleritian(~euleritia@ip4d17f864.dynamic.kabel-deutschland.de)
2025-05-18 16:47:49 +0000lxsameer(~lxsameer@Serene/lxsameer) lxsameer
2025-05-18 16:49:14 +0000ljdarj(~Thunderbi@user/ljdarj) (Ping timeout: 265 seconds)
2025-05-18 16:49:14 +0000ljdarj1ljdarj
2025-05-18 16:50:22 +0000euouae(~euouae@user/euouae) euouae
2025-05-18 16:51:03 +0000 <euouae> Hello I have a project where I read stuff from a "stream" (I call it that) and then I either: 1) output or 2) prepend to "stream" for subsequent reads.
2025-05-18 16:51:28 +0000 <euouae> What I want to ask is if Haskell has something that I can use that does this already, a sort of byte deque.
2025-05-18 16:52:03 +0000 <euouae> What I thought about doing is using a list of strings and a lens to treat them as one string
2025-05-18 16:54:55 +0000Frostillicus(~Frostilli@pool-71-174-119-69.bstnma.fios.verizon.net)
2025-05-18 16:57:08 +0000 <euouae> Nevermind I guess that's what I'll do :)
2025-05-18 16:57:08 +0000euouae(~euouae@user/euouae) ()
2025-05-18 16:59:15 +0000tomboy64(~tomboy64@user/tomboy64) (Read error: Connection reset by peer)
2025-05-18 16:59:29 +0000tomboy64(~tomboy64@user/tomboy64) tomboy64
2025-05-18 16:59:53 +0000acidjnk(~acidjnk@p200300d6e71c4f033d258f2e8b70eea4.dip0.t-ipconnect.de) acidjnk
2025-05-18 17:01:43 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 17:02:03 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 17:02:17 +0000robertm(robertm@lattice.rojoma.com) (Quit: ,,,)
2025-05-18 17:05:08 +0000robertm(robertm@lattice.rojoma.com) robertm
2025-05-18 17:07:25 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 17:07:48 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 17:11:10 +0000Frostillicus(~Frostilli@pool-71-174-119-69.bstnma.fios.verizon.net) (Ping timeout: 252 seconds)
2025-05-18 17:17:22 +0000notzmv(~daniel@user/notzmv) notzmv
2025-05-18 17:23:35 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 17:23:57 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 17:24:19 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479) (Quit: My iMac has gone to sleep. ZZZzzz…)
2025-05-18 17:26:17 +0000ystael(~ystael@user/ystael) ystael
2025-05-18 17:29:21 +0000tomboy64(~tomboy64@user/tomboy64) (Read error: Connection reset by peer)
2025-05-18 17:29:29 +0000tomboy65(~tomboy64@user/tomboy64) tomboy64
2025-05-18 17:30:25 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 17:30:46 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 17:36:07 +0000j1n37-(~j1n37@user/j1n37) j1n37
2025-05-18 17:37:01 +0000j1n37(~j1n37@user/j1n37) (Ping timeout: 276 seconds)
2025-05-18 17:37:12 +0000Nosrep(~Nosrep@user/nosrep) (Ping timeout: 252 seconds)
2025-05-18 17:41:57 +0000peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) peterbecich
2025-05-18 17:44:44 +0000 <__monty__> @tell euouae Consider looking at Data.Sequence for double-ended operations.
2025-05-18 17:44:44 +0000 <lambdabot> Consider it noted.
2025-05-18 17:45:26 +0000tzh(~tzh@c-76-115-131-146.hsd1.or.comcast.net)
2025-05-18 17:46:21 +0000Sgeo(~Sgeo@user/sgeo) Sgeo
2025-05-18 17:47:54 +0000 <monochrom> Although, it is not very fast.
2025-05-18 17:47:57 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479)
2025-05-18 17:49:57 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 17:50:21 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 17:55:49 +0000euleritian(~euleritia@ip4d17f864.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2025-05-18 17:56:57 +0000euleritian(~euleritia@77.23.248.100)
2025-05-18 17:58:07 +0000Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) Unicorn_Princess
2025-05-18 17:58:47 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 17:59:08 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 17:59:14 +0000tomboy65(~tomboy64@user/tomboy64) (Read error: Connection reset by peer)
2025-05-18 17:59:29 +0000tomboy64(~tomboy64@user/tomboy64) tomboy64
2025-05-18 18:07:53 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 18:08:17 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 18:13:57 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 18:14:19 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 18:16:04 +0000jmcantrell(~weechat@user/jmcantrell) jmcantrell
2025-05-18 18:16:45 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 276 seconds)
2025-05-18 18:27:18 +0000peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) (Quit: peterbecich)
2025-05-18 18:27:46 +0000peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) peterbecich
2025-05-18 18:29:12 +0000tomboy64(~tomboy64@user/tomboy64) (Read error: Connection reset by peer)
2025-05-18 18:29:29 +0000tomboy64(~tomboy64@user/tomboy64) tomboy64
2025-05-18 18:29:39 +0000jmcantrell(~weechat@user/jmcantrell) (Ping timeout: 260 seconds)
2025-05-18 18:29:41 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 18:32:17 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 18:32:39 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 18:41:10 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 18:41:32 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 18:42:42 +0000sprotte24(~sprotte24@p200300d16f0fc00010c55f6c38487736.dip0.t-ipconnect.de)
2025-05-18 18:45:01 +0000peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) (Ping timeout: 252 seconds)
2025-05-18 18:46:10 +0000j1n37-(~j1n37@user/j1n37) (Ping timeout: 260 seconds)
2025-05-18 18:46:22 +0000j1n37(~j1n37@user/j1n37) j1n37
2025-05-18 18:50:04 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 18:50:27 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 18:53:28 +0000bitmapper(uid464869@id-464869.lymington.irccloud.com) bitmapper
2025-05-18 18:53:28 +0000GdeVolpiano(~GdeVolpia@user/GdeVolpiano) GdeVolpiano
2025-05-18 18:55:33 +0000 <__monty__> Neither is `[String]` for operations on both ends though.
2025-05-18 18:55:41 +0000 <__monty__> It's plenty fast for AoC : )
2025-05-18 18:59:07 +0000peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) peterbecich
2025-05-18 19:00:03 +0000caconym7(~caconym@user/caconym) (Quit: bye)
2025-05-18 19:00:42 +0000caconym7(~caconym@user/caconym) caconym
2025-05-18 19:01:26 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 19:01:49 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 19:03:22 +0000peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) (Ping timeout: 252 seconds)
2025-05-18 19:07:42 +0000target_i(~target_i@user/target-i/x-6023099) target_i
2025-05-18 19:12:27 +0000Digitteknohippie(~user@user/digit) Digit
2025-05-18 19:12:27 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 19:12:48 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 19:13:50 +0000Digit(~user@user/digit) (Ping timeout: 272 seconds)
2025-05-18 19:19:32 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 19:19:54 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 19:21:05 +0000gmg(~user@user/gehmehgeh) gehmehgeh
2025-05-18 19:24:01 +0000infinity0(~infinity0@pwned.gg) (Ping timeout: 252 seconds)
2025-05-18 19:30:34 +0000DigitteknohippieDigit
2025-05-18 19:32:18 +0000j1n37-(~j1n37@user/j1n37) j1n37
2025-05-18 19:32:39 +0000wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2025-05-18 19:32:43 +0000j1n37(~j1n37@user/j1n37) (Ping timeout: 244 seconds)
2025-05-18 19:33:34 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Read error: Connection reset by peer)
2025-05-18 19:33:57 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 19:38:25 +0000 <[exa]> is there any technical difference between packages OpenGLRaw and gl ? The FFI code looks kinda confusingly same to me, I expected I'd be able to see at least something that's different
2025-05-18 19:39:54 +0000pavonia(~user@user/siracusa) siracusa
2025-05-18 19:41:03 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 19:41:23 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 19:44:41 +0000infinity0(~infinity0@pwned.gg) infinity0
2025-05-18 19:46:26 +0000 <EvanR> both OpenGLRaw and gl are supposed to be a direct reflection of the C api
2025-05-18 19:46:42 +0000 <EvanR> so I expect no difference if they both achieved
2025-05-18 19:47:05 +0000 <EvanR> why do we need two, not sure, but OpenGLRaw originally didn't exist
2025-05-18 19:47:31 +0000 <EvanR> I mean we don't need two, but why did OpenGLRaw happen I don't know
2025-05-18 19:47:40 +0000 <[exa]> like, gl seems a lil more organized
2025-05-18 19:47:50 +0000 <[exa]> but that's it
2025-05-18 19:48:05 +0000 <[exa]> I expected e.g. some radically different way to get the gl function pointers or so
2025-05-18 19:48:14 +0000 <EvanR> that would be OpenGL not-Raw
2025-05-18 19:48:19 +0000 <EvanR> it's radically different
2025-05-18 19:49:05 +0000Pozyomka(~pyon@user/pyon) pyon
2025-05-18 19:49:45 +0000 <[exa]> nah the OpenGL is very wrapped
2025-05-18 19:51:19 +0000 <[exa]> ok anyway I just wanted to change the way the ffi is done a very little and see if it explodes
2025-05-18 19:51:29 +0000 <[exa]> gl rebuilds itself automatically -> win
2025-05-18 19:51:44 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Read error: Connection reset by peer)
2025-05-18 19:52:04 +0000lxsameer(~lxsameer@Serene/lxsameer) (Ping timeout: 245 seconds)
2025-05-18 19:52:07 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 19:58:43 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 19:59:04 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 19:59:10 +0000 <[exa]> and whoa, it works
2025-05-18 20:00:11 +0000 <[exa]> is there anything very wrong about marking FFI imports in an essentially singlethreaded application as `unsafe` ?
2025-05-18 20:01:31 +0000 <tomsmeding> [exa]: unsafe is, ironically, typically the safer option
2025-05-18 20:01:55 +0000 <tomsmeding> GHC guarantees that the GC will not run during an unsafe FFI call
2025-05-18 20:01:57 +0000 <[exa]> for me it somehow kills like 80% of the call overhead
2025-05-18 20:02:13 +0000 <tomsmeding> so you can pass unpinned stuff to C and they won't move under C's feeet
2025-05-18 20:02:22 +0000 <bwe> I am loading a couple of hundred HTML files from SQLite DB, perform some parsing on them, creating a result data type from them. For this I fmap over all result rows of a SQL select. This exhausts the memory, the OS kills ghci altogether. -- It appears that after each entry is processed, the garbage collection does not happen. Solution would be using some streaming framework. But this is another rabbit hole (I want to avoid to open).
2025-05-18 20:02:23 +0000 <bwe> -- Which alternatives to streaming frameworks do you recommend to let the garbage collection happen after each entry of a list has been processed?
2025-05-18 20:02:35 +0000 <tomsmeding> [exa]: during a 'safe' FFI call, the GC can run; the point of a 'safe' FFI call is that the C you call can _call back to Haskell_
2025-05-18 20:02:44 +0000 <[exa]> ....which is quite a relief when trying to smash 60 batches of glDrawWhatever calls per second to the GPU.
2025-05-18 20:02:50 +0000 <[exa]> yeah
2025-05-18 20:02:54 +0000 <tomsmeding> to accomplish this, GHC starts a new capability, which has overhead
2025-05-18 20:03:17 +0000 <[exa]> yes, a scary lot of overhead.
2025-05-18 20:04:38 +0000 <EvanR> bwe, make sure to evaluate each parse result before going on to the next one
2025-05-18 20:04:40 +0000 <tomsmeding> bwe: I feel like this is not due to "GC not running", but because if you return something from IO, that thing gets evaluated first
2025-05-18 20:05:11 +0000 <tomsmeding> if that "thing" is a list, that list is not returned in a streaming fashion
2025-05-18 20:05:44 +0000 <tomsmeding> if it's a list of IO actions then it's even worse because all the IO actions need to run before the return can happen
2025-05-18 20:05:46 +0000 <[exa]> bwe: you can insert the GC call yourself but as pointed out above, it might be that you are accidentally doing a space leak somewhere which GC can't solve
2025-05-18 20:05:47 +0000 <tomsmeding> but also check EvanR's suggestion
2025-05-18 20:06:01 +0000 <tomsmeding> if you're running out of memory then GC will _definitely_ have attempted to run
2025-05-18 20:06:10 +0000 <[exa]> +1 ^
2025-05-18 20:06:14 +0000 <tomsmeding> so the fact that you run out of memory proves that manually calling GC will not help
2025-05-18 20:06:17 +0000 <monochrom> The worst nightmare is that GC ran and found nothing to free, so you spent both memory and time.
2025-05-18 20:06:34 +0000 <bwe> monochrom: that's what I assume is happening.
2025-05-18 20:06:49 +0000 <EvanR> well that would require the gc running
2025-05-18 20:06:54 +0000 <EvanR> at least once
2025-05-18 20:07:10 +0000 <tomsmeding> GC will run every n bytes allocated
2025-05-18 20:07:14 +0000 <monochrom> Theorem: A linear-space algorithm takes at least quadratic time in a GCed language. >:)
2025-05-18 20:07:17 +0000 <tomsmeding> n < amount of memory in your system
2025-05-18 20:07:41 +0000 <[exa]> bwe: btw what's the type of the sql result structure?
2025-05-18 20:07:48 +0000 <[exa]> (I suspect selda)
2025-05-18 20:09:05 +0000 <bwe> [exa]: loadRawHtmls :: IO [HTML]
2025-05-18 20:09:17 +0000 <bwe> [exa]: Confirmed. It's selda.
2025-05-18 20:09:56 +0000 <[exa]> can selda stream the results?
2025-05-18 20:10:01 +0000 <tomsmeding> that `IO [HTML]` type confirms what I wrote
2025-05-18 20:10:30 +0000 <bwe> [exa]: Not out of the box.
2025-05-18 20:11:02 +0000 <EvanR> a long list of file contentses is par for the course for web tech. You just need to make sure the results are all fully evaluated and compacted before returning the list
2025-05-18 20:11:21 +0000 <EvanR> and for good measure make sure it's not HTML = String
2025-05-18 20:11:31 +0000 <tomsmeding> yeah I guess you might try `sequence . fmap (map Control.DeepSeq.force)`
2025-05-18 20:11:47 +0000 <bwe> EvanR: I took my time to take your input in :). No, it's Text.
2025-05-18 20:12:23 +0000 <bwe> EvanR: So, lazy evaluation waits until full list is completed and only then GC can free the memory.
2025-05-18 20:12:25 +0000 <EvanR> a list of 100 big Text should be fine, as long as that's what it is
2025-05-18 20:12:31 +0000 <EvanR> no
2025-05-18 20:12:47 +0000 <tomsmeding> the IO action only returns when it's done
2025-05-18 20:12:56 +0000 <[exa]> bwe: what is your result type, roughly?
2025-05-18 20:12:58 +0000 <tomsmeding> it's done when all 100 HTML buffers have been read
2025-05-18 20:13:08 +0000 <tomsmeding> hence, all will be live in memory when the `IO [HTML]` action returns
2025-05-18 20:13:17 +0000 <[exa]> bwe: a lot of the job can be done by including a few strictness exclamation marks here and there
2025-05-18 20:13:26 +0000 <monochrom> It is not going to be as false-dichotomy as "more lazy is less space" or "more lazy is more space" because both have counterexamples.
2025-05-18 20:13:29 +0000 <[exa]> also Data.Vector.Strict, Data.Map.Strict, etc etc
2025-05-18 20:13:51 +0000 <tomsmeding> bwe: how large are the HTML strings? WOuld simply keeping the 100 strings in memory already be enough to exhaust your memory, or is there something else going on?
2025-05-18 20:14:53 +0000 <EvanR> I probably misunderstood, but you can't expect gc to collector strings before they you even start using them (after the IO finishes and returns them)
2025-05-18 20:15:00 +0000 <EvanR> collect your*
2025-05-18 20:15:05 +0000 <bwe> tomsmeding: 1.5 MB
2025-05-18 20:15:18 +0000 <tomsmeding> assuming you don't have a PC from the 90s, that should be okay
2025-05-18 20:15:42 +0000 <[exa]> like, that's a bit too much even for a pretty wild space leak
2025-05-18 20:15:43 +0000 <EvanR> 1.5 MB you exhausted my entire floppy disk
2025-05-18 20:16:02 +0000 <[exa]> EvanR: try the bigger floppies I heard they have more space
2025-05-18 20:16:06 +0000 <EvanR> lol
2025-05-18 20:16:10 +0000 <tomsmeding> % :t traverse @[] Control.Exception.evaluate
2025-05-18 20:16:10 +0000 <yahb2> traverse @[] Control.Exception.evaluate :: [b] -> IO [b]
2025-05-18 20:16:20 +0000 <monochrom> zip diskettes
2025-05-18 20:16:25 +0000 <tomsmeding> bwe: do that to your [HTML]
2025-05-18 20:16:41 +0000 <tomsmeding> the @[] is just to make the type here nicer
2025-05-18 20:17:07 +0000 <mauke> % :t traverse Control.Exception.evaluate
2025-05-18 20:17:07 +0000 <yahb2> traverse Control.Exception.evaluate ; :: Traversable t => t b -> IO (t b)
2025-05-18 20:17:21 +0000 <mauke> % :t traverse Control.Exception.evaluate `asAppliedTo` []
2025-05-18 20:17:21 +0000 <yahb2> <interactive>:1:37: error: [GHC-88464] ; Variable not in scope: ; asAppliedTo :: (t0 b0 -> IO (t0 b0)) -> [a0] -> t
2025-05-18 20:17:50 +0000 <mauke> huh
2025-05-18 20:18:35 +0000 <bwe> tomsmeding: The problem is that the function is an IO action because it will only return once it has read all of its input?
2025-05-18 20:18:41 +0000 <mauke> then where do I remember that from
2025-05-18 20:18:51 +0000 <tomsmeding> surely a function that reads 1.5 MB total will by itself not exhaust memory
2025-05-18 20:18:55 +0000 <tomsmeding> there is something going on that we're not seeing
2025-05-18 20:19:13 +0000 <[exa]> bwe: just to take a slightly more doubtful approach to the issue you might want to try to process a few smaller fractions of the HTML to see if it stops crashing at some point. Having tiny 1.5MB expanded to OOM seems a bit weird nowadays, instinctively I'd say there might be a corner case where the program actually explodes
2025-05-18 20:19:41 +0000tomsmedingnods
2025-05-18 20:19:48 +0000 <[exa]> (as in, some html so weird that it recurses infinitely. e.g. some binary ballast which doesn't parse well.)
2025-05-18 20:20:02 +0000 <mauke> I've seen processing ~35 MB of XML take about 2 GB of memory
2025-05-18 20:20:20 +0000 <bwe> tomsmeding: I considered profiling a couple of times. But I aborted that mission because it frustrated me to not being able to do it in ghci directly.
2025-05-18 20:20:31 +0000 <Rembane> There's the HAHAHA-attack, right?
2025-05-18 20:20:42 +0000 <mauke> not an attack
2025-05-18 20:21:06 +0000 <mauke> it involved an arrow-based xml parser and keeping everything as Strings
2025-05-18 20:21:10 +0000 <EvanR> bwe, a "normal" IO [Text] which gets each Text using I/O will "return" when it built the whole list
2025-05-18 20:21:21 +0000 <Rembane> mauke: Got it.
2025-05-18 20:21:37 +0000 <EvanR> there are abnormal methods though, depends on how your library works
2025-05-18 20:22:02 +0000 <EvanR> (unsafeInterleaveIO)
2025-05-18 20:23:36 +0000 <EvanR> to "normally" avoid collecting all the Text in memory before going on you would do some kind of streaming
2025-05-18 20:23:46 +0000 <mauke> (I managed to drastically reduce memory use by first discovering that the http endpoint in question could also deliver json and using aeson, and then switching to a streaming json parser)
2025-05-18 20:31:10 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 20:31:31 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 20:34:40 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 260 seconds)
2025-05-18 20:37:36 +0000 <bwe> [exa]: I might try in increments, starting with single HTML, to see how much the memory consumption is. Can I profile this on ghci?
2025-05-18 20:38:17 +0000 <[exa]> technically yes, but I wouldn't bother for the first try
2025-05-18 20:38:39 +0000 <[exa]> I expect there's an outlier that you'll simply detect manually
2025-05-18 20:38:51 +0000 <[exa]> also, Debug.Trace that prints progress helps a lot in such cases
2025-05-18 20:39:21 +0000tomsmeding. o O ( :set +s )
2025-05-18 20:40:39 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 20:40:39 +0000haskellbridge(~hackager@syn-096-028-224-255.res.spectrum.com) (Read error: Connection reset by peer)
2025-05-18 20:41:01 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 20:42:03 +0000 <bwe> tomsmeding: Ok. Is it now the IO returning only after the list is complete? Or is it an edge case in parsing? Or both?
2025-05-18 20:42:35 +0000 <tomsmeding> uh, I'm not sure what I'm supposed to base my answer on :)
2025-05-18 20:43:51 +0000 <bwe> [exa]: well, that means picking single parsers and running them with :set +s on ghci to see which is an outlier.
2025-05-18 20:44:24 +0000 <tomsmeding> bwe: does memory already blow up on a single HTML document?
2025-05-18 20:44:37 +0000 <EvanR> rofile stuff in isolation and see how it performs
2025-05-18 20:44:53 +0000tomsmeding. o O ( read-only file )
2025-05-18 20:44:53 +0000 <bwe> tomsmeding: No. I can take 100. If I take 300 or so, it blows up.
2025-05-18 20:45:05 +0000 <tomsmeding> is memory usage linear in the number of documents?
2025-05-18 20:45:28 +0000haskellbridge(~hackager@syn-096-028-224-255.res.spectrum.com) hackager
2025-05-18 20:45:28 +0000ChanServ+v haskellbridge
2025-05-18 20:46:08 +0000 <[exa]> tomsmeding: I sent the unsafe FFI question to gl maintainers, let's see. :D
2025-05-18 20:47:07 +0000 <EvanR> I don't think opengl callsback into your program for anything
2025-05-18 20:47:20 +0000 <tomsmeding> opengl has no fucking clue how to call into haskell
2025-05-18 20:47:49 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn
2025-05-18 20:48:10 +0000 <tomsmeding> [exa]: passing a haskell function pointer into C requires an explicit `foreign export`; that's easy to grep for
2025-05-18 20:48:40 +0000 <[exa]> grep says nope
2025-05-18 20:48:48 +0000 <tomsmeding> (as expected) good
2025-05-18 20:48:50 +0000[exa]happy
2025-05-18 20:48:59 +0000visilii_(~visilii@46.61.242.71)
2025-05-18 20:49:15 +0000 <tomsmeding> [exa]: are all those FFI calls short?
2025-05-18 20:49:19 +0000visilii(~visilii@85.94.27.197) (Ping timeout: 252 seconds)
2025-05-18 20:49:28 +0000 <tomsmeding> a long-lasting unsafe FFI call is not great because it blocks GC for a long time
2025-05-18 20:49:30 +0000 <[exa]> instant
2025-05-18 20:49:36 +0000 <tomsmeding> ok then no problem
2025-05-18 20:50:04 +0000 <[exa]> as in, the longest ones are the swapbufferish ones that might wait for a vblank or so, for astonishing 15 milliseconds or so
2025-05-18 20:50:06 +0000 <EvanR> though if you only have 1 thread there's no much for the GC to do during that time
2025-05-18 20:50:08 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 20:50:12 +0000 <tomsmeding> (GC will still decide to run and pause the other threads while it waits for an unsafe FFI call to complete; this can cause _significant_ pointless idle time)
2025-05-18 20:50:32 +0000 <EvanR> but now I'm wondering what "essentially single threaded" means
2025-05-18 20:50:33 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 20:50:36 +0000 <[exa]> spoiler: there's no other threads. :D
2025-05-18 20:50:39 +0000 <EvanR> is that the same thing as "not single threaded"
2025-05-18 20:50:44 +0000michalz(~michalz@185.246.207.221) (Remote host closed the connection)
2025-05-18 20:50:49 +0000 <haskellbridge> <magic_rb> I think 15ms is significant
2025-05-18 20:50:59 +0000 <EvanR> yes
2025-05-18 20:51:13 +0000 <tomsmeding> (this is an issue in accelerate (CPU backend): we do unsafe FFI calls to the individual kernels, and when GC attemps to run you get momentary big vertical blank space in your thread utilisation profiler)
2025-05-18 20:51:17 +0000 <haskellbridge> <magic_rb> If you can afford it you can try a foreign primop if youre minmaxing perf here, but you need to be careful with times, gc and shit
2025-05-18 20:51:32 +0000 <tomsmeding> but if no other threads then nobody cares :)
2025-05-18 20:52:05 +0000 <haskellbridge> <magic_rb> Interesting that gc wont say "welp, better luck some other time" and instead will pause anyway
2025-05-18 20:52:19 +0000 <tomsmeding> ¯\_(ツ)_/¯
2025-05-18 20:52:25 +0000 <haskellbridge> <magic_rb> Why not let the other threads run and only do GC when the unsafe ffi one returns, weird
2025-05-18 20:52:41 +0000 <tomsmeding> magic_rb: because those other threads might start more unsafe FFI calls in the meantime
2025-05-18 20:52:45 +0000 <tomsmeding> and GC might never get to run
2025-05-18 20:52:51 +0000 <haskellbridge> <magic_rb> Ah ig
2025-05-18 20:52:53 +0000 <tomsmeding> and then you run out of memory and the user is unhappy
2025-05-18 20:53:00 +0000 <[exa]> magic_rb: tbh I got rid of the 95% of the program runtime which it spent spinning in some place in RTS in `threadPaused()`. It's strictly less broken than before.
2025-05-18 20:53:09 +0000 <tomsmeding> :D
2025-05-18 20:53:14 +0000 <tomsmeding> by switching from safe to unsfe?
2025-05-18 20:53:17 +0000 <[exa]> yap
2025-05-18 20:53:20 +0000 <tomsmeding> neat
2025-05-18 20:53:21 +0000 <haskellbridge> <magic_rb> Then youd need a accounting system of "only so many unsafe ffis can run in sequence without a gc" or something
2025-05-18 20:53:25 +0000 <[exa]> https://github.com/ekmett/gl/issues/26
2025-05-18 20:53:31 +0000 <tomsmeding> I guess?
2025-05-18 20:53:37 +0000[exa]realizes it's maintained by ekmett
2025-05-18 20:53:47 +0000 <[exa]> good
2025-05-18 20:54:58 +0000 <tomsmeding> bodes well for actually getting a response, I guess :)
2025-05-18 20:55:46 +0000 <[exa]> yeah well let's see
2025-05-18 20:55:55 +0000 <bwe> tomsmeding: megabytes per single html parsed (for batch of `n`): 1: 3 GB, 10: 2.3 GB, 100: 1.5 GB (so, yes, a single html of 1.5 MB causes 1 GB while parsing)
2025-05-18 20:56:12 +0000 <[exa]> at wurst I'm going to learn what's broken in my code by smashing the unsafe everywhere.
2025-05-18 20:56:23 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 20:56:30 +0000 <bwe> tomsmeding: the memory consumption is excessively yet decreases with increasing batch size
2025-05-18 20:56:32 +0000 <tomsmeding> bwe: memory usage decreases when you pase more html files?
2025-05-18 20:56:37 +0000 <tomsmeding> oh
2025-05-18 20:56:43 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 20:56:48 +0000 <haskellbridge> <magic_rb> I should check what my ffi is doing in my FUSE bindings
2025-05-18 20:56:56 +0000 <[exa]> there's some shared stuff I guess
2025-05-18 20:57:01 +0000 <tomsmeding> what is memory usage if you parse _one_ html file, and _two_ html files? Not all files in various batch sizes, but just one or two files?
2025-05-18 20:57:36 +0000 <tomsmeding> also, get a better html parser?
2025-05-18 20:58:20 +0000 <[exa]> bwe: is that parsed with pandoc?
2025-05-18 20:58:40 +0000 <bwe> [exa]: no, scalpel.
2025-05-18 20:59:44 +0000 <bwe> tomsmeding: _one_: 3 GB, _two_: 2.2 GB (already divided by no. of files)
2025-05-18 21:00:43 +0000 <tomsmeding> bwe: you saying "already divided by" makes it sound like you're still parsing the whole lot instead of just one file
2025-05-18 21:01:14 +0000 <EvanR> one file takes 3 gigs, damn
2025-05-18 21:02:14 +0000 <bwe> tomsmeding: parsing one: 3124089080 bytes; parsing two: 4545550056 bytes
2025-05-18 21:02:26 +0000 <[exa]> bwe: which scrapers? is it possible that you have scrapers with lots of matches but you filter the matches manually and/or only take first finds?
2025-05-18 21:02:42 +0000 <tomsmeding> bwe: impressive
2025-05-18 21:03:24 +0000 <tomsmeding> does this memory usage occur in similar amounts in compiled code? ghci does not optimise, and optimisation might improve things
2025-05-18 21:04:00 +0000 <bwe> tomsmeding: better html parser... Give me one better than TagSoup or fast-tagsoup.
2025-05-18 21:04:23 +0000tomsmeding. o O ( it says "fast" so it's probably faster )
2025-05-18 21:04:52 +0000 <EvanR> there are better parsers, you just may not have written it yourself yet
2025-05-18 21:05:00 +0000 <tomsmeding> I never use html parsers in haskell so I won't be able to advise there
2025-05-18 21:05:50 +0000 <bwe> well, I considered naively cutting out irrelevant parts from the html before I feed it to the parser...
2025-05-18 21:06:21 +0000 <bwe> EvanR: What's your advice?
2025-05-18 21:07:17 +0000 <bwe> [exa]: I need to check that tomorrow. -- Sounds like you've got some specific experience there, do you?
2025-05-18 21:07:29 +0000loonycyborg(loonycybor@wesnoth/developer/loonycyborg) (Ping timeout: 244 seconds)
2025-05-18 21:08:47 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 21:09:10 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 21:09:33 +0000 <EvanR> I don't have a clear picture of the whole thing being measured. TagSoup can lazily stream tags so shouldn't use much memory, when doing something very simple with it.
2025-05-18 21:12:21 +0000 <bwe> (Well, the problem happens already with a single html file as I end up with GB memory consumption.)
2025-05-18 21:12:28 +0000tromp(~textual@2001:1c00:3487:1b00:ace7:b293:8f4:7479) (Quit: My iMac has gone to sleep. ZZZzzz…)
2025-05-18 21:12:34 +0000loonycyborg(loonycybor@wesnoth/developer/loonycyborg) loonycyborg
2025-05-18 21:13:34 +0000 <EvanR> is that total GB in memory at once or something like GB per second or something
2025-05-18 21:13:35 +0000 <[exa]> bwe: not really, got triggered into a vaguely similar issue once with pandoc but certainly didn't explode _that_ much
2025-05-18 21:14:21 +0000 <EvanR> if it's total GB in memory at once I'd like to see the minimum expression which does that
2025-05-18 21:15:14 +0000 <EvanR> (yes, reverse (replicate 3billion ())
2025-05-18 21:16:19 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 21:16:43 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 21:18:22 +0000 <bwe> [exa]: ...so I get, that filtering matches requires going over the full list of matches while taking only first find does not.
2025-05-18 21:18:41 +0000 <tomsmeding> if the filtering happens in IO, yes
2025-05-18 21:18:56 +0000 <tomsmeding> this depends very much on what exactly the type of the filtering function is
2025-05-18 21:19:30 +0000 <tomsmeding> `take 1 (filter p l)` takes just as much memory as `find p l`
2025-05-18 21:19:37 +0000tromp(~textual@2001:1c00:3487:1b00:f1c1:5955:9038:8985)
2025-05-18 21:19:51 +0000 <EvanR> all matches can be a lazy list
2025-05-18 21:20:04 +0000 <bwe> tomsmeding: What can I do so that after parsing of first html (within IO) the allocated memory is released (except for the result)?
2025-05-18 21:20:07 +0000 <[exa]> bwe: that is a quite likely source of memory being stuck around, yes
2025-05-18 21:20:17 +0000j1n37(~j1n37@user/j1n37) j1n37
2025-05-18 21:20:32 +0000 <[exa]> bwe: force the result with something like deepSeq or so
2025-05-18 21:20:37 +0000 <tomsmeding> bwe: this depends quite strongly on the precise types and the structure of your code; this cannot be answered in general
2025-05-18 21:20:58 +0000 <tomsmeding> perhaps Control.DeepSeq.force, but this not always applicable or the right choice
2025-05-18 21:21:21 +0000j1n37-(~j1n37@user/j1n37) (Ping timeout: 248 seconds)
2025-05-18 21:21:33 +0000 <EvanR> map parse longList, if consumed lazily would forget parts of longList if not referenced anywhere
2025-05-18 21:21:52 +0000 <[exa]> oh look at this beauty here: https://hackage.haskell.org/package/deepseq-1.5.1.0/docs/Control-DeepSeq.html#v:-60--36--33--33--62-
2025-05-18 21:21:55 +0000 <[exa]> bwe: ^
2025-05-18 21:22:10 +0000 <tomsmeding> however, if you use the result of `map parse longList` twice, then the whole list will be retained until the second use
2025-05-18 21:22:12 +0000 <EvanR> I am suspicious deepseq is the answer to these questions
2025-05-18 21:22:23 +0000 <EvanR> the whole list of results
2025-05-18 21:22:35 +0000 <bwe> EvanR: Can you elaborate, please?
2025-05-18 21:22:42 +0000 <EvanR> on what
2025-05-18 21:22:44 +0000 <[exa]> if deepseq isn't an answer, it's either ghci or programming bug, yes.
2025-05-18 21:22:56 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 21:23:18 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 21:23:32 +0000 <[exa]> bwe: can you use that <$!!> instead of your fmap and see what changed?
2025-05-18 21:29:05 +0000tomboy64(~tomboy64@user/tomboy64) (Ping timeout: 265 seconds)
2025-05-18 21:30:39 +0000loonycyborg(loonycybor@wesnoth/developer/loonycyborg) (Ping timeout: 272 seconds)
2025-05-18 21:30:54 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 21:31:08 +0000 <bwe> [exa]: It's not drop-in replacement for <$>. It requires some NFData constraint on `a` for `IO a`. Adding `Generic` to the deriving clause does not dedicates it an instance of NFData.
2025-05-18 21:31:17 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 21:32:20 +0000 <tomsmeding> `instance NFData ThatType` will do, it will use the Generic instance
2025-05-18 21:32:23 +0000tomboy64(~tomboy64@user/tomboy64) tomboy64
2025-05-18 21:32:31 +0000 <bwe> EvanR: nvm, I misread as deepseq _not_ to be the answer to these questions. -- Still, are you talking about using deepseq for the list of htmls or within parsing a single one?
2025-05-18 21:32:47 +0000 <[exa]> bwe: for each one
2025-05-18 21:33:57 +0000 <EvanR> if it would "work" then it would work better to put strict fields on the right fields and make sure you're evaluating results at the right time
2025-05-18 21:34:23 +0000 <EvanR> with bang patterns or a "primed" version of whatever utility, like modifyIOref'
2025-05-18 21:35:57 +0000 <EvanR> which is also good in the case that deepseq doesn't work
2025-05-18 21:44:59 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 21:45:20 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 21:45:27 +0000 <bwe> [exa]: Done. It didn't crash. System memory remained constant. Still 986 GB memory consumed (of course, this seemed to have been rolled over).
2025-05-18 21:45:56 +0000 <[exa]> how do you measure the consumption btw
2025-05-18 21:46:09 +0000 <[exa]> oh btw I read it's fixed?
2025-05-18 21:46:11 +0000 <bwe> [exa]: ghci :set +s
2025-05-18 21:47:18 +0000 <[exa]> ah that's reporting _allocated_ memory instead of actual resident memory
2025-05-18 21:47:27 +0000 <[exa]> (iirc)
2025-05-18 21:48:05 +0000 <bwe> sorry for being imprecise, I used `consumed` wrongly.
2025-05-18 21:48:23 +0000 <[exa]> ah np, just that a huge number there is kindof expected
2025-05-18 21:48:24 +0000 <bwe> Still, I have an average 1.3 GB per html memory allocated.
2025-05-18 21:48:53 +0000j1n37-(~j1n37@user/j1n37) j1n37
2025-05-18 21:49:03 +0000 <EvanR> ideally you keep resident memory at a minimum, but this can still cause unlimited "total allocated" to be huge, especially if the computation takes a while
2025-05-18 21:49:06 +0000peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) peterbecich
2025-05-18 21:49:08 +0000 <[exa]> it's not small for sure but a few gigs allocated this way doesn't mean a big issue
2025-05-18 21:49:32 +0000 <bwe> What does this result of the DeepSeq experiment mean now?
2025-05-18 21:49:35 +0000 <EvanR> the idea is you can easily gc lots of temporaries with the generational gc
2025-05-18 21:49:55 +0000 <EvanR> space leaks are when the resident memory grows to huge before the computation is over
2025-05-18 21:49:59 +0000 <[exa]> ghc RTS allocates a few bytes for basically each program step, but that's OK since that allocation is essentially no-op
2025-05-18 21:50:18 +0000 <EvanR> compared to malloc yes
2025-05-18 21:50:28 +0000j1n37(~j1n37@user/j1n37) (Ping timeout: 268 seconds)
2025-05-18 21:51:29 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 21:51:54 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 21:52:07 +0000 <EvanR> huge live memory -> slow gc, slow everything. low live memory (regardless of total objects ever) -> fast gc
2025-05-18 21:52:27 +0000 <[exa]> bwe: btw for the simplest demonstration of what likely happened try `foldl' (+) 0 [1..100000000]` and then without the tick.
2025-05-18 21:54:06 +0000 <bwe> EvanR: What's the generational GC?
2025-05-18 21:54:19 +0000 <EvanR> ghc's gc is generational
2025-05-18 21:54:32 +0000 <[exa]> bwe: anyway in short, if deepseq helped, it was a normal space leak, and ghc can't solve that effectively since it would need to guess which parts of the program to force into evaluation to actually save memory (generally a hard problem)
2025-05-18 21:54:37 +0000[exa]off, good luck!
2025-05-18 21:54:49 +0000 <EvanR> it collects recent garbage faster, which is luckily most garbage
2025-05-18 21:54:56 +0000 <bwe> [exa]: Kudos, thanks for your help!
2025-05-18 21:55:56 +0000 <EvanR> and immutable data can only reference older data, making it a good fit for haskell
2025-05-18 21:58:46 +0000hiredman(~hiredman@frontier1.downey.family) hiredman
2025-05-18 21:58:51 +0000 <bwe> EvanR: So, I've got a space leak that eats up my live (system's) memory. Therefore gc becomes slow.
2025-05-18 21:59:41 +0000tromp(~textual@2001:1c00:3487:1b00:f1c1:5955:9038:8985) (Quit: My iMac has gone to sleep. ZZZzzz…)
2025-05-18 22:00:05 +0000 <EvanR> sounds like it
2025-05-18 22:00:56 +0000 <EvanR> dumb as nail step 0 sanity check: write some lazy code in ghci which you know should be fast and not use much live memory, and make sure your tools confirm it
2025-05-18 22:01:28 +0000 <bwe> Shouldn't the profiler help me finding the space leak?
2025-05-18 22:01:42 +0000 <EvanR> so at least you are working with two extremes with two different characters
2025-05-18 22:01:49 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 22:01:56 +0000 <EvanR> dumb efficient code and real space leaking code
2025-05-18 22:02:04 +0000 <EvanR> and can tell the difference
2025-05-18 22:02:05 +0000ljdarj1(~Thunderbi@user/ljdarj) ljdarj
2025-05-18 22:02:10 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 22:02:18 +0000 <EvanR> if you already know all this then ignore me
2025-05-18 22:02:56 +0000 <EvanR> personally I've only been able to use profiling to notice a speak leak and not solve any
2025-05-18 22:03:02 +0000 <EvanR> space*
2025-05-18 22:04:08 +0000loonycyborg(loonycybor@wesnoth/developer/loonycyborg) loonycyborg
2025-05-18 22:04:09 +0000ljdarj(~Thunderbi@user/ljdarj) (Ping timeout: 245 seconds)
2025-05-18 22:04:09 +0000ljdarj1ljdarj
2025-05-18 22:09:23 +0000 <bwe> EvanR: I don't. - How do you solve a space leak?
2025-05-18 22:09:49 +0000 <darkling> Meteor patches. :)
2025-05-18 22:12:08 +0000 <EvanR> step 0, make sure it's a space leak by looking at a profile and judging that the problem shouldn't be amassing so much live memory
2025-05-18 22:12:34 +0000 <EvanR> the result might be, it's not actually a space leak and your problem is just that bad
2025-05-18 22:13:55 +0000 <EvanR> otherwise step 1, figure out your main driver of evaluation. Like printing out lines of outputs, writing to IORef, storing to a database. These can be quite late in the game so
2025-05-18 22:14:24 +0000 <EvanR> step 2, trace backward to see if you can evaluate something sooner using bang patterns, strict record fields, "primed utilities"
2025-05-18 22:15:27 +0000 <EvanR> or the evaluate :: a -> IO a thing from Control.Exceptions, which obviously only works in IO
2025-05-18 22:17:33 +0000 <EvanR> iterating step 2 might not fix it, but it ideally does
2025-05-18 22:18:53 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp)
2025-05-18 22:20:04 +0000 <EvanR> (note storing to IORef or MVar doesn't automatically evaluate anything, but there are primed utilities for that)
2025-05-18 22:25:37 +0000JuanDaugherty(~juan@user/JuanDaugherty) JuanDaugherty
2025-05-18 22:26:21 +0000ttybitnik(~ttybitnik@user/wolper) (Ping timeout: 276 seconds)
2025-05-18 22:29:39 +0000 <haskellbridge> <thirdofmay18081814goya> at the point of a type error, is it possible to introspect the state of the constraints stack?
2025-05-18 22:30:26 +0000 <bwe> Then, what does cause the space leak in the first place? A (temporary) value that is only kept longer in memory after its initial use because another use has not completed yet.
2025-05-18 22:31:24 +0000 <EvanR> it's usually a thunk that is holding a bunch of data, and you thought it was evaluated already, letting all that data go
2025-05-18 22:31:40 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 22:31:51 +0000 <EvanR> the solution is to make sure it gets evaluated at the time you wanted
2025-05-18 22:32:05 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 22:32:06 +0000 <int-e> In Haskell a common source of space leaks is so-called thunks, an implementation detail of lazy evaluation. Basically, rather than storing a value, the heap contains an object describing how to compute the value, and pointers to all the required ingredients. Which can also be thunks, so this can build up to a sizeable amount of memory.
2025-05-18 22:32:42 +0000 <bwe> ... and I do that with the prime variants of functions, bang pattern etc.
2025-05-18 22:33:17 +0000 <EvanR> if necessary yeah, the reasons for it being necessary are the deviled details, but those are the tools to control the when and what
2025-05-18 22:33:54 +0000 <EvanR> for a simple example of details
2025-05-18 22:34:03 +0000 <EvanR> consider let x = f a b c in y
2025-05-18 22:34:34 +0000 <EvanR> if you evaluate y and the value of x is not used any time soon, then f, a, b, and c are all waiting around
2025-05-18 22:34:52 +0000 <bwe> (consuming memory)
2025-05-18 22:34:54 +0000 <EvanR> (if x is not used at all then it should be collected)
2025-05-18 22:35:19 +0000 <EvanR> solution let !x = f a b c in y
2025-05-18 22:35:42 +0000 <EvanR> which is the same as let x = f a b c in x `seq` y
2025-05-18 22:36:00 +0000 <bwe> evaluate x (so you can let go of f, a, b, c in memory)
2025-05-18 22:36:13 +0000 <EvanR> yes as long as f a b and c aren't also needed for something
2025-05-18 22:36:25 +0000 <bwe> what if?
2025-05-18 22:36:37 +0000 <bwe> evaluate that thing, too?
2025-05-18 22:37:22 +0000 <EvanR> there's no one size fits all solution, even this example may actually benefit from leaving the bang off
2025-05-18 22:37:33 +0000 <EvanR> f, a, b, and c may take up less memory than the result
2025-05-18 22:37:53 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 22:37:59 +0000 <EvanR> programs can grow or shrink as they are "reduced"
2025-05-18 22:38:14 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 22:41:31 +0000 <EvanR> this is why you usually don't see anyone recommending put ! on every binding
2025-05-18 22:42:19 +0000mhatta(~mhatta@www21123ui.sakura.ne.jp) (Remote host closed the connection)
2025-05-18 22:44:10 +0000mhatta(~mhatta@www21123ui.sakura.ne.jp)
2025-05-18 22:45:28 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 22:45:44 +0000va10323(~v324@2802:8010:a026:e900:f93f:d782:dc7c:aeed)
2025-05-18 22:45:49 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 22:51:16 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 22:51:16 +0000 <bwe> Does the ghci interactive debugger show the thunks (currently kept in memory) / showing the currently allocated memory? ... I still wonder how to pinpoint the location of the space leaks in my code.
2025-05-18 22:51:44 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 22:54:09 +0000target_i(~target_i@user/target-i/x-6023099) (Quit: leaving)
2025-05-18 22:54:13 +0000 <bwe> Thanks for your inputs, anyways. It gives how I approach things now a different spin: Being aware of where yet to be evaluated stuff occupies memory because it hasn't been used in the second, third place yet.
2025-05-18 22:54:28 +0000 <bwe> (and solving by enforcing the evaluation)
2025-05-18 22:56:52 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 22:57:15 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 23:01:21 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp) (Read error: Connection reset by peer)
2025-05-18 23:03:59 +0000 <EvanR> ghci can show thunks I think, not sure what the flag is
2025-05-18 23:05:24 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 23:05:47 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 23:12:50 +0000weary-traveler(~user@user/user363627) user363627
2025-05-18 23:14:30 +0000 <geekosaur> use :print or :sprint instead of just typing the expression
2025-05-18 23:14:54 +0000 <geekosaur> most useful at breakpoints, since for top level stuff it'll just show _|_
2025-05-18 23:15:34 +0000__monty__(~toonn@user/toonn) (Quit: leaving)
2025-05-18 23:16:39 +0000todi(~todi@p57803331.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2025-05-18 23:19:08 +0000 <haskellbridge> <sm> bwe some related resources, possibly helpful: https://academy.fpblock.com/haskell/tutorial/all-about-strictness , https://github.com/haskell-perf/checklist , https://haskell.foundation/hs-opt-handbook.github.io
2025-05-18 23:19:23 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 23:19:44 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 23:21:56 +0000todi(~todi@p57803331.dip0.t-ipconnect.de) todi
2025-05-18 23:25:29 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 23:25:50 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 23:28:50 +0000sprotte24(~sprotte24@p200300d16f0fc00010c55f6c38487736.dip0.t-ipconnect.de) (Quit: Leaving)
2025-05-18 23:32:24 +0000jmcantrell(~weechat@user/jmcantrell) jmcantrell
2025-05-18 23:37:04 +0000craunts7(~craunts@136.158.8.87)
2025-05-18 23:37:21 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp)
2025-05-18 23:37:33 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr) (Remote host closed the connection)
2025-05-18 23:37:54 +0000sabathan2(~sabathan@amarseille-159-1-12-107.w86-203.abo.wanadoo.fr)
2025-05-18 23:37:56 +0000acidjnk(~acidjnk@p200300d6e71c4f033d258f2e8b70eea4.dip0.t-ipconnect.de) (Ping timeout: 272 seconds)
2025-05-18 23:45:23 +0000j1n37-(~j1n37@user/j1n37) (Read error: Connection reset by peer)
2025-05-18 23:48:28 +0000j1n37(~j1n37@user/j1n37) j1n37
2025-05-18 23:48:38 +0000Tuplanolla(~Tuplanoll@91-159-69-59.elisa-laajakaista.fi) (Quit: Leaving.)
2025-05-18 23:52:36 +0000merijn(~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 244 seconds)
2025-05-18 23:53:03 +0000 <haskellbridge> <thirdofmay18081814goya> hm is it possible to introspect the state of "TcM" (the type checker monad) at the point of a particular type error?
2025-05-18 23:53:12 +0000 <haskellbridge> <thirdofmay18081814goya> e.g. query its stateful values
2025-05-18 23:53:26 +0000 <haskellbridge> <thirdofmay18081814goya> can it get dumped anywhere?
2025-05-18 23:54:28 +0000Frostillicus(~Frostilli@pool-71-174-119-69.bstnma.fios.verizon.net)
2025-05-18 23:56:01 +0000ljdarj(~Thunderbi@user/ljdarj) (Ping timeout: 265 seconds)
2025-05-18 23:58:16 +0000xff0x(~xff0x@om126236151042.32.openmobile.ne.jp) (Read error: Connection reset by peer)
2025-05-18 23:59:57 +0000Frostillicus(~Frostilli@pool-71-174-119-69.bstnma.fios.verizon.net) (Ping timeout: 276 seconds)