IRCBrowse

2023/01/31

2023-01-31 00:06:23 +0100qorgi(~qorgi@141.161.133.94)
2023-01-31 00:06:28 +0100qorgi(~qorgi@141.161.133.94) (Remote host closed the connection)
2023-01-31 00:09:20 +0100qorgi(~qorgi@185.156.46.108)
2023-01-31 00:09:28 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-01-31 00:12:43 +0100jumper149(~jumper149@base.felixspringer.xyz)
2023-01-31 00:15:15 +0100king_gs(~Thunderbi@187.201.2.248)
2023-01-31 00:16:38 +0100qorgi(~qorgi@185.156.46.108) (Ping timeout: 260 seconds)
2023-01-31 00:16:48 +0100bilegeek(~bilegeek@2600:1008:b0a9:5822:3cbe:e760:543a:34cb) (Quit: Leaving)
2023-01-31 00:19:34 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net)
2023-01-31 00:21:06 +0100 <c_wraith> somebody was doing robotics work. Which is... sort of the opposite, I suppose.
2023-01-31 00:21:46 +0100 <juri_> the opposite is the modeler and slicer i maintain, in haskell. ;)
2023-01-31 00:22:14 +0100 <juri_> just hoping i don't have to add '3d scanner' to that list. its enough already.
2023-01-31 00:22:15 +0100 <c_wraith> that's a different opposite. robotics is causing things to be at points in space
2023-01-31 00:22:32 +0100 <c_wraith> Which is sort of an opposite of detecting them
2023-01-31 00:22:57 +0100 <juri_> ok, fair.
2023-01-31 00:23:18 +0100jargon(~jargon@184.101.182.107)
2023-01-31 00:23:27 +0100 <c_wraith> But still not useful to you
2023-01-31 00:25:46 +0100 <monochrom> Use https://www.smbc-comics.com/comic/four to reduce detection to actuation. >:D
2023-01-31 00:25:46 +0100king_gs(~Thunderbi@187.201.2.248) (Read error: Connection reset by peer)
2023-01-31 00:29:56 +0100tremon(~tremon@83-85-213-108.cable.dynamic.v4.ziggo.nl) (Quit: getting boxed in)
2023-01-31 00:30:31 +0100 <hpc> the alt text is how i do all my programming :P
2023-01-31 00:30:37 +0100thongpv(~thongpv87@14.179.159.25)
2023-01-31 00:35:56 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-31 00:38:33 +0100 <segfaultfizzbuzz> okay so what if programming languages were designed with the assumption that the programmer is an adversary
2023-01-31 00:38:53 +0100 <segfaultfizzbuzz> like if you hire a hundred people to work on your code base, a few of them might be bad apples, ya know
2023-01-31 00:39:09 +0100Feuermagier(~Feuermagi@user/feuermagier)
2023-01-31 00:39:37 +0100 <c_wraith> You'd probably get a language based around capabilities with strict static typing.
2023-01-31 00:39:45 +0100 <segfaultfizzbuzz> sounds right
2023-01-31 00:40:12 +0100 <segfaultfizzbuzz> and then probably half of the programmers won't be bad apples but will overestimate how correct they are
2023-01-31 00:40:23 +0100 <segfaultfizzbuzz> and then the remaining half will also overestimate how correct they are
2023-01-31 00:40:29 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-01-31 00:40:59 +0100 <segfaultfizzbuzz> haskell has capabilities...?
2023-01-31 00:42:24 +0100jero98772(~jero98772@2800:484:1d80:d8ce:9815:cfda:3661:17bb) (Ping timeout: 248 seconds)
2023-01-31 00:42:38 +0100 <c_wraith> eh. you could get there with some combination of careful libraries and an extension like Safe Haskell, but it'd be a lot of work.
2023-01-31 00:43:12 +0100 <c_wraith> also, Safe Haskell isn't quite the right tool for the job, so it would need to be something *like* it with a clearer purpose
2023-01-31 00:43:19 +0100 <monochrom> Is there any other goal such as some minimum level of productivity that your hypothetical programming language needs to achieve, and you forgot to mention it?
2023-01-31 00:43:46 +0100 <monochrom> Because without any other goals, the best way to deal with adversaries is to allow nothing.
2023-01-31 00:44:05 +0100 <segfaultfizzbuzz> uh but then you get nothing done
2023-01-31 00:44:21 +0100 <monochrom> Sure. So what's your other goals?
2023-01-31 00:44:32 +0100 <monochrom> And how much?
2023-01-31 00:45:03 +0100 <segfaultfizzbuzz> i don't know, i am personally interested in the "most ideal, least productive" languages these days
2023-01-31 00:45:20 +0100 <segfaultfizzbuzz> for the purpose of getting some kind of understanding of "what is best"
2023-01-31 00:45:28 +0100 <segfaultfizzbuzz> even if i never actually use them
2023-01-31 00:45:44 +0100 <monochrom> I don't know what "ideal" means. (Do you?) But trivially clearly least productive = allow nothing done
2023-01-31 00:46:07 +0100 <segfaultfizzbuzz> yeah i'm not fond of "the safest car is no car"
2023-01-31 00:46:31 +0100 <monochrom> If you want an actually interesting discussion, you need to state actually interesting goals.
2023-01-31 00:46:37 +0100off^(~tj99@c-24-30-76-89.hsd1.ga.comcast.net)
2023-01-31 00:46:57 +0100 <monochrom> Because otherwise I'll just trivialize all of your stated scenerios because they are trivial in the first place.
2023-01-31 00:48:54 +0100proportions(~proportio@91.150.188.137) ()
2023-01-31 00:54:26 +0100 <monochrom> And the other angle is that I learned from multiple practicing teachers and practicing economists that if you treat people as adversaries then they will game your system, but if you respect them then they will respect you.
2023-01-31 00:55:01 +0100 <segfaultfizzbuzz> sure there is the psychology angle on it, but the reality is that there are always some bad apples whatever the case
2023-01-31 00:55:11 +0100 <geekosaur> …often just to get things done
2023-01-31 00:55:16 +0100 <monochrom> I would rather s/bad apples/honest mistakes/
2023-01-31 00:55:54 +0100jumper149(~jumper149@base.felixspringer.xyz) (Quit: WeeChat 3.7.1)
2023-01-31 00:56:12 +0100 <monochrom> So my idea of a good programming language is it respects programmers but acknowledges that there are honest mistakes to guard against or maybe just discourage.
2023-01-31 00:56:40 +0100 <monochrom> But then that also closes this discussion because all practical programming languages already try to do that.
2023-01-31 00:57:15 +0100 <monochrom> So, anything new?
2023-01-31 01:02:18 +0100Inst(~Inst@2601:6c4:4081:54f0:891d:3999:8b1d:922e)
2023-01-31 01:02:19 +0100 <jackdk> An interesting consequence of that claim is that many programming languages with large user bases are in fact not practical
2023-01-31 01:02:21 +0100 <Inst> I still think it's sort of funny
2023-01-31 01:02:41 +0100 <Inst> that OOP is incidentally evolving closer to FP; i.e, "inheritance was a bad idea, composition is better"
2023-01-31 01:03:17 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) (Quit: Leaving.)
2023-01-31 01:03:49 +0100 <monochrom> Well, "honest mistakes" is broad and vague. You have to decide where to draw the line. Different designers draw different lines and assume different skill levels of programmers. So some languages are more lax than others.
2023-01-31 01:04:17 +0100 <geekosaur> jackdk, I'd say (a) they often evolve such mechanisms as they discover the need for them the hard way (b) their definitions of "guard against" and "discourage" may differ from ours
2023-01-31 01:05:00 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-31 01:05:01 +0100 <jackdk> I'm thinking about misfeatures like "I'm allowed to reassign `final` variables but you're not"; "I'm allowed to define a built-in enumerated type but you're not"; "I'm allowed to do ad-hoc polymorphism but you're not", to pick a few examples off the top of my head
2023-01-31 01:05:18 +0100 <segfaultfizzbuzz> i mean if you are expanding to include all the libraries for a language, supply chain attacks are a very real thing,...
2023-01-31 01:05:44 +0100 <monochrom> Oh heh, nobody is perfect, even by said nobody's personal standard. :)
2023-01-31 01:08:02 +0100arkeet(arkeet@moriya.ca) (Quit: ZNC 1.8.2 - https://znc.in)
2023-01-31 01:08:13 +0100arkeet(~arkeet@moriya.ca)
2023-01-31 01:09:27 +0100thongpv(~thongpv87@14.179.159.25) (Ping timeout: 252 seconds)
2023-01-31 01:11:17 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53) (Quit: segfaultfizzbuzz)
2023-01-31 01:11:20 +0100kee(~~kee@user/wizzwizz4) (Ping timeout: 268 seconds)
2023-01-31 01:11:21 +0100werneta(~werneta@137.79.207.195) (Remote host closed the connection)
2023-01-31 01:13:34 +0100[Leary](~Leary]@user/Leary/x-0910699) (Remote host closed the connection)
2023-01-31 01:14:09 +0100[Leary](~Leary]@user/Leary/x-0910699)
2023-01-31 01:18:45 +0100danza(~francesco@151.44.209.120)
2023-01-31 01:19:29 +0100ph88(~ph88@2a02:8109:9e00:71d0:dd:6cfd:8537:67c6)
2023-01-31 01:37:19 +0100danza(~francesco@151.44.209.120) (Read error: Connection reset by peer)
2023-01-31 01:38:35 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 264 seconds)
2023-01-31 01:39:48 +0100thongpv(~thongpv87@14.179.159.25)
2023-01-31 01:40:04 +0100ph88(~ph88@2a02:8109:9e00:71d0:dd:6cfd:8537:67c6) (Quit: Leaving)
2023-01-31 01:40:32 +0100ph88(~ph88@2a02:8109:9e00:71d0:760c:b1ba:cea2:4498)
2023-01-31 01:43:41 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 255 seconds)
2023-01-31 01:44:17 +0100acidjnk(~acidjnk@p200300d6e715c47228ee5485b7272aa0.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-01-31 01:44:56 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-01-31 01:44:58 +0100zeenk(~zeenk@2a02:2f04:a014:8700::7fe) (Quit: Konversation terminated!)
2023-01-31 01:46:15 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-01-31 01:46:15 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-01-31 01:46:15 +0100wroathe(~wroathe@user/wroathe)
2023-01-31 01:47:48 +0100ph88(~ph88@2a02:8109:9e00:71d0:760c:b1ba:cea2:4498) (Quit: Leaving)
2023-01-31 01:50:53 +0100opticblast(~Thunderbi@172.58.84.5) (Quit: opticblast)
2023-01-31 01:51:10 +0100opticblast(~Thunderbi@172.58.84.5)
2023-01-31 01:52:31 +0100danza(~francesco@151.44.217.224)
2023-01-31 01:52:35 +0100opticblast(~Thunderbi@172.58.84.5) (Read error: Connection reset by peer)
2023-01-31 01:52:53 +0100opticblast(~Thunderbi@172.58.82.233)
2023-01-31 01:54:28 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt)
2023-01-31 01:59:39 +0100opticblast(~Thunderbi@172.58.82.233) (Ping timeout: 260 seconds)
2023-01-31 02:16:47 +0100kee(~~kee@user/wizzwizz4)
2023-01-31 02:18:30 +0100troydm(~troydm@user/troydm)
2023-01-31 02:18:57 +0100slack1256(~slack1256@181.42.52.81) (Remote host closed the connection)
2023-01-31 02:23:26 +0100Guest75(~Guest75@178.141.149.12)
2023-01-31 02:37:36 +0100xff0x(~xff0x@ai081074.d.east.v6connect.net) (Ping timeout: 248 seconds)
2023-01-31 02:39:51 +0100 <Hammdist> how do I do optmap in haskell?
2023-01-31 02:39:55 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-01-31 02:40:36 +0100 <monochrom> What is optmap?
2023-01-31 02:41:37 +0100 <Hammdist> map f o is None if o is None and Some (f v) if o is Some v.
2023-01-31 02:41:51 +0100 <jackdk> > fmap (+3) (Just 4)
2023-01-31 02:41:53 +0100 <lambdabot> Just 7
2023-01-31 02:42:02 +0100 <jackdk> > (+3) <$> Nothing
2023-01-31 02:42:05 +0100 <lambdabot> Nothing
2023-01-31 02:42:23 +0100 <Hammdist> ah fmap. ok thanks
2023-01-31 02:42:31 +0100 <jackdk> (`<$>` is an infix alias for `fmap`, because it looks like `$` with wings)
2023-01-31 02:42:45 +0100 <jackdk> % :t fmap
2023-01-31 02:42:45 +0100 <yahb2> fmap :: Functor f => (a -> b) -> f a -> f b
2023-01-31 02:42:50 +0100 <jackdk> % :t fmap @Maybe
2023-01-31 02:42:50 +0100 <yahb2> fmap @Maybe :: (a -> b) -> Maybe a -> Maybe b
2023-01-31 02:50:31 +0100 <dsal> Do the wings provide lift?
2023-01-31 02:50:41 +0100 <yushyin> lol
2023-01-31 02:53:06 +0100ReinhildeAmyMalik
2023-01-31 03:16:00 +0100Feuermagier(~Feuermagi@user/feuermagier) (Read error: Connection reset by peer)
2023-01-31 03:16:03 +0100Feuermagier_(~Feuermagi@user/feuermagier)
2023-01-31 03:18:44 +0100thongpv87(~thongpv87@14.179.159.25)
2023-01-31 03:21:19 +0100thongpv(~thongpv87@14.179.159.25) (Ping timeout: 248 seconds)
2023-01-31 03:22:55 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-01-31 03:23:17 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 252 seconds)
2023-01-31 03:23:28 +0100telser(~quassel@user/telser) (Ping timeout: 248 seconds)
2023-01-31 03:24:29 +0100telser(~quassel@user/telser)
2023-01-31 03:26:22 +0100yrlnry(~yrlnry@pool-108-36-173-41.phlapa.fios.verizon.net) (Read error: Connection reset by peer)
2023-01-31 03:26:23 +0100phma(phma@2001:5b0:212a:9278:328d:f1cd:3dee:19c5) (Read error: Connection reset by peer)
2023-01-31 03:27:29 +0100yrlnry(~yrlnry@2600:4040:738e:5400:14e9:d2e1:808a:60f2)
2023-01-31 03:27:43 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com)
2023-01-31 03:27:49 +0100phma(~phma@2001:5b0:212a:9278:328d:f1cd:3dee:19c5)
2023-01-31 03:28:53 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf) (Remote host closed the connection)
2023-01-31 03:29:12 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf)
2023-01-31 03:34:49 +0100phma(~phma@2001:5b0:212a:9278:328d:f1cd:3dee:19c5) (Remote host closed the connection)
2023-01-31 03:35:09 +0100merijn(~merijn@86.86.29.250)
2023-01-31 03:37:04 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt) (Ping timeout: 260 seconds)
2023-01-31 03:40:23 +0100phma(~phma@host-67-44-208-111.hnremote.net)
2023-01-31 03:43:35 +0100califax_(~califax@user/califx)
2023-01-31 03:43:50 +0100califax(~califax@user/califx) (Ping timeout: 255 seconds)
2023-01-31 03:44:11 +0100Feuermagier_(~Feuermagi@user/feuermagier) (Ping timeout: 252 seconds)
2023-01-31 03:44:11 +0100thegeekinside(~thegeekin@189.180.66.244) (Remote host closed the connection)
2023-01-31 03:44:52 +0100califax_califax
2023-01-31 03:51:27 +0100 <EvanR> this is funny, went looking for what generics magic pretty-simple uses for pretty printing anything with a Show instance
2023-01-31 03:52:01 +0100michael_(~michael@2601:182:d17f:4a10:56e4:7b90:1599:5f77)
2023-01-31 03:52:02 +0100 <EvanR> it seems to parse the output of show into some kind of expression, then goes through and format and colors the expression
2023-01-31 03:52:17 +0100 <EvanR> it's stringly typed
2023-01-31 03:52:39 +0100 <monochrom> I think it doesn't. I think it parses standard Show outcomes back to an approximate grammar and then reformats.
2023-01-31 03:52:46 +0100 <monochrom> Yes.
2023-01-31 03:58:48 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-01-31 04:01:25 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Ping timeout: 252 seconds)
2023-01-31 04:02:06 +0100sammelweis(~quassel@mobile-107-92-121-168.mycingular.net)
2023-01-31 04:04:32 +0100michael_(~michael@2601:182:d17f:4a10:56e4:7b90:1599:5f77) (Ping timeout: 248 seconds)
2023-01-31 04:06:46 +0100Feuermagier(~Feuermagi@user/feuermagier)
2023-01-31 04:07:39 +0100Feuermagier(~Feuermagi@user/feuermagier) (Max SendQ exceeded)
2023-01-31 04:09:08 +0100Feuermagier(~Feuermagi@user/feuermagier)
2023-01-31 04:09:29 +0100merijn(~merijn@86.86.29.250) (Ping timeout: 252 seconds)
2023-01-31 04:13:04 +0100td_(~td@i53870926.versanet.de) (Ping timeout: 248 seconds)
2023-01-31 04:14:10 +0100thegeekinside(~thegeekin@189.180.66.244)
2023-01-31 04:14:39 +0100td_(~td@i53870908.versanet.de)
2023-01-31 04:28:14 +0100jargon(~jargon@184.101.182.107) (Remote host closed the connection)
2023-01-31 04:28:26 +0100forell(~forell@user/forell) (Ping timeout: 246 seconds)
2023-01-31 04:31:45 +0100forell(~forell@user/forell)
2023-01-31 04:32:27 +0100danza(~francesco@151.44.217.224) (Read error: Connection reset by peer)
2023-01-31 04:33:52 +0100codaraxis(~codaraxis@user/codaraxis) (Ping timeout: 248 seconds)
2023-01-31 04:34:03 +0100Feuermagier(~Feuermagi@user/feuermagier) (Ping timeout: 252 seconds)
2023-01-31 04:36:41 +0100forell(~forell@user/forell) (Ping timeout: 268 seconds)
2023-01-31 04:37:30 +0100thongpv87(~thongpv87@14.179.159.25) (Ping timeout: 260 seconds)
2023-01-31 04:37:33 +0100Feuermagier(~Feuermagi@user/feuermagier)
2023-01-31 04:39:16 +0100forell(~forell@user/forell)
2023-01-31 04:40:23 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-01-31 04:40:23 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-01-31 04:40:23 +0100finn_elijaFinnElija
2023-01-31 05:01:13 +0100off^(~tj99@c-24-30-76-89.hsd1.ga.comcast.net) (Remote host closed the connection)
2023-01-31 05:02:27 +0100Feuermagier_(~Feuermagi@user/feuermagier)
2023-01-31 05:03:24 +0100Feuermagier(~Feuermagi@user/feuermagier) (Ping timeout: 255 seconds)
2023-01-31 05:03:38 +0100Guest75(~Guest75@178.141.149.12) (Ping timeout: 260 seconds)
2023-01-31 05:04:07 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2023-01-31 05:05:36 +0100sammelweis(~quassel@mobile-107-92-121-168.mycingular.net) (Read error: Connection reset by peer)
2023-01-31 05:09:05 +0100 <EvanR> in Wai you have this response constructor called responseFile which takes a status code and file path of the file to serve. The System.IO routines seem to be geared towards try to open a file and catch exceptions if it doesn't exist, rather than testing for existence
2023-01-31 05:09:40 +0100sammelweis(~quassel@c-68-48-18-140.hsd1.mi.comcast.net)
2023-01-31 05:10:01 +0100 <EvanR> how do you know to use 200 or 404 xD
2023-01-31 05:10:27 +0100 <EvanR> try opening it then immediately close?
2023-01-31 05:12:23 +0100 <jackdk> A file could be removed between the existence test and opening it for reading, so just opening it and handling errors seems like good behaviour to me?
2023-01-31 05:14:01 +0100 <monochrom> I think the intention of responseFile is: You already know that the file path exists, hell you probably created it yourself, and its content is appropriate for 200 or 404 depending on the URL you received, which you decided separately whether that URL deserves a 202 or a 404.
2023-01-31 05:14:54 +0100 <monochrom> In other words in general "http://mycom.com/foo" does not always means responseFile ??? "foo"
2023-01-31 05:14:56 +0100 <mauke> https://hackage.haskell.org/package/directory-1.3.8.0/docs/System-Directory.html#v:doesFileExist
2023-01-31 05:16:15 +0100 <monochrom> Instead you do your "routing" to decide whether "foo" makes sense or not. If yes, responseFile 200 "internal-filename-for-foo"; if not, responseFile 404 "internal-filename-for-404-cases".
2023-01-31 05:17:02 +0100 <EvanR> it seems like the right thing would be to try to open the file, if success, begin the 200 and dumping of the file (and hope for the best after this). If it fails possibly 404. But this responseFile doesn't seem to work like that
2023-01-31 05:17:39 +0100 <EvanR> (all assuming this path might go to a file based on the path prefix)
2023-01-31 05:17:46 +0100 <monochrom> In case you really like to simplify it so that s/internal-filename-for-foo/foo, just use doesFileExist and don't overthink it. Yes there is a race condition, so control your computer to render that race condition impossible.
2023-01-31 05:19:00 +0100 <monochrom> But in general web libraries are designed to deviate from "web server = file server".
2023-01-31 05:19:58 +0100 <monochrom> The whole point of "web apps" and all the dynamism mutability it entails.
2023-01-31 05:20:22 +0100 <monochrom> URLs are no longer referentially transparent since 2000.
2023-01-31 05:21:06 +0100 <EvanR> responseFile does seems great if you "know" the file exists
2023-01-31 05:21:24 +0100 <EvanR> doesFileExist it is
2023-01-31 05:22:18 +0100 <monochrom> Is there a responseByteString? responseText? That would be much better for more use cases.
2023-01-31 05:22:58 +0100 <EvanR> responseLBS takes a lazy ByteString
2023-01-31 05:23:15 +0100 <monochrom> Less race condition if you're merely writing a file server. And exactly right if you're writing an actually dynamic webapp.
2023-01-31 05:23:45 +0100 <EvanR> are you talking about lazy I/O
2023-01-31 05:23:59 +0100 <EvanR> shocking
2023-01-31 05:24:42 +0100 <monochrom> Yeah with that you openFIle/openBinaryFile, if no exception then hGetContents >>= responseLBS 200, if exception then responseLBS 404 "your usual 404 page content here"
2023-01-31 05:25:18 +0100 <monochrom> which feels better than doesFileExist.
2023-01-31 05:25:43 +0100 <monochrom> OTOH I don't think it really matters in most cases. Who is going to delete that file behind your back? Your dog?
2023-01-31 05:25:54 +0100 <monochrom> "My dog ate my homework"
2023-01-31 05:26:14 +0100 <EvanR> hypothetically the DELETE http verb xD
2023-01-31 05:26:51 +0100 <EvanR> more realistically, PUT is going to modify this file
2023-01-31 05:27:00 +0100 <EvanR> race conditions everywhere
2023-01-31 05:27:08 +0100varoo(~varoo@122.161.91.19)
2023-01-31 05:27:49 +0100varoo(~varoo@122.161.91.19) (Client Quit)
2023-01-31 05:28:04 +0100 <monochrom> So I guess this is why a select loop is preferred to multi-threading. A select loop enforces serializable consistency by brute. >:)
2023-01-31 05:28:39 +0100 <monochrom> You complete one DELETE/PUT before you worry about a GET. Either that, or the GET is already finished before you see a DELETE?PUT.
2023-01-31 05:28:48 +0100varoo(~varoo@122.161.91.19)
2023-01-31 05:29:59 +0100 <monochrom> high latency high backlog highest consistency ever
2023-01-31 05:30:06 +0100 <EvanR> you have an infinite number of MVars one for each possible filename. Before doing a request take from the one corresponding to that filename and put it back after
2023-01-31 05:30:29 +0100 <monochrom> hee hee
2023-01-31 05:30:53 +0100 <monochrom> Perhaps add unsafeInterleaveIO to create those MVars lazily...
2023-01-31 05:31:25 +0100 <EvanR> that's a sick idea
2023-01-31 05:32:02 +0100razetime(~Thunderbi@43.254.111.18)
2023-01-31 05:32:58 +0100 <EvanR> fine, it's an STM bag of filenames. The taking from mvar is implemented as putting a filename in the bag or retrying if it's already there
2023-01-31 05:38:23 +0100razetime(~Thunderbi@43.254.111.18) (Ping timeout: 248 seconds)
2023-01-31 05:43:30 +0100thongpv87(~thongpv87@14.179.159.25)
2023-01-31 05:43:33 +0100varoo(~varoo@122.161.91.19) (Quit: Internet messed up)
2023-01-31 05:47:53 +0100varoo(~varoo@122.161.91.19)
2023-01-31 05:56:05 +0100biberu(~biberu@user/biberu) (Read error: Connection reset by peer)
2023-01-31 05:57:14 +0100thongpv87(~thongpv87@14.179.159.25) (Remote host closed the connection)
2023-01-31 05:58:22 +0100thongpv(~thongpv87@14.179.159.25)
2023-01-31 05:58:57 +0100biberu(~biberu@user/biberu)
2023-01-31 06:03:19 +0100Lycurgus(~juan@user/Lycurgus)
2023-01-31 06:03:59 +0100thongpv(~thongpv87@14.179.159.25) (Ping timeout: 248 seconds)
2023-01-31 06:05:32 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-31 06:11:17 +0100Maxdamantus(~Maxdamant@user/maxdamantus) (Ping timeout: 246 seconds)
2023-01-31 06:12:11 +0100Maxdamantus(~Maxdamant@user/maxdamantus)
2023-01-31 06:14:34 +0100myxokeph(~myxokeph@cpe-65-28-251-121.cinci.res.rr.com) (Ping timeout: 260 seconds)
2023-01-31 06:15:26 +0100 <Hammdist> I am interacting with GHC core library. Expr leads to Type. how do I access the TyVarTy case of Type? Not in scope: data constructor ‘TyVarTy’
2023-01-31 06:20:24 +0100thegeekinside(~thegeekin@189.180.66.244) (Ping timeout: 260 seconds)
2023-01-31 06:22:54 +0100myxokeph(~myxokeph@cpe-65-28-251-121.cinci.res.rr.com)
2023-01-31 06:28:47 +0100Feuermagier_(~Feuermagi@user/feuermagier) (Quit: Leaving)
2023-01-31 06:28:59 +0100Feuermagier(~Feuermagi@user/feuermagier)
2023-01-31 06:30:09 +0100thongpv(~thongpv87@14.179.159.25)
2023-01-31 06:32:09 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-01-31 06:33:49 +0100thegeekinside(~thegeekin@189.180.66.244)
2023-01-31 06:33:51 +0100sayola(~sayola@ipservice-092-213-087-211.092.213.pools.vodafone-ip.de) (Read error: Connection reset by peer)
2023-01-31 06:34:10 +0100sayola(~sayola@ipservice-092-213-087-211.092.213.pools.vodafone-ip.de)
2023-01-31 06:35:19 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-01-31 06:40:14 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 260 seconds)
2023-01-31 06:43:12 +0100danza(~francesco@151.35.11.63)
2023-01-31 06:43:28 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) (Ping timeout: 248 seconds)
2023-01-31 06:46:40 +0100bontaq(~user@ool-45779fe5.dyn.optonline.net) (Ping timeout: 248 seconds)
2023-01-31 06:48:05 +0100Inst_(~Inst@2601:6c4:4081:54f0:88ac:5549:dc57:9767)
2023-01-31 06:50:35 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 248 seconds)
2023-01-31 06:51:19 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 260 seconds)
2023-01-31 06:51:59 +0100Inst(~Inst@2601:6c4:4081:54f0:891d:3999:8b1d:922e) (Ping timeout: 248 seconds)
2023-01-31 06:52:27 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-01-31 06:58:14 +0100trev(~trev@user/trev)
2023-01-31 06:59:23 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-01-31 06:59:23 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-01-31 06:59:23 +0100wroathe(~wroathe@user/wroathe)
2023-01-31 07:03:49 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-01-31 07:04:12 +0100jakalx(~jakalx@base.jakalx.net)
2023-01-31 07:11:49 +0100codaraxis(~codaraxis@user/codaraxis)
2023-01-31 07:19:47 +0100tromp(~textual@92.110.219.57)
2023-01-31 07:26:39 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 248 seconds)
2023-01-31 07:27:50 +0100thongpv(~thongpv87@14.179.159.25) (Ping timeout: 260 seconds)
2023-01-31 07:29:15 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-01-31 07:31:08 +0100michalz(~michalz@185.246.207.221)
2023-01-31 07:47:45 +0100razetime(~Thunderbi@117.193.3.163)
2023-01-31 07:57:38 +0100freeside(~mengwong@122.11.248.245)
2023-01-31 08:04:18 +0100kenran`(~user@user/kenran)
2023-01-31 08:05:25 +0100tromp(~textual@92.110.219.57) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-01-31 08:07:36 +0100phma_(phma@2001:5b0:212a:9278:328d:f1cd:3dee:19c5)
2023-01-31 08:08:08 +0100kassouni(~textual@2601:646:400:68b0:18dc:d2:c373:8213)
2023-01-31 08:10:39 +0100phma(~phma@host-67-44-208-111.hnremote.net) (Ping timeout: 260 seconds)
2023-01-31 08:14:14 +0100codaraxis__(~codaraxis@user/codaraxis)
2023-01-31 08:15:17 +0100freeside_(~mengwong@202.161.55.11)
2023-01-31 08:15:36 +0100troydm(~troydm@user/troydm) (Ping timeout: 268 seconds)
2023-01-31 08:15:51 +0100kassouni(~textual@2601:646:400:68b0:18dc:d2:c373:8213) (Quit: Textual IRC Client: www.textualapp.com)
2023-01-31 08:17:21 +0100freeside(~mengwong@122.11.248.245) (Ping timeout: 252 seconds)
2023-01-31 08:17:48 +0100codaraxis(~codaraxis@user/codaraxis) (Ping timeout: 255 seconds)
2023-01-31 08:20:52 +0100xeelad(~xeelad@pool-151-202-46-37.nycmny.fios.verizon.net)
2023-01-31 08:21:29 +0100phma_phma
2023-01-31 08:29:16 +0100ddellacosta(~ddellacos@89.45.224.176)
2023-01-31 08:30:52 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:49d:d667:4c42:a171)
2023-01-31 08:36:04 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-31 08:41:13 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-01-31 08:46:49 +0100razetime(~Thunderbi@117.193.3.163) (Ping timeout: 260 seconds)
2023-01-31 08:50:03 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-01-31 08:50:21 +0100shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 252 seconds)
2023-01-31 08:54:23 +0100codaraxis__(~codaraxis@user/codaraxis) (Ping timeout: 252 seconds)
2023-01-31 08:56:29 +0100gensyst(gensyst@user/gensyst)
2023-01-31 08:57:05 +0100 <gensyst> How can I do something like class HasQuality e; getQuality :: e -> q ?
2023-01-31 08:57:27 +0100 <gensyst> Basically each e that has an HasQuality instance, must also have some associated q type to it
2023-01-31 08:57:35 +0100 <gensyst> How to get the q in there?
2023-01-31 08:58:47 +0100 <gensyst> This code as such compiles fine: class HasQuality e where getQuality :: e -> q
2023-01-31 09:00:51 +0100razetime(~Thunderbi@117.193.3.163)
2023-01-31 09:01:15 +0100mmhat(~mmh@p200300f1c707be48ee086bfffe095315.dip0.t-ipconnect.de)
2023-01-31 09:07:42 +0100 <gensyst> One moment let me start from scratch.
2023-01-31 09:12:18 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-31 09:15:50 +0100 <jackdk> I would generally not do this thing because you're either going to have bad type inference or only be able to associate one q with each e; however it is achievable using multiparam type classes (and a functional dependency e -> q) or an associated type (enabled by `-XTypeFamilies`)
2023-01-31 09:17:42 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-31 09:19:48 +0100ft(~ft@p4fc2a257.dip0.t-ipconnect.de) (Quit: leaving)
2023-01-31 09:21:16 +0100kuttenbrunzer(~kuttenbru@2a02:8108:8b80:1d48:399d:ce45:6432:bc43)
2023-01-31 09:22:01 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-01-31 09:22:30 +0100 <gensyst> jackdk,
2023-01-31 09:22:41 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-01-31 09:22:46 +0100 <gensyst> Here is a concrete example: https://dpaste.com/6PEG4HSPC
2023-01-31 09:23:07 +0100 <gensyst> If you "wouldn't do this", what's the alternative?
2023-01-31 09:23:27 +0100danza(~francesco@151.35.11.63) (Ping timeout: 248 seconds)
2023-01-31 09:23:45 +0100 <jackdk> An additional function argument to your computation
2023-01-31 09:24:28 +0100 <gensyst> jackdk, and scrape the type class altogether?
2023-01-31 09:24:42 +0100 <jackdk> Yeah
2023-01-31 09:25:13 +0100 <gensyst> lol
2023-01-31 09:25:28 +0100 <gensyst> why does it always end up being simple... why do i always overcomplicate things in my head
2023-01-31 09:25:41 +0100 <gensyst> it's interesting how much is achievable just with "simple haskell"
2023-01-31 09:26:05 +0100 <jackdk> I shipped a change at work late last year that was net -1000 LoC or so with no relevant change in functionality
2023-01-31 09:26:32 +0100turlando(~turlando@user/turlando) (Read error: Connection reset by peer)
2023-01-31 09:27:24 +0100zeenk(~zeenk@2a02:2f04:a014:8700::7fe)
2023-01-31 09:28:59 +0100califax(~califax@user/califx) (Ping timeout: 255 seconds)
2023-01-31 09:29:59 +0100turlando(~turlando@user/turlando)
2023-01-31 09:31:03 +0100 <gensyst> jackdk, what was the LoC before/after?
2023-01-31 09:31:44 +0100 <jackdk> ~4.5k -> ~3.5k
2023-01-31 09:32:55 +0100turlando(~turlando@user/turlando) (Read error: Connection reset by peer)
2023-01-31 09:33:21 +0100 <gensyst> impressive
2023-01-31 09:33:38 +0100 <darkling> Very nice. Always a good day when something like that happens. :)
2023-01-31 09:34:25 +0100turlando(~turlando@user/turlando)
2023-01-31 09:34:42 +0100 <jackdk> Impressive would have been not falling in love with an overcomplicated design in the first place, necessitating a day-and-a-half of careful refactoring so I had some confidence that the new version was right.
2023-01-31 09:35:15 +0100 <darkling> Well, past-me is always an idiot. :)
2023-01-31 09:39:01 +0100accord(uid568320@id-568320.hampstead.irccloud.com)
2023-01-31 09:40:47 +0100 <jackdk> How funny, past-me is a dummy too!
2023-01-31 09:43:43 +0100acidjnk(~acidjnk@p200300d6e715c450d0b080c45be0641e.dip0.t-ipconnect.de)
2023-01-31 09:50:49 +0100machinedgod(~machinedg@198.53.218.113)
2023-01-31 09:52:48 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-01-31 09:55:40 +0100 <gensyst> jackdk, however it's a balance. hmmmm.
2023-01-31 09:55:56 +0100 <gensyst> in my case what if the thing has not just quality but, e.g., color and location?
2023-01-31 09:56:12 +0100 <gensyst> would be kinda convenient to just have it all in the same "thing" instead of separate function parameters
2023-01-31 09:57:05 +0100machinedgod(~machinedg@198.53.218.113) (Ping timeout: 252 seconds)
2023-01-31 09:58:07 +0100merijn(~merijn@86.86.29.250)
2023-01-31 09:58:42 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-31 09:58:54 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-01-31 09:59:07 +0100 <jackdk> What are you actually building? Function composition will let you fuse "get the colour out of a thing" with "compute something from the colour". If you want to write back a new colour, you could accept a lens instead of a function
2023-01-31 10:01:30 +0100califax(~califax@user/califx)
2023-01-31 10:02:27 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-01-31 10:04:38 +0100thongpv(~thongpv87@14.179.159.25)
2023-01-31 10:15:47 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-01-31 10:16:20 +0100avicenzi(~avicenzi@193.86.92.180)
2023-01-31 10:18:01 +0100alex`(~user@97.red-83-36-47.dynamicip.rima-tde.net)
2023-01-31 10:20:18 +0100phma(phma@2001:5b0:212a:9278:328d:f1cd:3dee:19c5) (Read error: Connection reset by peer)
2023-01-31 10:20:19 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2023-01-31 10:27:53 +0100 <jackdk> gensyst: If it's ECS-ish, you could do something like this, but it still feels a bit overwrought. I dunno what Haskell ECS libs do though: https://www.irccloud.com/pastebin/vXKCVFzi/Quality.hs
2023-01-31 10:28:45 +0100 <jackdk> I chose to let the typelevel tag force the type of the thing inside the structure; if you did not want to do this you could make it an associated type of the class, and let it vary with each instance.
2023-01-31 10:30:13 +0100cfricke(~cfricke@user/cfricke)
2023-01-31 10:31:16 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf) (Remote host closed the connection)
2023-01-31 10:31:33 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf)
2023-01-31 10:31:55 +0100rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-05-174-88-194-86.dsl.bell.ca) (Ping timeout: 252 seconds)
2023-01-31 10:32:10 +0100Batzy(~quassel@user/batzy) (Ping timeout: 260 seconds)
2023-01-31 10:32:10 +0100hiredman(~hiredman@frontier1.downey.family) (Ping timeout: 260 seconds)
2023-01-31 10:32:16 +0100mei(~mei@user/mei) (Ping timeout: 248 seconds)
2023-01-31 10:32:19 +0100Batzy(~quassel@user/batzy)
2023-01-31 10:34:53 +0100mei(~mei@user/mei)
2023-01-31 10:36:10 +0100thegeekinside(~thegeekin@189.180.66.244) (Ping timeout: 252 seconds)
2023-01-31 10:38:51 +0100hiredman(~hiredman@frontier1.downey.family)
2023-01-31 10:44:35 +0100nschoe(~q@141.101.51.197)
2023-01-31 10:47:19 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 252 seconds)
2023-01-31 10:50:41 +0100Mahi(~Mahi@91-159-147-164.elisa-laajakaista.fi)
2023-01-31 10:51:32 +0100 <Mahi> Hello! I long time programmer who's never done functional programming before, and I want to learn Haskell as my first functional language. Unfortunately I'm struggling with basic exercises, is it ok to ask for beginner help here?
2023-01-31 10:52:06 +0100 <stefan-_> Mahi, sure
2023-01-31 10:52:57 +0100 <Mahi> I'm unsurprisingly stuck on a task that I'd normally resolve with for loops - I need to filter elements from a list that are greater than the previous filtered element, e.g. [1, 3, 2, 6, 4, 8] would yield [1, 3, 6, 8]
2023-01-31 10:53:08 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-01-31 10:53:15 +0100 <Mahi> I attempted the following code, but it doesn't seem to work for all cases:
2023-01-31 10:53:16 +0100 <Mahi> skipSmallers :: [Int] -> Int -> [Int]
2023-01-31 10:53:16 +0100 <Mahi> skipSmallers [i] x = if i >= x then [i] else []
2023-01-31 10:53:17 +0100 <Mahi> skipSmallers arr x =
2023-01-31 10:53:17 +0100 <Mahi>     if (head arr) > x
2023-01-31 10:53:18 +0100 <Mahi>         then head arr : skipSmallers (tail arr) (head arr)
2023-01-31 10:53:18 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba)
2023-01-31 10:53:18 +0100 <Mahi>     else skipSmallers (tail arr) x
2023-01-31 10:53:19 +0100 <Mahi> nextIsGreater  :: [Int] -> [Int]
2023-01-31 10:53:19 +0100 <Mahi> nextIsGreater [] = []
2023-01-31 10:53:20 +0100 <Mahi> nextIsGreater arr = (head arr) : skipSmallers (tail arr) (head arr)
2023-01-31 10:53:43 +0100 <_________> @Mahi use https://paste.tomsmeding.com when pasting code
2023-01-31 10:53:44 +0100 <lambdabot> Unknown command, try @list
2023-01-31 10:53:50 +0100 <Mahi> Any hints on what I'm doing wrong? I'm trying to complete an online course and the tester just tells me that tests didn't pass, no signal on what went wrong. Also few tests went through.
2023-01-31 10:53:57 +0100chele(~chele@user/chele)
2023-01-31 10:53:58 +0100 <Mahi> https://paste.tomsmeding.com/n5DWo4kY
2023-01-31 10:54:23 +0100 <Mahi> There's probably a much simpler way that I'm unaware of...
2023-01-31 10:54:55 +0100hiredman(~hiredman@frontier1.downey.family) (Ping timeout: 260 seconds)
2023-01-31 10:55:26 +0100teo(~teo@user/teo)
2023-01-31 10:55:58 +0100 <opqdonut> Mahi: that looks about right
2023-01-31 10:56:14 +0100 <opqdonut> you could use pattern matching instead of head & tail, but that's not that crucial
2023-01-31 10:56:40 +0100 <opqdonut> but a helper function that has one more parameter for keeping the state is the right approach (at least when learning the language :)
2023-01-31 10:56:59 +0100 <stefan-_> Mahi, should the next elements be greater-than or greater-equal-than?
2023-01-31 10:57:09 +0100 <stefan-_> you have: "i >= x"
2023-01-31 10:57:40 +0100 <Mahi> Greater-than, but I've tried both approaches numerous times already :D
2023-01-31 10:57:47 +0100phma(phma@2001:5b0:210d:808:caa:8672:8beb:4096)
2023-01-31 10:57:48 +0100 <_________> Mahi: what's `skipSmallers [] 1` ?
2023-01-31 10:57:50 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba) (Ping timeout: 260 seconds)
2023-01-31 10:58:13 +0100 <Mahi> Idk I never call that because the function is always invoked through `nextIsGreater`
2023-01-31 10:58:22 +0100 <_________> oh
2023-01-31 10:58:53 +0100 <_________> then `nextIsGreater [1]` ?
2023-01-31 10:59:04 +0100 <Mahi> I'm clueless with Haskell so I just assumed that I must be doing something wrong, but now that I've heard your thoughts I guess I'll send a message to the lecturer and ask if there's something wrong with the tester instead
2023-01-31 10:59:36 +0100 <int-e> well your code has at least one bug, which _________ is guiding you towards
2023-01-31 10:59:58 +0100 <Mahi> Ahh yes I'm not handling `[1]` properly, it ends up calling `skipSmallers []`
2023-01-31 10:59:59 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-01-31 11:00:07 +0100 <Mahi> That's the one yes?
2023-01-31 11:00:12 +0100 <_________> yeah
2023-01-31 11:00:18 +0100 <Mahi> Thank you very much, I'll see if that helps
2023-01-31 11:01:15 +0100hiredman(~hiredman@frontier1.downey.family)
2023-01-31 11:03:13 +0100 <int-e> Pattern matching *would* make this more readable indeed... you can use (i:is) and it'll only match non-empty lists, and then `i` is the head and `is` is the tail.
2023-01-31 11:04:34 +0100 <Mahi> All the tests passed now, thank you everyone! :) I will look into pattern matching next, I knew there must be a cleaner way
2023-01-31 11:04:39 +0100 <int-e> Hmm also `arr` ...they're lists, not arrays.
2023-01-31 11:05:19 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 248 seconds)
2023-01-31 11:05:26 +0100 <Mahi> Ah yes, should've been obvious. Thank you. int-e
2023-01-31 11:05:37 +0100 <gensyst> jackdk, lol i'm not going to add lenses - but thanks i'll store your example for future references
2023-01-31 11:05:46 +0100 <gensyst> jackdk, i'm going to go with your original advice of simplicity.
2023-01-31 11:06:12 +0100 <gensyst> I wonder how many "useless" typeclasses I have in my codebase... could potentially be replaced with function params
2023-01-31 11:06:14 +0100 <gensyst> :S
2023-01-31 11:06:16 +0100 <gensyst> fuuuuuuuu
2023-01-31 11:07:27 +0100 <geekosaur> arguably all of them, because they are function params 🙂
2023-01-31 11:08:04 +0100 <gensyst> so what's the point. i'm now more confused than ever
2023-01-31 11:08:49 +0100 <geekosaur> the compiler passes them for you, and when used correctly they tend to be more lawful
2023-01-31 11:09:35 +0100 <geekosaur> manual record passing, on the other hand, is more work bbut more flexible because you can swap around functions in the record for particular calls which you can't do with typeclasses
2023-01-31 11:10:43 +0100dcoutts(~duncan@host86-176-29-74.range86-176.btcentralplus.com)
2023-01-31 11:11:19 +0100Mahi(~Mahi@91-159-147-164.elisa-laajakaista.fi) (Quit: Client closed)
2023-01-31 11:12:53 +0100use-value1(~Thunderbi@2a00:23c6:8a03:2f01:bdd1:543a:a9a8:b96c)
2023-01-31 11:13:27 +0100troydm(~troydm@user/troydm)
2023-01-31 11:14:06 +0100 <int-e> classes can be very convenient... with data Tree a = Leaf a | Node [Tree a] deriving Eq, you can have foo :: Eq a => Tree a -> Tree a -> Bool; foo = (==), and the compiler will take care of generating the derived equality from the Eq record for `a` for you. Record style, foo would be something like foo eqA = eqField (deriveEqTree eqA) instead, where `eqField` selects the (==) method of the...
2023-01-31 11:14:12 +0100 <int-e> ...class. And that's a simple case.
2023-01-31 11:14:56 +0100 <int-e> And there's quite a lot of boilerplate covered by `deriving`.
2023-01-31 11:16:23 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf) (Ping timeout: 264 seconds)
2023-01-31 11:16:24 +0100use-value1use-value
2023-01-31 11:16:28 +0100Mahi(~Mahi@91-159-147-164.elisa-laajakaista.fi)
2023-01-31 11:18:15 +0100kuttenbrunzer(~kuttenbru@2a02:8108:8b80:1d48:399d:ce45:6432:bc43) (Quit: Leaving)
2023-01-31 11:18:39 +0100Mahi(~Mahi@91-159-147-164.elisa-laajakaista.fi) (Client Quit)
2023-01-31 11:19:46 +0100 <gensyst> ah, so they really are just for convenience - and now it's the programmer's choice how much convenience they want!
2023-01-31 11:20:41 +0100 <geekosaur> and for consistency: you know it'll behave the same way everywhere if it's a typeclass
2023-01-31 11:21:01 +0100 <geekosaur> you have to ensure that yourself if you pass a record of functions manually
2023-01-31 11:21:23 +0100gaff(~gaff@49.207.232.223)
2023-01-31 11:23:19 +0100 <gaff> does haddock turn a multiline comment into a single line? for example, `-- | this is line 1. -- this is line 2.` does this become `this is line this is line 2`?
2023-01-31 11:24:44 +0100 <geekosaur> looks to me like yes
2023-01-31 11:25:01 +0100 <geekosaur> put an empty comment between if you want a line break
2023-01-31 11:25:02 +0100 <gaff> ah that is sort of a disappointment
2023-01-31 11:25:19 +0100 <gaff> ok
2023-01-31 11:25:20 +0100 <geekosaur> -- | this is line 1\n--\n-- this is line 2
2023-01-31 11:25:32 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-01-31 11:25:32 +0100 <gaff> ok thanks
2023-01-31 11:25:54 +0100 <geekosaur> well, ideally it wants to render nicely on anything from a phone t a 4k display, so it wants to reflow text
2023-01-31 11:26:35 +0100phma(phma@2001:5b0:210d:808:caa:8672:8beb:4096) (Read error: Connection reset by peer)
2023-01-31 11:26:35 +0100 <gaff> seems to me haddock shouldn't be mergining different lines of comments
2023-01-31 11:27:10 +0100 <mauke> why?
2023-01-31 11:27:45 +0100 <gaff> well, that's why people write multiline comments because they want it "multiline" comments, you see
2023-01-31 11:28:05 +0100 <gaff> at least i want to that way
2023-01-31 11:28:35 +0100phma(~phma@host-67-44-208-170.hnremote.net)
2023-01-31 11:29:15 +0100 <geekosaur> usually I write multiline comments because I ran out of space on the first line
2023-01-31 11:30:22 +0100 <gaff> well, that could be one reason. but you could also write multiline comments because you simply want it multiline
2023-01-31 11:30:41 +0100 <gaff> it cuts both ways
2023-01-31 11:31:14 +0100 <gaff> but the tooling seems to have gone along with your prefernce
2023-01-31 11:31:20 +0100 <geekosaur> there might be some markup to preserve line breaks; I only know basic haddock
2023-01-31 11:31:25 +0100 <tomsmeding> gensyst: example of that consistency at work: if you make a Set, then certainly you'd want e.g. lookup, insert, union, etc. to use the same ordering for the elements, otherwise things would go very wrong. Typeclasses ensure there is precisely 1 definition of ordering for the element type
2023-01-31 11:31:51 +0100 <tomsmeding> ("ensure" modulo unsafeCoerce hackery)
2023-01-31 11:32:18 +0100 <gensyst> tomsmeding, great point!
2023-01-31 11:33:09 +0100 <gaff> another question: when generating haddock documentation through a cabal build, with hyperlinked source, when you get into the source code, some of the links there are broken. is this a known problem?
2023-01-31 11:38:54 +0100 <gaff> cabal version 3.4 is what i use
2023-01-31 11:43:52 +0100 <geekosaur> cabal has problems finding stuff in the store, sadly. `--haddock-for-hackage` tends to work better.
2023-01-31 11:44:02 +0100 <gaff> geekosaur: well, your suggestion of putting an empty comment does give multiline comments. thanks a bunch.
2023-01-31 11:44:51 +0100 <gaff> `--haddock-for-hackage` -- is that a cabal option?
2023-01-31 11:45:05 +0100 <geekosaur> `stack` puts a bit more effort into maintaining a central documentation registry, at the expense of needing to do more work to expose the right versions of things in the registry (which haddock has little support for)
2023-01-31 11:45:18 +0100 <geekosaur> `cabal haddock` option, yes
2023-01-31 11:45:34 +0100 <mauke> https://haskell-haddock.readthedocs.io/en/latest/markup.html#paragraphs
2023-01-31 11:45:36 +0100 <gaff> ok, didn't see that in the documentation
2023-01-31 11:46:53 +0100 <gensyst> tomsmeding, jackdk, geekosaur: The question is at the bottom: https://dpaste.com/FH22DR53P Is that even possible? The issue is that StringSound can't AFAIK be put into line 36 because there is no sound to refer to (since it's inside of the class)
2023-01-31 11:46:55 +0100foul_owl(~kerry@157.97.134.62) (Read error: Connection reset by peer)
2023-01-31 11:47:08 +0100 <gaff> mauke: thank you very much
2023-01-31 11:47:48 +0100Pickchea(~private@user/pickchea)
2023-01-31 11:48:24 +0100 <gensyst> BTW I Know this particular case can be replaced with a function call, but my real world use-case has more things in Animal (not just "getSound"). So since I already have other things, I might as well throw getSound in there too. That's the idea.
2023-01-31 11:49:59 +0100freeside_(~mengwong@202.161.55.11) (Ping timeout: 264 seconds)
2023-01-31 11:50:29 +0100 <gensyst> So, instead of having a separate function parameter in foo to extract the sound, I just put a getSound in with the existing Animal - for convenience
2023-01-31 11:50:33 +0100 <gensyst> it would be cool if this can be pulled off
2023-01-31 11:50:44 +0100 <geekosaur> gensyst, I'm not sure exactly how to do it but an associated type is actually a type family
2023-01-31 11:51:43 +0100 <geekosaur> `StringSound (Sound animal)` might "just work"
2023-01-31 11:52:13 +0100 <mauke> my first attempt would be something like: `(Animal animal, StringSound (Sound animal)) => ...`. is that valid syntax?
2023-01-31 11:52:38 +0100xff0x(~xff0x@2405:6580:b080:900:edaa:53ba:199:2268)
2023-01-31 11:52:56 +0100 <geekosaur> looks like mauke and I went the same direction
2023-01-31 11:53:11 +0100 <geekosaur> nice to know I'm not completely off the wall
2023-01-31 11:56:03 +0100 <gensyst> that compiles lol
2023-01-31 11:56:08 +0100 <gensyst> mauke's one
2023-01-31 11:56:20 +0100 <gensyst> gotta try this out...
2023-01-31 11:56:57 +0100 <geekosaur> mine assumed yoou kept the existing `Animal animal`, so it's the same thing
2023-01-31 11:57:05 +0100gaff(~gaff@49.207.232.223) ()
2023-01-31 11:57:27 +0100 <gensyst> of course you're right, sorry about that
2023-01-31 11:57:27 +0100 <geekosaur> associated types are shorthand for defining a type family after the class and a `type instance` to go with each class instance
2023-01-31 11:58:05 +0100 <geekosaur> so it should work fine "outside" the class/instance
2023-01-31 12:03:13 +0100 <mauke> I don't understand type families, but associated types are fine
2023-01-31 12:03:42 +0100 <geekosaur> I have a simplistic understanding of them
2023-01-31 12:03:53 +0100 <gensyst> This is mind-blowing... this is like dynamically typed languages except you're not crashing at runtime
2023-01-31 12:03:54 +0100 <geekosaur> associated types are certainly easier
2023-01-31 12:04:17 +0100 <gensyst> this is the first time i use associated types
2023-01-31 12:05:04 +0100telser(~quassel@user/telser) (Ping timeout: 248 seconds)
2023-01-31 12:05:10 +0100foul_owl(~kerry@157.97.134.63)
2023-01-31 12:05:41 +0100telser(~quassel@user/telser)
2023-01-31 12:06:01 +0100 <gensyst> But can you see where I'm coming from (with the thing about just adding what I need into the existing typeclass instead of adding an extra function parameter to extract the sound)? Is this a legitimate use case, or overkill?
2023-01-31 12:07:03 +0100 <geekosaur> it has a certain "trying to use typeclasses for OOP" feel to it, but that might just be the example
2023-01-31 12:17:48 +0100accord(uid568320@id-568320.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-31 12:18:49 +0100Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-01-31 12:22:59 +0100kritzefitz(~kritzefit@debian/kritzefitz) (Ping timeout: 264 seconds)
2023-01-31 12:25:41 +0100xeelad(~xeelad@pool-151-202-46-37.nycmny.fios.verizon.net) (Read error: Connection reset by peer)
2023-01-31 12:26:20 +0100xeelad(~xeelad@pool-151-202-46-37.nycmny.fios.verizon.net)
2023-01-31 12:28:18 +0100ubert1(~Thunderbi@2a02:8109:abc0:6434:2d8a:1036:b201:e1eb)
2023-01-31 12:28:38 +0100razetime(~Thunderbi@117.193.3.163) (Ping timeout: 246 seconds)
2023-01-31 12:29:37 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2023-01-31 12:31:18 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt)
2023-01-31 12:32:07 +0100ccapndave(~ccapndave@xcpe-62-167-164-99.cgn.res.adslplus.ch)
2023-01-31 12:32:11 +0100xeelad(~xeelad@pool-151-202-46-37.nycmny.fios.verizon.net) (Ping timeout: 252 seconds)
2023-01-31 12:32:51 +0100xeelad(~xeelad@pool-151-202-46-37.nycmny.fios.verizon.net)
2023-01-31 12:34:18 +0100Bocaneri(~sauvin@user/Sauvin)
2023-01-31 12:34:24 +0100Sauvin(~sauvin@user/Sauvin) (Ping timeout: 248 seconds)
2023-01-31 12:34:39 +0100BocaneriSauvin
2023-01-31 12:35:23 +0100xeelad(~xeelad@pool-151-202-46-37.nycmny.fios.verizon.net) (Max SendQ exceeded)
2023-01-31 12:36:57 +0100xeelad(~xeelad@pool-151-202-46-37.nycmny.fios.verizon.net)
2023-01-31 12:38:16 +0100Bocaneri(~sauvin@user/Sauvin)
2023-01-31 12:38:39 +0100BocaneriGuest4854
2023-01-31 12:40:23 +0100tomsmedingthinks of associated types like a type family bundled with a type class, instead of the other way round
2023-01-31 12:40:59 +0100Sauvin(~sauvin@user/Sauvin) (Ping timeout: 248 seconds)
2023-01-31 12:41:44 +0100 <tomsmeding> if you haven't yet, check out the difference between open type families and closed type families, and use closed type families always for fucks sake unless you have no other choice
2023-01-31 12:42:24 +0100 <tomsmeding> open type families feel much more like a type class indeed
2023-01-31 12:43:24 +0100 <[exa]> open type familiess are 1:1 convertible to MPTCs, no?
2023-01-31 12:45:23 +0100 <dminuoso> https://hackage.haskell.org/package/powerdns-0.4.1/docs/src/PowerDNS.API.Zones.html#CIText
2023-01-31 12:45:32 +0100Lycurgus(~juan@user/Lycurgus)
2023-01-31 12:45:40 +0100 <dminuoso> https://hackage.haskell.org/package/powerdns-0.4.1/docs/PowerDNS-API-Zones.html#t:CIText
2023-01-31 12:45:56 +0100 <dminuoso> Oh hold on.
2023-01-31 12:46:19 +0100 <dminuoso> Staging restriction surprise. Move along
2023-01-31 12:46:59 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-31 12:49:07 +0100mmhat(~mmh@p200300f1c707be48ee086bfffe095315.dip0.t-ipconnect.de) (Quit: WeeChat 3.8)
2023-01-31 12:49:13 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com)
2023-01-31 12:49:51 +0100mc47(~mc47@xmonad/TheMC47)
2023-01-31 12:51:38 +0100 <tomsmeding> [exa]: at least to associated types, but perhaps also to MPTCs yes
2023-01-31 12:52:14 +0100 <geekosaur> to MPTCs with fundeps, specifically, iirc
2023-01-31 12:52:23 +0100 <tomsmeding> certainly
2023-01-31 12:52:43 +0100 <tomsmeding> dminuoso: ... staging restriction is TH, right? Where the ** does TH come into CIText?
2023-01-31 12:53:54 +0100Guest4854Sauvin
2023-01-31 12:55:14 +0100ccapndave(~ccapndave@xcpe-62-167-164-99.cgn.res.adslplus.ch) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-01-31 12:56:08 +0100 <dminuoso> tomsmeding: Hah, I was just doing some refactoring from generic aeson into TH, and I had some "no instance for" errors I couldnt make heads or tails of
2023-01-31 13:05:55 +0100 <gensyst> tomsmeding, "and use closed type families always" why?
2023-01-31 13:06:15 +0100 <gensyst> what's wrong with associated types?
2023-01-31 13:06:36 +0100 <geekosaur> he meant as opposed to directly using open type families
2023-01-31 13:06:40 +0100 <gensyst> ah ok
2023-01-31 13:06:43 +0100 <gensyst> great to know, thanks
2023-01-31 13:06:54 +0100 <geekosaur> associated types are fine because the typeclass effectively "closes" them
2023-01-31 13:08:05 +0100 <geekosaur> more specifically because you can test typeclass membership, whereas using an open type family at a type it has no instance for will error out with no way to test for it beforehand
2023-01-31 13:08:36 +0100 <geekosaur> s/test/verify
2023-01-31 13:10:06 +0100 <gensyst> geekosaur, error out at runtime?
2023-01-31 13:10:42 +0100 <geekosaur> compile time, but with a worse error message than with a closed type family
2023-01-31 13:10:45 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:49d:d667:4c42:a171) (Quit: WeeChat 2.8)
2023-01-31 13:10:46 +0100 <gensyst> ok
2023-01-31 13:11:25 +0100 <geekosaur> because an open type family can have instances defined "after the fact" by other modules/packages, so errors have to be caught by the linker instead of the compiler
2023-01-31 13:11:58 +0100 <geekosaur> whereas the compiler knows exactly what instances exist with a closed type family
2023-01-31 13:14:33 +0100 <albet70> how to declare a recursive type? data Task = F | E, but I want to make it like data Task = F | E | Task, how to change?
2023-01-31 13:16:29 +0100 <albet70> a -> b can't be an ADT type?
2023-01-31 13:16:41 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 255 seconds)
2023-01-31 13:18:07 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2023-01-31 13:18:20 +0100 <geekosaur> `data Task = F | E | T Task`
2023-01-31 13:18:32 +0100 <geekosaur> it has to have a data constructor
2023-01-31 13:19:07 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-01-31 13:19:08 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-01-31 13:19:40 +0100 <albet70> ok
2023-01-31 13:20:00 +0100 <gensyst> Thank you so much for the help guys.
2023-01-31 13:20:15 +0100 <gensyst> I'm using associate types without understanding them, and it's useful.
2023-01-31 13:20:37 +0100 <gensyst> One day I'll try to understand them more
2023-01-31 13:22:10 +0100 <gensyst> geekosaur, tomsmeding, jackdk post a lightning invoice here - i'll send some coffee sats your way
2023-01-31 13:22:17 +0100freeside(~mengwong@103.252.202.170)
2023-01-31 13:22:39 +0100 <gensyst> (or pm it to me)
2023-01-31 13:23:11 +0100 <gensyst> & mauke
2023-01-31 13:23:34 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2023-01-31 13:23:36 +0100 <gensyst> & int-e
2023-01-31 13:23:55 +0100 <gensyst> (hope i didn't forget anyone - let me know if i did)
2023-01-31 13:26:49 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 252 seconds)
2023-01-31 13:26:52 +0100 <[exa]> tomsmeding geekosaur ah yeh true, fundeps. thanks.
2023-01-31 13:28:39 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 252 seconds)
2023-01-31 13:28:40 +0100merijn(~merijn@86.86.29.250) (Quit: leaving)
2023-01-31 13:31:02 +0100danza(~francesco@151.43.80.9)
2023-01-31 13:31:59 +0100alex`(~user@97.red-83-36-47.dynamicip.rima-tde.net) (Ping timeout: 248 seconds)
2023-01-31 13:33:52 +0100titibandit1(~titibandi@xdsl-85-197-0-96.nc.de)
2023-01-31 13:36:50 +0100razetime(~Thunderbi@117.193.3.163)
2023-01-31 13:36:50 +0100danza(~francesco@151.43.80.9) (Read error: Connection reset by peer)
2023-01-31 13:38:01 +0100jumper149(~jumper149@base.felixspringer.xyz)
2023-01-31 13:42:35 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-31 13:43:59 +0100freeside(~mengwong@103.252.202.170)
2023-01-31 13:45:54 +0100 <mauke> data Task = Finite Int Bool | Infinite
2023-01-31 13:48:31 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 248 seconds)
2023-01-31 13:53:01 +0100 <tomsmeding> gensyst: having helped someone is enough for me :)
2023-01-31 13:53:04 +0100danza(~francesco@151.37.98.16)
2023-01-31 13:53:35 +0100 <geekosaur> same
2023-01-31 13:56:27 +0100 <merijn> Feel free to forwards all your rewards to me ;)
2023-01-31 14:04:47 +0100titibandit1(~titibandi@xdsl-85-197-0-96.nc.de) (Remote host closed the connection)
2023-01-31 14:06:20 +0100kritzefitz(~kritzefit@debian/kritzefitz)
2023-01-31 14:08:16 +0100sidk(~sidk@102.70.0.138)
2023-01-31 14:10:26 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-01-31 14:10:49 +0100nschoe(~q@141.101.51.197) (Ping timeout: 252 seconds)
2023-01-31 14:11:30 +0100xilo(~yourname@user/xilo) (Ping timeout: 260 seconds)
2023-01-31 14:12:03 +0100cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.7.1)
2023-01-31 14:13:42 +0100 <sidk> barrucadu dejafu looks really cool and I'd like to use it to test my project -- a concurrent version control store that uses Servant (https://hackage.haskell.org/package/inferno-vc-0.1.0). I was wondering if you'd tried something like that before, or if you had any pointers for me on how to get started? Cheers
2023-01-31 14:21:12 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:4748:566a:a8dd:fb06)
2023-01-31 14:32:36 +0100lagash_(lagash@lagash.shelltalk.net) (Remote host closed the connection)
2023-01-31 14:37:40 +0100 <gensyst> thanks again guys
2023-01-31 14:40:56 +0100lagash_(lagash@lagash.shelltalk.net)
2023-01-31 14:44:46 +0100freeside(~mengwong@103.252.202.170)
2023-01-31 14:59:07 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:4748:566a:a8dd:fb06) (Quit: WeeChat 2.8)
2023-01-31 14:59:15 +0100Inst__(~Inst@c-98-208-218-119.hsd1.fl.comcast.net)
2023-01-31 15:01:49 +0100jakalx(~jakalx@base.jakalx.net)
2023-01-31 15:02:20 +0100Inst_(~Inst@2601:6c4:4081:54f0:88ac:5549:dc57:9767) (Ping timeout: 255 seconds)
2023-01-31 15:06:24 +0100turlando(~turlando@user/turlando) (Ping timeout: 248 seconds)
2023-01-31 15:08:30 +0100mjacob_(~mjacob@adrastea.uberspace.de) (Remote host closed the connection)
2023-01-31 15:08:49 +0100 <Hammdist> in haskell ghc core library, how do I get the type of an Expr? I had found a function yesterday but I forgot to make a note of it and I can't find it again due to huge library. thanks
2023-01-31 15:13:57 +0100 <dminuoso> Hammdist: Good question, I suggest you ask for a pointer in #haskell-language-server
2023-01-31 15:14:51 +0100 <dminuoso> Also, merely an `Expr` might be difficult. Do you want the Expr typed standalone?
2023-01-31 15:14:59 +0100 <dminuoso> Or with respect to its environment?
2023-01-31 15:19:17 +0100gensyst(gensyst@user/gensyst) (Quit: Leaving)
2023-01-31 15:22:52 +0100 <Hammdist> wrt environment
2023-01-31 15:27:08 +0100 <Hammdist> ah I found it again 'exprtotype' but looking at the implementation it looks useless
2023-01-31 15:27:13 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:bdd1:543a:a9a8:b96c) (Quit: use-value)
2023-01-31 15:27:37 +0100 <Hammdist> exprToType
2023-01-31 15:30:03 +0100kurbus(~kurbus@user/kurbus)
2023-01-31 15:30:08 +0100 <merijn> What's up with binary's deprecated/messed up 0.9 and 0.10 releases??
2023-01-31 15:35:12 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-01-31 15:35:12 +0100danza(~francesco@151.37.98.16) (Read error: Connection reset by peer)
2023-01-31 15:35:35 +0100danza(~francesco@151.37.98.16)
2023-01-31 15:36:06 +0100turlando(~turlando@user/turlando)
2023-01-31 15:37:27 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-01-31 15:38:16 +0100jero98772(~jero98772@2800:484:1d80:d8ce:9815:cfda:3661:17bb)
2023-01-31 15:39:51 +0100nschoe(~q@2a04:cec0:10cc:8516:9f30:a105:6adc:b8ea)
2023-01-31 15:40:18 +0100nschoe(~q@2a04:cec0:10cc:8516:9f30:a105:6adc:b8ea) (Client Quit)
2023-01-31 15:41:23 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:4748:566a:a8dd:fb06)
2023-01-31 15:41:45 +0100thegeekinside(~thegeekin@189.180.66.244)
2023-01-31 15:48:13 +0100sidk(~sidk@102.70.0.138) (Ping timeout: 260 seconds)
2023-01-31 15:49:02 +0100 <dminuoso> Hammdist: Ask the HLS folks then.
2023-01-31 15:49:10 +0100 <dminuoso> Hammdist: Because that feature exactly is rigged into HLS
2023-01-31 15:49:26 +0100 <dminuoso> Or possibly in #ghc, but I think #haskell-language-server might be a better bet
2023-01-31 15:49:33 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:4748:566a:a8dd:fb06) (Quit: WeeChat 2.8)
2023-01-31 15:49:45 +0100 <Hammdist> not sure that would be helpful afaik HLS is based on querying types in the AST, not in core
2023-01-31 15:50:02 +0100 <dminuoso> Oh now I see what you meant by `core library` heh
2023-01-31 15:50:21 +0100 <dminuoso> Hammdist: there isnt any general inference for it.
2023-01-31 15:50:26 +0100 <dminuoso> In fact it cant even exist
2023-01-31 15:50:54 +0100 <Hammdist> :/
2023-01-31 15:50:55 +0100 <dminuoso> It has full blown impredicative types
2023-01-31 15:51:11 +0100thongpv(~thongpv87@14.179.159.25) (Ping timeout: 248 seconds)
2023-01-31 15:51:22 +0100 <Hammdist> well what I really need is the arity like in the simply typed lambda calculus
2023-01-31 15:51:23 +0100 <dminuoso> (Well given quicklook, perhaps we could add it to core after the fact I dont know)
2023-01-31 15:51:36 +0100 <geekosaur> I'm not sure useful types exist at all in core since the typechecker and associated `TcM` are gone at that point
2023-01-31 15:51:40 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-31 15:51:49 +0100 <dminuoso> geekosaur: of course they exist, all core is explicitly typed.
2023-01-31 15:52:35 +0100 <dminuoso> core lint is the type checker that does the type checking for it
2023-01-31 15:52:54 +0100 <dminuoso> (and it being explicitly typed is why impredicative types are not a problem)
2023-01-31 15:53:32 +0100varoo(~varoo@122.161.91.19) (Quit: Probably got disconnect dure to unstable internet)
2023-01-31 15:53:33 +0100danza(~francesco@151.37.98.16) (Read error: Connection reset by peer)
2023-01-31 15:53:47 +0100varoo(~varoo@2401:4900:4111:3c14:0:13:cf76:1001)
2023-01-31 15:54:18 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-01-31 15:54:23 +0100sammelweis(~quassel@c-68-48-18-140.hsd1.mi.comcast.net) (Ping timeout: 248 seconds)
2023-01-31 15:54:24 +0100 <dminuoso> Hammdist: So arity analysis is one of the things the simplifier is concerned about
2023-01-31 15:55:02 +0100 <dminuoso> See compiler/GHC/Core/Opt/CallArity.hs
2023-01-31 15:55:04 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-01-31 15:56:34 +0100Sgeo(~Sgeo@user/sgeo)
2023-01-31 15:57:46 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba)
2023-01-31 15:58:40 +0100 <dminuoso> Hammdist: thats for inferring arity from its use.
2023-01-31 15:59:44 +0100 <dminuoso> Hammdist: similarly, refer to ./compiler/GHC/Core/Opt/Arity.hs for figuring out arity from a definition side.
2023-01-31 16:00:22 +0100 <Hammdist> callArityAnalProgram :: CoreProgram -> CoreProgram <-- I don't understand this signature. where would the arity analysis output be?
2023-01-31 16:00:49 +0100 <Hammdist> you must excuse me I'm trying to do something rather difficult and I'm relatively new to Haskell at the same time
2023-01-31 16:00:53 +0100 <geekosaur> annotations to the CoreProgram
2023-01-31 16:02:02 +0100 <dminuoso> Hammdist: long story short, at Core level there isnt something like a simple "tell me the arity"
2023-01-31 16:02:19 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba) (Ping timeout: 252 seconds)
2023-01-31 16:02:21 +0100 <dminuoso> consider, that it requires computation - possibly dependent on arguments - to know that.
2023-01-31 16:02:46 +0100 <dminuoso> which is why there's two different heuristics to figure out the arity of something by either doing some analysis on the definition side, or some analysis from usage
2023-01-31 16:02:48 +0100 <dminuoso> for example
2023-01-31 16:03:02 +0100 <dminuoso> if you see `f 1 2 3` somewhere, you can without hesitation simply assume `f` to take *at least* 3 arguments.
2023-01-31 16:03:35 +0100 <dminuoso> and there's also interaction with lazyness
2023-01-31 16:03:42 +0100 <dminuoso> and pattern matching
2023-01-31 16:03:48 +0100 <dminuoso> for instance
2023-01-31 16:04:08 +0100 <dminuoso> % let f = \1 -> \x -> () in f undefined `seq` ()
2023-01-31 16:04:08 +0100 <yahb2> *** Exception: Prelude.undefined ; CallStack (from HasCallStack): ; error, called at libraries/base/GHC/Err.hs:74:14 in base:GHC.Err ; undefined, called at <interactive>:96:29 in interactive:Gh...
2023-01-31 16:04:14 +0100 <dminuoso> % let f = \1 x -> () in f undefined `seq` ()
2023-01-31 16:04:14 +0100 <yahb2> ()
2023-01-31 16:04:28 +0100 <dminuoso> What you consider "arity" kind of depends on the mind model you have
2023-01-31 16:04:46 +0100 <dminuoso> and GHC has a lot of tools to generate efficient code according to the semantics
2023-01-31 16:04:48 +0100 <[exa]> > id id id id id id id gcd 5 3
2023-01-31 16:04:49 +0100 <lambdabot> 1
2023-01-31 16:04:52 +0100 <[exa]> ^ don't.
2023-01-31 16:07:14 +0100ddellacosta(~ddellacos@89.45.224.176) (Ping timeout: 260 seconds)
2023-01-31 16:12:16 +0100 <merijn> hmm
2023-01-31 16:12:56 +0100 <merijn> unix-compat 0.6 has a revision to support unix 2.8.0.0, but cabal is rejecting claiming it excludes 2.8 (the old bound before revision)
2023-01-31 16:13:34 +0100 <dminuoso> merijn: the opposite is the case.
2023-01-31 16:13:43 +0100 <dminuoso> https://hackage.haskell.org/package/unix-compat-0.6/revisions/
2023-01-31 16:13:51 +0100 <dminuoso> from >=2.6 && <2.9 to >=2.6 && <2.8
2023-01-31 16:14:37 +0100 <merijn> oh, wait, yeah
2023-01-31 16:14:39 +0100 <merijn> well fuck
2023-01-31 16:15:44 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-31 16:17:12 +0100 <merijn> fun times, now I need to lower a bunch of other constraints too
2023-01-31 16:21:01 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow)
2023-01-31 16:23:01 +0100 <merijn> Only had to bump 77 bounds to update this shit xD
2023-01-31 16:37:29 +0100acidjnk(~acidjnk@p200300d6e715c450d0b080c45be0641e.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-01-31 16:37:39 +0100hounded(~hounded@2603:7000:da43:eccc::cec)
2023-01-31 16:37:59 +0100hounded_woodstoc(~hounded@2603:7000:da43:eccc::cec)
2023-01-31 16:38:18 +0100CiaoSen(~Jura@2003:c9:5732:8400:2a3a:4dff:fe84:dbd5)
2023-01-31 16:38:24 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-01-31 16:48:58 +0100kurbus(~kurbus@user/kurbus) (Quit: Client closed)
2023-01-31 16:49:25 +0100bitmapper(uid464869@id-464869.lymington.irccloud.com)
2023-01-31 16:52:35 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba)
2023-01-31 16:57:08 +0100phma(~phma@host-67-44-208-170.hnremote.net) (Read error: Connection reset by peer)
2023-01-31 16:57:38 +0100titibandit1(~titibandi@xdsl-85-197-0-96.nc.de)
2023-01-31 17:00:40 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-01-31 17:05:40 +0100phma(~phma@host-67-44-208-33.hnremote.net)
2023-01-31 17:06:54 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba) (Remote host closed the connection)
2023-01-31 17:08:10 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt) (Remote host closed the connection)
2023-01-31 17:08:34 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt)
2023-01-31 17:11:18 +0100kurbus(~kurbus@user/kurbus)
2023-01-31 17:11:21 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-01-31 17:11:58 +0100Cale(~cale@cpebc4dfb3052b3-cmbc4dfb3052b0.cpe.net.cable.rogers.com) (Read error: Connection reset by peer)
2023-01-31 17:13:25 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-31 17:16:18 +0100jumper149(~jumper149@base.felixspringer.xyz) (Quit: WeeChat 3.8)
2023-01-31 17:17:28 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-01-31 17:23:53 +0100kurbus(~kurbus@user/kurbus) (Ping timeout: 260 seconds)
2023-01-31 17:27:06 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-31 17:29:21 +0100kenran`(~user@user/kenran) (Remote host closed the connection)
2023-01-31 17:29:51 +0100razetime(~Thunderbi@117.193.3.163) (Remote host closed the connection)
2023-01-31 17:34:54 +0100gurkenglas(~gurkengla@dynamic-046-114-176-228.46.114.pool.telefonica.de)
2023-01-31 17:36:49 +0100ubert1(~Thunderbi@2a02:8109:abc0:6434:2d8a:1036:b201:e1eb) (Quit: ubert1)
2023-01-31 17:38:52 +0100sadmax(~user@209-172-15-113-ama.pathwayz.com)
2023-01-31 17:40:25 +0100ec_(~ec@gateway/tor-sasl/ec)
2023-01-31 17:43:14 +0100ddellacosta(~ddellacos@143.244.47.100)
2023-01-31 17:43:59 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 255 seconds)
2023-01-31 17:50:48 +0100kurbus(~kurbus@user/kurbus)
2023-01-31 17:54:05 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-01-31 17:56:25 +0100ec(~ec@gateway/tor-sasl/ec)
2023-01-31 17:56:41 +0100avicenzi(~avicenzi@193.86.92.180) (Ping timeout: 252 seconds)
2023-01-31 18:00:11 +0100ec_(~ec@gateway/tor-sasl/ec) (Ping timeout: 255 seconds)
2023-01-31 18:03:35 +0100ddellacosta(~ddellacos@143.244.47.100) (Ping timeout: 246 seconds)
2023-01-31 18:04:04 +0100remedan(~remedan@ip-94-112-0-18.bb.vodafone.cz) (Remote host closed the connection)
2023-01-31 18:07:25 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba)
2023-01-31 18:08:22 +0100mokee(~mokee@37.228.215.106)
2023-01-31 18:09:54 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:d1aa:86d0:796e:605)
2023-01-31 18:11:50 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba) (Ping timeout: 260 seconds)
2023-01-31 18:14:55 +0100 <sm> hehe, better you than your users
2023-01-31 18:16:10 +0100 <merijn> sm: That was without being able to bump unix/directory, sadly :\
2023-01-31 18:16:30 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-31 18:17:24 +0100mechap(~mechap@user/mechap)
2023-01-31 18:18:22 +0100remedan(~remedan@ip-94-112-0-18.bb.vodafone.cz)
2023-01-31 18:24:08 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Quit: restart)
2023-01-31 18:25:07 +0100merijn(~merijn@86.86.29.250)
2023-01-31 18:25:21 +0100forell_(~forell@host-178-216-90-220.sta.tvknaszapraca.pl)
2023-01-31 18:26:04 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Ping timeout: 260 seconds)
2023-01-31 18:26:04 +0100forell(~forell@user/forell) (Ping timeout: 260 seconds)
2023-01-31 18:28:28 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-01-31 18:32:53 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-01-31 18:33:05 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-31 18:36:19 +0100varoo(~varoo@2401:4900:4111:3c14:0:13:cf76:1001) (Read error: Connection reset by peer)
2023-01-31 18:36:55 +0100varoo(~varoo@122.161.91.19)
2023-01-31 18:36:59 +0100titibandit1(~titibandi@xdsl-85-197-0-96.nc.de) (Quit: Leaving.)
2023-01-31 18:37:03 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net)
2023-01-31 18:39:35 +0100sadmax(~user@209-172-15-113-ama.pathwayz.com) (Ping timeout: 252 seconds)
2023-01-31 18:45:39 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-31 18:46:07 +0100codaraxis(~codaraxis@user/codaraxis)
2023-01-31 18:50:10 +0100chele(~chele@user/chele) (Remote host closed the connection)
2023-01-31 18:55:36 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba)
2023-01-31 18:55:44 +0100mechap(~mechap@user/mechap) (Ping timeout: 248 seconds)
2023-01-31 18:56:47 +0100mechap(~mechap@user/mechap)
2023-01-31 18:56:59 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2023-01-31 18:56:59 +0100motherfsck(~motherfsc@user/motherfsck) (Remote host closed the connection)
2023-01-31 18:58:32 +0100 <Las[m]> Does anyone know how you can unsafely create a coercion, i.e. `Coercible a b` for two `a` and `b`?
2023-01-31 18:59:08 +0100Hammdist(~Hammdist@67.169.114.135) (Quit: Client closed)
2023-01-31 19:00:02 +0100 <geekosaur> you can't; they're a figment of the typechecker
2023-01-31 19:00:37 +0100 <EvanR> two a and one b? two a and two b?
2023-01-31 19:00:40 +0100 <geekosaur> well, maybe there's a plugin that you could run during typechecking that could manufacture one
2023-01-31 19:01:11 +0100ft(~ft@p4fc2a257.dip0.t-ipconnect.de)
2023-01-31 19:01:26 +0100 <geekosaur> and, well, it could be very unsafe
2023-01-31 19:01:47 +0100gurkenglas(~gurkengla@dynamic-046-114-176-228.46.114.pool.telefonica.de) (Ping timeout: 248 seconds)
2023-01-31 19:03:10 +0100teo(~teo@user/teo) (Ping timeout: 260 seconds)
2023-01-31 19:03:33 +0100 <Las[m]> What happens if I do `unsafeCoerce (d :: Dict (Coercible ()) ()) :: Dict (Coercible a) b`?
2023-01-31 19:03:37 +0100 <Las[m]> `Dict` from sop-core
2023-01-31 19:04:10 +0100Lycurgus(~juan@user/Lycurgus)
2023-01-31 19:04:53 +0100 <geekosaur> my understanding is that Coercible isn't actually a Dict
2023-01-31 19:05:06 +0100 <geekosaur> it's a hack inside the typechecker
2023-01-31 19:05:35 +0100bhall(~brunohall@195.147.207.136)
2023-01-31 19:05:41 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 252 seconds)
2023-01-31 19:05:41 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-01-31 19:07:14 +0100 <geekosaur> https://downloads.haskell.org/ghc/9.2.5/docs/html/libraries/base-4.16.4.0/Data-Coerce.html#t:Coerc… "This class does not have regular instances; instead they are created on-the-fly during type-checking. Trying to manually declare an instance of Coercible is an error."
2023-01-31 19:07:17 +0100proportions(~proportio@91.150.188.137)
2023-01-31 19:08:25 +0100 <geekosaur> http://research.microsoft.com/en-us/um/people/simonpj/papers/ext-f/coercible.pdf
2023-01-31 19:08:37 +0100 <geekosaur> that's what I was really looking for
2023-01-31 19:09:11 +0100 <Las[m]> thanks
2023-01-31 19:10:35 +0100kurbus(~kurbus@user/kurbus) (Quit: Client closed)
2023-01-31 19:10:48 +0100kurbus(~kurbus@user/kurbus)
2023-01-31 19:10:56 +0100cheater_(~Username@user/cheater)
2023-01-31 19:11:00 +0100econo(uid147250@user/econo)
2023-01-31 19:11:02 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow) (Quit: WeeChat 3.8)
2023-01-31 19:11:14 +0100 <EvanR> type classes vs the world. Being an instance of a class is like a logical assertion which can be used as part of proof of a larger assertion
2023-01-31 19:11:34 +0100 <EvanR> somehow got confused with ad hoc polymorphism support dictionaries xD
2023-01-31 19:13:31 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow)
2023-01-31 19:13:44 +0100proportions(~proportio@91.150.188.137) ()
2023-01-31 19:13:51 +0100cheater(~Username@user/cheater) (Ping timeout: 248 seconds)
2023-01-31 19:14:01 +0100cheater_cheater
2023-01-31 19:14:36 +0100Inst__(~Inst@c-98-208-218-119.hsd1.fl.comcast.net) (Remote host closed the connection)
2023-01-31 19:14:53 +0100Inst__(~Inst@2601:6c4:4081:54f0:d8af:1b99:f61a:780e)
2023-01-31 19:15:30 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-01-31 19:16:41 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 255 seconds)
2023-01-31 19:18:01 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow) (Read error: Connection reset by peer)
2023-01-31 19:19:16 +0100ec(~ec@gateway/tor-sasl/ec)
2023-01-31 19:20:50 +0100bontaq(~user@ool-45779fe5.dyn.optonline.net)
2023-01-31 19:21:14 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-01-31 19:24:10 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow)
2023-01-31 19:24:51 +0100Xeroine(~Xeroine@user/xeroine) (Ping timeout: 260 seconds)
2023-01-31 19:25:21 +0100simendsjo(~user@84.211.91.241)
2023-01-31 19:26:12 +0100Xeroine(~Xeroine@user/xeroine)
2023-01-31 19:27:51 +0100tremon(~tremon@83-85-213-108.cable.dynamic.v4.ziggo.nl)
2023-01-31 19:29:35 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-01-31 19:30:25 +0100kuribas(~user@ptr-17d51enb5ebo8t8l3i4.18120a2.ip6.access.telenet.be)
2023-01-31 19:30:49 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 260 seconds)
2023-01-31 19:36:31 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt) (Ping timeout: 260 seconds)
2023-01-31 19:37:49 +0100bitmapper(uid464869@id-464869.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-31 19:39:30 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba) (Remote host closed the connection)
2023-01-31 19:40:03 +0100king_gs(~Thunderbi@2806:103e:29:34e5:ecc6:ec8d:1c5b:35a6)
2023-01-31 19:44:05 +0100simendsjo(~user@84.211.91.241) (Remote host closed the connection)
2023-01-31 19:44:58 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt)
2023-01-31 19:49:14 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt) (Ping timeout: 246 seconds)
2023-01-31 19:56:54 +0100acidjnk(~acidjnk@p200300d6e715c483d4ac9ea2255c502f.dip0.t-ipconnect.de)
2023-01-31 19:57:01 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-31 19:59:17 +0100akegalj(~akegalj@222-217.dsl.iskon.hr)
2023-01-31 20:01:43 +0100CiaoSen(~Jura@2003:c9:5732:8400:2a3a:4dff:fe84:dbd5) (Ping timeout: 252 seconds)
2023-01-31 20:02:10 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow) (Quit: WeeChat 3.8)
2023-01-31 20:04:03 +0100 <jean-paul[m]> is there a megaparsec combinator for "take exactly N tokens matched by P"?
2023-01-31 20:05:32 +0100 <jean-paul[m]> meeh. count is in the index. which is exactly what I thought it would be. it's just not on the Text.Megaparsec page. :/
2023-01-31 20:07:22 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-01-31 20:10:34 +0100gensyst(gensyst@user/gensyst)
2023-01-31 20:11:45 +0100 <byorgey> jean-paul[m]: that means it's not exported
2023-01-31 20:12:02 +0100 <gensyst> How can I get rid of the warning? https://dpaste.com/D54Z5R9FV Where would I put the @Double for example?
2023-01-31 20:12:11 +0100 <jean-paul[m]> ghc seems to think it is exported, though
2023-01-31 20:12:58 +0100 <sm> finding what's available to use in a megaparsec parser is not simple alas
2023-01-31 20:13:03 +0100 <byorgey> hmm, interesting, maybe I was confused. If it works for you, then great
2023-01-31 20:13:41 +0100 <byorgey> gensyst: computeSummary @Double thing should work
2023-01-31 20:14:04 +0100 <gensyst> byorgey, doesn't
2023-01-31 20:14:22 +0100 <byorgey> wait, no, sorry
2023-01-31 20:14:22 +0100varoo(~varoo@122.161.91.19) (Read error: Connection reset by peer)
2023-01-31 20:15:16 +0100 <geekosaur> doesn't that want to be `x :: Double; x = …`
2023-01-31 20:15:30 +0100 <byorgey> gensyst: what is the purpose of quantifying over f in the instance for HasSummary Thing?
2023-01-31 20:15:37 +0100varoo(~varoo@122.161.91.19)
2023-01-31 20:15:47 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow)
2023-01-31 20:15:48 +0100 <byorgey> why not just complexity :: Double = ... ?
2023-01-31 20:16:09 +0100 <byorgey> geekosaur: x is not the problem, that definition has type Double since computeSummary returns a Double
2023-01-31 20:16:15 +0100 <byorgey> s/definition/definitely/
2023-01-31 20:16:42 +0100 <byorgey> the problem is that the instance for HasSummary Thing contains an ambiguous type
2023-01-31 20:16:45 +0100 <gensyst> byorgey, for Thing (unlike for some other instances of HasSummary), the computeSummary is particularly complex - and I don't want to hardcode Double. I want to try running it first with Double and later with BigFloat, and so son.
2023-01-31 20:16:58 +0100 <gensyst> but it's only for the internal use
2023-01-31 20:17:33 +0100 <geekosaur> that "internal" means you have no control over it
2023-01-31 20:17:52 +0100son0p(~ff@181.136.122.143) (Ping timeout: 248 seconds)
2023-01-31 20:18:33 +0100 <gensyst> anyway what's the point of the forall feature for instances, if I can't even use it?
2023-01-31 20:18:46 +0100 <byorgey> sure, if it's only for internal use then it shouldn't be in the instance head like that
2023-01-31 20:18:48 +0100 <geekosaur> if you want to be able to swap it, use a type alias
2023-01-31 20:18:50 +0100 <byorgey> what about this? https://dpaste.com/36LXV7TPX
2023-01-31 20:19:27 +0100jero98772(~jero98772@2800:484:1d80:d8ce:9815:cfda:3661:17bb) (Ping timeout: 248 seconds)
2023-01-31 20:19:39 +0100 <byorgey> so the implementation of complexity has a polymorphic type, to make sure that you don't use Double-specific features. You only specialize it to Double in one place, so you can easily try out different types later.
2023-01-31 20:19:46 +0100 <byorgey> but none of this leaks out of the instance.
2023-01-31 20:20:29 +0100 <cheater> how can i force cabal to build a package (eg lens) without adding it to the cabal file?
2023-01-31 20:20:55 +0100 <geekosaur> --build-depends=pkg
2023-01-31 20:21:11 +0100 <geekosaur> but I'd have to question why you would do this
2023-01-31 20:23:29 +0100 <kuribas> I was reviewing Python code with a new colleage, and I mentioned FP. She then told me she got a distaste of FP by working in a complex scala project.
2023-01-31 20:24:01 +0100 <kuribas> My other colleage also went to clojure from scala, and got a hate for static types. I wonder if there is a pattern here. I read only about another scala programmer that did this.
2023-01-31 20:24:16 +0100 <kuribas> I never hear from people going from haskell to clojure or dynamic languages.
2023-01-31 20:25:27 +0100 <geekosaur> seems like I have heard a decent amount of that in -offtopic 🙂
2023-01-31 20:26:41 +0100 <kuribas> yeah
2023-01-31 20:29:22 +0100 <kuribas> kind of sad that scala is ruining static typed FP for people.
2023-01-31 20:29:53 +0100kuribas(~user@ptr-17d51enb5ebo8t8l3i4.18120a2.ip6.access.telenet.be) (Quit: ERC (IRC client for Emacs 27.1))
2023-01-31 20:30:51 +0100 <cheater> geekosaur: didn't you use to be able to just do "cabal build lens"?
2023-01-31 20:31:22 +0100 <geekosaur> you may be thinking of cabal v1, which could create big messes that way
2023-01-31 20:31:37 +0100 <geekosaur> there's still a way to do it but if it breaks you get to keep all the pieces
2023-01-31 20:31:45 +0100 <geekosaur> cabal install --lib lens
2023-01-31 20:31:55 +0100 <cheater> why would something break?
2023-01-31 20:32:15 +0100 <geekosaur> multiple versions installed invites ghc to pick the wrong one
2023-01-31 20:32:50 +0100 <geekosaur> we left cabal v1 behind for a reason. see "cabal hell", which this more or less re-invites
2023-01-31 20:33:13 +0100 <cheater> k
2023-01-31 20:33:20 +0100 <cheater> anyways,
2023-01-31 20:34:01 +0100 <cheater> i'm looking for a network comms lib of some sort, to have a server running on a port or listening on a socket file. receive messages, send messages. that kind of thing.
2023-01-31 20:34:14 +0100 <cheater> when a message is received it's given to a handler.
2023-01-31 20:34:26 +0100 <cheater> i thought of using some http server library but it seems overkill.
2023-01-31 20:35:04 +0100 <monochrom> I think C++ and Java discouraged a lot of people from static typing too, out of the gross verbosity. I imagine Scala merely inherits the same issue.
2023-01-31 20:35:37 +0100 <cheater> i only used scala years and years ago and since then haven't had to
2023-01-31 20:35:45 +0100 <cheater> i remember a lot of pain
2023-01-31 20:35:46 +0100 <jean-paul[m]> cheater: HTTP servers are a dime a dozen, I wouldn't worry about wasting one on a too-small project
2023-01-31 20:35:53 +0100 <monochrom> To be sure, I'm cold-hearted and unsympathetic. Clearly and logically, "static typing or else untyped" is a false dichotomy, i.e., ever heard of type inference?
2023-01-31 20:36:19 +0100 <cheater> jean-paul[m]: yeah but i just would like to try something that's tcp and doesn't use http.
2023-01-31 20:37:22 +0100 <monochrom> To be sure, subtyping and type inference don't mix very well. OCaml shows the best effort known, and it shows that there are limits. Although, in practice it needs very minimal type annotations.
2023-01-31 20:37:45 +0100 <jean-paul[m]> cheater: Oh, ok. Well, try what you want. Just responding to the reason you gave - "overkill".
2023-01-31 20:37:54 +0100 <monochrom> And very sensible ones.
2023-01-31 20:38:11 +0100 <cheater> the only ocaml projects i worked on (like tezos) fully forbid the "o" part
2023-01-31 20:38:31 +0100 <cheater> jean-paul[m]: i don't know any such libraries so i came here to ask.
2023-01-31 20:38:34 +0100 <jean-paul[m]> is basement's wordToInt safe? Does every Word fit in an Int? Word says it is "the same size as an Int" but Int is signed. Is it "the same size" in memory or is it "the same size" for the number of values it can hold?
2023-01-31 20:38:52 +0100 <monochrom> Now let's wait another 5 years to see people to saying "I switched from Rust to Racket because I'm tired of static typing". >:)
2023-01-31 20:39:24 +0100 <monochrom> "oh and also tired of static ownership systems" >:D
2023-01-31 20:39:25 +0100 <jean-paul[m]> cheater: protobufs, capnproto, messagepack
2023-01-31 20:39:29 +0100 <cheater> making my programs not buggy is so limiting
2023-01-31 20:39:37 +0100 <cheater> right, that rings a bell
2023-01-31 20:39:40 +0100 <cheater> i've used those in the past
2023-01-31 20:39:43 +0100 <cheater> let me try them then
2023-01-31 20:39:44 +0100 <cheater> thanks
2023-01-31 20:40:00 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba)
2023-01-31 20:40:01 +0100monochromswitched from Rust to Haskell because tired of that, actually LOL
2023-01-31 20:40:09 +0100 <cheater> static ownership is terrible. i'm all for redistribution of wealth
2023-01-31 20:40:59 +0100 <cheater> rust is pretty bad too. you want to keep your guillotine in good shape
2023-01-31 20:42:17 +0100 <varoo> cheater: why is rust bad exactly?
2023-01-31 20:42:26 +0100yrlnry(~yrlnry@2600:4040:738e:5400:14e9:d2e1:808a:60f2) (Remote host closed the connection)
2023-01-31 20:42:28 +0100 <jean-paul[m]> Okay ... answered it myself. wordToInt 18446744073709551615 == -1
2023-01-31 20:43:15 +0100yrlnry(~yrlnry@pool-108-36-173-41.phlapa.fios.verizon.net)
2023-01-31 20:43:23 +0100 <jean-paul[m]> why does Basement offer me a dedicated conversion between two types that wraps on overflow, don't I already have plenty of functions for that
2023-01-31 20:43:26 +0100 <geekosaur> right, there's no magical way it can stretch an Int to hold a maximal-value Word
2023-01-31 20:43:45 +0100 <geekosaur> it would need to use Int128
2023-01-31 20:44:15 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba) (Ping timeout: 252 seconds)
2023-01-31 20:45:53 +0100 <monochrom> You should ask the author of Basement.
2023-01-31 20:46:17 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi)
2023-01-31 20:46:54 +0100 <monochrom> For overflow guarding, https://hackage.haskell.org/package/int-cast helps.
2023-01-31 20:46:57 +0100jero98772(~jero98772@2800:484:1d80:d8ce:2a22:c4e3:dc8b:e5c2)
2023-01-31 20:47:04 +0100 <dminuoso> That library should be part of base.
2023-01-31 20:47:51 +0100 <dminuoso> Touting type safety but forcing people to just fromIntegral + realToFrac everywhere is a bit of a joke.
2023-01-31 20:48:08 +0100 <dminuoso> I think the numerical system is perhaps one of the larger warts of Haskell.
2023-01-31 20:49:22 +0100 <cheater> varoo: it dulls the edge
2023-01-31 20:50:04 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba)
2023-01-31 20:50:05 +0100 <[exa]> cheater: that's on point, I'm writing that down
2023-01-31 20:50:25 +0100 <gensyst> This is what I have right now: https://dpaste.com/6WUZBUSUH
2023-01-31 20:50:31 +0100 <cheater> don't lose your head over it
2023-01-31 20:50:33 +0100 <gensyst> Is it possible to avoid Proxy?
2023-01-31 20:50:55 +0100jle`(~jle`@cpe-23-240-75-236.socal.res.rr.com) (Ping timeout: 248 seconds)
2023-01-31 20:50:57 +0100 <gensyst> cc geekosaur byorgey ^ that's more what i was after. i could do it with proxy
2023-01-31 20:52:52 +0100 <jean-paul[m]> monochrom, geekosaur : thanks
2023-01-31 20:52:57 +0100jle`(~jle`@cpe-23-240-75-236.socal.res.rr.com)
2023-01-31 20:53:22 +0100 <geekosaur> in some future version of ghc (or it might already be in 9.4 or 9.6 alpha2?) you would be able to declare it as `forall f -> a -> Double` and call it as `computeSummary Double thing`
2023-01-31 20:54:05 +0100 <gensyst> interesting. geekosaur so this is sort of a case where TypeApplications just don't work and Proxy are still needed?
2023-01-31 20:54:14 +0100danza(~francesco@151.43.92.170)
2023-01-31 20:54:50 +0100 <merijn> Define needed
2023-01-31 20:54:56 +0100 <merijn> dminuoso: words
2023-01-31 20:54:59 +0100 <geekosaur> right, because there's no exposed way to do a TypeApplication (except `Proxy @Double` which is not much better than what you're doing)
2023-01-31 20:55:00 +0100 <merijn> *word
2023-01-31 20:55:04 +0100mei(~mei@user/mei) (Remote host closed the connection)
2023-01-31 20:55:10 +0100 <jackdk> You can turn on AllowAmbiguousTypes, make `f` the first param in your typeclass, and use type applications at the use site. I did this in my example last night.
2023-01-31 20:55:21 +0100 <cheater> i think msgpack + msgpack-rpc is what i want
2023-01-31 20:55:32 +0100titibandit1(~titibandi@xdsl-85-197-0-96.nc.de)
2023-01-31 20:56:13 +0100 <monochrom> You need either Proxy or TypeApplication.
2023-01-31 20:56:35 +0100 <monochrom> Speaking of type inference being limited in the face of subtyping heh.
2023-01-31 20:56:51 +0100 <monochrom> And the ensuing "I hate static typing now" emotions >:)
2023-01-31 20:58:35 +0100 <cheater> hmm, i created a new cabal package, added msgpack-rps to build-depends on Main.hs, and it can't resolve dependencies... any idea why that's happening? it's a completely new cabal project.
2023-01-31 20:58:38 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-31 20:59:00 +0100 <gensyst> jackdk, it works lol
2023-01-31 20:59:28 +0100 <cheater> oh, msgpack-rpc requires base < 4.13
2023-01-31 20:59:29 +0100 <cheater> idk why
2023-01-31 20:59:32 +0100 <cheater> it's weird
2023-01-31 20:59:38 +0100 <gensyst> https://dpaste.com/CMNCJ4FP8
2023-01-31 21:00:14 +0100 <cheater> how do i make cabal work with an older base? (and i assume i need an older ghc for that too)
2023-01-31 21:00:24 +0100 <cheater> i installed cabal from the haskell-platform package in mate
2023-01-31 21:00:24 +0100kurbus(~kurbus@user/kurbus) (Quit: Client closed)
2023-01-31 21:01:01 +0100mei(~mei@user/mei)
2023-01-31 21:01:14 +0100 <cheater> ubuntu-mate that is
2023-01-31 21:01:14 +0100danza(~francesco@151.43.92.170) (Read error: Connection reset by peer)
2023-01-31 21:01:18 +0100kurbus(~kurbus@user/kurbus)
2023-01-31 21:02:14 +0100 <monochrom> Yes absolutely older GHC.
2023-01-31 21:02:17 +0100CiaoSen(~Jura@p200300c9573284002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-01-31 21:02:28 +0100 <sclv> its not about the version of cabal. its the version of ghc. if a package requires an older version of base, you need to use a ghc that provides that version of base
2023-01-31 21:02:59 +0100 <monochrom> But older than what ubuntu-mate provides? Then you'll be better off uninstalling ubuntu-mate's GHC and use ghcup and choose your GHC version instead.
2023-01-31 21:03:17 +0100 <merijn> Does ghcup even have versions old enough for base 4.13? :p
2023-01-31 21:03:42 +0100 <cheater> how do i get that?
2023-01-31 21:03:48 +0100 <cheater> i've never used ghcup
2023-01-31 21:03:59 +0100 <tomsmeding> merijn: 4.13 is only ghc 8.8.4, that's recent-ish
2023-01-31 21:04:01 +0100 <cheater> let me google...
2023-01-31 21:04:02 +0100 <merijn> cheater: ghcup should be in ubuntu's distro
2023-01-31 21:04:03 +0100 <sclv> alternately there's a newer and more maintained fork https://hackage.haskell.org/package/msgpack-rpc-conduit
2023-01-31 21:04:04 +0100 <monochrom> And yeah cabal doesn't have a say on this.
2023-01-31 21:04:08 +0100 <merijn> tomsmeding: <4.13 means 8.6, though
2023-01-31 21:04:13 +0100 <tomsmeding> oh <
2023-01-31 21:04:19 +0100 <sclv> installing an older ghc to use an older unmaintained package is usually a bad idea
2023-01-31 21:04:33 +0100titibandit1(~titibandi@xdsl-85-197-0-96.nc.de) (Remote host closed the connection)
2023-01-31 21:04:38 +0100 <cheater> it's not in mate's repisitory
2023-01-31 21:04:38 +0100 <sclv> because the rest of the ecosystem is splat. so you either use a newer fork of the package or update the package yourself
2023-01-31 21:04:42 +0100 <cheater> 8.6 is ancient
2023-01-31 21:04:43 +0100 <merijn> And I'm hitting the fact that some people cut support for 8.10 from megaparsec >.<
2023-01-31 21:04:46 +0100 <tomsmeding> but in any case my ghcup goes back to ghc 7.10.3 :)
2023-01-31 21:04:46 +0100 <monochrom> Yeah please don't save a sunk ship.
2023-01-31 21:04:54 +0100 <tomsmeding> cheater: https://www.haskell.org/ghcup/
2023-01-31 21:05:11 +0100 <sclv> i highly recommend not trying to use an older unmaintained package off the shelf. either update it yourself and use your locally updated fork, or use the newer fork already released on hackage
2023-01-31 21:05:11 +0100 <cheater> why is msgpack-rpc with ancient ghc
2023-01-31 21:05:20 +0100 <sclv> because its an old package that is unmaintained
2023-01-31 21:05:26 +0100 <sclv> it was last uploaded in 2015!
2023-01-31 21:05:34 +0100 <sclv> its like eight years out of date
2023-01-31 21:05:50 +0100 <merijn> Hell, even the last metadata revision is from 2019, i.e. 4 years ago
2023-01-31 21:06:22 +0100 <monochrom> I would give --allow-newer a try. If it works or almost works (trivial errors I can fix quickly), then cool. If not, I would just give up and forget it.
2023-01-31 21:07:17 +0100 <cheater> oh i forgot about that
2023-01-31 21:07:19 +0100 <cheater> i'll try that
2023-01-31 21:07:24 +0100 <merijn> monochrom: Yes, but you have given up on being unreasonable ;)
2023-01-31 21:08:04 +0100 <merijn> Meanwhile I just spent my afternoon reading changelogs for 77 dependencies to see if I can bump my bounds after not checking them for 3+ years :p
2023-01-31 21:08:08 +0100 <cheater> there should be like an allow-new override per-package in the cabal file
2023-01-31 21:08:17 +0100 <tomsmeding> merijn: F
2023-01-31 21:08:17 +0100 <merijn> cheater: there is...
2023-01-31 21:08:24 +0100 <cheater> how does it work?
2023-01-31 21:08:26 +0100 <geekosaur> cabal.project at least
2023-01-31 21:08:38 +0100 <tomsmeding> https://cabal.readthedocs.io/en/3.4/cabal-project.html#cfg-field-allow-newer
2023-01-31 21:09:04 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 248 seconds)
2023-01-31 21:09:18 +0100gensyst(gensyst@user/gensyst) (Quit: Leaving)
2023-01-31 21:09:24 +0100 <monochrom> merijn: BTW "ghcup list" lists the relation between GHC versions and base versions too.
2023-01-31 21:09:27 +0100 <geekosaur> --allow-newer is also per package, if you look at the usage
2023-01-31 21:09:27 +0100 <tomsmeding> mind that this is the cabal.project file, which is _distinct_ from your something.cabal file
2023-01-31 21:09:51 +0100 <merijn> monochrom: I'm a grumpy old curmudgeon who doesn't have ghcup installed :p
2023-01-31 21:09:55 +0100 <tomsmeding> minimal cabal.project is "packages: ."
2023-01-31 21:10:16 +0100 <merijn> tomsmeding: minimal cabal.project is no file ;)
2023-01-31 21:10:23 +0100son0p(~ff@181.136.122.143)
2023-01-31 21:10:33 +0100 <tomsmeding> sure, but what I wrote is minimal contents if you want the file
2023-01-31 21:10:38 +0100 <merijn> oh, fun times, people uploading broken code to hackage
2023-01-31 21:10:41 +0100 <tomsmeding> point being that an empty cabal.project isn't going to work
2023-01-31 21:10:45 +0100 <monochrom> "semantically minimal after syntax desugaring" >:)
2023-01-31 21:10:53 +0100 <tomsmeding> and it's quite unclear from docs what the _actual_ minimal contents is
2023-01-31 21:11:01 +0100 <merijn> "variable not in scope: when"
2023-01-31 21:11:53 +0100 <geekosaur> @index when
2023-01-31 21:11:53 +0100 <lambdabot> Control.Monad
2023-01-31 21:12:22 +0100 <merijn> geekosaur: I know that, but that doesn't fix this code on hackage so my build plan works
2023-01-31 21:12:51 +0100 <tomsmeding> code on hackage that uses 'when' without importing Control.Monad? Has there even been a base where 'when' was in Prelude
2023-01-31 21:12:59 +0100 <merijn> Me and my unreasonable expectation people try and at least "compile" before uploading
2023-01-31 21:13:01 +0100 <monochrom> I think no.
2023-01-31 21:13:11 +0100 <cheater> hmm can i make something make a cabal.project for me just like i can make cabal make the .cabal file for me?
2023-01-31 21:13:26 +0100 <monochrom> Ugh cabal doesn't make .cabal files.
2023-01-31 21:13:31 +0100 <tomsmeding> cheater: open an editor, type "packages: .", save, close
2023-01-31 21:13:34 +0100 <geekosaur> cabal init does
2023-01-31 21:13:39 +0100 <monochrom> Ah sorry.
2023-01-31 21:13:40 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-31 21:13:41 +0100 <geekosaur> but not cabal.project
2023-01-31 21:13:44 +0100 <cheater> that's too much to remember that
2023-01-31 21:13:48 +0100 <jackdk> There's a good chance that the package is unmaintained and and allow-newer on that base bound will let it compile
2023-01-31 21:13:55 +0100 <tomsmeding> cheater: I know, but there's no better currently
2023-01-31 21:14:24 +0100 <merijn> geekosaur: You can just do "cabal configure" and copy cabal.project.local to cabal.project
2023-01-31 21:14:39 +0100 <merijn> cheater: ^^
2023-01-31 21:14:46 +0100 <tomsmeding> cheater: example file, you'll only need the 'packages' and the 'allow-newer' (with your deps) https://git.tomsmeding.com/mandelhs/tree/cabal.project
2023-01-31 21:15:13 +0100 <cheater> i won't remember the url
2023-01-31 21:15:18 +0100 <geekosaur> I don't even use cabal init, I copy shit from existing projects
2023-01-31 21:15:24 +0100 <merijn> geekosaur: same
2023-01-31 21:15:31 +0100 <tomsmeding> same
2023-01-31 21:15:37 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba) (Remote host closed the connection)
2023-01-31 21:15:53 +0100 <tomsmeding> at some point you start remembering certain template projects that have suitable .cabal files to copy
2023-01-31 21:16:12 +0100 <merijn> anyone know a library that provides a weighted random shuffle function?
2023-01-31 21:16:24 +0100 <monochrom> I still use cabal init, but with version 3.8 adding -Wall religiously, I am slowly getting discouraged.
2023-01-31 21:16:27 +0100 <merijn> I used to use random-extras, but the last version is from 2012 and breaks
2023-01-31 21:16:53 +0100freeside(~mengwong@103.252.202.170)
2023-01-31 21:17:41 +0100 <tomsmeding> merijn: and you can't lift out the one function you need?
2023-01-31 21:18:52 +0100 <merijn> tomsmeding: not without essentially vendoring the entire thing
2023-01-31 21:19:04 +0100 <merijn> And this is some "absolute least amount of work" task
2023-01-31 21:20:20 +0100 <tomsmeding> oh I see it brings in a whole lot of stuff
2023-01-31 21:21:24 +0100 <dminuoso> Mmm. Okay, haskell.nix is really a sweet way to deal with haskell.
2023-01-31 21:21:39 +0100some02sudden
2023-01-31 21:21:54 +0100 <dminuoso> So I just had the idea how to restructure CI - and just started using the nixos test library to just execute haskell tests
2023-01-31 21:22:00 +0100 <merijn> tomsmeding: Well, also, I can't be arsed investing even a tiny amount of effort :p
2023-01-31 21:22:27 +0100 <dminuoso> https://gist.github.com/dminuoso/7a51d818b97d2c60c3099637807164c8
2023-01-31 21:22:30 +0100 <merijn> Especially since the entire point is to largely replace this code
2023-01-31 21:22:32 +0100 <dminuoso> This is far less oppressive than docker.
2023-01-31 21:22:40 +0100 <merijn> anyway, I give up for now
2023-01-31 21:22:40 +0100trev(~trev@user/trev)
2023-01-31 21:23:57 +0100ddellacosta(~ddellacos@143.244.47.100)
2023-01-31 21:27:53 +0100merijn(~merijn@86.86.29.250) (Ping timeout: 252 seconds)
2023-01-31 21:34:23 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 255 seconds)
2023-01-31 21:36:02 +0100 <cheater> tomsmeding: my problem is that cabal init will add all the stuff i might want to use. and it'll be commented etc. i want cabal to make a cabal.project file like that too.
2023-01-31 21:36:38 +0100 <tomsmeding> cheater: I see, I guess you can use my link as an example :p
2023-01-31 21:36:46 +0100 <tomsmeding> I'm not aware of any such generator for cabal.project files
2023-01-31 21:36:54 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-01-31 21:37:01 +0100 <tomsmeding> also there's a shit ton of keys for that file so listing them all would be counterproductive
2023-01-31 21:37:46 +0100 <tomsmeding> more productive is to search on that documentation page ( https://cabal.readthedocs.io/en/3.4/cabal-project.html ) for anything that comes up that you'd want to configure
2023-01-31 21:38:00 +0100kurbus(~kurbus@user/kurbus) (Quit: Client closed)
2023-01-31 21:40:31 +0100king_gs(~Thunderbi@2806:103e:29:34e5:ecc6:ec8d:1c5b:35a6) (Remote host closed the connection)
2023-01-31 21:40:51 +0100king_gs(~Thunderbi@2806:103e:29:34e5:ecc6:ec8d:1c5b:35a6)
2023-01-31 21:41:58 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-31 21:49:02 +0100Lycurgus(~juan@user/Lycurgus)
2023-01-31 21:53:46 +0100coot(~coot@213.134.171.3)
2023-01-31 21:54:32 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-31 22:03:01 +0100 <MangoIV[m]> Hi, I'm wondering why `($)` is not fully levity polymorphic:... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/3ea06772c617aaeb5a2e74b9e3c2a6b8dfed…>)
2023-01-31 22:03:08 +0100 <MangoIV[m]> * Hi, I'm wondering why `($)` is not fully levity polymorphic:... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/d96199568d292ee1612e8a63101e895b992a…>)
2023-01-31 22:03:28 +0100 <MangoIV[m]> * Hi, I'm wondering why `($)` is not fully levity polymorphic:... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/e0eddaffe744a38b6a26d5928a0abf3183e0…>)
2023-01-31 22:05:24 +0100 <geekosaur> levity polymorphism turns out to be hard
2023-01-31 22:06:14 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-01-31 22:06:41 +0100 <geekosaur> also, please don't use matrix edits over IRC. https://imgur.com/CFJD68B.png
2023-01-31 22:07:50 +0100aquoot(~aquoot@132.170.212.60)
2023-01-31 22:09:45 +0100 <geekosaur> https://downloads.haskell.org/~ghc/9.2.1-alpha1/docs/html/users_guide/exts/levity_polymorphism.htm…
2023-01-31 22:10:22 +0100gurkenglas(~gurkengla@dynamic-046-114-176-228.46.114.pool.telefonica.de)
2023-01-31 22:10:46 +0100 <geekosaur> I think that's the main showstopper
2023-01-31 22:12:50 +0100 <MangoIV[m]> geekosaur: this doesn't explain the latter implementation is wrong; my fully levity polymorphic $ compiles and works. it's just eta reduced
2023-01-31 22:13:56 +0100 <MangoIV[m]> <geekosaur> "also, please don't use matrix..." <- Sorry, I'm bridging to IRC.
2023-01-31 22:14:15 +0100 <geekosaur> yes, I know. matrix edits suck over the bridge
2023-01-31 22:15:23 +0100 <MangoIV[m]> again; this code compiles and works:... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/7f1766e9f465b363afef78f393e0c25e8713…>)
2023-01-31 22:15:53 +0100 <davean> Edits in an interactive medium just suck because they cause confusion for people who are interacting.
2023-01-31 22:16:06 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba)
2023-01-31 22:16:26 +0100 <geekosaur> MangoIV[m], does it also handle impredicativity?
2023-01-31 22:16:34 +0100aquoot(~aquoot@132.170.212.60) (Quit: Leaving)
2023-01-31 22:16:51 +0100 <geekosaur> one requirement for `$` is that `runST $ …` works
2023-01-31 22:17:36 +0100 <geekosaur> and I think there needs to be some "hook" for the compiler to recognize it and always turn on `ImpredicativeTypes`
2023-01-31 22:18:13 +0100 <MangoIV[m]> geekosaur: how is impredicativity handled? Isn't that magic that is specific to `($)` that I cannot replicate in my own implementation of `($)`?
2023-01-31 22:18:13 +0100 <MangoIV[m]> (Btw, I've voiced that exact concern already )
2023-01-31 22:18:32 +0100 <geekosaur> (which is kinda sucky but better than how it used to be done: recognized in the AST and removed from it so the question never came up)
2023-01-31 22:18:36 +0100jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) (Remote host closed the connection)
2023-01-31 22:19:13 +0100jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net)
2023-01-31 22:19:18 +0100 <geekosaur> it's not specific to `($)` except insofar as there's that hack to force it to always be impredicative
2023-01-31 22:19:47 +0100 <MangoIV[m]> it works with ImpredicativeTypes and runST, so no worries there.
2023-01-31 22:19:52 +0100 <davean> ttps://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/impredicative_types.html
2023-01-31 22:20:06 +0100geekosaurhands davean an h
2023-01-31 22:20:19 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:1805:fe0d:6c6e:4fba) (Ping timeout: 252 seconds)
2023-01-31 22:20:23 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 252 seconds)
2023-01-31 22:20:28 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-01-31 22:20:53 +0100freeside(~mengwong@103.252.202.170)
2023-01-31 22:20:57 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Read error: Connection reset by peer)
2023-01-31 22:21:06 +0100 <geekosaur> MangoIV[m], right, the trick is it should work without `ImpredicativeTypes` turned on, because people expect it to 😕
2023-01-31 22:21:09 +0100beteigeuze1(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-01-31 22:21:37 +0100 <geekosaur> even though it requires impredicativity
2023-01-31 22:21:37 +0100 <c_wraith> I often wonder if we should be able to tag definitions as Impredicative, rather than usage.
2023-01-31 22:21:54 +0100 <davean> geekosaur: people's expectations should change - as should the language.
2023-01-31 22:21:58 +0100 <MangoIV[m]> geekosaur: yeah, this is the magic that ghc inserts, but that doesn't matter for my case, I cannot have ghc magic in my own implementation; but that means that the implementation of `($)` in GHC is indeed not as polymorphic as it could be
2023-01-31 22:22:47 +0100 <geekosaur> then your question is probably best addressed to the libraries list or possibly the ghc list (but I'd start with libraries@)
2023-01-31 22:23:27 +0100beteigeuze1beteigeuze
2023-01-31 22:23:53 +0100mikko(~mikko@user/mikko)
2023-01-31 22:24:43 +0100pavonia(~user@user/siracusa)
2023-01-31 22:24:49 +0100 <davean> There are a lot of tricky problems that come up with levity
2023-01-31 22:25:23 +0100 <mikko> i would like to start my first haskell project and use the ansi-terminal package for it, however i can't figure out how to install it
2023-01-31 22:25:32 +0100schum(~schum@2001:470:69fc:105::38e0)
2023-01-31 22:25:59 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 268 seconds)
2023-01-31 22:26:04 +0100 <mikko> i have initialized a project using cabal and followed cabal's getting started guide which worked fine but when i try to install ansi-terminal instead of haskell-say i get errors
2023-01-31 22:26:30 +0100 <c_wraith> well.. what OS are you on, and what are the errors?
2023-01-31 22:26:45 +0100 <geekosaur> @where paste
2023-01-31 22:26:45 +0100 <lambdabot> Help us help you: please paste full code, input and/or output at e.g. https://paste.tomsmeding.com
2023-01-31 22:26:47 +0100 <mikko> https://bpa.st/TREQW
2023-01-31 22:27:13 +0100 <mikko> i'm on opensuse tumbleweed, using ghcup
2023-01-31 22:27:29 +0100 <c_wraith> that looks like your project's cabal file is specifying a really old version of base
2023-01-31 22:27:39 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-01-31 22:27:50 +0100schum(~schum@2001:470:69fc:105::38e0) ()
2023-01-31 22:27:57 +0100 <mikko> is there a way to just install whatever works? i don't really care what version it uses
2023-01-31 22:28:21 +0100 <mikko> i don't think i'm using anything from base myself since it's just printing hello world
2023-01-31 22:28:31 +0100 <c_wraith> base includes print. and putStrLn
2023-01-31 22:28:47 +0100 <c_wraith> Anyway, just change the constraint on base to something like <5
2023-01-31 22:28:58 +0100 <c_wraith> that's sort of a lie, but it'll work for your current needs
2023-01-31 22:30:16 +0100 <mikko> thanks, that seems to work
2023-01-31 22:30:34 +0100 <mikko> how do i work around if another dependency needs a different version of base?
2023-01-31 22:30:47 +0100 <c_wraith> Well, you can't change versions of base. It's closely tied to your version of GHC.
2023-01-31 22:31:56 +0100 <c_wraith> Your options are essentially changing what version of GHC you're using or telling cabal it's ok to ignore the version bound on base.
2023-01-31 22:32:33 +0100mechap(~mechap@user/mechap) (Quit: WeeChat 3.8)
2023-01-31 22:32:49 +0100 <c_wraith> the latter is done with the --allow-newer flag, in a command like cabal configure --allow-newer=base
2023-01-31 22:33:18 +0100 <mikko> i was thinking of using relude but it says base has to be <4.17
2023-01-31 22:33:35 +0100 <c_wraith> relude actually might care. It's pretty intensive
2023-01-31 22:33:55 +0100 <davean> mikko: relude still uses base
2023-01-31 22:34:13 +0100 <mikko> so there's no way to use these packages together?
2023-01-31 22:34:26 +0100 <c_wraith> well, you can see if it compiles if you tell it to allow newer
2023-01-31 22:34:34 +0100 <c_wraith> But it isn't a tested configuration
2023-01-31 22:34:48 +0100 <mikko> that sounds scary :D
2023-01-31 22:35:21 +0100 <c_wraith> Fortunately, *most* ways it can go wrong will fail to compile
2023-01-31 22:37:49 +0100 <davean> mikko: to be clear, 'base', at a slightly wrong and high level but appropriate to most programmers, is how you interface with the compiler
2023-01-31 22:37:57 +0100bontaq(~user@ool-45779fe5.dyn.optonline.net) (Remote host closed the connection)
2023-01-31 22:38:24 +0100 <davean> If you use Int, thats Base, if you use Char, thats base, if you use String, thats base
2023-01-31 22:38:45 +0100 <davean> ALMOST anything you do, is base because the compiler interacts with it. Again, not quite true, but true enough for now
2023-01-31 22:38:51 +0100 <mikko> i see
2023-01-31 22:38:58 +0100 <c_wraith> Hmm. base 4.17 is specific to ghc 9.4. The updates to base for 4.17 are probably quite small. It'll probably work.
2023-01-31 22:41:14 +0100 <cheater> hmm... any suggestions? https://pastebin.com/ste022vr
2023-01-31 22:41:36 +0100 <cheater> any modern alternatives to msgpack-rpc?
2023-01-31 22:41:51 +0100 <mikko> i can't get it to stop complaining about dependencies, i guess i'll stick to regular prelude so i can actually write some code finally
2023-01-31 22:42:31 +0100zeenk(~zeenk@2a02:2f04:a014:8700::7fe) (Quit: Konversation terminated!)
2023-01-31 22:43:05 +0100 <geekosaur> https://hackage.haskell.org/package/msgpack-rpc-conduit was suggested earlier
2023-01-31 22:43:25 +0100 <MangoIV[m]> <geekosaur> "then your question is probably..." <- Thank you, I’ll have a look.
2023-01-31 22:43:53 +0100gurkenglas(~gurkengla@dynamic-046-114-176-228.46.114.pool.telefonica.de) (Ping timeout: 246 seconds)
2023-01-31 22:44:29 +0100 <cheater> oh was it? i must have missed that.
2023-01-31 22:44:34 +0100zeenk(~zeenk@2a02:2f04:a014:8700::7fe)
2023-01-31 22:44:54 +0100 <cheater> curryer-rpc is recent, too
2023-01-31 22:45:05 +0100 <cheater> but they're both early in development which kinda sucks
2023-01-31 22:47:10 +0100 <cheater> https://hackage.haskell.org/package/msgpack-rpc-conduit-0.0.7/docs/Network-MessagePack-Server.html…
2023-01-31 22:47:11 +0100 <cheater> ....
2023-01-31 22:47:13 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-01-31 22:47:40 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 252 seconds)
2023-01-31 22:47:50 +0100 <cheater> i feel like i'm being punked
2023-01-31 22:49:41 +0100zeenk(~zeenk@2a02:2f04:a014:8700::7fe) (Quit: Konversation terminated!)
2023-01-31 22:50:00 +0100Lord_of_Life_Lord_of_Life
2023-01-31 22:51:39 +0100malte(~malte@mal.tc) (Remote host closed the connection)
2023-01-31 22:51:53 +0100zaquest(~notzaques@5.130.79.72) (Read error: Connection reset by peer)
2023-01-31 22:51:58 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Quit: Lost terminal)
2023-01-31 22:54:43 +0100freeside(~mengwong@103.252.202.170)
2023-01-31 22:58:12 +0100coot(~coot@213.134.171.3) (Quit: coot)
2023-01-31 22:58:43 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-31 22:59:02 +0100malte(~malte@mal.tc)
2023-01-31 23:01:05 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com)
2023-01-31 23:01:32 +0100 <hololeap> there is a Set.map, so why isn't there a Set.traverse?
2023-01-31 23:01:43 +0100zmt01(~zmt00@user/zmt00)
2023-01-31 23:04:55 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2023-01-31 23:05:11 +0100swamp_(~zmt00@user/zmt00) (Ping timeout: 255 seconds)
2023-01-31 23:09:49 +0100king_gs(~Thunderbi@2806:103e:29:34e5:ecc6:ec8d:1c5b:35a6) (Ping timeout: 252 seconds)
2023-01-31 23:14:34 +0100 <[Leary]> hololeap: Non-monotonic map/traverse are kinda pointless on Set. You might as well use `fmap S.fromList . traverse f . S.toList`. In fact, now that I look at the source, that's just how `S.map` is implemented.
2023-01-31 23:23:58 +0100[Leary](~Leary]@user/Leary/x-0910699) (Remote host closed the connection)
2023-01-31 23:24:31 +0100[Leary](~Leary]@user/Leary/x-0910699)
2023-01-31 23:26:49 +0100random-jellyfish(~random-je@user/random-jellyfish)
2023-01-31 23:30:01 +0100CiaoSen(~Jura@p200300c9573284002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-01-31 23:32:11 +0100akegalj(~akegalj@222-217.dsl.iskon.hr) (Quit: leaving)
2023-01-31 23:37:27 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-01-31 23:38:15 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow) (Ping timeout: 256 seconds)
2023-01-31 23:39:23 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow)
2023-01-31 23:40:23 +0100califax(~califax@user/califx) (Ping timeout: 255 seconds)
2023-01-31 23:42:11 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 255 seconds)
2023-01-31 23:42:11 +0100gmg(~user@user/gehmehgeh) (Ping timeout: 255 seconds)
2023-01-31 23:43:25 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-01-31 23:43:32 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 255 seconds)
2023-01-31 23:44:01 +0100CiaoSen(~Jura@p200300c9573284002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-01-31 23:44:12 +0100gmg(~user@user/gehmehgeh)
2023-01-31 23:44:21 +0100califax(~califax@user/califx)
2023-01-31 23:44:30 +0100michalz(~michalz@185.246.207.221) (Remote host closed the connection)
2023-01-31 23:44:33 +0100phma(~phma@host-67-44-208-33.hnremote.net) (Remote host closed the connection)
2023-01-31 23:44:43 +0100ec(~ec@gateway/tor-sasl/ec)
2023-01-31 23:45:00 +0100phma(~phma@host-67-44-208-33.hnremote.net)
2023-01-31 23:48:18 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-01-31 23:50:23 +0100 <hololeap> I think that makes sense
2023-01-31 23:53:52 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-31 23:59:36 +0100johnw(~johnw@2600:1700:cf00:db0:f0d6:3852:1ef5:be75) (Quit: ZNC - http://znc.in)