IRCBrowse

2023/02/20

2023-02-20 00:00:36 +0100 <jackdk> "reversible"? only if every function you use has a retraction, I suppose?
2023-02-20 00:01:20 +0100Me-me(~me-me@user/me-me) (Quit: Disconnecting on purpose.)
2023-02-20 00:01:42 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 00:01:50 +0100Midjak(~Midjak@82.66.147.146) (Quit: This computer has gone to sleep)
2023-02-20 00:03:25 +0100Me-me(~me-me@2602:ff16:3:0:1:dc:beef:d00d)
2023-02-20 00:04:41 +0100 <EvanR> functional programs can look like random noise just fine
2023-02-20 00:06:04 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) (Ping timeout: 252 seconds)
2023-02-20 00:09:50 +0100falafel(~falafel@2607:fb91:143f:e47f:7da8:d9be:52c3:2939)
2023-02-20 00:17:42 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 00:18:03 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:bc09:17b4:a9c9:5fe5)
2023-02-20 00:18:22 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-02-20 00:22:01 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) (Ping timeout: 252 seconds)
2023-02-20 00:26:47 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-02-20 00:26:47 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-02-20 00:26:47 +0100wroathe(~wroathe@user/wroathe)
2023-02-20 00:33:58 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-02-20 00:35:44 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 00:40:08 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) (Ping timeout: 255 seconds)
2023-02-20 00:45:40 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 252 seconds)
2023-02-20 00:52:19 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 00:56:47 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) (Ping timeout: 255 seconds)
2023-02-20 00:58:07 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 01:01:20 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-02-20 01:02:35 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) (Ping timeout: 260 seconds)
2023-02-20 01:04:16 +0100Axma23822Axman6
2023-02-20 01:14:53 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 01:16:34 +0100czy(~user@host-140-26.ilcub310.champaign.il.us.clients.pavlovmedia.net)
2023-02-20 01:17:29 +0100AlexZenon(~alzenon@178.34.160.79) (Ping timeout: 255 seconds)
2023-02-20 01:17:56 +0100Alex_test(~al_test@178.34.160.79) (Ping timeout: 255 seconds)
2023-02-20 01:18:24 +0100AlexNoo(~AlexNoo@178.34.160.79) (Ping timeout: 255 seconds)
2023-02-20 01:18:49 +0100mauke_(~mauke@user/mauke)
2023-02-20 01:19:13 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) (Ping timeout: 252 seconds)
2023-02-20 01:19:51 +0100mauke(~mauke@user/mauke) (Ping timeout: 255 seconds)
2023-02-20 01:19:51 +0100mauke_mauke
2023-02-20 01:20:20 +0100cassaundra(~cassaundr@c-73-25-18-25.hsd1.or.comcast.net)
2023-02-20 01:26:53 +0100acidjnk(~acidjnk@2003:d6:e715:c436:2c63:9e78:5d9e:e9c9) (Ping timeout: 252 seconds)
2023-02-20 01:28:10 +0100kee(~~kee@user/wizzwizz4) (Ping timeout: 268 seconds)
2023-02-20 01:28:33 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) (Quit: Leaving.)
2023-02-20 01:28:47 +0100 <gurkenglas> Found a GHC panic! "a :: (a => b c) -> d b; a b = (undefined :: x -> y x) (b undefined)" in 9.4.4
2023-02-20 01:28:49 +0100mikoto-chan(~mikoto-ch@85-76-71-143-nat.elisa-mobile.fi)
2023-02-20 01:30:30 +0100 <gurkenglas> With bonus points: Replace the c with another a, and instead of a panic you get a burning CPU x)
2023-02-20 01:31:23 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 01:31:33 +0100 <gurkenglas> oh, and then your RAM falls off
2023-02-20 01:32:09 +0100kee(~~kee@user/wizzwizz4)
2023-02-20 01:33:20 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds)
2023-02-20 01:35:56 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) (Ping timeout: 255 seconds)
2023-02-20 01:36:09 +0100k33(~~kee@user/wizzwizz4)
2023-02-20 01:36:57 +0100kee(~~kee@user/wizzwizz4) (Ping timeout: 255 seconds)
2023-02-20 01:44:30 +0100sagax(~sagax_nb@user/sagax) (Quit: Konversation terminated!)
2023-02-20 01:46:27 +0100merijn(~merijn@c-001-001-009.client.esciencecenter.eduvpn.nl)
2023-02-20 01:47:41 +0100k33kee
2023-02-20 01:49:11 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 01:50:47 +0100meinside(uid24933@id-24933.helmsley.irccloud.com)
2023-02-20 01:51:00 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-02-20 01:51:14 +0100merijn(~merijn@c-001-001-009.client.esciencecenter.eduvpn.nl) (Ping timeout: 255 seconds)
2023-02-20 01:52:35 +0100 <albet70> how to compile with static ?
2023-02-20 01:53:32 +0100 <albet70> I use cabal build a binary file, and copy on other machine, one said missing libffi.so.6, another said missing libc.so.6
2023-02-20 01:53:51 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) (Ping timeout: 248 seconds)
2023-02-20 01:54:05 +0100 <albet70> how I can pack all the dependent so file into that one giant binary file?
2023-02-20 01:54:09 +0100 <geekosaur> ghc defaults to static for Haskell libraries. compiling anything else static requires you build on alpine with musl, especially if yoiu want static libc (glibc does not support static linking, period)
2023-02-20 01:56:02 +0100 <geekosaur> (people often static link with glibc. it works if and only if all the dynaically loaded shared objects for NSS, locales, etc. are present on the target in the expected places *and* happen to be sufficiently compatible with the statically linked glibc)
2023-02-20 01:56:57 +0100 <geekosaur> and especially if some system does not have libc.so.6 you are just plain out of luck on that system unless you find and install glibc on it
2023-02-20 01:57:35 +0100 <albet70> geekosaur , because the version of libc isn't right
2023-02-20 01:57:58 +0100opticblast(~Thunderbi@172.58.85.230) (Remote host closed the connection)
2023-02-20 01:58:04 +0100 <geekosaur> all versions of glibc use libc.so.6; the versioning is done by version tags within the shared object
2023-02-20 01:59:22 +0100 <geekosaur> if you do not have libc.so.6 then you do not have glibc on that system; it's probably using musl or some other alternative libc
2023-02-20 01:59:27 +0100 <albet70> where I can find an alpine for compile?
2023-02-20 01:59:42 +0100 <geekosaur> usually you use a docker image
2023-02-20 02:00:23 +0100 <geekosaur> https://hub.docker.com/_/alpine https://www.docker.com/blog/how-to-use-the-alpine-docker-official-image/
2023-02-20 02:01:09 +0100 <albet70> wait a second, I do compile it in a charoot env, how about pack the chroot env?
2023-02-20 02:01:24 +0100 <albet70> is that gonna work, chroot has the so files
2023-02-20 02:01:52 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-02-20 02:02:06 +0100 <albet70> racket has a tool could pack those binary and so files into a directory, and just use it
2023-02-20 02:02:47 +0100 <geekosaur> that tool probably works with anything, not just racket, if you want to risk it
2023-02-20 02:02:56 +0100califax(~califax@user/califx)
2023-02-20 02:02:58 +0100 <geekosaur> I'm telling you the safe way to do it
2023-02-20 02:03:38 +0100 <geekosaur> if you don'[t care about safety, find a tool to bundle shared objects and hope you got them all, or even just `ghc-options: -Wl-static` and hope the result doesn't crash
2023-02-20 02:04:17 +0100 <albet70> cabal doesn't provide that function?
2023-02-20 02:04:23 +0100 <geekosaur> no
2023-02-20 02:04:34 +0100 <geekosaur> cabal believes in safety
2023-02-20 02:05:19 +0100 <albet70> because most package are hidden, so ghc won't find a lot package that installed not by system package
2023-02-20 02:05:23 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 02:06:00 +0100 <albet70> config depends in cabal config can let me use that packages
2023-02-20 02:09:41 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) (Ping timeout: 255 seconds)
2023-02-20 02:10:19 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-02-20 02:11:31 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-02-20 02:15:43 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 248 seconds)
2023-02-20 02:16:32 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-02-20 02:21:43 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 02:23:15 +0100gpncarl(~gpncarl@222.249.231.4)
2023-02-20 02:25:12 +0100slack1256(~slack1256@191.125.227.71)
2023-02-20 02:26:19 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) (Ping timeout: 252 seconds)
2023-02-20 02:33:28 +0100mikoto-chan(~mikoto-ch@85-76-71-143-nat.elisa-mobile.fi) (Ping timeout: 252 seconds)
2023-02-20 02:35:21 +0100xff0x(~xff0x@2405:6580:b080:900:2ba9:89b5:e4d8:5d14) (Ping timeout: 255 seconds)
2023-02-20 02:38:09 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 02:40:03 +0100cheater(~Username@user/cheater) (Remote host closed the connection)
2023-02-20 02:42:49 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) (Ping timeout: 252 seconds)
2023-02-20 02:42:52 +0100slac56924(~slack1256@186.11.53.84)
2023-02-20 02:44:34 +0100gpncarl_(~gpncarl@210.12.195.2)
2023-02-20 02:44:54 +0100slack1256(~slack1256@191.125.227.71) (Ping timeout: 255 seconds)
2023-02-20 02:45:48 +0100gpncarl(~gpncarl@222.249.231.4) (Ping timeout: 255 seconds)
2023-02-20 02:51:42 +0100gpncarl(~gpncarl@222.249.231.4)
2023-02-20 02:54:08 +0100gpncarl_(~gpncarl@210.12.195.2) (Ping timeout: 248 seconds)
2023-02-20 02:54:46 +0100gurkenglas(~gurkengla@dynamic-046-114-178-211.46.114.pool.telefonica.de) (Ping timeout: 246 seconds)
2023-02-20 02:55:00 +0100gpncarl_(~gpncarl@222.249.231.4)
2023-02-20 02:56:30 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 02:56:36 +0100gpncarl(~gpncarl@222.249.231.4) (Ping timeout: 255 seconds)
2023-02-20 03:01:03 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) (Ping timeout: 248 seconds)
2023-02-20 03:05:48 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 03:09:32 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-02-20 03:10:38 +0100gehmehgeh(~user@user/gehmehgeh)
2023-02-20 03:11:53 +0100gmg(~user@user/gehmehgeh) (Ping timeout: 255 seconds)
2023-02-20 03:13:40 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 246 seconds)
2023-02-20 03:22:15 +0100hrberg(~quassel@171.79-160-161.customer.lyse.net) (Ping timeout: 255 seconds)
2023-02-20 03:24:08 +0100hrberg(~quassel@171.79-160-161.customer.lyse.net)
2023-02-20 03:24:17 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-02-20 03:24:57 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 255 seconds)
2023-02-20 03:26:07 +0100hsw(~hsw@2001:b030:2303:104:172:25:12:132)
2023-02-20 03:26:39 +0100eruditass(uid248673@id-248673.uxbridge.irccloud.com) ()
2023-02-20 03:28:44 +0100robobub(uid248673@2a03:5180:f:5::3:cb61)
2023-02-20 03:29:07 +0100oxide(~lambda@user/oxide) (Quit: oxide)
2023-02-20 03:29:53 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds)
2023-02-20 03:32:56 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-02-20 03:34:31 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Remote host closed the connection)
2023-02-20 03:37:53 +0100falafel(~falafel@2607:fb91:143f:e47f:7da8:d9be:52c3:2939) (Ping timeout: 255 seconds)
2023-02-20 03:41:39 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) (Remote host closed the connection)
2023-02-20 03:45:18 +0100prasadi01Newuser(~Thunderbi@c-73-22-232-123.hsd1.il.comcast.net)
2023-02-20 03:46:41 +0100razetime(~Thunderbi@117.193.2.7)
2023-02-20 03:47:00 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-20 03:47:54 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-02-20 03:51:44 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 03:51:57 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 255 seconds)
2023-02-20 04:05:54 +0100cods(~fred@82-65-232-44.subs.proxad.net) (Ping timeout: 255 seconds)
2023-02-20 04:07:22 +0100 <albet70> in alpine, why cabal build using gcc not musl?
2023-02-20 04:10:40 +0100 <prasadi01Newuser> Hi, I need suggestion on how to solve the Number of Island problem. Here is the problem https://leetcode.com/problems/number-of-islands/. Given a grid with 1 and 0 if the "1" are adjacent it is counted as 1 island. Usually in Java I would iterate through each cell and if the adjacent cell is 1 turn it into 0 & increase the counter by 1 and the end return the counter. Need directions on how to start
2023-02-20 04:14:00 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) (Remote host closed the connection)
2023-02-20 04:25:05 +0100gehmehgeh(~user@user/gehmehgeh) (Remote host closed the connection)
2023-02-20 04:26:14 +0100gehmehgeh(~user@user/gehmehgeh)
2023-02-20 04:27:11 +0100dibblego(~dibblego@haskell/developer/dibblego) (Ping timeout: 264 seconds)
2023-02-20 04:30:28 +0100 <sm> prasadi01Newuser: an easier and more typical way in haskell would be to `filter` just the 1s and then count them with `length`
2023-02-20 04:32:55 +0100 <jackdk> sm: needs to count the islands but - with a mutable language I'd probably floodfill each island into water while incrementing the count
2023-02-20 04:34:24 +0100 <prasadi01Newuser> jackdk: That's the solution I have for imperative implementation. If I find 1's I go through all the adjacent cells which has 1's. Basically DFS on each cell converting it to 0
2023-02-20 04:35:21 +0100 <jackdk> look honestly I'd probably go full "Haskell is my favourite imperative language" and use a mutable array in the ST monad.
2023-02-20 04:35:36 +0100razetime(~Thunderbi@117.193.2.7) (Ping timeout: 255 seconds)
2023-02-20 04:36:09 +0100 <jackdk> There is probably some elegant solution where you annotate each cell with the number of islands you know about and merge them using `max`, but I can't figure out the best way to handle water
2023-02-20 04:36:57 +0100 <jackdk> There might be some cool comonadic solution a la the game of life comonadic solutions, but I don't know what that looks like either
2023-02-20 04:37:16 +0100 <sm> I misread, sorry
2023-02-20 04:38:12 +0100 <prasadi01Newuser> I am struggling with Grid based problem like Game of Life and Number of Island
2023-02-20 04:38:55 +0100dibblego(~dibblego@122-199-1-30.ip4.superloop.com)
2023-02-20 04:38:55 +0100dibblego(~dibblego@122-199-1-30.ip4.superloop.com) (Changing host)
2023-02-20 04:38:55 +0100dibblego(~dibblego@haskell/developer/dibblego)
2023-02-20 04:39:02 +0100 <jackdk> you could maybe implement this with a scan - look to the elements (up 1) and (left 1) of the cell you're looking at. If either of those are land, you know you're connected to an existing island. If both are water, start a new island. That would let you turn a `[[Terrain]]` into `[[(Terrain, Int)]]`, where the ints are the last know island number
2023-02-20 04:39:11 +0100 <jackdk> and then return the final one
2023-02-20 04:39:39 +0100wroathe(~wroathe@user/wroathe) (Quit: leaving)
2023-02-20 04:42:05 +0100 <c_wraith> I'm a weirdo and would just union-find it
2023-02-20 04:42:18 +0100 <jackdk> if you're learning Haskell, I would stuff the "array" into a `Map (Int, Int) whatever` (from package `containers`) and pass it around all your functions. Then depending on how much you want to flex, rewrite it to use the state monad, or `ST` and an actual mutable array.
2023-02-20 04:42:57 +0100 <jackdk> oh yeah right union-find!
2023-02-20 04:44:33 +0100 <c_wraith> (despite union-find being one of the most awkward things to encode in Haskell..)
2023-02-20 04:44:38 +0100gpncarl(~gpncarl@222.249.231.4)
2023-02-20 04:46:01 +0100gpncarl_(~gpncarl@222.249.231.4) (Ping timeout: 252 seconds)
2023-02-20 04:46:06 +0100 <jackdk> I mean that's what I was blindly grasping at when I was talking about "max-or-something"; you can implement dodgy union-find with an intmap or whatever
2023-02-20 04:46:07 +0100 <prasadi01Newuser> I am not sure about union-find But I guess Map would be better option to maintain list of the already visited node which has 1's
2023-02-20 04:46:59 +0100 <prasadi01Newuser> And increase the counter when a new island is detected
2023-02-20 04:48:47 +0100td_(~td@i5387093b.versanet.de) (Ping timeout: 248 seconds)
2023-02-20 04:50:34 +0100td_(~td@i5387093A.versanet.de)
2023-02-20 04:52:14 +0100 <jackdk> yeah so you should look up union-find if you're doing algorithmic study because it's really cool. Then your problem simplifies to: Scan through the world. At each land node, generate a new set containing just that piece of land, and union it with any sets that exist either north or west of it. When you're done, scan your union-find structure and count the non-redundant nodes.
2023-02-20 04:54:14 +0100 <Hammdist> I always wondered how you implement union find efficiently in FP since the path compression basically requires mutation
2023-02-20 04:54:40 +0100 <jackdk> https://hackage.haskell.org/package/union-find seems to do it either with intmap or ST
2023-02-20 04:55:20 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-02-20 04:55:20 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-02-20 04:55:20 +0100finn_elijaFinnElija
2023-02-20 04:57:40 +0100prasadi01Newuser(~Thunderbi@c-73-22-232-123.hsd1.il.comcast.net) (Quit: prasadi01Newuser)
2023-02-20 04:57:53 +0100prasadi01Newuser(~Thunderbi@c-73-22-232-123.hsd1.il.comcast.net)
2023-02-20 04:58:57 +0100razetime(~Thunderbi@117.193.2.7)
2023-02-20 04:59:06 +0100jero98772(~jero98772@2800:484:1d80:d8ce:efcc:cbb3:7f2a:6dff) (Remote host closed the connection)
2023-02-20 05:01:16 +0100cheater(~Username@user/cheater)
2023-02-20 05:06:07 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-02-20 05:09:10 +0100p0lyph3m(~polyphem@2a02:810d:840:8754:4d31:9178:35f:6608) (Ping timeout: 246 seconds)
2023-02-20 05:10:23 +0100 <prasadi01Newuser> I think I can use Mutable Vector
2023-02-20 05:10:56 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-02-20 05:12:50 +0100slac56924(~slack1256@186.11.53.84) (Ping timeout: 255 seconds)
2023-02-20 05:14:45 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 255 seconds)
2023-02-20 05:22:44 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 255 seconds)
2023-02-20 05:25:16 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-02-20 05:29:23 +0100falafel(~falafel@2607:fb91:143f:e47f:1eff:7815:d8e4:34a9)
2023-02-20 05:29:42 +0100prasadi01Newuser(~Thunderbi@c-73-22-232-123.hsd1.il.comcast.net) (Quit: prasadi01Newuser)
2023-02-20 05:29:55 +0100prasadi01Newuser(~Thunderbi@c-73-22-232-123.hsd1.il.comcast.net)
2023-02-20 05:32:42 +0100justsomeguy(~justsomeg@user/justsomeguy)
2023-02-20 05:34:03 +0100gpncarl_(~gpncarl@222.249.231.4)
2023-02-20 05:34:06 +0100gpncarl(~gpncarl@222.249.231.4) (Ping timeout: 255 seconds)
2023-02-20 05:37:20 +0100razetime(~Thunderbi@117.193.2.7) (Ping timeout: 248 seconds)
2023-02-20 05:41:19 +0100 <EvanR> prasadi01Newuser, I used a Grid in many of the advent of code challenges. What Grid means depends on what it needs to do in that day
2023-02-20 05:42:25 +0100 <EvanR> maybe Map (Int,Int), maybe Array, maybe Vector
2023-02-20 05:42:49 +0100 <EvanR> have no run into something that screamed mutable array in ST or something
2023-02-20 05:47:18 +0100razetime(~Thunderbi@117.193.2.7)
2023-02-20 05:48:27 +0100merijn(~merijn@c-001-001-009.client.esciencecenter.eduvpn.nl)
2023-02-20 05:48:38 +0100 <prasadi01Newuser> EvanR: Thanks I would try that
2023-02-20 05:52:55 +0100merijn(~merijn@c-001-001-009.client.esciencecenter.eduvpn.nl) (Ping timeout: 246 seconds)
2023-02-20 05:53:53 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-02-20 05:53:58 +0100biberu(~biberu@user/biberu) (Read error: Connection reset by peer)
2023-02-20 05:58:17 +0100jinsun(~jinsun@user/jinsun) (Ping timeout: 255 seconds)
2023-02-20 05:58:30 +0100ubert(~Thunderbi@p200300ecdf1301aeed9235aafc85dd9a.dip0.t-ipconnect.de) (Remote host closed the connection)
2023-02-20 05:58:49 +0100ubert(~Thunderbi@p200300ecdf1301aeed9235aafc85dd9a.dip0.t-ipconnect.de)
2023-02-20 05:59:10 +0100biberu(~biberu@user/biberu)
2023-02-20 05:59:12 +0100prasadi01Newuser(~Thunderbi@c-73-22-232-123.hsd1.il.comcast.net) (Ping timeout: 246 seconds)
2023-02-20 06:02:51 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-02-20 06:03:36 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-02-20 06:06:21 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-02-20 06:07:25 +0100 <cheater> can someone suggest an rpc lib that'll let me call a function on a remote server, say via a socket, and give what that function returned? arg / return types i need are normal scalar types, as well as records. both the client and server are my haskell code.
2023-02-20 06:07:49 +0100 <cheater> i've been trying to use msgpack-rpc-conduit but i have no idea how to make it work with records.
2023-02-20 06:08:06 +0100p0lyph3m(~polyphem@95.91.253.85)
2023-02-20 06:08:34 +0100 <cheater> it's "experimental" though so wouldn't be surprised if it didn't support it at all. and there's zero documentation at all. i guessed all the usage from tests.
2023-02-20 06:17:24 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 246 seconds)
2023-02-20 06:18:48 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net)
2023-02-20 06:19:21 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-02-20 06:23:19 +0100_leo___(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-02-20 06:32:00 +0100trev(~trev@user/trev)
2023-02-20 06:48:27 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 252 seconds)
2023-02-20 06:51:46 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Quit: Leaving)
2023-02-20 07:01:39 +0100polyphem(~rod@2a02:810d:840:8754:224e:f6ff:fe5e:bc17) (Ping timeout: 252 seconds)
2023-02-20 07:03:59 +0100andrewboltachev(~andrey@178.141.125.176)
2023-02-20 07:04:06 +0100p0lyph3m(~polyphem@95.91.253.85) (Ping timeout: 255 seconds)
2023-02-20 07:13:09 +0100Inst(~Inst@2601:6c4:4081:54f0:254f:b13a:16f3:9f7c)
2023-02-20 07:22:20 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-02-20 07:27:04 +0100dsrt^(~dsrt@c-24-30-76-89.hsd1.ga.comcast.net) (Ping timeout: 246 seconds)
2023-02-20 07:29:04 +0100dsrt^(~dsrt@c-24-30-76-89.hsd1.ga.comcast.net)
2023-02-20 07:29:29 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-02-20 07:32:16 +0100 <albet70> compile aeson takes 1 hour, why it takes so long?
2023-02-20 07:34:00 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 260 seconds)
2023-02-20 07:38:04 +0100 <dsal> albet70: Do you have any RAM?
2023-02-20 07:38:18 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) (Ping timeout: 255 seconds)
2023-02-20 07:39:21 +0100myyo(~myyo@71-211-142-215.hlrn.qwest.net) ()
2023-02-20 07:39:40 +0100eggplant_(~Eggplanta@2600:1700:38c5:d800:6111:c483:164:5daf)
2023-02-20 07:41:25 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:bc09:17b4:a9c9:5fe5) (Ping timeout: 246 seconds)
2023-02-20 07:43:02 +0100 <albet70> 1GB
2023-02-20 07:44:52 +0100cods(~fred@82-65-232-44.subs.proxad.net)
2023-02-20 07:45:18 +0100 <dsal> That's going to be super hard to build things.
2023-02-20 07:45:27 +0100 <albet70> haha
2023-02-20 07:45:45 +0100 <dsal> 4GB is regular hard.
2023-02-20 07:46:04 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-02-20 07:46:29 +0100 <albet70> people compile things in the old days, it takes so long?
2023-02-20 07:48:08 +0100 <dsal> Lots of things were simpler in the past.
2023-02-20 07:48:20 +0100 <dsal> aeson does a lot
2023-02-20 07:48:44 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-20 07:49:26 +0100 <albet70> I thought aeson just do json stuff, why it so big?
2023-02-20 07:49:39 +0100 <albet70> json is huge?
2023-02-20 07:49:59 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 255 seconds)
2023-02-20 07:50:20 +0100voidzero(~voidzero@user/voidzero) (Ping timeout: 260 seconds)
2023-02-20 07:51:04 +0100 <albet70> if cabal provide binary packages would be nice
2023-02-20 07:51:13 +0100 <albet70> save a lot of time
2023-02-20 07:51:49 +0100 <albet70> system package manager are not nice to ghc, specially archlinux
2023-02-20 07:52:13 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-02-20 07:53:11 +0100 <albet70> I'm on alpine linux for compiling, I want a native code which can run on some different machines
2023-02-20 07:53:40 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 246 seconds)
2023-02-20 07:54:23 +0100czy(~user@host-140-26.ilcub310.champaign.il.us.clients.pavlovmedia.net) (Ping timeout: 255 seconds)
2023-02-20 07:54:44 +0100 <albet70> why haskell doesn't have something like jar for java? that's cross platform to run and save time
2023-02-20 07:55:10 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:50e2:6d7:efc7:59a5) (Remote host closed the connection)
2023-02-20 07:55:39 +0100mikess(~sam@user/mikess) (Ping timeout: 248 seconds)
2023-02-20 07:55:45 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:50e2:6d7:efc7:59a5)
2023-02-20 07:57:32 +0100 <dsal> I assume it's all the instances aeson expands to. I've not actually looked at it much. I just know there are a couple of libs that don't work out well without a lot of RAM.
2023-02-20 07:57:45 +0100razetime(~Thunderbi@117.193.2.7) (Quit: See You Space Cowboy)
2023-02-20 07:57:59 +0100 <dsal> "jar for java" is not native code. Haskell compiles to native code.
2023-02-20 07:58:07 +0100 <dsal> Er, ghc
2023-02-20 07:58:26 +0100 <dsal> Someone could certainly make a haskell VM. When I used to do ocaml back in the day, it had such a thing.
2023-02-20 07:59:11 +0100 <albet70> what about binary code, compile to binary code, and run it on vm, that save time too
2023-02-20 07:59:58 +0100 <dsal> Yes, ocaml does that as well.
2023-02-20 08:00:30 +0100 <albet70> why haskell doesn't have that proposal?
2023-02-20 08:00:34 +0100 <albet70> or ghc
2023-02-20 08:00:49 +0100 <dsal> No idea what you're talking about. That's what GHC does and why you're having problems with dynamic linking.
2023-02-20 08:01:24 +0100 <albet70> because glibc is dynamic linked
2023-02-20 08:02:27 +0100 <dsal> glibc is a C library, not a Haskell library.
2023-02-20 08:03:07 +0100voidzero(~voidzero@user/voidzero)
2023-02-20 08:04:13 +0100razetime(~Thunderbi@117.193.2.7)
2023-02-20 08:07:00 +0100 <dsal> I think that's already come up here, but more reading: https://stackoverflow.com/questions/57476533/why-is-statically-linking-glibc-discouraged
2023-02-20 08:07:42 +0100 <chreekat> Actually ghc does have a bytecode interpreter, and in 9.6 there's even been some work to make it better in some way (I don't know the details). But I guess it would be a huuge effort to build an entire ecosystem around packaging and distributing bytecode
2023-02-20 08:08:55 +0100 <chreekat> Or perhaps not, with the JavaScript and/or WASM backends
2023-02-20 08:09:48 +0100 <davean> Why would anywant to package and distribute bytecode? It has so many drawbacks
2023-02-20 08:09:48 +0100 <dsal> Oh yeah, I've never quite understood what I might want to do with those things.
2023-02-20 08:10:29 +0100 <davean> You might want a VM, you don't want Haskell bytecode
2023-02-20 08:10:37 +0100 <dsal> The java example is basically "Assuming the user already has the operating system and dependencies installed, this program will work," which was *kind of* the case with some java in the past.
2023-02-20 08:17:00 +0100kenran(~user@user/kenran)
2023-02-20 08:29:42 +0100razetime(~Thunderbi@117.193.2.7) (Read error: Connection reset by peer)
2023-02-20 08:30:00 +0100razetime(~Thunderbi@117.193.2.7)
2023-02-20 08:33:35 +0100oxide(~lambda@user/oxide)
2023-02-20 08:34:16 +0100gpncarl(~gpncarl@222.249.231.4)
2023-02-20 08:34:58 +0100gpncarl_(~gpncarl@222.249.231.4) (Ping timeout: 246 seconds)
2023-02-20 08:37:35 +0100falafel(~falafel@2607:fb91:143f:e47f:1eff:7815:d8e4:34a9) (Ping timeout: 260 seconds)
2023-02-20 08:42:58 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-02-20 08:43:08 +0100mncheck(~mncheck@193.224.205.254)
2023-02-20 08:44:43 +0100razetime(~Thunderbi@117.193.2.7) (Ping timeout: 248 seconds)
2023-02-20 08:49:48 +0100ubert(~Thunderbi@p200300ecdf1301aeed9235aafc85dd9a.dip0.t-ipconnect.de) (Quit: ubert)
2023-02-20 08:53:08 +0100finnekit9(~finnekit@fsf/member/finnekit)
2023-02-20 08:53:14 +0100razetime(~Thunderbi@117.193.2.7)
2023-02-20 08:53:20 +0100bramhaag7(~bramhaag@134.195.121.39)
2023-02-20 08:53:28 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-02-20 08:53:48 +0100bramhaag(~bramhaag@134.195.121.39) (Read error: Connection reset by peer)
2023-02-20 08:53:49 +0100bramhaag7bramhaag
2023-02-20 08:54:47 +0100finnekit(~finnekit@fsf/member/finnekit) (Ping timeout: 264 seconds)
2023-02-20 08:54:47 +0100finnekit9finnekit
2023-02-20 09:05:21 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:52b5:b626:421e:76da)
2023-02-20 09:06:29 +0100michalz(~michalz@185.246.207.221)
2023-02-20 09:09:47 +0100oxide(~lambda@user/oxide) (Ping timeout: 248 seconds)
2023-02-20 09:12:37 +0100AlexNoo(~AlexNoo@178.34.161.237)
2023-02-20 09:13:17 +0100AlexZenon(~alzenon@178.34.161.237)
2023-02-20 09:14:46 +0100Alex_test(~al_test@178.34.161.237)
2023-02-20 09:15:04 +0100Alex_test(~al_test@178.34.161.237) (Client Quit)
2023-02-20 09:15:15 +0100elkcl(~elkcl@broadband-37-110-27-252.ip.moscow.rt.ru)
2023-02-20 09:15:36 +0100Alex_test(~al_test@178.34.161.237)
2023-02-20 09:26:27 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:50e2:6d7:efc7:59a5) (Remote host closed the connection)
2023-02-20 09:26:46 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf)
2023-02-20 09:29:35 +0100debclair(~debclair@157.100.197.31)
2023-02-20 09:30:03 +0100CiaoSen(~Jura@p200300c9570460002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-02-20 09:30:38 +0100debclair(~debclair@157.100.197.31) (Client Quit)
2023-02-20 09:30:50 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-02-20 09:36:53 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-02-20 09:38:00 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-02-20 09:40:08 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-02-20 09:47:08 +0100acidjnk(~acidjnk@p200300d6e715c4362c639e785d9ee9c9.dip0.t-ipconnect.de)
2023-02-20 09:47:10 +0100 <albet70> https://paste.tomsmeding.com/Y8biSz4I
2023-02-20 09:47:26 +0100 <albet70> why servant wouldn't export this?
2023-02-20 09:47:33 +0100 <albet70> how I can fix it?
2023-02-20 09:49:15 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 255 seconds)
2023-02-20 09:49:20 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-02-20 09:50:01 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-02-20 09:51:31 +0100 <int-e> Looking at https://github.com/haskell-servant/servant/blob/master/servant-client/src/Servant/Client/Internal/… there's no such function at all. There's a `defaultMakeClientRequest` and a `makeClientRequest` in `ClientEnv`.
2023-02-20 09:58:02 +0100Alex_test(~al_test@178.34.161.237) (Quit: ;-)
2023-02-20 09:58:30 +0100 <albet70> I see, it may be an old version of servant
2023-02-20 09:59:14 +0100AlexZenon(~alzenon@178.34.161.237) (Quit: ;-)
2023-02-20 09:59:54 +0100 <geekosaur> hoogle says the only such function is in servant-http-streams
2023-02-20 10:00:02 +0100AlexNoo(~AlexNoo@178.34.161.237) (Quit: Leaving)
2023-02-20 10:09:35 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-02-20 10:10:52 +0100 <albet70> https://github.com/klappvisor/haskell-telegram-api/blob/master/src/Servant/Client/MultipartFormDat…
2023-02-20 10:10:53 +0100merijn(~merijn@c-001-001-009.client.esciencecenter.eduvpn.nl)
2023-02-20 10:14:09 +0100 <albet70> https://hackage.haskell.org/package/servant-client-0.16/docs/src/Servant.Client.Internal.HttpClien…
2023-02-20 10:14:24 +0100 <albet70> it's in 0.16
2023-02-20 10:15:12 +0100 <geekosaur> removed in 0.17, yeh
2023-02-20 10:15:20 +0100 <int-e> looks very similar to defaultMakeClientRequest so I suppose it got renamed
2023-02-20 10:15:35 +0100 <albet70> it was removed since 0.17
2023-02-20 10:20:19 +0100geekosaurwonders if we need a better way to bisect a haddock for function removal/addition
2023-02-20 10:20:39 +0100AlexZenon(~alzenon@178.34.161.237)
2023-02-20 10:20:43 +0100AlexNoo(~AlexNoo@178.34.161.237)
2023-02-20 10:21:08 +0100akegalj(~akegalj@78-3-37-43.adsl.net.t-com.hr)
2023-02-20 10:21:18 +0100 <int-e> Ah, 0.17 added the `makeClientRequest` field that allows customizing how requests are made, so now requestToClientRequest is no longer *the* way to make requests, but merely the default way.
2023-02-20 10:22:25 +0100Alex_test(~al_test@178.34.161.237)
2023-02-20 10:22:57 +0100 <albet70> please help me to solve the confilict version, https://paste.tomsmeding.com/MzS9qdha
2023-02-20 10:23:16 +0100 <int-e> Renaming also makes sure that all uses of the old function will be flagged so you can check whether there's a ClientEnv (in which case `makeClientRequest` is the function to use) or something standalone (where defaultMakeClientRequest is the only option)
2023-02-20 10:23:44 +0100 <geekosaur> albet70, a conflict on base version means you need an older ghc
2023-02-20 10:23:46 +0100 <albet70> to solve conflict version of packages and compile environments take more time than I code...
2023-02-20 10:23:55 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2023-02-20 10:24:09 +0100 <geekosaur> but see what int-e said above, you just have to change the code to use the new way of making a client request
2023-02-20 10:24:56 +0100 <albet70> geekosaur , to get an older ghc, you mean I have to compile ghc?
2023-02-20 10:25:39 +0100 <int-e> you can try your luck with --allow-newer=base
2023-02-20 10:25:49 +0100 <geekosaur> no. ideally you are using ghcup and can simply select an older version in `ghcup tui` (or install it and use `cabal -w ghc-whatever-version`)
2023-02-20 10:25:54 +0100 <int-e> the `base` library is tied to the compiler
2023-02-20 10:25:56 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-02-20 10:26:04 +0100 <int-e> 4.14 means 8.10.x
2023-02-20 10:26:13 +0100 <int-e> uh
2023-02-20 10:26:44 +0100 <int-e> so we're talking 8.8.x or earlier here, given base < 4.14
2023-02-20 10:27:00 +0100 <albet70> int-e , no luck, still confilct
2023-02-20 10:27:22 +0100eggplant_(~Eggplanta@2600:1700:38c5:d800:6111:c483:164:5daf) (Remote host closed the connection)
2023-02-20 10:27:44 +0100 <int-e> is it the same conflict?
2023-02-20 10:28:35 +0100 <albet70> int-e , https://paste.tomsmeding.com/K339QnZl
2023-02-20 10:29:29 +0100 <int-e> okay, same story for template-haskell. This is going to be fun because that actually routinely breaks the API. (base doesn't do that a lot)
2023-02-20 10:30:43 +0100 <albet70> what they call that? dependency hell?
2023-02-20 10:31:04 +0100 <int-e> I suspect you'll be better off updating the telegram-api code than trying to get the older servant to compile with ghc 9.0.
2023-02-20 10:31:15 +0100 <int-e> No, this is bit rot.
2023-02-20 10:32:32 +0100 <int-e> You could use ghc 8.8 I suppose... judging by those constraints that's contemporary with the telegram-api package and also servant-0.16.
2023-02-20 10:34:14 +0100 <int-e> Or maybe version hell is a form of bit rot. That's arguable.
2023-02-20 10:35:29 +0100 <albet70> change the function requestToClientRequest should be simpler to solve it
2023-02-20 10:36:01 +0100MajorBiscuit(~MajorBisc@145.94.158.133)
2023-02-20 10:36:04 +0100ph88(~ph88@ip5b426553.dynamic.kabel-deutschland.de) (Ping timeout: 246 seconds)
2023-02-20 10:36:09 +0100 <int-e> But I think version hell is more about combining libraries from two mostly separate ecosystems that update to newer versions at different pace, while you seem to be firmly in the servant ecosystem.
2023-02-20 10:36:39 +0100ft(~ft@p3e9bc443.dip0.t-ipconnect.de) (Quit: leaving)
2023-02-20 10:48:15 +0100MajorBiscuit(~MajorBisc@145.94.158.133) (Quit: WeeChat 3.6)
2023-02-20 10:48:39 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:52b5:b626:421e:76da) (Ping timeout: 246 seconds)
2023-02-20 10:49:45 +0100bgamari(~bgamari@2a06:a000:b00d::2) (Quit: ZNC 1.8.2 - https://znc.in)
2023-02-20 10:50:04 +0100bgamari(~bgamari@64.223.169.135)
2023-02-20 10:51:54 +0100 <merijn> int-e: eh, I'd be more inclined to call it "trying to use a completely abandonned and unmaintained package"
2023-02-20 10:52:04 +0100 <merijn> The last release of telegram-api was 5 years ago
2023-02-20 10:52:35 +0100 <merijn> The last commit on the repo is 4 years old
2023-02-20 10:55:55 +0100 <int-e> merijn: isn't that what bit rot is though, code that (presumably) used to work but decayed over time?
2023-02-20 10:56:38 +0100 <merijn> int-e: I was referring to you saying "combining libraries from two mostly separate ecosystems updating at a different pace", whereas this one just appears to not be updating at all :p
2023-02-20 10:57:19 +0100 <int-e> well, the problem with that combination is that there may never have been a time where they could coexist.
2023-02-20 10:57:26 +0100 <int-e> so I think it's different
2023-02-20 10:57:32 +0100 <int-e> though, of course, related
2023-02-20 10:59:05 +0100gurkenglas(~gurkengla@dynamic-046-114-178-211.46.114.pool.telefonica.de)
2023-02-20 11:00:04 +0100 <int-e> merijn: Anyway, yes, I agree that that's not what is happening here. I was trying to describe what distinguishes mere bit rot from what I would call dependency hell.
2023-02-20 11:00:35 +0100 <int-e> "mere" -- it's a lesser evil because you can "go back in time", using old tools.
2023-02-20 11:01:05 +0100 <geekosaur> I'd say dependency hell is where you end up with a diamond dependency somewhere, usually in a support library
2023-02-20 11:01:12 +0100comerijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)
2023-02-20 11:01:46 +0100 <geekosaur> here it'd be something like servant-client and telegram-api requiring different versions of, say, bytestring
2023-02-20 11:02:05 +0100 <int-e> support library A, ecosystem B updates for versions 0.1, 0.3, 0.5, etc; ecosystem C updates for versions 0.2, 0.4, 0.6, poor user wants to combine the two.
2023-02-20 11:03:10 +0100 <int-e> (this is artificial but if you have more than one support library... and we do... it becomes quite plausible that there's always *some* support dependency that won't match up)
2023-02-20 11:03:14 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi)
2023-02-20 11:03:29 +0100 <int-e> thanks for the "support library" term, it's helpful
2023-02-20 11:03:43 +0100merijn(~merijn@c-001-001-009.client.esciencecenter.eduvpn.nl) (Ping timeout: 246 seconds)
2023-02-20 11:03:50 +0100shriekingnoise(~shrieking@186.137.175.87) (Quit: Quit)
2023-02-20 11:04:18 +0100 <int-e> the idea of a homogeneous ecosystem is also idealized of course.
2023-02-20 11:04:49 +0100 <geekosaur> well, this kind of thing is why stackage exists
2023-02-20 11:05:10 +0100freeside(~mengwong@122.11.212.92)
2023-02-20 11:05:14 +0100 <geekosaur> pushes the whole problem on someone else, as long as you stick to stackage-curated packages
2023-02-20 11:06:31 +0100 <int-e> that actually makes sense
2023-02-20 11:07:50 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 268 seconds)
2023-02-20 11:08:02 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-02-20 11:10:36 +0100 <geekosaur> oh, also the elephant in the room wrt telegram-api is "does it still work with 4-years-later telegram?"
2023-02-20 11:11:57 +0100 <int-e> Nice walls though. :P
2023-02-20 11:14:03 +0100zeenk(~zeenk@2a02:2f04:a214:1e00::7fe)
2023-02-20 11:19:40 +0100 <freeside> so ... I'm trying to get some line numbers into my runtime stack trace, which means i'm already deep in it, but anyway, the guidance at https://wiki.haskell.org/Debugging#Source-located_errors seems to have succumbed to some bit-rot ... if I understand correctly, loch has become loch-th, and -no-recomp has become -fforce-recomp. Should I dare to tweak the wiki directly or should this be better left to
2023-02-20 11:19:46 +0100 <freeside> someone who knows better?
2023-02-20 11:21:08 +0100k(~k@fork.wtf) (Quit: :x)
2023-02-20 11:21:16 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:46:c70:7349:66e1)
2023-02-20 11:23:22 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-02-20 11:23:25 +0100 <mauke> do you know about HasCallStack?
2023-02-20 11:23:31 +0100 <freeside> negative
2023-02-20 11:25:11 +0100 <freeside> i'm dying on a "No match in record selector" error, but i can't for the life of me isolate the cause
2023-02-20 11:27:50 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6111:c483:164:5daf)
2023-02-20 11:27:55 +0100 <mauke> does the error point to your code?
2023-02-20 11:27:58 +0100 <comerijn> freeside: I mean, first of all if you compiling with --enable-profiling and use +RTS -xc you can just get stack traces of where it crashes
2023-02-20 11:30:06 +0100 <mauke> re: HasCallStack, here is an explanation of the idea: https://downloads.haskell.org/ghc/latest/docs/users_guide/exts/callstack.html
2023-02-20 11:30:08 +0100 <freeside> i'm running stack --profile run ... and the -xc gets me a stack trace, but no line numbers
2023-02-20 11:30:55 +0100 <comerijn> it should tell you the function names. Although "no match in record selector" sounds like using record syntax with multiple constructors where not all of them have the same fields, which is no bueno to begin with
2023-02-20 11:31:10 +0100 <geekosaur> that was my thought too
2023-02-20 11:31:21 +0100 <comerijn> And -Wall should point that out
2023-02-20 11:31:23 +0100 <freeside> agreed, i am doing some archaeology on this codebase, and that is next up to be fixed
2023-02-20 11:32:11 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6111:c483:164:5daf) (Ping timeout: 255 seconds)
2023-02-20 11:32:40 +0100igghibu(~igghibu@178.249.211.74)
2023-02-20 11:38:38 +0100king_gs(~Thunderbi@2806:103e:29:1779:7fb9:3db:d5e5:7d2c)
2023-02-20 11:49:31 +0100igghibu(~igghibu@178.249.211.74) (Quit: igghibu)
2023-02-20 11:53:39 +0100freeside(~mengwong@122.11.212.92) (Read error: Connection reset by peer)
2023-02-20 12:00:25 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2023-02-20 12:02:26 +0100igghibu(~igghibu@178.249.211.74)
2023-02-20 12:05:15 +0100acidjnk(~acidjnk@p200300d6e715c4362c639e785d9ee9c9.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
2023-02-20 12:06:48 +0100igghibu(~igghibu@178.249.211.74) (Client Quit)
2023-02-20 12:07:40 +0100ph88(~ph88@ip5b426553.dynamic.kabel-deutschland.de)
2023-02-20 12:10:33 +0100cods(~fred@82-65-232-44.subs.proxad.net) (Ping timeout: 255 seconds)
2023-02-20 12:13:31 +0100xff0x(~xff0x@ai081074.d.east.v6connect.net)
2023-02-20 12:25:58 +0100ph88(~ph88@ip5b426553.dynamic.kabel-deutschland.de) (Ping timeout: 246 seconds)
2023-02-20 12:26:39 +0100razetime(~Thunderbi@117.193.2.7) (Ping timeout: 255 seconds)
2023-02-20 12:30:10 +0100CiaoSen(~Jura@p200300c9570460002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-02-20 12:33:57 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-02-20 12:37:21 +0100cfricke(~cfricke@user/cfricke)
2023-02-20 12:38:21 +0100Square(~Square4@user/square)
2023-02-20 12:40:17 +0100akegalj(~akegalj@78-3-37-43.adsl.net.t-com.hr) (Quit: leaving)
2023-02-20 12:40:57 +0100gurkenglas(~gurkengla@dynamic-046-114-178-211.46.114.pool.telefonica.de) (Ping timeout: 268 seconds)
2023-02-20 12:41:41 +0100pernzs(~pernzs@101.175.168.100)
2023-02-20 12:41:50 +0100razetime(~Thunderbi@117.193.2.7)
2023-02-20 12:48:21 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-02-20 12:57:41 +0100razetime(~Thunderbi@117.193.2.7) (Remote host closed the connection)
2023-02-20 13:00:29 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 255 seconds)
2023-02-20 13:00:41 +0100acidjnk(~acidjnk@p200300d6e715c4362c639e785d9ee9c9.dip0.t-ipconnect.de)
2023-02-20 13:03:04 +0100comerijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl) (Ping timeout: 246 seconds)
2023-02-20 13:03:24 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-02-20 13:05:52 +0100polyphem(~rod@2a02:810d:840:8754:996d:6779:a2f3:34bb)
2023-02-20 13:07:07 +0100p0lyph3m(~polyphem@2a02:810d:840:8754:4d31:9178:35f:6608)
2023-02-20 13:08:18 +0100Square(~Square4@user/square) (Remote host closed the connection)
2023-02-20 13:18:46 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-02-20 13:23:21 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 252 seconds)
2023-02-20 13:35:37 +0100king_gs(~Thunderbi@2806:103e:29:1779:7fb9:3db:d5e5:7d2c) (Ping timeout: 246 seconds)
2023-02-20 13:39:33 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-02-20 13:45:44 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-02-20 13:46:56 +0100nschoe(~q@141.101.51.197)
2023-02-20 13:49:32 +0100mauke(~mauke@user/mauke) (Quit: bbl)
2023-02-20 14:05:18 +0100pernzs(~pernzs@101.175.168.100) (Ping timeout: 260 seconds)
2023-02-20 14:05:49 +0100merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)
2023-02-20 14:07:23 +0100pernzs(~pernzs@101.175.168.100)
2023-02-20 14:13:04 +0100dsrt^(~dsrt@c-24-30-76-89.hsd1.ga.comcast.net) (Remote host closed the connection)
2023-02-20 14:14:28 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-02-20 14:20:02 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-02-20 14:20:26 +0100GuestW48(~GuestW48@46.146.247.46)
2023-02-20 14:20:36 +0100cods(~fred@82.65.232.44)
2023-02-20 14:21:24 +0100 <GuestW48> Hello, is there some "default" package for working with Time units Hours/Minutes/Seconds/Milli ?
2023-02-20 14:21:57 +0100 <geekosaur> @hackage time
2023-02-20 14:21:57 +0100 <lambdabot> https://hackage.haskell.org/package/time
2023-02-20 14:22:52 +0100 <geekosaur> note that we don't include more than the bare minimum in the `base` library because it's tied to the compiler, so as much as possible is unbundled from it
2023-02-20 14:23:38 +0100 <GuestW48> Hm, I didn't see where units are there
2023-02-20 14:24:19 +0100abcdw(8c3442b76e@user/abcdw)
2023-02-20 14:26:53 +0100lyle(~lyle@104.246.145.237)
2023-02-20 14:27:17 +0100 <GuestW48> So in the `time` package it seems there are no Units constructors, for example purescript have it the nice way https://pursuit.purescript.org/packages/purescript-datetime/6.1.0/docs/Data.Time.Component
2023-02-20 14:29:46 +0100__monty__(~toonn@user/toonn)
2023-02-20 14:30:42 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6111:c483:164:5daf)
2023-02-20 14:31:34 +0100pernzs(~pernzs@101.175.168.100) (Quit: Client closed)
2023-02-20 14:31:37 +0100 <geekosaur> yeh, I think the closest this package gets is https://hackage.haskell.org/package/time-1.13/docs/Data-Time-Format.html#g:2
2023-02-20 14:33:11 +0100 <GuestW48> It is really strange ) such a common task
2023-02-20 14:35:07 +0100andrewboltachev(~andrey@178.141.125.176) (Quit: Leaving.)
2023-02-20 14:35:10 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6111:c483:164:5daf) (Ping timeout: 260 seconds)
2023-02-20 14:35:10 +0100 <GuestW48> Probably this is the closeset https://hackage.haskell.org/package/hourglass-0.2.10/docs/Time-Types.html
2023-02-20 15:03:31 +0100ccapndave(~ccapndave@mob-194-230-158-118.cgn.sunrise.net)
2023-02-20 15:05:30 +0100polyphem(~rod@2a02:810d:840:8754:996d:6779:a2f3:34bb) (Ping timeout: 260 seconds)
2023-02-20 15:06:14 +0100polyphem(~rod@2a02:810d:840:8754:224e:f6ff:fe5e:bc17)
2023-02-20 15:10:07 +0100razetime(~Thunderbi@117.193.2.7)
2023-02-20 15:15:56 +0100ccapndave(~ccapndave@mob-194-230-158-118.cgn.sunrise.net) (Quit: Textual IRC Client: www.textualapp.com)
2023-02-20 15:18:41 +0100mauke(~mauke@user/mauke)
2023-02-20 15:22:24 +0100lackita(~user@73.114.250.252)
2023-02-20 15:23:28 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-02-20 15:25:18 +0100Feuermagier(~Feuermagi@user/feuermagier) (Ping timeout: 255 seconds)
2023-02-20 15:25:29 +0100thegeekinside(~thegeekin@189.180.66.126)
2023-02-20 15:29:07 +0100lackita(~user@73.114.250.252) (Ping timeout: 252 seconds)
2023-02-20 15:31:32 +0100sol41(~sol@cm-171-101-5-118.revip11.asianet.co.th)
2023-02-20 15:31:39 +0100Feuermagier(~Feuermagi@user/feuermagier)
2023-02-20 15:31:53 +0100sol41solirc_
2023-02-20 15:34:17 +0100solirc_(~sol@cm-171-101-5-118.revip11.asianet.co.th) (Client Quit)
2023-02-20 15:42:12 +0100jinsun(~jinsun@user/jinsun)
2023-02-20 15:45:37 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 252 seconds)
2023-02-20 15:52:26 +0100elbear(~lucian@109.101.137.234)
2023-02-20 15:55:42 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net)
2023-02-20 15:58:02 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2023-02-20 15:58:50 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-02-20 16:00:32 +0100 <albet70> x86_64-alpine-linux-musl/bin/ld: cannot find -lz: No such file or directory
2023-02-20 16:01:00 +0100 <albet70> cabal v2-build --enable-executable-static --enable-executable-stripping got that error
2023-02-20 16:01:09 +0100 <albet70> what's missing?
2023-02-20 16:01:14 +0100 <merijn> libz, presumably ;)
2023-02-20 16:01:33 +0100CiaoSen(~Jura@p200300c9570460002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-02-20 16:02:40 +0100 <mauke> https://pkgs.alpinelinux.org/package/edge/main/x86_64/zlib ?
2023-02-20 16:02:52 +0100 <geekosaur> zlib, yes
2023-02-20 16:05:52 +0100 <albet70> I did run apk add zlib, is it wrong?
2023-02-20 16:06:09 +0100 <albet70> apk add zlib-dev?
2023-02-20 16:06:19 +0100 <geekosaur> you need zlib-dev
2023-02-20 16:06:51 +0100 <albet70> after install zlib-dev, it still the same error
2023-02-20 16:07:00 +0100jumper149(~jumper149@base.felixspringer.xyz)
2023-02-20 16:07:09 +0100 <albet70> Linking /root/forBuild/dist-newstyle/build/x86_64-linux/ghc-9.0.2/sendMsg-0.1.0.0/x/sendMsg/build/sendMsg/sendMsg ... /usr/lib/gcc/x86_64-alpine-linux-musl/12.2.1/../../../../x86_64-alpine-linux-musl/bin/ld: cannot find -lz: No such file or directory
2023-02-20 16:07:16 +0100jumper149(~jumper149@base.felixspringer.xyz) (Client Quit)
2023-02-20 16:07:22 +0100Guest|62(~Guest|62@m90-131-34-42.cust.tele2.lt)
2023-02-20 16:07:31 +0100 <geekosaur> zlib-static appears to be a separate package
2023-02-20 16:07:37 +0100 <geekosaur> so try that
2023-02-20 16:08:15 +0100 <geekosaur> https://pkgs.alpinelinux.org/contents?branch=edge&name=zlib-static&arch=x86_64&repo=main
2023-02-20 16:09:09 +0100 <albet70> right, it works
2023-02-20 16:09:49 +0100 <albet70> why zlib-dev is different to zlib-static?
2023-02-20 16:10:33 +0100 <geekosaur> https://pkgs.alpinelinux.org/contents?branch=edge&name=zlib-dev&arch=x86_64&repo=main pkg-config files, header file, shared object
2023-02-20 16:10:48 +0100 <albet70> in cabal config ghc-options: -optl-static, and cabal build —enable-executable-static, are they same?
2023-02-20 16:11:29 +0100 <geekosaur> iirc --enable-executable-static applies to HYaskell libraries (and is the default)
2023-02-20 16:11:44 +0100 <geekosaur> -optl-static applies to system-provided libraries
2023-02-20 16:14:08 +0100Guest|62(~Guest|62@m90-131-34-42.cust.tele2.lt) (Quit: Connection closed)
2023-02-20 16:14:31 +0100 <albet70> so -optl-static is what I need?
2023-02-20 16:14:51 +0100 <albet70> and what's —enable-executable-stripping doing?
2023-02-20 16:15:23 +0100 <geekosaur> removes debugging symbols
2023-02-20 16:16:16 +0100 <geekosaur> and I just checked and apparently you don't also need -optl-static with --enable-executable-static; it's distinct from --disable-executable-dynamic. (Not confusing at all…)
2023-02-20 16:17:52 +0100merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl) (Ping timeout: 248 seconds)
2023-02-20 16:18:32 +0100 <albet70> so just cabal v2-build —enable-executable-stripping?
2023-02-20 16:18:56 +0100 <geekosaur> with --enable-executable-static
2023-02-20 16:19:14 +0100 <geekosaur> but not the explicit ghc-options
2023-02-20 16:19:26 +0100 <geekosaur> well, use one or the other, you just don't need both
2023-02-20 16:19:28 +0100 <albet70> ok
2023-02-20 16:20:51 +0100 <albet70> what a day! all for compile!
2023-02-20 16:22:24 +0100 <albet70> and finally, it compile successfully
2023-02-20 16:22:56 +0100 <albet70> and it worked!
2023-02-20 16:26:45 +0100 <p0lyph3m> albet70 ,what is the size of the executable ?
2023-02-20 16:26:53 +0100merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)
2023-02-20 16:27:17 +0100sagax(~sagax_nb@user/sagax)
2023-02-20 16:27:29 +0100 <albet70> p0lyph3m , 48M
2023-02-20 16:28:40 +0100 <p0lyph3m> handleable :)
2023-02-20 16:29:00 +0100 <albet70> I wonder how that cross-platform browser like chrome or intellij-idea work on linux? are they static-lined?
2023-02-20 16:29:32 +0100phma(~phma@host-67-44-208-191.hnremote.net) (Read error: Connection reset by peer)
2023-02-20 16:30:14 +0100 <geekosaur> dynamic but they build for multiple platforms, so presumably there's a static one for alpine
2023-02-20 16:30:21 +0100 <albet70> they provide binary file on their website
2023-02-20 16:30:38 +0100ph88(~ph88@ip5b426553.dynamic.kabel-deutschland.de)
2023-02-20 16:31:47 +0100 <geekosaur> or they make you install e.g. gtk shared libs, like libz has a shared lib despite using static libc
2023-02-20 16:32:10 +0100phma(~phma@2001:5b0:2144:4228:838a:a514:d9cb:e024)
2023-02-20 16:32:22 +0100merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl) (Ping timeout: 246 seconds)
2023-02-20 16:33:02 +0100 <geekosaur> I haven't looked at the generic binary, I just install the ubuntu package they provide
2023-02-20 16:34:35 +0100elbear(~lucian@109.101.137.234) (Ping timeout: 255 seconds)
2023-02-20 16:34:58 +0100elbear(~lucian@109.101.137.234)
2023-02-20 16:35:14 +0100 <cheater> hi
2023-02-20 16:35:24 +0100 <cheater> can someone tell me what a "data instance" is? https://hackage.haskell.org/package/capnp-0.17.0.0/docs/Capnp-Tutorial.html#g:1
2023-02-20 16:35:28 +0100 <cheater> it's in the first haskell listing.
2023-02-20 16:36:43 +0100 <c_wraith> it's part of a data family
2023-02-20 16:36:48 +0100 <geekosaur> https://downloads.haskell.org/ghc/9.6.1-alpha3/docs/users_guide/exts/type_families.html#data-insta…
2023-02-20 16:37:15 +0100 <geekosaur> (it's from before 9.6, that's just what I have open atm)
2023-02-20 16:39:26 +0100Midjak(~Midjak@82.66.147.146)
2023-02-20 16:43:09 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-02-20 16:46:03 +0100merijn(~merijn@145.108.92.169)
2023-02-20 16:46:50 +0100kenran(~user@user/kenran) (Remote host closed the connection)
2023-02-20 16:48:25 +0100oxide(~lambda@user/oxide)
2023-02-20 16:50:27 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 255 seconds)
2023-02-20 16:54:01 +0100Sgeo(~Sgeo@user/sgeo)
2023-02-20 16:55:40 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-02-20 16:57:50 +0100prasadi01Newuser(~Thunderbi@c-73-22-232-123.hsd1.il.comcast.net)
2023-02-20 16:58:02 +0100freeside(~mengwong@103.252.202.170)
2023-02-20 17:02:36 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 255 seconds)
2023-02-20 17:09:04 +0100Feuermagier(~Feuermagi@user/feuermagier) (Remote host closed the connection)
2023-02-20 17:09:44 +0100ddellacosta(~ddellacos@146.70.166.221) (Quit: WeeChat 3.8)
2023-02-20 17:11:21 +0100ddellacosta(~ddellacos@146.70.166.221)
2023-02-20 17:11:33 +0100Feuermagier(~Feuermagi@user/feuermagier)
2023-02-20 17:12:02 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-02-20 17:13:37 +0100freeside(~mengwong@103.252.202.170)
2023-02-20 17:14:02 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 265 seconds)
2023-02-20 17:18:01 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 252 seconds)
2023-02-20 17:18:06 +0100 <cheater> right
2023-02-20 17:18:10 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-02-20 17:18:36 +0100 <cheater> it's weird though because when i generate the code, there is no line that says "data instance"
2023-02-20 17:18:53 +0100 <cheater> i took that listing and generated the code as they instruct
2023-02-20 17:18:55 +0100 <cheater> and it's not there.
2023-02-20 17:19:04 +0100 <cheater> there's some data's
2023-02-20 17:19:15 +0100elbear(~lucian@109.101.137.234) (Ping timeout: 255 seconds)
2023-02-20 17:20:10 +0100 <cheater> as in, grep "data instance" -ir . find any files
2023-02-20 17:20:40 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-02-20 17:20:40 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-02-20 17:20:40 +0100wroathe(~wroathe@user/wroathe)
2023-02-20 17:20:40 +0100 <cheater> *doesn't find any files
2023-02-20 17:20:43 +0100 <cheater> neither does grep "family" -ir .
2023-02-20 17:20:43 +0100jero98772(~jero98772@2800:484:1d80:d8ce:efcc:cbb3:7f2a:6dff)
2023-02-20 17:20:57 +0100 <[exa]> cheater: maybe they use "type instance" or so. also they can be associated with typeclasses, which is quite common
2023-02-20 17:21:12 +0100 <[exa]> iirc `transformers` is all associated types
2023-02-20 17:21:21 +0100 <cheater> well in the haskell listing it's specifically "data instance"
2023-02-20 17:21:32 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-02-20 17:21:33 +0100 <cheater> check the link
2023-02-20 17:21:49 +0100 <geekosaur> they also say it's cleaned up; might be on separate lines or more than one space (or even a tab), etc.
2023-02-20 17:22:09 +0100 <cheater> they ALSO have type instance, which is also not in the generated code
2023-02-20 17:22:36 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:46:c70:7349:66e1) (Quit: WeeChat 2.8)
2023-02-20 17:22:52 +0100 <cheater> could it be that those data instance / type instance things are somehow... not generated, but instead exist somewhere else in a module that you don't have to generate?
2023-02-20 17:23:15 +0100 <[exa]> might be
2023-02-20 17:23:57 +0100 <cheater> geekosaur: well if i grep for "instance" then it only finds lines like this
2023-02-20 17:24:10 +0100czy(~user@host-140-23.ilcub310.champaign.il.us.clients.pavlovmedia.net)
2023-02-20 17:24:31 +0100 <cheater> ./Capnp/Gen/Addressbook/Pure.hs:instance (Classes.Cerialize s (V.Vector (V.Vector Capnp.Gen.ById.Xcd6db6afb4a0cf5c.Person'PhoneNumber'Type))) where
2023-02-20 17:24:38 +0100 <cheater> that seems to be class instances
2023-02-20 17:24:43 +0100 <cheater> not a data instance or type instance
2023-02-20 17:25:09 +0100 <[exa]> they have plenty data instances here https://hackage.haskell.org/package/capnp-0.17.0.0/docs/src/Capnp.Basics.html and I guess that covers it for the generated code
2023-02-20 17:25:24 +0100 <[exa]> s/plenty/ok 3/
2023-02-20 17:25:47 +0100 <[exa]> ok that might not be it. :D
2023-02-20 17:28:48 +0100 <cheater> well it would be surprising for them to just so happen to have a data instance and type instance named like every type i could come up with, what i meant was maybe those are generated somehow? but i doubt they can be
2023-02-20 17:29:00 +0100 <cheater> esp generated at runtime
2023-02-20 17:29:48 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-02-20 17:33:28 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6111:c483:164:5daf)
2023-02-20 17:34:20 +0100prasadi01Newuser(~Thunderbi@c-73-22-232-123.hsd1.il.comcast.net) (Ping timeout: 265 seconds)
2023-02-20 17:36:25 +0100czy(~user@host-140-23.ilcub310.champaign.il.us.clients.pavlovmedia.net) (Ping timeout: 246 seconds)
2023-02-20 17:37:49 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6111:c483:164:5daf) (Ping timeout: 246 seconds)
2023-02-20 17:38:35 +0100 <cheater> ugh
2023-02-20 17:38:37 +0100 <cheater> it's weird
2023-02-20 17:40:45 +0100merijn(~merijn@145.108.92.169) (Ping timeout: 255 seconds)
2023-02-20 17:51:00 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2023-02-20 17:51:20 +0100motherfsck(~motherfsc@user/motherfsck)
2023-02-20 17:51:28 +0100enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7)
2023-02-20 17:52:33 +0100gpncarl(~gpncarl@222.249.231.4) (Ping timeout: 255 seconds)
2023-02-20 17:52:57 +0100gpncarl(~gpncarl@222.249.231.4)
2023-02-20 17:56:45 +0100freeside(~mengwong@103.252.202.170)
2023-02-20 17:59:28 +0100jinsl-(~jinsl@2408:8207:255b:27c0:211:32ff:fec8:6aea) (Ping timeout: 265 seconds)
2023-02-20 17:59:48 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-02-20 18:01:45 +0100jinsl(~jinsl@2408:8207:2557:8800:211:32ff:fec8:6aea)
2023-02-20 18:01:59 +0100cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.8)
2023-02-20 18:03:31 +0100mikess(~sam@user/mikess)
2023-02-20 18:04:42 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 268 seconds)
2023-02-20 18:08:03 +0100Sciencentistguy4(~sciencent@hacksoc/ordinary-member)
2023-02-20 18:10:33 +0100Sciencentistguy(~sciencent@hacksoc/ordinary-member) (Ping timeout: 255 seconds)
2023-02-20 18:10:34 +0100Sciencentistguy4Sciencentistguy
2023-02-20 18:15:17 +0100Kuttenbrunzer(~Kuttenbru@2a02:8108:8b80:1d48::160)
2023-02-20 18:17:45 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 255 seconds)
2023-02-20 18:17:46 +0100mmhat(~mmh@p200300f1c71c17cbee086bfffe095315.dip0.t-ipconnect.de)
2023-02-20 18:21:47 +0100elbear(~lucian@2a02:2f01:5302:8b00:51af:cfc:cb5f:1da8)
2023-02-20 18:26:04 +0100elbear(~lucian@2a02:2f01:5302:8b00:51af:cfc:cb5f:1da8) (Ping timeout: 252 seconds)
2023-02-20 18:26:29 +0100freeside(~mengwong@103.252.202.170)
2023-02-20 18:30:04 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-02-20 18:30:48 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 255 seconds)
2023-02-20 18:31:08 +0100Feuermagier(~Feuermagi@user/feuermagier) (Remote host closed the connection)
2023-02-20 18:31:15 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 255 seconds)
2023-02-20 18:32:53 +0100Lord_of_Life_Lord_of_Life
2023-02-20 18:36:01 +0100razetime(~Thunderbi@117.193.2.7) (Quit: See You Space Cowboy)
2023-02-20 18:38:35 +0100robobub(uid248673@2a03:5180:f:5::3:cb61) (Quit: Connection closed for inactivity)
2023-02-20 18:41:47 +0100econo(uid147250@user/econo)
2023-02-20 18:43:44 +0100oxide(~lambda@user/oxide) (Ping timeout: 255 seconds)
2023-02-20 18:44:01 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-02-20 18:45:08 +0100oxide(~lambda@user/oxide)
2023-02-20 18:48:06 +0100freeside(~mengwong@103.252.202.170)
2023-02-20 18:52:31 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 248 seconds)
2023-02-20 18:53:25 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-02-20 18:53:59 +0100mmhat(~mmh@p200300f1c71c17cbee086bfffe095315.dip0.t-ipconnect.de) (Quit: WeeChat 3.8)
2023-02-20 18:55:04 +0100jakalx(~jakalx@base.jakalx.net) (Disconnected: Replaced by new connection)
2023-02-20 18:55:05 +0100jakalx(~jakalx@base.jakalx.net)
2023-02-20 18:57:25 +0100jonathanx(~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) (Remote host closed the connection)
2023-02-20 18:59:03 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6111:c483:164:5daf)
2023-02-20 19:03:42 +0100elbear(~lucian@188.25.92.21)
2023-02-20 19:04:03 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67)
2023-02-20 19:05:24 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67) (Remote host closed the connection)
2023-02-20 19:06:01 +0100nschoe(~q@141.101.51.197) (Ping timeout: 246 seconds)
2023-02-20 19:08:23 +0100elbear(~lucian@188.25.92.21) (Ping timeout: 252 seconds)
2023-02-20 19:10:40 +0100CiaoSen(~Jura@p200300c9570460002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
2023-02-20 19:10:57 +0100Kuttenbrunzer(~Kuttenbru@2a02:8108:8b80:1d48::160) (Remote host closed the connection)
2023-02-20 19:13:35 +0100freeside(~mengwong@103.252.202.170)
2023-02-20 19:13:51 +0100 <ghostbuster> i am a recovering imperative programmer and this page was making sense until the last example with triangles... feels like sorcery http://learnyouahaskell.com/starting-out#babys-first-functions
2023-02-20 19:16:32 +0100 <c_wraith> would it feel less like sorcery if you split it into a bunch of different parts?
2023-02-20 19:17:36 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 255 seconds)
2023-02-20 19:18:03 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 255 seconds)
2023-02-20 19:18:03 +0100telser(~quassel@user/telser) (Ping timeout: 255 seconds)
2023-02-20 19:18:30 +0100telser(~quassel@user/telser)
2023-02-20 19:19:28 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-02-20 19:19:41 +0100 <mauke> that's just a bunch of nested loops, really
2023-02-20 19:19:55 +0100 <ghostbuster> is the compiler just bruteforcing it?
2023-02-20 19:20:00 +0100 <c_wraith> yes.
2023-02-20 19:20:05 +0100 <c_wraith> Nothing special going on there at all
2023-02-20 19:20:28 +0100 <ghostbuster> ok well that's less magical, but still nice syntactic sugar
2023-02-20 19:21:11 +0100 <mauke> I'd say the programmer is brute-forcing it :-)
2023-02-20 19:21:24 +0100 <EvanR> list comprehensions are great for that one specific use case
2023-02-20 19:22:01 +0100 <mauke> especially the part where they're making 'a' loop over [1..b] only to then add the condition a+b+c == 24
2023-02-20 19:22:25 +0100 <mauke> so there's only one choice for a: let a = 24 - b - c
2023-02-20 19:23:00 +0100oxide(~lambda@user/oxide) (Ping timeout: 255 seconds)
2023-02-20 19:23:42 +0100 <c_wraith> meanwhile, if you want to remove the sugar...
2023-02-20 19:23:43 +0100 <c_wraith> > concatMap (\c -> concatMap (\b -> concatMap (\a -> if a+b+c == 24 && a*a + b*b == c*c then [(a, b, c)] else []) [1..b]) [1..c]) [1..10]
2023-02-20 19:23:45 +0100 <lambdabot> [(6,8,10)]
2023-02-20 19:24:58 +0100 <ghostbuster> is anyone familiar with music theory? i'm thinking it would be a good first functional project to try representing notes/chords/keys etc.
2023-02-20 19:25:06 +0100 <c_wraith> You can probably see why people will prefer the list comprehension for things with exactly that shape
2023-02-20 19:25:11 +0100 <mauke> > do { c <- [1 .. 10]; b <- [1..c]; a <- [1..b]; guard (a^2 + b^2 == c^2); guard (a+b+c == 24); pure (a,b,c) }
2023-02-20 19:25:13 +0100 <lambdabot> [(6,8,10)]
2023-02-20 19:25:20 +0100maukeadds different sugar
2023-02-20 19:36:09 +0100oxide(~lambda@user/oxide)
2023-02-20 19:36:45 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-02-20 19:38:35 +0100freeside(~mengwong@103.252.202.170)
2023-02-20 19:40:35 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2023-02-20 19:40:51 +0100 <Guillaum[m]> I do have a piece of code such as `case x of {Just y -> pure y; Nothing -> unsafePerformIO (writeIORef ref something >> pure 0)}` I want to be sure that the write on the ioref is done each time the case is evaluated, and I'm afraid of let floating or any other optimisation. Am I safe? If not, what can I change?
2023-02-20 19:42:52 +0100 <c_wraith> That sort of reads like "I want to hammer on this hand grenade, is that safe?"
2023-02-20 19:43:16 +0100ft(~ft@p3e9bc443.dip0.t-ipconnect.de)
2023-02-20 19:43:30 +0100 <c_wraith> well, maybe, if all the explosives have been removed. But why are you doing it in the first place?
2023-02-20 19:47:50 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 260 seconds)
2023-02-20 19:48:26 +0100hexagoxel(~hexagoxel@hexagoxel.de) (Quit: ZNC 1.7.2+deb3 - https://znc.in)
2023-02-20 19:48:54 +0100 <Guillaum[m]> c_wraith: This is a good question. I'm using a library for which I have no control and this library requires a callback function which is used inside an FFI Call (i.e.: haskell calls C, which then calls back Haskell). Problem is, this function can fail with an exception, which is interepted by the FFI wrapper which terminate the program. I can avoid the exception and instead return a dummy value to the C program, but I need a way to pass
2023-02-20 19:48:54 +0100 <Guillaum[m]> the information that something went wrong, and in order to do that I'm using an IORef ;)
2023-02-20 19:48:54 +0100 <Guillaum[m]> It works everywhere in this library because all of the callback functions (but one) are defined as `IO (a -> b)`, but that's one is the only one which is not `IO`.
2023-02-20 19:48:54 +0100 <Guillaum[m]> That's definitely a problem in the API of the library, but I have no control on that immediatly.
2023-02-20 19:49:11 +0100 <c_wraith> GHC optimizes heavily based on an assumption of referential transparency. If you want to violate that assumption, you're going to be fighting GHC constantly. Maybe it'll work in one version and break in the next.
2023-02-20 19:49:22 +0100freeside(~mengwong@103.252.202.170)
2023-02-20 19:49:40 +0100 <c_wraith> You're far better off not breaking the compiler's assumptions
2023-02-20 19:50:16 +0100 <eldritchcookie[m> is this library open source if so fork it it will be less painful in the long run
2023-02-20 19:50:55 +0100 <EvanR> ghostbuster, you could start with baby steps and look at MIDI
2023-02-20 19:51:26 +0100 <EvanR> not exactly faithful to Actual Music Notation but does bring you your favorite hits of today
2023-02-20 19:51:47 +0100 <Guillaum[m]> eldritch cookie: that's the best option and I'm actually also doing the change, but that's a way more complexe change (which I would have to also maintain for months, well, you know the drawbacks), so the patch won't be ready for tomorrow ;)
2023-02-20 19:53:36 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 255 seconds)
2023-02-20 19:54:03 +0100 <Guillaum[m]> Looks like I won't get ride of this ticket using the famous "FIXME: This hackish code is temporary" ;)
2023-02-20 19:54:08 +0100 <eldritchcookie[m> which monad are you writing your code in?
2023-02-20 19:54:27 +0100 <EvanR> rather than IO for a pure function that might fail you could use a -> Maybe b
2023-02-20 19:55:19 +0100 <EvanR> if the might fail isn't pure... that's another story
2023-02-20 19:55:26 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-02-20 19:56:13 +0100 <EvanR> one way around that is pretend it can't fail, on failure return (the same) nonsense
2023-02-20 19:57:35 +0100 <geekosaur> re FIXME, there is nothing so permanent as a temporary bandaid
2023-02-20 19:57:53 +0100 <monochrom> ghostbuster: Paul Hudak's "Haskell School of Music" https://www.cs.yale.edu/homes/hudak/Papers/HSoM.pdf
2023-02-20 20:00:55 +0100 <Guillaum[m]> eldritch cookie: the callback function is technically a `Vector Float -> Vector Float` one, so I have not much freedom here.
2023-02-20 20:04:28 +0100wootehfoot(~wootehfoo@user/wootehfoot)
2023-02-20 20:04:28 +0100 <eldritchcookie[m> is it exactly Float? or just Floating type class?
2023-02-20 20:04:47 +0100zeenk(~zeenk@2a02:2f04:a214:1e00::7fe) (Quit: Konversation terminated!)
2023-02-20 20:07:59 +0100czy(~user@host-140-23.ilcub310.champaign.il.us.clients.pavlovmedia.net)
2023-02-20 20:10:28 +0100 <Guillaum[m]> eldritch cookie: That's `Float`
2023-02-20 20:11:04 +0100elbear(~lucian@188.25.92.21)
2023-02-20 20:14:06 +0100 <eldritchcookie[m> ok you said technically so i thought either it isn't a Vector or not Float
2023-02-20 20:14:13 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-02-20 20:14:43 +0100 <eldritchcookie[m> can you say which library it is you are using for me to avoid?
2023-02-20 20:15:11 +0100elbear(~lucian@188.25.92.21) (Ping timeout: 248 seconds)
2023-02-20 20:15:53 +0100 <eldritchcookie[m> how are the Floats used maybe you could try sending all -1s?
2023-02-20 20:16:17 +0100elbear(~lucian@188.25.92.21)
2023-02-20 20:17:24 +0100 <Guillaum[m]> eldritch cookie: That's hmatrix-sundials. But the problem is that there is no way to interrupt the solving in this context, so putting `-1` in the Vector is fine, but how do I detect that something was wrong during the solving.
2023-02-20 20:17:24 +0100 <Guillaum[m]> I'll patch the lib, that's fine, no need to avoid it, really.
2023-02-20 20:17:31 +0100hexagoxel(~hexagoxel@2a01:4f8:c0c:e::2)
2023-02-20 20:18:26 +0100 <eldritchcookie[m> what does this return? maybe you could try using the Cont Monad to invert control
2023-02-20 20:20:06 +0100hexagoxel(~hexagoxel@2a01:4f8:c0c:e::2) (Quit: ZNC 1.8.2+deb2+b1 - https://znc.in)
2023-02-20 20:21:37 +0100 <EvanR> Guillaum[m], "empty vector" is a valid Vector Float xD
2023-02-20 20:22:52 +0100 <Guillaum[m]> EvanR: haha, you are right, and actually, that's something which should be tested. Maybe the library will stop in the event the outptu vector is not of the right size (or maybe it will just read / write garbage somewhere in RAM and someone will die, let's try ;)
2023-02-20 20:23:01 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 246 seconds)
2023-02-20 20:27:28 +0100gpncarl_(~gpncarl@222.249.231.4)
2023-02-20 20:28:31 +0100Square(~Square4@user/square)
2023-02-20 20:30:14 +0100gpncarl(~gpncarl@222.249.231.4) (Ping timeout: 268 seconds)
2023-02-20 20:34:02 +0100freeside(~mengwong@103.252.202.170)
2023-02-20 20:37:02 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-02-20 20:39:49 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 246 seconds)
2023-02-20 20:40:18 +0100 <eldritchcookie[m> wow finally found a place where implicitParams are better than ReaderT, you can use a function that has implicitParams as normal IE i can give to fmap a function of type (?implicit :: c ) => a -> b
2023-02-20 20:44:20 +0100 <EvanR> that's pretty cool
2023-02-20 20:45:35 +0100phma(~phma@2001:5b0:2144:4228:838a:a514:d9cb:e024) (Read error: Connection reset by peer)
2023-02-20 20:45:36 +0100 <akadude[m]> Have you seen any attempts to create classes for algebraic structures that would tie Monoids with Semigroups and other structures that depend on more than 1 Monoid? Purescript seems to try pretty hard to make nice classes, but their Semiring is still completely independent of Monoids. I've proved that it's possible here: https://github.com/Mr-Andersen/newtype-algebra but I still don't understand why it wasn't implemented in Purescript,
2023-02-20 20:45:36 +0100 <akadude[m]> seems pretty easy
2023-02-20 20:46:50 +0100phma(phma@2001:5b0:210d:d318:8379:59cc:8734:cbbf)
2023-02-20 20:46:57 +0100random-jellyfish(~random-je@user/random-jellyfish)
2023-02-20 20:48:50 +0100mikess_(~sam@user/mikess)
2023-02-20 20:49:50 +0100 <EvanR> there are a lot of those on hackage
2023-02-20 20:50:05 +0100 <EvanR> an embarrassment of riches
2023-02-20 20:50:09 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-02-20 20:51:01 +0100mikess(~sam@user/mikess) (Ping timeout: 246 seconds)
2023-02-20 20:52:03 +0100 <akadude[m]> Oh really
2023-02-20 20:53:23 +0100 <ghostbuster> monochrom: cool thanks
2023-02-20 20:54:31 +0100Inst(~Inst@2601:6c4:4081:54f0:254f:b13a:16f3:9f7c) (Read error: Connection reset by peer)
2023-02-20 20:54:54 +0100Square(~Square4@user/square) (Ping timeout: 268 seconds)
2023-02-20 20:54:55 +0100Inst(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240)
2023-02-20 20:56:05 +0100Guest5(~Guest5@45.92.120.189)
2023-02-20 20:56:43 +0100Guest5(~Guest5@45.92.120.189) (Client Quit)
2023-02-20 21:00:06 +0100nschoe(~q@2a01:e0a:8e:a190:e3e4:2623:c51a:3dd4)
2023-02-20 21:03:16 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2023-02-20 21:03:24 +0100a_coll(~acoll@45.92.120.189)
2023-02-20 21:03:39 +0100geekosaur(~geekosaur@xmonad/geekosaur)
2023-02-20 21:12:46 +0100 <ghostbuster> i've found several guides including that book and LYAH that suggest this syntax is valid... circumference :: Float -> Float
2023-02-20 21:12:56 +0100 <ghostbuster> but when i enter that in ghci, i get an error
2023-02-20 21:13:10 +0100 <ghostbuster> i'm not sure what it's supposed to do, but it's styled in the guides as if it's something that should be entered
2023-02-20 21:13:34 +0100 <geekosaur> if you're using ghci, you need to group it with the actual binding with semicolons or :{ :}
2023-02-20 21:13:53 +0100 <geekosaur> ghci doesn't know if you're going to type the binding on the next line or not
2023-02-20 21:14:17 +0100 <ghostbuster> ah
2023-02-20 21:14:23 +0100 <geekosaur> better is to put stuff in a file and :load it
2023-02-20 21:18:05 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 255 seconds)
2023-02-20 21:28:54 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-02-20 21:30:49 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-02-20 21:34:57 +0100freeside(~mengwong@103.252.202.170)
2023-02-20 21:37:36 +0100 <ph88> hi all i am trying to use websockets based off this example https://jaspervdj.be/websockets/example.html my code is here https://bpa.st/Q43LO which is just a simplification of the example code. Whenever i send a message to the websocket it sends Hello back and then hangs up the connection. How can i keep the connection open ?
2023-02-20 21:39:27 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 248 seconds)
2023-02-20 21:39:40 +0100wootehfoot(~wootehfoo@user/wootehfoot) (Quit: Leaving)
2023-02-20 21:42:05 +0100wootehfoot(~wootehfoo@user/wootehfoot)
2023-02-20 21:45:16 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 246 seconds)
2023-02-20 21:46:40 +0100mei(~mei@user/mei) (Ping timeout: 246 seconds)
2023-02-20 21:49:49 +0100nschoe(~q@2a01:e0a:8e:a190:e3e4:2623:c51a:3dd4) (Ping timeout: 246 seconds)
2023-02-20 21:55:37 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-02-20 21:58:42 +0100elbear(~lucian@188.25.92.21) (Ping timeout: 255 seconds)
2023-02-20 21:58:43 +0100 <ddellacosta> ph88: you have to loop with a recursive function, or forever, or etc. inside of the do block you pass to withPingThread. It just stops as soon as the IO action you pass it is complete.
2023-02-20 21:59:54 +0100 <dsal> Hmm... At that point, it's not clear how `clients` changes.
2023-02-20 22:01:18 +0100ozkutuk53(~ozkutuk@176.240.174.60)
2023-02-20 22:03:05 +0100 <dsal> ph88: Here's an example handler that I use in my GoPro web UI to stream the server-side log events to the client: https://github.com/dustin/gopro/blob/master/src/GoPro/Commands/Web.hs#L61-L65 -- basically what ddellacosta said
2023-02-20 22:03:28 +0100andrewboltachev(~andrey@178.141.125.176)
2023-02-20 22:03:59 +0100elevenkb(~elevenkb@105.226.22.146)
2023-02-20 22:04:14 +0100andrewboltachev(~andrey@178.141.125.176) ()
2023-02-20 22:06:37 +0100ph88(~ph88@ip5b426553.dynamic.kabel-deutschland.de) (Ping timeout: 246 seconds)
2023-02-20 22:08:11 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-02-20 22:08:39 +0100L29Ah(~L29Ah@wikipedia/L29Ah) ()
2023-02-20 22:11:03 +0100L29Ah(~L29Ah@wikipedia/L29Ah)
2023-02-20 22:14:03 +0100strychnic(~jade@113.184.75.78)
2023-02-20 22:14:14 +0100strychnic(~jade@113.184.75.78) (K-Lined)
2023-02-20 22:16:06 +0100L29Ah(~L29Ah@wikipedia/L29Ah) (Read error: Connection reset by peer)
2023-02-20 22:16:14 +0100slack1256(~slack1256@186.11.53.84)
2023-02-20 22:16:32 +0100falafel(~falafel@2607:fb91:143f:e47f:c71e:8658:fcaf:8a93)
2023-02-20 22:21:15 +0100falafel(~falafel@2607:fb91:143f:e47f:c71e:8658:fcaf:8a93) (Ping timeout: 260 seconds)
2023-02-20 22:22:02 +0100ph88(~ph88@ip5b426553.dynamic.kabel-deutschland.de)
2023-02-20 22:22:07 +0100 <slack1256> I remember there was a hackage sub-page sorting packages by extension used. I am looking for the usage of -XLinearTypes in the wild.
2023-02-20 22:22:41 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-02-20 22:23:41 +0100L29Ah(~L29Ah@wikipedia/L29Ah)
2023-02-20 22:24:31 +0100azathough(uid589374@user/azathough) (Quit: Connection closed for inactivity)
2023-02-20 22:24:57 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53) (Quit: segfaultfizzbuzz)
2023-02-20 22:25:18 +0100 <geekosaur> sounds to me like your best bet is to look for revdeps of linear-base
2023-02-20 22:25:42 +0100pavonia(~user@user/siracusa)
2023-02-20 22:25:45 +0100 <slack1256> Sounds like it.
2023-02-20 22:26:31 +0100 <geekosaur> https://packdeps.haskellers.com/reverse/linear-base but that's a pretty paltry list…
2023-02-20 22:27:27 +0100ph88(~ph88@ip5b426553.dynamic.kabel-deutschland.de) (Ping timeout: 248 seconds)
2023-02-20 22:28:19 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-02-20 22:28:36 +0100L29Ah(~L29Ah@wikipedia/L29Ah) (Read error: Connection reset by peer)
2023-02-20 22:31:35 +0100 <davean> I couldn't even manage to write a correct program that did a disk merge sort with it :/
2023-02-20 22:31:57 +0100ubert(~Thunderbi@p200300ecdf1301ae3ee9643eaa29223e.dip0.t-ipconnect.de)
2023-02-20 22:32:27 +0100dcoutts_(~duncan@host86-167-90-212.range86-167.btcentralplus.com) (Ping timeout: 255 seconds)
2023-02-20 22:32:31 +0100 <davean> I mean just the merge portion infact
2023-02-20 22:33:40 +0100 <slack1256> davean: I lost the context, you mean with -XLinearTypes you could make a merge sort type check?
2023-02-20 22:33:49 +0100 <slack1256> could *not*
2023-02-20 22:34:09 +0100khumba(~khumba@user/khumba)
2023-02-20 22:34:16 +0100son0p(~ff@181.136.122.143) (Ping timeout: 246 seconds)
2023-02-20 22:34:27 +0100 <davean> One that merged contents of filehandles
2023-02-20 22:34:46 +0100 <davean> Several of us coudln't figure out how to deal with exceptions with it - infact proved all approaches we could think of couldn't work
2023-02-20 22:34:59 +0100jero98772(~jero98772@2800:484:1d80:d8ce:efcc:cbb3:7f2a:6dff) (Ping timeout: 264 seconds)
2023-02-20 22:36:28 +0100jero98772(~jero98772@2800:484:1d80:d8ce:9bb4:3da:515:fe96)
2023-02-20 22:38:02 +0100 <davean> I'd really like to see a 2 file disk merge implimented with it. I'd find it very informative and its a very simple problem.
2023-02-20 22:38:19 +0100 <davean> (one that specificly is exception safe for a POSIX enviroment)
2023-02-20 22:39:25 +0100ph88(~ph88@ip5b426553.dynamic.kabel-deutschland.de)
2023-02-20 22:41:16 +0100 <ph88> ddellacosta, i already see one forever here in the source code https://hackage.haskell.org/package/websockets-0.12.7.3/docs/src/Network.WebSockets.Server.html#ru… why would i need another one in my user code ?
2023-02-20 22:46:35 +0100lyle(~lyle@104.246.145.237) (Quit: WeeChat 3.8)
2023-02-20 22:46:52 +0100ubert(~Thunderbi@p200300ecdf1301ae3ee9643eaa29223e.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-02-20 22:47:10 +0100ubert(~Thunderbi@p200300ecdf130131a36700041663782c.dip0.t-ipconnect.de)
2023-02-20 22:47:47 +0100Midjak(~Midjak@82.66.147.146) (Quit: This computer has gone to sleep)
2023-02-20 22:48:41 +0100stackdroid18(14094@de1.hashbang.sh)
2023-02-20 23:00:23 +0100michalz(~michalz@185.246.207.221) (Remote host closed the connection)
2023-02-20 23:00:24 +0100jespada_(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net)
2023-02-20 23:00:38 +0100L29Ah(~L29Ah@wikipedia/L29Ah)
2023-02-20 23:03:02 +0100dcoutts_(~duncan@host86-167-90-212.range86-167.btcentralplus.com)
2023-02-20 23:03:08 +0100elevenkb(~elevenkb@105.226.22.146) (Ping timeout: 260 seconds)
2023-02-20 23:03:47 +0100jespada(~jespada@77.98.179.16) (Ping timeout: 252 seconds)
2023-02-20 23:08:45 +0100 <danso> is there a way to deriving Semigroup and Monoid for obvious `data` types?
2023-02-20 23:08:52 +0100 <danso> looking at this: https://danso.ca/tmp/derivable.txt
2023-02-20 23:09:00 +0100 <danso> this code is fully boilerplate
2023-02-20 23:09:23 +0100 <danso> is there an extension to enable deriving this maybe?
2023-02-20 23:09:29 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-02-20 23:10:26 +0100 <danso> if i changed the definition to `newtype Record = Record (Int,String)` then i could do it with GNT
2023-02-20 23:10:39 +0100 <danso> but is it possible with `data`?
2023-02-20 23:10:56 +0100 <danso> s/GND/GNT/
2023-02-20 23:11:22 +0100 <slack1256> > (8 :: Int) <> (9 :: Int)
2023-02-20 23:11:24 +0100 <lambdabot> error:
2023-02-20 23:11:24 +0100 <lambdabot> • No instance for (Semigroup Int) arising from a use of ‘<>’
2023-02-20 23:11:24 +0100 <lambdabot> • In the expression: (8 :: Int) <> (9 :: Int)
2023-02-20 23:11:45 +0100 <slack1256> danso: That code is wrong, Int does not have a default Semigroup instance.
2023-02-20 23:11:47 +0100 <danso> ah i forgot there's no default Monoid instance for Int
2023-02-20 23:11:54 +0100 <danso> but assume there is one defined ;^)
2023-02-20 23:12:10 +0100 <geekosaur> nobody has implemented such an extension as yet]
2023-02-20 23:12:30 +0100 <geekosaur> https://downloads.haskell.org/ghc/9.6.1-alpha3/docs/users_guide/exts/deriving_extra.html
2023-02-20 23:13:28 +0100 <geekosaur> and it's not clear that there should be, because for e.g. Int there is no unique Semigroup for it
2023-02-20 23:14:03 +0100 <danso> yes, using Int in my example was a poor choice
2023-02-20 23:14:16 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-02-20 23:14:46 +0100 <geekosaur> there's Sum, Product, Min, Max, etc.
2023-02-20 23:14:58 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-02-20 23:16:06 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Ping timeout: 255 seconds)
2023-02-20 23:18:00 +0100a_coll(~acoll@45.92.120.189) (Leaving)
2023-02-20 23:18:08 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6111:c483:164:5daf) (Remote host closed the connection)
2023-02-20 23:21:39 +0100wootehfoot(~wootehfoo@user/wootehfoot) (Quit: Leaving)
2023-02-20 23:25:33 +0100 <AWizzArd> Is the GADTSyntax mostly there to simplify the implementation of the GADT extension?
2023-02-20 23:25:47 +0100 <AWizzArd> Is the GADTSyntax extension mostly there to simplify the implementation of the GADT extension?
2023-02-20 23:26:24 +0100 <akadude[m]> deriving via Generically A instance Monoid A I think is the closest you get to automatic deriving
2023-02-20 23:26:37 +0100 <c_wraith> AWizzArd: I think it actually came from the other direction. Some people prefer the GADT syntax, and asked for it to be allowed without enabling GADTs
2023-02-20 23:27:13 +0100elevenkb(~elevenkb@105.226.22.146)
2023-02-20 23:27:21 +0100 <AWizzArd> c_wraith: ah okay, I see. I thought that when working on GADT they realized "Hey, now that we have the syntax let’s seperate those concerns and make that too an extension".
2023-02-20 23:27:38 +0100 <AWizzArd> But yeah, such thoughts regularly come afterwards.
2023-02-20 23:29:46 +0100 <gqplox[m]> hi guys bit off topic but does anyone know the color scheme used in the haskell.hackage source website
2023-02-20 23:29:48 +0100 <gqplox[m]> e.g. https://hackage.haskell.org/package/base-4.17.0.0/docs/src/Data.Foldable.html#minimum
2023-02-20 23:30:32 +0100 <geekosaur> whatever the version of haddock used to produce that documentation uses by default, I think
2023-02-20 23:34:59 +0100son0p(~ff@181.136.122.143)
2023-02-20 23:42:33 +0100elevenkb(~elevenkb@105.226.22.146) (Quit: Client closed)
2023-02-20 23:43:04 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-02-20 23:44:26 +0100elevenkb(~elevenkb@105.226.22.146)
2023-02-20 23:47:18 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6111:c483:164:5daf)