2024/04/29

2024-04-29 00:06:05 +0200Batzy(~quassel@user/batzy) (Ping timeout: 256 seconds)
2024-04-29 00:07:21 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2024-04-29 00:08:10 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 00:09:15 +0200peterbecich(~Thunderbi@47.229.123.186)
2024-04-29 00:23:07 +0200gmg(~user@user/gehmehgeh) (Quit: Leaving)
2024-04-29 00:25:17 +0200mwnaylor(~user@2601:5cf:837e:2bb0::824e)
2024-04-29 00:27:39 +0200 <mwnaylor> I want to get Haskell installed, in order to be able to install the xmonad window manager. BUT, the slackbuild fails. Any suggestions?
2024-04-29 00:30:32 +0200acidjnk(~acidjnk@p200300d6e714dc79605b18ab3e573168.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2024-04-29 00:31:31 +0200 <jackdk> That's not enough information for us to be able to help, it's like calling your mechanic and saying "my car makes a funny noise and won't start". ghcup is the preferred way to install GHC these days - are you using that? Also, please provide error messages, context, etc in a pastebin
2024-04-29 00:31:35 +0200 <jackdk> @where paste
2024-04-29 00:31:35 +0200 <lambdabot> Help us help you: please paste full code, input and/or output at e.g. https://paste.tomsmeding.com
2024-04-29 00:35:24 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 255 seconds)
2024-04-29 00:36:47 +0200 <EvanR> fix the slackbuild or use ghcup instead
2024-04-29 00:37:06 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2024-04-29 00:49:18 +0200stefan-_(~cri@42dots.de) (Quit: ZNC 1.8.2+deb2build5 - https://znc.in)
2024-04-29 00:49:18 +0200stefan-__(~m-yh2rcc@42dots.de) (Remote host closed the connection)
2024-04-29 00:49:58 +0200stefan-_(~cri@42dots.de)
2024-04-29 00:53:59 +0200esph(~weechat@user/esph) (Ping timeout: 252 seconds)
2024-04-29 00:55:05 +0200waldo(~waldo@user/waldo)
2024-04-29 00:55:17 +0200target_i(~target_i@user/target-i/x-6023099) (Quit: leaving)
2024-04-29 00:55:26 +0200esph(~weechat@user/esph)
2024-04-29 00:56:45 +0200sawilagar(~sawilagar@user/sawilagar) (Ping timeout: 252 seconds)
2024-04-29 00:59:00 +0200stefan-__(~m-yh2rcc@42dots.de)
2024-04-29 01:00:49 +0200stefan-__(~m-yh2rcc@42dots.de) (Remote host closed the connection)
2024-04-29 01:01:12 +0200stefan-__(~m-yh2rcc@42dots.de)
2024-04-29 01:03:09 +0200phma(~phma@2001:5b0:2172:cfd8:e2ba:31ce:8b83:bc5) (Read error: Connection reset by peer)
2024-04-29 01:04:08 +0200phma(~phma@host-67-44-208-75.hnremote.net)
2024-04-29 01:05:20 +0200Tuplanolla(~Tuplanoll@91-159-69-59.elisa-laajakaista.fi) (Quit: Leaving.)
2024-04-29 01:10:05 +0200mei(~mei@user/mei) (Remote host closed the connection)
2024-04-29 01:11:10 +0200cashew(~cashewsta@65.17.175.150) (Ping timeout: 245 seconds)
2024-04-29 01:13:24 +0200xff0x(~xff0x@softbank219059019218.bbtec.net)
2024-04-29 01:16:29 +0200mei(~mei@user/mei)
2024-04-29 01:17:25 +0200mechap(~mechap@user/mechap) (Ping timeout: 245 seconds)
2024-04-29 01:20:27 +0200Riviera(Riviera@user/riviera)
2024-04-29 01:23:38 +0200ChaiTRex(~ChaiTRex@user/chaitrex) (Ping timeout: 260 seconds)
2024-04-29 01:24:18 +0200ChaiTRex(~ChaiTRex@user/chaitrex)
2024-04-29 01:24:30 +0200picnoir(~picnoir@about/aquilenet/vodoo/NinjaTrappeur) (Ping timeout: 245 seconds)
2024-04-29 01:25:15 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 01:26:55 +0200madeleine-sydney(~madeleine@c-76-155-235-153.hsd1.co.comcast.net) (Quit: Konversation terminated!)
2024-04-29 01:30:46 +0200cashew(~cashewsta@65.17.175.150) (Ping timeout: 255 seconds)
2024-04-29 01:37:34 +0200picnoir(~picnoir@about/aquilenet/vodoo/NinjaTrappeur)
2024-04-29 01:41:04 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net) (Read error: Connection reset by peer)
2024-04-29 01:44:36 +0200peterbecich(~Thunderbi@47.229.123.186) (Ping timeout: 252 seconds)
2024-04-29 01:44:49 +0200dsrt^(~cd@c-98-242-74-66.hsd1.ga.comcast.net)
2024-04-29 01:50:50 +0200waldo(~waldo@user/waldo) (Ping timeout: 256 seconds)
2024-04-29 01:53:26 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2024-04-29 01:53:44 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 01:55:34 +0200szkl(uid110435@id-110435.uxbridge.irccloud.com)
2024-04-29 01:59:12 +0200cashew(~cashewsta@65.17.175.150) (Ping timeout: 260 seconds)
2024-04-29 02:02:25 +0200califax(~califax@user/califx) (Remote host closed the connection)
2024-04-29 02:04:10 +0200califax(~califax@user/califx)
2024-04-29 02:06:37 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net)
2024-04-29 02:09:54 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 02:10:39 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2024-04-29 02:11:19 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net) (Ping timeout: 256 seconds)
2024-04-29 02:17:23 +0200cashew(~cashewsta@65.17.175.150) (Ping timeout: 264 seconds)
2024-04-29 02:19:06 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 02:24:43 +0200yin_(~yin@user/zero)
2024-04-29 02:26:09 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.5)
2024-04-29 02:35:03 +0200TonyStone(~TonyStone@user/TonyStone) (Quit: Leaving)
2024-04-29 02:40:20 +0200xff0x(~xff0x@softbank219059019218.bbtec.net) (Ping timeout: 245 seconds)
2024-04-29 02:42:50 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 245 seconds)
2024-04-29 02:44:47 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2024-04-29 02:47:28 +0200esph(~weechat@user/esph) (Ping timeout: 246 seconds)
2024-04-29 02:49:11 +0200esph(~weechat@user/esph)
2024-04-29 02:49:29 +0200yin_(~yin@user/zero) (Ping timeout: 252 seconds)
2024-04-29 02:51:51 +0200y04nn(~username@2a03:1b20:8:f011::e10d) (Ping timeout: 272 seconds)
2024-04-29 02:57:09 +0200Ranhir(~Ranhir@157.97.53.139) (Read error: Connection reset by peer)
2024-04-29 02:58:40 +0200mei(~mei@user/mei) (Remote host closed the connection)
2024-04-29 02:58:51 +0200Ranhir(~Ranhir@157.97.53.139)
2024-04-29 03:00:47 +0200cashew(~cashewsta@65.17.175.150) (Remote host closed the connection)
2024-04-29 03:07:02 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Remote host closed the connection)
2024-04-29 03:13:05 +0200mei(~mei@user/mei)
2024-04-29 03:15:02 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2024-04-29 03:26:20 +0200yin_(~yin@user/zero)
2024-04-29 03:30:36 +0200otto_s(~user@p5b0442ac.dip0.t-ipconnect.de) (Ping timeout: 268 seconds)
2024-04-29 03:31:48 +0200otto_s(~user@p5de2f4e6.dip0.t-ipconnect.de)
2024-04-29 03:34:05 +0200yin_(~yin@user/zero) (Ping timeout: 240 seconds)
2024-04-29 03:34:27 +0200Rodney_(~Rodney@176.254.244.83)
2024-04-29 03:39:23 +0200waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Quit: WeeChat 4.1.2)
2024-04-29 03:44:06 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 260 seconds)
2024-04-29 03:45:58 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2024-04-29 03:46:24 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 03:50:45 +0200cashew(~cashewsta@65.17.175.150) (Ping timeout: 245 seconds)
2024-04-29 04:00:04 +0200esph(~weechat@user/esph) (Ping timeout: 260 seconds)
2024-04-29 04:04:40 +0200madeleine-sydney(~madeleine@c-76-155-235-153.hsd1.co.comcast.net)
2024-04-29 04:05:02 +0200xdminsy(~xdminsy@117.147.70.233) (Quit: Konversation terminated!)
2024-04-29 04:18:41 +0200machinedgod(~machinedg@d173-183-246-216.abhsia.telus.net)
2024-04-29 04:25:25 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 04:30:20 +0200td_(~td@i53870914.versanet.de) (Ping timeout: 245 seconds)
2024-04-29 04:31:18 +0200peterbecich(~Thunderbi@47.229.123.186)
2024-04-29 04:32:15 +0200td_(~td@i5387093D.versanet.de)
2024-04-29 04:35:47 +0200machinedgod(~machinedg@d173-183-246-216.abhsia.telus.net) (Ping timeout: 260 seconds)
2024-04-29 04:38:15 +0200cashew(~cashewsta@65.17.175.150) (Remote host closed the connection)
2024-04-29 04:50:07 +0200philopsos(~caecilius@user/philopsos)
2024-04-29 05:00:27 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 255 seconds)
2024-04-29 05:01:15 +0200philopsos(~caecilius@user/philopsos) (Ping timeout: 268 seconds)
2024-04-29 05:08:51 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2024-04-29 05:09:08 +0200aforemny(~aforemny@i59F516F8.versanet.de)
2024-04-29 05:09:44 +0200aforemny_(~aforemny@i59f516da.versanet.de) (Ping timeout: 252 seconds)
2024-04-29 05:19:27 +0200peterbecich(~Thunderbi@47.229.123.186) (Ping timeout: 268 seconds)
2024-04-29 05:27:13 +0200ddellacosta(~ddellacos@ool-44c73d29.dyn.optonline.net)
2024-04-29 05:32:30 +0200JimL(~quassel@89.162.16.26) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2024-04-29 05:35:25 +0200JimL(~quassel@89.162.16.26)
2024-04-29 05:41:10 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 05:44:02 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 260 seconds)
2024-04-29 05:50:01 +0200ec(~ec@gateway/tor-sasl/ec)
2024-04-29 05:51:01 +0200andrewboltachev(~andrewbol@178.141.238.156)
2024-04-29 05:51:47 +0200 <andrewboltachev> Hello! Does anyone has example of successful wasm32-wasi-cabal builds? Aka cabal in non-standard environments
2024-04-29 05:51:55 +0200xigua(~xigua@user/xigua) (Read error: Connection reset by peer)
2024-04-29 05:52:09 +0200xigua(~xigua@user/xigua)
2024-04-29 05:52:38 +0200 <andrewboltachev> I have a simple WebAssembly project and Cabal is saying me:
2024-04-29 05:52:39 +0200 <andrewboltachev> Error: cabal: Could not resolve dependencies:
2024-04-29 05:52:40 +0200 <andrewboltachev> [__0] trying: h1-0.1.0.0 (user goal)
2024-04-29 05:52:40 +0200 <andrewboltachev> [__1] next goal: base (dependency of h1)
2024-04-29 05:52:41 +0200 <andrewboltachev> [__1] rejecting: base-4.20.0.0/installed-inplace (conflict: h1 =>
2024-04-29 05:52:41 +0200 <andrewboltachev> base==4.19.1.0)
2024-04-29 05:53:16 +0200cashew(~cashewsta@65.17.175.150) (Remote host closed the connection)
2024-04-29 05:55:34 +0200 <jackdk> andrewboltachev: whatever your `h1` package is (is it the name of your test program?), it's claiming a dependency on `base-4.19.1.0`, but the compiler you're using provides `base-4.20.0.0`. https://wiki.haskell.org/Base_package has not updated to list `4.20.0.0`, but I would get it's the GHC 9.10 RC? I would try adjusting the `base` bound in `h1.cabal` to `== 4.20.0.0` to see if that gets you moving.
2024-04-29 05:56:02 +0200 <jackdk> (`s/I would get/I would guess/`)
2024-04-29 06:02:32 +0200 <andrewboltachev> jackdk: aha, trying
2024-04-29 06:03:59 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2024-04-29 06:04:09 +0200 <andrewboltachev> well it's this then: https://paste.tomsmeding.com/fT1guof4
2024-04-29 06:04:30 +0200 <andrewboltachev> so I think I should get compiler that will provide 4.19
2024-04-29 06:05:07 +0200 <jackdk> It is possible to override those bounds, one sec
2024-04-29 06:05:20 +0200 <andrewboltachev> as deps that are deep in the tree ask for 4.19. 4.20 is too new (and an answer to all of the universe or sth)
2024-04-29 06:05:22 +0200 <jackdk> Also, if you're playing with WASM, only 9.10 has the WASM->JS FFI
2024-04-29 06:05:56 +0200 <andrewboltachev> yes, I think I need that
2024-04-29 06:06:32 +0200 <andrewboltachev> ➜ h1 git:(master) ✗ wasm32-wasi-ghc --version
2024-04-29 06:06:33 +0200 <andrewboltachev> The Glorious Glasgow Haskell Compilation System, version 9.11.20240420
2024-04-29 06:07:34 +0200 <andrewboltachev> I think I've launched an exported function from the wasm file successfully
2024-04-29 06:07:34 +0200 <jackdk> Create a `cabal.project` file next to your `.cabal` file, telling cabal that it's allowed to relax the `base` bound for all pacakges: https://www.irccloud.com/pastebin/anN72RgX/cabal.project
2024-04-29 06:08:19 +0200hgolden(~hgolden@2603:8000:9d00:3ed1:f849:272c:fda5:33c9) (Remote host closed the connection)
2024-04-29 06:09:08 +0200ski(~ski@ext-1-033.eduroam.chalmers.se) (Ping timeout: 252 seconds)
2024-04-29 06:09:30 +0200ski(~ski@ext-1-033.eduroam.chalmers.se)
2024-04-29 06:10:27 +0200 <andrewboltachev> wow: https://paste.tomsmeding.com/AKjcvAqu
2024-04-29 06:11:40 +0200 <andrewboltachev> will try cabal.project file with this now (didn't work 'cause of "base" error as well): https://github.com/tweag/ormolu/tree/master/ormolu-live
2024-04-29 06:11:45 +0200hgolden(~hgolden@2603:8000:9d00:3ed1:2678:8497:aa5c:7fa9)
2024-04-29 06:12:39 +0200 <jackdk> That is a three-year-old version of `bytestring`, and it had a correct upper bound which we just told GHC to ignore. Try adding `constraints: bytestring ^>= 0.12.1.0` to your `cabal.project` to see if it gives you a better shot at building.
2024-04-29 06:15:38 +0200 <andrewboltachev> jackdk: thanks. I'm still a noob in Haskell, even though I created this project myself: https://github.com/andrewboltachev/matcher/blob/master/src/Logicore/Matcher/Core.hs
2024-04-29 06:15:47 +0200michalz(~michalz@185.246.207.203)
2024-04-29 06:16:36 +0200 <jackdk> Someone should do something about cabal's solver output, because while it has the information most people need, it fails to communicate it clearly.
2024-04-29 06:16:59 +0200 <sclv> we have a big pr landing on it
2024-04-29 06:17:34 +0200 <sclv> may not help enough, but its something
2024-04-29 06:18:34 +0200 <jackdk> I am delighted to hear this - does the PR have an output sample?
2024-04-29 06:18:59 +0200 <andrewboltachev> similar foldl' error though: https://paste.tomsmeding.com/ao8zbeZA
2024-04-29 06:19:25 +0200 <andrewboltachev> how do I define which ver. to pick for unordered-containers (and other library)?
2024-04-29 06:19:46 +0200 <andrewboltachev> I guess earliest one that doesn't clash with foldl'
2024-04-29 06:21:40 +0200tri(~tri@ool-18bc2e74.dyn.optonline.net)
2024-04-29 06:22:44 +0200 <jackdk> The re-export of `foldl'` from `Prelude` is a new change in `base-4.20.0.0`: https://gitlab.haskell.org/ghc/ghc/-/blob/master/libraries/base/changelog.md?ref_type=heads . Add another constraint to your `cabal.project` to select `unordered-containers ^>=0.2.0`, and you may need to add more `allow-newer`: https://hackage.haskell.org/package/unordered-containers-0.2.20/changelog
2024-04-29 06:23:21 +0200 <jackdk> `constraints: bytestring ^>= 0.12.1.0, unordered-containers ^>= 0.2.20`, I guess. Welcome to life on the bleeding edge
2024-04-29 06:23:22 +0200 <andrewboltachev> jackdk: maybe I can instead shift down to 4.19?
2024-04-29 06:23:47 +0200 <jackdk> You could try that, and if it has enough WASM support for what you're trying I'd recommend it
2024-04-29 06:26:30 +0200 <andrewboltachev> okay. but, what should I reinstall?
2024-04-29 06:27:02 +0200 <andrewboltachev> the whole `wasm32-wasi` stack?
2024-04-29 06:27:17 +0200 <andrewboltachev> i.e. which has the wasm32-wasi-ghc
2024-04-29 06:28:16 +0200 <jackdk> You'll need a 9.8-series `wasm32-wasi-ghc`, from wherever you got the 9.10-series one from. I'm not really sure, sorry, I mostly work with native code
2024-04-29 06:32:42 +0200 <andrewboltachev> jackdk: thanks for useful help! I guess I'll crash into it just by: `FLAVOUR=9.8 ./setup.sh` :-)
2024-04-29 06:35:20 +0200 <jackdk> No worries, good luck!
2024-04-29 06:39:10 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 06:39:47 +0200peterbecich(~Thunderbi@47.229.123.186)
2024-04-29 06:41:28 +0200bilegeek(~bilegeek@2600:1008:b025:e5c1:3276:e96d:2d6f:14d7) (Quit: Leaving)
2024-04-29 06:43:30 +0200cashew(~cashewsta@65.17.175.150) (Ping timeout: 255 seconds)
2024-04-29 06:48:34 +0200mima(~mmh@aftr-62-216-211-53.dynamic.mnet-online.de)
2024-04-29 06:51:20 +0200tri(~tri@ool-18bc2e74.dyn.optonline.net) (Remote host closed the connection)
2024-04-29 06:52:52 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Remote host closed the connection)
2024-04-29 06:52:53 +0200tri(~tri@ool-18bc2e74.dyn.optonline.net)
2024-04-29 06:57:27 +0200tri(~tri@ool-18bc2e74.dyn.optonline.net) (Ping timeout: 255 seconds)
2024-04-29 06:58:56 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2024-04-29 06:59:06 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 256 seconds)
2024-04-29 07:02:14 +0200euleritian(~euleritia@dynamic-176-007-161-086.176.7.pool.telefonica.de)
2024-04-29 07:07:40 +0200Moyst_(~moyst@user/moyst) (Ping timeout: 260 seconds)
2024-04-29 07:08:58 +0200Moyst(~moyst@user/moyst)
2024-04-29 07:09:16 +0200 <andrewboltachev> Does `ghc-experimental` only exist on 4.20? Is it a library or something else (like a flag to enable)?
2024-04-29 07:10:53 +0200peterbecich(~Thunderbi@47.229.123.186) (Ping timeout: 272 seconds)
2024-04-29 07:14:27 +0200mei(~mei@user/mei) (Ping timeout: 268 seconds)
2024-04-29 07:15:04 +0200euleritian(~euleritia@dynamic-176-007-161-086.176.7.pool.telefonica.de) (Read error: Connection reset by peer)
2024-04-29 07:15:23 +0200euleritian(~euleritia@77.22.252.56)
2024-04-29 07:20:37 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Ping timeout: 268 seconds)
2024-04-29 07:24:25 +0200madeleine-sydney(~madeleine@c-76-155-235-153.hsd1.co.comcast.net) (Quit: Konversation terminated!)
2024-04-29 07:29:23 +0200euleritian(~euleritia@77.22.252.56) (Ping timeout: 264 seconds)
2024-04-29 07:29:49 +0200euleritian(~euleritia@dynamic-176-007-161-086.176.7.pool.telefonica.de)
2024-04-29 07:30:03 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2024-04-29 07:31:45 +0200rosco(~rosco@yp-146-6.tm.net.my)
2024-04-29 07:31:57 +0200waldo(~waldo@user/waldo)
2024-04-29 07:32:31 +0200euleritian(~euleritia@dynamic-176-007-161-086.176.7.pool.telefonica.de) (Read error: Connection reset by peer)
2024-04-29 07:32:48 +0200euleritian(~euleritia@77.22.252.56)
2024-04-29 07:39:20 +0200mei(~mei@user/mei)
2024-04-29 07:44:41 +0200rembo10(~rembo10@main.remulis.com) (Quit: ZNC 1.8.2 - https://znc.in)
2024-04-29 07:45:32 +0200rembo10(~rembo10@main.remulis.com)
2024-04-29 07:46:42 +0200euleritian(~euleritia@77.22.252.56) (Ping timeout: 256 seconds)
2024-04-29 07:47:24 +0200euleritian(~euleritia@dynamic-176-007-161-086.176.7.pool.telefonica.de)
2024-04-29 07:48:07 +0200emergence2(emergence@ip221.ip-51-79-0.net)
2024-04-29 07:48:30 +0200emergence2(emergence@ip221.ip-51-79-0.net) (Client Quit)
2024-04-29 07:57:58 +0200acidjnk(~acidjnk@p200300d6e714dc2634962692522af535.dip0.t-ipconnect.de)
2024-04-29 08:05:16 +0200waldo(~waldo@user/waldo) (Ping timeout: 246 seconds)
2024-04-29 08:09:35 +0200waldo(~waldo@user/waldo)
2024-04-29 08:09:37 +0200waldo(~waldo@user/waldo) (Client Quit)
2024-04-29 08:10:34 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 260 seconds)
2024-04-29 08:11:33 +0200rosco(~rosco@yp-146-6.tm.net.my) (Quit: Lost terminal)
2024-04-29 08:16:25 +0200xff0x(~xff0x@softbank219059019218.bbtec.net)
2024-04-29 08:19:27 +0200euphores(~SASL_euph@user/euphores) (Quit: Leaving.)
2024-04-29 08:20:29 +0200 <haskellbridge> <J​ade> it's part of the split of base into base, ghc-internal and ghc-experimental
2024-04-29 08:31:00 +0200euphores(~SASL_euph@user/euphores)
2024-04-29 08:33:18 +0200y04nn(~username@2a03:1b20:8:f011::e10d)
2024-04-29 08:40:11 +0200Benzi-Junior(~BenziJuni@232-148-209-31.dynamic.hringdu.is) (Ping timeout: 264 seconds)
2024-04-29 08:41:11 +0200Benzi-Junior(~BenziJuni@232-148-209-31.dynamic.hringdu.is)
2024-04-29 08:45:58 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2024-04-29 08:46:54 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4)
2024-04-29 08:58:41 +0200sord937(~sord937@gateway/tor-sasl/sord937)
2024-04-29 09:05:43 +0200Tuplanolla(~Tuplanoll@91-159-69-59.elisa-laajakaista.fi)
2024-04-29 09:06:07 +0200xff0x(~xff0x@softbank219059019218.bbtec.net) (Ping timeout: 256 seconds)
2024-04-29 09:07:40 +0200xff0x(~xff0x@softbank219059019218.bbtec.net)
2024-04-29 09:11:17 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Read error: Connection reset by peer)
2024-04-29 09:21:23 +0200xff0x(~xff0x@softbank219059019218.bbtec.net) (Ping timeout: 260 seconds)
2024-04-29 09:22:52 +0200xff0x(~xff0x@softbank219059019218.bbtec.net)
2024-04-29 09:33:27 +0200gmg(~user@user/gehmehgeh)
2024-04-29 09:35:04 +0200andrewboltachev(~andrewbol@178.141.238.156) (Ping timeout: 250 seconds)
2024-04-29 09:37:42 +0200chele(~chele@user/chele)
2024-04-29 09:42:13 +0200oo_miguel(~Thunderbi@78-11-181-16.static.ip.netia.com.pl)
2024-04-29 09:43:15 +0200xff0x(~xff0x@softbank219059019218.bbtec.net) (Ping timeout: 245 seconds)
2024-04-29 09:45:05 +0200xff0x(~xff0x@softbank219059019218.bbtec.net)
2024-04-29 09:57:52 +0200machinedgod(~machinedg@d173-183-246-216.abhsia.telus.net)
2024-04-29 10:00:12 +0200euleritian(~euleritia@dynamic-176-007-161-086.176.7.pool.telefonica.de) (Read error: Connection reset by peer)
2024-04-29 10:00:30 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2024-04-29 10:17:36 +0200AlexNoo_(~AlexNoo@94.233.241.102)
2024-04-29 10:18:47 +0200mreh(~matthew@host86-160-168-68.range86-160.btcentralplus.com)
2024-04-29 10:19:17 +0200sawilagar(~sawilagar@user/sawilagar)
2024-04-29 10:20:04 +0200AlexZenon(~alzenon@178.34.161.189) (Ping timeout: 268 seconds)
2024-04-29 10:20:09 +0200zmt00(~zmt00@user/zmt00)
2024-04-29 10:21:18 +0200AlexNoo(~AlexNoo@178.34.161.189) (Ping timeout: 268 seconds)
2024-04-29 10:22:31 +0200swamp_(~zmt00@user/zmt00) (Ping timeout: 260 seconds)
2024-04-29 10:23:25 +0200AlexZenon(~alzenon@94.233.241.102)
2024-04-29 10:29:03 +0200danza(~francesco@151.37.162.148)
2024-04-29 10:33:19 +0200danza(~francesco@151.37.162.148) (Ping timeout: 246 seconds)
2024-04-29 10:34:32 +0200ft(~ft@p4fc2a1f9.dip0.t-ipconnect.de) (Quit: leaving)
2024-04-29 10:50:03 +0200zmt01(~zmt00@user/zmt00)
2024-04-29 10:52:55 +0200zmt00(~zmt00@user/zmt00) (Ping timeout: 246 seconds)
2024-04-29 10:52:58 +0200__monty__(~toonn@user/toonn)
2024-04-29 10:56:24 +0200y04nn(~username@2a03:1b20:8:f011::e10d) (Ping timeout: 255 seconds)
2024-04-29 11:09:04 +0200tzh(~tzh@c-73-164-206-160.hsd1.or.comcast.net) (Quit: zzz)
2024-04-29 11:12:58 +0200xdminsy(~xdminsy@117.147.70.233)
2024-04-29 11:19:00 +0200wei2912(~wei2912@137.132.26.109)
2024-04-29 11:19:39 +0200wei2912(~wei2912@137.132.26.109) (Client Quit)
2024-04-29 11:20:20 +0200wei2912(~wei2912@137.132.26.109)
2024-04-29 11:23:56 +0200danza(~francesco@151.37.162.148)
2024-04-29 11:35:56 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2024-04-29 11:35:56 +0200chiselfuse(~chiselfus@user/chiselfuse) (Remote host closed the connection)
2024-04-29 11:36:51 +0200xff0x(~xff0x@softbank219059019218.bbtec.net) (Ping timeout: 268 seconds)
2024-04-29 11:36:52 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2024-04-29 11:37:00 +0200chiselfuse(~chiselfus@user/chiselfuse)
2024-04-29 11:51:08 +0200danza(~francesco@151.37.162.148) (Read error: Connection reset by peer)
2024-04-29 11:51:47 +0200danza(~francesco@151.37.162.148)
2024-04-29 12:03:39 +0200rosco(~rosco@yp-146-6.tm.net.my)
2024-04-29 12:06:03 +0200Square3(~Square4@user/square)
2024-04-29 12:12:17 +0200demon-cat(~demon-cat@82-132-217-251.dab.02.net)
2024-04-29 12:17:50 +0200mwnaylor(~user@2601:5cf:837e:2bb0::824e) (Ping timeout: 245 seconds)
2024-04-29 12:31:24 +0200demon-cat(~demon-cat@82-132-217-251.dab.02.net) (Ping timeout: 252 seconds)
2024-04-29 12:32:27 +0200xff0x(~xff0x@softbank219059019218.bbtec.net)
2024-04-29 12:36:54 +0200rosco(~rosco@yp-146-6.tm.net.my) (Ping timeout: 252 seconds)
2024-04-29 12:39:28 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4) (Ping timeout: 255 seconds)
2024-04-29 12:46:41 +0200noumenon(~noumenon@113.51-175-156.customer.lyse.net)
2024-04-29 12:49:00 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 252 seconds)
2024-04-29 12:52:05 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2024-04-29 12:53:12 +0200demon-cat(~demon-cat@82-132-217-251.dab.02.net)
2024-04-29 12:58:17 +0200lambdap2371(~lambdap@static.167.190.119.168.clients.your-server.de) (Quit: Ping timeout (120 seconds))
2024-04-29 12:58:48 +0200teqwve(teqwve@static.141.38.201.195.clients.your-server.de) (Quit: cya)
2024-04-29 12:59:06 +0200lockna_(~lockna@static.139.16.130.94.clients.your-server.de) (Quit: ZNC 1.8.2 - https://znc.in)
2024-04-29 12:59:07 +0200fiddlerw-(~fiddlerwo@user/fiddlerwoaroof) (Quit: Gone.)
2024-04-29 12:59:17 +0200A_Dragon(A_D@libera/staff/dragon) (Quit: ZNC - https://znc.in)
2024-04-29 12:59:24 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4)
2024-04-29 12:59:59 +0200wei2912(~wei2912@137.132.26.109) (Quit: Lost terminal)
2024-04-29 13:01:04 +0200kmein(~weechat@user/kmein) (Ping timeout: 255 seconds)
2024-04-29 13:01:21 +0200lockna(~lockna@2a01:4f8:10b:14f1::2)
2024-04-29 13:01:25 +0200teqwve(teqwve@static.141.38.201.195.clients.your-server.de)
2024-04-29 13:01:32 +0200A_Dragon(A_D@libera/staff/dragon)
2024-04-29 13:01:43 +0200canta(~canta@user/canta) (Ping timeout: 246 seconds)
2024-04-29 13:01:44 +0200kosmikus(~kosmikus@nullzig.kosmikus.org) (Ping timeout: 256 seconds)
2024-04-29 13:01:44 +0200cjay(cjay@nerdbox.nerd2nerd.org) (Ping timeout: 256 seconds)
2024-04-29 13:02:08 +0200kmein(~weechat@user/kmein)
2024-04-29 13:02:12 +0200fiddlerwoaroof(~fiddlerwo@user/fiddlerwoaroof)
2024-04-29 13:02:25 +0200kosmikus(~kosmikus@nullzig.kosmikus.org)
2024-04-29 13:03:05 +0200lambdap2371(~lambdap@static.167.190.119.168.clients.your-server.de)
2024-04-29 13:03:37 +0200sord937(~sord937@gateway/tor-sasl/sord937) (Ping timeout: 260 seconds)
2024-04-29 13:03:37 +0200gmg(~user@user/gehmehgeh) (Ping timeout: 260 seconds)
2024-04-29 13:05:03 +0200gmg(~user@user/gehmehgeh)
2024-04-29 13:05:22 +0200sord937(~sord937@gateway/tor-sasl/sord937)
2024-04-29 13:07:12 +0200cjay(cjay@nerdbox.nerd2nerd.org)
2024-04-29 13:13:47 +0200canta(~canta@user/canta)
2024-04-29 13:25:20 +0200danza(~francesco@151.37.162.148) (Ping timeout: 245 seconds)
2024-04-29 13:46:45 +0200euphores(~SASL_euph@user/euphores) (Ping timeout: 252 seconds)
2024-04-29 13:50:00 +0200andrewboltachev(~andrewbol@178.141.238.156)
2024-04-29 13:53:16 +0200euphores(~SASL_euph@user/euphores)
2024-04-29 13:55:17 +0200rosco(~rosco@yp-146-6.tm.net.my)
2024-04-29 14:00:44 +0200TheOneWhoFuncts(~Thunderbi@104.28.233.86)
2024-04-29 14:13:40 +0200ddellacosta(~ddellacos@ool-44c73d29.dyn.optonline.net) (Ping timeout: 245 seconds)
2024-04-29 14:16:07 +0200kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2024-04-29 14:20:38 +0200chexum(~quassel@gateway/tor-sasl/chexum) (Ping timeout: 260 seconds)
2024-04-29 14:23:21 +0200chexum(~quassel@gateway/tor-sasl/chexum)
2024-04-29 14:26:03 +0200 <TheOneWhoFuncts> Hello, I am a haskell beginner and I wanted to ask how are applicative functors generalization of Monads wrt Category theory?
2024-04-29 14:27:35 +0200demon-cat(~demon-cat@82-132-217-251.dab.02.net) (Ping timeout: 264 seconds)
2024-04-29 14:28:35 +0200 <ncf> every (strong) monad gives rise to an applicative functor (often two), so there are "more" applicative functors than monads
2024-04-29 14:29:02 +0200chiselfuse(~chiselfus@user/chiselfuse) (Remote host closed the connection)
2024-04-29 14:29:59 +0200chiselfuse(~chiselfus@user/chiselfuse)
2024-04-29 14:33:23 +0200 <TheOneWhoFuncts> Ok, so is it possible to implement <*> using bind and return?
2024-04-29 14:33:23 +0200 <TheOneWhoFuncts> Also, what does an applicative functor correspond to in category theory?
2024-04-29 14:33:23 +0200 <TheOneWhoFuncts> P.S - I have seen bartosz milewski's lecture videos for category theory I and II
2024-04-29 14:34:43 +0200 <ncf> @src ap
2024-04-29 14:34:43 +0200 <lambdabot> ap = liftM2 id
2024-04-29 14:34:47 +0200 <ncf> :t ap
2024-04-29 14:34:48 +0200 <lambdabot> Monad m => m (a -> b) -> m a -> m b
2024-04-29 14:34:58 +0200 <ncf> @src liftM2
2024-04-29 14:34:59 +0200 <lambdabot> liftM2 f m1 m2 = do
2024-04-29 14:34:59 +0200 <lambdabot> x1 <- m1
2024-04-29 14:34:59 +0200 <lambdabot> x2 <- m2
2024-04-29 14:34:59 +0200 <lambdabot> return (f x1 x2)
2024-04-29 14:35:45 +0200 <ncf> a second implementation would be liftM2' f m1 m2 = do x2 <- m2; x1 <- m1; return (f x1 x2) -- this corresponds to sequencing the effects backwards, or right-to-left
2024-04-29 14:35:53 +0200eron(~eron@168.196.116.143)
2024-04-29 14:36:43 +0200 <ncf> applicative functors can be modelled as either lax closed functors or (most often) lax monoidal functors
2024-04-29 14:37:34 +0200 <ncf> (these notions coincide on closed monoidal categories)
2024-04-29 14:43:57 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2024-04-29 14:44:54 +0200gmg(~user@user/gehmehgeh) (Ping timeout: 260 seconds)
2024-04-29 14:45:56 +0200gmg(~user@user/gehmehgeh)
2024-04-29 14:46:15 +0200 <TheOneWhoFuncts> Oh ok Thanks a lot!
2024-04-29 14:46:15 +0200 <TheOneWhoFuncts> Is there any ghci command like the one you used for viewing source?
2024-04-29 14:50:02 +0200AlexNoo_AlexNoo
2024-04-29 15:03:41 +0200xff0x(~xff0x@softbank219059019218.bbtec.net) (Ping timeout: 256 seconds)
2024-04-29 15:04:50 +0200 <probie> If the code is interpreted by GHCi, you can use :list, but that won't work for compiled modules so probably won't do what you want
2024-04-29 15:05:47 +0200rosco(~rosco@yp-146-6.tm.net.my) (Remote host closed the connection)
2024-04-29 15:06:39 +0200rosco(~rosco@yp-146-6.tm.net.my)
2024-04-29 15:07:08 +0200 <TheOneWhoFuncts> Thanks, I guess online search is the best option
2024-04-29 15:07:31 +0200sand-witch(~m-mzmz6l@vmi833741.contaboserver.net) (Ping timeout: 256 seconds)
2024-04-29 15:09:41 +0200xff0x(~xff0x@softbank219059019218.bbtec.net)
2024-04-29 15:12:54 +0200chiselfuse(~chiselfus@user/chiselfuse) (Ping timeout: 260 seconds)
2024-04-29 15:15:20 +0200chiselfuse(~chiselfus@user/chiselfuse)
2024-04-29 15:18:23 +0200andrewboltachev(~andrewbol@178.141.238.156) (Quit: Client closed)
2024-04-29 15:21:00 +0200xff0x(~xff0x@softbank219059019218.bbtec.net) (Ping timeout: 255 seconds)
2024-04-29 15:25:08 +0200demon-cat(~demon-cat@82-132-217-251.dab.02.net)
2024-04-29 15:28:10 +0200ystael(~ystael@user/ystael)
2024-04-29 15:29:57 +0200demon-cat(~demon-cat@82-132-217-251.dab.02.net) (Ping timeout: 272 seconds)
2024-04-29 15:36:10 +0200xff0x(~xff0x@softbank219059019218.bbtec.net)
2024-04-29 15:40:02 +0200famubu(~julinuser@user/famubu)
2024-04-29 15:41:03 +0200dsrt^(~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Remote host closed the connection)
2024-04-29 15:41:17 +0200 <famubu> I had been trying to use megaparsec to make a parser for simple regex. For concatenation, I have a constructor `Cat Re Re` where `Re` is type of regex. How should I make parser for `Cat`? It should be like `Parser Re -> Parser Re -> Parser (Re -> Re -> Re)`, right?
2024-04-29 15:42:54 +0200meiGuest488
2024-04-29 15:42:54 +0200Guest488(~mei@user/mei) (Killed (platinum.libera.chat (Nickname regained by services)))
2024-04-29 15:42:59 +0200mei(~mei@user/mei)
2024-04-29 15:43:37 +0200 <famubu> I mean, it should take two parser (one each for the two regex) and make a parser for the concatenation of them, right?
2024-04-29 15:45:07 +0200 <ncf> parse a list of atoms and then fold that into a regex using Cat and your constructor for the empty regex?
2024-04-29 15:45:31 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net)
2024-04-29 15:47:22 +0200Miroboru(~myrvoll@178-164-114.82.3p.ntebredband.no) (Quit: Lost terminal)
2024-04-29 15:47:25 +0200 <famubu> The top answer here also does it that way: https://stackoverflow.com/questions/9020254/using-parsec-to-parse-regular-expressions
2024-04-29 15:47:33 +0200 <famubu> Is that how it's usually done?
2024-04-29 15:48:26 +0200 <EvanR> is the regular expression language regular
2024-04-29 15:48:35 +0200 <EvanR> can it "parse" itself
2024-04-29 15:48:53 +0200 <dolio> No.
2024-04-29 15:50:18 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net) (Ping timeout: 268 seconds)
2024-04-29 15:50:27 +0200 <famubu> 🤔
2024-04-29 15:50:29 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 240 seconds)
2024-04-29 15:51:00 +0200 <famubu> I heard people saying that parsing needs something more than regex. So I guess not.
2024-04-29 15:51:04 +0200 <ncf> it has parentheses
2024-04-29 15:51:30 +0200 <famubu> Ah.. that itself makes it at least context free to do the balancing act, I guess.
2024-04-29 15:51:31 +0200 <EvanR> it depends on the language
2024-04-29 15:51:46 +0200 <ncf> is there *a* regular language that describes regular expressions
2024-04-29 15:52:08 +0200 <famubu> No
2024-04-29 15:52:17 +0200 <famubu> Recursion is needed.
2024-04-29 15:52:40 +0200famubuis wondering if what he just typed is correct..
2024-04-29 15:53:02 +0200EvanRruns famubu through the type checker
2024-04-29 15:53:07 +0200 <ncf> actually, is Unlambda regular
2024-04-29 15:53:11 +0200 <famubu> :D
2024-04-29 15:53:51 +0200 <ncf> i guess not
2024-04-29 15:53:59 +0200euleritian(~euleritia@dynamic-176-007-169-212.176.7.pool.telefonica.de)
2024-04-29 15:55:30 +0200 <ncf> take a long enough word like `^n k^n then pump the backticks
2024-04-29 15:55:43 +0200 <ncf> er k^{n+1}
2024-04-29 15:58:50 +0200Miroboru(~myrvoll@178-164-114.82.3p.ntebredband.no)
2024-04-29 16:01:03 +0200 <ncf> https://stackoverflow.com/questions/19533804/is-there-a-regular-language-to-represent-regular-expr…
2024-04-29 16:01:15 +0200 <ncf> » a regular language cannot be isomorphic to a non-regular language
2024-04-29 16:01:46 +0200tri(~tri@ool-18bbef1a.static.optonline.net)
2024-04-29 16:01:55 +0200 <dolio> What does isomorphic mean there?
2024-04-29 16:02:01 +0200 <ncf> no idea
2024-04-29 16:02:17 +0200 <ncf> i wonder if the isomorphism has to be "regular" itself for this to work :^)
2024-04-29 16:02:49 +0200 <ncf> (i.e. implementable as a finite-state transducer or something)
2024-04-29 16:02:57 +0200 <dolio> I was thinking you could try to replace parentheses by something like numbers that say how to group the following expressions. But I think that still isn't regular.
2024-04-29 16:03:06 +0200 <ncf> yeah
2024-04-29 16:03:23 +0200 <ncf> that's basically what unlambda (or generally prefix notation) does, but with unary numbers
2024-04-29 16:03:31 +0200 <dolio> You could recognize the numbers, but not whether the rest of the string is able to be grouped successfully by the numbers.
2024-04-29 16:05:24 +0200target_i(~target_i@user/target-i/x-6023099)
2024-04-29 16:05:41 +0200tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 240 seconds)
2024-04-29 16:06:22 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 16:06:31 +0200xff0x(~xff0x@softbank219059019218.bbtec.net) (Ping timeout: 246 seconds)
2024-04-29 16:10:16 +0200eron(~eron@168.196.116.143) (Ping timeout: 250 seconds)
2024-04-29 16:14:34 +0200causal(~eric@50.35.88.207)
2024-04-29 16:15:44 +0200TheOneWhoFuncts(~Thunderbi@104.28.233.86) (Quit: TheOneWhoFuncts)
2024-04-29 16:17:19 +0200Guest83(~Guest83@104.28.201.82)
2024-04-29 16:17:20 +0200Guest83(~Guest83@104.28.201.82) ()
2024-04-29 16:17:51 +0200ocra8(ocra8@user/ocra8) (Quit: WeeChat 4.2.2)
2024-04-29 16:19:51 +0200 <famubu> Another megaparsec doubt: To have a parser for parsing `r{2,3}` where r is repeated as per bounds, what should the type of the parser be? Should it be `Parser (Re -> Re)`? But then, how would I take care of the two `Int` values?
2024-04-29 16:20:57 +0200 <ncf> the type of the parser dictates what the parser produces, rather than what it parses. `r{2,3}` is a regular expression, so your type is Parser Re
2024-04-29 16:21:47 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net)
2024-04-29 16:22:02 +0200 <ncf> Parser (Re -> Re) could be used if you wanted to parse a regular *operator* (like * or ?) separately
2024-04-29 16:22:13 +0200 <ncf> since those correspond to functions Re -> Re
2024-04-29 16:22:27 +0200 <famubu> Oh.. okay. Thanks.
2024-04-29 16:26:12 +0200 <famubu> Then would concatenation (if made as `Cat Re Re` constructor) also not be an operator?
2024-04-29 16:26:36 +0200 <ncf> a binary operator, yes
2024-04-29 16:26:37 +0200 <famubu> I had figured `r{2,3}` to be an operator because it takes another regex and kind of augments uit.
2024-04-29 16:26:55 +0200 <ncf> if you mean just the {2,3} part sure
2024-04-29 16:27:55 +0200 <famubu> This is what I got at the moment: https://bpa.st/GEVQ
2024-04-29 16:28:48 +0200 <famubu> Oh wait.. I think `cat` was modified afterwards..
2024-04-29 16:29:30 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net) (Ping timeout: 245 seconds)
2024-04-29 16:29:34 +0200 <famubu> Let me try fixing that.
2024-04-29 16:30:27 +0200 <famubu> I got the concatenation wrong as well: https://bpa.st/RUFA
2024-04-29 16:30:32 +0200 <famubu> Any pointers anyone?
2024-04-29 16:31:14 +0200 <ncf> what's wrong there?
2024-04-29 16:31:30 +0200 <famubu> It's parsing as `-- Cat (Atom 'A') (Cat (Atom 'B') (Cat (Atom 'C') (Atom 'D')))
2024-04-29 16:31:53 +0200 <ncf> and?
2024-04-29 16:31:53 +0200 <famubu> I wanted `Cat (Atom 'A') (Cat (Atom 'B') (Cat (Atom 'C')))`
2024-04-29 16:32:04 +0200 <int-e> but there's a D
2024-04-29 16:32:26 +0200 <famubu> Well, yeah that too.
2024-04-29 16:32:28 +0200 <int-e> Cat (Atom 'C') makes no sense
2024-04-29 16:32:37 +0200 <int-e> `Cat` needs a second argument
2024-04-29 16:32:52 +0200 <int-e> (well it makes sense in isolation but not in your expression)
2024-04-29 16:33:34 +0200 <famubu> Yeah I meant: `Cat (Atom 'A') (Cat (Atom 'B') (Cat (Atom 'C') (Atom 'D')))`
2024-04-29 16:33:44 +0200 <int-e> that is exactly what you got
2024-04-29 16:33:47 +0200 <ncf> these are the same pictures
2024-04-29 16:34:26 +0200 <famubu> Huh...
2024-04-29 16:34:27 +0200 <famubu> Oh...
2024-04-29 16:34:29 +0200 <famubu> Sorry!!!
2024-04-29 16:34:32 +0200 <ncf> perhaps use an infix operator for Cat so that it's clearer
2024-04-29 16:34:50 +0200 <famubu> Okay.
2024-04-29 16:35:30 +0200rvalue(~rvalue@user/rvalue) (Read error: Connection reset by peer)
2024-04-29 16:36:00 +0200rvalue(~rvalue@user/rvalue)
2024-04-29 16:37:33 +0200 <famubu> How do we mention associativity with infix?
2024-04-29 16:37:42 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net)
2024-04-29 16:37:48 +0200 <ncf> infixl/infixr
2024-04-29 16:39:19 +0200justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 268 seconds)
2024-04-29 16:39:31 +0200 <famubu> Is there a way to directly make a constructor infix? Or should we make a function and make that infix?
2024-04-29 16:40:27 +0200 <lortabac> you can define an infix constructor by using a name that starts with ':'
2024-04-29 16:40:41 +0200 <lortabac> and only contains symbols
2024-04-29 16:40:53 +0200 <ncf> data Re a = ... | Re a :- Re a | ...
2024-04-29 16:41:28 +0200euleritian(~euleritia@dynamic-176-007-169-212.176.7.pool.telefonica.de) (Read error: Connection reset by peer)
2024-04-29 16:41:48 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2024-04-29 16:42:10 +0200 <EvanR> > 2 :+ 1
2024-04-29 16:42:12 +0200 <lambdabot> 2 :+ 1
2024-04-29 16:42:20 +0200 <EvanR> :t 2 :+ 1
2024-04-29 16:42:21 +0200 <lambdabot> Num a => Complex a
2024-04-29 16:42:52 +0200 <famubu> Thanks! Made it to: https://bpa.st/AJQA
2024-04-29 16:42:56 +0200 <famubu> Got output like `-- Atom 'A' :- (Atom 'B' :- (Atom 'C' :- Atom 'D'))`
2024-04-29 16:45:13 +0200 <int-e> Yeah the derived Show instances don't take the declared associativity into account.
2024-04-29 16:45:31 +0200stefan-__(~m-yh2rcc@42dots.de) (Remote host closed the connection)
2024-04-29 16:45:55 +0200stefan-__(~m-yh2rcc@42dots.de)
2024-04-29 16:45:56 +0200 <famubu> But it is showing it as right associativity here, right?
2024-04-29 16:45:59 +0200 <int-e> and neither do the Read instances
2024-04-29 16:46:04 +0200 <int-e> yes it is
2024-04-29 16:46:45 +0200 <famubu> Oh you meant for the other version.
2024-04-29 16:47:09 +0200 <int-e> I was testing a trimmed down version in ghci: infixl :-; data X = X :- X | Z deriving (Show, Read)
2024-04-29 16:47:38 +0200 <int-e> because I didn't remember what Show and Read do in that case.
2024-04-29 16:48:47 +0200justsomeguy(~justsomeg@user/justsomeguy)
2024-04-29 16:50:46 +0200 <famubu> Where can we find documentation mentioning infixl,infixr,etc? Couldn't spot it with a simple internet search.
2024-04-29 16:51:17 +0200 <EvanR> haskell report xD
2024-04-29 16:52:43 +0200 <int-e> https://www.haskell.org/onlinereport/decls.html#fixity
2024-04-29 16:53:24 +0200 <int-e> (putting `haskell "infixl" "infixr"` into a search engine worked for me)
2024-04-29 16:55:35 +0200 <famubu> Thanks
2024-04-29 16:57:17 +0200 <mauke> https://www.haskell.org/onlinereport/haskell2010/haskellch4.html#x10-820004.4.2
2024-04-29 16:57:24 +0200 <mauke> in the "newer" report
2024-04-29 16:58:28 +0200 <EvanR> duck it
2024-04-29 16:58:43 +0200 <famubu> I had been often finding it difficult to find documentation for haskell. Even for things that I had seen earlier but forgotten. I guess a glance at the haskell report is a way to go in such circumstances.
2024-04-29 16:59:29 +0200rosco(~rosco@yp-146-6.tm.net.my) (Quit: Lost terminal)
2024-04-29 17:02:21 +0200 <EvanR> worse case scenario start putting together a haskell cheatsheet for your own inscrutable purposes
2024-04-29 17:02:23 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 264 seconds)
2024-04-29 17:02:45 +0200 <int-e> write a compiler to really understand all the details
2024-04-29 17:02:52 +0200 <famubu> Well.. I have started: https://rawtext.club/~famubu/wiki/haskell/general.html
2024-04-29 17:02:58 +0200 <famubu> Don't know how accurate.
2024-04-29 17:03:26 +0200euleritian(~euleritia@dynamic-176-007-169-212.176.7.pool.telefonica.de)
2024-04-29 17:04:27 +0200 <EvanR> an inaccurate cheatsheet is definitely hazardous
2024-04-29 17:05:04 +0200 <famubu> 😬
2024-04-29 17:05:17 +0200 <famubu> It at least gives something to build on.
2024-04-29 17:05:57 +0200famubuis going afk
2024-04-29 17:07:35 +0200euleritian(~euleritia@dynamic-176-007-169-212.176.7.pool.telefonica.de) (Read error: Connection reset by peer)
2024-04-29 17:07:52 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2024-04-29 17:18:22 +0200shapr(~user@c-24-218-186-89.hsd1.ma.comcast.net)
2024-04-29 17:25:42 +0200chele(~chele@user/chele) (Remote host closed the connection)
2024-04-29 17:29:21 +0200tri(~tri@ool-18bbef1a.static.optonline.net)
2024-04-29 17:33:46 +0200tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 256 seconds)
2024-04-29 17:37:45 +0200kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Ping timeout: 252 seconds)
2024-04-29 17:41:41 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net) (Ping timeout: 272 seconds)
2024-04-29 17:43:11 +0200pyooque(~puke@user/puke)
2024-04-29 17:43:11 +0200puke(~puke@user/puke) (Killed (lithium.libera.chat (Nickname regained by services)))
2024-04-29 17:43:11 +0200pyooquepuke
2024-04-29 17:46:06 +0200 <shapr> In case anyone wants to enable code coverage for tests, you will find success with: cabal clean && cabal configure --enable-coverage --enable-tests && cabal test
2024-04-29 17:46:36 +0200 <shapr> you will *not* find success with: cabal run tests --enable-coverage # THIS DOES NOT DO WHAT YOU WANT
2024-04-29 17:46:51 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4) (Ping timeout: 268 seconds)
2024-04-29 17:47:24 +0200 <EvanR> cabal test vs cabal run tests... what
2024-04-29 17:48:15 +0200 <shapr> I dunno
2024-04-29 17:48:24 +0200 <shapr> this is live coverage of this exciting news event
2024-04-29 17:48:27 +0200 <shapr> ok, it's not exciting
2024-04-29 17:48:47 +0200 <shapr> but at least I figured out why I wasn't seeing any coverage from the tests
2024-04-29 17:49:34 +0200 <shapr> I'm working on Kudzu again, and I'd like to compare QuickCheck and HedgeHog tests, if I can create equivalent properties.
2024-04-29 17:49:54 +0200 <int-e> This is HNN reporting live from the scene where we can observe a developer uncovering the mysteries of a nefarious cabal that has made it their mission to drive 42.765% of its users insane.
2024-04-29 17:49:54 +0200 <shapr> I could create props in QuickCheck and run them with both QC and HH?
2024-04-29 17:50:04 +0200 <shapr> int-e: does feel like that sometimes
2024-04-29 17:50:36 +0200 <shapr> on the good side, cabal configure told me that I had an existing cabal.project.local and it made a backup and wrote the correct combination of options into the new cabal.project.local
2024-04-29 17:52:43 +0200 <shapr> hm
2024-04-29 17:52:47 +0200 <shapr> I thought it was enough to have "coverage: True" but cabal gave me this cabal.project.local: ignore-project: False \n tests: True \n coverage: True \n library-coverage: True
2024-04-29 17:54:07 +0200justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 256 seconds)
2024-04-29 17:54:38 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net)
2024-04-29 17:56:35 +0200 <shapr> next step is to see if I can extract the tix files with their counts so I can get raw coverage before it's stuffed into HPC's html output
2024-04-29 18:03:28 +0200hiredman(~hiredman@frontier1.downey.family)
2024-04-29 18:04:42 +0200jumper149(~jumper149@base.felixspringer.xyz) (Ping timeout: 252 seconds)
2024-04-29 18:05:01 +0200pavonia(~user@user/siracusa) (Quit: Bye!)
2024-04-29 18:06:37 +0200jumper149(~jumper149@base.felixspringer.xyz)
2024-04-29 18:06:53 +0200YuutaW(~YuutaW@mail.yuuta.moe) (Ping timeout: 268 seconds)
2024-04-29 18:07:15 +0200econo_(uid147250@id-147250.tinside.irccloud.com)
2024-04-29 18:22:00 +0200machinedgod(~machinedg@d173-183-246-216.abhsia.telus.net) (Ping timeout: 260 seconds)
2024-04-29 18:23:43 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4)
2024-04-29 18:23:44 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2024-04-29 18:23:46 +0200gaff(~gaff@49.207.216.126)
2024-04-29 18:23:50 +0200euleritian(~euleritia@dynamic-176-007-169-212.176.7.pool.telefonica.de)
2024-04-29 18:24:12 +0200euleritian(~euleritia@dynamic-176-007-169-212.176.7.pool.telefonica.de) (Read error: Connection reset by peer)
2024-04-29 18:24:29 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2024-04-29 18:26:57 +0200 <famubu> Hi again. I am trying to write a regex parser with megaparsec. Am trying to make a parser to deal with `r{2,3}` where the corresponding constructor is `Rep Re Integer Integer`. How would I do this using operator table? I guess we need the parser to take a regex and 2 integers as argument? But all arguments need to be same type, right? Then that isn't it, right?
2024-04-29 18:27:31 +0200 <famubu> This is what I got now: https://bpa.st/XOWA
2024-04-29 18:27:59 +0200remedan(~remedan@ip-78-102-118-253.bb.vodafone.cz) (Quit: Bye!)
2024-04-29 18:28:10 +0200tzh(~tzh@c-73-164-206-160.hsd1.or.comcast.net)
2024-04-29 18:29:12 +0200 <ncf> it's a postfix operator
2024-04-29 18:29:51 +0200 <gaff> Using the State monad helps in threading the state through computations behind the scenes, but you will/may still need to use get and put in individual functions involved, right?
2024-04-29 18:31:33 +0200 <ncf> famubu: rep should only parse {n,m} and return the function \r -> Rep r n m
2024-04-29 18:34:57 +0200 <ncf> gaff: sure, if that's the API you're using
2024-04-29 18:36:20 +0200 <gaff> ncf: that repeated use of `get` and `put` in functions involved wouldn't be considered "state bookkeeping" boilerplate code then?
2024-04-29 18:38:07 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4) (Ping timeout: 255 seconds)
2024-04-29 18:38:13 +0200 <ncf> i don't know how i'm supposed to answer that without seeing any code!
2024-04-29 18:38:46 +0200gmg(~user@user/gehmehgeh) (Remote host closed the connection)
2024-04-29 18:38:46 +0200chiselfuse(~chiselfus@user/chiselfuse) (Read error: Connection reset by peer)
2024-04-29 18:38:47 +0200stiell_(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2024-04-29 18:39:38 +0200chiselfuse(~chiselfus@user/chiselfuse)
2024-04-29 18:39:52 +0200stiell_(~stiell@gateway/tor-sasl/stiell)
2024-04-29 18:39:53 +0200gmg(~user@user/gehmehgeh)
2024-04-29 18:40:09 +0200 <gaff> here is an example: `f = do { s <- get; let (a, b) = g s; put b; return a }` and similar stuff in perhaps other functions as well.
2024-04-29 18:41:24 +0200jumper149(~jumper149@base.felixspringer.xyz) (Quit: WeeChat 4.2.1)
2024-04-29 18:41:50 +0200 <ncf> in that specific case you could perhaps just use `state`
2024-04-29 18:41:51 +0200 <ncf> :t state
2024-04-29 18:41:52 +0200 <lambdabot> MonadState s m => (s -> (a, s)) -> m a
2024-04-29 18:42:11 +0200 <ncf> f = state g
2024-04-29 18:42:34 +0200remedan(~remedan@ip-78-102-118-253.bb.vodafone.cz)
2024-04-29 18:43:56 +0200rvalue(~rvalue@user/rvalue) (Read error: Connection reset by peer)
2024-04-29 18:44:25 +0200 <gaff> ncf: thanks. I know. But i am asking that structure I presented, or more generally the use of `get` and `put`, are expected monadic operations in code dealing with the State monad?
2024-04-29 18:44:26 +0200rvalue(~rvalue@user/rvalue)
2024-04-29 18:45:10 +0200 <ncf> sure
2024-04-29 18:45:33 +0200 <ncf> why else would they be exported
2024-04-29 18:46:38 +0200 <geekosaur> the state monad would be pretty useless if you couldn't access or update the state
2024-04-29 18:46:39 +0200 <EvanR> you say boilerplate and say can you move the boilerplate to a function which can be called
2024-04-29 18:46:46 +0200 <EvanR> I say*
2024-04-29 18:47:11 +0200noumenon(~noumenon@113.51-175-156.customer.lyse.net) (Quit: Leaving)
2024-04-29 18:47:50 +0200Lears(~Leary]@user/Leary/x-0910699) (Remote host closed the connection)
2024-04-29 18:47:53 +0200 <gaff> ncf: well, I want to be clear about what is state "bookkeeping" (which you would have to do if you didn't use the State monad) vs the use of these functions `get` and `put`.
2024-04-29 18:47:57 +0200tri(~tri@ool-18bbef1a.static.optonline.net)
2024-04-29 18:48:26 +0200 <ncf> that's not a well-defined concept, just a vibe
2024-04-29 18:48:55 +0200justsomeguy(~justsomeg@user/justsomeguy)
2024-04-29 18:49:14 +0200 <ncf> if you end up using get and put in between every function call then i would say you are bookkeeping and defeating the purpose of State
2024-04-29 18:49:44 +0200 <ncf> but other than that get and put are just part of the normal State interface
2024-04-29 18:50:28 +0200 <gaff> ncf: I am not really clear what you meant there.
2024-04-29 18:52:07 +0200 <ncf> i mean you are asking for a general yes/no answer to something that is essentially a value judgement (bookkeeping) and highly context-dependent
2024-04-29 18:52:15 +0200 <gaff> Consider the following example. you are writing a bunch of parser combinators, and many of these combinators use `get` and `put`. Is that circumventing the State monad?
2024-04-29 18:52:35 +0200tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 260 seconds)
2024-04-29 18:53:55 +0200 <ncf> @8ball
2024-04-29 18:53:55 +0200 <lambdabot> Unknown command, try @list
2024-04-29 18:54:11 +0200 <ncf> :(
2024-04-29 18:54:12 +0200Square3(~Square4@user/square) (Ping timeout: 252 seconds)
2024-04-29 18:54:26 +0200 <EvanR> outlook unclear call again
2024-04-29 18:55:47 +0200 <ncf> let's go with no
2024-04-29 18:56:03 +0200 <gaff> ncf: thanks
2024-04-29 18:56:54 +0200Square(~Square@user/square)
2024-04-29 18:58:51 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net) (Ping timeout: 256 seconds)
2024-04-29 19:00:38 +0200gaff(~gaff@49.207.216.126) ()
2024-04-29 19:12:08 +0200andrewboltachev(~andrewbol@178.141.238.156)
2024-04-29 19:15:50 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net)
2024-04-29 19:18:32 +0200sawilagar(~sawilagar@user/sawilagar) (Quit: Leaving)
2024-04-29 19:20:15 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net) (Ping timeout: 256 seconds)
2024-04-29 19:20:55 +0200ocra8(ocra8@user/ocra8)
2024-04-29 19:21:03 +0200machinedgod(~machinedg@d173-183-246-216.abhsia.telus.net)
2024-04-29 19:22:44 +0200manwithluck(manwithluc@gateway/vpn/protonvpn/manwithluck) (Ping timeout: 268 seconds)
2024-04-29 19:23:33 +0200manwithluck(manwithluc@gateway/vpn/protonvpn/manwithluck)
2024-04-29 19:26:26 +0200machinedgod(~machinedg@d173-183-246-216.abhsia.telus.net) (Ping timeout: 268 seconds)
2024-04-29 19:33:43 +0200ec(~ec@gateway/tor-sasl/ec)
2024-04-29 19:36:20 +0200cashew(~cashewsta@65.17.175.150) (Remote host closed the connection)
2024-04-29 19:36:39 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2024-04-29 19:37:12 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2024-04-29 19:50:53 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2024-04-29 19:56:42 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net)
2024-04-29 19:59:31 +0200philopsos(~caecilius@user/philopsos)
2024-04-29 19:59:36 +0200sand-witch(~m-mzmz6l@vmi833741.contaboserver.net)
2024-04-29 20:03:46 +0200andrewboltachev(~andrewbol@178.141.238.156) (Quit: Client closed)
2024-04-29 20:04:03 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 252 seconds)
2024-04-29 20:05:50 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 20:07:37 +0200cashew(~cashewsta@65.17.175.150) (Remote host closed the connection)
2024-04-29 20:07:50 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 20:08:13 +0200qqq(~qqq@92.43.167.61)
2024-04-29 20:08:19 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2024-04-29 20:10:46 +0200dsrt^(~cd@c-98-242-74-66.hsd1.ga.comcast.net)
2024-04-29 20:13:32 +0200tri(~tri@ool-18bbef1a.static.optonline.net)
2024-04-29 20:17:47 +0200tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 252 seconds)
2024-04-29 20:23:15 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 245 seconds)
2024-04-29 20:25:06 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2024-04-29 20:26:01 +0200cashew(~cashewsta@65.17.175.150) (Remote host closed the connection)
2024-04-29 20:26:35 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 20:30:07 +0200cashew(~cashewsta@65.17.175.150) (Remote host closed the connection)
2024-04-29 20:30:16 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 268 seconds)
2024-04-29 20:30:19 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 20:30:37 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2024-04-29 20:30:50 +0200tri(~tri@ool-18bbef1a.static.optonline.net)
2024-04-29 20:35:06 +0200tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 255 seconds)
2024-04-29 20:38:46 +0200euphores(~SASL_euph@user/euphores) (Quit: Leaving.)
2024-04-29 20:46:35 +0200 <monochrom> Belate hot take: Which part of computation at all is not bookkeeping anyway. >:)
2024-04-29 20:49:41 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4)
2024-04-29 20:50:14 +0200euphores(~SASL_euph@user/euphores)
2024-04-29 20:51:14 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 268 seconds)
2024-04-29 20:52:11 +0200sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2024-04-29 20:53:00 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2024-04-29 20:55:24 +0200andrewboltachev(~andrewbol@178.141.238.156)
2024-04-29 21:03:43 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net) (Ping timeout: 260 seconds)
2024-04-29 21:05:03 +0200ft(~ft@p4fc2a1f9.dip0.t-ipconnect.de)
2024-04-29 21:05:08 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 256 seconds)
2024-04-29 21:06:43 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2024-04-29 21:07:05 +0200cashew(~cashewsta@65.17.175.150) (Remote host closed the connection)
2024-04-29 21:07:39 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 21:08:58 +0200gmg(~user@user/gehmehgeh) (Ping timeout: 260 seconds)
2024-04-29 21:10:04 +0200gmg(~user@user/gehmehgeh)
2024-04-29 21:11:24 +0200gmg(~user@user/gehmehgeh) (Remote host closed the connection)
2024-04-29 21:12:15 +0200cashew(~cashewsta@65.17.175.150) (Ping timeout: 252 seconds)
2024-04-29 21:14:16 +0200gmg(~user@user/gehmehgeh)
2024-04-29 21:16:06 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 21:18:10 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net)
2024-04-29 21:22:43 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net) (Ping timeout: 272 seconds)
2024-04-29 21:28:43 +0200 <bastelfreak> autojoin add
2024-04-29 21:29:01 +0200 <dolio> Okay.
2024-04-29 21:30:15 +0200tri(~tri@ool-18bbef1a.static.optonline.net)
2024-04-29 21:30:17 +0200 <dolio> monochrom: I once had a vague idea that linear logic is all bookkeeping, and in some sense is not computation.
2024-04-29 21:30:59 +0200 <bastelfreak> autojoin add --run
2024-04-29 21:32:41 +0200 <dolio> It's only the parts where you move things around without looking at them.
2024-04-29 21:34:29 +0200tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 240 seconds)
2024-04-29 21:35:37 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4) (Quit: WeeChat 4.2.1)
2024-04-29 21:37:12 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net)
2024-04-29 21:43:51 +0200philopsos(~caecilius@user/philopsos) (Ping timeout: 260 seconds)
2024-04-29 21:44:19 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net) (Ping timeout: 256 seconds)
2024-04-29 21:46:58 +0200peterbecich(~Thunderbi@47.229.123.186)
2024-04-29 21:49:37 +0200Maxdaman1us(~Maxdamant@user/maxdamantus)
2024-04-29 21:50:59 +0200Maxdamantus(~Maxdamant@user/maxdamantus) (Ping timeout: 264 seconds)
2024-04-29 21:54:03 +0200foul_owl(~kerry@185.219.141.160) (Ping timeout: 252 seconds)
2024-04-29 21:55:09 +0200juri_(~juri@implicitcad.org) (Ping timeout: 252 seconds)
2024-04-29 21:55:58 +0200foul_owl(~kerry@174-21-71-155.tukw.qwest.net)
2024-04-29 21:58:06 +0200demon-cat(~demon-cat@dund-15-b2-v4wan-169642-cust1347.vm6.cable.virginm.net)
2024-04-29 22:01:09 +0200mwnaylor(~user@2601:5cf:837e:2bb0::f472)
2024-04-29 22:03:21 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Remote host closed the connection)
2024-04-29 22:03:57 +0200machinedgod(~machinedg@d173-183-246-216.abhsia.telus.net)
2024-04-29 22:06:54 +0200peterbecich(~Thunderbi@47.229.123.186) (Ping timeout: 255 seconds)
2024-04-29 22:08:58 +0200 <shapr> I dug around to find a Haskell library with a decent amount of property based tests, and accelerate is one option
2024-04-29 22:09:09 +0200 <shapr> Docs said the tests take a long time and much memory, and they were not joking.
2024-04-29 22:09:13 +0200ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2024-04-29 22:09:51 +0200ec(~ec@gateway/tor-sasl/ec)
2024-04-29 22:10:11 +0200 <Rembane> shapr: Are you on your way to buy more RAM now?
2024-04-29 22:10:42 +0200 <tomsmeding> shapr: would you call those things property tests?
2024-04-29 22:10:58 +0200 <shapr> Rembane: nah, it's only using 32 GB of RAM so far
2024-04-29 22:11:05 +0200 <tomsmeding> they are essentially unit tests, but because the thing being tested is a compiler, the unit tests are programs, and to test correct compilation of a program you have to generate inputs for it
2024-04-29 22:11:13 +0200 <shapr> tomsmeding: The nofib tests have a bunch of hedgehog calls, so I hope so?
2024-04-29 22:11:18 +0200 <tomsmeding> the fact that it uses a property testing _framework_ notwithstanding
2024-04-29 22:11:24 +0200 <shapr> that's a good point
2024-04-29 22:11:26 +0200 <Rembane> shapr: Lovely!
2024-04-29 22:11:28 +0200 <shapr> do you have any other suggestions?
2024-04-29 22:11:55 +0200 <tomsmeding> the code I write is typically compiler-y so it has the same situation :p
2024-04-29 22:12:04 +0200zetef(~quassel@2a02:2f00:5202:1200:90bc:b4a5:eea5:19e6)
2024-04-29 22:12:19 +0200 <shapr> My goal is to compare coverage driven testing to existing test suites, so I'd like to hear about any projects with a big pile of PBT
2024-04-29 22:12:34 +0200 <tomsmeding> I've asked about this here before, but I find it somewhat awkward that we PL people say that property tests are great, but the standard PL example (compilers) doesn't lend itself very well for property testing
2024-04-29 22:12:58 +0200 <shapr> I've never tried testing a compiler, why doesn't it lend itself to that?
2024-04-29 22:13:06 +0200 <tomsmeding> you can roundtrip-test a parser, if can generate valid syntax, and you can do some property testing of optimisations or subroutines of optimisations if you're lucky
2024-04-29 22:13:09 +0200 <tomsmeding> but that's mostly it
2024-04-29 22:13:09 +0200 <shapr> Is it because it's difficult to generate AST pieces?
2024-04-29 22:13:47 +0200 <tomsmeding> it's surprisingly difficult to generate _useful_ AST pieces (there was a paper at one of the major PL conferences about that last year, I can look it up if you want)
2024-04-29 22:13:57 +0200 <tomsmeding> but that's not even my point, even assuming you can do that there is not a whole lot to property-test
2024-04-29 22:14:21 +0200Square3(~Square4@user/square)
2024-04-29 22:14:30 +0200 <tomsmeding> because a compiler is fundamentally about translating between representations, so to do any large-scale property testing there you have to have a semantics for both your source and your target language, as well as a link between them
2024-04-29 22:14:36 +0200 <tomsmeding> which is essentially another compiler
2024-04-29 22:14:43 +0200 <tomsmeding> so that's not helpful
2024-04-29 22:15:09 +0200 <tomsmeding> you can only test certain components
2024-04-29 22:15:15 +0200 <shapr> can you pull in equivalence relations?
2024-04-29 22:15:20 +0200 <tomsmeding> of what?
2024-04-29 22:15:56 +0200 <shapr> If you had equivalance saturation floating around you could check that the compiler produces something in the output of eq-sat
2024-04-29 22:16:04 +0200 <shapr> but that's not so useful because you already have eq-sat :-(
2024-04-29 22:17:12 +0200Square(~Square@user/square) (Ping timeout: 260 seconds)
2024-04-29 22:17:17 +0200 <tomsmeding> you mean an equivalence relation on source programs, one on target programs, and an external proof that if S1 ~ S2 && semantics(S1) == semantics(T1) && semantics(S2) == semantics(T2) then also T1 ~ T2?
2024-04-29 22:17:23 +0200 <tomsmeding> er
2024-04-29 22:17:32 +0200 <tomsmeding> s/, and an external proof that/and then test that/
2024-04-29 22:17:45 +0200 <tomsmeding> but then you need to define full semantics again
2024-04-29 22:17:55 +0200 <tomsmeding> which is not much easier than writing a compiler in the first place
2024-04-29 22:18:18 +0200 <tomsmeding> maybe if your languages are easy toy languages writing an interpreter for them is easy
2024-04-29 22:19:08 +0200 <tomsmeding> if you have semantics (interpreters) for source and target languages you can do model testing (a subset of PBT), i.e. generate source programs and test that interpret_src == interpret_tgt . compile
2024-04-29 22:19:13 +0200 <shapr> the egg group has a tool that discovers equivalences for you
2024-04-29 22:19:21 +0200 <tomsmeding> equivalences in what
2024-04-29 22:19:26 +0200 <tomsmeding> source programs? target programs?
2024-04-29 22:19:33 +0200 <shapr> I think in source programs
2024-04-29 22:19:38 +0200 <tomsmeding> based on what? :p
2024-04-29 22:19:44 +0200 <shapr> based on trying a bunch of things
2024-04-29 22:19:47 +0200 <shapr> brute force from what I read
2024-04-29 22:19:56 +0200 <tomsmeding> based on seeing whether your compiler produces the same output for them?
2024-04-29 22:19:59 +0200 <shapr> yup
2024-04-29 22:20:01 +0200 <tomsmeding> I see
2024-04-29 22:20:08 +0200 <tomsmeding> and then?
2024-04-29 22:20:20 +0200 <shapr> then it uses those to build an equivalence graph
2024-04-29 22:20:23 +0200 <tomsmeding> a human looks at those discovered equivalences and thinks hard about whether they make sense?
2024-04-29 22:20:40 +0200 <shapr> probably :-)
2024-04-29 22:21:09 +0200 <monochrom> What is the egg group?
2024-04-29 22:21:11 +0200 <tomsmeding> it's an interesting way to do things, I hadn't thought about that
2024-04-29 22:21:15 +0200 <tomsmeding> e-graphs-good
2024-04-29 22:21:31 +0200 <tomsmeding> some people working on egraphs and saying that they're good
2024-04-29 22:21:38 +0200 <shapr> :-)
2024-04-29 22:22:18 +0200 <tomsmeding> this discovered equivalence approach is not an automated testing method, but if you're lucky the synthesised equivalences could I guess be sufficiently abstract that it might genuinely tell you something useful
2024-04-29 22:22:24 +0200 <tomsmeding> after you filter out the useless stuff
2024-04-29 22:22:41 +0200 <tomsmeding> all of the commutative properties that are uninteresting but will come out of that
2024-04-29 22:22:43 +0200 <monochrom> Hrm, I guess people who liked union-find missed the opportunity to form a union-find-good group.
2024-04-29 22:23:12 +0200 <tomsmeding> I think most academically trained programmers know of the existence of UF
2024-04-29 22:23:16 +0200 <tomsmeding> the same cannot be said for egraphs
2024-04-29 22:23:38 +0200 <tomsmeding> though you can implement UF in like <20 lines of code if you're careful
2024-04-29 22:23:54 +0200 <monochrom> Yeah I'm being sarcastic. Oh we missed the opportunity to form a function-programming-good group too! Oh wait... >:)
2024-04-29 22:23:54 +0200 <tomsmeding> egraphs are trickier, but also more powerful
2024-04-29 22:23:59 +0200 <tomsmeding> :D
2024-04-29 22:24:03 +0200 <tomsmeding> aren't we in there?
2024-04-29 22:24:55 +0200 <monochrom> We also need a monoid-good group. :)
2024-04-29 22:24:58 +0200flounders(~flounders@24.246.176.178)
2024-04-29 22:25:08 +0200 <tomsmeding> yes
2024-04-29 22:25:26 +0200 <dolio> Trickier than union-find?
2024-04-29 22:25:54 +0200 <tomsmeding> I can write a passable UF implementation in <15 minutes
2024-04-29 22:26:02 +0200 <tomsmeding> I cannot at all say the same for egraphs
2024-04-29 22:26:38 +0200 <tomsmeding> which is not anything deep; egraphs are just more complex, I also cannot write a red-black tree in <15 minutes
2024-04-29 22:26:51 +0200 <shapr> I can't do much in <15 minutes
2024-04-29 22:27:01 +0200waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se)
2024-04-29 22:28:35 +0200 <shapr> tomsmeding: oh, I didn't know you did your master's thesis on accelerate
2024-04-29 22:29:11 +0200 <tomsmeding> I share my office at the university with two PhDs who work on accelerate almost full-time :p
2024-04-29 22:29:19 +0200 <shapr> neato
2024-04-29 22:29:33 +0200 <tomsmeding> I don't myself, but I have a highlight on 'accelerate' here on irc
2024-04-29 22:29:39 +0200 <tomsmeding> (which I why I responded :p)
2024-04-29 22:32:18 +0200tri(~tri@ool-18bbef1a.static.optonline.net)
2024-04-29 22:33:12 +0200 <shapr> now it's up to using 60 GB of RAM
2024-04-29 22:33:18 +0200 <shapr> 2.5 hours
2024-04-29 22:33:24 +0200 <tomsmeding> what test suite are you running
2024-04-29 22:33:28 +0200 <tomsmeding> nofib-accelerate in the interpreer?
2024-04-29 22:33:44 +0200 <tomsmeding> I'm _quite_ sure it's not supposed to do that
2024-04-29 22:33:47 +0200 <shapr> if that's what I get from accelerate "cabal test -f nofib"
2024-04-29 22:33:53 +0200 <tomsmeding> on master?
2024-04-29 22:33:57 +0200 <shapr> I think so
2024-04-29 22:34:13 +0200 <shapr> there's a bug report that says it does this, but it's not the desired result
2024-04-29 22:34:22 +0200 <shapr> https://gitlab.haskell.org/ghc/ghc/-/issues/15751
2024-04-29 22:34:35 +0200 <tomsmeding> doesn't `cabal test` also run doctest
2024-04-29 22:34:44 +0200 <shapr> yes, doctest runs quickly
2024-04-29 22:34:50 +0200 <tomsmeding> doctest works for you ?!
2024-04-29 22:34:55 +0200 <tomsmeding> well that's good I guess
2024-04-29 22:35:05 +0200 <shapr> I get tix values out of doctest, so I think it runs?
2024-04-29 22:35:08 +0200 <tomsmeding> I haven't tried recently, I confess, but when I was doing my master thesis I never got that to work
2024-04-29 22:35:10 +0200 <shapr> I could be wrong
2024-04-29 22:35:19 +0200 <tomsmeding> doesn't matter anyway if the problem is not there
2024-04-29 22:35:48 +0200 <shapr> My real goal is to find a big pile of PBTs, I'm thinking accelerate isn't what I want
2024-04-29 22:36:00 +0200tomsmedingruns `cabal run nofib-interpreter -f nofib`
2024-04-29 22:36:07 +0200 <tomsmeding> I don't think so
2024-04-29 22:36:21 +0200 <shapr> too bad, gotta pick another few candidates
2024-04-29 22:36:30 +0200 <tomsmeding> and as you may have gathered I don't have a good suggestion for you either
2024-04-29 22:36:49 +0200tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 272 seconds)
2024-04-29 22:37:02 +0200 <shapr> I wish I could write a SQL query against hackage
2024-04-29 22:37:20 +0200 <tomsmeding> download all the sources and grep
2024-04-29 22:37:23 +0200 <shapr> I want to find all direct depends on QuickCheck or Hedgehog, and extract the repository value
2024-04-29 22:37:26 +0200 <tomsmeding> iirc people have done that before
2024-04-29 22:37:54 +0200 <shapr> then I can clone all the repos and use ripgrep to see how many modules depend on Hedgehog or QuickCheck
2024-04-29 22:38:48 +0200 <tomsmeding> https://packdeps.haskellers.com/reverse/QuickCheck
2024-04-29 22:41:17 +0200 <tomsmeding> the worst part about accelerate's nofib is that compiling the test suite takes ages
2024-04-29 22:42:11 +0200 <shapr> it doesn't take much time on my system
2024-04-29 22:42:16 +0200 <shapr> but the runtime is impressive
2024-04-29 22:42:23 +0200 <shapr> I dunno why it's only running on two cores though
2024-04-29 22:42:52 +0200 <tomsmeding> nofib-interpreter on current accelerate master takes 25 seconds for me
2024-04-29 22:42:54 +0200dsrt^(~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Remote host closed the connection)
2024-04-29 22:44:40 +0200 <shapr> many years later, I have published sandwatch: https://hackage.haskell.org/package/sandwatch-0.1.1.0
2024-04-29 22:44:58 +0200 <shapr> oops, I forgot to add a source repo section *sigh*
2024-04-29 22:45:05 +0200cashew(~cashewsta@65.17.175.150) (Remote host closed the connection)
2024-04-29 22:45:14 +0200 <shapr> https://github.com/shapr/sandwatch
2024-04-29 22:45:32 +0200 <tomsmeding> shapr: what took 60 GB for you?
2024-04-29 22:45:38 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 22:45:52 +0200 <shapr> nofib is still running, three hours later
2024-04-29 22:45:57 +0200 <shapr> and it's taking 60 GB of ram
2024-04-29 22:46:13 +0200shaprshrugs
2024-04-29 22:46:13 +0200 <tomsmeding> it finishes in about 25.5 seconds for me with a maximum resident set size of 102 MB
2024-04-29 22:46:18 +0200 <shapr> oh wow
2024-04-29 22:46:27 +0200 <tomsmeding> there is something wrong with what's happening for you
2024-04-29 22:46:30 +0200 <shapr> I'm using ghc 9.6.3
2024-04-29 22:46:44 +0200 <tomsmeding> 9.4.7 for me, lemme do 9.6.4
2024-04-29 22:46:57 +0200 <tomsmeding> (need to build the world first)
2024-04-29 22:47:01 +0200 <shapr> I'm using 5ceb2da5d9ddc4ea0a5705d46bf4de9321ba17da
2024-04-29 22:47:11 +0200 <shapr> April 9 2024, merge by you
2024-04-29 22:47:23 +0200 <tomsmeding> ok you miss one commit but that commit is irrelevant if you're not using -fdebug
2024-04-29 22:47:28 +0200 <tomsmeding> so looks good
2024-04-29 22:47:58 +0200 <shapr> I am using --enable-coverage and --enable-tests
2024-04-29 22:48:00 +0200 <shapr> so that might be it
2024-04-29 22:48:17 +0200 <tomsmeding> hm I'm not doing --enable-coverage
2024-04-29 22:48:28 +0200 <tomsmeding> lemme try without first
2024-04-29 22:48:32 +0200 <shapr> I'm improving my kudzu library that uses HPC at runtime to decide when to stop iterating on a PBT
2024-04-29 22:48:46 +0200 <tomsmeding> is that sound?
2024-04-29 22:48:48 +0200cashew(~cashewsta@65.17.175.150) (Remote host closed the connection)
2024-04-29 22:48:50 +0200 <shapr> sound?
2024-04-29 22:49:13 +0200 <shapr> I convert hpc's regions into a count of "regions that have been executed"
2024-04-29 22:49:23 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 22:49:28 +0200 <shapr> run a test, if the region count increases, keep going
2024-04-29 22:49:53 +0200 <shapr> right now I'm using 40 for the number of tests to run without new region execution
2024-04-29 22:50:16 +0200 <shapr> but I have no way to know if that's too high or low, so I want to try different sizes on a few different projects
2024-04-29 22:50:30 +0200 <shapr> https://www.scannedinavian.com/run-property-tests-until-coverage-stops-increasing.html
2024-04-29 22:50:39 +0200 <shapr> I forgot to link to the actual code in that blog post :-|
2024-04-29 22:50:47 +0200 <shapr> https://github.com/shapr/kudzu/
2024-04-29 22:51:06 +0200 <shapr> tomsmeding: can you think of a way that could be unsound?
2024-04-29 22:52:58 +0200 <tomsmeding> > quickCheck $ \(Positive x) -> round (2.000000001 ** fromIntegral (x :: Int) / 1e6) == (round (2 ^ x / 1e6) :: Int)
2024-04-29 22:53:00 +0200 <lambdabot> error:
2024-04-29 22:53:00 +0200 <lambdabot> • Couldn't match expected type ‘Test.QuickCheck.Random.QCGen’
2024-04-29 22:53:00 +0200 <lambdabot> with actual type ‘Positive Int -> Bool’
2024-04-29 22:53:08 +0200 <tomsmeding> blegh, runs in my ghci
2024-04-29 22:53:16 +0200 <tomsmeding> fails at x = 45
2024-04-29 22:53:26 +0200 <tomsmeding> clearly this is a constructed example
2024-04-29 22:53:43 +0200 <tomsmeding> but my point is that equalities can fail to hold without any conditionals, but seem to be fine for small inputs
2024-04-29 22:54:17 +0200 <int-e> @check \(Positive x) -> round (2.000000001 ** fromIntegral (x :: Int) / 1e6) == (round (2 ^ x / 1e6) :: Int)
2024-04-29 22:54:19 +0200 <lambdabot> *** Failed! Falsifiable (after 60 tests and 2 shrinks):
2024-04-29 22:54:19 +0200 <lambdabot> Positive {getPositive = 58}
2024-04-29 22:55:07 +0200 <tomsmeding> > find (\x -> round (2.000000001 ** fromIntegral (x :: Int) / 1e6) /= (round (2 ^ x / 1e6) :: Int)) [1..]
2024-04-29 22:55:08 +0200 <lambdabot> Just 45
2024-04-29 22:55:17 +0200 <int-e> (it's *not* QuickCheck because QuickCheck tests embed IO)
2024-04-29 22:55:30 +0200 <tomsmeding> ah right
2024-04-29 22:55:46 +0200mei(~mei@user/mei) (Remote host closed the connection)
2024-04-29 22:56:15 +0200 <tomsmeding> (grr, --enable-coverage rebuilds the world again)
2024-04-29 22:57:14 +0200 <tomsmeding> shapr: https://math.stackexchange.com/a/111939/68044
2024-04-29 22:57:50 +0200cashew(~cashewsta@65.17.175.150) (Ping timeout: 245 seconds)
2024-04-29 22:58:10 +0200mei(~mei@user/mei)
2024-04-29 22:58:39 +0200shaprthinks about that
2024-04-29 22:59:02 +0200 <tomsmeding> your heuristic might be very useful and applicable in practical cases
2024-04-29 22:59:08 +0200 <tomsmeding> I'm not saying it's a bad idea
2024-04-29 22:59:17 +0200 <tomsmeding> I'm just saying that it's a heuristic, and it's not completely sound
2024-04-29 22:59:22 +0200 <shapr> oh, I agree with that
2024-04-29 22:59:32 +0200 <shapr> I think that also holds true for property based testing
2024-04-29 22:59:48 +0200 <shapr> PBT isn't proof by exhaustion or SMT solver
2024-04-29 23:00:11 +0200 <tomsmeding> true, though adding a more intelligent stopping criterion to PBT sounds like that stopping criterion should give stronger guarantees than "let's do 100 tests"
2024-04-29 23:01:02 +0200 <tomsmeding> it does tell you something in the opposite case, though: if you've exhausted your test budget but you haven't achieved coverage, maybe you need to think about your test case distribution
2024-04-29 23:01:10 +0200 <tomsmeding> that would be the selling point for me
2024-04-29 23:01:16 +0200 <shapr> Kudzu's stopping criterion is "hpc did not observe new coverage for N iterations of this PBT"
2024-04-29 23:01:16 +0200tomsmedinghasn't read your post yet
2024-04-29 23:01:29 +0200 <mwnaylor> Building ghc w/ slapt-src. Aliased python to python3. Piping stdout and stderr to separate files to save the results. Will share results when complete.
2024-04-29 23:01:32 +0200 <tomsmeding> with some hard maximum, presumably
2024-04-29 23:01:52 +0200 <shapr> There isn't a hard maximum, but I can't imagine a case where that would be a problem
2024-04-29 23:01:59 +0200shaprthinks
2024-04-29 23:02:12 +0200 <shapr> I don't think it's possible
2024-04-29 23:02:30 +0200 <tomsmeding> hm right, test duration is at most linear in your code size
2024-04-29 23:02:46 +0200 <tomsmeding> but what I would be most interested in is the coverage report after testing
2024-04-29 23:03:08 +0200 <shapr> I gave a lightning talk on Kudzu at ICFP 2022 and John Hughes brought up the point that he would prefer to see coverage defined not as "executed once" but instead "executed at least N times"
2024-04-29 23:03:18 +0200 <tomsmeding> meh
2024-04-29 23:03:19 +0200 <shapr> tomsmeding: yes! that's what I want to do next!
2024-04-29 23:03:34 +0200 <shapr> tomsmeding: Hughes' point is that many functions are reached through multiple code paths
2024-04-29 23:03:35 +0200 <tomsmeding> that does something about my unsoundness complaint but doesn't solve it
2024-04-29 23:03:51 +0200 <tomsmeding> that's a complaint about the coverage metric
2024-04-29 23:03:58 +0200 <tomsmeding> how path-sensitive is your coverage
2024-04-29 23:03:59 +0200 <shapr> I've been thinking about how to identify code paths, but I dunno yet
2024-04-29 23:04:14 +0200 <tomsmeding> sure, path-insensitive coverage tracking is overly optimistic, that's known
2024-04-29 23:04:33 +0200 <tomsmeding> but path-sensitive coverage tracking, while more accurate, is very depressing to test with
2024-04-29 23:04:39 +0200 <shapr> how so?
2024-04-29 23:04:49 +0200 <shapr> because it shows you how few paths are executed?
2024-04-29 23:05:07 +0200 <tomsmeding> bajeezus nofib-interpreter has just finished building and started executing with --enable-coverage and this is at least 1e4 times slower
2024-04-29 23:05:17 +0200 <tomsmeding> there's your problem for sure
2024-04-29 23:05:41 +0200 <tomsmeding> it didn't even finish the third case in the time I previously did the whole suite
2024-04-29 23:05:46 +0200 <tomsmeding> shapr: yes
2024-04-29 23:05:47 +0200 <shapr> I require coverage info for kudzu, that's what got me here
2024-04-29 23:06:00 +0200 <tomsmeding> this feels like a bug in coverage tracking
2024-04-29 23:06:02 +0200 <shapr> it's at three hours five minutes
2024-04-29 23:06:05 +0200 <shapr> I dunno
2024-04-29 23:06:22 +0200 <tomsmeding> is it progressing, or has it stalled somewhere?
2024-04-29 23:06:42 +0200 <shapr> I can't tell
2024-04-29 23:06:50 +0200 <shapr> it hasn't increased memory usage
2024-04-29 23:06:51 +0200 <tomsmeding> what's the case it's currently doing
2024-04-29 23:07:01 +0200 <tomsmeding> did that change in the past hour
2024-04-29 23:07:01 +0200 <shapr> it's not printing anything to stdout, I don't know
2024-04-29 23:07:16 +0200 <tomsmeding> are you running `cabal test` without `--test-show-details=direct`
2024-04-29 23:07:18 +0200 <shapr> memory did increase from 30GB ram to 60GB ram in the past hour
2024-04-29 23:07:19 +0200 <tomsmeding> classic beginner mistake
2024-04-29 23:07:21 +0200 <shapr> haha
2024-04-29 23:07:30 +0200 <shapr> I know about --test-show-details=direct but I was hoping it would just do the thing :-)
2024-04-29 23:07:33 +0200 <tomsmeding> I despise `cabal test`
2024-04-29 23:07:38 +0200 <tomsmeding> for one reason -- this one
2024-04-29 23:07:41 +0200 <shapr> I don't actually want to know what it's doing, I want the coverage info
2024-04-29 23:07:54 +0200 <tomsmeding> I guess it might print to the log file
2024-04-29 23:08:01 +0200 <shapr> I might as well kill it, it won't help me get closer to my goal
2024-04-29 23:08:13 +0200 <tomsmeding> send me the log file if you will
2024-04-29 23:08:25 +0200 <shapr> where's the log file?
2024-04-29 23:08:39 +0200 <tomsmeding> doesn't `cabal test` say something like "writing output to XXX.log"?
2024-04-29 23:09:34 +0200 <shapr> I only see that for doctest
2024-04-29 23:09:38 +0200 <shapr> and that one passed quickly
2024-04-29 23:10:19 +0200tomsmedinghates cabal test even more
2024-04-29 23:10:24 +0200shaprshrugs
2024-04-29 23:10:27 +0200 <tomsmeding> at it prints the log location when it's done
2024-04-29 23:10:34 +0200 <shapr> oh
2024-04-29 23:10:43 +0200 <tomsmeding> dist-newstyle/build/.../test/*-test.log
2024-04-29 23:10:45 +0200andrewboltachev(~andrewbol@178.141.238.156) (Quit: Client closed)
2024-04-29 23:10:58 +0200 <tomsmeding> find dist-newstyle/ -name '*-test.log'
2024-04-29 23:11:25 +0200 <shapr> doctest.log is the only file
2024-04-29 23:11:33 +0200 <shapr> so either it's not writing to the file, or it writes at the end
2024-04-29 23:11:44 +0200 <shapr> I can re-run with --test-show-details=direct if you want
2024-04-29 23:11:45 +0200 <tomsmeding> it doesn't even write the file until it's done?
2024-04-29 23:11:47 +0200 <tomsmeding> can `cabal test` die
2024-04-29 23:12:07 +0200 <tomsmeding> try `cabal run nofib-accelerate -f nofib --enable-coverage`
2024-04-29 23:12:12 +0200 <tomsmeding> at least then you know what you're getting :p
2024-04-29 23:12:15 +0200 <shapr> heh, ok
2024-04-29 23:12:45 +0200 <tomsmeding> does it spin infinitely on one case or does it progress super slowly
2024-04-29 23:14:03 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 23:14:44 +0200 <shapr> looks like it sticks on "sort:"
2024-04-29 23:15:47 +0200 <tomsmeding> surely this is a bug somewhere
2024-04-29 23:15:53 +0200 <shapr> I'd believe that
2024-04-29 23:16:16 +0200 <shapr> but again, doesn't help me poke at kudzu
2024-04-29 23:16:17 +0200 <tomsmeding> this is not even the backend, which does runtime code generation using LLVM
2024-04-29 23:16:46 +0200 <tomsmeding> (which HPC might actually be fine with considering that's just FFI calls in the end)
2024-04-29 23:17:20 +0200 <shapr> I'm using nixos, and LLVM is not in scope, could that be it?
2024-04-29 23:17:26 +0200 <shapr> I'd see an error, right?
2024-04-29 23:18:09 +0200 <tomsmeding> the LLVM stuff is in accelerate-llvm{,-native,-ptx}
2024-04-29 23:18:15 +0200 <tomsmeding> not in `accelerate`
2024-04-29 23:18:15 +0200 <shapr> ah, not a problem then
2024-04-29 23:18:25 +0200 <tomsmeding> the latter just has an interpreter in normal haskell
2024-04-29 23:18:53 +0200 <tomsmeding> the `accelerate` package itself is actually not anything special, it's just haskell
2024-04-29 23:18:58 +0200 <tomsmeding> I wonder why HPC is tripping on it
2024-04-29 23:19:16 +0200 <shapr> I would guess it's related to the specialize things in that bug report
2024-04-29 23:19:19 +0200 <shapr> but that's just a guess
2024-04-29 23:19:53 +0200 <tomsmeding> that there's just a huge amount of core, you mean?
2024-04-29 23:20:04 +0200 <shapr> that's my guess
2024-04-29 23:20:07 +0200 <tomsmeding> because compilation is definitely slow, but that's not the issue at hand here
2024-04-29 23:20:14 +0200 <shapr> iirc, hpc puts a counter on every little definition
2024-04-29 23:20:26 +0200 <shapr> now that you mention it, lemme check the size of the mix files
2024-04-29 23:20:34 +0200 <tomsmeding> does it do that at the source level or in core after optimisation
2024-04-29 23:20:42 +0200 <tomsmeding> if the former, then core size is irrelevant
2024-04-29 23:20:59 +0200 <tomsmeding> surely it's the former, you don't want core coverage, you want haskell coverage
2024-04-29 23:21:50 +0200 <shapr> wow, hpc produced a 440k mix file
2024-04-29 23:22:59 +0200 <shapr> 82kb source file turned into a 440kb mix file
2024-04-29 23:23:07 +0200tomsmedinghas no reference here
2024-04-29 23:23:11 +0200 <shapr> https://github.com/AccelerateHS/accelerate/blob/master/src/Data/Array/Accelerate/Test/NoFib/Issues…
2024-04-29 23:23:39 +0200 <tomsmeding> those are long arrays
2024-04-29 23:23:40 +0200 <shapr> tomsmeding: the mix file holds the list of regions that can be annotated, it's later turned into the pretty html output: https://wiki.haskell.org/Haskell_program_coverage
2024-04-29 23:23:52 +0200 <tomsmeding> I see
2024-04-29 23:24:28 +0200 <tomsmeding> so you'd expect that to scale about linearly with program text size divided by the average variable name length?
2024-04-29 23:24:55 +0200 <shapr> Well, you get more regions with more depth, but I wouldn't expect this sort of size explosion
2024-04-29 23:25:21 +0200cashew(~cashewsta@65.17.175.150) (Ping timeout: 252 seconds)
2024-04-29 23:25:48 +0200 <tomsmeding> but surely those regions are still about the source, not about the core?
2024-04-29 23:26:53 +0200 <shapr> yes, I wonder why the regions explode like that?
2024-04-29 23:27:07 +0200 <tomsmeding> what's in the file
2024-04-29 23:27:22 +0200 <tomsmeding> curl --data-binary @thefile.mix https://tomsmeding.com/gooi/file.mix
2024-04-29 23:27:29 +0200 <tomsmeding> (the '@' is syntax, put the filename after it)
2024-04-29 23:27:32 +0200 <shapr> right on
2024-04-29 23:28:28 +0200 <shapr> tomsmeding: sent!
2024-04-29 23:28:30 +0200 <tomsmeding> (and gimme the link :) )
2024-04-29 23:28:39 +0200 <shapr> https://tomsmeding.com/vang/WUaWIm/file.mix
2024-04-29 23:28:51 +0200 <tomsmeding> or I have to go and ssh into my server and look at the gooi directory and I'm too lazy for that
2024-04-29 23:28:58 +0200 <tomsmeding> you forgot the @
2024-04-29 23:29:20 +0200 <tomsmeding> you uploaded the file name, not the file :)
2024-04-29 23:29:22 +0200 <shapr> oops https://tomsmeding.com/vang/PJiBEz/file.mix
2024-04-29 23:30:11 +0200gmg(~user@user/gehmehgeh) (Remote host closed the connection)
2024-04-29 23:30:24 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 23:30:25 +0200 <tomsmeding> 440 kb of text without newlines
2024-04-29 23:30:42 +0200 <tomsmeding> vim only takes 1 second to move to end-of-line, I'm impressed
2024-04-29 23:31:07 +0200gmg(~user@user/gehmehgeh)
2024-04-29 23:31:41 +0200 <EvanR> I rotate my web-ready monitor from the 90s and vim suddenly finds such files easy
2024-04-29 23:32:11 +0200 <EvanR> argument from rotational symmetry
2024-04-29 23:34:28 +0200 <tomsmeding> shapr: every integer literal in those arrays is a separate ExpBox
2024-04-29 23:34:44 +0200 <tomsmeding> there's a lot of integer literals in that file
2024-04-29 23:35:05 +0200 <tomsmeding> but surely you can't break hpc just by putting a long list of ints in a file?
2024-04-29 23:36:16 +0200 <tomsmeding> 1218 regions on line 115, 1161 regions on line 172, with a long tail
2024-04-29 23:36:55 +0200 <tomsmeding> well not really, there's 12 lines with 800-1200 regions, then the rest is <=126
2024-04-29 23:37:00 +0200 <tomsmeding> er, 216
2024-04-29 23:37:33 +0200 <shapr> is this something to do with accelerate types? are they internall HList or something?
2024-04-29 23:38:02 +0200cashew(~cashewsta@65.17.175.150) (Ping timeout: 268 seconds)
2024-04-29 23:38:10 +0200 <tomsmeding> if you just write `foo :: [Int] ; foo = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]` in a file
2024-04-29 23:38:16 +0200 <tomsmeding> doesn't every one of those ints get a separate region?
2024-04-29 23:38:24 +0200 <tomsmeding> this file just has thousands of ints
2024-04-29 23:38:34 +0200 <shapr> I would guess, yes
2024-04-29 23:38:37 +0200 <tomsmeding> accelerate arrays are certainly not hlists
2024-04-29 23:38:39 +0200 <tomsmeding> the _shapes_ are
2024-04-29 23:38:48 +0200 <shapr> because part of the goal of HPC is to tell you which parts of your program did anything
2024-04-29 23:38:53 +0200 <tomsmeding> i.e. a three-dimensional array has its shape (three ints) in a hlist-like structure
2024-04-29 23:38:58 +0200 <tomsmeding> right
2024-04-29 23:39:14 +0200 <tomsmeding> so this is not anything accelerate-specific, this file is just a bit heavy on the int literals
2024-04-29 23:39:17 +0200 <shapr> yup
2024-04-29 23:40:16 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2024-04-29 23:42:28 +0200 <shapr> tomsmeding: do you run many long running Haskell compiles? Would you like to know how long they might take? Try sandwatch! https://github.com/shapr/sandwatch
2024-04-29 23:42:48 +0200 <shapr> Similarly, would you like to know the instant a long running compile has ended? try bloohm! https://github.com/shapr/bloohm
2024-04-29 23:42:56 +0200 <shapr> (hardware purchase required for bloohm)
2024-04-29 23:42:57 +0200ocra8(ocra8@user/ocra8) (Quit: WeeChat 4.2.2)
2024-04-29 23:43:04 +0200 <tomsmeding> heh
2024-04-29 23:43:24 +0200 <tomsmeding> I try to not get blocked on haskell compiles and mostly succeed
2024-04-29 23:43:31 +0200 <tomsmeding> of course not always
2024-04-29 23:43:37 +0200 <shapr> impressive
2024-04-29 23:44:19 +0200 <shapr> friend of mine rewrote bloohm in rust, with a small gif https://mclare.blog/posts/adapting-a-bloom-filter-to-rust/
2024-04-29 23:44:19 +0200mreh(~matthew@host86-160-168-68.range86-160.btcentralplus.com) (Ping timeout: 246 seconds)
2024-04-29 23:44:39 +0200 <shapr> tomsmeding: so basically, not a compiler bug worth reporting
2024-04-29 23:44:44 +0200 <shapr> thanks for talking that out with me
2024-04-29 23:45:10 +0200 <tomsmeding> I mean, the getting stuck on sort has little to do with Issue119 producing a large mix file, I hope?
2024-04-29 23:45:14 +0200ocra8(ocra8@user/ocra8)
2024-04-29 23:45:14 +0200 <tomsmeding> that would be a bug I'd say
2024-04-29 23:45:28 +0200 <shapr> hm
2024-04-29 23:45:29 +0200 <shapr> probably so
2024-04-29 23:45:44 +0200 <tomsmeding> but yeah, accelerate is dearly understaffed for the care that it needs
2024-04-29 23:45:51 +0200 <tomsmeding> I try to help by being liaison here :)
2024-04-29 23:46:09 +0200 <shapr> heh, I pair with Josh once a week, that's how I got started with accelerate
2024-04-29 23:46:15 +0200 <shapr> but it's not the PBT suite I want :-(
2024-04-29 23:46:27 +0200 <tomsmeding> gif is cool
2024-04-29 23:46:34 +0200 <tomsmeding> fun electronics is cool
2024-04-29 23:47:09 +0200 <shapr> Speaking of which, serialport needs some improvement, the test suite should not require an attached arduino
2024-04-29 23:47:13 +0200 <shapr> @hackage serialport
2024-04-29 23:47:13 +0200 <lambdabot> https://hackage.haskell.org/package/serialport
2024-04-29 23:47:33 +0200 <shapr> but I dunno how to create a virtual serial port in software
2024-04-29 23:48:25 +0200tomsmedinghides
2024-04-29 23:48:31 +0200 <shapr> do you know how?!
2024-04-29 23:48:35 +0200 <tomsmeding> no!
2024-04-29 23:48:38 +0200 <shapr> yeah, me neither
2024-04-29 23:48:50 +0200 <tomsmeding> I know nothing about how serial ports work, nor about emulating hardware, let alone the combination
2024-04-29 23:49:05 +0200 <shapr> I know some, not as much as I need, and more than I want
2024-04-29 23:49:10 +0200 <tomsmeding> :D
2024-04-29 23:49:39 +0200 <geekosaur> run it under vbox 😛
2024-04-29 23:49:53 +0200 <shapr> I'm thinking about adding a parameter to bloohm for "number of pixels" then I can use it with any RGB grid.
2024-04-29 23:50:15 +0200 <shapr> We sort of got it working on the keyboard.io : https://mclare.blog/posts/making-a-bloom-filter-keyboard/
2024-04-29 23:50:59 +0200cashew(~cashewsta@65.17.175.150)
2024-04-29 23:53:02 +0200 <tomsmeding> shapr: edsko wrote 'falsify', a new PBT library, so perhaps he has ideas on stuff that uses PBT a lot
2024-04-29 23:53:14 +0200 <tomsmeding> hoping that it's not all proprietary code that he saw through consulting
2024-04-29 23:54:23 +0200 <shapr> edsko was in the audience for my lightning talk
2024-04-29 23:54:47 +0200 <shapr> I don't remember all the questions that were asked, and that part of the ICFP talk videos hasn't been published :-(
2024-04-29 23:56:36 +0200 <tomsmeding> oh sad
2024-04-29 23:56:38 +0200 <tomsmeding> which icfp was this?
2024-04-29 23:56:50 +0200 <tomsmeding> this year, seattle?
2024-04-29 23:56:52 +0200 <shapr> the past one in seattle
2024-04-29 23:56:58 +0200 <tomsmeding> right, I wasn't there
2024-04-29 23:58:10 +0200 <tomsmeding> every conference's recording seems to have _something_ that goes wrong
2024-04-29 23:58:19 +0200 <tomsmeding> maybe there's just too many things that can fail
2024-04-29 23:59:38 +0200oo_miguel(~Thunderbi@78-11-181-16.static.ip.netia.com.pl) (Ping timeout: 256 seconds)