IRCBrowse

2021/09/28

2021-09-28 00:02:35 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2021-09-28 00:03:45 +0200 <janus> alzgh: what do you mean when you say 'ghc master is 8.10.7'? i thought the master would be the most unstable of all, so that should be something after 9.2.0-alpha1?
2021-09-28 00:03:52 +0200Robin_Jadoul(~Robin_Jad@152.67.64.160) (Remote host closed the connection)
2021-09-28 00:04:06 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Quit: Free ZNC ~ Powered by LunarBNC: https://LunarBNC.net)
2021-09-28 00:04:14 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-09-28 00:04:30 +0200 <geekosaur> just because 8.10.7 was most recently released does not nmake it master; in fact they hope they're done with the 8.10 branch
2021-09-28 00:04:34 +0200Robin_Jadoul(~Robin_Jad@152.67.64.160)
2021-09-28 00:04:37 +0200noctux(~noctux@user/noctux) (Read error: Connection reset by peer)
2021-09-28 00:04:45 +0200noctux(~noctux@user/noctux)
2021-09-28 00:04:56 +0200 <alzgh> janus: I may be wrong, I'm very new. Just had a very small experience with it.
2021-09-28 00:05:06 +0200bsima(~bsima@simatime.com) (Quit: ZNC 1.8.2 - https://znc.in)
2021-09-28 00:05:06 +0200Xnuk(~xnuk@45.76.202.58) (Quit: ZNC - https://znc.in)
2021-09-28 00:05:07 +0200drdo(~drdo@overlord0.drdo.eu) (Remote host closed the connection)
2021-09-28 00:05:08 +0200remedan(~remedan@balak.me) (Quit: Bye!)
2021-09-28 00:05:10 +0200 <geekosaur> precisely because it's so far behind and they want to work on cutting 9.2.1
2021-09-28 00:05:23 +0200Xnuk(~xnuk@45.76.202.58)
2021-09-28 00:05:27 +0200bsima(~bsima@simatime.com)
2021-09-28 00:05:35 +0200remedan(~remedan@balak.me)
2021-09-28 00:05:38 +0200edr(~edr@user/edr) (Ping timeout: 250 seconds)
2021-09-28 00:05:47 +0200s-h-i-n-o-b-i(~quassel@104.244.75.124) (Remote host closed the connection)
2021-09-28 00:05:57 +0200drdo(~drdo@overlord0.drdo.eu)
2021-09-28 00:06:41 +0200remexre(~nathan@user/remexre) (Ping timeout: 246 seconds)
2021-09-28 00:06:41 +0200finsternis(~X@23.226.237.192) (Ping timeout: 246 seconds)
2021-09-28 00:06:50 +0200edr(~edr@enlo.co)
2021-09-28 00:06:50 +0200edr(~edr@enlo.co) (Changing host)
2021-09-28 00:06:50 +0200edr(~edr@user/edr)
2021-09-28 00:07:10 +0200aegon(~mike@174.127.249.180)
2021-09-28 00:07:32 +0200remexre(~nathan@user/remexre)
2021-09-28 00:07:34 +0200finsternis(~X@23.226.237.192)
2021-09-28 00:10:26 +0200michalz(~michalz@185.246.204.55) (Remote host closed the connection)
2021-09-28 00:15:16 +0200max22-(~maxime@2a01cb0883359800761b1c69d9198b7f.ipv6.abo.wanadoo.fr) (Quit: Leaving)
2021-09-28 00:19:15 +0200hnOsmium0001(uid453710@id-453710.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-09-28 00:28:09 +0200geranim0(~geranim0@modemcable242.171-178-173.mc.videotron.ca) (Remote host closed the connection)
2021-09-28 00:30:40 +0200free_functor(~asdf@ip-64-72-99-234.lasvegas.net)
2021-09-28 00:30:49 +0200mestre(~mestre@191.177.175.57)
2021-09-28 00:31:21 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 245 seconds)
2021-09-28 00:33:17 +0200 <free_functor> hello all
2021-09-28 00:33:31 +0200 <free_functor> I want to refactor this code a bit: https://github.com/maxsu/vitrea/tree/master/source
2021-09-28 00:34:31 +0200 <free_functor> each file has the same 24 lines of LANGUAGE directives, and most files import all of the same standard modules
2021-09-28 00:35:51 +0200 <geekosaur> you can put common LANGUAGE pragmas in the cabal file, and make a single file that imports and re-exports the "standard" modules
2021-09-28 00:36:17 +0200 <geekosaur> module MyPrelude (module A, module B, ...) where import A; import B; ...
2021-09-28 00:36:32 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:75e5:da2f:c054:6c5d) (Remote host closed the connection)
2021-09-28 00:36:39 +0200 <free_functor> the cabal refactoring is very nice!
2021-09-28 00:36:45 +0200 <monochrom> I might keep the "redundant" language directives.
2021-09-28 00:37:37 +0200hnOsmium0001(uid453710@id-453710.hampstead.irccloud.com)
2021-09-28 00:37:54 +0200 <monochrom> "refactoring" should not mean "dropping contexts"
2021-09-28 00:38:02 +0200 <free_functor> could I cram the language directives into MyPrelude as well?
2021-09-28 00:38:47 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:75e5:da2f:c054:6c5d)
2021-09-28 00:38:50 +0200 <geekosaur> no, they can't be re-exported
2021-09-28 00:39:02 +0200nctcf^(~nctcf@68.101.50.106) (Remote host closed the connection)
2021-09-28 00:39:55 +0200 <monochrom> Moreover, there is no rule that says each extension must take up its own "{-# language X #-}" line.
2021-09-28 00:39:58 +0200 <geekosaur> one warning with making a module like MyPrelude is you can't use qualification any more, because everything would be qualified as MyPrelude.whatever in importing modules
2021-09-28 00:40:27 +0200Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de) (Ping timeout: 265 seconds)
2021-09-28 00:40:46 +0200 <monochrom> "{-# language GADTs, FlexibleContexts, TypeInType #-}" is a thing.
2021-09-28 00:41:06 +0200 <monochrom> That readily reduces 24 lines into 8 lines.
2021-09-28 00:41:35 +0200 <monochrom> can go further down to 6, even 4, depending on your comfortable screen width.
2021-09-28 00:41:58 +0200 <monochrom> I trust that you didn't rotate your monitor to a portrait mode.
2021-09-28 00:42:36 +0200xff0x(~xff0x@2001:1a81:5315:a700:248e:1ff5:c263:f618) (Ping timeout: 245 seconds)
2021-09-28 00:43:27 +0200cjb(~cjb@user/cjb)
2021-09-28 00:45:05 +0200xff0x(~xff0x@83.236.22.151)
2021-09-28 00:45:29 +0200eL_Bart0(eL_Bart0@dietunichtguten.org) (Ping timeout: 252 seconds)
2021-09-28 00:45:56 +0200 <free_functor> @geekosaur, here it is! https://cabal.readthedocs.io/en/3.4/cabal-package.html#pkg-field-default-extensions
2021-09-28 00:45:56 +0200 <lambdabot> Unknown command, try @list
2021-09-28 00:46:50 +0200 <free_functor> if I want to, as monocrome intimates, put all that context into the last place someone will look the first read through of the code, I would shuttle all those lines into the cabal file
2021-09-28 00:47:02 +0200eL_Bart0(eL_Bart0@dietunichtguten.org)
2021-09-28 00:47:16 +0200 <free_functor> and I might do just that. Because I am fundamentally an /evil/ functor.
2021-09-28 00:48:38 +0200 <monochrom> Sure, ideally, extensions may be better off sitting near the end of a file, not near the beginning.
2021-09-28 00:49:16 +0200chomwitt(~chomwitt@2a02:587:dc0a:5800:12c3:7bff:fe6d:d374) (Ping timeout: 252 seconds)
2021-09-28 00:50:41 +0200 <monochrom> I guess I can soften my position because in practice you just look at a line of code and you can guess which extensions it is using, you don't need reminders.
2021-09-28 00:51:10 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-09-28 00:51:12 +0200acidjnk_new3(~acidjnk@p200300d0c703cb83d5f3bf11d040064f.dip0.t-ipconnect.de)
2021-09-28 00:51:24 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-09-28 00:52:35 +0200 <monochrom> There used to be one single line {-# OPTION -fglasgow-exts #-}.
2021-09-28 00:52:55 +0200 <free_functor> Here the sheer consistency and reuse of extensions is somewhat suspicious and seems intentional, such that changing one extension line in one file without changing the corresponding lines in the other files would likely be a bug or at least go against the author's intent
2021-09-28 00:53:16 +0200 <free_functor> so ideally I would like to take that shared context and document it in one place... and ideally I would make a passing reference to this at the beggining of each file, so that readers won't forget that we're operating in a special context
2021-09-28 00:53:39 +0200 <monochrom> I agree with that.
2021-09-28 00:54:57 +0200acidjnk_new(~acidjnk@p200300d0c703cb837cfb9841cc066d33.dip0.t-ipconnect.de) (Ping timeout: 265 seconds)
2021-09-28 00:57:30 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-09-28 00:59:10 +0200Tuplanolla(~Tuplanoll@91-159-69-50.elisa-laajakaista.fi) (Quit: Leaving.)
2021-09-28 00:59:44 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net)
2021-09-28 01:01:17 +0200Null_A(~null_a@2601:645:8700:2290:91f2:4a69:be9c:a77e) (Remote host closed the connection)
2021-09-28 01:04:37 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net) (Ping timeout: 252 seconds)
2021-09-28 01:05:18 +0200yinghua(~yinghua@2800:2121:1400:1db:1c60:aa3c:8d:9122)
2021-09-28 01:07:51 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 01:08:49 +0200dextaa(~DV@user/dextaa) (Ping timeout: 265 seconds)
2021-09-28 01:09:17 +0200dextaa(~DV@user/dextaa)
2021-09-28 01:10:10 +0200hgolden(~hgolden2@cpe-172-114-81-123.socal.res.rr.com) (Remote host closed the connection)
2021-09-28 01:11:20 +0200xff0x(~xff0x@83.236.22.151) (Ping timeout: 252 seconds)
2021-09-28 01:11:51 +0200hgolden(~hgolden2@172.114.81.123)
2021-09-28 01:11:51 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Read error: Connection reset by peer)
2021-09-28 01:13:17 +0200xff0x(~xff0x@2001:1a81:533c:2c00:5093:30e6:359f:919)
2021-09-28 01:13:34 +0200 <free_functor> the common extensions were listed in the cabal file under the 'other-extensions' field. After I renamed this to the 'default-extensions' field, I was able to remove all extension declarations from the code
2021-09-28 01:14:26 +0200 <geekosaur> yeh, other-extensions is just documentation when you want to keep a record in one place
2021-09-28 01:14:38 +0200 <geekosaur> I think it may also be used by hackage for some things
2021-09-28 01:16:53 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-09-28 01:17:07 +0200 <free_functor> I like this solution from the perspective of a maintainer. It documents that the author really does want to use the same extensions for each file, and it controls the extensions from one place.
2021-09-28 01:18:54 +0200 <free_functor> but this sucks from a discoverability perspective - to read the code, a new maintainer must first closely read the cabal file.
2021-09-28 01:20:58 +0200 <geekosaur> my perspective is you need to read the cabal file to know what the code is anyway (what is what library, executable, etc.) so this is just one more thingt you get first
2021-09-28 01:21:23 +0200 <free_functor> I could compromise: In main.hs I can leave a comment that says "for extensions see the default-extensions field of the cabal file." That is a clue for the new reader, without being too anoying to someone that has to see the code.
2021-09-28 01:22:52 +0200 <free_functor> geekosaur, I think that might be the more mature perspective, and if we take that perspective then the "clue" comment is extraneous
2021-09-28 01:24:40 +0200 <free_functor> https://github.com/maxsu/vitrea/blob/master/source/Categories.hs so much cleaner :3
2021-09-28 01:25:49 +0200xsarnik(xsarnik@lounge.fi.muni.cz) (Quit: Ping timeout (120 seconds))
2021-09-28 01:26:30 +0200xsarnik(xsarnik@lounge.fi.muni.cz)
2021-09-28 01:26:45 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.3)
2021-09-28 01:28:51 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 245 seconds)
2021-09-28 01:30:57 +0200mrkajetanp(~mrkajetan@2a01:4b00:ea36:6c00:7994:941c:3f5d:2b88) (Ping timeout: 268 seconds)
2021-09-28 01:31:20 +0200mrkajetanp(~mrkajetan@88.98.245.28)
2021-09-28 01:31:23 +0200monadfritz[m](~ahdytmatr@2001:470:69fc:105::e1f1) (Ping timeout: 246 seconds)
2021-09-28 01:31:23 +0200stoicswe[m](~deadlette@2001:470:69fc:105::d277) (Ping timeout: 246 seconds)
2021-09-28 01:31:23 +0200jesser[m](~jessermat@2001:470:69fc:105::d5ae) (Ping timeout: 246 seconds)
2021-09-28 01:31:23 +0200kevin[m]1(~pnotequal@2001:470:69fc:105::a54) (Ping timeout: 246 seconds)
2021-09-28 01:31:23 +0200Christoph[m](~hpotsirhc@2001:470:69fc:105::2ff8) (Ping timeout: 246 seconds)
2021-09-28 01:31:23 +0200lwe[m](~dendrumat@2001:470:69fc:105::2f9b) (Ping timeout: 246 seconds)
2021-09-28 01:31:27 +0200sam[m]1(~sammtopoi@2001:470:69fc:105::e887) (Ping timeout: 250 seconds)
2021-09-28 01:31:27 +0200ormaaj(~ormaaj@user/ormaaj) (Ping timeout: 250 seconds)
2021-09-28 01:31:34 +0200afotgkmnzj7asv3r(~afotgkmnz@2001:470:69fc:105::c24b) (Ping timeout: 268 seconds)
2021-09-28 01:31:34 +0200sm(~sm@plaintextaccounting/sm) (Ping timeout: 268 seconds)
2021-09-28 01:31:44 +0200fendor[m](~fendormat@2001:470:69fc:105::fcbd) (Ping timeout: 246 seconds)
2021-09-28 01:31:44 +0200smichel17[m](~smichel17@2001:470:69fc:105::2d32) (Ping timeout: 246 seconds)
2021-09-28 01:31:44 +0200ongy[m](~ongymatri@2001:470:69fc:105::5018) (Ping timeout: 246 seconds)
2021-09-28 01:31:53 +0200craige[m](~craigemcw@2001:470:69fc:105::35f1) (Ping timeout: 250 seconds)
2021-09-28 01:31:53 +0200alexfmpe[m](~alexfmpem@2001:470:69fc:105::38ba) (Ping timeout: 250 seconds)
2021-09-28 01:31:53 +0200hsek[m](~hsekmatri@2001:470:69fc:105::d18f) (Ping timeout: 250 seconds)
2021-09-28 01:31:53 +0200Deide(~deide@user/deide) (Ping timeout: 250 seconds)
2021-09-28 01:31:53 +0200ixlun(~ixlun@2001:470:69fc:105::41b3) (Ping timeout: 250 seconds)
2021-09-28 01:31:53 +0200dexmad[m](~dexmadmat@2001:470:69fc:105::e056) (Ping timeout: 264 seconds)
2021-09-28 01:31:53 +0200fakehacker[m](~fakehacke@2001:470:69fc:105::b5f0) (Ping timeout: 264 seconds)
2021-09-28 01:31:53 +0200justosophy[m](~justosoph@2001:470:69fc:105::572f) (Ping timeout: 264 seconds)
2021-09-28 01:31:54 +0200jakefromstatefar(~jakefroms@2001:470:69fc:105::15ef) (Ping timeout: 264 seconds)
2021-09-28 01:31:54 +0200the-coot[m](~the-cootm@2001:470:69fc:105::95f) (Ping timeout: 264 seconds)
2021-09-28 01:31:54 +0200rednaZ[m](~r3dnazmat@2001:470:69fc:105::ba70) (Ping timeout: 264 seconds)
2021-09-28 01:32:05 +0200Orbstheorem(~orbstheor@2001:470:69fc:105::a56) (Ping timeout: 246 seconds)
2021-09-28 01:32:05 +0200Drew[m](~drewefenw@2001:470:69fc:105::c8c4) (Ping timeout: 246 seconds)
2021-09-28 01:32:05 +0200Tisoxin(~ikosit@user/ikosit) (Ping timeout: 246 seconds)
2021-09-28 01:32:05 +0200cdsmith(~cdsmithma@2001:470:69fc:105::284) (Ping timeout: 246 seconds)
2021-09-28 01:32:11 +0200IgnatInsarov[m](~kindaroma@2001:470:69fc:105::f5d9) (Ping timeout: 268 seconds)
2021-09-28 01:32:11 +0200asdofindia-m(~akshaymat@2001:470:69fc:105::831) (Ping timeout: 268 seconds)
2021-09-28 01:32:11 +0200hughjfchen[m](~hughjfche@2001:470:69fc:105::c29d) (Ping timeout: 268 seconds)
2021-09-28 01:32:11 +0200jneira[m](~jneiramat@2001:470:69fc:105::d729) (Ping timeout: 268 seconds)
2021-09-28 01:32:12 +0200unrooted(~unrooted@2001:470:69fc:105::a4a) (Ping timeout: 268 seconds)
2021-09-28 01:32:12 +0200ServerStatsDisco(~serversta@2001:470:69fc:105::1a) (Ping timeout: 268 seconds)
2021-09-28 01:32:18 +0200rosariopulella[m(~rosariopu@2001:470:69fc:105::a57) (Ping timeout: 250 seconds)
2021-09-28 01:32:18 +0200infinisil(~infinisil@2001:470:69fc:105::ff8) (Ping timeout: 250 seconds)
2021-09-28 01:32:29 +0200reddishblue[m](~reddishbl@2001:470:69fc:105::21eb) (Ping timeout: 264 seconds)
2021-09-28 01:32:46 +0200 <alzgh> I'm trying to compile ghc. I have setup a Fedora34 container and installed all the required packages as requested. I get this error when I run `.configure`. https://paste.tomsmeding.com/mbxAJtXX
2021-09-28 01:32:59 +0200 <alzgh> Can provide further information if needed.
2021-09-28 01:33:34 +0200 <monochrom> Perhaps you need the Fedora package that has diff.
2021-09-28 01:34:12 +0200 <monochrom> Most container images sacrifice completeness for smaller download size.
2021-09-28 01:35:40 +0200monadfritz[m](~ahdytmatr@2001:470:69fc:105::e1f1)
2021-09-28 01:35:48 +0200jesser[m](~jessermat@2001:470:69fc:105::d5ae)
2021-09-28 01:36:05 +0200 <alzgh> Ok, thanks monochrom will check that
2021-09-28 01:36:11 +0200stoicswe[m](~deadlette@2001:470:69fc:105::d277)
2021-09-28 01:38:04 +0200pbrisbin(~patrick@pool-173-49-147-250.phlapa.fios.verizon.net)
2021-09-28 01:40:22 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-28 01:42:15 +0200Guest1344(~chris@81.96.113.213) (Remote host closed the connection)
2021-09-28 01:42:37 +0200fakehacker[m](~fakehacke@2001:470:69fc:105::b5f0)
2021-09-28 01:42:48 +0200smichel17[m](~smichel17@2001:470:69fc:105::2d32)
2021-09-28 01:48:28 +0200craige[m](~craigemcw@2001:470:69fc:105::35f1)
2021-09-28 01:49:43 +0200chris(~chris@81.96.113.213)
2021-09-28 01:49:47 +0200chrisGuest9694
2021-09-28 01:49:57 +0200ixlun(~ixlun@2001:470:69fc:105::41b3)
2021-09-28 01:49:57 +0200alexfmpe[m](~alexfmpem@2001:470:69fc:105::38ba)
2021-09-28 01:50:56 +0200acidjnk_new3(~acidjnk@p200300d0c703cb83d5f3bf11d040064f.dip0.t-ipconnect.de) (Ping timeout: 250 seconds)
2021-09-28 01:51:15 +0200Orbstheorem(~orbstheor@2001:470:69fc:105::a56)
2021-09-28 01:52:02 +0200kevin[m]1(~pnotequal@2001:470:69fc:105::a54)
2021-09-28 01:53:25 +0200Guest9694(~chris@81.96.113.213) (Remote host closed the connection)
2021-09-28 01:53:34 +0200afotgkmnzj7asv3r(~afotgkmnz@2001:470:69fc:105::c24b)
2021-09-28 01:54:28 +0200chris(~chris@81.96.113.213)
2021-09-28 01:54:32 +0200chrisGuest8820
2021-09-28 01:55:23 +0200hexfive(~eric@50.35.83.177)
2021-09-28 01:55:24 +0200ServerStatsDisco(~serversta@2001:470:69fc:105::1a)
2021-09-28 01:57:13 +0200jakefromstatefar(~jakefroms@2001:470:69fc:105::15ef)
2021-09-28 01:57:48 +0200reddishblue[m](~reddishbl@2001:470:69fc:105::21eb)
2021-09-28 01:58:12 +0200hexfive(~eric@50.35.83.177) (Client Quit)
2021-09-28 01:58:36 +0200justosophy[m](~justosoph@2001:470:69fc:105::572f)
2021-09-28 01:58:47 +0200Christoph[m](~hpotsirhc@2001:470:69fc:105::2ff8)
2021-09-28 01:58:54 +0200sm(~sm@plaintextaccounting/sm)
2021-09-28 02:00:09 +0200sam[m]1(~sammtopoi@2001:470:69fc:105::e887)
2021-09-28 02:00:54 +0200unrooted(~unrooted@2001:470:69fc:105::a4a)
2021-09-28 02:02:12 +0200asdofindia-m(~akshaymat@2001:470:69fc:105::831)
2021-09-28 02:02:17 +0200lwe[m](~dendrumat@2001:470:69fc:105::2f9b)
2021-09-28 02:02:42 +0200the-coot[m](~the-cootm@2001:470:69fc:105::95f)
2021-09-28 02:03:50 +0200dexmad[m](~dexmadmat@2001:470:69fc:105::e056)
2021-09-28 02:04:14 +0200Deide(~deide@user/deide)
2021-09-28 02:04:16 +0200ongy[m](~ongymatri@2001:470:69fc:105::5018)
2021-09-28 02:04:27 +0200fendor[m](~fendormat@2001:470:69fc:105::fcbd)
2021-09-28 02:04:34 +0200hughjfchen[m](~hughjfche@2001:470:69fc:105::c29d)
2021-09-28 02:05:31 +0200jneira[m](~jneiramat@2001:470:69fc:105::d729)
2021-09-28 02:05:31 +0200infinisil(~infinisil@2001:470:69fc:105::ff8)
2021-09-28 02:06:55 +0200rosariopulella[m(~rosariopu@2001:470:69fc:105::a57)
2021-09-28 02:07:00 +0200Drew[m](~drewefenw@2001:470:69fc:105::c8c4)
2021-09-28 02:07:14 +0200cdsmith(~cdsmithma@2001:470:69fc:105::284)
2021-09-28 02:07:32 +0200Tisoxin(~ikosit@user/ikosit)
2021-09-28 02:08:31 +0200 <alzgh> Yo, I'm building GHC in a Fedora container and it's woorking.
2021-09-28 02:08:32 +0200rednaZ[m](~r3dnazmat@2001:470:69fc:105::ba70)
2021-09-28 02:08:36 +0200ormaaj(~ormaaj@user/ormaaj)
2021-09-28 02:08:37 +0200IgnatInsarov[m](~kindaroma@2001:470:69fc:105::f5d9)
2021-09-28 02:08:57 +0200 <monochrom> congrats
2021-09-28 02:09:19 +0200 <monochrom> "Not sure what to congrat for, but congrats" >:)
2021-09-28 02:10:52 +0200 <alzgh> :D
2021-09-28 02:10:52 +0200alzgh(~alzgh@user/alzgh) (Remote host closed the connection)
2021-09-28 02:11:03 +0200alzgh(~alzgh@user/alzgh)
2021-09-28 02:12:11 +0200nfd(~nfd@user/nfd) (Ping timeout: 245 seconds)
2021-09-28 02:12:38 +0200nabaiste^(~nabaiste@68.101.50.106)
2021-09-28 02:15:12 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-28 02:15:12 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-28 02:15:12 +0200wroathe(~wroathe@user/wroathe)
2021-09-28 02:27:06 +0200lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-09-28 02:27:42 +0200lavaman(~lavaman@98.38.249.169)
2021-09-28 02:30:28 +0200tommd(~tommd@75-164-130-101.ptld.qwest.net) (Ping timeout: 252 seconds)
2021-09-28 02:32:11 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 245 seconds)
2021-09-28 02:33:56 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2021-09-28 02:37:29 +0200lavaman(~lavaman@98.38.249.169)
2021-09-28 02:41:31 +0200mestre(~mestre@191.177.175.57) (Quit: Lost terminal)
2021-09-28 02:49:42 +0200tremon(~tremon@217-63-61-89.cable.dynamic.v4.ziggo.nl) (Quit: getting boxed in)
2021-09-28 02:55:45 +0200lbseale(~lbseale@user/ep1ctetus) (Read error: Connection reset by peer)
2021-09-28 02:56:51 +0200Null_A(~null_a@2601:645:8700:2290:91f2:4a69:be9c:a77e)
2021-09-28 02:57:22 +0200pbrisbin(~patrick@pool-173-49-147-250.phlapa.fios.verizon.net) (Ping timeout: 252 seconds)
2021-09-28 03:01:49 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net)
2021-09-28 03:05:56 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net) (Ping timeout: 245 seconds)
2021-09-28 03:07:35 +0200Null_A(~null_a@2601:645:8700:2290:91f2:4a69:be9c:a77e) (Remote host closed the connection)
2021-09-28 03:10:32 +0200 <alzgh> managed to compile ghc with a looot of warnings at the end though
2021-09-28 03:10:43 +0200 <alzgh> didn't even check if it worked at the end
2021-09-28 03:10:51 +0200 <alzgh> gotta go sleep
2021-09-28 03:10:55 +0200 <alzgh> good night
2021-09-28 03:11:03 +0200alzgh(~alzgh@user/alzgh) (Remote host closed the connection)
2021-09-28 03:12:04 +0200jespada(~jespada@2803:9800:9842:7a62:8558:368:788c:6dc6) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-09-28 03:13:31 +0200Robin_Jadoul(~Robin_Jad@152.67.64.160) (Ping timeout: 265 seconds)
2021-09-28 03:14:17 +0200Null_A(~null_a@2601:645:8700:2290:91f2:4a69:be9c:a77e)
2021-09-28 03:18:38 +0200emf(~emf@2620:10d:c090:400::5:92d0) (Ping timeout: 260 seconds)
2021-09-28 03:22:36 +0200xff0x(~xff0x@2001:1a81:533c:2c00:5093:30e6:359f:919) (Ping timeout: 245 seconds)
2021-09-28 03:24:29 +0200xff0x(~xff0x@2001:1a81:534d:3900:44bc:177a:6fca:f4ca)
2021-09-28 03:25:16 +0200waleee(~waleee@h-98-128-228-119.NA.cust.bahnhof.se) (Ping timeout: 265 seconds)
2021-09-28 03:26:30 +0200Null_A(~null_a@2601:645:8700:2290:91f2:4a69:be9c:a77e) (Remote host closed the connection)
2021-09-28 03:26:49 +0200Null_A(~null_a@2601:645:8700:2290:91f2:4a69:be9c:a77e)
2021-09-28 03:30:06 +0200juhp(~juhp@118.200.109.69) (Ping timeout: 245 seconds)
2021-09-28 03:37:27 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 03:38:51 +0200yinghua(~yinghua@2800:2121:1400:1db:1c60:aa3c:8d:9122) (Quit: Leaving)
2021-09-28 03:40:20 +0200_xor(~xor@74.215.232.67) (Quit: brb, rebooting)
2021-09-28 03:49:18 +0200retroid_(~retro@176.255.22.194) (Quit: Connection error?!)
2021-09-28 03:49:41 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-09-28 03:55:00 +0200Everything(~Everythin@37.115.210.35)
2021-09-28 04:06:14 +0200Null_A(~null_a@2601:645:8700:2290:91f2:4a69:be9c:a77e) (Remote host closed the connection)
2021-09-28 04:11:11 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-28 04:15:43 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net)
2021-09-28 04:19:59 +0200alx741(~alx741@186.178.109.237) (Quit: alx741)
2021-09-28 04:20:34 +0200iqubic`(~user@2601:602:9502:c70:4c2b:3e65:2528:a4da)
2021-09-28 04:20:39 +0200iqubic`(~user@2601:602:9502:c70:4c2b:3e65:2528:a4da) (Remote host closed the connection)
2021-09-28 04:24:17 +0200justsomeguy(~justsomeg@user/justsomeguy)
2021-09-28 04:24:51 +0200Null_A(~null_a@2601:645:8700:2290:91f2:4a69:be9c:a77e)
2021-09-28 04:25:17 +0200iqubic(~user@2601:602:9502:c70:f7dd:50c9:a1b6:901a) (Ping timeout: 264 seconds)
2021-09-28 04:28:51 +0200Null_A(~null_a@2601:645:8700:2290:91f2:4a69:be9c:a77e) (Ping timeout: 245 seconds)
2021-09-28 04:31:20 +0200juhp(~juhp@128.106.188.220)
2021-09-28 04:31:40 +0200juhp(~juhp@128.106.188.220) (Remote host closed the connection)
2021-09-28 04:31:53 +0200juhp(~juhp@128.106.188.220)
2021-09-28 04:32:00 +0200_xor(~xor@74.215.232.67)
2021-09-28 04:39:04 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 265 seconds)
2021-09-28 04:39:36 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-09-28 04:40:57 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2021-09-28 04:42:36 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Ping timeout: 265 seconds)
2021-09-28 04:46:08 +0200juhp(~juhp@128.106.188.220) (Quit: juhp)
2021-09-28 04:46:22 +0200juhp(~juhp@128.106.188.220)
2021-09-28 04:46:34 +0200juhp(~juhp@128.106.188.220) (Read error: Connection reset by peer)
2021-09-28 04:46:47 +0200juhp(~juhp@128.106.188.220)
2021-09-28 04:49:51 +0200terrorjack(~terrorjac@2a05:d012:f4:f400:3981:7d7e:56ee:2dd9) (Ping timeout: 265 seconds)
2021-09-28 05:00:37 +0200juhp(~juhp@128.106.188.220) (Read error: Connection reset by peer)
2021-09-28 05:00:45 +0200juhp(~juhp@128.106.188.220)
2021-09-28 05:12:26 +0200vysn(~vysn@user/vysn)
2021-09-28 05:18:17 +0200ec(~ec@gateway/tor-sasl/ec)
2021-09-28 05:19:23 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net) (Ping timeout: 252 seconds)
2021-09-28 05:26:34 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer)
2021-09-28 05:28:10 +0200theproffesor(~theproffe@2601:282:847f:8010::7704)
2021-09-28 05:28:10 +0200theproffesor(~theproffe@2601:282:847f:8010::7704) (Changing host)
2021-09-28 05:28:10 +0200theproffesor(~theproffe@user/theproffesor)
2021-09-28 05:38:14 +0200td_(~td@muedsl-82-207-238-070.citykom.de)
2021-09-28 05:39:11 +0200segfaultfizzbuzz(~segfaultf@135-180-0-138.static.sonic.net) (Ping timeout: 252 seconds)
2021-09-28 05:44:37 +0200hendursaga(~weechat@user/hendursaga) (Remote host closed the connection)
2021-09-28 05:45:02 +0200hendursaga(~weechat@user/hendursaga)
2021-09-28 06:00:41 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net)
2021-09-28 06:05:35 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net) (Ping timeout: 252 seconds)
2021-09-28 06:08:50 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 06:09:03 +0200falafel(~falafel@2603-8000-d800-688c-d1df-4118-0ede-09f0.res6.spectrum.com)
2021-09-28 06:09:40 +0200aegon(~mike@174.127.249.180) (Remote host closed the connection)
2021-09-28 06:17:47 +0200slowButPresent(~slowButPr@user/slowbutpresent) (Quit: leaving)
2021-09-28 06:20:38 +0200fjmorazan(~quassel@user/fjmorazan) (Ping timeout: 260 seconds)
2021-09-28 06:20:56 +0200fjmorazan(~quassel@user/fjmorazan)
2021-09-28 06:32:53 +0200falafel_(~falafel@2603-8000-d800-688c-d1df-4118-0ede-09f0.res6.spectrum.com)
2021-09-28 06:34:41 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Ping timeout: 245 seconds)
2021-09-28 06:35:42 +0200lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-09-28 06:35:56 +0200falafel(~falafel@2603-8000-d800-688c-d1df-4118-0ede-09f0.res6.spectrum.com) (Ping timeout: 245 seconds)
2021-09-28 06:36:14 +0200lavaman(~lavaman@98.38.249.169)
2021-09-28 06:39:20 +0200lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-09-28 06:39:32 +0200lavaman(~lavaman@98.38.249.169)
2021-09-28 06:39:36 +0200lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-09-28 06:40:08 +0200darkstardevx(~darkstard@2601:1c2:300:c8a0::f2b6)
2021-09-28 06:40:10 +0200lavaman(~lavaman@98.38.249.169)
2021-09-28 06:42:11 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-09-28 06:44:16 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 245 seconds)
2021-09-28 06:45:32 +0200_ht(~quassel@82-169-194-8.biz.kpn.net)
2021-09-28 06:53:24 +0200justsomeguy(~justsomeg@user/justsomeguy) (Quit: WeeChat 3.2)
2021-09-28 06:54:09 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-09-28 06:54:52 +0200monochrom(trebla@216.138.220.146) (Quit: NO CARRIER)
2021-09-28 06:56:06 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-09-28 06:56:08 +0200nabaiste^(~nabaiste@68.101.50.106) (Remote host closed the connection)
2021-09-28 06:56:14 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-09-28 06:58:51 +0200monochrom(trebla@216.138.220.146)
2021-09-28 07:20:03 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net)
2021-09-28 07:22:45 +0200ridcully_(~ridcully@p57b523cc.dip0.t-ipconnect.de) (Quit: update)
2021-09-28 07:23:27 +0200ridcully(~ridcully@p57b523cc.dip0.t-ipconnect.de)
2021-09-28 07:24:16 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net) (Ping timeout: 245 seconds)
2021-09-28 07:31:51 +0200qbt(~edun@user/edun)
2021-09-28 07:38:59 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2021-09-28 07:41:56 +0200peterhil(~peterhil@dsl-hkibng32-54fb52-57.dhcp.inet.fi)
2021-09-28 07:46:57 +0200lavaman(~lavaman@98.38.249.169)
2021-09-28 07:48:37 +0200retroid_(~retro@176.255.22.194)
2021-09-28 07:51:11 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 252 seconds)
2021-09-28 07:52:33 +0200Pseudonym(~Pseudonym@118.211.105.253)
2021-09-28 07:57:36 +0200falafel_(~falafel@2603-8000-d800-688c-d1df-4118-0ede-09f0.res6.spectrum.com) (Ping timeout: 245 seconds)
2021-09-28 08:01:32 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-09-28 08:07:47 +0200cjb(~cjb@user/cjb) ()
2021-09-28 08:08:07 +0200ubert(~Thunderbi@77.119.219.178.wireless.dyn.drei.com)
2021-09-28 08:08:19 +0200michalz(~michalz@185.246.204.58)
2021-09-28 08:08:25 +0200Guest8820(~chris@81.96.113.213) (Remote host closed the connection)
2021-09-28 08:08:43 +0200xff0x(~xff0x@2001:1a81:534d:3900:44bc:177a:6fca:f4ca) (Ping timeout: 252 seconds)
2021-09-28 08:09:41 +0200xff0x(~xff0x@2001:1a81:534d:3900:6377:c16b:fb27:9326)
2021-09-28 08:10:13 +0200jakalx(~jakalx@base.jakalx.net) ()
2021-09-28 08:18:58 +0200chomwitt(~chomwitt@2a02:587:dc0a:5800:12c3:7bff:fe6d:d374)
2021-09-28 08:25:10 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2021-09-28 08:28:55 +0200jakalx(~jakalx@base.jakalx.net)
2021-09-28 08:30:40 +0200brainfreeze(~brainfree@2a03:1b20:4:f011::20d) (Quit: Leaving)
2021-09-28 08:30:42 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:5b7d:5292:5e11:8e47)
2021-09-28 08:32:02 +0200lavaman(~lavaman@98.38.249.169)
2021-09-28 08:36:21 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 245 seconds)
2021-09-28 08:38:30 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 08:38:58 +0200xff0x(~xff0x@2001:1a81:534d:3900:6377:c16b:fb27:9326) (Ping timeout: 252 seconds)
2021-09-28 08:39:52 +0200xff0x(~xff0x@2001:1a81:534d:3900:325e:28e:425a:62e0)
2021-09-28 08:40:08 +0200chris(~chris@81.96.113.213)
2021-09-28 08:40:11 +0200chrisGuest5661
2021-09-28 08:44:32 +0200Guest5661(~chris@81.96.113.213) (Ping timeout: 252 seconds)
2021-09-28 08:44:41 +0200ubert1(~Thunderbi@77.119.219.178.wireless.dyn.drei.com)
2021-09-28 08:45:17 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-09-28 08:45:56 +0200shriekingnoise(~shrieking@186.137.144.80) (Quit: Quit)
2021-09-28 08:46:37 +0200ubert(~Thunderbi@77.119.219.178.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-28 08:46:37 +0200ubert1ubert
2021-09-28 08:53:47 +0200chomwitt(~chomwitt@2a02:587:dc0a:5800:12c3:7bff:fe6d:d374) (Remote host closed the connection)
2021-09-28 08:54:35 +0200echoreply(~echoreply@2001:19f0:9002:1f3b:5400:ff:fe6f:8b8d) (Quit: WeeChat 2.8)
2021-09-28 08:55:06 +0200echoreply(~echoreply@45.32.163.16)
2021-09-28 08:57:18 +0200 <Hecate> morning Haskell
2021-09-28 08:58:06 +0200chele(~chele@user/chele)
2021-09-28 09:09:21 +0200dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be)
2021-09-28 09:11:34 +0200alzgh(~alzgh@user/alzgh)
2021-09-28 09:13:01 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-28 09:13:16 +0200_ht(~quassel@82-169-194-8.biz.kpn.net) (Remote host closed the connection)
2021-09-28 09:17:45 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-09-28 09:27:25 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-09-28 09:30:42 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 09:32:55 +0200fef(~thedawn@user/thedawn)
2021-09-28 09:34:47 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:75e5:da2f:c054:6c5d) (Remote host closed the connection)
2021-09-28 09:35:53 +0200norskalm(~norskalm@101.175.64.73)
2021-09-28 09:36:22 +0200Everything(~Everythin@37.115.210.35) (Quit: leaving)
2021-09-28 09:37:49 +0200vysn(~vysn@user/vysn) (Ping timeout: 252 seconds)
2021-09-28 09:37:54 +0200pavonia(~user@user/siracusa) (Quit: Bye!)
2021-09-28 09:40:18 +0200 <tomsmeding> mrianbloom: assuming you haven't found a solution yet: as far as I know Accelerate doesn't have a "top-level" filter function as you say, but one could relatively easily implement one analogous to the implementation of "filter" itself :)
2021-09-28 09:40:25 +0200max22-(~maxime@2a01cb0883359800761b1c69d9198b7f.ipv6.abo.wanadoo.fr)
2021-09-28 09:41:26 +0200acidjnk_new3(~acidjnk@p200300d0c703cb49f045ad1a041448f2.dip0.t-ipconnect.de)
2021-09-28 09:45:56 +0200neurocyte0132(~neurocyte@user/neurocyte) (Quit: The Lounge - https://thelounge.chat)
2021-09-28 09:47:44 +0200kuribas(~user@ptr-25vy0i9jx2ordo6ztok.18120a2.ip6.access.telenet.be)
2021-09-28 09:52:25 +0200neurocyte0132(~neurocyte@user/neurocyte)
2021-09-28 09:52:29 +0200ub(~Thunderbi@77.119.219.178.wireless.dyn.drei.com)
2021-09-28 09:52:36 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 245 seconds)
2021-09-28 09:53:40 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:48d7:e5a9:dcd4:1044)
2021-09-28 09:57:50 +0200Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de)
2021-09-28 09:58:01 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:48d7:e5a9:dcd4:1044) (Ping timeout: 245 seconds)
2021-09-28 10:01:43 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2021-09-28 10:02:08 +0200 <kuribas> With RIO, you're supposed to always use exceptions, never Either/ExceptT?
2021-09-28 10:02:18 +0200 <kuribas> Doesn't that negate the advantages of Either, namely visibility of errors, and enforcing handling them?
2021-09-28 10:03:07 +0200 <Franciman> yes
2021-09-28 10:03:32 +0200 <Franciman> fpcomplete is known for writing dumbass software
2021-09-28 10:03:44 +0200ub(~Thunderbi@77.119.219.178.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-28 10:03:45 +0200 <Franciman> that may be very useful occasionally
2021-09-28 10:04:39 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:a04c:1131:d9f9:a052)
2021-09-28 10:05:03 +0200 <Franciman> as you read from their readme, it is intended as a cross between:
2021-09-28 10:05:05 +0200 <Franciman> Collection of well designed, trusted libraries
2021-09-28 10:05:07 +0200 <Franciman> Useful Prelude replacement
2021-09-28 10:05:09 +0200 <Franciman> A set of best practices for writing production quality Haskell code
2021-09-28 10:05:17 +0200 <Franciman> it seems that at fpcomplete using exceptions is considered better than using Either/ExceptT
2021-09-28 10:05:20 +0200 <Franciman> maybe it is faster?
2021-09-28 10:05:36 +0200 <kuribas> I don't think so.
2021-09-28 10:05:43 +0200 <kuribas> It's less complex.
2021-09-28 10:06:03 +0200 <Franciman> Either/ExceptT is less complex, you mean?
2021-09-28 10:06:25 +0200 <kuribas> No Exceptions are. But IMO, the complexity is the benefit, it requires you to think about when and how to handle errors.
2021-09-28 10:06:41 +0200 <kuribas> As opposed to just catching it at some toplevel.
2021-09-28 10:06:43 +0200 <Franciman> well do notation helps quite a bit reducing the complexity, imho
2021-09-28 10:06:43 +0200 <kuribas> Or not at all :)
2021-09-28 10:06:45 +0200eggplant_(~Eggplanta@2600:1700:bef1:5e10:45b4:2298:3c2b:6589)
2021-09-28 10:07:41 +0200 <kuribas> Or maybe RIO is a way to onboard imperative developers into haskell?
2021-09-28 10:07:53 +0200 <Franciman> The goal of the rio library is to make it easier to adopt Haskell for writing production software.
2021-09-28 10:07:57 +0200 <Franciman> (from the readme)
2021-09-28 10:07:59 +0200 <Franciman> possibly
2021-09-28 10:08:06 +0200 <kuribas> yeah
2021-09-28 10:08:46 +0200raym(~raym@user/raym)
2021-09-28 10:08:51 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:a04c:1131:d9f9:a052) (Ping timeout: 245 seconds)
2021-09-28 10:10:56 +0200eggplant_(~Eggplanta@2600:1700:bef1:5e10:45b4:2298:3c2b:6589) (Ping timeout: 245 seconds)
2021-09-28 10:16:37 +0200tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2021-09-28 10:17:17 +0200cfricke(~cfricke@user/cfricke)
2021-09-28 10:17:17 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2021-09-28 10:19:16 +0200hnOsmium0001(uid453710@id-453710.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-09-28 10:21:26 +0200econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2021-09-28 10:24:11 +0200Heisen(~Heisen@77.240.67.20)
2021-09-28 10:26:00 +0200 <kuribas> For that purpose it's fine.
2021-09-28 10:26:28 +0200 <dminuoso> 10:09:30 kuribas | [08:02:08] With RIO, you're supposed to always use exceptions, never Either/ExceptT?
2021-09-28 10:26:34 +0200 <dminuoso> No, you can use Either/ExceptT just fine.
2021-09-28 10:27:02 +0200 <dminuoso> It's rather with RIO you can't use non ReaderT/Identity based transformers globally.
2021-09-28 10:27:32 +0200 <dminuoso> A lot of my programs are written in something isomorphic to RIO, and I use MaybeT locally a lot.
2021-09-28 10:27:33 +0200 <kuribas> so ExceptT err (RIO r) a ?
2021-09-28 10:27:35 +0200nfd(~nfd@user/nfd)
2021-09-28 10:27:45 +0200 <dminuoso> Sure, as a local effect this is fine.
2021-09-28 10:28:03 +0200 <kuribas> or RIO r (Either err a), then use ExceptT to plumb stuff together?
2021-09-28 10:28:16 +0200 <kuribas> Which is actually what I do know, but without RIO.
2021-09-28 10:28:56 +0200 <kuribas> in fact just "localState -> IO a"
2021-09-28 10:29:27 +0200 <maerwald> why use RIO at all, just roll your own
2021-09-28 10:29:49 +0200 <kuribas> maerwald: to have an easy to use library for newcommers?
2021-09-28 10:29:50 +0200 <maerwald> mtl MonadReader + labeloptics + ExceptT
2021-09-28 10:30:07 +0200 <maerwald> kuribas: but is that INDUSTRY-grade?
2021-09-28 10:30:17 +0200 <dminuoso> I always roll my own stack, it's usually some `newtype AppM a = AppM { runApp :: LoggingT (ReaderT Env IO) a }`
2021-09-28 10:30:36 +0200 <kuribas> maerwald: I think it's all the same, just a different jacket.
2021-09-28 10:30:37 +0200 <maerwald> oh, i never use a newtyped monad
2021-09-28 10:30:55 +0200 <dminuoso> With GND its wonderful.
2021-09-28 10:31:08 +0200 <kuribas> maerwald: I *always* use a newtype monad. It saves me from writing the plumbing.
2021-09-28 10:31:25 +0200 <maerwald> what plumbing
2021-09-28 10:31:26 +0200Heisen(~Heisen@77.240.67.20) (Quit: Client closed)
2021-09-28 10:31:36 +0200 <kuribas> the monad/applicative instances
2021-09-28 10:31:42 +0200 <maerwald> odd, I don't write any
2021-09-28 10:31:58 +0200 <dminuoso> maerwald: I just use a newtype for guaranteed better diagnostics.
2021-09-28 10:32:18 +0200terrorjack(~terrorjac@2a05:d012:f4:f400:3981:7d7e:56ee:2dd9)
2021-09-28 10:32:21 +0200 <kuribas> a newtype gives a nice level of abstraction.
2021-09-28 10:32:28 +0200 <dminuoso> Sometimes GHC is being silly and expands type aliases when it doesnt help, and doesnt expand then when it would help..
2021-09-28 10:32:45 +0200 <maerwald> it hides the details, I want to see the details, because transformers are a poor abstraction, I'd rather see them
2021-09-28 10:32:58 +0200 <dminuoso> With ReaderT/LoggingT in my mind it's always essentially IO.
2021-09-28 10:33:05 +0200 <dminuoso> So their abstraction is almost weightless.
2021-09-28 10:36:57 +0200 <kuribas> dminuoso: can't you put the logging inside the r?
2021-09-28 10:37:05 +0200 <kuribas> Env in your case?
2021-09-28 10:37:23 +0200 <kuribas> as a callback
2021-09-28 10:37:48 +0200 <maerwald> I do logging via IO and labeloptics
2021-09-28 10:37:57 +0200Pseudonym(~Pseudonym@118.211.105.253) (Quit: Going offline, see ya! (www.adiirc.com))
2021-09-28 10:38:03 +0200 <maerwald> hooking into the MonadReader env
2021-09-28 10:38:05 +0200 <kuribas> what does labeloptics have to do with logging?
2021-09-28 10:38:19 +0200 <kuribas> right, that's what I mean.
2021-09-28 10:38:21 +0200 <maerwald> you can run it over MonadReader and IO
2021-09-28 10:38:50 +0200 <maerwald> your logging config is in the monadreader, you access it via labeloptics and the actual logging is just plain IO
2021-09-28 10:38:54 +0200 <maerwald> it's like 30 lines of code
2021-09-28 10:39:02 +0200 <maerwald> instead of an entire library
2021-09-28 10:40:09 +0200 <kuribas> yeah
2021-09-28 10:40:44 +0200 <dminuoso> kuribas: Sure I could, but I like being lazy and monad-logger gets the job done.
2021-09-28 10:40:56 +0200 <maerwald> and pulls in conduit and 20 other libs
2021-09-28 10:41:10 +0200 <dminuoso> Havent had the time to massage monad-logger into what I want, and the interface is acceptable to me.
2021-09-28 10:41:24 +0200 <dminuoso> Also most of its dependency footprint happens to coincide with what I often have too
2021-09-28 10:41:29 +0200 <dminuoso> So it's not a big deal for me
2021-09-28 10:41:39 +0200 <maerwald> you're a conduit user? x(
2021-09-28 10:41:56 +0200 <dminuoso> No, not generally.
2021-09-28 10:42:03 +0200 <kuribas> maerwald: conduit is fine when you need it.
2021-09-28 10:42:21 +0200 <maerwald> I'd rather use something with less over-engineered API and better performance :p
2021-09-28 10:42:31 +0200 <kuribas> dminuoso: and how would you model a REST endpoint server (servant)? Throw exceptions for abnormal status codes?
2021-09-28 10:42:43 +0200 <dminuoso> maerwald: conduit is rather hard to avoid in your transitive dependency tree.
2021-09-28 10:42:53 +0200 <maerwald> dminuoso: I managed it though
2021-09-28 10:43:01 +0200 <maerwald> but had to remove 3 deps or so
2021-09-28 10:43:13 +0200 <kuribas> haskell programs usually have huge dependency trees.
2021-09-28 10:43:20 +0200 <kuribas> for example dhall.
2021-09-28 10:43:21 +0200 <dminuoso> mine dont, usually
2021-09-28 10:43:44 +0200 <maerwald> I'm starting to go the low dep footprint and also regularly copy-paste code and adjust it rather than wasting 6 months on trying to upstream it
2021-09-28 10:43:58 +0200 <maerwald> or just re-implement something simple
2021-09-28 10:44:12 +0200 <dminuoso> Same, mostly.
2021-09-28 10:44:33 +0200 <maerwald> NMU also doesn't work well
2021-09-28 10:44:33 +0200 <dminuoso> 10:42:31 kuribas | dminuoso: and how would you model a REST endpoint server (servant)? Throw exceptions for abnormal status codes?
2021-09-28 10:44:35 +0200 <dminuoso> Yes.
2021-09-28 10:44:35 +0200azeem(~azeem@2a00:801:2d0:9de5:7998:f5fe:f405:f6a8) (Read error: Connection reset by peer)
2021-09-28 10:44:48 +0200azeem(~azeem@emp-180-222.eduroam.uu.se)
2021-09-28 10:44:49 +0200 <dminuoso> kuribas: So ServantError already has an instance Exception, you can throw that.
2021-09-28 10:44:57 +0200 <kuribas> or maybe even a single exception containing body and status code...
2021-09-28 10:45:09 +0200 <kuribas> right
2021-09-28 10:45:11 +0200 <dminuoso> My natural transformation `AppM ~> Handler` catches them and rewraps them into a Left error.
2021-09-28 10:45:31 +0200 <dminuoso> That's the style I use in all three of our servant apps.
2021-09-28 10:45:36 +0200azeem(~azeem@emp-180-222.eduroam.uu.se) (Read error: Connection reset by peer)
2021-09-28 10:45:42 +0200 <dminuoso> *servers
2021-09-28 10:46:30 +0200 <dminuoso> ServerError they are actually called I think
2021-09-28 10:46:36 +0200 <kuribas> neat
2021-09-28 10:46:58 +0200 <maerwald> https://hackage.haskell.org/package/servant-exceptions
2021-09-28 10:47:04 +0200 <dminuoso> It's not perfect, you have to be careful with IO in negative position
2021-09-28 10:47:19 +0200 <Hecate> I never used servant-exceptions
2021-09-28 10:47:27 +0200max22-(~maxime@2a01cb0883359800761b1c69d9198b7f.ipv6.abo.wanadoo.fr) (Ping timeout: 240 seconds)
2021-09-28 10:47:28 +0200 <dminuoso> A careless `catch/catches` can prevent them from working
2021-09-28 10:47:53 +0200 <dminuoso> For us its not a big deal, because mostly we maintain hierarchial exception trees that we can catch with precision
2021-09-28 10:47:56 +0200 <maerwald> There's also https://hackage.haskell.org/package/servant-checked-exceptions
2021-09-28 10:47:59 +0200 <Hecate> but I had to interface Servant endpoints with legacy code that was massively using custom exceptions, so I re-throw the business logic exceptions as ExceptT in the natural transform
2021-09-28 10:48:02 +0200 <dminuoso> But on the care occasion you have to blindly catch an IOException, it sucks.
2021-09-28 10:48:14 +0200 <maerwald> But there's an upstream issue about changing the api to allow expressing failures directly
2021-09-28 10:48:18 +0200 <dminuoso> Because you have to explicitly rethrow ServerError
2021-09-28 10:48:37 +0200azeem(~azeem@emp-180-222.eduroam.uu.se)
2021-09-28 10:48:39 +0200 <maerwald> https://github.com/haskell-servant/servant/pull/1314
2021-09-28 10:48:42 +0200 <maerwald> which is actually merged
2021-09-28 10:49:10 +0200 <maerwald> https://github.com/haskell-servant/servant/blob/c1105899f47d5537c1bdc8c86bee3523bdf05282/doc/cookb…
2021-09-28 10:49:32 +0200 <maerwald> So there's `WithStatus blah`
2021-09-28 10:51:06 +0200tomsmeding(~tomsmedin@tomsmeding.com) (Quit: ZNC 1.8.2 - https://znc.in)
2021-09-28 10:51:09 +0200acidjnk_new(~acidjnk@p200300d0c703cb4919aae83405072cdc.dip0.t-ipconnect.de)
2021-09-28 10:52:30 +0200Guest53(~Guest53@77.240.67.20)
2021-09-28 10:52:51 +0200tomsmeding(~tomsmedin@tomsmeding.com)
2021-09-28 10:53:12 +0200acidjnk(~acidjnk@p200300d0c703cb4919aae83405072cdc.dip0.t-ipconnect.de)
2021-09-28 10:54:16 +0200acidjnk_new3(~acidjnk@p200300d0c703cb49f045ad1a041448f2.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2021-09-28 10:55:55 +0200acidjnk_new(~acidjnk@p200300d0c703cb4919aae83405072cdc.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2021-09-28 10:56:22 +0200kuribas(~user@ptr-25vy0i9jx2ordo6ztok.18120a2.ip6.access.telenet.be) (Remote host closed the connection)
2021-09-28 10:56:39 +0200kuribas(~user@ptr-25vy0i9jx2ordo6ztok.18120a2.ip6.access.telenet.be)
2021-09-28 10:59:09 +0200Guest53(~Guest53@77.240.67.20) (Quit: Client closed)
2021-09-28 10:59:09 +0200 <kuribas> I am recreating servant in idris, with better ergonomics (hopefully).
2021-09-28 10:59:20 +0200 <kuribas> It looks promising.
2021-09-28 10:59:55 +0200 <Franciman> but good luck
2021-09-28 10:59:57 +0200 <Franciman> let us know
2021-09-28 10:59:59 +0200 <Franciman> -but
2021-09-28 11:00:00 +0200 <kuribas> I have an anonymous record implementation for dealing with captures and parameters, rather than positional parameters.
2021-09-28 11:00:08 +0200RohitGoswami[m](~rgoswamim@2001:470:69fc:105::16cc) (Quit: You have been kicked for being idle)
2021-09-28 11:00:21 +0200 <kuribas> IMO those get complicated fast, if you have a lot of parameters.
2021-09-28 11:00:25 +0200 <kuribas> like more than 3 :)
2021-09-28 11:00:33 +0200RohitGoswami[m](~rgoswamim@2001:470:69fc:105::16cc)
2021-09-28 11:02:23 +0200 <kuribas> I already wrote a haskell library to deal with that https://hackage.haskell.org/package/named-servant
2021-09-28 11:02:31 +0200 <kuribas> but writing it was a pain.
2021-09-28 11:02:45 +0200 <kuribas> And so is extending servant to do anything besides base functionality.
2021-09-28 11:03:58 +0200 <kuribas> Franciman: I will :) It's just that idris seems to be lacking libraries for about anything.
2021-09-28 11:06:04 +0200 <kuribas> I could port wai, then implement it on a jvm server (or chez scheme server).
2021-09-28 11:06:57 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-09-28 11:07:37 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-09-28 11:07:50 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-09-28 11:08:09 +0200oxide(~lambda@user/oxide)
2021-09-28 11:09:16 +0200xff0x(~xff0x@2001:1a81:534d:3900:325e:28e:425a:62e0) (Ping timeout: 245 seconds)
2021-09-28 11:10:03 +0200xff0x(~xff0x@2001:1a81:534d:3900:7ca7:1f1d:7921:2152)
2021-09-28 11:10:46 +0200 <kuribas> My basic idea is not to make something super generic, but rather give a lot of tools (parsers for parameters, etc..), so you can just roll your own solution that fits your API.
2021-09-28 11:23:06 +0200amk(~amk@109.255.169.126) (Remote host closed the connection)
2021-09-28 11:23:14 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net)
2021-09-28 11:23:16 +0200amk(~amk@109.255.169.126)
2021-09-28 11:26:17 +0200chomwitt(~chomwitt@2a02:587:dc0a:5800:12c3:7bff:fe6d:d374)
2021-09-28 11:26:44 +0200 <carbolymer> are call stacks somehow extractable from exceptions? I have a few functions with `HasCallStack` calling each other, in `catch` I'm calling `GHC.Stack.whoCreated` on exception, and I'm not getting anything
2021-09-28 11:27:19 +0200 <kuribas> carbolymer: did you compile with profiling option?
2021-09-28 11:27:31 +0200 <carbolymer> kuribas: HasCallStack does not require -prof
2021-09-28 11:27:36 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net) (Ping timeout: 245 seconds)
2021-09-28 11:28:46 +0200 <carbolymer> ah, but whoCreated requires...
2021-09-28 11:29:16 +0200 <carbolymer> so I need to attach callStack to exceptions at the throw site manually, right?
2021-09-28 11:30:12 +0200 <kuribas> AFAIK you have to add the constraint.
2021-09-28 11:30:15 +0200 <kuribas> HasCallStack
2021-09-28 11:30:29 +0200 <carbolymer> yes, but how can you extract call stack from exception?
2021-09-28 11:30:50 +0200dunj3(~dunj3@2001:981:9d95:1:886d:656c:9636:23f4)
2021-09-28 11:30:53 +0200 <dminuoso> % :t callStack
2021-09-28 11:30:53 +0200 <yahb> dminuoso: ; <interactive>:1:1: error: Variable not in scope: callStack
2021-09-28 11:31:00 +0200 <dminuoso> % import GHC.Stack.HasCallStack
2021-09-28 11:31:01 +0200 <yahb> dminuoso: ; <no location info>: error:; Could not find module `GHC.Stack.HasCallStack'; It is not a module in the current program, or in any known package.
2021-09-28 11:31:03 +0200 <dminuoso> Oh well.
2021-09-28 11:31:06 +0200 <dminuoso> carbolymer: Use callStack.
2021-09-28 11:31:16 +0200 <dminuoso> https://hackage.haskell.org/package/base-4.15.0.0/docs/GHC-Stack.html#v:callStack
2021-09-28 11:31:38 +0200 <carbolymer> dminuoso: but callStack returns call stack at the invocation place, I need the call stack from throwIO / throwM was used
2021-09-28 11:36:38 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-09-28 11:38:35 +0200 <carbolymer> hmm that could work with ImplicitParams magic...
2021-09-28 11:40:29 +0200 <carbolymer> can I use Implicit params with constructors? like:
2021-09-28 11:40:29 +0200 <carbolymer> data SubAException = (?stacktrace :: CallStack) => SubAException { stacktrace :: !CallStack }
2021-09-28 11:40:59 +0200 <carbolymer> but the problem is that SubAException is `CallStack -> SubAException`
2021-09-28 11:41:20 +0200 <carbolymer> I guess I need a helper function to do that, don't I?
2021-09-28 11:42:16 +0200 <carbolymer> https://hackage.haskell.org/package/base-4.15.0.0/docs/src/GHC-Err.html#error
2021-09-28 11:42:22 +0200 <carbolymer> I think the answer is yes
2021-09-28 11:42:42 +0200 <Franciman> I remember there was an haskell-numeric channel for numeric calculus in haskell
2021-09-28 11:42:55 +0200 <Franciman> but i don't recall the name of the channel, any help?
2021-09-28 11:45:12 +0200 <carbolymer> Franciman: #numerical-haskell
2021-09-28 11:45:13 +0200 <carbolymer> ?
2021-09-28 11:45:16 +0200 <carbolymer> try /list
2021-09-28 11:46:07 +0200mestre(~mestre@191.177.175.57)
2021-09-28 11:46:19 +0200 <Franciman> thanks carbolymer
2021-09-28 11:55:46 +0200max22-(~maxime@2a01cb0883359800af7b6a67b5a81e97.ipv6.abo.wanadoo.fr)
2021-09-28 12:02:14 +0200benin036932301(~benin@183.82.204.86)
2021-09-28 12:05:52 +0200 <carbolymer> that does not look bad: https://bpa.st/A6LQ - now I need to figure out if I can combine `throwM` with `withStack`
2021-09-28 12:07:57 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:45b4:2298:3c2b:6589)
2021-09-28 12:12:11 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:45b4:2298:3c2b:6589) (Ping timeout: 245 seconds)
2021-09-28 12:13:29 +0200fef(~thedawn@user/thedawn) (Remote host closed the connection)
2021-09-28 12:15:13 +0200dunj3(~dunj3@2001:981:9d95:1:886d:656c:9636:23f4) (Quit: Leaving)
2021-09-28 12:15:31 +0200Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de) (Ping timeout: 245 seconds)
2021-09-28 12:15:34 +0200dunj3(~dunj3@kingdread.de)
2021-09-28 12:19:13 +0200ubert1(~Thunderbi@77.119.208.41.wireless.dyn.drei.com)
2021-09-28 12:20:01 +0200ubert(~Thunderbi@77.119.219.178.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-28 12:20:01 +0200ubert1ubert
2021-09-28 12:28:24 +0200fef(~thedawn@user/thedawn)
2021-09-28 12:31:12 +0200fef(~thedawn@user/thedawn) (Remote host closed the connection)
2021-09-28 12:32:35 +0200gehmehgeh(~user@user/gehmehgeh)
2021-09-28 12:45:25 +0200jakalx(~jakalx@base.jakalx.net) ()
2021-09-28 12:45:26 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-28 12:45:40 +0200fef(~thedawn@user/thedawn)
2021-09-28 12:46:33 +0200jakalx(~jakalx@base.jakalx.net)
2021-09-28 12:46:47 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 12:51:55 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-28 12:52:21 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 12:55:09 +0200ozzymcduff(~mathieu@81-234-151-21-no94.tbcn.telia.com) (Remote host closed the connection)
2021-09-28 12:57:36 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-09-28 12:58:15 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 12:59:16 +0200oxide(~lambda@user/oxide) (Ping timeout: 245 seconds)
2021-09-28 12:59:39 +0200betelgeuse(~betelgeus@94-225-47-8.access.telenet.be)
2021-09-28 13:00:23 +0200oxide(~lambda@user/oxide)
2021-09-28 13:00:52 +0200alx741(~alx741@186.178.109.237)
2021-09-28 13:03:35 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-28 13:04:06 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 13:09:16 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-09-28 13:10:13 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 13:13:50 +0200enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7)
2021-09-28 13:15:34 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-28 13:16:04 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 13:20:06 +0200azeem(~azeem@emp-180-222.eduroam.uu.se) (Read error: Connection reset by peer)
2021-09-28 13:20:21 +0200azeem(~azeem@emp-180-222.eduroam.uu.se)
2021-09-28 13:21:11 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-28 13:21:54 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 13:25:00 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-09-28 13:27:19 +0200fef(~thedawn@user/thedawn) (Remote host closed the connection)
2021-09-28 13:37:56 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:45b4:2298:3c2b:6589)
2021-09-28 13:40:40 +0200xsperry(~xs@cpe-188-129-101-182.dynamic.amis.hr) (Changing host)
2021-09-28 13:40:40 +0200xsperry(~xs@user/xsperry)
2021-09-28 13:42:11 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:45b4:2298:3c2b:6589) (Ping timeout: 245 seconds)
2021-09-28 13:46:50 +0200Heisen(~Heisen@77.240.67.20)
2021-09-28 13:48:20 +0200xiongxin(~quassel@113.116.33.5)
2021-09-28 13:48:41 +0200 <Heisen> How come we return "again" and not the "My Shangri-La" in getX? https://paste.tomsmeding.com/ecU7GGtn
2021-09-28 13:51:51 +0200 <dminuoso> Heisen: `return` is misleadingly named
2021-09-28 13:52:28 +0200 <dminuoso> `return` does not short circuit some block of imperative code, instead it creates a "pure action that immediately returns the right hand side as its result"
2021-09-28 13:52:49 +0200 <dminuoso> So for IO, `pure 1 :: IO Int` is a (pure) IO action that, as the result of its execution, would yield 1 instantly .
2021-09-28 13:52:55 +0200 <dminuoso> Note that `pure == return`.
2021-09-28 13:53:01 +0200peterhil(~peterhil@dsl-hkibng32-54fb52-57.dhcp.inet.fi) (Quit: Must not waste too much time here...)
2021-09-28 13:53:15 +0200 <dminuoso> I tend to prefer `pure` over `return` simply because its better named. :)
2021-09-28 13:54:43 +0200 <dminuoso> This is better observed if, instead of do-notation, we use explicit (>>=)
2021-09-28 13:55:28 +0200 <dminuoso> Consider: getLine >>= (\str -> pure (str ++ "!"))
2021-09-28 13:56:30 +0200mestre(~mestre@191.177.175.57) (Quit: Lost terminal)
2021-09-28 13:59:27 +0200jlamothe(~jlamothe@104.158.48.100) (Quit: leaving)
2021-09-28 14:00:07 +0200max22-(~maxime@2a01cb0883359800af7b6a67b5a81e97.ipv6.abo.wanadoo.fr) (Ping timeout: 240 seconds)
2021-09-28 14:03:25 +0200 <xsperry> > do return 10; return 20 :: Maybe Int
2021-09-28 14:03:26 +0200 <lambdabot> Just 20
2021-09-28 14:04:02 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2021-09-28 14:04:07 +0200 <Heisen> dminuoso We are returning "again" since the value of a sequence of IO actions is the same as the value of the last action in the sequence and what Return is doing is turning the String into an action? Is that correct?
2021-09-28 14:04:23 +0200jespada(~jespada@2803:9800:9842:7a62:8558:368:788c:6dc6)
2021-09-28 14:05:29 +0200 <Heisen> If return isn't turning "again" into an action how can we do x <- getX, in particular <-, since that operator requires an IO of something right?
2021-09-28 14:07:06 +0200 <xsperry> `return "foo"' just creates a NOP action that will, when run, produce "foo". it doesn't stop the execution of the rest of the do block
2021-09-28 14:10:08 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 252 seconds)
2021-09-28 14:11:14 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-28 14:12:05 +0200fef(~thedawn@user/thedawn)
2021-09-28 14:15:23 +0200Heisen(~Heisen@77.240.67.20) (Quit: Client closed)
2021-09-28 14:15:51 +0200acidjnk_new(~acidjnk@p200300d0c703cb495908c3ed7e15521a.dip0.t-ipconnect.de)
2021-09-28 14:16:17 +0200geranim0(~geranim0@modemcable242.171-178-173.mc.videotron.ca)
2021-09-28 14:18:03 +0200geranim0(~geranim0@modemcable242.171-178-173.mc.videotron.ca) (Remote host closed the connection)
2021-09-28 14:18:23 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 252 seconds)
2021-09-28 14:19:07 +0200slowButPresent(~slowButPr@user/slowbutpresent)
2021-09-28 14:19:25 +0200acidjnk(~acidjnk@p200300d0c703cb4919aae83405072cdc.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2021-09-28 14:19:55 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2021-09-28 14:20:21 +0200 <tdammers> it may be helpful to reason about `return` in terms of a different type, like Maybe, Either a, or []
2021-09-28 14:20:32 +0200 <tdammers> > return 10 :: [Int]
2021-09-28 14:20:33 +0200 <Cale> I think of it not as being that return is misleadingly named so much as that it just doesn't refer to the same thing as you might be familiar with from imperative languages. The action (return v) is an action which does nothing except to, well, return v
2021-09-28 14:20:34 +0200 <lambdabot> [10]
2021-09-28 14:21:26 +0200 <Cale> In most imperative languages, it doesn't behave quite like any other procedure call you could put there -- it has a control effect that you couldn't otherwise obtain.
2021-09-28 14:22:47 +0200lstor(~lstor@user/lstor)
2021-09-28 14:22:58 +0200 <Cale> But in Haskell, it's not magic, just a way of making a simple action that returns a given value when executed.
2021-09-28 14:24:32 +0200geranim0(~geranim0@modemcable242.171-178-173.mc.videotron.ca)
2021-09-28 14:24:54 +0200jlamothe(~jlamothe@104.158.48.100)
2021-09-28 14:25:36 +0200Robin_Jadoul(~Robin_Jad@152.67.64.160)
2021-09-28 14:26:05 +0200kenran(~kenran@200116b82b7c770026c5086ce7603c15.dip.versatel-1u1.de)
2021-09-28 14:26:35 +0200brsvh(~brsvh@45.33.39.92)
2021-09-28 14:27:15 +0200lbseale(~lbseale@user/ep1ctetus)
2021-09-28 14:28:48 +0200 <Cale> (To put it another way, return v returns v from itself, not from the surrounding procedure definition or whatever.
2021-09-28 14:28:49 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Read error: Connection reset by peer)
2021-09-28 14:28:51 +0200 <Cale> )
2021-09-28 14:28:57 +0200MQ-17J(~MQ-17J@8.6.144.233)
2021-09-28 14:29:13 +0200Psybur(~Psybur@mobile-166-170-32-197.mycingular.net)
2021-09-28 14:30:10 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-09-28 14:34:11 +0200lavaman(~lavaman@98.38.249.169)
2021-09-28 14:34:48 +0200jumper149(~jumper149@80.240.31.34)
2021-09-28 14:36:10 +0200pbrisbin(~patrick@pool-173-49-147-250.phlapa.fios.verizon.net)
2021-09-28 14:38:35 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-28 14:39:50 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 252 seconds)
2021-09-28 14:42:59 +0200CiaoSen(~Jura@p2e5c6ba6.dip0.t-ipconnect.de)
2021-09-28 14:45:40 +0200fef(~thedawn@user/thedawn) (Remote host closed the connection)
2021-09-28 14:45:47 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-09-28 14:46:05 +0200fef(~thedawn@user/thedawn)
2021-09-28 14:46:06 +0200Robin_Jadoul(~Robin_Jad@152.67.64.160) (Remote host closed the connection)
2021-09-28 14:47:31 +0200desantra(~skykanin@user/skykanin)
2021-09-28 14:49:14 +0200geranim0(~geranim0@modemcable242.171-178-173.mc.videotron.ca) (Remote host closed the connection)
2021-09-28 14:50:10 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Quit: WeeChat 3.3)
2021-09-28 14:50:25 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2)
2021-09-28 14:54:41 +0200kenran(~kenran@200116b82b7c770026c5086ce7603c15.dip.versatel-1u1.de) (Quit: WeeChat info:version)
2021-09-28 14:54:41 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2) (Ping timeout: 245 seconds)
2021-09-28 14:59:01 +0200Robin_Jadoul(~Robin_Jad@152.67.64.160)
2021-09-28 15:00:14 +0200desantra(~skykanin@user/skykanin) (Quit: WeeChat 3.3)
2021-09-28 15:00:51 +0200zer0bitz(~zer0bitz@dsl-hkibng31-54fafc-123.dhcp.inet.fi)
2021-09-28 15:06:12 +0200neurocyte0132(~neurocyte@user/neurocyte) (Quit: The Lounge - https://thelounge.chat)
2021-09-28 15:08:52 +0200 <ldlework> I just think of `return` as `pure` which i think of as `box`
2021-09-28 15:09:17 +0200 <merijn> I just don't think \o/
2021-09-28 15:09:36 +0200 <ldlework> be the haskell
2021-09-28 15:09:58 +0200 <merijn> I didn't switch to a strongly typed language because I wanna think about the stuff I write!
2021-09-28 15:10:07 +0200 <ldlework> hah
2021-09-28 15:10:43 +0200 <shapr> it is easier to write Haskell than other languages when really tired
2021-09-28 15:12:32 +0200 <merijn> Haskell best-in-slot language for coding drunk :p
2021-09-28 15:13:33 +0200Guest20(~Guest20@p200300f77707f3fd2b40c5f534cfc2c2.dip0.t-ipconnect.de)
2021-09-28 15:14:26 +0200brsvh(~brsvh@45.33.39.92) (Quit: Client closed)
2021-09-28 15:15:18 +0200Guest20(~Guest20@p200300f77707f3fd2b40c5f534cfc2c2.dip0.t-ipconnect.de) (Client Quit)
2021-09-28 15:18:52 +0200max22-(~maxime@2a01cb088335980013e52131b43b1c30.ipv6.abo.wanadoo.fr)
2021-09-28 15:21:31 +0200vpan(~vilius@212.117.1.172)
2021-09-28 15:27:22 +0200chris(~chris@81.96.113.213)
2021-09-28 15:27:26 +0200chrisGuest6083
2021-09-28 15:28:59 +0200Guest6083(~chris@81.96.113.213) (Remote host closed the connection)
2021-09-28 15:29:11 +0200chris(~chris@81.96.113.213)
2021-09-28 15:29:15 +0200chrisGuest6000
2021-09-28 15:29:18 +0200Guest6000(~chris@81.96.113.213) (Remote host closed the connection)
2021-09-28 15:30:48 +0200chris(~chris@81.96.113.213)
2021-09-28 15:30:52 +0200chrisGuest4408
2021-09-28 15:38:49 +0200lbseale(~lbseale@user/ep1ctetus) (Ping timeout: 265 seconds)
2021-09-28 15:40:36 +0200 <maerwald> merijn: I disagree
2021-09-28 15:40:44 +0200 <maerwald> Java is the best language for drunken coding
2021-09-28 15:40:49 +0200 <maerwald> in fact, I can only code java when drunk
2021-09-28 15:41:06 +0200 <maerwald> for Haskell, I need to be awake
2021-09-28 15:42:02 +0200shriekingnoise(~shrieking@186.137.144.80)
2021-09-28 15:42:10 +0200 <merijn> If that was true I'd never have finished my thesis >.>
2021-09-28 15:42:15 +0200 <maerwald> lol
2021-09-28 15:42:18 +0200 <maerwald> did you?
2021-09-28 15:42:20 +0200Morrow(~Morrow@147.161.14.157)
2021-09-28 15:42:22 +0200azeem(~azeem@emp-180-222.eduroam.uu.se) (Read error: Connection reset by peer)
2021-09-28 15:43:30 +0200 <merijn> maerwald: That's the kinda talk that gets men stabbed ;)
2021-09-28 15:44:24 +0200 <merijn> 2 chapters worth of comments left this week, although most of them so far are "slightly reword a sentence" and "fuck that, too much work, just gonna mark that as addressed and assume they won't notice on a 2nd read" :p
2021-09-28 15:44:28 +0200azeem(~azeem@emp-180-222.eduroam.uu.se)
2021-09-28 15:44:37 +0200CiaoSen(~Jura@p2e5c6ba6.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2021-09-28 15:47:40 +0200 <maerwald> I have an Auchentoshan 3-wood left here. That would get you through half of the week, I guess.
2021-09-28 15:49:47 +0200 <merijn> maerwald: The only good Auchentoshan :)
2021-09-28 15:49:58 +0200 <merijn> I really like the Three Wood
2021-09-28 15:50:09 +0200 <merijn> Not so easy to get here anymore, though
2021-09-28 15:50:38 +0200 <merijn> maerwald: At this point the writing is more of an "Ardbeg Corryvreckan"-thing, then a Three Wood :p
2021-09-28 15:59:58 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2)
2021-09-28 16:01:41 +0200fvr(uid503686@id-503686.uxbridge.irccloud.com)
2021-09-28 16:04:18 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-28 16:04:18 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-28 16:04:18 +0200wroathe(~wroathe@user/wroathe)
2021-09-28 16:04:35 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2) (Ping timeout: 265 seconds)
2021-09-28 16:08:22 +0200azimut_(~azimut@gateway/tor-sasl/azimut)
2021-09-28 16:10:39 +0200 <janus> can i make an instance that quantifies over type parameters supplied via DataKinds?
2021-09-28 16:11:10 +0200 <janus> i have 'instance ToJSON (Foobar a) where' but the instance is not getting picked up on 9.0.1, on 8.6.5 it works fine
2021-09-28 16:11:12 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 276 seconds)
2021-09-28 16:11:59 +0200 <janus> so i was thinking it must be related to GHC prop 0055-instance-foralls which mentions some things that landed in 8.8.
2021-09-28 16:12:22 +0200 <janus> it says that TypeInType makes it such that it is not possible to infer kinds of type variables
2021-09-28 16:12:48 +0200 <janus> ok, so i tried changing the instance to 'instance forall (a :: Type). ToJSON (Foobar a) where' but that doesn't seem to work
2021-09-28 16:14:08 +0200 <lortabac> janus: what do you mean by "type parameters supplied via DataKinds"?
2021-09-28 16:16:25 +0200 <janus> lortabac: well i have "type MasterFoobar = Foobar 'Master" and "type HouseFoobar = Foobar 'House". they come from "data Designator = Master | House"
2021-09-28 16:16:49 +0200yinghua(~yinghua@2800:2121:1400:1db:c8ff:6a08:d6d8:71db)
2021-09-28 16:16:51 +0200 <janus> so Foobar is supposed parameterized with values of the Designator type
2021-09-28 16:17:02 +0200 <lortabac> janus: then your signature is not correct
2021-09-28 16:17:18 +0200 <janus> aaah right cause that wouldn't be a type, ok, hmm
2021-09-28 16:17:19 +0200 <lortabac> forall (a :: Type) means that 'a' is a type
2021-09-28 16:18:00 +0200Guest4408(~chris@81.96.113.213) (Remote host closed the connection)
2021-09-28 16:18:03 +0200 <janus> right , ok, i have modelled the 'typical' case instead of the fancy ass case i have where values flow into the type system with datakinds
2021-09-28 16:19:31 +0200 <lortabac> if you replace Type with Designator there is no reason it shouldn't work
2021-09-28 16:20:11 +0200 <janus> i did replace it as you suggest. it doesn't seem to work, though. i get "No instance arising for (ToJSON (Foobar 'Master))" ... hmmm
2021-09-28 16:20:25 +0200acidjnk_new(~acidjnk@p200300d0c703cb495908c3ed7e15521a.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2021-09-28 16:20:39 +0200 <janus> i could work around it and just make a function that works for both, and then make the two instances manually... surely that should work
2021-09-28 16:21:18 +0200 <lortabac> there must be some other problem
2021-09-28 16:21:35 +0200 <janus> yeah i'll try to make a minimal reproducible example :)
2021-09-28 16:22:27 +0200 <lortabac> using other kinds than Type is certainly possible, if GHC 9 stops supporting it half of Hackage would break :D
2021-09-28 16:23:25 +0200choucavalier(~choucaval@peanutbuttervibes.com)
2021-09-28 16:26:48 +0200choucavalier(~choucaval@peanutbuttervibes.com) (Changing host)
2021-09-28 16:26:48 +0200choucavalier(~choucaval@user/choucavalier)
2021-09-28 16:28:35 +0200spruit11(~quassel@2a02:a467:ccd6:1:1568:8cd5:25bd:6e4e) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2021-09-28 16:31:58 +0200ec(~ec@gateway/tor-sasl/ec)
2021-09-28 16:35:01 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-28 16:37:37 +0200chris(~chris@81.96.113.213)
2021-09-28 16:37:41 +0200chrisGuest8402
2021-09-28 16:49:18 +0200hnOsmium0001(uid453710@id-453710.hampstead.irccloud.com)
2021-09-28 16:52:17 +0200Sgeo(~Sgeo@user/sgeo)
2021-09-28 16:53:58 +0200ubert(~Thunderbi@77.119.208.41.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-28 16:54:24 +0200Guest8402(~chris@81.96.113.213) (Remote host closed the connection)
2021-09-28 16:55:24 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-09-28 16:57:26 +0200chris(~chris@81.96.113.213)
2021-09-28 16:57:30 +0200chrisGuest9854
2021-09-28 16:57:41 +0200Guest9854(~chris@81.96.113.213) (Remote host closed the connection)
2021-09-28 16:59:19 +0200Null_A(~null_a@2601:645:8700:2290:91f2:4a69:be9c:a77e)
2021-09-28 17:01:37 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 265 seconds)
2021-09-28 17:02:36 +0200Guest5827(~chris@81.96.113.213)
2021-09-28 17:03:51 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-09-28 17:05:48 +0200troydm1(~troydm@host-176-37-124-197.b025.la.net.ua) (Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset)
2021-09-28 17:07:00 +0200Guest5827(~chris@81.96.113.213) (Ping timeout: 250 seconds)
2021-09-28 17:09:28 +0200ozzymcduff(~mathieu@81-234-151-21-no94.tbcn.telia.com)
2021-09-28 17:18:51 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-28 17:18:51 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-28 17:18:51 +0200wroathe(~wroathe@user/wroathe)
2021-09-28 17:20:03 +0200vysn(~vysn@user/vysn)
2021-09-28 17:20:06 +0200Tuplanolla(~Tuplanoll@91-159-69-50.elisa-laajakaista.fi)
2021-09-28 17:20:55 +0200notzmv(~zmv@user/notzmv) (Ping timeout: 252 seconds)
2021-09-28 17:21:42 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2)
2021-09-28 17:23:28 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 250 seconds)
2021-09-28 17:25:03 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:5b7d:5292:5e11:8e47) (Quit: WeeChat 2.8)
2021-09-28 17:25:56 +0200troydm(~troydm@host-176-37-124-197.b025.la.net.ua)
2021-09-28 17:28:35 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-28 17:28:35 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-28 17:28:35 +0200wroathe(~wroathe@user/wroathe)
2021-09-28 17:29:33 +0200yin[m]zwro[m]
2021-09-28 17:31:42 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net)
2021-09-28 17:32:28 +0200theproffesor(~theproffe@user/theproffesor) (Leaving)
2021-09-28 17:33:29 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-09-28 17:33:32 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-09-28 17:34:06 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 17:35:37 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-09-28 17:36:10 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2) (Remote host closed the connection)
2021-09-28 17:39:05 +0200Null_A(~null_a@2601:645:8700:2290:91f2:4a69:be9c:a77e) (Remote host closed the connection)
2021-09-28 17:39:05 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-09-28 17:42:49 +0200mjrosenb(~mjrosenb@pool-108-54-97-96.nycmny.fios.verizon.net)
2021-09-28 17:44:35 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net) (Remote host closed the connection)
2021-09-28 17:45:08 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 250 seconds)
2021-09-28 17:46:00 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net)
2021-09-28 17:46:04 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2)
2021-09-28 17:47:15 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2) (Remote host closed the connection)
2021-09-28 17:47:30 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2)
2021-09-28 17:48:22 +0200ec(~ec@gateway/tor-sasl/ec)
2021-09-28 17:48:34 +0200tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2021-09-28 17:49:42 +0200xiongxin(~quassel@113.116.33.5) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2021-09-28 17:54:14 +0200Guest47(~Guest47@eth-west-pareq2-46-193-4-100.wb.wifirst.net)
2021-09-28 17:56:37 +0200 <Guest47> Given that Haskell makes quite a big use of recursion (correct me if I'm wrong), does GHC have any special optimizations against redundant calculations?
2021-09-28 17:56:47 +0200ysavd^(~ysavd@68.101.50.106)
2021-09-28 17:56:54 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-09-28 17:57:10 +0200lbseale(~lbseale@user/ep1ctetus)
2021-09-28 17:57:46 +0200justache(~justache@user/justache) (Read error: Connection reset by peer)
2021-09-28 17:58:37 +0200justache(~justache@user/justache)
2021-09-28 17:59:22 +0200 <c_wraith> I'm not seeing a connection between the premise (which is true) and the question
2021-09-28 17:59:40 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2021-09-28 18:00:12 +0200RohitGoswami[m](~rgoswamim@2001:470:69fc:105::16cc) (Quit: You have been kicked for being idle)
2021-09-28 18:00:44 +0200notzmv(~zmv@user/notzmv)
2021-09-28 18:00:56 +0200 <Guest47> well as I see it, the premise is a good motivation to have opt-in memoization for example
2021-09-28 18:01:00 +0200 <c_wraith> as for the question itself - GHC will do common subexpression elimination in limited circumstances, and it will do a transform called "full laziness" in slightly less limited circumstances. Both are quite likely to destroy performance when it guesses wrong.
2021-09-28 18:01:11 +0200 <Franciman> Guest47: haskell uses call by need
2021-09-28 18:01:29 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-28 18:01:29 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-28 18:01:29 +0200wroathe(~wroathe@user/wroathe)
2021-09-28 18:01:30 +0200 <c_wraith> memoization is not a performance improvement in general
2021-09-28 18:01:43 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-09-28 18:01:55 +0200econo(uid147250@user/econo)
2021-09-28 18:02:18 +0200 <Guest47> c_wraith: could you please elaborate on that since I just left my lecture haha
2021-09-28 18:02:50 +0200 <c_wraith> memoization only helps if the cost of storing and looking up results is cheaper than the cost of calculating them.
2021-09-28 18:02:54 +0200 <c_wraith> That's very often not true.
2021-09-28 18:03:43 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-28 18:03:50 +0200 <Guest47> like if you're doing IO over a network? Or does it take much less than that?
2021-09-28 18:04:06 +0200 <c_wraith> It's not even *valid* to memoize IO in general
2021-09-28 18:04:27 +0200 <c_wraith> the whole point of IO is that things can change.
2021-09-28 18:04:37 +0200Lycurgus(~juan@98.4.112.204)
2021-09-28 18:05:07 +0200 <c_wraith> your ntp client really should memoize server responses!
2021-09-28 18:05:13 +0200 <tdammers> the way Haskell is evaluated means that typical recursions can be evaluated in constant space. depending on how you look at it, this can be interpreted as "Haskell does automatic TCO", or "Haskell doesn't need TCO"
2021-09-28 18:05:14 +0200 <c_wraith> err. +not
2021-09-28 18:05:15 +0200 <Guest47> yes how very silly of me
2021-09-28 18:05:44 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 246 seconds)
2021-09-28 18:06:10 +0200 <c_wraith> but, like.. even common subexpression elimination can be really bad for performance in haskell
2021-09-28 18:06:44 +0200 <Guest47> I don't really see how you can do subexpression elimination in recursive calls
2021-09-28 18:06:59 +0200 <c_wraith> as an example: (sum [1..10000000000] + product [1..10000000000]) should not introduce sharing of the [1..10000000000] value
2021-09-28 18:07:18 +0200 <c_wraith> It's a very long list.
2021-09-28 18:07:24 +0200 <c_wraith> if it's shared, it's kept in memory
2021-09-28 18:07:28 +0200 <mjrosenb> the CSE is separate from any form of recursion.
2021-09-28 18:07:34 +0200 <c_wraith> and that adds quite a bit of drag on the garbage collector
2021-09-28 18:07:45 +0200 <c_wraith> If it's not shared, it's streamed twice.
2021-09-28 18:07:54 +0200 <c_wraith> And that's a lot more efficient
2021-09-28 18:08:03 +0200 <Guest47> excuse me, what does streaming mean?
2021-09-28 18:08:06 +0200azeem(~azeem@emp-180-222.eduroam.uu.se) (Ping timeout: 250 seconds)
2021-09-28 18:08:16 +0200 <mjrosenb> c_wraith: the compiler could theoretically share it, and interleave the sum and product calculations
2021-09-28 18:08:22 +0200 <mjrosenb> but that sounds like a lot of work
2021-09-28 18:08:25 +0200 <Guest47> keeping only the required value in memory at any give time?
2021-09-28 18:08:34 +0200 <c_wraith> it means that all that's ever in memory is the head of the list and a thunk to generate the rest of the list
2021-09-28 18:08:39 +0200azeem(~azeem@2a00:801:2d5:6b0b:3559:4c30:7a57:5531)
2021-09-28 18:09:18 +0200 <Guest47> so we're assuming something like: `sum x:xs = x + sum xs`?
2021-09-28 18:09:44 +0200 <c_wraith> I was just assuming Prelude.sum
2021-09-28 18:10:29 +0200 <c_wraith> which is really Data.Foldable.sum now, I suppose.
2021-09-28 18:12:03 +0200 <c_wraith> But `sum [] = 0; sum (x:xs) = x + sum xs` is a good example of why memoization can be a huge performance loss.
2021-09-28 18:12:30 +0200 <c_wraith> a memo table for that function would take lists as input
2021-09-28 18:12:41 +0200Robin_Jadoul(~Robin_Jad@152.67.64.160) (Ping timeout: 252 seconds)
2021-09-28 18:13:23 +0200 <c_wraith> Just checking to see if a list is currently in the memo table would probably be slower than computing its sum
2021-09-28 18:14:22 +0200 <c_wraith> Not to mention the incredible amount of memory it could end up using.
2021-09-28 18:14:23 +0200 <Guest47> you would need to make sure that all the list's elements are in the memoization table I suppose
2021-09-28 18:14:52 +0200enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) (Quit: enoq)
2021-09-28 18:16:04 +0200 <c_wraith> Memoization tends to only be a significant win if the problem structure is multiply-recursive
2021-09-28 18:16:18 +0200 <c_wraith> And each recursive call needs to do overlapping work
2021-09-28 18:16:29 +0200benin0369323019(~benin@106.198.91.149)
2021-09-28 18:16:51 +0200 <c_wraith> It's the latter part that's non-trivial to detect statically.
2021-09-28 18:17:03 +0200 <c_wraith> It's also not really that common
2021-09-28 18:17:16 +0200 <davean> Its trivial to detect *statistically* its difficult to detect algrithmicly
2021-09-28 18:17:16 +0200 <c_wraith> So it's just left to the programmer to memoize when it does help
2021-09-28 18:17:35 +0200 <davean> we have a serious lack of statistics driven optimization though
2021-09-28 18:17:39 +0200 <Hecate> we do
2021-09-28 18:17:59 +0200 <Guest47> Aha yes, my professor gave examples with factorial and Fibonacci so I got my hopes up
2021-09-28 18:18:21 +0200 <c_wraith> factorial doesn't even memoize that well.
2021-09-28 18:18:44 +0200benin036932301(~benin@183.82.204.86) (Ping timeout: 252 seconds)
2021-09-28 18:18:45 +0200benin0369323019benin036932301
2021-09-28 18:18:48 +0200 <c_wraith> fibonacci, on the other hand, is a perfect example of multiply-recursive and overlapping.
2021-09-28 18:19:03 +0200 <c_wraith> It's so perfect, though, that you only ever need two elements in the table. :)
2021-09-28 18:19:03 +0200 <Guest47> yes it does 2^(n/2) additions
2021-09-28 18:19:06 +0200 <mjrosenb> as it turns out, most problems don't share many properties with naieve implementations of fibonacci.
2021-09-28 18:19:10 +0200 <Guest47> instead of n
2021-09-28 18:19:30 +0200 <c_wraith> Fibonacci(n) does Fibonacci(n)-1 additions.
2021-09-28 18:19:30 +0200 <mjrosenb> it does fib(n) additions
2021-09-28 18:19:43 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd)
2021-09-28 18:20:02 +0200 <Franciman> 2*fib(n) - 1 recursions
2021-09-28 18:20:17 +0200earthflax(~earthflax@171.49.232.104)
2021-09-28 18:20:53 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 265 seconds)
2021-09-28 18:21:19 +0200 <c_wraith> common memoization problems are things like "longest common subsequence"
2021-09-28 18:21:44 +0200 <mjrosenb> c_wraith: if you're hand-unrolling it, you'll probably want more elements in the table :-)
2021-09-28 18:21:55 +0200hgolden(~hgolden2@172.114.81.123) (Remote host closed the connection)
2021-09-28 18:22:43 +0200earthflax(~earthflax@171.49.232.104) (Client Quit)
2021-09-28 18:22:59 +0200 <c_wraith> nah, 2 does the job when you work bottom-up. Of course that's not really efficient either, but the really efficient solutions involve *math*
2021-09-28 18:23:42 +0200hgolden(~hgolden2@cpe-172-114-81-123.socal.res.rr.com)
2021-09-28 18:24:27 +0200 <Guest47> the formula with the golden ratio?
2021-09-28 18:24:39 +0200 <mjrosenb> right. At least when I tried to do that, I needed memoization on random subsets of the fibonacci sequence
2021-09-28 18:24:41 +0200 <davean> Generally if memoization is actually good, its part of the specification of the alg.
2021-09-28 18:25:03 +0200 <c_wraith> Sort of. If you use the golden ratio formula naively, you exceed the precision of floating-point pretty fast.
2021-09-28 18:25:06 +0200 <Guest47> specification of the alg?
2021-09-28 18:25:13 +0200 <mjrosenb> Guest47: that's fine if you have a fast infinite precision library.
2021-09-28 18:25:33 +0200 <c_wraith> You need to do a change of base so you can use that formula with integers only
2021-09-28 18:25:37 +0200 <geekosaur> algorithm
2021-09-28 18:25:41 +0200 <c_wraith> and that's real math
2021-09-28 18:26:11 +0200earthflax(~earthflax@171.49.232.104)
2021-09-28 18:26:12 +0200 <Guest47> geekosaur: yes but spec of what algorithm?
2021-09-28 18:26:14 +0200 <davean> Bah, if theres a concievable way to apply it to an actual problem, its applied math, not real math :(
2021-09-28 18:26:24 +0200 <davean> Guest47: what ever one you're implimenting
2021-09-28 18:26:25 +0200 <geekosaur> whichever one you're using memoization with
2021-09-28 18:27:11 +0200 <mjrosenb> fib n = fib (n-1) + fib (n-2) => fib n = 2*fib(n-2) + fib(n-3) => fib n = 3*fib(n-3)+2*fib(n-4) =>...=> fib n = fib m * fib (n-m) + fib (m-1) * fib (n-m-1)
2021-09-28 18:27:14 +0200 <Guest47> oh sorry I misread the original comment
2021-09-28 18:27:15 +0200 <mjrosenb> or some such
2021-09-28 18:27:19 +0200Robin_Jadoul(~Robin_Jad@152.67.64.160)
2021-09-28 18:27:34 +0200 <geekosaur> (this is not circular, the point is that memoization is best used in specific circumstances and those circumstances will usually specify memoization directly)
2021-09-28 18:28:10 +0200 <davean> And the speciication of the memoization is critical - theres generally only 1 good way to memoize something
2021-09-28 18:30:17 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 252 seconds)
2021-09-28 18:31:32 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-28 18:33:23 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2) (Remote host closed the connection)
2021-09-28 18:34:05 +0200ubert(~Thunderbi@178.115.72.201.wireless.dyn.drei.com)
2021-09-28 18:34:12 +0200Brumaire(~quassel@81-64-14-121.rev.numericable.fr)
2021-09-28 18:35:41 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2)
2021-09-28 18:37:52 +0200geranim0(~sam@modemcable242.171-178-173.mc.videotron.ca)
2021-09-28 18:39:26 +0200benin0369323011(~benin@183.82.176.107)
2021-09-28 18:41:40 +0200benin036932301(~benin@106.198.91.149) (Ping timeout: 265 seconds)
2021-09-28 18:41:40 +0200benin0369323011benin036932301
2021-09-28 18:41:50 +0200 <monochrom> Ugh I missed all the fun discussions!
2021-09-28 18:42:04 +0200roboguy(~roboguy@user/roboguy)
2021-09-28 18:42:21 +0200 <Guest47> I struggle to understand what people mean when they say "Applicatives allow function application within a computational context"
2021-09-28 18:42:28 +0200 <Guest47> what is a computational context?
2021-09-28 18:43:12 +0200 <monochrom> Well yeah generally those "intuitive" wordings are people "explaining" to themselves after they have understood.
2021-09-28 18:43:27 +0200 <Guest47> I understand that my function, its input and output are all wrapped in a type called f but what does that mean?
2021-09-28 18:43:28 +0200 <monochrom> I.e., not before, not useful for those who haven't understood.
2021-09-28 18:43:41 +0200 <zwro[m]> we can, however, abstract memorization patterns
2021-09-28 18:43:56 +0200 <shapr> memoize memoization patterns?
2021-09-28 18:43:58 +0200 <monochrom> Generally most blogs are like that. Making the authors feel so good about themselves.
2021-09-28 18:44:00 +0200 <zwro[m]> s/memorization/memoization/
2021-09-28 18:44:15 +0200 <maerwald> anyone has a template for creating blog with hakyll or whatever on github pages?
2021-09-28 18:44:36 +0200zebrag(~chris@user/zebrag)
2021-09-28 18:44:49 +0200 <monochrom> Even the much revered dons wrote a sh*tty analogy on his blog.
2021-09-28 18:45:19 +0200segfaultfizzbuzz(~segfaultf@135-180-0-138.static.sonic.net)
2021-09-28 18:45:24 +0200 <Guest47> I wrote some garbage on my blog too :^)
2021-09-28 18:45:31 +0200 <Guest47> https://www.fuzzypixelz.com/2021/05/01/The-M-Word
2021-09-28 18:45:35 +0200 <Guest47> (shameless plug)
2021-09-28 18:45:50 +0200 <monochrom> The first monad analogy, and still the worst ever, second to none.
2021-09-28 18:45:56 +0200 <shapr> maerwald: I copied mine from someone else, but I forget where: https://github.com/shapr/shapr.github.io/tree/develop
2021-09-28 18:46:26 +0200 <Guest47> I recall people here telling me that starting with the monad laws was a bad idea
2021-09-28 18:47:06 +0200 <monochrom> You should also recall people telling you that starting with blogger wordings is also a bad idea, and worse than the laws.
2021-09-28 18:47:26 +0200 <shapr> I say do what you think is a good idea, and pay attention to any feedback you get
2021-09-28 18:47:30 +0200 <monochrom> I say that starting with instances is the best.
2021-09-28 18:47:40 +0200 <shapr> everything is imperfect, try to improve over time
2021-09-28 18:48:05 +0200 <maerwald> shapr: you push to master manually?
2021-09-28 18:48:46 +0200 <monochrom> And perhaps also with use cases, if you are one of those "practically minded" people who use "I don't understand" to mean "actually I understand, I am just not convinced it's useful".
2021-09-28 18:49:31 +0200 <c_wraith> I started by spending a while understanding how to use IO. after I got that, I decided to learn how to use parsec. it was at that point I had my first understanding of what "monad" meant. it meant "things that work like those". it took quite a while longer to understand how to associate the definition and laws with "work like those"
2021-09-28 18:49:37 +0200 <monochrom> Right? People use "I don't understand" to mean all sorts of things that have nothing to do with understanding.
2021-09-28 18:49:48 +0200 <Guest47> well if you're not convinced it's useful, when it's clearly is, then you don't understand anything
2021-09-28 18:49:50 +0200 <monochrom> Feynman pointed out another one. "I don't like it".
2021-09-28 18:50:29 +0200geranim0(~sam@modemcable242.171-178-173.mc.videotron.ca) (Ping timeout: 264 seconds)
2021-09-28 18:50:32 +0200ysavd^(~ysavd@68.101.50.106) (Ping timeout: 246 seconds)
2021-09-28 18:50:32 +0200 <monochrom> You don't draw a line between "what it is" and "why I care"? You lump them together?
2021-09-28 18:51:05 +0200 <Guest47> I am surely guilty of that
2021-09-28 18:51:06 +0200alzgh(~alzgh@user/alzgh) (Remote host closed the connection)
2021-09-28 18:51:25 +0200alzgh(~alzgh@user/alzgh)
2021-09-28 18:51:29 +0200 <Guest47> And I've never thought of that before
2021-09-28 18:51:35 +0200ysavd^(~ysavd@68.101.50.106)
2021-09-28 18:51:41 +0200 <monochrom> Yeah c_wraith most people (me included) report that the parser monad is when it clicks. My students too.
2021-09-28 18:51:44 +0200 <alzgh> yo, #haskell
2021-09-28 18:51:52 +0200 <alzgh> hope, y'all doing great today
2021-09-28 18:52:21 +0200 <monochrom> And once again perhaps it just means "finally an interesting example / use case".
2021-09-28 18:52:44 +0200 <Guest47> monochrom: you mean MonadParsec right?
2021-09-28 18:53:07 +0200 <monochrom> No, simply any of the old "monadic parser combinators" paper.
2021-09-28 18:53:12 +0200 <monochrom> papers
2021-09-28 18:53:30 +0200 <monochrom> "MonadParsec" did not exist.
2021-09-28 18:53:32 +0200 <Guest47> could please elaborate
2021-09-28 18:55:13 +0200 <c_wraith> I was working from a pdf that was... the parsec manual, maybe?
2021-09-28 18:55:17 +0200 <monochrom> The papers have already elaborated.
2021-09-28 18:55:34 +0200 <c_wraith> I just stepped through examples and modified them to see what would happen.
2021-09-28 18:55:38 +0200 <Guest47> the way I see it that each parser you write is a Monad and you use bind to sequence them into more complex parsers
2021-09-28 18:56:09 +0200 <c_wraith> and eventually I got to an example where I went "what if I wanted to look for this in parentheses, but not return them?"
2021-09-28 18:56:33 +0200 <c_wraith> and I just tried using <- to bind the value I cared about.... and it worked.
2021-09-28 18:56:44 +0200 <monochrom> :)
2021-09-28 18:57:00 +0200vpan(~vilius@212.117.1.172) (Quit: Leaving.)
2021-09-28 18:57:17 +0200 <monochrom> Yeah my students have those moments too. Sometimes I hinted them, sometimes they thought it up themselves.
2021-09-28 18:57:23 +0200 <c_wraith> I didn't understand why, exactly. but I knew that was the moment when I had caught on to the edge of something
2021-09-28 18:58:54 +0200Guest47(~Guest47@eth-west-pareq2-46-193-4-100.wb.wifirst.net) (Quit: Client closed)
2021-09-28 18:59:50 +0200Guest47(~Guest47@eth-west-pareq2-46-193-4-100.wb.wifirst.net)
2021-09-28 19:00:12 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-09-28 19:02:56 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-09-28 19:03:57 +0200emf_(~emf@2620:10d:c090:400::5:49ef)
2021-09-28 19:05:44 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-09-28 19:05:56 +0200xff0x(~xff0x@2001:1a81:534d:3900:7ca7:1f1d:7921:2152) (Ping timeout: 245 seconds)
2021-09-28 19:09:34 +0200koolazer(~koo@user/koolazer)
2021-09-28 19:09:42 +0200alzgh(~alzgh@user/alzgh) (Remote host closed the connection)
2021-09-28 19:10:02 +0200alzgh(~alzgh@user/alzgh)
2021-09-28 19:16:32 +0200xff0x(~xff0x@2001:1a81:534d:3900:7ca7:1f1d:7921:2152)
2021-09-28 19:17:17 +0200 <earthflax> alzgh: you too :)
2021-09-28 19:18:01 +0200earthflax(~earthflax@171.49.232.104) (Good Bye)
2021-09-28 19:18:20 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-09-28 19:21:48 +0200Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de)
2021-09-28 19:23:51 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 245 seconds)
2021-09-28 19:24:48 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-09-28 19:25:14 +0200vysn(~vysn@user/vysn) (Ping timeout: 250 seconds)
2021-09-28 19:30:39 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-09-28 19:33:45 +0200Cajun(~Cajun@user/cajun) (Quit: Client closed)
2021-09-28 19:34:18 +0200_xor(~xor@74.215.232.67) (Read error: Connection reset by peer)
2021-09-28 19:34:38 +0200martin02(~silas@141.84.69.76) (Ping timeout: 252 seconds)
2021-09-28 19:34:47 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 19:35:14 +0200asgas(~asgas@c-24-30-27-91.hsd1.ga.comcast.net)
2021-09-28 19:35:33 +0200 <asgas> I've heard functional languages like haskell are slow compared to C or C++. Is this true?
2021-09-28 19:37:09 +0200 <c_wraith> no.
2021-09-28 19:37:30 +0200 <sclv> haskell is a garbage collected language. you should expect the cost of gc and automatic memory management to bring about a roughly 1.5x or so slowdown in idiomatic highly optimized code compared to one with manual memory, but nonetheless haskell is extremely efficient and competitive or better, compared to any comparable high level languages.
2021-09-28 19:37:53 +0200 <monochrom> I've heard OOP languages like C++ are slow compared to Fortran. It is true.
2021-09-28 19:38:04 +0200MQ-17J(~MQ-17J@8.6.144.233) (Ping timeout: 265 seconds)
2021-09-28 19:38:14 +0200 <c_wraith> everything is slow compared to fortran
2021-09-28 19:38:19 +0200 <monochrom> And pointer languages like C slow compared to Fortran, too.
2021-09-28 19:38:30 +0200 <c_wraith> we'd better go back and rewrite operating systems in fortran
2021-09-28 19:38:35 +0200 <monochrom> or rather, pointer arithmetic languages
2021-09-28 19:38:40 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2) (Remote host closed the connection)
2021-09-28 19:39:05 +0200 <robbert-vdh> Just implement your program in cmm with only unboxed types :)
2021-09-28 19:39:06 +0200_xor(~xor@74.215.232.67)
2021-09-28 19:39:09 +0200 <monochrom> Oh, that one would be unfair, an OS is not meant to be superfast, but it is meant to do pointer arithmetic.
2021-09-28 19:39:19 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2)
2021-09-28 19:39:29 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-28 19:39:29 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-28 19:39:29 +0200wroathe(~wroathe@user/wroathe)
2021-09-28 19:39:38 +0200 <Guest47> what does Fortran replace pointer arithmetic with?
2021-09-28 19:39:46 +0200 <c_wraith> arrays
2021-09-28 19:39:46 +0200 <monochrom> C compilers already do the best they can under random pointer arithmetic semantics.
2021-09-28 19:40:28 +0200 <free_functor> Guest47, for reference, Fortran is the game engine that Fortnight is written in. V. fast langauge. V. Powerful.
2021-09-28 19:41:07 +0200 <sclv> an important tradeoff to note is that languages like haskell make parallel and concurrent computation easy, while low level languages generally make it a pain. in settings (most) where you want to achieve more performance scaling through parallel computation, high level languages with easy parallelism will be wins over low level languages
2021-09-28 19:41:14 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-09-28 19:41:20 +0200 <sclv> free_functor: lmao
2021-09-28 19:41:24 +0200 <Guest47> free_functor: that's a joke ... right?
2021-09-28 19:41:53 +0200 <monochrom> I respect "C is fast under the constraint that I want C features" and "C++ is fast under the constraint that I want C++ features".
2021-09-28 19:42:05 +0200 <monochrom> But "C/C++ is fast, unconditionally" is a joke.
2021-09-28 19:42:18 +0200 <monochrom> But then, what's the fun in being honest?
2021-09-28 19:42:29 +0200 <robbert-vdh> sclv: Rust would like a word with you :) (and presumably Erlang, but I've never used that)
2021-09-28 19:42:41 +0200 <robbert-vdh> *Erlang isn't low level of course, ignore that part
2021-09-28 19:42:57 +0200 <sclv> erlang is also very slow, relatively speaking, becaue it is interpreted
2021-09-28 19:43:03 +0200 <monochrom> "C is fast under the constraint that I want C features" now can't be used as a critique on Haskell, because GHC-generated code is fast under the contraint that I want Haskell features, too.
2021-09-28 19:43:10 +0200 <awpr> "high level language with easy parallelism" sounds like a good description of Rust to me
2021-09-28 19:43:39 +0200 <Franciman> haskell making concurrency easier is mostly dependent on the situation
2021-09-28 19:43:42 +0200 <sclv> rust is a low level language, its just very good at being one!!!
2021-09-28 19:43:56 +0200 <Franciman> because you may need mutation nevertheless
2021-09-28 19:44:01 +0200 <Franciman> and then nobody saves you from hell
2021-09-28 19:44:08 +0200 <Franciman> not even STM in some cases
2021-09-28 19:44:15 +0200 <Franciman> where you need less optimistic behaviours
2021-09-28 19:44:32 +0200 <sclv> this is not true. you at least don't have to deal with a batshit memory model where you manually consider "volatile" declarations and write barriers
2021-09-28 19:44:47 +0200kuribas(~user@ptr-25vy0i9jx2ordo6ztok.18120a2.ip6.access.telenet.be) (Quit: ERC (IRC client for Emacs 26.3))
2021-09-28 19:44:49 +0200 <Franciman> again, this depends
2021-09-28 19:45:13 +0200 <Franciman> MVar can get really nasty, in my experience
2021-09-28 19:45:30 +0200 <Franciman> and STM rerunning the same computation over and over until there is no conflict is not what you need
2021-09-28 19:45:32 +0200 <monochrom> Someone on haskell-cafe recently wrote a great sentence. "You are trading off performance for the ability to preempt."
2021-09-28 19:46:03 +0200 <sclv> if you're being this blase over the memory model in C, that can only be because you're not familiar with how utterly hopeless it is
2021-09-28 19:46:15 +0200 <Franciman> wut
2021-09-28 19:46:21 +0200 <Franciman> do you mean me, sclv ?
2021-09-28 19:46:32 +0200 <monochrom> Yeah, about that.
2021-09-28 19:46:46 +0200 <Franciman> you said: Haskell makes parallel and concurrent computations easy
2021-09-28 19:46:52 +0200 <Franciman> easy is a great understatement
2021-09-28 19:46:57 +0200 <Franciman> in many situations
2021-09-28 19:46:58 +0200 <monochrom> https://queue.acm.org/detail.cfm?id=3212479
2021-09-28 19:47:02 +0200 <dsal> sclv: erlang is slow at computation, but pretty hard to beat in terms of general application latency.
2021-09-28 19:47:04 +0200Guest|33(~Guest|33@65.88.88.200)
2021-09-28 19:47:38 +0200martin02(~silas@141.84.69.76)
2021-09-28 19:47:38 +0200 <sclv> https://bajamircea.github.io/coding/cpp/2019/11/05/cpp11-volatile.html
2021-09-28 19:48:10 +0200 <free_functor> Guest47, I would never joke about important Game/Game-Engine pairings such as Fortnight/Fortran, Team Fortress/Tensor Flow, Minecraft/Malbolge, Halflife/Haskell98, and so on. Telling jokes about modern Games and the Game Engines that run them... is liable to start flame wars.
2021-09-28 19:48:23 +0200YoungChiefBTW(~youngchie@user/youngchiefbtw)
2021-09-28 19:48:59 +0200Guest|33(~Guest|33@65.88.88.200) (Client Quit)
2021-09-28 19:49:24 +0200 <monochrom> Do people still remember browser games and Flash games?
2021-09-28 19:49:36 +0200 <sclv> "easy" as in you don't encounter situations where you said "look i literally said to do this thing in this order, and now its doing something else entirely!??" https://stackoverflow.com/questions/2484980/why-is-volatile-not-considered-useful-in-multithreaded…
2021-09-28 19:50:03 +0200 <monochrom> So apparently nothing went wrong when game engines were writte in javascript or flash. And on 20-year-old hardware, no less.
2021-09-28 19:50:23 +0200chele(~chele@user/chele) (Remote host closed the connection)
2021-09-28 19:51:30 +0200 <free_functor> what is a good example of clean, speed critical haskell code that does heavy numerical lifting of some sort?
2021-09-28 19:51:54 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-09-28 19:51:57 +0200 <Guest47> I personally think CS/C# is the killer combo
2021-09-28 19:52:16 +0200 <asgas> Something like a javascript engine would probably be in C or C++. Could haskell do something like what v8 can do from chrome?
2021-09-28 19:52:57 +0200 <free_functor> hmm, it's not at all fair to ask that the speed critical code should also be clean. I apologize
2021-09-28 19:54:00 +0200 <Franciman> with linear types
2021-09-28 19:54:05 +0200 <Franciman> I think you can go a greater way
2021-09-28 19:54:10 +0200 <sclv> there's a lot of classic highly-optimized (perhaps over-optimized) code in the benchmarks game: https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/haskell.html
2021-09-28 19:54:23 +0200 <Franciman> the main problem of low latency things is the garbage collector, I don't see other problems
2021-09-28 19:54:30 +0200 <asgas> I hope there's no misunderstanding. I'm not trying to start a flame war, I just want to know how haskell compares to more mainstream languages like C++ and why haskell isn't used as much.
2021-09-28 19:54:34 +0200 <Franciman> I don't know enough about how to control the GC
2021-09-28 19:54:50 +0200 <sclv> asgas: anyway the answer isn't performance. that's an old myth
2021-09-28 19:54:59 +0200 <sclv> i write high performance haskell for a day job and its fine
2021-09-28 19:55:00 +0200 <free_functor> Guest47, how many hundreds of lines of C# code do you currently maintain, and what is the total yearly commercial revenue of that code?
2021-09-28 19:55:38 +0200 <Franciman> if you know well the execution model of haskell
2021-09-28 19:55:42 +0200 <Franciman> and know how to wrestle with the GC
2021-09-28 19:55:48 +0200 <Franciman> you can make it go SUUUUUUUUPER fast
2021-09-28 19:55:56 +0200emf_(~emf@2620:10d:c090:400::5:49ef) (Ping timeout: 245 seconds)
2021-09-28 19:56:04 +0200 <sclv> haskell is a fine language that can be used well for almost anything. its just different than other languages and has historically not had a Big Industry Player backing it, and also, the related ecosystem of tooling (ides, special purpose libraries, etc) is correspondingly less mature.
2021-09-28 19:56:10 +0200 <Franciman> another cool thing is that GHC is SUUUUUUPER good at optimizing declarative code
2021-09-28 19:56:20 +0200 <asgas> So even with garbage collection, you could write a fast javascript engine in pure haskell sclv?
2021-09-28 19:56:28 +0200 <sclv> sure
2021-09-28 19:56:30 +0200 <shiraeeshi[m]> Franciman: "and STM rerunning the same computation over and over until there is no conflict is not what you need"
2021-09-28 19:56:30 +0200 <Franciman> so most of the time if you try to do lower level things, it gets slower. So you do your own high level thing
2021-09-28 19:56:42 +0200spruit11(~quassel@2a02:a467:ccd6:1:ed67:f262:991e:7f5)
2021-09-28 19:56:48 +0200 <Franciman> and GHC makes a lot of effort to make it fast, doing a great job, from my tests
2021-09-28 19:56:50 +0200 <shiraeeshi[m]> I heard that STM does something more smart than literally rerunning
2021-09-28 19:56:52 +0200 <monochrom> mainstream? In mainstream there are as many people preferring Java or Python or PHP as there are people preferring C++. So first off proving that performance is not going to be a high priority.
2021-09-28 19:57:24 +0200danso(~danso@23-233-111-52.cpe.pppoe.ca) (Quit: WeeChat 3.2)
2021-09-28 19:57:24 +0200 <Franciman> asgas: imho the only problem of GC is when you want to do performance critical things, like real time systems like video games with ULTRA MEGA DETAILS
2021-09-28 19:57:34 +0200 <Franciman> if you don't need to be within 10ms
2021-09-28 19:57:38 +0200 <shiraeeshi[m]> STM tracks which TVars you read, then waits for them to change and then triggers your transaction
2021-09-28 19:57:39 +0200 <Franciman> haskell is fine
2021-09-28 19:57:45 +0200 <sclv> but note that most fast javascript engines are not interpreters -- they're actually hybrid JIT gadgets that compile on the fly to machine code. the hard part is not the performance of the surrounding language -- its that writing this engine, in any language at all, is a tremendous engineering task.
2021-09-28 19:57:59 +0200 <monochrom> The priorities are, instead, personality, style, ecosystem, networking effect, and dumb luck in which one was your 1st language.
2021-09-28 19:58:11 +0200 <monochrom> And you can see how Haskell can lose on all those fronts.
2021-09-28 19:58:13 +0200 <Franciman> haskell's ecosystem is one of the poorest imho
2021-09-28 19:58:14 +0200 <sclv> so i should qualify and say "very few people, and probably not me, are well equipped to write a fast JITter for js in _any_ language"
2021-09-28 19:58:19 +0200cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.2.1)
2021-09-28 19:58:21 +0200 <Franciman> but it has great other things :)
2021-09-28 19:58:51 +0200 <monochrom> Personally I am not excited about "what if Haskell were more popular". There is no need to fight into the mainstream.
2021-09-28 19:59:12 +0200asgas(~asgas@c-24-30-27-91.hsd1.ga.comcast.net) (Quit: Leaving)
2021-09-28 19:59:20 +0200CiaoSen(~Jura@p2e5c6ba6.dip0.t-ipconnect.de)
2021-09-28 19:59:21 +0200fef(~thedawn@user/thedawn) (Ping timeout: 276 seconds)
2021-09-28 19:59:27 +0200 <monochrom> And here is my answer to what if Haskell were more popular: It would then drop Haskell values and adopt mainstream values, it would no longer be Haskell.
2021-09-28 19:59:36 +0200 <tdammers> exactly
2021-09-28 19:59:53 +0200zebrag(~chris@user/zebrag) (Remote host closed the connection)
2021-09-28 19:59:55 +0200 <Franciman> it is already happening monochrom
2021-09-28 20:00:14 +0200 <monochrom> Do not be naïve. "haskell become mainstream" does not imply "mainstream cherishes Haskell values". Far from it.
2021-09-28 20:00:17 +0200 <maerwald> monochrom: I'm basically saying this all the time whenever HF is pushing for "lets increase adoption in industry" but I have the feeling I'm misunderstood most of the time
2021-09-28 20:00:24 +0200 <Franciman> the time when haskell dropped away the old IO system to use monads
2021-09-28 20:00:26 +0200 <Franciman> are gone
2021-09-28 20:00:29 +0200 <Franciman> now we make thousands of extensions
2021-09-28 20:00:35 +0200 <Franciman> because we also want to be backwords compatible
2021-09-28 20:00:39 +0200 <Franciman> for the corps using haskell
2021-09-28 20:01:10 +0200 <Franciman> now we have legacy and we value it
2021-09-28 20:01:19 +0200 <Franciman> I don't see haskell totally breaking any time soon
2021-09-28 20:01:36 +0200 <Franciman> for example dependent types
2021-09-28 20:01:43 +0200 <Franciman> they work hard to make them retrofit in haskell
2021-09-28 20:01:45 +0200 <Franciman> it seems to me
2021-09-28 20:03:19 +0200free_functoris thinking of porting a profunctorial lenses library to python
2021-09-28 20:04:02 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 246 seconds)
2021-09-28 20:04:25 +0200MoC(~moc@user/moc)
2021-09-28 20:04:59 +0200 <geekosaur> they're just barely started on dependent types. the later stages are likely to be more invasive
2021-09-28 20:05:42 +0200 <free_functor> python has become my go-to language for quick and dirty notebook based computations, and even more complex domain driven designs - mainly because I can just throw open a colab notebook, pull in some numeric or AI libraries, and very quickly do heavy lifting and visualization
2021-09-28 20:06:07 +0200 <monochrom> Perhaps ironically, invasive is good. I complain that the current DataKind and singleton stuff is emulating, encoding, which means clumsy.
2021-09-28 20:06:36 +0200 <free_functor> you can get haskell in colab, but I think it's currently pretty slow and painful
2021-09-28 20:08:31 +0200 <shiraeeshi[m]> haskell should have dialects: industrial haskell, experimental haskell, haskell with memory management fixed, etc.
2021-09-28 20:08:34 +0200martin02(~silas@141.84.69.76) (Ping timeout: 250 seconds)
2021-09-28 20:09:07 +0200 <shiraeeshi[m]> haskell with exceptions fixed
2021-09-28 20:09:09 +0200martin02(~silas@141.84.69.76)
2021-09-28 20:09:13 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2) (Remote host closed the connection)
2021-09-28 20:09:19 +0200 <tdammers> it already does
2021-09-28 20:09:27 +0200 <tdammers> in much the same way as C++ does
2021-09-28 20:09:41 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-09-28 20:09:56 +0200 <shiraeeshi[m]> haskell that doesn't care about backwards compatibility and legasy
2021-09-28 20:10:32 +0200 <shiraeeshi[m]> haskell that cares about backwards compatibility and legacy
2021-09-28 20:10:35 +0200 <free_functor> shiraeeshi[m], that's kind of how I think of haskell within a project I'm reading lately. The author enables a couple dozen extensions, and some parts are like the hyper-modern space haskell that I don't fully understand
2021-09-28 20:12:20 +0200myShoggoth(~myShoggot@97-120-70-214.ptld.qwest.net)
2021-09-28 20:13:01 +0200max22-(~maxime@2a01cb088335980013e52131b43b1c30.ipv6.abo.wanadoo.fr) (Ping timeout: 265 seconds)
2021-09-28 20:14:24 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f920:a9dd:18bc:fca2)
2021-09-28 20:15:13 +0200 <free_functor> shiraeeshi[m], it would be nice to see a commercial distibution of haskell - I'm not sure if you can buy support licenses for haskell application servers
2021-09-28 20:15:37 +0200 <free_functor> Does any company currently have the audacity to charge hefty bux for special, mission critical haskell runtimes and libraries?
2021-09-28 20:17:01 +0200free_functorfeels there must be some fintech offerings here... and I think there are other commercial haskel based DSLs like cryptol
2021-09-28 20:17:11 +0200benin0369323017(benin@gateway/vpn/protonvpn/benin)
2021-09-28 20:17:44 +0200 <monochrom> I think yes. FP Complete. Galois.
2021-09-28 20:18:19 +0200 <monochrom> Well, not literally runtimes and libraries.
2021-09-28 20:18:35 +0200 <monochrom> They write Haskell programs for you.
2021-09-28 20:18:50 +0200benin036932301(~benin@183.82.176.107) (Ping timeout: 268 seconds)
2021-09-28 20:18:51 +0200benin0369323017benin036932301
2021-09-28 20:18:55 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net) (Remote host closed the connection)
2021-09-28 20:19:30 +0200 <monochrom> Galois probably fulfills "mission critical" too because they care about verification, IIUC.
2021-09-28 20:19:42 +0200 <geekosaur> well-typed?
2021-09-28 20:20:01 +0200 <monochrom> Yeah, I forgot that one.
2021-09-28 20:21:12 +0200 <monochrom> The Haskell Duality Theorem: The two questions "where can I find Haskell jobs?" and "where can I buy Haskell code from?" are reducible to each other. >:)
2021-09-28 20:21:24 +0200darkstardevx(~darkstard@2601:1c2:300:c8a0::f2b6) (Read error: Connection reset by peer)
2021-09-28 20:21:51 +0200 <exarkun> The mainstream is very mediocre. What would Haskell going mainstream mean, apart from being able to do very mediocre things with it?
2021-09-28 20:22:07 +0200 <monochrom> consumerism and producerism form an adjunction >:)
2021-09-28 20:22:22 +0200benin0369323011(~benin@183.82.176.107)
2021-09-28 20:22:34 +0200 <awpr> does that mean Western society forms a monad?
2021-09-28 20:23:13 +0200 <monochrom> I think no.
2021-09-28 20:23:30 +0200 <monochrom> My understanding is that Western society is consumerism, Eastern society is producerism.
2021-09-28 20:24:00 +0200 <exarkun> I suspect that is ... reductive
2021-09-28 20:24:18 +0200 <monochrom> Oh, very oversimplification, yes.
2021-09-28 20:24:41 +0200benin036932301(benin@gateway/vpn/protonvpn/benin) (Ping timeout: 264 seconds)
2021-09-28 20:24:41 +0200benin0369323011benin036932301
2021-09-28 20:24:46 +0200 <monochrom> But how is "Western society is consumerism and producerism" any less simplifying?
2021-09-28 20:25:13 +0200 <monochrom> And what's with singling out Western society?
2021-09-28 20:25:22 +0200 <exarkun> poor Western society, always picked on
2021-09-28 20:25:43 +0200 <monochrom> Is there any society that's any different? Honestly? Not believing certain exotic government propanganda?
2021-09-28 20:26:16 +0200 <exarkun> Only photosynthesizing communities truly embrace producerism
2021-09-28 20:26:26 +0200 <monochrom> heh
2021-09-28 20:28:07 +0200 <shiraeeshi[m]> well, they consume sunlight
2021-09-28 20:29:19 +0200 <Rembane> Star communities.
2021-09-28 20:29:44 +0200 <free_functor> monochrom, western per-capita carbon production is 20x higher than human per-capita carbon production, whereas a collapse of western society would reduce that number to merely 10x, if the collapse of the soviet union is a good model of carbon reduction effect of central collapse.
2021-09-28 20:30:44 +0200 <free_functor> therefore it's ethical and good to dog on western civilization if you are indeed part of western civilization - this is the internal sabotage theorem
2021-09-28 20:32:03 +0200 <exarkun> Should have known there would be sleepers from the stellar faction lurking
2021-09-28 20:32:50 +0200CiaoSen(~Jura@p2e5c6ba6.dip0.t-ipconnect.de) (Ping timeout: 265 seconds)
2021-09-28 20:34:09 +0200 <Lycurgus> western society is still not not christendom, or vestigial islam if you like
2021-09-28 20:35:28 +0200 <Lycurgus> things like consumerism, capitalism are way bigger than the west which is only even a thing because it was able to oversettle the americas
2021-09-28 20:35:51 +0200 <Lycurgus> and with that dominate the planet for a while
2021-09-28 20:36:32 +0200 <geekosaur> hasn't this discussion kinda slid off into offtopic-land?
2021-09-28 20:37:00 +0200 <Lycurgus> yeah i thought I'd push it to a termination
2021-09-28 20:37:43 +0200lavaman(~lavaman@98.38.249.169)
2021-09-28 20:38:04 +0200darkstardevx(~darkstard@2601:1c2:300:c8a0::f2b6)
2021-09-28 20:38:20 +0200 <Lycurgus> but for profit hs shops is sure on topic
2021-09-28 20:40:35 +0200 <Lycurgus> sfaict, their internal relations notwithstanding, being forced into FOSS culture, they are generally a good thing merging
2021-09-28 20:40:52 +0200 <Lycurgus> commercial standards with the standards of hs
2021-09-28 20:42:06 +0200 <Lycurgus> the conjecture might be that they have some wonderful thing that they're not sharing
2021-09-28 20:42:11 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 245 seconds)
2021-09-28 20:42:19 +0200 <Lycurgus> but that's unlikely to be true
2021-09-28 20:42:47 +0200 <free_functor> I am still not convinced that I can pay for someone to take my haskell platform woes off my hands so I can focus on writing teeny tiny haskell microservices that seamless run on both in house and cloud resources. Like, I think you could extend Serverless to support haskel, but really I want to pay for someone to have already done this thing
2021-09-28 20:43:21 +0200 <ldlework> lol
2021-09-28 20:43:24 +0200 <free_functor> and to deliver it to me for 30 bux a month or so
2021-09-28 20:43:44 +0200 <ldlework> free_functor: if only there were enough of you
2021-09-28 20:43:49 +0200 <geekosaur> I'd imagine it would cost more than that even if it was provided
2021-09-28 20:44:17 +0200 <geekosaur> although I should note that people have written starts to such things… and then gotten hired away from working on them
2021-09-28 20:44:32 +0200 <geekosaur> unless they've been developing them in-house
2021-09-28 20:44:41 +0200 <geekosaur> (cloud haskell, anyone?)
2021-09-28 20:44:47 +0200 <Lycurgus> 30 usd is about a minimum for hosting service alone
2021-09-28 20:45:07 +0200 <free_functor> geekosaur, I think bigger languages enjoy an economy of scale... once you solve certain scaling and API and interface design problems, I think it get very very cheap to offer that infrustructure to many tenants
2021-09-28 20:45:14 +0200 <Lycurgus> with a few physical threads and TB of transfer
2021-09-28 20:45:59 +0200 <Lycurgus> double that for a hs service that was customer specific would be reasonable
2021-09-28 20:46:05 +0200 <Lycurgus> *wasn't
2021-09-28 20:47:00 +0200chris(~chris@81.96.113.213)
2021-09-28 20:47:04 +0200chrisGuest2198
2021-09-28 20:47:21 +0200 <Lycurgus> but haskell doesn't have mass appeal so it hits that when capital is being allocated
2021-09-28 20:47:26 +0200 <free_functor> Lycurgus, I think it is not pretty reasonable to run a few lambda microservice for less than 5 bux a month, if the workloads are not heavy
2021-09-28 20:47:30 +0200 <free_functor> err
2021-09-28 20:47:43 +0200 <free_functor> s/not//
2021-09-28 20:48:14 +0200 <Lycurgus> sure just a service
2021-09-28 20:48:38 +0200 <Lycurgus> I was thinking more something that would bundle computing resources with it
2021-09-28 20:49:01 +0200 <Lycurgus> but just use of an api, that's a order lower in price domains
2021-09-28 20:51:03 +0200 <free_functor> I'm really interested in the whole idea of maintaining these tiny snippets of code. and the whole compilation, testing, and deployment basically happens automatically after a commit passes review
2021-09-28 20:52:05 +0200 <free_functor> I believe it is pretty easy to build this in go, javascript, python, or java, and I think that's because the platforms have nice tooling for those languages specifically
2021-09-28 20:52:34 +0200 <free_functor> but I haven't looked into what kind of extra trouble you might need to get amazon lambda running your haskell microservices, for example
2021-09-28 20:53:09 +0200 <free_functor> so i would defer to someone with more combined cloud and haskell experience
2021-09-28 20:54:04 +0200 <Lycurgus> and ofc the nature of the service provided by the API determines price
2021-09-28 20:54:27 +0200 <Lycurgus> the crossing from the one domain to the other is when privisioning is undertaken
2021-09-28 20:54:33 +0200emf(~emf@163.114.132.6)
2021-09-28 20:55:00 +0200 <Lycurgus> and how that is handled between the customer and the actual provider of the provisioned inventory
2021-09-28 20:55:18 +0200 <Lycurgus> for whom for me the defaults are AWS and linode
2021-09-28 20:56:05 +0200max22-(~maxime@2a01cb0883359800a9478b4b8829df15.ipv6.abo.wanadoo.fr)
2021-09-28 20:56:14 +0200 <shiraeeshi[m]> free_functor: I'm not sure I understand what are you willing to pay for. You can pay for a dedicated server and install anything you want. Unless you're talking about PAAS and IAAS companies creating haskell APIs.
2021-09-28 20:56:14 +0200 <Lycurgus> i in general avoid branded solutions when generic ones are clear to me (i.e. aws lambda)
2021-09-28 20:56:36 +0200farmfrmjakestate(~farmfromj@user/farmfrmjakestate)
2021-09-28 20:57:10 +0200 <free_functor> I will grant that the multi-cloud / hybrid cloud + baremetal story is currently a nightmare for both kubernetes and any "functions as a service" platform I've seen
2021-09-28 20:58:39 +0200 <free_functor> nobody /really/ wants to write software that can provision and seamlessly integrate, for example, an AWS machine, a digital ocean node, and 4 local raspberry pi servers
2021-09-28 20:59:00 +0200Guest2198(~chris@81.96.113.213) (Remote host closed the connection)
2021-09-28 20:59:07 +0200rtjure(~rtjure@bras-79-132-17-74.comnet.bg) (Ping timeout: 240 seconds)
2021-09-28 21:01:49 +0200 <free_functor> Lycurgus, I hear there has enough standardization around lambda that now we have competing DIY faas systems like Knative and Serverless. And if I'm not mistaken, loading haskell into one of these custom FAAS engines would be a "easy" as writing a knative plugin for haskell, or what have you
2021-09-28 21:01:50 +0200 <shiraeeshi[m]> free_functor: "nobody /really/ wants to write software that can provision and seamlessly integrate, for example, an AWS machine, a digital ocean node, and 4 local raspberry pi servers"
2021-09-28 21:02:15 +0200 <shiraeeshi[m]> what are talking about? you make them talk through REST services, no?
2021-09-28 21:02:26 +0200 <ldlework> free_functor: that's what i did at docker, before swarm or k8s were things
2021-09-28 21:02:30 +0200 <free_functor> but at the end of the day who are your customers, I guess - we get back to ldlework's idea that there are not enough customers who would want this
2021-09-28 21:02:35 +0200 <shiraeeshi[m]> you provision them using APIs
2021-09-28 21:02:38 +0200 <ldlework> i was pretty hyped at the time
2021-09-28 21:03:59 +0200Guest1162(~chris@81.96.113.213)
2021-09-28 21:04:03 +0200 <Lycurgus> free_functor, aknowledged
2021-09-28 21:04:47 +0200 <Lycurgus> *acknowledged
2021-09-28 21:06:41 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 264 seconds)
2021-09-28 21:08:26 +0200Guest1162(~chris@81.96.113.213) (Ping timeout: 246 seconds)
2021-09-28 21:11:24 +0200 <free_functor> shiraeeshi[m], you have two bare metal nodes on premises, which can handle all your requests. If these nodes go down, don't worry, because lambda will run the same workloads with hot fail-over for your users. How do you set up the hot fail over? How do you ensure that the same code that runs on the machines also runs on lambda? Would you say your current solution let you do this with little to no pain? If so, I'm curious how
2021-09-28 21:11:26 +0200emf(~emf@163.114.132.6) (Ping timeout: 252 seconds)
2021-09-28 21:11:29 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-28 21:12:24 +0200mei(~mei@user/mei)
2021-09-28 21:13:37 +0200 <free_functor> the closes multi-cloud + baremetal orchestration system that I know about is Redhat's OpenStack / OK4. But open stack is by no means a lightweight system that you deploy on some random hetergenous servers and raspberry pis
2021-09-28 21:13:51 +0200emf(~emf@2620:10d:c090:400::5:9ff)
2021-09-28 21:17:17 +0200Lycurgus(~juan@98.4.112.204) (Quit: Exeunt)
2021-09-28 21:17:25 +0200chomwitt(~chomwitt@2a02:587:dc0a:5800:12c3:7bff:fe6d:d374) (Ping timeout: 252 seconds)
2021-09-28 21:17:29 +0200Guest47(~Guest47@eth-west-pareq2-46-193-4-100.wb.wifirst.net) (Quit: Client closed)
2021-09-28 21:18:31 +0200 <free_functor> shiraeeshi[m], for example of multicloud code "nobody" wants to write, imagine a system that can refactor your deployment so that is uses more azure servers one month, more AWS servers another month, always choosing the deployment will perform the work cheapest
2021-09-28 21:19:34 +0200 <free_functor> amazon certainly does not want to write that federation code, and neither does microsoft - so right there the two most competent candidates refuse to touch the project
2021-09-28 21:20:45 +0200 <free_functor> who is left? well, people who are willing to write federation code for customers who are /so cheap/ they want to nickle and dime the spot rate across multiple clouds
2021-09-28 21:23:10 +0200zer0bitz(~zer0bitz@dsl-hkibng31-54fafc-123.dhcp.inet.fi) (Ping timeout: 260 seconds)
2021-09-28 21:25:07 +0200roboguy(~roboguy@user/roboguy) ()
2021-09-28 21:28:46 +0200emf(~emf@2620:10d:c090:400::5:9ff) (Ping timeout: 260 seconds)
2021-09-28 21:34:58 +0200qbt(~edun@user/edun) (Remote host closed the connection)
2021-09-28 21:35:57 +0200MoC(~moc@user/moc) (Quit: Konversation terminated!)
2021-09-28 21:42:06 +0200emf(~emf@163.114.132.6)
2021-09-28 21:45:57 +0200farmfrmjakestate(~farmfromj@user/farmfrmjakestate) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-09-28 21:51:29 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 246 seconds)
2021-09-28 22:02:43 +0200acidjnk_new(~acidjnk@p200300d0c703cb495908c3ed7e15521a.dip0.t-ipconnect.de)
2021-09-28 22:03:33 +0200 <ldlework> free_functor: what we did at docker was write a DSL that was backed by a "driver" system
2021-09-28 22:03:41 +0200 <ldlework> basically just implementing an interface essentially
2021-09-28 22:04:08 +0200 <ldlework> the most difficult part was not in implementing the interface but coming up with a useful common demoninator for our purposes at the time
2021-09-28 22:05:00 +0200nfd(~nfd@user/nfd) (Ping timeout: 265 seconds)
2021-09-28 22:05:06 +0200juhp(~juhp@128.106.188.220) (Ping timeout: 245 seconds)
2021-09-28 22:05:21 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-28 22:06:21 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2021-09-28 22:06:45 +0200juhp(~juhp@128.106.188.220)
2021-09-28 22:12:20 +0200acidjnk_new3(~acidjnk@p200300d0c703cb49b458fc4f9b844b2d.dip0.t-ipconnect.de)
2021-09-28 22:15:38 +0200acidjnk_new(~acidjnk@p200300d0c703cb495908c3ed7e15521a.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2021-09-28 22:17:13 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-09-28 22:17:32 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-28 22:20:43 +0200fvr(uid503686@id-503686.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2021-09-28 22:25:31 +0200oxide(~lambda@user/oxide) (Quit: oxide)
2021-09-28 22:29:23 +0200 <free_functor> ldlework, what kinds of operations did implement, and what do you mean by common denominator? Were you repackaging external cloud vendors in order to provide docker's own multitenant services?
2021-09-28 22:33:41 +0200 <ldlework> free_functor: we had a complex container based system that we needed to deploy and there were no orchestrators around yet. company wanted to ensure that we could deploy/migrate to azure at anytime. so we made a DSL that let us describe compute, storage, routing information, and that was backed by a cloud specific driver that you could swap out.
2021-09-28 22:39:48 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 250 seconds)
2021-09-28 22:40:42 +0200charukiewicz(~quassel@108.210.196.136)
2021-09-28 22:41:30 +0200 <free_functor> I think these days there are solutions like terraform and pulumi, but I sm not sure if they let you specify abstract services and dynamically set up multi-cloud deployment and routing.
2021-09-28 22:42:31 +0200ubert(~Thunderbi@178.115.72.201.wireless.dyn.drei.com) (Ping timeout: 268 seconds)
2021-09-28 22:42:38 +0200terrorjack(~terrorjac@2a05:d012:f4:f400:3981:7d7e:56ee:2dd9) (Quit: The Lounge - https://thelounge.chat)
2021-09-28 22:42:59 +0200 <free_functor> My use case is that I have a raspberry pi, a couple android devices, a linux work station / server, and a $5 digital ocean node
2021-09-28 22:44:40 +0200 <free_functor> and I want to be able to build a failsafe kubernetes cluster across these resources in 20 lines meta-orchestrator code... and I think I can't do that yet because reasons
2021-09-28 22:44:49 +0200 <lbseale> Does anyone have a recommendation for an automatic style-checking tool? Must be able to warn for line lengths
2021-09-28 22:44:51 +0200ec(~ec@gateway/tor-sasl/ec)
2021-09-28 22:45:24 +0200 <free_functor> lbseale, in python I use a pep-8 checker, and it's really persnickkety
2021-09-28 22:45:54 +0200 <free_functor> like it wants me to put two lines before and after each class declaration
2021-09-28 22:46:11 +0200 <lbseale> ok I'm looking for #haskell
2021-09-28 22:46:21 +0200 <free_functor> so what?
2021-09-28 22:46:26 +0200Morrow(~Morrow@147.161.14.157) (Ping timeout: 246 seconds)
2021-09-28 22:46:39 +0200 <ldlework> free_functor: yeah, none of those things existed at the time
2021-09-28 22:47:21 +0200 <lbseale> free_functor: isn't pep-8 a python standard? I am looking for a specific tool to check haskell code
2021-09-28 22:47:25 +0200charukiewicz(~quassel@108.210.196.136) (Quit: Quitting...)
2021-09-28 22:48:01 +0200 <free_functor> lbseale, yeah hol tf on while I google stylish-haskell for u, my impatient frend
2021-09-28 22:48:16 +0200 <free_functor> https://hackage.haskell.org/package/stylish-haskell
2021-09-28 22:49:12 +0200 <free_functor> this /could/ do what you need, but I have no idea - read and find out and tell me, because now I am curious1
2021-09-28 22:51:01 +0200ubert(~Thunderbi@178.115.72.201.wireless.dyn.drei.com)
2021-09-28 22:53:36 +0200charukiewicz(~quassel@108.210.196.136)
2021-09-28 22:53:39 +0200zebrag(~chris@user/zebrag)
2021-09-28 22:54:49 +0200 <free_functor> lbseale, nope, haskell-stylish does not warn on line numbers. The closest feature is the step that drops trailing white spaces: https://github.com/haskell/stylish-haskell/blob/main/lib/Language/Haskell/Stylish/Step/TrailingWhi…
2021-09-28 22:55:17 +0200bgamari_bgamari
2021-09-28 22:55:23 +0200 <lbseale> free_functor: yeah I couldn't find it anywhere. But this is definitely the kind of thing I had in mind
2021-09-28 22:55:54 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Ping timeout: 265 seconds)
2021-09-28 22:56:22 +0200 <lbseale> I haven't found anything with hlint for line length either, is it a bad idea to try to check for this? Or is there some more generic tool that can do that?
2021-09-28 22:57:03 +0200lavaman(~lavaman@98.38.249.169)
2021-09-28 22:57:16 +0200cunne(~cunne@user/cunne)
2021-09-28 22:57:21 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-28 22:57:30 +0200 <free_functor> I would use a grep to select and display all lines that are longer than 55 lines and consider refactoring the longlines
2021-09-28 22:57:40 +0200farmfrmjakestate(~farmfromj@user/farmfrmjakestate)
2021-09-28 23:00:18 +0200Cajun(~Cajun@user/cajun)
2021-09-28 23:01:38 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 268 seconds)
2021-09-28 23:02:46 +0200ysavd^(~ysavd@68.101.50.106) (Ping timeout: 250 seconds)
2021-09-28 23:03:13 +0200 <free_functor> lbseale, do grep -REn '^.{55}.*' in your project source root
2021-09-28 23:03:53 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Quit: Leaving)
2021-09-28 23:04:31 +0200 <lbseale> free_functor: nice, it definitely works
2021-09-28 23:04:34 +0200 <free_functor> that greps all lines that ^begin, do .anything for 55 charachters, and then have .more* charachters... and it does so recursively for each file in the directory, uses Extened regex to do so, and gives you the line number for each match
2021-09-28 23:05:09 +0200jumper149(~jumper149@80.240.31.34) (Quit: WeeChat 3.2)
2021-09-28 23:05:56 +0200 <free_functor> in VScode do a multi-file find with the regex ^.{55}.* to find all long lines
2021-09-28 23:06:21 +0200NieDzejkob(~quassel@195.149.98.3) (Ping timeout: 250 seconds)
2021-09-28 23:07:27 +0200NieDzejkob(~quassel@195.149.98.3)
2021-09-28 23:07:28 +0200vysn(~vysn@user/vysn)
2021-09-28 23:07:37 +0200 <free_functor> "Stinky detects a range of bad smells identified as
2021-09-28 23:07:37 +0200 <free_functor> common by University of Kent staff involved in teaching
2021-09-28 23:07:37 +0200 <free_functor> Haskell to 1st year computer science students"
2021-09-28 23:07:45 +0200 <free_functor> https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.114.9950&rep=rep1&type=pdf
2021-09-28 23:08:14 +0200mestre(~mestre@191.177.175.57)
2021-09-28 23:08:32 +0200seydar(~seydar@154-27-113-252.starry-inc.net)
2021-09-28 23:08:38 +0200 <free_functor> lbseale, section 6.7 describes a detector for "unecessarily long lines of code"
2021-09-28 23:09:40 +0200 <seydar> For some reason, my install of ghc (fresh from homebrew) can't find any standard packages (specifically Network.Socket). Is there a command I can run to better identify why it can't see anything?
2021-09-28 23:12:05 +0200Guest7240(~Guest72@eth-west-pareq2-46-193-4-100.wb.wifirst.net)
2021-09-28 23:12:44 +0200Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2021-09-28 23:12:45 +0200michalz(~michalz@185.246.204.58) (Remote host closed the connection)
2021-09-28 23:13:58 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 252 seconds)
2021-09-28 23:14:56 +0200Null_A(~null_a@2601:645:8700:2290:91f2:4a69:be9c:a77e)
2021-09-28 23:15:31 +0200Lord_of_Life_Lord_of_Life
2021-09-28 23:15:46 +0200 <monochrom> Here is a puzzle for you. What LOL mistake did I make that caused a memoizing algorithm to be slow? https://paste.tomsmeding.com/WtRqoWl1
2021-09-28 23:18:26 +0200pbrisbin(~patrick@pool-173-49-147-250.phlapa.fios.verizon.net) (Ping timeout: 245 seconds)
2021-09-28 23:20:29 +0200 <xerox> n-2 before n-1 ?
2021-09-28 23:20:29 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-28 23:20:29 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-28 23:20:29 +0200wroathe(~wroathe@user/wroathe)
2021-09-28 23:20:51 +0200 <monochrom> That doesn't make a big difference either.
2021-09-28 23:21:50 +0200 <awpr> don't want to spoil the answer, but `modify` might have had better luck`
2021-09-28 23:21:58 +0200 <monochrom> heehee
2021-09-28 23:22:09 +0200 <xerox> oops
2021-09-28 23:23:05 +0200 <seydar> monochrom: you retrieve the cache within the `go` function, so it's pulling the original base cache instead of the updated one?
2021-09-28 23:23:12 +0200 <monochrom> Yeah
2021-09-28 23:24:19 +0200 <seydar> i wouldn't have noticed it without awpr's hint — just the right level of helpful without giving it away
2021-09-28 23:24:25 +0200 <monochrom> So, after 5 days, out of the blue, I decided to look at Map.size of the final cache, and it's like 3, even if I attempt "fib 50". That was very surprising and pointed me in the right direction.
2021-09-28 23:24:32 +0200 <sm> my haskell dev instincts say "this code probably is defeating my hilarious performance aspirations in multiple ways"
2021-09-28 23:25:58 +0200 <sm> some sanity trace-ing on first few runs would have helped I guess
2021-09-28 23:26:44 +0200 <arahael> I'm afraid I'm not really getting it either!
2021-09-28 23:26:48 +0200Brumaire(~quassel@81-64-14-121.rev.numericable.fr) (Remote host closed the connection)
2021-09-28 23:26:57 +0200 <arahael> Even when it's spelled out by seydar!
2021-09-28 23:27:32 +0200 <monochrom> >:)
2021-09-28 23:27:37 +0200rtjure(~rtjure@bras-79-132-17-74.comnet.bg)
2021-09-28 23:27:49 +0200 <arahael> Oh, do'h. Just saw it.
2021-09-28 23:28:46 +0200 <arahael> monochrom: The other question, however is... How do you fix it?
2021-09-28 23:29:18 +0200 <monochrom> After the two recursive calls, you should "get" again for the most up-to-date cache before you "put".
2021-09-28 23:29:33 +0200 <monochrom> Or even more nicely, use "modify (Map.insert n a)".
2021-09-28 23:29:58 +0200 <arahael> So some aren't memoised, but at least most of them are?
2021-09-28 23:30:12 +0200 <arahael> I mean, so most of the cache accesses are hits.
2021-09-28 23:30:45 +0200 <arahael> Yeah, that's crazy subtle. I need a coffee, haven't had a coffee yet. (Just woke up)
2021-09-28 23:31:04 +0200 <monochrom> No. In the bad version, change "evalState" to "execState" to print the final Map and be very surprised that it basically memoizes nothing.
2021-09-28 23:31:32 +0200 <seydar> monochrom: oh, so it wasn't about the placement of your initial `cache <- get` expression?
2021-09-28 23:31:43 +0200 <monochrom> Or even what sm says. Print out the intermediate caches very often to see how it is not growing.
2021-09-28 23:31:48 +0200 <seydar> (<--- haskell nub)
2021-09-28 23:31:59 +0200 <monochrom> No, the initial get is necessary.
2021-09-28 23:32:19 +0200 <monochrom> You have to get and lookup, you can't avoid that, and you can't postpone that either.
2021-09-28 23:32:47 +0200 <seydar> I was thinking you would place it sooner, but now I see all the pieces falling into place and everything making sense
2021-09-28 23:33:21 +0200 <lbseale> free_functor: `hindent` is a nice tool for dealing with line lengths (https://github.com/mihaimaruseac/hindent)
2021-09-28 23:34:04 +0200 <arahael> monochrom: What I'm not completely clear on, is how to ensure that the 'go n-1' and 'go n-2' routines get actual benefit from the cache, even if the result does eventually get in.
2021-09-28 23:34:21 +0200 <sm> trace - the killer haskell analysis tool
2021-09-28 23:36:08 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 250 seconds)
2021-09-28 23:36:22 +0200 <monochrom> You want "go (n-2)" to add its findings to the cache, so that "go (n-1)" finds them in the cache.
2021-09-28 23:37:23 +0200 <monochrom> Or generally, the 2nd recursive call doesn't have to work as hard as the 1st.
2021-09-28 23:37:52 +0200zebrag(~chris@user/zebrag) (Ping timeout: 250 seconds)
2021-09-28 23:38:07 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-09-28 23:41:01 +0200 <free_functor> lbseale, hindent looks like the most versatile and active tool so far, good find!
2021-09-28 23:44:18 +0200 <free_functor> I wonder if you can declare hindent as a pre-commit hook via a cabal file
2021-09-28 23:45:09 +0200 <free_functor> perhaps in some kind of no-op warning mode for long lines and other pet peeves
2021-09-28 23:46:47 +0200 <arahael> monochrom: do they complete sequentially?
2021-09-28 23:49:35 +0200 <sshine> has anyone here used the 'hkd-delta' package for anything interesting?
2021-09-28 23:49:40 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net)
2021-09-28 23:49:47 +0200farmfrmjakestate(~farmfromj@user/farmfrmjakestate) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-09-28 23:50:18 +0200nvmd(~nvmd@user/nvmd) (Quit: Later, nerds.)
2021-09-28 23:54:16 +0200yauhsien(~yauhsien@118-167-48-21.dynamic-ip.hinet.net) (Ping timeout: 245 seconds)
2021-09-28 23:54:21 +0200 <free_functor> in python's poetry and javascript's npm package managers, you can automatically run pre-commit hooks when you try to bump the project's current version - these might include tests, code linters, and so on.
2021-09-28 23:55:07 +0200 <dminuoso> 23:34:21 sm | trace - the killer haskell analysis tool
2021-09-28 23:55:09 +0200 <monochrom> arahael: Yes, the State monad's >>= is fundamentally sequential. If you change over to ST, even more so.
2021-09-28 23:55:25 +0200 <dminuoso> Heh, oh yeah this "why the heck is this printed a gazillion times" tool :-)
2021-09-28 23:55:40 +0200 <free_functor> In addition, you can add tasks that you can invoke, like "npm run lintmaster_9000"
2021-09-28 23:56:02 +0200 <sm> that's some valuable analysis right there! :)
2021-09-28 23:56:27 +0200 <dminuoso> sm: Can you share your thoughts, please?
2021-09-28 23:56:32 +0200 <dminuoso> Sorry, couldn't resist that pun.
2021-09-28 23:57:06 +0200 <sm> pun ? that went way over my head :)
2021-09-28 23:57:07 +0200 <arahael> monochrom, makes sense!
2021-09-28 23:57:20 +0200 <monochrom> I think I don't get the pun. Is it just "trace is how GHC shares its thoughts"?
2021-09-28 23:57:49 +0200terrorjack(~terrorjac@static.3.200.12.49.clients.your-server.de)
2021-09-28 23:58:20 +0200 <dminuoso> Was just hinting at that when trace prints a gazillion times unexpectedly, it could just be a missed sharing/memoization location.
2021-09-28 23:58:32 +0200 <monochrom> Oh!
2021-09-28 23:58:41 +0200 <sm> trace really is a killer tool, but I don't mean always just vanilla `trace`. Eg I add pretty printing and runtime choice of debug level, for a bit more control
2021-09-28 23:58:42 +0200 <monochrom> Yeah, definitely.
2021-09-28 23:59:02 +0200 <monochrom> Your puns are very sophisticated. I guess this is the difference between good puns and dad jokes.
2021-09-28 23:59:08 +0200monochromcan only do dad jokes.
2021-09-28 23:59:49 +0200 <free_functor> it looks like a cabal file could specify a project's linting routines by defining special execution targets for cabal run. Is that true?