IRCBrowse

2023/03/01

2023-03-01 00:00:59 +0100 <c_wraith> Ashkan: This is also a space where a bit of bog-standard software engineering can resolve a lot of issues. Like if you meaningfully stripe your data structures to reduce update conflicts, you've made a massive improvement no matter which approach you're using.
2023-03-01 00:01:28 +0100 <hpc> probably just need to rename those constructors then?
2023-03-01 00:03:05 +0100 <Ashkan> I was thinking, if perhaps there is something to the effect of `StateT` but for concurrent access ?
2023-03-01 00:03:44 +0100 <segfaultfizzbuzz> [Leary]: well,... if the invariant breaks internally then at the very least the outside will encounter a delay as it is being restored
2023-03-01 00:03:50 +0100slack1256(~slack1256@186.11.13.167)
2023-03-01 00:03:55 +0100 <hpc> Ashkan: that's what STM and such are :P
2023-03-01 00:04:14 +0100 <hpc> there's no getting around that concurrency is tricky
2023-03-01 00:05:34 +0100 <Ashkan> Yeah but STM is more like modify in-place, *mutable* shared state but in `StateT` nothing is mutated. I was thinking could it be that there is a state monad but for concurrent access. Maybe it doesn't make sense. Too much cognitive load for my peanut Scala brain:D
2023-03-01 00:06:08 +0100 <c_wraith> Ashkan: there are ideas like CSP
2023-03-01 00:06:18 +0100 <hpc> the value inside isn't mutated, just what value TVars point to
2023-03-01 00:06:30 +0100 <hpc> in a (TVar Int), that Int value isn't suddenly mutable, it just gets switched out
2023-03-01 00:06:31 +0100 <[Leary]> segfaultfizzbuzz: That's not important. What matters is that the program never sees data violating the invariant.
2023-03-01 00:06:45 +0100 <hpc> the TVar part is what mutates
2023-03-01 00:06:49 +0100 <segfaultfizzbuzz> ok...
2023-03-01 00:07:34 +0100 <c_wraith> Ashkan: a library like https://hackage.haskell.org/package/chp gives you access to something a lot like go channels. (They're also based on CSP.) They are much more constrained than general mutable cells
2023-03-01 00:08:14 +0100 <hpc> segfaultfizzbuzz: for an example of mutation that's abstracted over the way [Leary] talks about, imagine a really slow thunk
2023-03-01 00:08:18 +0100 <c_wraith> .... though that library is old enough I'm not sure if it still builds...
2023-03-01 00:08:20 +0100 <hpc> like the thunk for (busyBeaver 5)
2023-03-01 00:08:38 +0100 <segfaultfizzbuzz> lol busyBeaver 5
2023-03-01 00:08:40 +0100 <hpc> it eventually resolves to an Int, and the first time you evaluate it your computer gets warm
2023-03-01 00:08:55 +0100 <hpc> the thunk gets mutated so instead of calculating it just produces the value
2023-03-01 00:08:56 +0100 <Ashkan> hpc hmm ... should think on it some more. I thought since concurrent access means sequencing is essentially lost, then talking *monadic* access is meaningless hence the shared states becomes mutable in nature
2023-03-01 00:09:01 +0100 <hpc> (this is actually how ghc works)
2023-03-01 00:09:12 +0100 <segfaultfizzbuzz> ok...
2023-03-01 00:09:16 +0100 <c_wraith> hpc: I don't think there's a Haskell implementation where Int is large enough to hold the result of busybeaver 5
2023-03-01 00:09:48 +0100 <hpc> c_wraith: your install doesn't have Int1267650600228229401496703205376?
2023-03-01 00:10:00 +0100 <c_wraith> let me double-check
2023-03-01 00:10:19 +0100 <hpc> :D
2023-03-01 00:10:21 +0100 <c_wraith> I don't even have something as cool as Int128
2023-03-01 00:10:25 +0100thegeekinside(~thegeekin@189.180.66.126) (Remote host closed the connection)
2023-03-01 00:11:00 +0100 <hpc> segfaultfizzbuzz: anyhoo, there's even a mutation before it starts evaluating
2023-03-01 00:11:27 +0100 <hpc> segfaultfizzbuzz: if you've ever written a loop that results in just printing <loop>, you've encountered that modified thunk
2023-03-01 00:11:42 +0100stackdroid18(14094@de1.hashbang.sh)
2023-03-01 00:11:45 +0100 <hpc> a thunk currently being evaluated gets modified so re-entering it detects a loop
2023-03-01 00:11:56 +0100 <c_wraith> oh, huh. This blog post I'm re-reading is bringing up an idea closely related to busy beavers. fun!
2023-03-01 00:11:57 +0100 <hpc> (or makes the thread go to sleep until something else can kill it, in the threaded runtime)
2023-03-01 00:12:31 +0100 <hpc> > fix id
2023-03-01 00:12:33 +0100 <lambdabot> *Exception: <<loop>>
2023-03-01 00:12:54 +0100 <hpc> ghc didn't solve the halting problem :P
2023-03-01 00:12:58 +0100 <c_wraith> the GC can kill a thread blocked on itself in the threaded runtime. I was surprised the first time I discovered that.
2023-03-01 00:13:50 +0100 <hpc> oh, that's neat
2023-03-01 00:14:01 +0100 <segfaultfizzbuzz> oh wow really
2023-03-01 00:14:04 +0100 <c_wraith> But it makes sense. the GC is all about tracking dependencies around
2023-03-01 00:14:36 +0100 <c_wraith> It obviously can't detect *all* evaluation loops, as some are too complex for it. But it can detect a lot of simplified ones.
2023-03-01 00:16:31 +0100 <hpc> in javascript, one might write a thunk as var thunk = function() {result = calculation(); thunk = function() {return result}; return result}
2023-03-01 00:17:02 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 246 seconds)
2023-03-01 00:17:54 +0100opticblast(~Thunderbi@172.58.82.191) (Quit: opticblast)
2023-03-01 00:18:13 +0100opticblast(~Thunderbi@172.58.82.191)
2023-03-01 00:18:19 +0100 <hpc> although probably not that exact way, you would have a hard time passing thunk around, but you get the idea
2023-03-01 00:20:50 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef)
2023-03-01 00:22:42 +0100opticblast(~Thunderbi@172.58.82.191) (Ping timeout: 255 seconds)
2023-03-01 00:25:06 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef) (Ping timeout: 252 seconds)
2023-03-01 00:29:40 +0100Ashkan(~Ashkan@a119011.upc-a.chello.nl) (Quit: Client closed)
2023-03-01 00:34:23 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com)
2023-03-01 00:39:10 +0100 <ph88> is it possible to make GADT without type variable ?
2023-03-01 00:40:40 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-03-01 00:40:48 +0100 <hpc> it wouldn't be a GADT, but the syntax is still available
2023-03-01 00:40:52 +0100 <geekosaur> ? you can use GADT syntax but I don't think a GADT is meaningful without a type variable
2023-03-01 00:40:58 +0100 <hpc> you can even get just the syntax with the GADTSyntax extension
2023-03-01 00:41:18 +0100 <mauke> my game is not tiny enough :-(
2023-03-01 00:41:26 +0100opticblast(~Thunderbi@172.58.82.191)
2023-03-01 00:43:23 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-03-01 00:45:52 +0100bontaq(~user@ool-45779fe5.dyn.optonline.net) (Ping timeout: 252 seconds)
2023-03-01 00:46:08 +0100 <ph88> hpc, geekosaur understood thank you
2023-03-01 00:51:39 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 248 seconds)
2023-03-01 00:52:10 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-03-01 00:52:44 +0100 <geekosaur> what are you trying to accomplish?
2023-03-01 00:52:45 +0100xff0x(~xff0x@ai081074.d.east.v6connect.net) (Ping timeout: 246 seconds)
2023-03-01 00:53:09 +0100xff0x(~xff0x@178.255.149.135)
2023-03-01 00:54:38 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds)
2023-03-01 00:56:39 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 260 seconds)
2023-03-01 00:58:24 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-03-01 00:59:24 +0100 <ph88> geekosaur, this is my code from my editor https://bpa.st/IWBKA i'm trying to model all possible state transitions. (see links in documentation) .. i'm not sure if it's going to work like this, do you have a better idea ?
2023-03-01 01:00:35 +0100 <ph88> trying to model it with inspiration from this post https://stackoverflow.com/a/28696299/1833322
2023-03-01 01:02:30 +0100 <ph88> i think i'm going to throw this code away .. it looks so ugly to making all these names for the data constructors :(
2023-03-01 01:04:35 +0100acidjnk_new(~acidjnk@p200300d6e715c4929ccd0d51d52c8268.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2023-03-01 01:06:21 +0100xff0x(~xff0x@178.255.149.135) (Ping timeout: 255 seconds)
2023-03-01 01:06:33 +0100forell(~forell@user/forell) (Ping timeout: 252 seconds)
2023-03-01 01:07:21 +0100 <geekosaur> kinda sorry I asked; type level in haskell drives me bonkers. maybe when we have actual dependent haskell…
2023-03-01 01:07:50 +0100mauke_(~mauke@user/mauke)
2023-03-01 01:08:26 +0100xff0x(~xff0x@ai081074.d.east.v6connect.net)
2023-03-01 01:09:06 +0100 <mon_aaraj> i love dependent types! i love idris and agda a lot... but i kind of feel like adding them to haskell is too much, no?
2023-03-01 01:09:15 +0100mauke(~mauke@user/mauke) (Ping timeout: 248 seconds)
2023-03-01 01:09:15 +0100mauke_mauke
2023-03-01 01:10:08 +0100 <mon_aaraj> the GHC team seems to be biting off more than they can chew already, and I think the language is awesome in all honestly -- we just need huge clean ups or rewrites of the code and some more optimizations
2023-03-01 01:10:13 +0100 <ph88> geekosaur, no worries, thanks for offering help anyway
2023-03-01 01:10:31 +0100 <ph88> mon_aaraj, what do you think of my paste ? is it doable ?
2023-03-01 01:10:34 +0100 <hpc> mon_aaraj: some say haskell has gone too far, but i say it hasn't gone too far enough
2023-03-01 01:10:48 +0100forell(~forell@user/forell)
2023-03-01 01:11:09 +0100 <mon_aaraj> hpc: haha! you may be right
2023-03-01 01:11:36 +0100 <c_wraith> There are some things that just aren't practical in current Haskell and would be way better with just a couple dependent features. Just having Pi types would allow type classes to vary on values, for instance.
2023-03-01 01:11:42 +0100 <mon_aaraj> i just wish GHC gets way more funding (especially tooling, cabal and ghcup) and more working hands on it (especially the compiler for this)
2023-03-01 01:12:40 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-03-01 01:13:02 +0100 <c_wraith> You can sort of fake classes that vary on values using reflection, but reflection is a horrible hack with unsafeCoerce at the core. Not using it makes things much more dependable
2023-03-01 01:14:18 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) (Quit: Leaving.)
2023-03-01 01:14:27 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 255 seconds)
2023-03-01 01:16:01 +0100 <mon_aaraj> also -- what's the benefit of encoding all of this in the type system? you can do the type level stuff in the value level rather easily
2023-03-01 01:16:37 +0100 <ph88> c_wraith, what do you think of package singletons ?
2023-03-01 01:17:13 +0100 <c_wraith> ph88: it has some shocking holes in it, like... Float and Double
2023-03-01 01:17:20 +0100 <ph88> hpc, maybe liquid haskell is something you would like to try
2023-03-01 01:17:38 +0100 <hpc> maybe
2023-03-01 01:17:59 +0100 <c_wraith> mon_aaraj: you get to use pre-existing tools like foldMap if you have a Monoid instance available.
2023-03-01 01:18:00 +0100 <ph88> c_wraith, what is missing with float and double ?
2023-03-01 01:18:09 +0100 <c_wraith> ph88: you can't promote them to the type level
2023-03-01 01:18:37 +0100 <ph88> ah ye
2023-03-01 01:19:02 +0100 <mon_aaraj> c_wraith: Ah, sorry. I didn't mean as in response to you, in response to ph88's source code.
2023-03-01 01:19:23 +0100 <c_wraith> Oh, hah. no problem. :)
2023-03-01 01:19:29 +0100 <mon_aaraj> In reality I think it's just not useful to do this at the type level at all. But I'm not really sure why one would do it in the first place
2023-03-01 01:19:48 +0100 <mon_aaraj> * In reality I think it's just not useful to implement this specific thing at the type level at all. But I'm not really sure why one would do it in the first place
2023-03-01 01:19:55 +0100 <ph88> mon_aaraj, i thought it was nice to have type level guarantees .. if only it would work ..
2023-03-01 01:20:26 +0100 <ph88> mon_aaraj, check this presentation for background https://www.lambdadays.org/static/upload/media/1519637389130819oskarwickstromfinitestatemachines_.…
2023-03-01 01:20:29 +0100 <c_wraith> ph88: I think you've identified the problem. It would be nice... if it worked. :)
2023-03-01 01:20:56 +0100 <ph88> c_wraith, i am still blaiming it on my own ignorance than compiler limitations :p
2023-03-01 01:21:15 +0100 <mon_aaraj> Meh, doing this at the type level won't really guarantee much for you. It's a lot of work for almost no benefit. You'll still get guarantees from the type system if you implement it at the value level too.
2023-03-01 01:21:42 +0100 <mon_aaraj> You very much _can_ do it, but you shouldn't. Maybe I should find the "you've spent so long thinking about if you could, you've never stopped to think if you should" meme, but I'm too lazy.
2023-03-01 01:23:58 +0100 <ph88> ok i give up
2023-03-01 01:25:09 +0100mrcsno(~mrcsno@71.69.152.220) (Ping timeout: 255 seconds)
2023-03-01 01:27:46 +0100 <hpc> sometimes instead of making sure you write correct code, you should write correct code instead?
2023-03-01 01:34:56 +0100stackdroid18(14094@de1.hashbang.sh) (Quit: hasta la vista... tchau!)
2023-03-01 01:36:47 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 264 seconds)
2023-03-01 01:46:33 +0100zeenk(~zeenk@2a02:2f04:a20d:f900::7fe) (Quit: Konversation terminated!)
2023-03-01 01:49:16 +0100dextaa(~DV@user/dextaa) (Quit: Ping timeout (120 seconds))
2023-03-01 01:52:35 +0100ph88(~ph88@ip5b426553.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2023-03-01 01:54:00 +0100dextaa(~DV@user/dextaa)
2023-03-01 01:59:16 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com)
2023-03-01 02:02:06 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-03-01 02:03:10 +0100califax(~califax@user/califx)
2023-03-01 02:04:32 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-03-01 02:04:32 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-03-01 02:04:32 +0100wroathe(~wroathe@user/wroathe)
2023-03-01 02:05:07 +0100 <mauke> https://github.com/mauke/mini-mine/blob/main/app/Main.hs I made a small, but unfortunately not tiny, game
2023-03-01 02:05:27 +0100 <mauke> (it's 15 lines, not 10)
2023-03-01 02:09:58 +0100thegeekinside(~thegeekin@189.180.66.126)
2023-03-01 02:10:47 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-03-01 02:13:32 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-01 02:15:49 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com)
2023-03-01 02:16:27 +0100dextaa(~DV@user/dextaa) (Ping timeout: 260 seconds)
2023-03-01 02:16:54 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-03-01 02:18:47 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 264 seconds)
2023-03-01 02:20:31 +0100dextaa(~DV@user/dextaa)
2023-03-01 02:22:20 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef)
2023-03-01 02:26:35 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef) (Ping timeout: 248 seconds)
2023-03-01 02:30:26 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-03-01 02:37:57 +0100 <sm> nice! might fit in the next jam
2023-03-01 02:42:07 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 260 seconds)
2023-03-01 02:43:16 +0100 <mauke> I only started like 5 hours before the deadline, and predictably ran out of time :-)
2023-03-01 02:45:44 +0100dextaa(~DV@user/dextaa) (Quit: Ping timeout (120 seconds))
2023-03-01 02:48:59 +0100 <sm> 10 lines can soak up a lot of hours :)
2023-03-01 02:50:04 +0100 <davean> More than 15 lines can! ;)
2023-03-01 02:50:12 +0100dextaa(~DV@user/dextaa)
2023-03-01 02:52:59 +0100thegeekinside(~thegeekin@189.180.66.126) (Ping timeout: 264 seconds)
2023-03-01 02:53:52 +0100thegeekinside(~thegeekin@189.141.115.134)
2023-03-01 03:06:15 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 256 seconds)
2023-03-01 03:07:10 +0100kritzefitz(~kritzefit@debian/kritzefitz) (Ping timeout: 246 seconds)
2023-03-01 03:07:23 +0100kritzefitz(~kritzefit@debian/kritzefitz)
2023-03-01 03:07:51 +0100xff0x(~xff0x@ai081074.d.east.v6connect.net) (Ping timeout: 255 seconds)
2023-03-01 03:08:29 +0100czy(~user@host-140-25.ilcub310.champaign.il.us.clients.pavlovmedia.net) (Quit: ERC 5.4.1 (IRC client for GNU Emacs 30.0.50))
2023-03-01 03:08:45 +0100 <ddellacosta> so I am reading about async exceptions and bound threads, and how a thread may not respond if a FFI call is being made. The workaround I'm reading is to spawn the FFI call in an async itself. However, this doesn't actually end the process/FFI call--is there any way to explicitly do that somehow?
2023-03-01 03:08:47 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-03-01 03:08:53 +0100czy(~user@host-140-25.ilcub310.champaign.il.us.clients.pavlovmedia.net)
2023-03-01 03:09:32 +0100 <davean> No, its not a seperate PROCESS
2023-03-01 03:10:21 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf) (Remote host closed the connection)
2023-03-01 03:10:21 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-03-01 03:10:41 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf)
2023-03-01 03:11:42 +0100 <ddellacosta> sorry I meant thread instead of process, in the case that you spawn a separate async in the manner I described
2023-03-01 03:19:17 +0100pavonia(~user@user/siracusa)
2023-03-01 03:20:54 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 268 seconds)
2023-03-01 03:20:56 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-03-01 03:22:15 +0100Lord_of_Life_Lord_of_Life
2023-03-01 03:26:22 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-03-01 03:29:54 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 252 seconds)
2023-03-01 03:32:11 +0100Square(~Square4@user/square) (Ping timeout: 248 seconds)
2023-03-01 03:34:32 +0100dsrt^(~dsrt@c-24-30-76-89.hsd1.ga.comcast.net)
2023-03-01 03:44:27 +0100opticblast1(~Thunderbi@172.58.85.161)
2023-03-01 03:45:39 +0100opticblast(~Thunderbi@172.58.82.191) (Ping timeout: 255 seconds)
2023-03-01 03:45:40 +0100opticblast1opticblast
2023-03-01 03:47:20 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-03-01 03:55:23 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 264 seconds)
2023-03-01 03:57:15 +0100thegeekinside(~thegeekin@189.141.115.134) (Ping timeout: 256 seconds)
2023-03-01 04:15:10 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-01 04:18:32 +0100jero98772(~jero98772@2800:484:1d80:d8ce:efcc:cbb3:7f2a:6dff) (Remote host closed the connection)
2023-03-01 04:24:33 +0100Everything(~Everythin@46.185.124.65)
2023-03-01 04:25:00 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-03-01 04:25:56 +0100gastus(~gastus@185.6.123.208)
2023-03-01 04:29:20 +0100gastus_(~gastus@185.6.123.141) (Ping timeout: 268 seconds)
2023-03-01 04:30:39 +0100ft(~ft@p3e9bc443.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
2023-03-01 04:31:53 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef)
2023-03-01 04:32:34 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-03-01 04:35:35 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-03-01 04:35:35 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-03-01 04:35:35 +0100finn_elijaFinnElija
2023-03-01 04:36:02 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-03-01 04:38:09 +0100td_(~td@i5387093D.versanet.de) (Ping timeout: 246 seconds)
2023-03-01 04:40:05 +0100td_(~td@i53870923.versanet.de)
2023-03-01 04:40:25 +0100slack1256(~slack1256@186.11.13.167) (Remote host closed the connection)
2023-03-01 04:41:28 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Quit: segfaultfizzbuzz)
2023-03-01 04:46:28 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-03-01 04:48:47 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 264 seconds)
2023-03-01 04:58:47 +0100razetime(~Thunderbi@117.193.3.64)
2023-03-01 05:00:13 +0100shailangsa(~shailangs@host165-120-169-78.range165-120.btcentralplus.com) (Ping timeout: 246 seconds)
2023-03-01 05:14:21 +0100m5zs7k(aquares@web10.mydevil.net) (Ping timeout: 268 seconds)
2023-03-01 05:16:20 +0100m5zs7k(aquares@web10.mydevil.net)
2023-03-01 05:18:40 +0100razetime(~Thunderbi@117.193.3.64) (Ping timeout: 252 seconds)
2023-03-01 05:21:53 +0100dsrt^(~dsrt@c-24-30-76-89.hsd1.ga.comcast.net) (Ping timeout: 246 seconds)
2023-03-01 05:22:39 +0100m5zs7k(aquares@web10.mydevil.net) (Ping timeout: 260 seconds)
2023-03-01 05:25:32 +0100dsrt^(~dsrt@c-24-30-76-89.hsd1.ga.comcast.net)
2023-03-01 05:25:53 +0100mbuf(~Shakthi@49.204.115.87)
2023-03-01 05:26:12 +0100jinsun__(~jinsun@user/jinsun)
2023-03-01 05:26:12 +0100jinsun(~jinsun@user/jinsun) (Killed (platinum.libera.chat (Nickname regained by services)))
2023-03-01 05:26:12 +0100jinsun__jinsun
2023-03-01 05:29:19 +0100jle`(~jle`@cpe-23-240-75-236.socal.res.rr.com) (Ping timeout: 248 seconds)
2023-03-01 05:29:56 +0100m5zs7k(aquares@web10.mydevil.net)
2023-03-01 05:31:14 +0100jle`(~jle`@cpe-23-240-75-236.socal.res.rr.com)
2023-03-01 05:33:36 +0100opticblast(~Thunderbi@172.58.85.161) (Quit: opticblast)
2023-03-01 05:33:49 +0100opticblast(~Thunderbi@172.58.82.223)
2023-03-01 05:34:43 +0100bliminse_(~bliminse@user/bliminse) (Ping timeout: 256 seconds)
2023-03-01 05:35:51 +0100m5zs7k(aquares@web10.mydevil.net) (Ping timeout: 256 seconds)
2023-03-01 05:36:23 +0100bliminse(~bliminse@user/bliminse)
2023-03-01 05:38:02 +0100opticblast(~Thunderbi@172.58.82.223) (Ping timeout: 255 seconds)
2023-03-01 05:38:28 +0100m5zs7k(aquares@web10.mydevil.net)
2023-03-01 05:39:09 +0100mrcsno(~mrcsno@71.69.152.220)
2023-03-01 05:41:34 +0100shailangsa_(~shailangs@host165-120-169-78.range165-120.btcentralplus.com)
2023-03-01 05:41:37 +0100czy(~user@host-140-25.ilcub310.champaign.il.us.clients.pavlovmedia.net) (Read error: Connection reset by peer)
2023-03-01 05:42:43 +0100Feuermagier_(~Feuermagi@user/feuermagier)
2023-03-01 05:45:14 +0100Feuermagier(~Feuermagi@user/feuermagier) (Ping timeout: 255 seconds)
2023-03-01 05:47:09 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 255 seconds)
2023-03-01 05:56:34 +0100Vajb(~Vajb@2001:999:230:f561:4ee8:ad7f:13ff:9959) (Read error: Connection reset by peer)
2023-03-01 05:56:45 +0100 <Axman6> ddellacosta: I would strongly recommend reading Simon Marlow's Parallel and Concurrent Haskell, there's really no better resource for understanding how exceptions and threading play with each other.
2023-03-01 05:56:51 +0100 <Axman6> @where pcph
2023-03-01 05:56:51 +0100 <lambdabot> "Parallel and Concurrent Programming in Haskell" by Simon Marlow in 2013 at <http://community.haskell.org/~simonmar/pcph/>,<http://chimera.labs.oreilly.com/books/1230000000929/>,<https://web.archive.
2023-03-01 05:56:51 +0100 <lambdabot> org/web/20180117194842/http://chimera.labs.oreilly.com/books/1230000000929>,<https://www.oreilly.com/library/view/parallel-and-concurrent/9781449335939/>
2023-03-01 05:56:59 +0100Vajb(~Vajb@hag-jnsbng11-58c3a5-27.dhcp.inet.fi)
2023-03-01 06:02:09 +0100kupi(uid212005@id-212005.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-03-01 06:03:10 +0100Vajb(~Vajb@hag-jnsbng11-58c3a5-27.dhcp.inet.fi) (Read error: Connection reset by peer)
2023-03-01 06:04:04 +0100Feuermagier_(~Feuermagi@user/feuermagier) (Quit: Leaving)
2023-03-01 06:04:47 +0100Vajb(~Vajb@2001:999:230:f561:4ee8:ad7f:13ff:9959)
2023-03-01 06:08:40 +0100polyphem_(~rod@2a02:810d:840:8754:224e:f6ff:fe5e:bc17) (Ping timeout: 252 seconds)
2023-03-01 06:09:54 +0100opticblast(~Thunderbi@172.58.85.161)
2023-03-01 06:10:20 +0100razetime(~Thunderbi@117.193.3.64)
2023-03-01 06:11:21 +0100cyphase(~cyphase@user/cyphase) (Ping timeout: 255 seconds)
2023-03-01 06:13:11 +0100johnw(~johnw@2600:1700:cf00:db0:90d9:7fcd:a65c:d4b3) (Quit: ZNC - http://znc.in)
2023-03-01 06:13:11 +0100jwiegley(~jwiegley@76-234-69-149.lightspeed.frokca.sbcglobal.net) (Quit: ZNC - http://znc.in)
2023-03-01 06:16:44 +0100cyphase(~cyphase@user/cyphase)
2023-03-01 06:17:12 +0100ddellacosta(~ddellacos@143.244.47.85) (Ping timeout: 246 seconds)
2023-03-01 06:35:34 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67)
2023-03-01 06:37:09 +0100Adran(~adran@botters/adran) (Quit: Este é o fim.)
2023-03-01 06:39:06 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-03-01 06:39:23 +0100califax(~califax@user/califx)
2023-03-01 06:39:26 +0100ddellacosta(~ddellacos@146.70.166.10)
2023-03-01 06:40:26 +0100xkuru(~xkuru@user/xkuru)
2023-03-01 06:45:01 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-01 06:45:16 +0100 <ddellacosta> Axman6: that was actually the book I was referencing when I asked the question, chapter 15, the section "Asychronous Exceptions and Foreign Calls." That is where I found the suggestion to make FFI calls using async, but I didn't see anything past that to understand if I can actually some how kill an FFI call somehow. I guess it just passes the same characteristics (not responding to async
2023-03-01 06:45:18 +0100 <ddellacosta> exceptions) on to the new thread that is running the FFI call. I'm probably missing something though.
2023-03-01 06:45:54 +0100Adran(adran@botters/adran)
2023-03-01 06:48:25 +0100 <Axman6> Well, what does it mean to kill an FFI call in the middle of running? It seems to me like it's more likely to be dangerous than not
2023-03-01 06:48:58 +0100JimL(~quassel@89-162-26-217.fiber.signal.no)
2023-03-01 06:49:25 +0100 <ddellacosta> I'm trying to run a Lua script in a fairly constrainted context, in multiple concurrent threads as needed, and I want those to be easily interruptible
2023-03-01 06:49:39 +0100JimL(~quassel@89-162-26-217.fiber.signal.no) (Client Quit)
2023-03-01 06:50:01 +0100 <ddellacosta> but I think I'm going to handle it by ensuring the scripts follow a given format, and try to bypass the problem
2023-03-01 06:50:03 +0100JimL(~quassel@89-162-26-217.fiber.signal.no)
2023-03-01 06:51:16 +0100trev(~trev@user/trev)
2023-03-01 07:05:48 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2023-03-01 07:07:46 +0100 <Axman6> Well, it's been a long time since I've read it, so can't really help any more than that, sorry =)
2023-03-01 07:10:31 +0100kupi(uid212005@id-212005.hampstead.irccloud.com)
2023-03-01 07:19:51 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 255 seconds)
2023-03-01 07:20:17 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-03-01 07:31:06 +0100razetime(~Thunderbi@117.193.3.64) (Ping timeout: 255 seconds)
2023-03-01 07:32:41 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-03-01 07:33:30 +0100johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net)
2023-03-01 07:34:00 +0100jwiegley(~jwiegley@76-234-69-149.lightspeed.frokca.sbcglobal.net)
2023-03-01 07:38:05 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-03-01 07:46:01 +0100michalz(~michalz@185.246.207.203)
2023-03-01 07:46:50 +0100 <Inst> what's wrong with tossing {-# INLINE funname #-} everywhere?
2023-03-01 07:47:17 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2023-03-01 07:47:20 +0100 <Jade[m]1> it blows up quickly if a function is used in a lot of places I'd assume
2023-03-01 07:50:20 +0100 <Inst> define blows up?
2023-03-01 07:51:25 +0100 <Axman6> i can make code larger, which might make it execute slower. generally small functions should be inlined (and GHC should do that automatically). I'm sure there's a lot of documentation in the GHC manual you can read
2023-03-01 07:52:38 +0100jakalx(~jakalx@base.jakalx.net)
2023-03-01 07:56:07 +0100 <Inst> yeah, i saw it, i'm just worried because afaik splitting files up into modules stops the inliner from working normally
2023-03-01 07:57:11 +0100opticblast(~Thunderbi@172.58.85.161) (Quit: opticblast)
2023-03-01 07:57:26 +0100opticblast(~Thunderbi@172.58.83.235)
2023-03-01 07:57:46 +0100 <Inst> also re: programming is hard, Haskell just doesn't hide it from you, from monochrom: my eyes literally glaze over when I find a file of source code that's over 100-150 lines
2023-03-01 07:57:54 +0100 <Inst> Haskell at least lets me organize everything into neat, separate packages
2023-03-01 07:57:59 +0100 <Inst> erm, neat, separate modules
2023-03-01 08:01:14 +0100 <Inst> i think Haskell, is somehow an easier language than everything else i've been exposed to
2023-03-01 08:03:54 +0100theproffesor(~theproffe@2601:282:8880:20::351b)
2023-03-01 08:03:54 +0100theproffesor(~theproffe@2601:282:8880:20::351b) (Changing host)
2023-03-01 08:03:54 +0100theproffesor(~theproffe@user/theproffesor)
2023-03-01 08:06:51 +0100shriekingnoise_(~shrieking@186.137.175.87) (Ping timeout: 248 seconds)
2023-03-01 08:08:15 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67) (Quit: Leaving)
2023-03-01 08:09:42 +0100Inst(~Inst@2601:6c4:4081:54f0:f532:ca97:ac1f:c1cd) (Ping timeout: 255 seconds)
2023-03-01 08:10:14 +0100Inst(~Inst@2601:6c4:4081:54f0:7069:999c:7e48:ff3b)
2023-03-01 08:30:23 +0100opticblast(~Thunderbi@172.58.83.235) (Ping timeout: 256 seconds)
2023-03-01 08:30:34 +0100lagash_(lagash@lagash.shelltalk.net) (Ping timeout: 246 seconds)
2023-03-01 08:31:40 +0100lagash_(lagash@lagash.shelltalk.net)
2023-03-01 08:33:55 +0100johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net) (Quit: ZNC - http://znc.in)
2023-03-01 08:34:16 +0100johnw(~johnw@2600:1700:cf00:db0:a85a:aa58:c54c:551d)
2023-03-01 08:36:37 +0100mjrosenb(~mjrosenb@pool-96-232-177-77.nycmny.fios.verizon.net) (Ping timeout: 268 seconds)
2023-03-01 08:37:09 +0100mjrosenb(~mjrosenb@pool-96-232-177-77.nycmny.fios.verizon.net)
2023-03-01 08:38:56 +0100kenran(~user@user/kenran)
2023-03-01 08:43:38 +0100gurkenglas(~gurkengla@dynamic-046-114-179-219.46.114.pool.telefonica.de)
2023-03-01 08:48:39 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-03-01 08:50:17 +0100gmg(~user@user/gehmehgeh) (Ping timeout: 255 seconds)
2023-03-01 08:52:31 +0100gmg(~user@user/gehmehgeh)
2023-03-01 08:53:56 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-01 08:54:17 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2023-03-01 08:56:03 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:1fc4:7ac2:9c57:911)
2023-03-01 08:57:21 +0100ft(~ft@p3e9bc443.dip0.t-ipconnect.de)
2023-03-01 09:02:13 +0100kenran`(~user@user/kenran)
2023-03-01 09:04:14 +0100zephyr__(~irfan@106.214.197.187)
2023-03-01 09:04:22 +0100kenran(~user@user/kenran) (Ping timeout: 268 seconds)
2023-03-01 09:12:50 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-03-01 09:20:26 +0100MajorBiscuit(~MajorBisc@c-001-028-045.client.tudelft.eduvpn.nl)
2023-03-01 09:28:48 +0100ft(~ft@p3e9bc443.dip0.t-ipconnect.de) (Quit: leaving)
2023-03-01 09:29:41 +0100akegalj(~akegalj@93-137-60-213.adsl.net.t-com.hr)
2023-03-01 09:35:01 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef) (Remote host closed the connection)
2023-03-01 09:37:19 +0100acidjnk_new(~acidjnk@p200300d6e715c4099ccd0d51d52c8268.dip0.t-ipconnect.de)
2023-03-01 09:40:35 +0100lagash_(lagash@lagash.shelltalk.net) (Ping timeout: 255 seconds)
2023-03-01 09:44:12 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-03-01 09:46:59 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 255 seconds)
2023-03-01 09:49:01 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-03-01 09:50:57 +0100MajorBiscuit(~MajorBisc@c-001-028-045.client.tudelft.eduvpn.nl) (Ping timeout: 255 seconds)
2023-03-01 09:55:26 +0100MajorBiscuit(~MajorBisc@2001:1c00:2408:a400:67e:5371:52a7:9b9a)
2023-03-01 09:56:59 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-03-01 09:57:10 +0100lagash(lagash@2605:6400:20:b4:9c76:1538:3398:ce71)
2023-03-01 10:03:04 +0100the_proffesor(~theproffe@2601:282:8880:20:bb29:952e:2032:246f)
2023-03-01 10:03:04 +0100the_proffesor(~theproffe@2601:282:8880:20:bb29:952e:2032:246f) (Changing host)
2023-03-01 10:03:04 +0100the_proffesor(~theproffe@user/theproffesor)
2023-03-01 10:03:09 +0100mc47(~mc47@xmonad/TheMC47)
2023-03-01 10:07:02 +0100nschoe(~q@141.101.51.197)
2023-03-01 10:07:23 +0100theproffesor(~theproffe@user/theproffesor) (Ping timeout: 248 seconds)
2023-03-01 10:10:18 +0100kupi(uid212005@id-212005.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-03-01 10:12:52 +0100cfricke(~cfricke@user/cfricke)
2023-03-01 10:15:38 +0100chele(~chele@user/chele)
2023-03-01 10:19:38 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-03-01 10:21:04 +0100remexre(~remexre@user/remexre) (Read error: Connection reset by peer)
2023-03-01 10:21:15 +0100remexre(~remexre@user/remexre)
2023-03-01 10:21:42 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-03-01 10:22:08 +0100califax(~califax@user/califx)
2023-03-01 10:23:59 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7)
2023-03-01 10:24:00 +0100cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.8)
2023-03-01 10:24:27 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 248 seconds)
2023-03-01 10:26:36 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 255 seconds)
2023-03-01 10:34:19 +0100wagle(~wagle@quassel.wagle.io) (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.)
2023-03-01 10:34:50 +0100wagle(~wagle@quassel.wagle.io)
2023-03-01 10:35:33 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef)
2023-03-01 10:36:28 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-01 10:39:41 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef) (Ping timeout: 246 seconds)
2023-03-01 10:42:34 +0100 <cheater> hi
2023-03-01 10:42:50 +0100 <zephyr__> hello
2023-03-01 10:43:44 +0100 <cheater> how could i modify the method echo'echo in instance Echo'server_ MyEchoServer so that it increments a TVar without forgetting it between calls? echo'echo is IO () but I just don't know how I would initialize / pass a TVar into this https://hackage.haskell.org/package/capnp-0.17.0.0/docs/Capnp-Tutorial.html#g:1
2023-03-01 10:47:31 +0100 <cheater> what do i do, stuff the TVar in an IORef or something?
2023-03-01 10:48:37 +0100 <mauke> that's a tutorial link
2023-03-01 10:48:53 +0100 <cheater> yes, it is
2023-03-01 10:49:00 +0100 <cheater> what are you trying to say
2023-03-01 10:49:01 +0100phma(phma@2001:5b0:215a:9618:c34:315f:ca7c:13ac) (Read error: Connection reset by peer)
2023-03-01 10:49:21 +0100 <mauke> how do you pass variables into tutorials
2023-03-01 10:49:33 +0100 <zephyr__> cheater: you'd need to pass the `TVar` reference as an argument.
2023-03-01 10:49:55 +0100phma(phma@2001:5b0:211f:30c8:d195:4c3:ddc4:3351)
2023-03-01 10:50:22 +0100 <cheater> pass it how? look how the server is started inside of main - there's no call to the actual function echo'ech
2023-03-01 10:50:28 +0100 <cheater> echo'echo
2023-03-01 10:50:59 +0100 <mauke> there are 10 mains on that page
2023-03-01 10:51:04 +0100[exa]can't help it but echo'echo sounds too much like 'allo'allo and I like it for servers
2023-03-01 10:51:06 +0100 <mauke> where are we?
2023-03-01 10:51:11 +0100 <cheater> getBootstrap = \sup -> Just . toClient <$> export @Echo sup MyEchoServer
2023-03-01 10:51:22 +0100MajorBiscuit(~MajorBisc@2001:1c00:2408:a400:67e:5371:52a7:9b9a) (Ping timeout: 252 seconds)
2023-03-01 10:51:28 +0100 <cheater> mauke: read again what i said. i mention the function name.
2023-03-01 10:51:38 +0100 <zephyr__> cheater: maybe have a global `TVar`, then.
2023-03-01 10:51:46 +0100 <mauke> ah, under RPC: https://hackage.haskell.org/package/capnp-0.17.0.0/docs/Capnp-Tutorial.html#g:10
2023-03-01 10:51:47 +0100 <cheater> how do you have a global TVar?
2023-03-01 10:53:31 +0100MajorBiscuit(~MajorBisc@c-001-028-045.client.tudelft.eduvpn.nl)
2023-03-01 10:55:08 +0100 <mauke> I haven't seen this library before, but my first instinct would be to embed it in the MyEchoServer type. no idea if that's sensible
2023-03-01 10:55:36 +0100 <cheater> i don't think it is
2023-03-01 10:57:29 +0100 <cheater> idk how
2023-03-01 10:57:32 +0100 <cheater> how would you do that mauke
2023-03-01 10:59:13 +0100 <mauke> https://github.com/zenhack/haskell-capnp/blob/master/examples/lib/Examples/Rpc/CalculatorServer.hs…
2023-03-01 10:59:26 +0100 <mauke> like this example, which stores a function
2023-03-01 10:59:34 +0100jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) (Remote host closed the connection)
2023-03-01 11:00:12 +0100jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net)
2023-03-01 11:01:17 +0100 <zephyr__> cheater: does this work?
2023-03-01 11:01:19 +0100 <zephyr__> cheater: https://paste.tomsmeding.com/ZZV87ly7
2023-03-01 11:01:50 +0100CiaoSen(~Jura@p200300c9570e91002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-03-01 11:02:13 +0100 <gurkenglas> Recommend a repository of strange/arcane uses of Haskell's type system?
2023-03-01 11:02:21 +0100 <int-e> zephyr__: add {-# NOINLINE t #-} and it probably works
2023-03-01 11:02:26 +0100teo(~teo@user/teo)
2023-03-01 11:02:40 +0100 <zephyr__> int-e: yeah, thanks
2023-03-01 11:02:51 +0100 <cheater> why NOINLINE?
2023-03-01 11:03:11 +0100 <int-e> cheater: imagine what the code looks like if both uses of t get inlined
2023-03-01 11:03:14 +0100 <zephyr__> cheater: you don't want to create a new TVar again and again, i think
2023-03-01 11:03:27 +0100 <cheater> oh yeah
2023-03-01 11:03:33 +0100 <cheater> mauke: i'm still reading your link
2023-03-01 11:03:48 +0100razetime(~Thunderbi@117.193.3.64)
2023-03-01 11:03:58 +0100 <zephyr__> cheater: you might not be comfortable with unsafePerformIO but it's a global TVar so you don't need to pass an argument to echo'echo
2023-03-01 11:04:14 +0100 <cheater> i'm comfortable ish
2023-03-01 11:04:44 +0100 <mauke> but echo'echo already takes an argument of user-defined type, so you can pass in whatever you like, no?
2023-03-01 11:05:12 +0100 <zephyr__> isn't echo'echo just `IO ()`, cheater?
2023-03-01 11:05:36 +0100 <cheater> mauke: it does? idk that it does
2023-03-01 11:05:38 +0100 <zephyr__> sorry, if there's a possibility to pass arguments, then that's the better solution.
2023-03-01 11:05:44 +0100 <cheater> zephyr__: yes, it's IO ()
2023-03-01 11:05:46 +0100 <zephyr__> i believe
2023-03-01 11:06:53 +0100 <mauke> cheater: the first argument
2023-03-01 11:06:54 +0100 <cheater> class (Echo'server_ s_) where { ... echo'echo :: s_ -> (GH.MethodHandler Echo'echo'params Echo'echo'results); echo'echo _ = GH.methodUnimplemented }
2023-03-01 11:07:02 +0100 <mauke> s_
2023-03-01 11:07:06 +0100 <mauke> that's your type
2023-03-01 11:07:22 +0100 <cheater> it also has an un-implementation
2023-03-01 11:07:26 +0100koz(~koz@121.99.240.58) (Ping timeout: 255 seconds)
2023-03-01 11:07:55 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 256 seconds)
2023-03-01 11:08:17 +0100 <cheater> so in my instance, it looks like this:
2023-03-01 11:08:39 +0100 <cheater> instance Echo'server_ MyEchoServer where { echo'echo MyEchoServer ... }
2023-03-01 11:08:45 +0100 <cheater> sorry i meant
2023-03-01 11:08:48 +0100 <cheater> instance Echo'server_ MyEchoServer where { echo'echo MyEchoServer = ... }
2023-03-01 11:09:00 +0100 <cheater> so yeah that's the constructor being passed
2023-03-01 11:09:10 +0100 <cheater> so i could put stuff inside the data definition i guess? like you said?
2023-03-01 11:09:22 +0100 <cheater> currently it's data MyEchoServer = MyEchoServer
2023-03-01 11:09:32 +0100 <mauke> yeah
2023-03-01 11:09:40 +0100 <cheater> but i could make it like data MyEchoServer = MyEchoServer { counter :: TVar Integer }
2023-03-01 11:09:59 +0100 <cheater> and then in the main function instead of saying
2023-03-01 11:09:59 +0100 <cheater> , getBootstrap = \sup -> Just . toClient <$> export @Echo sup MyEchoServer
2023-03-01 11:10:30 +0100 <cheater> i could say , getBootstrap = \sup -> Just . toClient <$> export @Echo sup (MyEchoServer myTvar )
2023-03-01 11:10:36 +0100 <mauke> right, that's what I was thinking of
2023-03-01 11:10:41 +0100 <cheater> gotcha
2023-03-01 11:10:51 +0100 <cheater> i could try that. saves us a global reference
2023-03-01 11:11:24 +0100 <zephyr__> sure, thanks mauke
2023-03-01 11:11:30 +0100 <cheater> see for some reason when i was looking at that getBootstrap line i thought that MyEchoServer was a syntactic reference to the type, not to the constructor
2023-03-01 11:11:35 +0100 <gurkenglas> int-e: how can I find more exercises like the (forall x. x a -> x b -> x c) -> Either (forall x. x a -> x c) (forall x. x b -> x c) one I came up with recently?
2023-03-01 11:11:47 +0100 <cheater> we need like a third case that's between lower case and upper case
2023-03-01 11:12:23 +0100 <cheater> that's what will bring on the year of the Haskell desktop
2023-03-01 11:15:57 +0100 <int-e> gurkenglas: I don't know, I found the last one by being on #haskell and reading one of your messages.
2023-03-01 11:16:09 +0100mud(~mud@user/kadoban) (Remote host closed the connection)
2023-03-01 11:16:14 +0100koz(~koz@121.99.240.58)
2023-03-01 11:16:35 +0100mud(~mud@user/kadoban)
2023-03-01 11:20:02 +0100 <Inst> god, I love Haskell
2023-03-01 11:20:12 +0100 <cheater> nice
2023-03-01 11:20:17 +0100 <Inst> I have no freaking clue what I'm doing, just copy-pasting code from an old project
2023-03-01 11:21:05 +0100 <Inst> got an 8x speed-up
2023-03-01 11:21:22 +0100 <Inst> just by doing a trivial refactor to exploit mapconcurrently because I can't figure out how to get Eval monad to work properly
2023-03-01 11:23:01 +0100 <Inst> that said, i'm doing old and crappy parallel code, i sprung a space leak ;_;
2023-03-01 11:23:35 +0100 <Inst> https://cdn.discordapp.com/attachments/968989726633779215/1080435068591407165/image.png
2023-03-01 11:24:16 +0100 <Inst> 85% spark conversion rate, hahahaha
2023-03-01 11:24:18 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-03-01 11:24:22 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-03-01 11:25:33 +0100 <Inst> crap no, i'm out of memory. ffff
2023-03-01 11:25:39 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-03-01 11:27:56 +0100 <int-e> Wow, that's a 15% spark fizzle rate. Lots of duds...
2023-03-01 11:28:19 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2023-03-01 11:29:19 +0100 <int-e> Oh, why are some of them getting GC'd? Are you `par`-ing values that you don't need?
2023-03-01 11:29:29 +0100 <Inst> ;_;
2023-03-01 11:29:36 +0100 <Inst> i was told this was good!
2023-03-01 11:30:25 +0100 <int-e> And I missed that there's an actual "dud" statistic, I wonder what the ghc folks think a dud is.
2023-03-01 11:30:51 +0100 <Inst> "when rpar is applied to an expression that is already evaluated, this is considered a dud and the rpar is ignored"
2023-03-01 11:31:40 +0100 <Inst> ugh, it's probably the overuse of state
2023-03-01 11:31:53 +0100 <int-e> `par` is good if the value will be needed and computing it isn't instantaneous; there's some overhead in managing sparks. Basically they're added to a queue and idle threads look for items on that queue to evaluate.
2023-03-01 11:32:14 +0100ubert1(~Thunderbi@2a02:8109:abc0:6434:64ad:38c9:a22a:dbbb)
2023-03-01 11:32:47 +0100 <Inst> halp
2023-03-01 11:32:59 +0100 <Inst> recompile with all the puts in StateT strict made strict?
2023-03-01 11:33:00 +0100 <Inst> https://media.discordapp.net/attachments/968989726633779215/1080437435760128040/image.png
2023-03-01 11:36:24 +0100shryke(~shryke@2a00:4b00:13c:cc:b27b:25ff:fe18:efd)
2023-03-01 11:36:37 +0100Midjak(~Midjak@82.66.147.146)
2023-03-01 11:37:37 +0100 <int-e> Inst: If you suspect that a non-strict state is the culprit (plausible), there's Control.Monad.State.Strict
2023-03-01 11:39:15 +0100 <Inst> I'm already on Control.Monad.State.Strict! ugh!!!!
2023-03-01 11:39:27 +0100 <Inst> import Control.Monad.Trans.State.Strict (StateT, gets, get, put)
2023-03-01 11:40:00 +0100 <int-e> Well, then a non-strict state isn't your issue. It might still be a non-strict component of your state if it's a record.
2023-03-01 11:40:23 +0100 <int-e> This kind of thing is impossible to figure out without code.
2023-03-01 11:40:58 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7)
2023-03-01 11:42:20 +0100 <Inst> unfortunately, the code isn't really readable
2023-03-01 11:42:45 +0100 <Inst> https://paste.tomsmeding.com/PzLh1rkF
2023-03-01 11:43:39 +0100 <Inst> i'm blaming mapConcurrently
2023-03-01 11:43:49 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-03-01 11:44:12 +0100 <Inst> tbh might be better to redo and try again, but with Vector instead of List
2023-03-01 11:47:24 +0100 <Inst> still leaking with vector and bang patterns slapped over most of the place, but acceptable rate, roughly 100kb per second this time
2023-03-01 11:47:32 +0100razetime(~Thunderbi@117.193.3.64) (Remote host closed the connection)
2023-03-01 11:49:56 +0100xkuru(~xkuru@user/xkuru) (Quit: Unvirtualizing)
2023-03-01 11:50:48 +0100xkuru(~xkuru@user/xkuru)
2023-03-01 11:51:22 +0100xkuru(~xkuru@user/xkuru) (Remote host closed the connection)
2023-03-01 11:51:32 +0100fnurglewitz(uid263868@id-263868.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-03-01 11:51:54 +0100xkuru(~xkuru@user/xkuru)
2023-03-01 11:52:34 +0100xkuru(~xkuru@user/xkuru) (Remote host closed the connection)
2023-03-01 11:52:47 +0100 <tomsmeding> possibly relevant: https://www.well-typed.com/blog/2020/09/nothunks/
2023-03-01 11:52:58 +0100xkuru(~xkuru@user/xkuru)
2023-03-01 11:56:14 +0100xkuru(~xkuru@user/xkuru) (Read error: Connection reset by peer)
2023-03-01 11:56:43 +0100tubogram44(~tubogram@user/tubogram) (Quit: Ping timeout (120 seconds))
2023-03-01 11:57:01 +0100 <kuribas> meh, I was discussing how we could leverage stream fusion to get well performing time series computations at the fraction of the cost and with lower error rate than doing it in java, and all I get is that I am "an evangelist", and that I shouldn't look down on java programmers.
2023-03-01 11:57:01 +0100tubogram44(~tubogram@user/tubogram)
2023-03-01 11:57:15 +0100acidjnk_new(~acidjnk@p200300d6e715c4099ccd0d51d52c8268.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
2023-03-01 11:57:20 +0100 <kuribas> How I claiming that one programming language is better suited for a problem than another "looking down"?
2023-03-01 11:57:37 +0100 <kuribas> Then couldn't we write everything in assembly language?
2023-03-01 11:58:13 +0100 <tomsmeding> kuribas: would it be possible to put stream fusion rules in a java streaming library
2023-03-01 11:58:32 +0100 <kuribas> tomsmeding: at the expense of a lot of complexity, maybe...
2023-03-01 11:58:37 +0100 <tomsmeding> yes
2023-03-01 11:58:42 +0100 <tomsmeding> but reusable complexity, possibly
2023-03-01 11:58:56 +0100cfricke(~cfricke@user/cfricke)
2023-03-01 11:59:00 +0100 <kuribas> something was done by Oleg I remember...
2023-03-01 11:59:38 +0100 <kuribas> But java streams doesn't have the same performance as haskell stream fusion IIRC.
2023-03-01 11:59:55 +0100 <kuribas> I should do a study, benchmarking a solution in java, haskell, and clojure.
2023-03-01 12:00:00 +0100 <kuribas> And present it.
2023-03-01 12:00:33 +0100akegalj(~akegalj@93-137-60-213.adsl.net.t-com.hr) (Quit: leaving)
2023-03-01 12:01:26 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Remote host closed the connection)
2023-03-01 12:01:50 +0100 <hellwolf[m]> When push comes to the shove, would you prefer the 2-3x performance or elegant and maintainable code?
2023-03-01 12:01:51 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-03-01 12:01:54 +0100 <hellwolf[m]> (Just curious)
2023-03-01 12:02:04 +0100 <kuribas> hellwolf[m]: me, or the company?
2023-03-01 12:02:14 +0100 <hellwolf[m]> * (Yes, loaded question, I am just curious)
2023-03-01 12:02:22 +0100 <kuribas> Of course I prefer maintainable over 2-3x performance.
2023-03-01 12:02:40 +0100 <hellwolf[m]> how about you and your own company
2023-03-01 12:03:20 +0100 <kuribas> I can write a super optimized SIMD version in 20x the time I write the haskell.
2023-03-01 12:03:24 +0100 <kuribas> With twice the bugs.
2023-03-01 12:03:36 +0100 <kuribas> And segmentation faults as added bonus.
2023-03-01 12:03:43 +0100 <kuribas> hellwolf[m]: I am an employee
2023-03-01 12:04:14 +0100 <gurkenglas> int-e: I guessed as much, I had just hoped from your initial confidence against is solubility and eventual elegance of solution that you might have seen similar situations elsewhere :D
2023-03-01 12:04:53 +0100 <gurkenglas> If I were asked this, the best I could point the asker at is to read edward kmett's Kan extensions module
2023-03-01 12:06:59 +0100 <gurkenglas> (which I say with the ulterior motive of showing that I'm desperate enough to look even for answers that matches my question that little)
2023-03-01 12:07:00 +0100 <hellwolf[m]> I am asking everyone...
2023-03-01 12:07:00 +0100 <hellwolf[m]> And in the case of edward kmett code: `read ~= be shocked about|be awed at|be confused of|in perpetual denial with`
2023-03-01 12:07:27 +0100V(~v@ircpuzzles/2022/april/winner/V) (Remote host closed the connection)
2023-03-01 12:07:54 +0100jinsl-(~jinsl@2408:8207:2558:e50:211:32ff:fec8:6aea) (Quit: ZNC - https://znc.in)
2023-03-01 12:08:05 +0100jinsl(~jinsl@2408:8207:2558:e50:211:32ff:fec8:6aea)
2023-03-01 12:08:12 +0100xff0x(~xff0x@ai081074.d.east.v6connect.net)
2023-03-01 12:08:12 +0100 <kuribas> hellwolf[m]: just get a PHD in category theory, problem solved!
2023-03-01 12:08:54 +0100V(~v@ircpuzzles/2022/april/winner/V)
2023-03-01 12:09:01 +0100 <hellwolf[m]> How to decompose the meaning of a word in a human uttered sentence? Use Yoneda lemma and enumerate all the iso-emotions evoked by the word.
2023-03-01 12:09:22 +0100 <kuribas> ask chatGPT?
2023-03-01 12:09:26 +0100 <hellwolf[m]> kuribas: Got it. See you in 20 years!
2023-03-01 12:11:09 +0100 <gurkenglas> hellwolf[m]: elegant! the time for 2-3x performance is when you have all of 1. you're working on the core loop of the code 2. you're actually bottlenecked on compute 3. you can't throw 25% of coder salary at the compute problem to make it go away
2023-03-01 12:11:49 +0100 <gurkenglas> hellwolf[m]: scratch the iso, yoneda is oriented
2023-03-01 12:12:23 +0100 <kuribas> This, it should be demonstrated that the 2x gain by not using stream fusion is actually having a benifit on the system, like it isn't swamped by IO.
2023-03-01 12:12:55 +0100 <cheater> make zephyr__ putting stuff in the record worked thanks
2023-03-01 12:13:07 +0100 <cheater> mauke
2023-03-01 12:13:14 +0100 <cheater> sorry :) :)
2023-03-01 12:13:18 +0100acidjnk_new(~acidjnk@p200300d6e715c409795fa7f63fedb700.dip0.t-ipconnect.de)
2023-03-01 12:13:45 +0100 <hellwolf[m]> > One observer described the solution as “cute but not extensible” (para-phrasing);... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/2c96a99ecae09a7e1833c20a6dcd7481d0f5…>)
2023-03-01 12:13:46 +0100 <lambdabot> <hint>:1:40: error: lexical error at character 'c'
2023-03-01 12:15:24 +0100 <gurkenglas> Is there a searchable or downloadable version of https://ircbrowse.tomsmeding.com/browse/lchaskell ?
2023-03-01 12:16:49 +0100 <gurkenglas> oh, https://github.com/tomsmeding/ircbrowse says how to set up the db
2023-03-01 12:18:38 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-03-01 12:19:01 +0100 <mon_aaraj> the gitlab milestone page for ghc 9.6 says it's gonna be released today (or was it yesterday?), is it in any way accurate?
2023-03-01 12:21:31 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7) (Remote host closed the connection)
2023-03-01 12:21:51 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7)
2023-03-01 12:22:42 +0100 <merijn> Maybe? :p
2023-03-01 12:23:08 +0100 <tomsmeding> gurkenglas: I still need to add search to that :p
2023-03-01 12:23:37 +0100Guest11(~Guest11@c83-251-160-169.bredband.tele2.se)
2023-03-01 12:23:46 +0100 <tomsmeding> setting it up locally kinda works, instructions might be kinda outdated (I revived the project from a semi-forgotten state)
2023-03-01 12:23:55 +0100 <Guest11> I'm so freaking confused, are there any haskell libraries that implements FRP correctly or not?
2023-03-01 12:24:08 +0100 <merijn> Guest11: Define "implement", "FRP", and "correctly" :)
2023-03-01 12:24:17 +0100 <Guest11> Right, that's where I have been
2023-03-01 12:24:19 +0100 <Guest11> lol
2023-03-01 12:24:41 +0100 <Guest11> So according to Eliott, there's a clear meaning, but no library is true to it?
2023-03-01 12:24:50 +0100 <Guest11> Elliott*
2023-03-01 12:24:51 +0100 <merijn> Guest11: That sounds likely
2023-03-01 12:25:07 +0100 <Jade[m]1> what is FRP
2023-03-01 12:25:25 +0100 <Guest11> Google it, there are *loads* of explanations
2023-03-01 12:25:33 +0100 <merijn> Guest11: Essentially, FRP is a semantics, that is "a description of what something means" without definition of *how to achieve that*
2023-03-01 12:26:17 +0100 <Guest11> So am I to give up until there is a correct one, or what? I'm semi-new to haskell, but is interested in the subject of FRP.
2023-03-01 12:26:28 +0100 <merijn> Guest11: So if you look at Conal's papers he gives you the semantics of Behaviour, Event, etc. but "implementing those semantics in a way that doesn't suck" is an exercise for the reader (well, stuff like Push-Pull FRP talks a bit about how to implement things)
2023-03-01 12:27:30 +0100 <merijn> Guest11: Well, there's basically 2 axes to look at "how far does this library deviate from the semantics described?" and "how poorly does it perform?" and atm there seems to be a trade-off between those two (i.e. more correct versions suffer performance issues due to time leaks)
2023-03-01 12:27:41 +0100 <Guest11> I mean, I really want to get some hands on experience on anything. FRP seems like a really interesting rabbit hole. Will you please just give me some direction, as you seem experienced?
2023-03-01 12:28:02 +0100 <merijn> tbh, I haven't touched FRP in nearly a decade, so I don't really know what's new atm
2023-03-01 12:28:40 +0100 <merijn> Thinking about it, something like FRP for FPGA's could be cool :>
2023-03-01 12:29:13 +0100 <hellwolf[m]> I can't stop myself to plug this, I have an alternative FRP application, applied to money/payment :) Actually the production system (which is before I discover it is basically FRP applied to money) is live.
2023-03-01 12:29:34 +0100 <Guest11> i was JUST thinking about applying FRP to money/payments. Interesting!
2023-03-01 12:29:48 +0100 <hellwolf[m]> We processed 80M$ (well, "money") cumulatively so far.
2023-03-01 12:30:05 +0100 <Guest11> What do you mean by "alternative"?
2023-03-01 12:30:29 +0100 <hellwolf[m]> It is not an application that is mentioned anywhere, including on Wikipedia
2023-03-01 12:30:54 +0100__monty__(~toonn@user/toonn)
2023-03-01 12:30:59 +0100 <hellwolf[m]> "not commonly", I should say, I have done quite a bit of digging
2023-03-01 12:31:54 +0100 <Guest11> Sounds mysterious. I just want hop on a journey with haskell so I can get experienced, should I just shoot my shot at, say, Yampa?
2023-03-01 12:32:31 +0100 <hellwolf[m]> It's actually wide open, I just haven't found my audience about its FRP angle yet :)
2023-03-01 12:32:51 +0100 <hellwolf[m]> https://github.com/superfluid-finance/protocol-monorepo/tree/semantic-money/packages/spec-haskell/…
2023-03-01 12:32:54 +0100 <jackdk> Guest11: http://joeyh.name/blog/entry/my_haskell_controlled_offgrid_fridge/ is something I remember from the past
2023-03-01 12:34:04 +0100 <Guest11> That was an interesting read!
2023-03-01 12:34:13 +0100 <hellwolf[m]> Live system is at : app.superfluid.finance/
2023-03-01 12:34:13 +0100 <hellwolf[m]> Enough of my shameless plug, happy to be DM-ed if you want to discuss more
2023-03-01 12:34:15 +0100MasseR46(thelounge@2001:bc8:47a0:1521::1) (Quit: The Lounge - https://thelounge.chat)
2023-03-01 12:34:23 +0100 <dminuoso_> merijn: From everything I have seen, FRP certainly seems cool on an idealistic level, but its far from practical. While I can see if you have a team of dedicated specialist you can build things with reflex, I think it sets for an extremely high bar.
2023-03-01 12:34:35 +0100 <Guest11> Massive! I'll take a look! hellwolf[m]
2023-03-01 12:34:55 +0100MasseR46(thelounge@2001:bc8:47a0:1521::1)
2023-03-01 12:35:38 +0100 <jackdk> dminuoso_: ISTM that a lot of it is "how do I organise code?" because there's comparatively little folklore. (On top of the abstractions being somehow both simple and hard to grok)
2023-03-01 12:40:46 +0100mmhat(~mmh@p200300f1c7046216ee086bfffe095315.dip0.t-ipconnect.de)
2023-03-01 12:42:08 +0100mmhat(~mmh@p200300f1c7046216ee086bfffe095315.dip0.t-ipconnect.de) (Client Quit)
2023-03-01 12:43:16 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7) (Remote host closed the connection)
2023-03-01 12:43:36 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7)
2023-03-01 12:44:31 +0100 <gurkenglas> Is there a free theorem generator that golfs its output by skipping type signatures that could be rederived from context?
2023-03-01 12:48:04 +0100 <gurkenglas> Once one has seen enough examples of free theorems, is it obvious what the free theorem for any given type would be?
2023-03-01 12:48:57 +0100 <mon_aaraj> I love FRP. It's genuinely one of the most interesting pieces of engineering I've seen on haskell
2023-03-01 12:49:32 +0100 <Guest11> Which library have you preferred, and why?
2023-03-01 12:49:32 +0100 <Axman6> does reflex count as FRP?
2023-03-01 12:49:47 +0100 <Guest11> That's kind of my question, does any library cohere to true FRP?
2023-03-01 12:49:56 +0100 <gurkenglas> I can imagine that they end up "you can thread a function through each usage of a free variable before or after" and then one can prove a precise phrasing of "therefore free theorems are useless"
2023-03-01 12:49:58 +0100 <Axman6> almost certainly not
2023-03-01 12:50:10 +0100 <hellwolf[m]> Would love to learn more about: what is true FRP?
2023-03-01 12:50:17 +0100 <cheater> i thought there was some front end stuff that did frp
2023-03-01 12:50:41 +0100 <Guest11> I'm 8  months into Haskell, I don't believe I'm qualified to answer any questions at all yet lol
2023-03-01 12:50:46 +0100 <gurkenglas> but i'd like to know precisely what kind of useless, or equivalently precisely what class of statements they can express
2023-03-01 12:50:52 +0100 <mon_aaraj> Axman6: Yep.
2023-03-01 12:51:10 +0100 <Guest11> How do you guys @ people?
2023-03-01 12:51:10 +0100 <mon_aaraj> Guest11: dunai, and I don't think there's any competition
2023-03-01 12:51:21 +0100 <gurkenglas> s/free variable/bound variable/ :(
2023-03-01 12:51:22 +0100 <Guest11> Oh really, interesting!
2023-03-01 12:51:29 +0100 <mon_aaraj> er, I'm not on IRC - I'm replying to messages on Matrix.
2023-03-01 12:52:14 +0100 <mon_aaraj> hellwolf[m]: You should read conal's blog, conal's stackoverflow, and look up "denotative continuous time programming"
2023-03-01 12:52:44 +0100 <mon_aaraj> Guest11: Never the less, you can just type their username and they should be notified.
2023-03-01 12:52:45 +0100 <Inst> wait, curious
2023-03-01 12:52:48 +0100 <Axman6> Guest11: you just say their name, usually suffixed with : if it's the beginning of the message
2023-03-01 12:52:56 +0100 <Axman6> see ^
2023-03-01 12:52:57 +0100 <Inst> can you store a function in an IORef?
2023-03-01 12:53:02 +0100 <Axman6> yes
2023-03-01 12:53:09 +0100 <Inst> does that do anything, or is it worthless?
2023-03-01 12:53:09 +0100 <Guest11> Axman6: Test
2023-03-01 12:53:09 +0100 <hellwolf[m]> I read the original paper, hugely inspired by it. And hence realized what I have been doing is FRP but for different domain
2023-03-01 12:53:17 +0100 <Axman6> pass
2023-03-01 12:53:22 +0100 <hellwolf[m]> But what is true frp...
2023-03-01 12:53:43 +0100 <mon_aaraj> by the words of conal -- denotative continuous time programming
2023-03-01 12:53:47 +0100 <mon_aaraj> shortened to DCTP
2023-03-01 12:53:49 +0100 <Axman6> Hmm, conal isn't in here at the moment, I wonder when he was around last
2023-03-01 12:54:00 +0100 <Inst> i'm having a big issue with a memory leak, probably related to a specific function, in part because quite a few of its arguments are truly enormous entities
2023-03-01 12:54:22 +0100 <mon_aaraj> I wasn't quoting him from this Matrix room, just from texts I've seen him write online
2023-03-01 12:55:17 +0100 <Guest11> See this thread, in which Conal says which libraries should be considered true FRP, lol: https://twitter.com/conal/status/532683685003141120
2023-03-01 12:55:19 +0100 <hellwolf[m]> maybe an example of an implementation that violates that definition would be more concrete for the discussion
2023-03-01 12:55:26 +0100 <Axman6> I mean he used to be in the IRC channel fairly regularly
2023-03-01 12:56:51 +0100 <merijn> He still shows up occasionally
2023-03-01 12:57:20 +0100 <hellwolf[m]> ah, yes, "not even wrong" is the key phrase
2023-03-01 12:57:49 +0100 <hellwolf[m]> I think Conal moved to Agda camp and wanting the denotational spec entirely in Agda :)
2023-03-01 12:58:11 +0100 <Axman6> Inst: there's nothing special about IORefs, they don't force evaluation or anything, they are literally a pointer to a heap object
2023-03-01 12:58:16 +0100 <hellwolf[m]> I have been trying to catch up but...
2023-03-01 12:58:21 +0100 <Axman6> which could be a thunk
2023-03-01 12:58:40 +0100 <Inst> thanks
2023-03-01 12:58:47 +0100 <Inst> sigh, i can't get the profiler to work either
2023-03-01 13:02:03 +0100zephyr__(~irfan@106.214.197.187) ()
2023-03-01 13:03:00 +0100 <Inst> probably cabal clean, but giving it a shot
2023-03-01 13:03:09 +0100 <Inst> under the current performance situation
2023-03-01 13:03:09 +0100 <mon_aaraj> <hellwolf[m]> "I think Conal moved to Agda camp..." <- That would make sense.
2023-03-01 13:04:02 +0100 <Inst> http://conal.net/cv.pdf
2023-03-01 13:04:03 +0100 <Inst> huh
2023-03-01 13:04:11 +0100 <Inst> looks like he got shook out with Tikhon at Target?
2023-03-01 13:04:12 +0100 <hellwolf[m]> mon_aaraj: It does, it just means many folks like me need more time to catch up with the state of the art
2023-03-01 13:05:50 +0100 <hellwolf[m]> https://github.com/conal/Collaboration
2023-03-01 13:05:50 +0100 <hellwolf[m]> I have been through a few sessions of his. It's worth it and recommend everyone to contact him if you are up for a shaking up of your belief system too :)
2023-03-01 13:06:28 +0100 <Guest11> Wait, just like that?
2023-03-01 13:06:52 +0100 <gurkenglas> it seems silly that the parametricity theorem talks about relations rather than functions. what prevents us from saying it in terms of functions?
2023-03-01 13:08:05 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:1fc4:7ac2:9c57:911) (Ping timeout: 246 seconds)
2023-03-01 13:11:07 +0100 <Inst> there we go, cabal configure --enable-profiling, then rebuild
2023-03-01 13:12:27 +0100 <hellwolf[m]> there is only categories, objects and morphisms. Function is rather a special type of morphism built on top of a category, e.g. Husk.
2023-03-01 13:13:24 +0100 <Axman6> the podcast he did a few months ago was excellent
2023-03-01 13:13:42 +0100 <Axman6> Hask is just a Husk of a category
2023-03-01 13:13:51 +0100infinity0(~infinity0@pwned.gg) (Remote host closed the connection)
2023-03-01 13:14:27 +0100 <hellwolf[m]> Only Agda people cares about the bottoms now :) Haskellers have submitted to them.
2023-03-01 13:15:37 +0100 <Axman6> https://www.typetheoryforall.com/2022/05/09/17-The-Lost-Elegance-of-Computation-(Conal-Elliott).html#1fe23b61
2023-03-01 13:15:58 +0100infinity0(~infinity0@pwned.gg)
2023-03-01 13:26:58 +0100bontaq(~user@ool-45779fe5.dyn.optonline.net)
2023-03-01 13:35:12 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-03-01 13:35:19 +0100 <gurkenglas> hellwolf[m]: shiny! i've emailed the guy, i do have this CT insight I'd like to formalize.
2023-03-01 13:35:37 +0100 <gurkenglas> how long can I expect to wait for the first session?
2023-03-01 13:36:55 +0100 <hellwolf[m]> In my experience, fairly quickly :)
2023-03-01 13:37:04 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-03-01 13:37:31 +0100 <gurkenglas> are we talking minutes or hours or days :P
2023-03-01 13:39:28 +0100 <hellwolf[m]> I don't know, but I just found out he's been working on this: https://github.com/conal/felix
2023-03-01 13:39:29 +0100 <hellwolf[m]> We could stalk his work while waiting.
2023-03-01 13:40:06 +0100 <gurkenglas> pfft looks like if this were paid, he should be paying me
2023-03-01 13:40:24 +0100 <hellwolf[m]> heh, no no, I don't think so.
2023-03-01 13:41:09 +0100swistak(~swistak@185.21.216.141) (Quit: bye bye)
2023-03-01 13:41:21 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7) (Ping timeout: 255 seconds)
2023-03-01 13:42:29 +0100melonai(~mel@rnrd.eu) (Quit: ZNC 1.8.2 - https://znc.in)
2023-03-01 13:42:45 +0100melonai(~mel@rnrd.eu)
2023-03-01 13:42:57 +0100lyle(~lyle@104.246.145.237)
2023-03-01 13:43:43 +0100mud(~mud@user/kadoban) (Remote host closed the connection)
2023-03-01 13:43:43 +0100Cheery(~cheery@server-239-7.tentacle.cloud) (Ping timeout: 268 seconds)
2023-03-01 13:43:44 +0100tureba(~tureba@tureba.org) (Ping timeout: 268 seconds)
2023-03-01 13:43:58 +0100simpleauthority(~simpleaut@user/simpleauthority) (Quit: ZNC 1.8.2 - https://znc.in)
2023-03-01 13:44:09 +0100mud(~mud@user/kadoban)
2023-03-01 13:44:13 +0100Cheery(~cheery@server-239-7.tentacle.cloud)
2023-03-01 13:44:27 +0100simpleauthority(~simpleaut@user/simpleauthority)
2023-03-01 13:44:57 +0100gurkenglas(~gurkengla@dynamic-046-114-179-219.46.114.pool.telefonica.de) (Ping timeout: 268 seconds)
2023-03-01 13:45:52 +0100gurkenglas(~gurkengla@dynamic-046-114-179-219.46.114.pool.telefonica.de)
2023-03-01 13:45:57 +0100swistak(~swistak@185.21.216.141)
2023-03-01 13:46:39 +0100Logio(em@kapsi.fi)
2023-03-01 13:46:45 +0100stefan-__(~cri@42dots.de)
2023-03-01 13:47:47 +0100codolio(~dolio@130.44.134.54)
2023-03-01 13:47:48 +0100user___(~user@162.255.84.96)
2023-03-01 13:48:08 +0100ystael_(~ystael@user/ystael)
2023-03-01 13:51:40 +0100califax_(~califax@user/califx)
2023-03-01 13:51:41 +0100tired(~tired@user/tired) (Ping timeout: 256 seconds)
2023-03-01 13:51:47 +0100califax(~califax@user/califx) (Ping timeout: 255 seconds)
2023-03-01 13:51:55 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 260 seconds)
2023-03-01 13:52:32 +0100xerox(~edi@user/edi) (Ping timeout: 246 seconds)
2023-03-01 13:52:34 +0100tired(~tired@user/tired)
2023-03-01 13:52:53 +0100kosmikus(~kosmikus@nullzig.kosmikus.org) (Ping timeout: 246 seconds)
2023-03-01 13:52:59 +0100califax_califax
2023-03-01 13:53:06 +0100kosmikus(~kosmikus@nullzig.kosmikus.org)
2023-03-01 13:53:08 +0100gmg(~user@user/gehmehgeh) (Ping timeout: 255 seconds)
2023-03-01 13:53:16 +0100Guest11(~Guest11@c83-251-160-169.bredband.tele2.se) (Quit: Client closed)
2023-03-01 13:53:30 +0100xerox(~edi@user/edi)
2023-03-01 13:55:09 +0100gmg(~user@user/gehmehgeh)
2023-03-01 13:55:51 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 255 seconds)
2023-03-01 13:56:13 +0100CiaoSen(~Jura@p200300c9570e91002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-03-01 13:56:16 +0100cfricke(~cfricke@user/cfricke) (*.net *.split)
2023-03-01 13:56:16 +0100wagle(~wagle@quassel.wagle.io) (*.net *.split)
2023-03-01 13:56:16 +0100biberu(~biberu@user/biberu) (*.net *.split)
2023-03-01 13:56:16 +0100manwithluck(~manwithlu@hoeven.dossingday.ml) (*.net *.split)
2023-03-01 13:56:16 +0100meejah(~meejah@rutas.meejah.ca) (*.net *.split)
2023-03-01 13:56:16 +0100ystael(~ystael@user/ystael) (*.net *.split)
2023-03-01 13:56:16 +0100ubert(~Thunderbi@p548c9fde.dip0.t-ipconnect.de) (*.net *.split)
2023-03-01 13:56:16 +0100kimiamania(~65804703@user/kimiamania) (*.net *.split)
2023-03-01 13:56:16 +0100matthews(~matthews@gentoo/developer/matthew) (*.net *.split)
2023-03-01 13:56:16 +0100dolio(~dolio@130.44.134.54) (*.net *.split)
2023-03-01 13:56:16 +0100simeon(~pi@143.231.7.51.dyn.plus.net) (*.net *.split)
2023-03-01 13:56:16 +0100Vq(~vq@90-227-195-41-no77.tbcn.telia.com) (*.net *.split)
2023-03-01 13:56:16 +0100APic(apic@apic.name) (*.net *.split)
2023-03-01 13:56:16 +0100user2(~user@162.255.84.96) (*.net *.split)
2023-03-01 13:56:16 +0100noteness_(~noteness@user/noteness) (*.net *.split)
2023-03-01 13:56:16 +0100energizer(~energizer@user/energizer) (*.net *.split)
2023-03-01 13:56:16 +0100heath1(~heath@user/heath) (*.net *.split)
2023-03-01 13:56:16 +0100noctux1(Zx24REiiwW@user/noctux) (*.net *.split)
2023-03-01 13:56:16 +0100aforemny(~aforemny@static.248.158.34.188.clients.your-server.de) (*.net *.split)
2023-03-01 13:56:16 +0100AWizzArd(~code@user/awizzard) (*.net *.split)
2023-03-01 13:56:16 +0100Logio_(em@kapsi.fi) (*.net *.split)
2023-03-01 13:56:16 +0100kaol(~kaol@94-237-42-30.nl-ams1.upcloud.host) (*.net *.split)
2023-03-01 13:56:16 +0100cjay(cjay@nerdbox.nerd2nerd.org) (*.net *.split)
2023-03-01 13:56:16 +0100dfordvm(~dfordivam@tk2-219-19469.vs.sakura.ne.jp) (*.net *.split)
2023-03-01 13:56:16 +0100laman2(~laman@rego.ai) (*.net *.split)
2023-03-01 13:56:16 +0100hammond__(proscan@gateway02.insomnia247.nl) (*.net *.split)
2023-03-01 13:56:16 +0100thaumavorio_(~thaumavor@thaumavor.io) (*.net *.split)
2023-03-01 13:56:16 +0100dminuoso_(~dminuoso@user/dminuoso) (*.net *.split)
2023-03-01 13:56:16 +0100guygastineau(~guygastin@137.184.131.156) (*.net *.split)
2023-03-01 13:56:16 +0100tstat_(~tstat@user/tstat) (*.net *.split)
2023-03-01 13:56:16 +0100davl_(~davl@207.154.228.18) (*.net *.split)
2023-03-01 13:56:16 +0100shachaf(~shachaf@user/shachaf) (*.net *.split)
2023-03-01 13:56:16 +0100robbert-vdh(~robbert@robbertvanderhelm.nl) (*.net *.split)
2023-03-01 13:56:17 +0100jakalx(~jakalx@base.jakalx.net) (*.net *.split)
2023-03-01 13:56:17 +0100ario(~ario@159.65.220.102) (*.net *.split)
2023-03-01 13:56:17 +0100raoul(~raoul@95.179.203.88) (*.net *.split)
2023-03-01 13:56:17 +0100ralu1(~ralu@static.211.245.203.116.clients.your-server.de) (*.net *.split)
2023-03-01 13:56:17 +0100ridcully_(~ridcully@p508acd69.dip0.t-ipconnect.de) (*.net *.split)
2023-03-01 13:56:17 +0100defanor(~defanor@tart.uberspace.net) (*.net *.split)
2023-03-01 13:56:17 +0100chymera(~chymera@ns1000526.ip-51-81-46.us) (*.net *.split)
2023-03-01 13:56:17 +0100hank_(~hank@45-33-24-80.ip.linodeusercontent.com) (*.net *.split)
2023-03-01 13:56:17 +0100mesaoptimizer(apotheosis@user/PapuaHardyNet) (*.net *.split)
2023-03-01 13:56:17 +0100lambdap237(~lambdap@static.167.190.119.168.clients.your-server.de) (*.net *.split)
2023-03-01 13:56:17 +0100DigitalKiwi(~kiwi@137.184.156.191) (*.net *.split)
2023-03-01 13:56:17 +0100nicole(ilbelkyr@libera/staff/ilbelkyr) (*.net *.split)
2023-03-01 13:56:17 +0100stefan-_(~cri@42dots.de) (*.net *.split)
2023-03-01 13:56:17 +0100auri(~auri@fsf/member/auri) (*.net *.split)
2023-03-01 13:56:17 +0100hexology(~hexology@user/hexology) (*.net *.split)
2023-03-01 13:56:17 +0100ubert1ubert
2023-03-01 13:56:35 +0100APic(apic@apic.name)
2023-03-01 13:56:40 +0100kimiamania(~65804703@user/kimiamania)
2023-03-01 13:56:41 +0100tureba(~tureba@tureba.org)
2023-03-01 13:56:42 +0100hexology(~hexology@user/hexology)
2023-03-01 13:56:50 +0100energizer(~energizer@user/energizer)
2023-03-01 13:57:08 +0100chymera(~chymera@ns1000526.ip-51-81-46.us)
2023-03-01 13:57:20 +0100manwithluck(~manwithlu@hoeven.dossingday.ml)
2023-03-01 13:57:39 +0100cfricke(~cfricke@user/cfricke)
2023-03-01 13:57:40 +0100stefan-__stefan-_
2023-03-01 14:00:37 +0100noteness(~noteness@user/noteness)
2023-03-01 14:00:43 +0100ubert078AALVPE
2023-03-01 14:00:49 +0100auri(~auri@static.46.108.40.188.clients.your-server.de)
2023-03-01 14:00:49 +0100wagle(~wagle@quassel.wagle.io)
2023-03-01 14:00:49 +0100jakalx(~jakalx@base.jakalx.net)
2023-03-01 14:00:49 +0100biberu(~biberu@user/biberu)
2023-03-01 14:00:49 +0100meejah(~meejah@rutas.meejah.ca)
2023-03-01 14:00:49 +0100ubert(~Thunderbi@p548c9fde.dip0.t-ipconnect.de)
2023-03-01 14:00:49 +0100matthews(~matthews@gentoo/developer/matthew)
2023-03-01 14:00:49 +0100simeon(~pi@143.231.7.51.dyn.plus.net)
2023-03-01 14:00:49 +0100Vq(~vq@90-227-195-41-no77.tbcn.telia.com)
2023-03-01 14:00:49 +0100heath1(~heath@user/heath)
2023-03-01 14:00:49 +0100noctux1(Zx24REiiwW@user/noctux)
2023-03-01 14:00:49 +0100aforemny(~aforemny@static.248.158.34.188.clients.your-server.de)
2023-03-01 14:00:49 +0100AWizzArd(~code@user/awizzard)
2023-03-01 14:00:49 +0100kaol(~kaol@94-237-42-30.nl-ams1.upcloud.host)
2023-03-01 14:00:49 +0100cjay(cjay@nerdbox.nerd2nerd.org)
2023-03-01 14:00:49 +0100dfordvm(~dfordivam@tk2-219-19469.vs.sakura.ne.jp)
2023-03-01 14:00:49 +0100laman2(~laman@rego.ai)
2023-03-01 14:00:49 +0100hammond__(proscan@gateway02.insomnia247.nl)
2023-03-01 14:00:49 +0100thaumavorio_(~thaumavor@thaumavor.io)
2023-03-01 14:00:49 +0100dminuoso_(~dminuoso@user/dminuoso)
2023-03-01 14:00:49 +0100guygastineau(~guygastin@137.184.131.156)
2023-03-01 14:00:49 +0100tstat_(~tstat@user/tstat)
2023-03-01 14:00:49 +0100davl_(~davl@207.154.228.18)
2023-03-01 14:00:49 +0100shachaf(~shachaf@user/shachaf)
2023-03-01 14:00:49 +0100robbert-vdh(~robbert@robbertvanderhelm.nl)
2023-03-01 14:00:49 +0100ario(~ario@159.65.220.102)
2023-03-01 14:00:49 +0100raoul(~raoul@95.179.203.88)
2023-03-01 14:00:49 +0100ralu1(~ralu@static.211.245.203.116.clients.your-server.de)
2023-03-01 14:00:49 +0100ridcully_(~ridcully@p508acd69.dip0.t-ipconnect.de)
2023-03-01 14:00:49 +0100defanor(~defanor@tart.uberspace.net)
2023-03-01 14:00:49 +0100hank_(~hank@45-33-24-80.ip.linodeusercontent.com)
2023-03-01 14:00:49 +0100mesaoptimizer(apotheosis@user/PapuaHardyNet)
2023-03-01 14:00:49 +0100lambdap237(~lambdap@static.167.190.119.168.clients.your-server.de)
2023-03-01 14:00:49 +0100DigitalKiwi(~kiwi@137.184.156.191)
2023-03-01 14:00:49 +0100nicole(ilbelkyr@libera/staff/ilbelkyr)
2023-03-01 14:01:00 +0100Guest11(~Guest11@c83-251-160-169.bredband.tele2.se)
2023-03-01 14:01:16 +0100swistak(~swistak@185.21.216.141) (Quit: bye bye)
2023-03-01 14:01:51 +0100 <Guest11> So, just to conclude things, would FRP be an interesting rabbit hole to develop myself as a Haskell programmer?
2023-03-01 14:02:46 +0100 <mon_aaraj> I suppose. Though be warned, FRP is kind of magical at first.
2023-03-01 14:03:45 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-03-01 14:04:05 +0100 <Guest11> mon_aaraj: Magical as in things-get-done-and-I-don't-know-why?
2023-03-01 14:04:23 +0100 <mon_aaraj> Pretty much.
2023-03-01 14:04:39 +0100kraftwerk28(~kraftwerk@178.62.210.83) (Remote host closed the connection)
2023-03-01 14:04:53 +0100 <Guest11> I see. That's fine I suppose. Thank you!
2023-03-01 14:05:14 +0100 <gurkenglas> mon_aaraj, "you get things done" or "things are happening"?
2023-03-01 14:05:39 +0100 <mon_aaraj> it's more like "my code is working and i have no clue how or why it does"
2023-03-01 14:05:50 +0100kraftwerk28(~kraftwerk@178.62.210.83)
2023-03-01 14:06:10 +0100 <gurkenglas> did the hypothetical person write what came to mind or manipulate copypasted snippets :P
2023-03-01 14:06:49 +0100 <mon_aaraj> the hypothetical person checked the documentation and followed the types
2023-03-01 14:07:40 +0100 <mon_aaraj> when one matches the types up, more often than not i've experienced that stuff will start working. it's just one needs to see what is happening when the stuff is working and why it worked
2023-03-01 14:09:24 +0100 <mon_aaraj> I think for me, I came upon FRP before really even having a proper knowledge of Haskell. After reading Haskell From First Principles I then opened up Yampa in a REPL and just matched the types of some functions. It felt really nice to get stuff working even though I didn't have a single clue what i was doing.
2023-03-01 14:09:46 +0100 <kuribas> Guest11: IMO it's one the rabit holes that actually have practical uses.
2023-03-01 14:10:10 +0100 <kuribas> Guest11: unlike most of category theory.
2023-03-01 14:10:51 +0100 <gurkenglas> noice. can one bring this to its natural conclusion - put half one's code in terms of a type that one suspects has one natural inhabitant even though one couldn't write it, the compiler agrees and doesn't ask for an implementation?
2023-03-01 14:11:11 +0100 <Guest11> kuribas: I had a suspicion of that. Great! I'm digging in!
2023-03-01 14:12:23 +0100 <mon_aaraj> gurkenglas: That's kind of already implemented in wingman. It's used more frequently in Idris and Agda -- stuff like that's called "conversations with the compiler", I like that form of interactive programming.
2023-03-01 14:14:24 +0100Guest11(~Guest11@c83-251-160-169.bredband.tele2.se) (Quit: Client closed)
2023-03-01 14:14:33 +0100dsrt^(~dsrt@c-24-30-76-89.hsd1.ga.comcast.net) (Remote host closed the connection)
2023-03-01 14:15:36 +0100king_gs(~Thunderbi@187.201.41.239)
2023-03-01 14:16:23 +0100MajorBiscuit(~MajorBisc@c-001-028-045.client.tudelft.eduvpn.nl) (Ping timeout: 264 seconds)
2023-03-01 14:16:41 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-03-01 14:16:59 +0100chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2023-03-01 14:17:23 +0100chexum(~quassel@gateway/tor-sasl/chexum)
2023-03-01 14:17:53 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 255 seconds)
2023-03-01 14:18:06 +0100MajorBiscuit(~MajorBisc@2001:1c00:2408:a400:67e:5371:52a7:9b9a)
2023-03-01 14:18:31 +0100swistak(~swistak@185.21.216.141)
2023-03-01 14:19:31 +0100 <kuribas> using type holes in haskell is also pretty common.
2023-03-01 14:19:40 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-03-01 14:20:02 +0100 <kuribas> we just need an AI that fill in holes
2023-03-01 14:20:44 +0100 <gurkenglas> mon_aaraj: *checks out wingman* aww, that looks like it only does the basic things, as opposed to like https://paste.tomsmeding.com/6GRAZ33t
2023-03-01 14:21:18 +0100 <mon_aaraj> Yep... It's also not working for GHC 9.2
2023-03-01 14:21:26 +0100swistak(~swistak@185.21.216.141) (Client Quit)
2023-03-01 14:21:40 +0100 <mon_aaraj> Those along with some other reasons are why I use Agda and Idris a good number of times.
2023-03-01 14:21:46 +0100swistak(~swistak@185.21.216.141)
2023-03-01 14:22:03 +0100 <gurkenglas> kuribas: Copilot is basically this, HLS should add plumbing to give it type signature context
2023-03-01 14:22:30 +0100 <kuribas> yeah, except that it doesn't check the type, or does it?
2023-03-01 14:22:33 +0100 <gurkenglas> (by the time they're done with the plumbing Copilot should be good enough to work with Haskell...)
2023-03-01 14:22:47 +0100 <Axman6> does that code even make any sense? I'm struggling to see how (forall x. x a -> x c) would ever be useful
2023-03-01 14:22:56 +0100 <kuribas> There was an interesting demo in idris where it filled in continuation monad code, based on the type.
2023-03-01 14:23:04 +0100 <merijn> @quote didn't.you.write.it
2023-03-01 14:23:04 +0100 <lambdabot> No quotes match. BOB says: You seem to have forgotten your passwd, enter another!
2023-03-01 14:23:06 +0100 <merijn> aww
2023-03-01 14:23:07 +0100 <kuribas> Sadly not implemented in the latest idris.
2023-03-01 14:23:09 +0100 <gurkenglas> Axman6: (forall x. x a -> x b) witnesses a=b
2023-03-01 14:23:13 +0100 <mon_aaraj> kuribas: Eh. AI can be and usually is wrong, especially with dependent types. Good Type systems can't.
2023-03-01 14:23:31 +0100 <kuribas> mon_aaraj: that's why we need to mix AI and types :)
2023-03-01 14:23:32 +0100 <gurkenglas> mon_aaraj: just get 10 completions and pick the one that compiles :shrug:
2023-03-01 14:24:03 +0100 <Axman6> I understand those words but don't understand how it does that
2023-03-01 14:24:17 +0100 <mon_aaraj> kuribas: I don't really think that'll work out as well as you think it will
2023-03-01 14:24:21 +0100 <merijn> @quote Didn't.you.write.that
2023-03-01 14:24:21 +0100 <lambdabot> autrijus says: * autrijus stares at type Eval x = forall r. ContT r (ReaderT x IO) (ReaderT x IO x) and feels very lost <shapr> Didn't you write that code? <autrijus> yeah. and it works <autrijus> I
2023-03-01 14:24:21 +0100 <lambdabot> just don't know what it means.
2023-03-01 14:24:29 +0100 <merijn> That was the quote I was thinking off ;)
2023-03-01 14:24:42 +0100 <gurkenglas> fine, make the AI write comments too.
2023-03-01 14:24:50 +0100swistak(~swistak@185.21.216.141) (Client Quit)
2023-03-01 14:25:07 +0100 <kuribas> mon_aaraj: that's what research is for, isn't it?
2023-03-01 14:25:11 +0100 <mon_aaraj> an AI like, let's say ChatGPT, would just output the most statistically plausible word soup when you give it a prompt. Same thing for Copilot. There's no logic checking at all.
2023-03-01 14:25:21 +0100 <Axman6> is lambdabot's quote dictionary available anywhere? I'd hate for it to disappear
2023-03-01 14:25:27 +0100euandreh(~Thunderbi@189.6.18.7) (Quit: euandreh)
2023-03-01 14:25:34 +0100 <gurkenglas> mon_aaraj: guess what i do
2023-03-01 14:25:37 +0100 <mon_aaraj> The difference is that for Copilot in very popular languages, the most statistically plausible word soup is usually correct
2023-03-01 14:25:44 +0100 <merijn> Axman6: Whoever hosts it
2023-03-01 14:25:52 +0100 <kuribas> mon_aaraj: I managed ChatGPT to give me a correct implementation of safeTail.
2023-03-01 14:25:55 +0100 <merijn> Axman6: I have a (by now fairly old) copy of it
2023-03-01 14:26:13 +0100 <kuribas> mon_aaraj: it did typecheck.
2023-03-01 14:26:17 +0100 <Axman6> @quote Axman6
2023-03-01 14:26:17 +0100 <lambdabot> Axman6 says: -ddump-occur-anal <- another terrible name...
2023-03-01 14:26:32 +0100 <Axman6> well, that one certainly is old...
2023-03-01 14:26:41 +0100 <merijn> A lot of them are :p
2023-03-01 14:26:43 +0100 <merijn> @quote merijn
2023-03-01 14:26:43 +0100 <lambdabot> merijn says: after a week you can delete 80% of your code and replace it with whatever edwardk wrote that day ;-)
2023-03-01 14:26:51 +0100 <merijn> Still relevant :p
2023-03-01 14:27:04 +0100 <Axman6> very
2023-03-01 14:27:27 +0100 <gurkenglas> Axman6: (forall x. x a -> x b) doesn't give whoever implements it enough information about x to let them do anything except return the value they have that partially matches the expected type and hope that it completely matches
2023-03-01 14:27:31 +0100 <Axman6> I remember doing exactly that with jackdk once, replaced 5-6 lines of State code with a single lens operator
2023-03-01 14:27:50 +0100 <kuribas> mon_aaraj: https://gist.github.com/kuribas/eada8c691e93e2b519dfb21959d9806e
2023-03-01 14:27:50 +0100 <Axman6> gurkenglas: yeah, right, I can see that now. neat
2023-03-01 14:28:16 +0100 <kuribas> mon_aaraj: but maybe it just got it from somewhere in its database.
2023-03-01 14:28:30 +0100 <kuribas> mon_aaraj: I should try it with a completely new usecase.
2023-03-01 14:29:46 +0100 <mon_aaraj> I've never said it could never be right. I just said it doesn't check if it's right, and it just sends the most plausible output. People can get ChatGPT to do something eventually... but it gets harder and harder the more detailed you want to be and the more obscure your field is -- i.e., dependent types.
2023-03-01 14:29:48 +0100 <mon_aaraj> kuribas: Recursion would be funny.
2023-03-01 14:30:14 +0100 <kuribas> idk, it didn't take that many tries...
2023-03-01 14:30:27 +0100 <jackdk> Axman6: lens continues to do that in my code, fwiw
2023-03-01 14:30:31 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:22c2:703e:85c8:b082)
2023-03-01 14:30:51 +0100 <kuribas> "it doesn't check if it's right" <= how could it? It doesn't have a builtin idris interpreter.
2023-03-01 14:31:55 +0100 <mon_aaraj> Doesn't have a built-in logic interpreter, either -- which is the main issue.
2023-03-01 14:32:16 +0100 <merijn> mon_aaraj: to be fair, most people are missing that too :p
2023-03-01 14:32:40 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-03-01 14:32:43 +0100swistak(~swistak@185.21.216.141)
2023-03-01 14:33:03 +0100 <kuribas> hehe, this. Why do people expect a LLM to be magick that could just program out of nowhere? People can't do that either.
2023-03-01 14:35:35 +0100MajorBiscuit(~MajorBisc@2001:1c00:2408:a400:67e:5371:52a7:9b9a) (Ping timeout: 264 seconds)
2023-03-01 14:35:36 +0100 <gurkenglas> this doesn't rule out that the LLM can replace me
2023-03-01 14:35:39 +0100swistak(~swistak@185.21.216.141) (Client Quit)
2023-03-01 14:36:43 +0100 <kuribas> depends on what you do in your day job ...
2023-03-01 14:37:21 +0100MajorBiscuit(~MajorBisc@c-001-028-045.client.tudelft.eduvpn.nl)
2023-03-01 14:37:30 +0100 <gurkenglas> *almost* "make LLMs replace people", wouldn't that be a fun answer
2023-03-01 14:38:32 +0100swistak(~swistak@185.21.216.141)
2023-03-01 14:38:39 +0100 <kuribas> most of what a programmer does is not churning out code, it's gathering requirements, acquiring domain logic, etc...
2023-03-01 14:39:10 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef)
2023-03-01 14:39:20 +0100 <gurkenglas> 1. is that most of what edward kmett does? 2. sure it can do that
2023-03-01 14:40:11 +0100 <gurkenglas> (we don't *really* need another hundred of us. another hundred of edward kmett, on the other hand, would be handy)
2023-03-01 14:41:53 +0100 <kuribas> gurkenglas: I don't think edward kmett "acquires domain logic". He probably absorbs it by osmosis.
2023-03-01 14:42:05 +0100 <gurkenglas> domain logic acquires him.
2023-03-01 14:42:26 +0100vglfr(~vglfr@145.224.100.76)
2023-03-01 14:42:28 +0100 <kuribas> right :)
2023-03-01 14:43:49 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef) (Ping timeout: 256 seconds)
2023-03-01 14:43:51 +0100king_gs(~Thunderbi@187.201.41.239) (Read error: Connection reset by peer)
2023-03-01 14:43:55 +0100 <sclv> gurkenglas: parametricity is about one to many relationships between types. those types may be function types!
2023-03-01 14:44:47 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7)
2023-03-01 14:45:49 +0100 <mon_aaraj> <kuribas> "hehe, this. Why do people..." <- I didn't complain about that because people can do that, i complained about that because they can't do what type systems do.
2023-03-01 14:48:35 +0100 <gurkenglas> sclv: functions form a subset of relations. does retricting the parametricity theorem to relations that are functions actually weaken it?
2023-03-01 14:49:22 +0100 <sclv> think about why we talk about equality in terms of a relation
2023-03-01 14:50:11 +0100 <sclv> hard to be meaningfully reflexive without being trivial otherwise, no?
2023-03-01 14:50:43 +0100 <gurkenglas> equivalence relations can be expressed using equality and functions to equivalence classes, do you have another example?
2023-03-01 14:51:45 +0100 <gurkenglas> (or if what i just said does not suffice to refute your point, we can stay here)
2023-03-01 14:53:23 +0100 <sclv> i think that alternate expression may work for an equiv relation — if you restrict both sides to equiv classes, then you have a function between them.
2023-03-01 14:53:43 +0100 <sclv> but in my mind thats just a clunkier way of expressing the same thing
2023-03-01 14:54:11 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 264 seconds)
2023-03-01 14:54:14 +0100 <gurkenglas> Can you give some corollary of parametricity that i wouldn't want to route through functional language?
2023-03-01 14:54:31 +0100 <sclv> a logical relation is a fattened equiv relation expressed in a certain way. you can re-express it in another equiv way
2023-03-01 14:55:02 +0100 <sclv> like all relations are boolean valued binary functions of a certain form, and you can do that too
2023-03-01 14:55:55 +0100Vajb(~Vajb@2001:999:230:f561:4ee8:ad7f:13ff:9959) (Ping timeout: 248 seconds)
2023-03-01 14:55:57 +0100 <gurkenglas> I prefer to think of a relation as the set of pairs equipped with two projections to avert boolean blindness
2023-03-01 14:56:29 +0100cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.8)
2023-03-01 14:56:46 +0100Vajb(~Vajb@2001:999:68c:7f92:37da:222a:b35b:af4d)
2023-03-01 14:57:01 +0100 <gurkenglas> hmm, if we drop the requirement that every pair appear at most once, we might get a neat categorical phrasing of parametricity
2023-03-01 14:57:28 +0100 <gurkenglas> quick, what's the proof of the parametricity theorem
2023-03-01 14:57:52 +0100 <kuribas> mon_aaraj: my experimentation shows that they can. Sort of ...
2023-03-01 14:58:22 +0100 <gurkenglas> (or, to be fair. what... is the *precise statement* of the parametricity theorem??)
2023-03-01 14:59:06 +0100 <ncf> for t : T, (t, t) ∈ [T] where [T] is a binary relation built by induction on T
2023-03-01 14:59:28 +0100systemhalted(~systemhal@130.51.137.77)
2023-03-01 14:59:48 +0100zer0bitz_(~zer0bitz@2001:2003:f443:d600:fc46:678f:19c6:5892)
2023-03-01 14:59:53 +0100anatta_(~AdiIRC@h-155-4-132-216.NA.cust.bahnhof.se)
2023-03-01 15:00:01 +0100codaraxis___(~codaraxis@user/codaraxis)
2023-03-01 15:00:31 +0100rodental(~rodental@38.146.5.222)
2023-03-01 15:01:05 +0100systemhalted(~systemhal@130.51.137.77) (Remote host closed the connection)
2023-03-01 15:02:34 +0100anatta(~AdiIRC@h-155-4-132-216.NA.cust.bahnhof.se) (Ping timeout: 246 seconds)
2023-03-01 15:02:40 +0100anatta_anatta
2023-03-01 15:02:55 +0100zer0bitz(~zer0bitz@2001:2003:f443:d600:9d80:2d1f:b124:730) (Ping timeout: 246 seconds)
2023-03-01 15:02:55 +0100codaraxis__(~codaraxis@user/codaraxis) (Ping timeout: 246 seconds)
2023-03-01 15:02:57 +0100Ghostpatsch(~Profpatsc@static.88-198-193-255.clients.your-server.de) (Quit: WeeChat 3.7.1)
2023-03-01 15:03:24 +0100 <gurkenglas> ncf: [T] is some particular such relation, yes? is [T] polymorphic in T :)?
2023-03-01 15:04:19 +0100 <ncf> you start with [Bool], [Nat] etc being just equality and then build up
2023-03-01 15:04:51 +0100 <ncf> something like (f, f') ∈ [A → B] iff ∀ (a, a') ∈ [A], (f a, f' a') ∈ [B]
2023-03-01 15:05:09 +0100 <ncf> and the interpretation of forall leads you to quantify over relations
2023-03-01 15:05:25 +0100 <gurkenglas> okay, so it's the smallest reflexive relation
2023-03-01 15:06:11 +0100 <ncf> no, that would be equality
2023-03-01 15:06:27 +0100 <gurkenglas> oh. name some related pair that isn't equal?
2023-03-01 15:07:04 +0100 <ncf> hang on
2023-03-01 15:09:15 +0100 <gurkenglas> (oh, my :03 line was under the impression that you meant T=Type, not T∈Type)
2023-03-01 15:11:11 +0100 <ncf> right so the point is that this is a kind of equality *across types*
2023-03-01 15:11:41 +0100 <gurkenglas> whuh? i didn't expect to read that last line
2023-03-01 15:12:51 +0100coot(~coot@213.134.171.3)
2023-03-01 15:12:53 +0100 <ncf> e.g. for any binary relation R between A and B, you can say that id_A and id_B are related by the relation R → R
2023-03-01 15:13:26 +0100 <ncf> it's a variation on equality, if you will
2023-03-01 15:13:55 +0100 <ncf> indeed the way it's implemented in cubical agda is with a second interval type (the first one being used to implement "equality" (paths)) with slightly different semantics
2023-03-01 15:14:34 +0100 <gurkenglas> let me rephrase. for every two types A,B, you're defining a subset of (A,B)?
2023-03-01 15:15:21 +0100 <gurkenglas> And you're defining it by "induction on Type", which means that it's the least family of relations that satisfies some listed properties
2023-03-01 15:16:26 +0100 <gurkenglas> Presumably the subset of (Int,Int) is the diagonal, and the subset of (Int,Bool) is the empty subset
2023-03-01 15:16:56 +0100 <gurkenglas> What is the subset of (Int,[Int])?
2023-03-01 15:16:58 +0100 <ncf> no, you're defining an interpretation of types as binary relations
2023-03-01 15:17:14 +0100 <ncf> Int is interpreted as the equality relation ⊂ Int × Int
2023-03-01 15:17:38 +0100 <gurkenglas> how does "interpret" differ from "mapped to"?
2023-03-01 15:17:42 +0100 <ncf> → is interpreted as an operator that takes two relations between A × B and A' × B' and outputs a relation between (A → A') × (B → B')
2023-03-01 15:19:27 +0100 <ncf> the point is that this construction does not give you an arbitrary relation Int × Bool. it gives you, for each type T, a relation T × T, but this relation is built from operators that operate on heterogeneous relations
2023-03-01 15:19:39 +0100 <ncf> and the heterogeneity plays a role, as you'd expect, in the interpretation of forall.
2023-03-01 15:19:51 +0100 <ncf> at this point i encourage you to read wadler's paper, it's quite easy to read
2023-03-01 15:20:16 +0100 <gurkenglas> I bounced off it! I came here to ask why it's written in terms of relations.
2023-03-01 15:20:18 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-01 15:20:39 +0100Guest2820(~Guest28@HFA62-0-131-117.bb.netvision.net.il)
2023-03-01 15:21:02 +0100 <ncf> because there's no reason not to, but you can replace every instance of "relation" with "function" if that's easier
2023-03-01 15:21:16 +0100 <ncf> as for whether the version restricted to function is less general, i don't know; i suspect so
2023-03-01 15:21:20 +0100 <ncf> functions*
2023-03-01 15:22:01 +0100 <gurkenglas> ah no wadler's is the *second* link on wikipedia, i bounced off the first link https://people.mpi-sws.org/~dreyer/tor/papers/reynolds.pdf
2023-03-01 15:22:15 +0100 <ncf> that's a lot harder to read!
2023-03-01 15:24:32 +0100thegeekinside(~thegeekin@189.141.115.134)
2023-03-01 15:25:34 +0100ph88(~ph88@ip5b426553.dynamic.kabel-deutschland.de)
2023-03-01 15:26:00 +0100 <ph88> is there some extension to allow this? data Foo = Bar {hello :: Int} | Qux {hello :: String} why is it now allowed ?
2023-03-01 15:26:06 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7) (Remote host closed the connection)
2023-03-01 15:26:26 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7)
2023-03-01 15:26:44 +0100 <geekosaur> ph88, because `hello` is also a function Foo -> (what?)
2023-03-01 15:27:21 +0100 <geekosaur> the `NoFieldSelectors` extension might permit it, but then you have to figure out how to extract `hello`
2023-03-01 15:27:37 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2023-03-01 15:27:41 +0100 <gurkenglas> ncf: you're telling me to read https://homepages.inf.ed.ac.uk/wadler/papers/gr2/gr2-tcs.pdf yes?
2023-03-01 15:28:07 +0100 <ncf> gurkenglas: no, i'm talking about the canonical "Theorems for free!" paper
2023-03-01 15:28:13 +0100 <ncf> https://people.mpi-sws.org/~dreyer/tor/papers/wadler.pdf
2023-03-01 15:29:21 +0100 <ph88> geekosaur, if it would be this data Foo = Bar {hello :: Int} | Qux {bye :: String} would `hello 2` make Bar ? don't really get how that is a function
2023-03-01 15:30:08 +0100 <geekosaur> if `foo :: Foo`, `hello foo` is the value held in the `Bar` alternative or else a runtime error
2023-03-01 15:30:35 +0100 <geekosaur> (if it's a `Qux` instead of a `Bar`)
2023-03-01 15:31:47 +0100 <geekosaur> but if you have `data Foo = Bar {hello :: Int} | Quz {hello :: String}` then for `foo :: Foo`, `hello foo` has no single type; it could be Int or String. which is not permitted
2023-03-01 15:31:52 +0100 <ph88> oh ok understood .. i've only this before when i didn't have a sum type
2023-03-01 15:34:00 +0100systemhalted(~systemhal@130.51.137.77)
2023-03-01 15:35:04 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-03-01 15:35:05 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7) (Ping timeout: 246 seconds)
2023-03-01 15:39:04 +0100systemhalted(~systemhal@130.51.137.77) (Remote host closed the connection)
2023-03-01 15:39:11 +0100MajorBiscuit(~MajorBisc@c-001-028-045.client.tudelft.eduvpn.nl) (Ping timeout: 264 seconds)
2023-03-01 15:39:37 +0100 <ncf> gurkenglas: btw i may have misled you with <ncf> you can replace every instance of "relation" with "function" if that's easier
2023-03-01 15:39:57 +0100 <ncf> you can't actually do that; the constructions involved don't preserve functionality
2023-03-01 15:40:08 +0100gurkenglas(~gurkengla@dynamic-046-114-179-219.46.114.pool.telefonica.de) (Ping timeout: 255 seconds)
2023-03-01 15:40:20 +0100 <ncf> it's really just best to stick to the intuition that we're dealing with arbitrary ways that values could be related oh bye then
2023-03-01 15:41:46 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-03-01 15:41:56 +0100Guest2820(~Guest28@HFA62-0-131-117.bb.netvision.net.il) (Quit: Client closed)
2023-03-01 15:42:03 +0100gurkenglas(~gurkengla@dynamic-089-204-138-097.89.204.138.pool.telefonica.de)
2023-03-01 15:43:53 +0100 <ncf> gurkenglas: https://ircbrowse.tomsmeding.com/browse/lchaskell?id=891025#trid891025
2023-03-01 15:43:59 +0100 <gurkenglas> *reads some* okay yeah i see now why relations, not functions.
2023-03-01 15:45:06 +0100 <geekosaur> fwiw my understanding is this all derives from relations between sets, which are less flexible than functions?
2023-03-01 15:45:07 +0100 <gurkenglas> it's about commuting squares
2023-03-01 15:45:16 +0100waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se)
2023-03-01 15:45:41 +0100 <gurkenglas> i don't see yet why one wouldn't go straight to categories instead of staying at relations *keeps reading*
2023-03-01 15:45:42 +0100coot(~coot@213.134.171.3) (Quit: coot)
2023-03-01 15:46:17 +0100king_gs(~Thunderbi@187.201.41.239)
2023-03-01 15:46:33 +0100MajorBiscuit(~MajorBisc@2001:1c00:2408:a400:67e:5371:52a7:9b9a)
2023-03-01 15:46:33 +0100 <ncf> there's a nice conceptual explanation of parametricity in terms of category if you're interested https://golem.ph.utexas.edu/category/2013/04/scones_logical_relations_and_p.html
2023-03-01 15:46:47 +0100 <ncf> it's a bit high-level
2023-03-01 15:48:18 +0100 <gurkenglas> *reads introduction* hesjustlikemeforreal
2023-03-01 15:49:35 +0100 <gurkenglas> oh yeah i should have read this years ago
2023-03-01 15:49:53 +0100 <gurkenglas> (which i would have if i had seem *this* one years ago :P)
2023-03-01 15:51:10 +0100 <cheater> hey all
2023-03-01 15:51:21 +0100 <cheater> what's that stuff that starts with a pound sign? like GH.encodeField #pubkey pubkey raw_
2023-03-01 15:54:58 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-01 15:56:32 +0100 <geekosaur> these days it's equivalent to `@"pubkey"`, because nobody liked it; as such, it's kinda hard to find documentation for
2023-03-01 15:56:57 +0100 <geekosaur> (and likely both are going away in favor of record dot syntax, sadly)
2023-03-01 15:58:45 +0100 <geekosaur> basically it desugars to a HasField constraint (https://downloads.haskell.org/ghc/9.6.1-alpha3/docs/users_guide/exts/hasfield.html)
2023-03-01 15:59:55 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds)
2023-03-01 16:00:26 +0100 <gurkenglas> *reads further* omfg it then goes on to accidentally hand me what i needed to formalize my CT insight en passant, 50% chance
2023-03-01 16:01:43 +0100 <ncf> the bit about sections?
2023-03-01 16:03:18 +0100 <ncf> that's essentially why i was objecting that you can do this: you need dependent types to express sections
2023-03-01 16:07:50 +0100 <cheater> geekosaur: and what's `@"pubkey"` ?
2023-03-01 16:11:38 +0100 <cheater> reading the link...
2023-03-01 16:11:45 +0100 <cheater> so uh... is there any difference?
2023-03-01 16:13:42 +0100ddellacosta(~ddellacos@146.70.166.10) (Quit: WeeChat 3.8)
2023-03-01 16:14:40 +0100ddellacosta(~ddellacos@146.70.166.10)
2023-03-01 16:16:27 +0100 <geekosaur> any difference where?
2023-03-01 16:16:30 +0100king_gs(~Thunderbi@187.201.41.239) (Read error: Connection reset by peer)
2023-03-01 16:16:58 +0100 <geekosaur> the @"foo" version requires proper support for type level strings; that's relatively recent
2023-03-01 16:17:00 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7)
2023-03-01 16:17:11 +0100 <geekosaur> #foo goes back a bit farther
2023-03-01 16:17:37 +0100 <geekosaur> in either case it's more flexible than old style field selectors
2023-03-01 16:18:14 +0100 <geekosaur> (and is equivalent to doing record accesses/updates using lens; in fact HasField is pretty much the same as the one used by lens)
2023-03-01 16:18:37 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-03-01 16:19:13 +0100 <geekosaur> so using #foo instead of @"foo" just gets that code more compatibility with older ghcs
2023-03-01 16:19:16 +0100polyphem_(~rod@2a02:810d:840:8754:fedd:193c:1a4:58ad)
2023-03-01 16:19:50 +0100chexum(~quassel@gateway/tor-sasl/chexum) (Ping timeout: 255 seconds)
2023-03-01 16:20:16 +0100Guest11(~Guest11@c83-251-160-169.bredband.tele2.se)
2023-03-01 16:20:50 +0100 <gurkenglas> ncf: yes, the bit about sections. if *this* is what doing it with dependent types looks like that is pretty strong evidence that i do need em
2023-03-01 16:21:32 +0100chexum(~quassel@gateway/tor-sasl/chexum)
2023-03-01 16:21:56 +0100Guest11(~Guest11@c83-251-160-169.bredband.tele2.se) (Client Quit)
2023-03-01 16:22:07 +0100 <cheater> geekosaur: hmm... ok
2023-03-01 16:24:20 +0100ddellacosta(~ddellacos@146.70.166.10) (Quit: WeeChat 3.8)
2023-03-01 16:24:44 +0100ddellacosta(~ddellacos@146.70.166.10)
2023-03-01 16:24:58 +0100 <geekosaur> more precisely older ghcs had Symbol / type level strings, but @"foo" wasn't yet accepted
2023-03-01 16:25:07 +0100 <geekosaur> iirc
2023-03-01 16:25:24 +0100 <geekosaur> so you had to use #foo
2023-03-01 16:26:13 +0100 <gurkenglas> ncf: one exercise that fell out of my insight was "there's a unique natural way to define composition for free categories" and the bit about sections also reminds me of my proof there
2023-03-01 16:26:25 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-03-01 16:27:22 +0100 <gurkenglas> (which is evidence that this language fits my use case)
2023-03-01 16:28:17 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-03-01 16:28:51 +0100 <gurkenglas> (made that connection after my three-lines-ago 8-minutes-ago line)
2023-03-01 16:30:36 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-03-01 16:31:45 +0100Guest2870(~Guest28@HFA62-0-131-117.bb.netvision.net.il)
2023-03-01 16:31:45 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-03-01 16:32:53 +0100Guest2870(~Guest28@HFA62-0-131-117.bb.netvision.net.il) (Client Quit)
2023-03-01 16:35:30 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7) (Ping timeout: 255 seconds)
2023-03-01 16:38:58 +0100teo(~teo@user/teo) (Ping timeout: 252 seconds)
2023-03-01 16:38:58 +0100Sgeo(~Sgeo@user/sgeo)
2023-03-01 16:41:36 +0100jero98772(~jero98772@2800:484:1d80:d8ce:efcc:cbb3:7f2a:6dff)
2023-03-01 16:45:52 +0100codoliodolio
2023-03-01 16:46:06 +0100Ashkan(~Ashkan@a119011.upc-a.chello.nl)
2023-03-01 16:48:15 +0100 <Ashkan> Hello
2023-03-01 16:48:15 +0100 <Ashkan> I've noticed a lot of `newtype` definitions use an `un-` prefix for the field inside e.g. `HandlerFor { unHandlerFor :: HandlerData site site -> ...` but others go the opposite direction and use a `run-` prefix like `ResourceT`. I was wondering why is that ?
2023-03-01 16:51:30 +0100 <geekosaur> `un` implies unwrapping; `run` implies execution or evaluation
2023-03-01 16:52:29 +0100 <c_wraith> I don't really think the prefix means that much.
2023-03-01 16:53:15 +0100waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se) (Ping timeout: 248 seconds)
2023-03-01 16:53:44 +0100Everything(~Everythin@46.185.124.65) (Quit: leaving)
2023-03-01 16:54:03 +0100foul_owl(~kerry@157.97.134.62) (Ping timeout: 255 seconds)
2023-03-01 16:55:04 +0100kenran`(~user@user/kenran) (Remote host closed the connection)
2023-03-01 16:56:23 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:22c2:703e:85c8:b082) (Quit: WeeChat 2.8)
2023-03-01 16:59:14 +0100Guest73(~Guest73@165.225.213.116)
2023-03-01 16:59:20 +0100 <Ashkan> when is it considered unwrapping ? e.g. both `HandlerFor` and `StateT` essentially contain the same thing : a function from something to something else. They encapsulate an action that requires an argument and produces a result in the desired monad
2023-03-01 17:00:11 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 264 seconds)
2023-03-01 17:00:39 +0100 <Ashkan> I have my own datatype which I'm not sure how to name `newtype InMemeory id session a = InMemeory {unInMemory :: TVar (M.Map id session) -> STM a`
2023-03-01 17:00:39 +0100 <Ashkan> It is supposed to mean : an in-memory session store is a `TVar` holding a map from `id`s to `sessions`
2023-03-01 17:01:34 +0100 <gurkenglas> why do you have it?
2023-03-01 17:01:40 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-03-01 17:02:00 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-03-01 17:02:51 +0100gentauro(~gentauro@user/gentauro) (Read error: Connection reset by peer)
2023-03-01 17:03:16 +0100king_gs(~Thunderbi@187.201.41.239)
2023-03-01 17:04:25 +0100chele(~chele@user/chele) (Quit: Leaving)
2023-03-01 17:08:37 +0100gentauro(~gentauro@user/gentauro)
2023-03-01 17:10:36 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-03-01 17:12:07 +0100CiaoSen(~Jura@p200300c9570e91002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-03-01 17:15:28 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-03-01 17:15:29 +0100 <Ashkan> have what ? the `InMemory` ?
2023-03-01 17:17:22 +0100jinsun__(~jinsun@user/jinsun)
2023-03-01 17:17:22 +0100jinsunGuest1057
2023-03-01 17:17:22 +0100Guest1057(~jinsun@user/jinsun) (Killed (molybdenum.libera.chat (Nickname regained by services)))
2023-03-01 17:17:22 +0100jinsun__jinsun
2023-03-01 17:21:06 +0100 <geekosaur> I would wonder what the newtype is getting you
2023-03-01 17:22:17 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 255 seconds)
2023-03-01 17:22:44 +0100king_gs(~Thunderbi@187.201.41.239) (Read error: Connection reset by peer)
2023-03-01 17:23:35 +0100razetime(~Thunderbi@117.193.3.64)
2023-03-01 17:24:19 +0100pwntips_(~user@24-113-98-114.wavecable.com) (Ping timeout: 246 seconds)
2023-03-01 17:24:36 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7)
2023-03-01 17:24:43 +0100Ashkan(~Ashkan@a119011.upc-a.chello.nl) (Ping timeout: 260 seconds)
2023-03-01 17:24:51 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-03-01 17:24:51 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-03-01 17:25:45 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-03-01 17:26:26 +0100pwntips_(~user@24-113-98-114.wavecable.com)
2023-03-01 17:31:37 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-03-01 17:32:50 +0100078AALVPE(~Thunderbi@2a02:8109:abc0:6434:64ad:38c9:a22a:dbbb) (Remote host closed the connection)
2023-03-01 17:32:51 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-03-01 17:33:44 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef)
2023-03-01 17:34:05 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-03-01 17:34:06 +0100vglfr(~vglfr@145.224.100.76) (Ping timeout: 255 seconds)
2023-03-01 17:34:38 +0100Guest73(~Guest73@165.225.213.116) (Ping timeout: 260 seconds)
2023-03-01 17:35:35 +0100BasLaa(~BasLaa@84-28-141-28.cable.dynamic.v4.ziggo.nl)
2023-03-01 17:37:43 +0100BasLaa(~BasLaa@84-28-141-28.cable.dynamic.v4.ziggo.nl) (Client Quit)
2023-03-01 17:41:12 +0100vglfr(~vglfr@145.224.100.76)
2023-03-01 17:46:57 +0100mmhat(~mmh@p200300f1c7046216ee086bfffe095315.dip0.t-ipconnect.de)
2023-03-01 17:48:03 +0100vglfr(~vglfr@145.224.100.76) (Ping timeout: 255 seconds)
2023-03-01 17:49:07 +0100mbuf(~Shakthi@49.204.115.87) (Quit: Leaving)
2023-03-01 17:49:23 +0100vglfr(~vglfr@145.224.100.76)
2023-03-01 17:51:06 +0100euandreh(~Thunderbi@189.6.18.7)
2023-03-01 17:51:38 +0100Guest11(~Guest11@c83-251-160-169.bredband.tele2.se)
2023-03-01 17:51:47 +0100mmhat(~mmh@p200300f1c7046216ee086bfffe095315.dip0.t-ipconnect.de) (Client Quit)
2023-03-01 17:52:34 +0100Guest11(~Guest11@c83-251-160-169.bredband.tele2.se) (Client Quit)
2023-03-01 17:55:01 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef) (Remote host closed the connection)
2023-03-01 18:10:48 +0100vglfr(~vglfr@145.224.100.76) (Read error: Connection reset by peer)
2023-03-01 18:11:00 +0100vglfr(~vglfr@145.224.100.76)
2023-03-01 18:14:05 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi)
2023-03-01 18:17:12 +0100razetime(~Thunderbi@117.193.3.64) (Remote host closed the connection)
2023-03-01 18:17:47 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-03-01 18:18:59 +0100polyphem_(~rod@2a02:810d:840:8754:fedd:193c:1a4:58ad) (Ping timeout: 255 seconds)
2023-03-01 18:19:46 +0100polyphem_(~rod@2a02:810d:840:8754:224e:f6ff:fe5e:bc17)
2023-03-01 18:30:09 +0100 <cheater> geekosaur: thanks
2023-03-01 18:32:38 +0100stackdroid18(14094@de1.hashbang.sh)
2023-03-01 18:34:25 +0100zeenk(~zeenk@2a02:2f04:a20d:f900::7fe)
2023-03-01 18:34:44 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2023-03-01 18:35:09 +0100MajorBiscuit(~MajorBisc@2001:1c00:2408:a400:67e:5371:52a7:9b9a) (Quit: WeeChat 3.6)
2023-03-01 18:36:33 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-01 18:39:08 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Quit: ERC (IRC client for Emacs 27.1))
2023-03-01 18:42:47 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7) (Ping timeout: 264 seconds)
2023-03-01 18:43:06 +0100king_gs(~Thunderbi@187.201.41.239)
2023-03-01 18:44:48 +0100mechap(~mechap@user/mechap)
2023-03-01 18:45:37 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef)
2023-03-01 18:46:25 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-03-01 18:47:04 +0100foul_owl(~kerry@193.29.61.203)
2023-03-01 18:53:44 +0100codaraxis___(~codaraxis@user/codaraxis) (Quit: Leaving)
2023-03-01 18:59:08 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 246 seconds)
2023-03-01 19:00:15 +0100nschoe(~q@141.101.51.197) (Ping timeout: 260 seconds)
2023-03-01 19:02:28 +0100econo(uid147250@user/econo)
2023-03-01 19:03:12 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-03-01 19:03:48 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 252 seconds)
2023-03-01 19:04:29 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-03-01 19:05:26 +0100CiaoSen(~Jura@p200300c9570e91002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-03-01 19:11:03 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-03-01 19:11:18 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 255 seconds)
2023-03-01 19:11:48 +0100Kuttenbrunzer(~Kuttenbru@2a02:8108:8b80:1d48::9550)
2023-03-01 19:15:51 +0100Midjak(~Midjak@82.66.147.146) (Read error: Connection reset by peer)
2023-03-01 19:16:39 +0100dcoutts_(~duncan@cpc69403-oxfd27-2-0-cust285.4-3.cable.virginm.net) (Remote host closed the connection)
2023-03-01 19:16:50 +0100jakalx(~jakalx@base.jakalx.net) ()
2023-03-01 19:17:02 +0100dcoutts_(~duncan@cpc69403-oxfd27-2-0-cust285.4-3.cable.virginm.net)
2023-03-01 19:21:21 +0100Kuttenbrunzer(~Kuttenbru@2a02:8108:8b80:1d48::9550) (Quit: Where is it)
2023-03-01 19:21:34 +0100mechap(~mechap@user/mechap) (Quit: WeeChat 3.8)
2023-03-01 19:23:17 +0100mechap(~mechap@user/mechap)
2023-03-01 19:23:42 +0100Ashkan(~Ashkan@ec2-54-78-14-109.eu-west-1.compute.amazonaws.com)
2023-03-01 19:24:28 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-03-01 19:24:46 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-03-01 19:25:01 +0100jakalx(~jakalx@base.jakalx.net)
2023-03-01 19:26:36 +0100opticblast(~Thunderbi@172.58.83.235)
2023-03-01 19:28:57 +0100king_gs1(~Thunderbi@187.201.41.239)
2023-03-01 19:29:03 +0100king_gs(~Thunderbi@187.201.41.239) (Read error: Connection reset by peer)
2023-03-01 19:29:03 +0100king_gs1king_gs
2023-03-01 19:30:39 +0100Monster196883(~hp@103.15.228.66)
2023-03-01 19:31:59 +0100azimut_(~azimut@gateway/tor-sasl/azimut)
2023-03-01 19:32:26 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-03-01 19:33:21 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-03-01 19:33:43 +0100califax(~califax@user/califx)
2023-03-01 19:35:39 +0100hugo(znc@verdigris.lysator.liu.se) (Ping timeout: 256 seconds)
2023-03-01 19:38:06 +0100ft(~ft@p3e9bc443.dip0.t-ipconnect.de)
2023-03-01 19:42:20 +0100hugo-(znc@verdigris.lysator.liu.se)
2023-03-01 19:44:43 +0100king_gs(~Thunderbi@187.201.41.239) (Ping timeout: 256 seconds)
2023-03-01 19:46:44 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-03-01 19:50:26 +0100azimut_(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-03-01 19:50:39 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-03-01 19:50:54 +0100opticblast(~Thunderbi@172.58.83.235) (Ping timeout: 255 seconds)
2023-03-01 19:53:01 +0100Midjak(~Midjak@82.66.147.146)
2023-03-01 19:53:24 +0100Midjak(~Midjak@82.66.147.146) (Remote host closed the connection)
2023-03-01 19:53:59 +0100Midjak(~Midjak@82.66.147.146)
2023-03-01 19:57:15 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com)
2023-03-01 19:58:01 +0100michalz(~michalz@185.246.207.203) (Remote host closed the connection)
2023-03-01 19:59:12 +0100nschoe(~q@2a01:e0a:8e:a190:91bd:1aae:19b1:2ad9)
2023-03-01 20:01:16 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-03-01 20:07:12 +0100 <dminuoso_> Ashkan: Names dont have intrinsic meaning, we humans attach meaning to them. Seasoned programmers have a tendency to name according to some semantics or mind model.
2023-03-01 20:09:11 +0100Midjak(~Midjak@82.66.147.146) (Ping timeout: 264 seconds)
2023-03-01 20:09:20 +0100 <dminuoso_> One of my all time favourite package is `monad-chronicle`, which has very "suggestive" names that make a lot of sense if you adopt a certain mindmodel: https://hackage.haskell.org/package/monad-chronicle-1.0.1/docs/Control-Monad-Chronicle-Class.html#…
2023-03-01 20:09:24 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67)
2023-03-01 20:10:26 +0100azure_vermilion(~azure_ver@164.39.138.83) (Remote host closed the connection)
2023-03-01 20:11:27 +0100mei(~mei@user/mei) (Quit: mei)
2023-03-01 20:11:27 +0100azure_vermilion(~Thunderbi@164.39.138.83)
2023-03-01 20:11:35 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Ping timeout: 264 seconds)
2023-03-01 20:15:17 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-03-01 20:17:15 +0100Midjak(~Midjak@82.66.147.146)
2023-03-01 20:17:24 +0100azure_vermilion(~Thunderbi@164.39.138.83) (Quit: azure_vermilion)
2023-03-01 20:19:18 +0100Midjak(~Midjak@82.66.147.146) (Read error: Connection reset by peer)
2023-03-01 20:19:51 +0100Midjak(~Midjak@82.66.147.146)
2023-03-01 20:20:17 +0100kenaryn(~aurele@cre71-h03-89-88-44-27.dsl.sta.abo.bbox.fr)
2023-03-01 20:24:46 +0100Ashkan(~Ashkan@ec2-54-78-14-109.eu-west-1.compute.amazonaws.com) (Quit: Client closed)
2023-03-01 20:28:06 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-03-01 20:28:57 +0100trev(~trev@user/trev)
2023-03-01 20:32:36 +0100dcoutts_(~duncan@cpc69403-oxfd27-2-0-cust285.4-3.cable.virginm.net) (Remote host closed the connection)
2023-03-01 20:32:59 +0100dcoutts_(~duncan@cpc69403-oxfd27-2-0-cust285.4-3.cable.virginm.net)
2023-03-01 20:34:30 +0100dhil(~dhil@78.45.150.83.ewm.ftth.as8758.net)
2023-03-01 20:34:35 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7) (Ping timeout: 256 seconds)
2023-03-01 20:35:37 +0100bilegeek(~bilegeek@2600:1008:b027:385c:33be:5951:6763:bc55)
2023-03-01 20:35:54 +0100shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 255 seconds)
2023-03-01 20:38:26 +0100michalz(~michalz@185.246.207.193)
2023-03-01 20:39:57 +0100dcoutts_(~duncan@cpc69403-oxfd27-2-0-cust285.4-3.cable.virginm.net) (Ping timeout: 255 seconds)
2023-03-01 20:44:57 +0100Ashkan(~Ashkan@a119011.upc-a.chello.nl)
2023-03-01 20:45:57 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef) (Remote host closed the connection)
2023-03-01 20:51:38 +0100Guest73(~Guest73@165.225.213.116)
2023-03-01 20:57:57 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-03-01 20:59:05 +0100hagbard(~hagbard@user/hagbard)
2023-03-01 20:59:45 +0100dhil(~dhil@78.45.150.83.ewm.ftth.as8758.net) (Ping timeout: 255 seconds)
2023-03-01 21:03:00 +0100vglfr(~vglfr@145.224.100.76) (Remote host closed the connection)
2023-03-01 21:03:31 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67) (Quit: Leaving)
2023-03-01 21:05:37 +0100vglfr(~vglfr@145.224.100.76)
2023-03-01 21:06:01 +0100dcoutts_(~duncan@cpc69403-oxfd27-2-0-cust285.4-3.cable.virginm.net)
2023-03-01 21:07:32 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-03-01 21:12:51 +0100michalz(~michalz@185.246.207.193) (Remote host closed the connection)
2023-03-01 21:13:58 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-03-01 21:16:51 +0100michalz(~michalz@185.246.207.221)
2023-03-01 21:17:29 +0100mncheck(~mncheck@193.224.205.254)
2023-03-01 21:17:30 +0100mncheck(~mncheck@193.224.205.254) (Read error: Connection reset by peer)
2023-03-01 21:20:21 +0100 <hagbard> Hi. A small code snippet results in a warning about noncanonical return definitions. Can someone explain to me (a noob) what that means and what to to about for the specific example? https://paste.tomsmeding.com/Dtd4qtz7
2023-03-01 21:21:20 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-03-01 21:21:26 +0100 <Jade[m]1> return should be implemented like return = pure where pure is the function from the Applicative typeclass
2023-03-01 21:21:46 +0100 <Jade[m]1> return is simply a relict from when there was no type hierarchy for monads
2023-03-01 21:22:00 +0100077AAMFUK(~mncheck@193.224.205.254)
2023-03-01 21:22:45 +0100Monster196883(~hp@103.15.228.66) (Ping timeout: 256 seconds)
2023-03-01 21:23:44 +0100 <hagbard> thanks Jade[m]1 . *thinks about it*
2023-03-01 21:24:27 +0100 <[exa]> hagbard: to supplement the "problematic" case -- assumption that `return` is indistinguishable from `pure` is very common, and breaking it in your monads may very easily break libraries
2023-03-01 21:25:19 +0100 <Jade[m]1> which is why it's deprecated - stuff like that shouldn't happen (but it does)
2023-03-01 21:25:33 +0100 <[exa]> (and there's a few other kinda semantic gripes there, such as return not actually returning anywhere, etc.)
2023-03-01 21:25:35 +0100vglfr(~vglfr@145.224.100.76) (Remote host closed the connection)
2023-03-01 21:26:46 +0100vglfr(~vglfr@145.224.100.76)
2023-03-01 21:26:48 +0100vglfr(~vglfr@145.224.100.76) (Remote host closed the connection)
2023-03-01 21:27:20 +0100 <Jade[m]1> the only place where it "returns" is in the context of a do-block as the last statement
2023-03-01 21:27:33 +0100 <Jade[m]1> which in itself shouldn't be a reason to call it that
2023-03-01 21:27:38 +0100 <[exa]> hagbard: btw I assume your `pure` implementation for applicative isn't different, right?
2023-03-01 21:28:07 +0100 <hagbard> That's right.
2023-03-01 21:28:50 +0100 <[exa]> hagbard: ok that's good. You can safely erase the `return` then :]
2023-03-01 21:29:40 +0100 <[exa]> Jade[m]1: +1 :]
2023-03-01 21:29:53 +0100vglfr(~vglfr@145.224.100.76)
2023-03-01 21:30:18 +0100Guest73(~Guest73@165.225.213.116) (Ping timeout: 260 seconds)
2023-03-01 21:30:34 +0100 <Jade[m]1> * which in itself shouldn't be a *reason* to call it that, because it's just syntactic sugar
2023-03-01 21:31:09 +0100 <hagbard> So, i just get rid of the return line?
2023-03-01 21:31:25 +0100 <Jade[m]1> yep, the default implementation takes care of it
2023-03-01 21:31:32 +0100 <[exa]> hagbard: yap, that should work. The default is `return=pure`
2023-03-01 21:31:40 +0100 <hagbard> Got rid of the warning, thanks!
2023-03-01 21:31:54 +0100 <[exa]> also 1 line golfed \o/
2023-03-01 21:31:59 +0100dcoutts_(~duncan@cpc69403-oxfd27-2-0-cust285.4-3.cable.virginm.net) (Ping timeout: 264 seconds)
2023-03-01 21:32:48 +0100 <Jade[m]1> [exa]: hahaha
2023-03-01 21:35:26 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-03-01 21:42:03 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 255 seconds)
2023-03-01 21:44:34 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf) (Remote host closed the connection)
2023-03-01 21:44:37 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-03-01 21:44:53 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf)
2023-03-01 21:48:29 +0100niko(niko@libera/staff/niko) (Ping timeout: 615 seconds)
2023-03-01 21:51:36 +0100vglfr(~vglfr@145.224.100.76) (Remote host closed the connection)
2023-03-01 21:53:18 +0100vglfr(~vglfr@145.224.100.76)
2023-03-01 21:53:30 +0100Ashkan(~Ashkan@a119011.upc-a.chello.nl) (Quit: Client closed)
2023-03-01 21:53:59 +0100fnurglewitz(uid263868@id-263868.lymington.irccloud.com)
2023-03-01 21:55:46 +0100 <fnurglewitz> anyone knows if there's a way to download a file via https and pass it to a function as a lazy bytestring? my goal is to let the function "drive" when the chunks of the file are read (to avoid loading the whole file in memory before starting to process it)
2023-03-01 21:56:34 +0100 <fnurglewitz> I tried to do it with withResponse/brRead but failed
2023-03-01 21:56:52 +0100 <c_wraith> that's not really compatible with http
2023-03-01 21:57:35 +0100 <c_wraith> (unless you're doing stuff with the range header and the server supports it
2023-03-01 21:57:37 +0100 <c_wraith> )
2023-03-01 21:57:46 +0100 <sm> I've heard of streaming ajax responses I think..
2023-03-01 21:58:05 +0100 <geekosaur> but that's not strictly http
2023-03-01 21:58:07 +0100 <c_wraith> sure, long-polling exists
2023-03-01 21:58:20 +0100 <Jade[m]1> mhm
2023-03-01 21:58:25 +0100 <c_wraith> but that's server-driven, not client-driven
2023-03-01 21:58:30 +0100 <geekosaur> if you make an http or https request the response comes back as one big lump of data that you can't really stream
2023-03-01 21:58:43 +0100 <Jade[m]1> I don't think it's a problem to process the entire response at once
2023-03-01 21:59:00 +0100 <Jade[m]1> which is the intended way
2023-03-01 21:59:59 +0100 <mauke> if you make an http request, the response comes back on a socket, which the only thing you can do with is stream
2023-03-01 22:00:14 +0100 <mauke> i.e. call read() repeatedly
2023-03-01 22:00:34 +0100 <c_wraith> If you read too slowly, http servers consider that to be an attack and terminate the connection
2023-03-01 22:00:43 +0100 <fnurglewitz> understood
2023-03-01 22:00:46 +0100 <c_wraith> You can't let the consumer drive the process arbitrarily
2023-03-01 22:01:16 +0100 <mauke> eh, slow connections are a thing
2023-03-01 22:02:25 +0100 <mauke> my concern is more that this would involve unsafeInterleaveIO, which I consider black magic
2023-03-01 22:02:30 +0100 <fnurglewitz> it should still be possible to start parse the bytestring before receiving all the data, right?
2023-03-01 22:02:32 +0100 <c_wraith> like I said before - if you really want to drive this from the consumer side, you want to make multiple http requests with range headers - and you need the server to support them
2023-03-01 22:02:50 +0100 <geekosaur> I was going to suggest conduit, which is the principled way
2023-03-01 22:03:00 +0100 <fnurglewitz> the data is going into a conduit later
2023-03-01 22:03:12 +0100 <fnurglewitz> net -> json-stream -> conduit
2023-03-01 22:03:17 +0100 <mauke> if you need it as a single (even lazy) bytestring, there's going to be some friction
2023-03-01 22:03:50 +0100 <fnurglewitz> yup, a single lazy bytestring (which should be just a list of bytestrings internally if I understood correctly)
2023-03-01 22:04:12 +0100 <mauke> yeah, that means unsafeInterleaveIO *shudder*
2023-03-01 22:06:55 +0100Midjak(~Midjak@82.66.147.146) (Quit: This computer has gone to sleep)
2023-03-01 22:07:01 +0100dcoutts_(~duncan@cpc69403-oxfd27-2-0-cust285.4-3.cable.virginm.net)
2023-03-01 22:07:25 +0100 <fnurglewitz> never used it :D
2023-03-01 22:08:27 +0100 <mauke> good. your soul can still be saved
2023-03-01 22:08:32 +0100 <fnurglewitz> oh ok, I suppose the lazy BS readFile function uses it because when I read the file from disk the process uses like 15M of memory
2023-03-01 22:08:37 +0100Guest73(~Guest73@165.225.213.116)
2023-03-01 22:08:38 +0100 <fnurglewitz> with a 1.5G file
2023-03-01 22:08:54 +0100 <c_wraith> honestly, unsafePerformIO is fine unless you intentionally make it awful.
2023-03-01 22:08:55 +0100 <fnurglewitz> when downloading it directly from the net the memory is 2G, RIP
2023-03-01 22:09:19 +0100 <c_wraith> unlike unsafePerformST, which gets much more awful much more easily.
2023-03-01 22:09:36 +0100 <fnurglewitz> I wonder if dowloading the file to the filesystem and then reading it helps a bit with the memory
2023-03-01 22:09:41 +0100 <Guest73> Hi, was reading https://wiki.haskell.org/Seq, at the end of the page there's this example, but it doesn't compile. Not sure what that example is supposed to mean? https://godbolt.org/z/xY7nM1bKn
2023-03-01 22:10:01 +0100 <fnurglewitz> maybe the chunks are garbage collected as soon as the buffers are written to disk
2023-03-01 22:10:03 +0100 <fnurglewitz> hm
2023-03-01 22:10:10 +0100lyle(~lyle@104.246.145.237) (Quit: WeeChat 3.8)
2023-03-01 22:10:35 +0100 <mauke> https://hackage.haskell.org/package/bytestring-0.11.4.0/docs/src/Data.ByteString.Lazy.html#hGetCon… <- here's how that's implemented
2023-03-01 22:10:36 +0100 <geekosaur> Guest73, those aren't code, they are values with their types
2023-03-01 22:10:36 +0100 <c_wraith> Guest73: that's just showing two expressions. it's not intended to be complete code
2023-03-01 22:11:26 +0100 <fnurglewitz> mauke: lovely <3
2023-03-01 22:12:18 +0100 <fnurglewitz> I have just 1 doubt now
2023-03-01 22:12:19 +0100 <Guest73> Ok maybe more specifically, does `const undefined :: a -> b` mean something, or what is it missing to mean something?
2023-03-01 22:12:28 +0100 <fnurglewitz> I understand that I can't drive when the server sends data to my socket
2023-03-01 22:12:43 +0100 <geekosaur> :t const undefined
2023-03-01 22:12:44 +0100 <lambdabot> b -> a
2023-03-01 22:12:49 +0100 <fnurglewitz> but still, shouldn't the lazy bytestring I produce be parsed while the data is coming?
2023-03-01 22:12:52 +0100 <geekosaur> :t const
2023-03-01 22:12:52 +0100 <lambdabot> a -> b -> a
2023-03-01 22:13:04 +0100 <fnurglewitz> as of now it's like the parser waits for the whole file to be in memory
2023-03-01 22:13:27 +0100 <geekosaur> in this case `a` is `(undefined :: a)` (any type, since it never actually produces a value), and `b` is yet to be specified
2023-03-01 22:13:38 +0100 <mauke> fnurglewitz: depends on how you're reading the data from the network
2023-03-01 22:13:47 +0100cyphase(~cyphase@user/cyphase) (Ping timeout: 248 seconds)
2023-03-01 22:13:55 +0100 <fnurglewitz> may i link a pastebin? the code is horrible but probably you can spot where I'm wrong
2023-03-01 22:13:55 +0100hugo-(znc@verdigris.lysator.liu.se) (Ping timeout: 260 seconds)
2023-03-01 22:14:08 +0100 <mauke> sure
2023-03-01 22:14:23 +0100 <geekosaur> and the point of this is that thyere is normally no way to distinguish between the two `undefined`s
2023-03-01 22:14:29 +0100 <fnurglewitz> mauke: https://pastebin.com/TEXNyjKS
2023-03-01 22:14:37 +0100 <fnurglewitz> pls don't mind the code, I'm really bad :D
2023-03-01 22:14:44 +0100 <mauke> (I'm probably not going to be much help, but I hope others are more knowledgeable)
2023-03-01 22:15:46 +0100 <geekosaur> but `seq` means these two cases (direct `undefined` used at a function type, vs. a function which always produces `undefined` when applied) can be distinguished
2023-03-01 22:15:58 +0100 <geekosaur> it is admittedly a tricky case
2023-03-01 22:16:15 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 248 seconds)
2023-03-01 22:16:53 +0100 <Guest73> Ok thanks geekosaur, will take a few minutes (...hours) to sink that in :P
2023-03-01 22:18:28 +0100 <mauke> fnurglewitz: OK, so your provaRead/go function contains a loop that collects the whole response in memory before returning
2023-03-01 22:19:20 +0100 <fnurglewitz> mauke: I was hoping for it to be lazy
2023-03-01 22:19:55 +0100dhil(~dhil@78.45.150.83.ewm.ftth.as8758.net)
2023-03-01 22:20:02 +0100 <mauke> it can't be, really; it's sequenced by IO
2023-03-01 22:21:18 +0100 <fnurglewitz> hm, but readFile is lazy :D
2023-03-01 22:21:25 +0100 <fnurglewitz> and it's still IO
2023-03-01 22:22:15 +0100 <geekosaur> readFile uses unsafeInterleaveIO, which is evil
2023-03-01 22:22:22 +0100 <fnurglewitz> :D
2023-03-01 22:22:43 +0100 <fnurglewitz> maybe something evil like mutating an IORef?
2023-03-01 22:22:56 +0100 <geekosaur> it's doing reads in pure code
2023-03-01 22:23:07 +0100 <geekosaur> s/reads/I\/O/
2023-03-01 22:23:42 +0100 <fnurglewitz> or maybe just spawn wget, wait for it to be done and read from FS, lol
2023-03-01 22:24:07 +0100 <mauke> the "morally right" way to do this would be to use https://hackage.haskell.org/package/json-stream-0.4.5.2/docs/Data-JsonStream-Parser.html#t:ParseOu…
2023-03-01 22:24:17 +0100 <mauke> and feed it bytestring chunks as they're received
2023-03-01 22:24:35 +0100 <mauke> (I don't know if conduit has a streaming json parser built in)
2023-03-01 22:25:31 +0100 <fnurglewitz> I can try
2023-03-01 22:25:34 +0100 <fnurglewitz> thanks
2023-03-01 22:25:38 +0100 <fnurglewitz> "morally" :D
2023-03-01 22:25:44 +0100 <geekosaur> "built in" isn't a thing; rather, it provides an interface for things like JSON parsers to use, much as base provides a framework for traditional I/O
2023-03-01 22:25:59 +0100 <mauke> in fact, the whole thing should probably be set up as a conduit pipeline, not just the part after JSON parsing
2023-03-01 22:26:03 +0100 <mauke> https://hackage.haskell.org/package/http-conduit-2.3.8/docs/Network-HTTP-Client-Conduit.html#v:wit…
2023-03-01 22:26:39 +0100 <mauke> you'd "just" have to fit the JSON parser in there somehow
2023-03-01 22:27:02 +0100 <fnurglewitz> sounds scary
2023-03-01 22:27:19 +0100 <fnurglewitz> I'll try
2023-03-01 22:27:36 +0100 <geekosaur> https://hackage.haskell.org/package/ndjson-conduit ?
2023-03-01 22:27:57 +0100 <mauke> doesn't sound like it's newline delimited
2023-03-01 22:28:02 +0100mrcsno(~mrcsno@71.69.152.220) (Read error: Connection reset by peer)
2023-03-01 22:28:10 +0100 <mauke> because that's the other issue: raw JSON isn't exactly streaming friendly
2023-03-01 22:28:39 +0100 <fnurglewitz> luckily the json is quite simple
2023-03-01 22:28:44 +0100 <mauke> hey, but at least conduit has actual documentation
2023-03-01 22:28:46 +0100 <fnurglewitz> json-stream had no issues reading it
2023-03-01 22:28:48 +0100 <fnurglewitz> *parsing
2023-03-01 22:29:23 +0100 <mauke> I tried 'streaming' and parts of the documentation just devolve into unhinged ranting
2023-03-01 22:29:38 +0100 <mauke> and the documentation stops halfway through :-)
2023-03-01 22:30:13 +0100 <mauke> fnurglewitz: you weren't really doing streaming, though. you just fed the whole input to parseLazyByteString
2023-03-01 22:30:49 +0100 <fnurglewitz> when reading from FS the process topped at 15M in memory though
2023-03-01 22:31:07 +0100 <fnurglewitz> it never loaded the whole json in memory
2023-03-01 22:31:28 +0100hugo-(znc@verdigris.lysator.liu.se)
2023-03-01 22:31:38 +0100 <fnurglewitz> when getting it from http-client I agree that it wasn't doing any streaming
2023-03-01 22:31:40 +0100dhil(~dhil@78.45.150.83.ewm.ftth.as8758.net) (Ping timeout: 260 seconds)
2023-03-01 22:31:51 +0100 <mauke> yes, because of the unsafeInterleaveIO shenanigans in readFile
2023-03-01 22:32:09 +0100 <fnurglewitz> best function ever
2023-03-01 22:32:38 +0100ph88(~ph88@ip5b426553.dynamic.kabel-deutschland.de) (Ping timeout: 246 seconds)
2023-03-01 22:32:47 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-03-01 22:33:18 +0100Guest73(~Guest73@165.225.213.116) (Ping timeout: 260 seconds)
2023-03-01 22:36:15 +0100__monty__(~toonn@user/toonn)
2023-03-01 22:36:25 +0100rekahsoft(~rekahsoft@142.188.185.92)
2023-03-01 22:36:27 +0100cyphase(~cyphase@user/cyphase)
2023-03-01 22:37:14 +0100fbytez(~uid@2001:bc8:2117:100::)
2023-03-01 22:39:16 +0100kenaryn(~aurele@cre71-h03-89-88-44-27.dsl.sta.abo.bbox.fr) (Quit: leaving)
2023-03-01 22:39:49 +0100notzmv(~zmv@user/notzmv)
2023-03-01 22:40:26 +0100Guest73(~Guest73@165.225.213.116)
2023-03-01 22:50:03 +0100hugo-(znc@verdigris.lysator.liu.se) (Ping timeout: 248 seconds)
2023-03-01 22:53:24 +0100akegalj(~akegalj@78-1-169-101.adsl.net.t-com.hr)
2023-03-01 22:55:26 +0100niko(niko@libera/staff/niko)
2023-03-01 22:56:51 +0100xkuru(~xkuru@user/xkuru)
2023-03-01 22:57:03 +0100Sinbad(~Sinbad@user/sinbad)
2023-03-01 22:58:52 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-03-01 23:00:13 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-03-01 23:01:16 +0100 <Sinbad> using cabal install with --prefix=<some-path> or --bindir=<some-path> doesn't seem to make any difference, it always installs into ~/.cabal/bin. am I overlooking something?
2023-03-01 23:01:19 +0100hugo-(znc@verdigris.lysator.liu.se)
2023-03-01 23:01:26 +0100 <akegalj> what is the intuition behind traverse over list. traverse (\x -> [0..x]) [0..2] === [[0,0,0],[0,0,1],[0,0,2],[0,1,0],[0,1,1],[0,1,2]] . I cant figure out how to use this, or even build model around it. When is this used and when is it useful ?
2023-03-01 23:01:45 +0100michalz(~michalz@185.246.207.221) (Remote host closed the connection)
2023-03-01 23:02:03 +0100 <Sinbad> I am using cabal-install version 3.8.1.0
2023-03-01 23:02:16 +0100Guest|57(~Guest|57@2004223482.kn.vutbr.cz)
2023-03-01 23:02:28 +0100 <c_wraith> akegalj: that example probably isn't very useful. But you can think of it as a combination of fmap and sequenceA, each of which is quite natural there
2023-03-01 23:02:59 +0100 <geekosaur> Sinbad, those are cabal v1-style. for v2 you want --installdir
2023-03-01 23:03:13 +0100 <c_wraith> > fmap (\x -> [0 .. x]) [0..2] -- yeah, over lists it's just map
2023-03-01 23:03:14 +0100 <lambdabot> [[0],[0,1],[0,1,2]]
2023-03-01 23:03:20 +0100 <jackdk> Also, you often find implementations of things because they must exist, not because they're "for" anything in particular.
2023-03-01 23:03:24 +0100 <geekosaur> (v2 doesn't really install, it drops a symlink into cabal's store)
2023-03-01 23:03:35 +0100 <c_wraith> > sequenceA [[1,2],[3,4],[5,6,7]]
2023-03-01 23:03:37 +0100 <lambdabot> [[1,3,5],[1,3,6],[1,3,7],[1,4,5],[1,4,6],[1,4,7],[2,3,5],[2,3,6],[2,3,7],[2,...
2023-03-01 23:04:02 +0100 <c_wraith> so sequenceA is pretty naturally just a sort of generalized product, over lists of lists
2023-03-01 23:04:25 +0100 <c_wraith> traverse just happens to do both at once. Not always useful for lists of lists, but often a very useful combination
2023-03-01 23:06:32 +0100thegeekinside(~thegeekin@189.141.115.134) (Ping timeout: 252 seconds)
2023-03-01 23:07:39 +0100Guest|57(~Guest|57@2004223482.kn.vutbr.cz) (Quit: Connection closed)
2023-03-01 23:07:50 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Ping timeout: 260 seconds)
2023-03-01 23:07:52 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-03-01 23:11:06 +0100 <akegalj> c_wraith: ok, I think I had wrong intution about sequence. It makes sense now. Thanks for patience!
2023-03-01 23:11:35 +0100 <Sinbad> geekosaur: thanks. where is this documented? the help just list all the flags what I am using and what you just said without mentioning v1/v2. the docs (stable) don't even contain --installdir
2023-03-01 23:11:35 +0100nschoe(~q@2a01:e0a:8e:a190:91bd:1aae:19b1:2ad9) (Ping timeout: 264 seconds)
2023-03-01 23:12:27 +0100Square2(~Square4@user/square)
2023-03-01 23:13:54 +0100 <geekosaur> I'm not sure it is. 😞 I know it because I've been using cabal for years. the help in particular is a known problem area which I think people will be working on (hopefully they'll do a Season of Docs project on it…)
2023-03-01 23:14:32 +0100 <geekosaur> https://cabal.readthedocs.io/en/3.8/cabal-commands.html?highlight=--installdir#cabal-install
2023-03-01 23:15:09 +0100 <geekosaur> (the "stable" thing is a recently discovered wart in the docs, which they're still trying to sort out)
2023-03-01 23:15:48 +0100 <geekosaur> (readthedocs picked it automatically and they're still trying to figutre out how to make it pick the right one; it should be using the doc set I did)
2023-03-01 23:20:59 +0100 <Sinbad> geekosaur: I see, I should keep in mind to read the 3.8 docs. I tried first the --help, found --bindir and went with it without reading to to bottom where the very last entry is --installdir. I might fill a bug about that.
2023-03-01 23:21:58 +0100 <geekosaur> yeh, the v1 and v2-style options are all jumbled together
2023-03-01 23:24:26 +0100kenaryn(~aurele@89-88-44-27.abo.bbox.fr)
2023-03-01 23:24:57 +0100kenaryn(~aurele@89-88-44-27.abo.bbox.fr) (Client Quit)
2023-03-01 23:28:09 +0100dcoutts_(~duncan@cpc69403-oxfd27-2-0-cust285.4-3.cable.virginm.net) (Ping timeout: 255 seconds)
2023-03-01 23:30:10 +0100dcoutts_(~duncan@cpc69403-oxfd27-2-0-cust285.4-3.cable.virginm.net)
2023-03-01 23:34:14 +0100thegeekinside(~thegeekin@189.141.115.134)
2023-03-01 23:36:05 +0100Guest73(~Guest73@165.225.213.116) (Quit: Client closed)
2023-03-01 23:36:16 +0100 <remexre> anyone know the name of the technique for getting extensible datatypes/languages w/ pattern functors as like, Fix (PartA :+: PartB :+: PartC)
2023-03-01 23:37:35 +0100 <akegalj> how to find out lambdabot options? Is there help for it here on irc? I was sent a message via lambdabot which was delivered when I got online - which is a nice so would like to find out how can I use it
2023-03-01 23:38:36 +0100 <geekosaur> not sure what you mean by options?
2023-03-01 23:39:18 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-03-01 23:40:37 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-03-01 23:40:46 +0100 <geekosaur> https://github.com/lambdabot/lambdabot/pull/205/files has a full list of commands (and you can see it's waiting to be accepted upstream)
2023-03-01 23:42:52 +0100Sinbad(~Sinbad@user/sinbad) (Quit: WeeChat 3.8)
2023-03-01 23:43:02 +0100 <akegalj> geekosaur: thanks! so to send message to someone who is offline I do `@ask user msg`
2023-03-01 23:43:56 +0100 <geekosaur> or @tell, yes. (it just changes the word used in the delivered message: `<foo> asks` vs. `<foo> says`)
2023-03-01 23:44:27 +0100 <akegalj> got it
2023-03-01 23:44:58 +0100gurkenglas(~gurkengla@dynamic-089-204-138-097.89.204.138.pool.telefonica.de) (Ping timeout: 268 seconds)
2023-03-01 23:46:49 +0100ph88(~ph88@ip5b426553.dynamic.kabel-deutschland.de)
2023-03-01 23:47:13 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-03-01 23:49:57 +0100 <monochrom> remexre: Perhaps "data types a la carte"? That's the name of the paper that did it.
2023-03-01 23:50:01 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-03-01 23:51:10 +0100 <remexre> That's it, thanks!
2023-03-01 23:54:26 +0100slack1256(~slack1256@186.11.13.167)
2023-03-01 23:55:40 +0100forell(~forell@user/forell) (Ping timeout: 252 seconds)
2023-03-01 23:59:47 +0100ubert(~Thunderbi@p548c9fde.dip0.t-ipconnect.de) (Ping timeout: 268 seconds)
2023-03-01 23:59:48 +0100ub(~Thunderbi@p548c9fde.dip0.t-ipconnect.de)