IRCBrowse

2023/09/22

2023-09-22 00:00:18 +0200Alleria(~JohnGalt@user/alleria)
2023-09-22 00:01:14 +0200 <geekosaur> (nothing before 8.10.5 supports apple silicon, and 8.10.5 and 8.10.6 are unusably buggy)
2023-09-22 00:04:33 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 258 seconds)
2023-09-22 00:05:13 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-09-22 00:05:19 +0200cole-k(~cole@128.54.36.179) (Ping timeout: 258 seconds)
2023-09-22 00:05:43 +0200raym(~ray@user/raym) (Ping timeout: 264 seconds)
2023-09-22 00:07:33 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2)
2023-09-22 00:08:30 +0200 <haskellbridge> <s​m> the ghc issue tracker is full of platform specific bugs with each ghc version, especially before 9.4
2023-09-22 00:09:01 +0200 <haskellbridge> <s​m> maybe working in a linux vm would be quicker
2023-09-22 00:10:20 +0200 <jackdk> The 8.6 era may be usable on mac via nix - I think nixpkgs had decent enough darwin support back then
2023-09-22 00:12:09 +0200Alleria(~JohnGalt@user/alleria) (Quit: Textual IRC Client: www.textualapp.com)
2023-09-22 00:15:43 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-22 00:16:19 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2) (Ping timeout: 245 seconds)
2023-09-22 00:17:13 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2)
2023-09-22 00:21:02 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 258 seconds)
2023-09-22 00:21:55 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2) (Ping timeout: 264 seconds)
2023-09-22 00:23:03 +0200misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 240 seconds)
2023-09-22 00:25:13 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-09-22 00:25:24 +0200smoothdev(~smoothdev@2a01:e0a:279:fb20:4cf8:38ef:a356:a6a) (Ping timeout: 240 seconds)
2023-09-22 00:26:40 +0200smoothdev(~smoothdev@2a01:e0a:279:fb20:7dd9:976f:b2c3:2ca)
2023-09-22 00:27:14 +0200cole-k(~cole@128.54.36.179)
2023-09-22 00:31:45 +0200gmg(~user@user/gehmehgeh) (Quit: Leaving)
2023-09-22 00:31:46 +0200cole-k(~cole@128.54.36.179) (Ping timeout: 258 seconds)
2023-09-22 00:43:02 +0200danza(~francesco@na-19-82-154.service.infuturo.it) (Ping timeout: 260 seconds)
2023-09-22 00:47:32 +0200Lycurgus(~juan@user/Lycurgus)
2023-09-22 00:48:06 +0200privacy(~privacy@47.219.84.6) (Quit: Leaving)
2023-09-22 00:48:52 +0200privacy(~privacy@47.219.84.6)
2023-09-22 00:51:34 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2)
2023-09-22 00:55:36 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-09-22 00:57:01 +0200kaskal(~kaskal@213-147-167-98.nat.highway.webapn.at) (Quit: ZNC - https://znc.in)
2023-09-22 00:57:32 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-09-22 00:57:35 +0200kaskal(~kaskal@213-147-167-98.nat.highway.webapn.at)
2023-09-22 00:57:59 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2) (Ping timeout: 255 seconds)
2023-09-22 00:59:44 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-09-22 01:00:11 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2)
2023-09-22 01:05:43 +0200aforemny(~aforemny@2001:9e8:6cf3:1100:cc54:3ca5:e7eb:bd95) (Ping timeout: 264 seconds)
2023-09-22 01:09:52 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2) (Ping timeout: 260 seconds)
2023-09-22 01:12:57 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2)
2023-09-22 01:14:58 +0200smoothdev_(~smoothdev@2a01:e0a:279:fb20:cded:cb9e:f595:9b75)
2023-09-22 01:15:00 +0200smoothdev(~smoothdev@2a01:e0a:279:fb20:7dd9:976f:b2c3:2ca) (Ping timeout: 246 seconds)
2023-09-22 01:15:00 +0200smoothdev_smoothdev
2023-09-22 01:19:17 +0200aforemny(~aforemny@i59F516F1.versanet.de)
2023-09-22 01:19:54 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Ping timeout: 244 seconds)
2023-09-22 01:20:59 +0200Lycurgus(~juan@user/Lycurgus) (Quit: Tschüss)
2023-09-22 01:21:38 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-22 01:25:50 +0200smoothdev_(~smoothdev@91-169-231-236.subs.proxad.net)
2023-09-22 01:26:37 +0200bontaq(~user@ool-45707d2c.dyn.optonline.net) (Ping timeout: 244 seconds)
2023-09-22 01:26:43 +0200smoothdev(~smoothdev@2a01:e0a:279:fb20:cded:cb9e:f595:9b75) (Ping timeout: 264 seconds)
2023-09-22 01:26:43 +0200smoothdev_smoothdev
2023-09-22 01:39:22 +0200wroathe(~wroathe@user/wroathe)
2023-09-22 01:40:29 +0200deriamis(deriamis@ec2-54-187-167-69.us-west-2.compute.amazonaws.com) (Quit: ZNC 1.8.2+deb3.1 - https://znc.in)
2023-09-22 01:40:55 +0200deriamis(deriamis@ec2-54-187-167-69.us-west-2.compute.amazonaws.com)
2023-09-22 01:43:57 +0200libertyprime(~libertypr@203.96.203.44)
2023-09-22 01:49:59 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2) (Ping timeout: 258 seconds)
2023-09-22 01:50:04 +0200pavonia(~user@user/siracusa)
2023-09-22 01:50:15 +0200nyc(~nyc@user/nyc)
2023-09-22 01:50:34 +0200 <nyc> How do I find where an instance was defined?
2023-09-22 01:50:39 +0200xff0x(~xff0x@2405:6580:b080:900:7a46:13e1:bddb:2397) (Ping timeout: 240 seconds)
2023-09-22 01:51:02 +0200xff0x(~xff0x@178.255.149.135)
2023-09-22 01:52:47 +0200 <glguy> In GHCi, :info will show the module an instance came from
2023-09-22 01:53:40 +0200 <glguy> and :info! will show more than :info will, if you still don't see it
2023-09-22 01:55:33 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2023-09-22 01:56:45 +0200emmanuelux_(~emmanuelu@user/emmanuelux)
2023-09-22 01:57:14 +0200deriamis(deriamis@ec2-54-187-167-69.us-west-2.compute.amazonaws.com) (Quit: ZNC - https://znc.in)
2023-09-22 01:57:40 +0200deriamis(deriamis@2600:1f14:1251:ba02:2994:f9dc:75a8:113b)
2023-09-22 02:00:01 +0200emmanuelux(~emmanuelu@user/emmanuelux) (Ping timeout: 255 seconds)
2023-09-22 02:01:06 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 258 seconds)
2023-09-22 02:02:04 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2023-09-22 02:02:17 +0200califax(~califax@user/califx) (Remote host closed the connection)
2023-09-22 02:02:22 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2)
2023-09-22 02:03:19 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 264 seconds)
2023-09-22 02:04:15 +0200xff0x(~xff0x@178.255.149.135) (Ping timeout: 240 seconds)
2023-09-22 02:05:22 +0200emmanuelux_(~emmanuelu@user/emmanuelux) (Ping timeout: 244 seconds)
2023-09-22 02:05:58 +0200deriamis(deriamis@2600:1f14:1251:ba02:2994:f9dc:75a8:113b) (Quit: ZNC - https://znc.in)
2023-09-22 02:06:14 +0200xff0x(~xff0x@2405:6580:b080:900:7a46:13e1:bddb:2397)
2023-09-22 02:06:35 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2) (Ping timeout: 240 seconds)
2023-09-22 02:07:05 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2)
2023-09-22 02:07:19 +0200deriamis(deriamis@2600:1f14:1251:ba02:2994:f9dc:75a8:113b)
2023-09-22 02:08:39 +0200Alex_test(~al_test@178.34.160.78) (Ping timeout: 240 seconds)
2023-09-22 02:10:39 +0200AlexZenon(~alzenon@178.34.160.78) (Ping timeout: 240 seconds)
2023-09-22 02:11:49 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2) (Ping timeout: 258 seconds)
2023-09-22 02:13:21 +0200califax(~califax@user/califx)
2023-09-22 02:13:59 +0200remedan(~remedan@ip-94-112-0-18.bb.vodafone.cz) (Ping timeout: 246 seconds)
2023-09-22 02:15:50 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2)
2023-09-22 02:16:56 +0200g(g@libera/staff/glguy) (Remote host closed the connection)
2023-09-22 02:17:00 +0200g(g@libera/staff/glguy)
2023-09-22 02:17:33 +0200remedan(~remedan@ip-94-112-0-18.bb.vodafone.cz)
2023-09-22 02:18:40 +0200Alex_test(~al_test@178.34.160.78)
2023-09-22 02:20:18 +0200AlexZenon(~alzenon@178.34.160.78)
2023-09-22 02:23:51 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2023-09-22 02:26:43 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2) (Ping timeout: 264 seconds)
2023-09-22 02:33:53 +0200yosef`(~yosef`@user/yosef/x-2947716)
2023-09-22 02:35:41 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2)
2023-09-22 02:37:50 +0200Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-09-22 02:38:32 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 260 seconds)
2023-09-22 02:40:25 +0200tremon(~tremon@83.80.159.219) (Quit: getting boxed in)
2023-09-22 02:40:27 +0200Square3(~Square4@user/square)
2023-09-22 02:43:12 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2) (Ping timeout: 260 seconds)
2023-09-22 02:47:16 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2)
2023-09-22 02:58:31 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2) (Ping timeout: 264 seconds)
2023-09-22 02:58:33 +0200bienjensu(~user@user/bienjensu)
2023-09-22 02:59:45 +0200shapr(~user@2600:1700:c640:3100:cd69:69ab:9143:deea)
2023-09-22 03:02:47 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2)
2023-09-22 03:09:42 +0200dagit(~dagit@2001:558:6025:38:71c6:9d58:7252:8976) (Ping timeout: 258 seconds)
2023-09-22 03:10:08 +0200dagit(~dagit@2001:558:6025:38:71c6:9d58:7252:8976)
2023-09-22 03:12:00 +0200libertyprime(~libertypr@203.96.203.44) (Ping timeout: 258 seconds)
2023-09-22 03:13:00 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-22 03:16:09 +0200bienjensu(~user@user/bienjensu) (Ping timeout: 244 seconds)
2023-09-22 03:17:43 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 264 seconds)
2023-09-22 03:18:54 +0200 <albet70> what's the difference between State and ST?
2023-09-22 03:19:58 +0200 <geekosaur> uh? they're very different
2023-09-22 03:20:41 +0200 <geekosaur> ST has a "state" but it's phantom, and that's the point: it's untouchable, so you can hide impure data by associating it with the untouchable state so it can never escape ST
2023-09-22 03:21:36 +0200bilegeek(~bilegeek@2600:1008:b08d:e679:af4d:681:cfe8:969c)
2023-09-22 03:21:40 +0200 <geekosaur> so now you can have mutable variables (STRef) and mutable arrays (STArray/STUArray), and can write mutating code as long as what you finally return is pure
2023-09-22 03:22:26 +0200 <c_wraith> State is a convenience wrapper for a pattern you can write by hand.
2023-09-22 03:22:45 +0200 <c_wraith> ST provides a unique interface that allows you to use true mutability in an externally-pure interface
2023-09-22 03:23:35 +0200vulpine(xfnw@tilde.team) (Quit: Connection reset by purr)
2023-09-22 03:30:53 +0200 <dmj`> is valderman around ?
2023-09-22 03:31:30 +0200powderhorn(~powderhor@207-153-12-54.static.fttp.usinternet.com)
2023-09-22 03:38:56 +0200vulpine(xfnw@tilde.team)
2023-09-22 03:45:19 +0200otto_s(~user@p5b044509.dip0.t-ipconnect.de) (Ping timeout: 264 seconds)
2023-09-22 03:46:46 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-09-22 03:46:47 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-09-22 03:46:47 +0200wroathe(~wroathe@user/wroathe)
2023-09-22 03:46:54 +0200otto_s(~user@p4ff27dc1.dip0.t-ipconnect.de)
2023-09-22 03:47:43 +0200libertyprime(~libertypr@203.96.203.44)
2023-09-22 03:58:09 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049) (Remote host closed the connection)
2023-09-22 03:58:25 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049)
2023-09-22 03:59:55 +0200hyiltiz(~hyiltiz@2620:149:13d1::5a2) (Ping timeout: 258 seconds)
2023-09-22 04:01:45 +0200hyiltiz(~hyiltiz@2603-8080-1f00-082f-15d9-d49d-e7d8-6241.res6.spectrum.com)
2023-09-22 04:03:28 +0200yosef`(~yosef`@user/yosef/x-2947716) (Ping timeout: 245 seconds)
2023-09-22 04:07:35 +0200xff0x(~xff0x@2405:6580:b080:900:7a46:13e1:bddb:2397) (Ping timeout: 240 seconds)
2023-09-22 04:07:55 +0200 <albet70> what's the relationship of STRef and ST?
2023-09-22 04:09:23 +0200 <glguy> STRef : ST :: IORef : IO
2023-09-22 04:09:36 +0200 <glguy> do you know the relationship between IORef and IO?
2023-09-22 04:09:43 +0200 <albet70> no
2023-09-22 04:10:25 +0200 <glguy> OK, then don't worry about ST and STRef yet. Are you familiar with the IO type yet?
2023-09-22 04:10:34 +0200 <albet70> yes
2023-09-22 04:11:07 +0200 <glguy> IORefs are mutable references. You can make a new one: newIORef :: a -> IO a
2023-09-22 04:11:17 +0200 <glguy> You can read what's stored in one: readIORef :: IORef a -> IO a
2023-09-22 04:11:40 +0200 <glguy> and you can store something in one: writeIORef :: IORef a -> a -> IO ()
2023-09-22 04:11:52 +0200 <glguy> What you get back when you read from one is the last thing you wrote to it
2023-09-22 04:12:00 +0200 <glguy> (or the initial value you provided with newIORef
2023-09-22 04:12:24 +0200 <albet70> IORef can construct an IO a?
2023-09-22 04:12:45 +0200 <glguy> err
2023-09-22 04:12:46 +0200 <albet70> but 2 :: IO Int is ok?
2023-09-22 04:12:51 +0200 <glguy> newIORef :: a -> IO (IORef a)
2023-09-22 04:13:59 +0200 <monochrom> I don't know what "IORef can construct an IO a?" means. But you can use IORef in IO. (And STRef in ST.)
2023-09-22 04:16:24 +0200td_(~td@i5387091A.versanet.de) (Ping timeout: 258 seconds)
2023-09-22 04:17:28 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-22 04:18:05 +0200td_(~td@i5387090B.versanet.de)
2023-09-22 04:23:07 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-09-22 04:24:22 +0200finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-09-22 04:24:23 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-09-22 04:24:23 +0200finn_elijaFinnElija
2023-09-22 04:26:40 +0200 <dmj`> albet70: if you're trying to implement mutable algorithms in ST, use an Int accumulator before an STRef Int, faster
2023-09-22 04:37:07 +0200hpc(~juzz@ip98-169-35-163.dc.dc.cox.net) (Ping timeout: 258 seconds)
2023-09-22 04:37:20 +0200hpc(~juzz@ip98-169-35-163.dc.dc.cox.net)
2023-09-22 04:53:40 +0200qqq(~qqq@92.43.167.61) (Quit: leaving)
2023-09-22 04:57:00 +0200xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-09-22 04:57:55 +0200mysl(~mysl@user/mysl) (Ping timeout: 252 seconds)
2023-09-22 04:59:30 +0200mysl(~mysl@user/mysl)
2023-09-22 05:00:51 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-22 05:08:34 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-09-22 05:16:41 +0200Inst(~Inst@120.244.192.250)
2023-09-22 05:20:47 +0200 <Inst> danse-nr3: remember ICQ?
2023-09-22 05:25:19 +0200 <monochrom> I remember that.
2023-09-22 05:27:37 +0200 <int-e> . o O ( bad AIM )
2023-09-22 05:30:16 +0200lisbeths(uid135845@id-135845.lymington.irccloud.com)
2023-09-22 05:32:26 +0200 <EvanR> you were only cool if you were on Jabber
2023-09-22 05:35:17 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 260 seconds)
2023-09-22 05:36:10 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 244 seconds)
2023-09-22 05:41:55 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 252 seconds)
2023-09-22 05:53:02 +0200 <jackdk> I remember writing and IRC<->jabber bot to ping my friends when someone wanted to challenge us to games
2023-09-22 05:53:37 +0200 <jackdk> the jabber side of the bot had my friends' MSN etc contacts imported via bridge. Amazing that we'd basically solved instant messaging in the 2000s and then decided to break it all again.
2023-09-22 05:55:17 +0200ystael(~ystael@user/ystael) (Ping timeout: 244 seconds)
2023-09-22 05:56:19 +0200aforemny_(~aforemny@2001:9e8:6cd8:8a00:99a8:9435:f04:65fe)
2023-09-22 05:56:50 +0200aforemny(~aforemny@i59F516F1.versanet.de) (Ping timeout: 244 seconds)
2023-09-22 06:07:04 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-09-22 06:09:25 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-09-22 06:09:25 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-09-22 06:09:25 +0200wroathe(~wroathe@user/wroathe)
2023-09-22 06:10:32 +0200sabino(~sabino@user/sabino) (Quit: Lambda _ -> x)
2023-09-22 06:15:37 +0200jargon(~jargon@184.101.67.95)
2023-09-22 06:23:53 +0200chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2023-09-22 06:24:06 +0200chexum(~quassel@gateway/tor-sasl/chexum)
2023-09-22 06:24:39 +0200vglfr(~vglfr@188.239.201.89)
2023-09-22 06:27:03 +0200khumba(~khumba@user/khumba)
2023-09-22 06:36:35 +0200michalz(~michalz@185.246.207.197)
2023-09-22 06:38:43 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 264 seconds)
2023-09-22 06:40:14 +0200misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-09-22 06:40:41 +0200vglfr(~vglfr@188.239.201.89) (Remote host closed the connection)
2023-09-22 06:41:05 +0200dcoutts_(~duncan@2a02:8012:ae9a:0:217c:5666:d075:6292) (Ping timeout: 240 seconds)
2023-09-22 06:41:43 +0200vglfr(~vglfr@188.239.201.89)
2023-09-22 06:42:00 +0200vglfr(~vglfr@188.239.201.89) (Remote host closed the connection)
2023-09-22 06:45:17 +0200vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua)
2023-09-22 06:51:54 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-22 07:03:49 +0200acidjnk_new(~acidjnk@p200300d6e7072f380063779f7ab954b0.dip0.t-ipconnect.de)
2023-09-22 07:03:55 +0200Inst(~Inst@120.244.192.250) (Ping timeout: 258 seconds)
2023-09-22 07:10:42 +0200Inst(~Inst@120.244.192.250)
2023-09-22 07:10:56 +0200 <Inst> jackdk: monetization
2023-09-22 07:11:27 +0200 <Inst> end of the day, labor -> trading off a bit of your life for value, opportunity costs -> what else you could be doing with your time
2023-09-22 07:11:42 +0200 <Inst> I wish, say, EU, US, Chinese, any one of the three, were subsidizing FOSS development
2023-09-22 07:12:51 +0200 <Inst> would tremendously increase efficiency and productivity in the field, because end of the day, FOSS is a public good, and governments should be taking care of public goods
2023-09-22 07:17:43 +0200idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-09-22 07:22:38 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2023-09-22 07:24:41 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Read error: Connection reset by peer)
2023-09-22 07:25:25 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2023-09-22 07:26:13 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2023-09-22 07:29:06 +0200stiell_(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2023-09-22 07:29:48 +0200stiell_(~stiell@gateway/tor-sasl/stiell)
2023-09-22 07:29:54 +0200monochrom(~trebla@216.138.220.146) (Quit: Leaving)
2023-09-22 07:31:51 +0200monochrom(~trebla@216.138.220.146)
2023-09-22 07:32:23 +0200sm(~sm@plaintextaccounting/sm)
2023-09-22 07:33:57 +0200monochrom(~trebla@216.138.220.146) (Client Quit)
2023-09-22 07:36:44 +0200sm(~sm@plaintextaccounting/sm) (Ping timeout: 245 seconds)
2023-09-22 07:37:40 +0200 <phma> I'm writing the same program in both Rust and Haskell and timing how long it takes to run.
2023-09-22 07:38:23 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-09-22 07:38:44 +0200CiaoSen(~Jura@2a05:5800:29e:d200:664b:f0ff:fe37:9ef)
2023-09-22 07:39:04 +0200 <phma> Compiled with -O2 -fllvm, the Haskell program takes 12.3 s real, 18.1 s user (it's multithreaded), to hash a megabyte.
2023-09-22 07:39:51 +0200lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-09-22 07:40:02 +0200 <phma> The Rust program, which is not multithreaded, takes 8.8 s to do the same thing. That's compiled in debug mode.
2023-09-22 07:41:11 +0200 <phma> So far, Haskell taking half again as long as Rust isn't bad. But then I compiled the Rust program in release mode
2023-09-22 07:41:25 +0200 <phma> and it took only half a second to hash a megabyte.
2023-09-22 07:42:13 +0200 <phma> That means it's spending over eight seconds checking bounds and such.
2023-09-22 07:43:03 +0200powderhorn(~powderhor@207-153-12-54.static.fttp.usinternet.com) (Ping timeout: 245 seconds)
2023-09-22 07:43:19 +0200 <phma> The Haskell program spends most of its time manipulating unboxed arrays. Is it possible to disable bounds checking and such,
2023-09-22 07:43:22 +0200 <int-e> Hmmmm was that https://github.com/phma/wring-twistree/ ?
2023-09-22 07:43:35 +0200 <phma> int-e: yes
2023-09-22 07:43:58 +0200 <phma> without using unsafe functions?
2023-09-22 07:47:30 +0200 <int-e> no, the bounds checks are just plain Haskell code, not guarded by any compiler flag
2023-09-22 07:48:12 +0200 <phma> How much speedup would I get by switching to unboxed vectors?
2023-09-22 07:49:09 +0200 <int-e> only one way to find out
2023-09-22 07:53:36 +0200khumba(~khumba@user/khumba) ()
2023-09-22 07:55:17 +0200misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 260 seconds)
2023-09-22 07:58:09 +0200ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net) (Ping timeout: 252 seconds)
2023-09-22 08:02:21 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 252 seconds)
2023-09-22 08:02:47 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-09-22 08:03:57 +0200dsrt^(~cd@c-66-56-7-24.hsd1.ga.comcast.net)
2023-09-22 08:04:33 +0200idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.0.2)
2023-09-22 08:07:20 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-22 08:13:05 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2023-09-22 08:14:43 +0200notzmv(~zmv@user/notzmv) (Ping timeout: 264 seconds)
2023-09-22 08:19:13 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-22 08:19:14 +0200vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua) (Read error: Connection reset by peer)
2023-09-22 08:19:36 +0200vglfr(vglfr@gateway/vpn/protonvpn/vglfr)
2023-09-22 08:24:02 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 258 seconds)
2023-09-22 08:24:51 +0200yosef`(~yosef`@user/yosef/x-2947716)
2023-09-22 08:25:49 +0200jackneill__(~Jackneill@20014C4E1E062E0011575DEE5212F0F8.dsl.pool.telekom.hu)
2023-09-22 08:29:41 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:882f:270a:9fdd:8778)
2023-09-22 08:29:44 +0200notzmv(~zmv@user/notzmv)
2023-09-22 08:38:55 +0200tv(~tv@user/tv) (Read error: Connection reset by peer)
2023-09-22 08:39:06 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-22 08:40:44 +0200vglfr(vglfr@gateway/vpn/protonvpn/vglfr) (Ping timeout: 246 seconds)
2023-09-22 08:40:50 +0200 <phma> Does profiling with -hc, -hy, or the like work properly on multithreaded programs?
2023-09-22 08:41:45 +0200sm(~sm@plaintextaccounting/sm)
2023-09-22 08:42:18 +0200Teestt3434(~User@2001:1970:5199:fa00::a4bf)
2023-09-22 08:43:20 +0200vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua)
2023-09-22 08:46:05 +0200akegalj(~akegalj@93-142-180-5.adsl.net.t-com.hr)
2023-09-22 08:46:28 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-09-22 08:46:50 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-09-22 08:47:02 +0200smoothdev(~smoothdev@91-169-231-236.subs.proxad.net) (Ping timeout: 258 seconds)
2023-09-22 08:50:34 +0200 <Inst> https://downloads.haskell.org/ghc/8.8.1-alpha1/docs/html/libraries/Cabal-2.5.0.0/Distribution-Simp…
2023-09-22 08:50:36 +0200 <Inst> what's going on here?
2023-09-22 08:50:55 +0200 <Inst> AFAIK, it's a custom Maybe type with Just being on the 0 index, and different monoid / semigroup instances
2023-09-22 08:51:08 +0200ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2023-09-22 08:51:31 +0200ChaiTRex(~ChaiTRex@user/chaitrex)
2023-09-22 08:52:24 +0200smoothdev(~smoothdev@2a01:e0a:279:fb20:6dba:5cf9:a0d3:5827)
2023-09-22 08:56:47 +0200akegalj(~akegalj@93-142-180-5.adsl.net.t-com.hr) (Ping timeout: 255 seconds)
2023-09-22 08:56:54 +0200akegalj_(~akegalj@93-142-166-66.adsl.net.t-com.hr)
2023-09-22 08:57:41 +0200sm(~sm@plaintextaccounting/sm) (Ping timeout: 255 seconds)
2023-09-22 09:04:59 +0200dove_dove
2023-09-22 09:05:17 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-09-22 09:06:21 +0200smoothdev_(~smoothdev@91-169-231-236.subs.proxad.net)
2023-09-22 09:06:58 +0200smoothdev(~smoothdev@2a01:e0a:279:fb20:6dba:5cf9:a0d3:5827) (Ping timeout: 258 seconds)
2023-09-22 09:06:59 +0200smoothdev_smoothdev
2023-09-22 09:09:33 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-09-22 09:10:39 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-22 09:11:27 +0200tcard(~tcard@2400:4051:5801:7500:cf17:befc:ff82:5303) (Quit: Leaving)
2023-09-22 09:11:59 +0200aforemny_aforemny
2023-09-22 09:13:25 +0200tcard(~tcard@2400:4051:5801:7500:cf17:befc:ff82:5303)
2023-09-22 09:17:37 +0200Inst(~Inst@120.244.192.250) (Remote host closed the connection)
2023-09-22 09:18:02 +0200Inst(~Inst@120.244.192.250)
2023-09-22 09:18:12 +0200dsrt^(~cd@c-66-56-7-24.hsd1.ga.comcast.net) (Remote host closed the connection)
2023-09-22 09:20:10 +0200random-jellyfish(~random-je@user/random-jellyfish)
2023-09-22 09:21:40 +0200fendor(~fendor@2a02:8388:1640:be00:aab:1226:f274:5021)
2023-09-22 09:24:21 +0200 <jackdk> The link at the top of the haddocks is still live: https://mail.haskell.org/pipermail/cabal-devel/2007-December/001509.html
2023-09-22 09:25:33 +0200sord937(~sord937@gateway/tor-sasl/sord937)
2023-09-22 09:30:12 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-22 09:33:07 +0200mc47(~mc47@xmonad/TheMC47)
2023-09-22 09:34:34 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-09-22 09:38:05 +0200tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net) (Quit: zzz)
2023-09-22 09:38:26 +0200sm(~sm@plaintextaccounting/sm)
2023-09-22 09:42:39 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 240 seconds)
2023-09-22 09:45:02 +0200gmg(~user@user/gehmehgeh)
2023-09-22 09:46:01 +0200 <Inst> just a question, what is the value of foldr?
2023-09-22 09:46:13 +0200 <Inst> I mean, I know how foldr is implemented for lists, I can probably grok how it's implemented via foldable
2023-09-22 09:46:27 +0200 <Inst> but it's what I'd consider way too powerful
2023-09-22 09:47:05 +0200 <Inst> is it wrong to consider it equivalent to for, or even while?
2023-09-22 09:47:28 +0200 <Inst> (then again, all recursion can be expressed as while + some complexities)
2023-09-22 09:48:22 +0200Vajb(~Vajb@2001:999:500:7771:18aa:c4e5:e7a9:f44b) (Read error: Connection reset by peer)
2023-09-22 09:49:07 +0200cfricke(~cfricke@user/cfricke)
2023-09-22 09:49:10 +0200Vajb(~Vajb@2001:999:500:7771:18aa:c4e5:e7a9:f44b)
2023-09-22 09:50:52 +0200danza(~francesco@rm-19-27-218.service.infuturo.it)
2023-09-22 09:54:50 +0200 <lortabac> Inst: foldr gives you an easy way to iterate on a structure and accumulate a result in a right-associative way
2023-09-22 09:55:43 +0200 <Inst> on lists, at least, foldr's inefficient and for most uses foldl' is better
2023-09-22 09:55:57 +0200 <Inst> i'm aware that foldr has an advantage insofar as it's usefully lazy on lists
2023-09-22 09:56:01 +0200 <lortabac> it's true that with 'foldr' you can theoretically do much more, but in practice it's too complex to be done for real
2023-09-22 09:56:19 +0200 <lortabac> Inst: there is no better and worse, foldl and foldr do different things
2023-09-22 09:58:39 +0200 <Inst> i think there's an implementation of foldl' in prelude using foldr as a continuation builder
2023-09-22 09:59:05 +0200 <jackdk> foldr performs constructor replacement. http://web.archive.org/web/20230103210800/data.tmorris.net/talks/list-folds/b30aa0fdff296c731bc5b1…
2023-09-22 09:59:56 +0200Teestt3434(~User@2001:1970:5199:fa00::a4bf) (Quit: Leaving)
2023-09-22 10:00:28 +0200 <Inst> yeah, in that case foldr is better, since it can exploit laziness
2023-09-22 10:00:37 +0200 <Inst> foldl' i tend to default toward for performance reasons
2023-09-22 10:00:56 +0200 <Inst> i'd guessing with Hughes Lists / Diff Lists foldl' is likely to be more inefficient, though
2023-09-22 10:01:08 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-09-22 10:01:45 +0200 <lortabac> imagine you are implementing a compiler, and you need to convert all multi-argument lambdas in curried one-argument ones
2023-09-22 10:02:12 +0200 <lortabac> you would use foldr since Lam is right-associative
2023-09-22 10:02:31 +0200 <lortabac> now if you want to do the same thing for function application
2023-09-22 10:02:39 +0200 <lortabac> you would use foldl since it's left-associative
2023-09-22 10:03:08 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049) (Remote host closed the connection)
2023-09-22 10:04:38 +0200 <Inst> yeah and I'd assume I'd have Foldable instances for Lam for this purpose, no?
2023-09-22 10:04:46 +0200 <lortabac> no
2023-09-22 10:04:59 +0200 <lortabac> you fold over the arguments of the lambda
2023-09-22 10:05:10 +0200 <Inst> I guess I'm just thinking operationally
2023-09-22 10:05:11 +0200 <lortabac> foldr Lam arguments body
2023-09-22 10:05:39 +0200 <lortabac> foldl App arguments function
2023-09-22 10:06:13 +0200 <lortabac> sorry I inverted the last two arguments
2023-09-22 10:06:21 +0200 <lortabac> but I hope you get the idea
2023-09-22 10:06:28 +0200 <Inst> and, I'm guessing, on Vector, at least, foldr' and foldl' are essentially identical when it comes to performance characteristics, except that foldl' would have to get the vector length first?
2023-09-22 10:08:36 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-09-22 10:08:36 +0200gentauro(~gentauro@user/gentauro) (Read error: Connection reset by peer)
2023-09-22 10:13:48 +0200tv(~tv@user/tv)
2023-09-22 10:13:59 +0200bilegeek(~bilegeek@2600:1008:b08d:e679:af4d:681:cfe8:969c) (Quit: Leaving)
2023-09-22 10:14:02 +0200gentauro(~gentauro@user/gentauro)
2023-09-22 10:16:12 +0200mfg(~user@128.176.164.115)
2023-09-22 10:18:12 +0200Square3(~Square4@user/square) (Ping timeout: 260 seconds)
2023-09-22 10:20:03 +0200danza(~francesco@rm-19-27-218.service.infuturo.it) (Ping timeout: 252 seconds)
2023-09-22 10:20:46 +0200 <mfg> Hi, i'm using bench (a wrapper around criterion) to benchmark some command line applications and was wondering what is the minimum amount of actual program runs this performs, if this is configurable and how exactly is determined how many runs are actually done.
2023-09-22 10:24:15 +0200 <Inst> tbh do I have the wrong concept of foldr / foldl @lortabac?
2023-09-22 10:24:44 +0200 <Inst> i.e, I'm thinking of them specifically in the sense of how they interact with a value of type [a], not in the core semantics (right to left fold, left to right fold)
2023-09-22 10:25:45 +0200 <lortabac> Inst: the difference is not in how they interact with the list, it's in how they accumulate the value
2023-09-22 10:26:09 +0200 <Inst> i mean i know the definition, foldr with lists replaces the cons data constructor with the function
2023-09-22 10:26:24 +0200 <Inst> the accumulation, unless you're doing an outside accumulation via continuation building
2023-09-22 10:27:26 +0200 <Inst> but i get the feeling i'd be better off reading jack dk (avoid highlighting)'s link for more information on that
2023-09-22 10:27:54 +0200ft(~ft@p3e9bc680.dip0.t-ipconnect.de) (Quit: leaving)
2023-09-22 10:29:20 +0200chele(~chele@user/chele)
2023-09-22 10:29:22 +0200 <lortabac> > foldl (+) 0 [x, y, z]
2023-09-22 10:29:24 +0200 <lambdabot> 0 + x + y + z
2023-09-22 10:29:27 +0200myme(~myme@2a01:799:d60:e400:e336:7d0f:f75f:76b1) (Ping timeout: 240 seconds)
2023-09-22 10:29:40 +0200 <lortabac> (+) is left-associative so the parentheses are omitted
2023-09-22 10:30:00 +0200 <lortabac> but this would be ((0 + x) + y) + z
2023-09-22 10:30:11 +0200 <lortabac> > foldr (+) 0 [x, y, z]
2023-09-22 10:30:13 +0200 <lambdabot> x + (y + (z + 0))
2023-09-22 10:30:21 +0200 <lortabac> Inst: ↑
2023-09-22 10:30:33 +0200myme(~myme@2a01:799:d60:e400:2874:313d:614e:da9)
2023-09-22 10:31:37 +0200 <probie> > foldr (\n k acc -> k (acc + n)) id [x, y, z] 0
2023-09-22 10:31:39 +0200 <lambdabot> 0 + x + y + z
2023-09-22 10:32:24 +0200 <Inst> yeah, i think we have like a miscommunication, I'm familiar with the semantics of foldr and foldl, my issue is more that I've asserted that foldr is equivalent to for or while in the past, i.e, foldr with its short-circuiting capability being able to implement any algorithm, is a bit smelly
2023-09-22 10:32:34 +0200 <Inst> whereas foldl' is, at least on lists, more constrained and more performant
2023-09-22 10:33:05 +0200 <lortabac> (+) is confusing because you can fold it both ways and the result won't change
2023-09-22 10:33:07 +0200 <Inst> i'm assuming that if i assert that any foldl can be implemented as a foldr
2023-09-22 10:33:18 +0200 <Inst> someone will bring up a counterexample
2023-09-22 10:33:29 +0200 <lortabac> but in other cases you can't really choose, one of the two is correct and the other is wrong
2023-09-22 10:33:31 +0200 <Inst> but of course, foldr implemented as foldl isn't possible for infinite lists, as a minimum counterexample
2023-09-22 10:33:46 +0200 <Inst> let f = flip g
2023-09-22 10:34:59 +0200 <Inst> and i suppose for a left associative data structure, foldl takes the properties of foldr for that data structure
2023-09-22 10:35:01 +0200 <lortabac> flip is not enough
2023-09-22 10:35:45 +0200 <lortabac> you can try, flip doesn't transform foldl into foldr (nor viceversa)
2023-09-22 10:36:05 +0200 <lortabac> the transformation is more complex, but I think you already know
2023-09-22 10:36:29 +0200 <probie> Inst: No, _every_ foldl (over lists) can be implemented as a foldr
2023-09-22 10:37:24 +0200 <Inst> yeah, but i was saying, if the data structure is different the same property may not hold
2023-09-22 10:38:05 +0200 <Inst> and actually, i'm wrong, : is right associative
2023-09-22 10:41:36 +0200__monty__(~toonn@user/toonn)
2023-09-22 10:42:45 +0200danse-nr3_(~francesco@rm-19-27-218.service.infuturo.it)
2023-09-22 10:43:01 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049)
2023-09-22 10:56:30 +0200misterfish(~misterfis@87.215.131.102)
2023-09-22 10:58:13 +0200Xe(~cadey@tailscale/xe) (Ping timeout: 240 seconds)
2023-09-22 10:58:36 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-22 10:59:42 +0200Pickchea(~private@user/pickchea)
2023-09-22 10:59:53 +0200sm(~sm@plaintextaccounting/sm) (Quit: sm)
2023-09-22 11:00:27 +0200Xe(~cadey@tailscale/xe)
2023-09-22 11:00:44 +0200fweht(uid404746@id-404746.lymington.irccloud.com)
2023-09-22 11:01:36 +0200danse-nr3__(~francesco@151.47.77.179)
2023-09-22 11:02:45 +0200danse-nr3_(~francesco@rm-19-27-218.service.infuturo.it) (Read error: Connection reset by peer)
2023-09-22 11:03:30 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2023-09-22 11:05:10 +0200econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-09-22 11:07:50 +0200libertyprime(~libertypr@203.96.203.44) (Quit: leaving)
2023-09-22 11:08:37 +0200cptaffe(~cptaffe@user/cptaffe) (Ping timeout: 252 seconds)
2023-09-22 11:08:49 +0200cptaffe`(~cptaffe@user/cptaffe)
2023-09-22 11:13:26 +0200jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) (Quit: Textual IRC Client: www.textualapp.com)
2023-09-22 11:18:41 +0200DoubleB(~DoubleB@202.126.88.184)
2023-09-22 11:18:56 +0200dcoutts_(~duncan@2a02:8012:ae9a:0:217c:5666:d075:6292)
2023-09-22 11:20:11 +0200ubert(~Thunderbi@178.165.190.116.wireless.dyn.drei.com)
2023-09-22 11:20:56 +0200DoubleB(~DoubleB@202.126.88.184) (Client Quit)
2023-09-22 11:28:11 +0200RSCASTILHO(~RSCASTILH@187.40.124.54)
2023-09-22 11:31:20 +0200random-jellyfish(~random-je@user/random-jellyfish) (Quit: Client closed)
2023-09-22 11:35:40 +0200jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net)
2023-09-22 11:36:48 +0200yosef`(~yosef`@user/yosef/x-2947716) (Ping timeout: 245 seconds)
2023-09-22 11:43:16 +0200Inst(~Inst@120.244.192.250) (Read error: Connection reset by peer)
2023-09-22 11:49:12 +0200xmachina(~xmachina@modemcable048.127-56-74.mc.videotron.ca) (Ping timeout: 260 seconds)
2023-09-22 11:53:08 +0200Inst(~Inst@120.244.192.250)
2023-09-22 11:55:48 +0200sm(~sm@plaintextaccounting/sm)
2023-09-22 11:57:17 +0200Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-09-22 12:02:56 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Read error: Connection reset by peer)
2023-09-22 12:03:16 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-22 12:03:26 +0200xmachina(xmachina@gateway/vpn/protonvpn/xmachina)
2023-09-22 12:03:55 +0200notzmv(~zmv@user/notzmv) (Ping timeout: 264 seconds)
2023-09-22 12:09:19 +0200xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 264 seconds)
2023-09-22 12:10:32 +0200sm(~sm@plaintextaccounting/sm) (Quit: sm)
2023-09-22 12:12:28 +0200driib(~driib@vmi931078.contaboserver.net) (Quit: The Lounge - https://thelounge.chat)
2023-09-22 12:13:08 +0200driib(~driib@vmi931078.contaboserver.net)
2023-09-22 12:20:59 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-22 12:25:47 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 246 seconds)
2023-09-22 12:31:05 +0200privacy(~privacy@47.219.84.6) (Quit: Leaving)
2023-09-22 12:32:44 +0200califax_(~califax@user/califx)
2023-09-22 12:32:57 +0200stiell_(~stiell@gateway/tor-sasl/stiell) (Ping timeout: 252 seconds)
2023-09-22 12:32:58 +0200califax(~califax@user/califx) (Ping timeout: 252 seconds)
2023-09-22 12:33:41 +0200sord937(~sord937@gateway/tor-sasl/sord937) (Ping timeout: 252 seconds)
2023-09-22 12:33:41 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Ping timeout: 252 seconds)
2023-09-22 12:34:04 +0200califax_califax
2023-09-22 12:35:44 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-09-22 12:36:05 +0200sord937(~sord937@gateway/tor-sasl/sord937)
2023-09-22 12:36:12 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 240 seconds)
2023-09-22 12:39:37 +0200stiell_(~stiell@gateway/tor-sasl/stiell)
2023-09-22 12:46:39 +0200CiaoSen(~Jura@2a05:5800:29e:d200:664b:f0ff:fe37:9ef) (Ping timeout: 240 seconds)
2023-09-22 12:46:43 +0200pyooque(~puke@user/puke)
2023-09-22 12:46:43 +0200pukeGuest7199
2023-09-22 12:46:43 +0200Guest7199(~puke@user/puke) (Killed (lead.libera.chat (Nickname regained by services)))
2023-09-22 12:46:43 +0200pyooquepuke
2023-09-22 12:48:37 +0200Inst(~Inst@120.244.192.250) (Ping timeout: 244 seconds)
2023-09-22 12:49:07 +0200sm(~sm@plaintextaccounting/sm)
2023-09-22 12:50:06 +0200Nixkernal(~Nixkernal@119.4.193.178.dynamic.wline.res.cust.swisscom.ch) (Quit: No Ping reply in 180 seconds.)
2023-09-22 12:51:32 +0200Nixkernal(~Nixkernal@119.4.193.178.dynamic.wline.res.cust.swisscom.ch)
2023-09-22 12:51:38 +0200akegalj_(~akegalj@93-142-166-66.adsl.net.t-com.hr) (Quit: leaving)
2023-09-22 12:53:17 +0200vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua) (Remote host closed the connection)
2023-09-22 12:54:15 +0200vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua)
2023-09-22 12:55:13 +0200vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua) (Remote host closed the connection)
2023-09-22 12:56:10 +0200vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua)
2023-09-22 12:58:48 +0200xmachina(xmachina@gateway/vpn/protonvpn/xmachina) (Ping timeout: 255 seconds)
2023-09-22 13:05:25 +0200 <danse-nr3__> hi all, how is life going in haskell land?
2023-09-22 13:06:04 +0200billchenchina(~billchenc@103.152.35.21)
2023-09-22 13:09:51 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-09-22 13:10:07 +0200Pickchea(~private@user/pickchea)
2023-09-22 13:10:53 +0200 <arahael> danse-nr3__: Is it really a life without a grip on the Real World?
2023-09-22 13:12:06 +0200 <danse-nr3__> to the contrary, it has a nicely abstracted grip on it
2023-09-22 13:12:48 +0200xmachina(~xmachina@modemcable048.127-56-74.mc.videotron.ca)
2023-09-22 13:14:04 +0200Pickchea(~private@user/pickchea) (Client Quit)
2023-09-22 13:15:42 +0200 <arahael> I dunno, when I go on a date, I prefer dinner to be a real thing. ;)
2023-09-22 13:16:57 +0200 <danse-nr3__> yeah but what can i say, our "civilized" world prompts us to use fork and spoon
2023-09-22 13:17:22 +0200 <arahael> Damned civilisation!
2023-09-22 13:17:27 +0200 <danse-nr3__> true that
2023-09-22 13:21:11 +0200CAT_S(apic@brezn3.muc.ccc.de) (Read error: Connection reset by peer)
2023-09-22 13:25:31 +0200Batzy_(~quassel@user/batzy) (Ping timeout: 264 seconds)
2023-09-22 13:26:50 +0200Batzy(~quassel@user/batzy)
2023-09-22 13:34:31 +0200puke(~puke@user/puke) (Ping timeout: 264 seconds)
2023-09-22 13:35:51 +0200danse-nr3__(~francesco@151.47.77.179) (Ping timeout: 240 seconds)
2023-09-22 13:37:20 +0200CAT_S(~apic@brezn3.muc.ccc.de)
2023-09-22 13:42:11 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-09-22 13:49:22 +0200jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 260 seconds)
2023-09-22 13:51:12 +0200sm(~sm@plaintextaccounting/sm) (Quit: sm)
2023-09-22 13:52:26 +0200sm(~sm@plaintextaccounting/sm)
2023-09-22 13:53:56 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-22 13:54:06 +0200sm(~sm@plaintextaccounting/sm) (Client Quit)
2023-09-22 14:04:36 +0200skippy(sid26890@user/slice) (Quit: Connection closed for inactivity)
2023-09-22 14:08:19 +0200xff0x(~xff0x@2405:6580:b080:900:5520:f57a:a6e0:cbf2)
2023-09-22 14:11:01 +0200RSCASTILHO(~RSCASTILH@187.40.124.54) ()
2023-09-22 14:13:38 +0200random-jellyfish(~random-je@user/random-jellyfish)
2023-09-22 14:16:13 +0200notzmv(~zmv@user/notzmv)
2023-09-22 14:18:06 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-09-22 14:27:23 +0200Inst(~Inst@120.244.192.250)
2023-09-22 14:27:51 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 240 seconds)
2023-09-22 14:31:46 +0200random-jellyfish(~random-je@user/random-jellyfish) (Quit: Client closed)
2023-09-22 14:35:30 +0200danse-nr3(~francesco@151.47.77.179)
2023-09-22 14:37:07 +0200privacy(~privacy@47.219.84.6)
2023-09-22 14:41:38 +0200hyiltiz2(~hyiltiz@2620:149:13d1:100::138)
2023-09-22 14:41:44 +0200hyiltiz(~hyiltiz@2603-8080-1f00-082f-15d9-d49d-e7d8-6241.res6.spectrum.com) (Read error: Connection reset by peer)
2023-09-22 14:44:41 +0200mfg(~user@128.176.164.115) (Ping timeout: 258 seconds)
2023-09-22 14:46:33 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-09-22 14:49:32 +0200xmachina1(xmachina@gateway/vpn/protonvpn/xmachina)
2023-09-22 14:51:04 +0200xmachina(~xmachina@modemcable048.127-56-74.mc.videotron.ca) (Ping timeout: 244 seconds)
2023-09-22 14:54:14 +0200xmachina1Co2
2023-09-22 14:57:25 +0200Co2(xmachina@gateway/vpn/protonvpn/xmachina) (Quit: WeeChat 4.0.4)
2023-09-22 14:57:34 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 245 seconds)
2023-09-22 15:01:38 +0200danse-nr3(~francesco@151.47.77.179) (Read error: Connection reset by peer)
2023-09-22 15:01:40 +0200danse-nr3_(~francesco@151.47.41.11)
2023-09-22 15:02:23 +0200 <danse-nr3_> i have been told by a colleague that haskell's typeclasses are meant to be used as an abstraction only when the instances are expected to satisfy some laws.
2023-09-22 15:02:26 +0200 <danse-nr3_> Had never read about this in learning material, so although several classes follow this pattern, i was wondering whether that is a recognized good practice
2023-09-22 15:02:27 +0200Alex_test(~al_test@178.34.160.78) (Quit: ;-)
2023-09-22 15:02:50 +0200AlexZenon(~alzenon@178.34.160.78) (Quit: ;-)
2023-09-22 15:03:09 +0200 <dminuoso> Some say yes, plenty of libraries say no.
2023-09-22 15:03:13 +0200AlexNoo(~AlexNoo@178.34.160.78) (Quit: Leaving)
2023-09-22 15:03:16 +0200 <dminuoso> It's the wild west.
2023-09-22 15:03:46 +0200 <dminuoso> The one thing I never hear about, is *why* typeclasses should be lawful.
2023-09-22 15:04:07 +0200 <dminuoso> It feels like some religious belief.
2023-09-22 15:07:21 +0200 <exarkun> There's two pieces right? "There are laws that apply to the class" and "an instance follows the laws ('is lawful')"
2023-09-22 15:08:08 +0200 <exarkun> You can't have an unlawful Data.Default because there are no laws to break. But you can have an unlawful Functor because there are Functor laws.
2023-09-22 15:08:28 +0200 <exarkun> It seems like there's pretty clear reasons to have lawful instances if there are laws at all
2023-09-22 15:08:50 +0200 <dminuoso> exarkun: They are referring to a belief, that typeclasses are a smell if they dont have mathematical laws attached to them.
2023-09-22 15:08:53 +0200 <danse-nr3_> i was referring to defining a class without laws associated to it
2023-09-22 15:09:10 +0200 <lortabac> for me the idea is 1) predictability 2) ability to write code that is generic over all instances of the class
2023-09-22 15:09:11 +0200 <exarkun> dminuoso: Sure, just making sure
2023-09-22 15:09:38 +0200 <lortabac> laws are a good way to achieve those goals, but not the only one
2023-09-22 15:10:40 +0200 <dminuoso> I guess if you document expected semantics (in the sense of interfaces/protocols), that would be fine too.
2023-09-22 15:12:05 +0200powderhorn(~powderhor@207-153-12-54.static.fttp.usinternet.com)
2023-09-22 15:12:29 +0200 <[exa]> danse-nr3_: extra laws can create extra assumptions that you can use in the program. For many people the assumption about the typeclass methods having types checked is sufficient. Do they count as laws?
2023-09-22 15:13:16 +0200 <exarkun> I have the impression that "laws" are usually exactly the things that the language cannot check.
2023-09-22 15:13:17 +0200 <danse-nr3_> no, i think they do not count. I agree laws are great, but i thought classes were useful independently
2023-09-22 15:13:41 +0200 <[exa]> danse-nr3_: ofc they are, you can't do sensible overloading without them :]
2023-09-22 15:14:01 +0200 <danse-nr3_> that is what i thought, but apparently there is no agreement about this
2023-09-22 15:14:20 +0200 <[exa]> anyway the definition of "laws" as "theorems that are hard to prove automatically by the type/other system" is pretty much OK for me
2023-09-22 15:14:44 +0200Nixkernal(~Nixkernal@119.4.193.178.dynamic.wline.res.cust.swisscom.ch) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-09-22 15:15:04 +0200Nixkernal(~Nixkernal@119.4.193.178.dynamic.wline.res.cust.swisscom.ch)
2023-09-22 15:15:06 +0200 <exarkun> danse-nr3_: There is certainly agreement! One group of people agree that you should have laws, another group of people agree that you don't need to ;)
2023-09-22 15:15:18 +0200 <danse-nr3_> ^.^;
2023-09-22 15:15:40 +0200 <[exa]> notably one of the groups doesn't know how undecidable is checking even of the very simple laws
2023-09-22 15:15:44 +0200ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net)
2023-09-22 15:16:28 +0200 <danse-nr3_> provability is not a concern here. I would love to add laws to all my classes, just i find that classes are useful for many cases where i cannot think of any law (yet?)
2023-09-22 15:16:31 +0200 <haskellbridge> <m​auke> Does Bounded have laws?
2023-09-22 15:16:55 +0200AlexNoo(~AlexNoo@178.34.160.78)
2023-09-22 15:17:40 +0200 <exarkun> does a class have laws if they aren't written in its haddocks?
2023-09-22 15:17:48 +0200AlexZenon(~alzenon@178.34.160.78)
2023-09-22 15:17:55 +0200 <[exa]> traditional laws™
2023-09-22 15:18:16 +0200 <[exa]> "sure this * is commutative"
2023-09-22 15:21:01 +0200 <danse-nr3_> Bounded and Enum are an interesting case. There are laws for when _both_ classes go together. I guess that if one had to wait for laws before creating them, the classes had never existed and therefore not even the overlap laws
2023-09-22 15:22:34 +0200Alex_test(~al_test@178.34.160.78)
2023-09-22 15:22:38 +0200ystael(~ystael@user/ystael)
2023-09-22 15:24:25 +0200 <tomsmeding> what are the laws for Hashable? https://hackage.haskell.org/package/hashable-1.4.3.0/docs/Data-Hashable.html#t:Hashable
2023-09-22 15:24:32 +0200 <tomsmeding> there are expected semantics
2023-09-22 15:24:56 +0200 <tomsmeding> but there are basically no straight laws that can be expected to always hold
2023-09-22 15:25:02 +0200 <tomsmeding> yet it is clearly a well-defined and useful class
2023-09-22 15:26:09 +0200sabino(~sabino@user/sabino)
2023-09-22 15:26:30 +0200 <tomsmeding> type classes are a method of abstraction, and their point is that functions can use certain functionality without caring precisely which implementation they're using. For that to work, there has to be some kind of abstract functionality that the type class provides
2023-09-22 15:27:12 +0200 <tomsmeding> and sometimes there are also algebraic laws that hold, which enable further reasoning about the type class methods, but those need not be there for the type class to be useful for their intended purpose: abstraction
2023-09-22 15:27:41 +0200 <danse-nr3_> i guess me and you are in one of the two agreement groups
2023-09-22 15:27:50 +0200vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua) (Remote host closed the connection)
2023-09-22 15:28:15 +0200 <tomsmeding> sometimes people write type classes with almost no abstraction, just to be able to use the same function name in multiple fairly unrelated contexts (really ad hoc overloading). This is also possible with type classes, but not really a nice use of them
2023-09-22 15:28:58 +0200vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua)
2023-09-22 15:29:03 +0200 <tomsmeding> danse-nr3_: I guess it depends on whether you would count the expected semantics of e.g. Hashable as a "law"
2023-09-22 15:30:44 +0200vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua) (Remote host closed the connection)
2023-09-22 15:30:58 +0200 <tomsmeding> but this "not nice" use of type classes would correspond, in an OOP language, with a function with a bunch of overloads that have little to do with each other. OOP people would call that "not nice" too
2023-09-22 15:31:04 +0200 <tomsmeding> this is not specific to type classes or FP
2023-09-22 15:31:10 +0200vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua)
2023-09-22 15:31:22 +0200 <danse-nr3_> i meant that we are on the same group, considering classes just as an abstraction mean. And to be honest i would also use them with almost no abstraction. Sometimes one writes code (declaring a variable, for instance) just for consistence and convenience, and then some patterns get more explicit
2023-09-22 15:31:24 +0200Feuermagier(~Feuermagi@user/feuermagier) (Ping timeout: 240 seconds)
2023-09-22 15:31:35 +0200 <tomsmeding> sure
2023-09-22 15:32:39 +0200vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua) (Remote host closed the connection)
2023-09-22 15:33:31 +0200 <tomsmeding> I would maybe even go so far as to say the following: type classes that are fully specified by a set of algebraic laws could be called _algebraic type classes_
2023-09-22 15:33:41 +0200 <tomsmeding> examples: Monoid, Monad, Eq, etc.
2023-09-22 15:33:46 +0200 <tomsmeding> MonadIO
2023-09-22 15:34:07 +0200 <tomsmeding> they're a subset of the useful type classes that correspond, in a way, to some mathematical concept
2023-09-22 15:34:11 +0200tremon(~tremon@83.80.159.219)
2023-09-22 15:34:19 +0200 <tomsmeding> not all abstraction corresponds to a mathematical concept, and yet we want to use such abstractions too
2023-09-22 15:34:49 +0200 <danse-nr3_> well i think they do, but those are trivial concepts that do not involve laws
2023-09-22 15:35:09 +0200 <tomsmeding> but they are not fully specified by the mathematical concept
2023-09-22 15:35:24 +0200 <tomsmeding> everything about Eq is specified by being being an equivalence relation
2023-09-22 15:35:40 +0200 <tomsmeding> there might be some trivial properties about Hashable, but there is more to it than just that
2023-09-22 15:36:41 +0200 <tomsmeding> what are the laws of ToField? https://hackage.haskell.org/package/sqlite-simple-0.4.18.2/docs/Database-SQLite-Simple-ToField.html
2023-09-22 15:37:16 +0200 <danse-nr3_> i agree that having a specific concept like "algebraic type classes" or something similar would make sense
2023-09-22 15:37:18 +0200 <tomsmeding> one might say that there are some laws in combination with FromField, that they have to be inverses of each other in some sense. So there are laws you can formulate. But surely that's not all there is too them!
2023-09-22 15:37:37 +0200 <tomsmeding> they also have to map naturally into the SQL data type domain, and that's an essential component of the abstraction
2023-09-22 15:38:00 +0200 <tomsmeding> s/too them/to them/
2023-09-22 15:38:17 +0200 <Rembane> That sounds painful and like a nice research project.
2023-09-22 15:38:25 +0200 <tomsmeding> what does?
2023-09-22 15:38:35 +0200xmachina(xmachina@gateway/vpn/protonvpn/xmachina)
2023-09-22 15:38:36 +0200 <Rembane> Adding and proving laws to FromField and ToField.
2023-09-22 15:38:59 +0200 <tomsmeding> hah
2023-09-22 15:39:03 +0200 <tomsmeding> yeah
2023-09-22 15:39:26 +0200 <tomsmeding> but my point is that not all of the semantics abstracted by those classes will be contained in those laws
2023-09-22 15:40:00 +0200 <Rembane> I agree.
2023-09-22 15:40:04 +0200 <tomsmeding> good luck formalising that String ought to map to SQLText and Text also, but ByteString ought not to
2023-09-22 15:41:22 +0200vglfr(~vglfr@188.239.201.89)
2023-09-22 15:41:37 +0200texasmynsted(~username@99.96.221.112) (Quit: WeeChat 3.0)
2023-09-22 15:42:01 +0200powderhorn(~powderhor@207-153-12-54.static.fttp.usinternet.com) (Quit: Client closed)
2023-09-22 15:42:12 +0200powderhorn(~powderhor@207-153-12-54.static.fttp.usinternet.com)
2023-09-22 15:43:23 +0200xmachina(xmachina@gateway/vpn/protonvpn/xmachina) (Client Quit)
2023-09-22 15:45:07 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-22 15:49:51 +0200acidjnk_new(~acidjnk@p200300d6e7072f380063779f7ab954b0.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-09-22 15:53:15 +0200xmachina(xmachina@gateway/vpn/protonvpn/xmachina)
2023-09-22 15:53:16 +0200xmachinaCo2
2023-09-22 15:53:43 +0200Co2xmachina
2023-09-22 15:54:19 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-09-22 15:54:19 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-09-22 15:54:19 +0200wroathe(~wroathe@user/wroathe)
2023-09-22 15:56:14 +0200stef204(~stef204@user/stef204)
2023-09-22 15:57:49 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-22 16:03:48 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2023-09-22 16:08:50 +0200RSCASTILHO(~RSCASTILH@187.40.124.54)
2023-09-22 16:11:02 +0200Guest65(~Guest65@dynamic-077-009-004-123.77.9.pool.telefonica.de)
2023-09-22 16:11:22 +0200Guest65(~Guest65@dynamic-077-009-004-123.77.9.pool.telefonica.de) (Client Quit)
2023-09-22 16:12:05 +0200Guest65(~Guest65@dynamic-077-009-004-123.77.9.pool.telefonica.de)
2023-09-22 16:18:15 +0200cfricke(~cfricke@user/cfricke) (Quit: WeeChat 4.0.4)
2023-09-22 16:19:25 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2023-09-22 16:21:00 +0200notzmv(~zmv@user/notzmv) (Ping timeout: 240 seconds)
2023-09-22 16:22:43 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-22 16:25:56 +0200acidjnk_new(~acidjnk@p200300d6e7072f380063779f7ab954b0.dip0.t-ipconnect.de)
2023-09-22 16:27:36 +0200mfg(~user@2a02:908:d13:e3e0:6a54:5aff:fe66:a805)
2023-09-22 16:27:55 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-09-22 16:41:02 +0200ft(~ft@p3e9bc680.dip0.t-ipconnect.de)
2023-09-22 16:41:23 +0200powderhorn(~powderhor@207-153-12-54.static.fttp.usinternet.com) (Ping timeout: 245 seconds)
2023-09-22 16:42:28 +0200dhil(~dhil@78.45.150.83.ewm.ftth.as8758.net)
2023-09-22 16:42:51 +0200misterfish(~misterfis@87.215.131.102) (Ping timeout: 252 seconds)
2023-09-22 16:43:17 +0200hugo-(~hugo@verdigris.lysator.liu.se)
2023-09-22 16:55:55 +0200tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net)
2023-09-22 16:56:07 +0200stef204(~stef204@user/stef204) (Quit: WeeChat 4.0.4)
2023-09-22 16:57:12 +0200Achylles(~Achylles_@45.182.57.64)
2023-09-22 16:58:13 +0200Achylles(~Achylles_@45.182.57.64) (Read error: Connection reset by peer)
2023-09-22 17:02:41 +0200Guest65(~Guest65@dynamic-077-009-004-123.77.9.pool.telefonica.de) (Quit: Client closed)
2023-09-22 17:06:11 +0200Sgeo(~Sgeo@user/sgeo)
2023-09-22 17:07:02 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:882f:270a:9fdd:8778) (Quit: WeeChat 2.8)
2023-09-22 17:19:58 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-22 17:23:58 +0200michalz(~michalz@185.246.207.197) (Remote host closed the connection)
2023-09-22 17:25:52 +0200econo_(uid147250@id-147250.tinside.irccloud.com)
2023-09-22 17:29:43 +0200mfg(~user@2a02:908:d13:e3e0:6a54:5aff:fe66:a805) (Ping timeout: 264 seconds)
2023-09-22 17:31:37 +0200mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2023-09-22 17:32:53 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-22 17:34:45 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-22 17:36:39 +0200acidjnk_new(~acidjnk@p200300d6e7072f380063779f7ab954b0.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2023-09-22 17:36:48 +0200bontaq(~user@ool-45707d2c.dyn.optonline.net)
2023-09-22 17:37:42 +0200smoothdev(~smoothdev@91-169-231-236.subs.proxad.net) (Read error: Connection reset by peer)
2023-09-22 17:41:03 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049) (Remote host closed the connection)
2023-09-22 17:41:18 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049)
2023-09-22 17:42:58 +0200dcoutts_(~duncan@2a02:8012:ae9a:0:217c:5666:d075:6292) (Ping timeout: 252 seconds)
2023-09-22 17:51:45 +0200xmachina(xmachina@gateway/vpn/protonvpn/xmachina) (Ping timeout: 258 seconds)
2023-09-22 17:52:38 +0200hugo-(~hugo@verdigris.lysator.liu.se) (Ping timeout: 260 seconds)
2023-09-22 17:52:53 +0200 <fendor> Can I have Codensity for a graded/parameterised monad in Haskell?
2023-09-22 18:00:15 +0200danse-nr3_(~francesco@151.47.41.11) (Ping timeout: 240 seconds)
2023-09-22 18:01:42 +0200hugo-(~hugo@verdigris.lysator.liu.se)
2023-09-22 18:03:16 +0200 <lyxia> fendor: sure
2023-09-22 18:03:40 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049) (Remote host closed the connection)
2023-09-22 18:04:33 +0200 <lyxia> newtype Codensity m g a = Codensity (forall h r. (a -> m h r) -> m (g <> h) r)
2023-09-22 18:05:34 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-22 18:05:40 +0200xmachina(~xmachina@modemcable048.127-56-74.mc.videotron.ca)
2023-09-22 18:06:50 +0200 <fendor> Where `<>` is some appropriate monoid... That makes sense, and for a parameterised monad? I had `newtype ICodensity m p q a = ICodensity (forall c . (a -> m p q c) -> m p q c)`
2023-09-22 18:07:02 +0200 <fendor> but that looks like it is incorrect
2023-09-22 18:07:03 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 240 seconds)
2023-09-22 18:07:19 +0200 <fendor> the inner p and q should be i and j,
2023-09-22 18:08:14 +0200cptaffe`(~cptaffe@user/cptaffe) (Quit: ZNC 1.8.2 - https://znc.in)
2023-09-22 18:08:36 +0200cptaffe(~cptaffe@user/cptaffe)
2023-09-22 18:08:38 +0200edr(~edr@user/edr)
2023-09-22 18:09:58 +0200 <ncf> ICodensity m j k a = ICodensity (forall c. (a -> m i j c) -> m i k c) ?
2023-09-22 18:10:06 +0200 <ncf> might need to swap them depending on how you're composing
2023-09-22 18:10:37 +0200 <fendor> and it should be `forall i.` I assume?
2023-09-22 18:10:52 +0200 <ncf> yeah
2023-09-22 18:11:59 +0200 <fendor> I am not sure I see that this is correct... Why is j and k in the post condition only?
2023-09-22 18:12:34 +0200 <fendor> s/that/why/
2023-09-22 18:14:25 +0200 <ncf> think of yoneda: (j -> k) is isomorphic to (forall i. (i -> j) -> i -> k)
2023-09-22 18:15:23 +0200 <ncf> or just partially apply your bind operator to some value of type m j k a and see what type you get
2023-09-22 18:16:53 +0200 <fendor> ah, ok, that makes sense
2023-09-22 18:21:55 +0200 <fendor> thanks!
2023-09-22 18:23:39 +0200cptaffe`(~cptaffe@user/cptaffe)
2023-09-22 18:23:48 +0200azimut_(~azimut@gateway/tor-sasl/azimut)
2023-09-22 18:24:13 +0200cptaffe(~cptaffe@user/cptaffe) (Ping timeout: 252 seconds)
2023-09-22 18:24:35 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 252 seconds)
2023-09-22 18:27:48 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-22 18:29:46 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-09-22 18:30:51 +0200dhil(~dhil@78.45.150.83.ewm.ftth.as8758.net) (Ping timeout: 258 seconds)
2023-09-22 18:32:34 +0200danse-nr3_(~francesco@151.47.41.11)
2023-09-22 18:39:35 +0200 <fendor> ncf, btw, when I enter `m j k a >>=` it becomes `(a -> m j k b) -> m i k b`. Which probably is what you meant by swapping?
2023-09-22 18:40:35 +0200 <ncf> yeah
2023-09-22 18:40:55 +0200 <fendor> thank you for your help!
2023-09-22 18:41:13 +0200orcus(~orcus@mail.brprice.uk) (Quit: ZNC 1.8.2 - https://znc.in)
2023-09-22 18:41:13 +0200dispater(~dispater@mail.brprice.uk) (Quit: ZNC 1.8.2 - https://znc.in)
2023-09-22 18:41:46 +0200chele(~chele@user/chele) (Remote host closed the connection)
2023-09-22 18:41:59 +0200notzmv(~zmv@user/notzmv)
2023-09-22 18:42:58 +0200dispater(~dispater@mail.brprice.uk)
2023-09-22 18:42:58 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049)
2023-09-22 18:43:28 +0200orcus(~orcus@mail.brprice.uk)
2023-09-22 18:47:11 +0200fendor(~fendor@2a02:8388:1640:be00:aab:1226:f274:5021) (Remote host closed the connection)
2023-09-22 18:51:28 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049) (Remote host closed the connection)
2023-09-22 18:51:43 +0200eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-09-22 18:58:55 +0200sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2023-09-22 19:00:58 +0200danse-nr3_(~francesco@151.47.41.11) (Read error: Connection reset by peer)
2023-09-22 19:01:52 +0200danse-nr3_(~francesco@na-19-67-153.service.infuturo.it)
2023-09-22 19:08:33 +0200monochrom(~trebla@216.138.220.146)
2023-09-22 19:17:34 +0200acidjnk_new(~acidjnk@p200300d6e7072f38e0c62ed7d1d3bf45.dip0.t-ipconnect.de)
2023-09-22 19:17:48 +0200idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-09-22 19:20:06 +0200cptaffe`(~cptaffe@user/cptaffe) (Quit: ZNC 1.8.2 - https://znc.in)
2023-09-22 19:20:24 +0200cptaffe(~cptaffe@user/cptaffe)
2023-09-22 19:23:26 +0200smoothdev(~smoothdev@91-169-231-236.subs.proxad.net)
2023-09-22 19:24:00 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-22 19:26:32 +0200gatekempt(~gatekempt@user/gatekempt)
2023-09-22 19:28:44 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 248 seconds)
2023-09-22 19:36:49 +0200sm(~sm@plaintextaccounting/sm)
2023-09-22 19:40:39 +0200dhil(~dhil@78.45.150.83.ewm.ftth.as8758.net)
2023-09-22 19:42:41 +0200azimut_(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 252 seconds)
2023-09-22 19:44:05 +0200sm(~sm@plaintextaccounting/sm) (Quit: sm)
2023-09-22 19:45:08 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-22 19:45:43 +0200eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-09-22 19:47:11 +0200qqq(~qqq@92.43.167.61)
2023-09-22 19:48:49 +0200RSCASTILHO(~RSCASTILH@187.40.124.54) ()
2023-09-22 19:51:30 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-09-22 19:54:05 +0200billchenchina(~billchenc@103.152.35.21) (Remote host closed the connection)
2023-09-22 19:56:37 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 252 seconds)
2023-09-22 20:00:57 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-09-22 20:02:20 +0200 <exarkun> Anyone have experience with or opinions about https://ramirez7.github.io/monad-fault/Control-Monad-Trans-Fault.html or similar libraries? Can it be said either that "fault injection" a good or bad idea in Haskell?
2023-09-22 20:05:51 +0200phma(~phma@host-67-44-208-41.hnremote.net) (Read error: Connection reset by peer)
2023-09-22 20:06:50 +0200phma(~phma@2001:5b0:212a:dfd8:7461:70e8:4780:de84)
2023-09-22 20:08:30 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049)
2023-09-22 20:18:23 +0200TimWolla(~timwolla@2a01:4f8:150:6153:beef::6667) (Quit: Bye)
2023-09-22 20:23:18 +0200TimWolla(~timwolla@2a01:4f8:150:6153:beef::6667)
2023-09-22 20:24:27 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-22 20:26:55 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049) (Remote host closed the connection)
2023-09-22 20:29:14 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 245 seconds)
2023-09-22 20:30:44 +0200Tesfe2321(~School@2001:1970:5199:fa00::a4bf)
2023-09-22 20:31:41 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049)
2023-09-22 20:32:37 +0200zincy(~tom@2a00:23c8:970c:4801:5b6a:e81b:79dc:f684)
2023-09-22 20:33:22 +0200 <zincy> let centering_matrix: OMatrix<f64, Dyn, Dyn> = OMatrix::<f64, Dyn, Dyn>::from_vec(n, m.ncols(), col_means);
2023-09-22 20:33:30 +0200 <zincy> Oh wrong channel sorry
2023-09-22 20:35:18 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-09-22 20:36:53 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049) (Remote host closed the connection)
2023-09-22 20:37:52 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049)
2023-09-22 20:38:14 +0200spatchkaa(~spatchkaa@S010600fc8da47b63.gv.shawcable.net)
2023-09-22 20:41:13 +0200misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-09-22 20:41:19 +0200sm(~sm@plaintextaccounting/sm)
2023-09-22 20:41:48 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049) (Remote host closed the connection)
2023-09-22 20:43:50 +0200sm(~sm@plaintextaccounting/sm) (Client Quit)
2023-09-22 20:47:26 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-22 20:47:29 +0200wootehfoot(~wootehfoo@user/wootehfoot)
2023-09-22 20:48:49 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-22 20:49:27 +0200 <exarkun> no opinions on fault injection huh
2023-09-22 20:57:48 +0200ByronJohnson(~bairyn@50-250-232-19-static.hfc.comcastbusiness.net) (Ping timeout: 240 seconds)
2023-09-22 21:03:22 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 260 seconds)
2023-09-22 21:03:45 +0200ByronJohnson(~bairyn@50-250-232-19-static.hfc.comcastbusiness.net)
2023-09-22 21:04:23 +0200 <monochrom> I don't know fault injection. I don't suppose it would hurt.
2023-09-22 21:09:08 +0200EvanR(~EvanR@user/evanr) (Remote host closed the connection)
2023-09-22 21:10:45 +0200 <mauke> I inject my faults the old-fashioned way, using a keyboard
2023-09-22 21:11:12 +0200bardman(~bardman@4.17.84.154)
2023-09-22 21:11:29 +0200 <danse-nr3_> i do not have many opinions on transformers, normally my efforts are geared towards moving most logic to pure functions
2023-09-22 21:12:54 +0200EvanR(~EvanR@user/evanr)
2023-09-22 21:14:42 +0200bardman(~bardman@4.17.84.154) (Client Quit)
2023-09-22 21:14:45 +0200 <exarkun> I do like pure functions.
2023-09-22 21:16:22 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-22 21:17:24 +0200stefan-__(uid620054@id-620054.lymington.irccloud.com)
2023-09-22 21:17:48 +0200 <davean> Pure functions is where most logic should be
2023-09-22 21:21:35 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:182a:8598:da7e:1049)
2023-09-22 21:22:25 +0200 <mauke> in haskell, all functions are pure
2023-09-22 21:22:46 +0200cptaffe(~cptaffe@user/cptaffe) (Remote host closed the connection)
2023-09-22 21:22:48 +0200 <mauke> s/all/most/
2023-09-22 21:23:19 +0200 <exarkun> did you count them
2023-09-22 21:23:50 +0200 <EvanR> in haskell the purity of the function reflects the purity of the person who wrote it's heart
2023-09-22 21:24:06 +0200 <davean> mauke: I don't consider FFI pure really.
2023-09-22 21:24:17 +0200 <mauke> I discounted unsafePerformIO and trace
2023-09-22 21:25:00 +0200 <exarkun> if you enumerate all possible functions, what is the ratio of safe to unsafe
2023-09-22 21:25:04 +0200 <exarkun> I mean pure to impure
2023-09-22 21:25:26 +0200 <EvanR> don't try to enumerate all functions
2023-09-22 21:25:39 +0200 <exarkun> There's more than one way to take a pure function and make it impure, so the ratio of impure to pure must be greater than 1
2023-09-22 21:25:39 +0200 <tomsmeding> > let inf = read "Infinity" :: Double in inf / inf
2023-09-22 21:25:40 +0200 <EvanR> that's like enumerating all reals
2023-09-22 21:25:41 +0200 <lambdabot> NaN
2023-09-22 21:25:53 +0200 <exarkun> EvanR: It's _like_ it, but there's far fewer functions than reals.
2023-09-22 21:26:03 +0200 <EvanR> no because how many types are there
2023-09-22 21:26:05 +0200 <danse-nr3_> by "pure" i meant "without side effects", meaning they do not need monads. But yeah, technically i would consider also monadic functions as pure
2023-09-22 21:26:11 +0200 <EvanR> for instance, reals are a type
2023-09-22 21:26:29 +0200 <mauke> (a ->) is a monad, so don't even get me started
2023-09-22 21:26:29 +0200 <exarkun> EvanR: Reals aren't a type in Haskell!
2023-09-22 21:26:48 +0200 <tomsmeding> @hackage exact-real
2023-09-22 21:26:48 +0200 <lambdabot> https://hackage.haskell.org/package/exact-real
2023-09-22 21:27:17 +0200 <exarkun> tomsmeding: Clever, but.
2023-09-22 21:27:19 +0200 <monochrom> If you enumerate all possible functions, firstly what's your definition for "function"? :)
2023-09-22 21:28:05 +0200 <monochrom> Secondly why should I count functions that nobody writes?
2023-09-22 21:28:05 +0200 <EvanR> my ultrafinitism dar is going off too, watch your back
2023-09-22 21:28:37 +0200 <EvanR> there's only so many haskell functions you can write before someone stops paying your bills
2023-09-22 21:28:44 +0200 <mauke> all the lonely functions, where do they all come from
2023-09-22 21:29:40 +0200 <monochrom> Analogously, the density of rational numbers among real numbers (or even merely cyclotomic numbers) is 0, yet we use rational numbers so much more often than the rest.
2023-09-22 21:30:28 +0200euleritian(~euleritia@ip4d16fc12.dynamic.kabel-deutschland.de)
2023-09-22 21:30:30 +0200 <monochrom> The point is "ratio of all possible X" is very likely irrelevant.
2023-09-22 21:31:35 +0200 <monochrom> ObHaskell: https://hackage.haskell.org/package/cyclotomic :)
2023-09-22 21:31:57 +0200danse-nr3_(~francesco@na-19-67-153.service.infuturo.it) (Ping timeout: 260 seconds)
2023-09-22 21:32:33 +0200 <tomsmeding> > mutiplication
2023-09-22 21:33:59 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-22 21:34:35 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-22 21:36:23 +0200spatchkaa(~spatchkaa@S010600fc8da47b63.gv.shawcable.net) (Ping timeout: 245 seconds)
2023-09-22 21:37:25 +0200 <mauke> mutable implication
2023-09-22 21:38:36 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2023-09-22 21:38:54 +0200 <monochrom> Oh heh
2023-09-22 21:39:14 +0200 <monochrom> Is it OK to say you mean Kleisli arrows? :)
2023-09-22 21:40:13 +0200Tesfe2321(~School@2001:1970:5199:fa00::a4bf) (Ping timeout: 258 seconds)
2023-09-22 21:40:27 +0200 <mauke> huh. I just realized Kleisli /= Kleene
2023-09-22 21:40:56 +0200 <monochrom> Kleene also had interesting stuff. :)
2023-09-22 21:41:19 +0200 <mauke> I guess my brain uses hashing to locate memories
2023-09-22 21:41:56 +0200 <darkling> I've often felt that, too. The more you put in, the harder it is to recall the right thing, because there's more collisions.
2023-09-22 21:42:07 +0200 <monochrom> I think we all do. I have my share of mixing up things.
2023-09-22 21:42:19 +0200 <darkling> It almost certainly doesn't work that way, but it feels like a practical model.
2023-09-22 21:42:43 +0200 <EvanR> if IRC users have the same length nick with same beginning and ending letter, I have no idea which is which
2023-09-22 21:43:22 +0200 <tomsmeding> it gets worse if weechat gives them the same colour
2023-09-22 21:43:51 +0200 <darkling> Indeed. (Although it's HexChat here)
2023-09-22 21:44:03 +0200myme(~myme@2a01:799:d60:e400:2874:313d:614e:da9) (Ping timeout: 258 seconds)
2023-09-22 21:44:20 +0200 <tomsmeding> I added the client because I'm not sure how many others also do colours like that :p
2023-09-22 21:44:54 +0200myme(~myme@2a01:799:d60:e400:2729:4165:2cf3:cd0e)
2023-09-22 21:46:41 +0200RedFlamingos(~RedFlamin@user/RedFlamingos)
2023-09-22 21:47:25 +0200ft(~ft@p3e9bc680.dip0.t-ipconnect.de) (Remote host closed the connection)
2023-09-22 21:50:43 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 264 seconds)
2023-09-22 21:51:10 +0200idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.0.2)
2023-09-22 21:51:38 +0200ft(~ft@p3e9bc680.dip0.t-ipconnect.de)
2023-09-22 21:54:29 +0200Natch(~natch@c-9e07225c.038-60-73746f7.bbcust.telenor.se) (Remote host closed the connection)
2023-09-22 22:00:43 +0200Pickchea(~private@user/pickchea)
2023-09-22 22:02:37 +0200hgolden(~hgolden@2603-8000-9d00-3ed1-a11a-09f7-e752-5c28.res6.spectrum.com)
2023-09-22 22:04:39 +0200jackneill__(~Jackneill@20014C4E1E062E0011575DEE5212F0F8.dsl.pool.telekom.hu) (Ping timeout: 240 seconds)
2023-09-22 22:18:19 +0200Natch(~natch@c-9e07225c.038-60-73746f7.bbcust.telenor.se)
2023-09-22 22:18:59 +0200monochrommonochrm
2023-09-22 22:20:43 +0200misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 264 seconds)
2023-09-22 22:21:06 +0200Inst(~Inst@120.244.192.250) (Ping timeout: 252 seconds)
2023-09-22 22:28:36 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-09-22 22:45:33 +0200ubert(~Thunderbi@178.165.190.116.wireless.dyn.drei.com) (Remote host closed the connection)
2023-09-22 22:59:49 +0200 <int-e> phma: https://paste.debian.net/1292852/ gets within 50% of Rust for me. The main change is to use mutable arrays to reduce allocations; I'm also using `vector` because the indexing there doesn't suffer from the overhead brought in by `Ix`. Using `unsafeRead` and `unsafeWrite` and `unsafeIndex` would give another 10% speedup... not dramatic. I dropped the -N RTS flags default because it made the...
2023-09-22 22:59:55 +0200 <int-e> ...code slower for me. Finally note that the compiler flags in the `.cabal` file only apply to the package itself, so make sure that the dependencies are actually compiled with optimizations enabled.
2023-09-22 23:01:34 +0200kimiamania4(~65804703@user/kimiamania) (Quit: PegeLinux)
2023-09-22 23:02:00 +0200kimiamania4(~65804703@user/kimiamania)
2023-09-22 23:02:47 +0200Guest|7(~Guest|7@37.140.50.226)
2023-09-22 23:03:02 +0200Guest|7(~Guest|7@37.140.50.226) (Client Quit)
2023-09-22 23:04:35 +0200Tesfe2321(~School@2001:1970:5199:fa00::a4bf)
2023-09-22 23:05:12 +0200 <int-e> (The funniest (and maybe embarrassing) part of this are two NOINLINE pragmas that made the code 2x faster.)
2023-09-22 23:07:16 +0200 <EvanR> NOINLINE made the code faster
2023-09-22 23:07:18 +0200 <EvanR> wut
2023-09-22 23:07:45 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-22 23:07:48 +0200 <davean> NOINLINE can often make haskell faster, or slower, it depends.
2023-09-22 23:08:00 +0200 <davean> Haskell has a few problems with over inlining and a few problems when you don't inline
2023-09-22 23:08:10 +0200 <davean> one needs to consider inlining fairly carefully for performant code
2023-09-22 23:08:30 +0200 <davean> one example is that inlining can blow out the trace, and Haskell is already decode heavy for the CPU
2023-09-22 23:08:52 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-09-22 23:09:32 +0200 <davean> int-e: Haven't looked specificly, but did you try -N with the single threaded GC?
2023-09-22 23:09:45 +0200 <int-e> Unfortunate inlining decisions can cause GHC to evaluate an expensive expression multiple tiems... I suspect that was the case here.
2023-09-22 23:09:59 +0200 <davean> int-e: yep!
2023-09-22 23:10:04 +0200 <davean> There are a number of issues
2023-09-22 23:10:10 +0200 <EvanR> so we want to be lazier
2023-09-22 23:10:17 +0200 <davean> EvanR: Yes, very often
2023-09-22 23:10:31 +0200 <davean> Haskell's performance often comes from its laziness correctly applied
2023-09-22 23:10:37 +0200 <davean> its the biggest hammer we have to make code faster
2023-09-22 23:10:50 +0200 <int-e> davean: I didn't, there's little parallelism to begin with. AIUI -N is an insane default anyway when there's hyperthreading.
2023-09-22 23:10:53 +0200 <EvanR> do less work, get done faster
2023-09-22 23:10:56 +0200 <davean> Inlining is mostly important in Haskell because it can simplify the code paths and remove indirection
2023-09-22 23:11:12 +0200 <davean> EvanR: its not even doing less work
2023-09-22 23:11:21 +0200 <davean> laziness is about control flow.
2023-09-22 23:11:46 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-09-22 23:11:51 +0200 <davean> and it can also rearrange access patterns, etc
2023-09-22 23:14:22 +0200monochrm(~trebla@216.138.220.146) (Remote host closed the connection)
2023-09-22 23:14:43 +0200dhil(~dhil@78.45.150.83.ewm.ftth.as8758.net) (Ping timeout: 264 seconds)
2023-09-22 23:15:39 +0200monochrom(trebla@216.138.220.146)
2023-09-22 23:16:07 +0200danza(~francesco@rm-19-3-110.service.infuturo.it)
2023-09-22 23:16:31 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-09-22 23:17:55 +0200solution(~solution@178-164-206-58.pool.digikabel.hu) (Ping timeout: 244 seconds)
2023-09-22 23:18:19 +0200Feuermagier(~Feuermagi@user/feuermagier)
2023-09-22 23:19:49 +0200solution(~solution@77-234-80-135.pool.digikabel.hu)
2023-09-22 23:21:51 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-22 23:24:03 +0200jargon(~jargon@184.101.67.95) (Remote host closed the connection)
2023-09-22 23:25:15 +0200acidjnk_new(~acidjnk@p200300d6e7072f38e0c62ed7d1d3bf45.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-09-22 23:26:38 +0200jargon(~jargon@184.101.67.95)
2023-09-22 23:28:31 +0200gatekempt(~gatekempt@user/gatekempt) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-09-22 23:34:15 +0200danza(~francesco@rm-19-3-110.service.infuturo.it) (Ping timeout: 240 seconds)
2023-09-22 23:35:23 +0200ulysses4ever(~artem@2601:408:c408:405:e59c:f774:75db:69ea)
2023-09-22 23:35:33 +0200chiselfuse(~chiselfus@user/chiselfuse) (Quit: leaving)
2023-09-22 23:35:46 +0200random-jellyfish(~random-je@user/random-jellyfish)
2023-09-22 23:35:54 +0200ulysses4everartem
2023-09-22 23:36:37 +0200smoothdev(~smoothdev@91-169-231-236.subs.proxad.net) (Quit: smoothdev)
2023-09-22 23:36:43 +0200chiselfuse(~chiselfus@user/chiselfuse)
2023-09-22 23:41:51 +0200merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 240 seconds)
2023-09-22 23:44:58 +0200son0p(~ff@181.136.122.143)
2023-09-22 23:53:41 +0200artem(~artem@2601:408:c408:405:e59c:f774:75db:69ea) (Read error: Connection reset by peer)
2023-09-22 23:56:08 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)