IRCBrowse

2023/11/08

2023-11-08 00:02:19 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 00:04:44 +0100alp(~alp@2001:861:5e02:eff0:86bc:a0a1:58c4:4dac)
2023-11-08 00:06:57 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 00:10:08 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 00:11:33 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-08 00:13:19 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 00:14:22 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 00:17:34 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 00:19:59 +0100pixelmonk(~pixelmonk@50.205.76.66) (Ping timeout: 252 seconds)
2023-11-08 00:21:28 +0100pointlessslippe1(~pointless@212.82.82.3)
2023-11-08 00:24:05 +0100acidjnk(~acidjnk@p200300d6e72b9352bd047a176d81e23c.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-11-08 00:24:17 +0100accord(uid568320@id-568320.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-08 00:27:12 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 00:30:27 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 00:30:28 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 00:32:38 +0100Jackneill_(~Jackneill@20014C4E1E058A00193351DCDA9024FA.dsl.pool.telekom.hu) (Ping timeout: 252 seconds)
2023-11-08 00:33:47 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 00:42:05 +0100pixelmonk(~pixelmonk@50.205.76.66)
2023-11-08 00:44:44 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 00:46:33 +0100Sgeo(~Sgeo@user/sgeo)
2023-11-08 00:49:26 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 00:52:02 +0100dfg(~dfg@user/dfg) (Server closed connection)
2023-11-08 00:52:20 +0100dfg(~dfg@dfg.rocks)
2023-11-08 00:52:20 +0100dfg(~dfg@dfg.rocks) (Changing host)
2023-11-08 00:52:20 +0100dfg(~dfg@user/dfg)
2023-11-08 00:56:57 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 01:00:36 +0100exarkun(~exarkun@user/exarkun) (Server closed connection)
2023-11-08 01:01:27 +0100exarkun(~exarkun@user/exarkun)
2023-11-08 01:03:42 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 01:05:01 +0100hgolden(~hgolden@2603-8000-9d00-3ed1-a6e3-3ba3-0107-8cff.res6.spectrum.com) (Remote host closed the connection)
2023-11-08 01:05:01 +0100gentauro(~gentauro@user/gentauro) (Read error: Connection reset by peer)
2023-11-08 01:05:10 +0100hgolden(~hgolden@2603-8000-9d00-3ed1-dd4f-298a-9c49-a0ed.res6.spectrum.com)
2023-11-08 01:10:16 +0100gentauro(~gentauro@user/gentauro)
2023-11-08 01:12:56 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 01:17:45 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 01:17:59 +0100CO2(CO2@gateway/vpn/protonvpn/co2) (Quit: WeeChat 4.1.1)
2023-11-08 01:26:41 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 01:31:56 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 01:34:03 +0100 <Axman6> Now that Go has/is getting generics, can I release a library for monads called gonads?
2023-11-08 01:35:55 +0100 <monochrom> haha
2023-11-08 01:36:09 +0100 <EvanR> can you write a function or something with the signature m a -> (a -> m b) -> m b in go
2023-11-08 01:36:20 +0100 <EvanR> can you even pass functions around
2023-11-08 01:36:23 +0100 <Axman6> I would be shocked if you camn
2023-11-08 01:36:28 +0100 <Axman6> can*
2023-11-08 01:36:39 +0100 <monochrom> I ruin your joke with: geonads. >:)
2023-11-08 01:37:14 +0100 <Axman6> for testicular geology?
2023-11-08 01:37:15 +0100 <monochrom> Perhaps use concurrency primitives to emulate passing functions around.
2023-11-08 01:37:46 +0100 <EvanR> are threads as bad as they are in java in go
2023-11-08 01:37:46 +0100 <monochrom> for causing great internet debates on how to pronounce the g there :)
2023-11-08 01:38:15 +0100 <EvanR> or are they as bad as threads in C
2023-11-08 01:38:30 +0100 <monochrom> https://www.smbc-comics.com/comic/jiffy
2023-11-08 01:40:00 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 01:43:15 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 01:43:30 +0100landonf(landonf@mac68k.info) (Server closed connection)
2023-11-08 01:43:42 +0100landonf(landonf@mac68k.info)
2023-11-08 01:45:16 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-11-08 01:45:25 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 01:47:54 +0100 <EvanR> I'd settle for functors for go
2023-11-08 01:47:55 +0100 <probie> EvanR: You can pass functions around and Go's concurrency is meant to be one of the selling points
2023-11-08 01:48:13 +0100 <EvanR> ok that's promising
2023-11-08 01:49:11 +0100 <Axman6> it's pretty limited concurrency though, coroutines and channels basically (though maybe that's changed since I last looked?)
2023-11-08 01:50:23 +0100 <geekosaur> supposed to be "foolproof" (in the "all programmers are fools" sense)
2023-11-08 01:51:03 +0100 <probie> You've also got mutexes, await groups and atomic swaps
2023-11-08 01:51:09 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 01:51:14 +0100 <Axman6> That attitude is my main reason for disliking Go, they seem to intentionally want to push the idea that programmers are idiots and can't handle abstraction
2023-11-08 01:51:39 +0100 <monochrom> <customer> May I have a burrito please? <cashier> Is that to Go or Haskell in? >:)
2023-11-08 01:52:42 +0100 <monochrom> But Haskell is where programmers are idiots and can't handle untyped lambda calculus!
2023-11-08 01:53:20 +0100 <monochrom> Scheme is where they can't handle typed lambda calculus!
2023-11-08 01:53:57 +0100 <monochrom> And the dependent languages, they can't handle anything. >:)
2023-11-08 01:54:14 +0100 <monochrom> well, can't handle anything until proved otherwise. :)
2023-11-08 01:55:20 +0100 <probie> I haven't written much Go since they added generics, but I hated it less than I thought I would back when I was writing a lot of it for a job.
2023-11-08 01:55:46 +0100 <probie> I felt a bit like I was writing C+ (one plus intentional)
2023-11-08 01:55:47 +0100 <Axman6> You had a job???
2023-11-08 01:56:05 +0100 <monochrom> Well yeah I stopped hating English after finishing English classes, too. :)
2023-11-08 01:56:34 +0100 <Axman6> I just hated reading Go and being interrupted with every second line being error handling. My kingdom for an Either!
2023-11-08 01:57:23 +0100 <monochrom> Sounds like they direly need gonads to make it nicer.
2023-11-08 01:58:14 +0100 <probie> If you don't have a keyboard macro for `if err != nil {`, you're not a real gopher
2023-11-08 01:59:03 +0100 <monochrom> Wait, do they call themselves gophers?
2023-11-08 01:59:16 +0100 <Axman6> >:(
2023-11-08 01:59:42 +0100 <EvanR> that's why in C I put the error handling on the same line
2023-11-08 01:59:46 +0100 <monochrom> I wouldn't mind. It has a diminishing connotation. >:)
2023-11-08 02:00:41 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 02:00:47 +0100 <EvanR> e = unlink(whatever); if (e < 0) { initiate self destruct sequence macro; }
2023-11-08 02:01:20 +0100 <EvanR> then use the editor to hide stuff after the first ; on a line xD
2023-11-08 02:01:34 +0100 <EvanR> (except for loops)
2023-11-08 02:03:06 +0100 <monochrom> I feel like if your editor is advanced enough for that, you may as well tell it to let you enter Haskell code and it translates to spaghetti Go.
2023-11-08 02:03:46 +0100 <EvanR> sometimes I wonder about that!
2023-11-08 02:04:00 +0100 <EvanR> what is source code anyway
2023-11-08 02:04:28 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 02:05:02 +0100alp(~alp@2001:861:5e02:eff0:86bc:a0a1:58c4:4dac) (Ping timeout: 252 seconds)
2023-11-08 02:05:38 +0100 <Axman6> it's all just thoughts anyway, who cares what language it is
2023-11-08 02:05:44 +0100 <probie> Golang has some great idioms. It has varargs, but no way of doing optional or named args. So the blessed way is to 1. Create a (private) type to hold optional/named args 2. Export functions to mutate that type 3. Use varargs to take an arbitrary number of those private-type mutating functions
2023-11-08 02:06:01 +0100finsternis(~X@23.226.237.192) (Ping timeout: 255 seconds)
2023-11-08 02:06:17 +0100 <EvanR> lol
2023-11-08 02:06:58 +0100 <Axman6> >>:(
2023-11-08 02:07:12 +0100 <EvanR> does go have partial application
2023-11-08 02:07:18 +0100 <Axman6> I cannae furrow me brow much more!
2023-11-08 02:07:35 +0100 <c_wraith> partial application requires accepting functions as values
2023-11-08 02:07:47 +0100 <monochrom> Try contraction. »
2023-11-08 02:07:49 +0100 <EvanR> probie says it has that
2023-11-08 02:07:55 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 02:07:57 +0100 <probie> e.g. in Haskell-like syntax `data OptArgsType = ...; type OptArg = OptArgsType -> OptArgsType; foo :: Int -> OptArg; bar :: String -> OptArg; doMyThing :: T1 -> T2 -> [OptArg] -> T3` and then called like `doMyThing t1 t2 [foo 42, bar "baz"]`
2023-11-08 02:08:17 +0100 <probie> It has partial application in the same way that most languages without currying have partial application
2023-11-08 02:09:25 +0100 <probie> If I've got something like `func foo(x int, y int) int`, I can do something like `bar := func (y int) int { return foo(42, y) }`
2023-11-08 02:09:30 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-11-08 02:09:31 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 264 seconds)
2023-11-08 02:09:36 +0100 <EvanR> does the body of the function then stitch together all the optarg mutators
2023-11-08 02:09:40 +0100 <monochrom> I think that idiom came close to rediscovering monoids but then went the other way.
2023-11-08 02:10:20 +0100danza(~francesco@ge-19-117-186.service.infuturo.it) (Read error: Connection reset by peer)
2023-11-08 02:10:27 +0100 <monochrom> Because that's how we do configs too. (modifier1 <> modifier2 <> modifier3 <> ...) defaultConfig
2023-11-08 02:10:48 +0100 <probie> EvanR: Yes, so now the first 3-4 lines of your function are just boilerplate, but extra boilerplate is no obstacle to idiomatic go code
2023-11-08 02:10:55 +0100Lord_of_Life_Lord_of_Life
2023-11-08 02:14:10 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 02:14:29 +0100falafel(~falafel@62.175.113.194.dyn.user.ono.com)
2023-11-08 02:14:39 +0100 <EvanR> can't that idiom be reduced a bit to creating a temporary record with the named arguments in it directly
2023-11-08 02:14:57 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.5)
2023-11-08 02:15:24 +0100 <monochrom> I think that's the private type.
2023-11-08 02:15:48 +0100 <EvanR> (C version) r = func((struct CoolArgs){ .arg1 = 7, .arg2 = "whoa" })
2023-11-08 02:16:58 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 02:17:51 +0100Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Quit: Leaving.)
2023-11-08 02:17:57 +0100 <probie> EvanR: Yes, but then users can put whatever they want into that type, and you may want to restrict that (e.g. two fields depend on each other)
2023-11-08 02:19:04 +0100 <EvanR> I should stop deconstructing this idiom, haskell has the same idiom basically!
2023-11-08 02:19:10 +0100 <EvanR> configuration monoid
2023-11-08 02:19:37 +0100 <monochrom> Moreover, we have lens and template haskell to auto-gen the modifiers!
2023-11-08 02:19:58 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 02:20:23 +0100 <probie> If you were to pass a configuration type directly, then whenever that type changes, it would be a breaking change to the API if the default value for a field isn't the zero value
2023-11-08 02:20:24 +0100 <monochrom> It's like C all over again except with <> instead of ,
2023-11-08 02:22:04 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 02:25:09 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 02:26:38 +0100danza(~francesco@151.43.111.166)
2023-11-08 02:27:43 +0100 <geekosaur> "went the other way" — for some reason I imagine that being deliberate
2023-11-08 02:28:11 +0100 <geekosaur> "must avoid doing something intelligent and sensible"
2023-11-08 02:28:56 +0100 <monochrom> Don't offend coders with actual math. :)
2023-11-08 02:38:54 +0100[itchyjunk]semsogg`
2023-11-08 02:39:33 +0100semsogg``[itchyjunk]`
2023-11-08 02:39:36 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 02:41:05 +0100Square(~Square@user/square)
2023-11-08 02:46:30 +0100EllenorMelanieMalik
2023-11-08 02:47:02 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 02:53:12 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 272 seconds)
2023-11-08 02:54:32 +0100dsrt^(~cd@70-88-177-118-Atlanta.hfc.comcastbusiness.net)
2023-11-08 02:58:04 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 03:00:41 +0100falafel(~falafel@62.175.113.194.dyn.user.ono.com) (Ping timeout: 240 seconds)
2023-11-08 03:01:11 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 03:03:42 +0100`[itchyjunk]`(~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-11-08 03:04:00 +0100`[itchyjunk]`(~itchyjunk@user/itchyjunk/x-7353470)
2023-11-08 03:04:17 +0100pointlessslippe1(~pointless@212.82.82.3) (Ping timeout: 255 seconds)
2023-11-08 03:07:10 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 03:11:54 +0100califax(~califax@user/califx) (Ping timeout: 256 seconds)
2023-11-08 03:12:14 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 03:12:41 +0100xff0x(~xff0x@2405:6580:b080:900:c499:902e:6f70:c890) (Ping timeout: 252 seconds)
2023-11-08 03:12:45 +0100califax(~califax@user/califx)
2023-11-08 03:16:24 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 03:19:28 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 03:21:19 +0100otto_s(~user@p4ff276b4.dip0.t-ipconnect.de) (Ping timeout: 245 seconds)
2023-11-08 03:23:08 +0100otto_s(~user@p5b044db0.dip0.t-ipconnect.de)
2023-11-08 03:34:09 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 03:36:17 +0100nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-08 03:37:25 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 03:38:03 +0100fryguybob(~fryguybob@cpe-24-94-50-22.stny.res.rr.com) (Ping timeout: 258 seconds)
2023-11-08 03:38:14 +0100euleritian(~euleritia@dynamic-046-114-207-195.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-08 03:38:31 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-08 03:38:55 +0100fryguybob(~fryguybob@cpe-24-94-50-22.stny.res.rr.com)
2023-11-08 03:42:13 +0100aforemny_(~aforemny@2001:9e8:6cdb:f00:338e:9cc8:ffb0:8e6c)
2023-11-08 03:42:16 +0100aforemny(~aforemny@i59F516D1.versanet.de) (Ping timeout: 258 seconds)
2023-11-08 03:43:29 +0100dsrt^(~cd@70-88-177-118-Atlanta.hfc.comcastbusiness.net) (Ping timeout: 252 seconds)
2023-11-08 03:44:27 +0100dsrt^(~cd@70-88-177-118-atlanta.hfc.comcastbusiness.net)
2023-11-08 03:46:52 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 03:50:44 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 03:52:14 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 03:52:44 +0100Katarushisu1(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) (Ping timeout: 272 seconds)
2023-11-08 03:53:31 +0100Katarushisu1(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net)
2023-11-08 03:55:47 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-11-08 03:56:28 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 04:02:52 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 04:05:29 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6d7a:4eb0:231d:253f) (Remote host closed the connection)
2023-11-08 04:05:44 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6d7a:4eb0:231d:253f)
2023-11-08 04:05:49 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-11-08 04:05:49 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-11-08 04:05:49 +0100finn_elijaFinnElija
2023-11-08 04:06:10 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 04:06:32 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 04:07:13 +0100edr(~edr@user/edr) (Quit: Leaving)
2023-11-08 04:10:07 +0100nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-11-08 04:11:18 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 04:11:35 +0100nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-08 04:12:46 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-08 04:13:38 +0100dsrt^(~cd@70-88-177-118-atlanta.hfc.comcastbusiness.net) (Ping timeout: 272 seconds)
2023-11-08 04:15:56 +0100nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 252 seconds)
2023-11-08 04:16:11 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-11-08 04:17:15 +0100dsrt^(~cd@70-88-177-118-atlanta.hfc.comcastbusiness.net)
2023-11-08 04:18:08 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 252 seconds)
2023-11-08 04:20:53 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 04:23:48 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 04:26:44 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 04:29:57 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 04:40:16 +0100Inst(~Inst@120.244.192.250)
2023-11-08 04:40:36 +0100 <Inst> EvanR with the sample code, I'm trying to get a random value of type Int, using the Proxy value to carry the type information
2023-11-08 04:41:00 +0100 <Inst> I think you can still get a random type, however, with dynamic typing overrides
2023-11-08 04:41:12 +0100 <Inst> generate some Ints, have each value correspond to a type
2023-11-08 04:41:26 +0100 <Inst> get a union via existential types or dynamic
2023-11-08 04:45:49 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 04:45:49 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-08 04:46:40 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-08 04:47:47 +0100td_(~td@i5387090C.versanet.de) (Ping timeout: 255 seconds)
2023-11-08 04:48:56 +0100todi(~todi@79.209.163.230)
2023-11-08 04:49:28 +0100td_(~td@i53870921.versanet.de)
2023-11-08 04:52:12 +0100madnight(~madnight@static.59.103.201.195.clients.your-server.de) (Server closed connection)
2023-11-08 04:52:27 +0100madnight(~madnight@static.59.103.201.195.clients.your-server.de)
2023-11-08 04:52:48 +0100Jackneill_(~Jackneill@20014C4E1E058A0009BBD059E8BC0D29.dsl.pool.telekom.hu)
2023-11-08 04:56:18 +0100rosco(~rosco@yp-150-69.tm.net.my)
2023-11-08 04:56:18 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-08 04:56:24 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-08 04:56:55 +0100todi(~todi@79.209.163.230) (Read error: Connection reset by peer)
2023-11-08 05:01:08 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 05:01:27 +0100fweht(uid404746@id-404746.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-08 05:12:35 +0100dumptruckman(~dumptruck@23-239-13-136.ip.linodeusercontent.com) (Server closed connection)
2023-11-08 05:13:16 +0100dumptruckman(~dumptruck@23-239-13-136.ip.linodeusercontent.com)
2023-11-08 05:14:59 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 05:18:43 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 05:18:49 +0100aforemny(~aforemny@2001:9e8:6ce5:5c00:3494:c671:8982:8a94)
2023-11-08 05:19:44 +0100aforemny_(~aforemny@2001:9e8:6cdb:f00:338e:9cc8:ffb0:8e6c) (Ping timeout: 252 seconds)
2023-11-08 05:20:11 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 255 seconds)
2023-11-08 05:21:27 +0100Inst(~Inst@120.244.192.250) (Ping timeout: 240 seconds)
2023-11-08 05:37:03 +0100Lycurgus(~georg@user/Lycurgus)
2023-11-08 05:40:23 +0100`[itchyjunk]`(~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-11-08 05:44:58 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 05:48:35 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 05:50:28 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 05:51:04 +0100cheater_(~Username@user/cheater)
2023-11-08 05:51:09 +0100cheater(~Username@user/cheater) (Ping timeout: 255 seconds)
2023-11-08 05:51:18 +0100cheater_cheater
2023-11-08 05:55:42 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 05:56:54 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 05:59:10 +0100thegman(~thegman@072-239-207-086.res.spectrum.com)
2023-11-08 06:00:31 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 06:00:46 +0100trev(~trev@user/trev)
2023-11-08 06:04:03 +0100gabiruh(~gabiruh@vps19177.publiccloud.com.br) (Server closed connection)
2023-11-08 06:04:18 +0100gabiruh(~gabiruh@vps19177.publiccloud.com.br)
2023-11-08 06:09:28 +0100krei-se(~krei-se@p50874770.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-11-08 06:13:38 +0100danza(~francesco@151.43.111.166) (Ping timeout: 252 seconds)
2023-11-08 06:15:34 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-08 06:16:55 +0100bradparker(sid262931@id-262931.uxbridge.irccloud.com) (Server closed connection)
2023-11-08 06:16:56 +0100Guest25(~Guest25@2600:4040:959f:a700:b173:8684:b4e1:f33)
2023-11-08 06:17:03 +0100bradparker(sid262931@id-262931.uxbridge.irccloud.com)
2023-11-08 06:18:26 +0100jargon(~jargon@184.101.69.217)
2023-11-08 06:18:53 +0100 <dibblego> Why does this file run fine with cabal 3.0.0.0 but not 3.10.2.0? https://gist.github.com/tonymorris/0eea5e45d745c45a3505845ff7b036cd
2023-11-08 06:20:16 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-08 06:22:48 +0100jargon(~jargon@184.101.69.217) (Remote host closed the connection)
2023-11-08 06:24:43 +0100 <jackdk> What happens?
2023-11-08 06:26:22 +0100danza(~francesco@151.57.107.193)
2023-11-08 06:30:26 +0100Guest25(~Guest25@2600:4040:959f:a700:b173:8684:b4e1:f33) (Quit: Client closed)
2023-11-08 06:31:31 +0100rosco(~rosco@yp-150-69.tm.net.my) (Read error: Connection reset by peer)
2023-11-08 06:37:17 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 252 seconds)
2023-11-08 06:37:32 +0100euleritian(~euleritia@dynamic-046-114-207-195.46.114.pool.telefonica.de)
2023-11-08 06:37:57 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 06:39:26 +0100m1dnight(~christoph@78-22-4-67.access.telenet.be) (Server closed connection)
2023-11-08 06:39:51 +0100m1dnight(~christoph@78-22-4-67.access.telenet.be)
2023-11-08 06:42:09 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 06:45:38 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 06:48:48 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 06:49:33 +0100kaskal-(~kaskal@2001:4bb8:2c2:d155:91d2:a4ad:c9f9:5f9a) (Ping timeout: 260 seconds)
2023-11-08 06:50:09 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 06:52:08 +0100kaskal(~kaskal@89.144.222.250)
2023-11-08 06:53:19 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 06:57:16 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 07:01:18 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 07:05:00 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 07:05:36 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-11-08 07:07:57 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 07:08:45 +0100euleritian(~euleritia@dynamic-046-114-207-195.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-08 07:09:01 +0100euleritian(~euleritia@77.22.252.56)
2023-11-08 07:10:44 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 07:14:01 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 07:16:10 +0100alp(~alp@2001:861:5e02:eff0:2565:907e:1d8d:7aea)
2023-11-08 07:16:31 +0100dsrt^(~cd@70-88-177-118-atlanta.hfc.comcastbusiness.net) (Ping timeout: 255 seconds)
2023-11-08 07:17:11 +0100dsrt^(~cd@70-88-177-118-Atlanta.hfc.comcastbusiness.net)
2023-11-08 07:18:05 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-11-08 07:19:39 +0100pixelmonk(~pixelmonk@50.205.76.66) (Ping timeout: 245 seconds)
2023-11-08 07:20:39 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 07:21:45 +0100krei-se(~krei-se@p5085dea2.dip0.t-ipconnect.de)
2023-11-08 07:22:22 +0100ec_(~ec@gateway/tor-sasl/ec) (Ping timeout: 256 seconds)
2023-11-08 07:24:25 +0100ec_(~ec@gateway/tor-sasl/ec)
2023-11-08 07:24:56 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 07:25:08 +0100thegman(~thegman@072-239-207-086.res.spectrum.com) (Quit: leaving)
2023-11-08 07:25:42 +0100michalz(~michalz@185.246.207.205)
2023-11-08 07:26:41 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 07:28:24 +0100euleritian(~euleritia@77.22.252.56) (Ping timeout: 245 seconds)
2023-11-08 07:29:18 +0100euleritian(~euleritia@dynamic-046-114-207-195.46.114.pool.telefonica.de)
2023-11-08 07:30:54 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 07:31:59 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 07:32:15 +0100thegeekinside(~thegeekin@189.141.80.123) (Remote host closed the connection)
2023-11-08 07:33:52 +0100pixelmonk(~pixelmonk@50.205.76.66)
2023-11-08 07:33:52 +0100pixelmonk(~pixelmonk@50.205.76.66) (Client Quit)
2023-11-08 07:35:45 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 07:37:07 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 07:40:42 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 07:40:57 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 07:41:47 +0100Inst(~Inst@120.244.192.250)
2023-11-08 07:44:20 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 07:44:52 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 07:49:39 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 07:52:38 +0100thegeekinside(~thegeekin@189.141.80.123)
2023-11-08 07:56:52 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 07:58:56 +0100wagle(~wagle@quassel.wagle.io) (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.)
2023-11-08 08:00:10 +0100wagle(~wagle@quassel.wagle.io)
2023-11-08 08:01:33 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 08:03:31 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 08:07:20 +0100p3n(~p3n@2a00:19a0:3:7c:0:d9c6:7cf6:1) (Quit: ZNC 1.8.2 - https://znc.in)
2023-11-08 08:08:11 +0100rosco(~rosco@yp-150-69.tm.net.my)
2023-11-08 08:08:40 +0100p3n(~p3n@217.198.124.246)
2023-11-08 08:10:38 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 08:11:53 +0100Square(~Square@user/square) (Ping timeout: 252 seconds)
2023-11-08 08:16:57 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 08:20:15 +0100rosco(~rosco@yp-150-69.tm.net.my) (Quit: Lost terminal)
2023-11-08 08:20:39 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 08:21:46 +0100ec_(~ec@gateway/tor-sasl/ec) (*.net *.split)
2023-11-08 08:21:46 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (*.net *.split)
2023-11-08 08:21:46 +0100califax(~califax@user/califx) (*.net *.split)
2023-11-08 08:21:46 +0100stiell_(~stiell@gateway/tor-sasl/stiell) (*.net *.split)
2023-11-08 08:21:46 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (*.net *.split)
2023-11-08 08:21:46 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (*.net *.split)
2023-11-08 08:21:46 +0100adanwan(~adanwan@gateway/tor-sasl/adanwan) (*.net *.split)
2023-11-08 08:21:46 +0100chiselfuse(~chiselfus@user/chiselfuse) (*.net *.split)
2023-11-08 08:21:47 +0100chexum(~quassel@gateway/tor-sasl/chexum) (*.net *.split)
2023-11-08 08:22:07 +0100coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-11-08 08:24:06 +0100chexum(~quassel@gateway/tor-sasl/chexum)
2023-11-08 08:24:07 +0100califax(~califax@user/califx)
2023-11-08 08:24:13 +0100adanwan(~adanwan@gateway/tor-sasl/adanwan)
2023-11-08 08:24:55 +0100ec_(~ec@gateway/tor-sasl/ec)
2023-11-08 08:24:56 +0100stiell_(~stiell@gateway/tor-sasl/stiell)
2023-11-08 08:24:59 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-11-08 08:25:07 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-11-08 08:25:25 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-11-08 08:25:27 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 08:27:21 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-11-08 08:29:20 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 08:33:03 +0100gmg(~user@user/gehmehgeh)
2023-11-08 08:35:00 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 08:35:15 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2023-11-08 08:35:26 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net) (Quit: zzz)
2023-11-08 08:38:09 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 08:39:00 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 08:41:29 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-11-08 08:43:48 +0100zetef(~quassel@5.2.182.98)
2023-11-08 08:44:08 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 08:44:58 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 08:48:44 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 08:49:36 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Remote host closed the connection)
2023-11-08 08:50:01 +0100euleritian(~euleritia@dynamic-046-114-207-195.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-08 08:50:33 +0100euleritian(~euleritia@77.22.252.56)
2023-11-08 08:50:41 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-08 08:50:45 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2023-11-08 08:55:23 +0100acidjnk(~acidjnk@p200300d6e72b939468149480f7812d1a.dip0.t-ipconnect.de)
2023-11-08 08:57:10 +0100fendor(~fendor@2a02:8388:1640:be00:cb6e:46f6:2fe6:1728)
2023-11-08 08:57:52 +0100Lycurgus(~georg@user/Lycurgus) (Quit: leaving)
2023-11-08 08:57:53 +0100alp(~alp@2001:861:5e02:eff0:2565:907e:1d8d:7aea) (Ping timeout: 260 seconds)
2023-11-08 08:58:49 +0100euleritian(~euleritia@77.22.252.56) (Read error: Connection reset by peer)
2023-11-08 08:59:22 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-08 09:01:19 +0100lortabac(~lorenzo@2a01:e0a:541:b8f0:a220:937e:62a3:88d0)
2023-11-08 09:02:29 +0100paddymahoney(~paddymaho@cpe883d24bcf597-cmbc4dfb741f80.cpe.net.cable.rogers.com) (Remote host closed the connection)
2023-11-08 09:02:29 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-08 09:02:41 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-08 09:03:53 +0100thegeekinside(~thegeekin@189.141.80.123) (Ping timeout: 258 seconds)
2023-11-08 09:06:53 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 252 seconds)
2023-11-08 09:07:56 +0100euleritian(~euleritia@dynamic-046-114-207-195.46.114.pool.telefonica.de)
2023-11-08 09:09:38 +0100mmhat(~mmh@p200300f1c7445ecbee086bfffe095315.dip0.t-ipconnect.de)
2023-11-08 09:09:41 +0100mmhat(~mmh@p200300f1c7445ecbee086bfffe095315.dip0.t-ipconnect.de) (Client Quit)
2023-11-08 09:15:21 +0100pointlessslippe1(~pointless@212.82.82.3)
2023-11-08 09:25:53 +0100dsrt^(~cd@70-88-177-118-Atlanta.hfc.comcastbusiness.net) (Ping timeout: 260 seconds)
2023-11-08 09:26:36 +0100dsrt^(~cd@70-88-177-118-Atlanta.hfc.comcastbusiness.net)
2023-11-08 09:31:41 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com)
2023-11-08 09:32:57 +0100alp(~alp@2001:861:5e02:eff0:2d1c:5a65:2649:274e)
2023-11-08 09:35:19 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 264 seconds)
2023-11-08 09:36:44 +0100zetef(~quassel@5.2.182.98) (Ping timeout: 245 seconds)
2023-11-08 09:38:36 +0100juri_(~juri@84-19-175-187.pool.ovpn.com) (Ping timeout: 240 seconds)
2023-11-08 09:40:37 +0100juri_(~juri@79.140.117.217)
2023-11-08 09:42:43 +0100euleritian(~euleritia@dynamic-046-114-207-195.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-08 09:43:00 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-08 09:44:10 +0100arahael(~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net)
2023-11-08 09:45:07 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-11-08 09:45:56 +0100juri_(~juri@79.140.117.217) (Ping timeout: 252 seconds)
2023-11-08 09:47:09 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 245 seconds)
2023-11-08 09:47:16 +0100euleritian(~euleritia@dynamic-046-114-207-195.46.114.pool.telefonica.de)
2023-11-08 09:47:22 +0100juri_(~juri@84-19-175-187.pool.ovpn.com)
2023-11-08 09:51:27 +0100dsrt^(~cd@70-88-177-118-Atlanta.hfc.comcastbusiness.net) (Ping timeout: 255 seconds)
2023-11-08 09:52:06 +0100dsrt^(~cd@70-88-177-118-Atlanta.hfc.comcastbusiness.net)
2023-11-08 09:54:27 +0100kraftwerk28(~kraftwerk@164.92.219.160) (Quit: *disconnects*)
2023-11-08 09:55:32 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-11-08 09:56:03 +0100kraftwerk28(~kraftwerk@164.92.219.160)
2023-11-08 09:56:05 +0100euleritian(~euleritia@dynamic-046-114-207-195.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-08 09:56:22 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-08 09:57:40 +0100paddymahoney(~paddymaho@cpe883d24bcf597-cmbc4dfb741f80.cpe.net.cable.rogers.com)
2023-11-08 09:59:52 +0100rosco(~rosco@yp-150-69.tm.net.my)
2023-11-08 10:03:06 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-11-08 10:13:27 +0100danza(~francesco@151.57.107.193) (Ping timeout: 240 seconds)
2023-11-08 10:16:56 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-08 10:17:34 +0100dsrt^(~cd@70-88-177-118-Atlanta.hfc.comcastbusiness.net) (Ping timeout: 245 seconds)
2023-11-08 10:18:08 +0100dsrt^(~cd@70-88-177-118-atlanta.hfc.comcastbusiness.net)
2023-11-08 10:19:35 +0100mechap(~mechap@user/mechap)
2023-11-08 10:21:36 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-08 10:24:36 +0100__monty__(~toonn@user/toonn)
2023-11-08 10:25:36 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6d7a:4eb0:231d:253f) (Remote host closed the connection)
2023-11-08 10:30:56 +0100econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-08 10:31:31 +0100 <geekosaur> it's working for me but it's building a shitload of stuff and I have no idea why
2023-11-08 10:32:08 +0100bgag(~bgag@146-241-2-216.dyn.eolo.it)
2023-11-08 10:32:13 +0100bgag(~bgag@146-241-2-216.dyn.eolo.it) ()
2023-11-08 10:33:58 +0100 <geekosaur> well. it saw fit to install lens before running. which took a while because I'd purged my 8.10.7 store
2023-11-08 10:34:25 +0100 <geekosaur> I don't see anything in my test dir or parents that would cause it
2023-11-08 10:34:39 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-11-08 10:41:51 +0100Guest|70(~Guest|70@84-238-167-232.ip.btc-net.bg)
2023-11-08 10:43:09 +0100Guest|70(~Guest|70@84-238-167-232.ip.btc-net.bg) (Client Quit)
2023-11-08 10:45:54 +0100xigua(~xigua@user/xigua) (Read error: Connection reset by peer)
2023-11-08 10:46:03 +0100chele(~chele@user/chele)
2023-11-08 10:46:08 +0100xigua(~xigua@user/xigua)
2023-11-08 10:46:12 +0100Pickchea(~private@user/pickchea)
2023-11-08 10:48:40 +0100danse-nr3(~danse@151.35.115.233)
2023-11-08 10:51:16 +0100 <tomsmeding> geekosaur: no trace in dist-newstyle/cache/plan.json ?
2023-11-08 10:59:48 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6d7a:4eb0:231d:253f)
2023-11-08 11:01:38 +0100jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net)
2023-11-08 11:14:22 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-11-08 11:14:50 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-11-08 11:16:09 +0100 <geekosaur> oh, I missed that lens was listed as a dep, n/m
2023-11-08 11:17:07 +0100 <geekosaur> anyway it worked here, although my cabal reports as 3.10.1.0 because of https://github.com/haskell/cabal/issues/9415
2023-11-08 11:21:01 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 240 seconds)
2023-11-08 11:24:18 +0100mechap(~mechap@user/mechap) (Ping timeout: 272 seconds)
2023-11-08 11:27:35 +0100Inst(~Inst@120.244.192.250) (Ping timeout: 240 seconds)
2023-11-08 11:27:35 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2023-11-08 11:31:15 +0100rosco(~rosco@yp-150-69.tm.net.my) (Quit: Lost terminal)
2023-11-08 11:31:35 +0100zaquest(~notzaques@5.130.79.72)
2023-11-08 11:37:10 +0100Inst(~Inst@120.244.192.250)
2023-11-08 11:44:17 +0100notzmv(~zmv@user/notzmv)
2023-11-08 11:46:27 +0100zetef(~quassel@95.77.17.251)
2023-11-08 11:47:09 +0100mrvdb(~mrvdb@2001:19f0:5000:8582:5400:ff:fe07:3df5) (Server closed connection)
2023-11-08 11:47:26 +0100mrvdb(~mrvdb@2001:19f0:5000:8582:5400:ff:fe07:3df5)
2023-11-08 11:50:20 +0100cptaffe(~cptaffe@user/cptaffe) (Ping timeout: 248 seconds)
2023-11-08 11:50:58 +0100cptaffe(~cptaffe@user/cptaffe)
2023-11-08 11:51:31 +0100elkcl(~elkcl@broadband-95-84-226-240.ip.moscow.rt.ru) (Ping timeout: 264 seconds)
2023-11-08 11:54:38 +0100coot(~coot@89-69-206-216.dynamic.chello.pl) (Ping timeout: 252 seconds)
2023-11-08 11:58:03 +0100elkcl(~elkcl@broadband-95-84-226-240.ip.moscow.rt.ru)
2023-11-08 12:03:04 +0100mc47(~mc47@xmonad/TheMC47)
2023-11-08 12:05:17 +0100kraftwerk28(~kraftwerk@164.92.219.160) (Quit: *disconnects*)
2023-11-08 12:06:41 +0100kraftwerk28(~kraftwerk@164.92.219.160)
2023-11-08 12:07:43 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-08 12:09:48 +0100lortabac(~lorenzo@2a01:e0a:541:b8f0:a220:937e:62a3:88d0) (Ping timeout: 260 seconds)
2023-11-08 12:11:19 +0100fendor(~fendor@2a02:8388:1640:be00:cb6e:46f6:2fe6:1728) (Remote host closed the connection)
2023-11-08 12:11:41 +0100Pickchea(~private@user/pickchea) (Ping timeout: 240 seconds)
2023-11-08 12:12:46 +0100ft(~ft@p4fc2a529.dip0.t-ipconnect.de) (Quit: leaving)
2023-11-08 12:14:58 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 272 seconds)
2023-11-08 12:16:17 +0100lortabac(~lorenzo@2a01:e0a:541:b8f0:f652:8911:8b9b:c1a8)
2023-11-08 12:16:32 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2023-11-08 12:23:51 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-08 12:24:08 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-08 12:25:26 +0100arahael(~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net) (Ping timeout: 252 seconds)
2023-11-08 12:27:15 +0100xff0x(~xff0x@2405:6580:b080:900:568f:45bf:9aab:4d48)
2023-11-08 12:33:16 +0100Hecate(~mariposa@user/hecate) (Server closed connection)
2023-11-08 12:33:24 +0100Hecate(~mariposa@user/hecate)
2023-11-08 12:33:33 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2023-11-08 12:41:01 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-08 12:55:30 +0100aliosablack(~chomwitt@ppp-94-67-203-175.home.otenet.gr)
2023-11-08 12:56:01 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 240 seconds)
2023-11-08 13:00:44 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-08 13:02:42 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 258 seconds)
2023-11-08 13:09:14 +0100doyougnu(~doyougnu@45.46.170.68)
2023-11-08 13:11:52 +0100adium(adium@user/adium) (Server closed connection)
2023-11-08 13:12:47 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-11-08 13:12:56 +0100adium(adium@user/adium)
2023-11-08 13:18:18 +0100int-e(~noone@int-e.eu) (Server closed connection)
2023-11-08 13:18:26 +0100int-e(~noone@int-e.eu)
2023-11-08 13:24:01 +0100aliosablack(~chomwitt@ppp-94-67-203-175.home.otenet.gr) (Ping timeout: 240 seconds)
2023-11-08 13:24:44 +0100lambdabot(~lambdabot@haskell/bot/lambdabot) (Server closed connection)
2023-11-08 13:24:51 +0100lambdabot(~lambdabot@silicon.int-e.eu)
2023-11-08 13:24:51 +0100lambdabot(~lambdabot@silicon.int-e.eu) (Changing host)
2023-11-08 13:24:51 +0100lambdabot(~lambdabot@haskell/bot/lambdabot)
2023-11-08 13:24:51 +0100ChanServ+v lambdabot
2023-11-08 13:26:43 +0100edr(~edr@user/edr)
2023-11-08 13:34:43 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Remote host closed the connection)
2023-11-08 13:42:23 +0100erty(~user@user/aeroplane)
2023-11-08 13:45:37 +0100chomwitt(~chomwitt@ppp-2-87-3-224.home.otenet.gr)
2023-11-08 13:46:35 +0100jrm(~jrm@user/jrm) (Quit: ciao)
2023-11-08 13:47:17 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-08 13:48:50 +0100jrm(~jrm@user/jrm)
2023-11-08 13:51:07 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-08 13:52:21 +0100danse-nr3(~danse@151.35.115.233) (Ping timeout: 240 seconds)
2023-11-08 13:54:51 +0100CiaoSen(~Jura@2a05:5800:28f:de00:664b:f0ff:fe37:9ef)
2023-11-08 13:58:32 +0100hueso_(~root@user/hueso) (Quit: hueso_)
2023-11-08 13:58:57 +0100notzmv(~zmv@user/notzmv)
2023-11-08 13:59:27 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 240 seconds)
2023-11-08 14:02:15 +0100hueso(~root@user/hueso)
2023-11-08 14:12:30 +0100falafel(~falafel@62.175.113.194.dyn.user.ono.com)
2023-11-08 14:14:30 +0100Lycurgus(~georg@user/Lycurgus)
2023-11-08 14:16:12 +0100hugo(znc@130.236.254.26) (Server closed connection)
2023-11-08 14:16:26 +0100hugo(znc@quicksilver.lysator.liu.se)
2023-11-08 14:17:50 +0100chomwitt(~chomwitt@ppp-2-87-3-224.home.otenet.gr) (Ping timeout: 258 seconds)
2023-11-08 14:17:52 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-11-08 14:18:25 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-08 14:23:07 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-08 14:23:27 +0100Pickchea(~private@user/pickchea)
2023-11-08 14:31:33 +0100falafel(~falafel@62.175.113.194.dyn.user.ono.com) (Ping timeout: 260 seconds)
2023-11-08 14:36:23 +0100danse-nr3(~danse@ge-19-113-42.service.infuturo.it)
2023-11-08 14:37:56 +0100chomwitt(~chomwitt@ppp-2-85-137-218.home.otenet.gr)
2023-11-08 14:41:21 +0100danse-nr3(~danse@ge-19-113-42.service.infuturo.it) (Ping timeout: 240 seconds)
2023-11-08 14:41:42 +0100danse-nr3(~danse@ge-19-113-42.service.infuturo.it)
2023-11-08 14:51:49 +0100dsrt^(~cd@70-88-177-118-atlanta.hfc.comcastbusiness.net) (Remote host closed the connection)
2023-11-08 14:52:33 +0100hiyori(~hiyori@user/hiyori)
2023-11-08 14:54:38 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 258 seconds)
2023-11-08 15:02:56 +0100rosco(~rosco@yp-150-69.tm.net.my)
2023-11-08 15:11:09 +0100Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-11-08 15:13:25 +0100CiaoSen(~Jura@2a05:5800:28f:de00:664b:f0ff:fe37:9ef) (Ping timeout: 258 seconds)
2023-11-08 15:14:38 +0100chomwitt(~chomwitt@ppp-2-85-137-218.home.otenet.gr) (Ping timeout: 255 seconds)
2023-11-08 15:22:50 +0100notzmv(~zmv@user/notzmv)
2023-11-08 15:23:45 +0100lg188(~lg188@82.18.98.230) (Quit: Bye.)
2023-11-08 15:24:14 +0100thegeekinside(~thegeekin@189.141.80.123)
2023-11-08 15:24:21 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-11-08 15:32:06 +0100lg188(~lg188@82.18.98.230)
2023-11-08 15:34:05 +0100erty(~user@user/aeroplane) (Ping timeout: 240 seconds)
2023-11-08 15:35:03 +0100lg188(~lg188@82.18.98.230) (Client Quit)
2023-11-08 15:36:18 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-08 15:36:52 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-08 15:38:45 +0100zzz(~z@user/zero) (Server closed connection)
2023-11-08 15:38:45 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-08 15:39:00 +0100euleritian(~euleritia@77.22.252.56)
2023-11-08 15:39:06 +0100zero(~z@user/zero)
2023-11-08 15:40:59 +0100euleritian(~euleritia@77.22.252.56) (Read error: Connection reset by peer)
2023-11-08 15:41:45 +0100euleritian(~euleritia@dynamic-046-114-206-064.46.114.pool.telefonica.de)
2023-11-08 15:42:07 +0100euleritian(~euleritia@dynamic-046-114-206-064.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-08 15:42:53 +0100lg188(~lg188@82.18.98.230)
2023-11-08 15:43:14 +0100euleritian(~euleritia@77.22.252.56)
2023-11-08 15:43:47 +0100Lycurgus(~georg@user/Lycurgus) (Quit: leaving)
2023-11-08 15:47:19 +0100doyougnu(~doyougnu@45.46.170.68) (Ping timeout: 264 seconds)
2023-11-08 15:47:52 +0100doyougnu(~doyougnu@45.46.170.68)
2023-11-08 15:52:35 +0100euleritian(~euleritia@77.22.252.56) (Ping timeout: 240 seconds)
2023-11-08 15:52:42 +0100euleritian(~euleritia@dynamic-046-114-206-064.46.114.pool.telefonica.de)
2023-11-08 15:56:39 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-08 16:07:06 +0100Angelz(Angelz@2605:6400:30:fc15:9bd1:2217:41cd:bb15) (Ping timeout: 260 seconds)
2023-11-08 16:07:52 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 264 seconds)
2023-11-08 16:08:53 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-11-08 16:10:43 +0100Guest67(~Guest67@70.19.76.200)
2023-11-08 16:16:37 +0100mechap(~mechap@user/mechap)
2023-11-08 16:17:32 +0100fendor(~fendor@2a02:8388:1640:be00:cb6e:46f6:2fe6:1728)
2023-11-08 16:17:52 +0100doyougnu(~doyougnu@45.46.170.68) (Quit: ZNC 1.8.2 - https://znc.in)
2023-11-08 16:20:23 +0100doyougnu(~doyougnu@45.46.170.68)
2023-11-08 16:23:43 +0100 <Guest67> Does anybody know of a robust function to unify intersecting lists in a list? I have this function but it does not work for the example I provided https://pastebin.com/12D5nRV6
2023-11-08 16:24:45 +0100doyougnu(~doyougnu@45.46.170.68) (Client Quit)
2023-11-08 16:26:16 +0100 <[exa]> "intersecting" literally as finding the set intersection?
2023-11-08 16:26:18 +0100doyougnu(~doyougnu@45.46.170.68)
2023-11-08 16:26:37 +0100AlexNoo(~AlexNoo@94.233.241.129) (Read error: Connection reset by peer)
2023-11-08 16:26:55 +0100 <[exa]> (not sure if I get what operation it does)
2023-11-08 16:27:01 +0100AlexNoo(~AlexNoo@94.233.241.129)
2023-11-08 16:28:14 +0100ph88(~ph88@2a02:8109:9e26:c800::302a)
2023-11-08 16:30:13 +0100Hafydd(~Hafydd@user/hafydd) (Server closed connection)
2023-11-08 16:30:32 +0100Hafydd(~Hafydd@user/hafydd)
2023-11-08 16:31:01 +0100 <ncf> looks like you need some sort of union-find
2023-11-08 16:33:32 +0100 <c_wraith> [exa]: take a list of sets, merge all the ones that have common elements.
2023-11-08 16:34:35 +0100 <ncf> basically you have some presentation of an equivalence relation with possibly overlapping equivalence classes, and you want a set of non-overlapping equivalence classes
2023-11-08 16:35:38 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se)
2023-11-08 16:36:44 +0100doyougnu(~doyougnu@45.46.170.68) (Quit: ZNC 1.8.2 - https://znc.in)
2023-11-08 16:37:29 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2023-11-08 16:37:41 +0100doyougnu(~doyougnu@45.46.170.68)
2023-11-08 16:37:41 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2023-11-08 16:39:01 +0100 <Inst> jesus christ, this textbook
2023-11-08 16:39:03 +0100 <c_wraith> Guest67: do you have any simpler failing case? I don't see the error in the example offhand.
2023-11-08 16:39:09 +0100 <Inst> okay, i'll wait :)
2023-11-08 16:39:35 +0100 <c_wraith> wait, nevermind. I see a problem, at least.
2023-11-08 16:39:59 +0100 <ncf> the error is pretty obvious: ntr' should check all lists for intersection, not just the first one
2023-11-08 16:40:17 +0100Lycurgus(~georg@user/Lycurgus)
2023-11-08 16:40:36 +0100 <c_wraith> Oh, right. It might intersect multiple lists that were previously disjoint
2023-11-08 16:40:44 +0100 <ncf> ...and merge all intersecting lists, not just the first one, i guess
2023-11-08 16:41:04 +0100 <c_wraith> both cases should be recursive!
2023-11-08 16:42:39 +0100 <c_wraith> The part of me that cares about predictable performance is not having a happy time with [[a]] as the data type here. Or with using foldr
2023-11-08 16:42:58 +0100 <c_wraith> But that's like several steps down the line from getting it correct
2023-11-08 16:43:23 +0100alp(~alp@2001:861:5e02:eff0:2d1c:5a65:2649:274e) (Ping timeout: 252 seconds)
2023-11-08 16:45:07 +0100doyougnu(~doyougnu@45.46.170.68) (Quit: ZNC 1.8.2 - https://znc.in)
2023-11-08 16:47:25 +0100doyougnu(~doyougnu@45.46.170.68)
2023-11-08 16:50:04 +0100 <ncf> i don't think lists are the appropriate data structure for this anyway
2023-11-08 16:50:19 +0100 <c_wraith> well, [Set a] is fine
2023-11-08 16:51:02 +0100 <c_wraith> though its strictness properties are awkward.
2023-11-08 16:52:09 +0100doyougnu-(~doyougnu@45.46.170.68)
2023-11-08 16:52:11 +0100doyougnu(~doyougnu@45.46.170.68) (Ping timeout: 252 seconds)
2023-11-08 16:52:49 +0100 <c_wraith> but that use of foldr is stack-pessimal, because the first thing it does is pattern-match on the recursive case.
2023-11-08 16:58:12 +0100Angelz(Angelz@2605:6400:30:fc15:d55b:fa6c:bd14:9973)
2023-11-08 17:01:33 +0100lortabac(~lorenzo@2a01:e0a:541:b8f0:f652:8911:8b9b:c1a8) (Quit: WeeChat 3.5)
2023-11-08 17:02:25 +0100euleritian(~euleritia@dynamic-046-114-206-064.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-08 17:02:45 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-08 17:03:05 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net)
2023-11-08 17:04:21 +0100 <Guest67> Hey sorry for the delayed response. Is there a way to resolve it without using a different data type?
2023-11-08 17:05:27 +0100Nixkernal_(~Nixkernal@115.16.194.178.dynamic.wline.res.cust.swisscom.ch)
2023-11-08 17:06:53 +0100Nixkernal(~Nixkernal@115.16.194.178.dynamic.wline.res.cust.swisscom.ch) (Ping timeout: 258 seconds)
2023-11-08 17:08:51 +0100Lycurgus(~georg@user/Lycurgus) (Quit: leaving)
2023-11-08 17:09:27 +0100 <Inst> but yeah, this textbook
2023-11-08 17:12:43 +0100 <Inst> I'm going over the Chinese textbook I mentioned earlier and it's hilarious
2023-11-08 17:12:48 +0100chomwitt(~chomwitt@2a02:587:7a1a:4300:1ac0:4dff:fedb:a3f1)
2023-11-08 17:13:08 +0100 <Inst> claims that it's suitable for "self-study", people beginning computer science, as well as introductory computer science courses
2023-11-08 17:13:13 +0100 <Inst> stuffs recursion in your face in chapter 1.2
2023-11-08 17:14:08 +0100 <[exa]> Guest67: pre-sorted lists make pretty good Sets w.r.t. merging
2023-11-08 17:15:30 +0100 <[exa]> Inst: my honest opinion on a good point to start with recursion is chapter -0.5 :D
2023-11-08 17:15:54 +0100 <Inst> i'm not saying it's bad, at this point, i preliminarily decided this is worth translating with the permission of the author
2023-11-08 17:15:59 +0100 <Inst> if i can get it
2023-11-08 17:16:07 +0100 <Inst> but the norms are just so... different
2023-11-08 17:16:17 +0100 <Inst> chapter 2: discussion of mathematical functions
2023-11-08 17:16:26 +0100econo_(uid147250@id-147250.tinside.irccloud.com)
2023-11-08 17:16:35 +0100rosco(~rosco@yp-150-69.tm.net.my) (Quit: Lost terminal)
2023-11-08 17:16:36 +0100 <danse-nr3> seems interesting
2023-11-08 17:16:40 +0100 <Inst> the closest analogue is a mixture of Haskell from the Very Beginning (ultra-accessible, based on a OCaml book) and Hutton's Programming in Haskell
2023-11-08 17:17:01 +0100 <danse-nr3> is it specific to haskell?
2023-11-08 17:17:03 +0100 <Inst> and yup, good ole Z shows up
2023-11-08 17:17:04 +0100 <Inst> yes
2023-11-08 17:17:12 +0100 <c_wraith> Guest67: ntr' is the problem with your current implementation. You didn't consider the case where a new list might intersect multiples in the current accumulator
2023-11-08 17:17:20 +0100 <Inst> Z indicates the set of real numbers
2023-11-08 17:17:28 +0100 <Inst> erm, set of integers
2023-11-08 17:17:34 +0100 <[exa]> ...phew :D
2023-11-08 17:17:53 +0100 <c_wraith> Guest67: A simpler test case would be [[1,2],[1,3],[2,4]]
2023-11-08 17:18:08 +0100 <Inst> my fault, parsing three languages at once, math, chinese, and english
2023-11-08 17:20:02 +0100 <[exa]> Inst: anyway it is quite common to see textbooks like this, people tend to to just write down a reference for their course and at some point it suddenly gets the "self-study" sticker and that's it
2023-11-08 17:20:10 +0100 <c_wraith> Guest67: ntr' will get called with [2,4] and [], giving the result [[2,4]]. Then it will get called with [1,3] [[2,4]], giving the result [[2,4],[1,3]]. Finally, it will be called with [1,2] [[2,4],[1,3]], and that's where it goes wrong
2023-11-08 17:20:35 +0100 <Inst> ehhh, i mean, Chinese Haskell culture seems isolated from Western Haskell culture
2023-11-08 17:20:46 +0100 <Inst> would be interesting to see what kind of weirdness results
2023-11-08 17:20:56 +0100 <Inst> I should go hunt down Granin and ask him about what the Russian Haskell community is like
2023-11-08 17:20:57 +0100 <c_wraith> Guest67: That call should result in one output list, but it will result in two because you stop recursing as soon as it intersects with one thing
2023-11-08 17:21:16 +0100 <Inst> in a different Chinese Haskell book, there was a prolonged section on Data.Bits
2023-11-08 17:21:51 +0100 <danse-nr3> recursion and math functions do not seem that unrelated to be honest. Not sure about Data.Bits, but i guess, like for english books, there can be different focuses
2023-11-08 17:22:15 +0100 <Inst> no, I mean, recursion is hilarious because it gives traditional programmers a stroke
2023-11-08 17:22:30 +0100 <Inst> whereas it's bread and butter in FP
2023-11-08 17:22:53 +0100 <c_wraith> meh. It was a long time before I learned FP, and I never had issues with recursion
2023-11-08 17:23:17 +0100 <c_wraith> well, other than understanding why. Examples like factorial are not convincing
2023-11-08 17:23:36 +0100 <Inst> his example is maximum
2023-11-08 17:23:42 +0100 <Inst> mymax [x] = x
2023-11-08 17:23:49 +0100 <Inst> mymax (x:xs) = max x (mymax xs)
2023-11-08 17:23:57 +0100 <Inst> then gcd
2023-11-08 17:24:22 +0100 <Inst> gcd (x, 0) = x; gcd (x, y) = gcd (y, mod x y)
2023-11-08 17:24:57 +0100 <Inst> the initial introduction starts with mymax: Z+ -> Z, actually, the mymax function written in math notation
2023-11-08 17:26:50 +0100ski(~ski@ext-1-042.eduroam.chalmers.se)
2023-11-08 17:27:27 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 240 seconds)
2023-11-08 17:27:35 +0100 <[exa]> Inst: yeah that's quite oldstyle
2023-11-08 17:27:51 +0100 <Inst> why is it old style?
2023-11-08 17:28:14 +0100doyougnu(~doyougnu@45.46.170.68)
2023-11-08 17:28:56 +0100 <[exa]> normally I avoid stuff like GCD or any mathematical kind of recursion now and present it more like a case analysis (a bit like mymax, but explicitly with "what are the possibilities that can happen and we can reduce them immediately")
2023-11-08 17:29:05 +0100doyougnu-(~doyougnu@45.46.170.68) (Ping timeout: 240 seconds)
2023-11-08 17:29:52 +0100 <[exa]> basically trying to follow the cata/ana schemes for good intuition; the more complex recursion schemes become less scary with that
2023-11-08 17:30:16 +0100 <Inst> this is part of chapter 1 as an introduction
2023-11-08 17:30:31 +0100 <Inst> he actually starts with some C code explaining what imperative programming is
2023-11-08 17:32:25 +0100WzC(~Frank@77-162-168-71.fixed.kpn.net) (Server closed connection)
2023-11-08 17:32:39 +0100Noinia(~Frank@77-162-168-71.fixed.kpn.net)
2023-11-08 17:33:29 +0100 <ski> ("mathematical kind of recursion" here referring to ?)
2023-11-08 17:36:23 +0100 <[exa]> ski: like GCD... not really a catamorphism or anamorphism unless you can see the bezout coefficients behind that
2023-11-08 17:37:41 +0100 <dolio> Recursion was around long before people doing pseudo category theory categorized some special cases of it.
2023-11-08 17:38:29 +0100 <[exa]> :]
2023-11-08 17:38:33 +0100 <ski> hm, perhaps one could say "non-structural recursion" ?
2023-11-08 17:38:50 +0100 <Inst> exa: you were around when I was bloviating about that glamour model streaming baby rudin, right?
2023-11-08 17:38:50 +0100 <[exa]> ah yeah, that would be more correct.
2023-11-08 17:39:09 +0100 <[exa]> Inst: I saw some of the last lines of that and didn't quite get it :D
2023-11-08 17:39:10 +0100 <ski> (s/correct/precise/, i was more aiming for)
2023-11-08 17:40:16 +0100 <Inst> I guess my assumption is that if the professor knows what he's doing, and he's teaching at the 5th or 6th ranked school in China, it's just stating that the math background of his audience is good enough that he can introduce Haskell by introducing statements in mathematical notation, then translating it directly into Haskell
2023-11-08 17:40:26 +0100danse-nr3(~danse@ge-19-113-42.service.infuturo.it) (Ping timeout: 255 seconds)
2023-11-08 17:41:05 +0100 <[exa]> Inst: might be very much the case
2023-11-08 17:42:05 +0100[exa]remembers people doing the same with matlab
2023-11-08 17:42:12 +0100[exa]shudders
2023-11-08 17:42:20 +0100danse-nr3(~danse@ge-19-113-42.service.infuturo.it)
2023-11-08 17:43:52 +0100dut(~dut@user/dut)
2023-11-08 17:46:53 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:6d7a:4eb0:231d:253f) (Remote host closed the connection)
2023-11-08 17:47:11 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3c67:344e:72ec:4543)
2023-11-08 17:47:27 +0100danse-nr3(~danse@ge-19-113-42.service.infuturo.it) (Ping timeout: 240 seconds)
2023-11-08 17:49:02 +0100erty(~user@user/aeroplane)
2023-11-08 17:52:04 +0100ski. o O ( "Domain-Specific Languages of Mathematics: Presenting Mathematical Analysis Using Functional Programming" by Cezar Ionescu,Patrik Jansson in 2016-11-29 at <https://arxiv.org/abs/1611.09475>,<https://github.com/DSLsofMath/DSLsofMath> )
2023-11-08 18:02:52 +0100lg188(~lg188@82.18.98.230) (Quit: Bye.)
2023-11-08 18:03:51 +0100 <Inst> i guess the book is weird
2023-11-08 18:03:57 +0100 <Inst> the author's read quite a few Haskell textbooks
2023-11-08 18:04:05 +0100 <Inst> it starts really intimidating looking with math
2023-11-08 18:04:30 +0100 <Inst> by the middle you're looking at stuff that looks cribbed off Simon Thompson's "The Craft of Functional Programming"
2023-11-08 18:05:01 +0100 <Unicorn_Princess> i'd like to get multi-line input for interactive haskell working without using :{:}, in emacs eshell. it works for the "let a=0\nb=1" case, but can't get it to work for a pattern-matching function def, like "let f 0 = 1\nf x = 3". uses only the last definition without the let, and syntax errors on '=' with the let
2023-11-08 18:06:08 +0100 <Unicorn_Princess> (right now i just start an eshell and run ghci, not using any haskell-inferior-mode or such packages)
2023-11-08 18:07:37 +0100thegman(~thegman@072-239-207-086.res.spectrum.com)
2023-11-08 18:08:08 +0100Simikando(~Simikando@adsl-dyn216.91-127-84.t-com.sk)
2023-11-08 18:09:56 +0100 <zero> ghcup recommended versions for cabal and ghc are, respectively. but "Warning: Unknown/unsupported 'ghc' version detected (Cabal 3.6.2.0 supports 'ghc' version < 9.4): /home/zero/.ghcup/bin/ghc is version 9.4.7"
2023-11-08 18:10:48 +0100 <zero> my message is clearly missing the versions after "respectively" but it's redundant
2023-11-08 18:11:57 +0100hueso(~root@user/hueso) (Quit: hueso)
2023-11-08 18:13:00 +0100aosync(~alews@user/aws)
2023-11-08 18:15:15 +0100hueso(~root@user/hueso)
2023-11-08 18:17:19 +0100chomwitt(~chomwitt@2a02:587:7a1a:4300:1ac0:4dff:fedb:a3f1) (Ping timeout: 264 seconds)
2023-11-08 18:19:54 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-08 18:21:11 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-11-08 18:23:03 +0100mmhat(~mmh@p200300f1c7445ecbee086bfffe095315.dip0.t-ipconnect.de)
2023-11-08 18:23:04 +0100mmhat(~mmh@p200300f1c7445ecbee086bfffe095315.dip0.t-ipconnect.de) (Client Quit)
2023-11-08 18:24:59 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-08 18:25:21 +0100dom0(~u0_a242@79.116.123.64)
2023-11-08 18:25:47 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Quit: ERC (IRC client for Emacs 27.1))
2023-11-08 18:32:50 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 252 seconds)
2023-11-08 18:33:40 +0100lg188(~lg188@82.18.98.230)
2023-11-08 18:39:08 +0100Guest67(~Guest67@70.19.76.200) (Quit: Client closed)
2023-11-08 18:41:04 +0100dom0(~u0_a242@79.116.123.64) (Quit: WeeChat 4.0.5)
2023-11-08 18:44:16 +0100alp(~alp@2001:861:5e02:eff0:a4ec:9755:9740:6f21)
2023-11-08 18:48:03 +0100dut(~dut@user/dut) (Quit: Leaving)
2023-11-08 18:54:58 +0100 <EvanR> is mtl-style capabilities the same thing as "tagless final"
2023-11-08 18:55:48 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-08 18:57:25 +0100danza(~francesco@151.37.118.190)
2023-11-08 18:57:33 +0100alp(~alp@2001:861:5e02:eff0:a4ec:9755:9740:6f21) (Ping timeout: 260 seconds)
2023-11-08 18:58:13 +0100chele(~chele@user/chele) (Quit: Leaving)
2023-11-08 19:08:13 +0100Simikando(~Simikando@adsl-dyn216.91-127-84.t-com.sk) (Quit: Leaving)
2023-11-08 19:10:35 +0100 <Inst> huh, i guess Qiao Haiyan's book changed my mind on recursion
2023-11-08 19:10:48 +0100 <zero> Inst: how so?
2023-11-08 19:10:58 +0100 <Inst> I was cargo culting Professor Krishnamurti's line on factorial and fib being dumb
2023-11-08 19:11:02 +0100 <Inst> https://www.quora.com/How-does-professor-Shriram-Krishnamurthi-teach-the-concept-of-recursion
2023-11-08 19:13:57 +0100 <ski> how did it change your mind ?
2023-11-08 19:14:42 +0100 <Inst> I mean, their approach is to start with a mathematically recursive definition
2023-11-08 19:14:53 +0100 <Inst> then translate the mathematical definition into haskell
2023-11-08 19:15:11 +0100ursa-major(~ursa-majo@37.19.210.38)
2023-11-08 19:16:47 +0100skiwaits for the punchline
2023-11-08 19:16:59 +0100 <Inst> there is no punchline, their approach just seems valid and convincing to me
2023-11-08 19:17:23 +0100 <Inst> Krishnamurti's line is start with recursive data structures
2023-11-08 19:17:36 +0100 <ski> i'm wondering how it changed your mind
2023-11-08 19:19:06 +0100 <ski> (i respect Shriram .. but perhaps he may have a bit dogmatic bent, at times)
2023-11-08 19:20:11 +0100 <EvanR> Inst, in haskell dumb things get a lot of Milage
2023-11-08 19:21:20 +0100 <EvanR> data Either a b = Left a | Right b, so dumb nothing can go wrong and you have no incentive to reinvent it
2023-11-08 19:22:25 +0100 <Inst> the feeling i got from Qiao Haiyan and Zhou Xiaocong's book is that they connect Haskell to mathematics and mathematical notation quite closely, despite trying to write an intro book
2023-11-08 19:22:25 +0100accord(uid568320@id-568320.hampstead.irccloud.com)
2023-11-08 19:22:38 +0100 <Inst> somehow just converting from mathematical notation to haskell code is convincing
2023-11-08 19:23:15 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-11-08 19:23:16 +0100 <Inst> meanwhile in Haskelbook, you get more or less the same thing
2023-11-08 19:23:24 +0100justThanksjustTesting
2023-11-08 19:24:07 +0100 <Inst> https://media.discordapp.net/attachments/968989726633779215/1171877720540594237/image.png?ex=655e4…
2023-11-08 19:24:09 +0100 <Inst> this somehow seems
2023-11-08 19:24:49 +0100 <Inst> to be less convincing than n! = n * (n-1) * ... * 1
2023-11-08 19:25:13 +0100 <EvanR> it does look better than the equivalent Integer computation in many other languages
2023-11-08 19:25:35 +0100 <EvanR> which involves calls to the arbitrary precision library
2023-11-08 19:26:23 +0100ski. o O ( "The Swine Before Perl" (talk/presentation) by Shriram Krishnamurthi in 2001-11 at <https://cs.brown.edu/~sk/Publications/Talks/SwineBeforePerl/> (with audio file),<http://www.ai.mit.edu/projects/dynlangs/ll1/shriram-talk.pdf> )
2023-11-08 19:29:41 +0100 <Inst> ugh, i think this laptop's bluetooth is borked :(
2023-11-08 19:33:20 +0100danza(~francesco@151.37.118.190) (Ping timeout: 252 seconds)
2023-11-08 19:35:32 +0100 <zero> ah that shriram. i like his talk on expressiveness
2023-11-08 19:36:36 +0100 <zero> https://yewtu.be/watch?v=43XaZEn2aLc
2023-11-08 19:39:22 +0100 <ski> yea, based on Felleisen's paper
2023-11-08 19:40:50 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-08 19:41:11 +0100 <Inst> https://media.discordapp.net/attachments/1130582451752796322/1171882022462038056/e53ad72c49256e3b7…
2023-11-08 19:42:09 +0100 <ski> Inst : do they connect that with induction, in the text ?
2023-11-08 19:42:29 +0100 <Inst> not sure, would have to look elsewhere
2023-11-08 19:43:38 +0100statusbot1(~statusbot@ec2-34-198-122-184.compute-1.amazonaws.com)
2023-11-08 19:44:05 +0100 <ski> yea, i guess i meant, in close connection to introducing recursion
2023-11-08 19:45:41 +0100 <ski> EvanR : oh, btw, would you still be interested in seeing that coroutine `zipWith' stuff ?
2023-11-08 19:47:08 +0100 <EvanR> sure
2023-11-08 19:47:08 +0100statusbot(~statusbot@ec2-34-198-122-184.compute-1.amazonaws.com) (Ping timeout: 248 seconds)
2023-11-08 19:48:12 +0100mechap(~mechap@user/mechap) (Quit: WeeChat 4.1.1)
2023-11-08 19:52:25 +0100 <Inst> https://media.discordapp.net/attachments/1130582451752796322/1171884700181217411/30b0ecdaf9dd840a8…
2023-11-08 19:53:22 +0100 <Inst> https://media.discordapp.net/attachments/1130582451752796322/1171884852409278474/d505b138ca765bdd2…
2023-11-08 19:53:38 +0100 <ski> EvanR : "FoldrZip.hs" (2007-04-10),"FoldrZipAlternate.hs" (2011-06-14) <https://paste.tomsmeding.com/hh2TNgYy>
2023-11-08 19:54:14 +0100 <Inst> ski: that's what i mean by it seems a bit dumbed down in some places and too advanced in others
2023-11-08 19:55:03 +0100 <ski> Inst : since `mymax' is restricted to positive integers, why don't they also handle the empty list ?
2023-11-08 19:55:10 +0100 <EvanR> if you like math and functional programming notation there is the homotopy type theory book
2023-11-08 19:55:18 +0100 <ski> .. oh. sorry, i misread, actually
2023-11-08 19:55:29 +0100 <Inst> yeah it's partial :(
2023-11-08 19:55:33 +0100 <ski> yea, the superscript plus is for list, i just realized
2023-11-08 19:55:47 +0100 <EvanR> whoa you can paste 2 files
2023-11-08 19:55:57 +0100 <ski> (non-empty list, presumably .. so it's, in the theory/model, not partial)
2023-11-08 19:56:03 +0100 <ski> sure
2023-11-08 19:56:54 +0100neceve(~neceve@user/neceve)
2023-11-08 19:56:57 +0100zetef(~quassel@95.77.17.251)
2023-11-08 19:57:05 +0100 <EvanR> your empty list [ ] ...
2023-11-08 19:57:50 +0100 <EvanR> it makes me wonder why the romans never spelled 2 like I I
2023-11-08 19:58:25 +0100 <ski> the different (numbered) versions are supposed to be stepwise refactorings, to hopefully help show where the code in the end came from, not completely "pulling the rabbit out of the hat" (aka "oracle method")
2023-11-08 19:59:42 +0100 <Inst> in the 2.4?
2023-11-08 20:00:40 +0100 <ski> (and `A' and `B' are the two coroutine types, that communicate with each other, handing off the "baton" to the other one, including its own current state, so the other one can resume the former one when it wants to)
2023-11-08 20:00:57 +0100 <ski> Inst ?
2023-11-08 20:01:02 +0100 <Inst> ah okay, misunderstood
2023-11-08 20:01:15 +0100 <Inst> too tired, sorry for bugging you with a brain fart, have a nice day :)
2023-11-08 20:01:18 +0100skiwas talking about the (repaste of an old) paste
2023-11-08 20:01:29 +0100 <ski> nw, have fun
2023-11-08 20:01:39 +0100hiyori(~hiyori@user/hiyori) (Quit: Client closed)
2023-11-08 20:01:39 +0100erty(~user@user/aeroplane) (Ping timeout: 255 seconds)
2023-11-08 20:02:43 +0100 <EvanR> I'm still on zipWith2 xD
2023-11-08 20:02:59 +0100 <EvanR> I see zipWith3 accomplish the mission without pattern match
2023-11-08 20:03:25 +0100 <EvanR> have you benchmarked their performance
2023-11-08 20:03:44 +0100thegman(~thegman@072-239-207-086.res.spectrum.com) (Read error: Connection reset by peer)
2023-11-08 20:04:59 +0100thegman(~thegman@072-239-207-086.res.spectrum.com)
2023-11-08 20:05:18 +0100 <ski> `zipWith1' to `zipWith2' is merely the definition of `foldr'
2023-11-08 20:05:37 +0100 <ski> i didn't benchmark, no
2023-11-08 20:06:05 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 240 seconds)
2023-11-08 20:06:51 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Quit: ChaiTRex)
2023-11-08 20:06:54 +0100 <ski> (`zipWith2' to `zipWith3' is the step that's a bit more of a leap)
2023-11-08 20:08:03 +0100 <ski> (one could also unfold `A' into `B' (or vice versa), which would make the CPS nature of it slightly more apparent)
2023-11-08 20:10:00 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se)
2023-11-08 20:10:00 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-11-08 20:12:04 +0100 <ski> (iow, `newtype A a b c = MkA {unA :: (a -> A a b c -> [c]) -> [c]}' resp. `newtype B a b c = MkB {unB :: a -> (B a b c -> [c]) -> [c]}', iow `A a b c' is `Cont [c] (a,A a b c)' and `B a b c' is `a -> Cont [c] (B a b c)' .. although interfacing them with each other then might be a bit more bureaucratic. anyway, if you squint, you can see that `A a b c' is kinda a stream of `a's, and `B a b c' is kinda a
2023-11-08 20:12:10 +0100 <ski> consumer of an `a' stream)
2023-11-08 20:13:10 +0100 <ski> (and yes, the `b' parameter there is completely useless. you'll see that in the second file, i skipped it (and generalized `[c]' to `r' in the `newtype's))
2023-11-08 20:14:41 +0100[Leary](~Leary]@user/Leary/x-0910699) (Ping timeout: 240 seconds)
2023-11-08 20:15:24 +0100Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-11-08 20:19:23 +0100target_i(~target_i@217.175.14.39)
2023-11-08 20:20:00 +0100trev(~trev@user/trev) (Quit: trev)
2023-11-08 20:21:18 +0100 <EvanR> I just finished that scheme talk and it was the exact opposite of standard youtube information undensity xD
2023-11-08 20:21:40 +0100fweht(uid404746@id-404746.lymington.irccloud.com)
2023-11-08 20:22:22 +0100 <EvanR> I like at the very end it's a debate between statically typed higher order functions compiling an automaton vs using scheme macros to get the same effect (before compiling)
2023-11-08 20:22:37 +0100 <EvanR> alright zipWith3
2023-11-08 20:22:40 +0100 <ski> which talk ? the Swine one, or the expressivity one ?
2023-11-08 20:22:54 +0100aosync(~alews@user/aws) (Server closed connection)
2023-11-08 20:22:55 +0100 <ski> ah, Swine it is
2023-11-08 20:23:10 +0100aosync(~alews@user/aws)
2023-11-08 20:23:17 +0100 <EvanR> yes. Also tomsmedingpaste coloring as in the code as bs is really throwing me off xD
2023-11-08 20:23:38 +0100 <ski> yea, i also noticed that :p
2023-11-08 20:29:21 +0100 <EvanR> and we can link this up with the Swine talk by understanding your code using a sort of automaton?
2023-11-08 20:30:21 +0100 <EvanR> but there are 2 input streams
2023-11-08 20:30:39 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-11-08 20:31:13 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 255 seconds)
2023-11-08 20:31:21 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 240 seconds)
2023-11-08 20:31:32 +0100 <EvanR> and I'm not sure what the states would be
2023-11-08 20:32:08 +0100 <EvanR> initiate *think very hard* strategy
2023-11-08 20:32:16 +0100 <ski> EvanR : ah .. no, the Swine talk was unrelated (at least afaik)
2023-11-08 20:32:38 +0100 <ski> (been a while since i (re)watched it, though)
2023-11-08 20:33:00 +0100 <ski> (i only mentioned it because Shriram came up previously)
2023-11-08 20:33:09 +0100Pickchea(~private@user/pickchea)
2023-11-08 20:33:22 +0100 <EvanR> yeah it is
2023-11-08 20:33:28 +0100 <EvanR> I'm trying to relate them xD
2023-11-08 20:34:11 +0100 <ski> i guess they're talking about using tail calls to switch between states .. and i'm also switching between states (which coroutine is active), kina
2023-11-08 20:37:59 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 245 seconds)
2023-11-08 20:40:33 +0100 <EvanR> state 0, look at [a] stream, if it's empty yield [], otherwise goto "state 1 with the a". state 1 (with an a), look at [b]. If it's empty yield [], otherwise yield f a b and go back to state 0
2023-11-08 20:41:16 +0100 <ski> yep, exactly
2023-11-08 20:41:30 +0100 <ski> (or state `A' and state `B', if you prefer)
2023-11-08 20:42:08 +0100 <ski> the `kA's and `kB's are the current states of each respective coroutine, which is passed along when relinguishing control to the other one
2023-11-08 20:42:39 +0100hgolden_(~hgolden@2603-8000-9d00-3ed1-dd4f-298a-9c49-a0ed.res6.spectrum.com)
2023-11-08 20:42:46 +0100 <ski> .. the main trick here was figuring out that you needed recursive types, and then what exact recursive types would work
2023-11-08 20:43:09 +0100hgolden_(~hgolden@2603-8000-9d00-3ed1-dd4f-298a-9c49-a0ed.res6.spectrum.com) (Client Quit)
2023-11-08 20:43:33 +0100 <ski> (i started from the (initially rather vague) intuition of coroutine states, though. iirc, i added the versions zero,one,two as an afterthought)
2023-11-08 20:43:42 +0100hgolden_(~hgolden@2603-8000-9d00-3ed1-dd4f-298a-9c49-a0ed.res6.spectrum.com)
2023-11-08 20:44:17 +0100hgolden(~hgolden@2603-8000-9d00-3ed1-dd4f-298a-9c49-a0ed.res6.spectrum.com) (Ping timeout: 252 seconds)
2023-11-08 20:44:46 +0100danza(~francesco@151.37.118.190)
2023-11-08 20:44:52 +0100 <EvanR> I don't recall seeing this sort of thing on "evolution of a haskell programmer" xD
2023-11-08 20:45:24 +0100 <ski> (each coroutine takes the state of the other coroutine as an argument. it would be interesting to fiddle with some example requiring three coroutines, and preferably not just a cyclic (or linear) handoff of the baton, but at least handoffs in four directions)
2023-11-08 20:45:46 +0100 <ski> hm, i forget when the evolution thing came
2023-11-08 20:47:23 +0100 <EvanR> consB b kB = MkB $ \a kA -> f a b : unA kA kB
2023-11-08 20:48:21 +0100shoggouth(uid607148@user/shoggouth)
2023-11-08 20:48:26 +0100 <EvanR> so someone consumes the f a b, and wants to get the next element... so evaluates unA kA kB...
2023-11-08 20:48:34 +0100 <ski> <http://www.willamette.edu/~fruehr/haskell/evolution.html> says 2001-07-11
2023-11-08 20:49:06 +0100 <EvanR> kA contains a function taking kB... and there it is...
2023-11-08 20:49:29 +0100 <EvanR> and the function ...
2023-11-08 20:49:33 +0100 <ski> yea. ideally, when reading, ignore the `MkA's,`MkB's,`unA's,`unB's .. those are only needed because cyclic types aren't allowed (unlike say `ocaml -rectypes')
2023-11-08 20:50:44 +0100 <EvanR> is doing a foldr
2023-11-08 20:51:40 +0100 <EvanR> so unA kA kB will evaluate to [] or another f a b : unA kA kB
2023-11-08 20:51:56 +0100 <ski> i was delightfully surprised when i realized that the basic idea did work
2023-11-08 20:52:01 +0100danza(~francesco@151.37.118.190) (Ping timeout: 240 seconds)
2023-11-08 20:52:08 +0100 <ski> yea
2023-11-08 20:52:40 +0100 <EvanR> I wonder if there's a nicer way to visualize it, probably by removing all the MkA and unA etc
2023-11-08 20:53:20 +0100Inst(~Inst@120.244.192.250) (Leaving)
2023-11-08 20:56:40 +0100 <EvanR> each coroutine state is basically a tail of one of the input lists being consumed, so they could be visualized as like a ribosome (which yields DNA by zipping down an mRNA strand)
2023-11-08 20:56:54 +0100 <EvanR> or tRNA or something like that
2023-11-08 20:57:48 +0100kraftwerk28(~kraftwerk@164.92.219.160) (Quit: *disconnects*)
2023-11-08 20:59:41 +0100 <ski> hm .. i guess one could make a version with passing the states back and forth, without using `foldr' for the looping (so each coroutine has explicit recursion)
2023-11-08 20:59:43 +0100 <EvanR> and contains each others state so it can be expressed by a single expression tree
2023-11-08 21:01:06 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-08 21:01:31 +0100 <EvanR> oh yeah, zipWith3 not only has no pattern matching but no explicit recursion
2023-11-08 21:01:36 +0100 <EvanR> and no data
2023-11-08 21:02:06 +0100 <ski> (btw, i think it's possible to add a `forall' on `[c]'/`r' inside at least `A', perhaps also `B')
2023-11-08 21:02:23 +0100 <ski> quite a neat trick, huh ?
2023-11-08 21:02:30 +0100 <ski> :)
2023-11-08 21:03:01 +0100 <EvanR> and this was in an old oleg paper? figures xD
2023-11-08 21:03:26 +0100 <ski> well, apparently Oleg did something similar
2023-11-08 21:03:36 +0100 <ski> but i came up with it on my own, independently
2023-11-08 21:04:20 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-11-08 21:06:14 +0100 <EvanR> to generalize it, I'd identify what direction to generalize. More input streams? More coroutines? More memory (like the a being carried between state 0 and state 1)? Is memory associated with the coroutine or is it global
2023-11-08 21:06:21 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 240 seconds)
2023-11-08 21:06:29 +0100 <EvanR> is it necessarily 1 input stream per coroutine
2023-11-08 21:06:37 +0100 <ski> anyway, the one i solved a couple of days ago, along similar lines (although a little bit more involved), was `sameFringe :: Eq a => Tree a -> Tree a -> Bool' (specified as `sameFringe t0 t1 = toList t0 == toList t1') where `data Tree a = Empty | Leaf a | Branch (Tree a) (Tree a)'
2023-11-08 21:06:43 +0100 <EvanR> what even identifies what as a coroutine
2023-11-08 21:06:46 +0100euleritian(~euleritia@dynamic-046-114-202-140.46.114.pool.telefonica.de)
2023-11-08 21:06:54 +0100 <ski> good questions
2023-11-08 21:07:13 +0100 <ski> you could have multiple (alternate) "entry points" for each type of coroutine
2023-11-08 21:07:26 +0100 <ski> (just use a record of functions)
2023-11-08 21:09:23 +0100 <ski> the natural way to think about would be each coroutine having its own local state, i think. you could also possibly pass auxilary state on to the awoken coroutine, together with the self state. or you could use `IORef's, if you want to
2023-11-08 21:09:55 +0100neceve(~neceve@user/neceve) (Ping timeout: 255 seconds)
2023-11-08 21:10:39 +0100neceve(~neceve@user/neceve)
2023-11-08 21:10:39 +0100 <ski> (e.g. perhaps you would like to either wake a coroutine up, handing it an element, or else waking it up to tell it that there's no more elements ..)
2023-11-08 21:11:04 +0100 <EvanR> lets say you are passed "the state" of 99 other coroutines. Then you can optionally yield output, then move to the next state by entering one (?) of the 99 states, along with your updated state. So there's this all-the-states-minus-yourself structure getting passed in? Anyway, which routine to you enter next
2023-11-08 21:11:16 +0100 <ski> (.. although i found a different solution, for `sameFringe')
2023-11-08 21:11:49 +0100 <EvanR> to give everyone a chance to go you'd need some kind of scheduler
2023-11-08 21:12:53 +0100 <EvanR> in this case the other routine only goes when you need something from it
2023-11-08 21:13:07 +0100 <ski> "So there's this all-the-states-minus-yourself structure getting passed in?" -- now this reminds me of a simple (cyclic) graph traverser i made, without using cyclic data structures, nor using node identifiers
2023-11-08 21:13:25 +0100 <ski> (in the form of a small text adventure, for fun)
2023-11-08 21:13:33 +0100justTestingjustThanks
2023-11-08 21:14:06 +0100 <ski> EvanR : yea, its cooperative, not preemptive, concurrency
2023-11-08 21:15:04 +0100ec_(~ec@gateway/tor-sasl/ec) (Ping timeout: 264 seconds)
2023-11-08 21:15:33 +0100 <ski> each one explicitly hands off to a different one (although they're loosely coupled in the sense that they're only bound together at the top-level. so it's more that each coroutine depends on the interface of the others, but is not bound directly to their implementation, except when firing it all off)
2023-11-08 21:15:33 +0100ec_(~ec@gateway/tor-sasl/ec)
2023-11-08 21:15:45 +0100 <EvanR> so you could round robin, A does something, enters B, which does something, enters C, which does something, eventually coming back to A which could be acting like the main interpreter loop or something
2023-11-08 21:16:35 +0100 <EvanR> or were you thinking something more complex
2023-11-08 21:16:42 +0100 <ski> with a dynamic situation, one'd like some kind of scheduler to keep track of which coroutine corresponds to which channel identifier, or whatever
2023-11-08 21:20:39 +0100 <ski> "A Poor Man's Concurrency Monad" by Koen Claessen in 1993 at <https://github.com/papers-we-love/papers-we-love/blob/main/languages/haskell/a-poor-mans-concurren…> may be relevant
2023-11-08 21:21:54 +0100 <EvanR> I wonder what ghc thinks the difference is between zipWith0 and zipWith3 (in terms of compiler output)
2023-11-08 21:25:01 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-08 21:26:19 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 264 seconds)
2023-11-08 21:35:00 +0100Jackneill_(~Jackneill@20014C4E1E058A0009BBD059E8BC0D29.dsl.pool.telekom.hu) (Quit: Leaving)
2023-11-08 21:35:01 +0100She(haveident@libera/staff/she/her) (Quit: Either upgrades, or the world's ending.)
2023-11-08 21:35:11 +0100Shelob(haveident@libera/staff/she/her)
2023-11-08 21:35:18 +0100Jackneill(~Jackneill@20014C4E1E058A0009BBD059E8BC0D29.dsl.pool.telekom.hu)
2023-11-08 21:35:27 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-11-08 21:35:35 +0100ShelobShe
2023-11-08 21:35:48 +0100krj(~krjst@2604:a880:800:c1::16b:8001) (Server closed connection)
2023-11-08 21:36:59 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-11-08 21:37:01 +0100krj(~krjst@2604:a880:800:c1::16b:8001)
2023-11-08 21:37:48 +0100neceve(~neceve@user/neceve) (Read error: Connection reset by peer)
2023-11-08 21:38:21 +0100She(haveident@libera/staff/she/her) (Client Quit)
2023-11-08 21:41:29 +0100She(haveident@libera/staff/she/her)
2023-11-08 21:42:17 +0100neceve(~neceve@user/neceve)
2023-11-08 21:43:07 +0100santiagopim(~user@90.167.66.131)
2023-11-08 21:49:04 +0100thegeekinside(~thegeekin@189.141.80.123) (Ping timeout: 255 seconds)
2023-11-08 21:49:45 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-11-08 21:50:56 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3c67:344e:72ec:4543) (Remote host closed the connection)
2023-11-08 21:57:26 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2023-11-08 22:01:22 +0100ft(~ft@p4fc2a529.dip0.t-ipconnect.de)
2023-11-08 22:02:53 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-11-08 22:04:32 +0100target_i(~target_i@217.175.14.39) (Quit: leaving)
2023-11-08 22:05:15 +0100ubert(~Thunderbi@77.119.168.33.wireless.dyn.drei.com) (Remote host closed the connection)
2023-11-08 22:07:17 +0100thegman(~thegman@072-239-207-086.res.spectrum.com) (Quit: leaving)
2023-11-08 22:07:59 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 245 seconds)
2023-11-08 22:09:58 +0100chomwitt(~chomwitt@2a02:587:7a1a:4300:1ac0:4dff:fedb:a3f1)
2023-11-08 22:10:39 +0100zetef(~quassel@5.2.182.98)
2023-11-08 22:11:16 +0100thegman(~thegman@072-239-207-086.res.spectrum.com)
2023-11-08 22:13:03 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-11-08 22:13:56 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 252 seconds)
2023-11-08 22:22:56 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3c67:344e:72ec:4543)
2023-11-08 22:23:14 +0100thegman(~thegman@072-239-207-086.res.spectrum.com) (Quit: leaving)
2023-11-08 22:24:58 +0100thegeekinside(~thegeekin@189.141.80.123)
2023-11-08 22:25:30 +0100zetef(~quassel@5.2.182.98) (Remote host closed the connection)
2023-11-08 22:29:08 +0100zetef(~quassel@5.2.182.98)
2023-11-08 22:35:01 +0100[Leary](~Leary]@user/Leary/x-0910699)
2023-11-08 22:39:35 +0100elkcl(~elkcl@broadband-95-84-226-240.ip.moscow.rt.ru) (Ping timeout: 240 seconds)
2023-11-08 22:42:03 +0100thegman(~thegman@072-239-207-086.res.spectrum.com)
2023-11-08 22:43:16 +0100chiselfuse(~chiselfus@user/chiselfuse) (Ping timeout: 264 seconds)
2023-11-08 22:44:13 +0100qqq(~qqq@92.43.167.61) (Remote host closed the connection)
2023-11-08 22:45:50 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-11-08 22:46:22 +0100elkcl(~elkcl@broadband-95-84-226-240.ip.moscow.rt.ru)
2023-11-08 22:46:57 +0100Lycurgus(~georg@user/Lycurgus)
2023-11-08 22:50:24 +0100zetef(~quassel@5.2.182.98) (Remote host closed the connection)
2023-11-08 22:51:13 +0100zetef(~quassel@5.2.182.98)
2023-11-08 22:51:53 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 252 seconds)
2023-11-08 22:52:29 +0100Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-11-08 22:57:05 +0100acidjnk(~acidjnk@p200300d6e72b939468149480f7812d1a.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2023-11-08 22:58:50 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2023-11-08 22:58:51 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2023-11-08 22:59:19 +0100 <[Leary]> ski, EvanR: Relevant, if you want to keep twisting your brain: https://doisinkidney.com/posts/2021-03-14-hyperfunctions.html
2023-11-08 23:00:15 +0100pavonia(~user@user/siracusa)
2023-11-08 23:00:18 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-11-08 23:02:47 +0100 <ski> [Leary] : oh, ty :)
2023-11-08 23:03:05 +0100kraftwerk28(~kraftwerk@164.92.219.160)
2023-11-08 23:03:29 +0100 <EvanR> to understand hyperfunctions you must first what
2023-11-08 23:04:51 +0100 <ski> (istr "hyperfunctions" being used to describe something like `data Hyper a b = H (a -> b) (Hyper (a,a) (b,b))', though .. which is obviously different)
2023-11-08 23:06:55 +0100kraftwerk28(~kraftwerk@164.92.219.160) (Client Quit)
2023-11-08 23:07:29 +0100kraftwerk28(~kraftwerk@164.92.219.160)
2023-11-08 23:12:45 +0100fendor(~fendor@2a02:8388:1640:be00:cb6e:46f6:2fe6:1728) (Remote host closed the connection)
2023-11-08 23:13:49 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.5)
2023-11-08 23:15:43 +0100 <EvanR> their zip function uses no explicit recursion pattern matching or additional data (other than applying the (,) constructor which could just as well by the f from zipWith)
2023-11-08 23:16:02 +0100 <EvanR> oh it requires infinite types
2023-11-08 23:16:23 +0100 <EvanR> why don't we allowed infinite types again? xD
2023-11-08 23:16:40 +0100 <dminuoso> Well we do allow them, up to isomorphism.
2023-11-08 23:16:45 +0100 <dminuoso> :p
2023-11-08 23:17:09 +0100 <dminuoso> (That is, an isomorphism of allowance)
2023-11-08 23:20:48 +0100Lycurgus(~georg@user/Lycurgus) (Quit: leaving)
2023-11-08 23:24:15 +0100michalz(~michalz@185.246.207.205) (Remote host closed the connection)
2023-11-08 23:27:53 +0100kraftwerk28(~kraftwerk@164.92.219.160) (Quit: *disconnects*)
2023-11-08 23:30:59 +0100 <monochrom> Infinite types can recurse the world. >:)
2023-11-08 23:31:04 +0100kraftwerk28(~kraftwerk@164.92.219.160)
2023-11-08 23:35:06 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-11-08 23:35:35 +0100mechap(~mechap@user/mechap)
2023-11-08 23:37:31 +0100lbseale(~quassel@user/ep1ctetus) (Ping timeout: 255 seconds)
2023-11-08 23:41:25 +0100gmg(~user@user/gehmehgeh) (Quit: Leaving)
2023-11-08 23:42:19 +0100CO2(CO2@gateway/vpn/protonvpn/co2)
2023-11-08 23:44:24 +0100 <EvanR> so hyperfunctions unironically speed up your zip code xD
2023-11-08 23:45:31 +0100chomwitt(~chomwitt@2a02:587:7a1a:4300:1ac0:4dff:fedb:a3f1) (Ping timeout: 264 seconds)
2023-11-08 23:56:25 +0100 <c_wraith> apparently if you allow infinite types, a lot of code is accepted that you really want to fail to type-check
2023-11-08 23:59:55 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)