IRCBrowse

2024/12/22

2024-12-22 00:01:53 +0100peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) peterbecich
2024-12-22 00:03:53 +0100chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2024-12-22 00:04:13 +0100chexum(~quassel@gateway/tor-sasl/chexum) chexum
2024-12-22 00:09:03 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 00:14:58 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 00:20:26 +0100 <exarkun> today, right now
2024-12-22 00:20:41 +0100 <haskellbridge> <thirdofmay18081814goya> really? cool
2024-12-22 00:20:45 +0100 <haskellbridge> <thirdofmay18081814goya> what library are you using
2024-12-22 00:20:56 +0100 <exarkun> reflex-sdl2
2024-12-22 00:21:10 +0100 <exarkun> and reflex, of course
2024-12-22 00:22:05 +0100 <haskellbridge> <thirdofmay18081814goya> neat, will try out reflex right now
2024-12-22 00:22:13 +0100ubert1(~Thunderbi@p200300ecdf117cbda8ce35cba2c9a19e.dip0.t-ipconnect.de) ubert
2024-12-22 00:23:13 +0100ubert(~Thunderbi@p200300ecdf117ce99c7826839207afbb.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2024-12-22 00:23:13 +0100ubert1ubert
2024-12-22 00:25:41 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 00:30:39 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 276 seconds)
2024-12-22 00:31:20 +0100son0p(~ff@186.121.98.118) (Ping timeout: 265 seconds)
2024-12-22 00:32:01 +0100peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) (Ping timeout: 252 seconds)
2024-12-22 00:34:27 +0100hiredman(~hiredman@frontier1.downey.family) (Quit: Lost terminal)
2024-12-22 00:38:12 +0100son0p(~ff@186.121.98.118) son0p
2024-12-22 00:39:51 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2024-12-22 00:41:03 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 00:42:30 +0100tremon(~tremon@83.80.159.219) (Quit: getting boxed in)
2024-12-22 00:46:11 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 00:49:00 +0100E2Combinator(~E2Combina@190.180.45.137)
2024-12-22 00:55:17 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 00:58:09 +0100housemate(~housemate@ppp203-122-213-191.static.internode.on.net) housemate
2024-12-22 00:58:09 +0100MyNetAz(~MyNetAz@user/MyNetAz) (Remote host closed the connection)
2024-12-22 00:58:57 +0100gorignak(~gorignak@user/gorignak) (Ping timeout: 252 seconds)
2024-12-22 01:01:58 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 01:04:28 +0100 <Leary> % :t \xs i -> either Just (const Nothing) . flip runStateT 0 $ for_ xs \x -> do{ j <- get; put (j + 1); when (j == i) (throwError x) }
2024-12-22 01:04:28 +0100 <yahb2> \xs i -> either Just (const Nothing) . flip runStateT 0 $ for_ xs \x -> do{ j <- get; put (j + 1); when (j == i) (throwError x) } ; :: (Eq a, Num a, Foldable t) => t e -> a -> Maybe e
2024-12-22 01:04:41 +0100cptaffe(~cptaffe@user/cptaffe) (Ping timeout: 265 seconds)
2024-12-22 01:05:03 +0100sprotte24(~sprotte24@p200300d16f1a2c0064c6ee858fd5dcfe.dip0.t-ipconnect.de)
2024-12-22 01:05:09 +0100MyNetAz(~MyNetAz@user/MyNetAz) MyNetAz
2024-12-22 01:05:16 +0100E2Combinator(~E2Combina@190.180.45.137) (Quit: Client closed)
2024-12-22 01:05:23 +0100 <Leary> EvanR: `Foldable` already has indexing.
2024-12-22 01:06:47 +0100cptaffe(~cptaffe@user/cptaffe) cptaffe
2024-12-22 01:10:12 +0100housemate(~housemate@ppp203-122-213-191.static.internode.on.net) (Quit: Nothing to see here. I wasn't there. I take IRC seriously.)
2024-12-22 01:10:22 +0100E2Combinator(~E2Combina@190.180.45.137)
2024-12-22 01:13:20 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 01:17:27 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2024-12-22 01:17:47 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 01:23:12 +0100 <monochrom> Wait, do you mean one can just do toList and index into that list?!
2024-12-22 01:23:36 +0100 <monochrom> Not very efficient but I guess it counts.
2024-12-22 01:24:00 +0100 <monochrom> Then again Napier functors can have inefficient indexing too.
2024-12-22 01:28:42 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 01:33:08 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 01:34:04 +0100housemate(~housemate@ppp203-122-213-191.static.internode.on.net) housemate
2024-12-22 01:42:31 +0100CrunchyFlakes(~CrunchyFl@31.19.233.78) (Read error: Connection reset by peer)
2024-12-22 01:44:05 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 01:44:46 +0100CrunchyFlakes(~CrunchyFl@ip1f13e94e.dynamic.kabel-deutschland.de)
2024-12-22 01:45:45 +0100 <E2Combinator> Hi. I have some serious issues tryong to define a wrapper effect in fused-effects, anyone can help with that?
2024-12-22 01:46:33 +0100 <E2Combinator> I have defined the effect as such:
2024-12-22 01:46:33 +0100 <E2Combinator> https://paste.tomsmeding.com/4J7pz5eI
2024-12-22 01:46:33 +0100 <E2Combinator> And it typechecks and all
2024-12-22 01:47:05 +0100 <E2Combinator> I have defined an operation as such:
2024-12-22 01:47:07 +0100 <E2Combinator> resolveMovementStep :: Has UpdateTracking sig m => WilMaze InMovement -> m (WilMaze InMovement)
2024-12-22 01:47:12 +0100 <E2Combinator> And it typechecks and all
2024-12-22 01:47:36 +0100 <E2Combinator> But the moment I try to run resolveMovementStep with an effect carrier stack, I get the following:
2024-12-22 01:47:48 +0100 <E2Combinator> run $ runUpdateTracking $ resolveMovementStep m
2024-12-22 01:48:28 +0100 <E2Combinator> https://paste.tomsmeding.com/pXrMkP7e
2024-12-22 01:48:40 +0100ljdarj(~Thunderbi@user/ljdarj) (Ping timeout: 265 seconds)
2024-12-22 01:49:09 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 265 seconds)
2024-12-22 01:49:09 +0100 <E2Combinator> It complains partially about a missing effect signature, but even if I add the Has (Writer Any) constraint, it still fails
2024-12-22 01:50:07 +0100 <E2Combinator> Nvm, I saw the issue. Extraneous constraint in the Algebra instance
2024-12-22 01:55:45 +0100MyNetAz(~MyNetAz@user/MyNetAz) (Remote host closed the connection)
2024-12-22 01:59:46 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 02:02:46 +0100MyNetAz(~MyNetAz@user/MyNetAz) MyNetAz
2024-12-22 02:04:52 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 272 seconds)
2024-12-22 02:15:05 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 02:15:27 +0100ryanbooker(uid4340@id-4340.hampstead.irccloud.com) ryanbooker
2024-12-22 02:17:27 +0100sprotte24(~sprotte24@p200300d16f1a2c0064c6ee858fd5dcfe.dip0.t-ipconnect.de) (Quit: Leaving)
2024-12-22 02:20:05 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 265 seconds)
2024-12-22 02:21:17 +0100 <orangeflu> Bowuigi, you here?
2024-12-22 02:27:00 +0100 <haskellbridge> <Bowuigi> Yes, also Matrix stores messages when I'm offline
2024-12-22 02:30:47 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 02:35:17 +0100machinedgod(~machinedg@d108-173-18-100.abhsia.telus.net) (Ping timeout: 244 seconds)
2024-12-22 02:37:21 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-12-22 02:38:08 +0100 <orangeflu> ok, so weird thing
2024-12-22 02:38:14 +0100 <orangeflu> been coding some more on that branch today
2024-12-22 02:38:38 +0100 <orangeflu> decided, what the hell, haven't done a cabal test in a few hours, let me make sure i didn't fuck anything up in the meanwhile
2024-12-22 02:38:49 +0100 <orangeflu> that few gigs we were talking about yesterday
2024-12-22 02:38:54 +0100 <orangeflu> disappeared completely
2024-12-22 02:39:06 +0100 <orangeflu> if i run test.asm, it doesn't do that anymore
2024-12-22 02:39:10 +0100 <orangeflu> not sure when it stopped
2024-12-22 02:39:14 +0100housemate(~housemate@ppp203-122-213-191.static.internode.on.net) (Quit: Nothing to see here. I wasn't there. I take IRC seriously.)
2024-12-22 02:39:41 +0100 <orangeflu> i tried to go back to yesterday's commits but no luck, it simply isn't there
2024-12-22 02:40:10 +0100 <orangeflu> so i'ma just decide its a compiler weirdness and hope it never comes back, but it is weird indeed
2024-12-22 02:41:07 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 02:42:08 +0100 <haskellbridge> <thirdofmay18081814goya> hm, how owuld FRP model something like viewer state? e.g., the current page the user is on in a website
2024-12-22 02:42:08 +0100 <orangeflu> you know what, i might retry some profiling right now since it seems that the compiler decided to behave
2024-12-22 02:42:15 +0100 <haskellbridge> <thirdofmay18081814goya> * would
2024-12-22 02:43:30 +0100sprotte24(~sprotte24@p200300d16f1a2c0064c6ee858fd5dcfe.dip0.t-ipconnect.de)
2024-12-22 02:43:54 +0100Tuplanolla(~Tuplanoll@91-159-69-59.elisa-laajakaista.fi) (Quit: Leaving.)
2024-12-22 02:45:24 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 02:45:39 +0100sprotte24(~sprotte24@p200300d16f1a2c0064c6ee858fd5dcfe.dip0.t-ipconnect.de) (Client Quit)
2024-12-22 02:46:39 +0100acidjnk_new(~acidjnk@p200300d6e7283f52b5be3bacf47f1ed3.dip0.t-ipconnect.de) (Ping timeout: 245 seconds)
2024-12-22 02:50:27 +0100mhatta(~mhatta@www21123ui.sakura.ne.jp) (Quit: ZNC 1.9.1+deb2+b1 - https://znc.in)
2024-12-22 02:51:05 +0100 <haskellbridge> <thirdofmay18081814goya> oh this would be represented as a constant stream that changes contents as the user changes pages, right?
2024-12-22 02:51:19 +0100 <haskellbridge> <thirdofmay18081814goya> uh not "constant" stream, but continuous stream
2024-12-22 02:52:01 +0100mhatta(~mhatta@www21123ui.sakura.ne.jp)
2024-12-22 02:52:01 +0100 <haskellbridge> <thirdofmay18081814goya> e.g. a stream whose content is the unique ID of the current page
2024-12-22 02:52:03 +0100 <haskellbridge> <thirdofmay18081814goya> right?
2024-12-22 02:56:25 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 02:59:51 +0100weary-traveler(~user@user/user363627) user363627
2024-12-22 03:00:54 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 03:11:46 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 03:11:54 +0100 <haskellbridge> <Bowuigi> orangeflu odd stuff, but I'm glad it got solved
2024-12-22 03:16:24 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 03:18:00 +0100sawilagar(~sawilagar@user/sawilagar) (Ping timeout: 260 seconds)
2024-12-22 03:22:45 +0100housemate(~housemate@125.63.162.34) housemate
2024-12-22 03:30:37 +0100E2Combinator(~E2Combina@190.180.45.137) ()
2024-12-22 03:33:04 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 03:33:33 +0100housemate(~housemate@125.63.162.34) (Ping timeout: 265 seconds)
2024-12-22 03:37:03 +0100 <orangeflu> Bowuigi: I don't like that i don't know where it came from, and i still can't make profiling work
2024-12-22 03:37:54 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 03:38:13 +0100 <haskellbridge> <Bowuigi> Did you update or change any settings?
2024-12-22 03:39:01 +0100 <orangeflu> i disabled test coverage
2024-12-22 03:39:27 +0100 <orangeflu> waaaait
2024-12-22 03:39:37 +0100 <orangeflu> it compiled with profiling
2024-12-22 03:39:43 +0100 <orangeflu> stand-by for results
2024-12-22 03:42:36 +0100 <orangeflu> nvm
2024-12-22 03:47:14 +0100 <orangeflu> idk why it doesn't work. I try to build it wiht -prof, cabal complains i shouldn't do that. not like it matters, it gives an error anyway. Then i do cabal build --enable-profiling and then when i run it, no prog file is generated
2024-12-22 03:47:28 +0100 <orangeflu> How this whole process is supposed to work is hideously explained
2024-12-22 03:48:26 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 03:50:30 +0100 <orangeflu> ok, i ended up doing it
2024-12-22 03:50:42 +0100 <orangeflu> you want the results? not sure how to interpret them
2024-12-22 03:51:51 +0100 <haskellbridge> <Bowuigi> To be honest no idea how to profile either, but if it is a text file just drop it in https://paste.tomsmeding.com
2024-12-22 03:52:40 +0100 <haskellbridge> <Bowuigi> In particular, allocation spikes is what you are looking for
2024-12-22 03:52:59 +0100 <haskellbridge> <thirdofmay18081814goya> in FRP, do we suppose there exists a stream between the user's ability-to-click and buttons?
2024-12-22 03:53:00 +0100 <orangeflu> https://paste.tomsmeding.com/b9owLIrr
2024-12-22 03:53:41 +0100 <geekosaur> generally you need to compile with profiling (cabal will do this with --enable-profiling) and then run with profiling enabled (which is an RTS option: https://downloads.haskell.org/ghc/9.10.1/docs/users_guide/runtime_control.html#rts-profiling)
2024-12-22 03:53:51 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 265 seconds)
2024-12-22 03:53:58 +0100 <orangeflu> am i reading it correctly when it says it allocated 914 megabytes?
2024-12-22 03:54:07 +0100 <orangeflu> total alloc = 914,690,800 bytes (excludes profiling overheads)
2024-12-22 03:55:08 +0100 <orangeflu> geekosaur: yeah, what i did is i added profiling: True in cabal.project.local, and these arguments to ghc-options: -fprof-auto "-with-rtsopts=-N -p -s -h -i0.1"
2024-12-22 03:55:12 +0100 <orangeflu> and it seems to work now
2024-12-22 03:57:50 +0100machinedgod(~machinedg@d108-173-18-100.abhsia.telus.net) machinedgod
2024-12-22 03:57:58 +0100 <geekosaur> also note that "total alloc" includes ephemeral allocations which never leave the nursery and can generally be ignored because they're very fast to both allocate and reclaim
2024-12-22 03:58:24 +0100 <haskellbridge> <Bowuigi> thirdofmay18081814goya re:current-page yes, a value that may change as time moves is represented like that
2024-12-22 03:58:55 +0100 <haskellbridge> <Bowuigi> orangeflu the tables on the allocation report show how much time and allocation is used on every function
2024-12-22 03:58:59 +0100 <orangeflu> geekosaur: still seems like a lot, for what the programs does
2024-12-22 04:00:48 +0100 <haskellbridge> <Bowuigi> thirdofmay18081814goya you might want to check the source for reactive-banana or some other FRP UI library, I don't know enough about that, sorry
2024-12-22 04:01:45 +0100 <orangeflu> so what should i take away from this report? that the ST instruction takes a lot of time, since it's in a program where it's used a lot?
2024-12-22 04:02:01 +0100 <haskellbridge> <thirdofmay18081814goya> hm I see ty
2024-12-22 04:02:34 +0100 <haskellbridge> <Bowuigi> st might have a space leak, 961MB for bubble sort is too much lol
2024-12-22 04:03:42 +0100 <orangeflu> yeah, but ST is used a lot in that program
2024-12-22 04:04:07 +0100 <orangeflu> and if haskell allocates and deallocates those EmulatorState everytime i modify the arrays inside
2024-12-22 04:04:14 +0100 <orangeflu> it would make sense to consume that much
2024-12-22 04:04:20 +0100 <orangeflu> right?
2024-12-22 04:04:24 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 04:04:47 +0100 <orangeflu> cause the ST instruction stores something in the memory, which is a 2000 bytes array
2024-12-22 04:05:04 +0100op_4(~tslil@user/op-4/x-9116473) (Remote host closed the connection)
2024-12-22 04:05:06 +0100 <haskellbridge> <Bowuigi> Oh could you move to MVector?
2024-12-22 04:05:13 +0100 <orangeflu> I could
2024-12-22 04:05:18 +0100 <orangeflu> already made plans to
2024-12-22 04:05:29 +0100housemate(~housemate@ppp203-122-213-191.static.internode.on.net) housemate
2024-12-22 04:05:34 +0100op_4(~tslil@user/op-4/x-9116473) op_4
2024-12-22 04:05:52 +0100 <orangeflu> i have an idea though. My emulator has configurable SRAM sizes. Let's see if the total allocation decreases if i give it less total SRAM
2024-12-22 04:05:53 +0100 <haskellbridge> <Bowuigi> Because GHC tries to make stuff mutable on lower layers, but it can't if large parts are modified (as in the case of Array)
2024-12-22 04:06:14 +0100housemate(~housemate@ppp203-122-213-191.static.internode.on.net) (Max SendQ exceeded)
2024-12-22 04:07:11 +0100housemate(~housemate@ppp203-122-213-191.static.internode.on.net) housemate
2024-12-22 04:07:15 +0100housemate(~housemate@ppp203-122-213-191.static.internode.on.net) (Remote host closed the connection)
2024-12-22 04:07:29 +0100 <orangeflu> memory allocation drops to 511 mb if i give it 500 bytes of SRAM instead
2024-12-22 04:08:11 +0100 <geekosaur> Array does carding but the cards are fairly large
2024-12-22 04:08:22 +0100 <haskellbridge> <Bowuigi> The tree below indicates the local (with respect to the siblings of the tree and children) time and allocation usage
2024-12-22 04:08:26 +0100 <geekosaur> 128 elements last I heard?
2024-12-22 04:08:58 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 04:09:33 +0100 <orangeflu> if i use another assembly file, like one that doesn't write to memory at all, total allocation is 1-2 mb, and changing the memory size doesn't make that much of a difference
2024-12-22 04:10:09 +0100 <orangeflu> geekosaur: carding?
2024-12-22 04:10:32 +0100 <geekosaur> instead of GCing the entire array, it's divided into cards and individual cards are GCd
2024-12-22 04:11:43 +0100 <geekosaur> but f you touch elements in a lot of cards, it's slightly less performant than GCing the whole array; it works best if only nearby elements are modified
2024-12-22 04:12:02 +0100 <orangeflu> but why GC the array in the first place is what i don't understand. Like, i assume the compiler is smart enough to see that i always take the array, modify it and return the copy. does that not imply that it should make it mutable behind the scenes?
2024-12-22 04:12:33 +0100 <haskellbridge> <Bowuigi> Not exactly, the compiler likely can't assume that
2024-12-22 04:12:35 +0100 <geekosaur> if you're not modifying it, why was MVector the alternative?
2024-12-22 04:13:09 +0100 <orangeflu> i am "modifying it", by making a copy of it with the element i want modified changed, and i return that instead
2024-12-22 04:13:17 +0100 <haskellbridge> <Bowuigi> It was being modified, orangeflu refers to copy/mutate semantics, not explicit cloning
2024-12-22 04:13:32 +0100 <orangeflu> yeah
2024-12-22 04:14:04 +0100 <haskellbridge> <Bowuigi> So MVector would help here, as it has better fusion and is supposed to be mutable
2024-12-22 04:14:44 +0100 <orangeflu> let me see if i can make a quick experiment to see how it would work
2024-12-22 04:15:08 +0100 <orangeflu> but it may prove to be difficult because i would need to modify every function for every instruction, may take a while
2024-12-22 04:15:40 +0100 <haskellbridge> <Bowuigi> It is likely rebuilding the emulator state and array, but the only way to know for certain is to read the Core. That is way too far from a begginer topic
2024-12-22 04:15:41 +0100 <orangeflu> and i never worked with monads in this way before
2024-12-22 04:15:59 +0100 <orangeflu> is the Core in haskell?
2024-12-22 04:18:08 +0100 <haskellbridge> <Bowuigi> With "Core" I mean GHC Core, one of the intermediate representations of Haskell code used in GHC, specifically, the one that seems to have the most influence in the compilation result while being functional
2024-12-22 04:19:33 +0100 <haskellbridge> <Bowuigi> Practice with MVector outside of the emulator (and possibly with the strict state monad, the recommendation that was made yesterday) before implementing it, to understand it better
2024-12-22 04:19:44 +0100 <geekosaur> Core is kinda a simplified Haskell, but with annotations for things like strictness of parameters which guide optimization
2024-12-22 04:19:46 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 04:22:35 +0100 <orangeflu> By strict state monad, what do you mean?
2024-12-22 04:24:36 +0100 <orangeflu> ST?
2024-12-22 04:26:32 +0100 <geekosaur> https://downloads.haskell.org/ghc/latest/docs/libraries/mtl-2.3.1-a17d/Control-Monad-State-Strict.…
2024-12-22 04:26:40 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 04:27:07 +0100housemate(~housemate@ppp203-122-213-191.static.internode.on.net) housemate
2024-12-22 04:27:18 +0100 <geekosaur> ST is not "state" in the same sense, it is an execution context with private state in the form of STRefs and STArrays
2024-12-22 04:30:08 +0100 <orangeflu> i wish i knew what you were trying to say
2024-12-22 04:30:51 +0100 <orangeflu> when i was trying to understand monads, i thought "after i get this, everything else will be easy, this is the hardest thing ever"
2024-12-22 04:30:52 +0100 <geekosaur> the concept behind ST is a bit difficult to understand, yes
2024-12-22 04:30:55 +0100 <orangeflu> apparently not
2024-12-22 04:32:29 +0100housemate(~housemate@ppp203-122-213-191.static.internode.on.net) (Quit: Nothing to see here. I wasn't there. I take IRC seriously.)
2024-12-22 04:33:08 +0100 <geekosaur> when we talk about threads, we normally talk about CPU threads. ST is a difference concept, a state thread. instead of representing a separate CPU execution environment, it's a separate local state environment. in Haskell this means you have access to mutable data within the thread that can't be accessed outside of it
2024-12-22 04:35:33 +0100 <geekosaur> the best explanation is probably one in the paper linked at the top of the Control.Monad.ST documentation
2024-12-22 04:36:00 +0100 <geekosaur> also, trust me, you haven't by far exhausted the complexities of Haskell
2024-12-22 04:37:49 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 04:37:50 +0100 <geekosaur> rank-N types (which you're on the border of with ST), STM (software transactional memory), type level programming, … the list goes on
2024-12-22 04:38:29 +0100 <orangeflu> you might as well be speaking dutch
2024-12-22 04:41:16 +0100 <geekosaur> that was kinda the point 🙂
2024-12-22 04:42:20 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 04:43:25 +0100 <orangeflu> i am already stuck with this vector
2024-12-22 04:43:43 +0100td_(~td@i53870903.versanet.de) (Ping timeout: 244 seconds)
2024-12-22 04:45:03 +0100alecs(~alecs@61.pool85-58-154.dynamic.orange.es) alecs
2024-12-22 04:45:39 +0100td_(~td@i5387092A.versanet.de) td_
2024-12-22 04:49:24 +0100alecs(~alecs@61.pool85-58-154.dynamic.orange.es) (Ping timeout: 244 seconds)
2024-12-22 04:49:42 +0100 <orangeflu> i can't even create an mvector, it doesn't let me
2024-12-22 04:53:10 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 04:55:13 +0100peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) peterbecich
2024-12-22 04:57:44 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 04:59:12 +0100 <orangeflu> how do i unwrap from ST?
2024-12-22 04:59:37 +0100 <c_wraith> :t runST
2024-12-22 04:59:38 +0100 <lambdabot> (forall s. ST s a) -> a
2024-12-22 05:00:15 +0100 <orangeflu> i thought so too but it doesnt work
2024-12-22 05:00:40 +0100 <c_wraith> it does if you aren't trying to leak things that you're not supposed to
2024-12-22 05:00:48 +0100 <orangeflu> Couldn't match type: M.MVector s Int with: IO a0
2024-12-22 05:00:58 +0100 <orangeflu> leak?
2024-12-22 05:01:14 +0100 <c_wraith> ST is designed to prevent mutable values from leaking into pure code.
2024-12-22 05:01:27 +0100 <c_wraith> but if you're getting an error about IO, you're doing something else wrong.
2024-12-22 05:01:47 +0100 <orangeflu> probably because i am running this in main
2024-12-22 05:04:22 +0100L29Ah(~L29Ah@wikipedia/L29Ah) ()
2024-12-22 05:08:34 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 05:09:12 +0100 <orangeflu> i think i made it work somehow
2024-12-22 05:09:48 +0100 <orangeflu> but i had to make like 3 functions just to set a value and return it, and i lost the vector
2024-12-22 05:11:32 +0100dostoevsky(~dostoevsk@user/dostoevsky) (Quit: Leaving)
2024-12-22 05:13:07 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 265 seconds)
2024-12-22 05:13:30 +0100 <haskellbridge> <thirdofmay18081814goya> hm
2024-12-22 05:13:36 +0100 <haskellbridge> <thirdofmay18081814goya> what's the right way to think of switches in FRP?
2024-12-22 05:13:54 +0100 <haskellbridge> <thirdofmay18081814goya> e.g. if a switch has two possible targets, do we think of it as a function from one signal to two signals?
2024-12-22 05:13:56 +0100 <monochrom> A stream of booleans?
2024-12-22 05:14:22 +0100 <monochrom> If the two signals are mutually exclusive then it is just one signal of two states.
2024-12-22 05:14:56 +0100 <monochrom> or 3 states if they are {0, 1, neither}
2024-12-22 05:15:34 +0100 <haskellbridge> <thirdofmay18081814goya> hm, I'm not sure I understand. don't we think of a switch as changing the target signal?
2024-12-22 05:16:00 +0100 <haskellbridge> <thirdofmay18081814goya> like network switches
2024-12-22 05:16:17 +0100 <monochrom> A long time ago, Shannon already turned switches into logic gates, so still just booleans.
2024-12-22 05:17:16 +0100 <haskellbridge> <thirdofmay18081814goya> we're talking about e.g. Yampa switches here right?
2024-12-22 05:18:26 +0100 <monochrom> Are they really non-isomorphic to relays?
2024-12-22 05:18:56 +0100 <haskellbridge> <thirdofmay18081814goya> I don't know, here's the type "switch :: SF i (o, Event e) -> (e -> SF i o) -> SF i o"
2024-12-22 05:19:00 +0100 <orangeflu> c_wraith: so, if i understand correctly, everywhere i need to modify the mvector, it needs to return ST s (MVector s Int). Just to read it, i need to be in at least ST s Int. Then how do I reconcile that with getting user input and stuff. I have a bunch of other monads i need to think about in my REPL, that need to take input from the user and so on. But if i escape this ST by running through runST, i
2024-12-22 05:19:06 +0100 <orangeflu> lose the vector, right?
2024-12-22 05:23:56 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 05:24:27 +0100machinedgod(~machinedg@d108-173-18-100.abhsia.telus.net) (Ping timeout: 276 seconds)
2024-12-22 05:27:06 +0100aforemny(~aforemny@2001:9e8:6cf6:8000:f088:f772:a53:8f63) (Ping timeout: 246 seconds)
2024-12-22 05:27:45 +0100aforemny(~aforemny@89.244.199.39) aforemny
2024-12-22 05:28:35 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 265 seconds)
2024-12-22 05:30:13 +0100 <c_wraith> orangeflu: The point of ST is that you encapsulate *all* the mutation in a single call to runST. You return an immutable value.
2024-12-22 05:32:43 +0100 <haskellbridge> <Bowuigi> orangeflu you have to create the MVector in IO, not in ST
2024-12-22 05:33:08 +0100 <haskellbridge> <Bowuigi> So you allocate the memory in main as usual, but instead of creating an array you create an MVector
2024-12-22 05:33:21 +0100 <c_wraith> Bowuigi: eh? If you want to mutate it in ST, you need to allocate it in ST.
2024-12-22 05:36:00 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 05:36:01 +0100 <haskellbridge> <Bowuigi> The idea was to have an MVector on IO, not on ST
2024-12-22 05:36:02 +0100 <orangeflu> how do i return an immutable value?
2024-12-22 05:36:30 +0100 <haskellbridge> <Bowuigi> What
2024-12-22 05:36:43 +0100 <c_wraith> Eh, I started answering questions starting from "what's the eliminator for ST"
2024-12-22 05:37:37 +0100 <c_wraith> If you're using IO mutable vectors, ignore everything about ST.
2024-12-22 05:37:37 +0100 <orangeflu> c_wraith said "you return an immutable value". So i go in ST or IO, mutate it however i wish based on what the instruction needs to do, then when i remove it from IO, it becomes immutable?
2024-12-22 05:39:41 +0100 <haskellbridge> <Bowuigi> c_wraith Some context, orangeflu is writing an emulator. This emulator has a fixed memory, which used to be in an Array. This caused space leaks, so I and [exa] suggested using an MVector because it provides benefits on this use case
2024-12-22 05:40:24 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-12-22 05:41:13 +0100 <haskellbridge> <Bowuigi> orangeflu the idea is to run the modifications on IO only (ST also works but it's not what we want here), that's what the "PrimMonad" stuff means
2024-12-22 05:41:18 +0100 <c_wraith> That's a kind of bad way to avoid space leaks. It's better to write code that uses space invariants properly. But it has enough other benefits that it's still worth doing.
2024-12-22 05:41:47 +0100 <c_wraith> (It's likely to not avoid space leaks)
2024-12-22 05:43:35 +0100 <haskellbridge> <Bowuigi> The Array here was used as if it was a mutable one (it was the original idea, but the name Array was somewhat misleading since it isn't a C array)
2024-12-22 05:45:26 +0100housemate(~housemate@124.187.109.206) housemate
2024-12-22 05:49:10 +0100xff0x(~xff0x@p3704193-ipxg12201sapodori.hokkaido.ocn.ne.jp)
2024-12-22 05:50:33 +0100 <orangeflu> well, the idea is to transition to mvectors, but i thought it would be easier. I am also using InputT IO (EmulatorState) in my REPL because i am using haskeline, so not sure how that is going to affect things with mvector. Also, there is also the functionality for reading a file and then ditching the IO after that, before executing
2024-12-22 05:50:50 +0100 <orangeflu> Does that mean now I will need to have IO everywhere?
2024-12-22 05:51:18 +0100peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) (Ping timeout: 265 seconds)
2024-12-22 05:51:38 +0100 <haskellbridge> <Bowuigi> c_wraith you might be able to help more with this, the codebase is in https://github.com/Flu/avr-emulator and the profiling results are in https://paste.tomsmeding.com/b9owLIrr
2024-12-22 05:51:38 +0100 <orangeflu> This seems more trouble than its worth considering I don't even understand how to use, let alone modify all my pure functions into using it atop of my InputT IO stuff
2024-12-22 05:52:25 +0100 <haskellbridge> <Bowuigi> With MVector you need something like IO everywhere yes. Haskell optimization is not for begginners
2024-12-22 05:52:31 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 05:52:47 +0100 <haskellbridge> <Bowuigi> Just like optimization in other languages ofc
2024-12-22 05:53:42 +0100 <haskellbridge> <Bowuigi> There might be a more obvious refactor that we missed tho
2024-12-22 05:54:35 +0100 <orangeflu> i'm sure i did a horrible job of writing this and there are a bunch of stuff that make no sense or could be optimized heavily
2024-12-22 05:55:02 +0100 <orangeflu> thing is, this is both a learning project and something that i want to be useful
2024-12-22 05:55:39 +0100xff0x(~xff0x@p3704193-ipxg12201sapodori.hokkaido.ocn.ne.jp) (Ping timeout: 265 seconds)
2024-12-22 05:56:01 +0100rvalue(~rvalue@user/rvalue) (Read error: Connection reset by peer)
2024-12-22 05:56:06 +0100 <haskellbridge> <Bowuigi> MVector is a somewhat extreme solution, mutable stuff is fairly common in heavily optimized programs/libraries like smalltt or flatparse (there are a lot more examples but I know those two more in depth than anything else)
2024-12-22 05:56:33 +0100rvalue(~rvalue@user/rvalue) rvalue
2024-12-22 05:57:03 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 05:58:10 +0100 <haskellbridge> <Bowuigi> Hmmm moving to a strict state monad to handle your emulator state could also help. It attacks space leaks more directly and is a smaller change
2024-12-22 05:58:10 +0100housemate(~housemate@124.187.109.206) (Quit: Nothing to see here. I wasn't there. I take IRC seriously.)
2024-12-22 06:00:55 +0100 <orangeflu> i know what a state monad is, i think. like, if i have a function, that takes a container and returns a modified container and a result, i can chain them together with do notation. that's what i understand anyway. But how is that different from what i'm doing now? except for the fact that i don't chain them in a do block (which wouldn't be useful anyway, cause i don't execute instructions that way
2024-12-22 06:01:02 +0100 <orangeflu> anyway)
2024-12-22 06:02:43 +0100 <haskellbridge> <Bowuigi> Passing state around in a strict way, along with nice syntax sugar is what this is supposed to do
2024-12-22 06:03:41 +0100housemate(~housemate@124.187.109.206) housemate
2024-12-22 06:03:41 +0100 <orangeflu> when you say 'strict', do you mean not lazily?
2024-12-22 06:04:16 +0100 <haskellbridge> <Bowuigi> Yes, but not eagerly either
2024-12-22 06:05:18 +0100 <orangeflu> c_wraith: what do you think about the project?
2024-12-22 06:05:18 +0100califax(~califax@user/califx) (Remote host closed the connection)
2024-12-22 06:05:18 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2024-12-22 06:05:35 +0100califax(~califax@user/califx) califx
2024-12-22 06:05:41 +0100ChaiTRex(~ChaiTRex@user/chaitrex) ChaiTRex
2024-12-22 06:05:55 +0100peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) peterbecich
2024-12-22 06:06:35 +0100 <haskellbridge> <Bowuigi> "Eager" is "fully evaluate", "Strict" is "evaluate only what I'm directly responsible for" and "Lazy" is "evaluate only what I will pattern match on, as I pattern match on it". Or at least that seems to be the general consensus
2024-12-22 06:07:30 +0100 <orangeflu> and why is the laziness causing me space leaks while strictness wouldn't?
2024-12-22 06:07:52 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 06:08:37 +0100 <haskellbridge> <Bowuigi> Space leaks are caused by duplication of code, code is duplicated wherever variables are duplicated in lazy evaluation
2024-12-22 06:09:37 +0100 <haskellbridge> <Bowuigi> Strict evaluation would evaluate the value once and possibly duplicate other computations inside that value
2024-12-22 06:10:10 +0100Guest78(~Guest78@37.228.252.73) (Ping timeout: 240 seconds)
2024-12-22 06:10:45 +0100Guest78(~Guest78@213.233.155.134)
2024-12-22 06:10:45 +0100 <monochrom> Ugh no, strictness is a denotational notion, not an operational (evaluation) notion. A strict function means f bottom = bottom.
2024-12-22 06:11:46 +0100 <haskellbridge> <Bowuigi> So what do you call the operational notion?
2024-12-22 06:12:02 +0100 <monochrom> denotational means you only talk about whether you get an answer and what answer if yes, it deliberately avoids how the computer manages to do it.
2024-12-22 06:12:09 +0100 <monochrom> eager and lazy
2024-12-22 06:12:19 +0100 <haskellbridge> <Bowuigi> That's why I prefer working with total languages lol
2024-12-22 06:12:34 +0100 <haskellbridge> <Bowuigi> Oh there we go
2024-12-22 06:12:44 +0100chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2024-12-22 06:13:16 +0100chexum(~quassel@gateway/tor-sasl/chexum) chexum
2024-12-22 06:13:16 +0100 <monochrom> there is also speculative evaluation, it can result in non-strict while being even more eager than eager.
2024-12-22 06:13:46 +0100 <monochrom> So even the "eager : lazy :: strict : non-strict" "correspondence" is easily broken.
2024-12-22 06:14:59 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 265 seconds)
2024-12-22 06:15:40 +0100 <haskellbridge> <Bowuigi> So the duplication is operational right?
2024-12-22 06:16:58 +0100 <monochrom> Yes absolutely. If you want to predict how much time and how much space are spent, they emphatically require knowing the evaluation strategy, i.e., operational.
2024-12-22 06:17:32 +0100 <monochrom> Denotational semantics strives to (even prides in) avoid talking about them.
2024-12-22 06:17:42 +0100poscat(~poscat@user/poscat) (Read error: Connection reset by peer)
2024-12-22 06:17:53 +0100poscat0x04(~poscat@user/poscat) poscat
2024-12-22 06:21:38 +0100 <haskellbridge> <Bowuigi> I see, yeah Haskell can be hard to understand sometimes lol
2024-12-22 06:23:54 +0100 <monochrom> Having said that, if you say you are only using GHC, then you know it almost sticks to "use lazy for non-strict, use eager for strict". But there are occasional deviations when the code optimizer thinks it's more efficient to do it some other way.
2024-12-22 06:25:14 +0100ryanbooker(uid4340@id-4340.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2024-12-22 06:25:54 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 06:30:30 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 06:33:05 +0100tnt1(~Thunderbi@user/tnt1) (Ping timeout: 248 seconds)
2024-12-22 06:39:28 +0100tnt1(~Thunderbi@user/tnt1) tnt1
2024-12-22 06:41:18 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 06:44:30 +0100CrunchyFlakes(~CrunchyFl@ip1f13e94e.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2024-12-22 06:46:10 +0100alecs(~alecs@61.pool85-58-154.dynamic.orange.es) alecs
2024-12-22 06:46:21 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 276 seconds)
2024-12-22 06:47:00 +0100CrunchyFlakes(~CrunchyFl@31.19.233.78)
2024-12-22 06:50:45 +0100alecs(~alecs@61.pool85-58-154.dynamic.orange.es) (Ping timeout: 265 seconds)
2024-12-22 06:56:40 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 07:00:22 +0100housemate_(~housemate@124.187.109.206) housemate
2024-12-22 07:01:23 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 265 seconds)
2024-12-22 07:01:56 +0100tnt2(~Thunderbi@user/tnt1) tnt1
2024-12-22 07:02:50 +0100housemate(~housemate@124.187.109.206) (Ping timeout: 265 seconds)
2024-12-22 07:03:21 +0100housemate_(~housemate@124.187.109.206) (Remote host closed the connection)
2024-12-22 07:03:30 +0100tnt1(~Thunderbi@user/tnt1) (Ping timeout: 252 seconds)
2024-12-22 07:03:30 +0100tnt2tnt1
2024-12-22 07:12:03 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 07:14:22 +0100tnt2(~Thunderbi@user/tnt1) tnt1
2024-12-22 07:15:24 +0100tnt1(~Thunderbi@user/tnt1) (Ping timeout: 265 seconds)
2024-12-22 07:15:24 +0100tnt2tnt1
2024-12-22 07:16:39 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 07:27:25 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 07:27:55 +0100agent314(~quassel@149.40.50.111) agent314
2024-12-22 07:31:44 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 07:37:00 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 07:41:38 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 07:43:06 +0100hiredman(~hiredman@frontier1.downey.family) hiredman
2024-12-22 07:43:51 +0100youthlic(~Thunderbi@user/youthlic) youthlic
2024-12-22 07:44:54 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2024-12-22 07:50:40 +0100Guest78(~Guest78@213.233.155.134) (Ping timeout: 240 seconds)
2024-12-22 07:52:23 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 07:54:34 +0100gorignak(~gorignak@user/gorignak) gorignak
2024-12-22 08:00:59 +0100jaava(~nick@syn-076-035-209-158.res.spectrum.com)
2024-12-22 08:01:05 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 248 seconds)
2024-12-22 08:01:59 +0100 <jaava> hi discovered haskell through xmonad but now i'm curious about using it for other things
2024-12-22 08:02:48 +0100 <jaava> is haskell good for physics simulations where one would probably lean towards c++, fortran or python depending on the use case?
2024-12-22 08:09:12 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2024-12-22 08:12:15 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 08:16:49 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 08:20:55 +0100flukiluke(~m-7humut@2603:c023:c000:6c7e:8945:ad24:9113:a962) (Remote host closed the connection)
2024-12-22 08:22:11 +0100flukiluke(~m-7humut@2603:c023:c000:6c7e:8945:ad24:9113:a962) flukiluke
2024-12-22 08:23:05 +0100ephilalethes(~noumenon@202.186.203.84) noumenon
2024-12-22 08:28:08 +0100 <iqubic> Looks like Hoogle is down right now due to an SSL handshake failure.
2024-12-22 08:28:37 +0100 <iqubic> Oh, refreshing seems to have fixed it.
2024-12-22 08:29:54 +0100 <iqubic> Actually, it seems a bit inconsistent right now.
2024-12-22 08:31:17 +0100 <jaava> I didn't know hoogle was a thing
2024-12-22 08:31:30 +0100peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) (Ping timeout: 252 seconds)
2024-12-22 08:31:32 +0100 <iqubic> hoogle is great
2024-12-22 08:31:37 +0100 <iqubic> @whereis hoogle
2024-12-22 08:31:37 +0100 <lambdabot> Maybe you meant: where+ where
2024-12-22 08:31:44 +0100 <iqubic> @where hoogle
2024-12-22 08:31:44 +0100 <lambdabot> https://hoogle.haskell.org
2024-12-22 08:32:02 +0100 <jaava> nice thanks
2024-12-22 08:32:22 +0100 <iqubic> If you have a question of "do any functions exist that match a given type signature?" that's a really useful tool.
2024-12-22 08:32:30 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 08:32:42 +0100 <jaava> there's so much software for haskell I can't believe no one ever talks about it. at least in my world
2024-12-22 08:36:44 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 08:36:56 +0100N0ping(~N0ping@31-208-56-179.cust.bredband2.com)
2024-12-22 08:38:05 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 08:39:39 +0100jaava(~nick@syn-076-035-209-158.res.spectrum.com) (Quit: Lost terminal)
2024-12-22 08:41:34 +0100jaava(~nick@syn-076-035-209-158.res.spectrum.com)
2024-12-22 08:42:25 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 08:47:51 +0100monochrom(trebla@216.138.220.146) (Read error: Connection reset by peer)
2024-12-22 08:48:01 +0100monochrm(trebla@216.138.220.146)
2024-12-22 08:48:25 +0100monochrmmonochrom
2024-12-22 08:51:24 +0100xff0x(~xff0x@p3704193-ipxg12201sapodori.hokkaido.ocn.ne.jp)
2024-12-22 08:53:23 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 08:53:25 +0100ubert(~Thunderbi@p200300ecdf117cbda8ce35cba2c9a19e.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
2024-12-22 08:57:55 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 09:00:03 +0100caconym(~caconym@user/caconym) (Quit: bye)
2024-12-22 09:00:08 +0100tt12310978324354(~tt1231@2603:6010:8700:4a81:219f:50d3:618a:a6ee) (Quit: The Lounge - https://thelounge.chat)
2024-12-22 09:00:40 +0100caconym(~caconym@user/caconym) caconym
2024-12-22 09:01:26 +0100target_i(~target_i@user/target-i/x-6023099) target_i
2024-12-22 09:02:10 +0100N0ping(~N0ping@31-208-56-179.cust.bredband2.com) (Ping timeout: 240 seconds)
2024-12-22 09:03:53 +0100tt12310978324354(~tt1231@2603:6010:8700:4a81:219f:50d3:618a:a6ee) tt1231
2024-12-22 09:05:23 +0100housemate(~housemate@124.187.109.206) housemate
2024-12-22 09:06:49 +0100housemate(~housemate@124.187.109.206) (Remote host closed the connection)
2024-12-22 09:09:41 +0100housemate(~housemate@124.187.109.206) housemate
2024-12-22 09:13:44 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 09:16:08 +0100img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2024-12-22 09:17:28 +0100img(~img@user/img) img
2024-12-22 09:18:29 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 248 seconds)
2024-12-22 09:21:14 +0100weary-traveler(~user@user/user363627) (Remote host closed the connection)
2024-12-22 09:28:57 +0100 <hellwolf> which one do you use the most.
2024-12-22 09:29:08 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 09:30:23 +0100tzh(~tzh@c-76-115-131-146.hsd1.or.comcast.net) (Quit: zzz)
2024-12-22 09:33:34 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 09:39:02 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 09:44:38 +0100xff0x(~xff0x@p3704193-ipxg12201sapodori.hokkaido.ocn.ne.jp) (Ping timeout: 244 seconds)
2024-12-22 09:45:48 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 245 seconds)
2024-12-22 09:46:16 +0100jaava(~nick@syn-076-035-209-158.res.spectrum.com) (Quit: Lost terminal)
2024-12-22 09:48:17 +0100jaava(~nick@syn-076-035-209-158.res.spectrum.com)
2024-12-22 09:49:50 +0100jaava(~nick@syn-076-035-209-158.res.spectrum.com) (Client Quit)
2024-12-22 09:51:50 +0100acidjnk_new(~acidjnk@p200300d6e7283f49b5be3bacf47f1ed3.dip0.t-ipconnect.de) acidjnk
2024-12-22 09:57:03 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 09:57:44 +0100jaava(~nick@syn-076-035-209-158.res.spectrum.com)
2024-12-22 10:03:45 +0100jaava(~nick@syn-076-035-209-158.res.spectrum.com) (Quit: Lost terminal)
2024-12-22 10:03:57 +0100Guest78(~Guest78@64.43.50.117)
2024-12-22 10:04:34 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 265 seconds)
2024-12-22 10:15:25 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 10:19:49 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 248 seconds)
2024-12-22 10:22:30 +0100yuuta(~YuutaW@2404:f4c0:f9c3:502::100:17b7) (Ping timeout: 246 seconds)
2024-12-22 10:22:55 +0100L29Ah(~L29Ah@wikipedia/L29Ah) L29Ah
2024-12-22 10:26:06 +0100YuutaW(~YuutaW@2404:f4c0:f9c3:502::100:17b7) YuutaW
2024-12-22 10:30:48 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 10:36:18 +0100housemate(~housemate@124.187.109.206) (Quit: Nothing to see here. I wasn't there. I take IRC seriously.)
2024-12-22 10:36:36 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 10:40:06 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 10:41:32 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2024-12-22 10:41:36 +0100tnt2(~Thunderbi@user/tnt1) tnt1
2024-12-22 10:42:17 +0100tnt1(~Thunderbi@user/tnt1) (Ping timeout: 244 seconds)
2024-12-22 10:42:17 +0100tnt2tnt1
2024-12-22 10:44:22 +0100ephilalethes(~noumenon@202.186.203.84) (Quit: Leaving)
2024-12-22 10:44:50 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 272 seconds)
2024-12-22 10:54:01 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 10:57:07 +0100sawilagar(~sawilagar@user/sawilagar) sawilagar
2024-12-22 10:58:18 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 11:00:57 +0100econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2024-12-22 11:02:32 +0100__monty__(~toonn@user/toonn) toonn
2024-12-22 11:06:03 +0100ljdarj(~Thunderbi@user/ljdarj) ljdarj
2024-12-22 11:09:23 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 11:11:46 +0100l_k(~student@46.61.242.35)
2024-12-22 11:13:41 +0100student(~student@85.172.111.189) (Ping timeout: 265 seconds)
2024-12-22 11:14:09 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 248 seconds)
2024-12-22 11:17:32 +0100xff0x(~xff0x@p3704193-ipxg12201sapodori.hokkaido.ocn.ne.jp)
2024-12-22 11:19:03 +0100Tuplanolla(~Tuplanoll@91-159-69-59.elisa-laajakaista.fi) Tuplanolla
2024-12-22 11:23:59 +0100ash3en(~Thunderbi@2a03:7846:b6eb:101:93ac:a90a:da67:f207) ash3en
2024-12-22 11:24:46 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 11:29:18 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 11:35:55 +0100ljdarj(~Thunderbi@user/ljdarj) (Ping timeout: 265 seconds)
2024-12-22 11:38:25 +0100ash3en(~Thunderbi@2a03:7846:b6eb:101:93ac:a90a:da67:f207) (Quit: ash3en)
2024-12-22 11:40:10 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 11:41:29 +0100sprotte24(~sprotte24@p200300d16f236f0034c2c833107a461e.dip0.t-ipconnect.de)
2024-12-22 11:47:33 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 272 seconds)
2024-12-22 11:57:57 +0100Lain_(~Lain@102.211.6.62)
2024-12-22 11:58:11 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 11:58:54 +0100driib318(~driib@vmi931078.contaboserver.net) (Quit: The Lounge - https://thelounge.chat)
2024-12-22 11:59:17 +0100Lain_(~Lain@102.211.6.62) (Remote host closed the connection)
2024-12-22 12:00:12 +0100Piedro(~Piedro@213.226.141.133) Piedro
2024-12-22 12:00:14 +0100driib318(~driib@vmi931078.contaboserver.net) driib
2024-12-22 12:01:58 +0100Square(~Square@user/square) (Ping timeout: 252 seconds)
2024-12-22 12:02:49 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 260 seconds)
2024-12-22 12:04:24 +0100driib318(~driib@vmi931078.contaboserver.net) (Client Quit)
2024-12-22 12:05:14 +0100alexherbo2(~alexherbo@2a02-8440-350e-cece-a50d-b49e-108d-0242.rev.sfr.net) alexherbo2
2024-12-22 12:06:14 +0100ljdarj(~Thunderbi@user/ljdarj) ljdarj
2024-12-22 12:06:21 +0100machinedgod(~machinedg@d108-173-18-100.abhsia.telus.net) machinedgod
2024-12-22 12:08:51 +0100driib318(~driib@vmi931078.contaboserver.net) driib
2024-12-22 12:10:42 +0100sawilagar(~sawilagar@user/sawilagar) (Ping timeout: 276 seconds)
2024-12-22 12:13:33 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 12:15:13 +0100CiaoSen(~Jura@2a05:5800:2da:8900:ca4b:d6ff:fec1:99da) CiaoSen
2024-12-22 12:17:52 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 12:20:48 +0100homo_(~homo@37-33-152-6.bb.dnainternet.fi)
2024-12-22 12:21:07 +0100homo_(~homo@37-33-152-6.bb.dnainternet.fi) (Changing host)
2024-12-22 12:21:07 +0100homo_(~homo@user/homo) homo
2024-12-22 12:23:33 +0100CiaoSen(~Jura@2a05:5800:2da:8900:ca4b:d6ff:fec1:99da) (Ping timeout: 248 seconds)
2024-12-22 12:24:42 +0100homo(~homo@user/homo) (Ping timeout: 252 seconds)
2024-12-22 12:26:08 +0100homo_homo
2024-12-22 12:27:07 +0100homo_(~homo@37-33-136-207.bb.dnainternet.fi)
2024-12-22 12:28:54 +0100homo_(~homo@37-33-136-207.bb.dnainternet.fi) (Changing host)
2024-12-22 12:28:54 +0100homo_(~homo@user/homo) homo
2024-12-22 12:28:55 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 12:30:15 +0100homo(~homo@user/homo) (Ping timeout: 246 seconds)
2024-12-22 12:30:21 +0100homo_homo
2024-12-22 12:30:40 +0100Piedro(~Piedro@213.226.141.133) (Ping timeout: 240 seconds)
2024-12-22 12:32:27 +0100housemate(~housemate@124.187.109.206) housemate
2024-12-22 12:33:24 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-12-22 12:39:33 +0100gmg(~user@user/gehmehgeh) gehmehgeh
2024-12-22 12:41:10 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 12:45:53 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 248 seconds)
2024-12-22 12:47:50 +0100housemate(~housemate@124.187.109.206) (Quit: Nothing to see here. I wasn't there. I take IRC seriously.)
2024-12-22 12:51:19 +0100sawilagar(~sawilagar@user/sawilagar) sawilagar
2024-12-22 12:51:39 +0100pavonia(~user@user/siracusa) siracusa
2024-12-22 12:54:23 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2024-12-22 12:56:31 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 13:01:00 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 13:03:04 +0100youthlic(~Thunderbi@user/youthlic) (Quit: youthlic)
2024-12-22 13:04:06 +0100mrmr155334346318(~mrmr@user/mrmr) (Quit: Bye, See ya later!)
2024-12-22 13:04:22 +0100Guest78(~Guest78@64.43.50.117) (Quit: Client closed)
2024-12-22 13:11:54 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 13:16:27 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 265 seconds)
2024-12-22 13:17:23 +0100alexherbo2(~alexherbo@2a02-8440-350e-cece-a50d-b49e-108d-0242.rev.sfr.net) (Remote host closed the connection)
2024-12-22 13:27:16 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 13:27:44 +0100wootehfoot(~wootehfoo@user/wootehfoot) wootehfoot
2024-12-22 13:31:56 +0100lxsameer(~lxsameer@Serene/lxsameer) lxsameer
2024-12-22 13:32:02 +0100son0p(~ff@186.121.98.118) (Ping timeout: 272 seconds)
2024-12-22 13:34:00 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 13:35:29 +0100mrmr155334346318(~mrmr@user/mrmr) mrmr
2024-12-22 13:42:10 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 13:46:44 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 13:47:14 +0100alexherbo2(~alexherbo@2a02-8440-350e-cece-fc33-ab37-4fc7-9825.rev.sfr.net) alexherbo2
2024-12-22 13:49:49 +0100ljdarj(~Thunderbi@user/ljdarj) (Quit: ljdarj)
2024-12-22 13:50:14 +0100ljdarj(~Thunderbi@user/ljdarj) ljdarj
2024-12-22 13:57:32 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 14:02:26 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 272 seconds)
2024-12-22 14:04:26 +0100agent314(~quassel@149.40.50.111) (Ping timeout: 252 seconds)
2024-12-22 14:08:40 +0100califax_(~califax@user/califx) califx
2024-12-22 14:08:58 +0100califax(~califax@user/califx) (Remote host closed the connection)
2024-12-22 14:09:54 +0100califax_califax
2024-12-22 14:11:46 +0100kronicmage(~kronicmag@neotame.csclub.uwaterloo.ca) (Ping timeout: 252 seconds)
2024-12-22 14:12:54 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 14:15:36 +0100tnt2(~Thunderbi@user/tnt1) tnt1
2024-12-22 14:15:40 +0100tnt1(~Thunderbi@user/tnt1) (Ping timeout: 244 seconds)
2024-12-22 14:15:40 +0100tnt2tnt1
2024-12-22 14:18:06 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 276 seconds)
2024-12-22 14:25:36 +0100michalz(~michalz@185.246.207.203)
2024-12-22 14:28:16 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 14:30:40 +0100son0p(~ff@186.121.98.118) son0p
2024-12-22 14:33:06 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-12-22 14:38:45 +0100ft(~ft@p508db070.dip0.t-ipconnect.de) (Quit: leaving)
2024-12-22 14:38:57 +0100ft(~ft@p508db070.dip0.t-ipconnect.de) ft
2024-12-22 14:40:34 +0100ft(~ft@p508db070.dip0.t-ipconnect.de) (Client Quit)
2024-12-22 14:40:45 +0100ft(~ft@p508db070.dip0.t-ipconnect.de) ft
2024-12-22 14:43:09 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 14:47:42 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 14:50:41 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2024-12-22 14:52:57 +0100ash3en(~Thunderbi@2a03:7846:b6eb:101:93ac:a90a:da67:f207) ash3en
2024-12-22 14:58:33 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 15:05:25 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 15:08:11 +0100alexherbo2(~alexherbo@2a02-8440-350e-cece-fc33-ab37-4fc7-9825.rev.sfr.net) (Remote host closed the connection)
2024-12-22 15:11:55 +0100ash3en(~Thunderbi@2a03:7846:b6eb:101:93ac:a90a:da67:f207) (Quit: ash3en)
2024-12-22 15:13:20 +0100lxsameer(~lxsameer@Serene/lxsameer) (Ping timeout: 264 seconds)
2024-12-22 15:15:05 +0100machinedgod(~machinedg@d108-173-18-100.abhsia.telus.net) (Ping timeout: 244 seconds)
2024-12-22 15:16:36 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 15:21:37 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 272 seconds)
2024-12-22 15:22:32 +0100zenmov(~zenmov@user/zenmov) zenmov
2024-12-22 15:26:57 +0100Digit(~user@user/digit) (Ping timeout: 265 seconds)
2024-12-22 15:27:55 +0100Smiles(uid551636@id-551636.lymington.irccloud.com) Smiles
2024-12-22 15:31:57 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 15:35:21 +0100ljdarj(~Thunderbi@user/ljdarj) (Ping timeout: 252 seconds)
2024-12-22 15:36:28 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 15:42:39 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 15:43:16 +0100manwithluck(~manwithlu@194.177.28.164) manwithluck
2024-12-22 15:45:30 +0100ljdarj(~Thunderbi@user/ljdarj) ljdarj
2024-12-22 15:47:12 +0100xff0x(~xff0x@p3704193-ipxg12201sapodori.hokkaido.ocn.ne.jp) (Ping timeout: 252 seconds)
2024-12-22 15:48:22 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 15:51:08 +0100ash3en(~Thunderbi@2a03:7846:b6eb:101:93ac:a90a:da67:f207) ash3en
2024-12-22 15:59:18 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 16:03:25 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2024-12-22 16:04:10 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 265 seconds)
2024-12-22 16:06:02 +0100lxsameer(~lxsameer@Serene/lxsameer) lxsameer
2024-12-22 16:07:42 +0100JuanDaugherty(~juan@user/JuanDaugherty) JuanDaugherty
2024-12-22 16:14:40 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 16:18:40 +0100JuanDaugherty(~juan@user/JuanDaugherty) (Ping timeout: 265 seconds)
2024-12-22 16:19:09 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-12-22 16:30:04 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 16:31:38 +0100 <haskellbridge> <thirdofmay18081814goya> I recall reading somewhere that modal types are given by monads
2024-12-22 16:31:49 +0100 <haskellbridge> <thirdofmay18081814goya> can Haskell monads simulate modal types?
2024-12-22 16:32:17 +0100ljdarj(~Thunderbi@user/ljdarj) (Ping timeout: 244 seconds)
2024-12-22 16:33:26 +0100JuanDaugherty(~juan@user/JuanDaugherty) JuanDaugherty
2024-12-22 16:34:57 +0100 <ncf> do you mean anything precise by that
2024-12-22 16:35:04 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 272 seconds)
2024-12-22 16:36:08 +0100 <haskellbridge> <thirdofmay18081814goya> well this could be a way to make that precise: a monad-encoding of a modal type is inhabited iff it's corresponding modal type is inhabited
2024-12-22 16:38:00 +0100 <albet70> hello everyone
2024-12-22 16:39:21 +0100ljdarj(~Thunderbi@user/ljdarj) ljdarj
2024-12-22 16:40:29 +0100 <albet70> how to share or passing one variable between two async function? like there are async function f and g, jump between f and g with one variable so that f and g can both modify
2024-12-22 16:45:09 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 16:47:13 +0100 <geekosaur> STM is the usual method
2024-12-22 16:47:25 +0100Digit(~user@user/digit) Digit
2024-12-22 16:51:32 +0100lxsameer(~lxsameer@Serene/lxsameer) (Ping timeout: 265 seconds)
2024-12-22 16:51:42 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 16:52:13 +0100 <probie> If it's just a single variable, `MVar`s might be sufficient
2024-12-22 16:53:03 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2024-12-22 16:59:03 +0100 <albet70> what mvar is based on?
2024-12-22 16:59:54 +0100 <geekosaur> it's a primitive synchronization variable
2024-12-22 17:00:08 +0100 <geekosaur> well, not primitive, MutVar# is the primitive
2024-12-22 17:00:26 +0100 <geekosaur> but it's a very low level thing
2024-12-22 17:01:15 +0100 <int-e> MutVar# != MVar# (MutVar# is STRef/IORef)
2024-12-22 17:01:21 +0100 <ski> thirdofmay18081814goya : "possible"-type modalities would be the ones which could be monadic, while "neccesary"-type ones could be comonadic
2024-12-22 17:02:09 +0100 <albet70> I learned scheme a few years ago, I saw a article about call/cc to do coroutine, it can jump between two functions with variable, but I can't find that article now
2024-12-22 17:02:25 +0100 <geekosaur> anyway, AIUI one shared var in entire program is atomicModifyIORef, one shared between two given threads is MVar, anything more requires something more complex and STM is preferred these days
2024-12-22 17:02:54 +0100 <geekosaur> otherwise you risk deadlocks
2024-12-22 17:03:12 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 17:03:14 +0100 <int-e> . o O ( deadlocks are bad, let's starve instead )
2024-12-22 17:03:23 +0100 <albet70> like it capture k1 inside f, then call g with k1, then capture g's rest as k2, it jumps to k1 with k2
2024-12-22 17:04:26 +0100 <albet70> what that is called?
2024-12-22 17:07:11 +0100 <haskellbridge> <thirdofmay18081814goya> ski: I see! ty
2024-12-22 17:07:45 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 248 seconds)
2024-12-22 17:18:35 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 17:18:55 +0100swistak(~swistak@185.21.216.141) (Quit: bye bye)
2024-12-22 17:19:01 +0100roosterphant_(~roosterph@185.21.217.76) (Remote host closed the connection)
2024-12-22 17:19:12 +0100swistak(~swistak@185.21.216.141)
2024-12-22 17:19:24 +0100roosterphant(~roosterph@185.21.217.76)
2024-12-22 17:20:50 +0100alecs(~alecs@61.pool85-58-154.dynamic.orange.es) alecs
2024-12-22 17:22:54 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 17:25:07 +0100alecs(~alecs@61.pool85-58-154.dynamic.orange.es) (Ping timeout: 252 seconds)
2024-12-22 17:25:19 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2024-12-22 17:31:17 +0100 <ski> thirdofmay18081814goya : if `<>' represents "possibility" of some kind (alethic ("possible"), temporal ("sometimes","eventually/later","earlier/before"), epistemic ("is consistent with my knowledge / might hold for all i know"), doxastic ("is consistent with my belief", deontic ("permissible"), provability ("is consistent with derivability in the formal system"), ..), then if we assume `A |- B' holds, then
2024-12-22 17:31:23 +0100 <ski> we can derive `A |- <> B' (under the condition of `A', `B' holds, so `B' is possible), and then we can derive `<> A |- <> B' (should `A' hold only possibly, `B' will then still hold possibly). first step is monadic unit
2024-12-22 17:32:15 +0100 <ski> (`return'). second step is monadic extension (`(=<<)', `(>>=)'/"bind")
2024-12-22 17:33:57 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 17:37:28 +0100 <ski> thirdofmay18081814goya : if `[]' represents "necessity" of some kind (alethic ("necessary"), temporal ("always","henceforth/hereafter","hitherto/heretofore"), epistemic ("is known by me"), doxastic ("is believed by me", deontic ("obligatory"), provability ("is provable in the formal system"), ..), then if we assume `A |- B' holds, then we can derive `[] A |- B' (under the stronger condition of `A' holding
2024-12-22 17:37:34 +0100 <ski> necessarily, `A' still holds, so `B' is also still holds), and then we can derive `[] A |- [] B' (when `A' holds even necessarily, `B' will then also hold necessarily). first step is comonadic unit (`extract'). second step is comonadic "preservation" (`(<<=)', `(=>>)')
2024-12-22 17:38:15 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-12-22 17:38:36 +0100gmg(~user@user/gehmehgeh) (Ping timeout: 264 seconds)
2024-12-22 17:39:48 +0100tnt2(~Thunderbi@user/tnt1) tnt1
2024-12-22 17:40:17 +0100tnt1(~Thunderbi@user/tnt1) (Ping timeout: 248 seconds)
2024-12-22 17:40:18 +0100tnt2tnt1
2024-12-22 17:40:29 +0100 <ski> more generally, one can have a rule that if `[] Gamma |- A' (where `Gamma' is a collection of hypotheses considered conjunctively, and `[] Gamma' means `[]' applied to each one of them, individually), then `[] Gamma |- [] A' (or even : if `[] Gamma |- A , <> Delta', then `[] Gamma |- [] A , <> Delta', where `Delta' is a collection taken disjunctively (`,' on the right of `|-' means "or" roughly, while to the
2024-12-22 17:40:35 +0100 <ski> left it means "and" roughly))
2024-12-22 17:42:45 +0100 <ski> and, symmetrically, we can have a rule that if `[] Gamma , A |- <> Delta', then `[] Gamma , <> A |- <> Delta'
2024-12-22 17:44:37 +0100toch(toch@user/toch) (Quit: WeeChat 4.5.0)
2024-12-22 17:44:38 +0100 <ski> (or, if we want to restrict to single conclusions, just : if `[] Gamma , A |- <> B', then `[] Gamma , <> A |- <> B')
2024-12-22 17:45:19 +0100toch(toch@user/toch) toch
2024-12-22 17:45:37 +0100 <haskellbridge> <thirdofmay18081814goya> woah thank you very much for the extensive comments! I'm studying these
2024-12-22 17:45:51 +0100 <ski> albet70 : sounds like coroutines
2024-12-22 17:46:10 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 17:49:34 +0100 <albet70> ski , but that coroutine passing variable between two functions
2024-12-22 17:50:25 +0100 <albet70> or say passing function inside context into another function
2024-12-22 17:50:38 +0100econo_(uid147250@id-147250.tinside.irccloud.com)
2024-12-22 17:50:48 +0100 <albet70> how to archive that with async?
2024-12-22 17:51:04 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 272 seconds)
2024-12-22 17:53:36 +0100 <ski> thirdofmay18081814goya : from what i've seen, it's more common for formalize modal logics in axiomatic / Hilbert-style (with possible axioms like `[] A |- A',`[] A |- [] [] A',`A |- [] <> A',`[] A |- <> A',`<> A |- [] <> A ',&c. depending on the particular modal logic in question that we're formalizing), rather than in a natural deduction, or in a sequent calculus (what i sketched above) style
2024-12-22 17:55:00 +0100tnt2(~Thunderbi@user/tnt1) tnt1
2024-12-22 17:55:03 +0100tnt1(~Thunderbi@user/tnt1) (Ping timeout: 246 seconds)
2024-12-22 17:55:03 +0100tnt2tnt1
2024-12-22 17:56:19 +0100 <ski> albet70 : dunno whether it'd be reasonable with `async'. passing data (and not just the frozen control point) as "baton" back and forth between coroutines requires them to know about each other, or at least about the interface of the other(s), so would seem to assume synchronous communication
2024-12-22 17:57:02 +0100Smiles(uid551636@id-551636.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2024-12-22 17:58:28 +0100 <ski> albet70 : btw, i literally did the "like it capture k1 inside f, then call g with k1, then capture g's rest as k2, it jumps to k1 with k2" thing, in Haskell, to do coroutines, to be able to jump back and forth between two parallel (and a priori independent) traversals of two data structures, combining their data "pointwise"/"coordinatewise"/"in lockstep"
2024-12-22 17:59:50 +0100rvalue(~rvalue@user/rvalue) (Read error: Connection reset by peer)
2024-12-22 18:00:21 +0100rvalue(~rvalue@user/rvalue) rvalue
2024-12-22 18:00:33 +0100tnt2(~Thunderbi@user/tnt1) tnt1
2024-12-22 18:01:32 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 18:01:40 +0100tnt1(~Thunderbi@user/tnt1) (Ping timeout: 252 seconds)
2024-12-22 18:01:40 +0100tnt2tnt1
2024-12-22 18:06:15 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 276 seconds)
2024-12-22 18:07:02 +0100machinedgod(~machinedg@d108-173-18-100.abhsia.telus.net) machinedgod
2024-12-22 18:07:33 +0100toch(toch@user/toch) (Ping timeout: 248 seconds)
2024-12-22 18:09:28 +0100sinbad(~sinbad@user/sinbad) Sinbad
2024-12-22 18:09:39 +0100toch(toch@user/toch) toch
2024-12-22 18:10:54 +0100gmg(~user@user/gehmehgeh) gehmehgeh
2024-12-22 18:11:33 +0100 <sinbad> How can I parse an empty line ("/n/n") between non-empty lines using readP?
2024-12-22 18:13:33 +0100ash3en(~Thunderbi@2a03:7846:b6eb:101:93ac:a90a:da67:f207) (Ping timeout: 244 seconds)
2024-12-22 18:22:46 +0100 <c_wraith> Usually you approach it from the other direction
2024-12-22 18:23:23 +0100 <c_wraith> match the newlines in the stuff you care about. throw a (char '\n') parser between them.
2024-12-22 18:23:50 +0100 <c_wraith> Note that you need to be using backslashes (\) for escape codes, not forward slashes (/)
2024-12-22 18:24:48 +0100 <sinbad> c_wraith: yes I should have used \
2024-12-22 18:25:11 +0100 <probie> Assuming you already know the last line wasn't empty, perhaps something like `count 2 (char "\n") >> look >>= \case { ('\n':_) -> pfail; _ -> pure () }`
2024-12-22 18:26:22 +0100 <c_wraith> Here's my day 19 aoc parser. It literally matches (string "\n\n") at one point. https://github.com/chowells79/aoc/blob/main/2024/Day19.hs#L21-L31
2024-12-22 18:27:49 +0100zenmov(~zenmov@user/zenmov) (Ping timeout: 272 seconds)
2024-12-22 18:29:13 +0100 <c_wraith> And my day 17 parser: https://github.com/chowells79/aoc/blob/main/2024/Day17.hs#L33-L48 . It matches a series of lines including the terminal \n, then matches one more \n before the next section.
2024-12-22 18:29:20 +0100 <c_wraith> Those are the two main ways
2024-12-22 18:29:21 +0100 <albet70> ski , how you did it?
2024-12-22 18:29:24 +0100 <enikar> sinbad: use (string "\n\n")
2024-12-22 18:29:35 +0100 <enikar> it's what I use
2024-12-22 18:30:05 +0100 <albet70> I found that 'yield' in python can do that
2024-12-22 18:30:41 +0100 <enikar> ah! yield in python is awesome
2024-12-22 18:31:23 +0100son0p(~ff@186.121.98.118) (Remote host closed the connection)
2024-12-22 18:32:16 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 18:32:56 +0100 <monochrom> You can make your own yield in Haskell: https://www.vex.net/~trebla/haskell/cont.xhtml#yield
2024-12-22 18:34:45 +0100 <albet70> call/cc in scheme can capture the outside/rest code of call/cc, I don't think Cont or callCC in haskell can do that
2024-12-22 18:35:24 +0100 <albet70> callCC only capture what is inside callCC
2024-12-22 18:35:27 +0100son0p(~ff@186.121.98.118) son0p
2024-12-22 18:36:21 +0100 <enikar> there are arguments against call/cc.
2024-12-22 18:36:54 +0100__monty__(~toonn@user/toonn) (Ping timeout: 265 seconds)
2024-12-22 18:38:00 +0100 <ski> albet70 : the challenge was to implement `zipWith' (or `zip', if you prefer), only traversing either input list (and only once), with a single call to `foldr' for each, not inspecting the lists in any way apart from that
2024-12-22 18:38:11 +0100 <sinbad> c_wraith: thank you
2024-12-22 18:38:34 +0100 <enikar> albet70: https://okmij.org/ftp/continuations/against-callcc.html
2024-12-22 18:38:44 +0100 <ski> `callCC' is delimited by the `runCont'/`runContT', yes
2024-12-22 18:39:12 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 272 seconds)
2024-12-22 18:41:42 +0100 <ski> (albet70 : and no recursive computation needed/permitted, apart from the one inside `foldr')
2024-12-22 18:41:51 +0100 <albet70> enikar , but call/cc still in r4rs?
2024-12-22 18:42:33 +0100 <albet70> ski , what's the delimited continuation
2024-12-22 18:44:36 +0100 <probie> ski: That sounds like a fun challenge. I think I'll have a go
2024-12-22 18:45:24 +0100 <ski> evalCont ca = ca `runCont` id -- `id' here is the initial ("empty") delimited/composable continuation
2024-12-22 18:46:19 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2024-12-22 18:47:11 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 18:47:41 +0100 <enikar> albet70: yes, r4rs is quite old.
2024-12-22 18:48:21 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2024-12-22 18:49:12 +0100 <ski> probie : i first solved it (out of curiosity), around 2007-04-10 (and made a smaller edit for elegance and generality, in 2011-06-14)
2024-12-22 18:51:12 +0100JuanDaugherty(~juan@user/JuanDaugherty) (Quit: JuanDaugherty)
2024-12-22 18:52:04 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 245 seconds)
2024-12-22 18:57:27 +0100 <albet70> can I say callCC is delimited continuation and call/cc is full contit?
2024-12-22 18:58:45 +0100machinedgod(~machinedg@d108-173-18-100.abhsia.telus.net) (Ping timeout: 246 seconds)
2024-12-22 19:00:13 +0100Guest78(~Guest78@2a02:8084:1:6500::db)
2024-12-22 19:02:57 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 19:09:12 +0100 <monochrom> callCC is global because there is no reset to scope it.
2024-12-22 19:09:28 +0100tzh(~tzh@c-76-115-131-146.hsd1.or.comcast.net)
2024-12-22 19:09:43 +0100 <monochrom> Of course you get to say "but only within runCont" but it is not like you really have multiple levels of runCont.
2024-12-22 19:10:06 +0100 <monochrom> Whereas with shift-reset you really always have multiple levels.
2024-12-22 19:11:02 +0100 <monochrom> As Oleg points out, call/cc is not very nice. shift-reset is better. Even the Haskell Cont library provides shift-reset.
2024-12-22 19:11:45 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 260 seconds)
2024-12-22 19:11:47 +0100 <albet70> is that redis distributed lock very like MVar?
2024-12-22 19:12:55 +0100 <monochrom> And Python's yield corresponds to shift-reset rather than call/cc. https://www.cs.indiana.edu/~sabry/papers/yield.pdf
2024-12-22 19:13:30 +0100 <albet70> monochrom , callCC can capture the rest code which is after it?
2024-12-22 19:15:10 +0100housemate(~housemate@125.63.162.34) housemate
2024-12-22 19:18:02 +0100 <monochrom> Although, when you instead look for extending Curry-Howard to classical logic, call/cc is Pierce's law and is exactly the one single thing you need to complete classical logic.
2024-12-22 19:18:23 +0100 <monochrom> s/look for/look to/ # English is hard, I hate prepositions
2024-12-22 19:19:35 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915) Lord_of_Life
2024-12-22 19:20:13 +0100housemate(~housemate@125.63.162.34) (Remote host closed the connection)
2024-12-22 19:20:53 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 265 seconds)
2024-12-22 19:20:56 +0100Lord_of_Life_Lord_of_Life
2024-12-22 19:21:19 +0100haver(~Enviosity@2.219.56.221)
2024-12-22 19:22:04 +0100 <albet70> monochrom , Pierce's law is related to Yoneda embedding?
2024-12-22 19:22:10 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 19:22:16 +0100ash3en(~Thunderbi@2a03:7846:b6eb:101:93ac:a90a:da67:f207) ash3en
2024-12-22 19:23:07 +0100sinbad(~sinbad@user/sinbad) ()
2024-12-22 19:24:10 +0100Enviosity_(~Enviosity@2.219.56.221) (Ping timeout: 252 seconds)
2024-12-22 19:27:10 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 265 seconds)
2024-12-22 19:29:30 +0100 <ski> resetCont :: Cont o o -> Cont p o
2024-12-22 19:29:34 +0100 <ski> resetCont = return . evalCont
2024-12-22 19:32:09 +0100 <monochrom> If you do use call/cc aka Pierce's law to extend Curry-Howard, then excluded middle executes like this story: https://www.cs.cmu.edu/~cmartens/if/dem.html#4.8 >:)
2024-12-22 19:32:18 +0100lxsameer(~lxsameer@Serene/lxsameer) lxsameer
2024-12-22 19:34:31 +0100 <monochrom> I heard of it last month on the haskell-cafe mailing list: https://mail.haskell.org/pipermail/haskell-cafe/2024-November/136916.html
2024-12-22 19:36:41 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2024-12-22 19:37:32 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 19:38:45 +0100 <ncf> btw, is anyone aware of an elementary proof that pierce's law / call/cc is undefinable in system f or something? maybe using parametricity?
2024-12-22 19:40:18 +0100 <ski> you can draw `call/cc', with a box in the style of "To Dissect a Mockingbird: A Graphical Notation for the Lambda Calculus with Animated Reduction" by David C. Keenan in 1996-08-27 - 2014-04-01 at <https://web.archive.org/web/20231128103508/https://dkeenan.com/Lambda/>, only that you'll need a line *exiting* a box abnormally (crossing the border), as opposed to *entering* (using a variable, inside a lambda,
2024-12-22 19:40:24 +0100 <ski> where it was bound outside the lambda)
2024-12-22 19:41:39 +0100 <ski> (`K'/"Kestrel" (`\x. \y. x') there is an example of the latter)
2024-12-22 19:42:12 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 19:44:31 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2024-12-22 19:44:38 +0100 <ncf> @free ((a -> b) -> a) -> a
2024-12-22 19:44:38 +0100 <lambdabot> Try `free <ident>` or `free <ident> :: <type>`
2024-12-22 19:44:45 +0100 <ncf> @free callCC :: ((a -> b) -> a) -> a
2024-12-22 19:44:45 +0100 <lambdabot> (forall p q. g . p = q . f => f (h p) = k q) => f (callCC h) = callCC k
2024-12-22 19:49:39 +0100 <monochrom> ncf: Interesting question! Thanks. Maybe excluded-middle is easier. So someone promises me ∀a. a + not a. By parametricity (very high-level-ly), it cannot say "I give you Left or Right depending on your a", it has to either "I give you Left regardless of a" or "I give you Right regardless of a". But always-Left breaks (a = false), always-Right also breaks (a = true).
2024-12-22 19:50:25 +0100lxsameer(~lxsameer@Serene/lxsameer) (Ping timeout: 248 seconds)
2024-12-22 19:51:53 +0100 <ncf> yeah, it's easy to see for LEM (and you can always argue that call/cc implies LEM), but i wonder if there's a more direct story
2024-12-22 19:52:55 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 19:53:21 +0100 <monochrom> That may be harder to understand when you finish it. :)
2024-12-22 19:53:23 +0100 <ncf> for Martin-Löf type theory it's easy to prove that the type of pierce's law is not inhabited in the family model (presheaves over ∙ → ∙): https://gist.github.com/ncfavier/6ca209ab691f640a8d08e9f67bd041e1
2024-12-22 19:54:06 +0100 <ncf> i'm not familiar enough with the semantics of system f to know if something similar can be done there
2024-12-22 19:56:18 +0100 <monochrom> But hey I'm going to put it on the exam! (OK, I just mean: Suppose e :: ∀a. Either [a] (Maybe a). Prove: (always e = Left ...) or (always e = Right ...).)
2024-12-22 19:59:40 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-12-22 20:04:17 +0100 <haskellbridge> <thirdofmay18081814goya> hm, in an FRP setting, suppose I want to model the signal function that takes two input signals: the first is the device's screen specs, and the second is an IO event representing a click, and the output is a coordinate of the click
2024-12-22 20:04:30 +0100 <haskellbridge> <thirdofmay18081814goya> what should be the type of the IO event?
2024-12-22 20:04:47 +0100 <haskellbridge> <thirdofmay18081814goya> hm, in an FRP setting, suppose I want to model the signal function that takes two input signals: the first is the device's screen specs, and the second is an IO event representing a click, and the output is the coordinates of the click
2024-12-22 20:05:23 +0100 <geekosaur> (careful with those edits)
2024-12-22 20:05:38 +0100 <haskellbridge> <thirdofmay18081814goya> uh right yes my bad
2024-12-22 20:06:49 +0100 <monochrom> I'm OK with those edits. :)
2024-12-22 20:07:06 +0100 <haskellbridge> <thirdofmay18081814goya> so the function has:
2024-12-22 20:07:06 +0100 <haskellbridge> ... long message truncated: https://kf8nh.com/_heisenbridge/media/kf8nh.com/OhYpqzWlQxOOEZERbielBCRQ/4iEIbaNtSto (4 lines)
2024-12-22 20:08:37 +0100ash3en(~Thunderbi@2a03:7846:b6eb:101:93ac:a90a:da67:f207) (Quit: ash3en)
2024-12-22 20:09:05 +0100ash3en(~Thunderbi@2a03:7846:b6eb:101:93ac:a90a:da67:f207) ash3en
2024-12-22 20:10:29 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) merijn
2024-12-22 20:12:04 +0100ash3en(~Thunderbi@2a03:7846:b6eb:101:93ac:a90a:da67:f207) (Client Quit)
2024-12-22 20:12:12 +0100sinbad(~sinbad@user/sinbad) Sinbad
2024-12-22 20:14:03 +0100ski. o O ( `(forall a. Either (f a) (g a)) -> Either (forall a. f a) (forall a. g a)' )
2024-12-22 20:15:58 +0100 <haskellbridge> <thirdofmay18081814goya> hm... right that makes sense, I will be thinking about this formulation, thank you!
2024-12-22 20:17:02 +0100merijn(~merijn@128-137-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-12-22 20:17:03 +0100 <ski> (afaik, you can't internalize this, in System F)
2024-12-22 20:20:39 +0100sefidel(~sefidel@user/sefidel) (Remote host closed the connection)
2024-12-22 20:20:55 +0100 <monochrom> Yeah, System F doesn't know that itself is parametric. :)