IRCBrowse

2023/02/28

2023-02-28 00:00:00 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-28 00:04:42 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 255 seconds)
2023-02-28 00:11:38 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-02-28 00:13:52 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-02-28 00:19:33 +0100gmg(~user@user/gehmehgeh)
2023-02-28 00:24:05 +0100zeenk(~zeenk@2a02:2f04:a20d:f900::7fe)
2023-02-28 00:25:21 +0100gmg(~user@user/gehmehgeh) (Quit: Leaving)
2023-02-28 00:28:41 +0100 <c_wraith> These days if you're on x64 and using aes that's not using the CPU intructions for it, you're leaving a lot on the floor in terms of performance. Neither C nor Haskell are gonna give you that by default. You want quick access to machine code.
2023-02-28 00:31:24 +0100 <AWizzArd> For newtype Cont a = Cont { unCont :: forall r. (a -> r) -> r } I have this fmap implementation: fmap f (Cont c) = Cont (\b -> c (b . f))
2023-02-28 00:32:11 +0100 <AWizzArd> Interestingly fmap f (Cont c) = Cont (\b -> b (c f)) also compiles.
2023-02-28 00:33:48 +0100 <mauke> c_wraith: or C compiler intrinsics
2023-02-28 00:36:47 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-02-28 00:39:49 +0100notzmv(~zmv@user/notzmv)
2023-02-28 00:43:02 +0100alecs(~alecs@host-79-44-188-195.retail.telecomitalia.it) (Quit: WeeChat 3.8)
2023-02-28 00:54:54 +0100tremon(~tremon@83-85-213-108.cable.dynamic.v4.ziggo.nl) (Quit: getting boxed in)
2023-02-28 00:58:26 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) (Quit: Leaving.)
2023-02-28 01:01:27 +0100 <monochrom> AWizzArd: Something about parametricity or Yoneda's lemma says that they do the same thing, too!
2023-02-28 01:02:12 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:f1bd:eef9:4eee:a4c2)
2023-02-28 01:03:38 +0100lxi(~quassel@2a02:2f08:4d1c:400:8170:232:8e57:afe9) (Remote host closed the connection)
2023-02-28 01:04:10 +0100zeenk(~zeenk@2a02:2f04:a20d:f900::7fe) (Quit: Konversation terminated!)
2023-02-28 01:04:52 +0100lyle(~lyle@104.246.145.237) (Quit: WeeChat 3.8)
2023-02-28 01:06:41 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:f1bd:eef9:4eee:a4c2) (Ping timeout: 255 seconds)
2023-02-28 01:08:55 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-02-28 01:09:43 +0100mauke_(~mauke@user/mauke)
2023-02-28 01:11:28 +0100mauke(~mauke@user/mauke) (Ping timeout: 268 seconds)
2023-02-28 01:11:28 +0100mauke_mauke
2023-02-28 01:15:04 +0100kupi(uid212005@id-212005.hampstead.irccloud.com)
2023-02-28 01:18:25 +0100dsrt^(~dsrt@c-24-30-76-89.hsd1.ga.comcast.net)
2023-02-28 01:19:11 +0100acidjnk(~acidjnk@p200300d6e715c49250da1057090936da.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
2023-02-28 01:20:02 +0100tubogram44(~tubogram@user/tubogram)
2023-02-28 01:34:23 +0100mrcsno(~mrcsno@71.69.152.220) (Ping timeout: 264 seconds)
2023-02-28 01:50:20 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-02-28 01:52:35 +0100AlexNoo(~AlexNoo@94.233.240.140) (Read error: Connection reset by peer)
2023-02-28 01:55:24 +0100AlexZenon(~alzenon@94.233.240.140) (Ping timeout: 255 seconds)
2023-02-28 01:55:27 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Killed (NickServ (GHOST command used by allbery_b)))
2023-02-28 01:55:27 +0100allbery_b(~geekosaur@xmonad/geekosaur)
2023-02-28 01:55:31 +0100allbery_bgeekosaur
2023-02-28 01:55:47 +0100AlexNoo(~AlexNoo@94.233.240.140)
2023-02-28 01:55:51 +0100Alex_test(~al_test@94.233.240.140) (Ping timeout: 255 seconds)
2023-02-28 01:58:35 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-02-28 01:58:35 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-02-28 01:58:35 +0100wroathe(~wroathe@user/wroathe)
2023-02-28 01:59:40 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 252 seconds)
2023-02-28 02:00:29 +0100emmanuelux_(~emmanuelu@user/emmanuelux)
2023-02-28 02:01:06 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-28 02:03:08 +0100Alex_test(~al_test@94.233.240.140)
2023-02-28 02:03:50 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Ping timeout: 255 seconds)
2023-02-28 02:04:24 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-02-28 02:08:36 +0100AlexZenon(~alzenon@94.233.240.140)
2023-02-28 02:10:45 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-02-28 02:16:52 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-02-28 02:18:00 +0100bitmapper(uid464869@id-464869.lymington.irccloud.com)
2023-02-28 02:21:15 +0100emmanuelux_(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-02-28 02:33:32 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 255 seconds)
2023-02-28 02:47:32 +0100AlexNoo(~AlexNoo@94.233.240.140) (Read error: Connection reset by peer)
2023-02-28 02:49:01 +0100Feuermagier(~Feuermagi@user/feuermagier)
2023-02-28 02:49:09 +0100AlexNoo(~AlexNoo@94.233.240.140)
2023-02-28 02:55:43 +0100bontaq(~user@ool-45779fe5.dyn.optonline.net) (Ping timeout: 248 seconds)
2023-02-28 03:00:10 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 252 seconds)
2023-02-28 03:01:58 +0100mniip(mniip@libera/staff/mniip) (Quit: This page is intentionally left blank)
2023-02-28 03:02:06 +0100mniip(mniip@libera/staff/mniip)
2023-02-28 03:18:34 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Read error: Connection reset by peer)
2023-02-28 03:22:58 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2023-02-28 03:26:38 +0100bilegeek(~bilegeek@2600:1008:b04a:2640:a05a:3165:8f58:e872)
2023-02-28 03:36:44 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-28 03:41:56 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 268 seconds)
2023-02-28 03:43:22 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-02-28 03:44:51 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-02-28 03:49:14 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds)
2023-02-28 03:50:36 +0100xff0x(~xff0x@ai081074.d.east.v6connect.net) (Ping timeout: 255 seconds)
2023-02-28 03:53:05 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-02-28 03:53:28 +0100gastus(~gastus@185.6.123.209) (Ping timeout: 246 seconds)
2023-02-28 03:56:53 +0100razetime(~Thunderbi@43.254.111.18)
2023-02-28 04:01:05 +0100jero98772(~jero98772@2800:484:1d80:d8ce:efcc:cbb3:7f2a:6dff) (Remote host closed the connection)
2023-02-28 04:09:34 +0100gastus(~gastus@185.6.123.209)
2023-02-28 04:23:30 +0100chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2023-02-28 04:23:45 +0100chexum(~quassel@gateway/tor-sasl/chexum)
2023-02-28 04:24:25 +0100bitmapper(uid464869@id-464869.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-02-28 04:26:44 +0100xff0x(~xff0x@125.103.176.34)
2023-02-28 04:27:24 +0100gastus_(~gastus@185.6.123.141)
2023-02-28 04:27:50 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 255 seconds)
2023-02-28 04:30:22 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:f1bd:eef9:4eee:a4c2)
2023-02-28 04:30:39 +0100gastus(~gastus@185.6.123.209) (Ping timeout: 255 seconds)
2023-02-28 04:36:50 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Ping timeout: 255 seconds)
2023-02-28 04:39:39 +0100td_(~td@i53870919.versanet.de) (Ping timeout: 255 seconds)
2023-02-28 04:40:15 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-02-28 04:41:20 +0100td_(~td@i5387093D.versanet.de)
2023-02-28 04:44:22 +0100terrorjack(~terrorjac@2a01:4f8:1c1e:4e8c::) (Quit: The Lounge - https://thelounge.chat)
2023-02-28 04:45:46 +0100terrorjack(~terrorjac@2a01:4f8:1c1e:4e8c::)
2023-02-28 04:46:19 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 252 seconds)
2023-02-28 04:47:48 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-02-28 04:47:48 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-02-28 04:47:48 +0100finn_elijaFinnElija
2023-02-28 04:56:42 +0100nattiestnate(~nate@202.138.250.9) (Quit: WeeChat 3.8)
2023-02-28 05:08:07 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-02-28 05:09:43 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-02-28 05:15:05 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2023-02-28 05:37:28 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-28 05:42:58 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com)
2023-02-28 05:50:45 +0100son0p(~ff@181.136.122.143) (Ping timeout: 255 seconds)
2023-02-28 05:53:27 +0100Square(~Square4@user/square) (Ping timeout: 255 seconds)
2023-02-28 05:55:08 +0100Vajb(~Vajb@hag-jnsbng11-58c3a5-27.dhcp.inet.fi)
2023-02-28 05:59:14 +0100mrcsno(~mrcsno@71.69.152.220)
2023-02-28 06:04:48 +0100Vajb(~Vajb@hag-jnsbng11-58c3a5-27.dhcp.inet.fi) (Read error: Connection reset by peer)
2023-02-28 06:06:07 +0100polyphem_(~rod@2a02:810d:840:8754:224e:f6ff:fe5e:bc17) (Ping timeout: 246 seconds)
2023-02-28 06:06:36 +0100Vajb(~Vajb@2001:999:230:f561:4ee8:ad7f:13ff:9959)
2023-02-28 06:11:10 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 268 seconds)
2023-02-28 06:23:16 +0100razetime(~Thunderbi@43.254.111.18) (Ping timeout: 246 seconds)
2023-02-28 06:25:25 +0100razetime(~Thunderbi@43.254.111.18)
2023-02-28 06:26:07 +0100mbuf(~Shakthi@49.204.135.165)
2023-02-28 06:27:49 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 246 seconds)
2023-02-28 06:32:26 +0100jakalx(~jakalx@base.jakalx.net)
2023-02-28 06:33:27 +0100trev(~trev@user/trev)
2023-02-28 06:49:52 +0100inversed(~inversed@bcdcac82.skybroadband.com) (Ping timeout: 248 seconds)
2023-02-28 06:56:54 +0100razetime(~Thunderbi@43.254.111.18) (Ping timeout: 255 seconds)
2023-02-28 06:57:22 +0100inversed(~inversed@bcdcac82.skybroadband.com)
2023-02-28 07:09:19 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-02-28 07:09:48 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-02-28 07:14:39 +0100bilegeek(~bilegeek@2600:1008:b04a:2640:a05a:3165:8f58:e872) (Quit: Leaving)
2023-02-28 07:20:16 +0100lottaquestions_(~nick@2607:fa49:503e:7100:376d:3f27:951:60f7) (Remote host closed the connection)
2023-02-28 07:20:42 +0100lottaquestions_(~nick@2607:fa49:503e:7100:508:8f8d:b11d:43cd)
2023-02-28 07:22:26 +0100mechap(~mechap@user/mechap) (Ping timeout: 255 seconds)
2023-02-28 07:23:29 +0100kupi(uid212005@id-212005.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-02-28 07:23:49 +0100Jade[m]1(~jade1024t@2001:470:69fc:105::3:238b)
2023-02-28 07:24:21 +0100shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 255 seconds)
2023-02-28 07:25:46 +0100mechap(~mechap@user/mechap)
2023-02-28 07:28:50 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-02-28 07:32:02 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-02-28 07:35:09 +0100inversed(~inversed@bcdcac82.skybroadband.com) (Ping timeout: 255 seconds)
2023-02-28 07:37:52 +0100inversed(~inversed@bcdcac82.skybroadband.com)
2023-02-28 07:45:07 +0100whatsupdoc(uid509081@2a03:5180:f:4::7:c499) (Quit: Connection closed for inactivity)
2023-02-28 07:48:34 +0100demsh(~demsh@algiz.demsh.org) ()
2023-02-28 07:52:08 +0100michalz(~michalz@185.246.207.215)
2023-02-28 07:57:14 +0100Natch(~natch@c-9e07225c.038-60-73746f7.bbcust.telenor.se)
2023-02-28 08:08:16 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-28 08:15:32 +0100alecs(~alecs@host-79-44-188-195.retail.telecomitalia.it)
2023-02-28 08:15:58 +0100roboguy_(~roboguy_@cpe-69-76-235-109.kc.res.rr.com)
2023-02-28 08:21:24 +0100razetime(~Thunderbi@117.193.6.229)
2023-02-28 08:23:45 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 255 seconds)
2023-02-28 08:29:37 +0100opticblast(~Thunderbi@172.58.85.230) (Ping timeout: 246 seconds)
2023-02-28 08:31:29 +0100xelxebar(~xelxebar@KD111239181227.au-net.ne.jp) (Read error: Connection reset by peer)
2023-02-28 08:32:03 +0100xelxebar(~xelxebar@om126166170159.28.openmobile.ne.jp)
2023-02-28 08:34:45 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-02-28 08:36:33 +0100mrcsno(~mrcsno@71.69.152.220) (Ping timeout: 252 seconds)
2023-02-28 08:41:45 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 255 seconds)
2023-02-28 08:42:39 +0100roboguy_(~roboguy_@cpe-69-76-235-109.kc.res.rr.com) (Quit: Leaving...)
2023-02-28 08:44:03 +0100coot(~coot@213.134.171.3)
2023-02-28 08:58:53 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-02-28 09:01:28 +0100razetime(~Thunderbi@117.193.6.229) (Ping timeout: 246 seconds)
2023-02-28 09:03:37 +0100MajorBiscuit(~MajorBisc@2001:1c00:2408:a400:67e:5371:52a7:9b9a)
2023-02-28 09:08:24 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-28 09:08:58 +0100Midjak(~Midjak@82.66.147.146)
2023-02-28 09:12:02 +0100lottaquestions(~nick@2607:fa49:503e:7100:29d5:6a23:249a:7ab4)
2023-02-28 09:13:22 +0100lottaquestions_(~nick@2607:fa49:503e:7100:508:8f8d:b11d:43cd) (Ping timeout: 246 seconds)
2023-02-28 09:13:58 +0100[_________](~oos95GWG@user/oos95GWG) (Quit: [_________])
2023-02-28 09:14:11 +0100razetime(~Thunderbi@117.193.6.229)
2023-02-28 09:14:41 +0100xelxebar_(~xelxebar@KD111239153139.au-net.ne.jp)
2023-02-28 09:16:12 +0100[_________](~oos95GWG@user/oos95GWG)
2023-02-28 09:17:36 +0100xelxebar(~xelxebar@om126166170159.28.openmobile.ne.jp) (Ping timeout: 252 seconds)
2023-02-28 09:19:11 +0100mechap_(~mechap@user/mechap)
2023-02-28 09:21:04 +0100acidjnk(~acidjnk@p200300d6e715c49275c5935bb14ea82c.dip0.t-ipconnect.de)
2023-02-28 09:21:27 +0100cfricke(~cfricke@user/cfricke)
2023-02-28 09:22:15 +0100mechap(~mechap@user/mechap) (Ping timeout: 255 seconds)
2023-02-28 09:22:48 +0100 <sm> 3,75h remaining in the haskell tiny game jam. If anyone has a tiny games still in mind , we could make 50 entries with 2 more. Submitting the PR before deadline will count. Good night all ! 🕹️🌙
2023-02-28 09:23:19 +0100 <sm> https://github.com/haskell-game/tiny-games-hs
2023-02-28 09:23:26 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:9ac6:7f56:c345:9bac)
2023-02-28 09:26:05 +0100razetime(~Thunderbi@117.193.6.229) (Remote host closed the connection)
2023-02-28 09:30:22 +0100zeenk(~zeenk@2a02:2f04:a20d:f900::7fe)
2023-02-28 09:34:40 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7)
2023-02-28 09:37:59 +0100Alex_test(~al_test@94.233.240.140) (Quit: ;-)
2023-02-28 09:39:08 +0100AlexZenon(~alzenon@94.233.240.140) (Quit: ;-)
2023-02-28 09:39:29 +0100AlexNoo(~AlexNoo@94.233.240.140) (Quit: Leaving)
2023-02-28 09:51:41 +0100machinedgod(~machinedg@2001:56a:7d0a:4a00:b9be:a4dc:5fc0:1fa5)
2023-02-28 09:53:44 +0100acidjnk_new(~acidjnk@2003:d6:e715:c492:38f8:489b:736b:3478)
2023-02-28 09:54:34 +0100yobson__(~yobson@mail.jotron.com)
2023-02-28 09:56:12 +0100gmg(~user@user/gehmehgeh)
2023-02-28 09:56:27 +0100teo(~teo@user/teo)
2023-02-28 09:57:36 +0100acidjnk(~acidjnk@p200300d6e715c49275c5935bb14ea82c.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
2023-02-28 10:01:51 +0100phma(~phma@host-67-44-208-187.hnremote.net) (Read error: Connection reset by peer)
2023-02-28 10:02:46 +0100phma(phma@2001:5b0:210d:cd18:ce32:5877:1a8e:e7d3)
2023-02-28 10:05:38 +0100lxi(~quassel@2a02:2f08:4d1c:400:444f:c660:fa90:43e5)
2023-02-28 10:05:38 +0100lxi(~quassel@2a02:2f08:4d1c:400:444f:c660:fa90:43e5) (Client Quit)
2023-02-28 10:07:30 +0100ft(~ft@p3e9bc443.dip0.t-ipconnect.de) (Quit: leaving)
2023-02-28 10:08:02 +0100lxi(~quassel@2a02:2f08:4d1c:400:444f:c660:fa90:43e5)
2023-02-28 10:09:38 +0100edwtjo(~edwtjo@h-109-228-137-133.A213.priv.bahnhof.se)
2023-02-28 10:09:38 +0100edwtjo(~edwtjo@h-109-228-137-133.A213.priv.bahnhof.se) (Changing host)
2023-02-28 10:09:38 +0100edwtjo(~edwtjo@fsf/member/edwtjo)
2023-02-28 10:11:31 +0100bontaq(~user@ool-45779fe5.dyn.optonline.net)
2023-02-28 10:13:03 +0100chele(~chele@user/chele)
2023-02-28 10:14:02 +0100mauke(~mauke@user/mauke) (Quit: leaving)
2023-02-28 10:16:15 +0100CiaoSen(~Jura@p200300c9570e91002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-02-28 10:21:13 +0100AlexZenon(~alzenon@94.233.240.140)
2023-02-28 10:22:14 +0100AlexNoo(~AlexNoo@94.233.240.140)
2023-02-28 10:22:23 +0100kupi(uid212005@id-212005.hampstead.irccloud.com)
2023-02-28 10:23:43 +0100MajorBiscuit(~MajorBisc@2001:1c00:2408:a400:67e:5371:52a7:9b9a) (Ping timeout: 246 seconds)
2023-02-28 10:24:36 +0100Alex_test(~al_test@94.233.240.140)
2023-02-28 10:25:56 +0100MajorBiscuit(~MajorBisc@c-001-024-033.client.tudelft.eduvpn.nl)
2023-02-28 10:28:29 +0100kuribas(~user@ptr-17d51eo9wm7f6qjcnfd.18120a2.ip6.access.telenet.be)
2023-02-28 10:29:46 +0100ubert1(~Thunderbi@2a02:8109:abc0:6434:5492:5a32:98f1:9180)
2023-02-28 10:33:20 +0100caryhartline(~caryhartl@2600:1700:2d0:8d30:cdb3:8615:a2b3:ec7c)
2023-02-28 10:35:37 +0100mc47(~mc47@xmonad/TheMC47)
2023-02-28 10:39:18 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-02-28 10:40:19 +0100MQ-17J(~MQ-17J@104.28.216.166)
2023-02-28 10:43:20 +0100gmg(~user@user/gehmehgeh) (Quit: Leaving)
2023-02-28 10:44:01 +0100mbuf(~Shakthi@49.204.135.165) (Ping timeout: 246 seconds)
2023-02-28 10:45:39 +0100gurkenglas(~gurkengla@dynamic-046-114-180-031.46.114.pool.telefonica.de)
2023-02-28 10:48:35 +0100yobson__(~yobson@mail.jotron.com) (Quit: Leaving...)
2023-02-28 10:57:35 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-02-28 10:59:06 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:f1bd:eef9:4eee:a4c2) (Remote host closed the connection)
2023-02-28 11:07:13 +0100Milan19(~Milan@46.143.81.55)
2023-02-28 11:09:14 +0100 <Milan19> Hi all, Do you recommend Functional programming languages as first language ? if yes,please recommend a simple language for self study
2023-02-28 11:09:47 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf) (Quit: use-value)
2023-02-28 11:10:30 +0100xelxebar_xelxebar
2023-02-28 11:10:55 +0100acidjnk_new(~acidjnk@2003:d6:e715:c492:38f8:489b:736b:3478) (Ping timeout: 252 seconds)
2023-02-28 11:12:40 +0100 <kuribas> Milan19: scheme
2023-02-28 11:13:18 +0100 <kuribas> Milan19: but it depends on your goals.
2023-02-28 11:14:08 +0100 <kuribas> If you just want to write a simple webapp to impress friends and family, go with python.
2023-02-28 11:14:11 +0100KaitoDaumoto(~asdf@user/kaitodaumoto) (Remote host closed the connection)
2023-02-28 11:15:26 +0100 <Milan19> I am patient and i want to do the right sustainable option ,not "most in fashion" option
2023-02-28 11:15:41 +0100xff0x(~xff0x@125.103.176.34) (Ping timeout: 252 seconds)
2023-02-28 11:16:25 +0100 <kuribas> sustainable?
2023-02-28 11:16:30 +0100 <kuribas> there is no "right" option.
2023-02-28 11:16:35 +0100__monty__(~toonn@user/toonn)
2023-02-28 11:17:23 +0100 <kuribas> If you want to do game programming, learn C++ and 3d mathematics. If you want to just make money programming in a business environment, learn java.
2023-02-28 11:17:29 +0100 <kuribas> If you want to do data science, learn python.
2023-02-28 11:17:31 +0100 <kuribas> etc...
2023-02-28 11:17:51 +0100 <_________> sustainable? learn cobol ;)
2023-02-28 11:19:32 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2023-02-28 11:19:44 +0100manwithluck(~manwithlu@194.177.28.192) (Remote host closed the connection)
2023-02-28 11:20:07 +0100 <Milan19> so I must see where I want to work and choose a language based on that?
2023-02-28 11:20:37 +0100 <kuribas> Milan19: That's a good idea in general
2023-02-28 11:20:44 +0100acidjnk_new(~acidjnk@p200300d6e715c492692e8d0c7f4fe68f.dip0.t-ipconnect.de)
2023-02-28 11:22:20 +0100 <Milan19> excuse me,it is a shame,I thought there are bad and good programming languages
2023-02-28 11:22:48 +0100 <kuribas> Milan19: you can become a generalist as well.
2023-02-28 11:22:51 +0100 <Milan19> thank you very much
2023-02-28 11:24:08 +0100 <tomsmeding> Milan19: there are bad and good programming languages for particular purposes; unfortunately, that ranking differs per purpose :)
2023-02-28 11:24:36 +0100 <tomsmeding> people like to get into flame wars based on bad vs good programming languages in general, but ultimately, it depends on the purpose
2023-02-28 11:24:36 +0100manwithluck(~manwithlu@194.177.28.192)
2023-02-28 11:25:00 +0100 <tomsmeding> (excluding obvious things like Brainfuck, which is suitable only for exercising your brain, not for any actual application)
2023-02-28 11:25:18 +0100 <kuribas> Milan19: there are bad languages for sure, only people don't agree which ones...
2023-02-28 11:25:20 +0100 <__monty__> Haskell scores pretty high if the goal is to be exposed to interesting stuff though : )
2023-02-28 11:25:28 +0100 <tomsmeding> kuribas++
2023-02-28 11:25:53 +0100 <Milan19> which language force thinking in  a  way ,that boost my problem solving skills?
2023-02-28 11:26:19 +0100ubert1(~Thunderbi@2a02:8109:abc0:6434:5492:5a32:98f1:9180) (Ping timeout: 248 seconds)
2023-02-28 11:26:25 +0100 <tomsmeding> there functional languages may well be helpful, haskell is a decent candidate
2023-02-28 11:26:25 +0100 <_________> intercal ;)
2023-02-28 11:26:30 +0100 <kuribas> Milan19: any language, just do a lot of exercises.
2023-02-28 11:26:33 +0100 <tomsmeding> _________: PLEASE no
2023-02-28 11:26:41 +0100 <_________> :D
2023-02-28 11:27:01 +0100 <tomsmeding> I mean, then do malbolge
2023-02-28 11:27:21 +0100 <Milan19> are yo making fun of me
2023-02-28 11:27:22 +0100 <kuribas> Milan19: haskell helps you thinking about state management, and composition and parametricity.
2023-02-28 11:27:47 +0100 <kuribas> Milan19: "making fun", not of you...
2023-02-28 11:28:02 +0100 <tomsmeding> Milan19: I'm definitely not making fun of you, though intercal and malbolge are not serious languages, that was a joke :p
2023-02-28 11:28:40 +0100 <_________> programming in intercal posses a problem by itself, so it should boost your problem solving skills ;)
2023-02-28 11:30:52 +0100 <Milan19> thank you ,I  guess i understand what yo meant
2023-02-28 11:31:21 +0100 <Milan19> haskell has a really friendly community
2023-02-28 11:31:39 +0100 <Milan19> I try to learn haskell one day
2023-02-28 11:31:47 +0100 <merijn> _________: I mean, intercal is much easier than malbolge :p
2023-02-28 11:31:48 +0100 <kuribas> Milan19: But more importantly, write code, do programming exercises, learn algorithms, etc..
2023-02-28 11:32:06 +0100 <merijn> Milan19: for what it's worth, my girlfriend learned haskell as a first language just fine
2023-02-28 11:32:41 +0100 <_________> merijn: that's true; it can be next step in the journey...
2023-02-28 11:32:46 +0100coot(~coot@213.134.171.3) (Quit: coot)
2023-02-28 11:33:59 +0100 <kuribas> IMO "Structure and interpretation of computer programs" is one of the best resources to learn about programming paradigms.
2023-02-28 11:34:12 +0100 <kuribas> Except for static types and type theory.
2023-02-28 11:35:53 +0100a_coll(~acoll@45.92.120.189)
2023-02-28 11:38:51 +0100 <Milan19> is it wise to start learning java? does it promote good programming habits? and then start learning functional programing or it is better to invest on learning a functional programming first?
2023-02-28 11:39:39 +0100 <Milan19> i know functional programming jobs is not as much as oop
2023-02-28 11:40:27 +0100 <tomsmeding> Milan19: "better" for what?
2023-02-28 11:40:42 +0100 <kuribas> Milan19: there are some absolutately abysmal practices in java.
2023-02-28 11:40:48 +0100 <tomsmeding> getting a job quickly, being able to produce beautiful code, being able to solve algorithmic problems quickly, or something else?
2023-02-28 11:40:51 +0100 <kuribas> spring boot, hybernate ORM, etc...
2023-02-28 11:41:09 +0100 <kuribas> all this no-code xml stuff is pretty hairy.
2023-02-28 11:41:35 +0100theproffesor(~theproffe@user/theproffesor) (Ping timeout: 260 seconds)
2023-02-28 11:42:20 +0100 <kuribas> Milan19: learning haskell and idris or lisps can really spoil working in other languages.
2023-02-28 11:43:01 +0100 <kuribas> Because then you know how not code, except that you find out most of the code out there is don't in that way.
2023-02-28 11:43:30 +0100 <hellwolf[m]> spoiler or spoiling the appetite?
2023-02-28 11:44:59 +0100 <kuribas> ruining the experience.
2023-02-28 11:45:45 +0100 <kuribas> Especially when you have to deal with people claiming FP is only for "academics with no practical insights".
2023-02-28 11:46:36 +0100 <kuribas> Or people who claim that formal verification and type systems should not be used because they make your program too rigid.
2023-02-28 11:50:28 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-02-28 11:50:38 +0100theproffesor(~theproffe@user/theproffesor)
2023-02-28 11:54:05 +0100 <Milan19> it seems most of people in haskell community are professional programmers , if you were me with your current experiences,what would be the roadmap for me as an absolute beginner?
2023-02-28 11:54:37 +0100 <Milan19> and I like you are not stuck in one holy paradigm
2023-02-28 11:58:44 +0100 <Milan19> excuse me if i asked too much .
2023-02-28 11:59:35 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:f1bd:eef9:4eee:a4c2)
2023-02-28 12:00:45 +0100theproffesor(~theproffe@user/theproffesor) (Read error: Connection reset by peer)
2023-02-28 12:01:07 +0100theproffesor(~theproffe@user/theproffesor)
2023-02-28 12:02:25 +0100acidjnk_new(~acidjnk@p200300d6e715c492692e8d0c7f4fe68f.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-02-28 12:04:52 +0100mmhat(~mmh@p200300f1c7054cf0ee086bfffe095315.dip0.t-ipconnect.de)
2023-02-28 12:05:30 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:f1bd:eef9:4eee:a4c2) (Ping timeout: 260 seconds)
2023-02-28 12:06:37 +0100xff0x(~xff0x@ai081074.d.east.v6connect.net)
2023-02-28 12:06:49 +0100 <hellwolf[m]> Good question, it really depends on what's your expectation.... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/2cb6bda9a585e9314bf7a2d12dad9cb318e2…>)
2023-02-28 12:07:18 +0100 <hellwolf[m]> I am biased, but I have programming decades and do know many languages.
2023-02-28 12:07:40 +0100mmhat(~mmh@p200300f1c7054cf0ee086bfffe095315.dip0.t-ipconnect.de) (Client Quit)
2023-02-28 12:07:47 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Read error: Connection reset by peer)
2023-02-28 12:10:33 +0100YoungFrog(~youngfrog@39.129-180-91.adsl-dyn.isp.belgacom.be) (Ping timeout: 255 seconds)
2023-02-28 12:12:20 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-02-28 12:17:02 +0100 <kuribas> Milan19: again, it dependens on your goals.
2023-02-28 12:18:51 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-02-28 12:23:51 +0100 <Milan19> thank you all ,you are fantastic
2023-02-28 12:23:55 +0100alecs(~alecs@host-79-44-188-195.retail.telecomitalia.it) (Quit: WeeChat 3.8)
2023-02-28 12:24:38 +0100phma(phma@2001:5b0:210d:cd18:ce32:5877:1a8e:e7d3) (Read error: Connection reset by peer)
2023-02-28 12:25:10 +0100bitmapper(uid464869@2a03:5180:f:2::7:17e5)
2023-02-28 12:25:32 +0100phma(~phma@host-67-44-208-37.hnremote.net)
2023-02-28 12:25:36 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-02-28 12:25:36 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-02-28 12:26:24 +0100Milan19(~Milan@46.143.81.55) (Quit: Client closed)
2023-02-28 12:28:23 +0100MQ-17J(~MQ-17J@104.28.216.166) (Ping timeout: 264 seconds)
2023-02-28 12:31:12 +0100MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2023-02-28 12:51:22 +0100CiaoSen(~Jura@p200300c9570e91002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-02-28 12:55:11 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:9ac6:7f56:c345:9bac) (Ping timeout: 248 seconds)
2023-02-28 13:03:47 +0100Nolrai(~Nolrai@c-73-240-99-98.hsd1.or.comcast.net)
2023-02-28 13:04:04 +0100Nolrai(~Nolrai@c-73-240-99-98.hsd1.or.comcast.net) (Client Quit)
2023-02-28 13:06:12 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf)
2023-02-28 13:07:16 +0100`2jt(~jtomas@84.78.228.193)
2023-02-28 13:09:01 +0100Lycurgus(~juan@user/Lycurgus)
2023-02-28 13:13:16 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-02-28 13:19:00 +0100theproffesor(~theproffe@user/theproffesor) (Ping timeout: 260 seconds)
2023-02-28 13:20:30 +0100zer0bitz(~zer0bitz@2001:2003:f443:d600:9d80:2d1f:b124:730)
2023-02-28 13:21:15 +0100lyle(~lyle@104.246.145.237)
2023-02-28 13:23:39 +0100 <lyxia> is there ever a reason to want foldl over foldl' for lists
2023-02-28 13:25:10 +0100CiaoSen(~Jura@p200300c9570e91002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-02-28 13:25:11 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:1e18:c182:81c1:156e)
2023-02-28 13:26:54 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-02-28 13:29:30 +0100`2jt(~jtomas@84.78.228.193) (Ping timeout: 260 seconds)
2023-02-28 13:30:21 +0100 <opqdonut> lyxia: for a short list with expensive elements and a short-circuiting operation maybe
2023-02-28 13:30:47 +0100 <opqdonut> but yeah, mostly not
2023-02-28 13:42:00 +0100acidjnk_new(~acidjnk@p200300d6e715c492c929333b144a2034.dip0.t-ipconnect.de)
2023-02-28 13:42:29 +0100 <tomsmeding> at that point I wonder if it'll be clearer what you're doing if you write it in terms of foldr and reverse instead
2023-02-28 13:43:08 +0100 <opqdonut> might be
2023-02-28 13:43:53 +0100 <tomsmeding> :t \f z -> foldr (flip f) z . reverse
2023-02-28 13:43:54 +0100 <lambdabot> (c -> b -> c) -> c -> [b] -> c
2023-02-28 13:44:04 +0100 <lyxia> yeah I imagine that would be my first thought too before wanting foldl
2023-02-28 13:44:12 +0100 <tomsmeding> because operationally that's kinda what you'll be doing with foldl anyway
2023-02-28 13:44:34 +0100 <tomsmeding> scan to the end, then walk backwards until the operation becomes lazy in its left argumnet
2023-02-28 13:45:10 +0100 <opqdonut> yeah
2023-02-28 13:48:51 +0100Midjak(~Midjak@82.66.147.146) (Read error: Connection reset by peer)
2023-02-28 13:49:45 +0100Midjak(~Midjak@82.66.147.146)
2023-02-28 13:52:37 +0100Midjak(~Midjak@82.66.147.146) (Read error: Connection reset by peer)
2023-02-28 13:53:19 +0100Midjak(~Midjak@82.66.147.146)
2023-02-28 13:54:32 +0100mrcsno(~mrcsno@71.69.152.220)
2023-02-28 13:57:50 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-02-28 13:59:50 +0100lxi(~quassel@2a02:2f08:4d1c:400:444f:c660:fa90:43e5) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-02-28 14:00:54 +0100jero98772(~jero98772@2800:484:1d80:d8ce:efcc:cbb3:7f2a:6dff)
2023-02-28 14:02:18 +0100K4su(~quassel@v2202212189510211193.supersrv.de) (Quit: ,o>)
2023-02-28 14:02:59 +0100it_(~quassel@v2202212189510211193.supersrv.de)
2023-02-28 14:03:57 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 255 seconds)
2023-02-28 14:13:29 +0100kenran(~user@user/kenran)
2023-02-28 14:28:30 +0100Midjak(~Midjak@82.66.147.146) (Read error: Connection reset by peer)
2023-02-28 14:29:15 +0100MajorBiscuit(~MajorBisc@c-001-024-033.client.tudelft.eduvpn.nl) (Ping timeout: 248 seconds)
2023-02-28 14:29:18 +0100Midjak(~Midjak@82.66.147.146)
2023-02-28 14:29:40 +0100 <kuribas> lyxia: theoretically yes, practially no :)
2023-02-28 14:31:40 +0100 <kuribas> > let lastEven = foldl (\a e -> if even? e then e else a) 0 in lastEven [1, undefined, 2, 3]
2023-02-28 14:31:42 +0100 <lambdabot> error:
2023-02-28 14:31:42 +0100 <lambdabot> Variable not in scope: (?) :: (a0 -> Bool) -> b1 -> Bool
2023-02-28 14:32:02 +0100 <kuribas> > let lastEven = foldl (\a e -> if e `mod` 2 == 0 then e else a) 0 in lastEven [1, undefined, 2, 3]
2023-02-28 14:32:04 +0100 <lambdabot> 2
2023-02-28 14:32:08 +0100 <kuribas> > let lastEven = foldl' (\a e -> if e `mod` 2 == 0 then e else a) 0 in lastEven [1, undefined, 2, 3]
2023-02-28 14:32:10 +0100 <lambdabot> *Exception: Prelude.undefined
2023-02-28 14:35:24 +0100MajorBiscuit(~MajorBisc@2001:1c00:2408:a400:67e:5371:52a7:9b9a)
2023-02-28 14:37:19 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-02-28 14:38:26 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2023-02-28 14:43:37 +0100MajorBiscuit(~MajorBisc@2001:1c00:2408:a400:67e:5371:52a7:9b9a) (Ping timeout: 252 seconds)
2023-02-28 14:43:37 +0100MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Read error: Connection reset by peer)
2023-02-28 14:45:38 +0100MajorBiscuit(~MajorBisc@c-001-024-033.client.tudelft.eduvpn.nl)
2023-02-28 14:52:53 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-02-28 14:54:07 +0100gurkenglas(~gurkengla@dynamic-046-114-180-031.46.114.pool.telefonica.de) (Ping timeout: 265 seconds)
2023-02-28 14:56:49 +0100masterbuilder(~masterbui@user/masterbuilder)
2023-02-28 14:59:46 +0100theproffesor(~theproffe@user/theproffesor)
2023-02-28 15:00:11 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds)
2023-02-28 15:01:54 +0100theproffesor(~theproffe@user/theproffesor) (Read error: Connection reset by peer)
2023-02-28 15:02:14 +0100lxi(~quassel@2a02:2f08:4d1c:400:508d:2f08:6dd4:357e)
2023-02-28 15:04:02 +0100stevan(~stevan@user/stevan)
2023-02-28 15:05:55 +0100masterbuilder(~masterbui@user/masterbuilder) (Quit: leaving)
2023-02-28 15:12:22 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-02-28 15:20:19 +0100xelxebar(~xelxebar@KD111239153139.au-net.ne.jp) (Ping timeout: 260 seconds)
2023-02-28 15:30:23 +0100CiaoSen(~Jura@p200300c9570e91002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
2023-02-28 15:31:17 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-02-28 15:31:25 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2023-02-28 15:34:19 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:1e18:c182:81c1:156e) (Ping timeout: 248 seconds)
2023-02-28 15:37:20 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2023-02-28 15:38:12 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 252 seconds)
2023-02-28 15:41:13 +0100theproffesor(~theproffe@user/theproffesor)
2023-02-28 15:45:41 +0100EllenorAmyMalik
2023-02-28 15:47:03 +0100theproffesor(~theproffe@user/theproffesor) (Read error: Connection reset by peer)
2023-02-28 15:48:34 +0100Square(~Square4@user/square)
2023-02-28 15:50:00 +0100qhong_(~qhong@DN160vrd000d6kpg009l6c0000ep.stanford.edu)
2023-02-28 15:51:12 +0100Angelz(Angelz@2605:6400:30:fc15:9bd1:2217:41cd:bb15) (Ping timeout: 248 seconds)
2023-02-28 15:52:23 +0100bigtestaccount[m(~bigtestac@2001:470:69fc:105::2:fae3) (Ping timeout: 264 seconds)
2023-02-28 15:52:24 +0100mimi1vx[m](~osukupmat@2001:470:69fc:105::2:418d) (Ping timeout: 264 seconds)
2023-02-28 15:52:27 +0100tjnhxmzhmqgytuwt(~tjnhxmzhm@2001:470:69fc:105::3:70e) (Ping timeout: 248 seconds)
2023-02-28 15:52:27 +0100fgaz(~fgaz@2001:470:69fc:105::842) (Ping timeout: 248 seconds)
2023-02-28 15:52:27 +0100bgamari[m](~bgamari@2001:470:69fc:105::c7b9) (Ping timeout: 248 seconds)
2023-02-28 15:52:28 +0100chreekat(~chreekat@2001:470:69fc:105::16b5) (Ping timeout: 248 seconds)
2023-02-28 15:52:29 +0100jade[m](~jadecatgi@2001:470:69fc:105::3:194e) (Ping timeout: 256 seconds)
2023-02-28 15:52:29 +0100JensPetersen[m](~juhp@2001:470:69fc:105::6e9) (Ping timeout: 256 seconds)
2023-02-28 15:52:29 +0100jmcantrell(~jmcantrel@user/jmcantrell) (Ping timeout: 256 seconds)
2023-02-28 15:52:29 +0100Orbstheorem(~orbstheor@2001:470:69fc:105::a56) (Ping timeout: 256 seconds)
2023-02-28 15:52:29 +0100VOID[m](~void404ma@2001:470:69fc:105::2:c72c) (Ping timeout: 256 seconds)
2023-02-28 15:52:31 +0100M0rphee[m](~M0rpheema@2001:470:69fc:105::2:b1ce) (Ping timeout: 260 seconds)
2023-02-28 15:52:32 +0100MangoIV[m](~mangoivma@2001:470:69fc:105::2:8417) (Ping timeout: 260 seconds)
2023-02-28 15:52:32 +0100nomagno(~nomagno@2001:470:69fc:105::c1f0) (Ping timeout: 260 seconds)
2023-02-28 15:52:32 +0100maralorn(~maralorn@2001:470:69fc:105::251) (Ping timeout: 260 seconds)
2023-02-28 15:52:36 +0100JonathanWatson[m(~jjwmatrix@2001:470:69fc:105::2:a544) (Ping timeout: 265 seconds)
2023-02-28 15:52:37 +0100psydroid(~psydroid@user/psydroid) (Ping timeout: 265 seconds)
2023-02-28 15:52:37 +0100disco-dave[m](~disco-dav@2001:470:69fc:105::2:1892) (Ping timeout: 265 seconds)
2023-02-28 15:52:38 +0100Natch(~natch@c-9e07225c.038-60-73746f7.bbcust.telenor.se) (Read error: Connection reset by peer)
2023-02-28 15:52:42 +0100tiziodcaio(~tiziodcai@2001:470:69fc:105::1:2bf8) (Ping timeout: 246 seconds)
2023-02-28 15:52:48 +0100Franciman(~Franciman@mx1.fracta.dev) (Ping timeout: 248 seconds)
2023-02-28 15:52:52 +0100charukiewicz[m](~charukiew@2001:470:69fc:105::ded4) (Ping timeout: 252 seconds)
2023-02-28 15:52:52 +0100elvishjerricco(~elvishjer@2001:470:69fc:105::6172) (Ping timeout: 252 seconds)
2023-02-28 15:52:52 +0100peddie(~peddie@2001:470:69fc:105::25d) (Ping timeout: 252 seconds)
2023-02-28 15:52:52 +0100cstml[m](~cstmmatri@2001:470:69fc:105::2:f76f) (Ping timeout: 252 seconds)
2023-02-28 15:52:52 +0100mon_aaraj(~montchncs@2001:470:69fc:105::8e6b) (Ping timeout: 252 seconds)
2023-02-28 15:52:52 +0100hussam(~hussam@user/hussam) (Ping timeout: 252 seconds)
2023-02-28 15:52:59 +0100Jade[m]1(~jade1024t@2001:470:69fc:105::3:238b) (Ping timeout: 248 seconds)
2023-02-28 15:53:00 +0100aaRabbit[m](~rootsandw@2001:470:69fc:105::2:ca2e) (Ping timeout: 260 seconds)
2023-02-28 15:53:00 +0100kadenwolff[m](~kadenwolf@2001:470:69fc:105::1:d97f) (Ping timeout: 260 seconds)
2023-02-28 15:53:00 +0100maerwald[m](~maerwaldm@2001:470:69fc:105::1ee) (Ping timeout: 248 seconds)
2023-02-28 15:53:00 +0100eldritchcookie[m(~eldritchc@2001:470:69fc:105::2:d53c) (Ping timeout: 248 seconds)
2023-02-28 15:53:00 +0100ormaaj(~ormaaj@user/ormaaj) (Ping timeout: 264 seconds)
2023-02-28 15:53:00 +0100VarikValefor[m](~varikvale@2001:470:69fc:105::a5d) (Ping timeout: 248 seconds)
2023-02-28 15:53:00 +0100alexfmpe[m](~alexfmpem@2001:470:69fc:105::38ba) (Ping timeout: 248 seconds)
2023-02-28 15:53:00 +0100Guillaum[m](~guiboumat@2001:470:69fc:105::1:72ac) (Ping timeout: 264 seconds)
2023-02-28 15:53:00 +0100ericson2314(~ericson23@2001:470:69fc:105::70c) (Ping timeout: 264 seconds)
2023-02-28 15:53:00 +0100jneira[m](~jneiramat@2001:470:69fc:105::d729) (Ping timeout: 264 seconds)
2023-02-28 15:53:00 +0100Christoph[m](~hpotsirhc@2001:470:69fc:105::2ff8) (Ping timeout: 264 seconds)
2023-02-28 15:53:00 +0100smichel17[m](~smichel17@2001:470:69fc:105::2d32) (Ping timeout: 264 seconds)
2023-02-28 15:53:00 +0100akadude[m](~akadudema@2001:470:69fc:105::2:5bf7) (Ping timeout: 264 seconds)
2023-02-28 15:53:00 +0100geekosaur[m](~geekosaur@xmonad/geekosaur) (Ping timeout: 248 seconds)
2023-02-28 15:53:02 +0100Deide(~deide@user/deide) (Ping timeout: 246 seconds)
2023-02-28 15:53:02 +0100famubu[m](~famubumat@2001:470:69fc:105::1081) (Ping timeout: 246 seconds)
2023-02-28 15:53:02 +0100ManofLetters[m](~manoflett@2001:470:69fc:105::3be) (Ping timeout: 246 seconds)
2023-02-28 15:53:03 +0100cdsmith(~cdsmithma@2001:470:69fc:105::284) (Ping timeout: 256 seconds)
2023-02-28 15:53:03 +0100paulapatience(~paulapati@2001:470:69fc:105::16a4) (Ping timeout: 256 seconds)
2023-02-28 15:53:03 +0100steve[m](~stevetrou@2001:470:69fc:105::e0b) (Ping timeout: 256 seconds)
2023-02-28 15:53:05 +0100megaTherion(~therion@unix.io) (Ping timeout: 265 seconds)
2023-02-28 15:53:05 +0100instagib[m](~instagibm@2001:470:69fc:105::8156) (Ping timeout: 265 seconds)
2023-02-28 15:53:05 +0100agevelt[m](~ageveltmo@2001:470:69fc:105::3:16db) (Ping timeout: 265 seconds)
2023-02-28 15:53:05 +0100foghorn(~foghorn@user/foghorn) (Ping timeout: 265 seconds)
2023-02-28 15:53:06 +0100SeanKing[m](~seankingm@2001:470:69fc:105::cf9c) (Ping timeout: 265 seconds)
2023-02-28 15:53:14 +0100christiansen[m](~christian@2001:470:69fc:105::2:f23d) (Ping timeout: 252 seconds)
2023-02-28 15:53:15 +0100qhong(~qhong@2607:f6d0:d:3533:1:3533:0:1d9) (Ping timeout: 252 seconds)
2023-02-28 15:53:16 +0100megaTherion(~therion@unix.io)
2023-02-28 15:53:27 +0100hellwolf[m](~hellwolfm@2001:470:69fc:105::3:6a4) (Ping timeout: 260 seconds)
2023-02-28 15:53:35 +0100KabeloMsobomvuMo(~elevenkb@2001:470:69fc:105::2:cb89) (Ping timeout: 264 seconds)
2023-02-28 15:53:35 +0100sm(~sm@plaintextaccounting/sm) (Ping timeout: 264 seconds)
2023-02-28 15:53:37 +0100yl53[m](~yl53matri@2001:470:69fc:105::85b) (Ping timeout: 256 seconds)
2023-02-28 15:53:37 +0100Clinton[m](~clintonme@2001:470:69fc:105::2:31d4) (Ping timeout: 256 seconds)
2023-02-28 15:53:41 +0100Franciman(~Franciman@mx1.fracta.dev)
2023-02-28 15:53:50 +0100MironZ(~MironZ@nat-infra.ehlab.uk) (Quit: Ping timeout (120 seconds))
2023-02-28 15:54:40 +0100MironZ(~MironZ@nat-infra.ehlab.uk)
2023-02-28 15:57:04 +0100 <cheater> can someone explain to me what all this type instance / data instance stuff is all about? i used to know, but it flew out
2023-02-28 15:57:30 +0100acidjnk_new(~acidjnk@p200300d6e715c492c929333b144a2034.dip0.t-ipconnect.de) (Remote host closed the connection)
2023-02-28 15:57:54 +0100acidjnk_new(~acidjnk@p200300d6e715c4929ccd0d51d52c8268.dip0.t-ipconnect.de)
2023-02-28 15:58:02 +0100Natch(~natch@c-9e07225c.038-60-73746f7.bbcust.telenor.se)
2023-02-28 15:58:45 +0100machinedgod(~machinedg@2001:56a:7d0a:4a00:b9be:a4dc:5fc0:1fa5) (Ping timeout: 252 seconds)
2023-02-28 15:58:57 +0100 <merijn> cheater: Type and data families
2023-02-28 15:59:11 +0100 <cheater> you'll have to start me from zero
2023-02-28 15:59:12 +0100 <merijn> Should be a chapter in the GHC user guide
2023-02-28 15:59:30 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-02-28 15:59:31 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-02-28 15:59:31 +0100wroathe(~wroathe@user/wroathe)
2023-02-28 16:00:39 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-02-28 16:01:54 +0100maralorn(~maralorn@2001:470:69fc:105::251)
2023-02-28 16:03:44 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:f1bd:eef9:4eee:a4c2)
2023-02-28 16:03:52 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-02-28 16:04:08 +0100chreekat(~chreekat@2001:470:69fc:105::16b5)
2023-02-28 16:04:18 +0100Angelz(Angelz@Angelz.oddprotocol.org)
2023-02-28 16:07:21 +0100 <cheater> yeah but it's like really dry and opaque. i don't understand it
2023-02-28 16:08:02 +0100MironZ(~MironZ@nat-infra.ehlab.uk) (Quit: Ping timeout (120 seconds))
2023-02-28 16:08:03 +0100M0rphee[m](~M0rpheema@2001:470:69fc:105::2:b1ce)
2023-02-28 16:08:05 +0100Orbstheorem(~orbstheor@2001:470:69fc:105::a56)
2023-02-28 16:08:21 +0100MironZ(~MironZ@nat-infra.ehlab.uk)
2023-02-28 16:08:23 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:f1bd:eef9:4eee:a4c2) (Ping timeout: 260 seconds)
2023-02-28 16:08:32 +0100jade[m](~jadecatgi@2001:470:69fc:105::3:194e)
2023-02-28 16:10:13 +0100geekosaur[m](~geekosaur@xmonad/geekosaur)
2023-02-28 16:11:36 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.)
2023-02-28 16:12:13 +0100cdsmith(~cdsmithma@2001:470:69fc:105::284)
2023-02-28 16:12:17 +0100jneira[m](~jneiramat@2001:470:69fc:105::d729)
2023-02-28 16:12:18 +0100alexfmpe[m](~alexfmpem@2001:470:69fc:105::38ba)
2023-02-28 16:12:18 +0100Guillaum[m](~guiboumat@2001:470:69fc:105::1:72ac)
2023-02-28 16:12:48 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-02-28 16:12:53 +0100 <c_wraith> first off: start with type families. You'll get a long way if you just think of them as functions from types to types. That's not a 100% accurate description, but it gets you a long way
2023-02-28 16:13:25 +0100psydroid(~psydroid@user/psydroid)
2023-02-28 16:16:41 +0100 <c_wraith> data families are a specialization of type families to the specific case where each data instance results in a new, unique type
2023-02-28 16:17:07 +0100foghorn(~foghorn@user/foghorn)
2023-02-28 16:17:24 +0100 <c_wraith> Without polluting the namespace with types you intend to use only via the family
2023-02-28 16:21:02 +0100JonathanWatson[m(~jjwmatrix@2001:470:69fc:105::2:a544)
2023-02-28 16:21:24 +0100hussam(~hussam@user/hussam)
2023-02-28 16:21:25 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:a4e4:67ed:f903:e93d)
2023-02-28 16:21:49 +0100gurkenglas(~gurkengla@dynamic-046-114-179-219.46.114.pool.telefonica.de)
2023-02-28 16:21:54 +0100elvishjerricco(~elvishjer@2001:470:69fc:105::6172)
2023-02-28 16:22:25 +0100akadude[m](~akadudema@2001:470:69fc:105::2:5bf7)
2023-02-28 16:22:28 +0100Jade[m]1(~jade1024t@2001:470:69fc:105::3:238b)
2023-02-28 16:22:49 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-02-28 16:23:07 +0100disco-dave[m](~disco-dav@2001:470:69fc:105::2:1892)
2023-02-28 16:27:26 +0100 <kuribas> and data families are injective, which means they have less unpleasant surprises.
2023-02-28 16:27:47 +0100sidy(~sidy@user/sidy) (Quit: Leaving)
2023-02-28 16:28:12 +0100polyphem_(~rod@2a02:810d:840:8754:7a70:3c2e:4ee0:14f)
2023-02-28 16:29:15 +0100 <kuribas> and type families look like type functions. Except that type level haskell is basically prolog, so they are more like horn clauses.
2023-02-28 16:29:28 +0100 <maerwald> heh
2023-02-28 16:30:03 +0100 <c_wraith> while I'm sure that data family injectivity was intentional, it's also sort of inevitable.
2023-02-28 16:30:35 +0100 <c_wraith> Since every data instance is a new type, there's no way for them to not be injective
2023-02-28 16:32:11 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 260 seconds)
2023-02-28 16:32:25 +0100 <c_wraith> oh! and of course, just to complicate things, there are also associated type families and data families. They aren't different things, but they're slightly different syntax and have slightly different definition requirements.
2023-02-28 16:34:14 +0100 <gurkenglas> Can Haskell define the subtype of X a for which "all functions (forall b. X b -> Y b) agree"?
2023-02-28 16:36:03 +0100mimi1vx[m](~osukupmat@2001:470:69fc:105::2:418d)
2023-02-28 16:37:08 +0100 <c_wraith> the only subtyping relationship in Haskell is "type A is more general than type B
2023-02-28 16:37:42 +0100 <c_wraith> But maybe you meant something more colloquial by "subtyping"?
2023-02-28 16:37:55 +0100 <gurkenglas> Nope! I am wondering whether my thing fits into that.
2023-02-28 16:39:38 +0100 <gurkenglas> A traversal is a more general lens; an X a is a more general "X a on which all (X -> Y) agree".
2023-02-28 16:40:09 +0100JensPetersen[m](~juhp@2001:470:69fc:105::6e9)
2023-02-28 16:40:11 +0100fgaz(~fgaz@2001:470:69fc:105::842)
2023-02-28 16:40:20 +0100SeanKing[m](~seankingm@2001:470:69fc:105::cf9c)
2023-02-28 16:40:34 +0100 <gurkenglas> It's fine if X a needs to be rewritten into another form for that to be possible.
2023-02-28 16:41:00 +0100npm_i_kurbus(~npm_i_kur@user/kurbus)
2023-02-28 16:41:44 +0100 <kuribas> gurkenglas: "traversals" and "lenses" are type synonyms, they are not really first class things in haskell.
2023-02-28 16:42:07 +0100 <gurkenglas> kuribas: sure! it's fine if X needs to be rewritten into a type synonym.
2023-02-28 16:43:00 +0100tjnhxmzhmqgytuwt(~tjnhxmzhm@2001:470:69fc:105::3:70e)
2023-02-28 16:43:10 +0100nomagno(~nomagno@2001:470:69fc:105::c1f0)
2023-02-28 16:43:14 +0100ormaaj(~ormaaj@user/ormaaj)
2023-02-28 16:43:25 +0100 <c_wraith> gurkenglas: it feels like you're looking for ideas related to parametricity, as at the type level the only things you have to go on are free theorems. But I don't see how to express that in Haskell types
2023-02-28 16:43:33 +0100yl53[m](~yl53matri@2001:470:69fc:105::85b)
2023-02-28 16:44:10 +0100 <gurkenglas> c_wraith: yes i also think that i am looking for an arcane application of free theorems. what should i read about those
2023-02-28 16:44:32 +0100instagib[m](~instagibm@2001:470:69fc:105::8156)
2023-02-28 16:44:32 +0100agevelt[m](~ageveltmo@2001:470:69fc:105::3:16db)
2023-02-28 16:44:37 +0100cstml[m](~cstmmatri@2001:470:69fc:105::2:f76f)
2023-02-28 16:45:12 +0100bigtestaccount[m(~bigtestac@2001:470:69fc:105::2:fae3)
2023-02-28 16:45:26 +0100VOID[m](~void404ma@2001:470:69fc:105::2:c72c)
2023-02-28 16:46:14 +0100jmcantrell(~jmcantrel@user/jmcantrell)
2023-02-28 16:46:49 +0100 <c_wraith> I've never actually read any of the stuff about free theorems. It looks like Wadler's 1989 paper was a big deal. I also see https://bartoszmilewski.com/2014/09/22/parametricity-money-for-nothing-and-theorems-for-free/ exists, and that series of blog posts was highly regarded
2023-02-28 16:46:51 +0100ericson2314(~ericson23@2001:470:69fc:105::70c)
2023-02-28 16:47:01 +0100npm_i_kurbus(~npm_i_kur@user/kurbus) (Quit: Client closed)
2023-02-28 16:49:25 +0100hellwolf[m](~hellwolfm@2001:470:69fc:105::3:6a4)
2023-02-28 16:49:36 +0100KabeloMsobomvuMo(~elevenkb@2001:470:69fc:105::2:cb89)
2023-02-28 16:50:10 +0100bgamari[m](~bgamari@2001:470:69fc:105::c7b9)
2023-02-28 16:50:44 +0100sm(~sm@plaintextaccounting/sm)
2023-02-28 16:52:16 +0100charukiewicz[m](~charukiew@2001:470:69fc:105::ded4)
2023-02-28 16:52:31 +0100MangoIV[m](~mangoivma@2001:470:69fc:105::2:8417)
2023-02-28 16:52:31 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-02-28 16:53:27 +0100dsrt^(~dsrt@c-24-30-76-89.hsd1.ga.comcast.net) (Remote host closed the connection)
2023-02-28 16:53:37 +0100peddie(~peddie@2001:470:69fc:105::25d)
2023-02-28 16:53:54 +0100aaRabbit[m](~rootsandw@2001:470:69fc:105::2:ca2e)
2023-02-28 16:54:24 +0100kadenwolff[m](~kadenwolf@2001:470:69fc:105::1:d97f)
2023-02-28 16:54:55 +0100bitmapper(uid464869@2a03:5180:f:2::7:17e5) (Quit: Connection closed for inactivity)
2023-02-28 16:55:29 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-02-28 16:55:31 +0100paulapatience(~paulapati@2001:470:69fc:105::16a4)
2023-02-28 16:55:52 +0100 <gurkenglas> hmmmmm might there be some way to say "if you can take 2 values from a type and tell any difference between them, Void"
2023-02-28 16:56:28 +0100Sgeo(~Sgeo@user/sgeo)
2023-02-28 16:59:10 +0100christiansen[m](~christian@2001:470:69fc:105::2:f23d)
2023-02-28 17:00:07 +0100smichel17[m](~smichel17@2001:470:69fc:105::2d32)
2023-02-28 17:00:48 +0100ManofLetters[m](~manoflett@2001:470:69fc:105::3be)
2023-02-28 17:00:52 +0100mon_aaraj(~montchncs@2001:470:69fc:105::8e6b)
2023-02-28 17:01:41 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-02-28 17:01:44 +0100famubu[m](~famubumat@2001:470:69fc:105::1081)
2023-02-28 17:01:49 +0100Deide(~deide@user/deide)
2023-02-28 17:01:58 +0100maerwald[m](~maerwaldm@2001:470:69fc:105::1ee)
2023-02-28 17:02:06 +0100VarikValefor[m](~varikvale@2001:470:69fc:105::a5d)
2023-02-28 17:02:17 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-02-28 17:02:19 +0100eldritchcookie[m(~eldritchc@2001:470:69fc:105::2:d53c)
2023-02-28 17:02:46 +0100Clinton[m](~clintonme@2001:470:69fc:105::2:31d4)
2023-02-28 17:03:47 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 264 seconds)
2023-02-28 17:04:24 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67)
2023-02-28 17:04:52 +0100mechap_(~mechap@user/mechap) (Quit: WeeChat 3.8)
2023-02-28 17:05:05 +0100 <gurkenglas> (a -> b -> a) and (b -> a -> a) are subtypes of (a -> a -> a) with ~1 inhabitant each...
2023-02-28 17:05:15 +0100waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se)
2023-02-28 17:06:08 +0100xelxebar(~xelxebar@KD111239153139.au-net.ne.jp)
2023-02-28 17:07:13 +0100 <gurkenglas> but saying that the two A->A->A you can get that way are equal sounds like i've reduced the problem to itself
2023-02-28 17:08:20 +0100a_coll(~acoll@45.92.120.189) (Remote host closed the connection)
2023-02-28 17:09:56 +0100 <kuribas> Isn't it the other way?
2023-02-28 17:10:27 +0100 <kuribas> (a -> a -> a) is a subtype of (a -> b -> a)
2023-02-28 17:11:50 +0100 <gurkenglas> kuribas: nope! then both would be subtypes of (a -> b -> c), which is empty
2023-02-28 17:14:43 +0100steve[m](~stevetrou@2001:470:69fc:105::e0b)
2023-02-28 17:14:58 +0100Christoph[m](~hpotsirhc@2001:470:69fc:105::2ff8)
2023-02-28 17:15:06 +0100 <kuribas> hmm, right
2023-02-28 17:15:32 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Read error: Connection reset by peer)
2023-02-28 17:19:55 +0100waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se) (Ping timeout: 248 seconds)
2023-02-28 17:21:01 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-28 17:21:18 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:a4e4:67ed:f903:e93d) (Quit: WeeChat 2.8)
2023-02-28 17:21:43 +0100Philonous_(~Philonous@user/philonous) (Quit: ZNC - https://znc.in)
2023-02-28 17:22:03 +0100Philonous(~Philonous@user/philonous)
2023-02-28 17:22:44 +0100GoldsteinQ(~goldstein@goldstein.rs) (Quit: ZNC 1.8.2 - https://znc.in)
2023-02-28 17:23:33 +0100GoldsteinQ(~goldstein@goldstein.rs)
2023-02-28 17:23:59 +0100xerox(~edi@user/edi) (Ping timeout: 248 seconds)
2023-02-28 17:24:52 +0100xerox(~edi@user/edi)
2023-02-28 17:27:05 +0100stevan(~stevan@user/stevan) (Quit: leaving)
2023-02-28 17:27:33 +0100npm_i_kurbus(~npm_i_kur@user/kurbus)
2023-02-28 17:28:25 +0100finnekit1(~finnekit@fsf/member/finnekit)
2023-02-28 17:28:54 +0100rhart(~rhart@user/rhart) (Remote host closed the connection)
2023-02-28 17:29:27 +0100manwithluck(~manwithlu@194.177.28.192) (Excess Flood)
2023-02-28 17:30:03 +0100finnekit(~finnekit@fsf/member/finnekit) (Ping timeout: 255 seconds)
2023-02-28 17:30:03 +0100finnekit1finnekit
2023-02-28 17:30:15 +0100manwithluck(~manwithlu@194.177.28.192)
2023-02-28 17:30:25 +0100mechap(~mechap@user/mechap)
2023-02-28 17:30:48 +0100Ghostpatsch(~Profpatsc@static.88-198-193-255.clients.your-server.de)
2023-02-28 17:30:50 +0100 <gurkenglas> i think the thing i'm looking for could be cheated through the use of error and teaspoon, much like this makes Void "nonempty"
2023-02-28 17:31:17 +0100 <gurkenglas> What are some existing things known to be cheatable using error/teaspoon?
2023-02-28 17:32:11 +0100bliminse_(~bliminse@user/bliminse)
2023-02-28 17:33:33 +0100oats_(~thomas@user/oats)
2023-02-28 17:34:06 +0100oats(~thomas@user/oats) (Killed (NickServ (GHOST command used by oats_)))
2023-02-28 17:34:09 +0100oats_oats
2023-02-28 17:34:52 +0100 <gurkenglas> "-> Void" takes inhabited types to uninhabited ones and vice versa, now i'm looking for something which can distinguish uniquely inhabited from non-uniquely.
2023-02-28 17:36:25 +0100Franciman(~Franciman@mx1.fracta.dev) (*.net *.split)
2023-02-28 17:36:25 +0100Square(~Square4@user/square) (*.net *.split)
2023-02-28 17:36:25 +0100trev(~trev@user/trev) (*.net *.split)
2023-02-28 17:36:25 +0100notzmv(~zmv@user/notzmv) (*.net *.split)
2023-02-28 17:36:25 +0100SenFache(~sauvin@user/Sauvin) (*.net *.split)
2023-02-28 17:36:25 +0100asm(~alexander@user/asm) (*.net *.split)
2023-02-28 17:36:25 +0100phaazon(~phaazon@2001:41d0:a:fe76::1) (*.net *.split)
2023-02-28 17:36:25 +0100jle`(~jle`@cpe-23-240-75-236.socal.res.rr.com) (*.net *.split)
2023-02-28 17:36:25 +0100bgamari(~bgamari@2a06:a000:b00d::2) (*.net *.split)
2023-02-28 17:36:26 +0100fr33domlover(~fr33domlo@towards.vision) (*.net *.split)
2023-02-28 17:36:26 +0100bliminse(~bliminse@user/bliminse) (*.net *.split)
2023-02-28 17:36:26 +0100acarrico(~acarrico@dhcp-68-142-49-163.greenmountainaccess.net) (*.net *.split)
2023-02-28 17:36:26 +0100mixphix(~cigsender@74.124.58.162) (*.net *.split)
2023-02-28 17:36:26 +0100brettgilio(~brettgili@x-irc.gq) (*.net *.split)
2023-02-28 17:36:26 +0100Yumemi(~Yumemi@chamoin.net) (*.net *.split)
2023-02-28 17:36:26 +0100kaskal(~kaskal@089144220250.atnat0029.highway.webapn.at) (*.net *.split)
2023-02-28 17:36:26 +0100quintasan(~quassel@quintasan.pl) (*.net *.split)
2023-02-28 17:36:26 +0100sm[i]_(~user@li229-222.members.linode.com) (*.net *.split)
2023-02-28 17:36:26 +0100ghostbuster(~admin@user/ghostbuster) (*.net *.split)
2023-02-28 17:36:26 +0100aku(~aku@163.172.137.34) (*.net *.split)
2023-02-28 17:36:26 +0100Ekho(~Ekho@user/ekho) (*.net *.split)
2023-02-28 17:36:26 +0100gabiruh_(~gabiruh@vps19177.publiccloud.com.br) (*.net *.split)
2023-02-28 17:36:26 +0100Unode(~Unode@fg-ext-220.embl.de) (*.net *.split)
2023-02-28 17:36:26 +0100kronicma1(user13639@neotame.csclub.uwaterloo.ca) (*.net *.split)
2023-02-28 17:36:26 +0100nullsh(nullsh@user/nexeq) (*.net *.split)
2023-02-28 17:36:27 +0100wrengr(~wrengr@201.59.83.34.bc.googleusercontent.com) (*.net *.split)
2023-02-28 17:36:27 +0100EsoAlgo8(~EsoAlgo@129.146.136.145) (*.net *.split)
2023-02-28 17:36:27 +0100kitzman(~kitzman@user/dekenevs) (*.net *.split)
2023-02-28 17:36:27 +0100Profpatsch(~Profpatsc@static.88-198-193-255.clients.your-server.de) (*.net *.split)
2023-02-28 17:36:27 +0100hiredman(~hiredman@frontier1.downey.family) (*.net *.split)
2023-02-28 17:36:27 +0100AkechiShiro(~licht@user/akechishiro) (*.net *.split)
2023-02-28 17:36:27 +0100krjst(~krjst@2604:a880:800:c1::16b:8001) (*.net *.split)
2023-02-28 17:36:27 +0100sajith(~sajith@user/sajith) (*.net *.split)
2023-02-28 17:36:27 +0100drewolson(~drewolson@user/drewolson) (*.net *.split)
2023-02-28 17:37:35 +0100Franciman(~Franciman@mx1.fracta.dev)
2023-02-28 17:37:35 +0100Square(~Square4@user/square)
2023-02-28 17:37:35 +0100trev(~trev@user/trev)
2023-02-28 17:37:35 +0100notzmv(~zmv@user/notzmv)
2023-02-28 17:37:35 +0100SenFache(~sauvin@user/Sauvin)
2023-02-28 17:37:35 +0100asm(~alexander@user/asm)
2023-02-28 17:37:35 +0100phaazon(~phaazon@2001:41d0:a:fe76::1)
2023-02-28 17:37:35 +0100jle`(~jle`@cpe-23-240-75-236.socal.res.rr.com)
2023-02-28 17:37:35 +0100bgamari(~bgamari@2a06:a000:b00d::2)
2023-02-28 17:37:35 +0100fr33domlover(~fr33domlo@towards.vision)
2023-02-28 17:37:35 +0100acarrico(~acarrico@dhcp-68-142-49-163.greenmountainaccess.net)
2023-02-28 17:37:35 +0100mixphix(~cigsender@74.124.58.162)
2023-02-28 17:37:35 +0100brettgilio(~brettgili@x-irc.gq)
2023-02-28 17:37:35 +0100Yumemi(~Yumemi@chamoin.net)
2023-02-28 17:37:35 +0100kaskal(~kaskal@089144220250.atnat0029.highway.webapn.at)
2023-02-28 17:37:35 +0100quintasan(~quassel@quintasan.pl)
2023-02-28 17:37:35 +0100sm[i]_(~user@li229-222.members.linode.com)
2023-02-28 17:37:35 +0100ghostbuster(~admin@user/ghostbuster)
2023-02-28 17:37:35 +0100aku(~aku@163.172.137.34)
2023-02-28 17:37:35 +0100Ekho(~Ekho@user/ekho)
2023-02-28 17:37:35 +0100gabiruh_(~gabiruh@vps19177.publiccloud.com.br)
2023-02-28 17:37:35 +0100Unode(~Unode@fg-ext-220.embl.de)
2023-02-28 17:37:35 +0100kronicma1(user13639@neotame.csclub.uwaterloo.ca)
2023-02-28 17:37:35 +0100nullsh(nullsh@user/nexeq)
2023-02-28 17:37:35 +0100wrengr(~wrengr@201.59.83.34.bc.googleusercontent.com)
2023-02-28 17:37:35 +0100EsoAlgo8(~EsoAlgo@129.146.136.145)
2023-02-28 17:37:35 +0100kitzman(~kitzman@user/dekenevs)
2023-02-28 17:37:35 +0100hiredman(~hiredman@frontier1.downey.family)
2023-02-28 17:37:35 +0100AkechiShiro(~licht@user/akechishiro)
2023-02-28 17:37:35 +0100krjst(~krjst@2604:a880:800:c1::16b:8001)
2023-02-28 17:37:35 +0100sajith(~sajith@user/sajith)
2023-02-28 17:37:35 +0100drewolson(~drewolson@user/drewolson)
2023-02-28 17:37:56 +0100xelxebar(~xelxebar@KD111239153139.au-net.ne.jp) (Quit: WeeChat 3.8)
2023-02-28 17:37:59 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 264 seconds)
2023-02-28 17:38:52 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Read error: Connection reset by peer)
2023-02-28 17:39:58 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-02-28 17:40:33 +0100Square(~Square4@user/square) (Remote host closed the connection)
2023-02-28 17:40:33 +0100SenFache(~sauvin@user/Sauvin) (Remote host closed the connection)
2023-02-28 17:40:36 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67) (Quit: Leaving)
2023-02-28 17:40:47 +0100SenFache(~sauvin@user/Sauvin)
2023-02-28 17:41:03 +0100Square(~Square4@user/square)
2023-02-28 17:41:29 +0100shriekingnoise_(~shrieking@186.137.175.87)
2023-02-28 17:41:47 +0100shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 248 seconds)
2023-02-28 17:42:15 +0100 <gurkenglas> "A has exactly one element if, for any A->b, we already know what it's going to output"...
2023-02-28 17:44:47 +0100 <gurkenglas> or less circuitously, if given any A we didn't need to be given it
2023-02-28 17:45:18 +0100 <Jade[m]1> The concept of ()?
2023-02-28 17:45:32 +0100 <gurkenglas> What do you mean?
2023-02-28 17:45:52 +0100 <Jade[m]1> () is the type with exactly one inhabitant
2023-02-28 17:46:03 +0100 <Jade[m]1> which is () (unit)
2023-02-28 17:46:15 +0100malte(~malte@mal.tc) (Ping timeout: 255 seconds)
2023-02-28 17:46:38 +0100 <gurkenglas> sure. how do i tell whether a type (such as (forall x. x -> x)) is essentially that.
2023-02-28 17:47:12 +0100 <Jade[m]1> I'm having trouble understanding what you are asking for
2023-02-28 17:47:39 +0100 <Jade[m]1> `() -> x`?
2023-02-28 17:47:39 +0100 <Jade[m]1> * `() -> x` ?
2023-02-28 17:47:55 +0100 <Jade[m]1> * `forall x. () -> x` ?
2023-02-28 17:49:02 +0100 <gurkenglas> Jade[m]1: is there some type constructor AtLeastTwo of kind * -> * which maps a type with at least two values to a type with at least one value, and a type with one value to the empty type?
2023-02-28 17:49:46 +0100 <gurkenglas> (or vice versa: UniquelyInhabited of kind * -> *)
2023-02-28 17:49:47 +0100teo(~teo@user/teo) (Ping timeout: 256 seconds)
2023-02-28 17:49:48 +0100 <Jade[m]1> AFAIK there is no way to statically encode the inhabitancy (?) of types
2023-02-28 17:50:12 +0100 <Jade[m]1> can you show what you need with an actual use-case?
2023-02-28 17:50:23 +0100 <Jade[m]1> because you might just want normal polymorphic types
2023-02-28 17:50:46 +0100 <gurkenglas> Jade[m]1: "type ThisTypeHasNoValues a = forall b. a -> b" <- does that count as a way to encode inhabitancy?
2023-02-28 17:51:14 +0100 <Jade[m]1> no
2023-02-28 17:51:32 +0100 <Jade[m]1> it just aliases a general function from a -> b
2023-02-28 17:51:47 +0100 <Jade[m]1> ah no, let me rethink
2023-02-28 17:52:06 +0100 <geekosaur> if b is not otherwise constrained then it must be uninhabited
2023-02-28 17:52:14 +0100 <Jade[m]1> yes
2023-02-28 17:52:25 +0100 <geekosaur> but you can't generalize this to "has one element"
2023-02-28 17:52:31 +0100 <Jade[m]1> mhm
2023-02-28 17:52:33 +0100 <gurkenglas> geekosaur: is there proof of that?
2023-02-28 17:52:36 +0100 <geekosaur> no elements is a special case
2023-02-28 17:53:07 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-02-28 17:53:24 +0100 <geekosaur> by construction there is no value that inhabits all types, and the `forall` indicates that it's the caller of the function that picks `b`
2023-02-28 17:53:32 +0100 <geekosaur> (except bottom)
2023-02-28 17:54:05 +0100Guest78(~Guest78@41.36-131-109.adsl-dyn.isp.belgacom.be)
2023-02-28 17:54:24 +0100 <ncf> a proof of that would look like an interpretation of system F in a model with exactly two types
2023-02-28 17:54:26 +0100 <Jade[m]1> yeah, no type is truly uninhabited
2023-02-28 17:54:27 +0100 <ncf> i wonder if that exists
2023-02-28 17:55:20 +0100 <geekosaur> Jade[m]1, bottom doesn't really count here since it's a non-value
2023-02-28 17:55:31 +0100 <gurkenglas> geekosaur: that justifies being able to tell 0 from 1, but it doesn't justify being unable to tell 1 from 2
2023-02-28 17:55:32 +0100 <geekosaur> (nontermination, aka failure to produce a value)
2023-02-28 17:55:50 +0100 <Jade[m]1> mhm
2023-02-28 17:55:54 +0100 <geekosaur> gurkenglas, correct, that's why I called it a special case
2023-02-28 17:56:08 +0100 <gurkenglas> i said "unable" :D
2023-02-28 17:56:19 +0100 <gurkenglas> i'm not yet convinced that we can't do another trick to tell 1 from 2
2023-02-28 17:56:51 +0100 <geekosaur> I'm reasonably certain that requires true dependent types
2023-02-28 17:56:53 +0100 <Jade[m]1> The problem is that you cannot introspect on the type itself
2023-02-28 17:56:58 +0100cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.8)
2023-02-28 17:57:09 +0100 <Jade[m]1> geekosaur: mhm
2023-02-28 17:58:07 +0100 <gurkenglas> something like, "a type X is uniquely inhabited if, given some (forall a. a->a->a), you cannot tell whether it is "const" or "const id" by specializing it to X->X->X"
2023-02-28 18:00:37 +0100 <Jade[m]1> but how would you encode this in types?
2023-02-28 18:00:43 +0100 <gurkenglas> I'm thinking!
2023-02-28 18:00:50 +0100euandreh(~Thunderbi@189.6.18.7)
2023-02-28 18:01:00 +0100 <Jade[m]1> Something like this is what the compiler could do - but the compiler can also just look at the ADT defition
2023-02-28 18:01:50 +0100Guest78(~Guest78@41.36-131-109.adsl-dyn.isp.belgacom.be) (Quit: Connection closed)
2023-02-28 18:02:01 +0100 <gurkenglas> what im hoping to *use* this for is to enforce a typeclass law i found that fits this pattern surprisingly well
2023-02-28 18:02:31 +0100 <Jade[m]1> care to elaborate?
2023-02-28 18:02:46 +0100 <Jade[m]1> you've got me interested by this point lmao
2023-02-28 18:03:16 +0100 <gurkenglas> a category is a way to compose paths-of-arrows such that any way to compose em that you can construct from that one is that one
2023-02-28 18:04:56 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-28 18:06:57 +0100 <gurkenglas> (forall a. a -> a -> a) -> Either (forall a b. a -> b -> a) (forall a b. b -> a -> a) ...one can't actually construct this, can one
2023-02-28 18:07:37 +0100 <ncf> λ f. f (Left const) (Right (const id))
2023-02-28 18:07:41 +0100 <ncf> ?
2023-02-28 18:08:31 +0100 <gurkenglas> ahaha
2023-02-28 18:09:07 +0100 <gurkenglas> i mean i didn't actually rule out even "\_ -> Left const" but that one is fun
2023-02-28 18:09:58 +0100 <gurkenglas> what i meant was, one can't actually do "take the f, check whether it is Left const or Right (const id) by experiment, then having proven this return it specialized properly"
2023-02-28 18:10:29 +0100 <Jade[m]1> that can't really be encoded in the type
2023-02-28 18:10:34 +0100 <gurkenglas> i can probably scribble up a variant that rules out just saying "Left const" or "Right (const id)"
2023-02-28 18:11:49 +0100 <ncf> i'm pretty confident that system F is not expressive enough to let you prove the things you want to prove, but i don't have a reference; you should consider asking somewhere that isn't #haskell
2023-02-28 18:12:08 +0100 <ncf> (or Fω)
2023-02-28 18:13:12 +0100 <ncf> i'd ask on https://proofassistants.stackexchange.com/
2023-02-28 18:14:15 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-02-28 18:14:56 +0100 <ncf> (i'd love to be proven wrong, of course)
2023-02-28 18:16:14 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-02-28 18:16:38 +0100kenran(~user@user/kenran) (Remote host closed the connection)
2023-02-28 18:17:06 +0100 <gurkenglas> (forall x. x a -> x b -> x c) -> Either (forall x. x a -> x c) (forall x. x b -> x c) can one construct this?
2023-02-28 18:17:24 +0100dhil(~dhil@78.45.150.83.ewm.ftth.as8758.net)
2023-02-28 18:17:58 +0100 <gurkenglas> if one dares to use error "impossible", i think one can. can one also without that?
2023-02-28 18:20:04 +0100 <int-e> Nah, it would amount to a runtime check whether a = c or b = c. But there's no type information available.
2023-02-28 18:20:43 +0100 <gurkenglas> int-e: what about a runtime check whether the operator returns the first or second argument when called?
2023-02-28 18:27:28 +0100 <gurkenglas> :t gurk -- int-e, be amazed!
2023-02-28 18:27:29 +0100 <lambdabot> forall k (a :: k) (b :: k) (c :: k) r. (forall (x :: k -> *). x a -> x b -> x c) -> ((forall (x :: k -> *). x a -> x c) -> r) -> ((forall (x :: k -> *). x b -> x c) -> r) -> r
2023-02-28 18:27:47 +0100polyphem_(~rod@2a02:810d:840:8754:7a70:3c2e:4ee0:14f) (Ping timeout: 264 seconds)
2023-02-28 18:28:25 +0100polyphem_(~rod@2a02:810d:840:8754:224e:f6ff:fe5e:bc17)
2023-02-28 18:29:57 +0100 <gurkenglas> (that one does use undefined in a manner which should never be executed)
2023-02-28 18:36:13 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-02-28 18:37:05 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-02-28 18:37:23 +0100MajorBiscuit(~MajorBisc@c-001-024-033.client.tudelft.eduvpn.nl) (Quit: WeeChat 3.6)
2023-02-28 18:38:13 +0100chele(~chele@user/chele) (Remote host closed the connection)
2023-02-28 18:38:34 +0100econo(uid147250@user/econo)
2023-02-28 18:49:15 +0100euandreh(~Thunderbi@189.6.18.7) (Remote host closed the connection)
2023-02-28 18:49:54 +0100mauke(~mauke@user/mauke)
2023-02-28 18:51:31 +0100CiaoSen(~Jura@p200300c9570e91002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-02-28 18:55:09 +0100zeenk(~zeenk@2a02:2f04:a20d:f900::7fe) (Quit: Konversation terminated!)
2023-02-28 18:56:01 +0100euandreh(~Thunderbi@189.6.18.7)
2023-02-28 18:57:59 +0100 <sm> Haskell Tiny Game Jam update: my last post was wrong, there's still a few hours left to enter. Correct timer is here:
2023-02-28 18:57:59 +0100 <sm> https://www.timeanddate.com/countdown/generic?iso=20230228T235959&p0=1440&msg=Haskell+Tiny+Game+Ja…
2023-02-28 18:59:28 +0100 <shapr> We never pushed ours, sadly
2023-02-28 18:59:44 +0100 <int-e> gurkenglas: in the end it's really easy: https://paste.tomsmeding.com/6GRAZ33t
2023-02-28 19:00:31 +0100 <shapr> oh, six hours left?
2023-02-28 19:00:36 +0100 <shapr> hmmm
2023-02-28 19:01:28 +0100 <int-e> UTC?
2023-02-28 19:01:48 +0100 <int-e> Ah it says that right there.
2023-02-28 19:03:04 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-02-28 19:03:10 +0100 <segfaultfizzbuzz> what is "reify" or "reified"?
2023-02-28 19:04:11 +0100 <int-e> roughly the same as "materialize"
2023-02-28 19:04:17 +0100 <segfaultfizzbuzz> which is...?
2023-02-28 19:04:23 +0100 <int-e> https://www.merriam-webster.com/dictionary/reify
2023-02-28 19:04:36 +0100 <segfaultfizzbuzz> ok so it doesn't mean anything specific in programming...?
2023-02-28 19:05:09 +0100 <monochrom> Everyone uses it for their own purposes...
2023-02-28 19:05:28 +0100 <int-e> Well, there's reflection/reification that reflects types in values, and reifies values as types.
2023-02-28 19:05:45 +0100 <gurkenglas> int-e: nice :)
2023-02-28 19:05:52 +0100 <segfaultfizzbuzz> ayyyy ok so it's a terrible term
2023-02-28 19:06:04 +0100 <int-e> Pet peeve warning... which, of course, makes no sense at all, because the values should be the concrete material thing.
2023-02-28 19:06:19 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:f1bd:eef9:4eee:a4c2)
2023-02-28 19:06:37 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:f1bd:eef9:4eee:a4c2) (Remote host closed the connection)
2023-02-28 19:06:51 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:f1bd:eef9:4eee:a4c2)
2023-02-28 19:07:03 +0100opticblast(~Thunderbi@172.58.82.191)
2023-02-28 19:07:22 +0100 <gurkenglas> next step would be: can we encode in the types that the two possibilities must be distinguished by plugging in two different values of our given type? to use this for AtLeastTwoDistinguishableInhabitants :: * -> *
2023-02-28 19:07:23 +0100 <int-e> segfaultfizzbuzz: you haven't provided context though, so you may be encountering the word in a different meaning.
2023-02-28 19:09:30 +0100 <segfaultfizzbuzz> i was looking at https://arxiv.org/pdf/1804.00746.pdf for instance which mentions reification on the first page,... and someone else was talking about reification in the ad haskell package, saying that it was somehow bad
2023-02-28 19:10:45 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-28 19:15:59 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds)
2023-02-28 19:17:58 +0100 <gurkenglas> int-e: *looks again* wait, now i'm confused. why does *this* work?
2023-02-28 19:18:52 +0100 <gurkenglas> One can say both "Left id" and "Right id" without it therefore unifying all a,b,c??
2023-02-28 19:19:27 +0100 <int-e> gurkenglas: no, you take c = a for the first value, c = b for the second value and the result has c = c.
2023-02-28 19:19:43 +0100 <mauke> segfaultfizzbuzz: I think in that context it means "represented explicitly"
2023-02-28 19:19:59 +0100 <mauke> it's from the latin word "res" (thing)
2023-02-28 19:20:06 +0100 <segfaultfizzbuzz> evaluated/strict, basically?
2023-02-28 19:20:15 +0100 <mauke> no
2023-02-28 19:20:25 +0100 <gurkenglas> ah, that makes much more sense :)
2023-02-28 19:21:34 +0100akegalj(~akegalj@89-164-77-228.dsl.iskon.hr)
2023-02-28 19:23:09 +0100 <mauke> I'm not familiar with the domain, but perhaps even "represented symbolically"
2023-02-28 19:24:16 +0100 <mauke> > 1 + 2 * 3 :: Expr
2023-02-28 19:24:18 +0100 <lambdabot> 1 + 2 * 3
2023-02-28 19:24:49 +0100czy(~user@50.30.140.25)
2023-02-28 19:24:51 +0100 <mauke> that's not just a lazily evaluated number, that's a full expression tree
2023-02-28 19:24:59 +0100 <segfaultfizzbuzz> as opposed to like 1 + my_mult_function(2, 3) ?
2023-02-28 19:25:12 +0100 <mauke> > 1 + 2 * 3
2023-02-28 19:25:14 +0100 <lambdabot> 7
2023-02-28 19:25:16 +0100 <mauke> as opposed to 7
2023-02-28 19:25:30 +0100 <segfaultfizzbuzz> 7 is reified, 1 + 2*3 is not, then?
2023-02-28 19:26:00 +0100 <mauke> no, I would say Add (Const 1) (Mul (Const 2) (Const 2)) is a reified expression
2023-02-28 19:26:02 +0100 <int-e> one of the references is about "observable sharing" which is probably a more fruitful keyword
2023-02-28 19:26:26 +0100 <mauke> s/2\)\)/3))/
2023-02-28 19:27:25 +0100 <int-e> So rather than an expression tree, we'll actually have a DAG.
2023-02-28 19:28:31 +0100 <Inst> is there any research on the Haskell IO story?
2023-02-28 19:28:49 +0100 <Inst> tbh, you have "Avoid $ Success At All Costs", which is to say, Haskell is not interested in being too popular
2023-02-28 19:28:58 +0100 <Jade[m]1> what do you mean by that?
2023-02-28 19:29:01 +0100 <Inst> but the reason Haskell isn't popular is, for complicated algorithms
2023-02-28 19:29:10 +0100 <monochrom> I don't think we take that seriously.
2023-02-28 19:29:26 +0100 <Jade[m]1> Inst: I disagree
2023-02-28 19:29:33 +0100 <Jade[m]1> > <@Inst:libera.chat> but the reason Haskell isn't popular is, for complicated algorithms
2023-02-28 19:29:33 +0100 <Jade[m]1> * I disagree, strongly
2023-02-28 19:29:35 +0100 <lambdabot> <hint>:1:1: error: parse error on input ‘<@’
2023-02-28 19:29:56 +0100 <Inst> you pay lambda tax; often the algorithm is less performant than a similar imperative algorithm due to translation from lambda calculus (or STG) to something a Von Neumann machine can handle, and immutability
2023-02-28 19:30:04 +0100 <segfaultfizzbuzz> Inst: justin beiber programs in haskell but people don't know that yet
2023-02-28 19:30:10 +0100 <int-e> Even if you can't use Haskell directly for, say, performance reasons, it can still be a great meta language.
2023-02-28 19:30:24 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:f1bd:eef9:4eee:a4c2) (Remote host closed the connection)
2023-02-28 19:30:26 +0100 <Inst> for IO-facing issues, it's often more complicated than dedicated scripting languages
2023-02-28 19:30:32 +0100 <Inst> the lambda tax problem is actively being worked on
2023-02-28 19:30:43 +0100 <Inst> we're working on better abstractions and better ways for the compiler to handle the abstractions
2023-02-28 19:30:57 +0100 <monochrom> When are you going to accept that popularity is a function of networking effects not technical reasons? Programming is a social construct.
2023-02-28 19:31:28 +0100 <mauke> no, no. if I just make my programming language *really good*, everyone will start using it
2023-02-28 19:31:35 +0100 <Inst> (in 20 years)
2023-02-28 19:31:50 +0100 <Inst> or rather, 25, it took 25 for Python to become the imperative scripting language par excellence
2023-02-28 19:31:59 +0100 <mauke> and it still sucks
2023-02-28 19:32:00 +0100 <segfaultfizzbuzz> or maybe programming languages are just in a pre-scientific era
2023-02-28 19:32:22 +0100 <int-e> PL Cemetary. A horror story.
2023-02-28 19:32:24 +0100 <kuribas> "popularity" is a social construct. I can give objective reasons why languages are deficient.
2023-02-28 19:32:27 +0100 <Inst> they'll likely always be in a pre-scientific era, we'll figure out how to replace developers with AI before we figure out how to get a "very good, 80% of the way there" language
2023-02-28 19:32:34 +0100 <segfaultfizzbuzz> kuribas: i mostly agree with you
2023-02-28 19:32:57 +0100 <int-e> (Where *all* programming languages ever invented come back to life.)
2023-02-28 19:32:59 +0100 <Inst> w/e, not intending on trolling
2023-02-28 19:33:33 +0100 <mauke> kuribas: same. for example, python has indentation-based syntax, which is obviously deficient
2023-02-28 19:33:33 +0100 <kuribas> I can refute most arguments clojurists make wrt to types. But I still think criticising haskell for its complexity is valid.
2023-02-28 19:34:14 +0100 <kuribas> mauke: in a way yes
2023-02-28 19:34:16 +0100 <Inst> my issue right now is that either I don't know the effectful computation / IO loop story in Haskell properly, i.e, there are great abstractions I don't understand, or Haskell can't beat Python at scripting
2023-02-28 19:34:40 +0100 <mauke> Inst: both can be true
2023-02-28 19:34:51 +0100 <mauke> also, python is not a scripting language
2023-02-28 19:34:52 +0100 <Inst> it seems as though someone would have identified this as a problem, and worked toward fixing it
2023-02-28 19:35:00 +0100 <kuribas> language A "beating" B is a silly discussion, more interesting is how we can augment our experience.
2023-02-28 19:35:10 +0100 <mauke> ... LSD?
2023-02-28 19:35:16 +0100 <kuribas> That's one way :)
2023-02-28 19:35:18 +0100 <Inst> I prefer a nice Grand Marnier :)
2023-02-28 19:35:35 +0100 <segfaultfizzbuzz> Inst: try maintaining 10M lines of python used in prod vs haskell and then we can talk
2023-02-28 19:35:42 +0100 <mauke> Inst: what keeps you from writing imperative algorithms in ST?
2023-02-28 19:35:44 +0100 <kuribas> But I doubt it will improve the efficiency or programmers.
2023-02-28 19:35:45 +0100 <Inst> segfaultfizzbuzz: in that scenario it clearly wins
2023-02-28 19:36:03 +0100 <Inst> I'm just sad I can't show newbies "look how nice your Python script is in Haskell" and watch their heads explode
2023-02-28 19:36:27 +0100 <segfaultfizzbuzz> nobody is worried about newbie orthopaedic surgeons
2023-02-28 19:36:29 +0100 <kuribas> Inst: why would you want that?
2023-02-28 19:36:33 +0100 <segfaultfizzbuzz> why are we worried about newbie programmers
2023-02-28 19:36:35 +0100 <mauke> Inst: do you have any examples of "look how nice your Haskell script is in Python"?
2023-02-28 19:36:53 +0100 <Inst> I can make exactly one Python program much better in the Haskell version
2023-02-28 19:36:54 +0100 <int-e> segfaultfizzbuzz: they practice on animals and corpses
2023-02-28 19:37:15 +0100 <Inst> because it's doing a cryptographic transformation over String, but I can't do it in a natural fashion, only in a code-golfed fashion
2023-02-28 19:37:35 +0100 <Inst> then again, we still have the problem that doing it in an idiomatic python style is cancer / disgusting when you know what an idiomatic Haskell style looks like
2023-02-28 19:37:41 +0100 <segfaultfizzbuzz> Inst: as a potentially more productive direction for this discussion, check out elm-lang and roc-lang
2023-02-28 19:37:51 +0100 <Inst> roc i haven't heard of
2023-02-28 19:38:05 +0100 <Inst> elm, FP courses should switch to Elm instead more often instead of Haskell
2023-02-28 19:38:14 +0100 <Inst> same nice currying syntax, less hardcore abstractions that make newbie brains explode
2023-02-28 19:38:32 +0100 <monochrom> This is why programming is still not a profession.
2023-02-28 19:38:33 +0100 <mauke> where's the fun if your brain doesn't explode now and then?
2023-02-28 19:38:42 +0100 <sm> Inst: I'm interested in haskell scripting, feel free to share scripts you've made that aren't satisfying
2023-02-28 19:39:04 +0100 <monochrom> In all professions --- accounting, law, medicine, ... --- no one worries about "make it easier for newbies".
2023-02-28 19:39:09 +0100 <Inst> mauke: what's the human quality if you don't enjoy having your brain explode every now and then?
2023-02-28 19:39:10 +0100 <int-e> monochrom: you mean, like, managing a theatre's program?
2023-02-28 19:39:28 +0100 <segfaultfizzbuzz> monochrom: yeah exactly :-P
2023-02-28 19:39:29 +0100 <Inst> sm: thank you so much for the offer
2023-02-28 19:39:38 +0100 <Inst> I'll get to you on Matrix
2023-02-28 19:39:43 +0100 <Inst> query there?
2023-02-28 19:39:59 +0100 <mauke> Inst: neophobia?
2023-02-28 19:40:22 +0100 <sm> https://github.com/haskell-game/tiny-games-hs is one repository of small scripts (the unminified versions). Haskell seems not too bad for scripting, except for the hassle of imports
2023-02-28 19:40:33 +0100weirdsmiley(~weirdsmil@103.25.231.102)
2023-02-28 19:40:48 +0100 <Inst> I have monomer working, I probably can get img-ui working. I love your part of the community, i.e, the Haskell games community.
2023-02-28 19:41:11 +0100 <sm> public chat is better, we'll all learnm
2023-02-28 19:41:13 +0100 <hellwolf[m]> > except for the hassle of imports
2023-02-28 19:41:13 +0100 <hellwolf[m]> @sm is that different in other language?
2023-02-28 19:41:13 +0100 <lambdabot> *SMACK*, *SLAM*, take that is that different in other language?!
2023-02-28 19:41:14 +0100 <hellwolf[m]> s/language/languages/
2023-02-28 19:41:14 +0100 <lambdabot> <hint>:1:23: error: parse error on input ‘of’
2023-02-28 19:41:20 +0100 <Inst> welp
2023-02-28 19:41:21 +0100 <Inst> https://github.com/haskell-game/tiny-games-hs/blob/main/prelude/guess1/guess1.hs
2023-02-28 19:41:22 +0100weirdsmiley(~weirdsmil@103.25.231.102) (Client Quit)
2023-02-28 19:41:24 +0100 <hellwolf[m]> It's probably about what is by default imported.
2023-02-28 19:41:30 +0100weirdsmiley(~weirdsmil@103.25.231.102)
2023-02-28 19:41:36 +0100 <sm> some languages have more batteries included or packaged in fewer imports I feel
2023-02-28 19:41:39 +0100 <sm> php being a good example
2023-02-28 19:41:48 +0100 <monochrom> Java and Python have a lot of imports too.
2023-02-28 19:41:53 +0100 <hellwolf[m]> yea, perhaps a runghc -bigger-battery would be an idea
2023-02-28 19:41:55 +0100 <Inst> i'm not sure if our prelude is considered notoriously bad
2023-02-28 19:42:15 +0100 <monochrom> Especially since their communities frown upon "import x.y.*".
2023-02-28 19:42:26 +0100 <int-e> hellwolf[m]: that's why `cabal run` and whatever the `stack` command is are a thing
2023-02-28 19:42:41 +0100 <mauke> heh. I love having 2000 reserved identifiers in the global namespace
2023-02-28 19:43:04 +0100 <hellwolf[m]> yea, in python you'd also need to do import math, this kind of thing
2023-02-28 19:43:11 +0100 <int-e> mauke: _how _about _infinitely _many _of _them?
2023-02-28 19:43:21 +0100 <Inst> what is with the Haskell games community, anyways? I know someone's working on both Linear-Haskell and Haskell Games?
2023-02-28 19:43:46 +0100 <Inst> the blackjack game I'm working on right now, is about 200 lines, which is probably 100-150 lines too many for me
2023-02-28 19:43:47 +0100 <weirdsmiley> hey folks, i have a vim+coc setup, but i can't jump to definitions.
2023-02-28 19:43:51 +0100 <mauke> int-e: those are only reserved in theory. php actually dumps thousands of identifiers in your global environment
2023-02-28 19:43:52 +0100 <Inst> i'm going to rework it into a testing framework soon
2023-02-28 19:44:18 +0100 <hellwolf[m]> int-e: fair, perhaps qualified imports such as "control", "math", "text", etc.
2023-02-28 19:44:20 +0100 <int-e> Inst: that combination makes sense, when one of the promises of linear types is timely resource management
2023-02-28 19:44:39 +0100 <hellwolf[m]> * fair, perhaps implicit qualified imports
2023-02-28 19:44:54 +0100 <mauke> oh, like ocaml?
2023-02-28 19:45:01 +0100 <Inst> I mean, my agenda right now is working, in my own incompetent way, toward having a turnkey ability for the Haskell community
2023-02-28 19:45:04 +0100 <mauke> well, not quite
2023-02-28 19:45:21 +0100 <Inst> so when the Haskell community finally gets bored with research and says: "send in the monkeys!" we'll have the pedagogy and libraries to support them
2023-02-28 19:45:38 +0100 <int-e> mauke: you said "reserved" though :) (we're all trolling a bit, aren't we)
2023-02-28 19:45:44 +0100maukehas flashbacks to ENTERPRISE TURKEY SOLUTIONS
2023-02-28 19:46:24 +0100hellwolf[m]looking at Urbit community, wondering why would we ever care about being popular
2023-02-28 19:47:16 +0100 <int-e> hellwolf[m]: FWIW, I don't use Haskell for scripting but the reason for that is compile time/binary size, not the imports.
2023-02-28 19:47:30 +0100 <monochrom> I still go by what Graham Hutton said. Programming is difficult, Haskell is just being honest about it.
2023-02-28 19:47:56 +0100 <hellwolf[m]> I must say I haven't noticed compile time cost most of the time for prelude/base/default tiny games.
2023-02-28 19:48:03 +0100 <Inst> for some definition of programming, as opposed to codemonkeys using brain-dead frameworks for very repetitive design tasks
2023-02-28 19:48:06 +0100 <hellwolf[m]> s/most/at/, s/of/all/, s/the time//
2023-02-28 19:48:30 +0100 <mauke> well, that was a silly edit
2023-02-28 19:48:47 +0100 <hellwolf[m]> :D
2023-02-28 19:49:05 +0100 <mauke> could be massively simplified to s/most of the time/at all/
2023-02-28 19:49:10 +0100 <Inst> i wonder, would it be more fun to crap on the Clojurians instead?
2023-02-28 19:49:22 +0100 <Inst> supposedly the core Clojure team has made clear that they don't want to expand their community
2023-02-28 19:49:28 +0100 <Inst> I have an emotional attachment toward Haskell / Haskell community
2023-02-28 19:49:36 +0100 <Inst> trying to expand their community against their will would be funny
2023-02-28 19:50:27 +0100 <int-e> that doesn't sound constructive
2023-02-28 19:50:46 +0100 <int-e> we joke, but I don't think we're here to cause actual drama in any language's community
2023-02-28 19:51:08 +0100 <Inst> yeah, sorry, shouldn't be discussing that here
2023-02-28 19:51:10 +0100 <int-e> except maybe Haskell's, on occasion.
2023-02-28 19:52:33 +0100xelxebar(~xelxebar@wilsonb.com)
2023-02-28 19:53:09 +0100 <monochrom> It is easy to be snobbish and dismiss what codemonkeys do as brain-dead. But given that they are making big money, considering them brain-dead makes no economic sense.
2023-02-28 19:54:12 +0100ft(~ft@p3e9bc443.dip0.t-ipconnect.de)
2023-02-28 19:55:05 +0100 <Inst> i don't think codemonkeys make that much money; the salaries are less than other professional jobs, at least in the United States
2023-02-28 19:55:12 +0100 <Inst> solidly middle-class on average
2023-02-28 19:55:41 +0100 <Inst> you can hire Haskellers for 20k a year from China, it seems. Ukrainians might be even cheaper.
2023-02-28 19:55:45 +0100 <sm> int-e yes the heavy toolchain requirement is the biggest downside of haskell for scripting. It's best for folks already bought in to the language
2023-02-28 19:56:27 +0100 <sm> there's no need to compile or make large binaries, but you do need 2G of tools and deps
2023-02-28 19:57:21 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi)
2023-02-28 19:57:54 +0100 <Inst> i'm more interested in what being good at scripting represents, i.e, a highly-efficient way to handle IO
2023-02-28 19:57:55 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7)
2023-02-28 19:57:55 +0100king_gs(~Thunderbi@2806:103e:29:1779:19a5:ca6b:2f79:45e7) (Client Quit)
2023-02-28 19:58:12 +0100 <Inst> Haskell is already good at scripting, if you're willing to sacrifice pure expressivity for correctness and call it a win
2023-02-28 20:01:41 +0100 <segfaultfizzbuzz> inst: maybe you can move this to #haskell-beginners unless you have a specific question
2023-02-28 20:03:09 +0100 <sm> segfaultfizzbuzz: why ? this is the general haskell channel
2023-02-28 20:03:23 +0100euandreh(~Thunderbi@189.6.18.7) (Remote host closed the connection)
2023-02-28 20:06:01 +0100 <Inst> i can take it elsewhere if you want, I know the community is fed up with me griping about Haskell while not having the ability to improve things
2023-02-28 20:06:26 +0100 <Inst> the specific question was asking about research efforts toward improving Haskell in scripting and IO-facing code
2023-02-28 20:06:59 +0100 <mauke> I disagree with your definition of "scripting"
2023-02-28 20:07:14 +0100 <hellwolf[m]> it would be more constructive if you could present a small example that we can try to think what can we improve with
2023-02-28 20:07:38 +0100 <segfaultfizzbuzz> there is no such thing as scripting, only bad programming and languages which do not enforce invariants
2023-02-28 20:08:33 +0100 <mauke> there is such a thing as scripting, which is driving a normally interactive application through program code
2023-02-28 20:08:50 +0100 <mauke> (see also: scriptable text editors, scriptable debuggers)
2023-02-28 20:08:56 +0100 <int-e> Of course there's scripting. In its bare form it's like a cooking recipe, a sequence of steps to be performed to accomplish a task.
2023-02-28 20:08:59 +0100 <Jade[m]1> I use haskell for "scripting" with ghci
2023-02-28 20:09:05 +0100 <segfaultfizzbuzz> so you mean hotswappable code then?
2023-02-28 20:09:22 +0100 <sm> no need for griping, but let's get concrete once in a while. Show us what you made, it always helps
2023-02-28 20:09:26 +0100 <Inst> https://pastebin.com/h25rn0HR
2023-02-28 20:09:53 +0100 <mauke> oh god, that syntax highlighting is unreadable
2023-02-28 20:09:54 +0100 <sm> nice!
2023-02-28 20:09:56 +0100 <Inst> https://inventwithpython.com/bigbookpython/project1.html
2023-02-28 20:10:00 +0100 <mauke> white text on light green background
2023-02-28 20:10:24 +0100 <int-e> But this is computers, so scripts will grow conditionals and loops. And then might end up with something like the Bourne shell. Or Perl or... well, the list is endless. It's hard to delineate it from other programming languages that have all those capabilities and more.
2023-02-28 20:10:41 +0100 <Inst> fixed version:
2023-02-28 20:10:42 +0100 <Inst> https://pastebin.com/MMKjh1R2
2023-02-28 20:11:16 +0100 <mauke> Perl is not a scripting language, under my definition
2023-02-28 20:11:24 +0100 <sm> but yes god my eyes, how about
2023-02-28 20:11:24 +0100 <sm> @where paste
2023-02-28 20:11:25 +0100 <lambdabot> Help us help you: please paste full code, input and/or output at e.g. https://paste.tomsmeding.com
2023-02-28 20:11:34 +0100 <int-e> (Personally I tend to think that scripting languages are interpreted, low on boilerplate to execute a single command, and also low on syntactic overhead to execute external commands. This is rather subjective.)
2023-02-28 20:12:20 +0100 <hellwolf[m]> As far as I can tell the hs tiny games rarely had boilerplate!
2023-02-28 20:12:25 +0100 <Inst> yeah, for whatever reason, Tom's pastebin got taken off topic
2023-02-28 20:12:49 +0100 <sm> I see it there
2023-02-28 20:13:03 +0100 <mauke> ... | Paste code/errors: https://paste.tomsmeding.com | ...
2023-02-28 20:13:04 +0100 <sm> some clients won't show it all
2023-02-28 20:13:38 +0100 <sclv> yeah its just topic got big lmao
2023-02-28 20:14:00 +0100 <Inst> there's obviously partiality
2023-02-28 20:14:03 +0100 <Inst> in part of the code
2023-02-28 20:14:28 +0100 <sm> Inst: planning to add a shebang line to make that more runnable ?
2023-02-28 20:14:33 +0100 <mauke> -!- Topic for #haskell: https://www.reddit.com/r/haskell | Admin: #haskell-ops | Offtopic: #haskell-offtopic | https://downloads.haskell.org https://play-haskell.tomsmeding.com/ | Paste code/errors: https://paste.tomsmeding.com | Logs: https://ircbrowse.tomsmeding.com/browse/lchaskell
2023-02-28 20:14:36 +0100 <Inst> shebang line?
2023-02-28 20:14:38 +0100 <mauke> (for completeness)
2023-02-28 20:14:47 +0100 <mauke> Inst: #!...
2023-02-28 20:15:16 +0100 <sm> like: #!/usr/bin/env runghc
2023-02-28 20:15:16 +0100 <sm> or: #!/usr/bin/env -S stack script --resolver lts-20 --package random
2023-02-28 20:15:29 +0100 <Inst> ahhh
2023-02-28 20:15:35 +0100 <int-e> mauke: hmm does that have room for another | between the downloads and the playground link?
2023-02-28 20:15:50 +0100 <sm> also, chmod +x myscript.hs. Then it's more like a typical script
2023-02-28 20:15:54 +0100 <mauke> int-e: no idea :-)
2023-02-28 20:16:04 +0100 <mauke> don't ask me what the IRC limits are
2023-02-28 20:16:30 +0100 <darkling> Server-dependent, I think.
2023-02-28 20:16:46 +0100 <darkling> (Plus other arbitrary limits imposed by clients, most likely)
2023-02-28 20:16:49 +0100 <sm> Inst: also, you may not have time but that looks to me possibly compressible to 10 lines
2023-02-28 20:17:32 +0100 <int-e> It's still way under the ~480 characters limit where things usually start to break.
2023-02-28 20:17:34 +0100 <Inst> sm: can I take a raincheck on that? Because that's awesome.
2023-02-28 20:17:47 +0100 <Inst> Sans comments, the Python original is 78 lines
2023-02-28 20:18:13 +0100 <Inst> I generally regard boilerplatey or verbose Haskell as a bug
2023-02-28 20:18:25 +0100 <Inst> or, more accurately, a deficiency in the developer, but a bug is that too, no?
2023-02-28 20:18:36 +0100 <int-e> ?
2023-02-28 20:18:46 +0100 <sm> still https://www.timeanddate.com/countdown/generic?iso=20230228T235959&p0=1440&msg=Haskell+Tiny+Game+Ja… ~4 hours to go and folks in #haskell-game:matrix.org happy to help with golfing. But no pressure :)
2023-02-28 20:20:21 +0100 <Inst> well, the question is, how idiomatic is it?
2023-02-28 20:20:26 +0100 <Inst> i had a golfed solution that was completely unreadable
2023-02-28 20:20:59 +0100 <yushyin> so i wouldn't measure 'good', 'bugfree' code by the density of the code ...
2023-02-28 20:22:04 +0100hellwolf[m]ponders that "unbearable lightness of Haskell" would be a good movie.
2023-02-28 20:22:43 +0100smlikes a semi golfed style: one item per line, long lines, short names with a legend in comments - very compact yet still somewhat readable
2023-02-28 20:23:06 +0100 <sm> it's apl/j/k like
2023-02-28 20:23:11 +0100gurkenglas(~gurkengla@dynamic-046-114-179-219.46.114.pool.telefonica.de) (Ping timeout: 260 seconds)
2023-02-28 20:24:03 +0100mei(~mei@user/mei) (Quit: mei)
2023-02-28 20:26:37 +0100 <Inst> and thanks, sm, for offering to teach me a little bit of how to do Haskell code in IO-facing side properly
2023-02-28 20:26:57 +0100euandreh(~Thunderbi@189.6.18.7)
2023-02-28 20:27:15 +0100 <mauke> sm: what are the default packages?
2023-02-28 20:27:52 +0100 <sm> the ones that come with ghc.. there's a list in the ghc guide I don't have just now
2023-02-28 20:30:54 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef)
2023-02-28 20:32:34 +0100dumptruckman(~dumptruck@45-33-69-234.ip.linodeusercontent.com) (Quit: ZNC - https://znc.in)
2023-02-28 20:34:35 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 248 seconds)
2023-02-28 20:35:19 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef) (Ping timeout: 260 seconds)
2023-02-28 20:37:13 +0100dumptruckman(~dumptruck@143-42-239-71.ip.linodeusercontent.com)
2023-02-28 20:41:23 +0100 <hellwolf[m]> ghc-pkgs list
2023-02-28 20:41:38 +0100gurkenglas(~gurkengla@dynamic-046-114-179-219.46.114.pool.telefonica.de)
2023-02-28 20:41:38 +0100 <gurkenglas> proooobably this doesn't quite do it, but here's attempt number one at a class that forces whoever implements it to have at least two distinguishable inhabitants
2023-02-28 20:42:06 +0100 <gurkenglas> proooobably this doesn't quite do it, but here's attempt number one at a class that forces whoever implements it to have at least two distinguishable inhabitants: class AtLeastTwo t where distinguish :: forall constraint. constraint (Const t) => (forall x. constraint x => x a -> x b -> x c) -> Either (forall x. constraint x => x a -> x c) (forall x. constraint x => x b -> x c)
2023-02-28 20:43:03 +0100npm_i_kurbus(~npm_i_kur@user/kurbus) (Quit: Client closed)
2023-02-28 20:44:11 +0100 <hellwolf[m]> what is distinguishable, or the meaning of equality here? Runtime representation wise?
2023-02-28 20:44:34 +0100 <gurkenglas> of course, what i actually want instead of my last line 2 minutes ago is "the subtype of X a on which all functions (forall a. X a -> Y a) agree". i might be able to build it from this, using -> Void and the like? but maybe there's a nicer way
2023-02-28 20:45:16 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef)
2023-02-28 20:45:45 +0100 <gurkenglas> hellwolf[m]: observation-wise - whether you can use it to tell between "const id" and "cost"
2023-02-28 20:45:50 +0100 <gurkenglas> s/cost/const/
2023-02-28 20:47:48 +0100 <gurkenglas> hm, my attempt doesn't work because constraint could be Applicative and then the (x a -> x b -> x c) needn't be const id or const.
2023-02-28 20:48:16 +0100dcoutts_(~duncan@cpc69403-oxfd27-2-0-cust285.4-3.cable.virginm.net) (Ping timeout: 252 seconds)
2023-02-28 20:50:01 +0100 <hellwolf[m]> I wonder how you can prove such thing in logic.... you'd have to contradiction?
2023-02-28 20:50:09 +0100 <hellwolf[m]> I can't imagine how you'd do that even in Agda
2023-02-28 20:54:16 +0100 <gurkenglas> i need to both force the definer of distinguish to be unable to set x to anything but Const, and force the caller of distinguish to be unable to assume anything about x...
2023-02-28 20:56:41 +0100gmg(~user@user/gehmehgeh)
2023-02-28 21:01:25 +0100hugo(znc@verdigris.lysator.liu.se) (Ping timeout: 246 seconds)
2023-02-28 21:03:10 +0100 <hellwolf[m]> What about coercibles. Maybe it's relevant to know how this is being used?
2023-02-28 21:03:30 +0100mei(~mei@user/mei)
2023-02-28 21:03:51 +0100 <gurkenglas> hellwolf[m], a category is a way to compose paths-of-arrows such that any way to compose em that you can construct from that one is that one
2023-02-28 21:04:25 +0100 <gurkenglas> which looks suspiciously-convenient enough that one might be able to express it in a type somehow
2023-02-28 21:04:55 +0100wootehfoot(~wootehfoo@user/wootehfoot)
2023-02-28 21:09:28 +0100 <ncf> gurkenglas: what is to stop me from defining distinguish for t ~ () ? just return Left always?
2023-02-28 21:10:00 +0100 <gurkenglas> ncf: Left what? :)
2023-02-28 21:10:56 +0100 <ncf> ah i see
2023-02-28 21:11:07 +0100 <ncf> let me flip this around then: how do you define distinguish @Bool?
2023-02-28 21:11:57 +0100 <gurkenglas> Good question! the hope-plan was: call the argument with x=Const Bool, figure out which one it is, return that one
2023-02-28 21:12:03 +0100hugo(znc@verdigris.lysator.liu.se)
2023-02-28 21:12:13 +0100qhong_qhong
2023-02-28 21:12:14 +0100 <gurkenglas> but yes, there's a problem convincing the compmiler that this works out
2023-02-28 21:12:31 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-28 21:17:47 +0100 <gurkenglas> "a type t has at least two inhabitants if for any a b there is some t -> Either a b via which you can build (a,b)"...
2023-02-28 21:18:05 +0100 <gurkenglas> (a and b both inhabited, of course)
2023-02-28 21:18:15 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef) (Remote host closed the connection)
2023-02-28 21:19:23 +0100dhil(~dhil@78.45.150.83.ewm.ftth.as8758.net) (Ping timeout: 248 seconds)
2023-02-28 21:19:44 +0100lyle(~lyle@104.246.145.237) (Quit: WeeChat 3.8)
2023-02-28 21:22:32 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-02-28 21:26:53 +0100akegalj(~akegalj@89-164-77-228.dsl.iskon.hr) (Quit: leaving)
2023-02-28 21:27:07 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 260 seconds)
2023-02-28 21:28:38 +0100 <hellwolf[m]> would a this alternative work
2023-02-28 21:28:38 +0100 <hellwolf[m]> class AtLeastTwoInhatants k where
2023-02-28 21:28:38 +0100 <hellwolf[m]> prove_me :: (~(Coercible a b), k a, k b) => a -> b -> ()
2023-02-28 21:28:38 +0100 <hellwolf[m]> Ignore me if I am completely misunderstanding it.
2023-02-28 21:29:02 +0100 <hellwolf[m]> (doing it on mobile.. likely wrong code)
2023-02-28 21:29:16 +0100 <ncf> can you negate constraints like that?
2023-02-28 21:30:33 +0100 <gurkenglas> k is a constraint here? a and b are... surely not inhabitants?
2023-02-28 21:32:22 +0100 <gurkenglas> "a type o has exactly one inhabitant iff any calculation you can do with it, you can do without it"... where once again i can't express "and arrive at the same result"
2023-02-28 21:33:10 +0100 <gurkenglas> ...or can I?
2023-02-28 21:34:52 +0100 <gurkenglas> nope. thought free theorems would get me "same result" in this case, but not quite.
2023-02-28 21:36:15 +0100mauke(~mauke@user/mauke) (Read error: Connection reset by peer)
2023-02-28 21:37:06 +0100mauke(~mauke@user/mauke)
2023-02-28 21:40:46 +0100 <dminuoso_> ncf: At least in case of Coercible, a Nocoercible constraint is at least conceivable on a technical level
2023-02-28 21:40:50 +0100CiaoSen(~Jura@p200300c9570e91002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-02-28 21:41:02 +0100 <dminuoso_> But not in general
2023-02-28 21:42:40 +0100 <gurkenglas> "a type o has exactly one inhabitant iff any (o -> Either a b) -> x a b polymorphic in a and b must have the x a b be actually (forall c. x a c) or (forall c. x c b)"
2023-02-28 21:43:39 +0100 <gurkenglas> but how do i say that it is polymorphic in a and b while remaining able to say that we can make some (forall c. x a c) or (forall c. x c b) out of it?
2023-02-28 21:45:26 +0100 <jean-paul[m]> Can I get a pretty printer for lists of byte strings in tasty / hunit test failures?
2023-02-28 21:45:58 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-02-28 21:49:22 +0100 <hellwolf[m]> https://hackage.haskell.org/package/type-eq-0.5/docs/Type-Eq.html would this be of any help
2023-02-28 21:49:33 +0100 <gurkenglas> oh, of course!
2023-02-28 21:51:53 +0100fnurglewitz(uid263868@id-263868.lymington.irccloud.com)
2023-02-28 21:54:04 +0100 <gurkenglas> @let class ExactlyOne o where sift :: (forall x a b. (o -> Either a b) -> x a b) -> forall r. ((forall x a b c. (o -> Either a b) -> x a c) -> r) -> ((forall x a b c. (o -> Either a b) -> x c b) -> r) -> r -- does this do it? I think this does it!
2023-02-28 21:54:05 +0100 <lambdabot> /sandbox/tmp/.L.hs:177:9: error:
2023-02-28 21:54:05 +0100 <lambdabot> Multiple declarations of ‘sift’
2023-02-28 21:54:05 +0100 <lambdabot> Declared at: /sandbox/tmp/.L.hs:170:9
2023-02-28 21:54:11 +0100 <gurkenglas> @undefine
2023-02-28 21:54:11 +0100 <lambdabot> Undefined.
2023-02-28 21:54:15 +0100 <gurkenglas> @let class ExactlyOne o where sift :: (forall x a b. (o -> Either a b) -> x a b) -> forall r. ((forall x a b c. (o -> Either a b) -> x a c) -> r) -> ((forall x a b c. (o -> Either a b) -> x c b) -> r) -> r
2023-02-28 21:54:17 +0100 <lambdabot> Defined.
2023-02-28 21:54:39 +0100 <gurkenglas> (excuse the impredicative-types-caused continuation passing style.)
2023-02-28 21:55:27 +0100 <gurkenglas> a *separate* question is whether this can actually be instantiated for (), but that feels relatively possible since the space of all x is so large
2023-02-28 21:56:07 +0100 <fnurglewitz> hi, anyone knows an http library that gives you a lazy bytestring when GETting a file? I would like to pipe it into json-stream to avoid loading a quite big json (1.5+ gigs) into memory
2023-02-28 21:57:29 +0100Guest5069(~m-mzmz6l@38.242.236.220) (Remote host closed the connection)
2023-02-28 21:59:01 +0100manwithl-(~manwithlu@hoeven.dossingday.ml)
2023-02-28 21:59:02 +0100dcoutts_(~duncan@cpc69403-oxfd27-2-0-cust285.4-3.cable.virginm.net)
2023-02-28 21:59:14 +0100root(~m-mzmz6l@vmi833741.contaboserver.net)
2023-02-28 21:59:28 +0100 <gurkenglas> (flaw spotted in ExactlyOne: the x renders sift's first argument too powerful. maybe one can just replace every "Either a b" with "Either (forall c. x a c) (forall c. x c b)"?)
2023-02-28 21:59:38 +0100rootGuest3592
2023-02-28 22:02:15 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Remote host closed the connection)
2023-02-28 22:02:39 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-02-28 22:05:16 +0100 <hellwolf[m]> And this old article: https://ryanglscott.github.io/2018/03/04/how-quantifiedconstraints-can-let-us-put-join-back-in-mon…
2023-02-28 22:06:57 +0100wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2023-02-28 22:06:59 +0100Sciencentistguy7(~sciencent@hacksoc/ordinary-member)
2023-02-28 22:07:28 +0100manwithluck(~manwithlu@194.177.28.192) (Quit: ZNC - https://znc.in)
2023-02-28 22:07:50 +0100manwithl-(~manwithlu@hoeven.dossingday.ml) (Quit: ZNC - https://znc.in)
2023-02-28 22:09:27 +0100Sciencentistguy(~sciencent@hacksoc/ordinary-member) (Ping timeout: 252 seconds)
2023-02-28 22:09:27 +0100Sciencentistguy7Sciencentistguy
2023-02-28 22:10:12 +0100manwithluck(~manwithlu@hoeven.dossingday.ml)
2023-02-28 22:11:31 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-02-28 22:16:23 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 264 seconds)
2023-02-28 22:18:18 +0100cheater_(~Username@user/cheater)
2023-02-28 22:18:45 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef)
2023-02-28 22:20:55 +0100cheater(~Username@user/cheater) (Ping timeout: 260 seconds)
2023-02-28 22:21:03 +0100cheater_cheater
2023-02-28 22:23:15 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:8429:4ceb:8103:61ef) (Ping timeout: 260 seconds)
2023-02-28 22:26:18 +0100Lycurgus(~juan@user/Lycurgus)
2023-02-28 22:30:36 +0100segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-02-28 22:31:05 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-02-28 22:31:21 +0100jinsun__(~jinsun@user/jinsun)
2023-02-28 22:31:21 +0100jinsun(~jinsun@user/jinsun) (Killed (silver.libera.chat (Nickname regained by services)))
2023-02-28 22:31:21 +0100jinsun__jinsun
2023-02-28 22:31:43 +0100gurkenglas(~gurkengla@dynamic-046-114-179-219.46.114.pool.telefonica.de) (Ping timeout: 248 seconds)
2023-02-28 22:37:13 +0100 <hellwolf[m]> gurkenglas: what about this https://pastebin.com/zemLtfu0
2023-02-28 22:38:06 +0100hellwolf[m]sent a code block: https://libera.ems.host/_matrix/media/v3/download/libera.chat/5a8f2d13e43ce63d40d6878ec6fe2a8d13d4…
2023-02-28 22:42:27 +0100mauke(~mauke@user/mauke) (Read error: Connection reset by peer)
2023-02-28 22:46:55 +0100mauke(~mauke@user/mauke)
2023-02-28 22:49:20 +0100czy(~user@50.30.140.25) (Quit: ERC 5.4.1 (IRC client for GNU Emacs 30.0.50))
2023-02-28 22:49:40 +0100czy(~user@host-140-25.ilcub310.champaign.il.us.clients.pavlovmedia.net)
2023-02-28 22:50:08 +0100gurkenglas(~gurkengla@dynamic-046-114-179-219.46.114.pool.telefonica.de)
2023-02-28 22:55:23 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 264 seconds)
2023-02-28 22:57:34 +0100gurkenglas(~gurkengla@dynamic-046-114-179-219.46.114.pool.telefonica.de) (Ping timeout: 268 seconds)
2023-02-28 23:00:11 +0100mechap(~mechap@user/mechap) (Ping timeout: 264 seconds)
2023-02-28 23:01:29 +0100dgb8(~dgb@astra4961.startdedicated.net) (Quit: Ping timeout (120 seconds))
2023-02-28 23:01:29 +0100phma(~phma@host-67-44-208-37.hnremote.net) (Read error: Connection reset by peer)
2023-02-28 23:01:45 +0100dgb8(~dgb@astra4961.startdedicated.net)
2023-02-28 23:02:05 +0100mechap(~mechap@user/mechap)
2023-02-28 23:02:37 +0100phma(phma@2001:5b0:215a:9618:c34:315f:ca7c:13ac)
2023-02-28 23:03:22 +0100gurkenglas(~gurkengla@dynamic-046-114-179-219.46.114.pool.telefonica.de)
2023-02-28 23:04:08 +0100 <mauke> how do I know which version of base Data.Ord.clamp was added in?
2023-02-28 23:05:40 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-02-28 23:06:25 +0100 <lyxia> enumerate base versions?
2023-02-28 23:06:35 +0100 <xerox> https://github.com/ghc/ghc/commit/fc965c0910757410d624229419f36f0829cf73f6
2023-02-28 23:06:52 +0100 <lyxia> it's in 4.16 but not 4.15
2023-02-28 23:07:40 +0100Midjak(~Midjak@82.66.147.146) (Quit: This computer has gone to sleep)
2023-02-28 23:08:07 +0100 <mauke> xerox: I know the commit
2023-02-28 23:08:11 +0100 <mauke> but how does that help me?
2023-02-28 23:08:25 +0100 <xerox> mauke: to be honest I was just hoping it would!
2023-02-28 23:10:18 +0100 <geekosaur> it shows what ghc release tags it's in, then check version-history to see what version of base corresponds to the oldest? (9.2.1 => 4.16.0.0)
2023-02-28 23:10:46 +0100 <xerox> maybe with ghcup one can figure out ghc<->base mapping? I have some vague memory about that
2023-02-28 23:11:02 +0100gurkenglas(~gurkengla@dynamic-046-114-179-219.46.114.pool.telefonica.de) (Ping timeout: 255 seconds)
2023-02-28 23:11:29 +0100 <segfaultfizzbuzz> so i was watching this: https://twitter.com/chenwang_j/status/1628792565385564160 and it got me thinking about the fact that this robot would watch a towel it was supposed to fold, and then when the environment (a hostile person) comes along an unfolds the towel, the robot figures out the right way to re-fold the towel
2023-02-28 23:11:38 +0100 <geekosaur> yes, ghcup tui in particular shows which base version goes with a ghc version
2023-02-28 23:11:56 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-02-28 23:12:39 +0100 <lyxia> also https://wiki.haskell.org/Base_package
2023-02-28 23:12:44 +0100 <segfaultfizzbuzz> in the context of programming, this would be like assuming that the program state can get screwed up in many ways and having the program "comb" the program state towards some kind of fixed point,...
2023-02-28 23:12:53 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Read error: Connection reset by peer)
2023-02-28 23:13:20 +0100 <segfaultfizzbuzz> this would (i guess?) be an alternative to the pure functional style of programming, ... is there a name for this?
2023-02-28 23:14:25 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 246 seconds)
2023-02-28 23:16:11 +0100michalz(~michalz@185.246.207.215) (Remote host closed the connection)
2023-02-28 23:16:33 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-02-28 23:16:52 +0100gurkenglas(~gurkengla@dynamic-046-114-179-219.46.114.pool.telefonica.de)
2023-02-28 23:19:39 +0100 <[exa]> l.org/Base_package
2023-02-28 23:19:55 +0100 <[exa]> oh noes wrong button, sorry
2023-02-28 23:20:30 +0100 <segfaultfizzbuzz> [exa]: any commentary on "fixed point oriented computing"?
2023-02-28 23:22:48 +0100 <c_wraith> Just replace direct recursion with explicit fixed-point combinators
2023-02-28 23:22:58 +0100 <c_wraith> then all programming is fixed-point-oriented
2023-02-28 23:23:52 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7) (Ping timeout: 246 seconds)
2023-02-28 23:24:33 +0100 <segfaultfizzbuzz> c_wraith: how does that interact with mutability? and i don't understand what a fixed-point combinator is
2023-02-28 23:25:06 +0100 <c_wraith> > fix (\loop n -> if n == 0 then 1 else n * loop (n - 1)) 5
2023-02-28 23:25:08 +0100 <lambdabot> 120
2023-02-28 23:26:08 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-02-28 23:26:21 +0100 <c_wraith> as far as working with mutability, one of my favorite uses of fix is for loops in IO that close over something previously bound in a do block.
2023-02-28 23:26:24 +0100mechap(~mechap@user/mechap) (Quit: WeeChat 3.8)
2023-02-28 23:26:47 +0100 <segfaultfizzbuzz> hmmm? ok i will have to look up fix, but do you have a small example of this?
2023-02-28 23:26:57 +0100 <c_wraith> :t fix
2023-02-28 23:26:58 +0100 <lambdabot> (a -> a) -> a
2023-02-28 23:26:59 +0100 <segfaultfizzbuzz> so i guess this is a structure which is actually used?
2023-02-28 23:27:13 +0100 <c_wraith> Don't try to make too much sense out of that type. It's a logical fallacy. :)
2023-02-28 23:27:20 +0100 <segfaultfizzbuzz> lol
2023-02-28 23:27:30 +0100 <segfaultfizzbuzz> the more i learn about programming the less i try to make sense out of anything
2023-02-28 23:28:05 +0100weirdsmiley(~weirdsmil@103.25.231.102) ()
2023-02-28 23:28:07 +0100 <c_wraith> you know how like foldl is abstracting out "recursion with an accumulator"?
2023-02-28 23:28:23 +0100 <c_wraith> fix is abstracting out general recursion. Just any and all recursion
2023-02-28 23:28:35 +0100 <segfaultfizzbuzz> vaguely, i get the folds mixed up but sure one of them has an accumulator ;-)
2023-02-28 23:28:45 +0100 <segfaultfizzbuzz> ok interesting and strange
2023-02-28 23:29:08 +0100 <c_wraith> it's *mostly* of theoretical interest
2023-02-28 23:29:23 +0100 <segfaultfizzbuzz> ok, but what i am talking about is extremely practical
2023-02-28 23:29:29 +0100 <c_wraith> But there are some times when it's more convenient.
2023-02-28 23:29:54 +0100kuribas(~user@ptr-17d51eo9wm7f6qjcnfd.18120a2.ip6.access.telenet.be) (Quit: ERC (IRC client for Emacs 27.1))
2023-02-28 23:30:09 +0100 <hpc> arguably fix isn't the interesting bit, but the function you pass to it
2023-02-28 23:30:21 +0100 <segfaultfizzbuzz> i am saying is that the pure fp paradigm is to minimize shared state, be explicit with state, etc... basically treat program state like a fragile piece of glass which is delicately handed off
2023-02-28 23:30:24 +0100 <hpc> (\loop n -> if n == 0 then 1 else n * loop (n - 1)) is a perfectly fine lambda
2023-02-28 23:30:38 +0100 <hpc> and you can pass it to fix, or you can pass it to a modified fix that prints all the intermediate results
2023-02-28 23:30:53 +0100 <segfaultfizzbuzz> whereas i am saying that the opposite is also interesting, which is to assume that your program state always gets screwed up and write code which can bring it back to a good state, however the program state gets broken
2023-02-28 23:30:56 +0100 <hpc> or steps through the function every time you press enter
2023-02-28 23:31:53 +0100 <c_wraith> yeah. moving the recursion out allows you to modify the way recursion works.
2023-02-28 23:32:24 +0100EvanR(~EvanR@user/evanr) (Remote host closed the connection)
2023-02-28 23:32:27 +0100 <hpc> :t iterate
2023-02-28 23:32:28 +0100 <lambdabot> (a -> a) -> a -> [a]
2023-02-28 23:32:34 +0100 <hpc> > iterate (\loop n -> if n == 0 then 1 else n * loop (n - 1))
2023-02-28 23:32:35 +0100 <lambdabot> <(Integer -> Integer) -> [Integer -> Integer]>
2023-02-28 23:32:44 +0100EvanR(~EvanR@user/evanr)
2023-02-28 23:33:06 +0100 <hpc> > iterate ((\loop n -> if n == 0 then 1 else n * loop (n - 1)) 5)
2023-02-28 23:33:07 +0100 <lambdabot> error:
2023-02-28 23:33:07 +0100 <lambdabot> • No instance for (Num (Integer -> Integer))
2023-02-28 23:33:07 +0100 <lambdabot> arising from a use of ‘e_10115’
2023-02-28 23:33:24 +0100 <hpc> bah, pretend i am not an idiot right now :P
2023-02-28 23:33:39 +0100 <c_wraith> there's a reason I tested in a private chat with lambdabot first :)
2023-02-28 23:33:55 +0100 <c_wraith> it's not that I'm magically good at this stuff, it's that I hide all my failures
2023-02-28 23:34:40 +0100 <hpc> i was feeling lucky
2023-02-28 23:34:46 +0100 <hpc> i didn't learn my lesson from clint eastwood :P
2023-02-28 23:34:51 +0100 <segfaultfizzbuzz> hahaha
2023-02-28 23:35:54 +0100thegeekinside(~thegeekin@189.180.66.126)
2023-02-28 23:36:26 +0100biberu(~biberu@user/biberu) (Read error: Connection reset by peer)
2023-02-28 23:37:25 +0100SenFacheSauvin
2023-02-28 23:38:00 +0100 <c_wraith> anyway... this is a different kind of fixed point than you probably meant.
2023-02-28 23:38:08 +0100ph88(~ph88@ip5b426553.dynamic.kabel-deutschland.de)
2023-02-28 23:38:08 +0100 <c_wraith> this is a fixed point in domain theory
2023-02-28 23:39:05 +0100 <ph88> i'm trying to model connecting to a server and tracking the server's state (i'm writing the client). From this post https://stackoverflow.com/a/28696299/1833322 what would be the type of DVD ? what could/should i put there ?
2023-02-28 23:40:06 +0100 <c_wraith> > fix $ (0:) . scanl (+) 1 -- and of course, there's everyone's favorite parlor trick with fix
2023-02-28 23:40:08 +0100 <lambdabot> [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,...
2023-02-28 23:40:16 +0100 <segfaultfizzbuzz> c_wraith: a simple example of what i mean by fixed point would be "the entries in this list of integers shall be sorted by value"
2023-02-28 23:40:38 +0100 <segfaultfizzbuzz> c_wraith: the list we will treat as a mutable structure, and something will mutate the list to generate a list which violates the fixed point
2023-02-28 23:41:43 +0100biberu(~biberu@user/biberu)
2023-02-28 23:41:58 +0100 <hpc> ph88: in that particular example? maybe it would be a wrapper around a device file like "/dev/cdrom0"
2023-02-28 23:42:10 +0100 <segfaultfizzbuzz> c_wraith: and then something periodically checks that the list is indeed sorted by value, realizes it is not sorted by value, and then begins sorting the list...
2023-02-28 23:42:14 +0100 <hpc> or maybe you're writing a hypervisor and it can be either a device or a path to a .iso file
2023-02-28 23:42:32 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-28 23:42:38 +0100 <segfaultfizzbuzz> lol fix fibonacci parlor trick eh
2023-02-28 23:42:59 +0100 <hpc> for you, dInsert might be onClientConnect, and dEject onClientDisconnect
2023-02-28 23:43:01 +0100 <hpc> or something
2023-02-28 23:43:12 +0100 <hpc> and DVD would be replaced with some info about the client that's connecting
2023-02-28 23:44:17 +0100 <ph88> hpc, i am writing the client .. maybe it would hold some info about the connection to the server ?
2023-02-28 23:44:34 +0100 <hpc> yeah, probably that then
2023-02-28 23:44:36 +0100 <[Leary]> segfaultfizzbuzz: That's just a data invariant. If deviations are observable, however, then it's quite pointless. A system that maintains invariants by preventing such observation but nevertheless proceeds optimistically would be something like STM.
2023-02-28 23:44:56 +0100lxi(~quassel@2a02:2f08:4d1c:400:508d:2f08:6dd4:357e) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-02-28 23:44:57 +0100 <hpc> at a minimum, the handle it communicates over
2023-02-28 23:45:31 +0100 <ph88> hpc, in the example of the DVD the state transitions make a circle. A -> B -> C -> A (as example) .. but in my case i have a diamond shape like A -> B, A -> C, B -> D, C -> D, D -> A how should i model that ?
2023-02-28 23:45:44 +0100 <segfaultfizzbuzz> [Leary]: i am here actually saying that the invariant *can* be violated, but that the program works to restore the invariant when it (inevitably) breaks
2023-02-28 23:46:07 +0100 <hpc> you'd have more sorts of things with which you index the monad
2023-02-28 23:46:14 +0100 <hpc> and then functions that represent each of those transitions
2023-02-28 23:46:44 +0100 <hpc> so like how dInsert is False->True and dEject is True->False, maybe you have
2023-02-28 23:46:54 +0100 <hpc> connect is Disconnected->Request
2023-02-28 23:47:03 +0100 <hpc> send is Request->Response
2023-02-28 23:47:03 +0100Ashkan(~Ashkan@a119011.upc-a.chello.nl)
2023-02-28 23:47:09 +0100 <hpc> and close is Response->Disconnected
2023-02-28 23:47:18 +0100 <ph88> hpc, i have this https://bpa.st/EG7F6 .. but i'm not sure if it is the right shape. It's supposed to track the state of the server
2023-02-28 23:47:54 +0100 <ph88> hpc, i have connect Disconnected -> Connected and connect Disconnected -> Defunct (connection refused). That is what i meant with diamond shape state transition
2023-02-28 23:48:01 +0100 <hpc> ah
2023-02-28 23:49:17 +0100 <Ashkan> Hi
2023-02-28 23:49:18 +0100 <Ashkan> I need to share a `Map` between multiple (green) threads, each thread potentially trying to both read from and write to the map. I should use `TVar` right ?
2023-02-28 23:49:31 +0100 <ph88> hpc, here i get confused https://bpa.st/7G5IQ
2023-02-28 23:50:10 +0100gurkenglas(~gurkengla@dynamic-046-114-179-219.46.114.pool.telefonica.de) (Ping timeout: 260 seconds)
2023-02-28 23:50:23 +0100 <hpc> Ashkan: yeah, probably
2023-02-28 23:50:33 +0100 <hpc> TVar is transaction-y, MVar is lock-y
2023-02-28 23:50:56 +0100 <hpc> if you change your mind later, they have pretty much the exact same api
2023-02-28 23:51:01 +0100 <Ashkan> hpc Thank you . Care to elaborate on the *probably* part ?
2023-02-28 23:51:03 +0100 <hpc> shouldn't be too hard to switch
2023-02-28 23:51:53 +0100 <hpc> Ashkan: depending on access patterns one might be faster than the other
2023-02-28 23:51:57 +0100 <[Leary]> segfaultfizzbuzz: Yes, my point is that you really want your system to cleverly fix the breakage before anything else is able to notice it. An invariant that can't be assumed to hold at the time of observation doesn't buy you anything.
2023-02-28 23:52:03 +0100 <Ashkan> hpc Oh I see, the `TVar` vs `MVar` . I believe I'm better of with the safer option so `TVar` for now:D
2023-02-28 23:52:05 +0100 <hpc> like if you have lots of reads, it's silly to have MVar's locking
2023-02-28 23:53:14 +0100 <hpc> ph88: i guess you're running into that you don't know statically if a connect succeeded
2023-02-28 23:53:33 +0100 <hpc> so you can't really produce one or the other, and you can't express it in the type either
2023-02-28 23:54:02 +0100 <ph88> hpc, no i don't know that statically .. but i would only like to allow those two options as valid state. I was thinking about making it an Either
2023-02-28 23:54:05 +0100 <Ashkan> hpc I see your point. The actual usage profile is to be seen. The idea is to share a central registry of sorts between threads that are spawn as clients make http calls to endpoints (`createGame` / `joinGame` / `listGames`) in Yesod
2023-02-28 23:54:13 +0100 <hpc> maybe, withConnection :: ConnectOptions -> (Server Connected k a) -> (Server ??? k a)?
2023-02-28 23:54:16 +0100 <hpc> or something
2023-02-28 23:54:55 +0100 <c_wraith> Ashkan: TVar use is more likely to run into thundering herd issues if you aren't careful with how you use them. but the compose cleanly with a very nice API, unlike MVars
2023-02-28 23:55:07 +0100zeenk(~zeenk@2a02:2f04:a20d:f900::7fe)
2023-02-28 23:55:13 +0100 <hpc> or maybe, withConnection :: ConnectOptions -> (Server Connected k a) -> (Server Defunct k a) -> (Server ??? k a)
2023-02-28 23:55:27 +0100 <ph88> hpc, Either was suggested on slide 34 / 35 here https://www.lambdadays.org/static/upload/media/1519637389130819oskarwickstromfinitestatemachines_.…
2023-02-28 23:55:28 +0100 <hpc> and then withConnection dynamically moves things through the right states
2023-02-28 23:55:54 +0100 <hpc> that works too, you'd need a data constructor that can satisfy that type
2023-02-28 23:56:05 +0100 <hpc> (for Server)
2023-02-28 23:56:06 +0100 <ph88> but then on slide 37 "Either would not work, only handles two"
2023-02-28 23:56:22 +0100 <ph88> ok i will try to remodel State type
2023-02-28 23:57:59 +0100 <Ashkan> c_wraith honestly not sure how things will turn out atm but I appreciate the heads up
2023-02-28 23:58:32 +0100 <segfaultfizzbuzz> [Leary]: realistically the core of a computer program will be stateful (such as a database) and mutable... and mutation means your invariants will break...
2023-02-28 23:58:38 +0100 <ph88> hpc, i think that doesn't work out https://bpa.st/ATWNO
2023-02-28 23:59:51 +0100 <[Leary]> segfaultfizzbuzz: "Break" /internally/. Not /observably/, from the outside.