IRCBrowse

2023/01/02

2023-01-02 00:02:38 +0100Guest9971(~finn@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Ping timeout: 272 seconds)
2023-01-02 00:02:46 +0100 <hololeap> eldritchcookie[4: when you say N elements, is N a fixed value or are you trying to count it with type level programming?
2023-01-02 00:02:57 +0100 <hololeap> *n arguments
2023-01-02 00:04:27 +0100 <eldritchcookie[4> with type level programming if it were a fixed n i could just template haskell my way to victory
2023-01-02 00:04:30 +0100sh1n(~sh1n@181.229.121.151)
2023-01-02 00:04:47 +0100morb(~morb@pool-72-80-94-112.nycmny.fios.verizon.net)
2023-01-02 00:04:51 +0100 <hololeap> what do you have so far?
2023-01-02 00:05:06 +0100sh1n(~sh1n@181.229.121.151) (Client Quit)
2023-01-02 00:05:23 +0100 <eldritchcookie[4> type ResultProof::Natural -> Type -> Type -> Type... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/98755511f3686891a1c20ade4e48307da848…>)
2023-01-02 00:05:47 +0100 <eldritchcookie[4> but i can't make the recursive instance
2023-01-02 00:07:17 +0100morb(~morb@pool-72-80-94-112.nycmny.fios.verizon.net) (Remote host closed the connection)
2023-01-02 00:08:10 +0100 <eldritchcookie[4> if i try
2023-01-02 00:08:10 +0100 <eldritchcookie[4> instance IsFunctionClass n a r => IsFunctionClass (n+1) (b -> a) r where
2023-01-02 00:08:10 +0100 <eldritchcookie[4> isFunctionProof = ResultIsNext isFunctionProof
2023-01-02 00:08:44 +0100 <eldritchcookie[4> it complains about illegal type synonym family
2023-01-02 00:09:34 +0100 <eldritchcookie[4> and
2023-01-02 00:09:34 +0100 <eldritchcookie[4> instance IsFunctionClass (n-1) a r => IsFunctionClass n (b -> a) r where
2023-01-02 00:09:34 +0100 <eldritchcookie[4> isFunctionProof = ResultIsNext isFunctionProof
2023-01-02 00:10:01 +0100 <eldritchcookie[4> fails with not satisfying the liberal coverage condition
2023-01-02 00:12:13 +0100 <hololeap> are you trying to set the kind for `data ResultProof` using `type ResultProof` on a different line? maybe that's valid syntax but I haven't seen it before
2023-01-02 00:12:13 +0100 <eldritchcookie[4> https://paste.tomsmeding.com/X8U9pJrC
2023-01-02 00:12:39 +0100 <eldritchcookie[4> that is a standalone kind signature
2023-01-02 00:12:57 +0100 <eldritchcookie[4> the idea is that kind declarations mirror type declarrations
2023-01-02 00:13:41 +0100 <hololeap> oh, I've never used that extension before
2023-01-02 00:15:58 +0100 <eldritchcookie[4> https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/poly_kinds.html#extension-StandaloneKindSi… the idea is to substitute CUSKs
2023-01-02 00:16:52 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-01-02 00:19:38 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-01-02 00:19:38 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-01-02 00:19:38 +0100wroathe(~wroathe@user/wroathe)
2023-01-02 00:22:14 +0100 <eldritchcookie[4> wow amazing now i get can't match n with ((n - 1) + 1)
2023-01-02 00:22:35 +0100 <geekosaur> ghc doesn't really know how to do type level math
2023-01-02 00:22:58 +0100 <hololeap> ResultIsNext :: ResultProof n a r -> ResultProof (n+1) (v -> a) r
2023-01-02 00:23:31 +0100 <hololeap> so this looks like there is an implicit existential quantification on v, it isn't mentioned anywhere else
2023-01-02 00:23:31 +0100 <eldritchcookie[4> yes?
2023-01-02 00:23:32 +0100 <geekosaur> there are some plugins available that recognize type level math and add enough extra context so ghc can solve it. see natnormalize for example
2023-01-02 00:25:53 +0100caryhartline(~caryhartl@2600:1700:2d0:8d30:2936:808f:4be4:4fc1) (Quit: caryhartline)
2023-01-02 00:27:24 +0100 <hololeap> I'm not sure I'll be much help with this, it's a bit beyond my level :)
2023-01-02 00:28:01 +0100 <eldritchcookie[4> no problem :)
2023-01-02 00:28:04 +0100 <hololeap> I have played around with something similar in the past but my implementation was very different, and that was also a long time ago
2023-01-02 00:28:44 +0100 <hololeap> I have a hard time with FunctionalDependencies, for some reason
2023-01-02 00:30:06 +0100 <eldritchcookie[4> you can just ignore them just add the head on the context like instance Functor f=>Functor f where
2023-01-02 00:30:35 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Ping timeout: 268 seconds)
2023-01-02 00:31:37 +0100 <eldritchcookie[4> geekosaur i search for natnormalize and nat normalize on hackage and i didn't find it can you send a link?
2023-01-02 00:32:18 +0100 <geekosaur> turns out it's spelled britishly. https://hackage.haskell.org/package/ghc-typelits-natnormalise
2023-01-02 00:34:26 +0100jakalx(~jakalx@base.jakalx.net)
2023-01-02 00:37:39 +0100forell(~forell@user/forell) (Quit: ZNC - https://znc.in)
2023-01-02 00:38:49 +0100morb(~morb@pool-72-80-94-112.nycmny.fios.verizon.net)
2023-01-02 00:38:54 +0100justsomeguy(~justsomeg@user/justsomeguy)
2023-01-02 00:40:17 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-01-02 00:43:57 +0100morb(~morb@pool-72-80-94-112.nycmny.fios.verizon.net) (Remote host closed the connection)
2023-01-02 00:46:00 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2023-01-02 00:46:53 +0100 <Profpatsch> In GHCI, can I tell it to just enable hidden packages
2023-01-02 00:47:06 +0100 <Profpatsch> I hate having to modify the cabal file just to experiment with stuff
2023-01-02 00:47:42 +0100 <geekosaur> https://hackage.haskell.org/package/ghc-typelits-knownnat is another useful one
2023-01-02 00:48:23 +0100 <geekosaur> Profpatsch, there's no way to do it for all packages, no
2023-01-02 00:48:26 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-01-02 00:48:26 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-01-02 00:48:26 +0100wroathe(~wroathe@user/wroathe)
2023-01-02 00:48:44 +0100 <geekosaur> you can enable a specific package with :set -package foo
2023-01-02 00:49:05 +0100 <Profpatsch> geekosaur: nice, that does it
2023-01-02 00:49:10 +0100 <Profpatsch> should be in the error message
2023-01-02 00:53:47 +0100 <geekosaur> I think it used to be, but the error message doesn't know if it's been triggered by ghci or compilation and randomly tossing -package options into ghc-options is a good way to break stack in particular
2023-01-02 00:54:34 +0100 <Profpatsch> how … could that brneak stack
2023-01-02 00:54:40 +0100 <Profpatsch> Unless you add it to .ghci
2023-01-02 00:54:58 +0100 <geekosaur> again, it does not know that it was invoked from ghci
2023-01-02 00:55:43 +0100 <geekosaur> it's the same error message whether you're using ghci, building with raw ghc, building with stack, building with cabal, etc.
2023-01-02 00:56:37 +0100 <geekosaur> it's less likely to happen with stack or cabal builds, but it can still happen and following a suggestion to use -package will have bad results in those cases
2023-01-02 00:57:28 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) (Quit: Leaving.)
2023-01-02 00:57:33 +0100 <Profpatsch> What kind of error would happen?
2023-01-02 00:57:47 +0100 <Profpatsch> As far as I understand, ghc package databases only allow one packages of the same name
2023-01-02 00:58:15 +0100 <geekosaur> okay, forget I said anything. somehow we aren't even in the same book much less on the same page
2023-01-02 00:59:37 +0100 <geekosaur> (you said you wanted -package to be mentioned in the error message. I am talking about that error message. it is not a ghci-specific error message)
2023-01-02 00:59:50 +0100 <Profpatsch> It’s a GHC error message, no?
2023-01-02 00:59:53 +0100 <geekosaur> yes
2023-01-02 00:59:58 +0100 <Profpatsch> GHC uses ghc packages
2023-01-02 01:00:01 +0100 <Profpatsch> package databases
2023-01-02 01:00:29 +0100 <geekosaur> yes. cabal and stack also use the same package databases, and mark as hidden the packages not exposed via build-depeds
2023-01-02 01:00:33 +0100 <Profpatsch> when I run ghc-pkg list, I get one version of each package
2023-01-02 01:00:50 +0100 <Profpatsch> So how would I every make stack break by adding a package from the package database
2023-01-02 01:01:17 +0100 <Profpatsch> (temporarily, in my ghci repl)
2023-01-02 01:01:23 +0100 <geekosaur> otherwise you could not have used -package inside ghci in a context where adding to build-depends was also a possibility
2023-01-02 01:01:47 +0100 <geekosaur> if that works inside ghci then it also works with ghc-options in cabal/stack
2023-01-02 01:01:58 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2023-01-02 01:02:10 +0100 <Profpatsch> yes of course, but that’s just an abstraction leak
2023-01-02 01:02:58 +0100 <Profpatsch> now, I could see it being a problem if we had something like rust, where you can have different versions of the same package in the closure
2023-01-02 01:03:29 +0100 <Profpatsch> z-attoparsec-z-attoparsec-internal-0.14.4 hm
2023-01-02 01:03:34 +0100 <geekosaur> you can cause cabal/stack to misconpute the closure if you sneak packages in with -package instead of using build-depends
2023-01-02 01:03:52 +0100 <geekosaur> *miscompute
2023-01-02 01:03:57 +0100 <Profpatsch> why … would the compute the closure from a running ghci
2023-01-02 01:04:02 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-01-02 01:04:12 +0100 <Profpatsch> *they
2023-01-02 01:04:16 +0100 <geekosaur> we still have not communicated
2023-01-02 01:04:21 +0100 <geekosaur> forget I said anything
2023-01-02 01:04:33 +0100Typedfern(~Typedfern@60.red-83-37-32.dynamicip.rima-tde.net) (Remote host closed the connection)
2023-01-02 01:04:53 +0100 <Profpatsch> I said “it would be good if the message contained a hint that you can use ‘:set -package filepath’ in ghci”
2023-01-02 01:05:24 +0100 <geekosaur> what you said was "should be in the error message"
2023-01-02 01:05:29 +0100 <Profpatsch> yes
2023-01-02 01:05:37 +0100 <Profpatsch> It already says that you can add it to your .cabal
2023-01-02 01:05:38 +0100 <geekosaur> it used to be a hint that using -package was a possible solution
2023-01-02 01:05:47 +0100 <Profpatsch> so why shouldn’t it say that you can manually add it in ghci
2023-01-02 01:06:08 +0100 <Profpatsch> funnily enough, you wouldn’t see that message outside of ghci, because cabal would stop you
2023-01-02 01:06:15 +0100 <geekosaur> it didn't say "only in ghci", and blindly doing that in stack or cabal can break things, so they removed it
2023-01-02 01:06:25 +0100 <Profpatsch> well then
2023-01-02 01:07:38 +0100 <geekosaur> for that matter, doing it in ghci already controlled by stack ghci/cabal repl can cause ghci to pick an incompatible version, because ghci doesn't check that all dependencies are met like stack and cabal do
2023-01-02 01:07:45 +0100 <monochrom> Normally, if you use ghci directly, you don't need -package; if you use cabal/stack, you should let cabal/stack take over.
2023-01-02 01:08:19 +0100 <monochrom> You are now talking about an edge case of using cabal/stack and then going on to circumvent cabal/stack. This should not be encouraged by an "improvement" of error messages.
2023-01-02 01:08:19 +0100leah2(~leah@vuxu.org) (Read error: Connection reset by peer)
2023-01-02 01:08:27 +0100 <geekosaur> (ghc is very stupid about this, which is a large part of the reason that cabal and stack exist)
2023-01-02 01:08:57 +0100 <Profpatsch> monochrom: I’m talking about the *specific* use case that happens *a lot* in day-to-day production Haskell
2023-01-02 01:09:26 +0100 <Profpatsch> where you have a repl open, potentially with a bunch of interpreted modules (potentially hundreds) loaded, and you just want to experiment
2023-01-02 01:09:30 +0100 <monochrom> Well rust is also a "dumb" plain vanilla compiler that leaves packages to cargo...
2023-01-02 01:09:37 +0100 <Profpatsch> but you can’t import a module because cabal stops you
2023-01-02 01:09:47 +0100 <Profpatsch> So
2023-01-02 01:09:56 +0100 <Profpatsch> - As a haskell cabal ghci user
2023-01-02 01:09:57 +0100Typedfern(~Typedfern@60.red-83-37-32.dynamicip.rima-tde.net)
2023-01-02 01:10:05 +0100 <Profpatsch> - I want to temporarily import a module to try something
2023-01-02 01:10:17 +0100 <Profpatsch> - without closing and repoening the repl or adjusting my .cabal file
2023-01-02 01:10:29 +0100 <Profpatsch> This is not an edge case
2023-01-02 01:10:34 +0100 <Profpatsch> it’s something that happens all the time
2023-01-02 01:10:55 +0100 <Profpatsch> Maybe in the nice technical implementation-detail view of things it’s an edge case
2023-01-02 01:11:18 +0100 <monochrom> No, you began by refusing to add a dependency in *.cabal. There is no conflict between "I'm experiementing" and "I add a dependency in *.cabal".
2023-01-02 01:11:41 +0100 <Profpatsch> monochrom: yes, there is a difference of a few minutes
2023-01-02 01:11:55 +0100 <Profpatsch> reloading a `cabal repl` can take minutes on big repos
2023-01-02 01:12:18 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:bccb:1151:f053:cd4c)
2023-01-02 01:13:41 +0100 <geekosaur> again, trusting -package is unsafe because ghci will happily pick an incompatible version
2023-01-02 01:13:58 +0100 <geekosaur> cabal and stack *exist* to force ghc to do the right thing
2023-01-02 01:15:15 +0100 <Profpatsch> It’s so silly that Haskellers argue on the level of “noooo, you have to add this line to the file and wait for a minute do do $simpleThing because that’s how things areee”, while Visual Studio is over there and allows hot-reload of C++ code while the executable is running https://www.youtube.com/watch?v=x_gr6DNrJuM
2023-01-02 01:15:43 +0100 <c_wraith> I've written Haskell that allows hot-reload of C++ while the executable is running
2023-01-02 01:15:48 +0100 <c_wraith> It's no big deal
2023-01-02 01:15:57 +0100 <c_wraith> As long as you give it a sane environment to work in
2023-01-02 01:16:13 +0100 <c_wraith> Which is what Visual Studio spends a lot of time doing.
2023-01-02 01:16:27 +0100 <Profpatsch> yep, sane environment, so the opposite of cabal :)
2023-01-02 01:16:36 +0100 <dminuoso> Profpatsch: It's not really silly, it's merely a matter of industry funding. Meta has hot code reload for Haskell.
2023-01-02 01:17:05 +0100 <geekosaur> you try going back to pre-cabal days and then tell me about sane environments
2023-01-02 01:17:26 +0100 <dminuoso> But it's relatively adhoc and special purposed, and they happen to have Simon Marlow on payroll.
2023-01-02 01:17:41 +0100 <geekosaur> hell, even cabal v1 days which were roughly like what you appear to want (and are why stack exists, not to say cabal v2)
2023-01-02 01:18:18 +0100 <Profpatsch> geekosaur: nobody is talking about randomly installing things mutably into a ghc package database
2023-01-02 01:18:22 +0100 <c_wraith> Have you ever tried to run msvc *without* Visual Studio? sane environment? It's never heard of one.
2023-01-02 01:18:56 +0100 <dminuoso> It's not really fair to compare especially something like visual studio to Haskell, when the former is the commercial product of a billion dollar tech giant that has dozens of engineers working full time on the product.. *shrugs*
2023-01-02 01:19:47 +0100 <Profpatsch> well, I guess #haskell is not the place to talk about the future of things then
2023-01-02 01:20:45 +0100 <Profpatsch> I happen to have a nice setup here, but that happen by being “adhoc”, i.e. making decisions on environment and use-cases
2023-01-02 01:21:33 +0100Typedfern(~Typedfern@60.red-83-37-32.dynamicip.rima-tde.net) (Remote host closed the connection)
2023-01-02 01:21:37 +0100 <c_wraith> so your point is no one has sunk hundreds of programmer-years into a Haskell IDE that just decides those things for you?
2023-01-02 01:22:57 +0100 <c_wraith> heck, I wouldn't be surprised if Visual Studio was at tens of thousands of programmer years.
2023-01-02 01:22:59 +0100 <Profpatsch> c_wraith: I spent about 50–100 hours on it, and I’m at a point where I can support a sub 50k LoC project. I’m pretty sure we are gonna hit a wall at 50–100k, but hls & vscode *is* that IDE
2023-01-02 01:23:37 +0100 <Profpatsch> Putting everything into one cabal package, because the cross-package workflow breaks down most of the UX
2023-01-02 01:25:04 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-02 01:25:10 +0100 <Profpatsch> We tried splitting some things into cabal packages, but the resulting overhead & breakage is not worth the friction
2023-01-02 01:25:11 +0100 <dminuoso> And to be fair, comparing the long replanning and rebuild process with MSVC that doesnt even have a notion of build plans is a strange thing to do.
2023-01-02 01:25:46 +0100 <dminuoso> There's a certain degree of orthogonality here
2023-01-02 01:25:50 +0100 <Profpatsch> In particular, one “adhoc” decision is to use stackage as the base
2023-01-02 01:26:18 +0100 <c_wraith> as opposed to VS, which just tells you "find it somewhere"?
2023-01-02 01:27:00 +0100 <sclv> i’m not sure what the actual proposal here is
2023-01-02 01:27:05 +0100leah2(~leah@vuxu.org)
2023-01-02 01:28:12 +0100 <dminuoso> But yes, if you are in a situation where you have lots of packages in a sort of mono-repo, there is a bunch of UX problems. Are they solvable in principle? Sure, donate money or engineering time to cabal.
2023-01-02 01:29:11 +0100 <Profpatsch> sclv: I triggered a bunch of people by saying “it should probably be mentioned that you can un-hide a package in ghci by running a command”
2023-01-02 01:29:31 +0100 <Profpatsch> There was no proposal, just the assertion that it’s absolutely impossible to improve the status quo
2023-01-02 01:29:40 +0100 <sclv> is the proposal just that one change the ghci message?
2023-01-02 01:29:43 +0100 <Profpatsch> yes
2023-01-02 01:29:52 +0100 <Profpatsch> I don’t even care what produces the message
2023-01-02 01:30:12 +0100 <Profpatsch> If ghci parses the message & adds its own line, I’d be fine with that
2023-01-02 01:30:20 +0100acidjnk(~acidjnk@p200300d6e7137a577d241e14a75b8650.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-01-02 01:30:44 +0100 <sclv> that seems reasonable. i don't think that solves the bigger issue you're gesturing at, which does seem _very_ hard
2023-01-02 01:31:12 +0100 <Profpatsch> I feel like many problems can be solved by agreeing that they don’t need solving :)
2023-01-02 01:32:13 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-02 01:34:02 +0100nft_slut(~user@50-110-204-205.mrbg.wv.frontiernet.net) (ERC 5.4 (IRC client for GNU Emacs 28.2))
2023-01-02 01:34:12 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 01:35:34 +0100 <dminuoso> Whats the right way to expose a C macro from a C standard library header into a Haskell binding?
2023-01-02 01:36:22 +0100talismanick(~talismani@76.133.152.122) (Ping timeout: 272 seconds)
2023-01-02 01:37:36 +0100 <monochrom> foreign import capi ...
2023-01-02 01:37:47 +0100 <monochrom> so, capi instead of ccall
2023-01-02 01:38:58 +0100 <dminuoso> monochrom: Ah, that looks spot on. Thanks, I did not know about this extension.
2023-01-02 01:39:08 +0100 <monochrom> Ah you have to add {-# language CApiFFI #-} too.
2023-01-02 01:39:25 +0100 <monochrom> https://downloads.haskell.org/~ghc/9.2.5/docs/html/users_guide/exts/ffi.html?highlight=capi#extens… has an example
2023-01-02 01:39:33 +0100 <dminuoso> Got it, cheers
2023-01-02 01:40:22 +0100 <geekosaur> https://downloads.haskell.org/ghc/9.4.1/docs/users_guide/exts/ffi.html#the-capi-calling-convention
2023-01-02 01:40:31 +0100 <geekosaur> oh, I'm slow, sorry
2023-01-02 01:49:43 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 260 seconds)
2023-01-02 02:03:11 +0100freeside(~mengwong@103.252.202.159)
2023-01-02 02:03:56 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Ping timeout: 255 seconds)
2023-01-02 02:05:31 +0100v0id_ptr(~adrift@user/ptr-frac7al/x-0038398)
2023-01-02 02:07:00 +0100meinside(uid24933@id-24933.helmsley.irccloud.com)
2023-01-02 02:07:24 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Ping timeout: 268 seconds)
2023-01-02 02:09:54 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 260 seconds)
2023-01-02 02:10:12 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-01-02 02:16:19 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-01-02 02:16:51 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-01-02 02:23:51 +0100freeside(~mengwong@103.252.202.159)
2023-01-02 02:26:25 +0100razetime(~Thunderbi@49.207.194.134)
2023-01-02 02:28:45 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-01-02 02:41:19 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 268 seconds)
2023-01-02 02:41:36 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 272 seconds)
2023-01-02 02:43:09 +0100gurkenglas(~gurkengla@p548ac72e.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2023-01-02 02:47:26 +0100Everything(~Everythin@46.185.124.170)
2023-01-02 02:51:53 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 02:54:28 +0100freeside(~mengwong@103.252.202.159)
2023-01-02 03:04:43 +0100hyperbolic-dg(~quassel@i577AA562.versanet.de) (Remote host closed the connection)
2023-01-02 03:19:06 +0100ddellacosta(~ddellacos@143.244.47.68)
2023-01-02 03:36:02 +0100Guest4496(~finn@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2023-01-02 03:36:21 +0100arguapacha(~arguapach@bras-base-mtrlpq02hsy-grc-10-76-68-190-46.dsl.bell.ca)
2023-01-02 03:39:19 +0100tremon(~tremon@83-85-213-108.cable.dynamic.v4.ziggo.nl) (Quit: getting boxed in)
2023-01-02 03:41:46 +0100Guest4496(~finn@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Ping timeout: 272 seconds)
2023-01-02 03:43:20 +0100arguapacha(~arguapach@bras-base-mtrlpq02hsy-grc-10-76-68-190-46.dsl.bell.ca) (Quit: Client closed)
2023-01-02 03:43:30 +0100haris_(~haris@45.32.196.242)
2023-01-02 03:44:17 +0100thongpv87(~thongpv87@2402:9d80:3e6:e30e:d1ec:9bf2:ae21:f5c4) (Read error: Connection reset by peer)
2023-01-02 03:45:51 +0100thongpv87(~thongpv87@14.246.240.163)
2023-01-02 03:47:59 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-01-02 03:49:26 +0100hgolden(~hgolden@cpe-172-251-233-141.socal.res.rr.com) (Remote host closed the connection)
2023-01-02 03:50:35 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-01-02 03:51:10 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 260 seconds)
2023-01-02 03:51:19 +0100justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 265 seconds)
2023-01-02 03:53:59 +0100hgolden(~hgolden@cpe-172-251-233-141.socal.res.rr.com)
2023-01-02 04:01:21 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Ping timeout: 256 seconds)
2023-01-02 04:05:54 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-01-02 04:05:54 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-01-02 04:05:54 +0100finn_elijaFinnElija
2023-01-02 04:06:51 +0100xff0x(~xff0x@2405:6580:b080:900:18f:39b6:7457:a86b) (Ping timeout: 248 seconds)
2023-01-02 04:11:12 +0100nasrudin__(~nasrudin_@ip68-101-166-83.sd.sd.cox.net)
2023-01-02 04:12:01 +0100nasrudin__(~nasrudin_@ip68-101-166-83.sd.sd.cox.net) (Client Quit)
2023-01-02 04:12:16 +0100nasrudin__(~nasrudin_@ip68-101-166-83.sd.sd.cox.net)
2023-01-02 04:14:51 +0100nasrudin__(~nasrudin_@ip68-101-166-83.sd.sd.cox.net) (Client Quit)
2023-01-02 04:15:36 +0100nasrudin__(~nasrudin_@ip68-101-166-83.sd.sd.cox.net)
2023-01-02 04:15:40 +0100td_(~td@83.135.9.35) (Ping timeout: 260 seconds)
2023-01-02 04:16:21 +0100freeside(~mengwong@103.252.202.159)
2023-01-02 04:17:03 +0100 <nasrudin__> asdii
2023-01-02 04:17:08 +0100td_(~td@83.135.9.63)
2023-01-02 04:23:15 +0100Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net) (Ping timeout: 260 seconds)
2023-01-02 04:37:15 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 268 seconds)
2023-01-02 04:48:58 +0100mzan(~quassel@mail.asterisell.com) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-01-02 04:49:57 +0100mzan(~quassel@mail.asterisell.com)
2023-01-02 04:55:28 +0100Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net)
2023-01-02 05:04:40 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-02 05:06:57 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Quit: Lost terminal)
2023-01-02 05:08:05 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-01-02 05:10:33 +0100ddellacosta(~ddellacos@143.244.47.68) (Ping timeout: 268 seconds)
2023-01-02 05:10:48 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-01-02 05:15:07 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-01-02 05:21:51 +0100igghibu(~igghibu@37.120.201.86)
2023-01-02 05:23:19 +0100morb(~morb@pool-72-80-94-112.nycmny.fios.verizon.net)
2023-01-02 05:52:21 +0100alexiscott(~user@97.red-83-36-47.dynamicip.rima-tde.net)
2023-01-02 05:55:04 +0100cheater(~Username@user/cheater) (Read error: Connection reset by peer)
2023-01-02 05:55:50 +0100cheater(~Username@user/cheater)
2023-01-02 06:00:54 +0100razetime(~Thunderbi@49.207.194.134) (Read error: Connection reset by peer)
2023-01-02 06:02:41 +0100thongpv87(~thongpv87@14.246.240.163) (Ping timeout: 246 seconds)
2023-01-02 06:03:36 +0100razetime(~Thunderbi@49.207.194.134)
2023-01-02 06:04:05 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 06:06:03 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2023-01-02 06:09:47 +0100sympt9(~sympt@user/sympt)
2023-01-02 06:10:18 +0100beefbambi(~beefbambi@183.82.25.141)
2023-01-02 06:10:28 +0100sympt(~sympt@user/sympt) (Ping timeout: 260 seconds)
2023-01-02 06:10:29 +0100sympt9sympt
2023-01-02 06:11:19 +0100morb(~morb@pool-72-80-94-112.nycmny.fios.verizon.net) (Remote host closed the connection)
2023-01-02 06:14:05 +0100sympt5(~sympt@user/sympt)
2023-01-02 06:15:19 +0100sympt(~sympt@user/sympt) (Ping timeout: 268 seconds)
2023-01-02 06:15:19 +0100sympt5sympt
2023-01-02 06:15:39 +0100mbuf(~Shakthi@49.205.86.73)
2023-01-02 06:22:08 +0100beefbambi(~beefbambi@183.82.25.141) (Read error: Connection reset by peer)
2023-01-02 06:22:46 +0100beefbambi(~beefbambi@2401:4900:230d:f57c:538c:d7cc:50c0:e377)
2023-01-02 06:23:16 +0100beefbambi(~beefbambi@2401:4900:230d:f57c:538c:d7cc:50c0:e377) (Read error: Connection reset by peer)
2023-01-02 06:23:33 +0100beefbambi(~beefbambi@183.82.25.141)
2023-01-02 06:26:35 +0100beefbambi(~beefbambi@183.82.25.141) (Read error: Connection reset by peer)
2023-01-02 06:27:18 +0100beefbambi(~beefbambi@183.82.25.141)
2023-01-02 06:29:21 +0100Blightmain(~Blightmai@203.29.154.219)
2023-01-02 06:34:35 +0100alexiscott(~user@97.red-83-36-47.dynamicip.rima-tde.net) (Ping timeout: 248 seconds)
2023-01-02 06:36:14 +0100cameron_(~quassel@050-089-109-059.res.spectrum.com)
2023-01-02 06:40:35 +0100beefbambi(~beefbambi@183.82.25.141) (Ping timeout: 256 seconds)
2023-01-02 06:42:24 +0100beefbambi(~beefbambi@2401:4900:230d:f57c:538c:d7cc:50c0:e377)
2023-01-02 06:43:30 +0100 <cameron_> i just wrote my first line of haskell and reading into this i have to say its blowing my mind
2023-01-02 06:44:13 +0100 <Blightmain> Enjoy the journey :)
2023-01-02 06:45:24 +0100ix(~ix@2a02:8010:674f:0:d65d:64ff:fe52:5efe) (Quit: WeeChat 3.7.1)
2023-01-02 06:47:32 +0100ix(~ix@2a02:8010:674f:0:d65d:64ff:fe52:5efe)
2023-01-02 06:47:55 +0100 <razetime> cameron_: it only gets more fun from here :)
2023-01-02 06:48:32 +0100 <cameron_> i feel like this is how i speak english to my computer
2023-01-02 06:48:47 +0100 <zzz> "fun"
2023-01-02 06:49:03 +0100 <zzz> https://dwarffortresswiki.org/index.php?title=DF2014:Fun&redirect=no
2023-01-02 06:49:23 +0100qy(~ix@2a02:8010:674f:0:d65d:64ff:fe52:5efe)
2023-01-02 06:49:24 +0100 <cameron_> dont worry i am very familiar with the concept of fun
2023-01-02 06:49:59 +0100v0id_ptr(~adrift@user/ptr-frac7al/x-0038398) (Ping timeout: 264 seconds)
2023-01-02 06:50:08 +0100 <Blightmain> In other languages like java/c# you are able to load a file once at app startup and reference the contents of that file for the lifetime of the app. For example, reading configuration from a file. Is there something similar in haskell? What im trying to do is read db connection string from my config file.
2023-01-02 06:50:23 +0100 <cameron_> the immediate dwarf fortress reference tells me im in the right place
2023-01-02 06:51:32 +0100 <zzz> cameron_: you'll enjoy this then :) https://github.com/swarm-game/swarm
2023-01-02 06:52:35 +0100ix(~ix@2a02:8010:674f:0:d65d:64ff:fe52:5efe) (Ping timeout: 260 seconds)
2023-01-02 06:52:45 +0100alexiscott(~user@97.red-83-36-47.dynamicip.rima-tde.net)
2023-01-02 06:53:01 +0100 <zzz> Blightmain: https://hackage.haskell.org/package/base-4.17.0.0/docs/Prelude.html#v:readFile ?
2023-01-02 06:54:54 +0100 <cameron_> zzz thank you ive always enjoyed games where you get to script stuff
2023-01-02 06:55:22 +0100razetime(~Thunderbi@49.207.194.134) (Quit: razetime)
2023-01-02 06:55:23 +0100titibandit(~titibandi@xdsl-89-0-163-79.nc.de)
2023-01-02 06:55:39 +0100 <Blightmain> Are you able to bind the contents of a file using readFile to some object and reference that instead of doing an IO operation to the disk everytime I need the contents?
2023-01-02 06:55:53 +0100razetime(~Thunderbi@49.207.194.134)
2023-01-02 06:56:12 +0100 <zzz> Blightmain: what do you mean "doing an IO operation to the disk everytime"?
2023-01-02 06:56:36 +0100 <razetime> i assume they want stream I/O?
2023-01-02 06:58:00 +0100 <Blightmain> For example, in other languages I can have some object called MyConfig and at application startup I would bind the file contents to that object and add that MyConfig object as a singleton which can be referenced instead of reading the file everytime I need to access its contents.
2023-01-02 06:58:26 +0100 <monochrom> If you call readFile only once, the file is read at most once.
2023-01-02 06:58:46 +0100 <EvanR> Blightmain, the most straightforward way to do this is read the file once at the beginning, then provide the results to whatever needs it (perhaps after processing it into a sane format)
2023-01-02 06:59:13 +0100 <EvanR> like, passing it in as a function argument
2023-01-02 07:00:20 +0100 <EvanR> there are other shenanigans to achieve the same thing but try this method first to compare against
2023-01-02 07:00:24 +0100 <zzz> maybe some examplke code would help
2023-01-02 07:01:41 +0100 <razetime> worth looking at https://wiki.haskell.org/Global_variables, maybe.
2023-01-02 07:02:43 +0100 <Blightmain> Ill give you my exact scenario. I have an API I made with servant that connects to postgres and I have my connecionstring stored in a config file. I assume that everytime I call my endpoint I will read the contents of the file to get the connectionstring. Is there some way to have that config bound to some type that persists across requests so I don't have to constantly read the file for every request?
2023-01-02 07:02:44 +0100 <zzz> that first sentence in the Answer :p
2023-01-02 07:04:26 +0100 <Blightmain> This is my code: https://github.com/PhilG112/ToDoApp/blob/master/ToDoApp.Api/src/Config/ConfigUtil.hs
2023-01-02 07:04:30 +0100 <zzz> Blightmain: are you familiar with passing state around?
2023-01-02 07:04:47 +0100 <Blightmain> In haskell not really still very new to it
2023-01-02 07:06:42 +0100haris_(~haris@45.32.196.242) (Remote host closed the connection)
2023-01-02 07:07:33 +0100talismanick(~talismani@76.133.152.122)
2023-01-02 07:08:19 +0100 <talismanick> Is there a modern alternative to the "auto" library? (arrowized automata for wiring state machines together)
2023-01-02 07:09:33 +0100 <zzz> Blightmain: so the idea is to get the contents of the file once, and then pass it around to any functions that will need it
2023-01-02 07:12:21 +0100 <Blightmain> Exactly! Get the contents once at app startup then pass it around for the lifetime of my application. Sorry if its confusing I come from a c# background so im probbably making some assumptions I shouldn't
2023-01-02 07:12:54 +0100 <zzz> Blightmain: i would advise you to study on the State monad, which can be useful
2023-01-02 07:13:18 +0100 <zzz> but in principle, what you want is this:
2023-01-02 07:14:29 +0100 <zzz> imagine you have some function `someFunction :: a -> b` and you want it to perform some action that depends on something in the config file
2023-01-02 07:14:47 +0100 <zzz> you can turn it into `someFunction :: Config -> a -> b`
2023-01-02 07:14:53 +0100 <zzz> and pass it the config
2023-01-02 07:14:53 +0100 <talismanick> Arrows in generally seem underused
2023-01-02 07:15:11 +0100 <talismanick> Any reasons beside unfamiliarity?
2023-01-02 07:16:59 +0100 <razetime> what are arrowized automata?
2023-01-02 07:17:06 +0100nasrudin__(~nasrudin_@ip68-101-166-83.sd.sd.cox.net) (Ping timeout: 272 seconds)
2023-01-02 07:17:30 +0100 <EvanR> wait wait... this is not "state" because you aren't changing the state
2023-01-02 07:17:59 +0100 <EvanR> you *read* the file once, and use the contents over and over (without updating it, in this case usually requiring a restart)
2023-01-02 07:18:50 +0100 <EvanR> Arrows exploded onto the scene and then the good parts were extracted into profunctors and related classes
2023-01-02 07:20:14 +0100 <talismanick> EvanR: ...what were the bad parts?
2023-01-02 07:20:17 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Ping timeout: 255 seconds)
2023-01-02 07:20:44 +0100 <EvanR> there is 1 method which makes it "a symmetric monoid category plus something"
2023-01-02 07:20:51 +0100 <EvanR> monoidal*
2023-01-02 07:22:17 +0100 <EvanR> arr :: Arrow a => (b -> c) -> a b c
2023-01-02 07:22:28 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-01-02 07:22:32 +0100 <talismanick> EvanR: Symmetric monoidal category?
2023-01-02 07:22:39 +0100 <EvanR> yeah
2023-01-02 07:23:05 +0100 <talismanick> That makes sense, since each produces a unique output which must be consumed once\
2023-01-02 07:23:07 +0100alexiscott(~user@97.red-83-36-47.dynamicip.rima-tde.net) (Ping timeout: 252 seconds)
2023-01-02 07:23:22 +0100 <talismanick> (hence dataflow diagram interpretation)
2023-01-02 07:23:44 +0100 <EvanR> if you want a symmetric monoidal category, then you might not be able to implement arr. If you want the rest of Arrow, you might just want profunctor
2023-01-02 07:23:45 +0100foul_owl(~kerry@157.97.134.156) (Ping timeout: 268 seconds)
2023-01-02 07:24:09 +0100 <EvanR> er, if you have arr, you might want profunctor
2023-01-02 07:24:35 +0100 <talismanick> Lenses have something to do with profunctors, right?
2023-01-02 07:24:55 +0100 <EvanR> profunctor optics is a thing, which includes lenses
2023-01-02 07:26:26 +0100 <talismanick> Are profunctors related to prosets? (preordered sets)
2023-01-02 07:26:44 +0100 <talismanick> (posets where isomorphism = identity)
2023-01-02 07:27:19 +0100haris(~haris@201.141.112.122)
2023-01-02 07:27:21 +0100foul_owl(~kerry@157.97.134.156)
2023-01-02 07:27:23 +0100 <talismanick> err, isomorphism is equality
2023-01-02 07:27:56 +0100 <EvanR> I don't know. I skipped straight to profunctor = a type which is a covariant functor in one parameter and contravariant in the other
2023-01-02 07:28:14 +0100 <talismanick> Okay, that makes sense
2023-01-02 07:28:15 +0100 <EvanR> e.g. (->)
2023-01-02 07:30:22 +0100thongpv87(~thongpv87@14.246.240.163)
2023-01-02 07:33:59 +0100johnw(~johnw@2600:1700:cf00:db0:bccc:cdbd:ef47:1293)
2023-01-02 07:47:52 +0100razetime(~Thunderbi@49.207.194.134) (Remote host closed the connection)
2023-01-02 07:52:33 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-02 07:56:58 +0100v0id_ptr(~adrift@user/ptr-frac7al/x-0038398)
2023-01-02 07:58:21 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Quit: Leaving)
2023-01-02 08:01:29 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 08:02:04 +0100cheater(~Username@user/cheater) (Ping timeout: 272 seconds)
2023-01-02 08:02:05 +0100cheater_(~Username@user/cheater)
2023-01-02 08:02:05 +0100cheater_cheater
2023-01-02 08:06:09 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 256 seconds)
2023-01-02 08:06:09 +0100 <talismanick> EvanR: So, is there an equivalent of the auto library, but with profunctors instead of arrows?
2023-01-02 08:11:10 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 08:11:14 +0100Everything(~Everythin@46.185.124.170) (Ping timeout: 268 seconds)
2023-01-02 08:13:48 +0100Blightmain(~Blightmai@203.29.154.219) (Remote host closed the connection)
2023-01-02 08:16:11 +0100Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net) (Ping timeout: 265 seconds)
2023-01-02 08:22:17 +0100kenran(~user@user/kenran)
2023-01-02 08:22:41 +0100kenran(~user@user/kenran) (Remote host closed the connection)
2023-01-02 08:26:36 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Remote host closed the connection)
2023-01-02 08:35:38 +0100kritzefitz(~kritzefit@debian/kritzefitz) (Ping timeout: 272 seconds)
2023-01-02 08:36:54 +0100kritzefitz(~kritzefit@debian/kritzefitz)
2023-01-02 08:37:27 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-01-02 08:40:18 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:83e4:99f0:e8cd:3cd7)
2023-01-02 08:42:17 +0100thongpv(~thongpv87@2001:ee0:54ae:c1f0:424b:c9a9:5031:b9c4)
2023-01-02 08:43:59 +0100thongpv87(~thongpv87@14.246.240.163) (Ping timeout: 264 seconds)
2023-01-02 08:52:39 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-02 08:55:01 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 268 seconds)
2023-01-02 09:01:38 +0100cameron_(~quassel@050-089-109-059.res.spectrum.com) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-01-02 09:08:29 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 09:09:44 +0100freeside(~mengwong@122.11.214.90)
2023-01-02 09:15:53 +0100freeside(~mengwong@122.11.214.90) (Ping timeout: 246 seconds)
2023-01-02 09:19:26 +0100perrierjouet(~perrier-j@modemcable048.127-56-74.mc.videotron.ca) (Quit: WeeChat 3.7.1)
2023-01-02 09:21:20 +0100v0id_ptr(~adrift@user/ptr-frac7al/x-0038398) (Ping timeout: 260 seconds)
2023-01-02 09:21:58 +0100coot(~coot@213.134.171.3)
2023-01-02 09:22:41 +0100coot(~coot@213.134.171.3) (Remote host closed the connection)
2023-01-02 09:23:07 +0100avicenzi(~avicenzi@2a00:ca8:a1f:b004::c32)
2023-01-02 09:25:16 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-02 09:32:28 +0100perrierjouet(~perrier-j@modemcable048.127-56-74.mc.videotron.ca)
2023-01-02 09:32:54 +0100Guest4496(~finn@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2023-01-02 09:36:50 +0100thongpv(~thongpv87@2001:ee0:54ae:c1f0:424b:c9a9:5031:b9c4) (Ping timeout: 246 seconds)
2023-01-02 09:38:01 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-02 09:39:39 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-01-02 09:46:31 +0100acidjnk(~acidjnk@p200300d6e7137a57e4469cf2ea7b5c7c.dip0.t-ipconnect.de)
2023-01-02 09:51:34 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7)
2023-01-02 09:56:04 +0100Guest4496(~finn@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Ping timeout: 272 seconds)
2023-01-02 09:58:00 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-02 09:59:42 +0100chiselfuse(~chiselfus@user/chiselfuse) (Remote host closed the connection)
2023-01-02 10:00:15 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-01-02 10:02:08 +0100fserucas_(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7)
2023-01-02 10:06:19 +0100cheater_(~Username@user/cheater)
2023-01-02 10:06:39 +0100mei(~mei@user/mei) (Ping timeout: 252 seconds)
2023-01-02 10:09:30 +0100nschoe(~q@141.101.51.197)
2023-01-02 10:09:41 +0100cheater(~Username@user/cheater) (Ping timeout: 256 seconds)
2023-01-02 10:09:45 +0100cheater_cheater
2023-01-02 10:10:21 +0100titibandit(~titibandi@xdsl-89-0-163-79.nc.de) (Remote host closed the connection)
2023-01-02 10:10:48 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-02 10:11:54 +0100foul_owl(~kerry@157.97.134.156) (Ping timeout: 272 seconds)
2023-01-02 10:16:28 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 252 seconds)
2023-01-02 10:16:49 +0100razetime(~Thunderbi@49.207.194.134)
2023-01-02 10:18:19 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-01-02 10:19:19 +0100freeside(~mengwong@103.252.202.159)
2023-01-02 10:25:38 +0100foul_owl(~kerry@157.97.134.61)
2023-01-02 10:27:44 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-02 10:31:40 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2023-01-02 10:33:21 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 10:35:41 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:bccb:1151:f053:cd4c) (Remote host closed the connection)
2023-01-02 10:37:38 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-02 10:38:04 +0100igghibu(~igghibu@37.120.201.86) (Quit: igghibu)
2023-01-02 10:42:33 +0100haris(~haris@201.141.112.122) (Remote host closed the connection)
2023-01-02 10:50:03 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-01-02 10:51:28 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 11:01:58 +0100thongpv(~thongpv87@2001:ee0:54ae:c1f0:c80b:7720:68f2:6f18)
2023-01-02 11:04:27 +0100CiaoSen(~Jura@p200300c9571bac002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-01-02 11:08:08 +0100boxscape_(~boxscape_@213.52.37.155)
2023-01-02 11:08:46 +0100 <boxscape_> what is the github repo with ghc+other tools' error numbers/codes again? I can't find it
2023-01-02 11:09:20 +0100 <boxscape_> ...I say, as I find it
2023-01-02 11:09:28 +0100 <boxscape_> https://github.com/haskellfoundation/error-message-index
2023-01-02 11:10:58 +0100 <boxscape_> or, better, https://errors.haskell.org/
2023-01-02 11:13:21 +0100kuribas(~user@ptr-17d51ema74fu5i8lm5c.18120a2.ip6.access.telenet.be)
2023-01-02 11:14:43 +0100 <[exa]> [rubber duck voice:] you're welcome boxscape_!
2023-01-02 11:14:51 +0100 <boxscape_> :D thanks
2023-01-02 11:15:18 +0100VY2(~user@213.24.126.94)
2023-01-02 11:18:27 +0100cheater(~Username@user/cheater) (Quit: Going offline, see ya! (www.adiirc.com))
2023-01-02 11:21:09 +0100thongpv(~thongpv87@2001:ee0:54ae:c1f0:c80b:7720:68f2:6f18) (Remote host closed the connection)
2023-01-02 11:22:06 +0100thongpv(~thongpv87@14.246.240.163)
2023-01-02 11:22:24 +0100cheater(~Username@user/cheater)
2023-01-02 11:28:14 +0100mechap(~mechap@148.163.20.109.rev.sfr.net)
2023-01-02 11:32:44 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2023-01-02 11:33:47 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 264 seconds)
2023-01-02 11:33:49 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-01-02 11:35:05 +0100Lord_of_Life_Lord_of_Life
2023-01-02 11:36:10 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:bccb:1151:f053:cd4c)
2023-01-02 11:40:45 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:bccb:1151:f053:cd4c) (Ping timeout: 260 seconds)
2023-01-02 11:44:32 +0100Lycurgus(~juan@user/Lycurgus)
2023-01-02 11:47:22 +0100xff0x(~xff0x@p3326132-ipngn2103sapodori.hokkaido.ocn.ne.jp)
2023-01-02 11:48:21 +0100noteness(~noteness@user/noteness) (Quit: bye)
2023-01-02 11:53:35 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-01-02 11:55:05 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-01-02 11:56:24 +0100mbuf(~Shakthi@49.205.86.73) (Ping timeout: 272 seconds)
2023-01-02 11:57:26 +0100 <eldritchcookie[4> is there any useful way to work with parameterized monadic continuations which return monadic continuations?
2023-01-02 11:58:24 +0100 <eldritchcookie[4> basically i have a (a -> r1) -> ContMT m o r2 b
2023-01-02 11:58:33 +0100 <mauke> that's too oleg for me
2023-01-02 11:58:46 +0100 <eldritchcookie[4> what does that mean?
2023-01-02 11:58:49 +0100 <mauke> @where oleg
2023-01-02 11:58:49 +0100 <lambdabot> http://okmij.org/ftp/
2023-01-02 11:59:54 +0100 <eldritchcookie[4> cool
2023-01-02 12:01:11 +0100 <eldritchcookie[4> but i already saw some of that site
2023-01-02 12:02:23 +0100 <eldritchcookie[4> i will look into delimited continuations so that will be useful but for now i am just trying to invert control
2023-01-02 12:03:06 +0100xff0x(~xff0x@p3326132-ipngn2103sapodori.hokkaido.ocn.ne.jp) (Ping timeout: 268 seconds)
2023-01-02 12:03:49 +0100mechap(~mechap@148.163.20.109.rev.sfr.net) (Changing host)
2023-01-02 12:03:49 +0100mechap(~mechap@user/mechap)
2023-01-02 12:04:53 +0100 <eldritchcookie[4> basically i want to turn a function like bracket into two ContT IO a
2023-01-02 12:06:31 +0100boxscape_(~boxscape_@213.52.37.155) (Ping timeout: 252 seconds)
2023-01-02 12:06:49 +0100noteness(~noteness@user/noteness)
2023-01-02 12:08:02 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 246 seconds)
2023-01-02 12:10:30 +0100systemfault(sid267009@uxbridge.irccloud.com) (Ping timeout: 268 seconds)
2023-01-02 12:14:26 +0100mechap(~mechap@user/mechap) (Quit: WeeChat 3.7.1)
2023-01-02 12:14:45 +0100mechap(~mechap@user/mechap)
2023-01-02 12:14:50 +0100systemfault(sid267009@id-267009.uxbridge.irccloud.com)
2023-01-02 12:15:58 +0100Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net)
2023-01-02 12:17:19 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-02 12:17:27 +0100thongpv87(~thongpv87@2001:ee0:54ae:c1f0:b9cc:872a:62dd:efd6)
2023-01-02 12:18:14 +0100 <cheater> @protontorpedo
2023-01-02 12:18:14 +0100 <lambdabot> why haskell over lisp?
2023-01-02 12:20:16 +0100thongpv(~thongpv87@14.246.240.163) (Ping timeout: 252 seconds)
2023-01-02 12:21:29 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 12:26:10 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 272 seconds)
2023-01-02 12:29:17 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 252 seconds)
2023-01-02 12:29:20 +0100CiaoSen(~Jura@p200300c9571bac002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 255 seconds)
2023-01-02 12:32:31 +0100kuribas(~user@ptr-17d51ema74fu5i8lm5c.18120a2.ip6.access.telenet.be) (Quit: ERC (IRC client for Emacs 27.1))
2023-01-02 12:34:35 +0100thongpv87(~thongpv87@2001:ee0:54ae:c1f0:b9cc:872a:62dd:efd6) (Ping timeout: 248 seconds)
2023-01-02 12:43:47 +0100thyriaen(~thyriaen@2a01:aea0:dd4:4bae:6245:cbff:fe9f:48b1)
2023-01-02 12:57:16 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 12:58:16 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7) (Quit: Leaving)
2023-01-02 13:01:28 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 252 seconds)
2023-01-02 13:07:48 +0100Blightmain(~Blightmai@203.29.154.219)
2023-01-02 13:16:15 +0100VY2_(~user@213.24.133.13)
2023-01-02 13:18:57 +0100VY2(~user@213.24.126.94) (Ping timeout: 268 seconds)
2023-01-02 13:30:25 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 13:30:57 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7)
2023-01-02 13:33:41 +0100fserucas_(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7) (Ping timeout: 256 seconds)
2023-01-02 13:42:26 +0100anpad(~pandeyan@user/anpad) (Quit: ZNC 1.8.2 - https://znc.in)
2023-01-02 13:44:50 +0100anpad(~pandeyan@user/anpad)
2023-01-02 13:46:15 +0100Blightmain(~Blightmai@203.29.154.219) (Quit: Leaving)
2023-01-02 13:46:24 +0100img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2023-01-02 13:46:41 +0100img(~img@user/img)
2023-01-02 13:52:10 +0100CiaoSen(~Jura@p200300c9571bac002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-01-02 13:54:07 +0100hyperbolic-dg(~quassel@i577AA562.versanet.de)
2023-01-02 13:57:02 +0100iik(~iik@5.46.250.195)
2023-01-02 13:59:34 +0100iik(~iik@5.46.250.195) (Client Quit)
2023-01-02 14:00:39 +0100dextaa0(~DV@user/dextaa)
2023-01-02 14:02:35 +0100dextaa(~DV@user/dextaa) (Ping timeout: 256 seconds)
2023-01-02 14:02:35 +0100dextaa0dextaa
2023-01-02 14:07:02 +0100 <dminuoso> newtype Params a = Params (Params.Params a)
2023-01-02 14:07:06 +0100 <dminuoso> Things are so clear now.
2023-01-02 14:08:22 +0100 <dminuoso> I have a feeling this is all some bizarre artifact of avoiding circular imports.
2023-01-02 14:09:15 +0100 <int-e> what's this parametric polymorphism
2023-01-02 14:11:19 +0100boxscape_(~boxscape_@213.52.37.155)
2023-01-02 14:11:19 +0100razetime(~Thunderbi@49.207.194.134) (Read error: Connection reset by peer)
2023-01-02 14:11:35 +0100razetime(~Thunderbi@49.207.194.134)
2023-01-02 14:12:03 +0100 <maerwald> what time format is "Thu, 15 Dec 2022 08:43:15 PST"
2023-01-02 14:12:59 +0100Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net) (Ping timeout: 260 seconds)
2023-01-02 14:15:05 +0100 <ncf> RFC 5322 but what does this have to do with haskell
2023-01-02 14:15:08 +0100Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net)
2023-01-02 14:15:26 +0100 <maerwald> https://github.com/brendanhay/amazonka/issues/866
2023-01-02 14:16:04 +0100 <merijn> dminuoso: All I want for Christmas...is automatic handling of circular imports >.>
2023-01-02 14:16:20 +0100 <merijn> (bit late with that, but I didn't open my work laptop over the vacation :p)
2023-01-02 14:16:26 +0100 <dminuoso> ncf: Not quite. Mmm
2023-01-02 14:16:32 +0100 <dminuoso> This is RFC1123
2023-01-02 14:17:45 +0100 <ncf> ah yes the keys are right next to each other
2023-01-02 14:18:02 +0100 <mechap> Has anyone had this issue with stack https://discourse.haskell.org/t/stack-connection-failure/5517 ?
2023-01-02 14:18:25 +0100 <dminuoso> ncf: The formats look very similar to be fair.
2023-01-02 14:18:36 +0100 <ncf> what's the difference?
2023-01-02 14:19:12 +0100 <dminuoso> RFC5322 is based on 822, which uses 2-digits years (but introduces a comma after the day. also uses 4-letter days)
2023-01-02 14:19:40 +0100 <dminuoso> "Thur, 16 Dec 22 08:43:15 PST"
2023-01-02 14:19:49 +0100 <dminuoso> "Thu, 16 Dec 2022 08:43:15 PST"
2023-01-02 14:20:06 +0100 <dminuoso> The former is 5322 and the latter is 1123
2023-01-02 14:20:12 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-01-02 14:20:29 +0100 <dminuoso> Or maybe uh. I dont know
2023-01-02 14:20:41 +0100 <dminuoso> https://xkcd.com/927/
2023-01-02 14:21:15 +0100 <maerwald> dminuoso: RFC822
2023-01-02 14:21:23 +0100 <maerwald> this parser seems to handle it
2023-01-02 14:21:28 +0100 <maerwald> it just fails on PST
2023-01-02 14:21:33 +0100xff0x(~xff0x@p3326132-ipngn2103sapodori.hokkaido.ocn.ne.jp)
2023-01-02 14:21:46 +0100 <ncf> i'm going by date(1), which says > output date and time in RFC 5322 format. Example: Mon, 14 Aug 2006 02:34:56 -0600
2023-01-02 14:21:47 +0100 <maerwald> "%a, %d %b %Y %H:%M:%S GMT"
2023-01-02 14:21:51 +0100fizbin(~fizbin@user/fizbin) (Ping timeout: 268 seconds)
2023-01-02 14:21:59 +0100 <maerwald> GMT is hardcoded
2023-01-02 14:22:15 +0100 <merijn> ncf: That has a numerical UTC offset and not a timezone, though
2023-01-02 14:22:27 +0100 <merijn> PST is not a numerical UTC offset
2023-01-02 14:22:51 +0100 <merijn> Also, reminds me I should avoid any shit involving dates
2023-01-02 14:22:57 +0100troydm(~troydm@host-176-37-124-197.b025.la.net.ua) (Ping timeout: 252 seconds)
2023-01-02 14:23:01 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-01-02 14:23:06 +0100 <dminuoso> ncf: Mmm, it seems it is at least RFC5322 compatible, anyway
2023-01-02 14:23:20 +0100 <dminuoso> That is, an RFC5322 compliant parser should be able to deal with it (@maerwald also)
2023-01-02 14:23:31 +0100 <dminuoso> zone = (FWS ( "+" / "-" ) 4DIGIT) / obs-zone
2023-01-02 14:23:36 +0100 <ncf> apparently section 4.3 of RFC5322 describes an "obsolete" format which allows 2-digit years *and* alphabetic timezones like PST (equivalent to -0800)
2023-01-02 14:23:44 +0100chiselfuse(~chiselfus@user/chiselfuse) (Ping timeout: 255 seconds)
2023-01-02 14:24:12 +0100 <dminuoso> Yeah.
2023-01-02 14:24:27 +0100 <dminuoso> I mean its impossible to say which RFC is followed from a sample sizse of 1
2023-01-02 14:24:29 +0100 <merijn> alphabetical timezones are very much not equivalent to UTC offsets, because the timezone to UTC mapping is not static :p
2023-01-02 14:24:31 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-01-02 14:24:43 +0100 <int-e> is this applied steganography ;)
2023-01-02 14:24:44 +0100 <merijn> This is also why you cannot store future times in UTC
2023-01-02 14:24:46 +0100 <dminuoso> RFC1123 and RFC5322 have production rules allowing for this particular example that maerwald provided.
2023-01-02 14:25:32 +0100 <dminuoso> merijn: Heh indeed, I didnt consider it until North Korea decided, for a short while, to change their timezone offset.
2023-01-02 14:26:05 +0100 <dminuoso> They switched from UTC+09:00 to UTC+08:30 for a few years
2023-01-02 14:26:21 +0100 <maerwald> time warfare
2023-01-02 14:26:59 +0100 <dminuoso> maerwald: Honestly if you want to correctly parse the time stamp, you will have to consult documentation or the implementation.
2023-01-02 14:27:17 +0100 <dminuoso> Judging from a singular sample can be tricky because you dont know under what conditions it might explore other production rules of whatever standard it is using
2023-01-02 14:27:19 +0100CiaoSen(~Jura@p200300c9571bac002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-01-02 14:27:41 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-02 14:27:42 +0100razetime(~Thunderbi@49.207.194.134) (Quit: razetime)
2023-01-02 14:28:04 +0100 <maerwald> is there a RFC5322 compliant parser?
2023-01-02 14:29:36 +0100fizbin(~fizbin@user/fizbin)
2023-01-02 14:30:24 +0100 <maerwald> I don't feel masochistic enough to write one
2023-01-02 14:30:49 +0100 <maerwald> don't think my opioid lasts for that long
2023-01-02 14:30:56 +0100 <dminuoso> Just interface with ChatGPT and ask it to convert into an ISO 8601 string.
2023-01-02 14:31:15 +0100 <dminuoso> Given that you're using amazonka, you clearly have an internet connection.
2023-01-02 14:31:28 +0100 <maerwald> I refuse to utilize ChatGPT
2023-01-02 14:31:41 +0100 <dminuoso> No I didnt mean to generate code, I meant it as part of your library!
2023-01-02 14:31:44 +0100 <dminuoso> :p
2023-01-02 14:31:49 +0100 <maerwald> that too
2023-01-02 14:32:30 +0100 <maerwald> they're taking our jobs... I wanna build an AI firewall
2023-01-02 14:32:46 +0100 <dminuoso> Why not use ChatGPT to build an AI firewall for you!
2023-01-02 14:33:15 +0100chiselfuse(~chiselfus@user/chiselfuse) (Remote host closed the connection)
2023-01-02 14:33:27 +0100 <maerwald> why S3 is such a clusterf**k I still don't know
2023-01-02 14:33:53 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-02 14:35:02 +0100 <merijn> dminuoso: EU is still working on ditching summer time, no?
2023-01-02 14:35:12 +0100 <merijn> dminuoso: That'll turn into a mess of changing timezones too
2023-01-02 14:35:33 +0100 <dminuoso> merijn: "working on" is one way of phrasing it.
2023-01-02 14:35:56 +0100 <merijn> I mean, every year there's a bunch of countries changing UTC offsets, so the North Korea is hardly unique
2023-01-02 14:36:11 +0100 <merijn> dminuoso: It was ratified and now mired indefinitely in bureaucracy? ;)
2023-01-02 14:36:19 +0100 <dminuoso> No
2023-01-02 14:36:31 +0100 <dminuoso> The decision hasnt been confirmed yet, and is de-facto blocked currently.
2023-01-02 14:36:39 +0100 <maerwald> ah, democracy
2023-01-02 14:37:07 +0100 <maerwald> just a bunch of groups trolling each other
2023-01-02 14:37:32 +0100 <dminuoso> Yup, the european commission is effectively delaying it, by just *waiting* for the member states to just randomly come together and come up with a shared position.
2023-01-02 14:37:43 +0100 <dminuoso> Which of course is never going to happen on its own magically
2023-01-02 14:38:49 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-01-02 14:40:05 +0100 <dminuoso> By the way, turns out ChatGPT accurately figured out this format to be RFC822 or one of its successors.
2023-01-02 14:40:13 +0100 <dminuoso> Scary piece of software
2023-01-02 14:40:30 +0100 <dminuoso> (Its still inaccurate in that its *not* actually RFC822, but oh-well)
2023-01-02 14:41:07 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Quit: ZNC - https://znc.in)
2023-01-02 14:42:10 +0100 <merijn> dminuoso: I mean, I do agree that ChatGPT is scary software, just not because of it's supposed intelligence :p
2023-01-02 14:42:35 +0100 <merijn> maerwald: Also, going back 15 minutes: s/S3/any AWS service/
2023-01-02 14:42:54 +0100 <dminuoso> Sure, I just see so much potential for degradation in the quality of learning, science and engineering.
2023-01-02 14:43:10 +0100 <dminuoso> It is just good enough to be really impressive, but subtly wrong all the time
2023-01-02 14:43:12 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-02 14:43:37 +0100 <maerwald> merijn: I'm not using AWS even
2023-01-02 14:44:47 +0100 <maerwald> some other services that started throwing 503 errors, then support told me that's the rate limiting for 750 requests per second... then I asked them how a single CI job with 4 threads can send that many requests
2023-01-02 14:44:53 +0100 <maerwald> I did not get a useful answer
2023-01-02 14:45:28 +0100 <dminuoso> maerwald: that being said, you can probably get awway by using parseTimeM with "%a, %d %b %Y %T %z" as the format string. Its not strictly RFC5322 compliant, but will at least work if the singular example is fully representative for all possible output formats.
2023-01-02 14:45:41 +0100 <dminuoso> Ah but hold on, $z is wrong
2023-01-02 14:45:55 +0100 <maerwald> yeah, it uses PTSD string
2023-01-02 14:46:01 +0100 <maerwald> or somesuch
2023-01-02 14:46:17 +0100 <dminuoso> Oh gosh
2023-01-02 14:48:41 +0100 <maerwald> hm, this error only happens on FreeBSD
2023-01-02 14:48:51 +0100 <maerwald> maybe the local time is funny?
2023-01-02 14:49:41 +0100 <maerwald> not surprising... FreeBSD goes to great lengths to annoy anyone who wants to support that platform
2023-01-02 14:50:01 +0100 <maerwald> Windows is more sane than that
2023-01-02 14:50:48 +0100 <dminuoso> So this is going to be tricky
2023-01-02 14:50:58 +0100 <dminuoso> I think you may need tzdata for full correctness
2023-01-02 14:52:13 +0100 <dminuoso> Unless they strictly adhere to RFC5322, in which case you only need to support UT, GMT, EST, EDT, CST, CDT, MST, MDT, PST and PDT
2023-01-02 14:52:19 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-02 14:52:20 +0100 <dminuoso> This is absurd.
2023-01-02 14:52:41 +0100 <dminuoso> But yeah, you absolutely need tzdata here
2023-01-02 14:53:32 +0100freeside(~mengwong@103.252.202.159)
2023-01-02 14:53:47 +0100 <dminuoso> And some library that uses tzdata to calculate the correct UTC offsets
2023-01-02 14:54:40 +0100 <dminuoso> It never occured to me how dumb using a timezone *name* in a timestamp is until today
2023-01-02 14:59:26 +0100thongpv87(~thongpv87@2402:9d80:347:404f:51d:aa77:e86f:6146)
2023-01-02 14:59:49 +0100xff0x(~xff0x@p3326132-ipngn2103sapodori.hokkaido.ocn.ne.jp) (Ping timeout: 256 seconds)
2023-01-02 15:03:10 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 15:03:26 +0100 <eldritchcookie[4> how can i define a injective type family any attempt i made was rejected
2023-01-02 15:03:36 +0100 <eldritchcookie[4> like besides Id?
2023-01-02 15:03:54 +0100 <dminuoso> eldritchcookie[4: Can you show some of your attempts, perhaps?
2023-01-02 15:04:08 +0100 <eldritchcookie[4> like why is this rejected ?
2023-01-02 15:04:08 +0100 <eldritchcookie[4> type family ListToFunctionWithArgs r as = f | f ->r as where
2023-01-02 15:04:08 +0100 <eldritchcookie[4> ListToFunctionWithArgs r (a ': as) = a -> ListToFunctionWithArgs r as
2023-01-02 15:04:08 +0100 <eldritchcookie[4> ListToFunctionWithArgs r '[] = r
2023-01-02 15:04:20 +0100dka(~code-is-a@ns3059207.ip-193-70-33.eu) (Ping timeout: 260 seconds)
2023-01-02 15:04:42 +0100 <eldritchcookie[4> at first glance it seems like i can find both r and as from f
2023-01-02 15:05:39 +0100 <eldritchcookie[4> but i genuinely couldn't just define a injective type family with more than one equation
2023-01-02 15:06:07 +0100igghibu(~igghibu@37.120.201.86)
2023-01-02 15:07:29 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-02 15:07:40 +0100 <eldritchcookie[4> actually how can i constraint r ? if i forbid any Type with a function arrow it obviously works
2023-01-02 15:09:23 +0100 <eldritchcookie[4> ListToFunctionWithArgs (a -> b) '[] = a -> b
2023-01-02 15:09:23 +0100 <eldritchcookie[4> and ListToFunctionWithArgs b '[a] = a -> b?
2023-01-02 15:09:53 +0100 <eldritchcookie[4> like if i know f and r i can find out as
2023-01-02 15:10:25 +0100 <dminuoso> eldritchcookie[4: Judging from just a skim of the type family equation requirements from both the GHC manual and the original PDF, I immediately notice the first problem:
2023-01-02 15:10:30 +0100 <dminuoso> `If a RHS of a type family equation is a type family application GHC reports that the type family is not injective.`
2023-01-02 15:10:49 +0100 <dminuoso> That's from the GHC manual, which is a slight relaxation from the original paper which requires:
2023-01-02 15:11:08 +0100 <dminuoso> A type family F is n-injective iff 1. For every equation F σ = τ : (a) τ is not a type family application, and [...]
2023-01-02 15:12:05 +0100 <dminuoso> And presumably this is becausee of the halting undecidability
2023-01-02 15:12:58 +0100 <eldritchcookie[4> ok how can i make a useful injective type family? please give any non trivial example
2023-01-02 15:13:32 +0100 <eldritchcookie[4> do i use it in constraint from a type class? and then define instances recursively?
2023-01-02 15:13:50 +0100 <dminuoso> Im not exactly sure what you are trying to do.
2023-01-02 15:14:20 +0100 <dminuoso> But it sounds like you have already settled that injective type families are needed for your problem, and are asking how to write them instead. A kind of XY problem
2023-01-02 15:15:27 +0100 <eldritchcookie[4> i have 2 things a problem and interst in injective type families if i could solve it with injective type families it would be amazing but i question more to learn about them
2023-01-02 15:15:36 +0100 <dminuoso> Injectivity is usually used if you either need to guide inference, or if you want to guarantee absence of wrong instances.
2023-01-02 15:20:52 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 15:22:09 +0100 <eldritchcookie[4> how can i turn a type list into a tuple type ?
2023-01-02 15:23:30 +0100 <dminuoso> Since tuple types are wired in, you have to write them out one at a time
2023-01-02 15:23:42 +0100 <dminuoso> There's no underlying recursive construction
2023-01-02 15:24:40 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2023-01-02 15:24:49 +0100 <c_wraith> being wired in is sort of irrelevant. the important part is that the types have no relation to each other
2023-01-02 15:26:23 +0100titibandit(~titibandi@xdsl-89-0-163-79.nc.de)
2023-01-02 15:27:04 +0100 <eldritchcookie[4> is there a default GADT heterogeneous list? i really do not want to just define a HList GADT but i also do not want to depend on a library made by people that think OOHaskel is a good idea
2023-01-02 15:27:07 +0100 <dminuoso> type family ToTuple (c :: [Type]) :: Type where ToTuple '[a] = (a); ToTuple '[a, b] = (a, b) ...
2023-01-02 15:27:12 +0100 <dminuoso> eldritchcookie[4: ^- something like this.
2023-01-02 15:27:20 +0100 <dminuoso> You can use TH of course to remove the boilerplate
2023-01-02 15:28:06 +0100troydm(~troydm@host-176-37-124-197.b025.la.net.ua)
2023-01-02 15:28:22 +0100nschoe(~q@141.101.51.197) (Quit: Switching off)
2023-01-02 15:28:29 +0100 <eldritchcookie[4> argh i hate writing TH is there really no other way:
2023-01-02 15:28:32 +0100 <eldritchcookie[4> ?
2023-01-02 15:29:30 +0100 <dminuoso> Like c_wraith said, there's no relationship between the individual tuple types
2023-01-02 15:29:41 +0100 <dminuoso> And there's an upper limit too (I think 63-tuple is the maximum)
2023-01-02 15:30:25 +0100 <dminuoso> Do think of just a bunch of separate types `data Tuple2 a b = Tuple2 a b`, `data Tuple3 a b c = Tuple3 a b c`
2023-01-02 15:30:41 +0100 <eldritchcookie[4> guess i will swallow the TH then, surely no one uses functions with more than 63 arguments right?
2023-01-02 15:31:00 +0100 <merijn> eldritchcookie[4: GHC doesn't even implement tuples with more then 63 arguments :p
2023-01-02 15:31:04 +0100 <dminuoso> I would just write out the cases, its much easier to write and be sure its right.
2023-01-02 15:31:19 +0100 <dminuoso> merijn: Just be silent on the backstory why that limit exists.
2023-01-02 15:31:30 +0100 <dminuoso> It might alarm people.
2023-01-02 15:31:35 +0100 <dminuoso> :p
2023-01-02 15:31:36 +0100 <merijn> dminuoso: Videogame programming :p
2023-01-02 15:31:50 +0100 <dminuoso> Okay Im not familiar with that expression
2023-01-02 15:32:05 +0100 <merijn> dminuoso: That's one my systems programming professor coined in the class teaching C
2023-01-02 15:32:09 +0100xff0x(~xff0x@p3326132-ipngn2103sapodori.hokkaido.ocn.ne.jp)
2023-01-02 15:32:16 +0100 <merijn> dminuoso: The process of treating programming as if it is a videogame
2023-01-02 15:32:42 +0100 <c_wraith> ooh, am I going for the high score in tuple size?
2023-01-02 15:32:43 +0100 <merijn> i.e. compiler error/crash is game over, and then you just randomly try something else until you "beat the level" (it compiles and appears to work)
2023-01-02 15:32:56 +0100 <dminuoso> I see.
2023-01-02 15:33:04 +0100 <merijn> dminuoso: As opposed to trying to understand what/how/why
2023-01-02 15:33:07 +0100 <dminuoso> So code golfing is the equivalent of speed runs then?
2023-01-02 15:33:47 +0100nschoe(~q@141.101.51.197)
2023-01-02 15:34:27 +0100 <merijn> dminuoso: not really, most code golfers actually think long and hard on how you can do things
2023-01-02 15:34:28 +0100 <dminuoso> eldritchcookie[4: If you are going to make a bet on that, I will create an acme-64 package just for you.
2023-01-02 15:34:45 +0100 <dminuoso> merijn: sure, just like speed runners think long and hard and practice how to do things.
2023-01-02 15:34:49 +0100 <merijn> dminuoso: It's more akin to "cargo cult programming" in the sense of "doing things without udnerstanding"
2023-01-02 15:34:57 +0100 <dminuoso> Its not like many of their paths are just accidental
2023-01-02 15:35:17 +0100titibandit(~titibandi@xdsl-89-0-163-79.nc.de) (Remote host closed the connection)
2023-01-02 15:36:11 +0100 <merijn> dminuoso: The difference is that "videogame programming" is about the *process* used to program, whereas code golfing is merely about the end result (and generally the way those results are obtained are the exact opposite of videogame programming)
2023-01-02 15:37:08 +0100 <dminuoso> eldritchcookie[4: that packge will have functions const65 through constXXXXXXXXXXXX until such a high number, that the linker will run out of memory. Goal of the package? Ensuring a quality universe of packages that do not assume an upper limit of function arguments.
2023-01-02 15:37:54 +0100 <dminuoso> merijn: Fair. I do recall when I was a kid learning C and just adding asterisks and ampersands until the compiler seemed to be happy.
2023-01-02 15:38:01 +0100 <dminuoso> It did seem like playing a videogame without understanding the rules.
2023-01-02 15:38:58 +0100 <boxscape_> sounds like me with rust and lifetime annotations
2023-01-02 15:39:21 +0100 <boxscape_> (except for the "when I was a kid" part)
2023-01-02 15:39:35 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340)
2023-01-02 15:40:28 +0100 <dminuoso> Some of Haskell was the same for me.
2023-01-02 15:40:45 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:bccb:1151:f053:cd4c)
2023-01-02 15:40:51 +0100jakalx(~jakalx@base.jakalx.net)
2023-01-02 15:40:52 +0100 <dminuoso> We even sometimes teach that style as hole-driven programming.
2023-01-02 15:41:08 +0100 <dminuoso> "Dont think about programming, just play the type checker"
2023-01-02 15:41:42 +0100 <boxscape_> yeah especially taken to its extreme when proving something in agda it can feel very much like a video game
2023-01-02 15:41:43 +0100geekosaurhates type tetris
2023-01-02 15:42:00 +0100 <geekosaur> strongly prefer to understand why
2023-01-02 15:42:21 +0100 <dminuoso> boxscape_: I mean the compiler is a computer program, there's a user interface (via text files), there's some output, and you get quite a level of gratification upon success.
2023-01-02 15:42:26 +0100 <dminuoso> This *is* computer games.
2023-01-02 15:42:31 +0100 <boxscape_> fair
2023-01-02 15:43:58 +0100 <dminuoso> maerwald: By the way, my mission for postgresql-micro has started! But I must say, hasql is really cleanly written - it's almost a shame it comes with a dependency forest the size of a kmettiverse.
2023-01-02 15:44:38 +0100 <dminuoso> A lot of the functions Im writing end up looking quite like Nikitas work accidentally
2023-01-02 15:45:02 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:bccb:1151:f053:cd4c) (Ping timeout: 246 seconds)
2023-01-02 15:45:57 +0100 <merijn> geekosaur: For you:
2023-01-02 15:46:03 +0100 <merijn> @quote autrijus didn't.you.write
2023-01-02 15:46:03 +0100 <lambdabot> autrijus says: * autrijus stares at type Eval x = forall r. ContT r (ReaderT x IO) (ReaderT x IO x) and feels very lost <shapr> Didn't you write that code? <autrijus> yeah. and it works <autrijus> I
2023-01-02 15:46:03 +0100 <lambdabot> just don't know what it means.
2023-01-02 15:46:18 +0100 <geekosaur> yep, I've seen that one
2023-01-02 15:46:27 +0100 <geekosaur> both the quote and the code in context 🙂
2023-01-02 15:46:42 +0100 <merijn> I certainly recall several times working on haskell that felt like that
2023-01-02 15:46:49 +0100 <geekosaur> tbh I understood the code better than the uses of it
2023-01-02 15:47:19 +0100 <geekosaur> my attempt to resuscitate pugs was very short lived
2023-01-02 15:47:24 +0100 <merijn> I wrote some subprocess management code to set up a process AND some extra pipes to it, it works marvelously, but I'm very confused looking at it now xD
2023-01-02 15:55:47 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.7.1)
2023-01-02 15:57:53 +0100 <maerwald[m]> dminuoso: yeah, he's a good engineer
2023-01-02 15:58:41 +0100 <maerwald[m]> As in: not stuffing everything full of category theory and type level programming, but making balanced decisions
2023-01-02 16:00:16 +0100 <maerwald[m]> E.g. avoiding type classes for the encoders/decoders
2023-01-02 16:00:30 +0100 <maerwald[m]> Because those really suck
2023-01-02 16:00:40 +0100CiaoSen(~Jura@p200300c9571bac002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-01-02 16:01:43 +0100igghibu(~igghibu@37.120.201.86) (Quit: igghibu)
2023-01-02 16:02:28 +0100xff0x(~xff0x@p3326132-ipngn2103sapodori.hokkaido.ocn.ne.jp) (Ping timeout: 252 seconds)
2023-01-02 16:04:04 +0100 <maerwald[m]> For the finicky parts, just using TH instead of coming up with beam style APIs
2023-01-02 16:07:08 +0100ryantrinkle(~ryantrink@209.91.238.110)
2023-01-02 16:07:33 +0100 <ryantrinkle> i'm using ghc 8.10.7 and -package flags seem to fail in the presence of cabal sublibraries
2023-01-02 16:07:46 +0100 <ryantrinkle> even though a -package flag is present, GHC still gives an error saying it is hidden
2023-01-02 16:07:49 +0100 <ryantrinkle> has anyone else seen this?
2023-01-02 16:12:26 +0100tremon(~tremon@83-85-213-108.cable.dynamic.v4.ziggo.nl)
2023-01-02 16:20:54 +0100 <c_wraith> is it a private sublibrary?
2023-01-02 16:21:48 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-02 16:25:55 +0100elkcl_(~elkcl@broadband-188-255-19-11.ip.moscow.rt.ru)
2023-01-02 16:27:26 +0100elkcl(~elkcl@broadband-188-255-19-11.ip.moscow.rt.ru) (Ping timeout: 246 seconds)
2023-01-02 16:29:18 +0100elkcl(~elkcl@broadband-188-255-19-11.ip.moscow.rt.ru)
2023-01-02 16:29:28 +0100boxscape_(~boxscape_@213.52.37.155) (Quit: Connection closed)
2023-01-02 16:30:38 +0100elkcl_(~elkcl@broadband-188-255-19-11.ip.moscow.rt.ru) (Ping timeout: 272 seconds)
2023-01-02 16:31:27 +0100 <merijn> It has been 0 days since I last wished I could combine qualified imports with an import list in one declaration
2023-01-02 16:33:36 +0100 <merijn> All these pointless syntax tweaking proposals and extensions, and that's the one that'd most directly impact my life positively :p
2023-01-02 16:33:49 +0100 <Jadesheit[m]> make it :)
2023-01-02 16:34:00 +0100 <dolio> You can combine them. It just doesn't mean what you want. :)
2023-01-02 16:34:04 +0100 <merijn> dminuoso: That'
2023-01-02 16:34:11 +0100 <merijn> dolio: That's my point
2023-01-02 16:34:18 +0100 <merijn> dolio: The current version is stupid >.<
2023-01-02 16:40:11 +0100 <eldritchcookie[4> why does this code fail with can't match as ++ '[f ] with as0 ++ '[f]... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/57e0fc7347352e9d4811266c4e93ebfb112f…>)
2023-01-02 16:40:33 +0100 <eldritchcookie[4> like i literally did nothing yet and it doesn't typecheck?
2023-01-02 16:45:08 +0100razetime(~Thunderbi@49.207.194.134)
2023-01-02 16:48:47 +0100yvan-sraka(sid419690@id-419690.lymington.irccloud.com)
2023-01-02 16:48:48 +0100chexum_(~quassel@gateway/tor-sasl/chexum)
2023-01-02 16:48:53 +0100chexum(~quassel@gateway/tor-sasl/chexum) (Quit: No Ping reply in 180 seconds.)
2023-01-02 16:53:48 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 16:53:49 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:83e4:99f0:e8cd:3cd7) (Quit: WeeChat 2.8)
2023-01-02 17:00:14 +0100CiaoSen(~Jura@p200300c9571bac002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 255 seconds)
2023-01-02 17:01:54 +0100ddellacosta(~ddellacos@86.106.143.57)
2023-01-02 17:02:50 +0100mei(~mei@user/mei)
2023-01-02 17:06:13 +0100king_gs(~Thunderbi@2806:103e:29:45ac:af0:afaf:29e7:dd60)
2023-01-02 17:08:54 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-01-02 17:11:10 +0100trev(~trev@user/trev)
2023-01-02 17:13:50 +0100 <EvanR> talismanick, well Auto is a Profunctor...
2023-01-02 17:16:23 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 264 seconds)
2023-01-02 17:17:35 +0100catern(~sbaugh@2604:2000:8fc0:b:a9c7:866a:bf36:3407) (Remote host closed the connection)
2023-01-02 17:24:58 +0100thongpv87(~thongpv87@2402:9d80:347:404f:51d:aa77:e86f:6146) (Ping timeout: 252 seconds)
2023-01-02 17:28:26 +0100shelby(~thomas_sh@115.96.219.157)
2023-01-02 17:29:03 +0100shelby(~thomas_sh@115.96.219.157) (Client Quit)
2023-01-02 17:29:20 +0100razetime(~Thunderbi@49.207.194.134) (Remote host closed the connection)
2023-01-02 17:29:55 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Ping timeout: 252 seconds)
2023-01-02 17:31:34 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-01-02 17:34:43 +0100freeside(~mengwong@103.252.202.159)
2023-01-02 17:35:23 +0100cameron_(~quassel@050-089-109-059.res.spectrum.com)
2023-01-02 17:35:26 +0100razetime(~Thunderbi@49.207.194.134)
2023-01-02 17:36:03 +0100 <cameron_> so are you guys telling me the only way to perform IO in this language is to treat IO as a function that takes in the state of reality before the operation and returns the state of reality after the operation has been performed
2023-01-02 17:37:07 +0100 <dolio> No, that is just the implementation used.
2023-01-02 17:37:15 +0100 <dolio> That explanation doesn't really make sense.
2023-01-02 17:37:31 +0100 <cameron_> so what is the explanation that does make sense
2023-01-02 17:38:01 +0100 <geekosaur> it's not really the "state of reality", it's just a baton that gets handed off between IO operations so they happen in the right order
2023-01-02 17:38:25 +0100 <mauke> depends on what exactly you are looking for
2023-01-02 17:38:31 +0100 <dolio> IO is some more abstract type that doesn't have the same degeneracies as `World -> (a, World)`.
2023-01-02 17:38:58 +0100 <mauke> e.g. do you know javascript with async/await?
2023-01-02 17:39:02 +0100 <cameron_> just wondering how an IO operation is still a pure function
2023-01-02 17:39:12 +0100 <cameron_> yeah ive been reasoning it as javascripts then basically
2023-01-02 17:39:37 +0100 <geekosaur> because you're in effect building a program purely, then handing it off to the impure runtime to execute
2023-01-02 17:39:47 +0100 <c_wraith> cameron_: what we're saying is that IO is reified as *values* which can be passed around, composed, and generally treated like any other kind of value. How is that implemented? Doesn't matter. What it *means* is the important part.
2023-01-02 17:40:08 +0100 <mauke> do you understand how a pure language with recursion can express any computation?
2023-01-02 17:40:38 +0100 <cameron_> just in the way that recursion and imperative loops are pretty much interchangeable
2023-01-02 17:41:48 +0100 <cameron_> so every IO operation is just like a checkpoint basically and the state is a collection of the actions you've performed?
2023-01-02 17:42:07 +0100 <mauke> there are no checkpoints, really
2023-01-02 17:42:44 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-01-02 17:42:44 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-01-02 17:42:44 +0100wroathe(~wroathe@user/wroathe)
2023-01-02 17:44:22 +0100 <mauke> the way I think about it (first approximation) is: Haskell is a (pure) macro language for an imperative runtime language
2023-01-02 17:45:21 +0100 <mauke> that is, your Haskell code simply builds a list of imperative actions for some other interpreter to execute
2023-01-02 17:45:57 +0100 <mauke> which is a lot like constructing a string, then running it as a shell script
2023-01-02 17:47:08 +0100 <mauke> that's enough to explain main, putStr, and >>, but it doesn't go further than that
2023-01-02 17:47:39 +0100king_gs(~Thunderbi@2806:103e:29:45ac:af0:afaf:29e7:dd60) (Ping timeout: 248 seconds)
2023-01-02 17:48:12 +0100 <mauke> to properly explain >>= and getChar, we need to add the concept of callbacks from impure to pure code
2023-01-02 17:48:45 +0100 <cameron_> its just wierd to imagine the pure mathematical model relies on the state of the hardware its running on at a certain point of execution as an input
2023-01-02 17:48:53 +0100 <yushyin> when i was learning haskell, i thought of IO as a kind of (e)DSL that is interpreted by the runtime eventually
2023-01-02 17:48:53 +0100 <mauke> like a shell script that can dynamically invoke a utility to build more script fragments to run next
2023-01-02 17:49:50 +0100 <geekosaur> cameron_, but it doesn't. as I said earlier, all that "state" does is ensure IO actions happen in the right order
2023-01-02 17:50:38 +0100 <geekosaur> it's an empty state that is passed between actions so they depend on each other. ghc even erases it after that part is done
2023-01-02 17:50:54 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-02 17:50:55 +0100 <mauke> the pure mathematical model might
2023-01-02 17:50:56 +0100 <mauke> but that's not what we're actually running
2023-01-02 17:52:16 +0100 <cameron_> i guess in the end its just instructions
2023-01-02 17:52:20 +0100 <cameron_> like an interface to the runtime
2023-01-02 17:53:22 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:bccb:1151:f053:cd4c)
2023-01-02 17:54:47 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds)
2023-01-02 17:55:39 +0100 <cameron_> so is the main way to write concurrent programs or fetch some data over the internet just similar to using .then in javascript?
2023-01-02 17:55:58 +0100 <monochrom> GHC uses "State#" as a coding trick to trick the code generator into preserving code order.
2023-01-02 17:56:48 +0100 <monochrom> Because normally (without a data dependency, real or fictional) the code generator aims at re-ordering code for optimizations.
2023-01-02 17:57:15 +0100 <monochrom> State# is a phantom type, i.e., no actual value. It's fictional data dependency.
2023-01-02 17:57:44 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 246 seconds)
2023-01-02 17:57:51 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-01-02 17:57:51 +0100 <monochrom> This we know because we can look at the asm code and see no State# there.
2023-01-02 17:58:05 +0100 <monochrom> As opposed to armchair-philosophizing it.
2023-01-02 17:58:12 +0100 <mauke> cameron_: yes, pretty much
2023-01-02 17:58:25 +0100merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)
2023-01-02 17:58:49 +0100 <mauke> only we spell it >>=, not .then
2023-01-02 17:59:18 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 272 seconds)
2023-01-02 17:59:18 +0100 <dolio> And have syntax that isn't terrible.
2023-01-02 17:59:28 +0100 <cameron_> so what is the basis in lambda calculus that accounts for data dependency
2023-01-02 17:59:29 +0100king_gs(~Thunderbi@187.201.110.169)
2023-01-02 17:59:30 +0100 <monochrom> :)
2023-01-02 17:59:35 +0100 <cameron_> like only perform this calculation if this data exists
2023-01-02 17:59:38 +0100 <mauke> debatable
2023-01-02 17:59:52 +0100 <mauke> huh?
2023-01-02 18:00:00 +0100 <monochrom> Lazy evaluation.
2023-01-02 18:00:32 +0100 <cameron_> i guess thats where the phantom data type comes in
2023-01-02 18:01:32 +0100 <cameron_> i do like the syntax though it is elegant, its just going to take some time to learn all the operators lol
2023-01-02 18:02:43 +0100 <mauke> data dependency is normally expressed through lambdas (or else I'm really confused what you are talking about)
2023-01-02 18:03:09 +0100 <dolio> I mean specifically writing .then(...).then(...).then(...) for a sequence of statements is pretty bad.
2023-01-02 18:03:38 +0100 <mauke> (\x.x+1) is a computation that depends on a value x
2023-01-02 18:03:56 +0100 <cameron_> i just dont know a lot about lambda calculus i figured the whole program would be modeled as given some input produce this output
2023-01-02 18:03:58 +0100 <monochrom> I fear that it's actuall .then(... .then(... .then(...))) :)
2023-01-02 18:04:05 +0100 <dolio> Yeah, that's even worse.
2023-01-02 18:04:07 +0100 <cameron_> but by data dependency i thought you meant data that may not exist yet at this time
2023-01-02 18:05:10 +0100 <cameron_> like what is the concept in lambda calculus that allows you to wait for something to happen
2023-01-02 18:06:03 +0100 <mauke> LC is timeless
2023-01-02 18:06:24 +0100 <dolio> An application of a function depends on that function.
2023-01-02 18:06:47 +0100 <mauke> but we're bolting it on to an imperative runtime that knows how to interact with the OS
2023-01-02 18:06:52 +0100 <cameron_> so you just have an instruction that tells the compiler that you are waiting for something
2023-01-02 18:07:16 +0100 <dolio> In pure lambda calculus, since you need to represent all data with functions, data dependencies are determined by function application.
2023-01-02 18:07:34 +0100mei_(~mei@user/mei)
2023-01-02 18:07:38 +0100 <mauke> and then it just calls a function with the results
2023-01-02 18:07:40 +0100 <dolio> In something richer you'd have case statements on data.
2023-01-02 18:08:24 +0100 <dolio> And you can't generally choose which branch to go to without looking at the data.
2023-01-02 18:08:36 +0100 <dminuoso> cameron_: My preferred interpretation of IO is more like `type IO = [Instruction]`, that is thinking of an IO action as just a series of instructions that can be executed by some abstract machine.
2023-01-02 18:08:53 +0100 <dminuoso> or `newtype IO = IO [Instruction]` if you want
2023-01-02 18:09:44 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:bccb:1151:f053:cd4c) (Remote host closed the connection)
2023-01-02 18:09:55 +0100 <dminuoso> I dont think there's much utility in looking at the internals of IO in hopes of gaining a deeper understanding of Haskell itself. After compilation, that "state threading" disappears entirely, erased, so its a completely fictional trick that is just used by GHC implementation.
2023-01-02 18:10:04 +0100mei(~mei@user/mei) (Ping timeout: 252 seconds)
2023-01-02 18:10:18 +0100 <mauke> yeah, the I/O library (e.g. getChar) is in cahoots with the runtime system
2023-01-02 18:11:02 +0100 <dminuoso> Oh `newtype IO a = ...` of course, I missed the relatively important type of the result you would get, if you were to execute said abstract instructions.
2023-01-02 18:11:29 +0100 <cameron_> that makes more sense to think of it as a functional interaction with the machine
2023-01-02 18:11:42 +0100 <dminuoso> not "functional" really
2023-01-02 18:13:39 +0100 <cameron_> so is haskell really "almost" purely functional
2023-01-02 18:14:10 +0100 <dminuoso> Our IO is pure in the sense that evaluation does not cause execution (in the absence of unsafePerformIO)
2023-01-02 18:14:11 +0100 <mauke> depends on your definition of "haskell" :-)
2023-01-02 18:14:16 +0100dsrt^(~dsrt@76.145.185.103) (Remote host closed the connection)
2023-01-02 18:14:23 +0100 <cameron_> lol
2023-01-02 18:14:32 +0100 <dminuoso> cameron_: Why do you say "almost"?
2023-01-02 18:14:49 +0100 <mauke> lambdabot: test
2023-01-02 18:14:53 +0100 <monochrom> To answer that, you must respect types, too.
2023-01-02 18:15:14 +0100 <cameron_> like there are some aspects that need to be passed off to the underlying turing machine at some point
2023-01-02 18:15:23 +0100 <monochrom> Suppose x :: String. Then purely function means that x is the same string every times. Haskell upholds that.
2023-01-02 18:15:24 +0100 <dminuoso> That's unrelated
2023-01-02 18:15:31 +0100 <jean-paul[m]> cameron_: Consider the type of `main`. It isn't `()`. It's `IO ()`. You _didn't_ do I/O by evaluating `main`.
2023-01-02 18:15:33 +0100 <dminuoso> cameron_: The key difference Im trying to get at is execution versus evaluation.
2023-01-02 18:15:45 +0100 <monochrom> Fortunately, getLine :: IO String, not getLine :: String.
2023-01-02 18:16:22 +0100 <dminuoso> cameron_: The *evaluation* of Haskell (in sense of a graph reduction machine) is in principle pure (in the absence of dark primitives like unsafePerformIO)
2023-01-02 18:16:47 +0100 <monochrom> Purely functional on getLine :: IO String requires only that getLine is the same procedure every time. Fortunately, that's a tautology.
2023-01-02 18:18:04 +0100 <cameron_> so the fact that you are performing the same operations on every execution is what makes it purely functional
2023-01-02 18:18:11 +0100 <dminuoso> cameron_: Here's a funny primitive that lets us explore it: `pseq` takes two argument, it first *evaluates* the first argument and then afterwards returns the second. It's a magic primitive provided by GHC Haskell. It is useful because it lets us maket hsi comparison:
2023-01-02 18:18:29 +0100 <dminuoso> By evaluate I mean in the sence of forcing it, graph reductions taking place, in the sence of substition, etc..
2023-01-02 18:18:46 +0100 <dminuoso> % pseq (putStrLn "Hello World") ()
2023-01-02 18:18:46 +0100 <yahb2> ()
2023-01-02 18:19:07 +0100 <cameron_> that sounds pretty hacky
2023-01-02 18:19:12 +0100 <dminuoso> Note how yahb2 did not cause any printing, despite the action `putStrLn "Hello World"` being evaluated
2023-01-02 18:19:13 +0100 <dolio> The only meaningful way to answer questions like these are with respect to useful properties that they entail, like, "can I reorder/factor/inline/etc. expressions without worrying about it?" And the answer to that is "yes," at least if you're precise about what an "expression" is.
2023-01-02 18:19:33 +0100 <monochrom> No. C's gets stands the same operation every time too. But since its type is ()->String, we judge it by asking "is gets() the same string every time?". The answer is no.
2023-01-02 18:20:20 +0100 <dminuoso> cameron_: So its not really hacky, seq (which is related to pseq) is actually part of the Haskell specification itself. It is useful because it lets us control evaluation order which can help in certain performance issues.
2023-01-02 18:21:04 +0100 <cameron_> so main = getLine >>= putStrLn is not exactly a pure function
2023-01-02 18:21:14 +0100 <dolio> It's not a function.
2023-01-02 18:21:14 +0100 <dminuoso> main is not a function.
2023-01-02 18:21:19 +0100 <dminuoso> But it is a pure valu.
2023-01-02 18:21:23 +0100 <monochrom> :D
2023-01-02 18:21:24 +0100 <cameron_> i see
2023-01-02 18:21:44 +0100 <dminuoso> cameron_: Like I said, think of `newtype IO a = IO [Instruction]`
2023-01-02 18:21:57 +0100 <dminuoso> cameron_: So evaluation would amount to evaluating the list of instructions to execute
2023-01-02 18:22:06 +0100 <dminuoso> (which is very different from actually executing them)
2023-01-02 18:22:53 +0100 <dminuoso> And by the same logic `>>=` doesnt actually execute either, in that view of the world it just calculates a new set of instructions that combines two IO actions.
2023-01-02 18:23:54 +0100 <cameron_> so it does make more sense to me in terms of creating lists of instructions
2023-01-02 18:24:37 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-02 18:25:12 +0100 <dminuoso> Right. And in the above case with `pseq (putStrLn "Hello World") ()` all we did was conceptually compute the list of instructions that, if executed, would print Hello World. But that doesnt print hello world for the same reason that computing a recipe doesnt actually bake the cake.
2023-01-02 18:25:14 +0100 <cameron_> which are then run seperately
2023-01-02 18:25:21 +0100razetime(~Thunderbi@49.207.194.134) (Remote host closed the connection)
2023-01-02 18:25:35 +0100 <dminuoso> (And in that analogy a recipe is just a list of cooking instructions)
2023-01-02 18:26:42 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 18:28:01 +0100justsomeguy(~justsomeg@user/justsomeguy)
2023-01-02 18:28:10 +0100 <dminuoso> cameron_: And further, in that sense putStrLn is a pure and deterministic function. If you apply `putStrLn` to "hello world" you always get the same list of instructions back - it's completely pure. Similarly any mention of `getLine` is the same list of instructions - its also completely pure
2023-01-02 18:28:43 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Ping timeout: 248 seconds)
2023-01-02 18:29:31 +0100 <cameron_> doesn't that get wierd if putStrLn were to for some reason fail
2023-01-02 18:29:41 +0100 <cameron_> but still the instructions for handling failure would be the same
2023-01-02 18:30:28 +0100titibandit(~titibandi@xdsl-89-0-163-79.nc.de)
2023-01-02 18:30:37 +0100 <dminuoso> That particular function not fail, the execution might however.
2023-01-02 18:30:49 +0100 <dminuoso> And for that failure we have IO exceptions
2023-01-02 18:30:59 +0100 <mauke> > let x = putStr "hello" in length [x, x, x]
2023-01-02 18:31:00 +0100 <lambdabot> 3
2023-01-02 18:31:16 +0100 <dminuoso> mauke: to be fair, you only forced the spine not the elements.
2023-01-02 18:31:20 +0100 <cameron_> thank you lambdabot lol
2023-01-02 18:31:45 +0100merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl) (Ping timeout: 256 seconds)
2023-01-02 18:31:57 +0100 <mauke> sure, but this example would work the same way in a strict language
2023-01-02 18:32:42 +0100 <dminuoso> cameron_: perhaps the strange thing about Haskell is not necessarily IO, but rather the potential lack of it.
2023-01-02 18:33:27 +0100 <dminuoso> cameron_: In traditional languages like say C or Python, if we used haskell equivalent types, everything ends up producing an IO action. There's no way to state "this thing is pure and doesnt do anything"
2023-01-02 18:34:24 +0100 <dminuoso> Which is why the terms functions and routines became intermingled to mean the same thing, because in C everything is a routine.
2023-01-02 18:34:37 +0100 <dminuoso> (well presumably the break in terminology dates back even further, but anyway)
2023-01-02 18:35:34 +0100 <dminuoso> So in an etymological sense, C erreoneously names everything a function, but in truth these are all routines. They dont have functions in the mathematical sense at all.
2023-01-02 18:36:27 +0100 <dminuoso> The way we do it in our type system, these can coexist. putStrLn is a function producing a "routine/action/list-of-instructions"
2023-01-02 18:36:31 +0100 <dolio> They do. You just can't tell them apart from all non-functions.
2023-01-02 18:39:46 +0100 <cameron_> so \x -> x is a function that returns the input but getStrLn >>= putStrLn is a function that produces a routine and then sends that output to another function that produces a seperate routine
2023-01-02 18:40:02 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-01-02 18:41:14 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net)
2023-01-02 18:41:56 +0100 <mauke> getStrLn >>= putStrLn is not a function
2023-01-02 18:42:23 +0100 <[exa]> cameron_: not sure if someone wrote it here already but I like the RealWorld look at IO, `newtype IO a = IO (RealWorld -> (a,RealWorld))`. Chaining is kinda straightforward there, and you see your get>>=put is very wrapped as a function
2023-01-02 18:42:43 +0100 <c_wraith> [exa]: that's exactly the bad starting point we're trying to get away from
2023-01-02 18:42:59 +0100 <[exa]> ah okay (but why, it helped me a lot. :D )
2023-01-02 18:43:29 +0100 <c_wraith> well, because it's not a function.
2023-01-02 18:43:38 +0100 <mauke> the RealWorld thing is a compiler hack inside ghc that simplifies code generation. it's not a useful abstraction
2023-01-02 18:43:41 +0100 <cameron_> well together they may not be but is getStrLn by itself not a function that produces some routine
2023-01-02 18:43:45 +0100 <cameron_> and then pipes its output to another
2023-01-02 18:44:16 +0100 <c_wraith> putStrLn is a function. (>>=) is a function. getLine is not a function, nor is (getLine >>= putStrLn)
2023-01-02 18:45:10 +0100 <cameron_> whoops i started blending stuff together lol
2023-01-02 18:45:33 +0100 <[exa]> c_wraith: well it "contains" a function (and the wrap is thin/zero because newtype), from runtime perspective that's egal
2023-01-02 18:46:16 +0100 <mauke> getLine is a constant, not a function
2023-01-02 18:46:34 +0100 <dminuoso> cameron_: Really do try and think of IO as list of instructions, then the role of >>= becomes clearer.
2023-01-02 18:47:27 +0100 <c_wraith> [exa]: The internal things really aren't functions in the Haskell sense. It's good to put a wall up between the meaning of IO and the way GHC implements it, because the way GHC implements it is heavily based on other things GHC does
2023-01-02 18:47:50 +0100 <[exa]> ok
2023-01-02 18:47:52 +0100 <dminuoso> `(>>=)` takes a list of instructions producing a, and a function taking a which would produce further instructions, and overall produces a list of instructions that stitches these two things together, a kind of compound action that if executed, would first execute the first sub-action, once the result was obtained, would feed it into the function, and then *execute* the obtained instructions
2023-01-02 18:47:54 +0100 <dminuoso> further
2023-01-02 18:48:38 +0100 <monochrom> I think you can safely go back to an earlier model you thought up. Haskell is functional and can still do I/O by outsourcing effects to something else, so you just need functional interaction with that something else.
2023-01-02 18:49:01 +0100 <monochrom> Anything more fine-grained is beyond your current level, it seems.
2023-01-02 18:50:46 +0100 <cameron_> yeah im not exactly a computer science phd student, i just started using arrow expressions in javascript and really enjoyed it lol
2023-01-02 18:50:53 +0100 <cameron_> but i am curious about how it all works
2023-01-02 18:51:03 +0100nschoe(~q@141.101.51.197) (Quit: Switching off)
2023-01-02 18:51:25 +0100 <dminuoso> cameron_: Imagine you holding Gordon Ramsays recipe for "blond roux', a further recipe that requires a roux would cook a kind of sauce, then you could just write a new note that combines these two into a new cooking note that first instructs you to make a blond roux, and then fill it into the second recipe. What you get out is a singular recipe.
2023-01-02 18:52:11 +0100Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net) (Ping timeout: 248 seconds)
2023-01-02 18:52:49 +0100 <dminuoso> My point is merely, computing a list of instructions is just different from executing them.
2023-01-02 18:55:37 +0100 <monochrom> physics : spherical elephant of uniform density :: haskell : ReadWorld#
2023-01-02 18:55:38 +0100 <cameron_> it feels like having a blend of all styles of programming in the same language could be both more productive or a nightmare if it goes badly
2023-01-02 18:55:51 +0100 <cameron_> just wanted to see whats going on over here and what the benefits are of staying to the functional style
2023-01-02 18:55:59 +0100merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)
2023-01-02 18:56:17 +0100 <dminuoso> Equational reasoning.
2023-01-02 18:56:27 +0100 <dminuoso> If you dont know what that is, substitute what I wrote with its definition.
2023-01-02 18:56:34 +0100 <cameron_> lol
2023-01-02 18:56:43 +0100 <monochrom> Ugh is that a pun haha
2023-01-02 18:56:56 +0100 <cameron_> seems like
2023-01-02 18:57:06 +0100 <mauke> hahaha
2023-01-02 18:57:37 +0100 <monochrom> Leibniz substitutability principle.
2023-01-02 18:58:13 +0100 <monochrom> http://www.vex.net/~trebla/haskell/prerequisite.xhtml#leibniz
2023-01-02 19:00:05 +0100jinsun__(~jinsun@user/jinsun)
2023-01-02 19:00:05 +0100jinsun(~jinsun@user/jinsun) (Killed (lithium.libera.chat (Nickname regained by services)))
2023-01-02 19:00:05 +0100jinsun__jinsun
2023-01-02 19:00:48 +0100merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl) (Ping timeout: 252 seconds)
2023-01-02 19:01:35 +0100 <cameron_> i like how they seperate the concept of "school math" and whatever black magic you've decided to embark on here
2023-01-02 19:03:33 +0100 <dminuoso> What do you mean?
2023-01-02 19:03:48 +0100 <monochrom> My article. It mentions "school math skills".
2023-01-02 19:04:02 +0100 <monochrom> which is equational reasoning :)
2023-01-02 19:04:05 +0100 <dminuoso> No in particular, what did they mean by black magic
2023-01-02 19:04:14 +0100 <cameron_> whatever comes next after school math lol
2023-01-02 19:04:19 +0100 <monochrom> programming? >:)
2023-01-02 19:04:32 +0100 <dminuoso> I think the crux of what we're talking about you already learned in school.
2023-01-02 19:04:40 +0100 <monochrom> or perhaps measure theory
2023-01-02 19:04:50 +0100 <cameron_> mostly yes
2023-01-02 19:05:12 +0100 <cameron_> although i've never heard the word monad in school before
2023-01-02 19:05:26 +0100 <dminuoso> I think much of "unlearning" that we talk about in Haskell is more about us using different terms in ways you may not be used to.
2023-01-02 19:05:55 +0100 <dminuoso> With something like `variable` its super strange, because the mathy notion you learn in school already when solving simple equations
2023-01-02 19:06:01 +0100thegeekinside(~thegeekin@189.217.82.244)
2023-01-02 19:06:32 +0100 <cameron_> the language does depend on context quite a bit
2023-01-02 19:06:44 +0100 <dminuoso> Which students of say C then proceed to replace with something different (namely that of a mutable store/reference), and then in Haskell we end up using the term variable in the math sense.
2023-01-02 19:07:06 +0100 <mauke> fortunately you can learn and understand the entirety of IO without touching monads in the abstract
2023-01-02 19:07:14 +0100 <monochrom> My most bitter complaint is =
2023-01-02 19:07:19 +0100 <mauke> just like you can learn addition (like 3+4) without group theory
2023-01-02 19:07:53 +0100 <dminuoso> monochrom: Do you happen to know whether <- from do-notation was borrowed from another language?
2023-01-02 19:08:42 +0100 <monochrom> A lot of 1970s pseudocode (e.g. Knuth's) write "x <- x+1" for Pascal's "x := x+1"
2023-01-02 19:08:51 +0100titibandit(~titibandi@xdsl-89-0-163-79.nc.de) (Quit: Leaving.)
2023-01-02 19:09:42 +0100 <mauke> maybe from list comprehension?
2023-01-02 19:09:46 +0100 <monochrom> In retrospect, perhaps "1970s pseudocode" is redundant, one can just say "pseudocode" without ambiguity, no one does pseudocode in the 21st century.
2023-01-02 19:10:20 +0100 <hpc> trying to define pseudocode is a bit futile anyway imo, the way they did it
2023-01-02 19:10:20 +0100 <cameron_> isnt 21st century pseudocode just python
2023-01-02 19:10:37 +0100 <hpc> the whole point of pseudocode is it isn't codified so you can express whatever with it
2023-01-02 19:11:00 +0100 <hpc> there's no "you can only write continuation passing style in pseudocode version 1.2"
2023-01-02 19:12:29 +0100 <dminuoso> hpc: This goes into my belief system of ignosticism. I think similarly to religious discussion, pseudocode is based on the notion that you just start writing in some language language without any definition whatsoever under the assumption that the other person will have a matching set of definitions for "pseudolanguage"
2023-01-02 19:12:36 +0100 <mauke> which version of pseudocode adds support for Win32 COM?
2023-01-02 19:13:00 +0100 <dminuoso> hpc: With sufficient complexity in the domain, you will have mismatching definitions leading to quirky discussions and emotions.
2023-01-02 19:13:33 +0100 <cameron_> i wonder when ai will be sufficiently advanced to infer your meaning from whatever pseudocode you've written
2023-01-02 19:14:01 +0100 <dminuoso> to be fair, copilot is often quite good at it already for some languages.
2023-01-02 19:14:15 +0100 <dminuoso> (well not for pseudocode, but still)
2023-01-02 19:14:29 +0100 <dminuoso> but who knows, maybe I should try tossing pseudo code at chatgpt and see what it does with it
2023-01-02 19:14:50 +0100 <cameron_> chatgpt can be pretty scary sometimes
2023-01-02 19:15:05 +0100 <mauke> copilot is also good for copying GPL'd code into your project :-P
2023-01-02 19:15:24 +0100 <cameron_> @FBI
2023-01-02 19:15:24 +0100 <lambdabot> Unknown command, try @list
2023-01-02 19:16:40 +0100 <dminuoso> mauke: Much worse, a better question is whether since it used GPLd code for training, whether copilot generated code is a derivative of said training material.
2023-01-02 19:16:56 +0100 <mauke> ooh
2023-01-02 19:17:16 +0100 <mauke> intuitively, I'd say yes
2023-01-02 19:17:35 +0100 <dminuoso> Intuitively, Id say this will be decided in courts all over the world in the following years.
2023-01-02 19:18:20 +0100 <dminuoso> And outside of common law, it will not be worth trying to prove that
2023-01-02 19:18:56 +0100 <monochrom> Intuitively, I'd say everyone avoids it because "this hasn't been tried in courts, let's not risk it".
2023-01-02 19:19:05 +0100 <monochrom> So, game theory!
2023-01-02 19:19:05 +0100 <dminuoso> Thats not my experience.
2023-01-02 19:19:34 +0100 <dminuoso> The first problem is, it will be incredibly difficult proving any particular region was generated by copilot.
2023-01-02 19:20:00 +0100 <monochrom> Ah OK, so the opposite effect.
2023-01-02 19:20:11 +0100 <dolio> Yeah, most programmers are too stupid to avoid it for that reason.
2023-01-02 19:20:36 +0100 <monochrom> Everyone does it, but nobody dares to bring it to court because "this hasn't been tried in courts" again. :)
2023-01-02 19:20:59 +0100econo(uid147250@user/econo)
2023-01-02 19:22:23 +0100 <dolio> (See all the folks who think using code on e.g. github with no license could never come back to bite them.)
2023-01-02 19:22:45 +0100son0p(~ff@2604:3d08:5b7f:5540::417e) (Ping timeout: 260 seconds)
2023-01-02 19:23:06 +0100 <ryantrinkle> c_wraith: the package *has* a private sublibrary, but i'm only trying to import the regular old public library
2023-01-02 19:23:18 +0100 <dminuoso> Jeesh, I have tossed half a dozen pseudo codes at chatgpt and it found the underlying algorithms every time, including an explanation. All identifiers were garbled to avoid some kind of pattern matching of wiki..
2023-01-02 19:23:19 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Ping timeout: 256 seconds)
2023-01-02 19:23:21 +0100 <ryantrinkle> using ghc-pkg to manually resolve it to a package ID, and then using -package-id instead of -package fixed it
2023-01-02 19:23:30 +0100 <dminuoso> chatgpt is mindboggling. :S
2023-01-02 19:23:36 +0100 <ryantrinkle> so it seems that for some reason ghc-8.10.7 just can't resolve packages to package-ids correctly
2023-01-02 19:24:39 +0100Guest4496(~finn@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2023-01-02 19:25:07 +0100 <monochrom> Hrm, yeah that looks like something it should not be good at, given that you changed the vocabulary, almost a substitution cipher.
2023-01-02 19:25:47 +0100 <cameron_> whats even crazier is that it usually explains what its doing step by step
2023-01-02 19:26:33 +0100 <dminuoso> The step-by-step explanation part I somewhat get, given that stackoverflow is riddled with answers where people explain code regions in great detail
2023-01-02 19:26:36 +0100jinsun(~jinsun@user/jinsun) (Read error: Connection reset by peer)
2023-01-02 19:27:15 +0100 <cameron_> i wonder what is the most complex working program its generated from scratch
2023-01-02 19:27:26 +0100jinsun(~jinsun@user/jinsun)
2023-01-02 19:27:45 +0100 <dminuoso> I've seen examples where complete webpages with interactive JavaScript and CSS were synthesized and customized based on some dialogs.
2023-01-02 19:27:54 +0100 <cameron_> insane
2023-01-02 19:28:11 +0100 <dminuoso> Well, its somewhat error prone and requires handholding
2023-01-02 19:28:34 +0100 <monochrom> Already beats a lot of entry-level programmers.
2023-01-02 19:28:53 +0100 <cameron_> youre just the senior dev emailing the junior dev lol
2023-01-02 19:29:03 +0100 <dminuoso> Sure, something like that
2023-01-02 19:30:03 +0100instantaphex(~jb@c-73-171-252-84.hsd1.fl.comcast.net)
2023-01-02 19:30:10 +0100 <dminuoso> You know what, next year I will just use chatgpt for advent of code.
2023-01-02 19:30:50 +0100 <dminuoso> (or whatever new language model will be the hot stuff at that point)
2023-01-02 19:31:45 +0100elevenkb(~elevenkb@105.224.37.128)
2023-01-02 19:32:17 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2023-01-02 19:34:59 +0100jakalx(~jakalx@base.jakalx.net)
2023-01-02 19:36:49 +0100Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net)
2023-01-02 19:38:32 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-01-02 19:39:40 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-01-02 19:41:41 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:780a:3a53:75ea:e01e)
2023-01-02 19:41:44 +0100abhixec(~abhinav@c-67-169-139-16.hsd1.ca.comcast.net)
2023-01-02 19:42:13 +0100 <cameron_> https://pastebin.com/HtvcQMSy
2023-01-02 19:42:21 +0100 <cameron_> i got chat gpt to generate this entire tic tac toe game
2023-01-02 19:42:32 +0100 <cameron_> you can overwrite the other players moves but it works lol
2023-01-02 19:43:24 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Ping timeout: 260 seconds)
2023-01-02 19:43:47 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-02 19:45:30 +0100 <mauke> duckduckgo.com down?
2023-01-02 19:45:40 +0100 <jean-paul[m]> working here
2023-01-02 19:47:46 +0100 <mauke> "It's not just you! duckduckgo.com is down."
2023-01-02 19:48:08 +0100 <mauke> or at least loading slowly, intermittently
2023-01-02 19:48:08 +0100 <darkling> WFM.
2023-01-02 19:48:41 +0100king_gs(~Thunderbi@187.201.110.169) (Ping timeout: 246 seconds)
2023-01-02 19:49:11 +0100elevenkb(~elevenkb@105.224.37.128) (Quit: Client closed)
2023-01-02 19:51:55 +0100jinsun(~jinsun@user/jinsun) (Ping timeout: 260 seconds)
2023-01-02 19:55:12 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2023-01-02 19:55:32 +0100panovia(~user@user/siracusa)
2023-01-02 19:56:11 +0100beefbambi(~beefbambi@2401:4900:230d:f57c:538c:d7cc:50c0:e377) (Read error: Connection reset by peer)
2023-01-02 19:57:53 +0100beefbambi(~beefbambi@183.82.26.189)
2023-01-02 19:58:18 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-02 19:58:37 +0100elevenkb(~elevenkb@105.224.37.128)
2023-01-02 19:58:57 +0100kuribas(~user@ptr-17d51eobge4k180xjsg.18120a2.ip6.access.telenet.be)
2023-01-02 20:03:56 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340)
2023-01-02 20:04:19 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-02 20:11:18 +0100FarisAlmutairi(~FarisAlmu@142.154.108.249)
2023-01-02 20:12:21 +0100nasrudin__(~nasrudin_@107-132-214-117.lightspeed.sndgca.sbcglobal.net)
2023-01-02 20:19:30 +0100merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)
2023-01-02 20:20:44 +0100johnjaye(~pi@173.209.64.74) (Ping timeout: 260 seconds)
2023-01-02 20:22:36 +0100johnjaye(~pi@173.209.64.74)
2023-01-02 20:22:36 +0100nasrudin__(~nasrudin_@107-132-214-117.lightspeed.sndgca.sbcglobal.net) (Read error: Connection reset by peer)
2023-01-02 20:22:48 +0100nasrudin__(~nasrudin_@107-132-214-117.lightspeed.sndgca.sbcglobal.net)
2023-01-02 20:25:17 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-01-02 20:27:55 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-01-02 20:28:52 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi)
2023-01-02 20:31:44 +0100phma(~phma@host-67-44-208-104.hnremote.net) (Read error: Connection reset by peer)
2023-01-02 20:31:55 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:780a:3a53:75ea:e01e) (Remote host closed the connection)
2023-01-02 20:32:17 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds)
2023-01-02 20:32:39 +0100phma(phma@2001:5b0:211b:f318:7482:d8c2:3f03:7c4c)
2023-01-02 20:34:09 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-01-02 20:35:08 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-02 20:35:12 +0100avicenzi(~avicenzi@2a00:ca8:a1f:b004::c32) (Ping timeout: 265 seconds)
2023-01-02 20:35:50 +0100merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl) (Read error: Connection reset by peer)
2023-01-02 20:39:48 +0100iqubic(~avi@2601:601:1100:edd0:43b1:181f:28ff:d60c) (Remote host closed the connection)
2023-01-02 20:45:53 +0100VY2_(~user@213.24.133.13) (Remote host closed the connection)
2023-01-02 20:54:47 +0100perrierjouet(~perrier-j@modemcable048.127-56-74.mc.videotron.ca) (Ping timeout: 246 seconds)
2023-01-02 20:59:44 +0100instantaphex(~jb@c-73-171-252-84.hsd1.fl.comcast.net) (Ping timeout: 246 seconds)
2023-01-02 20:59:48 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-01-02 21:06:58 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-02 21:09:40 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Client Quit)
2023-01-02 21:18:45 +0100Sgeo(~Sgeo@user/sgeo)
2023-01-02 21:19:08 +0100FarisAlmutairi(~FarisAlmu@142.154.108.249) (Quit: Client closed)
2023-01-02 21:20:06 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-02 21:20:14 +0100beefbambi(~beefbambi@183.82.26.189) (Read error: Connection reset by peer)
2023-01-02 21:20:25 +0100beefbambi(~beefbambi@183.82.26.189)
2023-01-02 21:21:16 +0100jero98772(~jero98772@190.158.28.44)
2023-01-02 21:22:20 +0100Guest4496(~finn@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Ping timeout: 260 seconds)
2023-01-02 21:23:25 +0100king_gs(~Thunderbi@187.201.110.169)
2023-01-02 21:24:29 +0100chiselfuse(~chiselfus@user/chiselfuse) (Ping timeout: 255 seconds)
2023-01-02 21:25:26 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-01-02 21:25:26 +0100beefbambi(~beefbambi@183.82.26.189) (Read error: Connection reset by peer)
2023-01-02 21:25:46 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 272 seconds)
2023-01-02 21:26:37 +0100beefbambi(~beefbambi@183.82.26.189)
2023-01-02 21:29:34 +0100freeside(~mengwong@103.252.202.159) (Ping timeout: 272 seconds)
2023-01-02 21:30:16 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-01-02 21:31:33 +0100nasrudin__(~nasrudin_@107-132-214-117.lightspeed.sndgca.sbcglobal.net) (Ping timeout: 260 seconds)
2023-01-02 21:34:25 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-02 21:35:59 +0100leah2(~leah@vuxu.org) (Ping timeout: 260 seconds)
2023-01-02 21:38:26 +0100king_gs(~Thunderbi@187.201.110.169) (Ping timeout: 272 seconds)
2023-01-02 21:38:50 +0100kuribas(~user@ptr-17d51eobge4k180xjsg.18120a2.ip6.access.telenet.be) (Remote host closed the connection)
2023-01-02 21:39:09 +0100perrierjouet(~perrier-j@modemcable048.127-56-74.mc.videotron.ca)
2023-01-02 21:46:08 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-01-02 21:47:58 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:780a:3a53:75ea:e01e)
2023-01-02 21:50:25 +0100leah2(~leah@vuxu.org)
2023-01-02 21:51:11 +0100nasrudin__(~nasrudin_@81.171.62.8)
2023-01-02 21:54:44 +0100freeside(~mengwong@103.252.202.159)
2023-01-02 22:00:52 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:780a:3a53:75ea:e01e) (Remote host closed the connection)
2023-01-02 22:01:40 +0100titibandit(~titibandi@xdsl-89-0-163-79.nc.de)
2023-01-02 22:08:03 +0100abhixec(~abhinav@c-67-169-139-16.hsd1.ca.comcast.net) (Ping timeout: 268 seconds)
2023-01-02 22:10:31 +0100Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net) (Ping timeout: 268 seconds)
2023-01-02 22:15:05 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-01-02 22:16:45 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-02 22:18:27 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-01-02 22:18:27 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-01-02 22:18:27 +0100wroathe(~wroathe@user/wroathe)
2023-01-02 22:18:27 +0100nasrudin__(~nasrudin_@81.171.62.8) (Read error: Connection reset by peer)
2023-01-02 22:19:10 +0100nasrudin__(~nasrudin_@81.171.62.8)
2023-01-02 22:23:34 +0100justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 252 seconds)
2023-01-02 22:27:43 +0100mikoto-chan(~mikoto-ch@2001:999:404:e3fe:180c:9642:5d86:5844)
2023-01-02 22:35:38 +0100 <eldritchcookie[4> how can i in a polymophic instance contrain so that the type isn't a function one so no types like a -> b
2023-01-02 22:36:22 +0100 <nasrudin__> Anyone here have intuitions about prepromorphisms?
2023-01-02 22:37:24 +0100 <[exa]> eldritchcookie[4: doing negation in constructive logic is pretty hard, but you can instead ask for some proof of property that the functions don't really have, like runtime representability (perhaps Data or so)
2023-01-02 22:38:12 +0100 <[exa]> (Data is probably a bad example but I imagine GHC base would have something relatable)
2023-01-02 22:38:59 +0100 <[exa]> nasrudin__: kinda. Don't ask to ask, just ask. :D
2023-01-02 22:39:45 +0100 <nasrudin__> Two questions about prepromorphisms:
2023-01-02 22:39:45 +0100 <nasrudin__> 1) Is there a good reason why the natural transformation of a prepromorphism isn't allowed to change the functor between its input and its output?
2023-01-02 22:39:45 +0100 <nasrudin__> 2) What are some motivations for prepromorphisms? In the context of recursion schemes and DSLs, I'd guess they might correspond to any kind of AST-to-AST transformation we might do before a fold, but again this makes me wonder why the natural transformation isn't allowed to change functors...
2023-01-02 22:41:30 +0100 <[exa]> the best answer I'd have is basically from here https://stackoverflow.com/a/47466960/1043097
2023-01-02 22:43:51 +0100elevenkb(~elevenkb@105.224.37.128) (Quit: Client closed)
2023-01-02 22:44:23 +0100 <eldritchcookie[4> my th generates this code... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/91968220574a592e755bc3f6d9b831ed8dd8…>)
2023-01-02 22:46:12 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 272 seconds)
2023-01-02 22:48:13 +0100Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-159-86.dhcp-dynamic.fibreop.nb.bellaliant.net)
2023-01-02 22:54:51 +0100 <[exa]> nasrudin__: did you check fokkinga's thesis? http://maartenfokkinga.github.io/utwente/mmfphd.pdf
2023-01-02 22:55:36 +0100 <[exa]> I'm not sure if the natural transformation requirement is implied there, just structure preservation (so that the whole thing is uniquely defined)
2023-01-02 22:56:04 +0100 <nasrudin__> Unfortunately, I can't follow much from his thesis
2023-01-02 22:56:31 +0100 <nasrudin__> (for now)
2023-01-02 22:57:59 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2023-01-02 23:01:22 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:780a:3a53:75ea:e01e)
2023-01-02 23:02:11 +0100motherfsck(~motherfsc@user/motherfsck) (Ping timeout: 260 seconds)
2023-01-02 23:04:50 +0100jakalx(~jakalx@base.jakalx.net)
2023-01-02 23:05:24 +0100ddellacosta(~ddellacos@86.106.143.57) (Ping timeout: 268 seconds)
2023-01-02 23:05:41 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:780a:3a53:75ea:e01e) (Ping timeout: 246 seconds)
2023-01-02 23:06:19 +0100 <[exa]> nasrudin__: like, me neither. :]
2023-01-02 23:07:14 +0100 <[exa]> btw there was another #haskell-something channel for discussing highly theoretical stuff, try playing with /list
2023-01-02 23:07:51 +0100 <nasrudin__> O_O
2023-01-02 23:07:55 +0100 <nasrudin__> that sounds perfect
2023-01-02 23:07:58 +0100 <nasrudin__> thanks!
2023-01-02 23:08:25 +0100 <[exa]> might have been #haskell-in-depth
2023-01-02 23:08:59 +0100 <[exa]> less chance that the question gets lost in scrollback before the venerable gurus see it
2023-01-02 23:09:52 +0100 <geekosaur> yeh, that was the original intent of #haskell-in-depth
2023-01-02 23:10:09 +0100 <geekosaur> sadly it only got used that way a few times, and then all the deep stuff moved back in here
2023-01-02 23:10:46 +0100 <[exa]> I'd still try. :D
2023-01-02 23:14:15 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7) (Ping timeout: 252 seconds)
2023-01-02 23:18:14 +0100 <cameron_> https://pastebin.com/EW1RVFHS
2023-01-02 23:18:22 +0100 <cameron_> now i got chatgpt to make a lisp interpreter using lisp
2023-01-02 23:19:31 +0100 <monochrom> Hrm maybe I should lurk in #haskell-in-depth too...
2023-01-02 23:21:57 +0100Guest71(~Guest71@81-224-186-223-no2000.tbcn.telia.com)
2023-01-02 23:22:27 +0100mikoto-chan(~mikoto-ch@2001:999:404:e3fe:180c:9642:5d86:5844) (Ping timeout: 256 seconds)
2023-01-02 23:23:53 +0100 <Guest71> Hi I have custom built ghc on a server machine and where I build my project. The cabal.project file has a `with-compiler` flag to pick up the custom GHC. However, now that i am developing on my local machine, I have to remove the cabal.project everytime I want to build anything. Is there some cabal.project clause I can use to conditionally build it
2023-01-02 23:24:12 +0100 <Guest71> I attempted to use a flag
2023-01-02 23:24:39 +0100 <Guest71> something like `if flag(server)....` and have the with-compiler field there
2023-01-02 23:24:51 +0100 <Guest71> but I got this error message "Cannot set compiler in a conditional clause of a cabal project file"
2023-01-02 23:25:56 +0100 <Guest71> This is version 3.8.1.0 of cabal
2023-01-02 23:26:11 +0100 <geekosaur> #hackage might be helpful with that
2023-01-02 23:26:15 +0100 <sclv> Guest71: set the custom compiler in a cabal.project.local specific to the server machine
2023-01-02 23:26:54 +0100 <Guest71> and not check it in my git repo right?
2023-01-02 23:27:02 +0100 <Guest71> is that the standard workflow?
2023-01-02 23:27:03 +0100 <sclv> you can't set the compiler in a conditional clause because A) cabal.project files don't take flags and B) conditional clauses can have _tests_ on compilers
2023-01-02 23:27:04 +0100 <sclv> Guest71: yep
2023-01-02 23:27:24 +0100 <sclv> if something is only for one or another specific machine, it goes in a cabal.project.local
2023-01-02 23:27:35 +0100 <sclv> You also can pass in a flag to cabal to pick which cabal project you use.
2023-01-02 23:27:46 +0100 <sclv> conditionals in cabal project files are specifically for casing on compiler and architecture.
2023-01-02 23:27:48 +0100 <Guest71> hmm I occasionally want to share my cabal.project files with my coworkers
2023-01-02 23:27:59 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-01-02 23:28:02 +0100 <sclv> Well you can share everything else in your cabal.project file with them!
2023-01-02 23:28:22 +0100 <sclv> cabal considers the union of the cabal.project and the cabal.project.local file
2023-01-02 23:28:36 +0100 <Guest71> "you also can pass in a flag to cabal to pick which cabal project you use" -> this would be nice as well
2023-01-02 23:29:07 +0100 <sclv> "cabal build --project-file=MYFILE"
2023-01-02 23:29:09 +0100 <Guest71> could you tell me what flag I need to pass to cabal to give it a cabal.project file in the command line
2023-01-02 23:29:13 +0100 <Guest71> sweet
2023-01-02 23:30:45 +0100thyriaen(~thyriaen@2a01:aea0:dd4:4bae:6245:cbff:fe9f:48b1) (Quit: Leaving)
2023-01-02 23:31:40 +0100 <Guest71> thanx!
2023-01-02 23:32:01 +0100 <monochrom> That one is discoverable from "cabal build --help".
2023-01-02 23:36:05 +0100Guest71(~Guest71@81-224-186-223-no2000.tbcn.telia.com) (Quit: Client closed)
2023-01-02 23:37:12 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.7.1)
2023-01-02 23:37:56 +0100erisco(~erisco@d24-141-66-165.home.cgocable.net)
2023-01-02 23:39:35 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 23:43:16 +0100unit73e(~emanuel@2001:818:e8dd:7c00:656:e5ff:fe72:9d36)
2023-01-02 23:44:28 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net) (Ping timeout: 272 seconds)
2023-01-02 23:47:14 +0100 <unit73e> not sure if it's just me, but that very useful "wish I knew when learning haskell" is often down. downloaded the pdf.
2023-01-02 23:47:44 +0100 <[exa]> unit73e: it's on github right? (is github down again? :D )
2023-01-02 23:48:19 +0100 <unit73e> [exa], it is indeed in github and it's not down lol
2023-01-02 23:48:23 +0100 <geekosaur> someone was reporting ddg down earlier, I wonder if there's a network "event" of some kind
2023-01-02 23:48:28 +0100 <unit73e> it's just the official site is convenient
2023-01-02 23:49:23 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-01-02 23:49:52 +0100 <unit73e> we're still in crazy clown world so maybe there was an "event"
2023-01-02 23:50:00 +0100 <unit73e> who knows?
2023-01-02 23:50:13 +0100 <unit73e> pick your clown, doesn't matter much
2023-01-02 23:56:43 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 248 seconds)
2023-01-02 23:56:53 +0100mizlan(~mizlan@c-67-169-7-31.hsd1.ca.comcast.net)
2023-01-02 23:57:19 +0100merijn(~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl)