IRCBrowse

2023/04/12

2023-04-12 00:00:01 +0200 <hpc> geekosaur: it's even better than that, according to strace it's renameat2()
2023-04-12 00:00:15 +0200 <geekosaur> true, I ignored that part
2023-04-12 00:00:40 +0200 <monochrom> There is no information you can gain from "read-write is more complex than read-write-write".
2023-04-12 00:00:47 +0200 <hpc> jeez, this is actually a lot
2023-04-12 00:00:57 +0200 <monochrom> err, s/more/less/
2023-04-12 00:01:14 +0200jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 255 seconds)
2023-04-12 00:01:15 +0200 <hpc> it has to know what the filesystem states are, to know if it can do renameat2 in the first place
2023-04-12 00:01:30 +0200 <hpc> which... is reading from a file that isn't even a file
2023-04-12 00:01:41 +0200 <hpc> because it's /proc :D
2023-04-12 00:02:14 +0200 <olle> Need to sleep, but thanks for feedback, the graph/reorder idea was interesting
2023-04-12 00:02:15 +0200 <olle> \o
2023-04-12 00:02:31 +0200 <mauke> '-'-'-' is a perfectly cromulent file descriptor
2023-04-12 00:03:25 +0200 <monochrom> OOOHHHH haha I forgot that the middle - just means subtraction.
2023-04-12 00:04:04 +0200 <monochrom> You have just certified that I can't even parse C grammar. :)
2023-04-12 00:05:16 +0200 <monochrom> My excuse is that I'm studying linear algebra right now, C is on swap.
2023-04-12 00:07:07 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2023-04-12 00:07:29 +0200trev(~trev@user/trev) (Quit: trev)
2023-04-12 00:07:45 +0200 <hpc> ppsh, "linear" means it's easy
2023-04-12 00:08:24 +0200 <monochrom> As with musical instruments, someone will find ways to make it difficult.
2023-04-12 00:08:48 +0200jpds(~jpds@gateway/tor-sasl/jpds)
2023-04-12 00:09:44 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-04-12 00:12:47 +0200gurkenglas(~gurkengla@dynamic-046-114-181-068.46.114.pool.telefonica.de) (Ping timeout: 264 seconds)
2023-04-12 00:12:52 +0200zmt01(~zmt00@user/zmt00)
2023-04-12 00:13:23 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-04-12 00:13:55 +0200gurkenglas(~gurkengla@dynamic-046-114-183-049.46.114.pool.telefonica.de)
2023-04-12 00:14:31 +0200zmt00(~zmt00@user/zmt00) (Ping timeout: 240 seconds)
2023-04-12 00:14:44 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 246 seconds)
2023-04-12 00:32:20 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-04-12 00:34:33 +0200urdh(~urdh@user/urdh) (Ping timeout: 255 seconds)
2023-04-12 00:35:48 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-04-12 00:40:23 +0200urdh(~urdh@user/urdh)
2023-04-12 00:46:57 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-04-12 00:49:07 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 250 seconds)
2023-04-12 00:49:55 +0200 <juri_> monochrom: has anyone exposed you to projective geometric algebra?
2023-04-12 00:50:06 +0200 <juri_> linear algebra is dead. ;)
2023-04-12 00:52:32 +0200 <monochrom> I think yes.
2023-04-12 00:53:00 +0200 <monochrom> Is that something about bivectors, Clifford algebra, etc.?
2023-04-12 00:53:45 +0200 <monochrom> linear algebra may be dead but still highly relevant and useful, like Fortran. :)
2023-04-12 00:57:25 +0200 <juri_> ok. your pain. ;)
2023-04-12 00:57:39 +0200 <juri_> i have written a haskell library for this, covering many of the 2D cases.
2023-04-12 00:58:41 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-04-12 00:58:49 +0200 <monochrom> Oh, I'm studing linear algebra because of the prospect of using the following as Num instance homework next time I teach Haskell in a course.
2023-04-12 00:59:25 +0200 <juri_> Oh! then stay far away from what i've done. its pure madness! :)
2023-04-12 00:59:42 +0200 <monochrom> The nxn matrices form a ring, so most of the Num methods are accounted for. Except what to do about signum and abs.
2023-04-12 01:00:48 +0200 <juri_> https://github.com/Haskell-Things/HSlice/blob/master/Graphics/Slicer/Math/PGAPrimitives.hs <-- in case you want to twist your brain. ;)
2023-04-12 01:00:49 +0200 <monochrom> I have just recalled learning that every square matrix is factorable into (some unitary matrix) * (positive square root of M* times M).
2023-04-12 01:01:37 +0200 <monochrom> That sounds like a great candidate for M = signum M * abs M. I'm investigating how to compute them.
2023-04-12 01:02:09 +0200gry(st@botters/gry)
2023-04-12 01:02:14 +0200 <juri_> you lost me completely. my last linear algebra was in high school, and it probably shows in my code.
2023-04-12 01:02:15 +0200 <monochrom> "ORMOLU_DISABLE" haha
2023-04-12 01:02:44 +0200 <juri_> me and ormolu don't agree on much. ;)
2023-04-12 01:02:53 +0200dextaa1(~DV@user/dextaa)
2023-04-12 01:03:16 +0200 <monochrom> Oh I have a feeling that learning C : learning Haskell :: learning linear algebra : learning geometric algebra
2023-04-12 01:03:34 +0200 <monochrom> Namely being a clean slate may make your life easier!
2023-04-12 01:03:42 +0200 <hpc> this is why i learned linear geometry
2023-04-12 01:03:47 +0200 <monochrom> haha
2023-04-12 01:04:01 +0200 <juri_> this is why i spent 25 years writing C.
2023-04-12 01:04:07 +0200 <juri_> *hides*
2023-04-12 01:04:11 +0200dextaa(~DV@user/dextaa) (Ping timeout: 248 seconds)
2023-04-12 01:04:11 +0200dextaa1dextaa
2023-04-12 01:07:09 +0200maxwarrior(~maxwarrio@2803:9800:98c1:795a:fc63:5ff3:390c:c0a0)
2023-04-12 01:07:33 +0200 <maxwarrior> Hi everybody!
2023-04-12 01:08:18 +0200jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 255 seconds)
2023-04-12 01:10:32 +0200zeenk(~zeenk@2a02:2f04:a307:2300::fba) (Quit: Konversation terminated!)
2023-04-12 01:10:54 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-04-12 01:11:02 +0200maxwarrior(~maxwarrio@2803:9800:98c1:795a:fc63:5ff3:390c:c0a0) (Remote host closed the connection)
2023-04-12 01:16:12 +0200pwug(~pwug@user/pwug) (Quit: Leaving)
2023-04-12 01:22:28 +0200jmdaemon(~jmdaemon@user/jmdaemon)
2023-04-12 01:24:06 +0200gurkenglas(~gurkengla@dynamic-046-114-183-049.46.114.pool.telefonica.de) (Ping timeout: 268 seconds)
2023-04-12 01:25:07 +0200jerg(~jerg@2001:a61:6134:5201:5df3:da85:9419:73e) (Quit: Leaving)
2023-04-12 01:29:50 +0200codaraxis(~codaraxis@user/codaraxis) (Ping timeout: 260 seconds)
2023-04-12 01:33:01 +0200acidjnk(~acidjnk@p200300d6e715c407d4f5be9b40c24016.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-04-12 01:34:37 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Quit: Leaving.)
2023-04-12 01:36:52 +0200harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67)
2023-04-12 01:41:13 +0200ell(~ellie@user/ellie) (Quit: Ping timeout (120 seconds))
2023-04-12 01:41:32 +0200ell(~ellie@user/ellie)
2023-04-12 01:42:03 +0200NiceBird(~NiceBird@185.133.111.196) (Ping timeout: 255 seconds)
2023-04-12 01:45:41 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 268 seconds)
2023-04-12 02:00:03 +0200mauke_(~mauke@user/mauke)
2023-04-12 02:01:31 +0200mauke(~mauke@user/mauke) (Ping timeout: 240 seconds)
2023-04-12 02:01:31 +0200mauke_mauke
2023-04-12 02:01:35 +0200Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-04-12 02:02:01 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 240 seconds)
2023-04-12 02:02:52 +0200Lord_of_Life_Lord_of_Life
2023-04-12 02:06:17 +0200ix(~ix@2a02:8012:281f:0:d65d:64ff:fe52:5efe) (Quit: WeeChat 3.8)
2023-04-12 02:10:14 +0200heraldo(~heraldo@user/heraldo) (Ping timeout: 246 seconds)
2023-04-12 02:16:06 +0200 <jackdk> Hi Dr. Maxwarror!
2023-04-12 02:17:34 +0200Vq(~vq@90-227-192-206-no77.tbcn.telia.com) (Ping timeout: 265 seconds)
2023-04-12 02:18:18 +0200 <geekosaur> they left
2023-04-12 02:19:26 +0200Vq(~vq@90-227-192-206-no77.tbcn.telia.com)
2023-04-12 02:24:00 +0200mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net) (Quit: ZNC 1.8.2 - https://znc.in)
2023-04-12 02:25:18 +0200chanceyan(~chanceyan@user/chanceyan)
2023-04-12 02:25:40 +0200mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net)
2023-04-12 02:26:37 +0200glguy(~glguy@libera/staff-emeritus/glguy)
2023-04-12 02:30:57 +0200codaraxis(~codaraxis@user/codaraxis)
2023-04-12 02:34:21 +0200fbytez(~uid@user/fbytez) (Quit: byte byte)
2023-04-12 02:34:39 +0200fbytez(~uid@2001:bc8:2117:100::)
2023-04-12 02:37:33 +0200 <Axman6> Goodbye, Dr. Maxwarrior, you dshall be missed
2023-04-12 02:37:51 +0200 <Axman6> s/ds/s/g
2023-04-12 02:38:11 +0200 <Axman6> (ds has no place existing anywhere)
2023-04-12 02:40:33 +0200 <Axman6> % :t only
2023-04-12 02:40:33 +0200 <yahb2> <interactive>:1:1: error: Variable not in scope: only
2023-04-12 02:40:47 +0200 <Axman6> % import Control.Lens
2023-04-12 02:40:48 +0200 <yahb2> <no location info>: error: ; Could not find module ‘Control.Lens’ ; It is not a module in the current program, or in any known package.
2023-04-12 02:40:53 +0200 <Axman6> :(
2023-04-12 02:41:14 +0200harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67) (Quit: Leaving)
2023-04-12 02:41:19 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-04-12 02:43:02 +0200 <Axman6> (only :: Eq a => a -> Prism' a () -- for anyone playing along at home)
2023-04-12 02:45:45 +0200 <jackdk> :t only
2023-04-12 02:45:46 +0200 <lambdabot> (Eq a, Choice p, Applicative f) => a -> p () (f ()) -> p a (f a)
2023-04-12 02:47:09 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-04-12 02:47:10 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-04-12 02:47:10 +0200wroathe(~wroathe@user/wroathe)
2023-04-12 02:52:04 +0200jinsun(~jinsun@user/jinsun) (Ping timeout: 252 seconds)
2023-04-12 02:52:36 +0200aweinstock(~aweinstoc@cpe-74-76-189-75.nycap.res.rr.com)
2023-04-12 02:53:59 +0200cheater_(~Username@user/cheater)
2023-04-12 02:57:27 +0200cheater(~Username@user/cheater) (Ping timeout: 256 seconds)
2023-04-12 02:57:36 +0200cheater_cheater
2023-04-12 03:01:47 +0200 <erisco> are there equivalently general solutions for finding the fixpoint other than fix :: (a -> a) -> a ? for example, why not loop :: (a -> Either a b) -> a -> b ?
2023-04-12 03:02:31 +0200cheater(~Username@user/cheater) (Ping timeout: 265 seconds)
2023-04-12 03:02:47 +0200zer0bitz_(~zer0bitz@2001:2003:f443:d600:c8fb:80d:3f21:d12f)
2023-04-12 03:03:15 +0200 <Axman6> :t let loop f x = fix (\case Left a -> f a; Right b -> b) . Left in loop
2023-04-12 03:03:16 +0200 <lambdabot> error:
2023-04-12 03:03:16 +0200 <lambdabot> • Couldn't match expected type ‘Either a1 b0 -> c1’
2023-04-12 03:03:16 +0200 <lambdabot> with actual type ‘Either t1 b1’
2023-04-12 03:03:27 +0200 <Axman6> :t let loop f = fix (\case Left a -> f a; Right b -> b) . Left in loop
2023-04-12 03:03:28 +0200 <lambdabot> error:
2023-04-12 03:03:28 +0200 <lambdabot> • Couldn't match expected type ‘Either a1 b0 -> c1’
2023-04-12 03:03:28 +0200 <lambdabot> with actual type ‘Either t1 b1’
2023-04-12 03:03:35 +0200jinsun(~jinsun@user/jinsun)
2023-04-12 03:03:43 +0200 <Axman6> I'm bad at Haskell
2023-04-12 03:04:10 +0200zer0bitz(~zer0bitz@2001:2003:f443:d600:8072:a2d3:32b3:1df4) (Ping timeout: 252 seconds)
2023-04-12 03:05:01 +0200 <erisco> you could go down a line of reasoning such as fix can become loop but loop cannot become fix, but then the question is, what is an example where fix suffices and loop does not?
2023-04-12 03:05:28 +0200 <jackdk> Axman6: `loop = fix $ \recur f -> either (recur f) id . f`?
2023-04-12 03:07:10 +0200 <jackdk> Hm, can you write `fix` in terms of `loop`?
2023-04-12 03:07:22 +0200 <Axman6> yeah that was my next question
2023-04-12 03:07:47 +0200 <Axman6> can you get the same behaviour as fix (1:)?
2023-04-12 03:08:47 +0200 <erisco> fix is about a fix point, and loop isn't, at least not obviously, but they both can be seen as implementations of recursion
2023-04-12 03:09:15 +0200 <erisco> I am not sure that you necessarily need fix for recursion, ie I am unaware of an example that cannot be implemented with loop
2023-04-12 03:09:44 +0200 <Axman6> it seems to be that loop forces a particular ordering to evaluation too, you can't progress without evaluating the Either, which feels different to the substitution of the function into itself
2023-04-12 03:10:14 +0200cheater(~Username@user/cheater)
2023-04-12 03:10:27 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-04-12 03:12:07 +0200cheater_(~Username@user/cheater)
2023-04-12 03:13:55 +0200 <Axman6> Currently going through Optics by Example, TIL about beside; definitely need to file that one away
2023-04-12 03:14:31 +0200cheater(~Username@user/cheater) (Ping timeout: 240 seconds)
2023-04-12 03:15:32 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-04-12 03:15:39 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 255 seconds)
2023-04-12 03:16:27 +0200cheater__(~Username@user/cheater)
2023-04-12 03:16:27 +0200cheater__cheater
2023-04-12 03:16:34 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-04-12 03:16:51 +0200 <erisco> we say that imperative loops and functional recursion are two ways to go about the same thing (operationally) ... I am gleaning this impression that the difference really is only found in the semantics
2023-04-12 03:17:03 +0200 <monochrom> erisco: Are you ruling out ones = 1 : ones? Or do you know how to get ones from loop?
2023-04-12 03:18:11 +0200cheater_(~Username@user/cheater) (Ping timeout: 250 seconds)
2023-04-12 03:18:35 +0200jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 248 seconds)
2023-04-12 03:18:39 +0200 <c_wraith> yeah, I don't see how loop can handle corecursion at all
2023-04-12 03:19:16 +0200 <erisco> sort of but not in the way you'd want
2023-04-12 03:20:36 +0200 <erisco> loop (\f -> Left (f . f)) (1:)
2023-04-12 03:21:28 +0200 <monochrom> does "take 1 (loop (\f -> Left (f . f)) (1:))" terminate and give [1]?
2023-04-12 03:22:03 +0200 <erisco> no
2023-04-12 03:22:11 +0200 <monochrom> I ask because I am too lazy to either ask what "loop" does (no, the type does not give enough information) or check the implementation given so far.
2023-04-12 03:22:40 +0200 <monochrom> But you know what loop does and you can quickly work out my take-1 example in your head.
2023-04-12 03:23:09 +0200 <erisco> https://hackage.haskell.org/package/extra-1.7.13/docs/src/Control.Monad.Extra.html#loop
2023-04-12 03:24:06 +0200cheater_(~Username@user/cheater)
2023-04-12 03:24:28 +0200 <monochrom> If you prefer imperative programming, main = do { s <- getLine; putStrLn ("hello " ++ s); main } is a prototype of a whole class of useful programs.
2023-04-12 03:24:47 +0200 <monochrom> e.g., web apps are that on steroid.
2023-04-12 03:24:48 +0200cheater(~Username@user/cheater) (Ping timeout: 248 seconds)
2023-04-12 03:25:17 +0200 <monochrom> Can you write web apps with loop?
2023-04-12 03:25:50 +0200cheater__(~Username@user/cheater)
2023-04-12 03:25:50 +0200cheater__cheater
2023-04-12 03:26:08 +0200 <erisco> somehow I didn't expect you to ever ask such a question :P
2023-04-12 03:26:27 +0200 <jackdk> :t interact
2023-04-12 03:26:28 +0200 <lambdabot> (String -> String) -> IO ()
2023-04-12 03:26:38 +0200 <c_wraith> and if you don't see the punchline coming - fix can do that.
2023-04-12 03:27:14 +0200 <c_wraith> I actually find fix most useful for ad-hoc loops in IO where I need to close over a previously-generated value.
2023-04-12 03:27:57 +0200 <monochrom> Yeah, "do = { .... ; let {myloop = ... myloop ...}; myloop ...}" gets old sometimes.
2023-04-12 03:28:41 +0200 <monochrom> "do = { ... ; fix (\myloop -> ... myloop ...) ...}" is sometimes nicer to the eyes.
2023-04-12 03:28:55 +0200cheater_(~Username@user/cheater) (Ping timeout: 252 seconds)
2023-04-12 03:29:13 +0200 <monochrom> Although, sometimes I find that unsatisfactory too. Haven't found a really beautiful solution.
2023-04-12 03:30:06 +0200jero98772(~jero98772@2800:484:1d84:9000::5) (Ping timeout: 265 seconds)
2023-04-12 03:30:22 +0200 <monochrom> Actually, I have found a really beautiful solution, but it's heresy: Reinstate flow charts.
2023-04-12 03:30:52 +0200 <erisco> so it seems what we're identifying is there is a difference in what you can see on the outside, in that we cannot see what loop is doing until it stops at a Right, whereas, at least with guarded recursion, we can see what fix is doing
2023-04-12 03:31:13 +0200 <monochrom> No.
2023-04-12 03:31:26 +0200 <erisco> k what is it then
2023-04-12 03:32:28 +0200 <monochrom> "take 1 ones" hardly qualifies as "see inside what it's doing". It's an emphatically blackbox observation.
2023-04-12 03:33:20 +0200 <monochrom> And running my main example too, I am merely saying I am at the terminal entering some input and hoping for some output, some interaction.
2023-04-12 03:33:47 +0200 <erisco> both the loop version and the fix version of building a list of ones operationally builds a list of ones, but we cannot access that list in the case of loop
2023-04-12 03:33:53 +0200 <monochrom> Interacting with the computer is clearly blackbox outside by definition. No one is running a debugger or strace.
2023-04-12 03:34:32 +0200 <erisco> we can say the same of this IO action
2023-04-12 03:34:36 +0200 <monochrom> Or at least I am not running a debugger or strace.
2023-04-12 03:34:54 +0200 <c_wraith> fix f reduces to a call to f with some argument. loop f reduces to a call to loop (when f is returning a Left, anyway)
2023-04-12 03:35:51 +0200 <c_wraith> that's roughly the same as the difference between foldr and foldl
2023-04-12 03:36:28 +0200jmdaemon(~jmdaemon@user/jmdaemon)
2023-04-12 03:36:38 +0200 <monochrom> "main = mapM_ print ones" is also a blackbox outside observation.
2023-04-12 03:36:50 +0200 <erisco> so now I am wondering what we might think if loop was generalised to:
2023-04-12 03:36:51 +0200 <erisco> loop :: Monad m => (a -> m (Either a b)) -> a -> m b
2023-04-12 03:36:51 +0200 <erisco> loop f x = f x >>= \r -> case r of Left y -> loop f y; Right z -> pure z
2023-04-12 03:37:02 +0200 <monochrom> I see spamming or I see darkness.
2023-04-12 03:38:07 +0200jinsun(~jinsun@user/jinsun) (Ping timeout: 250 seconds)
2023-04-12 03:39:43 +0200 <c_wraith> erisco: isn't that loopM, the next definition in that file?
2023-04-12 03:39:46 +0200cheater(~Username@user/cheater) (Ping timeout: 268 seconds)
2023-04-12 03:39:59 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:ad1e:c088:4c6f:8ed8)
2023-04-12 03:40:00 +0200 <erisco> yep
2023-04-12 03:40:14 +0200 <monochrom> My hunch is that using free theorems, the type "forall m. Monad m => ..." says that we can gain a lot of information by setting m = Identity.
2023-04-12 03:40:35 +0200 <monochrom> In fact, s/information/information on limitations/
2023-04-12 03:41:08 +0200jero98772(~jero98772@2800:484:1d84:9000::3)
2023-04-12 03:41:59 +0200jinsun(~jinsun@user/jinsun)
2023-04-12 03:42:13 +0200 <c_wraith> erisco: did you see where I was going with the foldr/foldl comparison?
2023-04-12 03:42:16 +0200 <monochrom> Now, if you upgrade to MonadPlus and try to use <|> somewhere, that will be a lot of interesting.
2023-04-12 03:42:27 +0200 <erisco> c_wraith, yes
2023-04-12 03:42:35 +0200 <monochrom> (In that case setting m = [] tells us a lot.)
2023-04-12 03:42:59 +0200 <monochrom> s/a lot of/a lot more/
2023-04-12 03:43:15 +0200ix(~ix@2a02:8012:281f:0:d65d:64ff:fe52:5efe)
2023-04-12 03:43:30 +0200razetime(~Thunderbi@117.193.5.39)
2023-04-12 03:44:28 +0200ix(~ix@2a02:8012:281f:0:d65d:64ff:fe52:5efe) (Client Quit)
2023-04-12 03:44:35 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:ad1e:c088:4c6f:8ed8) (Ping timeout: 260 seconds)
2023-04-12 03:44:44 +0200 <erisco> monochrom, well, when m = IO then your greeter program is implementable in the intended way
2023-04-12 03:47:20 +0200 <monochrom> Oh then I guess m = Cont [Integer] will get ones=1:ones done.
2023-04-12 03:47:58 +0200 <erisco> thanks I was trying to figure that one out :) and maybe fix is in there somewhere too
2023-04-12 03:53:20 +0200jinsun(~jinsun@user/jinsun) (Ping timeout: 260 seconds)
2023-04-12 03:53:26 +0200 <erisco> there is the idea of termination vs productivity, and it seems vaguely that loop is useful when you have termination and loopM or fix is useful when you have termination or just productivity
2023-04-12 03:54:37 +0200 <erisco> well these are good thoughts, thanks for the conversation
2023-04-12 03:55:32 +0200cheater(~Username@user/cheater)
2023-04-12 03:56:46 +0200jinsun(~jinsun@user/jinsun)
2023-04-12 03:58:18 +0200 <monochrom> Termination was an ancient 1960s idea when access to computers was barred and you submitted a program before 9PM and some one else on night shift ran it at 4AM for 5 minutes and you woke up at 8AM and collected the result (well, one could hope).
2023-04-12 03:58:25 +0200razetime1(~Thunderbi@117.193.5.39)
2023-04-12 03:58:50 +0200 <monochrom> Today productivity aka interactive responsiveness is the actual requirement.
2023-04-12 03:59:10 +0200razetime(~Thunderbi@117.193.5.39) (Ping timeout: 276 seconds)
2023-04-12 03:59:10 +0200razetime1razetime
2023-04-12 04:01:07 +0200xff0x(~xff0x@ai098135.d.east.v6connect.net) (Ping timeout: 276 seconds)
2023-04-12 04:02:32 +0200 <erisco> yeah I wouldn't argue with that but there seem to be semantic differences that are interesting and might motivate the choice of one over the other
2023-04-12 04:03:11 +0200 <monochrom> And here is how to use loop and Cont for ones=1:ones https://paste.tomsmeding.com/qzzaNKfH
2023-04-12 04:03:51 +0200 <erisco> nice
2023-04-12 04:04:03 +0200 <c_wraith> you can do it with Writer instead
2023-04-12 04:04:09 +0200hugo-hugo
2023-04-12 04:04:27 +0200 <monochrom> Oh the difference goes even beyond semantics. It completely changes how you prove correctness.
2023-04-12 04:05:09 +0200 <monochrom> Most formal methods invented for 1960s batch-mode computing are rendered useless for interactive programs.
2023-04-12 04:07:59 +0200 <erisco> What I was looking at with fix vs loop is that with fix you have these bottomless expressions, whereas with with loop you do not. Because I am interested in always being able to reduce an expression to some normal value, fix was posing a problem... I know there is some information lattice game you can play with the semantics to sort this out as well
2023-04-12 04:08:25 +0200ix(~ix@2a02:8012:281f:0:5a9c:fcff:fe09:a026)
2023-04-12 04:08:25 +0200 <[Leary]> erisco: You might be interested in `rec :: Functor f => (f (LFP f * a) -> a) -> LFP f -> a` and its dual `corec :: Functor f => (a -> f (GFP f + a)) -> a -> GFP f`. They can be written in the strongly-normalising System F, so despite encoding recursion, they're guaranteed to "terminate" and "produce" respectively.
2023-04-12 04:09:40 +0200 <erisco> so a simple example is fix (1+) versus loop (\x -> Left (1 + x)) 0 ... neither terminate, but the loop is operationally counting up the integers, whereas fix is building an infinite expression
2023-04-12 04:10:08 +0200 <monochrom> erisco: OK, fix in terms of loop+Cont: https://paste.tomsmeding.com/sL5V7uql
2023-04-12 04:10:25 +0200 <monochrom> "That covers everything now" :)
2023-04-12 04:10:28 +0200 <erisco> [Leary], thanks
2023-04-12 04:11:52 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-04-12 04:11:57 +0200_xor(~xor@74.215.46.17)
2023-04-12 04:12:12 +0200 <erisco> monochrom, very nice
2023-04-12 04:13:00 +0200 <erisco> there are echoes of code reviews playing in my head about your variable naming but very nice :P
2023-04-12 04:13:24 +0200 <monochrom> Oh, it really was just "since ones = fix (1:), wherever I see 1:foo I just generalize it to f foo".
2023-04-12 04:14:03 +0200_xor(~xor@74.215.46.17) (Client Quit)
2023-04-12 04:14:36 +0200 <monochrom> Right? (Or Left? Haha) I had "1 : k (Left ())" so it's just "f (k (Left ()))" in general.
2023-04-12 04:15:30 +0200td_(~td@i5387091F.versanet.de) (Ping timeout: 255 seconds)
2023-04-12 04:16:34 +0200nate1(~nate@98.45.169.16)
2023-04-12 04:17:05 +0200td_(~td@i53870927.versanet.de)
2023-04-12 04:18:08 +0200rburkholder(~blurb@96.45.2.121) (Ping timeout: 248 seconds)
2023-04-12 04:18:13 +0200 <monochrom> Unfortunately every iteration it keeps a new copy of "Right z -> pure z" just in case, so memory usage grows.
2023-04-12 04:18:42 +0200 <monochrom> Err no, that can't be right.
2023-04-12 04:19:33 +0200Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) (Ping timeout: 255 seconds)
2023-04-12 04:20:17 +0200Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net)
2023-04-12 04:22:45 +0200 <monochrom> Nah there is no memory growth, it's OK.
2023-04-12 04:22:58 +0200Me-me(~me-me@2602:ff16:3:0:1:dc:beef:d00d) (Remote host closed the connection)
2023-04-12 04:24:14 +0200Me-me(~me-me@user/me-me)
2023-04-12 04:24:59 +0200mei(~mei@user/mei) (Killed (tantalum.libera.chat (Nickname regained by services)))
2023-04-12 04:25:04 +0200mei(~mei@user/mei)
2023-04-12 04:34:23 +0200rburkholder(~blurb@96.45.2.121)
2023-04-12 04:44:40 +0200jero98772(~jero98772@2800:484:1d84:9000::3) (Ping timeout: 260 seconds)
2023-04-12 04:45:35 +0200xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-04-12 04:46:37 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 276 seconds)
2023-04-12 04:49:17 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:ad1e:c088:4c6f:8ed8)
2023-04-12 04:51:19 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-04-12 04:53:46 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 268 seconds)
2023-04-12 04:54:52 +0200jero98772(~jero98772@2800:484:1d84:9000::3)
2023-04-12 04:55:26 +0200jero98772(~jero98772@2800:484:1d84:9000::3) (Remote host closed the connection)
2023-04-12 04:58:38 +0200finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-04-12 04:58:38 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-04-12 04:58:38 +0200finn_elijaFinnElija
2023-04-12 05:01:25 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 265 seconds)
2023-04-12 05:04:38 +0200gehmehgeh(~user@user/gehmehgeh)
2023-04-12 05:05:53 +0200gmg(~user@user/gehmehgeh) (Ping timeout: 255 seconds)
2023-04-12 05:09:48 +0200ix(~ix@2a02:8012:281f:0:5a9c:fcff:fe09:a026) (Quit: WeeChat 3.8)
2023-04-12 05:13:15 +0200ix(~ix@2a02:8012:281f:0:5a9c:fcff:fe09:a026)
2023-04-12 05:13:35 +0200ix(~ix@2a02:8012:281f:0:5a9c:fcff:fe09:a026) (Client Quit)
2023-04-12 05:14:27 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 255 seconds)
2023-04-12 05:19:18 +0200nate1(~nate@98.45.169.16) (Ping timeout: 265 seconds)
2023-04-12 05:22:19 +0200Square(~Square4@user/square) (Ping timeout: 248 seconds)
2023-04-12 05:30:52 +0200ix(~ix@2a02:8012:281f:0:5a9c:fcff:fe09:a026)
2023-04-12 05:31:55 +0200ix(~ix@2a02:8012:281f:0:5a9c:fcff:fe09:a026) (Client Quit)
2023-04-12 05:35:03 +0200ix(~ix@2a02:8012:281f:0:5a9c:fcff:fe09:a026)
2023-04-12 05:35:05 +0200razetime(~Thunderbi@117.193.5.39) (Ping timeout: 268 seconds)
2023-04-12 05:35:11 +0200ix(~ix@2a02:8012:281f:0:5a9c:fcff:fe09:a026) (Client Quit)
2023-04-12 05:41:03 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf) (Remote host closed the connection)
2023-04-12 05:41:22 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf)
2023-04-12 05:42:45 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-04-12 05:46:57 +0200fernand(~fernand@179.156.34.250)
2023-04-12 05:47:18 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 255 seconds)
2023-04-12 05:58:52 +0200institor(~absentia@user/institor)
2023-04-12 06:13:28 +0200dibblego(~dibblego@haskell/developer/dibblego) (Ping timeout: 265 seconds)
2023-04-12 06:14:33 +0200dibblego(~dibblego@122-199-1-30.ip4.superloop.au)
2023-04-12 06:14:34 +0200dibblego(~dibblego@122-199-1-30.ip4.superloop.au) (Changing host)
2023-04-12 06:14:34 +0200dibblego(~dibblego@haskell/developer/dibblego)
2023-04-12 06:19:11 +0200razetime(~Thunderbi@117.193.5.39)
2023-04-12 06:22:24 +0200fernand(~fernand@179.156.34.250) (Ping timeout: 248 seconds)
2023-04-12 06:26:28 +0200 <Clinton[m]> If anyone knows a bit about using generics in Haskell, I'd appreciate it if they have a look at this question: https://stackoverflow.com/questions/75991896/generically-iterating-over-accessors-of-a-product-type
2023-04-12 06:26:39 +0200dsrt^(~dsrt@c-76-105-96-13.hsd1.ga.comcast.net)
2023-04-12 06:32:49 +0200mbuf(~Shakthi@49.207.178.186)
2023-04-12 06:36:28 +0200trev(~trev@user/trev)
2023-04-12 06:37:38 +0200dipper(~dipper@203.168.11.65)
2023-04-12 06:38:00 +0200 <probie> Clinton[m]: are you sure the types are right in that question? Or do you mean something like `productAccessorsToList :: ... => (forall b. c b => (a -> b) -> t) -> [a -> t]`?
2023-04-12 06:43:28 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-04-12 06:44:51 +0200freeside(~mengwong@50.216.111.242)
2023-04-12 06:44:53 +0200 <Clinton[m]> <probie> "Clinton: are you sure the..." <- No, it should be `-> [t]`, not `-> [a -> t]`. Given a type `a` with field `b`, an accessor for that field is of type `a -> b`. I've got a function that takes an accessor forall b. (i.e. forall b. a -> b) and produces some type `t`. I want those in a list.
2023-04-12 06:46:42 +0200 <Clinton[m]> It's almost like `productToList`, but instead of iterating over the values (which of course, needs an actual value of type `a`, and then iterate over the fields `b`) i iterate over the accessors which are `a -> b`, and hence there's now no need to pass an actual value.
2023-04-12 06:47:14 +0200chanceyan(~chanceyan@user/chanceyan) (Quit: Client closed)
2023-04-12 06:47:39 +0200chanceyan(~chanceyan@user/chanceyan)
2023-04-12 06:48:46 +0200 <probie> Clinton[m]: Right. I get what you mean now. I must still be half-asleep
2023-04-12 06:50:58 +0200 <institor> wew
2023-04-12 06:51:14 +0200 <institor> some hardcore types in `Generics.SOP`
2023-04-12 06:52:12 +0200 <Axman6> They're not really too scary
2023-04-12 06:54:09 +0200 <institor> :t id
2023-04-12 06:54:11 +0200 <lambdabot> a -> a
2023-04-12 06:54:34 +0200 <institor> :t (hcollapse . hcmap (Proxy :: Proxy c) (mapIK f))
2023-04-12 06:54:35 +0200 <lambdabot> error:
2023-04-12 06:54:35 +0200 <lambdabot> Variable not in scope: hcollapse :: b0 -> c
2023-04-12 06:54:46 +0200 <institor> :import Generics.SOP
2023-04-12 06:54:50 +0200 <institor> ehh...
2023-04-12 06:55:47 +0200JScript(~JScript@45.248.77.94)
2023-04-12 06:55:51 +0200JScript(~JScript@45.248.77.94) (Max SendQ exceeded)
2023-04-12 06:56:08 +0200 <Axman6> lambdabot can't import new modules IIRC, yahb2 can but needs to have it installed
2023-04-12 06:56:19 +0200JScript(~JScript@45.248.77.94)
2023-04-12 06:56:39 +0200JScript(~JScript@45.248.77.94) (Max SendQ exceeded)
2023-04-12 06:57:15 +0200JScript(~JScript@45.248.77.94)
2023-04-12 06:58:10 +0200 <institor> :!@t id
2023-04-12 06:59:17 +0200 <c_wraith> Axman6: lambdabot can, but it has the same restriction. and also the restriction that safe haskell allows the module
2023-04-12 07:04:23 +0200 <c_wraith> > compilerVersion
2023-04-12 07:04:24 +0200 <lambdabot> error: Variable not in scope: compilerVersion
2023-04-12 07:04:30 +0200 <c_wraith> @let import System.Info
2023-04-12 07:04:31 +0200 <lambdabot> Defined.
2023-04-12 07:04:33 +0200 <c_wraith> > compilerVersion
2023-04-12 07:04:34 +0200 <lambdabot> Version {versionBranch = [8,10], versionTags = []}
2023-04-12 07:05:11 +0200 <institor> > let import
2023-04-12 07:05:13 +0200 <lambdabot> <hint>:1:5: error: parse error on input ‘import’
2023-04-12 07:05:19 +0200 <institor> @let import Generics.SOP
2023-04-12 07:05:20 +0200 <lambdabot> /sandbox/tmp/.L.hs:132:1: error:
2023-04-12 07:05:20 +0200 <lambdabot> Could not find module ‘Generics.SOP’
2023-04-12 07:05:20 +0200 <lambdabot> Use -v (or `:set -v` in ghci) to see a list of the files searched for.
2023-04-12 07:05:24 +0200 <institor> rip
2023-04-12 07:05:29 +0200 <institor> generics-sop> Registering library for generics-sop-0.5.1.2..
2023-04-12 07:05:31 +0200 <institor> Completed 2 action(s).
2023-04-12 07:14:45 +0200michalz(~michalz@185.246.204.107)
2023-04-12 07:17:06 +0200bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-04-12 07:17:52 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds)
2023-04-12 07:20:25 +0200ddellacosta(~ddellacos@146.70.171.100) (Ping timeout: 250 seconds)
2023-04-12 07:21:13 +0200mniip_(mniip@libera/staff/mniip) (Quit: This page is intentionally left blank)
2023-04-12 07:21:18 +0200mniip(mniip@libera/staff/mniip)
2023-04-12 07:26:51 +0200remexre(~remexre@user/remexre) (Read error: Connection reset by peer)
2023-04-12 07:28:05 +0200JScript(~JScript@45.248.77.94) (Remote host closed the connection)
2023-04-12 07:29:13 +0200 <institor> i mean
2023-04-12 07:29:17 +0200 <institor> i'm not sure it typechecks
2023-04-12 07:29:28 +0200remexre(~remexre@user/remexre)
2023-04-12 07:30:22 +0200 <institor> > type family AllN (h :: (k -> Type) -> l -> Type) (c :: k -> Constraint) :: l -> Constraint
2023-04-12 07:30:24 +0200 <lambdabot> <hint>:1:1: error: parse error on input ‘type’
2023-04-12 07:30:32 +0200 <institor> `(c :: k -> Constraint)`
2023-04-12 07:33:59 +0200 <institor> @hoogle hcmap
2023-04-12 07:33:59 +0200 <lambdabot> Generics.SOP hcmap :: (AllN (Prod h) c xs, HAp h) => proxy c -> (forall (a :: k) . c a => f a -> f' a) -> h f xs -> h f' xs
2023-04-12 07:33:59 +0200 <lambdabot> Data.SOP hcmap :: (AllN (Prod h) c xs, HAp h) => proxy c -> (forall a . c a => f a -> f' a) -> h f xs -> h f' xs
2023-04-12 07:33:59 +0200 <lambdabot> Data.SOP.Classes hcmap :: (AllN (Prod h) c xs, HAp h) => proxy c -> (forall a . c a => f a -> f' a) -> h f xs -> h f' xs
2023-04-12 07:34:22 +0200 <institor> ghci> :t hcmap
2023-04-12 07:34:24 +0200 <institor> hcmap
2023-04-12 07:34:26 +0200 <institor> :: forall {k} {l} {h :: (k -> *) -> l -> *} {c :: k -> Constraint}
2023-04-12 07:34:28 +0200 <institor> {xs :: l} {proxy :: (k -> Constraint) -> *} {f :: k -> *}
2023-04-12 07:34:30 +0200 <institor> {f' :: k -> *}.
2023-04-12 07:43:30 +0200 <institor> error:
2023-04-12 07:43:32 +0200 <institor> • Couldn't match kind ‘*’ with ‘* -> Constraint’
2023-04-12 07:43:33 +0200 <institor> When matching types
2023-04-12 07:43:35 +0200 <institor> proxy0 :: (* -> Constraint) -> *
2023-04-12 07:43:37 +0200 <institor> Proxy :: * -> *
2023-04-12 07:43:40 +0200 <institor> Expected: proxy0 c1
2023-04-12 07:43:41 +0200 <institor> Actual: Proxy c0
2023-04-12 07:43:44 +0200 <institor> • In the first argument of ‘hcmap’, namely ‘(Proxy :: (Proxy c))’
2023-04-12 07:45:42 +0200 <probie> Clinton[m]: does something like https://paste.tomsmeding.com/XgcL37pd meet your requirements?
2023-04-12 07:46:40 +0200offtherock(~blurb@96.45.2.121)
2023-04-12 07:48:39 +0200 <probie> I may have just moved `accessors` into a where without cleaning up the signature xD
2023-04-12 07:49:16 +0200rburkholder(~blurb@96.45.2.121) (Ping timeout: 255 seconds)
2023-04-12 07:49:53 +0200kenran(~user@user/kenran)
2023-04-12 07:50:28 +0200 <probie> https://paste.tomsmeding.com/J0P2flH7 is a bit neater
2023-04-12 07:56:50 +0200gurkenglas(~gurkengla@dynamic-046-114-183-049.46.114.pool.telefonica.de)
2023-04-12 07:57:11 +0200 <Axman6> institor: please don't do that
2023-04-12 07:57:15 +0200 <Axman6> @where paste
2023-04-12 07:57:15 +0200 <lambdabot> Help us help you: please paste full code, input and/or output at e.g. https://paste.tomsmeding.com
2023-04-12 08:02:45 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 255 seconds)
2023-04-12 08:04:29 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-04-12 08:10:02 +0200hugo(znc@verdigris.lysator.liu.se) (Ping timeout: 246 seconds)
2023-04-12 08:13:44 +0200 <Clinton[m]> <probie> "Clinton: does something like..." <- Very very nice! I've shortened your code to this btw:... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/454a2e2151b69ebd0e721beb99b7a571241d…>)
2023-04-12 08:14:08 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-04-12 08:14:33 +0200mastarija(~mastarija@2a05:4f46:e03:6000:a9d6:2c1d:3bed:e943)
2023-04-12 08:16:00 +0200 <Clinton[m]> Thanks probie !
2023-04-12 08:21:56 +0200 <Clinton[m]> probie: can you explain what `genAccs` is doing?
2023-04-12 08:24:14 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:e94a:711d:cca5:b3e)
2023-04-12 08:25:08 +0200hugo(znc@verdigris.lysator.liu.se)
2023-04-12 08:28:30 +0200 <Clinton[m]> probie: if you've got time that is, I can probably just dig through the types and work it out myself
2023-04-12 08:28:36 +0200 <Clinton[m]> probie: but thank you again!
2023-04-12 08:30:59 +0200 <probie> Clinton[m]: It generates the accessor functions. If it were just over lists, it'd be something like `f :: [b] -> [[a] -> a]`, `f [] = []; f (_:xs) = head: (map (. tail) (f xs))`
2023-04-12 08:31:31 +0200 <probie> It takes a list describing the shape, and from that produces a list of functions, where the nth element of that list is a function which takes a list and returns the nth element
2023-04-12 08:31:44 +0200coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-04-12 08:34:28 +0200acidjnk(~acidjnk@p200300d6e715c435781b7adab6bb3c42.dip0.t-ipconnect.de)
2023-04-12 08:38:04 +0200 <probie> Given a type like `NP I '[Int, Char, Bool]` the base case gives us a `NP ((->) NP I '[]) '[]`, next we produce a `NP ((->) NP I '[Bool]) '[Bool]` next, a `NP ((->) NP I '[Char, Bool]) '[Char, Bool]` and then a `NP ((->) NP I '[Int, Char, Bool]) '[Int, Char, Bool]`
2023-04-12 08:39:49 +0200 <probie> and then `accessor` just takes that final result and turns it into a `NP ((->) a) '[Int, Char, Bool]` (assuming SOP.ProductCode a ~ '[Int, Char, Bool])
2023-04-12 08:40:22 +0200 <probie> s/accessor/accessors/
2023-04-12 08:43:15 +0200freeside(~mengwong@50.216.111.242) (Ping timeout: 255 seconds)
2023-04-12 08:43:18 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-04-12 08:43:18 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-04-12 08:43:18 +0200wroathe(~wroathe@user/wroathe)
2023-04-12 08:44:08 +0200freeside(~mengwong@50.216.111.242)
2023-04-12 08:47:13 +0200razetime(~Thunderbi@117.193.5.39) (Quit: See You Space Cowboy)
2023-04-12 08:47:51 +0200 <probie> tl;dr, genAccs produces a list like `[head, head . tail, head . tail . tail, head . tail . tail . tail...` of the needed length
2023-04-12 08:48:11 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds)
2023-04-12 08:48:47 +0200freeside(~mengwong@50.216.111.242) (Ping timeout: 264 seconds)
2023-04-12 08:50:22 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 276 seconds)
2023-04-12 08:57:58 +0200son0p(~ff@181.136.122.143) (Ping timeout: 268 seconds)
2023-04-12 09:02:13 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-04-12 09:03:40 +0200 <jackdk> probie: `[car, cadr, caadr, caaadr, ...`?
2023-04-12 09:19:24 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2023-04-12 09:20:16 +0200shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 276 seconds)
2023-04-12 09:24:50 +0200freeside(~mengwong@50.216.111.242)
2023-04-12 09:28:22 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-04-12 09:30:50 +0200MasseR46(thelounge@2001:bc8:47a0:1521::1) (Quit: The Lounge - https://thelounge.chat)
2023-04-12 09:31:58 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-04-12 09:37:28 +0200bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-04-12 09:37:58 +0200kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-04-12 09:38:17 +0200 <fendor[m]> can I say in lens, this tuple has at least the size three? I want to write some code that works with a three element tuple as well as five element tuple, but the last two values are irrelevant to me.
2023-04-12 09:38:39 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-04-12 09:39:13 +0200 <kuribas> fendor[m]: just turn the 5-tuple in a 3-tuple before the function then?
2023-04-12 09:39:23 +0200 <kuribas> Or write a single "adapter" function.
2023-04-12 09:40:03 +0200vglfr(~vglfr@88.155.17.187) (Read error: Connection reset by peer)
2023-04-12 09:42:07 +0200 <fendor[m]> right, that's what I was going to do, but I was wondering whether lens may be giving me something already
2023-04-12 09:43:13 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (*.net *.split)
2023-04-12 09:43:13 +0200freeside(~mengwong@50.216.111.242) (*.net *.split)
2023-04-12 09:43:13 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (*.net *.split)
2023-04-12 09:43:13 +0200xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (*.net *.split)
2023-04-12 09:43:13 +0200pieguy128_(~pieguy128@bras-base-mtrlpq5031w-grc-50-65-93-192-141.dsl.bell.ca) (*.net *.split)
2023-04-12 09:43:13 +0200jwiegley_(~jwiegley@76-234-69-149.lightspeed.frokca.sbcglobal.net) (*.net *.split)
2023-04-12 09:43:13 +0200Sauvin(~sauvin@user/Sauvin) (*.net *.split)
2023-04-12 09:43:13 +0200gry(st@botters/gry) (*.net *.split)
2023-04-12 09:43:13 +0200institor(~absentia@user/institor) (*.net *.split)
2023-04-12 09:43:13 +0200xstill_5(xstill@fimu/xstill) (*.net *.split)
2023-04-12 09:43:13 +0200xsarnik(xsarnik@lounge.fi.muni.cz) (*.net *.split)
2023-04-12 09:43:14 +0200dunj3(~dunj3@kingdread.de) (*.net *.split)
2023-04-12 09:43:14 +0200turlando(~turlando@user/turlando) (*.net *.split)
2023-04-12 09:43:14 +0200[Leary](~Leary]@user/Leary/x-0910699) (*.net *.split)
2023-04-12 09:43:14 +0200adium(adium@user/adium) (*.net *.split)
2023-04-12 09:43:14 +0200mcglk(~mcglk@131.191.19.145) (*.net *.split)
2023-04-12 09:43:14 +0200byorgey(~byorgey@155.138.238.211) (*.net *.split)
2023-04-12 09:43:14 +0200micro(~micro@user/micro) (*.net *.split)
2023-04-12 09:43:14 +0200davean(~davean@davean.sciesnet.net) (*.net *.split)
2023-04-12 09:43:14 +0200anderson(~ande@user/anderson) (*.net *.split)
2023-04-12 09:43:14 +0200madnight(~madnight@static.59.103.201.195.clients.your-server.de) (*.net *.split)
2023-04-12 09:43:14 +0200Cheery(~cheery@server-239-7.tentacle.cloud) (*.net *.split)
2023-04-12 09:43:14 +0200phileasfogg(~phileasfo@user/phileasfogg) (*.net *.split)
2023-04-12 09:43:14 +0200kraftwerk28(~kraftwerk@178.62.210.83) (*.net *.split)
2023-04-12 09:43:14 +0200Dykam(Dykam@dykam.nl) (*.net *.split)
2023-04-12 09:43:14 +0200meejah(~meejah@rutas.meejah.ca) (*.net *.split)
2023-04-12 09:43:14 +0200heath1(~heath@user/heath) (*.net *.split)
2023-04-12 09:43:14 +0200noctux1(Zx24REiiwW@user/noctux) (*.net *.split)
2023-04-12 09:43:14 +0200dfordvm(~dfordivam@tk2-219-19469.vs.sakura.ne.jp) (*.net *.split)
2023-04-12 09:43:14 +0200guygastineau(~guygastin@137.184.131.156) (*.net *.split)
2023-04-12 09:43:14 +0200davl_(~davl@207.154.228.18) (*.net *.split)
2023-04-12 09:43:14 +0200robbert-vdh(~robbert@robbertvanderhelm.nl) (*.net *.split)
2023-04-12 09:43:14 +0200ario(~ario@159.65.220.102) (*.net *.split)
2023-04-12 09:43:14 +0200defanor(~defanor@tart.uberspace.net) (*.net *.split)
2023-04-12 09:43:14 +0200hank_(~hank@45-33-24-80.ip.linodeusercontent.com) (*.net *.split)
2023-04-12 09:43:15 +0200DigitalKiwi(~kiwi@137.184.156.191) (*.net *.split)
2023-04-12 09:43:15 +0200nicole(ilbelkyr@libera/staff/ilbelkyr) (*.net *.split)
2023-04-12 09:43:22 +0200comerijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-04-12 09:43:24 +0200byorgey(~byorgey@155.138.238.211)
2023-04-12 09:43:25 +0200xsarnik(xsarnik@lounge.fi.muni.cz)
2023-04-12 09:43:27 +0200dunj3(~dunj3@kingdread.de)
2023-04-12 09:43:28 +0200defanor(~defanor@tart.uberspace.net)
2023-04-12 09:43:31 +0200institor(~absentia@66.234.62.215)
2023-04-12 09:43:31 +0200nicole(ilbelkyr@libera/staff/ilbelkyr)
2023-04-12 09:43:35 +0200micro(~micro@a9.lence.net)
2023-04-12 09:43:43 +0200ario(~ario@159.65.220.102)
2023-04-12 09:43:44 +0200jwiegley(~jwiegley@76-234-69-149.lightspeed.frokca.sbcglobal.net)
2023-04-12 09:43:52 +0200dfordvm(~dfordivam@tk2-219-19469.vs.sakura.ne.jp)
2023-04-12 09:43:58 +0200micro(~micro@a9.lence.net) (Changing host)
2023-04-12 09:43:58 +0200micro(~micro@user/micro)
2023-04-12 09:44:35 +0200Cheery(~cheery@server-239-7.tentacle.cloud)
2023-04-12 09:44:35 +0200freeside(~mengwong@50.216.111.242)
2023-04-12 09:44:40 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2023-04-12 09:44:51 +0200xstill_(xstill@fimu/xstill)
2023-04-12 09:45:00 +0200noctux1(vBYKluURgE@karif.server-speed.net)
2023-04-12 09:45:37 +0200Dykam(Dykam@dykam.nl)
2023-04-12 09:45:38 +0200Sauvin(~sauvin@user/Sauvin)
2023-04-12 09:45:41 +0200pieguy128(~pieguy128@bras-base-mtrlpq5031w-grc-50-65-93-192-141.dsl.bell.ca)
2023-04-12 09:45:41 +0200turlando(~turlando@user/turlando)
2023-04-12 09:45:44 +0200madnight(~madnight@static.59.103.201.195.clients.your-server.de)
2023-04-12 09:45:53 +0200enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7)
2023-04-12 09:46:05 +0200phileasfogg(~phileasfo@user/phileasfogg)
2023-04-12 09:46:06 +0200anderson(~ande@user/anderson)
2023-04-12 09:46:08 +0200DigitalKiwi(~kiwi@2604:a880:400:d0::1ca0:e001)
2023-04-12 09:46:09 +0200kraftwerk28(~kraftwerk@178.62.210.83)
2023-04-12 09:46:19 +0200davl(~davl@207.154.228.18)
2023-04-12 09:46:24 +0200[Leary](~Leary]@user/Leary/x-0910699)
2023-04-12 09:46:35 +0200RMSBach(~guygastin@137.184.131.156)
2023-04-12 09:46:38 +0200davean(~davean@davean.sciesnet.net)
2023-04-12 09:46:43 +0200heath1(~heath@user/heath)
2023-04-12 09:46:56 +0200adium(adium@user/adium)
2023-04-12 09:47:01 +0200robbert-vdh(~robbert@robbertvanderhelm.nl)
2023-04-12 09:47:45 +0200xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-04-12 09:48:43 +0200meejah(~meejah@rutas.meejah.ca)
2023-04-12 09:49:21 +0200 <kuribas> Why do I it easy, when there is a complicated solution?
2023-04-12 09:50:48 +0200 <c_wraith> kuribas: the lenses for tuple access are already polytypic...
2023-04-12 09:50:53 +0200mcglk(~mcglk@131.191.19.145)
2023-04-12 09:51:11 +0200 <c_wraith> > (1,2,3) ^. _3
2023-04-12 09:51:12 +0200 <lambdabot> 3
2023-04-12 09:51:16 +0200 <c_wraith> > (1,2,3,4,5) ^. _3
2023-04-12 09:51:18 +0200 <lambdabot> 3
2023-04-12 09:51:45 +0200 <mauke> inb4 costate comonad coalgebra
2023-04-12 09:51:47 +0200 <kuribas> c_wraith: sure, but they'll complicate the function signature.
2023-04-12 09:52:04 +0200 <kuribas> Btw, I would likely use a record instead of a tuple.
2023-04-12 09:52:25 +0200 <fendor[m]> kuribas: since it is in the context of beam, it is not as easy as I would like it to be
2023-04-12 09:52:39 +0200 <fendor[m]> or I am just not smart enough
2023-04-12 09:52:40 +0200 <c_wraith> I mean, they complicate it in exactly the way that says "this data structure has a third element"
2023-04-12 09:53:31 +0200 <kuribas> fendor[m]: ah right ... Yeah, I find beam tends to be quite complicated.
2023-04-12 09:53:57 +0200 <fendor[m]> it is, it is... Cool, but very complicated.
2023-04-12 09:55:11 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-04-12 10:00:58 +0200institor(~absentia@66.234.62.215) (Changing host)
2023-04-12 10:00:58 +0200institor(~absentia@user/institor)
2023-04-12 10:10:03 +0200enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) (Quit: enoq)
2023-04-12 10:11:22 +0200vpan(~0@mail.elitnet.lt)
2023-04-12 10:12:22 +0200enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7)
2023-04-12 10:19:27 +0200Guest12345(~Guest1234@79.191.65.29.ipv4.supernova.orange.pl)
2023-04-12 10:20:01 +0200Guest12345(~Guest1234@79.191.65.29.ipv4.supernova.orange.pl) (Quit: Connection closed)
2023-04-12 10:21:25 +0200barcisz(~barcisz@79.191.65.29.ipv4.supernova.orange.pl)
2023-04-12 10:28:21 +0200 <[exa]> would be nice if GHC or hlint spewed a warning like "You might want to finally name the fields in this 6-tuple"
2023-04-12 10:29:32 +0200 <Rembane> Isn't it possible to add custom hlint rules?
2023-04-12 10:29:45 +0200 <Rembane> ...or is that me who has hallucinated that when on too much mountain dew?
2023-04-12 10:31:05 +0200 <[exa]> well, you can always download the hlint source and just add them, which kinda matches the mountain dew solution
2023-04-12 10:31:07 +0200jtza8(~user@165.255.63.78)
2023-04-12 10:31:33 +0200 <Rembane> Too much mountain dew. I hoped there was a .hlint-rules file in the project folder.
2023-04-12 10:31:51 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:ad1e:c088:4c6f:8ed8) (Remote host closed the connection)
2023-04-12 10:32:14 +0200__monty__(~toonn@user/toonn)
2023-04-12 10:35:15 +0200zer0bitz_(~zer0bitz@2001:2003:f443:d600:c8fb:80d:3f21:d12f) ()
2023-04-12 10:37:58 +0200 <jtza8> I've got a small personal project that I'm trying to build for my Termux environment on my android phone. I've tried to build my project directly on my phone, but I seem to run out of memory. Are there any known tricks I could use to build something in a limited-memory environment?
2023-04-12 10:39:04 +0200 <jtza8> I'm using GHC 9.2.5, cabal-install and the cabal.config from the Stackage lts-20.11.
2023-04-12 10:39:41 +0200 <jtza8> The largest dependancy is probably scotty.
2023-04-12 10:41:07 +0200zer0bitz(~zer0bitz@2001:2003:f443:d600:c8fb:80d:3f21:d12f)
2023-04-12 10:41:43 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 265 seconds)
2023-04-12 10:44:09 +0200olle(~olle@h-155-4-129-160.NA.cust.bahnhof.se) ()
2023-04-12 10:51:04 +0200raym(~ray@user/raym) (Ping timeout: 255 seconds)
2023-04-12 10:55:01 +0200 <tomsmeding> jtza8: using cabal build -j1, for starters
2023-04-12 10:55:55 +0200 <tomsmeding> you may also try to set 'ghc-options: +RTS -M2G -RTS', which sets GHC's maximum heap size to 2 GiB
2023-04-12 10:56:05 +0200tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2023-04-12 10:56:11 +0200mncheck(~mncheck@193.224.205.254)
2023-04-12 10:56:14 +0200 <tomsmeding> (change the 2 to whatever you want, note that "heap size 2GiB" does not necessarily mean "resident memory usage 2GiB")
2023-04-12 10:56:27 +0200 <tomsmeding> also turn off optimisations, i.e. ghc-options: -O0
2023-04-12 10:56:48 +0200 <tomsmeding> (there's probably a cabal.project flag for the latter)
2023-04-12 10:57:05 +0200zer0bitz_(~zer0bitz@2001:2003:f443:d600:4118:2d56:8c2b:a747)
2023-04-12 10:57:48 +0200zer0bitz_(~zer0bitz@2001:2003:f443:d600:4118:2d56:8c2b:a747) (Client Quit)
2023-04-12 10:58:16 +0200zer0bitz(~zer0bitz@2001:2003:f443:d600:c8fb:80d:3f21:d12f) (Ping timeout: 252 seconds)
2023-04-12 10:59:36 +0200mikess(~sam@user/mikess) (Ping timeout: 255 seconds)
2023-04-12 11:00:08 +0200joebe[m](~joebematr@2001:470:69fc:105::3:2c53) (Quit: You have been kicked for being idle)
2023-04-12 11:01:51 +0200ubert(~Thunderbi@2a02:8109:abc0:6434:2d8a:83f8:5c8d:71a3)
2023-04-12 11:02:23 +0200 <jtza8> tomsmeding: Thank you for your answer. I realise it's a bit of a foolhardy thing to do, but if this works I won't need to try and figure out how to get cross-compiling to work just yet. :P
2023-04-12 11:02:49 +0200 <tomsmeding> jtza8: I've been in a similar situation trying to compile stuff on a cheap VPS
2023-04-12 11:03:00 +0200 <tomsmeding> at some point I gave up and gave the thing 4 GiB of swap space
2023-04-12 11:03:12 +0200zer0bitz(~zer0bitz@2001:2003:f443:d600:4118:2d56:8c2b:a747)
2023-04-12 11:03:23 +0200 <tomsmeding> that was just enough to get aeson and vector to compile, iirc
2023-04-12 11:03:38 +0200azimut_(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-04-12 11:03:40 +0200 <tomsmeding> (though I didn't disable optimisations)
2023-04-12 11:04:08 +0200 <__monty__> jtza8: FWIW, I hear cross-compilation can be pretty "easy" using Nix.
2023-04-12 11:04:33 +0200 <tomsmeding> question is, does nix support termux-android as a compilation target
2023-04-12 11:04:41 +0200 <tomsmeding> which undoubtedly is not quite the usual ARM target
2023-04-12 11:05:19 +0200 <__monty__> I didn't think the Termux part would matter?
2023-04-12 11:05:27 +0200 <tomsmeding> libraries and stuff are in weird places
2023-04-12 11:05:39 +0200 <tomsmeding> but yeah maybe it matters less than I fear
2023-04-12 11:06:03 +0200tomsmedingwonders how much the termux ghc is patched
2023-04-12 11:06:25 +0200 <__monty__> I don't actually have experience with cross-compiling so, caveat emptor.
2023-04-12 11:08:19 +0200ft(~ft@p4fc2a88b.dip0.t-ipconnect.de) (Quit: leaving)
2023-04-12 11:10:22 +0200forell(~forell@user/forell) (Quit: ZNC - https://znc.in)
2023-04-12 11:10:32 +0200son0p(~ff@181.136.122.143)
2023-04-12 11:11:46 +0200 <jtza8> __monty__: Haskell.nix seems to be a good way to go. And they have support for Android (which has a non-GNU libc.)
2023-04-12 11:12:38 +0200 <jtza8> I'm just a little new to Nix too. Although it's been a delight to use so far.
2023-04-12 11:12:41 +0200forell(~forell@user/forell)
2023-04-12 11:19:36 +0200zaquest(~notzaques@5.130.79.72) (Remote host closed the connection)
2023-04-12 11:22:03 +0200zeenk(~zeenk@2a02:2f04:a307:2300::7fe)
2023-04-12 11:23:07 +0200mechap(~mechap@user/mechap) (Quit: WeeChat 3.8)
2023-04-12 11:25:55 +0200NiceBird(~NiceBird@185.133.111.196)
2023-04-12 11:27:12 +0200sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-04-12 11:27:42 +0200megaTherion(~therion@unix.io) (Quit: ZNC 1.8.2 - https://znc.in)
2023-04-12 11:28:34 +0200sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-04-12 11:29:25 +0200megaTherion(~therion@unix.io)
2023-04-12 11:30:20 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf) (Quit: use-value)
2023-04-12 11:30:24 +0200econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2023-04-12 11:32:19 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6)
2023-04-12 11:37:13 +0200gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2023-04-12 11:37:49 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6) (Ping timeout: 250 seconds)
2023-04-12 11:39:52 +0200zmt00(~zmt00@user/zmt00)
2023-04-12 11:42:16 +0200raym(~ray@user/raym)
2023-04-12 11:43:01 +0200zmt01(~zmt00@user/zmt00) (Ping timeout: 250 seconds)
2023-04-12 11:44:35 +0200jtza8(~user@165.255.63.78) (ERC 5.4 (IRC client for GNU Emacs 28.2))
2023-04-12 11:46:19 +0200chanceyan(~chanceyan@user/chanceyan) (Quit: Client closed)
2023-04-12 11:50:34 +0200razetime(~Thunderbi@117.193.5.39)
2023-04-12 12:02:51 +0200cfricke(~cfricke@user/cfricke)
2023-04-12 12:05:29 +0200vglfr(~vglfr@88.155.5.190)
2023-04-12 12:07:08 +0200gtdg(~gtdg@user/gtdg)
2023-04-12 12:15:03 +0200dsrt^(~dsrt@c-76-105-96-13.hsd1.ga.comcast.net) (Remote host closed the connection)
2023-04-12 12:16:59 +0200pavonia(~user@user/siracusa) (Quit: Bye!)
2023-04-12 12:23:25 +0200vglfr(~vglfr@88.155.5.190) (Ping timeout: 240 seconds)
2023-04-12 12:24:22 +0200vglfr(~vglfr@88.155.5.190)
2023-04-12 12:25:38 +0200xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 265 seconds)
2023-04-12 12:25:44 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6)
2023-04-12 12:39:41 +0200JScript(~JScript@144.48.39.6)
2023-04-12 12:42:28 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-04-12 12:49:19 +0200L29Ah(~L29Ah@wikipedia/L29Ah) (Ping timeout: 250 seconds)
2023-04-12 13:10:28 +0200razetime(~Thunderbi@117.193.5.39) (Quit: See You Space Cowboy)
2023-04-12 13:14:47 +0200L29Ah(~L29Ah@wikipedia/L29Ah)
2023-04-12 13:17:27 +0200xff0x(~xff0x@ai098135.d.east.v6connect.net)
2023-04-12 13:17:59 +0200kei(~kei@42.105.220.41)
2023-04-12 13:27:22 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-04-12 13:33:23 +0200paulpaul1076(~textual@95-29-5-208.broadband.corbina.ru) (Remote host closed the connection)
2023-04-12 13:38:53 +0200kei(~kei@42.105.220.41) (Ping timeout: 260 seconds)
2023-04-12 13:41:15 +0200kei(~kei@42.105.218.54)
2023-04-12 13:41:30 +0200stiell_(~stiell@gateway/tor-sasl/stiell)
2023-04-12 13:42:24 +0200pyook(~puke@user/puke) (Ping timeout: 248 seconds)
2023-04-12 13:42:29 +0200stiell(~stiell@gateway/tor-sasl/stiell) (Ping timeout: 255 seconds)
2023-04-12 13:43:11 +0200pyook(~puke@user/puke)
2023-04-12 13:45:16 +0200hopelessness[m]uploaded an image: (118KiB) < https://libera.ems.host/_matrix/media/v3/download/matrix.org/EKEKSNMTzltbkddHsOfuNQvW/SmartSelect_… >
2023-04-12 13:45:18 +0200 <hopelessness[m]> literally wow
2023-04-12 13:45:45 +0200 <tomsmeding> hopelessness[m]: where's that from?
2023-04-12 13:45:45 +0200 <hopelessness[m]> someone that writes haskell like this should not write about it
2023-04-12 13:45:51 +0200 <hopelessness[m]> just... don't
2023-04-12 13:46:00 +0200 <tomsmeding> but yes the spacing is kinda... off
2023-04-12 13:46:08 +0200 <hopelessness[m]> tutorialspoint ... they are awful
2023-04-12 13:46:42 +0200 <hopelessness[m]> tomsmeding: not even the formatting, I can look beyond that
2023-04-12 13:46:42 +0200 <tomsmeding> wonder what ghc version they have running on the backend
2023-04-12 13:46:46 +0200 <tomsmeding> true
2023-04-12 13:47:10 +0200 <hopelessness[m]> it's just horrible code, like they are trying to use it as an imperative language
2023-04-12 13:47:37 +0200 <hopelessness[m]> they nest do-blocks for no reason
2023-04-12 13:47:50 +0200 <tomsmeding> well, they're inside an if
2023-04-12 13:48:39 +0200 <comerijn> tbh, the biggest crime there is the then/else indentation
2023-04-12 13:48:44 +0200 <comerijn> the rest looks mostly fine, tbh
2023-04-12 13:49:11 +0200 <tomsmeding> ghc 8.8 apparently
2023-04-12 13:49:16 +0200 <comerijn> Pretty sure that requires one of those stupid relaxed if syntax rules that I'm not even sure are a part of 2010
2023-04-12 13:49:20 +0200 <tomsmeding> (System.Info.compilerVersion)
2023-04-12 13:49:30 +0200 <hopelessness[m]> they are "initializing" the list with something they are ignoring
2023-04-12 13:50:17 +0200 <hopelessness[m]> it's really really odd
2023-04-12 13:50:35 +0200 <tomsmeding> oh lol what
2023-04-12 13:50:45 +0200 <tomsmeding> I didn't even try to read what it was actually doing
2023-04-12 13:51:12 +0200 <hopelessness[m]> yeah, exactly
2023-04-12 13:51:58 +0200mud(~mud@user/kadoban) (Ping timeout: 276 seconds)
2023-04-12 13:52:01 +0200razetime(~Thunderbi@117.193.5.39)
2023-04-12 13:53:00 +0200 <int-e> . o O ( Today I learned: In Haskell, the empty list is denoted as [-1]. But in order to print it, you have to call `init` first. )
2023-04-12 13:54:38 +0200 <darkling> I think the icon in the top right is important. You clearly have to edit it first before it'll run.
2023-04-12 13:54:43 +0200 <tomsmeding> wait until you need an empty list of non-numbers
2023-04-12 13:55:01 +0200jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 265 seconds)
2023-04-12 13:55:16 +0200 <tomsmeding> it will actually run, though not usefully because the system provides no input on stdin
2023-04-12 14:01:48 +0200 <int-e> darkling: It does work as written though.
2023-04-12 14:02:45 +0200 <darkling> My brain just says that something that looks so horrible has no right to work. :)
2023-04-12 14:03:08 +0200 <int-e> darkling: Actually, it *did* work as written up to ghc 8.10
2023-04-12 14:03:12 +0200 <int-e> https://downloads.haskell.org/ghc/latest/docs/users_guide/bugs.html#context-free-syntax
2023-04-12 14:03:45 +0200 <int-e> (9.0 changed the language default to Haskell2010 rather than Haskell98)
2023-04-12 14:05:09 +0200 <tomsmeding> didn't they change it to GHC2021 instead?
2023-04-12 14:05:22 +0200 <int-e> tomsmeding: Uh, maybe.
2023-04-12 14:05:29 +0200 <int-e> darkling: I do agree, however, that it shouldn't work; accepting this totally defeats the purose of indentation.
2023-04-12 14:06:31 +0200razetime(~Thunderbi@117.193.5.39) (Quit: See You Space Cowboy)
2023-04-12 14:08:10 +0200notzmv(~zmv@user/notzmv) (Ping timeout: 260 seconds)
2023-04-12 14:09:09 +0200 <int-e> Oh I got it all wrong. 9.2 changed the default language, to GHC2021.
2023-04-12 14:09:34 +0200 <int-e> And that atrociously indented code is still accepted by default in 9.0
2023-04-12 14:11:48 +0200kei(~kei@42.105.218.54) (Quit: Client closed)
2023-04-12 14:12:54 +0200razetime(~Thunderbi@117.193.5.39)
2023-04-12 14:31:33 +0200kenran(~user@user/kenran) (Ping timeout: 255 seconds)
2023-04-12 14:53:38 +0200razetime(~Thunderbi@117.193.5.39) (Remote host closed the connection)
2023-04-12 14:54:40 +0200razetime(~Thunderbi@117.193.5.39)
2023-04-12 15:05:43 +0200biberu(~biberu@user/biberu) (Read error: Connection reset by peer)
2023-04-12 15:08:06 +0200 <juri_> oh, thank god, that screenshot isn't my code.
2023-04-12 15:09:19 +0200razetime(~Thunderbi@117.193.5.39) (Quit: See You Space Cowboy)
2023-04-12 15:10:31 +0200 <juri_> i've been working on my slicer for long enough, and it's become large enough, that on occasion, i go to a section of the program i haven't had to touch in a long time, go "who wrote this crap?", then think oh. its me. i wrote that utter shite.
2023-04-12 15:11:52 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6) (Quit: use-value)
2023-04-12 15:13:33 +0200biberu(~biberu@user/biberu)
2023-04-12 15:15:06 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6)
2023-04-12 15:15:46 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6) (Client Quit)
2023-04-12 15:16:28 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6)
2023-04-12 15:18:11 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6) (Client Quit)
2023-04-12 15:20:51 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6)
2023-04-12 15:23:16 +0200paulpaul1076(~textual@95-29-5-208.broadband.corbina.ru)
2023-04-12 15:27:34 +0200razetime(~Thunderbi@117.193.5.39)
2023-04-12 15:28:38 +0200razetime(~Thunderbi@117.193.5.39) (Client Quit)
2023-04-12 15:31:46 +0200gensyst(~gensyst@user/gensyst)
2023-04-12 15:32:15 +0200zer0bitz_(~zer0bitz@2001:2003:f443:d600:1d40:2e2d:a29f:cc19)
2023-04-12 15:32:48 +0200zer0bitz(~zer0bitz@2001:2003:f443:d600:4118:2d56:8c2b:a747) (Ping timeout: 246 seconds)
2023-04-12 15:34:24 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2023-04-12 15:34:35 +0200segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-04-12 15:34:42 +0200 <gensyst> When you have "extra-libraries" in .cabal, why does Nix/haskellPackages seem to grab these things from the haskellPackages as opposed to the top-level nixpkgs?
2023-04-12 15:34:56 +0200 <gensyst> extra-libraries are supposed to be system libraries right?
2023-04-12 15:34:56 +0200__monty__(~toonn@user/toonn)
2023-04-12 15:36:47 +0200MasseR46(thelounge@2001:bc8:47a0:1521::1)
2023-04-12 15:37:54 +0200kenran(~user@user/kenran)
2023-04-12 15:40:08 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-04-12 15:41:10 +0200 <Artem[m]> gensyst: you may have better luck asking in the Nix Haskell Matrix room https://matrix.to/#/#haskell:nixos.org
2023-04-12 15:47:30 +0200xff0x(~xff0x@ai098135.d.east.v6connect.net) (Quit: xff0x)
2023-04-12 15:49:05 +0200segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 240 seconds)
2023-04-12 15:52:49 +0200xff0x(~xff0x@2405:6580:b080:900:22cb:546d:6546:a19b)
2023-04-12 15:53:44 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-04-12 15:55:46 +0200angelore(~u0_a291@37.214.66.179)
2023-04-12 15:56:10 +0200angelore(~u0_a291@37.214.66.179) (Client Quit)
2023-04-12 15:59:30 +0200mikess(~sam@user/mikess)
2023-04-12 16:01:01 +0200Square(~Square4@user/square)
2023-04-12 16:02:51 +0200ddellacosta(~ddellacos@146.70.166.152)
2023-04-12 16:06:34 +0200 <yin> is the set of legal symbols for infix type synonyms the same as for any infix function?
2023-04-12 16:08:41 +0200 <comerijn> yin: I think so
2023-04-12 16:10:41 +0200thegeekinside(~thegeekin@189.217.90.138)
2023-04-12 16:11:21 +0200 <yin> oh but we can start a type synonym with :
2023-04-12 16:15:30 +0200michalz(~michalz@185.246.204.107) (Ping timeout: 255 seconds)
2023-04-12 16:15:33 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2023-04-12 16:15:49 +0200segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-04-12 16:16:06 +0200__monty__(~toonn@user/toonn)
2023-04-12 16:16:58 +0200notzmv(~zmv@user/notzmv)
2023-04-12 16:17:37 +0200 <comerijn> yin: Originaly you *had* to use : for type synonyms, because they followed the logic that the valid syntax for them matches constructors (and : is the canonical "capital" symbol used for infix constructors)
2023-04-12 16:18:20 +0200 <comerijn> yin: At some point they relaxed to the rule for infix type synonyms to no longer require a starting :, abandonning the constructor naming scheme that applies for "normal" type synonyms, etc.
2023-04-12 16:18:37 +0200 <comerijn> Hence the inconsistency
2023-04-12 16:18:55 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:e94a:711d:cca5:b3e) (Quit: WeeChat 2.8)
2023-04-12 16:20:07 +0200 <yin> i came across some code that had non-: infix type synonyms and found it weird. thanks for the explanation
2023-04-12 16:24:02 +0200jero98772(~jero98772@190.158.28.80)
2023-04-12 16:26:25 +0200segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 250 seconds)
2023-04-12 16:27:25 +0200JScript(~JScript@144.48.39.6) (Ping timeout: 240 seconds)
2023-04-12 16:30:41 +0200freeside(~mengwong@50.216.111.242) (Ping timeout: 265 seconds)
2023-04-12 16:31:16 +0200 <probie> They seem fairly common these days, especially when the type synonym looks like an arrow
2023-04-12 16:31:23 +0200ddellacosta(~ddellacos@146.70.166.152) (Quit: WeeChat 3.8)
2023-04-12 16:31:34 +0200 <albet70> what's eDSLs?
2023-04-12 16:32:11 +0200 <Square> embedded DSL?
2023-04-12 16:32:30 +0200ddellacosta(~ddellacos@146.70.166.152)
2023-04-12 16:34:20 +0200 <Square> http://wiki.haskell.org/Embedded_domain_specific_language
2023-04-12 16:37:11 +0200segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-04-12 16:37:40 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6)
2023-04-12 16:41:57 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6) (Ping timeout: 256 seconds)
2023-04-12 16:42:33 +0200cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.8)
2023-04-12 16:46:54 +0200shriekingnoise(~shrieking@186.137.175.87)
2023-04-12 16:53:07 +0200hueso(~root@user/hueso) (Ping timeout: 260 seconds)
2023-04-12 16:54:46 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Quit: WeeChat 3.8)
2023-04-12 16:58:14 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-04-12 16:58:29 +0200tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2023-04-12 16:59:49 +0200ddellacosta(~ddellacos@146.70.166.152) (Ping timeout: 276 seconds)
2023-04-12 17:01:12 +0200ddellacosta(~ddellacos@143.244.47.83)
2023-04-12 17:01:29 +0200Sgeo(~Sgeo@user/sgeo)
2023-04-12 17:02:30 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-04-12 17:05:59 +0200zeenk(~zeenk@2a02:2f04:a307:2300::7fe) (Quit: Konversation terminated!)
2023-04-12 17:23:12 +0200kenran(~user@user/kenran) (Ping timeout: 248 seconds)
2023-04-12 17:27:21 +0200mcglk(~mcglk@131.191.19.145) (Quit: (seeya))
2023-04-12 17:28:53 +0200 <probie> Is there much prior art on generics that support GADTs, or is this a mostly empty space? I can find kind-generics which seems seldom used. Are there other approaches?
2023-04-12 17:35:35 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6)
2023-04-12 17:39:21 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6) (Quit: use-value)
2023-04-12 17:40:01 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6)
2023-04-12 17:41:44 +0200cheater_(~Username@user/cheater)
2023-04-12 17:43:39 +0200cheater(~Username@user/cheater) (Ping timeout: 248 seconds)
2023-04-12 17:43:40 +0200cheater_cheater
2023-04-12 17:44:28 +0200mbuf(~Shakthi@49.207.178.186) (Quit: Leaving)
2023-04-12 17:46:13 +0200gtdg(~gtdg@user/gtdg) (Ping timeout: 260 seconds)
2023-04-12 17:49:00 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6) (Quit: use-value)
2023-04-12 17:49:40 +0200mikess(~sam@user/mikess) (Ping timeout: 252 seconds)
2023-04-12 17:49:46 +0200 <TheMatten[m]> <probie> "Is there much prior art on..." <- I have an old prototype of generics interface using `DataKinds` - I think it should be extensible with support for GADTs by adding existential and dictionary constructor: https://gitlab.com/thematten/simple-generics/-/blob/master/src/Generics/Simple.hs
2023-04-12 17:51:20 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:95f6:6e4e:c0f4:2cf2)
2023-04-12 17:57:20 +0200dipper(~dipper@203.168.11.65) (Ping timeout: 248 seconds)
2023-04-12 17:57:30 +0200econo(uid147250@user/econo)
2023-04-12 17:58:36 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6)
2023-04-12 17:59:01 +0200vpan(~0@mail.elitnet.lt) (Quit: Leaving.)
2023-04-12 18:04:59 +0200kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Remote host closed the connection)
2023-04-12 18:08:58 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6) (Remote host closed the connection)
2023-04-12 18:14:36 +0200freeside(~mengwong@68.65.175.90)
2023-04-12 18:16:01 +0200jle`(~jle`@cpe-23-240-75-236.socal.res.rr.com) (Ping timeout: 265 seconds)
2023-04-12 18:17:38 +0200jle`(~jle`@cpe-23-240-75-236.socal.res.rr.com)
2023-04-12 18:18:11 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 264 seconds)
2023-04-12 18:18:25 +0200hugo(znc@verdigris.lysator.liu.se) (Ping timeout: 260 seconds)
2023-04-12 18:18:56 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6) (Quit: use-value)
2023-04-12 18:19:56 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-04-12 18:20:04 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6)
2023-04-12 18:20:58 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6) (Client Quit)
2023-04-12 18:23:08 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:95f6:6e4e:c0f4:2cf2) (Quit: WeeChat 2.8)
2023-04-12 18:32:03 +0200hugo(znc@verdigris.lysator.liu.se)
2023-04-12 18:42:37 +0200zmt00(~zmt00@user/zmt00) (Quit: Leaving)
2023-04-12 18:53:14 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6)
2023-04-12 19:00:55 +0200Alex_test(~al_test@178.34.162.18) (Quit: ;-)
2023-04-12 19:01:34 +0200AlexZenon(~alzenon@178.34.162.18) (Quit: ;-)
2023-04-12 19:02:31 +0200AlexNoo(~AlexNoo@178.34.162.18) (Quit: Leaving)
2023-04-12 19:03:25 +0200ubert(~Thunderbi@2a02:8109:abc0:6434:2d8a:83f8:5c8d:71a3) (Remote host closed the connection)
2023-04-12 19:03:39 +0200ubert(~Thunderbi@2a02:8109:abc0:6434:bd33:950c:bf25:e78b)
2023-04-12 19:05:55 +0200kimjetwav(~user@2607:fea8:235e:b600:f874:36b2:8b2c:6f8c)
2023-04-12 19:06:17 +0200mikess(~sam@user/mikess)
2023-04-12 19:07:10 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6) (Remote host closed the connection)
2023-04-12 19:09:02 +0200AlexNoo(~AlexNoo@178.34.162.18)
2023-04-12 19:11:07 +0200Square2(~Square4@user/square)
2023-04-12 19:11:12 +0200mikess(~sam@user/mikess) (Ping timeout: 246 seconds)
2023-04-12 19:13:16 +0200Square(~Square4@user/square) (Ping timeout: 252 seconds)
2023-04-12 19:16:34 +0200hochata(~user@user/hochata)
2023-04-12 19:16:54 +0200AlexZenon(~alzenon@178.34.162.18)
2023-04-12 19:17:07 +0200ubert(~Thunderbi@2a02:8109:abc0:6434:bd33:950c:bf25:e78b) (Quit: ubert)
2023-04-12 19:17:15 +0200hochata`(~user@2806:104e:1b:41de:3e48:b302:2801:10c5)
2023-04-12 19:18:25 +0200hochata`(~user@2806:104e:1b:41de:3e48:b302:2801:10c5) (Client Quit)
2023-04-12 19:18:41 +0200hochata(~user@user/hochata) (Client Quit)
2023-04-12 19:19:08 +0200hochata(~user@user/hochata)
2023-04-12 19:23:11 +0200olle(~olle@h-155-4-129-160.NA.cust.bahnhof.se)
2023-04-12 19:24:26 +0200irrgit(~irrgit@86.106.90.226)
2023-04-12 19:25:17 +0200 <olle> Regarding deferred If you *can* defer, say, a write, *should* you defer it?
2023-04-12 19:25:26 +0200 <olle> Regarding deferred effects*
2023-04-12 19:26:51 +0200 <olle> Consider a process_order function that also writes a new order to the database after a number of calculations. Would you prefer to have it handing you an effect object instead of a success result?
2023-04-12 19:27:46 +0200Alex_test(~al_test@178.34.162.18)
2023-04-12 19:30:03 +0200bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-04-12 19:33:19 +0200mikess(~sam@user/mikess)
2023-04-12 19:37:10 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-04-12 19:38:06 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6)
2023-04-12 19:38:54 +0200L29Ah(~L29Ah@wikipedia/L29Ah) ()
2023-04-12 19:39:14 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6)
2023-04-12 19:50:37 +0200tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: sdvfsjsl)
2023-04-12 20:01:54 +0200tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2023-04-12 20:02:16 +0200tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Remote host closed the connection)
2023-04-12 20:02:35 +0200tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2023-04-12 20:03:50 +0200ubert(~Thunderbi@p200300ecdf114f00fa3b3daf889d0c1b.dip0.t-ipconnect.de)
2023-04-12 20:03:58 +0200zer0bitz_(~zer0bitz@2001:2003:f443:d600:1d40:2e2d:a29f:cc19) ()
2023-04-12 20:08:09 +0200ubert(~Thunderbi@p200300ecdf114f00fa3b3daf889d0c1b.dip0.t-ipconnect.de) (Client Quit)
2023-04-12 20:08:37 +0200zer0bitz(~zer0bitz@2001:2003:f443:d600:1d40:2e2d:a29f:cc19)
2023-04-12 20:13:58 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6) (Remote host closed the connection)
2023-04-12 20:15:28 +0200segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 276 seconds)
2023-04-12 20:17:08 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6)
2023-04-12 20:18:43 +0200segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-04-12 20:18:47 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-04-12 20:18:49 +0200wootehfoot(~wootehfoo@user/wootehfoot)
2023-04-12 20:21:35 +0200LenarHoyt(~LenarHoyt@2a02:908:f13:daa3:d857:3f2f:13fa:1d70)
2023-04-12 20:26:12 +0200coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-04-12 20:28:47 +0200codaraxis__(~codaraxis@user/codaraxis)
2023-04-12 20:32:32 +0200codaraxis(~codaraxis@user/codaraxis) (Ping timeout: 248 seconds)
2023-04-12 20:34:20 +0200Angelz(Angelz@user/angelz) (Quit: IRCNow and Forever!)
2023-04-12 20:50:04 +0200matijja(~matijja@193.77.181.201) (Quit: ZNC 1.8.2 - https://znc.in)
2023-04-12 20:50:50 +0200matijja(~matijja@193.77.181.201)
2023-04-12 20:57:09 +0200wootehfoot(~wootehfoo@user/wootehfoot) (Quit: Leaving)
2023-04-12 21:12:04 +0200use-value(~Thunderbi@2a00:23c6:8a03:2f01:3438:d5fd:19ed:dac6) (Quit: use-value)
2023-04-12 21:12:20 +0200 <nomagno> In the Maybe monad, is Nothing a special case of Just foo ?
2023-04-12 21:12:43 +0200 <Rembane> No, they are two different cases of Maybe foo.
2023-04-12 21:13:47 +0200 <[exa]> what is a "special case"
2023-04-12 21:14:06 +0200 <nomagno> Well, specific case
2023-04-12 21:14:25 +0200 <[exa]> what metric of specificity?
2023-04-12 21:14:45 +0200freeside(~mengwong@68.65.175.90) (Ping timeout: 240 seconds)
2023-04-12 21:14:57 +0200 <[exa]> like, they are 2 completely different constructors with 2 completely different implementations of the bind (and other things)
2023-04-12 21:16:36 +0200 <hopelessness[m]> Maybe is a sum type (meaning a type that can assume multiple different forms), specifically it is either `Nothing` or `Just a` where `a` is something "contained" in the maybe
2023-04-12 21:16:46 +0200 <hopelessness[m]> these are called constructors in haskell
2023-04-12 21:19:38 +0200mei(~mei@user/mei) (Remote host closed the connection)
2023-04-12 21:21:42 +0200 <nomagno> Is Maybe in the monad form a monad, or a sum type of monads? I'm trying to build some kind of mental relationship between the monadic laws and Maybe
2023-04-12 21:22:01 +0200 <hopelessness[m]> what I explained has nothing to do with monads
2023-04-12 21:22:12 +0200 <hopelessness[m]> Maybe (the type) is a monad
2023-04-12 21:22:46 +0200Square(~Square@user/square)
2023-04-12 21:22:47 +0200 <hopelessness[m]> the specific constructors are simply how the type is internally constructed
2023-04-12 21:23:29 +0200Square2(~Square4@user/square) (Ping timeout: 246 seconds)
2023-04-12 21:24:18 +0200mei(~mei@user/mei)
2023-04-12 21:26:24 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 248 seconds)
2023-04-12 21:26:25 +0200segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 256 seconds)
2023-04-12 21:26:39 +0200ft(~ft@p4fc2a88b.dip0.t-ipconnect.de)
2023-04-12 21:27:34 +0200 <nomagno> I'm going to use the Wikipedia definition's terms here. A value of type `Maybe` has to look like `M T`. So in `m x`, the `x` can't be empty, that doesn't make sense and then `>>=` stops working. But if `Nothing` is the `x` when a function returns a value of type `Maybe` with specific value `Nothing`, `x` doesn't have type `T`, it has type `T + [some type with the only value "Nothing"] `...
2023-04-12 21:27:42 +0200freeside(~mengwong@68.65.175.90)
2023-04-12 21:27:59 +0200 <c_wraith> nomagno: you're conflating value and type levels
2023-04-12 21:28:06 +0200 <nomagno> I'm thinking about it wrong here, but I don't know how I'm thinking about it wrong
2023-04-12 21:28:19 +0200 <c_wraith> nomagno: in 'm x', those are both *type* expressions
2023-04-12 21:28:20 +0200 <hopelessness[m]> Nothing is not Just (Nothing)
2023-04-12 21:29:01 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-04-12 21:29:38 +0200 <ncf> "A value of type `Maybe`" is already wrong: Maybe is not a type, it's a type constructor
2023-04-12 21:29:57 +0200 <nomagno> A value of type Maybe T, alright
2023-04-12 21:30:08 +0200 <c_wraith> for instance, `Nothing :: Maybe Integer' and `Just 5 :: Maybe Integer' may have different value-level structures, but both have the type Maybe Integer
2023-04-12 21:30:14 +0200 <ncf> a value of type Maybe T looks like Nothing or Just t (for some t : T)
2023-04-12 21:31:35 +0200 <nomagno> But that makes no sense, if `Maybe T` looks like `Nothing`, then it doesn't hold that `unit x >>= f iff f(x)`... Or maybe it does?
2023-04-12 21:31:48 +0200 <c_wraith> once again, those are different levels
2023-04-12 21:31:53 +0200 <c_wraith> types and values are different
2023-04-12 21:32:02 +0200 <c_wraith> Think about them separately
2023-04-12 21:32:16 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6) (Remote host closed the connection)
2023-04-12 21:32:37 +0200 <c_wraith> `unit x' cannot be `Nothing'
2023-04-12 21:32:50 +0200 <c_wraith> (in haskell, unit is usually spelled "pure")
2023-04-12 21:33:02 +0200 <nomagno> So, if unit x cannot be Nothing, f(x) is just not?
2023-04-12 21:33:14 +0200 <ncf> the unit of the Maybe monad is Just :: a -> Maybe a
2023-04-12 21:33:44 +0200 <ncf> the law you're talking about says that Just x >>= f == f x, which is just part of the definition of >>= for Maybe
2023-04-12 21:34:08 +0200 <ncf> the other part says what happens to Nothing
2023-04-12 21:34:19 +0200 <nomagno> But, the law specifically does not talk about Nothing?
2023-04-12 21:34:50 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer)
2023-04-12 21:34:59 +0200 <c_wraith> true. the law doesn't define all the behavior. it just puts a constraint on it
2023-04-12 21:35:31 +0200 <nomagno> But, we still have that same monad of type M T... Wait no, bind returns a monad of type M U, oooooh
2023-04-12 21:35:31 +0200 <c_wraith> the type-specific implementation defines all the behavior. And if it's lawful, it obeys the constraints.
2023-04-12 21:36:20 +0200 <nomagno> This means that `Nothing >>= f` doesn't have an "obligation to be a valid statement" at all, according to the monad laws?
2023-04-12 21:36:29 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-04-12 21:36:29 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-04-12 21:36:36 +0200 <c_wraith> yeah. I think any presentation of the laws that doesn't give the types of the free variables is seriously lacking
2023-04-12 21:36:47 +0200 <hopelessness[m]> what do you mean by valid statement?
2023-04-12 21:36:57 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-04-12 21:37:03 +0200 <hopelessness[m]> monad laws don't really apply here
2023-04-12 21:37:19 +0200 <ncf> that's a value, not a statement
2023-04-12 21:37:23 +0200 <hopelessness[m]> hopelessness[m]: non-compiler enforced laws I should say
2023-04-12 21:37:25 +0200 <c_wraith> actually, the laws do apply.
2023-04-12 21:37:27 +0200 <hopelessness[m]> * non-compiler/type enforced
2023-04-12 21:37:30 +0200gmg(~user@user/gehmehgeh)
2023-04-12 21:37:35 +0200 <c_wraith> Because of the associativity law
2023-04-12 21:37:56 +0200 <c_wraith> but the identity laws don't apply
2023-04-12 21:38:09 +0200[_](~itchyjunk@user/itchyjunk/x-7353470)
2023-04-12 21:38:10 +0200gurkenglas(~gurkengla@dynamic-046-114-183-049.46.114.pool.telefonica.de) (Ping timeout: 255 seconds)
2023-04-12 21:38:36 +0200 <nomagno> If f expects an Int, it can't be fed Nothing, even if Nothing is a Maybe Int? Is this correct? Or is Nothing just its own monadic type M U now?
2023-04-12 21:39:11 +0200 <c_wraith> so the first part is absolutely true. `Nothing >>= f' cannot call f
2023-04-12 21:39:56 +0200 <c_wraith> So the only way to produce a total, type-checking result is for `Nothing >>= _ = Nothing'
2023-04-12 21:40:09 +0200 <hopelessness[m]> `Nothing >>= f` will always evaluate to `Nothing` because it's defined that way (`Nothing >>= _ = Nothing`)
2023-04-12 21:40:59 +0200 <c_wraith> Note that that isn't because of the monad laws - it's due to parametricity
2023-04-12 21:41:17 +0200 <nomagno> c_wraith: that's a violation of the left-identity law though, no?
2023-04-12 21:41:29 +0200 <hopelessness[m]> no
2023-04-12 21:41:37 +0200 <hopelessness[m]> return a = Just a
2023-04-12 21:41:47 +0200 <hopelessness[m]> return will never give you a Nothing
2023-04-12 21:42:19 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 250 seconds)
2023-04-12 21:42:25 +0200 <c_wraith> (parametricity is a separate big thing. It's more important than anything about monads in really understanding Haskell types.)
2023-04-12 21:42:31 +0200 <hopelessness[m]> s//`/, s//` (or rather `return = pure` which is the same thing in the end)/
2023-04-12 21:43:57 +0200 <ncf> if f expects an Int, it doesn't expect a Maybe Int
2023-04-12 21:44:03 +0200[_](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 250 seconds)
2023-04-12 21:44:21 +0200 <nomagno> But `>>=` is supposed to fix that
2023-04-12 21:44:44 +0200 <hopelessness[m]> ehhh, I understand what you mean but it's not really correct
2023-04-12 21:45:04 +0200 <ncf> >>= fixes that in the specific case where f also *produces* a Maybe something
2023-04-12 21:45:13 +0200 <hopelessness[m]> but we are using ambiguous language - what is "expects" for a function?
2023-04-12 21:45:27 +0200 <hopelessness[m]> unless I'm just being stupid right now
2023-04-12 21:45:29 +0200 <ncf> that is, if f :: Int -> Maybe b, then (>>= f) :: Maybe Int -> Maybe b
2023-04-12 21:45:43 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 260 seconds)
2023-04-12 21:46:14 +0200 <ncf> you can see Maybe as representing a "possible failure", and >>= as saying "carry over the possible failure of the input into the output"
2023-04-12 21:48:19 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-04-12 21:48:23 +0200 <nomagno> if we have `x` with type `Maybe Int`, `f` with type `Int -> Maybe Int`, and `g` with type `Int -> Maybe Int`; `x >>= f >>= g`. If `f` returns `Nothing`, what does `g(...)` look like now?
2023-04-12 21:48:38 +0200 <nomagno> That's as close to my actual question as I've gotten
2023-04-12 21:49:12 +0200 <hopelessness[m]> g is g, the entire expression will return Nothing
2023-04-12 21:49:15 +0200 <ncf> if f returns Nothing, then the entire computation evaluates to Nothing
2023-04-12 21:49:49 +0200 <nomagno> But `g` expects an `Int`, and `f` has returned a `Maybe Int`, which has a specific `>>=` implementation, not two!
2023-04-12 21:49:50 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-04-12 21:49:55 +0200 <nomagno> Or CAN it have two?
2023-04-12 21:49:58 +0200 <ddellacosta> nomagno: maybe it would help to just look at the code? https://hackage.haskell.org/package/base-4.18.0.0/docs/src/GHC.Base.html#line-1133
2023-04-12 21:50:06 +0200 <hopelessness[m]> `>>=` handles both cases
2023-04-12 21:50:10 +0200 <nomagno> Oh, if-then-else clause inside the `>>=`, lol
2023-04-12 21:50:15 +0200 <nomagno> Yeah I just realized writing it out
2023-04-12 21:50:21 +0200 <hopelessness[m]> there is no if-else
2023-04-12 21:50:25 +0200 <hopelessness[m]> just pattern matching
2023-04-12 21:50:56 +0200 <nomagno> Well, I understood now
2023-04-12 21:50:57 +0200 <nomagno> Jeez I didn't even consider >>= handling it like that
2023-04-12 21:50:57 +0200 <nomagno> Thanks!
2023-04-12 21:51:05 +0200freeside(~mengwong@68.65.175.90) (Ping timeout: 240 seconds)
2023-04-12 21:51:14 +0200 <nomagno> So THIS is what "computation policy" means
2023-04-12 21:52:30 +0200 <c_wraith> I suppose that's no worse than any other phrase I've seen used
2023-04-12 21:53:04 +0200olle(~olle@h-155-4-129-160.NA.cust.bahnhof.se) ()
2023-04-12 21:55:40 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-04-12 21:56:38 +0200 <nomagno> So, when `>>=` handles `Nothing`, it's handling a value that hasn't been constructed with `unit`, freeing it from the left-identity and right-identity laws?
2023-04-12 21:57:06 +0200 <c_wraith> correct
2023-04-12 21:57:34 +0200 <c_wraith> (the associativity law does still put some requirements on its behavior)
2023-04-12 22:00:32 +0200gurkenglas(~gurkengla@dynamic-046-114-183-049.46.114.pool.telefonica.de)
2023-04-12 22:00:35 +0200johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net)
2023-04-12 22:01:06 +0200 <johnw> Is anyone using GNU global with Haskell files? I have Pygments setup and gtags --explain shows that it's processing the file as a Haskell file, but it finds zero definitions, not in any of my files.
2023-04-12 22:02:14 +0200 <nomagno> `>>=` may also perform additional computations with the result of `f`?
2023-04-12 22:02:42 +0200 <c_wraith> nomagno: sure. Look at the Monad instance for Writer, for example
2023-04-12 22:03:26 +0200johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net) (ERC 5.4 (IRC client for GNU Emacs 28.2))
2023-04-12 22:03:30 +0200 <c_wraith> Well. don't. It's a mess because of historical reasons involving trying to share as much code as possible :)
2023-04-12 22:03:36 +0200 <nomagno> Yes, but in the Monad instance for Writer, it's never touching the "boxed" part, only the "box", if thay makes sense
2023-04-12 22:03:37 +0200trev(~trev@user/trev) (Quit: trev)
2023-04-12 22:03:48 +0200 <c_wraith> true
2023-04-12 22:03:56 +0200 <c_wraith> and that's sort of what the laws say it must do
2023-04-12 22:05:21 +0200 <nomagno> You can easily bypass this by having a version of unit that isn't unit though, right? And everything constructed with this unitClone would similarly not be helt to the identity laws
2023-04-12 22:05:41 +0200 <nomagno> Though you start to degrade the usefulness of monads then, I guess
2023-04-12 22:05:48 +0200 <hopelessness[m]> no
2023-04-12 22:05:58 +0200 <c_wraith> The whole point of Monad is that it's *only* that specific interface
2023-04-12 22:06:03 +0200 <hopelessness[m]> you cannot construct types outside of the constructors
2023-04-12 22:06:12 +0200 <nomagno> Ahhhhh
2023-04-12 22:06:15 +0200 <c_wraith> anything outside of that interface isn't part of Monad. It's part of something else
2023-04-12 22:06:33 +0200bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-04-12 22:06:33 +0200 <nomagno> Wait, so Nothing is only allowed because it's a constant?
2023-04-12 22:06:40 +0200 <hopelessness[m]> because it's a constructor of the Maybe type
2023-04-12 22:06:47 +0200 <c_wraith> Nothing is allowed because you know you're working with Maybe
2023-04-12 22:06:59 +0200 <hopelessness[m]> data Maybe a = Just a | Nothing
2023-04-12 22:07:27 +0200 <c_wraith> If you were working with the generic interface, on the other hand, you wouldn't have Nothing available because you wouldn't know m ~ Maybe
2023-04-12 22:07:29 +0200barcisz(~barcisz@79.191.65.29.ipv4.supernova.orange.pl) (Quit: Connection closed)
2023-04-12 22:07:31 +0200L29Ah(~L29Ah@wikipedia/L29Ah)
2023-04-12 22:07:32 +0200gensyst(~gensyst@user/gensyst) (Quit: Leaving)
2023-04-12 22:08:48 +0200 <nomagno> I'm not talking about Haskell anymore here, sorry for not clarifying. In the general case, you COULD have all sorts of values that are M T but constructed in weird ways not through unit, no? It takes away the point of monads, but still
2023-04-12 22:09:27 +0200Guest|81(~Guest|81@200.19.106.219)
2023-04-12 22:09:57 +0200 <hopelessness[m]> what are you talking about then?
2023-04-12 22:09:58 +0200 <hopelessness[m]> Category theory?
2023-04-12 22:10:05 +0200 <c_wraith> 1. yes, you can have all sorts of additional stuff. 2. It doesn't take away the point of monads, because it's *outside the scope*. forming a monad just means that it has a specific structure. It says nothing at all about any other structures that may be present.
2023-04-12 22:10:32 +0200 <nomagno> I'm trying to understand monads conceptually
2023-04-12 22:10:55 +0200 <hopelessness[m]> so category theory?
2023-04-12 22:11:03 +0200LenarHoyt(~LenarHoyt@2a02:908:f13:daa3:d857:3f2f:13fa:1d70) (Ping timeout: 260 seconds)
2023-04-12 22:11:33 +0200 <nomagno> If I say yes, I'd immediately go over my knowledge pay grade, so no, but otherwise yes
2023-04-12 22:11:57 +0200 <nomagno> I'm happy enough as-is though
2023-04-12 22:12:31 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6)
2023-04-12 22:12:35 +0200 <nomagno> It's clear to me now what can and can't be done through the "obvious" interfaces
2023-04-12 22:13:33 +0200 <hopelessness[m]> nomagno: Understanding monads in the context of haskell is essentially understanding them conceptually
2023-04-12 22:14:53 +0200 <hopelessness[m]> what helped me is to instead call monads `flatMappable` or `Chainable` - that's all `>>=` is, a flatmap (flatten . map)` where flatten is an operation `m (m a)) -> m a`
2023-04-12 22:15:07 +0200 <hopelessness[m]> s/flatMappable/FlatMappable/
2023-04-12 22:15:09 +0200segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-04-12 22:15:39 +0200 <hopelessness[m]> * what helped me is to instead call monads `FlatMappable` or `Chainable` - that's all `>>=` is, a flatmap `(flatten . map)`, where flatten is an operation `m (m a)) -> m a`
2023-04-12 22:16:03 +0200 <hopelessness[m]> * what helped me is to instead call monads `FlatMappable` or `Chainable` - that's all `>>=` is, a flatmap `(flatten . map)`, where flatten is an operation `Monad m => m (m a) -> m a`
2023-04-12 22:16:15 +0200 <nomagno> You could have `MyCustomMonadType = Just a | Perhaps a`, no? And then you could have the `>>=` implementation ignore the identity laws if it handles a value of the form `Perhaps a`
2023-04-12 22:16:41 +0200 <hopelessness[m]> that should be called MyCustomMaybeType - but yes
2023-04-12 22:16:56 +0200 <hopelessness[m]> you can ignore some laws, those that are not type-enforced
2023-04-12 22:17:02 +0200 <hopelessness[m]> which you should not do
2023-04-12 22:17:14 +0200 <nomagno> I said the identity laws, the first two of the three
2023-04-12 22:17:40 +0200 <hopelessness[m]> those would have to be non-total in the case of Maybe
2023-04-12 22:17:41 +0200 <nomagno> And only when handling Perhaps a, which is NOT unit a, that's Just a in this context
2023-04-12 22:18:06 +0200 <hopelessness[m]> Oh, I didn't read it right
2023-04-12 22:18:13 +0200 <ncf> i don't think there's a lawful monad instance on that type
2023-04-12 22:18:29 +0200 <ncf> (there is if you make it Left a | Right b, which is Either a b)
2023-04-12 22:19:09 +0200Angelz(Angelz@angelz.oddprotocol.org)
2023-04-12 22:19:11 +0200 <hopelessness[m]> but then the monad is only over one of the type parameters
2023-04-12 22:19:31 +0200 <ncf> yes
2023-04-12 22:19:55 +0200comerijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds)
2023-04-12 22:19:57 +0200jmdaemon(~jmdaemon@user/jmdaemon)
2023-04-12 22:20:17 +0200 <nomagno> Makes enough sense
2023-04-12 22:20:49 +0200 <ncf> hm there are valid monads on that, actually
2023-04-12 22:21:02 +0200 <ncf> your type is isomorphic to (a, Bool), so any monoid on Bool gives you a monad
2023-04-12 22:21:34 +0200 <ncf> i think i was thinking of data Pair a = Pair a a (which i think also has a monad, but it's not obvious)
2023-04-12 22:21:35 +0200segfaultfizzbuzz(~segfaultf@108.211.201.53) (Ping timeout: 246 seconds)
2023-04-12 22:21:47 +0200 <nomagno> ncf: it is isomorphic to (a, Bool), yes, a was either constructed with one constructor or the other :P
2023-04-12 22:21:59 +0200 <nomagno> m a *
2023-04-12 22:22:12 +0200 <hopelessness[m]> but you can make any type with one type parameter an (unlawful) monad instance, simply with `(>>=) = error ":("` or `(>>=) = (>>=)`; simply making it evaluate to bottom
2023-04-12 22:22:27 +0200sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-04-12 22:23:43 +0200sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-04-12 22:24:58 +0200 <hopelessness[m]> * but you can make any type with kind `* -> *` (I hope this is right, im not good with kinds) an (unlawful) monad instance, simply with `(>>=) = error ":("` or `(>>=) = (>>=)`; simply making it evaluate to bottom
2023-04-12 22:28:50 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 265 seconds)
2023-04-12 22:29:07 +0200MajorBiscuit(~MajorBisc@31-23-159.netrun.cytanet.com.cy)
2023-04-12 22:31:12 +0200retropikzel(9d1a4f9f46@2604:bf00:561:2000::ce) ()
2023-04-12 22:32:11 +0200retropikzel(9d1a4f9f46@2604:bf00:561:2000::ce)
2023-04-12 22:36:23 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-04-12 22:36:32 +0200freeside(~mengwong@68.65.175.90)
2023-04-12 22:37:30 +0200ix(~ix@2a02:8012:281f:0:d65d:64ff:fe52:5efe)
2023-04-12 22:40:57 +0200coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-04-12 22:44:03 +0200Guest|81(~Guest|81@200.19.106.219) (Quit: Connection closed)
2023-04-12 22:45:56 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-04-12 22:53:44 +0200zeenk(~zeenk@2a02:2f04:a307:2300::7fe)
2023-04-12 22:54:45 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-04-12 22:54:45 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-04-12 22:54:45 +0200wroathe(~wroathe@user/wroathe)
2023-04-12 23:01:25 +0200jero98772(~jero98772@190.158.28.80) (Ping timeout: 240 seconds)
2023-04-12 23:03:39 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 255 seconds)
2023-04-12 23:04:47 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6) (Remote host closed the connection)
2023-04-12 23:08:06 +0200ix(~ix@2a02:8012:281f:0:d65d:64ff:fe52:5efe) (Quit: WeeChat 3.8)
2023-04-12 23:09:36 +0200ix(~ix@2a02:8012:281f:0:d65d:64ff:fe52:5efe)
2023-04-12 23:10:24 +0200ix(~ix@2a02:8012:281f:0:d65d:64ff:fe52:5efe) (Client Quit)
2023-04-12 23:13:16 +0200gry(st@botters/gry)
2023-04-12 23:14:01 +0200jero98772(~jero98772@2800:484:1d84:9000::2)
2023-04-12 23:20:13 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-04-12 23:23:45 +0200ix(~ix@2a02:8012:281f:0:d65d:64ff:fe52:5efe)
2023-04-12 23:24:44 +0200ix(~ix@2a02:8012:281f:0:d65d:64ff:fe52:5efe) (Client Quit)
2023-04-12 23:26:10 +0200ix(~ix@2a02:8012:281f:0:d65d:64ff:fe52:5efe)
2023-04-12 23:27:59 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-04-12 23:32:45 +0200NiceBird(~NiceBird@185.133.111.196) (Ping timeout: 240 seconds)
2023-04-12 23:35:30 +0200segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-04-12 23:41:34 +0200MajorBiscuit(~MajorBisc@31-23-159.netrun.cytanet.com.cy) (Quit: WeeChat 3.6)
2023-04-12 23:50:42 +0200heraldo(~heraldo@user/heraldo)
2023-04-12 23:57:10 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2023-04-12 23:57:36 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9c10:cd7b:75b2:cda6)