IRCBrowse

2020/09/17

2020-09-17 00:00:11 +0200banner(~banner@116-255-17-98.ip4.superloop.com)
2020-09-17 00:00:49 +0200Rudd0(~Rudd0@185.189.115.98)
2020-09-17 00:02:11 +0200danvet(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa) (Ping timeout: 272 seconds)
2020-09-17 00:02:17 +0200hekkaidekapus(~tchouri@gateway/tor-sasl/hekkaidekapus) (Remote host closed the connection)
2020-09-17 00:02:17 +0200tomboy64(~tomboy64@gateway/tor-sasl/tomboy64) (Remote host closed the connection)
2020-09-17 00:02:45 +0200hekkaidekapus(~tchouri@gateway/tor-sasl/hekkaidekapus)
2020-09-17 00:02:59 +0200tomboy64(~tomboy64@gateway/tor-sasl/tomboy64)
2020-09-17 00:02:59 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 258 seconds)
2020-09-17 00:03:13 +0200frdg(~user@pool-71-184-143-249.bstnma.fios.verizon.net)
2020-09-17 00:03:54 +0200 <frdg> what is a nice way to visit every element in a list and perform an IO () on every visit?
2020-09-17 00:04:07 +0200 <monochrom> mapM_
2020-09-17 00:04:18 +0200 <frdg> ok
2020-09-17 00:04:36 +0200WeaponX(~WeaponX@178.239.173.252)
2020-09-17 00:04:46 +0200 <monochrom> Example: mapM_ putStrLn ["1st line", "2nd line"]
2020-09-17 00:04:48 +0200kritzefitz(~kritzefit@212.86.56.80) (Remote host closed the connection)
2020-09-17 00:06:20 +0200WeaponX(~WeaponX@178.239.173.252) (Quit: Leaving)
2020-09-17 00:06:26 +0200MorrowM(~max@147.161.8.74) (Ping timeout: 258 seconds)
2020-09-17 00:06:32 +0200 <hpc> it may also be more comfortable to do forM_ ["1st line", "2nd line"] $ do {...}
2020-09-17 00:06:50 +0200HarveyPwca(~HarveyPwc@c-98-220-98-201.hsd1.il.comcast.net)
2020-09-17 00:07:53 +0200 <monochrom> you missed a lambda. forM_ ["1st line", "2nd line"] $ \x -> do {...}
2020-09-17 00:08:04 +0200rihards(~rihards@balticom-142-78-50.balticom.lv) (Quit: rihards)
2020-09-17 00:09:02 +0200irc_user(uid423822@gateway/web/irccloud.com/x-cbxmaikgpxapbiip)
2020-09-17 00:09:20 +0200rihards(~rihards@balticom-142-78-50.balticom.lv)
2020-09-17 00:09:56 +0200 <hpc> oh yeah, i did
2020-09-17 00:11:59 +0200 <Boarders> I was getting a seg fault in my code which read from a file of size 10^9 bytes into a buffer which went away when I upgraded from ghc-8.6.5 to ghc-8.10.1. Does anyone know of any change that could have caused that? I was also using SIMD operations if that is even slightly relevant.
2020-09-17 00:12:07 +0200rihards(~rihards@balticom-142-78-50.balticom.lv) (Client Quit)
2020-09-17 00:12:33 +0200 <Graypup_> Boarders, it would probably be very computationally unpleasant but you could bisect it :P
2020-09-17 00:13:09 +0200justanotheruser(~justanoth@unaffiliated/justanotheruser)
2020-09-17 00:13:42 +0200 <monochrom> Knowing how ghc-8.8.x fares may help.
2020-09-17 00:14:35 +0200 <Boarders> I was hoping someone familiar with gritter details of ghc dev might have some hunches for the answer
2020-09-17 00:14:36 +0200carlomagno(~cararell@inet-hqmc01-o.oracle.com) (Remote host closed the connection)
2020-09-17 00:14:39 +0200carlomagno1(~cararell@inet-hqmc02-o.oracle.com)
2020-09-17 00:15:41 +0200 <sm[m]> Boarders: maybe check changelogs between the ghc versions and between the package versions
2020-09-17 00:15:52 +0200whataday(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2020-09-17 00:16:28 +0200nan`(~nan`@unaffiliated/nan/x-5405850)
2020-09-17 00:16:33 +0200 <Graypup_> what did my debugging book say .... "quit thinking and look"
2020-09-17 00:16:44 +0200frdg(~user@pool-71-184-143-249.bstnma.fios.verizon.net) (Remote host closed the connection)
2020-09-17 00:16:59 +0200whataday(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2020-09-17 00:17:53 +0200whataday(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Read error: Connection reset by peer)
2020-09-17 00:18:59 +0200whataday(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2020-09-17 00:19:20 +0200mananamenos(~mananamen@84.122.202.215.dyn.user.ono.com)
2020-09-17 00:19:21 +0200mananamenos(~mananamen@84.122.202.215.dyn.user.ono.com) (Read error: Connection reset by peer)
2020-09-17 00:19:28 +0200hackageorthotope 0.1.0.0 - Multidimensional arrays inspired by APL https://hackage.haskell.org/package/orthotope-0.1.0.0 (LennartAugustsson)
2020-09-17 00:20:15 +0200mdunnio(~mdunnio@208.59.170.5)
2020-09-17 00:21:29 +0200nan`(~nan`@unaffiliated/nan/x-5405850) (Ping timeout: 260 seconds)
2020-09-17 00:23:05 +0200banner(~banner@116-255-17-98.ip4.superloop.com) (Ping timeout: 272 seconds)
2020-09-17 00:23:26 +0200g-belmonte(~g-belmont@2804:14c:8786:9312:3638:eaf5:dc36:146d) (Quit: Leaving)
2020-09-17 00:24:49 +0200lembot(~lembot@179.8.176.163) (Ping timeout: 264 seconds)
2020-09-17 00:24:59 +0200mdunnio(~mdunnio@208.59.170.5) (Ping timeout: 272 seconds)
2020-09-17 00:26:48 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 244 seconds)
2020-09-17 00:27:56 +0200aarvar(~foewfoiew@50.35.43.33)
2020-09-17 00:28:33 +0200asdfasdfasdf(339a7d12@51.154.125.18) (Remote host closed the connection)
2020-09-17 00:30:19 +0200nan`(~nan`@unaffiliated/nan/x-5405850)
2020-09-17 00:32:46 +0200rprije(~rprije@27.143.220.203.dial.dynamic.acc01-myal-dub.comindico.com.au)
2020-09-17 00:33:09 +0200josh(~josh@c-67-164-104-206.hsd1.ca.comcast.net) (K-Lined)
2020-09-17 00:34:29 +0200wroathe(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 00:37:01 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 00:37:21 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-09-17 00:37:43 +0200oo_miguel(~miguel@89-72-187-203.dynamic.chello.pl)
2020-09-17 00:37:43 +0200heatsink(~heatsink@2600:1700:bef1:5e10:99ca:18ad:4e5f:ffdf) (Remote host closed the connection)
2020-09-17 00:38:02 +0200gmt(~gmt@pool-71-105-108-44.nycmny.fios.verizon.net) (Ping timeout: 260 seconds)
2020-09-17 00:39:40 +0200tom__(~tom@host86-169-79-54.range86-169.btcentralplus.com)
2020-09-17 00:39:43 +0200zincy__(~tom@2a00:23c8:970a:3501:38a6:4546:df42:c1cb) (Remote host closed the connection)
2020-09-17 00:47:55 +0200grant(~dead10cc@2607:fea8:2c60:2d2:b401:59a1:1f1b:bfe)
2020-09-17 00:50:38 +0200nan`(~nan`@unaffiliated/nan/x-5405850) (Ping timeout: 260 seconds)
2020-09-17 00:51:56 +0200dead10cc(~dead10cc@2607:fea8:2c60:2d2:b401:59a1:1f1b:bfe) (Ping timeout: 240 seconds)
2020-09-17 00:52:46 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 00:55:17 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb)
2020-09-17 00:57:17 +0200sfvm(~sfvm@37.228.215.148)
2020-09-17 00:57:30 +0200acidjnk_new3(~acidjnk@p200300d0c736587164f46f145ae9b6a7.dip0.t-ipconnect.de)
2020-09-17 00:57:55 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 00:57:59 +0200Turmfalke(~user@unaffiliated/siracusa) (Quit: Bye!)
2020-09-17 00:58:57 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net) (Ping timeout: 258 seconds)
2020-09-17 00:59:57 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 244 seconds)
2020-09-17 01:00:02 +0200grant(~dead10cc@2607:fea8:2c60:2d2:b401:59a1:1f1b:bfe) ("Konversation terminated!")
2020-09-17 01:00:23 +0200acidjnk_new2(~acidjnk@p200300d0c73658171887db1a128e4af1.dip0.t-ipconnect.de) (Ping timeout: 244 seconds)
2020-09-17 01:00:32 +0200lep-delete(~lep@94.31.82.44)
2020-09-17 01:03:15 +0200heatsink(~heatsink@2600:1700:bef1:5e10:99ca:18ad:4e5f:ffdf)
2020-09-17 01:03:34 +0200shutdown_-h_now(~arjan@2001:1c06:2d0b:2312:81d1:c87b:121a:a256) (Ping timeout: 244 seconds)
2020-09-17 01:04:25 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Ping timeout: 240 seconds)
2020-09-17 01:05:30 +0200__Joker(~Joker@180.151.106.108)
2020-09-17 01:09:47 +0200__Joker(~Joker@180.151.106.108) (Ping timeout: 240 seconds)
2020-09-17 01:10:17 +0200Tops2(~Tobias@dyndsl-095-033-025-182.ewe-ip-backbone.de) (Ping timeout: 246 seconds)
2020-09-17 01:12:21 +0200wroathe(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net)
2020-09-17 01:12:29 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 272 seconds)
2020-09-17 01:13:30 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 01:16:27 +0200nan`(~nan`@unaffiliated/nan/x-5405850)
2020-09-17 01:18:10 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 01:19:25 +0200falafel(~falafel@2605:e000:1527:d491:f090:20fe:cddf:2a1a) (Ping timeout: 240 seconds)
2020-09-17 01:21:25 +0200__Joker(~Joker@180.151.106.108)
2020-09-17 01:21:28 +0200nan`(~nan`@unaffiliated/nan/x-5405850) (Ping timeout: 272 seconds)
2020-09-17 01:21:40 +0200Cthalupa(~cthulhu@47.186.39.187) (Ping timeout: 256 seconds)
2020-09-17 01:22:59 +0200xerox_(~xerox@unaffiliated/xerox) (Ping timeout: 240 seconds)
2020-09-17 01:23:23 +0200mitchellsalad_(uid40617@gateway/web/irccloud.com/x-wopqfurhxhollxgh)
2020-09-17 01:24:21 +0200Cthalupa(~cthulhu@47.186.39.187)
2020-09-17 01:24:55 +0200board_control(~board_con@50-46-195-209.evrt.wa.frontiernet.net)
2020-09-17 01:26:06 +0200__Joker(~Joker@180.151.106.108) (Ping timeout: 260 seconds)
2020-09-17 01:28:13 +0200lembot(~lembot@179.8.176.163)
2020-09-17 01:28:28 +0200darjeeling_(~darjeelin@115.215.41.222) (Ping timeout: 256 seconds)
2020-09-17 01:30:21 +0200justanotheruser(~justanoth@unaffiliated/justanotheruser) (Ping timeout: 244 seconds)
2020-09-17 01:31:25 +0200borne(~fritjof@200116b864b6860060095f4622ae75c8.dip.versatel-1u1.de) (Ping timeout: 240 seconds)
2020-09-17 01:34:08 +0200son0p(~son0p@181.136.122.143) (Quit: Lost terminal)
2020-09-17 01:34:24 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 01:34:30 +0200oo_miguel(~miguel@89-72-187-203.dynamic.chello.pl) (Quit: WeeChat 2.3)
2020-09-17 01:35:55 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net) (Ping timeout: 272 seconds)
2020-09-17 01:35:59 +0200faker(bd0f81a2@189.15.129.162) (Remote host closed the connection)
2020-09-17 01:38:30 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-09-17 01:39:10 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 01:40:21 +0200asan(~yan4138@114.84.148.80) (Ping timeout: 272 seconds)
2020-09-17 01:40:36 +0200asan(~yan4138@114.84.148.87)
2020-09-17 01:40:39 +0200z0(~z0@bl15-162-186.dsl.telepac.pt)
2020-09-17 01:43:43 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2020-09-17 01:44:45 +0200Qez(52249602@cpc142018-dudl15-2-0-cust513.16-1.cable.virginm.net)
2020-09-17 01:45:24 +0200ddere(uid110888@gateway/web/irccloud.com/x-hxjfplopujbdeyav)
2020-09-17 01:49:27 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb)
2020-09-17 01:49:40 +0200darjeeling_(~darjeelin@115.215.41.222)
2020-09-17 01:52:32 +0200fresheyeball(~isaac@c-71-237-105-37.hsd1.co.comcast.net) (Quit: WeeChat 2.7.1)
2020-09-17 01:54:25 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 240 seconds)
2020-09-17 01:54:44 +0200Synthetica(uid199651@gateway/web/irccloud.com/x-phuwzqugvujuneob) (Quit: Connection closed for inactivity)
2020-09-17 01:55:12 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 01:58:17 +0200xerox_(~xerox@unaffiliated/xerox)
2020-09-17 02:00:02 +0200Suntop1(~Suntop@217.146.82.202) ()
2020-09-17 02:00:11 +0200ryansmccoy(~ryansmcco@193.37.254.27)
2020-09-17 02:00:13 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 264 seconds)
2020-09-17 02:01:45 +0200Qez(52249602@cpc142018-dudl15-2-0-cust513.16-1.cable.virginm.net) (Ping timeout: 245 seconds)
2020-09-17 02:02:42 +0200jumper149(~jumper149@ip185225.wh.uni-hannover.de) (Quit: WeeChat 2.9)
2020-09-17 02:07:40 +0200twopoint718(~cjw@fsf/member/twopoint718) (Quit: Textual IRC Client: www.textualapp.com)
2020-09-17 02:11:51 +0200wroathe_(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-09-17 02:13:17 +0200wroathe(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 02:13:34 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-09-17 02:15:51 +0200mariatsji(~mariatsji@155.84-234-177.customer.lyse.net)
2020-09-17 02:16:04 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 02:16:20 +0200josh(~josh@c-67-164-104-206.hsd1.ca.comcast.net)
2020-09-17 02:16:23 +0200wroathe_(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 02:16:30 +0200ryansmccoy(~ryansmcco@193.37.254.27) (Ping timeout: 260 seconds)
2020-09-17 02:16:38 +0200 <glguy> Hi, josh. Glad you could make it.
2020-09-17 02:18:06 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-09-17 02:20:22 +0200mariatsji(~mariatsji@155.84-234-177.customer.lyse.net) (Ping timeout: 272 seconds)
2020-09-17 02:20:42 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 02:21:06 +0200mdunnio(~mdunnio@208.59.170.5)
2020-09-17 02:23:32 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 02:24:47 +0200nan`(~nan`@unaffiliated/nan/x-5405850)
2020-09-17 02:26:04 +0200mdunnio(~mdunnio@208.59.170.5) (Ping timeout: 272 seconds)
2020-09-17 02:27:33 +0200justanotheruser(~justanoth@unaffiliated/justanotheruser)
2020-09-17 02:29:52 +0200nan`(~nan`@unaffiliated/nan/x-5405850) (Ping timeout: 272 seconds)
2020-09-17 02:32:14 +0200 <lc_> what's up justanotheruser. How ya been?
2020-09-17 02:32:50 +0200cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 02:34:55 +0200frdg(~user@pool-71-184-143-249.bstnma.fios.verizon.net)
2020-09-17 02:35:01 +0200spew(uid195861@gateway/web/irccloud.com/x-hbqiwomwemzgybnr) (Quit: Connection closed for inactivity)
2020-09-17 02:36:56 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 02:38:54 +0200gmt(~gmt@pool-71-105-108-44.nycmny.fios.verizon.net)
2020-09-17 02:40:31 +0200Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi) (Ping timeout: 272 seconds)
2020-09-17 02:41:22 +0200eric_(~eric@2804:431:c7d4:b75:19f7:ea85:5be8:4c8e)
2020-09-17 02:41:47 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 02:42:59 +0200HarveyPwca(~HarveyPwc@c-98-220-98-201.hsd1.il.comcast.net) (Quit: Leaving)
2020-09-17 02:43:36 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb)
2020-09-17 02:43:37 +0200 <sshine> monochrom, is there a good reason to use forM_ instead of for_?
2020-09-17 02:43:50 +0200 <monochrom> No.
2020-09-17 02:44:05 +0200 <sshine> ok, so it was just for the mapM_ <-> forM_ correspondence.
2020-09-17 02:44:25 +0200 <sshine> :t for_
2020-09-17 02:44:27 +0200 <lambdabot> (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
2020-09-17 02:44:50 +0200eric(~eric@2804:431:c7d4:b75:f492:17b0:3087:5bcd) (Ping timeout: 244 seconds)
2020-09-17 02:45:03 +0200 <monochrom> It's simpler than that. Different people learned different names, and first impressions are always the strongest.
2020-09-17 02:45:37 +0200 <dolio> I learned all the names before Applicative even existed, but I like the Applicative names better. :þ
2020-09-17 02:45:38 +0200 <ski> `Applicative' wasn't superclass of `Monad', back then
2020-09-17 02:46:30 +0200 <monochrom> Always look for human factors and social reasons before looking for technical reasons.
2020-09-17 02:46:45 +0200 <monochrom> Programmers are artisan humans not scientific robots.
2020-09-17 02:47:00 +0200 <monochrom> Oh I do wish programmers were scientific robots.
2020-09-17 02:47:36 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 272 seconds)
2020-09-17 02:47:38 +0200 <justanotheruser> lc_: hi whos this
2020-09-17 02:48:10 +0200 <lc_> just a friendly guy
2020-09-17 02:48:20 +0200 <justanotheruser> ok
2020-09-17 02:48:22 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 244 seconds)
2020-09-17 02:50:40 +0200 <sshine> I consider myself better of being a bayesian inference machine.
2020-09-17 02:50:50 +0200 <monochrom> Another good example is why Prelude has the head-tail couple, and why tail [] = undefined, and why they are neither a safeHead-safeTail couple nor a "listAnalysis z _ [] = z; listAnalysis _ f (x:xs) = f x xs" function like maybe and either.
2020-09-17 02:50:52 +0200 <sshine> I get to defy logic in completely subjective corner cases.
2020-09-17 02:51:01 +0200 <sshine> robots are doomed to repeat their program.
2020-09-17 02:52:15 +0200 <monochrom> It is because when the committee formed and sat down to write Prelude, the lot of them was from Lisp backgrounds and their first instinct was to replicate Lisp's car and cdr.
2020-09-17 02:53:01 +0200 <monochrom> And because of that background, they totally expected the head-tail couple would be very popular among users.
2020-09-17 02:53:04 +0200 <sshine> I thought the Lisp guys branched off to form the ML cult of which Haskell is more closely related?
2020-09-17 02:53:22 +0200 <monochrom> It is clearly technically inferior, and equally clearly socially popular.
2020-09-17 02:53:27 +0200 <sshine> SML has hd/tl, too.
2020-09-17 02:54:19 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-09-17 02:55:55 +0200 <monochrom> And I guess s/scientific robots/utilitarian robots/
2020-09-17 02:56:11 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 02:58:36 +0200Plazma(~Plazma@freenode/staff-emeritus/plazma)
2020-09-17 02:59:33 +0200 <monochrom> ML taught us the valuable lesson that pattern matching trumps head-tail, and after you have pattern matching you can pretty much throw away head-tail. A committee for a new language and its new library, having their chance to start from a clean slate, if they had really learned that lesson, you would think they would reflect this new value by omitting head-tail in their clean slate new library no?
2020-09-17 02:59:42 +0200falafel(~falafel@2605:e000:1527:d491:f090:20fe:cddf:2a1a)
2020-09-17 02:59:44 +0200justanotheruser(~justanoth@unaffiliated/justanotheruser) (Ping timeout: 244 seconds)
2020-09-17 03:00:18 +0200banner(~banner@116-255-17-98.ip4.superloop.com)
2020-09-17 03:00:30 +0200 <monochrom> That they totally (anti-pun!) didn't do it shows that the influence of social inertia trumps the influence of technical superiority.
2020-09-17 03:00:54 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 03:03:00 +0200 <josh> thanks, glguy. Glad to be here
2020-09-17 03:03:51 +0200 <Plazma> apologies if this has been brought up before or beaten to death but i came across this - https://www.stephendiehl.com/posts/crypto.html and it seems to be more of a negative against the community vs the language itself.. or did i read it incorrectly
2020-09-17 03:05:24 +0200 <sm[m]> Plazma: there's some discussion of it on /r/haskell and hacker news
2020-09-17 03:05:41 +0200 <josh> "the influence of social inertia trumps the influence of technical superiority" is the story of my Haskell life
2020-09-17 03:06:05 +0200banner(~banner@116-255-17-98.ip4.superloop.com) (Remote host closed the connection)
2020-09-17 03:06:31 +0200 <Plazma> i didn't realize social stuff was such a key part of using/loving a language
2020-09-17 03:06:36 +0200 <Axman6> it's negative about a view of some of the industrial uses of Haskell. I happen to work for a company which is using blockchain/DLT to build non-cryptocurrency stuff so I found the lumping of everyone with anyone who had anything to do with blockchain pretty disappointing and somewhat uninformed (though that's the same of most discussions of blockchain, everyone thinks it means cryptocurrency and boiling the oceans)
2020-09-17 03:07:33 +0200 <Plazma> Axman6: i've not worked with blockchain but i collaborate with some blockchain folks also (i'm a quantum guy) , and it's a similar story,, they aren't all trying to necessarily start their own cryptocurrency
2020-09-17 03:07:38 +0200elliott_(~elliott_@pool-71-114-77-65.washdc.fios.verizon.net) (Read error: Connection reset by peer)
2020-09-17 03:07:40 +0200 <Plazma> many are just exploring the waters
2020-09-17 03:07:52 +0200 <MarcelineVQ> It barely mentions haskell and baffles me why it's called a haskell elephant
2020-09-17 03:07:59 +0200elliott_(~elliott_@pool-71-114-77-65.washdc.fios.verizon.net)
2020-09-17 03:08:11 +0200 <monochrom> Hey I heard lately that Microsoft is going to be literally boiling the ocean, or at least seas, by putting data centres undersea.
2020-09-17 03:08:13 +0200 <Axman6> Plazma: it's not, I think a lot of the community found the article pretty extreme, particularly when the targer was IOHK, possibly (IMO) one of the least bad players in the cryptocurrency market. (I don't work for IOHK, but do know several people who do)
2020-09-17 03:08:33 +0200 <Plazma> MarcelineVQ: see that'w hat i noticed too.. like what the actual hell is he going on about haskell ? he's not..
2020-09-17 03:08:46 +0200 <Axman6> monochrom: heating the oceans is much more efficient if we avoid the wasteful atmospheric warming step :P
2020-09-17 03:09:12 +0200 <monochrom> The benefit is 90% reduction in failure rate.
2020-09-17 03:09:23 +0200 <Plazma> thermal physics is a signed integer, so we just need to heat it so much it rolls over to cooling through natural means
2020-09-17 03:09:54 +0200systemhalted(~aqualogic@71-129-231-253.lightspeed.rcsntx.sbcglobal.net)
2020-09-17 03:09:56 +0200 <monochrom> It looks like the new failure rate is so slow, they won't bother to repair a failed unit, just submerge a new one.
2020-09-17 03:10:08 +0200 <monochrom> s/slow/low/
2020-09-17 03:10:15 +0200jedws(~jedws@101.184.189.58)
2020-09-17 03:10:53 +0200systemhalted(~aqualogic@71-129-231-253.lightspeed.rcsntx.sbcglobal.net) (Remote host closed the connection)
2020-09-17 03:11:13 +0200 <MarcelineVQ> "why crypto is badong" would have been a better, though less publicly shared, title
2020-09-17 03:11:33 +0200xff0x_(~fox@2001:1a81:52d0:6b00:7599:d48:f5dc:5fef) (Ping timeout: 272 seconds)
2020-09-17 03:11:34 +0200 <Plazma> Axman6: yea i mean a source i trust sent me that basically telling me to stay away from haskell or learning it, but it makes no mention of haskell really , at all as a language .. just that some guy may have used some shit for it to do shady things
2020-09-17 03:11:40 +0200 <MarcelineVQ> "I don't like that some effort in haskell goes towards crypto currencies" ok. "haskell as an ecosystem and community has sold its soul to the devil" umm...
2020-09-17 03:12:12 +0200 <Axman6> Plazma: your friend seems equally uninformed then :P
2020-09-17 03:12:26 +0200 <Plazma> i mean malware is often written in C/win32 api stuff, someitmes C++ for ransomware, but we don't chastise C++ for that, we chastise it for every other reason
2020-09-17 03:12:41 +0200 <Plazma> i mostly just wanted to make sure i didn't misinterpret it
2020-09-17 03:12:51 +0200 <Plazma> Axman6: he didn't convince me at all with that article
2020-09-17 03:12:57 +0200xff0x_(~fox@2001:1a81:5306:e200:7599:d48:f5dc:5fef)
2020-09-17 03:13:05 +0200 <Axman6> there are definitely better technological and community reasons to avoid Haskell than some companies are using it for cryptocurrency development
2020-09-17 03:13:44 +0200 <monochrom> We chastise C for the equal and opposite reason. That C makes it easy to write programs that are vulnerable.
2020-09-17 03:14:24 +0200 <Plazma> monochrom: exactly.. scanf() just to name a simple/easy one
2020-09-17 03:14:35 +0200 <monochrom> I.e., while we don't chastise C for aggressors being written in C, we do chastise C for victims being written in C.
2020-09-17 03:14:47 +0200 <monochrom> Hey wait a second, does that count as blaming the victim? >:)
2020-09-17 03:14:52 +0200 <Axman6> for me, a big one is we seem to really struggle to develop projects as a community, we rely on a lot of single person efforts (edwardk's bus factor is astronomical). One of the few prohjects I've seen do a decent job in Haskell as building some sort of community is Servant
2020-09-17 03:15:16 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 03:15:19 +0200 <Plazma> monochrom: you're not on trial here :)
2020-09-17 03:15:30 +0200da39a3ee5e6b4b0d(~textual@2403:6200:8876:37d7:7100:a9d6:e349:d9ad)
2020-09-17 03:15:38 +0200 <Axman6> like I look at Rust and they seem be quite good at having projects which the community contributes to and progress is made quite quickly
2020-09-17 03:15:46 +0200 <Plazma> ahh i see
2020-09-17 03:16:04 +0200 <Plazma> i guess that's whewre community is kind of important..
2020-09-17 03:16:51 +0200 <Axman6> we do have an incredibly supportive community though, people will fall over themselves to help you learn something
2020-09-17 03:17:48 +0200 <MarcelineVQ> Even into a pit of spikes
2020-09-17 03:18:04 +0200 <Axman6> We're also starting to see some decent commercial use and support
2020-09-17 03:19:59 +0200bitmagie(~Thunderbi@200116b8063aa600b5d933e791b8d0ae.dip.versatel-1u1.de)
2020-09-17 03:20:52 +0200 <Plazma> so i guess in short that article is an opinion piece and worthless for most things
2020-09-17 03:20:56 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-09-17 03:21:27 +0200 <Axman6> that depends on your opinion I think :)
2020-09-17 03:21:52 +0200 <Plazma> i'm new so i don't have any , but the fact they don't mention anything remotely technical it's just some dribble to me
2020-09-17 03:22:03 +0200bitmagie(~Thunderbi@200116b8063aa600b5d933e791b8d0ae.dip.versatel-1u1.de) (Client Quit)
2020-09-17 03:22:09 +0200 <MarcelineVQ> For me there's nothing specific enough to be useful _about haskell_ in that article
2020-09-17 03:22:09 +0200 <Plazma> no offense to the guy personaly, i'm sure he's great and accomplished
2020-09-17 03:22:15 +0200__Joker(~Joker@180.151.106.108)
2020-09-17 03:23:51 +0200 <Axman6> it's not like all of the sommercial use of Haskell is in cryptocurrencies either, by a long shot. there's quite a lot of use in finance., Facebook has their spam detection system written in it, GitHub are using it for their new Semantic (IIRC) project, and several sproduct and contract companies
2020-09-17 03:24:31 +0200 <Axman6> Plazma: Don't write off everything he's written because of that article though, his What I Wish I Knew When Learning Haskell is incredibly valuable
2020-09-17 03:24:48 +0200 <Plazma> Axman6: yea actually i just discovered that too and was probably going to learn haskell better from it
2020-09-17 03:24:48 +0200elliott_(~elliott_@pool-71-114-77-65.washdc.fios.verizon.net) (Read error: Connection reset by peer)
2020-09-17 03:24:57 +0200 <Plazma> and some of his stuff and his company seem pretty legit
2020-09-17 03:25:07 +0200 <Plazma> he probably was just upset about that and wrote it
2020-09-17 03:25:24 +0200 <Plazma> he's not at all saying "don't learn haskell because of this" either, so
2020-09-17 03:25:31 +0200elliott_(~elliott_@pool-71-114-77-65.washdc.fios.verizon.net)
2020-09-17 03:25:31 +0200 <Plazma> my friend was probably just being overly opininoated
2020-09-17 03:25:37 +0200 <Plazma> (he told me to learn nim instead)
2020-09-17 03:26:41 +0200RusAlex(~Chel@unaffiliated/rusalex) (Ping timeout: 244 seconds)
2020-09-17 03:26:45 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 272 seconds)
2020-09-17 03:26:58 +0200__Joker(~Joker@180.151.106.108) (Ping timeout: 260 seconds)
2020-09-17 03:27:44 +0200RusAlex(~Chel@unaffiliated/rusalex)
2020-09-17 03:28:45 +0200aenesidemus(~aenesidem@c-73-53-247-25.hsd1.fl.comcast.net) (Read error: Connection reset by peer)
2020-09-17 03:29:15 +0200bakabiel(~bakabiel@79.104.200.71)
2020-09-17 03:29:29 +0200 <jchia> That article overgeneralizes things. Just because some 'crypto' stuff is bad doesn't mean all crypto stuff is bad. Just because some Haskell users do bad things doesn't mean the Haskell 'community' is bad. We don't do that kind of generalization for other languages. I don't understand how smart people can make this kind of overgeneralization mistakes.
2020-09-17 03:29:53 +0200banner(~banner@116-255-17-98.ip4.superloop.com)
2020-09-17 03:30:22 +0200urodna(~urodna@unaffiliated/urodna) (Quit: urodna)
2020-09-17 03:30:26 +0200 <Plazma> jchia: yea that's my conclusion too.. doesn't really make a lot of sense to me either
2020-09-17 03:30:42 +0200darjeeling_(~darjeelin@115.215.41.222) (Ping timeout: 260 seconds)
2020-09-17 03:30:53 +0200jbarnette(~jbarnette@185.204.1.185)
2020-09-17 03:31:40 +0200 <monochrom> Programmers seem to be more overgeneralizing than other people.
2020-09-17 03:32:09 +0200 <Plazma> i'm going to assume he was just emotional and upset and wrote it
2020-09-17 03:32:10 +0200 <monochrom> For example consider the "software engineer makes toaster" joke.
2020-09-17 03:32:11 +0200 <Plazma> and it got traction
2020-09-17 03:32:27 +0200 <Plazma> all i know is bread goes in, toast comes out... you can't explain that , man
2020-09-17 03:32:34 +0200elliott_(~elliott_@pool-71-114-77-65.washdc.fios.verizon.net) (Ping timeout: 272 seconds)
2020-09-17 03:32:58 +0200bakabiel(~bakabiel@79.104.200.71) (Client Quit)
2020-09-17 03:33:16 +0200wei2912(~wei2912@unaffiliated/wei2912)
2020-09-17 03:33:24 +0200 <monochrom> No no, it's a joke along the line of "a physicist, an engineer, and a programmer are each asked to make a toaster".
2020-09-17 03:33:26 +0200elliott_(~elliott_@pool-71-114-77-65.washdc.fios.verizon.net)
2020-09-17 03:33:26 +0200banner(~banner@116-255-17-98.ip4.superloop.com) (Remote host closed the connection)
2020-09-17 03:33:47 +0200 <Axman6> "Programmers seem to be more overgeneralizing than other people." so meta
2020-09-17 03:33:55 +0200 <monochrom> hahaha busted
2020-09-17 03:34:08 +0200 <jchia> he did say 'seems'
2020-09-17 03:34:26 +0200 <sm[m]> Axman6: there's good team work going on with ide tools lately
2020-09-17 03:34:36 +0200 <monochrom> So the joke goes on to say something funny but pretty OK on how a physicist would make a toaster, and how an engineer would make a toaster.
2020-09-17 03:34:57 +0200 <sm[m]> volunteer, gsoc, and company driven
2020-09-17 03:35:02 +0200 <MarcelineVQ> I just go down to the local library and use their toaster.
2020-09-17 03:36:02 +0200 <monochrom> The punchline is a very long sentence about how a programmer does it by going way overboard with the OOP kind of overgeneralization, plus a prophetic addition that the toast also connects to the Internet. (This joke was decades before the IoT movement.)
2020-09-17 03:36:41 +0200 <monochrom> a long sentence basically enumerating everything one does in OOP
2020-09-17 03:36:44 +0200 <Axman6> sm[m]: yeah that's true
2020-09-17 03:37:02 +0200olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber)
2020-09-17 03:37:06 +0200 <sm[m]> also haven't ghc, cabal, stack, hackage all involved quite a lot of cooperation
2020-09-17 03:37:38 +0200 <Plazma> monochrom: yo dawg i heard you like OOP and python so we put abstract classes in your classes , but they're not interfaces, but they are..
2020-09-17 03:37:47 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb)
2020-09-17 03:38:11 +0200__Joker(~Joker@180.151.106.108)
2020-09-17 03:40:12 +0200 <monochrom> Also consider that programmers have this saying "YAGNI" and other professions don't.
2020-09-17 03:40:41 +0200 <monochrom> We have it because we're doing poorly so we need this saying to warn ourselves.
2020-09-17 03:41:03 +0200 <monochrom> Other professions don't have it because they're already doing it right and don't need a warning.
2020-09-17 03:41:11 +0200 <sm[m]> KISS is a common saying
2020-09-17 03:41:35 +0200acidjnk_new3(~acidjnk@p200300d0c736587164f46f145ae9b6a7.dip0.t-ipconnect.de) (Ping timeout: 244 seconds)
2020-09-17 03:41:52 +0200 <monochrom> Well yeah OK so everyone else has one saying, we have two, we are still worse.
2020-09-17 03:42:16 +0200 <monochrom> Consider the possibility that KISS is not strong enough for us.
2020-09-17 03:42:31 +0200kleisli_(~kleisli@172-8-147-49.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 265 seconds)
2020-09-17 03:42:42 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 244 seconds)
2020-09-17 03:43:13 +0200__Joker(~Joker@180.151.106.108) (Ping timeout: 272 seconds)
2020-09-17 03:45:15 +0200MarcelineVQlearns the term yagni
2020-09-17 03:45:50 +0200 <sm[m]> Axman6: but I would agree that things usually don't seem to evolve very fast
2020-09-17 03:47:16 +0200 <sm[m]> that seems to be the Haskell way, often - it takes longer to build, but also lasts longer with less rework & maintenance ?
2020-09-17 03:47:51 +0200 <sm[m]> When tooling finally matures, perhaps that will change ?
2020-09-17 03:49:07 +0200 <monochrom> From what I saw, it doesn't take longer to build. Look at tomsmeding's paste site.
2020-09-17 03:49:10 +0200 <sm[m]> or.. the rust army is just much much bigger ? or.. they have more of an engineering and shipping focus ?
2020-09-17 03:49:47 +0200 <monochrom> But whenever more than one author is involved, it takes longer to reach consensus, because there are always more than one elegant way to do it, and they aren't compatible.
2020-09-17 03:50:30 +0200 <sm[m]> So we're like Lisp ? :-/
2020-09-17 03:51:12 +0200 <monochrom> Yes in this aspect.
2020-09-17 03:51:22 +0200 <monochrom> No in how many compilers to choose from.
2020-09-17 03:52:32 +0200 <sm[m]> monochrom: maybe as our libs, architectures, patterns mature, this will improve ?
2020-09-17 03:54:03 +0200 <monochrom> I wouldn't hold my breath.
2020-09-17 03:54:37 +0200Amras(~Amras@unaffiliated/amras0000) (Ping timeout: 272 seconds)
2020-09-17 03:55:32 +0200 <monochrom> Some convergence did happen in the past. transformers and mtl were in competition a long time ago, but one day they agreed to a partition of roles and worked together.
2020-09-17 03:56:03 +0200 <monochrom> pipes and conduit, I predict them to stay that way forever.
2020-09-17 03:56:12 +0200 <monochrom> cabal and stack, I predict them to stay that way forever.
2020-09-17 03:57:55 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-09-17 03:58:07 +0200falafel(~falafel@2605:e000:1527:d491:f090:20fe:cddf:2a1a) (Ping timeout: 244 seconds)
2020-09-17 03:58:13 +0200 <monochrom> Although, the pipes-conduit dichotomy is already a vast improvement compared to the long gone days of 3 choices of iteratees, 2 choices of enumeratees, and 5 choices of something in between.
2020-09-17 03:59:10 +0200lembot(~lembot@179.8.176.163) (Ping timeout: 272 seconds)
2020-09-17 04:00:20 +0200 <sm[m]> Yup
2020-09-17 04:00:43 +0200ransom(~c4264035@c-73-243-2-10.hsd1.co.comcast.net)
2020-09-17 04:00:51 +0200 <sm[m]> also, higher level frameworks will continue to improve
2020-09-17 04:02:20 +0200 <sm[m]> I think the ide tools are going to be impactful, they will attract more devs
2020-09-17 04:04:03 +0200 <sm[m]> vs code with hls 0.4 really works and is a real step up IME
2020-09-17 04:06:04 +0200Gurkenglas(~Gurkengla@unaffiliated/gurkenglas) (Ping timeout: 260 seconds)
2020-09-17 04:07:55 +0200theDon(~td@94.134.91.86) (Ping timeout: 272 seconds)
2020-09-17 04:08:20 +0200kleisli_(~kleisli@2605:e000:1804:94c6:68bd:9d76:dbd8:24e7)
2020-09-17 04:09:38 +0200theDon(~td@94.134.91.55)
2020-09-17 04:09:44 +0200shadowdaemon(~user@unaffiliated/shadowdaemon) (Remote host closed the connection)
2020-09-17 04:15:00 +0200lagothrix(~lagothrix@unaffiliated/lagothrix) (Killed (tolkien.freenode.net (Nickname regained by services)))
2020-09-17 04:15:08 +0200lagothrix(~lagothrix@unaffiliated/lagothrix)
2020-09-17 04:15:46 +0200 <sshine> yes
2020-09-17 04:16:00 +0200 <sshine> I didn't have to manually compile a file and copy it into VSCode's directory!
2020-09-17 04:17:55 +0200howdoi(uid224@gateway/web/irccloud.com/x-udrxcrwykbilfjcr) (Quit: Connection closed for inactivity)
2020-09-17 04:20:35 +0200drbean(~drbean@TC210-63-209-98.static.apol.com.tw)
2020-09-17 04:21:56 +0200mdunnio(~mdunnio@208.59.170.5)
2020-09-17 04:22:55 +0200shafox(~shafox@106.51.234.111)
2020-09-17 04:27:02 +0200mdunnio(~mdunnio@208.59.170.5) (Ping timeout: 272 seconds)
2020-09-17 04:27:07 +0200heatsink(~heatsink@2600:1700:bef1:5e10:99ca:18ad:4e5f:ffdf) (Remote host closed the connection)
2020-09-17 04:27:42 +0200nineonine(~nineonine@216.81.48.202) (Remote host closed the connection)
2020-09-17 04:31:55 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb)
2020-09-17 04:32:51 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 258 seconds)
2020-09-17 04:35:26 +0200tylerjl(~leothrix@elastic/staff/leothrix)
2020-09-17 04:36:55 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 240 seconds)
2020-09-17 04:38:07 +0200leothrix(~leothrix@elastic/staff/leothrix) (Ping timeout: 240 seconds)
2020-09-17 04:39:32 +0200asan(~yan4138@114.84.148.87) ()
2020-09-17 04:39:56 +0200asan(~yan4138@114.84.148.87)
2020-09-17 04:40:01 +0200 <frdg> how can I go from `Functor f => f (g (a)) -> g a` without pattern matching ?
2020-09-17 04:40:17 +0200 <frdg> err and `Functor g`
2020-09-17 04:40:36 +0200 <c_wraith> You can't just collapse them for any old pair of functors
2020-09-17 04:40:57 +0200 <frdg> oh
2020-09-17 04:41:55 +0200 <frdg> what about Traversables?
2020-09-17 04:42:25 +0200 <c_wraith> :t sequenceA
2020-09-17 04:42:27 +0200 <lambdabot> (Traversable t, Applicative f) => t (f a) -> f (t a)
2020-09-17 04:42:35 +0200 <c_wraith> that's as close as they'll get you
2020-09-17 04:42:51 +0200 <frdg> hmm
2020-09-17 04:43:16 +0200 <ski> @type asum
2020-09-17 04:43:18 +0200 <lambdabot> (Foldable t, Alternative f) => t (f a) -> f a
2020-09-17 04:44:11 +0200 <frdg> this should work.
2020-09-17 04:44:14 +0200 <c_wraith> Oh, yeah. If Alternative is good enough, that works
2020-09-17 04:45:31 +0200exodrifter(adacad5d@cpe-173-172-173-93.tx.res.rr.com)
2020-09-17 04:46:25 +0200robotmay(~beepboop@80.172.187.81.in-addr.arpa) (Quit: No Ping reply in 180 seconds.)
2020-09-17 04:47:08 +0200 <exodrifter> Does anyone happen to know if there's a Storable instance of Text floating around out there or how you'd generally represent UTF-8 in an FFI interface?
2020-09-17 04:47:58 +0200robotmay(~beepboop@80.172.187.81.in-addr.arpa)
2020-09-17 04:48:37 +0200 <c_wraith> text isn't even UTF-8
2020-09-17 04:49:24 +0200 <exodrifter> oh, unicode and utf-8 are not the same thing?
2020-09-17 04:49:30 +0200 <c_wraith> nope
2020-09-17 04:49:36 +0200 <c_wraith> unicode is a character set
2020-09-17 04:49:44 +0200 <c_wraith> utf8 is one way of encoding that character set in bytes
2020-09-17 04:50:43 +0200 <exodrifter> ah, I see. I assumed Text was UTF8 because of decodeUtf8, but that's just what character set to use for the bytestring
2020-09-17 04:50:55 +0200 <c_wraith> exactly
2020-09-17 04:51:15 +0200 <c_wraith> well. just what encoding to use for the bytestring.
2020-09-17 04:51:35 +0200 <exodrifter> yeah. what does it mean for Text to be unicode then? is it not any particular character set until you decide to encode it?
2020-09-17 04:52:04 +0200 <c_wraith> unicode is a character set. How the characters are represented inside a computer is an implementation detail
2020-09-17 04:52:58 +0200 <c_wraith> There are a bunch of ways to serialize it that are standardizes, though. UTF-8, UTF-16, and UCS4 are the options that give you the full unicode character set.
2020-09-17 04:53:03 +0200 <c_wraith> *standardized
2020-09-17 04:53:17 +0200 <exodrifter> so if i wanted to, say, encode a text into a utf-8 bytestring then marshall that representation out using FFI -- that wouldn't necessarily work because the memory representation might be different?
2020-09-17 04:53:23 +0200 <dolio> You could represent it other ways in a bytestring, too.
2020-09-17 04:53:47 +0200 <dolio> But you'd need to be careful.
2020-09-17 04:53:50 +0200 <c_wraith> Right. You should go through an explicit conversion to the correct encoding you want in a ByteString, then use useAsCString for the bytestring
2020-09-17 04:54:42 +0200machinedgod(~machinedg@d67-193-126-196.home3.cgocable.net) (Ping timeout: 260 seconds)
2020-09-17 04:54:57 +0200 <exodrifter> well, i want to have a foreign function call the haskell code, not the other way around, so useAsCString wouldn't work for what i'm trying to do.
2020-09-17 04:55:04 +0200 <c_wraith> Ah, ok.
2020-09-17 04:55:29 +0200Stanley00(~stanley00@unaffiliated/stanley00)
2020-09-17 04:55:45 +0200 <exodrifter> dolio: what do you mean exactly? represent it in what other ways?
2020-09-17 04:56:21 +0200 <dolio> You could have UTF-16 in a byte string, but each byte would be half of one of the basic units of the encoding.
2020-09-17 04:56:51 +0200 <dolio> Also it probably gives you more ways to mess up the endianness.
2020-09-17 04:56:59 +0200 <exodrifter> Ah, okay, yeah that makes sense
2020-09-17 04:57:25 +0200nineonine(~nineonine@216-19-190-182.dyn.novuscom.net)
2020-09-17 04:58:22 +0200 <exodrifter> so if the way the UTF-8 is represented is an implementation detail, is there then no way to marshall a UTF-8 string without implementing a decoder in the foreign code that knows how it's represented in haskell?
2020-09-17 04:59:32 +0200 <dolio> The foreign function is going to need to know the encoding used.
2020-09-17 04:59:44 +0200exodrifter(adacad5d@cpe-173-172-173-93.tx.res.rr.com) (Remote host closed the connection)
2020-09-17 04:59:48 +0200 <dolio> If it's UTF-8, it'll need to know that.
2020-09-17 05:00:01 +0200jbarnette(~jbarnette@185.204.1.185) ()
2020-09-17 05:00:51 +0200exodrifter(adacad5d@cpe-173-172-173-93.tx.res.rr.com)
2020-09-17 05:00:55 +0200alp_(~alp@2a01:e0a:58b:4920:557f:9e9f:2eef:4c23)
2020-09-17 05:01:38 +0200nineonine(~nineonine@216-19-190-182.dyn.novuscom.net) (Ping timeout: 246 seconds)
2020-09-17 05:01:58 +0200 <exodrifter> Hmm, okay. So if it knew the bytes were UTF-8, then it should be fine? I'm not sure if the UTF-8 standard defines how it would be represented in memory...
2020-09-17 05:02:18 +0200 <dolio> UTF-8 is a particular way of storing unicode.
2020-09-17 05:03:27 +0200 <exodrifter> Yes, so does that apply to in-memory? I'm aware that it would work for files, since i can usually open UTF-8 documents regardless of what computer i'm on.
2020-09-17 05:03:37 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-09-17 05:03:57 +0200 <dolio> It can be stored that way in memory, too. But Text doesn't.
2020-09-17 05:04:53 +0200 <exodrifter> sure. So I just need to encode the text into a UTF-8 bytestring, then figure out how to convert the bytestring into a CString, and that should work it sounds like
2020-09-17 05:04:55 +0200 <dolio> That's one of the resons there's `decodeUtf8`
2020-09-17 05:05:10 +0200 <dolio> Yeah, probably.
2020-09-17 05:05:39 +0200 <dolio> Although C doesn't necessarily know anything about UTF-8. That'd be up to libraries.
2020-09-17 05:06:20 +0200 <exodrifter> yeah, that makes sense. But, I'm assuming that if the user was using a library that had the equivalent of decodeUtf8 it should work
2020-09-17 05:06:55 +0200 <exodrifter> It's too bad ByteString doesn't expose a function that lets you return the CString... I'm looking at the implementation of it and i suuuuure don't understand it yet
2020-09-17 05:06:57 +0200 <dolio> And e.g. all sorts of Microsoft stuff uses UTF-16, I think.
2020-09-17 05:07:29 +0200 <exodrifter> I think i am satisfied limiting my use case to UTF-8.
2020-09-17 05:08:09 +0200heatsink(~heatsink@2600:1700:bef1:5e10:99ca:18ad:4e5f:ffdf)
2020-09-17 05:08:19 +0200 <dolio> Yeah, that's pretty safe.
2020-09-17 05:09:21 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 272 seconds)
2020-09-17 05:09:48 +0200 <exodrifter> oh -- i guess i don't really want a CString since I don't want to be limited by ascii. I want to return something more like an array of bytes or something.
2020-09-17 05:10:45 +0200 <exodrifter> ...wait, that is what byte is in c isn't it.
2020-09-17 05:10:47 +0200 <dolio> I think CString is a char pointer.
2020-09-17 05:10:58 +0200 <exodrifter> yeah, it's a char*
2020-09-17 05:14:19 +0200 <exodrifter> okay i think I know what i need to do. Thanks dolio & c_wraith <3
2020-09-17 05:19:58 +0200hackagesmash-lens 0.1.0.1 - Optics for the `smash` library https://hackage.haskell.org/package/smash-lens-0.1.0.1 (topos)
2020-09-17 05:20:58 +0200hackagesmash-optics 0.1.0.1 - Optics for the `smash` library using `optics-core` https://hackage.haskell.org/package/smash-optics-0.1.0.1 (topos)
2020-09-17 05:22:04 +0200finkata-(~dpetrov@83.222.188.39)
2020-09-17 05:26:06 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb)
2020-09-17 05:26:18 +0200eric_(~eric@2804:431:c7d4:b75:19f7:ea85:5be8:4c8e) (Remote host closed the connection)
2020-09-17 05:29:23 +0200mdunnio(~mdunnio@208.59.170.5)
2020-09-17 05:30:04 +0200sagax(~sagax_nb@213.138.71.146) (Ping timeout: 260 seconds)
2020-09-17 05:31:07 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 244 seconds)
2020-09-17 05:35:18 +0200toorevitimirp(~tooreviti@117.182.182.33)
2020-09-17 05:37:48 +0200elliott_(~elliott_@pool-71-114-77-65.washdc.fios.verizon.net) (Quit: Quit)
2020-09-17 05:37:51 +0200worc3131(~quassel@2a02:c7f:c026:9500:7d0b:65d0:38a4:4786) (Ping timeout: 272 seconds)
2020-09-17 05:38:12 +0200heatsink(~heatsink@2600:1700:bef1:5e10:99ca:18ad:4e5f:ffdf) (Remote host closed the connection)
2020-09-17 05:38:34 +0200gmt(~gmt@pool-71-105-108-44.nycmny.fios.verizon.net) (Ping timeout: 260 seconds)
2020-09-17 05:39:04 +0200__Joker(~Joker@180.151.106.108)
2020-09-17 05:39:10 +0200mdunnio(~mdunnio@208.59.170.5) (Ping timeout: 256 seconds)
2020-09-17 05:39:58 +0200hackagebase16-bytestring 1.0.0.0 - RFC 4648-compliant Base16 encodings for ByteStrings https://hackage.haskell.org/package/base16-bytestring-1.0.0.0 (topos)
2020-09-17 05:40:32 +0200board_control(~board_con@50-46-195-209.evrt.wa.frontiernet.net) (Quit: Leaving)
2020-09-17 05:40:49 +0200finkata-(~dpetrov@83.222.188.39) (Remote host closed the connection)
2020-09-17 05:42:33 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-09-17 05:43:32 +0200__Joker(~Joker@180.151.106.108) (Ping timeout: 256 seconds)
2020-09-17 05:44:50 +0200 <lemmih> topos: Woo, version 1.
2020-09-17 05:45:37 +0200ransom(~c4264035@c-73-243-2-10.hsd1.co.comcast.net) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-09-17 05:45:38 +0200 <MarcelineVQ> the madlad
2020-09-17 05:46:24 +0200ransom(~c4264035@c-73-243-2-10.hsd1.co.comcast.net)
2020-09-17 05:46:55 +0200 <topos> lemmih completely cleared out the backlog, basically rewrote the library and achieved some multipliers on performance
2020-09-17 05:46:58 +0200 <topos> so i'm happy
2020-09-17 05:48:00 +0200 <exodrifter> that sounds great!
2020-09-17 05:48:37 +0200alp_(~alp@2a01:e0a:58b:4920:557f:9e9f:2eef:4c23) (Ping timeout: 272 seconds)
2020-09-17 05:53:50 +0200 <lateef> hi does anyone know how to use tasty-discover with the rerun ingredient. can't find any examples
2020-09-17 05:54:17 +0200finkata-(~dpetrov@83.222.188.39)
2020-09-17 05:54:52 +0200finkata-finkata
2020-09-17 05:54:56 +0200__Joker(~Joker@180.151.106.108)
2020-09-17 05:55:24 +0200da39a3ee5e6b4b0d(~textual@2403:6200:8876:37d7:7100:a9d6:e349:d9ad) (Ping timeout: 244 seconds)
2020-09-17 05:55:28 +0200finkata(~dpetrov@83.222.188.39) (Remote host closed the connection)
2020-09-17 05:55:38 +0200wei2912(~wei2912@unaffiliated/wei2912) (Quit: Lost terminal)
2020-09-17 05:56:54 +0200finkata(~dpetrov@83.222.188.39)
2020-09-17 06:00:01 +0200__Joker(~Joker@180.151.106.108) (Ping timeout: 272 seconds)
2020-09-17 06:00:15 +0200banner(~banner@116-255-17-98.ip4.superloop.com)
2020-09-17 06:00:24 +0200banner(~banner@116-255-17-98.ip4.superloop.com) (Client Quit)
2020-09-17 06:00:48 +0200andreas303(~andreas@gateway/tor-sasl/andreas303) (Remote host closed the connection)
2020-09-17 06:01:24 +0200jneira(501e65ce@gateway/web/cgi-irc/kiwiirc.com/ip.80.30.101.206) (Ping timeout: 258 seconds)
2020-09-17 06:02:11 +0200Jeanne-Kamikaze(~Jeanne-Ka@107.152.99.41)
2020-09-17 06:02:28 +0200 <Axman6> topos: how many GB/s? :)
2020-09-17 06:02:33 +0200polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889) (Ping timeout: 272 seconds)
2020-09-17 06:02:48 +0200 <koz_> Axman6: The only measure that counts. :P
2020-09-17 06:02:50 +0200 <topos> ugh. i had that number at one point. hang on
2020-09-17 06:02:57 +0200finkata(~dpetrov@83.222.188.39) (Remote host closed the connection)
2020-09-17 06:02:57 +0200 <Axman6> koz_: of course
2020-09-17 06:03:10 +0200 <koz_> topos: Over 9000. :P
2020-09-17 06:03:13 +0200 <Axman6> though, speed for small strings is probably more important
2020-09-17 06:03:45 +0200unlink__(~unlink2@p200300ebcf25bd0068eb9d9c94da2a17.dip0.t-ipconnect.de) (Ping timeout: 244 seconds)
2020-09-17 06:06:39 +0200andreas303(~andreas@gateway/tor-sasl/andreas303)
2020-09-17 06:07:55 +0200falafel(~falafel@2605:e000:1527:d491:f090:20fe:cddf:2a1a)
2020-09-17 06:08:47 +0200irc_user(uid423822@gateway/web/irccloud.com/x-cbxmaikgpxapbiip) (Quit: Connection closed for inactivity)
2020-09-17 06:10:09 +0200mirrorbird(~psutcliff@2a00:801:44b:8959:8d6c:276b:332b:1c71) (Ping timeout: 272 seconds)
2020-09-17 06:10:34 +0200da39a3ee5e6b4b0d(~textual@2403:6200:8876:37d7:55fb:4d37:ffc2:715b)
2020-09-17 06:10:52 +0200mirrorbird(~psutcliff@2a00:801:44b:8959:8d6c:276b:332b:1c71)
2020-09-17 06:11:57 +0200jneira(501e65ce@gateway/web/cgi-irc/kiwiirc.com/ip.80.30.101.206)
2020-09-17 06:12:25 +0200testing_kirc(~testing_k@047-024-136-070.res.spectrum.com)
2020-09-17 06:13:23 +0200testing_kirc(~testing_k@047-024-136-070.res.spectrum.com) (Remote host closed the connection)
2020-09-17 06:15:16 +0200__Joker(~Joker@180.151.106.108)
2020-09-17 06:15:34 +0200sdx23(~sdx23@unaffiliated/sdx23) (Ping timeout: 260 seconds)
2020-09-17 06:15:38 +0200kleisli_(~kleisli@2605:e000:1804:94c6:68bd:9d76:dbd8:24e7) (Ping timeout: 244 seconds)
2020-09-17 06:16:18 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:59f2:1ee3:fe3e:b848)
2020-09-17 06:17:01 +0200day_(~Unknown@unaffiliated/day)
2020-09-17 06:17:05 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2020-09-17 06:19:57 +0200dbmikus(~dbmikus@cpe-76-167-86-219.natsow.res.rr.com)
2020-09-17 06:20:19 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb)
2020-09-17 06:20:37 +0200day(~Unknown@unaffiliated/day) (Ping timeout: 264 seconds)
2020-09-17 06:20:38 +0200day_day
2020-09-17 06:20:55 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:59f2:1ee3:fe3e:b848) (Ping timeout: 272 seconds)
2020-09-17 06:21:37 +0200 <topos> Axman6 https://pastebin.com/LEs9sBTx
2020-09-17 06:21:55 +0200 <topos> here's a bench of the old algo vs. the new algo for 1gb
2020-09-17 06:22:00 +0200nineonine(~nineonine@216-19-190-182.dyn.novuscom.net)
2020-09-17 06:22:54 +0200 <topos> encode is ~1GB/s, decode ~0.5GB/s compared to ~350MB/s (old encode) and ~120MB/s (old decode)
2020-09-17 06:23:31 +0200 <koz_> topos: So roughly threefold?
2020-09-17 06:23:34 +0200 <koz_> That's pretty damn good.
2020-09-17 06:23:38 +0200 <topos> yeah
2020-09-17 06:23:48 +0200 <topos> between 3-5 depending on the length of the bytestring
2020-09-17 06:23:50 +0200ddellacosta(~dd@86.106.121.168) (Ping timeout: 260 seconds)
2020-09-17 06:24:01 +0200 <topos> the old algo would degrade for larger bytestrings
2020-09-17 06:24:29 +0200 <topos> the new one is a steady ratio of encode ~ 2xdecode
2020-09-17 06:24:56 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 244 seconds)
2020-09-17 06:25:26 +0200 <topos> which makes sense because all you're doing in the encode step is reading a byte, munging it into two and writing it, where the decode case requires reading two, munging it, and then writing one
2020-09-17 06:25:34 +0200 <topos> oo. sorry for pinging whoever that was
2020-09-17 06:27:36 +0200banner(~banner@116-255-17-98.ip4.superloop.com)
2020-09-17 06:27:42 +0200 <Axman6> that's their problem :)
2020-09-17 06:28:22 +0200heatsink(~heatsink@2600:1700:bef1:5e10:99ca:18ad:4e5f:ffdf)
2020-09-17 06:28:29 +0200ransom(~c4264035@c-73-243-2-10.hsd1.co.comcast.net) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-09-17 06:29:20 +0200banner(~banner@116-255-17-98.ip4.superloop.com) (Client Quit)
2020-09-17 06:29:23 +0200 <Axman6> I really want to make this code work a word at a time...
2020-09-17 06:29:25 +0200falafel(~falafel@2605:e000:1527:d491:f090:20fe:cddf:2a1a) (Ping timeout: 240 seconds)
2020-09-17 06:29:42 +0200jjj(~jjj@195.206.169.184)
2020-09-17 06:29:52 +0200GuerrillaMonkey(~Jeanne-Ka@107.152.99.41)
2020-09-17 06:31:04 +0200 <topos> Axman6 i'd like to as well. The best I can think of is to make use of SIMD instructions, because at this point we can't do any better without the benefit of being able to multiple words into a single instruction
2020-09-17 06:31:35 +0200 <topos> but also, this code is dead. I'm not working on it anymore. It was strictly fanservice, and I'm encouraging everyone to move to https://hackage.haskell.org/package/base16
2020-09-17 06:31:56 +0200jedws(~jedws@101.184.189.58) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-09-17 06:32:00 +0200 <topos> if you want to contribute a SIMD version or AVX2 support, be my guest
2020-09-17 06:32:06 +0200 <topos> it won't happen on base16-bytestring tho
2020-09-17 06:32:21 +0200 <Axman6> you should have a ook at the PR I had on the text-utf8 repo for faster take/drop/indexing, it was roughly 100x faster than the streaming implementation and pretty much branchless
2020-09-17 06:32:28 +0200 <topos> ooo
2020-09-17 06:32:28 +0200Jeanne-Kamikaze(~Jeanne-Ka@107.152.99.41) (Ping timeout: 260 seconds)
2020-09-17 06:32:39 +0200Jeanne-Kamikaze(~Jeanne-Ka@static-198-54-131-92.cust.tzulo.com)
2020-09-17 06:32:47 +0200 <Axman6> but I never finished it off and it was probably too unclear to be maintainable
2020-09-17 06:32:54 +0200 <topos> https://github.com/text-utf8/text-utf8/pull/11 this guy?
2020-09-17 06:33:05 +0200 <koz_> topos: What're the numbers on that one?
2020-09-17 06:33:28 +0200 <topos> koz_ which one?
2020-09-17 06:33:33 +0200 <koz_> base16
2020-09-17 06:33:43 +0200 <koz_> For the same bench as you did for base16-bytestring.
2020-09-17 06:33:54 +0200 <Axman6> topos: https://github.com/text-utf8/text-utf8/pull/1
2020-09-17 06:33:54 +0200 <topos> ah i implemented the same algorithm
2020-09-17 06:33:58 +0200 <topos> so roughly the same
2020-09-17 06:34:09 +0200 <topos> ooo
2020-09-17 06:34:15 +0200sumo_r(0ec9fb69@14-201-251-105.tpgi.com.au)
2020-09-17 06:35:29 +0200GuerrillaMonkey(~Jeanne-Ka@107.152.99.41) (Ping timeout: 272 seconds)
2020-09-17 06:35:31 +0200 <koz_> Axman6: Is text-utf8 still a live project?
2020-09-17 06:35:41 +0200 <Axman6> I believe so...
2020-09-17 06:36:00 +0200 <topos> koz_ the only difference is that I provide a nicer general interface and more support for different types like Text, ShortText, and SHortByteString
2020-09-17 06:36:07 +0200mrte(~mrt@p4fcabee7.dip0.t-ipconnect.de) (Ping timeout: 272 seconds)
2020-09-17 06:36:21 +0200 <siraben> Does MTL use strict or lazy state monad by default?
2020-09-17 06:36:33 +0200 <siraben> Is strict just better space usage wise than lazy?
2020-09-17 06:36:56 +0200 <topos> Axman6 this is cool stuff :)
2020-09-17 06:37:03 +0200 <Axman6> hasn't been touched in a while though, hvr would be the best one to answer whether it's live though
2020-09-17 06:37:31 +0200 <topos> siraben lazy state - https://github.com/haskell/mtl/blob/master/Control/Monad/State.hs
2020-09-17 06:37:33 +0200 <Axman6> siraben: I believe lazy is the default, but that should be easy to check in the source
2020-09-17 06:37:54 +0200 <siraben> Ah I see. When should I use strict/lazy state? I've been using lazy all along then.
2020-09-17 06:37:56 +0200 <koz_> I always specify Control.Monad.State.Strict just to be safe when I import.
2020-09-17 06:38:09 +0200 <Axman6> the differences between lazy and strict is... one is lazy and one is strict, they have different semantics and there are things you can do in the lazy one which you can't do in the strict one
2020-09-17 06:38:11 +0200 <koz_> (better be explicit, even if it's just for other folks reading)
2020-09-17 06:38:28 +0200 <topos> but remember, Strict is better in some ways, but remember that strict state is (confusingly) not strict in its setting, so you still need to `put $! <thing>` if you need it evaluated
2020-09-17 06:38:48 +0200 <topos> i munged sentences sorry
2020-09-17 06:39:56 +0200heatsink(~heatsink@2600:1700:bef1:5e10:99ca:18ad:4e5f:ffdf) (Remote host closed the connection)
2020-09-17 06:40:25 +0200 <siraben> I see.
2020-09-17 06:40:35 +0200 <siraben> And what's the difference between Control.Monad.Error and Control.Monad.Except?
2020-09-17 06:40:52 +0200 <sumo_r> Hi all, does anyone know what the ghcxxxx.exe file created in AppData\Local\Temp on windows by cabal repl are? M365 just flagged one of those (ghcbdbc.exe) as Wacatac malware and our admin pinged me for more details
2020-09-17 06:40:59 +0200 <topos> siraben error is deprecated, use except
2020-09-17 06:41:12 +0200 <topos> https://hackage.haskell.org/package/mtl-2.2.2/docs/Control-Monad-Error.html
2020-09-17 06:41:16 +0200 <topos> top of the haddocks
2020-09-17 06:42:05 +0200 <siraben> Right
2020-09-17 06:42:18 +0200 <siraben> I was surprised to see Error so high up: https://www.sciencedirect.com/science/article/pii/S0167642320301313
2020-09-17 06:42:21 +0200 <siraben> Must be legacy
2020-09-17 06:42:25 +0200Sunblaze21(~sanjay@116.72.71.64)
2020-09-17 06:43:05 +0200 <siraben> Most commonly used monads are (most to least order) State, Trans, Reader, Error, Writer, RWS, Identity, Cont, List, Except
2020-09-17 06:43:24 +0200 <topos> very interesting study thanks. I could actually use this info
2020-09-17 06:44:15 +0200 <siraben> Turns out not many people use alternative monad transformer libraries
2020-09-17 06:44:43 +0200sumo_r9(0ec9fb69@14-201-251-105.tpgi.com.au)
2020-09-17 06:45:25 +0200 <dolio> All the stuff that used Error before it was deprecated didn't just disappear from hackage.
2020-09-17 06:45:55 +0200sumo_r(0ec9fb69@14-201-251-105.tpgi.com.au) (Ping timeout: 245 seconds)
2020-09-17 06:46:00 +0200Jeanne-Kamikaze(~Jeanne-Ka@static-198-54-131-92.cust.tzulo.com) (Quit: Leaving)
2020-09-17 06:46:45 +0200 <siraben> When does it deprecated?
2020-09-17 06:46:49 +0200 <siraben> s/does/was
2020-09-17 06:48:12 +0200 <koz_> Also why?
2020-09-17 06:48:17 +0200heatsink(~heatsink@2600:1700:bef1:5e10:99ca:18ad:4e5f:ffdf)
2020-09-17 06:49:12 +0200drbean(~drbean@TC210-63-209-98.static.apol.com.tw) (Quit: ZNC 1.8.2+cygwin1 - https://znc.in)
2020-09-17 06:50:18 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-09-17 06:50:20 +0200 <dolio> I'm not sure. But it probably hasn't been as long since it was deprecated as the (relevant) time before yet.
2020-09-17 06:50:25 +0200wavemode(~wavemode@097-070-075-143.res.spectrum.com) (Ping timeout: 240 seconds)
2020-09-17 06:51:41 +0200 <siraben> Why is continuation monad second least used?
2020-09-17 06:51:58 +0200ransom(~c4264035@c-73-243-2-10.hsd1.co.comcast.net)
2020-09-17 06:52:01 +0200 <topos> presumably because you have to define an additional `Error` class instance in order to use your errors, which was spurious
2020-09-17 06:52:23 +0200asan(~yan4138@114.84.148.87) (Ping timeout: 258 seconds)
2020-09-17 06:52:48 +0200 <topos> siraben because continuations are hard to get right, and also have very specific use cases that don't often intersect with industry
2020-09-17 06:53:05 +0200 <siraben> Oops I should correct my list, the actual list is State, Reader, Trans, Error, Writer, Identity, RWS, Except, Cont, List
2020-09-17 06:53:05 +0200kleisli_(~kleisli@2600:1700:4640:c560:68bd:9d76:dbd8:24e7)
2020-09-17 06:53:11 +0200 <siraben> Figure 9b
2020-09-17 06:53:16 +0200 <siraben> topos: I see
2020-09-17 06:53:31 +0200asan(~yan4138@124.78.128.72)
2020-09-17 06:53:38 +0200 <koz_> siraben: Cont is very powerful - it can implement all the others - but that's usually overkill.
2020-09-17 06:53:56 +0200 <siraben> Yeah, there's a great blog post on reimplementing other monads from Cont
2020-09-17 06:54:45 +0200 <dolio> It's kind of misleading to say Cont can implement the others.
2020-09-17 06:54:49 +0200elliott_(~elliott@pool-71-114-77-65.washdc.fios.verizon.net)
2020-09-17 06:54:56 +0200 <koz_> dolio: In what sense is it misleading?
2020-09-17 06:55:34 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2020-09-17 06:55:40 +0200 <dolio> Because the way you implement them uses different Cont monads depending on which ones you're embeding.
2020-09-17 06:56:46 +0200 <dolio> You choose a different `r`.
2020-09-17 06:56:47 +0200 <topos> callCC @Identity @a @⊥ what could go wrong
2020-09-17 06:58:08 +0200asan(~yan4138@124.78.128.72) (Ping timeout: 260 seconds)
2020-09-17 06:59:10 +0200lucid_0x80(~lucid_0x8@188.253.232.35)
2020-09-17 07:01:06 +0200 <davean> topos: It does exactly what it says it does, whats the problem?
2020-09-17 07:02:07 +0200 <topos> No problem here. Constructivists be damned
2020-09-17 07:03:02 +0200elliott_(~elliott@pool-71-114-77-65.washdc.fios.verizon.net) (Quit: WeeChat 2.9)
2020-09-17 07:03:08 +0200 <davean> If you want to complain so much topos, make me a way to record all your issues.
2020-09-17 07:03:24 +0200nan`(~nan`@unaffiliated/nan/x-5405850)
2020-09-17 07:03:26 +0200 <siraben> Should I be creating my own monads more? I usually just use an MTL monad and be done with it.
2020-09-17 07:03:30 +0200elliott_(~elliott@pool-71-114-77-65.washdc.fios.verizon.net)
2020-09-17 07:03:42 +0200 <siraben> Or some combination of MTL monads
2020-09-17 07:03:43 +0200 <davean> siraben: it varies. Generally you can make your own monad out of MTL's
2020-09-17 07:03:45 +0200 <topos> Who's complaining davean? I accept LEM as my lord and savior
2020-09-17 07:04:01 +0200 <siraben> GeneralizedNewtypeDeriving FTW
2020-09-17 07:04:03 +0200 <davean> siraben: Often making your own typeclass for them is whats really valuable.
2020-09-17 07:04:18 +0200 <davean> But not all important monads can be created via composing MTL
2020-09-17 07:04:24 +0200 <siraben> davean: any good examples on that?
2020-09-17 07:04:52 +0200 <siraben> That's one gap in the literature, books talk about monads and monad transformers but I haven't read material on modeling effects using custom monad typeclasses.
2020-09-17 07:05:00 +0200 <davean> siraben: PlanT in 'machines'
2020-09-17 07:05:08 +0200solonarv(~solonarv@astrasbourg-653-1-186-165.w90-13.abo.wanadoo.fr) (Ping timeout: 260 seconds)
2020-09-17 07:05:27 +0200 <davean> http://hackage.haskell.org/package/machines-0.7/docs/Data-Machine-Plan.html#t:Plan
2020-09-17 07:05:44 +0200mmohammadi9812(~mmohammad@5.116.223.123)
2020-09-17 07:05:46 +0200 <davean> I was doing on to thread parallelism through too today.
2020-09-17 07:06:01 +0200 <siraben> Huh, this looks exactly like ReqT from Oleg's work
2020-09-17 07:06:18 +0200 <davean> Usually if you're writing your own monad though not composing MTL you're doing something "interesting" that would get reused elsewhere.
2020-09-17 07:06:27 +0200 <davean> Not always but its a good predictor
2020-09-17 07:07:02 +0200 <davean> siraben: I'd say usually you write your own when you care about semantics, not capabilities, but thats not well defined.
2020-09-17 07:07:35 +0200exodrifter(adacad5d@cpe-173-172-173-93.tx.res.rr.com) (Remote host closed the connection)
2020-09-17 07:08:26 +0200isovector1(~isovector@172.103.216.166.cable.tpia.cipherkey.com) (Quit: Leaving)
2020-09-17 07:09:09 +0200asan(~yan4138@124.78.5.33)
2020-09-17 07:09:46 +0200 <davean> siraben: did that make sense?
2020-09-17 07:10:05 +0200 <siraben> davean: what do you mean by capabilities?
2020-09-17 07:10:28 +0200 <davean> "Get access to Disk" "Ask about a value"
2020-09-17 07:10:30 +0200nan`(~nan`@unaffiliated/nan/x-5405850) (Ping timeout: 260 seconds)
2020-09-17 07:10:54 +0200 <siraben> Ah, I see.
2020-09-17 07:11:01 +0200jedws(~jedws@101.184.189.58)
2020-09-17 07:11:05 +0200 <siraben> And semantics here as in PL semantics?
2020-09-17 07:11:10 +0200Lord_of_Life_(~Lord@unaffiliated/lord-of-life/x-0885362)
2020-09-17 07:11:21 +0200 <davean> semantics: "Do monadic things sequentually, but applicative things on a thread pool of a given size"
2020-09-17 07:11:37 +0200Lord_of_Life(~Lord@unaffiliated/lord-of-life/x-0885362) (Ping timeout: 264 seconds)
2020-09-17 07:12:12 +0200 <davean> yah, semantics are about how you do the computation
2020-09-17 07:12:29 +0200 <davean> hence PlanT as an example
2020-09-17 07:12:32 +0200Lord_of_Life_Lord_of_Life
2020-09-17 07:12:42 +0200 <davean> topos: slap me around and say something a little tighter?
2020-09-17 07:13:20 +0200toposslaps davean
2020-09-17 07:13:23 +0200 <topos> something a little tighter
2020-09-17 07:13:42 +0200 <davean> Cont is the exception
2020-09-17 07:13:46 +0200 <davean> that does anything, badly.
2020-09-17 07:14:12 +0200mmohammadi9812(~mmohammad@5.116.223.123) (Ping timeout: 256 seconds)
2020-09-17 07:14:25 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb)
2020-09-17 07:14:40 +0200 <siraben> One issue I've had with effects was trying to convert my Scheme interpreter to a monadic version
2020-09-17 07:14:41 +0200 <siraben> https://github.com/siraben/r5rs-denot/blob/fba3b49d88c6d7c4e7a2cff302589a669a4fdb88/src/SchemeEval…
2020-09-17 07:15:01 +0200Foritus(~buggery@cpc91334-watf11-2-0-cust153.15-2.cable.virginm.net) (Read error: Connection reset by peer)
2020-09-17 07:15:22 +0200Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-157-9.dhcp-dynamic.fibreop.nb.bellaliant.net) (Remote host closed the connection)
2020-09-17 07:15:39 +0200Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-157-9.dhcp-dynamic.fibreop.nb.bellaliant.net)
2020-09-17 07:15:44 +0200 <siraben> I tried something like, Except over Reader over Cont over State, but the Except <> Cont interaction didn't work out
2020-09-17 07:16:06 +0200 <siraben> In a sense I don't want Haskell's full range of continuations, just the Scheme continuations, if that makes sense
2020-09-17 07:16:06 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 07:16:07 +0200dansho(~dansho@ip68-108-167-185.lv.lv.cox.net)
2020-09-17 07:16:20 +0200 <davean> siraben: That sure is a scheme interpriter that reads like scheme!
2020-09-17 07:16:47 +0200 <siraben> davean: Heh, it was converted directly from the denotational semantics of R5RS
2020-09-17 07:16:59 +0200 <davean> I ... could have guessed
2020-09-17 07:17:20 +0200Foritus(~buggery@cpc91334-watf11-2-0-cust153.15-2.cable.virginm.net)
2020-09-17 07:18:12 +0200 <siraben> Maybe it was someone here who mentioned that they were working a similar project and was planning to encapsulate primitive operations in a typeclass
2020-09-17 07:18:35 +0200 <siraben> Like a CSEK machine.
2020-09-17 07:18:37 +0200 <siraben> CESK*
2020-09-17 07:19:11 +0200__Joker(~Joker@180.151.106.108) (Ping timeout: 272 seconds)
2020-09-17 07:19:49 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 272 seconds)
2020-09-17 07:20:11 +0200 <siraben> Hm, http://matt.might.net/articles/cesk-machines/
2020-09-17 07:20:48 +0200 <topos> i mean, edwardk's been doing some of that with his livestreaming. I'm working on a machine based on matt might's abstract abstract interpreters work as well
2020-09-17 07:20:51 +0200justanotheruser(~justanoth@unaffiliated/justanotheruser)
2020-09-17 07:21:00 +0200 <edwardk> i need to stream again
2020-09-17 07:21:12 +0200 <siraben> edwardk: streaming on twitch?
2020-09-17 07:21:39 +0200elliott_(~elliott@pool-71-114-77-65.washdc.fios.verizon.net) (Quit: WeeChat 2.9)
2020-09-17 07:21:58 +0200 <edwardk> yeah, i moved and never bothered to get set back up
2020-09-17 07:22:17 +0200 <siraben> topos: are you referring to http://matt.might.net/papers/might2010free.pdf ?
2020-09-17 07:22:19 +0200elliott_(~elliott@pool-71-114-77-65.washdc.fios.verizon.net)
2020-09-17 07:22:47 +0200 <siraben> Wow, that circular dependence in figure 1 is exactly the issue I came across
2020-09-17 07:22:48 +0200 <topos> yeah
2020-09-17 07:23:28 +0200 <topos> but this one http://matt.might.net/papers/vanhorn2010abstract.pdf
2020-09-17 07:23:39 +0200 <topos> it's all gravy tho
2020-09-17 07:24:03 +0200 <edwardk> siraben: that interpreter is nice and direct
2020-09-17 07:24:40 +0200 <siraben> edwardk: the r5rs-denot one?
2020-09-17 07:24:53 +0200 <edwardk> capturing scheme continuations in a CESK machine is super simple. Capture K, restore K,.
2020-09-17 07:24:58 +0200 <edwardk> yeah
2020-09-17 07:25:07 +0200 <siraben> Thanks.
2020-09-17 07:26:43 +0200elliott_(~elliott@pool-71-114-77-65.washdc.fios.verizon.net) (Client Quit)
2020-09-17 07:26:54 +0200eric(~eric@2804:431:c7d4:b75:19f7:ea85:5be8:4c8e)
2020-09-17 07:26:57 +0200 <siraben> topos: interesting paper
2020-09-17 07:27:23 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-09-17 07:27:41 +0200elliott_(~elliott@pool-71-114-77-65.washdc.fios.verizon.net)
2020-09-17 07:28:01 +0200Guest74761(sid13060@gateway/web/irccloud.com/x-rcuirdcnfpfdubdp) ()
2020-09-17 07:28:27 +0200dsal(sid13060@gateway/web/irccloud.com/x-pvmusdavojjxflwa)
2020-09-17 07:28:38 +0200 <siraben> These techniques, do they carry over to compilation as well? I haven't looked much into abstract interpretation.
2020-09-17 07:28:52 +0200dsalGuest85365
2020-09-17 07:30:25 +0200__Joker(~Joker@180.151.106.108)
2020-09-17 07:32:06 +0200eric(~eric@2804:431:c7d4:b75:19f7:ea85:5be8:4c8e) (Ping timeout: 244 seconds)
2020-09-17 07:33:23 +0200Guest85365dsal
2020-09-17 07:34:10 +0200 <edwardk> abstract interpretation can be a good first step towards compilation, as you get a sense of what cases are and aren't possible in each use site
2020-09-17 07:34:19 +0200ransom(~c4264035@c-73-243-2-10.hsd1.co.comcast.net) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-09-17 07:34:47 +0200 <edwardk> there's another paper by van horn and might on abstract abstract machines, that i'm particularly fond of
2020-09-17 07:34:48 +0200 <edwardk> https://arxiv.org/pdf/1007.4446.pdf
2020-09-17 07:34:59 +0200 <edwardk> that paper is the one that made abstract interpretation finally gel for me
2020-09-17 07:35:01 +0200falafel(~falafel@2605:e000:1527:d491:f090:20fe:cddf:2a1a)
2020-09-17 07:35:16 +0200__Joker(~Joker@180.151.106.108) (Ping timeout: 260 seconds)
2020-09-17 07:36:45 +0200 <siraben> edwardk: Heh, the notation looks somewhat intimidating
2020-09-17 07:37:19 +0200 <edwardk> all the greek letters and hats?
2020-09-17 07:39:26 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2020-09-17 07:39:34 +0200 <edwardk> the paper starts with a CEK machine, which you can squint at a krivine machine and see, adds a store, moves continuations into the store, then starts to play with what happens if you make the store, etc. less accurate approximations.
2020-09-17 07:40:09 +0200 <siraben> Ok, so on closer inspection it may be tractable for me.
2020-09-17 07:40:12 +0200lc_(~lc@94.198.42.164) (Ping timeout: 272 seconds)
2020-09-17 07:41:29 +0200 <Axman6> topos: for the encode loop, have you tried the version which just does the maths to compute the hex character for the nibble?
2020-09-17 07:41:39 +0200mitchellsalad_(uid40617@gateway/web/irccloud.com/x-wopqfurhxhollxgh) (Quit: Connection closed for inactivity)
2020-09-17 07:43:06 +0200ransom(~c4264035@c-73-243-2-10.hsd1.co.comcast.net)
2020-09-17 07:43:30 +0200ransom(~c4264035@c-73-243-2-10.hsd1.co.comcast.net) (Client Quit)
2020-09-17 07:43:39 +0200 <edwardk> one thing all these papers on quantitative type theory seem to sweep under the rug is how much harder it makes inference for things like what to instantiate meta variables to.
2020-09-17 07:44:06 +0200 <edwardk> (just to mention a frustraton that is on y mind)
2020-09-17 07:44:25 +0200 <siraben> edwardk: what paper are you reading?
2020-09-17 07:44:52 +0200 <edwardk> well. i've been trying to build a little "ELF" style logical framework with quantitative type theory bolted in.
2020-09-17 07:45:40 +0200 <siraben> Quantitative type theory differs from linear type theories in what way?
2020-09-17 07:46:58 +0200 <edwardk> the papers in question are https://personal.cis.strath.ac.uk/conor.mcbride/PlentyO-CR.pdf which came first https://bentnib.org/quantitative-type-theory.pdf which fixed it up. then abel and bernardy which gave us the formulation for linear haskell, https://wg28.mpi-sws.org/technical-presentations/files/cfdb7_uploads/1584070624-w28-qtt-zion.pdf and finally the choudhury et al paper
2020-09-17 07:46:58 +0200 <edwardk> https://richarde.dev/papers/2020/quantitative/quantitative.pdf
2020-09-17 07:47:06 +0200 <edwardk> but the gist is this
2020-09-17 07:47:08 +0200 <edwardk> take your type theory
2020-09-17 07:47:11 +0200mrte(~mrt@p4fcabee7.dip0.t-ipconnect.de)
2020-09-17 07:47:11 +0200 <edwardk> look at the environments
2020-09-17 07:47:26 +0200 <topos> Axman6 yeah
2020-09-17 07:47:27 +0200 <edwardk> you have Gamma, x : T
2020-09-17 07:47:31 +0200 <shafox> Anyone can share their ~/.cabal/config file. I want to know what I can do with all the options.
2020-09-17 07:47:49 +0200 <edwardk> add a member of some semiring with nice properties to the : annotating each typing judgment
2020-09-17 07:48:05 +0200 <edwardk> e.g. you might choose the semiring to have 0 for erased, 1 for present
2020-09-17 07:48:26 +0200elliott_(~elliott@pool-71-114-77-65.washdc.fios.verizon.net) (Ping timeout: 272 seconds)
2020-09-17 07:48:42 +0200 <edwardk> and then you run through all the usual rules of type theory, treating environments as semimodules (like vector spaces) over this scalar semiring
2020-09-17 07:48:47 +0200 <edwardk> why?
2020-09-17 07:48:53 +0200 <topos> Axman6 when i benched, computing the modulus was faster than doing yet another index look up on a different table. but i have come a long way with it and i might need to revisit
2020-09-17 07:49:01 +0200 <edwardk> you get to use this to compute erasure for one.
2020-09-17 07:49:35 +0200 <edwardk> but if you replace the semiring with {0,1,many} with 1+1=many, you get something like linear haskell
2020-09-17 07:49:40 +0200 <edwardk> but you can pick all sorts of other semirings
2020-09-17 07:49:57 +0200 <edwardk> e.g. just using the natural numbers would get you something like granule where you get exact usage counts of all variables
2020-09-17 07:50:09 +0200 <siraben> Oh that's fascinating, so the resource usage is determined by the chosen semiring?
2020-09-17 07:50:16 +0200 <topos> Axman6 sorry - wires crossed. i can get rid of that shift, yeah
2020-09-17 07:50:30 +0200 <edwardk> or using {0,1,affine,relevant,unrestricted} you can get something like david walker's post in "Advanced Topics in Types and Programming Languages"
2020-09-17 07:50:32 +0200 <edwardk> yeah
2020-09-17 07:50:54 +0200 <edwardk> i've been using a semiring with 6 elements, rather than those 5. {0,1,affine,relevant,STRICT,unrestricted}
2020-09-17 07:51:02 +0200 <edwardk> where strict and relevance are closely related but not the same
2020-09-17 07:52:04 +0200mrte(~mrt@p4fcabee7.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2020-09-17 07:52:16 +0200 <edwardk> in my toy type theory 1, strict, relevant all act as the dividing line at which i no longer have thunks in my data types. 0 doesn't exist at all in the result, and affine/unrestricted are lazy
2020-09-17 07:53:08 +0200 <edwardk> and 1 + 1 is relevant, but 1 + affine = strict rather than unrestricted like it'd be in the 5 point semiring above
2020-09-17 07:53:28 +0200ggole(~ggole@2001:8003:8119:7200:7c4d:5b32:3cf7:fd63)
2020-09-17 07:53:30 +0200 <edwardk> strictness then becomes the claim that you will definitely consume at least one of the copies of the thing you passed out to a bunch of sites
2020-09-17 07:53:40 +0200 <edwardk> where relevance is the claim you will consume ALL of them
2020-09-17 07:55:31 +0200 <edwardk> the dividing line is something like how relevance _could_ be managed by something that basically copied each A and made two of them and passed each out. Then relevance/linear in that universe would have you delete the structure when you're done. affine would still need the gc to help to know how to deal with something that was dropped, alternately you could maybe refine the notion of affine in that semiring to have versions that both
2020-09-17 07:55:32 +0200 <edwardk> supported unrestricted style dropping and ones that used an explicit finalizer to free like rust
2020-09-17 07:56:17 +0200 <edwardk> anything stuffed in a linear/relevant resource can get sort of freely added to some kind of gc root list, and you then don't even need to walk the relevant/linear stuff
2020-09-17 07:56:32 +0200 <edwardk> because you know it'll be consumed (and hence removed from the global gc root list) eventually
2020-09-17 07:56:51 +0200 <edwardk> this is a very resource-centric view, but one i've been playing with since i first found haskell
2020-09-17 07:57:02 +0200 <edwardk> qtt gave me the right framework, i was missing the + for the semiring
2020-09-17 07:58:10 +0200 <edwardk> now, this is still missing a last component, which is a notion of uniqueness, linearity says the consumer will definitely use up the thing, uniqueness says that you are being handed the only copy, and that the producer hasn't passed around any pointers to anybody else
2020-09-17 07:58:32 +0200lucid_0x80(~lucid_0x8@188.253.232.35) (Quit: Leaving)
2020-09-17 07:58:41 +0200 <edwardk> but the quantitative type theory stuff basically doesn't prejudge too much what the semiring means
2020-09-17 07:58:45 +0200 <edwardk> it is more of a formal tool
2020-09-17 07:59:11 +0200 <edwardk> and your semantics then clears up what you mean, the choudhury et al paper at the end of the reading list i dumped is actually quite clear.
2020-09-17 07:59:23 +0200 <Axman6> topos: nibbleChar :: Word8 -> Word8; nibbleChar (W8# n) = W8# (int2Word# (word2Int# n +# (48# +# ((geWord# n 10##) *# 39#))))
2020-09-17 08:00:02 +0200jjj(~jjj@195.206.169.184) ()
2020-09-17 08:00:07 +0200 <siraben> edwardk: that is fascinating. do you have a repository for this?
2020-09-17 08:00:14 +0200 <edwardk> anyways my general problem is this for a _ in my toy type theory i usually drop in a meta variable.
2020-09-17 08:00:33 +0200 <edwardk> github.com/ekmett/haskell has been where i've been scribbling thoughts, but i don't have any of the qtt stuff committed yet, it breaks the whole toy
2020-09-17 08:00:56 +0200toorevitimirp(~tooreviti@117.182.182.33) (Ping timeout: 260 seconds)
2020-09-17 08:01:15 +0200 <Axman6> topos: using that makes converting it to work a word at a time "trivial"
2020-09-17 08:01:24 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2020-09-17 08:02:31 +0200 <edwardk> for a meta variable the way i handle it is i look around at all the locally bound variables where i created and placed the meta variable and i just build a meta variable that gets all those as arguments. \x y z. foo M -- where M could reference x y and z requires M to know about contexts, and is messy, so instead I make it \x y z. foo (M x y z). Now if M instantiates to a constant valued function that ignores its arguments, the
2020-09-17 08:02:31 +0200 <edwardk> normalization done by my unification engine gets me the answer i want.
2020-09-17 08:02:38 +0200 <edwardk> but here I don't know the usage data for M.
2020-09-17 08:02:42 +0200 <siraben> edwardk: this metavariable is not the same as a type variable?
2020-09-17 08:02:48 +0200 <edwardk> which mucks with my ability to do type inference
2020-09-17 08:02:52 +0200mmohammadi9812(~mmohammad@5.116.223.123)
2020-09-17 08:03:12 +0200 <edwardk> meta variables here are like holes in the program. 'please put here the only thing that makes sense'
2020-09-17 08:03:36 +0200 <siraben> Oh, nice style for a repository. I might steal that, hehe. Maintaining separate repositories is annoying for small projects.
2020-09-17 08:03:53 +0200 <siraben> Right, I'm thinking of like Coq's metavariables then, ?A
2020-09-17 08:04:09 +0200 <edwardk> yeah. these are little existential holes
2020-09-17 08:04:13 +0200 <siraben> I use _ quite a lot when I want Coq to infer it
2020-09-17 08:04:32 +0200 <siraben> rewrite (mul_assoc _ b c)
2020-09-17 08:04:37 +0200 <edwardk> and they come up a bunch when you just write something like id :: {A} A -> A
2020-09-17 08:05:22 +0200 <siraben> Yes
2020-09-17 08:05:25 +0200hvr(~hvr@haskell/developer/hvr) (Ping timeout: 272 seconds)
2020-09-17 08:05:34 +0200 <edwardk> i have an implicit argument A there. great, but it really took id : {A : _} A -> A, and then when elaboration happened it expanded _ to a meta variable, and figured out that it should be 'type'
2020-09-17 08:05:35 +0200sfvm(~sfvm@37.228.215.148) (Quit: off to the basement, mixing up the medicine)
2020-09-17 08:06:19 +0200 <Axman6> topos: magic numbers in there are 48 = '0', 39 = 'a' - '0' - 10
2020-09-17 08:06:53 +0200 <edwardk> the general model is something like start out with a surface language with a bunch of extra nonsense and file locations and stuff in it, convert to some internal representation used for elaboration that has all these meta variables in it, then crush them out and you get the final 'core' equivalent.
2020-09-17 08:07:01 +0200heatsink(~heatsink@2600:1700:bef1:5e10:99ca:18ad:4e5f:ffdf) (Remote host closed the connection)
2020-09-17 08:07:34 +0200rihards(~rihards@balticom-142-78-50.balticom.lv)
2020-09-17 08:07:37 +0200 <edwardk> typechecking/inference produces terms in the elaboration form as witnesses that a given source term has a type
2020-09-17 08:07:46 +0200 <edwardk> but source terms have all sorts of extra bells and whistles.
2020-09-17 08:07:51 +0200 <edwardk> like in haskell we have where vs. let
2020-09-17 08:08:00 +0200 <edwardk> complex patterns, top level decls...
2020-09-17 08:08:37 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb)
2020-09-17 08:08:51 +0200knupfer(~Thunderbi@mue-88-130-61-060.dsl.tropolys.de)
2020-09-17 08:09:41 +0200 <edwardk> anyways, right now i'm currently wrestling with how to get resource usage constraints on each of my meta variables right, because _normally_ i can just sprinkle them around in my terms, but now i have a problem. their usage of resources affects how many resources i have to typecheck the _rest_ of the term.
2020-09-17 08:10:21 +0200 <edwardk> so i could try to carefully dance around and use up all the other resources and give them what is left, but i don't _really_ have a subtraction for resources (i'm in a semiring)
2020-09-17 08:10:43 +0200 <edwardk> i could also do something like first typecheck in the boring {0,1} presence/absence semiring, use that to flesh out my metas
2020-09-17 08:11:35 +0200 <edwardk> and then try to use backwards the fact that i have a semiring homomorphism from my final semiring to that semiring, and try to use that to 'redo' the job now that i actually have a sort of minimal bottom up chunk of resource usage data to go off
2020-09-17 08:11:49 +0200gnumonik(~gnumonik@c-73-170-91-210.hsd1.ca.comcast.net)
2020-09-17 08:12:04 +0200 <siraben> Hmm, seems tricky. I have no idea how semirings work when applied in a type theoretic context yet.
2020-09-17 08:12:19 +0200cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net)
2020-09-17 08:13:11 +0200 <edwardk> if you look at https://richarde.dev/papers/2020/quantitative/quantitative.pdf in figure 1, the rule for ST-App is my bane
2020-09-17 08:13:21 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 244 seconds)
2020-09-17 08:13:52 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece)
2020-09-17 08:14:13 +0200shafox(~shafox@106.51.234.111) (Remote host closed the connection)
2020-09-17 08:14:34 +0200shafox(~shafox@106.51.234.111)
2020-09-17 08:14:59 +0200 <edwardk> because you have to infer the type of (f) in (f x), then use that to get the usage information for the application rule. but if f is a meta variable then we have no usage to use to fill in
2020-09-17 08:15:52 +0200 <edwardk> the fact that these judgments tend to be written in a style where it isn't clear how to infer rather than just check doesn't help the story
2020-09-17 08:15:58 +0200 <siraben> These typing rules don't seem to have meta variables, you added them?
2020-09-17 08:16:02 +0200dhouthoo(~dhouthoo@ptr-eiv6509pb4ifhdr9lsd.18120a2.ip6.access.telenet.be)
2020-09-17 08:16:09 +0200 <Axman6> anyone know of a tool which accepts assembly and can give you how much instruction level parallelism it might have?
2020-09-17 08:16:55 +0200 <siraben> I meant like, meta variables being part of the source language, not in the meta language used to describe the language (which does have meta variables)
2020-09-17 08:16:57 +0200 <edwardk> correct. because i need inference and inference wants to put little holes in various places. (also that type theory in that figure is non-dependent, and mine is dependently typed)
2020-09-17 08:17:12 +0200ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex) (Remote host closed the connection)
2020-09-17 08:17:18 +0200 <siraben> Have you thought about using bidirectional type inference?
2020-09-17 08:17:26 +0200ddere(uid110888@gateway/web/irccloud.com/x-hxjfplopujbdeyav) (Quit: Connection closed for inactivity)
2020-09-17 08:17:26 +0200 <siraben> That's a technique I learned recently, very useful.
2020-09-17 08:17:27 +0200 <edwardk> this is in a bidirectional type checker =)
2020-09-17 08:17:44 +0200mmohammadi9812(~mmohammad@5.116.223.123) (Quit: I quit (╯°□°）╯︵ ┻━┻)
2020-09-17 08:17:48 +0200 <siraben> Where are the inferred vs. checked types then?
2020-09-17 08:17:50 +0200incognito9999(~incognito@hwsrv-648981.hostwindsdns.com) (Ping timeout: 256 seconds)
2020-09-17 08:18:01 +0200ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex)
2020-09-17 08:18:31 +0200 <edwardk> https://github.com/AndrasKovacs/implicit-fun-elaboration/blob/master/fcif/Elaboration.hs#L513 -- here's a version from andras kovacs
2020-09-17 08:19:26 +0200danvet(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa)
2020-09-17 08:19:30 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:59f2:1ee3:fe3e:b848)
2020-09-17 08:19:32 +0200danvet_(~danvet@2a02:168:57f4:0:5f80:650d:c6e6:3453)
2020-09-17 08:19:33 +0200mmohammadi9812(~mmohammad@5.116.223.123)
2020-09-17 08:19:44 +0200hvr(~hvr@haskell/developer/hvr)
2020-09-17 08:19:45 +0200danvet_(~danvet@2a02:168:57f4:0:5f80:650d:c6e6:3453) (Client Quit)
2020-09-17 08:20:01 +0200 <edwardk> that is in the 'infer' case for app, which delegates to an infer for the function, notice how it has to manufacture a couple of meta variables
2020-09-17 08:20:34 +0200 <edwardk> (notice there is a separate 'check' and infer and check bounce back and forth, bidirectional style
2020-09-17 08:20:49 +0200 <siraben> Heh, going straight for the IO monad
2020-09-17 08:20:53 +0200 <siraben> Right
2020-09-17 08:21:28 +0200 <edwardk> yeah andras runs in strict haskell and does evil things for IO
2020-09-17 08:21:43 +0200 <edwardk> I use slightly less evil things, but then unsafeInterleaveIO all over the same code =P
2020-09-17 08:22:00 +0200kori(~kori@2804:14c:85a3:9105::1000)
2020-09-17 08:22:00 +0200kori(~kori@2804:14c:85a3:9105::1000) (Changing host)
2020-09-17 08:22:00 +0200kori(~kori@arrowheads/kori)
2020-09-17 08:22:11 +0200 <edwardk> i've been basing things pretty closely on his work because he gets some pretty great type inference
2020-09-17 08:22:26 +0200 <edwardk> e.g. he can handle the runST $ do ... stuff without any magic rule for $.
2020-09-17 08:22:44 +0200 <edwardk> so i more or less grabbed that wholesale
2020-09-17 08:23:59 +0200 <siraben> Wow, he has an elaboration-zoo repo as well
2020-09-17 08:24:17 +0200falafel(~falafel@2605:e000:1527:d491:f090:20fe:cddf:2a1a) (Remote host closed the connection)
2020-09-17 08:24:18 +0200 <edwardk> if you rip out all the exotic Tel, PiTel, LamTel, Rec. stuff out of his type theory he gets a pretty good baseline typechecker (modulo the usual sort of implicit reordering that agda does)
2020-09-17 08:24:33 +0200dansho(~dansho@ip68-108-167-185.lv.lv.cox.net) (Remote host closed the connection)
2020-09-17 08:24:44 +0200falafel(~falafel@2605:e000:1527:d491:f090:20fe:cddf:2a1a)
2020-09-17 08:24:47 +0200dansho(~dansho@ip68-108-167-185.lv.lv.cox.net)
2020-09-17 08:24:48 +0200 <edwardk> We talked quite a bit at ICFP and it served as a good forcing function for me to stop dilly-dallying with other ways to do this, and just raid his toolbox for tricks
2020-09-17 08:25:11 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece) (Remote host closed the connection)
2020-09-17 08:25:42 +0200echoreply(~echoreply@unaffiliated/echoreply) (Quit: WeeChat 1.9.1)
2020-09-17 08:25:50 +0200 <edwardk> my usecase is a bit weird
2020-09-17 08:26:01 +0200 <edwardk> i'm currently trying to do this to build a "logical framework" like LF
2020-09-17 08:26:13 +0200echoreply(~echoreply@unaffiliated/echoreply)
2020-09-17 08:26:15 +0200 <edwardk> but with the qtt bits sprinkled on top
2020-09-17 08:26:49 +0200 <edwardk> LF is what you get if you take a dependent type theory, lop it off at the knees and stunt its growth.
2020-09-17 08:27:18 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece)
2020-09-17 08:27:25 +0200Cale(~cale@CPEf48e38ee8583-CM0c473de9d680.cpe.net.cable.rogers.com) (Ping timeout: 246 seconds)
2020-09-17 08:28:10 +0200 <edwardk> you remove all the bits that have to do with sigma, maybe cripple pi so you can make types that depend on terms but not use other things, force yourself to only have terms, types and kinds, and no universe tower, don't bother making traditional data types and induction principles and the like.
2020-09-17 08:28:27 +0200Neuromancer(~Neuromanc@unaffiliated/neuromancer) (Ping timeout: 240 seconds)
2020-09-17 08:28:37 +0200 <edwardk> which seems like an awful lot of surgery to do
2020-09-17 08:29:03 +0200 <edwardk> but once you've butcher the type system in this way, it becomes really easy to reason about HOAS.
2020-09-17 08:30:06 +0200 <edwardk> e.g. you can define tm : type; lam : (tm -> tm) -> tm; app : tm -> tm -> tm -- and have a higher order abstract syntax for terms. and you can know that that function from tm -> tm in lam just places the argument somewhere, BECAUSE IT CANT PATTERN MATCH ON IT.
2020-09-17 08:30:14 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Ping timeout: 272 seconds)
2020-09-17 08:30:16 +0200josh(~josh@c-67-164-104-206.hsd1.ca.comcast.net) (Remote host closed the connection)
2020-09-17 08:30:22 +0200 <edwardk> so you write your semantics in this logical framework and what have you
2020-09-17 08:31:01 +0200mmohammadi9812(~mmohammad@5.116.223.123) (Quit: I quit (╯°□°）╯︵ ┻━┻)
2020-09-17 08:31:07 +0200 <edwardk> and then reason about meta theorems about what you wrote, and those are simplified by the fact that the language the code manipulating your terms or judging things about your terms was written in is comparatively simple
2020-09-17 08:31:37 +0200 <edwardk> i figured i'd share because you started from 'hey i wrote down the denotational semantics of r5rs and ran them'
2020-09-17 08:32:18 +0200kori(~kori@arrowheads/kori) (Quit: WeeChat 2.8)
2020-09-17 08:32:27 +0200 <edwardk> normally to work with syntax tree representations you have to go off and fight with debruijn indices/levels or use 'parametric hoas' or use a library like bound or unbound or nominal or name...
2020-09-17 08:32:39 +0200 <edwardk> but each of those complicate reasoning about the program that manipulates those terms
2020-09-17 08:32:43 +0200mmohammadi9812(~mmohammad@5.116.223.123)
2020-09-17 08:32:52 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-09-17 08:33:15 +0200josh(~josh@c-67-164-104-206.hsd1.ca.comcast.net)
2020-09-17 08:33:25 +0200 <siraben> Thanks, that was insightful.
2020-09-17 08:33:26 +0200 <edwardk> so the old-school bob harper way to handle that was to build a crippled but still usable type system that was good enough for building up those judgments
2020-09-17 08:33:54 +0200 <siraben> Capture-avoiding substitution is a mess, I've recently using de bruijn to implement a linearly typed lambda calculus.
2020-09-17 08:33:57 +0200josh(~josh@c-67-164-104-206.hsd1.ca.comcast.net) (Remote host closed the connection)
2020-09-17 08:34:05 +0200finkata(~dpetrov@83.222.188.39)
2020-09-17 08:34:14 +0200incognito9999(~incognito@hwsrv-648981.hostwindsdns.com)
2020-09-17 08:34:14 +0200 <siraben> Thinking about implementing lambda pi from https://www.andres-loeh.de/LambdaPi/LambdaPi.pdf
2020-09-17 08:34:17 +0200__Joker(~Joker@180.151.106.108)
2020-09-17 08:34:31 +0200josh(~josh@c-67-164-104-206.hsd1.ca.comcast.net)
2020-09-17 08:34:43 +0200 <edwardk> i've been playing with ways to extend an LF, because, say, working on a language that has linear types in LF is awful. your binding forms don't match the host LF's binding forms in how they are managed and so all of a sudden you're stuck in debruijn hell... in a crippled type theory
2020-09-17 08:34:44 +0200 <siraben> edwardk: do you know if tagless final can be used to implement dependently typed languages?
2020-09-17 08:34:55 +0200josh(~josh@c-67-164-104-206.hsd1.ca.comcast.net) (Read error: Connection reset by peer)
2020-09-17 08:35:39 +0200 <edwardk> but if the lf itself has qtt, then it becomes pretty easy to reason about any language that uses a binding form that has constraints that look like any subsemiring of the ones offered by the host language.
2020-09-17 08:35:50 +0200 <edwardk> (there was some work on linear logical frameworks in the 90s)
2020-09-17 08:35:58 +0200 <edwardk> the answer is a hard 'sorta'
2020-09-17 08:36:12 +0200 <edwardk> so lets use the running example of an LF
2020-09-17 08:36:16 +0200 <edwardk> because its on my brain
2020-09-17 08:36:23 +0200 <edwardk> here we have 'dependent types' where types can depend on terms
2020-09-17 08:37:12 +0200 <edwardk> i wrote some code the other day and posted it to twitter for how to do typed "normalization-by-evaluation"
2020-09-17 08:37:35 +0200 <edwardk> https://gist.github.com/ekmett/6c64c3815f9949d067d8f9779e2347ef
2020-09-17 08:38:14 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2020-09-17 08:38:18 +0200 <edwardk> if you look at the very bottom of that code id_, k, kid_ are id, const, and const id in the little toy 'untyped except i happen to be borrowing haskell's types' typed language.
2020-09-17 08:38:37 +0200 <edwardk> basically Val represents terms crushed down to normal form.
2020-09-17 08:38:44 +0200 <edwardk> and expressions allows for you to be sloppier
2020-09-17 08:39:02 +0200Cale(~cale@CPEf48e38ee8583-CM0c473de9d680.cpe.net.cable.rogers.com)
2020-09-17 08:39:11 +0200 <edwardk> nf takes an expression to a val, which is internally representing something in beta normal form, and then converts the val back to an expr which happens to be in beta normal form
2020-09-17 08:39:37 +0200 <edwardk> so what does this have to do with dependently typed languages? this is clearly an untyped language
2020-09-17 08:39:45 +0200 <edwardk> well, haskelly-typed
2020-09-17 08:40:09 +0200 <edwardk> well, an old paper of conal elliott's (maybe his thesis, i forget) introduced a notion of 'approximately well typed' programs
2020-09-17 08:40:57 +0200 <edwardk> which is to say if you run through an LF and rip out all the dependent bits, turning [| Pi x : A. B |]. into [| A |] -> [| A |] ...
2020-09-17 08:41:05 +0200 <edwardk> er B
2020-09-17 08:41:21 +0200 <edwardk> then you get a non-dependently typed approxmation of the types in the LF
2020-09-17 08:41:48 +0200 <edwardk> and termination of unification, etc. in the LF is sort of governed by termination of it for this crippled type
2020-09-17 08:42:11 +0200ystael(~ystael@209.6.50.55) (Ping timeout: 240 seconds)
2020-09-17 08:42:28 +0200mmohammadi9812(~mmohammad@5.116.223.123) (Quit: I quit (╯°□°）╯︵ ┻━┻)
2020-09-17 08:42:53 +0200 <edwardk> so if you were working with something in the LF corner of the lambda cube where you have limited dependent types? then you can use what host language types those types erased to and have an 'approximately well typed' scheme for working with it, implemented finally tagless style
2020-09-17 08:43:33 +0200 <edwardk> but the finally-tagless bits? i personally tend to go for heavier tagged deep embeddings because i find they are really frustrating to work with when you want sweeter sugar
2020-09-17 08:43:33 +0200ystael(~ystael@209.6.50.55)
2020-09-17 08:43:50 +0200 <edwardk> er they here being finally tagless
2020-09-17 08:43:52 +0200 <siraben> That makes sense
2020-09-17 08:44:15 +0200mmohammadi9812(~mmohammad@5.116.223.123)
2020-09-17 08:44:18 +0200 <edwardk> http://www.cse.chalmers.se/~josefs/publications/svenningsson2015combining.pdf is a paper on how to do typed EDSLs that I rather like
2020-09-17 08:44:31 +0200 <edwardk> iceland jack posted a link to it the other day on twitter and it reminded me of its existence
2020-09-17 08:44:48 +0200 <edwardk> in theory a version of that that is 'approximately well typed' could work for an LF.
2020-09-17 08:45:06 +0200 <edwardk> so that gives the 'can i get the types right' answer with a sort of strong maybe.
2020-09-17 08:45:21 +0200mmohammadi9812(~mmohammad@5.116.223.123) (Client Quit)
2020-09-17 08:46:03 +0200 <edwardk> for working with dependent types in general i tend to stick to real syntax trees and libraries like bound.
2020-09-17 08:46:33 +0200 <edwardk> https://hub.darcs.net/dolio/upts/browse/Language/UPTS/SyntaxTree.hs#39 is an example of a small pure type system with universe polymorphism by dolio that uses bound
2020-09-17 08:46:38 +0200 <siraben> I haven't used the bound library before, will it handle the scoping and substitution for me?
2020-09-17 08:46:43 +0200 <edwardk> yeah
2020-09-17 08:47:05 +0200 <edwardk> your Term type becomes a monad, using (>>=) for substitution.
2020-09-17 08:47:15 +0200 <edwardk> and Scope () Term becomes 'and i need an extra bound variable'
2020-09-17 08:47:20 +0200 <MarcelineVQ> is the purpose of that 'approximately well typed' to check if something could be correct, with less work, before you check fully?
2020-09-17 08:47:23 +0200 <edwardk> and you use >>>= to walk over that
2020-09-17 08:47:28 +0200 <edwardk> MarcelineVQ: yeah
2020-09-17 08:47:37 +0200 <edwardk> catch most of the stupid programmer bugs
2020-09-17 08:47:40 +0200 <edwardk> basically a form of lint
2020-09-17 08:48:27 +0200 <edwardk> maybe if you cps transformed everything you could get into a state where you could do reflection to create the types off terms locally that you'd need... or you could wait for richard to finish dependent hakell
2020-09-17 08:48:29 +0200 <edwardk> er haskell
2020-09-17 08:48:49 +0200borne(~fritjof@200116b8641fc4005e981dab12496c3b.dip.versatel-1u1.de)
2020-09-17 08:49:00 +0200xff0x_(~fox@2001:1a81:5306:e200:7599:d48:f5dc:5fef) (Ping timeout: 244 seconds)
2020-09-17 08:49:14 +0200knupfer(~Thunderbi@mue-88-130-61-060.dsl.tropolys.de) (Ping timeout: 272 seconds)
2020-09-17 08:49:14 +0200 <edwardk> https://hub.darcs.net/dolio/upts/browse/Language/UPTS/SyntaxTree.hs#73 see how the >>>= is used for the body of the lambda?
2020-09-17 08:49:49 +0200 <siraben> Ah
2020-09-17 08:49:50 +0200 <edwardk> https://www.schoolofhaskell.com/user/edwardk/bound is an article i wrote on bound
2020-09-17 08:50:07 +0200xff0x_(~fox@2001:1a81:5306:e200:5d84:8198:9ead:fb9f)
2020-09-17 08:50:15 +0200 <siraben> great, saved.
2020-09-17 08:50:20 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311) ()
2020-09-17 08:50:30 +0200 <edwardk> the key is that when you need a Term and have a Scope () Term you need to give me the value for the extra variable. it won't typecheck if you f up the name manipulation
2020-09-17 08:51:08 +0200 <edwardk> abstract1 and instantiate1 give you tools for converting from Scope () m <-> m by capturing/instantiating
2020-09-17 08:51:21 +0200 <edwardk> bound works best when you're working with a language with one type of name
2020-09-17 08:51:39 +0200 <edwardk> we made it work for ermine by lots of hand-holding
2020-09-17 08:52:05 +0200 <edwardk> but its quite pleasant to just walk terms, be able to >>= for substituting in your environment, use foldMap to extract free variables.
2020-09-17 08:52:23 +0200 <edwardk> Scope is basically a 'faster' EitherT
2020-09-17 08:53:02 +0200 <edwardk> abstract and instantiate handle the case where you want to bind multiple variables at once, (i don't have to just put on a (), maybe i'm binding 8 variables at once in a recursive let binding/where clause, etc.
2020-09-17 08:54:12 +0200tomboy64(~tomboy64@gateway/tor-sasl/tomboy64) (Remote host closed the connection)
2020-09-17 08:55:52 +0200mirrorbird(~psutcliff@2a00:801:44b:8959:8d6c:276b:332b:1c71) (Remote host closed the connection)
2020-09-17 08:56:04 +0200chele(~chele@ip5b416ea2.dynamic.kabel-deutschland.de)
2020-09-17 08:56:32 +0200mirrorbird(~psutcliff@2a00:801:44b:8959:8d6c:276b:332b:1c71)
2020-09-17 08:58:24 +0200 <gnumonik> I thought I remembered some function in the lens library that returns a list of (maybe strings that represent?) the lenses/etc that exist for a datatype. Anyone know what that is or am I mistaken?
2020-09-17 09:02:27 +0200 <edwardk> :t universe
2020-09-17 09:02:28 +0200 <lambdabot> Plated a => a -> [a]
2020-09-17 09:02:33 +0200 <edwardk> er that's not it
2020-09-17 09:02:46 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb)
2020-09-17 09:03:21 +0200bitmagie(~Thunderbi@200116b80670970060cb385f030853d4.dip.versatel-1u1.de)
2020-09-17 09:03:28 +0200mmohammadi9812(~mmohammad@5.116.223.123)
2020-09-17 09:03:31 +0200 <edwardk> :t contexts
2020-09-17 09:03:33 +0200 <lambdabot> Plated a => a -> [Context a a a]
2020-09-17 09:03:47 +0200 <edwardk> :t contextsOf
2020-09-17 09:03:49 +0200 <lambdabot> ATraversal' a a -> a -> [Context a a a]
2020-09-17 09:03:55 +0200falafel(~falafel@2605:e000:1527:d491:f090:20fe:cddf:2a1a) (Ping timeout: 240 seconds)
2020-09-17 09:04:02 +0200 <edwardk> that gives you each of the 'one hole contexts' of a term
2020-09-17 09:04:53 +0200 <edwardk> you give a traversal that knows how to find all the parts, and it give you back a context which has what was in that position and a function that can sew the type back up around a new value.
2020-09-17 09:05:09 +0200 <edwardk> contexts works off the Plated data type
2020-09-17 09:05:39 +0200 <edwardk> a context is a "lens that has been applied to an 's'"
2020-09-17 09:05:51 +0200da39a3ee5e6b4b0d(~textual@2403:6200:8876:37d7:55fb:4d37:ffc2:715b) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-09-17 09:05:55 +0200 <gnumonik> That should work, thanks!
2020-09-17 09:06:13 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 09:06:14 +0200 <edwardk> if you think of a lens as s -> (a, b -> t) Context a b t = (a, b -> t)
2020-09-17 09:06:37 +0200 <edwardk> with some newtype and typical lens over-generality applied
2020-09-17 09:06:46 +0200 <edwardk> :info Context
2020-09-17 09:06:52 +0200whiteline(~whiteline@unaffiliated/whiteline)
2020-09-17 09:06:58 +0200 <edwardk> @info Context
2020-09-17 09:06:59 +0200 <lambdabot> Context
2020-09-17 09:07:05 +0200 <edwardk> that was helpful.
2020-09-17 09:07:07 +0200 <edwardk> @type Context
2020-09-17 09:07:09 +0200 <lambdabot> (b -> t) -> a -> Context a b t
2020-09-17 09:07:41 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 244 seconds)
2020-09-17 09:08:19 +0200sumo_r9(0ec9fb69@14-201-251-105.tpgi.com.au) (Remote host closed the connection)
2020-09-17 09:09:48 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-09-17 09:10:01 +0200mmohammadi9812(~mmohammad@5.116.223.123) (Ping timeout: 272 seconds)
2020-09-17 09:10:49 +0200mmohammadi9812(~mmohammad@5.238.164.128)
2020-09-17 09:10:52 +0200tzh(~tzh@2601:448:c500:5300::ad1c) (Quit: zzz)
2020-09-17 09:10:56 +0200tomboy64(~tomboy64@gateway/tor-sasl/tomboy64)
2020-09-17 09:11:06 +0200asan(~yan4138@124.78.5.33) (Ping timeout: 256 seconds)
2020-09-17 09:13:19 +0200kritzefitz(~kritzefit@fw-front.credativ.com)
2020-09-17 09:15:52 +0200finkata(~dpetrov@83.222.188.39) (Remote host closed the connection)
2020-09-17 09:15:55 +0200oxide(~lambda@unaffiliated/mclaren) (Read error: Connection reset by peer)
2020-09-17 09:16:21 +0200asan(~yan4138@61.170.146.94)
2020-09-17 09:17:40 +0200da39a3ee5e6b4b0d(~textual@2403:6200:8876:37d7:55fb:4d37:ffc2:715b)
2020-09-17 09:18:53 +0200pera(~pera@unaffiliated/pera) (Ping timeout: 272 seconds)
2020-09-17 09:19:56 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece) (Remote host closed the connection)
2020-09-17 09:20:58 +0200alp_(~alp@2a01:e0a:58b:4920:90ae:a5d:9349:f8d8)
2020-09-17 09:21:58 +0200ph88(~ph88@2a02:8109:9e40:2704:6cf2:c517:5b95:5f99)
2020-09-17 09:22:15 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 09:22:21 +0200maier(~maier@b2b-37-24-119-190.unitymedia.biz)
2020-09-17 09:22:29 +0200maierkenran
2020-09-17 09:22:38 +0200yoneda(~mike@193.206.102.122)
2020-09-17 09:23:06 +0200yoneda(~mike@193.206.102.122) (Client Quit)
2020-09-17 09:23:17 +0200 <kenran> Is there a specific reason why Data.Vector.Storable.Vector doesn't have "the usual" instances? I'm specifically wondering about Foldable.
2020-09-17 09:25:51 +0200yoneda(~mike@193.206.102.122)
2020-09-17 09:25:58 +0200stiell(~stian@fsf/member/stiell) (Ping timeout: 272 seconds)
2020-09-17 09:26:22 +0200pera(~pera@unaffiliated/pera)
2020-09-17 09:26:48 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 09:27:13 +0200 <Axman6> because you can't put a constraint on the types of the values stored in it to guarantee they are sStorablwe
2020-09-17 09:27:19 +0200 <Axman6> Storable*
2020-09-17 09:27:30 +0200 <dminuoso> % :t foldr
2020-09-17 09:27:31 +0200 <yahb> dminuoso: Foldable t => (a -> b -> b) -> b -> t a -> b
2020-09-17 09:27:40 +0200 <dminuoso> kenran: ^- See how b is unconstrained?
2020-09-17 09:28:07 +0200 <nshepperd> it's the lack of constraint on 'a' that is the problem here
2020-09-17 09:28:19 +0200 <dminuoso> Oh
2020-09-17 09:28:49 +0200 <dminuoso> nshepperd: Why does that matter?
2020-09-17 09:30:27 +0200AstroDroid(~AstroDroi@84.39.117.57)
2020-09-17 09:30:34 +0200 <dminuoso> Ah nevermind, heh.
2020-09-17 09:30:44 +0200 <nshepperd> because where t ~ Storable.Vector you can't get the 'a's out of that 't a' without having the Storable a instance at hand
2020-09-17 09:30:56 +0200 <dminuoso> nshepperd: I kept thinking of Functor for some bizarre reason.
2020-09-17 09:31:15 +0200 <dminuoso> In which case it'd be both a and b that'd need the Storable constraint
2020-09-17 09:32:42 +0200 <kenran> ah thanks. I can't try it out right now, but couldn't one have: instance Storable a => Foldable (Storable.Vector a)?
2020-09-17 09:33:13 +0200raichoo(~raichoo@dslb-178-001-022-071.178.001.pools.vodafone-ip.de)
2020-09-17 09:33:32 +0200 <dminuoso> kenran: Correct.
2020-09-17 09:33:41 +0200 <dminuoso> Multiple reasons
2020-09-17 09:33:46 +0200 <dminuoso> a) Wont kind check
2020-09-17 09:33:50 +0200 <dminuoso> % :k Foldable
2020-09-17 09:33:50 +0200 <yahb> dminuoso: (* -> *) -> Constraint
2020-09-17 09:34:09 +0200stiell(~stian@fsf/member/stiell)
2020-09-17 09:34:12 +0200 <dminuoso> b) The constraint would have to on the class method (something like quantified constraints would be needed)
2020-09-17 09:34:48 +0200 <dminuoso> And in addition c) *instance selection* does not consider any constraint on the instance declaration.
2020-09-17 09:35:08 +0200shutdown_-h_now(~arjan@2001:1c06:2d0b:2312:c058:b9a7:8857:8837)
2020-09-17 09:35:14 +0200 <kenran> ahh of course, I forgot that one doesn't do `instance Foldable (Foo a)` but `instance Foldable Foo)
2020-09-17 09:35:26 +0200 <kenran> thanks, very interesting!
2020-09-17 09:35:28 +0200 <nshepperd> i don't think b and c are really problems
2020-09-17 09:38:40 +0200 <nshepperd> yeah Foldable is meant to be applied to the, uh, generic container type
2020-09-17 09:38:45 +0200Unhammer(~Unhammer@gateway/tor-sasl/unhammer)
2020-09-17 09:39:22 +0200 <Unhammer> https://i.imgur.com/kyFW9B9.png duckduckgo found me an actual stack of haddocks =D
2020-09-17 09:40:24 +0200stiell(~stian@fsf/member/stiell) (Ping timeout: 256 seconds)
2020-09-17 09:41:10 +0200 <dminuoso> Unhammer: It wasnt until I visited scotland and england that I understood the reference. The brits do seem to eat a lot of haddock.
2020-09-17 09:41:36 +0200xlei(~akans@unaffiliated/xlei) (Quit: ZNC - https://znc.in)
2020-09-17 09:43:05 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 09:43:10 +0200 <Unhammer> well, it's yummy :) though I've never had it stacked before
2020-09-17 09:43:21 +0200 <Unhammer> `alias stack=smoke`
2020-09-17 09:43:25 +0200 <Unhammer> therewego
2020-09-17 09:43:44 +0200cfricke(~cfricke@unaffiliated/cfricke)
2020-09-17 09:44:10 +0200 <dminuoso> Oh haha I didn't get the joke until you mentioned that.
2020-09-17 09:44:18 +0200 <dminuoso> Cheeky
2020-09-17 09:46:07 +0200 <nshepperd> There's a different type class called MonoFoldable that you could give instances for Storable a => MonoFoldable (Vector a)
2020-09-17 09:46:49 +0200 <nshepperd> but defining MonoFoldable and using it requires extensions (type families) and is less convenient, so i don't think it's really commonly used
2020-09-17 09:47:48 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 09:54:16 +0200Sgeo(~Sgeo@ool-18b982ad.dyn.optonline.net) (Read error: Connection reset by peer)
2020-09-17 09:54:40 +0200mmohammadi9812(~mmohammad@5.238.164.128) (Quit: I quit (╯°□°）╯︵ ┻━┻)
2020-09-17 09:56:24 +0200mmohammadi9812(~mmohammad@5.238.164.128)
2020-09-17 09:56:40 +0200pera(~pera@unaffiliated/pera) (Ping timeout: 260 seconds)
2020-09-17 09:56:53 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb)
2020-09-17 09:57:31 +0200mmohammadi9812(~mmohammad@5.238.164.128) (Client Quit)
2020-09-17 09:59:37 +0200mmohammadi9812(~mmohammad@5.238.164.128)
2020-09-17 10:01:08 +0200nfd(~nfd9001@c-67-183-38-33.hsd1.wa.comcast.net) (Quit: Leaving)
2020-09-17 10:01:57 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 272 seconds)
2020-09-17 10:03:53 +0200dansho(~dansho@ip68-108-167-185.lv.lv.cox.net) (Quit: Leaving)
2020-09-17 10:03:57 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 10:05:53 +0200xlei(znc@unaffiliated/xlei)
2020-09-17 10:06:23 +0200revprez_anzio(~revprez_a@pool-108-49-213-40.bstnma.fios.verizon.net) (Ping timeout: 272 seconds)
2020-09-17 10:06:52 +0200Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi)
2020-09-17 10:06:57 +0200bahamas(~lucian@188.24.158.21)
2020-09-17 10:06:57 +0200bahamas(~lucian@188.24.158.21) (Changing host)
2020-09-17 10:06:58 +0200bahamas(~lucian@unaffiliated/bahamas)
2020-09-17 10:07:47 +0200cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net) (Quit: Goodbye)
2020-09-17 10:08:06 +0200revprez_anzio(~revprez_a@pool-108-49-213-40.bstnma.fios.verizon.net)
2020-09-17 10:08:22 +0200supercoven(~Supercove@dsl-hkibng32-54fb54-166.dhcp.inet.fi)
2020-09-17 10:08:35 +0200 <dminuoso> Is there a reason to use `cabal v2-test` over `cabal v2-run test:foo`?
2020-09-17 10:08:36 +0200nan`(~nan`@unaffiliated/nan/x-5405850)
2020-09-17 10:08:51 +0200 <dminuoso> The latter seems universally powerful since you can pass arguments to the testsuite
2020-09-17 10:08:53 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 10:09:04 +0200 <phadej> former runs multiple tests, changes to package directory, ...
2020-09-17 10:09:07 +0200 <phadej> is a bit different
2020-09-17 10:10:23 +0200 <dminuoso> Mmm, what kind of changes to the package directory?
2020-09-17 10:10:35 +0200 <dminuoso> Oh, you mean like the cwd?
2020-09-17 10:11:42 +0200oxide(~lambda@unaffiliated/mclaren)
2020-09-17 10:13:34 +0200nan`(~nan`@unaffiliated/nan/x-5405850) (Ping timeout: 260 seconds)
2020-09-17 10:13:50 +0200 <dminuoso> But I see what you mean, it is different. In case of hspec, v2-run can detect the interactive terminal properly, with v2-test it seems not
2020-09-17 10:20:03 +0200cantstanya(~chatting@gateway/tor-sasl/cantstanya) (Ping timeout: 240 seconds)
2020-09-17 10:20:20 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece)
2020-09-17 10:24:07 +0200cantstanya(~chatting@gateway/tor-sasl/cantstanya)
2020-09-17 10:24:35 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece) (Ping timeout: 244 seconds)
2020-09-17 10:24:49 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 10:26:26 +0200mmohammadi9812(~mmohammad@5.238.164.128) (Quit: I quit (╯°□°）╯︵ ┻━┻)
2020-09-17 10:26:56 +0200thc202(~thc202@unaffiliated/thc202)
2020-09-17 10:26:59 +0200raichoo(~raichoo@dslb-178-001-022-071.178.001.pools.vodafone-ip.de) (Quit: Lost terminal)
2020-09-17 10:27:12 +0200kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2020-09-17 10:28:09 +0200z0(~z0@bl15-162-186.dsl.telepac.pt) (Remote host closed the connection)
2020-09-17 10:28:19 +0200mmohammadi9812(~mmohammad@5.238.164.128)
2020-09-17 10:29:49 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 10:30:27 +0200vicfred_(~vicfred@unaffiliated/vicfred)
2020-09-17 10:31:10 +0200lemmih(~lemmih@2406:3003:2072:44:c9d8:3b2b:ae18:24e9) (Remote host closed the connection)
2020-09-17 10:31:32 +0200lemmih(~lemmih@2406:3003:2072:44:251c:6ccc:226:e43d)
2020-09-17 10:32:25 +0200s00pcan(~chris@075-133-056-178.res.spectrum.com) (Ping timeout: 240 seconds)
2020-09-17 10:33:03 +0200mmohammadi9812(~mmohammad@5.238.164.128) (Client Quit)
2020-09-17 10:33:37 +0200vicfred(~vicfred@unaffiliated/vicfred) (Ping timeout: 272 seconds)
2020-09-17 10:34:15 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 272 seconds)
2020-09-17 10:34:37 +0200 <kuribas> How do you solve the problem of having different types for a resource in a rest API? I came up with this solution: data Person read update extra = Person { age :: read Int , name :: update String, job :: extra String}
2020-09-17 10:34:38 +0200s00pcan(~chris@107.181.165.217)
2020-09-17 10:34:42 +0200mmohammadi9812(~mmohammad@5.238.164.128)
2020-09-17 10:35:38 +0200jneira(501e65ce@gateway/web/cgi-irc/kiwiirc.com/ip.80.30.101.206) (Ping timeout: 272 seconds)
2020-09-17 10:36:16 +0200 <kuribas> then type family Id where Id a = a; type family Null where Null a = Maybe Void
2020-09-17 10:37:22 +0200 <kuribas> Then I can do type ReadPerson = Person Id Id Id
2020-09-17 10:37:41 +0200 <kuribas> and type UpdatePerson = Person Null Id Null
2020-09-17 10:40:16 +0200 <kuribas> or the alternative is just to define three types ReadPerson, UpdatePerson, ShortReadPerson
2020-09-17 10:40:45 +0200 <kuribas> which uses simpler haskell, but doesn't ensure the consistency of the resource.
2020-09-17 10:42:50 +0200 <bahamas> I'm working on making a haskell quick reference and I'm reading through the haskell report. one thing confuses me. in what way are variables and constructors expressions? https://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-240003.2
2020-09-17 10:43:06 +0200 <bahamas> is it the fact that identifiers are expressions because they "return" a value?
2020-09-17 10:43:27 +0200 <kuribas> bahamas: haskell doesn't have the concept of return
2020-09-17 10:43:49 +0200 <kuribas> bahamas: variables are expressions in other language as while
2020-09-17 10:43:57 +0200 <kuribas> and Constructors in haskell or just functions
2020-09-17 10:43:59 +0200 <kuribas> :t Just
2020-09-17 10:44:01 +0200 <lambdabot> a -> Maybe a
2020-09-17 10:44:27 +0200Katarushisu(~Katarushi@cpc149712-finc20-2-0-cust535.4-2.cable.virginm.net) (Ping timeout: 256 seconds)
2020-09-17 10:44:37 +0200 <kuribas> s/as while/as well
2020-09-17 10:44:42 +0200 <bahamas> kuribas: I know
2020-09-17 10:44:44 +0200asan(~yan4138@61.170.146.94) (Ping timeout: 260 seconds)
2020-09-17 10:44:55 +0200 <kuribas> then what's the confusion
2020-09-17 10:44:58 +0200 <kuribas> ?
2020-09-17 10:45:40 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 10:46:16 +0200asan(~yan4138@124.78.128.72)
2020-09-17 10:46:21 +0200cmcma20(~cmcma20@l37-192-3-172.novotelecom.ru) (Quit: leaving)
2020-09-17 10:46:32 +0200 <bahamas> kuribas: well, how would you define an expression? my intuition tells me that an expression gives you a value. intuitively, function application is an expression, because the function returns a value
2020-09-17 10:46:41 +0200 <bahamas> however, in what way is a variable an expression?
2020-09-17 10:47:04 +0200 <kuribas> a variable gives you a value as well
2020-09-17 10:47:17 +0200 <kuribas> > let x = 1 in x
2020-09-17 10:47:18 +0200 <[exa]> bahamas: "represents" a value is better naming here I guess.
2020-09-17 10:47:20 +0200 <lambdabot> 1
2020-09-17 10:47:24 +0200 <lortabac> kuribas: alternatively, you can define three different types with the same field names and use GHC.Records.HasField or lenses to regain the ability to define generic operations over the 3 types
2020-09-17 10:47:33 +0200 <bahamas> and a constructor? a constructor, not a constructor application
2020-09-17 10:47:45 +0200vicfred_(~vicfred@unaffiliated/vicfred) (Quit: Leaving)
2020-09-17 10:47:51 +0200 <[exa]> bahamas: Nothing is a value right?
2020-09-17 10:47:57 +0200 <kuribas> bahamas: a constructor is a function
2020-09-17 10:48:06 +0200 <bahamas> and a function is a value
2020-09-17 10:48:23 +0200 <bahamas> what is wrong with saying that identifiers are expressions?
2020-09-17 10:48:32 +0200 <[exa]> nothing? :]
2020-09-17 10:48:34 +0200Katarushisu(~Katarushi@cpc149712-finc20-2-0-cust535.4-2.cable.virginm.net)
2020-09-17 10:48:43 +0200 <kuribas> an identifier is a syntactic construct
2020-09-17 10:48:57 +0200 <kuribas> it depends on the context if it's a value
2020-09-17 10:49:23 +0200stiell(~stian@fsf/member/stiell)
2020-09-17 10:50:20 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 10:50:50 +0200 <lortabac> kuribas: in my experience having different types is in most cases less annoying than dealing with the type families
2020-09-17 10:51:02 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb)
2020-09-17 10:51:14 +0200 <kuribas> lortabac: yeah, I guess you're right
2020-09-17 10:51:16 +0200 <bahamas> kuribas: ok. I think I know what you mean.
2020-09-17 10:51:46 +0200 <kuribas> lortabac: I find duplicateRecordFields and recordWildcards quite handy :)
2020-09-17 10:53:12 +0200 <kuribas> "let x = 2", the x is not an expression here, it's a variable binding.
2020-09-17 10:53:13 +0200 <dminuoso> bahamas: There's two connected notions of an expression: a) something that can be evaluated b) a grammatical production rule - the latter gives you all syntactical trees of evaluatable fragments
2020-09-17 10:53:55 +0200Lycurgus(~niemand@98.4.96.130)
2020-09-17 10:54:49 +0200 <bahamas> dminuoso: can you give an example of the second?
2020-09-17 10:55:28 +0200hackagepostgresql-binary 0.12.3.1 - Encoders and decoders for the PostgreSQL's binary format https://hackage.haskell.org/package/postgresql-binary-0.12.3.1 (NikitaVolkov)
2020-09-17 10:55:39 +0200 <kuribas> bahamas: also you are asking how to define an expression, but that page defines an expression exactly :) I guess you don't want a definition, but an intuition
2020-09-17 10:56:06 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 244 seconds)
2020-09-17 10:56:09 +0200 <dminuoso> bahamas: exp -> infixexp :: [context =>] type | infixexp
2020-09-17 10:56:19 +0200 <dminuoso> Is the topmost production rule for an expression in Haskell
2020-09-17 10:56:28 +0200hackagewai-extra 3.0.30 - Provides some basic WAI handlers and middleware. https://hackage.haskell.org/package/wai-extra-3.0.30 (MichaelSnoyman)
2020-09-17 10:57:19 +0200 <dminuoso> If you follow this down a bit, you'll end up with a production rule `aexp -> qvar | gcon | literal | ( exp ) | ...`
2020-09-17 10:59:30 +0200 <dminuoso> Roughly, you can think of Haskell evaluation as being a graph reduction machine on a haskell expression graph/tree.
2020-09-17 11:00:02 +0200AstroDroid(~AstroDroi@84.39.117.57) ()
2020-09-17 11:00:13 +0200 <dminuoso> (Taking expressions to expressions)
2020-09-17 11:00:56 +0200reed[m](reedriotfi@gateway/shell/matrix.org/x-zlxtwltpfmittewe) (Quit: Idle for 30+ days)
2020-09-17 11:01:00 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-09-17 11:02:37 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-09-17 11:06:32 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 11:09:28 +0200akegalj(~akegalj@93-136-206-221.adsl.net.t-com.hr)
2020-09-17 11:10:43 +0200ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex) (Ping timeout: 240 seconds)
2020-09-17 11:10:45 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 240 seconds)
2020-09-17 11:11:10 +0200dyeplexer(~lol@unaffiliated/terpin)
2020-09-17 11:12:18 +0200ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex)
2020-09-17 11:12:20 +0200 <kuribas> how would you ensure a lazy language is total?
2020-09-17 11:13:26 +0200 <kuribas> :t fix
2020-09-17 11:13:27 +0200 <lambdabot> (a -> a) -> a
2020-09-17 11:14:18 +0200 <phadej> fix isn't something you have to add to a language
2020-09-17 11:14:20 +0200 <kuribas> is there a fix-like function that doesn't diverge?
2020-09-17 11:14:23 +0200 <Lycurgus> by disregarding laziness as nothing more than a lang feature?
2020-09-17 11:14:37 +0200 <bahamas> dminuoso: does that mean that an expression's type signature is also an expression?
2020-09-17 11:14:48 +0200 <dminuoso> bahamas: There's an easy test:
2020-09-17 11:14:53 +0200 <dminuoso> bahamas: Go through the production rules
2020-09-17 11:15:02 +0200jzl(~jzl@unaffiliated/jzl) (Ping timeout: 256 seconds)
2020-09-17 11:15:10 +0200 <kuribas> bahamas: you can consider it a "type level expression"
2020-09-17 11:15:30 +0200 <kuribas> bahamas: however it isn't a value, it's a type.
2020-09-17 11:15:33 +0200jedws(~jedws@101.184.189.58) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-09-17 11:15:35 +0200 <dminuoso> bahamas: You'd need something like `aexp -> type | ...`
2020-09-17 11:15:40 +0200 <dminuoso> (or possibly not aexp, but you get the idea)
2020-09-17 11:15:55 +0200 <dminuoso> If such a production does not exist, then formally, a type is not an expression.
2020-09-17 11:16:13 +0200 <dminuoso> However, you can see it can be *part* of expressions, namely by the production rule:
2020-09-17 11:16:17 +0200 <dminuoso> exp -> infixexp :: [context =>] type
2020-09-17 11:16:34 +0200 <kuribas> Lycurgus: recursion can be total by ensuring the recursive step is smaller. But can you do the same with lazyness?
2020-09-17 11:17:16 +0200 <kuribas> Lycurgus: perhaps if the return of (a -> a) is smaller than the input?
2020-09-17 11:18:34 +0200 <kuribas> hmm, no because x = tail x still diverges...
2020-09-17 11:20:16 +0200 <bahamas> dminuoso: ok. all that recursion and the use of the name "infixexp" is confusing me a bit, but if I'm unpacking those terms, it's slowly falling into place
2020-09-17 11:20:19 +0200 <bahamas> thanks
2020-09-17 11:20:37 +0200 <Lycurgus> is laziness modeled as part of the active semantics of haskell? that's why I said what I did, that laziness is is between a compiler feature and the execution semantics
2020-09-17 11:20:45 +0200 <dminuoso> bahamas: Read a production `foo -> bar` as "to make a foo, use bar"
2020-09-17 11:20:57 +0200 <dminuoso> (It's why they are called production rules, they tell you how to *produce* the left hand side)
2020-09-17 11:21:02 +0200 <kuribas> Lycurgus: yes it is
2020-09-17 11:21:04 +0200 <Lycurgus> an if you only consider the latter then laziness can be disregarded
2020-09-17 11:21:41 +0200 <kuribas> Lycurgus: because bottom is part of the semantics, and lazyness changes the result when bottom is present.
2020-09-17 11:21:51 +0200 <Lycurgus> which is sort of cognitively consistent with a lang with the hubris or what ever to have ct as a model of computation
2020-09-17 11:21:55 +0200 <dminuoso> bahamas: And they are exhaustive. So if there's no production rule for some `f -> g`, then g does not make an f
2020-09-17 11:21:57 +0200blardo(~blardo@185.244.214.216)
2020-09-17 11:22:00 +0200ph88^(~ph88@ip5f5af726.dynamic.kabel-deutschland.de)
2020-09-17 11:22:42 +0200 <kuribas> > foldr const 1 (1:undefined)
2020-09-17 11:22:45 +0200 <lambdabot> 1
2020-09-17 11:22:56 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Quit: Quit.)
2020-09-17 11:22:56 +0200 <kuribas> Lycurgus: that would be bottom in a strict language
2020-09-17 11:23:07 +0200 <kuribas> Lycurgus: haskell ensures it's 1
2020-09-17 11:23:27 +0200 <Lycurgus> well i gave an easy and gordian way
2020-09-17 11:23:40 +0200 <Lycurgus> i suppose that's not the hs way tho
2020-09-17 11:24:02 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-09-17 11:24:07 +0200acidjnk_new3(~acidjnk@p200300d0c736587164f46f145ae9b6a7.dip0.t-ipconnect.de)
2020-09-17 11:24:29 +0200ph88_(~ph88@2a02:8109:9e40:2704:85f2:8dce:6e30:a554)
2020-09-17 11:24:44 +0200 <lortabac> kuribas: Agda is an example of a lazy total language
2020-09-17 11:25:14 +0200 <lortabac> maybe you can find some answers in the author's Phd thesis
2020-09-17 11:25:33 +0200ph88(~ph88@2a02:8109:9e40:2704:6cf2:c517:5b95:5f99) (Ping timeout: 272 seconds)
2020-09-17 11:27:03 +0200mirrorbird(~psutcliff@2a00:801:44b:8959:8d6c:276b:332b:1c71) (Quit: Leaving)
2020-09-17 11:27:21 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 11:27:53 +0200 <Taneb> I'm not sure the question is well defined: "lazy" is normally defined as there exist some functions such that f _|_ /= _|_. In a total language, there is no _|_ so we can't decide if the language is lazy or not
2020-09-17 11:28:01 +0200someuser123(59b76050@a89-183-96-80.net-htp.de)
2020-09-17 11:28:25 +0200ph88^(~ph88@ip5f5af726.dynamic.kabel-deutschland.de) (Ping timeout: 264 seconds)
2020-09-17 11:29:03 +0200 <lortabac> Taneb: you can still talk about the order of evaluation and sharing, can't you?
2020-09-17 11:29:19 +0200eric(~eric@2804:431:c7d4:b75:19f7:ea85:5be8:4c8e)
2020-09-17 11:29:37 +0200 <someuser123> is there a conventional name for a function `m a -> a` where `m` is a monad?
2020-09-17 11:30:21 +0200 <dminuoso> someuser123: Cokleisli Arrow
2020-09-17 11:30:27 +0200 <dminuoso> fsvo of "conventional"
2020-09-17 11:30:28 +0200 <merijn> someuser123: "nonexistent" :)
2020-09-17 11:32:00 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 11:33:26 +0200 <dminuoso> Oh wait, heh. Well that only works if m was a comonad. :)
2020-09-17 11:34:02 +0200v0d1ch(~v0d1ch@cable-178-148-120-241.dynamic.sbb.rs)
2020-09-17 11:34:16 +0200 <maerwald> quiz question: what does `LimitTo` in persistent do if you pass 0?
2020-09-17 11:34:17 +0200 <dminuoso> someuser123: Do you mean `m` as some *particular* monad, or just any monad?
2020-09-17 11:35:21 +0200cpressey(~cpressey@79-72-201-114.dynamic.dsl.as9105.com)
2020-09-17 11:35:41 +0200eric(~eric@2804:431:c7d4:b75:19f7:ea85:5be8:4c8e) (Ping timeout: 272 seconds)
2020-09-17 11:35:43 +0200 <someuser123> I'm thinking of a monad like Maybe that is used to capture computation which can fail
2020-09-17 11:36:23 +0200 <edwardk> lortabac: laziness in a total language is the differents between 'terminates' and 'terminates in my lifetime'
2020-09-17 11:36:54 +0200 <kuribas> someuser123: Maybe has fromJust which you shouldn't use
2020-09-17 11:37:17 +0200 <kuribas> someuser123: use fromMaybe instead
2020-09-17 11:37:27 +0200 <someuser123> kuribas: why not?
2020-09-17 11:37:45 +0200 <merijn> someuser123: Because it's bad and broken and you will regret it :p
2020-09-17 11:37:47 +0200 <kuribas> someuser123: because it will crash on Nothing
2020-09-17 11:37:49 +0200 <maerwald> someuser123: it's fine to use in local context or where you don't mind something to crash
2020-09-17 11:38:20 +0200 <merijn> maerwald: What local context is it fine in?
2020-09-17 11:38:34 +0200 <maerwald> merijn: where you have local proof that it's never Nothing
2020-09-17 11:38:37 +0200 <kuribas> it's never fine to crash without meaningful error message
2020-09-17 11:38:40 +0200 <kuribas> or stack trace
2020-09-17 11:38:52 +0200 <lortabac> edwardk: can you expand? I'm not sure I understand
2020-09-17 11:39:08 +0200 <merijn> maerwald: I don't see many case where you have both such a proof and still can't skip the maybe
2020-09-17 11:39:43 +0200 <edwardk> termination checking in a fancy total language might take until the sun explodes. its pretty easy to build tings that theoretically terminate, but won't terminate in my lifetime.
2020-09-17 11:40:15 +0200 <edwardk> laziness lets you skip some of the evaluation of parts, so while sure those parts will terminate eventually, it might be nice to not do that work at all
2020-09-17 11:40:27 +0200 <maerwald> merijn: I'm not sure I follow.
2020-09-17 11:41:45 +0200 <merijn> maerwald: I can't really think of any case where I have a proof that it's not Nothing where I can't simple skip going through Maybe (and thus fromJust)
2020-09-17 11:41:47 +0200 <maerwald> if you have a regex building function that might return Nothing, but there is no user input and you've verified it compiles at runtime, there's no point going through hoops just to satisfy the totality illusion
2020-09-17 11:42:14 +0200 <merijn> maerwald: Then you want
2020-09-17 11:42:20 +0200 <merijn> @hackage validated-literals ;)
2020-09-17 11:42:20 +0200 <lambdabot> https://hackage.haskell.org/package/validated-literals ;)
2020-09-17 11:42:27 +0200 <maerwald> I'm aware of that, this was an example
2020-09-17 11:42:31 +0200 <lortabac> edwardk: ok I see, thanks
2020-09-17 11:43:04 +0200 <edwardk> as an example, when writing a dependent type checker itself, i wind up having to eval terms to normal form. but those terms often carry around things like unerased type info. _eval_ doesn't care, but maybe they might appear in the final normal form
2020-09-17 11:43:22 +0200 <edwardk> but i should lazily skip past crunching those things down in case i don't need to compute those answers
2020-09-17 11:43:49 +0200 <edwardk> sure it'd terminate but it'd bloat the memory footprint of the proof process and significantly slow it down
2020-09-17 11:43:58 +0200 <kuribas> maerwald: if you have many regexes, change one of those then you don't know which one blew up.
2020-09-17 11:44:30 +0200 <maerwald> then don't use it
2020-09-17 11:44:44 +0200 <kuribas> maerwald: and if you know which one blew, it doesn't say what's wrong with it.
2020-09-17 11:44:51 +0200Franciman(~Franciman@acqua.team)
2020-09-17 11:45:16 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb)
2020-09-17 11:46:27 +0200 <Unhammer> Upgraded from 8.6.5 to 8.8.4, project compile time went from 3m to 2m30s, compile after changing single (TH) file from 30s to 24s :-) and the windows binary size went from 53MB to 43MB. That's pretty nice :-)
2020-09-17 11:47:15 +0200 <merijn> Unhammer: You can probably drastically shrink further
2020-09-17 11:47:26 +0200 <merijn> Unhammer: Enable split-sections
2020-09-17 11:47:34 +0200 <maerwald> does windows support split-sections?
2020-09-17 11:47:40 +0200 <Unhammer> on windows?
2020-09-17 11:47:45 +0200Lycurgus(~niemand@98.4.96.130) (Quit: Exeunt)
2020-09-17 11:47:45 +0200 <merijn> hmm, not sure?
2020-09-17 11:47:50 +0200 <merijn> Only one way to find out :p
2020-09-17 11:47:55 +0200da39a3ee5e6b4b0d(~textual@2403:6200:8876:37d7:55fb:4d37:ffc2:715b) (Ping timeout: 240 seconds)
2020-09-17 11:48:02 +0200 <merijn> Unhammer: Also, don't forget to strip
2020-09-17 11:48:16 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 11:48:26 +0200 <Unhammer> I think stack does that for me
2020-09-17 11:48:28 +0200 <Unhammer> on stack install
2020-09-17 11:48:56 +0200 <Unhammer> yeah, the one in "dist" is 64M, and the one in "install" doesn't get smaller when stripping
2020-09-17 11:49:04 +0200 <merijn> hmmm
2020-09-17 11:49:55 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 244 seconds)
2020-09-17 11:50:28 +0200hackageZ-Data 0.1.1.0 - array, vector and text https://hackage.haskell.org/package/Z-Data-0.1.1.0 (winterland)
2020-09-17 11:50:46 +0200 <Unhammer> oh I need to rebuild all deps to try split-sections … guess I'll wait, need to do some actual work instead of faffing around with compiler versions =P
2020-09-17 11:51:24 +0200 <merijn> Unhammer: Yeah, you do
2020-09-17 11:51:35 +0200 <merijn> Unhammer: It makes *massive* difference, though
2020-09-17 11:52:07 +0200 <merijn> Unhammer: Like, 10x on my executables
2020-09-17 11:52:54 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 11:54:17 +0200 <kuribas> merijn: why doesn't it do this by default?
2020-09-17 11:54:41 +0200alp_(~alp@2a01:e0a:58b:4920:90ae:a5d:9349:f8d8) (Ping timeout: 272 seconds)
2020-09-17 11:55:24 +0200 <merijn> kuribas: Because it's fairly new, doesn't work on all platforms, etc.
2020-09-17 11:55:28 +0200 <Unhammer> https://gitlab.haskell.org/ghc/ghc/-/issues/11445
2020-09-17 11:55:48 +0200 <merijn> hmm, older than I thought :p
2020-09-17 11:56:15 +0200 <Unhammer> does it work to put it in global stack.yaml ?
2020-09-17 11:56:36 +0200 <phadej> merijn: IIRC it was broken / not working somewhere somewhat
2020-09-17 11:57:03 +0200 <merijn> It doesn't work on macOS
2020-09-17 11:57:11 +0200 <maerwald> merijn: you don't need it there
2020-09-17 11:57:23 +0200 <merijn> maerwald: I know, but GHC error exited when you specified it
2020-09-17 11:57:29 +0200 <maerwald> yep
2020-09-17 11:57:32 +0200 <merijn> (now fixed after I whined about it)
2020-09-17 11:57:45 +0200 <merijn> Now it's just a warning on macOS
2020-09-17 11:58:42 +0200 <phadej> a problem is that GHC doesn't tell whether it's supported
2020-09-17 11:58:53 +0200 <phadej> there is ("Object splitting supported","YES") entry, which is about -split-objs
2020-09-17 11:58:57 +0200 <phadej> but not for -split-sections
2020-09-17 11:59:46 +0200 <phadej> GHC is not very uniform in how it exposes features
2020-09-17 12:00:04 +0200 <phadej> (to allow auto-configuration, vs. hardcoding stuff about particular compiler versions into Cabal)
2020-09-17 12:01:22 +0200 <phadej> an example
2020-09-17 12:01:24 +0200 <phadej> it tells
2020-09-17 12:01:24 +0200 <phadej> ,("unlit command","/opt/ghc/8.10.1/lib/ghc-8.10.1/bin/unlit")
2020-09-17 12:01:30 +0200 <phadej> but doesn't tell e.g. `ghc-pkg command`
2020-09-17 12:01:37 +0200 <phadej> so Cabal have to use heuristics to find one
2020-09-17 12:01:59 +0200 <phadej> (where I have no idea what's use case to knowing where is unlit command :P)
2020-09-17 12:02:19 +0200 <merijn> phadej: Sounds like we need a ticket about all missing things there and add them to GHC
2020-09-17 12:03:03 +0200 <phadej> merijn: one needs a pedantic person looking after that
2020-09-17 12:03:12 +0200yahb(xsbot@haskell/bot/yahb) (Ping timeout: 256 seconds)
2020-09-17 12:03:23 +0200yahb(xsbot@178.219.36.155)
2020-09-17 12:03:23 +0200yahb(xsbot@178.219.36.155) (Changing host)
2020-09-17 12:03:23 +0200yahb(xsbot@haskell/bot/yahb)
2020-09-17 12:03:26 +0200z0(~z0@bl15-162-186.dsl.telepac.pt)
2020-09-17 12:03:32 +0200 <phadej> new features need to get to that list when they introduced, not 2-3 releases after
2020-09-17 12:05:05 +0200 <merijn> kuribas: The short answer to why it's not the default is: Insufficient people baby sitting these sorts of tickets/fixes, tracking whether they work everywhere and flipping the switch
2020-09-17 12:05:28 +0200 <kuribas> merijn: the flipside of avoiding success.
2020-09-17 12:08:16 +0200Tops2(~Tobias@dyndsl-095-033-091-070.ewe-ip-backbone.de)
2020-09-17 12:08:39 +0200 <maerwald> pedantic person? Someone called my name?
2020-09-17 12:09:05 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 12:09:06 +0200 <merijn> maerwald: Please do :p
2020-09-17 12:10:04 +0200 <someuser123> where can I see the precedence ranks of operators such as <*> and <$>?
2020-09-17 12:10:22 +0200 <merijn> % :i (<$>)
2020-09-17 12:10:22 +0200 <yahb> merijn: (<$>) :: Functor f => (a -> b) -> f a -> f b -- Defined in `Data.Functor'; infixl 4 <$>
2020-09-17 12:10:33 +0200 <merijn> someuser123: The "infixl 4" is precedence
2020-09-17 12:10:36 +0200 <merijn> % :i (<*>)
2020-09-17 12:10:37 +0200 <yahb> merijn: type Applicative :: (* -> *) -> Constraint; class Functor f => Applicative f where; ...; (<*>) :: f (a -> b) -> f a -> f b; ...; -- Defined in `GHC.Base'; infixl 4 <*>
2020-09-17 12:10:46 +0200 <merijn> So, precedence level 4, left associative
2020-09-17 12:11:21 +0200alp_(~alp@88.126.45.36)
2020-09-17 12:11:40 +0200 <someuser123> thanks
2020-09-17 12:11:42 +0200adauguet(4d838b43@67.139.131.77.rev.sfr.net)
2020-09-17 12:12:12 +0200bahamas(~lucian@unaffiliated/bahamas) (Ping timeout: 256 seconds)
2020-09-17 12:14:19 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 12:14:24 +0200sw1nn(~sw1nn@host81-146-21-49.range81-146.btcentralplus.com) (Quit: WeeChat 2.9)
2020-09-17 12:14:58 +0200 <adauguet> Hi everyone, is this the right place to ask beginners questions about haskell?
2020-09-17 12:14:59 +0200 <dminuoso> Unhammer: I have added `split-sections: true` to my ~/.cabal/config and made profits ever since! :)
2020-09-17 12:15:03 +0200 <dminuoso> adauguet: Yes.
2020-09-17 12:15:25 +0200 <dminuoso> adauguet: You can also use #haskell-beginners if you want a more quiet/less chatty place, but we dont mind the most naive beginner questions either.
2020-09-17 12:15:36 +0200sw1nn(~sw1nn@host81-146-21-49.range81-146.btcentralplus.com)
2020-09-17 12:16:02 +0200 <adauguet> thanks, i will try on #haskell-beginners then
2020-09-17 12:18:43 +0200fendor(~fendor@77.119.129.27.wireless.dyn.drei.com)
2020-09-17 12:22:59 +0200darjeeling_(~darjeelin@115.215.41.222)
2020-09-17 12:24:32 +0200mmohammadi9812(~mmohammad@5.238.164.128) (Quit: I quit (╯°□°）╯︵ ┻━┻)
2020-09-17 12:27:58 +0200jumper149(~jumper149@ip185225.wh.uni-hannover.de)
2020-09-17 12:28:26 +0200nan`(~nan`@unaffiliated/nan/x-5405850)
2020-09-17 12:29:59 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 12:32:13 +0200perdent(~k4fr@212.102.36.136)
2020-09-17 12:32:22 +0200 <perdent> Anyone here want to be hired to code a 'hacking' CTF challenge for money? If so PM me for further details
2020-09-17 12:33:28 +0200nan`(~nan`@unaffiliated/nan/x-5405850) (Ping timeout: 260 seconds)
2020-09-17 12:33:28 +0200 <Raito_Bezarius> perdent: what's the relation with Haskell?
2020-09-17 12:34:28 +0200 <perdent> Raito_Bezarius: I want it to be coded in haskell
2020-09-17 12:34:33 +0200urodna(~urodna@unaffiliated/urodna)
2020-09-17 12:34:44 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 12:35:07 +0200 <perdent> Makes it more difficult for participants who are not used to functional programming
2020-09-17 12:35:48 +0200 <[exa]> also a lot more difficult to actually C the F
2020-09-17 12:36:29 +0200pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net) (Quit: gone to sleep. ZZZzzz…)
2020-09-17 12:39:15 +0200gnumonik(~gnumonik@c-73-170-91-210.hsd1.ca.comcast.net) (Quit: Leaving)
2020-09-17 12:39:27 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb)
2020-09-17 12:44:25 +0200rapskalian(~user@2601:804:8400:5750:6d07:cb01:64a9:36bb) (Ping timeout: 240 seconds)
2020-09-17 12:44:34 +0200darjeeling_(~darjeelin@115.215.41.222) (Ping timeout: 256 seconds)
2020-09-17 12:45:42 +0200sagax(~sagax_nb@213.138.71.146)
2020-09-17 12:45:47 +0200fendor(~fendor@77.119.129.27.wireless.dyn.drei.com) (Remote host closed the connection)
2020-09-17 12:46:51 +0200darjeeling_(~darjeelin@115.215.41.222)
2020-09-17 12:47:16 +0200Tops21(~Tobias@dyndsl-095-033-091-070.ewe-ip-backbone.de)
2020-09-17 12:48:25 +0200Tops2(~Tobias@dyndsl-095-033-091-070.ewe-ip-backbone.de) (Ping timeout: 240 seconds)
2020-09-17 12:50:02 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net)
2020-09-17 12:51:06 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 12:51:37 +0200Amras(~Amras@unaffiliated/amras0000)
2020-09-17 12:53:10 +0200 <dminuoso> How can I extract the test-suite binary in v2-*?
2020-09-17 12:53:24 +0200someuser123(59b76050@a89-183-96-80.net-htp.de) (Ping timeout: 245 seconds)
2020-09-17 12:55:17 +0200toorevitimirp(~tooreviti@117.182.182.33)
2020-09-17 12:56:52 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 13:05:17 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net)
2020-09-17 13:08:00 +0200adauguet(4d838b43@67.139.131.77.rev.sfr.net) (Ping timeout: 245 seconds)
2020-09-17 13:10:18 +0200olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber) (Remote host closed the connection)
2020-09-17 13:12:02 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 13:13:29 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Quit: Quit.)
2020-09-17 13:13:57 +0200ajcerejeira(~ajcerejei@2001:8a0:ddee:700:efbc:7163:11a0:b83)
2020-09-17 13:13:58 +0200jchia_(~jchia@58.32.37.220) (Quit: Leaving.)
2020-09-17 13:14:00 +0200 <maerwald> dminuoso: same as any other
2020-09-17 13:14:28 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-09-17 13:16:12 +0200 <dminuoso> Well until now it was just with `cp $(cabal v2-exec -- which foo) ..`
2020-09-17 13:16:21 +0200Turmfalke(~user@unaffiliated/siracusa)
2020-09-17 13:16:25 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 240 seconds)
2020-09-17 13:16:26 +0200 <dminuoso> So I guess you're proposing to just use cabal-plan?
2020-09-17 13:16:42 +0200yoneda(~mike@193.206.102.122) (Quit: leaving)
2020-09-17 13:17:33 +0200 <maerwald> I did that v2-exec with spec test as well I believe
2020-09-17 13:18:44 +0200rprije(~rprije@27.143.220.203.dial.dynamic.acc01-myal-dub.comindico.com.au) (Ping timeout: 260 seconds)
2020-09-17 13:18:44 +0200 <dminuoso> Ah, I did not realize the testsuite binaries are called after their testsuite name.
2020-09-17 13:19:35 +0200jchia__(~jchia@58.32.37.220) (Quit: Leaving.)
2020-09-17 13:19:59 +0200jchia__(~jchia@58.32.37.220)
2020-09-17 13:20:12 +0200jchia__(~jchia@58.32.37.220) (Client Quit)
2020-09-17 13:20:35 +0200Neuromancer(~Neuromanc@unaffiliated/neuromancer)
2020-09-17 13:21:18 +0200tchouri(~tchouri@gateway/tor-sasl/hekkaidekapus)
2020-09-17 13:21:27 +0200 <WzC> does anyone know how to get a fully statically compiled executable using ghc these days?
2020-09-17 13:21:46 +0200 <maerwald> WzC: with alipne
2020-09-17 13:22:02 +0200 <WzC> the internet claims 'ghc -static -optl-static -optl-pthread' should work, but that gives a bunch of errors
2020-09-17 13:22:10 +0200 <merijn> WzC: Depends on how extreme you wanna take "full static" :)
2020-09-17 13:22:23 +0200 <maerwald> there's only full static or none at all
2020-09-17 13:22:55 +0200 <WzC> as in: everything (including dependent c-libs) included in the binary
2020-09-17 13:22:57 +0200 <merijn> WzC: Well, for one, on linux you're hosed because glibc can't be linked statically, so you need a linux (or toolchain, at least) that has a statically linkable libc
2020-09-17 13:23:03 +0200 <maerwald> WzC: see https://github.com/actions/setup-haskell/issues/31#issuecomment-676001831
2020-09-17 13:23:43 +0200hekkaidekapus(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 240 seconds)
2020-09-17 13:23:51 +0200jchia__(~jchia@45.32.62.73)
2020-09-17 13:24:06 +0200jchia__(~jchia@45.32.62.73) (Client Quit)
2020-09-17 13:24:31 +0200jchia__(~jchia@45.32.62.73)
2020-09-17 13:24:40 +0200 <WzC> hmm I'll have to read through that a bit
2020-09-17 13:24:41 +0200jchia__(~jchia@45.32.62.73) (Client Quit)
2020-09-17 13:26:14 +0200 <WzC> essentially I'm trying to set up ghc in domjudge, some system to compile student handins and test them. Somehow the system is running the compiled executables in some chroot, and hence the basic approach to avoid that would be to compile static binaries
2020-09-17 13:26:16 +0200 <dminuoso> WzC: If you're a nix user, there's a static haskell overlay.
2020-09-17 13:26:24 +0200 <maerwald> which sometimes works
2020-09-17 13:27:09 +0200 <maerwald> WzC: it's easy
2020-09-17 13:27:10 +0200 <WzC> this is essentially what I now get with those options though: https://gist.github.com/noinia/a77769a70b833496501ffb6a6e64472f
2020-09-17 13:27:59 +0200akegalj_(~akegalj@93-142-93-99.adsl.net.t-com.hr)
2020-09-17 13:28:59 +0200ubert(~Thunderbi@178.165.131.132.wireless.dyn.drei.com)
2020-09-17 13:31:36 +0200akegalj(~akegalj@93-136-206-221.adsl.net.t-com.hr) (Ping timeout: 256 seconds)
2020-09-17 13:32:50 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 13:33:20 +0200TooDifficult(~TooDiffic@139.59.59.230)
2020-09-17 13:33:27 +0200hackageniv 0.2.18 - Easy dependency management for Nix projects https://hackage.haskell.org/package/niv-0.2.18 (nmattia)
2020-09-17 13:34:42 +0200gmt(~gmt@pool-71-105-108-44.nycmny.fios.verizon.net)
2020-09-17 13:34:59 +0200Stanley00(~stanley00@unaffiliated/stanley00) (Remote host closed the connection)
2020-09-17 13:35:09 +0200cpressey(~cpressey@79-72-201-114.dynamic.dsl.as9105.com) (Quit: kwit)
2020-09-17 13:35:45 +0200ALM49(7bc007ac@123-192-7-172.dynamic.kbronet.com.tw)
2020-09-17 13:36:01 +0200Dolly(585fd1fd@ti0203q160-5312.bb.online.no)
2020-09-17 13:36:21 +0200 <ALM49> Is it possible to qualify an infix operator?
2020-09-17 13:36:44 +0200 <lortabac> yes
2020-09-17 13:36:55 +0200 <opqdonut> > 1 Prelude.+ 2
2020-09-17 13:36:57 +0200 <lambdabot> 3
2020-09-17 13:36:59 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 240 seconds)
2020-09-17 13:37:02 +0200 <ALM49> ie. If I want to use `List.(++)` instead of having to `import Data.List (++)`
2020-09-17 13:37:13 +0200 <dminuoso> ALM49: No, you have to explicitly add an import.
2020-09-17 13:37:23 +0200 <opqdonut> but it could be a qualified import
2020-09-17 13:37:37 +0200 <ALM49> Oh, so I just omit the parentheses?
2020-09-17 13:37:47 +0200 <dminuoso> ALM49: Add additional parentheses.
2020-09-17 13:38:02 +0200 <dminuoso> import Data.List ((++)), and if you want it qualified you can do `import qualified Data.List ((++))`
2020-09-17 13:38:20 +0200 <dminuoso> And, then you can give an alias as well, like `import qualified Data.List as L ((++))`
2020-09-17 13:38:56 +0200gmt(~gmt@pool-71-105-108-44.nycmny.fios.verizon.net) (Ping timeout: 246 seconds)
2020-09-17 13:39:47 +0200george_____t(5c094cd5@host-92-9-76-213.as43234.net)
2020-09-17 13:40:17 +0200oxide(~lambda@unaffiliated/mclaren) (Read error: Connection reset by peer)
2020-09-17 13:40:30 +0200 <ALM49> oh, that's strange
2020-09-17 13:40:41 +0200 <ALM49> So I'd write something like
2020-09-17 13:40:44 +0200 <ALM49> `(List.++) "abc" "def"`
2020-09-17 13:41:54 +0200 <ALM49> Why do I need the parens there? What could that conflict with?
2020-09-17 13:43:14 +0200 <dminuoso> You're writing it in prefix position.
2020-09-17 13:43:30 +0200AlterEgo-(~ladew@124-198-158-163.dynamic.caiway.nl)
2020-09-17 13:43:57 +0200 <dminuoso> You can write named functions in infix position by wrapping them in ``, and you can write operators in prefix position by wrapping them in parens
2020-09-17 13:44:12 +0200 <dminuoso> The maybe confusing part is to realize that List.++ is an operator
2020-09-17 13:44:15 +0200 <ALM49> Wow, it never occured to me that I could use a qualified operator in infix position
2020-09-17 13:44:18 +0200gxt(~gxt@gateway/tor-sasl/gxt) (Remote host closed the connection)
2020-09-17 13:44:22 +0200 <dminuoso> Well, it *is* and remains an operator. ;)
2020-09-17 13:44:59 +0200gmt(~gmt@pool-71-105-108-44.nycmny.fios.verizon.net)
2020-09-17 13:45:03 +0200 <ALM49> Well, coming from OCaml, operators are basically just identifiers
2020-09-17 13:45:09 +0200gxt(~gxt@gateway/tor-sasl/gxt)
2020-09-17 13:45:30 +0200 <ALM49> I didn't realise that Haskell has a distinction between them
2020-09-17 13:45:31 +0200gxt(~gxt@gateway/tor-sasl/gxt) (Remote host closed the connection)
2020-09-17 13:47:11 +0200frdg`(~user@pool-71-184-143-249.bstnma.fios.verizon.net)
2020-09-17 13:48:21 +0200gxt(~gxt@gateway/tor-sasl/gxt)
2020-09-17 13:49:19 +0200frdg(~user@pool-71-184-143-249.bstnma.fios.verizon.net) (Ping timeout: 272 seconds)
2020-09-17 13:49:52 +0200 <dminuoso> ALM49: There's even more going on. We have a 2x2 matrix of [["Variable identifier", "Constructor identifier"], ["Operator identifier", "Operator constructor"]]
2020-09-17 13:50:18 +0200 <dminuoso> A common example of operator constructors is (:) from list. :)
2020-09-17 13:50:56 +0200 <dminuoso> https://www.haskell.org/onlinereport/haskell2010/haskellch2.html#x7-180002.4 contains a very readable and concise definition
2020-09-17 13:51:56 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Quit: Quit.)
2020-09-17 13:52:40 +0200lemmih(~lemmih@2406:3003:2072:44:251c:6ccc:226:e43d) (Remote host closed the connection)
2020-09-17 13:53:02 +0200lemmih(~lemmih@2406:3003:2072:44:251c:6ccc:226:e43d)
2020-09-17 13:53:40 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 13:53:56 +0200frdg``(~user@pool-71-184-143-249.bstnma.fios.verizon.net)
2020-09-17 13:54:25 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2020-09-17 13:54:36 +0200frdg``(~user@pool-71-184-143-249.bstnma.fios.verizon.net) ()
2020-09-17 13:54:49 +0200mmohammadi9812(~mmohammad@5.238.164.128)
2020-09-17 13:54:56 +0200arjaz(~user@91.218.15.22)
2020-09-17 13:55:00 +0200arjaz(~user@91.218.15.22) ()
2020-09-17 13:55:13 +0200jonathanx(~jonathan@dyn-8-sc.cdg.chalmers.se) (Ping timeout: 260 seconds)
2020-09-17 13:56:26 +0200sQVe(~sQVe@unaffiliated/sqve)
2020-09-17 13:58:22 +0200 <ALM49> thanks dminuoso
2020-09-17 13:58:25 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 264 seconds)
2020-09-17 13:58:44 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-09-17 13:58:49 +0200frdg`(~user@pool-71-184-143-249.bstnma.fios.verizon.net) (Ping timeout: 272 seconds)
2020-09-17 13:58:52 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net) (Ping timeout: 260 seconds)
2020-09-17 13:59:46 +0200knupfer(~Thunderbi@dynamic-046-114-150-052.46.114.pool.telefonica.de)
2020-09-17 13:59:54 +0200toorevitimirp(~tooreviti@117.182.182.33) (Ping timeout: 260 seconds)
2020-09-17 14:00:01 +0200blardo(~blardo@185.244.214.216) ()
2020-09-17 14:00:45 +0200tchourihekkaidekapus
2020-09-17 14:02:44 +0200ericsagnes(~ericsagne@i153-145-14-232.s42.a013.ap.plala.or.jp) (Ping timeout: 246 seconds)
2020-09-17 14:03:22 +0200sQVe(~sQVe@unaffiliated/sqve) (Ping timeout: 272 seconds)
2020-09-17 14:03:26 +0200 <ski> kuribas : "perhaps if the return of (a -> a) is smaller than the input?" -- how about if it's larger ?
2020-09-17 14:03:37 +0200 <ski> kuribas : "is there a fix-like function that doesn't diverge?" -- maybe some variant of `loeb' ?
2020-09-17 14:03:43 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net)
2020-09-17 14:03:58 +0200 <kuribas> ski: never heard of loeb... I'll look it up
2020-09-17 14:04:32 +0200 <hekkaidekapus> ALM49: In ghci, you can use qualified identifiers without a prior module import.
2020-09-17 14:04:44 +0200 <hekkaidekapus> % 4 Data.List.NonEmpty.:| [5, 6]
2020-09-17 14:04:45 +0200 <yahb> hekkaidekapus: 4 :| [5,6]
2020-09-17 14:05:25 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Quit: Quit.)
2020-09-17 14:05:27 +0200fendor(~fendor@e237-037.eduroam.tuwien.ac.at)
2020-09-17 14:06:36 +0200 <ski> kuribas : the usual Haskell combinator with that name is
2020-09-17 14:06:40 +0200lemmih(~lemmih@2406:3003:2072:44:251c:6ccc:226:e43d) (Remote host closed the connection)
2020-09-17 14:06:59 +0200lemmih(~lemmih@2406:3003:2072:44:251c:6ccc:226:e43d)
2020-09-17 14:07:46 +0200 <ski> @let loeb :: Functor f => f (f a -> a) -> f a; loeb fs = fa where fa = fmap ($ fa) ff
2020-09-17 14:07:48 +0200 <lambdabot> .L.hs:218:26: error:
2020-09-17 14:07:48 +0200 <lambdabot> • Variable not in scope: ff :: f1 (f1 b -> b)
2020-09-17 14:07:48 +0200 <lambdabot> • Perhaps you meant one of these:
2020-09-17 14:07:52 +0200 <ski> @let loeb :: Functor f => f (f a -> a) -> f a; loeb fs = fa where fa = fmap ($ fa) fs
2020-09-17 14:07:54 +0200 <lambdabot> Defined.
2020-09-17 14:08:01 +0200sQVe(~sQVe@unaffiliated/sqve)
2020-09-17 14:08:24 +0200sQVe(~sQVe@unaffiliated/sqve) (Client Quit)
2020-09-17 14:09:04 +0200 <ski> > loeb [sum . tail,length,const 2,liftA2 (*) (!! 1) (!! 2)]
2020-09-17 14:09:07 +0200 <lambdabot> [14,4,2,8]
2020-09-17 14:11:20 +0200dmiles(dmiles@c-73-67-179-188.hsd1.wa.comcast.net) (Ping timeout: 265 seconds)
2020-09-17 14:12:57 +0200pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net)
2020-09-17 14:12:59 +0200knupfer(~Thunderbi@dynamic-046-114-150-052.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2020-09-17 14:13:25 +0200 <kuribas> what weird magic is this?
2020-09-17 14:13:35 +0200ajcerejeira(~ajcerejei@2001:8a0:ddee:700:efbc:7163:11a0:b83) (Quit: ajcerejeira)
2020-09-17 14:13:48 +0200 <yushyin> loeb magic
2020-09-17 14:14:35 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 14:16:30 +0200 <enikar> :t loeb
2020-09-17 14:16:32 +0200 <lambdabot> Functor f => f (f a -> a) -> f a
2020-09-17 14:17:44 +0200 <ski> (named after some kind of analogy with <https://en.wikipedia.org/wiki/L%C3%B6b%27s_theorem>,<https://en.wikipedia.org/wiki/L%C3%B6b's_paradox>)
2020-09-17 14:17:49 +0200 <Uniaika> rally racing has made its way into Haskell!
2020-09-17 14:17:58 +0200 <ski> racing ?
2020-09-17 14:18:28 +0200 <Uniaika> https://en.wikipedia.org/wiki/S%C3%A9bastien_Loeb
2020-09-17 14:18:28 +0200 <phadej> https://en.wikipedia.org/wiki/S%C3%A9bastien_Loeb
2020-09-17 14:18:29 +0200 <Uniaika> :)
2020-09-17 14:18:34 +0200 <phadej> (:
2020-09-17 14:18:35 +0200 <Uniaika> haha, raced, phadej!
2020-09-17 14:18:42 +0200 <ski> hm, never heard about him
2020-09-17 14:18:54 +0200 <Uniaika> oh don't worry, I know him because I'm french
2020-09-17 14:19:01 +0200 <phadej> finns know rally too
2020-09-17 14:19:24 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 14:19:33 +0200 <ski> kuribas : anyway, can you follow that example, or would you like a hint ?
2020-09-17 14:21:05 +0200bicho_rastrero(~cerdito@154.85-87-39.dynamic.clientes.euskaltel.es)
2020-09-17 14:21:33 +0200 <phadej> eh, 9 consecutive championships
2020-09-17 14:21:42 +0200 <phadej> might been a bit boring at the end
2020-09-17 14:22:17 +0200 <kuribas> ski: more or less... I'll study it another time
2020-09-17 14:22:58 +0200 <phadej> "Loeb is a tarmac expert, having won all but three of the WRC rallies on that surface in which he has participated between 2005 and 2013."
2020-09-17 14:24:12 +0200 <ski> kuribas : basically, that example works sortof like a spreadsheet. every "cell" can refer to the value of all the other "cells"
2020-09-17 14:24:32 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz)
2020-09-17 14:24:37 +0200 <kuribas> ski: a comonad?
2020-09-17 14:24:59 +0200gmt(~gmt@pool-71-105-108-44.nycmny.fios.verizon.net) (Ping timeout: 260 seconds)
2020-09-17 14:25:02 +0200 <Unhammer> so split-sections on windows gives "ld.exe: blah.o: too many sections", "file is too big", when compiling blazehtml
2020-09-17 14:25:17 +0200 <Unhammer> too bad
2020-09-17 14:25:28 +0200 <ski> this `loeb' only requires a functor (and general recursion)
2020-09-17 14:26:11 +0200 <Unhammer> works great on my other project that doesn't need windows though :) 30M → 9.9M
2020-09-17 14:26:14 +0200 <ski> (if you pick `Identity', you get the usual `fix')
2020-09-17 14:26:34 +0200 <kuribas> indeed
2020-09-17 14:26:36 +0200 <kuribas> pretty neat
2020-09-17 14:26:53 +0200xerox_(~xerox@unaffiliated/xerox) (Ping timeout: 246 seconds)
2020-09-17 14:27:00 +0200 <ski> so, you can easily chase your own tail, with this `loeb'
2020-09-17 14:27:32 +0200 <ski> but if you only provided access to some other cells, in some well-founded order, say ..
2020-09-17 14:27:52 +0200 <ski> > foldr (\f as -> f as : as) [] (replicate 4 (succ . sum))
2020-09-17 14:27:55 +0200 <lambdabot> [8,4,2,1]
2020-09-17 14:27:58 +0200 <ski> @type foldr (\f as -> f as : as) []
2020-09-17 14:28:00 +0200 <lambdabot> Foldable t => t ([a] -> a) -> [a]
2020-09-17 14:28:24 +0200 <ski> in this case, each cell only gets access to the values of the cells after it
2020-09-17 14:28:39 +0200 <ski> and so, it's in some sense "like `fix'", but doesn't get you general recursion
2020-09-17 14:29:17 +0200 <kuribas> ski: but you just showed it is like fix?
2020-09-17 14:29:22 +0200 <kuribas> with Identity
2020-09-17 14:29:31 +0200 <ski> no, that was the `loeb' i just defined, above
2020-09-17 14:30:17 +0200 <kuribas> ah right...
2020-09-17 14:30:19 +0200 <ski> the original Löb's theorem, can be interpreted to be about staged computation, and in that case also doesn't give you general recursion
2020-09-17 14:30:31 +0200 <kuribas> and if instead of cell you take datatype fields... that may work
2020-09-17 14:30:37 +0200 <ski> (also related to quines)
2020-09-17 14:31:06 +0200 <ski> you have to avoid cycles. so you need to pick some well-founded order
2020-09-17 14:32:49 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz) (Quit: p-core)
2020-09-17 14:33:05 +0200 <ski> (or if you don't, you'd need to ensure that each step is productive. that's my "larger" suggestion from above)
2020-09-17 14:33:08 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz)
2020-09-17 14:34:02 +0200mirrorbird(~psutcliff@2a00:801:44b:8959:8d6c:276b:332b:1c71)
2020-09-17 14:34:43 +0200sQVe(~sQVe@unaffiliated/sqve)
2020-09-17 14:35:27 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 14:36:12 +0200sQVe(~sQVe@unaffiliated/sqve) (Client Quit)
2020-09-17 14:36:22 +0200wavemode(~wavemode@097-070-075-143.res.spectrum.com)
2020-09-17 14:36:46 +0200sQVe(~sQVe@unaffiliated/sqve)
2020-09-17 14:37:05 +0200sQVe(~sQVe@unaffiliated/sqve) (Client Quit)
2020-09-17 14:37:31 +0200mmohammadi9812(~mmohammad@5.238.164.128) (Quit: I quit (╯°□°）╯︵ ┻━┻)
2020-09-17 14:38:35 +0200george_____t(5c094cd5@host-92-9-76-213.as43234.net) (Remote host closed the connection)
2020-09-17 14:40:08 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 14:40:59 +0200sQVe(sQVe@gateway/vpn/mullvad/sqve)
2020-09-17 14:41:30 +0200sQVe(sQVe@gateway/vpn/mullvad/sqve) (Client Quit)
2020-09-17 14:41:56 +0200fendor_(~fendor@t204-126.demo.tuwien.ac.at)
2020-09-17 14:42:01 +0200sQVe(sQVe@gateway/vpn/mullvad/sqve)
2020-09-17 14:43:44 +0200fendor(~fendor@e237-037.eduroam.tuwien.ac.at) (Ping timeout: 256 seconds)
2020-09-17 14:44:03 +0200Unhammer(~Unhammer@gateway/tor-sasl/unhammer) (Ping timeout: 240 seconds)
2020-09-17 14:44:29 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz) (Quit: p-core)
2020-09-17 14:44:48 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz)
2020-09-17 14:46:24 +0200Aquazi(uid312403@gateway/web/irccloud.com/x-sjkqhkuufbqwprbm)
2020-09-17 14:47:17 +0200Achylles(~Achylles@201-27-79-1.dsl.telesp.net.br)
2020-09-17 14:48:46 +0200Unhammer(~Unhammer@gateway/tor-sasl/unhammer)
2020-09-17 14:50:32 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz) (Quit: p-core)
2020-09-17 14:50:53 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz)
2020-09-17 14:52:19 +0200akegalj_(~akegalj@93-142-93-99.adsl.net.t-com.hr) (Remote host closed the connection)
2020-09-17 14:52:27 +0200ericsagnes(~ericsagne@2405:6580:0:5100:bce9:b254:2a4:39d4)
2020-09-17 14:53:14 +0200jchia__(~jchia@45.32.62.73)
2020-09-17 14:53:57 +0200shatriff(~vitaliish@176.52.219.10) (Remote host closed the connection)
2020-09-17 14:54:57 +0200jchia__(~jchia@45.32.62.73) (Remote host closed the connection)
2020-09-17 14:55:45 +0200jchia__(~jchia@58.32.37.220)
2020-09-17 14:56:15 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 14:57:43 +0200ericsagnes(~ericsagne@2405:6580:0:5100:bce9:b254:2a4:39d4) (Ping timeout: 272 seconds)
2020-09-17 14:58:00 +0200shatriff(~vitaliish@176.52.219.10)
2020-09-17 14:58:57 +0200sQVe(sQVe@gateway/vpn/mullvad/sqve) (Quit: Bye!)
2020-09-17 14:59:04 +0200alp_(~alp@88.126.45.36) (Ping timeout: 260 seconds)
2020-09-17 15:00:56 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 15:01:06 +0200 <exarkun> Anyone want to recommend a prometheus library (I guess they're "prometheus client" libraries? for publishing metrics)? I see a lot of options out there.
2020-09-17 15:02:24 +0200kritzefitz(~kritzefit@fw-front.credativ.com) (Remote host closed the connection)
2020-09-17 15:06:55 +0200hyperisco(~hyperisco@d192-186-117-226.static.comm.cgocable.net)
2020-09-17 15:11:08 +0200 <exarkun> oops no there's only one in my stack resolver so I guess that's easy
2020-09-17 15:11:39 +0200Rudd0(~Rudd0@185.189.115.98) (Ping timeout: 260 seconds)
2020-09-17 15:12:27 +0200bicho_rastrero(~cerdito@154.85-87-39.dynamic.clientes.euskaltel.es) (Remote host closed the connection)
2020-09-17 15:12:41 +0200ALM49(7bc007ac@123-192-7-172.dynamic.kbronet.com.tw) (Remote host closed the connection)
2020-09-17 15:13:40 +0200eric_(~eric@2804:431:c7d4:b75:19f7:ea85:5be8:4c8e)
2020-09-17 15:13:59 +0200jedws(~jedws@101.184.189.58)
2020-09-17 15:15:43 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-09-17 15:16:47 +0200mmohammadi9812(~mmohammad@5.238.164.128)
2020-09-17 15:17:10 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 15:17:14 +0200gxt(~gxt@gateway/tor-sasl/gxt) (Remote host closed the connection)
2020-09-17 15:17:56 +0200gxt(~gxt@gateway/tor-sasl/gxt)
2020-09-17 15:18:58 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Quit: Free ZNC ~ Powered by LunarBNC: https://LunarBNC.net)
2020-09-17 15:20:08 +0200Dolly(585fd1fd@ti0203q160-5312.bb.online.no) (Remote host closed the connection)
2020-09-17 15:20:19 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2020-09-17 15:21:20 +0200ericsagnes(~ericsagne@2405:6580:0:5100:bce9:b254:2a4:39d4)
2020-09-17 15:21:54 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 265 seconds)
2020-09-17 15:22:26 +0200da39a3ee5e6b4b0d(~textual@2403:6200:8876:37d7:b93e:60af:b75b:c0ef)
2020-09-17 15:24:19 +0200xerox_(~xerox@unaffiliated/xerox)
2020-09-17 15:25:52 +0200eric__(~eric@2804:431:c7d4:b75:d805:ea78:a3e:f89f)
2020-09-17 15:28:14 +0200elliott_(~elliott@pool-71-114-77-65.washdc.fios.verizon.net)
2020-09-17 15:28:59 +0200eric_(~eric@2804:431:c7d4:b75:19f7:ea85:5be8:4c8e) (Ping timeout: 244 seconds)
2020-09-17 15:30:26 +0200 <dminuoso> exarkun: Both prometheus and prometheus-client are great.
2020-09-17 15:30:27 +0200jedws(~jedws@101.184.189.58) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-09-17 15:30:30 +0200machinedgod(~machinedg@d67-193-126-196.home3.cgocable.net)
2020-09-17 15:30:50 +0200MaddinSM(~MaddinSM@185.204.1.185)
2020-09-17 15:31:03 +0200 <exarkun> alright, cool. prometheus-client is what I'm looking at now. thanks.
2020-09-17 15:31:06 +0200 <dminuoso> Overall Id just run with prometheus-client
2020-09-17 15:31:16 +0200s00pcan(~chris@107.181.165.217) (Ping timeout: 246 seconds)
2020-09-17 15:31:28 +0200 <dminuoso> (It's what we use)
2020-09-17 15:31:46 +0200jedws(~jedws@101.184.189.58)
2020-09-17 15:31:47 +0200 <dminuoso> It uses a nasty global mutable registry, but oh well.
2020-09-17 15:32:24 +0200 <dminuoso> Just not a big fan of prometheus coming with warp, feels wrong
2020-09-17 15:32:57 +0200hvr_(~hvr@haskell/developer/hvr)
2020-09-17 15:33:17 +0200s00pcan(~chris@075-133-056-178.res.spectrum.com)
2020-09-17 15:33:18 +0200hvr(~hvr@haskell/developer/hvr) (Ping timeout: 272 seconds)
2020-09-17 15:36:25 +0200hyperisco(~hyperisco@d192-186-117-226.static.comm.cgocable.net) (Ping timeout: 240 seconds)
2020-09-17 15:37:38 +0200hyperisco(~hyperisco@d192-186-117-226.static.comm.cgocable.net)
2020-09-17 15:38:01 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 15:40:24 +0200son0p(~son0p@181.136.122.143)
2020-09-17 15:40:54 +0200aarvar(~foewfoiew@50.35.43.33) (Ping timeout: 272 seconds)
2020-09-17 15:41:27 +0200hackagewai-extra 3.0.31 - Provides some basic WAI handlers and middleware. https://hackage.haskell.org/package/wai-extra-3.0.31 (MichaelSnoyman)
2020-09-17 15:42:41 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 15:47:18 +0200inkbottle(~inkbottle@aaubervilliers-654-1-114-91.w86-198.abo.wanadoo.fr) (Quit: Konversation terminated!)
2020-09-17 15:47:22 +0200pingiun(~pingiun@ip-213-124-184-182.ip.prioritytelecom.net)
2020-09-17 15:47:40 +0200inkbottle(~inkbottle@aaubervilliers-654-1-114-91.w86-198.abo.wanadoo.fr)
2020-09-17 15:47:57 +0200hackageuniqueness-periods-vector-filters 0.1.0.0 - A library allows to change the structure of the 'RealFrac' function output. https://hackage.haskell.org/package/uniqueness-periods-vector-filters-0.1.0.0 (OleksandrZhabenko)
2020-09-17 15:47:58 +0200ransom(~c4264035@c-73-243-2-10.hsd1.co.comcast.net)
2020-09-17 15:50:05 +0200bitmagie(~Thunderbi@200116b80670970060cb385f030853d4.dip.versatel-1u1.de) (Ping timeout: 244 seconds)
2020-09-17 15:50:41 +0200Gerula(~Gerula@unaffiliated/gerula) (Ping timeout: 244 seconds)
2020-09-17 15:52:59 +0200Gerula(~Gerula@unaffiliated/gerula)
2020-09-17 15:54:44 +0200ericsagnes(~ericsagne@2405:6580:0:5100:bce9:b254:2a4:39d4) (Ping timeout: 244 seconds)
2020-09-17 15:55:10 +0200jlamothe(~jlamothe@dev.jlamothe.net)
2020-09-17 15:55:53 +0200jonathanx(~jonathan@dyn-8-sc.cdg.chalmers.se)
2020-09-17 15:57:15 +0200mirrorbird(~psutcliff@2a00:801:44b:8959:8d6c:276b:332b:1c71) (Ping timeout: 272 seconds)
2020-09-17 15:58:55 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 16:00:38 +0200mdunnio(~mdunnio@208.59.170.5)
2020-09-17 16:03:05 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 240 seconds)
2020-09-17 16:05:58 +0200mdunnio(~mdunnio@208.59.170.5) (Remote host closed the connection)
2020-09-17 16:06:10 +0200mdunnio(~mdunnio@208.59.170.5)
2020-09-17 16:07:00 +0200josh(~josh@c-67-164-104-206.hsd1.ca.comcast.net)
2020-09-17 16:08:28 +0200tzh(~tzh@2601:448:c500:5300::ad1c)
2020-09-17 16:08:59 +0200eric__(~eric@2804:431:c7d4:b75:d805:ea78:a3e:f89f) (Read error: Connection reset by peer)
2020-09-17 16:09:10 +0200gmt(~gmt@pool-71-105-108-44.nycmny.fios.verizon.net)
2020-09-17 16:09:35 +0200eric(~eric@2804:431:c7d4:b75:d805:ea78:a3e:f89f)
2020-09-17 16:10:15 +0200finkata(~dpetrov@83.222.188.39)
2020-09-17 16:11:20 +0200Neuromancer(~Neuromanc@unaffiliated/neuromancer) (Ping timeout: 256 seconds)
2020-09-17 16:13:04 +0200finkata(~dpetrov@83.222.188.39) (Remote host closed the connection)
2020-09-17 16:13:25 +0200gmt(~gmt@pool-71-105-108-44.nycmny.fios.verizon.net) (Ping timeout: 240 seconds)
2020-09-17 16:13:40 +0200 <ezzieyguywuf> lol, so turtle is supposed to replace bash?
2020-09-17 16:14:37 +0200finkata(~dpetrov@83.222.188.39)
2020-09-17 16:15:37 +0200borne(~fritjof@200116b8641fc4005e981dab12496c3b.dip.versatel-1u1.de) (Ping timeout: 272 seconds)
2020-09-17 16:16:25 +0200 <merijn> ezzieyguywuf: define "supposed" and "replace" :p
2020-09-17 16:17:17 +0200 <merijn> Think of Turtle as a library/framework optimised for making it easier/simpler to write "bash-like scripts" in Haskell
2020-09-17 16:17:51 +0200 <ezzieyguywuf> "supposed" is in "intended" and "replace" as in "use instead of all the time"
2020-09-17 16:18:24 +0200 <merijn> Realistically *nothing* is going to replace bash in the next century
2020-09-17 16:18:37 +0200 <merijn> It's like COBOL, ubiquitous to the point of immortality
2020-09-17 16:18:44 +0200seanvert(~user@177.84.244.242)
2020-09-17 16:19:18 +0200 <merijn> And nothing seriously aspires to replacing bash (I mean, that might be the wishful thinking marketing some shells throw about, but nobody believes that)
2020-09-17 16:19:36 +0200 <merijn> Not to mention the fact that bash is 2 things, an interactive shell and a scripting language
2020-09-17 16:19:38 +0200 <ezzieyguywuf> i've been using zsh
2020-09-17 16:19:44 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 16:19:48 +0200 <ezzieyguywuf> but since I just installed gentoo on a new laptop, i'm reconsideringb
2020-09-17 16:20:02 +0200 <ezzieyguywuf> b/c I think zsh just makes it easy to do things that you can already do in bash with a little bit of oomph
2020-09-17 16:20:54 +0200 <maerwald> use fish
2020-09-17 16:21:07 +0200 <ezzieyguywuf> 😂
2020-09-17 16:21:09 +0200Neuromancer(~Neuromanc@unaffiliated/neuromancer)
2020-09-17 16:21:12 +0200 <ezzieyguywuf> i tried fish for like a minute once
2020-09-17 16:21:20 +0200 <maerwald> I switch to bash occasionally when I need to do serious things
2020-09-17 16:21:25 +0200 <merijn> ezzieyguywuf: So at best turtle is an alternative to one of the two use cases of bash (i.e. shell scripts)
2020-09-17 16:21:26 +0200 <yushyin> have a look at rash, an interactive shell with the power of racket :D
2020-09-17 16:21:27 +0200 <maerwald> but the defaults aregood
2020-09-17 16:21:27 +0200 <ezzieyguywuf> oh you were forrill
2020-09-17 16:21:42 +0200 <yushyin> https://rash-lang.org/ ^^
2020-09-17 16:22:06 +0200 <merijn> ezzieyguywuf: The one thing bash (and shell) excel at is easily combining different processes together (the "process" library is a bit heavy weight to work with)
2020-09-17 16:22:28 +0200 <merijn> ezzieyguywuf: So turtle tries to make that sort of "multi-process" scripting easier/nicer to do in Haskell
2020-09-17 16:24:36 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 256 seconds)
2020-09-17 16:24:37 +0200 <ezzieyguywuf> rash looks interesting
2020-09-17 16:25:18 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece)
2020-09-17 16:25:50 +0200 <sm[m]> oil shell might do it
2020-09-17 16:25:57 +0200ski. o O ( F_{i}shell <http://fishell.sf.net> )
2020-09-17 16:26:49 +0200 <maerwald> download page is sourceforge, LoL
2020-09-17 16:27:03 +0200Sgeo(~Sgeo@ool-18b982ad.dyn.optonline.net)
2020-09-17 16:27:22 +0200 <ezzieyguywuf> maerwald: lol, for rash?
2020-09-17 16:27:37 +0200 <maerwald> fishell
2020-09-17 16:27:55 +0200 <ezzieyguywuf> 😂
2020-09-17 16:28:11 +0200 <ezzieyguywuf> that's weird b/c I just found a github for fish-shell
2020-09-17 16:28:25 +0200mmohammadi98127(~mmohammad@5.238.164.128)
2020-09-17 16:28:57 +0200 <ski> not the same thing
2020-09-17 16:29:05 +0200mmohammadi9812(~mmohammad@5.238.164.128) (Read error: Connection reset by peer)
2020-09-17 16:29:06 +0200mmohammadi98127mmohammadi9812
2020-09-17 16:29:57 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece) (Ping timeout: 244 seconds)
2020-09-17 16:30:07 +0200nan`(~nan`@unaffiliated/nan/x-5405850)
2020-09-17 16:33:03 +0200kleisli_(~kleisli@2600:1700:4640:c560:68bd:9d76:dbd8:24e7) (Ping timeout: 244 seconds)
2020-09-17 16:33:30 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Quit: Free ZNC ~ Powered by LunarBNC: https://LunarBNC.net)
2020-09-17 16:34:06 +0200mmohammadi9812(~mmohammad@5.238.164.128) (Ping timeout: 272 seconds)
2020-09-17 16:34:32 +0200mmohammadi9812(~mmohammad@5.238.164.128)
2020-09-17 16:34:45 +0200jneira(501e65ce@gateway/web/cgi-irc/kiwiirc.com/ip.80.30.101.206)
2020-09-17 16:35:01 +0200nan`(~nan`@unaffiliated/nan/x-5405850) (Ping timeout: 264 seconds)
2020-09-17 16:35:48 +0200ddellacosta(~dd@86.106.121.168)
2020-09-17 16:37:05 +0200shafox(~shafox@106.51.234.111) (Remote host closed the connection)
2020-09-17 16:38:12 +0200shafox(~shafox@106.51.234.111)
2020-09-17 16:38:13 +0200TooDifficult(~TooDiffic@139.59.59.230) (Quit: TooDifficult)
2020-09-17 16:38:16 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2020-09-17 16:38:47 +0200miklcct(quasselcor@2001:19f0:7001:5ad:5400:2ff:feb6:50d7) (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.)
2020-09-17 16:39:43 +0200cantstanya(~chatting@gateway/tor-sasl/cantstanya) (Ping timeout: 240 seconds)
2020-09-17 16:40:37 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 16:42:17 +0200miklcct(quasselcor@2001:19f0:7001:5ad:5400:2ff:feb6:50d7)
2020-09-17 16:43:44 +0200da39a3ee5e6b4b0d(~textual@2403:6200:8876:37d7:b93e:60af:b75b:c0ef) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-09-17 16:44:28 +0200 <z0> > 9 / (1/0)
2020-09-17 16:44:31 +0200 <lambdabot> 0.0
2020-09-17 16:44:47 +0200shadowdao(~user@unaffiliated/shadowdaemon)
2020-09-17 16:44:59 +0200 <z0> ^ can someone explain this to me?
2020-09-17 16:45:07 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 246 seconds)
2020-09-17 16:45:13 +0200cantstanya(~chatting@gateway/tor-sasl/cantstanya)
2020-09-17 16:45:22 +0200 <dolio> 1/0 is infinity, and 9/infinity = 0.
2020-09-17 16:46:10 +0200 <z0> i get the theory, but how does Haskell do this?
2020-09-17 16:46:21 +0200 <dolio> It's IEEE754 arithmetic.
2020-09-17 16:46:32 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:59f2:1ee3:fe3e:b848) (Remote host closed the connection)
2020-09-17 16:47:31 +0200kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Remote host closed the connection)
2020-09-17 16:47:53 +0200 <hyperisco> so obviously 0*infinity = 9
2020-09-17 16:48:22 +0200 <merijn> z0: What do you mean by "how does Haskell do this??
2020-09-17 16:48:31 +0200 <merijn> s/??/"?
2020-09-17 16:48:38 +0200 <hyperisco> > 0 * (1/0)
2020-09-17 16:48:41 +0200 <lambdabot> NaN
2020-09-17 16:48:58 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:59f2:1ee3:fe3e:b848)
2020-09-17 16:48:59 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Quit: Quit.)
2020-09-17 16:49:07 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:59f2:1ee3:fe3e:b848) (Remote host closed the connection)
2020-09-17 16:49:07 +0200 <merijn> The answer is, most likely, "the same way C does this"
2020-09-17 16:49:16 +0200 <hyperisco> maybe "NaN" should mean "more than one number"
2020-09-17 16:49:25 +0200 <z0> @type (1/0)
2020-09-17 16:49:27 +0200 <lambdabot> Fractional a => a
2020-09-17 16:49:34 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:59f2:1ee3:fe3e:b848)
2020-09-17 16:49:37 +0200 <z0> > 1/0
2020-09-17 16:49:40 +0200 <lambdabot> Infinity
2020-09-17 16:49:42 +0200 <dmwit> > 9 / (1/0) :: Rational
2020-09-17 16:49:44 +0200 <lambdabot> *Exception: Ratio has zero denominator
2020-09-17 16:49:46 +0200 <z0> @type Infinity
2020-09-17 16:49:48 +0200 <lambdabot> error:
2020-09-17 16:49:48 +0200 <lambdabot> • Data constructor not in scope: Infinity
2020-09-17 16:49:48 +0200 <lambdabot> • Perhaps you meant variable ‘infinity’ (imported from Data.Number.Natural)
2020-09-17 16:49:49 +0200 <ski> > sqrt (-1)
2020-09-17 16:49:51 +0200 <lambdabot> NaN
2020-09-17 16:49:52 +0200 <merijn> z0: Ah, how does it decide the type of a polymorphic expression?
2020-09-17 16:49:52 +0200 <ski> > log (-1)
2020-09-17 16:49:54 +0200 <lambdabot> NaN
2020-09-17 16:50:05 +0200 <merijn> z0: Was that the question?
2020-09-17 16:50:15 +0200 <z0> merijn: that's right
2020-09-17 16:50:19 +0200 <hyperisco> MoreThanOneNumber, NotInRealPlane
2020-09-17 16:50:34 +0200cfricke(~cfricke@unaffiliated/cfricke) (Quit: WeeChat 2.9)
2020-09-17 16:50:37 +0200 <hyperisco> FILE_NOT_FOUND probably somewhere in the arithmetic
2020-09-17 16:50:41 +0200 <dmwit> z0: It uses defaulting. The default default is (Integer, Double), I think.
2020-09-17 16:50:41 +0200agiza(2eef7ad3@larka.olf.sgsnet.se)
2020-09-17 16:50:55 +0200 <merijn> z0: Ok, so there's a bunch of rules in the report that define special cases for polymorphic types for Num/Integral and Fractional/etc.
2020-09-17 16:51:02 +0200ski. o O ( `abs (0/0)' )
2020-09-17 16:51:03 +0200 <z0> merijn: and what is Infinity treated as a value of type Fractional a => a
2020-09-17 16:51:18 +0200 <dmwit> Infinity is not a value of type Fractional a => a.
2020-09-17 16:51:24 +0200agiza(2eef7ad3@larka.olf.sgsnet.se) (Remote host closed the connection)
2020-09-17 16:51:24 +0200 <dmwit> It is a value of type Double, and a value of type Float.
2020-09-17 16:51:25 +0200 <merijn> z0: Which basically say "if you've got a polymorphic expression that's Num or Integral, default it to Integer" and "Double" for Fractional
2020-09-17 16:51:38 +0200 <dmwit> > (read "Infinity" :: Double, read "Infinity" :: Rational)
2020-09-17 16:51:41 +0200 <lambdabot> (Infinity,*Exception: Prelude.read: no parse
2020-09-17 16:51:50 +0200 <merijn> z0: This is covered by the "defaulting rules"
2020-09-17 16:51:54 +0200alp_(~alp@2a01:e0a:58b:4920:102b:86e3:d072:38a0)
2020-09-17 16:51:54 +0200 <hyperisco> yes, the seldom talked about defaults feature
2020-09-17 16:52:02 +0200 <merijn> z0: If you enable -Wall you should get warnings for defaulting, iirc
2020-09-17 16:52:10 +0200 <dolio> Well, Infinity isn't a valid expression unless you define a data type with a constructor of that name.
2020-09-17 16:52:19 +0200 <ski> (or pattern synonym)
2020-09-17 16:52:24 +0200 <dolio> Yeah, or that.
2020-09-17 16:52:28 +0200 <z0> dolio: i think that's what is confusing me
2020-09-17 16:52:52 +0200bahamas(~lucian@188.24.181.166)
2020-09-17 16:52:52 +0200bahamas(~lucian@188.24.181.166) (Changing host)
2020-09-17 16:52:52 +0200bahamas(~lucian@unaffiliated/bahamas)
2020-09-17 16:52:53 +0200 <dolio> 1/0 is an expression, and what it does depends on the type.
2020-09-17 16:53:09 +0200 <merijn> z0: "(1/0) :: Fractional a => a" gets defaulted to type "Double" and when you compute 1/0 for Double the result is a Double (which happens to have value Infinity)
2020-09-17 16:53:27 +0200 <ski> > 1 / 0 :: Rational
2020-09-17 16:53:30 +0200 <lambdabot> *Exception: Ratio has zero denominator
2020-09-17 16:53:47 +0200 <z0> > ((1/0) :: Double, (1/0) :: Rational, Infinity :: Double, Infinity :: Rational)
2020-09-17 16:53:48 +0200jonathanx(~jonathan@dyn-8-sc.cdg.chalmers.se) (Remote host closed the connection)
2020-09-17 16:53:50 +0200 <lambdabot> error:
2020-09-17 16:53:50 +0200 <lambdabot> • Data constructor not in scope: Infinity :: Double
2020-09-17 16:53:50 +0200 <lambdabot> • Perhaps you meant variable ‘infinity’ (imported from Data.Number.Natur...
2020-09-17 16:54:06 +0200 <z0> > ((1/0) :: Double, (1/0) :: Rational)
2020-09-17 16:54:09 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:59f2:1ee3:fe3e:b848) (Ping timeout: 244 seconds)
2020-09-17 16:54:09 +0200 <lambdabot> (Infinity,*Exception: Ratio has zero denominator
2020-09-17 16:54:22 +0200 <z0> > (Infinity :: Double)
2020-09-17 16:54:25 +0200 <lambdabot> error:
2020-09-17 16:54:25 +0200 <lambdabot> • Data constructor not in scope: Infinity :: Double
2020-09-17 16:54:25 +0200 <lambdabot> • Perhaps you meant variable ‘infinity’ (imported from Data.Number.Natural)
2020-09-17 16:54:32 +0200 <z0> hum
2020-09-17 16:54:40 +0200 <merijn> z0: Infinity is the string representation of a Double value
2020-09-17 16:54:48 +0200 <merijn> z0: That double value has no literal way to write it
2020-09-17 16:54:51 +0200jonathanx(~jonathan@dyn-8-sc.cdg.chalmers.se)
2020-09-17 16:54:56 +0200 <z0> ok i get it. thanks
2020-09-17 16:55:18 +0200 <merijn> I think adding a pattern synonym for Infinity would be good, tbh
2020-09-17 16:55:31 +0200ph88_(~ph88@2a02:8109:9e40:2704:85f2:8dce:6e30:a554) (Ping timeout: 272 seconds)
2020-09-17 16:55:40 +0200 <z0> but I also get how it can be a bad idea
2020-09-17 16:56:09 +0200 <dmwit> Perhaps it is not made a pattern synonym because its type is too hard.
2020-09-17 16:56:24 +0200 <dmwit> (Should we add a new class that just has Double and Float as instances just for this?)
2020-09-17 16:56:29 +0200 <merijn> dmwit: Just define it as Double
2020-09-17 16:56:37 +0200 <merijn> let's face it, no one gives a crap about Float
2020-09-17 16:56:53 +0200 <merijn> Boom!
2020-09-17 16:56:59 +0200 <dmwit> Mmm. Machine learning folks default to Float pretty consistently.
2020-09-17 16:57:00 +0200 <merijn> Problem solved with the power of pragmatism!
2020-09-17 16:57:22 +0200 <merijn> dmwit: They do silly stuff like use half-floats to, so that won't work anyway
2020-09-17 16:57:37 +0200 <merijn> dmwit: Also pretty sure machine learning people don't generally care about writing Infinity in their code :p
2020-09-17 16:58:04 +0200 <z0> ...yet
2020-09-17 16:58:41 +0200 <dmwit> Nobody cares about writing Infinity in their code. Boom! Problem solved without even doing any work through pragmatism.
2020-09-17 16:58:44 +0200 <merijn> z0: Anyway, I recommend enabling -Wall and avoiding defaulting :p
2020-09-17 16:58:47 +0200 <merijn> dmwit: I do, though!
2020-09-17 16:58:53 +0200 <ski> % 9 / Infinity
2020-09-17 16:58:53 +0200 <yahb> ski: 0.0
2020-09-17 16:59:02 +0200 <dolio> Well, you can propose it, and then someone else can run off an invent some kind of IEEE class that must be made to ensure maximal generality.
2020-09-17 16:59:33 +0200 <merijn> dolio: uh-huh, that's why we have the perfect generalised numeric typeclass hierarchy, now, right? ;)
2020-09-17 16:59:37 +0200 <dmwit> Pfft, you do silly stuff like serialization and deserialization, so that won't work anyway
2020-09-17 17:00:01 +0200MaddinSM(~MaddinSM@185.204.1.185) ()
2020-09-17 17:00:15 +0200polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889)
2020-09-17 17:00:19 +0200cosimone_(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-09-17 17:00:19 +0200 <hyperisco> I'll be impressed once we stop treating floats like reals
2020-09-17 17:00:32 +0200 <merijn> hyperisco: Smart people never started :p
2020-09-17 17:00:40 +0200 <dolio> merijn: Just hope that the requirement for the class to be perfect doesn't block your Infinity pattern getting added. :)
2020-09-17 17:00:45 +0200 <merijn> The reals are shit numbers anyway :p
2020-09-17 17:01:22 +0200 <merijn> Like a proper computer scientist I only care about whole numbers...and maybe rationals
2020-09-17 17:01:31 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 17:01:41 +0200 <hyperisco> whole numbers and pairs of whole numbers
2020-09-17 17:01:51 +0200 <maerwald> rationals escalate quickly
2020-09-17 17:02:15 +0200 <hyperisco> π is 22/7 and that's the end of it
2020-09-17 17:02:34 +0200 <merijn> Pi is basically 3
2020-09-17 17:02:58 +0200 <dolio> Floating point is just bad rationals, though.
2020-09-17 17:03:16 +0200 <dminuoso> Also, why dont we have support for transcedental numbers? :<
2020-09-17 17:03:34 +0200 <ski> how about algebraic numbers, to start with ?
2020-09-17 17:03:35 +0200 <merijn> dmwit: We barely know any of the numbers anyway
2020-09-17 17:03:43 +0200 <merijn> s/dmwit/dminuoso
2020-09-17 17:04:01 +0200 <hyperisco> I just want the imprecision of floats acknowledged by some static analysis
2020-09-17 17:04:18 +0200 <merijn> hyperisco: There's already a whole bunch of that
2020-09-17 17:04:27 +0200 <hyperisco> I don't want floats put into a type class with laws they don't hold
2020-09-17 17:04:34 +0200 <merijn> like http://herbie.uwplse.org/
2020-09-17 17:04:38 +0200 <dmwit> dminuoso: You might like the cyclotomic package.
2020-09-17 17:04:47 +0200cp-(~cp-@b157153.ppp.asahi-net.or.jp) (Ping timeout: 240 seconds)
2020-09-17 17:04:49 +0200 <merijn> hyperisco: Which typeclass's laws do they violate?
2020-09-17 17:05:00 +0200 <dmwit> It supports most of the transcendentals that come up in calculations, and doesn't have the observation problems that CReal does.
2020-09-17 17:05:10 +0200 <merijn> I guess Eq, but that's solved once Carter finishes the crusade to abolish value NaN :p
2020-09-17 17:05:20 +0200 <dmwit> ski: You, too. The cyclotomics are a superset of the algebraic numbers.
2020-09-17 17:05:47 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 240 seconds)
2020-09-17 17:06:18 +0200 <hyperisco> merijn, associativity for one
2020-09-17 17:06:38 +0200 <merijn> hyperisco: Of what?
2020-09-17 17:06:53 +0200Saukk(~Saukk@2001:998:dc:4a67:1c59:9bb5:b94c:4)
2020-09-17 17:06:56 +0200 <dolio> Additions and multiplication.
2020-09-17 17:06:56 +0200 <hyperisco> addition, multiplication, but the report has no laws for Num anyways
2020-09-17 17:07:17 +0200da39a3ee5e6b4b0d(~textual@2403:6200:8876:37d7:b93e:60af:b75b:c0ef)
2020-09-17 17:08:09 +0200 <hyperisco> if we were honest up front it might not be *that bad* in the end
2020-09-17 17:09:12 +0200cp-(~cp-@b157153.ppp.asahi-net.or.jp)
2020-09-17 17:09:35 +0200cosimone_(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Quit: Quit.)
2020-09-17 17:09:59 +0200machinedgod(~machinedg@d67-193-126-196.home3.cgocable.net) (Ping timeout: 246 seconds)
2020-09-17 17:11:12 +0200__Joker_(~Joker@180.151.105.86)
2020-09-17 17:11:26 +0200 <dolio> I don't know. Doesn't that mostly matter when people use other faulty operations, like equality?
2020-09-17 17:12:21 +0200 <merijn> dolio: Equality is fine, value NaN is bogus >.>
2020-09-17 17:12:30 +0200 <dolio> No, it's not fine.
2020-09-17 17:12:44 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net) (Ping timeout: 272 seconds)
2020-09-17 17:12:47 +0200 <dolio> You shouldn't be testing floats for equality, you should be testing that they're "close enough" usually.
2020-09-17 17:12:49 +0200 <merijn> Name one thing faulty about it excluding value NaN
2020-09-17 17:13:00 +0200 <merijn> dolio: I call bullshit
2020-09-17 17:13:12 +0200 <merijn> I frequently need exact equality for floats
2020-09-17 17:13:30 +0200 <merijn> Like "when checking that deterministic computations are in fact deterministic and remain identical"
2020-09-17 17:14:04 +0200 <merijn> equality on floats is a perfectly well-defined and reasonable operation in the absense of value NaN
2020-09-17 17:14:22 +0200 <hyperisco> dolio, equality for floats is much weaker than usual, yes… I think the error bars need to be accounted for
2020-09-17 17:14:38 +0200__Joker(~Joker@180.151.106.108) (Ping timeout: 272 seconds)
2020-09-17 17:14:42 +0200 <dolio> merijn: You're missing the point.
2020-09-17 17:14:48 +0200unlink__(~unlink2@p200300ebcf25bd0068eb9d9c94da2a17.dip0.t-ipconnect.de)
2020-09-17 17:14:58 +0200 <hyperisco> because if you only retain the error-free equalities then you can hardly say enough about floats
2020-09-17 17:15:07 +0200mud(~mud@unaffiliated/kadoban) (Quit: bye)
2020-09-17 17:15:15 +0200 <merijn> dolio: Which is?
2020-09-17 17:15:18 +0200Neuromancer(~Neuromanc@unaffiliated/neuromancer) (Read error: Connection reset by peer)
2020-09-17 17:15:27 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-09-17 17:15:37 +0200 <ski> (it would be nice to have `forall x y. x == y == True => x = y' and `forall x y. x == y = False => x =/= y')
2020-09-17 17:15:51 +0200 <ski> (s/== True/= True/)
2020-09-17 17:16:01 +0200 <merijn> ski:Right, which is the case once you elimiante value NaN
2020-09-17 17:16:22 +0200 <hyperisco> so I think probably instead you have to talk about intervals of reals, and then instead of equality you have interval relations
2020-09-17 17:16:30 +0200 <merijn> value NaN is what torpedoes reflexivity
2020-09-17 17:16:37 +0200 <hyperisco> (where actual equality becomes the relation of equality on intervals)
2020-09-17 17:17:33 +0200 <hyperisco> so you can say a < b if the interval of a precedes the interval of b
2020-09-17 17:17:42 +0200 <dolio> Which is that expected algebraic rules hold up to 'approximate equality', so you don't just tell people "addition isn't associative," because it's not the whole story. Part of the story is that exact equality is only reliable for exact sequences of operations, and shouldn't be treated as reliable in general.
2020-09-17 17:17:50 +0200 <hyperisco> precedes or meets
2020-09-17 17:17:59 +0200zaquest(~notzaques@5.128.210.178) (Read error: Connection reset by peer)
2020-09-17 17:18:01 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-09-17 17:18:12 +0200zaquest(~notzaques@5.128.210.178)
2020-09-17 17:18:25 +0200fendor__(~fendor@e237-037.eduroam.tuwien.ac.at)
2020-09-17 17:18:38 +0200 <hyperisco> a float calculation is exact if the interval is expressible as [x,x] for some x, etc
2020-09-17 17:18:39 +0200 <ski> dolio : that's separate from the `NaN' point, though
2020-09-17 17:18:46 +0200 <hyperisco> at least this is the line I would try to go down
2020-09-17 17:18:46 +0200 <dolio> I didn't even bring up NaN.
2020-09-17 17:18:55 +0200 <carter> merijn: did you see the final version of clamp that got merged in last week? It handles NaN in a pretty ncie way
2020-09-17 17:19:09 +0200 <carter> Yeah, agree with dolio , it’s a stance I’ve had myself.
2020-09-17 17:19:14 +0200 <ski> yes. iow you're (mostly) talking about different things
2020-09-17 17:19:17 +0200 <merijn> carter: No, I've been busy learning Fortran >.>
2020-09-17 17:19:23 +0200 <dolio> Yeah, so don't jump into what I'm saying.
2020-09-17 17:19:48 +0200 <carter> dolio: the 1 plus or minus epsilon flavor or approximate equality?
2020-09-17 17:19:58 +0200 <hyperisco> dolio, we can give "approximate equality" a precise meaning though, don't you think?
2020-09-17 17:20:11 +0200 <carter> merijn: is flang the only oss / free compiler for modern FORTRAN?
2020-09-17 17:20:14 +0200 <dolio> I don't know. I don't care enough to actually learn all the details necessary.
2020-09-17 17:20:19 +0200 <carter> hyperisco: ues you can
2020-09-17 17:20:49 +0200 <carter> Basically every operation has a error bound of multiplicative 1 plus or minus epsilon error
2020-09-17 17:20:51 +0200 <dolio> It's just my impression that people who actually work with IEEE heavily espouse this view.
2020-09-17 17:21:02 +0200 <merijn> carter: I dunno? We use gfortran and I am not sure what "modern Fortran" really entails, but I've become really sure that all documentation on Fortran sucks balls :)
2020-09-17 17:21:06 +0200fendor_(~fendor@t204-126.demo.tuwien.ac.at) (Ping timeout: 256 seconds)
2020-09-17 17:21:24 +0200 <carter> merijn: apparently you can kinda write sane stuff with new enough FORTRAN
2020-09-17 17:21:36 +0200 <hyperisco> carter, so I suspect my interval analysis is effective
2020-09-17 17:22:02 +0200 <carter> hyperisco: not quite. Interval analysis will always over estimate error
2020-09-17 17:22:14 +0200ubert(~Thunderbi@178.165.131.132.wireless.dyn.drei.com) (Ping timeout: 272 seconds)
2020-09-17 17:22:21 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 17:22:21 +0200 <carter> Though it’s still useful.
2020-09-17 17:22:42 +0200carlomagno1(~cararell@inet-hqmc02-o.oracle.com) (Remote host closed the connection)
2020-09-17 17:22:49 +0200 <hyperisco> how can we be more exact?
2020-09-17 17:23:13 +0200 <dolio> carter: I think people usually would have some defined epislon that their results need. Not necessarily the smallest possible epsilon.
2020-09-17 17:23:27 +0200Sunblaze21(~sanjay@116.72.71.64) (Quit: Leaving.)
2020-09-17 17:23:33 +0200 <carter> Absolutely
2020-09-17 17:23:35 +0200 <dolio> Oh, I guess that's what you meant.
2020-09-17 17:23:45 +0200 <carter> But for the computation itself
2020-09-17 17:23:46 +0200ph88_(~ph88@2a02:8109:9e40:2704:85f2:8dce:6e30:a554)
2020-09-17 17:24:06 +0200Sunblaze21(~sanjay@116.72.71.64)
2020-09-17 17:24:12 +0200 <carter> 333333hyperisco: there’s these pretty powerful but soemtimes annoying ideas called forwards and backwards stability
2020-09-17 17:24:38 +0200 <carter> So one flavor is that your result is a perturbation of the correct answer to the exact input.
2020-09-17 17:25:02 +0200 <carter> The other is that your output is an exact answer to some input that’s a nearby perturbation of your input
2020-09-17 17:25:42 +0200 <dmwit> > 0 == -0
2020-09-17 17:25:45 +0200 <lambdabot> True
2020-09-17 17:25:49 +0200 <dmwit> > 0 == (-0 :: Double)
2020-09-17 17:25:49 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:59f2:1ee3:fe3e:b848)
2020-09-17 17:25:52 +0200 <lambdabot> True
2020-09-17 17:26:00 +0200 <dmwit> merijn: ^
2020-09-17 17:26:07 +0200 <carter> That’s so you can handle directional limits
2020-09-17 17:26:11 +0200 <dmwit> Torpedoing NaN isn't enough to get ski's property.
2020-09-17 17:26:26 +0200 <carter> What property does he want
2020-09-17 17:26:35 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 240 seconds)
2020-09-17 17:26:36 +0200 <dmwit> (==) being Leibniz equality, basically.
2020-09-17 17:26:46 +0200 <ski> when it terminates
2020-09-17 17:26:51 +0200 <dmwit> right
2020-09-17 17:27:17 +0200 <carter> I mean, the signed zero thing is so you can talk about left or right limits
2020-09-17 17:27:28 +0200 <carter> Afaik.
2020-09-17 17:27:39 +0200 <dmwit> I think everybody agrees that every decision made in IEEE754 has a justification behind it.
2020-09-17 17:27:44 +0200 <carter> Yeah
2020-09-17 17:27:48 +0200 <dolio> Hahaha.
2020-09-17 17:27:57 +0200 <dmwit> That doesn't mean that at the end of justifying all those decisions you get something with nice properties.
2020-09-17 17:28:29 +0200 <carter> Oh did you read how idris2 proved false because it’s model of equalities for float were wrong?
2020-09-17 17:28:39 +0200 <carter> Apparently same happened to agda before
2020-09-17 17:28:48 +0200 <hyperisco> I figured it was as simple as it is a possible bitfield
2020-09-17 17:28:50 +0200 <dolio> Not surprised.
2020-09-17 17:28:52 +0200sid_cypher(~quassel@200116b80060a70031488a0eec1b5c23.dip.versatel-1u1.de)
2020-09-17 17:29:06 +0200 <carter> hyperisco: sign in floats?
2020-09-17 17:29:07 +0200 <hyperisco> like with 1's complement
2020-09-17 17:29:08 +0200 <dolio> Agda's is still wrong, I think, but someone is working on it.
2020-09-17 17:29:09 +0200 <hyperisco> yes
2020-09-17 17:29:13 +0200 <hyperisco> well -0 specifically
2020-09-17 17:29:26 +0200 <dolio> I don't know if you can prove false from it, though. It just doesn't make sense.
2020-09-17 17:29:40 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece)
2020-09-17 17:30:01 +0200 <dolio> Like, I think the ordering is just the induced ordering from Double -> Word64.
2020-09-17 17:30:18 +0200 <hyperisco> their other option is to leave that particular bitfield undefined?
2020-09-17 17:30:36 +0200 <carter> dolio: as bit rep ? Or other. I think that’s how the ieee tots order is defined
2020-09-17 17:30:54 +0200 <carter> hyperisco: or make it a quotiented type!
2020-09-17 17:30:59 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:59f2:1ee3:fe3e:b848) (Ping timeout: 272 seconds)
2020-09-17 17:31:10 +0200 <carter> Ideas from hott but for numerical computing formal methods
2020-09-17 17:31:19 +0200 <dolio> carter: Yeah, the bit representation. But it's not correct because Word64 is unsigned.
2020-09-17 17:31:47 +0200 <carter> I thought it was leading bit is sign. Then magnitude. The mantissa ?
2020-09-17 17:31:48 +0200 <dolio> So negative numbers are larger than positive numbers.
2020-09-17 17:31:54 +0200 <carter> Ok fuck that
2020-09-17 17:31:58 +0200 <carter> That’s bad
2020-09-17 17:32:05 +0200Lycurgus(~niemand@98.4.96.130)
2020-09-17 17:32:34 +0200 <carter> I’ve actually been thinking a lot about how quotient types a la hott or whatever might be amazing for generic programming
2020-09-17 17:33:07 +0200da39a3ee5e6b4b0d(~textual@2403:6200:8876:37d7:b93e:60af:b75b:c0ef) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-09-17 17:33:31 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 17:34:49 +0200 <dolio> Yeah, hopefully that bears some fruit. There are aspects to the HoTT approach to quotients that make it quite different than previous attempts.
2020-09-17 17:35:19 +0200 <dolio> And it seems like it could be capturing useful aspects of computation on quotients.
2020-09-17 17:35:24 +0200 <ski> we're already simulating factor/quotient types (and subset types), via abstract data types
2020-09-17 17:36:44 +0200jonathanx(~jonathan@dyn-8-sc.cdg.chalmers.se) (Remote host closed the connection)
2020-09-17 17:36:58 +0200 <ski> carter : why/how for generic programming ?
2020-09-17 17:37:38 +0200 <carter> Ski: so an example I’ve been thinking about is sets as data structures.
2020-09-17 17:38:05 +0200 <ski> yes
2020-09-17 17:38:05 +0200lemmih(~lemmih@2406:3003:2072:44:251c:6ccc:226:e43d) (Remote host closed the connection)
2020-09-17 17:38:08 +0200 <carter> In general you need element equality and kinda brute force finding the right permutation exists or not for set sequalith
2020-09-17 17:38:32 +0200lemmih(~lemmih@2406:3003:2072:44:251c:6ccc:226:e43d)
2020-09-17 17:38:35 +0200 <carter> So the weakest eq proof calc is equality modulo explicit permutation
2020-09-17 17:38:39 +0200 <ski> what kind of implementation/representation do you have in mind there ? some kind of balanced trees ?
2020-09-17 17:39:20 +0200 <carter> If the elements themselves have a total order or a well behaved binary serialization you can skip permutation discovery
2020-09-17 17:39:22 +0200 <ski> or starting from an arbitrary list, considering permutations and elision/introduction of duplicates ?
2020-09-17 17:39:26 +0200 <carter> And keep them sorting
2020-09-17 17:39:34 +0200wroathe(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net)
2020-09-17 17:39:38 +0200 <carter> Sorted
2020-09-17 17:39:50 +0200 <carter> These are different proof / computation strategies for sets
2020-09-17 17:39:54 +0200 <carter> Is my point
2020-09-17 17:40:02 +0200 <ski> yep
2020-09-17 17:40:10 +0200 <ski> it would be nice if they could coexist, perhaps
2020-09-17 17:40:29 +0200 <carter> So they could all be kinda constrained proof constructors for equality sortah
2020-09-17 17:40:41 +0200Lycurgus(~niemand@98.4.96.130) (Quit: Exeunt)
2020-09-17 17:40:58 +0200 <carter> In hott land, the equality type is sortah like an open data family. Sortah? Dolio sclv am I wrong?
2020-09-17 17:41:12 +0200 <ski> something like that
2020-09-17 17:41:21 +0200 <carter> So you could conceivably annotate the extra proof terms with a priority weight
2020-09-17 17:41:32 +0200 <carter> Or so something like a sibling to deriving via
2020-09-17 17:41:39 +0200 <dolio> Kind of. It's complex. :)
2020-09-17 17:41:40 +0200 <carter> With some preference ordering
2020-09-17 17:42:10 +0200 <carter> In some ways it veers into wanting relational programming In your functional programming
2020-09-17 17:42:18 +0200 <ski> you mean priorities for eq-via-permutation and eq-via-sorting, e.g. ?
2020-09-17 17:42:37 +0200 <carter> Yeah
2020-09-17 17:42:45 +0200 <carter> It’s still a fuzzy idea of mine
2020-09-17 17:43:02 +0200arianvp(~weechat@arianvp.me) (Quit: WeeChat 2.7.1)
2020-09-17 17:43:05 +0200 <ski> heh, i've recently been thinking about how to construct isomorphisms between types .. and that (in my mind) ties a bit into relational/logic programming
2020-09-17 17:43:11 +0200 <dolio> The interesting thing about quotients in HoTT to me is that the equalities between equal quotient values are computationally relevant.
2020-09-17 17:43:13 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 17:43:35 +0200arianvp(~weechat@arianvp.me)
2020-09-17 17:43:44 +0200 <ski> yes
2020-09-17 17:43:47 +0200sid_cypher(~quassel@200116b80060a70031488a0eec1b5c23.dip.versatel-1u1.de) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2020-09-17 17:43:49 +0200 <carter> Ski I’ve been way overdue to write down some of my ideas in this space.
2020-09-17 17:44:04 +0200sid_cypher(~quassel@200116b80060a70031488a0eec1b5c23.dip.versatel-1u1.de)
2020-09-17 17:44:22 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net) (Remote host closed the connection)
2020-09-17 17:44:24 +0200 <carter> Plague time plus forcing myself to look into new jobs for a change of pace have eaten into bandwidth. Current job is great. But kinda want a change of pace
2020-09-17 17:44:30 +0200lemmih_(~lemmih@58.182.131.25)
2020-09-17 17:44:34 +0200 <dolio> So you can possibly do 'different' things for 'equal' values, but those things are still able to be mediated between by some other computation.
2020-09-17 17:44:40 +0200 <ski> (my "reflective syntax" idea, that i introduced for effectful computations, also seems to fit nicely, with some modifications, to equality proofs, and to computing with such HITs)
2020-09-17 17:44:43 +0200kw(ac4a6125@cpe-172-74-97-37.nc.res.rr.com)
2020-09-17 17:44:48 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net)
2020-09-17 17:45:01 +0200 <carter> Ski how’d you get your logic programming thoughts
2020-09-17 17:45:41 +0200spew(uid195861@gateway/web/irccloud.com/x-dhwinilivvllyihf)
2020-09-17 17:46:18 +0200kenran(~maier@b2b-37-24-119-190.unitymedia.biz) (Ping timeout: 272 seconds)
2020-09-17 17:46:56 +0200lemmih(~lemmih@2406:3003:2072:44:251c:6ccc:226:e43d) (Ping timeout: 244 seconds)
2020-09-17 17:47:02 +0200 <ski> well. if you e.g. express an isomorphism between `Nat' and `Fin n * Nat', you're expressing a bidirectional translation. that's like a binary predicate (except that you enforce it being functional, in both directions). so the "body" of your definition will effectively come after something corresponding to `:-' in Prolog
2020-09-17 17:47:19 +0200proofofkeags(~proofofke@174-29-30-112.hlrn.qwest.net)
2020-09-17 17:47:27 +0200 <carter> i'm not super literate at prolog
2020-09-17 17:47:29 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:59f2:1ee3:fe3e:b848)
2020-09-17 17:47:35 +0200 <carter> more strict relational plus datalog
2020-09-17 17:48:03 +0200 <ski> `:-' is converse implication `<=', basically. or maybe converse entailment `-|', if you prefer
2020-09-17 17:48:13 +0200 <dolio> Which in some ways makes it "easier" to write functions from quotients. You don't need to decide some canonical representative of each equivalence class and produce an identical result. You just need to show how to mediate between the results when someone presents you with how two values are 'equal'.
2020-09-17 17:48:44 +0200 <carter> dolio: which referent?
2020-09-17 17:49:29 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net) (Remote host closed the connection)
2020-09-17 17:50:23 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net)
2020-09-17 17:50:24 +0200sid_cypher(~quassel@200116b80060a70031488a0eec1b5c23.dip.versatel-1u1.de) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2020-09-17 17:50:26 +0200 <dolio> Eh?
2020-09-17 17:50:32 +0200fendor(~fendor@t204-126.demo.tuwien.ac.at)
2020-09-17 17:50:43 +0200kritzefitz(~kritzefit@212.86.56.80)
2020-09-17 17:50:59 +0200 <ski> carter : i still have to consider more how computations with these isomorphism / type-equality definitions will actually work. but it seems to naturally want to express itself in logic programming terms, to me, when i'm following the way i'm trying to express things
2020-09-17 17:51:00 +0200kritzefitz(~kritzefit@212.86.56.80) (Client Quit)
2020-09-17 17:52:00 +0200fendor__(~fendor@e237-037.eduroam.tuwien.ac.at) (Ping timeout: 272 seconds)
2020-09-17 17:52:42 +0200 <carter> dolio: couldn't figure you which thing you were referrring to ;)
2020-09-17 17:52:47 +0200 <carter> ski: i can totally see that
2020-09-17 17:52:50 +0200bahamas(~lucian@unaffiliated/bahamas) (Ping timeout: 256 seconds)
2020-09-17 17:52:53 +0200 <carter> full linear logic seems relevant to me
2020-09-17 17:53:01 +0200 <carter> cause its a really nice way to think about certain relations
2020-09-17 17:53:09 +0200martin___(uid411878@gateway/web/irccloud.com/x-mpsimrgxgomecjvf)
2020-09-17 17:53:10 +0200 <dolio> I've just been rambling, so it's referring to stuff I've said, probably.
2020-09-17 17:53:39 +0200machinedgod(~machinedg@45.78.189.122)
2020-09-17 17:53:52 +0200 <carter> Fun rambles
2020-09-17 17:54:15 +0200kw(ac4a6125@cpe-172-74-97-37.nc.res.rr.com) (Ping timeout: 245 seconds)
2020-09-17 17:54:50 +0200 <dolio> It's kind of interesting, really. If you think about the details, it's tying up 'propositions as types' in a really satisfying way.
2020-09-17 17:54:55 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece) (Remote host closed the connection)
2020-09-17 17:55:00 +0200hololeap(~hololeap@unaffiliated/hololeap) (Quit: KVIrc 5.0.1 Aria http://www.kvirc.net/)
2020-09-17 17:55:22 +0200 <ski> carter : .. including also sometimes wanting to be able to use disjunction (not just conjunction), in the body of a rule
2020-09-17 17:55:32 +0200 <carter> which disjunction?
2020-09-17 17:55:32 +0200 <dolio> Because, the 'propositions as types' approach was originally like "well, A + B is used for A ∨ B, and we don't care that the former might have more than one distinct value."
2020-09-17 17:55:33 +0200 <carter> :)
2020-09-17 17:55:52 +0200 <carter> ski have you skimmed mike shulmans linear logic for constructive math?
2020-09-17 17:56:01 +0200 <carter> it kinda touches on this in a really cool way
2020-09-17 17:56:02 +0200 <ski> hm, i think i did, at some point, yes
2020-09-17 17:56:16 +0200 <ski> in what way are you seeing connections to linear logic ?
2020-09-17 17:56:18 +0200 <carter> its a weird paper , but for a conceputal flavor for full linear lgoic
2020-09-17 17:56:39 +0200 <carter> well, the duality structure for *full* linear logic is really good for functional programming / duality / logic programming
2020-09-17 17:56:40 +0200 <dolio> And most attempts to fix that latter part kind of try to make it _not_ have more than one value.
2020-09-17 17:56:40 +0200 <carter> idk
2020-09-17 17:56:48 +0200 <carter> err
2020-09-17 17:57:00 +0200 <carter> poke me about this in a few days, i need to mull how to explain this better
2020-09-17 17:57:02 +0200wgolden(~wgolden@178.162.204.238)
2020-09-17 17:57:11 +0200acidjnk_new3(~acidjnk@p200300d0c736587164f46f145ae9b6a7.dip0.t-ipconnect.de) (Ping timeout: 244 seconds)
2020-09-17 17:57:23 +0200skinods to dolio re functions from quotients
2020-09-17 17:57:26 +0200 <dolio> But the HoTT approach is kind of the opposite. It has more than one value, but there are mediating values between them that make it sort of equivalent to having only one value.
2020-09-17 17:57:51 +0200 <ski> (carter : at least if it's the slides i think it is. link ?)
2020-09-17 17:58:01 +0200 <dolio> More than one value in a strict sense, but not 'up to paths'.
2020-09-17 17:58:07 +0200pera(~pera@unaffiliated/pera)
2020-09-17 17:58:14 +0200 <carter> https://arxiv.org/abs/1805.07518 ?
2020-09-17 17:59:04 +0200 <ski> hm, i think i didn't see this paper (maybe i saw slides of a presentation of it, not sure)
2020-09-17 17:59:07 +0200 <ski> ty
2020-09-17 17:59:08 +0200zebrag(~inkbottle@aaubervilliers-654-1-94-225.w86-212.abo.wanadoo.fr)
2020-09-17 17:59:14 +0200inkbottle(~inkbottle@aaubervilliers-654-1-114-91.w86-198.abo.wanadoo.fr) (Ping timeout: 260 seconds)
2020-09-17 17:59:45 +0200ph88(~ph88@ip5f5af726.dynamic.kabel-deutschland.de)
2020-09-17 18:00:05 +0200Maxdamantus(~Maxdamant@unaffiliated/maxdamantus) (Ping timeout: 240 seconds)
2020-09-17 18:00:29 +0200Rudd0(~Rudd0@185.189.115.103)
2020-09-17 18:00:45 +0200ph88_(~ph88@2a02:8109:9e40:2704:85f2:8dce:6e30:a554) (Ping timeout: 272 seconds)
2020-09-17 18:00:52 +0200brnzhg[m](brnzhgmatr@gateway/shell/matrix.org/x-giqbkbtzwixrtmho) ("Kicked by @appservice-irc:matrix.org : Idle for 30+ days")
2020-09-17 18:01:57 +0200Saukk(~Saukk@2001:998:dc:4a67:1c59:9bb5:b94c:4) (Remote host closed the connection)
2020-09-17 18:02:03 +0200borne(~fritjof@200116b8641fc4005e981dab12496c3b.dip.versatel-1u1.de)
2020-09-17 18:02:13 +0200Maxdamantus(~Maxdamant@unaffiliated/maxdamantus)
2020-09-17 18:02:22 +0200 <ski> carter : "which disjunction?" -- well .. in this case, additive, i suppose you'd say
2020-09-17 18:02:39 +0200 <carter> is that the usual one?
2020-09-17 18:02:47 +0200 <ski> carter : but i've sometimes been pondering how one could program with multiplicative disjunction, as well
2020-09-17 18:02:49 +0200 <carter> the thing is ... the other one is also really nice
2020-09-17 18:02:52 +0200 <ski> the usual constructive one, yes
2020-09-17 18:03:25 +0200 <carter> ski: i have a tiny model of all 4 in haskell code https://github.com/cartazio/symmetric-monoidal/blob/master/src/Control/Monoidal.hs
2020-09-17 18:03:38 +0200 <carter> they are sortah matching pair eliminiators
2020-09-17 18:03:39 +0200 <ski> i have been pondering a pet example, converse of induction on naturals
2020-09-17 18:03:57 +0200 <carter> wait, PAR is the multiplicative one
2020-09-17 18:03:59 +0200 <carter> ddrr
2020-09-17 18:04:05 +0200 <carter> & is the mult product
2020-09-17 18:04:09 +0200 <carter> PAr is the XOR of proofs
2020-09-17 18:04:30 +0200 <ski> XOR ?
2020-09-17 18:04:40 +0200 <carter> yes
2020-09-17 18:04:47 +0200 <carter> multiplicative disjunction is constructive xor
2020-09-17 18:04:47 +0200 <ski> in which sense ?
2020-09-17 18:04:54 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 256 seconds)
2020-09-17 18:05:02 +0200 <carter> like a real number is zero XOR some signed nonzero distance from zero
2020-09-17 18:05:10 +0200 <carter> proving one rules out the other
2020-09-17 18:05:13 +0200Neuromancer(~Neuromanc@unaffiliated/neuromancer)
2020-09-17 18:05:15 +0200 <carter> or disproving one implies the other
2020-09-17 18:05:31 +0200 <carter> lets you be more explicit about mutally exclusive facts
2020-09-17 18:05:38 +0200 <carter> which IS COOL
2020-09-17 18:05:45 +0200 <ski> how about `x >= 0 \/ x =< 0', disproving one gives you information for proving the other ?
2020-09-17 18:05:48 +0200 <dumptruckman> Is it normal to have a data type with only a single value constructor or is there some better construct for this?
2020-09-17 18:05:58 +0200 <carter> ski: :P
2020-09-17 18:06:01 +0200 <ski> or `p | a*b => p | a \/ p | b', `p' a prime
2020-09-17 18:06:19 +0200 <ski> (the usual proof starts with "Assume not `p | a'.")
2020-09-17 18:06:27 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 18:06:41 +0200 <carter> ski i think your example isn't quite sound unless you have a != zero assumption
2020-09-17 18:06:42 +0200 <dumptruckman> Once again trying to use Haskell to better understand a problem in Java. However, I'm attempting to learn more about the type system this time.
2020-09-17 18:06:49 +0200 <monochrom> But x>=0 together with x >= 0 \/ x =< 0 does not give you any information about x=<0
2020-09-17 18:07:16 +0200 <carter> though x > 0 | x <=0 does thave the onely one is true at the same time
2020-09-17 18:07:27 +0200 <carter> ski: you need to have something where the XOR of the propreties is true
2020-09-17 18:07:33 +0200 <carter> Never the ANd
2020-09-17 18:07:42 +0200 <carter> monochrom: how're you?
2020-09-17 18:07:44 +0200 <monochrom> dumptruckman: It is normal.
2020-09-17 18:07:55 +0200 <ski> dumptruckman : sometimes `newtype' is preferable
2020-09-17 18:08:22 +0200 <ski> carter : i don't see why
2020-09-17 18:08:36 +0200 <ski> carter : `a != zero', for the prime example ?
2020-09-17 18:09:07 +0200 <carter> ski: your lack of parens confused me
2020-09-17 18:09:09 +0200 <ski> monochrom : the idea was that refuting one would give you information about the other
2020-09-17 18:09:19 +0200 <carter> *proves the other*
2020-09-17 18:09:40 +0200 <carter> so par is actually a really good model for bijections
2020-09-17 18:09:53 +0200 <carter> because negation could just be producer/consumer polarity
2020-09-17 18:10:01 +0200 <carter> in certain models of the logic
2020-09-17 18:10:11 +0200urdh(~urdh@unaffiliated/urdh) (Ping timeout: 240 seconds)
2020-09-17 18:10:19 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece)
2020-09-17 18:11:08 +0200 <carter> (gcd(a,b)==1, AND `p' a prime AND p | a*b ) => (p | a) xor (p | b'),
2020-09-17 18:11:16 +0200 <carter> ski: tweaks it
2020-09-17 18:11:25 +0200 <carter> *fixed it
2020-09-17 18:11:33 +0200 <carter> that would you be the property using par
2020-09-17 18:11:40 +0200 <dolio> I think the `A ∨ B` version would probably not be linear.
2020-09-17 18:11:57 +0200 <dolio> You can only do that argument linearly with par.
2020-09-17 18:12:08 +0200 <carter> dolio: yeah, the formal modelling this way is still useful sans linearity
2020-09-17 18:12:19 +0200 <carter> linearity is just how you derive the logic and dualities first
2020-09-17 18:12:25 +0200 <carter> or at least thats my perspective
2020-09-17 18:12:26 +0200 <carter> idk
2020-09-17 18:12:27 +0200 <dolio> Because for additive disjunction you'd be dropping a proof in the case you don't need it.
2020-09-17 18:12:27 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Quit: Free ZNC ~ Powered by LunarBNC: https://LunarBNC.net)
2020-09-17 18:12:31 +0200 <carter> yup
2020-09-17 18:12:38 +0200 <carter> dolio: sum?
2020-09-17 18:12:42 +0200 <dolio> Right.
2020-09-17 18:12:45 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2020-09-17 18:13:08 +0200 <carter> yeah,
2020-09-17 18:13:10 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2020-09-17 18:13:17 +0200 <dolio> Also `P \par Q` has aspects where they "can't both be true".
2020-09-17 18:13:24 +0200 <carter> dolio: oh?
2020-09-17 18:13:31 +0200 <carter> i mean, yes
2020-09-17 18:13:34 +0200 <carter> err
2020-09-17 18:13:39 +0200 <carter> dolio: example / explaborate?
2020-09-17 18:13:47 +0200 <carter> have i been wrong for years, AGAIN :)
2020-09-17 18:14:03 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2020-09-17 18:14:29 +0200 <carter> either way i'm happy to continue chatting about this with folks
2020-09-17 18:14:29 +0200urdh(~urdh@unaffiliated/urdh)
2020-09-17 18:14:29 +0200 <dolio> Well, that's what you'd expect from xor.
2020-09-17 18:14:33 +0200 <carter> oh yeah
2020-09-17 18:14:42 +0200 <ski> carter : yea .. except that one wants to be able to refer to primality, often, without having to make sure / know that the two factors are coprime
2020-09-17 18:14:45 +0200 <carter> if both are true or both are false, xor is fal
2020-09-17 18:14:52 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net) (Remote host closed the connection)
2020-09-17 18:15:00 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net)
2020-09-17 18:15:03 +0200 <carter> ski: absolutely, i'm just showing
2020-09-17 18:15:12 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2020-09-17 18:15:22 +0200cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net)
2020-09-17 18:15:48 +0200 <carter> dolio: you mean that/
2020-09-17 18:15:55 +0200 <dolio> carter: I don't have examples because I'm still not good at thinking about par.
2020-09-17 18:16:00 +0200 <carter> dolio: i was presupposing you have a proof of a xor b
2020-09-17 18:16:12 +0200 <carter> dolio: you can def prove a xor b false
2020-09-17 18:16:17 +0200 <ski> carter : anyway, i'm not convinced it should model `xor' in some sense. (and i didn't follow the "so par is actually a really good model for bijections" bit, either)
2020-09-17 18:16:33 +0200 <carter> ski: depends on your model of it
2020-09-17 18:16:34 +0200 <dolio> Yeah, proving both would be a way to prove a xor b false.
2020-09-17 18:16:40 +0200 <carter> yup
2020-09-17 18:16:42 +0200 <carter> exactly
2020-09-17 18:16:50 +0200 <carter> or disproving both
2020-09-17 18:16:59 +0200 <carter> ski: i'm aboslutely happy to help explain more
2020-09-17 18:16:59 +0200 <ski> usually, with boolean logic, biimplication would be `xnor', not `xor'
2020-09-17 18:17:16 +0200 <ski> (maybe that's not what you meant by "bijections", though)
2020-09-17 18:17:23 +0200 <carter> ski: for the relational model, negation could just be the direction that info flows
2020-09-17 18:17:30 +0200 <carter> *for bijections
2020-09-17 18:17:37 +0200 <carter> not a consumes an a
2020-09-17 18:17:41 +0200 <carter> a produces an a
2020-09-17 18:18:03 +0200 <carter> i think of A `par` B as ==== (not a -> b) & (not b -> a)
2020-09-17 18:18:24 +0200 <ski> yes, but that image would admit overlap
2020-09-17 18:18:25 +0200 <carter> & === multiplicative conj where you *choose which* field you get
2020-09-17 18:18:40 +0200 <carter> all the session type falvored stuff dropps the symmetries
2020-09-17 18:18:44 +0200 <ski> that would be additive conj.
2020-09-17 18:18:58 +0200 <carter> i get add and mult confused
2020-09-17 18:19:04 +0200 <carter> sum, pair, & and par
2020-09-17 18:19:23 +0200 <carter> i dont really see the metaphor for the additive vs mult binary operators perspective
2020-09-17 18:19:24 +0200 <ski> hm. when i read Wadler's paper on session types and linear logic, i was thinking all connectives were the opposite of what i expected
2020-09-17 18:19:47 +0200 <carter> and i alwasy forget which things are additives vs mult
2020-09-17 18:19:57 +0200 <ski> (iow, replaced by duals, everywhere. or possibly it was just for one of the subsystems described)
2020-09-17 18:20:20 +0200 <carter> i dont like a lott of / most expositions i've seen
2020-09-17 18:20:45 +0200 <dolio> ski: Might depend on how they were being used, I guess.
2020-09-17 18:20:45 +0200 <ski> consider `a * (b + c) = (a * b) + (a * c)'
2020-09-17 18:20:53 +0200 <ski> `*' is multiplicative, `+' is additive
2020-09-17 18:20:55 +0200 <dolio> Inputs vs outputs.
2020-09-17 18:20:57 +0200 <ski> that's how i remember it
2020-09-17 18:21:45 +0200 <ski> dolio : yes, presumably, but it still seemed simpler to me, to just flip all the connectives, then. not upset people's expectations, for what seemed to be no reason
2020-09-17 18:23:10 +0200 <ski> carter : fwiw, i don't like the usual notation for (some of) the connectives ..
2020-09-17 18:23:16 +0200bicho_rastrero(~cerdito@154.85-87-39.dynamic.clientes.euskaltel.es)
2020-09-17 18:23:24 +0200 <dolio> Which one? :)
2020-09-17 18:23:24 +0200 <ski> .. so, in personal notes, i'm using my own convention :)
2020-09-17 18:23:31 +0200 <ski> yea, there's several
2020-09-17 18:23:39 +0200 <ski> i had Girard's one in mind
2020-09-17 18:23:58 +0200 <dolio> I think both are wrong categorically.
2020-09-17 18:24:27 +0200 <ski> (i reconstructed it from memory, after getting exposed to the ideas. then, after a bit, i noticed my reconstructed version was not the same as in the papers i read)
2020-09-17 18:24:42 +0200 <carter> dolio: which are wrong how?
2020-09-17 18:25:04 +0200 <dolio> carter: Additives are (co)product, but I think neither notation uses * for additve conjunction.
2020-09-17 18:26:08 +0200 <dolio> That would suggest + for additive disjunction, too, but maybe Girard doesn't do that, either.
2020-09-17 18:26:17 +0200 <dolio> It's a circled +?
2020-09-17 18:26:41 +0200 <dolio> I've heard Girard's notation is supposed to remind you of distributive laws.
2020-09-17 18:26:48 +0200nan`(~nan`@unaffiliated/nan/x-5405850)
2020-09-17 18:27:18 +0200 <carter> lol
2020-09-17 18:27:46 +0200 <dolio> But I'm not sure that's worth it.
2020-09-17 18:29:26 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz) (Quit: p-core)
2020-09-17 18:29:28 +0200jedws(~jedws@101.184.189.58) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-09-17 18:29:45 +0200 <ezzieyguywuf> so pretty much always just use ghcup rather thn whatever my OS's package manager has, right?
2020-09-17 18:29:45 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz)
2020-09-17 18:29:57 +0200Gurkenglas(~Gurkengla@unaffiliated/gurkenglas)
2020-09-17 18:30:10 +0200carlomagno(~cararell@inet-hqmc02-o.oracle.com)
2020-09-17 18:30:34 +0200 <maerwald> ezzieyguywuf: if your OS PM gets it right... then that's also nice
2020-09-17 18:30:47 +0200 <ski> clearly ⌜+⌝ ought to be coproduct ("either","internal choice"), ⌜×⌝ be product ("with","external choice"), ⌜0⌝ be initial object ("void"), ⌜1⌝ be terminal object ("erase"), i thought. that leaves ⌜⊕⌝ for multiplicative disjunction ("par"), ⌜⊗⌝ for multiplicative conjunction, and then i took ⌜⊥⌝ ("bot") and ⌜⊤⌝ ("top","unit") as the respective neutral elements for those
2020-09-17 18:30:47 +0200 <dumptruckman> So... If I wanted to model a game state a Monad would be sensible for this, right?
2020-09-17 18:31:00 +0200 <maerwald> ezzieyguywuf: but ghcup is faster with adding new versions, most likely
2020-09-17 18:31:17 +0200 <dolio> Oh yeah, the units are all mixed up, too.
2020-09-17 18:31:28 +0200 <ezzieyguywuf> maerwald: they did the ghc nicely, they just pulled the binary from upstream, but the cabal install is a mess - I end up having to jump through all these hoops to get the cabal dependencies installed in the PM
2020-09-17 18:31:56 +0200 <ezzieyguywuf> I was planning to just install ghc and cabal from the OS, then cabal install to grab things I need for dev and install the locally
2020-09-17 18:32:57 +0200hackageuniqueness-periods-vector-filters 0.1.1.0 - A library allows to change the structure of the 'RealFrac' function output. https://hackage.haskell.org/package/uniqueness-periods-vector-filters-0.1.1.0 (OleksandrZhabenko)
2020-09-17 18:33:17 +0200 <ski> yes, Girard uses : ⌜⊕⌝,⌜&⌝,⌜0⌝,⌜⊤⌝ for the additives, and ⌜⅋⌝,⌜⊗⌝,⌜⊥⌝,⌜1⌝ for the multiplicatives
2020-09-17 18:34:01 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz) (Remote host closed the connection)
2020-09-17 18:34:25 +0200coot(~coot@37.30.52.181.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2020-09-17 18:34:27 +0200 <ski> dumptruckman : monads can be nice for keeping track of state, yes
2020-09-17 18:35:40 +0200 <ski> (oh, forgot to say that mult. conj. is "(both) .. and .."/"tensor")
2020-09-17 18:38:16 +0200coot(~coot@37.30.52.181.nat.umts.dynamic.t-mobile.pl)
2020-09-17 18:38:20 +0200fendor(~fendor@t204-126.demo.tuwien.ac.at) (Remote host closed the connection)
2020-09-17 18:41:30 +0200 <Uniaika> phadej: do you think if SqlQQ can be safely extracted from postgresql-simple? I'd like to use it for sqlite too but I'm not familiar with postgresql-simple's internals
2020-09-17 18:43:08 +0200 <ezzieyguywuf> k so really...no definitive answer on OS vs ghcup
2020-09-17 18:43:09 +0200 <ski> dumptruckman : some alternative might perhaps be to try to keep local state, maybe via some kind of stream processors or something (FRP ?)
2020-09-17 18:43:14 +0200LKoen(~LKoen@81.255.219.130)
2020-09-17 18:43:17 +0200 <dumptruckman> mmk
2020-09-17 18:43:37 +0200 <ezzieyguywuf> any gentoo users in here?
2020-09-17 18:43:44 +0200 <dumptruckman> How would I lift the list out of this to be able to use intersect on an instance of Shares? `data Shares = Shares [Sharable]`
2020-09-17 18:43:46 +0200 <maerwald> ezzieyguywuf: why
2020-09-17 18:44:00 +0200 <maerwald> also: gentoo is not the distro that does get GHC right
2020-09-17 18:44:12 +0200 <ski> dumptruckman : pattern-matching
2020-09-17 18:44:19 +0200 <dumptruckman> what would that look like
2020-09-17 18:44:28 +0200hackagepusher-http-haskell 2.0.0.1 - Haskell client library for the Pusher Channels HTTP API https://hackage.haskell.org/package/pusher-http-haskell-2.0.0.1 (willsewell)
2020-09-17 18:44:35 +0200 <dumptruckman> do i need to define `intersect :: Shares -> Shares -> Shares`?
2020-09-17 18:44:38 +0200 <ski> intersectShares :: Shares -> Shares -> Shares
2020-09-17 18:44:39 +0200 <dumptruckman> ok
2020-09-17 18:44:46 +0200 <monochrom> "OS vs ghcup" depends on the OS. However, for 90% of OSes, go with ghcup.
2020-09-17 18:44:52 +0200 <dumptruckman> oh, i have to name it differently?
2020-09-17 18:45:03 +0200 <ski> instersectShares (Shares ss0) (Shares ss1) = Shares (intersect ss0 ss1)
2020-09-17 18:45:15 +0200 <ski> depends on whether you import `intersect' qualified
2020-09-17 18:45:37 +0200 <dumptruckman> hmm ok
2020-09-17 18:45:59 +0200geekosaur(42d52102@66.213.33.2)
2020-09-17 18:46:47 +0200 <dumptruckman> is it silly to use the & operator for this?
2020-09-17 18:46:53 +0200 <dumptruckman> is that even possible?
2020-09-17 18:46:58 +0200 <monochrom> You can.
2020-09-17 18:47:00 +0200 <ezzieyguywuf> maerwald: there's been changes in gentoo rather recently, the haskell situation is lots better
2020-09-17 18:47:20 +0200 <ezzieyguywuf> but I still think I'm going to stick to ghcup - I don't want to have, like, mtl and stuff installed at the system level
2020-09-17 18:47:30 +0200coot(~coot@37.30.52.181.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2020-09-17 18:47:50 +0200 <maerwald> ezzieyguywuf: I'd be surprised, because the gentoo PM cannot handle installing the same package mulitple times
2020-09-17 18:48:01 +0200 <maerwald> which you need for haskell packages
2020-09-17 18:48:51 +0200 <maerwald> The proper way to packages haskell is: only package GHC and cabal and *nothing* else (no haskell packages)
2020-09-17 18:49:17 +0200 <ski> (dumptruckman : btw, in Haskell terminology, you wouldn't talk about "an instance of Shares", but rather about values of (type) `Shares')
2020-09-17 18:49:20 +0200 <maerwald> everything else ends up showing limitations of the package manager with the only exception being nix
2020-09-17 18:49:32 +0200 <maerwald> but then... you know... you'd have to use nix, ugh
2020-09-17 18:50:18 +0200 <ezzieyguywuf> maerwald: it can, it's called "slots"
2020-09-17 18:50:49 +0200 <ezzieyguywuf> maerwald: that's what I wanted to do, but in the current setup, I have separate packages for cabal's dependencies, i.e. mtl, fail, etc.
2020-09-17 18:51:04 +0200 <maerwald> ezzieyguywuf: no, I'm talking about the same version
2020-09-17 18:51:09 +0200 <maerwald> slots don't do that
2020-09-17 18:51:18 +0200 <ezzieyguywuf> also, on a different note - I accidentally ran `ghcup` in `/root` as `myUser`, and it gave me a permission error when it tried to do `cabal new-update`
2020-09-17 18:51:21 +0200 <phadej> Uniaika: https://hackage.haskell.org/package/postgresql-simple-0.6.2/docs/src/Database.PostgreSQL.Simple.Sq… just copy it
2020-09-17 18:51:27 +0200 <phadej> it doesn't really do anything smart
2020-09-17 18:51:29 +0200 <dumptruckman> ski: thanks, i wasn't sure about that
2020-09-17 18:51:31 +0200 <ezzieyguywuf> shouldn't it always dereference my ~ variable, no matter what the current directory is?
2020-09-17 18:51:53 +0200 <phadej> (cliking source on hackage docs pages is the trick, often enough ;)
2020-09-17 18:51:54 +0200 <ezzieyguywuf> maerwald: so there's a need for the same version of the same package to be installed multiple times?
2020-09-17 18:52:06 +0200 <maerwald> ezzieyguywuf: You cannot install filepath-1.2.0.0 for multiple GHC slots on gentoo
2020-09-17 18:52:21 +0200 <maerwald> that's a fact, slots don't solve this
2020-09-17 18:52:22 +0200 <maerwald> nix does
2020-09-17 18:52:38 +0200 <ski> dumptruckman : it's fine, got what you meant. just pointing it out, for more efficient future communication
2020-09-17 18:53:02 +0200 <ezzieyguywuf> neat! is ghcup tui using the boxes thing?
2020-09-17 18:53:08 +0200 <ezzieyguywuf> urm, bricks
2020-09-17 18:53:16 +0200 <maerwald> yes
2020-09-17 18:53:27 +0200 <ezzieyguywuf> 😍 ery cool
2020-09-17 18:53:33 +0200_ks(~kevin@nyc-0.mil.lat)
2020-09-17 18:54:04 +0200 <ezzieyguywuf> so I want to try using just cabal install of stack. If I want to install xmonad do I just do cabal install xmonad?
2020-09-17 18:54:25 +0200 <ezzieyguywuf> is there a different install command if I want/need to install a package in a 'sandbox' for a particular project?
2020-09-17 18:54:39 +0200 <maerwald> ezzieyguywuf: sandboxes are removed
2020-09-17 18:54:53 +0200 <ezzieyguywuf> so things..."just work"?
2020-09-17 18:55:17 +0200 <maerwald> you can point it to a different store dir to emulate that, but that's more like something you'd do in CI, not on your local machine
2020-09-17 18:55:36 +0200 <maerwald> ezzieyguywuf: https://cabal.readthedocs.io/en/3.4/nix-local-build-overview.html
2020-09-17 18:55:47 +0200nineonine(~nineonine@216-19-190-182.dyn.novuscom.net) (Remote host closed the connection)
2020-09-17 18:56:06 +0200 <sclv> xmonad is the one tricky thing because it doesn't work out of the box with new-build stuff in terms of its auto-reload on config chang estuff
2020-09-17 18:56:18 +0200 <sclv> there's some writeups of different techniques around the web
2020-09-17 18:56:37 +0200 <ezzieyguywuf> aw man
2020-09-17 18:56:39 +0200 <sclv> but that's now a cabal/new-build problem, its a "xmonad hasn't been updated to deal with new functionality well" problem
2020-09-17 18:56:58 +0200 <ezzieyguywuf> s/now/not/ I assume
2020-09-17 18:56:59 +0200 <sclv> i don't know offhand the "canonical" way to make it work, but i do know there are solutions
2020-09-17 18:57:03 +0200 <sclv> yes, typo
2020-09-17 18:58:01 +0200 <ezzieyguywuf> maerwald: thanks for the link reading now
2020-09-17 18:58:01 +0200 <carter> Ski dolio what makes them multiplicative vs additive?
2020-09-17 18:58:22 +0200 <ski> carter : i'd say, the distributive law(s)
2020-09-17 18:58:42 +0200 <dolio> Multiplicatives are tuple-like, and additives are choice-like.
2020-09-17 18:58:52 +0200 <ski> the replicated connective is multiplicative. the connective it's replicating over is additive
2020-09-17 18:58:53 +0200 <sclv> ezzieyguywuf: here's one xmonad ticket with some discussion on the issue -- using a build-script seems like the right approach but idk https://github.com/xmonad/xmonad/issues/199
2020-09-17 18:59:42 +0200 <zebrag> If `m` is an applicative, there really are `Int` in `m Int`. And it really puzzles me that it is always so. If it were only a functor it wouldn't be so. I'm wondering where, on the way from functor to applicative, is this property added.
2020-09-17 18:59:45 +0200 <dolio> Multiplicative conjunction values are like pairs of values. Multiplicative disjunction continuations are like pairs of continuations.
2020-09-17 18:59:57 +0200 <ski> yes, additives have to do with choice (internal or external). or information/exformation, if you want. while multiplicatives have to do with aggregation and communication/composition
2020-09-17 19:00:02 +0200 <carter> dolio: ok that makes more sense to me
2020-09-17 19:00:10 +0200 <maerwald> there are two kinds of oss projects: 1. unmaintained, 2. pedantic dictatorship maintained
2020-09-17 19:00:26 +0200 <carter> maerwald: reductive but not false?
2020-09-17 19:00:31 +0200 <carter> well, depends on what maintained means
2020-09-17 19:00:32 +0200 <maerwald> I chose 2. and went with i3
2020-09-17 19:00:39 +0200 <ski> zebrag : "If `m` is an applicative, there really are `Int` in `m Int`." -- nope
2020-09-17 19:01:08 +0200 <carter> ski: dolio ... but does this flavor of additive vs multiplicative have a formal meaning?
2020-09-17 19:01:14 +0200 <Uniaika> phadej: glorious, thank you!
2020-09-17 19:01:34 +0200 <zebrag> ski: What makes me thing that is that ocaml has some sort of do-notation for applicatives
2020-09-17 19:01:43 +0200 <amf> I'm using sortBy, but I need to order by 2 fields in a specific order, what is the technique? and would this be called a compound sort? (wasnt sure what to google)
2020-09-17 19:01:43 +0200 <ski> carter : .. dunno ?
2020-09-17 19:01:59 +0200 <zebrag> ski: can you give me an example
2020-09-17 19:02:01 +0200 <zebrag> ?
2020-09-17 19:02:14 +0200 <ezzieyguywuf> what about installing, say, hoogle or ghcid
2020-09-17 19:02:14 +0200 <ski> zebrag : okay ? iirc, OCaml also has GADTs, no ?
2020-09-17 19:02:18 +0200 <ezzieyguywuf> just cabal install ghcid?
2020-09-17 19:02:27 +0200 <ski> zebrag : well, `IO' is a canonical example, in Haskell
2020-09-17 19:02:36 +0200qqqqqq(~Me@185.142.40.143)
2020-09-17 19:02:39 +0200 <qqqqqq> 6 To be happy and lifted from hell and misery, Islam is your Jewel of the seas. Say no God except one(Allah)~ 4 To get blessings thru monotheism, He is the Only creator of heaven & earth. 6 He Designed the Universe 4 with Superb ingenuity. 6Lets praise Allah; 3he is our God, thee one; he is the god of Moses; Noah; Jesus & Mohammed; he sent us our Book 7 Quran, 10Monotheism is cleared by all prophets ~ 6 We get heaven by praying to the one god 6& by Sa
2020-09-17 19:02:39 +0200qqqqqq(~Me@185.142.40.143) (Killed (Sigyn (Spam is off topic on freenode.)))
2020-09-17 19:02:49 +0200 <ski> zebrag : there is no `String' inside `getLine :: IO String'
2020-09-17 19:02:55 +0200 <geekosaur> amf, combine the comparison operations with <>
2020-09-17 19:03:48 +0200 <amf> geekosaur: doh! yep, that was it, thanks!!
2020-09-17 19:04:09 +0200nineonine(~nineonine@216.81.48.202)
2020-09-17 19:04:19 +0200 <zebrag> ski: getLine >>= \x -> f? (isn't x substituted for a string along the way?)
2020-09-17 19:04:43 +0200nan`(~nan`@unaffiliated/nan/x-5405850) (Ping timeout: 272 seconds)
2020-09-17 19:05:06 +0200 <carter> Oh I see. Cause cause additive zero is void
2020-09-17 19:05:11 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece) (Remote host closed the connection)
2020-09-17 19:05:17 +0200 <monochrom> maerwald: What is i3?
2020-09-17 19:05:26 +0200 <ski> zebrag : yes, but `getLine' itself does not contain that `String'
2020-09-17 19:05:27 +0200 <ezzieyguywuf> monochrom: I window manager like xmonad
2020-09-17 19:05:29 +0200wroathe(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net) (Ping timeout: 246 seconds)
2020-09-17 19:05:38 +0200 <carter> And that zeros out multiplicative things
2020-09-17 19:05:40 +0200 <maerwald> monochrom: a tiling wm built by a german
2020-09-17 19:05:48 +0200 <maerwald> without window icons
2020-09-17 19:05:54 +0200 <dolio> carter: I'm not sure either. There are differences in the formal stuff, but I'm not sure that qualifies, and I mostly have informal explanations of them.
2020-09-17 19:06:04 +0200 <ezzieyguywuf> maerwald: I don' understand your statement about (1) vs (2) though - you're saying xmonad is unmaintained?
2020-09-17 19:06:07 +0200 <monochrom> I understand now. Was not reading it in context.
2020-09-17 19:06:17 +0200 <maerwald> ezzieyguywuf: yeah :p
2020-09-17 19:06:25 +0200 <ezzieyguywuf> i like i3 and have been using it for years, just considering xmonad b/c i love haskell, lol
2020-09-17 19:06:26 +0200 <monochrom> I went with ghcup for the same reason teeheehee!
2020-09-17 19:06:31 +0200 <dolio> Like, multiplicative stuff involves concatenating contexts, and additive involves sharing them.
2020-09-17 19:06:34 +0200 <carter> Dolio: i think that’s the reason why the distributive law only works that way?
2020-09-17 19:06:35 +0200 <maerwald> well, it's a slim core, so there's not much to maintain?
2020-09-17 19:06:40 +0200 <ezzieyguywuf> monochrom: lol.
2020-09-17 19:06:45 +0200 <carter> Hrmm
2020-09-17 19:06:53 +0200 <carter> I guess that worms
2020-09-17 19:06:55 +0200 <ski> carter : only works which way ?
2020-09-17 19:06:55 +0200 <dolio> That's 'formal', but it doesn't say much.
2020-09-17 19:06:55 +0200 <carter> Works
2020-09-17 19:07:40 +0200 <carter> Hrmm
2020-09-17 19:07:47 +0200 <ezzieyguywuf> worms, lol
2020-09-17 19:07:58 +0200 <carter> I’ll explain after lunch ski
2020-09-17 19:08:19 +0200 <geekosaur> there's plenty of changes to xmonad-contrib, we just don't release very often unless there's a breaking change in ghc (or even more rarely an external library)
2020-09-17 19:08:20 +0200 <dolio> Another informal description is, I think, that additive stuff involves one thing happening among many, while multiplicative stuff involves all things happening.
2020-09-17 19:08:24 +0200 <ezzieyguywuf> btw, `cabal install xmonad` worked once I made sure I had all the non-haskell dependencies avaliable
2020-09-17 19:08:49 +0200ubert(~Thunderbi@178.165.131.132.wireless.dyn.drei.com)
2020-09-17 19:08:58 +0200 <geekosaur> and yes, the core is kept very minimal and basically never changes except when a new ghc breaks something
2020-09-17 19:09:01 +0200 <dolio> So, like A \par B is a branching construct where all the branches happen, unlike A + B where only one branch happens.
2020-09-17 19:09:10 +0200 <carter> That’s true
2020-09-17 19:09:12 +0200 <carter> Ish
2020-09-17 19:09:27 +0200Lord_of_Life_(~Lord@unaffiliated/lord-of-life/x-0885362)
2020-09-17 19:09:38 +0200 <ski> yes
2020-09-17 19:09:38 +0200 <carter> Fork io is kinda a value of type par
2020-09-17 19:09:47 +0200 <carter> If you think In CPS
2020-09-17 19:09:51 +0200 <ski> yes
2020-09-17 19:10:18 +0200 <zebrag> ski: But if, instead of `IO String`, which is a monad, we would have only a functor, then that property of being able to substitute something for a string along the way wouldn't be granted (like if the functor is some constant functor sending every type on the same constant type)
2020-09-17 19:10:19 +0200 <sclv> as a general gripe, i'm tired of people thinking "infrequently updated" means "unmaintained" as opposed to the cases when it can mean "stable, and working, so not being actively worked on"
2020-09-17 19:10:43 +0200 <ski> (but `par :: a -> b -> b' is not, i think)
2020-09-17 19:11:29 +0200 <dolio> carter, ski: That kind of explains why it's related to functions, too. You have two branches: the code in the function, and the code that uses the function's results, and they both happen.
2020-09-17 19:11:42 +0200 <ski> zebrag : (nitpick, `IO' is the monad. not `IO String', and not `getLine') .. we could still substitute something for all zero occurances of `String's
2020-09-17 19:12:20 +0200Lord_of_Life(~Lord@unaffiliated/lord-of-life/x-0885362) (Ping timeout: 256 seconds)
2020-09-17 19:12:28 +0200Lord_of_Life_Lord_of_Life
2020-09-17 19:12:33 +0200igghibu(~igghibu@37.120.201.90)
2020-09-17 19:13:00 +0200 <ski> dolio : yes. also explains the `A -> B' being equivalent to `not A (+) B' thing
2020-09-17 19:13:16 +0200 <dolio> Yeah.
2020-09-17 19:14:45 +0200MorrowM(~max@bzq-110-168-31-106.red.bezeqint.net)
2020-09-17 19:15:44 +0200 <ski> (reminds me of a language (MPD,cf. SR) where, conceptually at least, every function call spawned a thread. depending on how you spawned it, and interacted with it, it could die after delivering back a result message, or persist to receive more messaged along the channel (the name of the function))
2020-09-17 19:16:09 +0200 <zebrag> ski: (yes, I'm ok with the nitpick, it was only an abuse of language)
2020-09-17 19:16:50 +0200 <geekosaur> sounds like Icon coroutines
2020-09-17 19:17:31 +0200rihards(~rihards@balticom-142-78-50.balticom.lv) (Quit: rihards)
2020-09-17 19:17:32 +0200knupfer(~Thunderbi@200116b82cb61c00e890525b81038fc7.dip.versatel-1u1.de)
2020-09-17 19:17:51 +0200rihards(~rihards@balticom-142-78-50.balticom.lv)
2020-09-17 19:17:55 +0200howdoi(uid224@gateway/web/irccloud.com/x-nrdufpvhwzpziwxu)
2020-09-17 19:18:46 +0200ephemeron(~ephemeron@unaffiliated/ephemeron) ()
2020-09-17 19:20:02 +0200 <ski> well, i guess in Icon the thread wouldn't continue executing semi-independently, preemptive concurrence
2020-09-17 19:20:40 +0200 <ski> zebrag : but yes, you couldn't "substitute" in the manner that `>>=' does it, if that was what you had in mind
2020-09-17 19:20:48 +0200 <geekosaur> not as normally implemented. I don't know offhand if there's a concurrent Icon
2020-09-17 19:21:23 +0200Saten-san(~Saten-san@ip-81-11-153-184.dsl.scarlet.be)
2020-09-17 19:23:54 +0200skinods
2020-09-17 19:24:11 +0200ransom(~c4264035@c-73-243-2-10.hsd1.co.comcast.net) (Quit: Textual IRC Client: www.textualapp.com)
2020-09-17 19:24:11 +0200 <ski> (i probably should look into Icon, sometime)
2020-09-17 19:24:55 +0200 <dolio> It doesn't need to be concurrent either, of course. Laziness is a particular choice of which order to process the 'branches that all must happen' in, and call-by-value is another.
2020-09-17 19:25:56 +0200wroathe(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net)
2020-09-17 19:27:07 +0200Lycurgus(~niemand@98.4.96.130)
2020-09-17 19:27:08 +0200tomsmeding(~tomsmedin@tomsmeding.com) (Quit: ZNC 1.7.5 - https://znc.in)
2020-09-17 19:27:36 +0200skinods
2020-09-17 19:27:39 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:59f2:1ee3:fe3e:b848) (Remote host closed the connection)
2020-09-17 19:31:21 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece)
2020-09-17 19:32:31 +0200ph88(~ph88@ip5f5af726.dynamic.kabel-deutschland.de) (Quit: Leaving)
2020-09-17 19:32:35 +0200alp_(~alp@2a01:e0a:58b:4920:102b:86e3:d072:38a0) (Ping timeout: 272 seconds)
2020-09-17 19:34:59 +0200 <zebrag> ski: yes, it is what I had in mind
2020-09-17 19:36:24 +0200 <geekosaur> lazy won't work in the case of icon coroutines because you yield a value to the coroutine (think of it as being connected with a pair of MVars, and yield is putMVar on one followed by takeMVar on the other)
2020-09-17 19:36:53 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:fcb4:8a4:b249:c1d3)
2020-09-17 19:36:54 +0200 <ski> zebrag : you could still do `fmap even (Const "hello" :: Const String Integer)', though
2020-09-17 19:37:47 +0200 <geekosaur> although there's the degenerate case where what's yielded to the coroutine is the equivalent of Nothing… but then Icon isn't pure so laziness has potential problems
2020-09-17 19:38:00 +0200 <ski> geekosaur : hmm .. i remember i figured out how to make `zipWith' a "good consumer" of both its list parameters, by thinking of it in terms of coroutines
2020-09-17 19:38:25 +0200 <dolio> geekosaur: It won't? The general point is that until one of them blocks, nothing forces an ordering.
2020-09-17 19:38:45 +0200 <dolio> So you can eagerly execute the one that will put, or you can execute the one that will take until it blocks on the take.
2020-09-17 19:39:01 +0200eric(~eric@2804:431:c7d4:b75:d805:ea78:a3e:f89f) (Remote host closed the connection)
2020-09-17 19:40:10 +0200 <dolio> And it doesn't necessarily matter as long as when something blocks you can go do other stuff to unblock it.
2020-09-17 19:40:26 +0200 <monochrom> I don't want to perpetuate "c :: F Int menas c contains an Int", because it is not always true, and sometimes it is not even wrong. (In what sense does stf :: S -> (S, Int) contains an Int?) But "pure" is one of the big differences between Functor and Applicative.
2020-09-17 19:40:42 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Quit: Quit.)
2020-09-17 19:41:05 +0200eric(~eric@2804:431:c7d4:b75:d805:ea78:a3e:f89f)
2020-09-17 19:41:07 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-09-17 19:41:13 +0200eric(~eric@2804:431:c7d4:b75:d805:ea78:a3e:f89f) (Remote host closed the connection)
2020-09-17 19:41:27 +0200eric(~eric@2804:431:c7d4:b75:d805:ea78:a3e:f89f)
2020-09-17 19:41:34 +0200dyeplexer(~lol@unaffiliated/terpin) (Read error: Connection reset by peer)
2020-09-17 19:41:47 +0200eric(~eric@2804:431:c7d4:b75:d805:ea78:a3e:f89f) (Remote host closed the connection)
2020-09-17 19:42:01 +0200kenran(~maier@b2b-37-24-119-190.unitymedia.biz)
2020-09-17 19:42:27 +0200 <monochrom> To understand how "pure" is special, I take inspiration from how Moggi uses monads. For his use case, he wants to rule out boring examples like Const, so he adds an extra law that's so strong it implies that "pure" is injective. (Now OK, in his time, there was no applicative, only monad, he would be saying "unit" or "eta" or "mu", I forgot which.)
2020-09-17 19:42:54 +0200 <monochrom> For most useful Applicative instances, pure is indeed injective.
2020-09-17 19:44:18 +0200 <monochrom> Now if pure is injective, if "pure 4" has to be somehow distinguishable from "pure 5", it does mean that your F Int type has to have at least as much information as Int, internally.
2020-09-17 19:44:43 +0200 <monochrom> In Shannon's sense of information.
2020-09-17 19:46:32 +0200nan`(~nan`@unaffiliated/nan/x-5405850)
2020-09-17 19:46:52 +0200tomsmeding(~tomsmedin@2a03:b0c0:0:1010::767:3001)
2020-09-17 19:47:04 +0200bicho_rastrero(~cerdito@154.85-87-39.dynamic.clientes.euskaltel.es) (Quit: leaving)
2020-09-17 19:47:16 +0200kenran(~maier@b2b-37-24-119-190.unitymedia.biz) (Ping timeout: 272 seconds)
2020-09-17 19:47:22 +0200 <monochrom> If you further throw in "pure is a natural transformation from Identity to F", then not just as much information, but also as much structure, i.e., the information is not even all that scrambled up badly.
2020-09-17 19:47:42 +0200 <monochrom> s/throw in/recall/
2020-09-17 19:51:37 +0200 <dolio> Category theorists might say that whether a value of `Identity Int` contains a value of Int is a nonsense question.
2020-09-17 19:51:42 +0200nan`(~nan`@unaffiliated/nan/x-5405850) (Ping timeout: 272 seconds)
2020-09-17 19:52:20 +0200 <dolio> Or, more accurately, it is an evil question.
2020-09-17 19:52:25 +0200 <monochrom> Yeah, at the objects-and-morphisms level, there is not supposed to be "elements".
2020-09-17 19:53:08 +0200finkata(~dpetrov@83.222.188.39) (Read error: Connection reset by peer)
2020-09-17 19:53:15 +0200 <dolio> Well, you would know it is a functor on sets, or types.
2020-09-17 19:53:28 +0200 <dolio> Which have elements/values.
2020-09-17 19:54:35 +0200 <dolio> But of course, it is also evil to distinguish between Int and other types/sets isomorphic to it.
2020-09-17 19:54:51 +0200juuandyy(~juuandyy@90.166.144.65)
2020-09-17 19:55:28 +0200 <monochrom> heh
2020-09-17 19:56:25 +0200 <monochrom> Then my joke yesterday about "mathematicians, category theorists, Haskellers" was wrong.
2020-09-17 19:56:27 +0200glguyhopes dolio doesn't start passing around a collection plate
2020-09-17 19:57:15 +0200 <monochrom> Category theorists should be put on the other side. The joke should go like: Category theorists say: "beware of mathematicians and Haskeller's, they're evil"
2020-09-17 19:57:31 +0200Lycurgus(~niemand@98.4.96.130) (Quit: Exeunt)
2020-09-17 19:57:58 +0200 <monochrom> St. Augustine was the first category theorist! Change my mind.
2020-09-17 19:58:18 +0200 <dolio> Category theorists aren't so great about not being evil either, really.
2020-09-17 19:58:26 +0200 <monochrom> OK!
2020-09-17 19:58:31 +0200 <ski> "wants to rule out boring examples" :(
2020-09-17 19:59:02 +0200 <ski> ("mu" is for `join'. probably "eta", i'd guess. when / from where did "unit" come to be used ?)
2020-09-17 19:59:23 +0200Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-157-9.dhcp-dynamic.fibreop.nb.bellaliant.net) (Remote host closed the connection)
2020-09-17 19:59:31 +0200alp_(~alp@2a01:e0a:58b:4920:98d3:8430:dd:99e)
2020-09-17 19:59:37 +0200 <phadej> eta is unit
2020-09-17 19:59:46 +0200 <dumptruckman> Can I make a typeclass that pulls the first parameter of a value where it's type may have other parameters?
2020-09-17 20:00:02 +0200wgolden(~wgolden@178.162.204.238) ()
2020-09-17 20:00:04 +0200 <phadej> though I forget which way counit/unit in adjunctions are named
2020-09-17 20:00:08 +0200 <phadej> eta/eps there
2020-09-17 20:00:17 +0200 <phadej> need more distinct greek letters
2020-09-17 20:00:35 +0200 <dolio> Unit goes way back to terms from abstract algebra, I imagine.
2020-09-17 20:00:39 +0200 <ski> phadej : the way that makes the monad one the unit
2020-09-17 20:01:23 +0200 <ski> dumptruckman : sorry, i didn't understand that, can you elaborate ?
2020-09-17 20:01:35 +0200 <dumptruckman> like... `class Named a` with a associated function like name :: a -> String
2020-09-17 20:01:57 +0200 <dumptruckman> and it's expected that instances of that type have a String as the first parameter of their values
2020-09-17 20:02:03 +0200 <phadej> ski: makes sense
2020-09-17 20:02:06 +0200 <dolio> Unit being another name for identity element.
2020-09-17 20:02:14 +0200 <ski> what does "the first parameter of their values" mean ?
2020-09-17 20:02:25 +0200 <dumptruckman> data Something = Something String a deriving (Named)
2020-09-17 20:02:50 +0200 <dumptruckman> and so the name function pulls the string out
2020-09-17 20:02:54 +0200 <ski> dolio : hm, yea. it makes sense, with the monoid connections
2020-09-17 20:03:24 +0200 <monochrom> dumptruckman: No.
2020-09-17 20:03:55 +0200 <ski> dumptruckman : if you really want such a type class, you could make it. however, are you going to define any functions that are polymorphic over types that are instances of this type class ? are you going to have more than one instance of the type class
2020-09-17 20:04:14 +0200igghibu(~igghibu@37.120.201.90) (Ping timeout: 256 seconds)
2020-09-17 20:04:27 +0200 <dumptruckman> yes
2020-09-17 20:04:46 +0200 <ski> what's some example of such polymorphic operations ?
2020-09-17 20:04:49 +0200 <dumptruckman> so I guess each instance would have to define implement name itself?
2020-09-17 20:04:57 +0200 <dumptruckman> s/define/
2020-09-17 20:04:59 +0200 <ski> yes, that's how instances work
2020-09-17 20:05:05 +0200 <dumptruckman> well yeah..
2020-09-17 20:05:07 +0200 <tomsmeding> well, like, there's generics
2020-09-17 20:05:31 +0200 <dumptruckman> but like, i don't have to implement anything to use Show for most stuff
2020-09-17 20:05:42 +0200 <tomsmeding> because Show is hard-wired :)
2020-09-17 20:05:43 +0200 <dumptruckman> so it has some kind of default implementation that "just works"?
2020-09-17 20:05:43 +0200 <ski> because `Show' can be derived
2020-09-17 20:05:55 +0200 <tomsmeding> you can use generics to do what you want, I think
2020-09-17 20:06:02 +0200 <ski> (and, usually, should be derived)
2020-09-17 20:06:03 +0200 <tomsmeding> but it's not very pretty
2020-09-17 20:06:04 +0200 <geekosaur> but you must derive it for it to be there
2020-09-17 20:06:14 +0200 <dumptruckman> right
2020-09-17 20:06:28 +0200 <dumptruckman> so i guess it's not an instance of the typeclass if i simply derive that typeclass
2020-09-17 20:06:55 +0200 <dumptruckman> so i suppose i'm wondering if there's a way to do this without making my data types an instance of it
2020-09-17 20:07:05 +0200 <monochrom> Rather, "deriving" is not for arbitrary classes of your own design.
2020-09-17 20:07:25 +0200 <tomsmeding> except for obscure ghc extensions mumble mumble
2020-09-17 20:07:40 +0200eric(~eric@2804:431:c7d4:b75:69f1:6cfd:8841:8fad)
2020-09-17 20:07:54 +0200 <tomsmeding> but, yes, in vanilla haskell, "deriving" is only for built-in things
2020-09-17 20:08:42 +0200 <tomsmeding> dumptruckman: alternative track: what if you define a type 'data CachedShow a = CachedShow String a'
2020-09-17 20:08:44 +0200 <dumptruckman> ahh
2020-09-17 20:08:52 +0200nyd(~nyd@unaffiliated/elysian)
2020-09-17 20:09:17 +0200 <tomsmeding> and then define 'data Something a = Something (CachedShow a)'
2020-09-17 20:09:20 +0200 <dumptruckman> ahhh
2020-09-17 20:09:23 +0200 <dumptruckman> that's a good idea
2020-09-17 20:09:25 +0200 <tomsmeding> where that 'a' is whatever you want of course
2020-09-17 20:09:30 +0200 <sm[m]> I got an SDL app working in GHCI by using -fno-ghci-sandbox per https://stackoverflow.com/questions/61842338/creating-an-sdl2-window-inside-ghci . But I'm having trouble getting rid of the window when the app exits. destroyWindow having no effect. Has anyone got this working ?
2020-09-17 20:09:49 +0200 <tomsmeding> then if you say 'instance Show (CachedShow a) where show (CachedShow s _) = s'
2020-09-17 20:09:57 +0200 <tomsmeding> and just use 'deriving (Show)' on Something
2020-09-17 20:10:14 +0200 <tomsmeding> then you get 'Something [whatever that string has]', which is not exactly what you asked, but it's close
2020-09-17 20:10:31 +0200 <tomsmeding> downside is that now there's a CachedShow constructor in between the Something constructor and the contained data
2020-09-17 20:10:41 +0200 <dumptruckman> or i could simply do: `data Name = Name String` `name :: Name -> String` ` name (Name s) = s` `data Something = Something name a b c`
2020-09-17 20:10:43 +0200 <dumptruckman> i think
2020-09-17 20:10:43 +0200 <tomsmeding> but if you're okay with that, this is a very vanilla way of sort-of getting that :)
2020-09-17 20:11:09 +0200 <tomsmeding> well 'Something Name a b c', not 'Something name a b c', but yes
2020-09-17 20:11:17 +0200 <dumptruckman> yes
2020-09-17 20:11:20 +0200 <dumptruckman> that's what i meant
2020-09-17 20:11:22 +0200 <tomsmeding> but then you still need to implement Show for Something yourself
2020-09-17 20:11:22 +0200 <dumptruckman> oh but wait
2020-09-17 20:11:29 +0200 <tomsmeding> so you haven't won anything
2020-09-17 20:11:32 +0200 <dumptruckman> and i'd still have to implement name
2020-09-17 20:11:40 +0200 <dumptruckman> name :: Show -> String
2020-09-17 20:11:48 +0200 <dumptruckman> er, name :: Something -> String
2020-09-17 20:11:49 +0200 <ski> tomsmeding : that would be bad, imho :)
2020-09-17 20:11:55 +0200fendor(~fendor@77.119.129.27.wireless.dyn.drei.com)
2020-09-17 20:11:59 +0200Gigabitten(~Somn@ip-99-203-18-60.pools.cgn.spcsdns.net)
2020-09-17 20:12:01 +0200 <tomsmeding> the point of my solution, with wrapping the rest of the Something contents _inside_ that Name, you can just 'deriving (Show)' and it works
2020-09-17 20:12:18 +0200 <tomsmeding> ski: yes you haven't won anything and you've made it more complicated :p
2020-09-17 20:12:25 +0200 <tomsmeding> or are you referring to my CachedShow thing
2020-09-17 20:12:26 +0200 <ski> (imho, that `Show' instance is incorrect)
2020-09-17 20:12:27 +0200 <ski> yes
2020-09-17 20:12:29 +0200eric(~eric@2804:431:c7d4:b75:69f1:6cfd:8841:8fad) (Ping timeout: 272 seconds)
2020-09-17 20:12:32 +0200 <tomsmeding> sure
2020-09-17 20:12:41 +0200z0(~z0@bl15-162-186.dsl.telepac.pt) (Quit: leaving)
2020-09-17 20:12:43 +0200 <tomsmeding> was just trying to satisfy dumptruckman's wishes :p
2020-09-17 20:12:53 +0200 <tomsmeding> but I guess yes, perhaps this shouldn't be Show, dumptruckman
2020-09-17 20:12:56 +0200 <ski> well .. they didn't seem to ask for `name' to be related to `show'
2020-09-17 20:13:01 +0200Gigabitten(~Somn@ip-99-203-18-60.pools.cgn.spcsdns.net) (Client Quit)
2020-09-17 20:13:02 +0200 <tomsmeding> OW
2020-09-17 20:13:10 +0200 <tomsmeding> my bad
2020-09-17 20:13:27 +0200 <tomsmeding> okay fair point gimme 1min
2020-09-17 20:14:47 +0200 <dumptruckman> yeah, i just have a bunch of different data types that all have a name
2020-09-17 20:14:57 +0200 <dumptruckman> and instead of having a separate name function for each i'd like to just use name
2020-09-17 20:15:02 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 20:15:37 +0200 <tomsmeding> okay so am I allowed to cheat and use GeneralizedNewtypeDeriving
2020-09-17 20:15:45 +0200 <monochrom> Do you really have an algorithm that cannot be written if every type has a separate name function?
2020-09-17 20:15:46 +0200Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-157-9.dhcp-dynamic.fibreop.nb.bellaliant.net)
2020-09-17 20:15:54 +0200 <dumptruckman> no
2020-09-17 20:16:00 +0200 <dumptruckman> it's more of a clarity thing i guess
2020-09-17 20:16:00 +0200 <monochrom> Then YAGNI
2020-09-17 20:16:16 +0200livvy(~livvy@gateway/tor-sasl/livvy)
2020-09-17 20:16:28 +0200 <monochrom> "clarity by overloading names" is in perpetual controversy.
2020-09-17 20:16:33 +0200 <dumptruckman> so i don't have to do `worldName world` `playerName player` `sharableName sharable` etc
2020-09-17 20:16:54 +0200 <dumptruckman> it maybe be a case of YAGNI but at the same time, i'd love to learn how to do this
2020-09-17 20:17:08 +0200 <tomsmeding> dumptruckman: implementation of my wacked idea: https://paste.tomsmeding.com/bSSsxieh
2020-09-17 20:17:20 +0200 <tomsmeding> 1. the newtype is crucial, 2. you need that HasName in between
2020-09-17 20:17:36 +0200 <tomsmeding> if you don't want the HasName, you need to use generics
2020-09-17 20:17:43 +0200 <tomsmeding> or not do this at all :)
2020-09-17 20:17:46 +0200 <geekosaur> this sounds like the kind of record field problem lens packages are designed for
2020-09-17 20:17:53 +0200frdg(~user@pool-71-184-143-249.bstnma.fios.verizon.net)
2020-09-17 20:17:58 +0200 <ski> dumptruckman : "i just have a bunch of different data types that all have a name","and instead of having a separate name function for each i'd like to just use name" -- that's what i figured possibly was the case :)
2020-09-17 20:18:24 +0200 <dumptruckman> sorry, i should've just said that but it wasn't immediately obvious to myself
2020-09-17 20:18:24 +0200ahmr88(~ahmr88@cpc85006-haye22-2-0-cust131.17-4.cable.virginm.net)
2020-09-17 20:18:37 +0200 <dumptruckman> tomsmeding: only thing is the tuple feels weird
2020-09-17 20:18:40 +0200 <monochrom> For learning purpose, just handwrite every instance. You said it, "learning".
2020-09-17 20:18:48 +0200 <tomsmeding> yeah the tuple is "whatever data you want there"
2020-09-17 20:18:58 +0200 <tomsmeding> had to put something :)
2020-09-17 20:18:59 +0200 <ski> dumptruckman : so .. since it seems you don't want to write overloaded polymorphic operations wrt this type class, i'd suggest that it's probably better to not make such a type class
2020-09-17 20:19:06 +0200 <tomsmeding> RT monochrom
2020-09-17 20:19:13 +0200 <monochrom> For thinking purpose, http://www.cs.utoronto.ca/~trebla/CSCC24-2020-Summer/05-haskell-types-2.html#why
2020-09-17 20:19:19 +0200pingiun(~pingiun@ip-213-124-184-182.ip.prioritytelecom.net) (Quit: Textual IRC Client: www.textualapp.com)
2020-09-17 20:19:28 +0200 <dumptruckman> i'd still like to be able to use the format like `Player { playerName :: String }`
2020-09-17 20:19:49 +0200 <dumptruckman> i tried to do it where each type was like `Player { name :: String }` but it yelled at me
2020-09-17 20:20:24 +0200 <dumptruckman> monochrom: haha nice
2020-09-17 20:21:32 +0200 <ski> monochrom : the law thing is a good point to bring up. perhaps you'd want to add the "have overloaded polymorphic operations defined in terms of methods" point to that, as well ?
2020-09-17 20:21:53 +0200 <monochrom> That's "can be used to build useful general algorithms"
2020-09-17 20:21:58 +0200 <ski> tomsmeding : "RT" ?
2020-09-17 20:22:01 +0200 <tomsmeding> retweet
2020-09-17 20:22:08 +0200 <ski> mhm
2020-09-17 20:22:12 +0200 <dolio> I don't see what's wrong with using type classes to overload something like this.
2020-09-17 20:22:14 +0200 <tomsmeding> except I don't actually use twitter
2020-09-17 20:22:17 +0200 <ski> (so, i guess, "seconded")
2020-09-17 20:22:18 +0200 <dolio> I've done it.
2020-09-17 20:22:20 +0200 <tomsmeding> yes
2020-09-17 20:23:22 +0200__Joker_(~Joker@180.151.105.86) (Ping timeout: 272 seconds)
2020-09-17 20:23:29 +0200ski. o O ( `Default' )
2020-09-17 20:23:42 +0200Sunblaze21(~sanjay@116.72.71.64) ()
2020-09-17 20:24:33 +0200 <frdg> I am trying to install a package with stack: https://dpaste.org/6kxx , how do I know what base versions different ghc's have?
2020-09-17 20:24:47 +0200 <monochrom> You can still set the bar lower or higher regarding how much expectation you expect out of your type class.
2020-09-17 20:25:04 +0200bahamas(~lucian@unaffiliated/bahamas)
2020-09-17 20:25:35 +0200 <monochrom> For example for a field-name type class like HasName, you still have some expectation, even though it's not as high as Ord's.
2020-09-17 20:25:42 +0200acidjnk_new3(~acidjnk@p200300d0c736587164f46f145ae9b6a7.dip0.t-ipconnect.de)
2020-09-17 20:26:12 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz)
2020-09-17 20:27:13 +0200 <monochrom> In this case the expectation being "the method X -> String behaves like field projection".
2020-09-17 20:28:08 +0200Sheilong(uid293653@gateway/web/irccloud.com/x-wnvbbxjsydmfebcp)
2020-09-17 20:28:09 +0200 <monochrom> You can keep it informal like that, or you can go further formalize it.
2020-09-17 20:28:38 +0200 <monochrom> You reckon that it doesn't lead to very powerful algorithms.
2020-09-17 20:28:58 +0200irc_user(uid423822@gateway/web/irccloud.com/x-rnfyabrjtddmocvm)
2020-09-17 20:29:14 +0200 <geekosaur> (…and then you discover lens)
2020-09-17 20:30:07 +0200tomsmeding(~tomsmedin@2a03:b0c0:0:1010::767:3001) (Quit: ZNC 1.7.5 - https://znc.in)
2020-09-17 20:30:08 +0200 <monochrom> But lens's potential for powerful algorithms doesn't come from classes like HasName.
2020-09-17 20:30:29 +0200 <monochrom> It comes from being able to pass a lens as a parameter.
2020-09-17 20:31:10 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 20:31:23 +0200 <monochrom> Regarding HasName it's the other way round. The power of lens leads to HasName. HasName leads to not much (apart from what I said), really.
2020-09-17 20:32:31 +0200tomsmeding(~tomsmedin@2a03:b0c0:0:1010::767:3001)
2020-09-17 20:33:11 +0200 <monochrom> In the case of Default, you have to set the bar pretty low, but it is still not dead zero.
2020-09-17 20:33:42 +0200v0d1ch(~v0d1ch@cable-178-148-120-241.dynamic.sbb.rs) (Ping timeout: 260 seconds)
2020-09-17 20:33:43 +0200 <sm[m]> frdg: memorise https://wiki.haskell.org/Base_package#Versions or https://www.fosskers.ca/en/blog/base in your browser
2020-09-17 20:34:01 +0200 <monochrom> An expectation is "it's a legal value of your type X, and in a very strong sense: it's also a legal value for all of your functions that take X parameters"
2020-09-17 20:34:12 +0200 <dolio> Just having things like `HasName` is very useful.
2020-09-17 20:34:35 +0200 <monochrom> In some cases you also get to expect the default value is also the identity element of a suitable monoid.
2020-09-17 20:34:48 +0200__Joker(~Joker@180.151.105.86)
2020-09-17 20:35:26 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 246 seconds)
2020-09-17 20:35:26 +0200 <dolio> They're more useful when they're lens type stuff than just `X -> String`, but not necessarily because you can pass them as parameters.
2020-09-17 20:36:15 +0200 <dolio> Or, well, they're useful because lenses are more useful than projection functions.
2020-09-17 20:36:36 +0200 <dumptruckman> well how about this... can you explain why `data Player = Player { name :: String }` and `data World = World { name :: String }` can't coexist?
2020-09-17 20:36:57 +0200 <geekosaur> becuase "name" is defined automatcially as a function
2020-09-17 20:36:58 +0200 <monochrom> "name" doubles as a function name.
2020-09-17 20:37:17 +0200 <geekosaur> and it can't simultaneously have type Player -> String and World -> String
2020-09-17 20:37:22 +0200 <sm[m]> frdg: looks like you should use a newer resolver
2020-09-17 20:37:42 +0200dbmikus(~dbmikus@cpe-76-167-86-219.natsow.res.rr.com) (Remote host closed the connection)
2020-09-17 20:37:50 +0200 <dumptruckman> geekosaur: why not? can't the compiler know which is being called?
2020-09-17 20:38:06 +0200 <dolio> Not in general.
2020-09-17 20:38:14 +0200supercoven(~Supercove@dsl-hkibng32-54fb54-166.dhcp.inet.fi) (Ping timeout: 256 seconds)
2020-09-17 20:38:18 +0200 <geekosaur> there are arguments about type-directed name resolution on the wiki iirc
2020-09-17 20:38:39 +0200 <geekosaur> it comes up every time this is discussed
2020-09-17 20:38:43 +0200 <frdg> thanks sm[m]
2020-09-17 20:38:44 +0200 <monochrom> The compiler knows if you make it a class method.
2020-09-17 20:38:47 +0200 <tomsmeding> dumptruckman: automatically deriving Named using Generics; please do not do this! :) https://paste.tomsmeding.com/XkbAiiRJ
2020-09-17 20:38:52 +0200 <geekosaur> and the solution is, basically, lens packages which do HasField
2020-09-17 20:38:53 +0200 <tomsmeding> wanted to flex my Generics muscles
2020-09-17 20:39:20 +0200 <dolio> The problem is that TDNR makes very little sense, because type classes are the sensible type for type-directed name resolution, if you ignore the gatekeeping people have been trying to force on you.
2020-09-17 20:39:39 +0200 <geekosaur> (I recommend fclabels or microlens if you do want to play with that; beware of https://ro-che.info/ccc/23)
2020-09-17 20:39:46 +0200__Joker(~Joker@180.151.105.86) (Ping timeout: 260 seconds)
2020-09-17 20:41:10 +0200stiell(~stian@fsf/member/stiell) (Ping timeout: 260 seconds)
2020-09-17 20:41:25 +0200knupfer(~Thunderbi@200116b82cb61c00e890525b81038fc7.dip.versatel-1u1.de) (Ping timeout: 240 seconds)
2020-09-17 20:41:51 +0200 <dolio> You don't need any lens packages to just overload 'name' to apply to a bunch of different types.
2020-09-17 20:42:05 +0200coot(~coot@37.30.53.120.nat.umts.dynamic.t-mobile.pl)
2020-09-17 20:42:07 +0200 <dolio> If that's really what you want to do.
2020-09-17 20:42:35 +0200 <dumptruckman> neat
2020-09-17 20:42:43 +0200 <dumptruckman> I'll have to read about generics cause that looks crazy
2020-09-17 20:42:51 +0200 <tomsmeding> again, this is killing a musquito with a bazooka :)
2020-09-17 20:42:52 +0200exodrifter(~exodrifte@cpe-173-172-173-93.tx.res.rr.com)
2020-09-17 20:42:54 +0200 <monochrom> I am not against having HasName. I am against having HasName and ending up not actually using it.
2020-09-17 20:42:55 +0200 <dumptruckman> particularly all the "junk"
2020-09-17 20:43:25 +0200 <monochrom> If you don't have an algorithm of type "HasName t => ... t ..." then you don't need HasName.
2020-09-17 20:44:01 +0200stiell(~stian@fsf/member/stiell)
2020-09-17 20:44:03 +0200 <dolio> Why? I have overloaded stuff that I don't use generically like that.
2020-09-17 20:44:19 +0200 <dolio> Because I want to write `peek ustk` and `peek bstk`.
2020-09-17 20:44:21 +0200 <frdg> it is not clear to me what a resolver is, and which different one I should choose with stack.
2020-09-17 20:44:26 +0200 <dolio> Where those are different types of stacks.
2020-09-17 20:44:33 +0200 <monochrom> OK, well, even when I'm against it, it is not 100% against, there are exceptions.
2020-09-17 20:45:09 +0200 <dolio> I mean, by definition, if you have the class, you have at least one thing like that.
2020-09-17 20:45:22 +0200 <monochrom> It then comes down to whether overloading the method name improves or impairs clarity.
2020-09-17 20:45:35 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz) (Ping timeout: 246 seconds)
2020-09-17 20:46:01 +0200 <dumptruckman> I guess I look at SNR with this
2020-09-17 20:46:42 +0200 <dumptruckman> in Java I would have an interface Person with method getPersonName and World with getWorldName, i'd have Person with getName and World with getName because it is less noise
2020-09-17 20:46:48 +0200 <monochrom> No there is no noise here. What you are really looking at is redundancy.
2020-09-17 20:46:58 +0200 <dumptruckman> s/would/wouldn't
2020-09-17 20:47:09 +0200 <dumptruckman> how is that not noise
2020-09-17 20:47:25 +0200 <monochrom> how is that noise instead of redundancy
2020-09-17 20:47:28 +0200 <dumptruckman> redundancy that doesn't aid with readability, impo
2020-09-17 20:47:30 +0200 <dumptruckman> imo*
2020-09-17 20:47:48 +0200 <dumptruckman> it impairs readability by becoming eye strain
2020-09-17 20:48:16 +0200 <dumptruckman> also it may lead you to wonder if they represent similar things
2020-09-17 20:48:22 +0200 <dumptruckman> or if WorldName is something different than PersonNAme
2020-09-17 20:49:34 +0200 <exodrifter> I think "eye strain" is a weak argument? You could install a different color scheme like Solarized. A stronger argument might be "I want to get the name of this entity, and i don't really care what kind of entity it is."
2020-09-17 20:49:42 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz)
2020-09-17 20:49:48 +0200 <tomsmeding> what if you define this Named class, giving a 'name' function, but then concede that Generics is too big a gun, and just hand-implement 'name' for each type you want it for
2020-09-17 20:50:06 +0200 <tomsmeding> 1. you get your noise-less name function, 2. no weird overengineering
2020-09-17 20:50:08 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net) (Remote host closed the connection)
2020-09-17 20:50:23 +0200 <tomsmeding> downside is a little boilerplate when you define the type, but IMO that's minor
2020-09-17 20:50:38 +0200 <exodrifter> you'd have to do that in java anyway if you implemented an interface
2020-09-17 20:50:56 +0200 <tomsmeding> indeed :)
2020-09-17 20:51:08 +0200 <geekosaur> you still need some boilerplate even with Generics
2020-09-17 20:51:17 +0200 <tomsmeding> true, but less
2020-09-17 20:51:59 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 20:52:02 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz) (Client Quit)
2020-09-17 20:52:02 +0200 <monochrom> Like I said, I'm not 100% against it, it depends, there are case-by-case ad hoc judgments to be made.
2020-09-17 20:52:21 +0200 <monochrom> If you rule that the redundancy helps, keep it. If you rule that the redundancy hurts, remove it.
2020-09-17 20:52:24 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz)
2020-09-17 20:52:58 +0200 <monochrom> If you're the sole author and audience, you rule on your own. If you are collaborating with people, you get a consensus.
2020-09-17 20:54:14 +0200 <dumptruckman> Yeah. Good points. I think individual implementations is probably what I'll go with. It's definitely simple and there's only like 3 types
2020-09-17 20:54:15 +0200 <monochrom> But me, having learned how people write explicit types even when types are inferred, how people write pointful code even when it could be pointfree, and most importantly how in both cases the more redundant ways actually help,
2020-09-17 20:54:22 +0200nan`(~nan`@unaffiliated/nan/x-5405850)
2020-09-17 20:54:33 +0200 <monochrom> I decided that in general I keep the redundancy.
2020-09-17 20:54:48 +0200 <frdg> I am having trouble figuring out how to just say `stack install --with_ghc=8.6.5 somepackage`
2020-09-17 20:56:03 +0200 <geekosaur> frdg, in general you don't. you say: stack install --with-resolver=<some resolver based on ghc-8.6.5> <somepackage>
2020-09-17 20:56:25 +0200fendor(~fendor@77.119.129.27.wireless.dyn.drei.com) (Remote host closed the connection)
2020-09-17 20:56:49 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 20:56:54 +0200 <geekosaur> a resolver combines a ghc version with a collection of libraries with versions known to work with each other and that ghc version
2020-09-17 20:57:29 +0200 <frdg> ok. This must be a big difference from cabal?
2020-09-17 20:57:34 +0200petrus(~petrus@unaffiliated/petrus)
2020-09-17 20:57:53 +0200immae_(~immae@static.233.10.9.176.clients.your-server.de) (Quit: WeeChat 2.9)
2020-09-17 20:58:16 +0200immae(~immae@2a01:4f8:141:53e7::)
2020-09-17 20:59:08 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net)
2020-09-17 20:59:28 +0200 <tomsmeding> in my limited experience with stack, it is _the_ most important difference from cabal
2020-09-17 21:00:08 +0200 <tomsmeding> shoving stuff like "it's a yaml file, not a cabal file (or also a cabal file)" under the ru
2020-09-17 21:00:08 +0200 <tomsmeding> g
2020-09-17 21:00:28 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:fcb4:8a4:b249:c1d3) (Remote host closed the connection)
2020-09-17 21:01:01 +0200 <Boarders> does anyone know if it is possible with earley to easily have "1 + 2 * 3" parse into all possible disambiguations/bracketings?
2020-09-17 21:01:23 +0200wroathe_(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-09-17 21:01:34 +0200 <phadej> doesn't it give you all parsing by default if you specify ambiguous grammar
2020-09-17 21:01:39 +0200wroathe(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 21:01:47 +0200 <Boarders> I thought so yes, I haven't used it before
2020-09-17 21:01:59 +0200 <monochrom> I don't know earley, but I know that if a parser supports ambiguous grammars, then "E ::= E + E | E * E | Literal" ought to do.
2020-09-17 21:02:06 +0200Saten-san(~Saten-san@ip-81-11-153-184.dsl.scarlet.be) (Quit: WeeChat 2.8)
2020-09-17 21:02:21 +0200 <Boarders> monochrom: not helpful
2020-09-17 21:02:34 +0200 <monochrom> Fine
2020-09-17 21:02:56 +0200 <monochrom> I'm done with askers playing adjudicators and playing GOd.
2020-09-17 21:03:14 +0200 <Boarders> sounds good
2020-09-17 21:03:16 +0200nan`(~nan`@unaffiliated/nan/x-5405850) (Ping timeout: 272 seconds)
2020-09-17 21:03:36 +0200alp(~alp@2a01:e0a:58b:4920:10b8:e9e6:f1db:edd0)
2020-09-17 21:03:40 +0200 <phadej> using Earley is not much more different than parsec. https://github.com/ollef/Earley/blob/master/examples/Expr.hs
2020-09-17 21:03:47 +0200alp_(~alp@2a01:e0a:58b:4920:98d3:8430:dd:99e) (Ping timeout: 272 seconds)
2020-09-17 21:03:49 +0200 <phadej> not hard to find examples either.
2020-09-17 21:04:03 +0200fendor(~fendor@77.119.129.27.wireless.dyn.drei.com)
2020-09-17 21:04:10 +0200 <phadej> (that example is in README, fwiw)
2020-09-17 21:04:44 +0200 <Boarders> yeah, I don't know how that example can be made ambiguous
2020-09-17 21:06:22 +0200wroathe_(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 21:06:50 +0200Rudd0(~Rudd0@185.189.115.103) (Ping timeout: 260 seconds)
2020-09-17 21:08:01 +0200bennofs(~quassel@dslb-188-103-036-188.188.103.pools.vodafone-ip.de) (Ping timeout: 264 seconds)
2020-09-17 21:08:07 +0200 <sm[m]> frdg: https://www.stackage.org shows which resolvers to pick for desired ghc versions
2020-09-17 21:08:14 +0200 <dolio> What happens if you make it into one binding, like `x <- rule $ Add <$> x <* namedToken "+" <*> x <|> Mul <$> x ...`?
2020-09-17 21:08:29 +0200bennofs(~quassel@dslb-188-106-228-057.188.106.pools.vodafone-ip.de)
2020-09-17 21:10:34 +0200 <frdg> sm[m]: I struggle with stack. I know that I want to use the lts-14.27 resolver. I cannot say `stack install --with-resolver=lts-14.27 somepackage`
2020-09-17 21:11:25 +0200 <sm[m]> it's stack install --resolver=lts-14.27 somepackage[-VERSION]
2020-09-17 21:11:30 +0200eric(~eric@2804:431:c7d4:402a:8db3:9561:773:fb8e)
2020-09-17 21:11:45 +0200 <sm[m]> if somepackage is not in lts-14.27 but only in hackage, then you need to add -VERSION
2020-09-17 21:12:15 +0200 <frdg> thank you
2020-09-17 21:12:33 +0200 <sm[m]> (because stack's raison d'etre is reproducible builds, so one way or another all versions must be specified)
2020-09-17 21:12:47 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 21:13:59 +0200 <sm[m]> also, if not only somepackage but some of its deps are not in the stackage snapshot, specify those on the command line too (if there's not too many)
2020-09-17 21:17:05 +0200stiell(~stian@fsf/member/stiell) (Ping timeout: 272 seconds)
2020-09-17 21:17:34 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 21:17:54 +0200 <frdg> after installing about 140 packages, right at the end I get this error: https://dpaste.org/rkw3
2020-09-17 21:18:55 +0200 <sm[m]> that looks like a keter bug then, it probably doesn't have correct bounds
2020-09-17 21:19:23 +0200 <sm[m]> stack guarantees a valid build plan with all bounds satisfied, but it doesn't guarantee all the packages compile
2020-09-17 21:20:17 +0200 <frdg> ill try a different resolver
2020-09-17 21:20:19 +0200 <sm[m]> a typical next move is to check keter's issue tracker or maybe search for the error
2020-09-17 21:20:33 +0200 <phadej> thy find a snapshot which has keter
2020-09-17 21:20:42 +0200 <phadej> it's one of the sad packages
2020-09-17 21:20:51 +0200 <phadej> https://matrix.hackage.haskell.org/#/package/keter
2020-09-17 21:20:59 +0200stiell(~stian@fsf/member/stiell)
2020-09-17 21:21:21 +0200 <sm[m]> https://github.com/snoyberg/keter/issues/207
2020-09-17 21:22:45 +0200 <frdg> hmm. To be honest I dont understand stack at all.
2020-09-17 21:23:16 +0200 <frdg> Ill try cabal
2020-09-17 21:23:49 +0200 <phadej> you'll get similar-ish failure :)
2020-09-17 21:24:19 +0200 <frdg> is all lost with keter?
2020-09-17 21:24:29 +0200 <sm[m]> if you have a look around the issue tracker you'll see lots of such issues. https://github.com/snoyberg/keter/issues/201 has some folks that might help, and maybe a newer branch
2020-09-17 21:24:46 +0200 <frdg> ok thanks for the help
2020-09-17 21:25:33 +0200 <dolio> Boarders: https://paste.tomsmeding.com/eFARmyei
2020-09-17 21:25:44 +0200 <phadej> you need process <1.6
2020-09-17 21:26:18 +0200 <phadej> which means using GHC-8.0
2020-09-17 21:26:26 +0200 <phadej> OR downgrading process library
2020-09-17 21:26:34 +0200 <phadej> which is probably not a good idea
2020-09-17 21:26:54 +0200 <phadej> but might work too
2020-09-17 21:27:11 +0200nyd(~nyd@unaffiliated/elysian) (Quit: nyd)
2020-09-17 21:27:13 +0200 <phadej> cabal install keter --constraint='process<1.6'
2020-09-17 21:27:50 +0200 <frdg> Do any other libraries do what keter does?
2020-09-17 21:28:02 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311)
2020-09-17 21:28:10 +0200juuandyy(~juuandyy@90.166.144.65) (Quit: Konversation terminated!)
2020-09-17 21:28:17 +0200AlterEgo-(~ladew@124-198-158-163.dynamic.caiway.nl) (Quit: Leaving)
2020-09-17 21:28:54 +0200 <phadej> I guess what keter does is handled by modern infrastructure for you
2020-09-17 21:29:09 +0200Tops2(~Tobias@dyndsl-095-033-091-070.ewe-ip-backbone.de)
2020-09-17 21:29:23 +0200notzmv`(~user@177.103.86.92)
2020-09-17 21:29:24 +0200petrus(~petrus@unaffiliated/petrus) (Read error: Connection reset by peer)
2020-09-17 21:29:41 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-09-17 21:30:05 +0200petrus(~petrus@unaffiliated/petrus)
2020-09-17 21:30:38 +0200notzmv(~user@unaffiliated/zmv) (Ping timeout: 260 seconds)
2020-09-17 21:30:56 +0200davidfischer(~davidfisc@193.56.252.210)
2020-09-17 21:31:25 +0200 <frdg> I have a Yesod web-app that I am ready to deploy.
2020-09-17 21:32:58 +0200 <frdg> I am just going by the yesod documentation which reccomends using keter, but it seems that there are other options. I do not know the tradeoffs.
2020-09-17 21:33:25 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz) (Quit: p-core)
2020-09-17 21:33:33 +0200Tops21(~Tobias@dyndsl-095-033-091-070.ewe-ip-backbone.de) (Ping timeout: 272 seconds)
2020-09-17 21:33:37 +0200petrus(~petrus@unaffiliated/petrus) (Client Quit)
2020-09-17 21:33:43 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 21:33:45 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz)
2020-09-17 21:33:52 +0200nan`(~nan`@unaffiliated/nan/x-5405850)
2020-09-17 21:34:30 +0200notzmv`notzmv
2020-09-17 21:34:40 +0200notzmv(~user@177.103.86.92) (Changing host)
2020-09-17 21:34:40 +0200notzmv(~user@unaffiliated/zmv)
2020-09-17 21:34:56 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 21:35:08 +0200 <sm[m]> frdg: IIRC keter helps minimise downtime and dropped requests while upgrading. If you're fine with just installing the new binary and restarting your app, you don't need keter
2020-09-17 21:35:51 +0200 <frdg> sm[m]: Yes I am fine with that.
2020-09-17 21:35:58 +0200 <sm[m]> where are you deploying ? if it has systemd, that's a way to keep your app running
2020-09-17 21:36:27 +0200 <sm[m]> or you can just run it yourself in a shell session made persistent by dtach or screen
2020-09-17 21:36:28 +0200 <frdg> I would like to run it from my laptop running opensuse
2020-09-17 21:36:32 +0200geekosaurconsiders that if it hasn't been updated since ghc-8.0 then it must not be used very much
2020-09-17 21:36:38 +0200ahmr88(~ahmr88@cpc85006-haye22-2-0-cust131.17-4.cable.virginm.net) (Read error: Connection reset by peer)
2020-09-17 21:37:03 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz) (Client Quit)
2020-09-17 21:37:05 +0200finkata(~dpetrov@83.222.188.39)
2020-09-17 21:37:12 +0200knupfer(~Thunderbi@mue-88-130-61-060.dsl.tropolys.de)
2020-09-17 21:37:13 +0200 <sm[m]> frdg: so.. just run it then ? Am I missing something
2020-09-17 21:37:24 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz)
2020-09-17 21:37:27 +0200ahmr88(~ahmr88@cpc85006-haye22-2-0-cust131.17-4.cable.virginm.net)
2020-09-17 21:38:00 +0200 <frdg> well that is what I have been doing...but that only runs on localhost.
2020-09-17 21:38:24 +0200nan`(~nan`@unaffiliated/nan/x-5405850) (Ping timeout: 260 seconds)
2020-09-17 21:38:24 +0200 <sm[m]> for others to access it, you'll run it on a server, like a VPS, right ?
2020-09-17 21:38:34 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 21:38:46 +0200 <frdg> oh I have to use a vps?
2020-09-17 21:38:53 +0200 <frdg> I wanted to just use my computer.
2020-09-17 21:39:35 +0200geekosaur(42d52102@66.213.33.2) (Remote host closed the connection)
2020-09-17 21:39:49 +0200 <sm[m]> are you wanting other people to access it ?
2020-09-17 21:39:51 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-09-17 21:39:52 +0200 <frdg> yes
2020-09-17 21:40:24 +0200 <sm[m]> while it's running on your laptop, and while your laptop is connected ? that's possible, but not easy and not usual
2020-09-17 21:40:31 +0200bahamas(~lucian@unaffiliated/bahamas) (Ping timeout: 272 seconds)
2020-09-17 21:41:01 +0200geekosaur(42d52102@66.213.33.2)
2020-09-17 21:41:07 +0200 <frdg> oh really
2020-09-17 21:41:23 +0200 <koz_> If statistical profiling gives me a lot of variance due to outliers, how do I deal with it?
2020-09-17 21:41:27 +0200 <sm[m]> "hey frdg, open your laptop so I can access the app!"
2020-09-17 21:42:11 +0200 <frdg> so usually people use a vps.
2020-09-17 21:42:20 +0200 <frdg> Only ones I have seen are paid.
2020-09-17 21:42:24 +0200 <geekosaur> not only that but you won't have a fixed address others could use to access it (I just got booted by my local address changing, for an example)
2020-09-17 21:42:51 +0200eric_(~eric@2804:431:c7d4:402a:e9bd:254c:fe89:5831)
2020-09-17 21:42:58 +0200kenran(~maier@b2b-37-24-119-190.unitymedia.biz)
2020-09-17 21:43:16 +0200 <geekosaur> names yes, but you'r unlikely to have a name either and if you do it'll be based on the address
2020-09-17 21:44:50 +0200 <sm[m]> frdg: sometimes people run their own physical server, eg a raspberry pi in a cupboard connected 24/7
2020-09-17 21:45:01 +0200 <koz_> sm[m]: Or, in my case, an old Eee-PC.
2020-09-17 21:45:06 +0200 <sm[m]> but yes a vps is by far the easiest
2020-09-17 21:45:16 +0200 <sm[m]> aha, koz_ knows how
2020-09-17 21:45:28 +0200 <koz_> I've been on the self-hosting train for a while, lol.
2020-09-17 21:45:40 +0200 <koz_> Best thing for a starting self-hoster is actually an old laptop IMHO.
2020-09-17 21:45:41 +0200 <geekosaur> eee pc re-users represent!
2020-09-17 21:46:03 +0200 <koz_> They're easy to set up, easy to fix if stuff breaks, and have a built-in UPS.
2020-09-17 21:46:13 +0200 <frdg> I have an old macbook
2020-09-17 21:46:13 +0200eric(~eric@2804:431:c7d4:402a:8db3:9561:773:fb8e) (Ping timeout: 272 seconds)
2020-09-17 21:46:59 +0200 <koz_> frdg: An old Macbook would work.
2020-09-17 21:47:03 +0200 <sm[m]> koz_: what's the way to ensure a fixed ip address ? use an ISP that will provide that ?
2020-09-17 21:47:18 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Quit: Lost terminal)
2020-09-17 21:47:20 +0200 <nineonine> hey all, I am trying to use hi all, I am trying to use https://hackage.haskell.org/package/process-1.6.10.0/docs/src/System.Process.html#withCreateProcess and sometimes no cleanup is happening
2020-09-17 21:47:23 +0200 <nineonine> is this expected?
2020-09-17 21:47:28 +0200 <koz_> sm[m]: That's what I do - mine charges me 10 bucks a month.
2020-09-17 21:47:33 +0200 <sm[m]> or is a fixed dns name good enough ?
2020-09-17 21:47:45 +0200 <frdg> koz_: Do I just need to get linux on it?
2020-09-17 21:47:46 +0200 <koz_> DNS name needs an IP address to aim at.
2020-09-17 21:47:51 +0200 <koz_> frdg: Yeah, any Linux will do.
2020-09-17 21:47:54 +0200kenran(~maier@b2b-37-24-119-190.unitymedia.biz) (Ping timeout: 260 seconds)
2020-09-17 21:48:22 +0200 <sm[m]> koz_: well there's the dynamic ones where the machine runs a client to update the record on boot
2020-09-17 21:48:24 +0200 <frdg> ok this may fall perfectly into place.
2020-09-17 21:48:30 +0200machinedgod(~machinedg@45.78.189.122) (Ping timeout: 256 seconds)
2020-09-17 21:48:31 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece) (Remote host closed the connection)
2020-09-17 21:48:34 +0200 <koz_> sm[m]: Perhaps, but I've never needed it.
2020-09-17 21:48:54 +0200 <glguy> My ISP has kept my "dynamic" IP address the same on the scale of years
2020-09-17 21:49:03 +0200 <nineonine> the process is not getting killed for some reason
2020-09-17 21:49:25 +0200notzmv`(~user@177.103.86.92)
2020-09-17 21:49:39 +0200 <koz_> glguy: Mine flipped my supposedly static one on me once.
2020-09-17 21:49:44 +0200 <koz_> (that was _real_ fun)
2020-09-17 21:50:02 +0200 <koz_> (both to diagnose and to subsequently inform customer service in _no uncertain terms_ that this was not good enough)
2020-09-17 21:50:08 +0200 <nineonine> ok I see this comment in code
2020-09-17 21:50:11 +0200 <nineonine> terminateProcess does not guarantee that it terminates the process.
2020-09-17 21:50:15 +0200 <geekosaur> right
2020-09-17 21:50:17 +0200 <nineonine> which answers my question
2020-09-17 21:50:28 +0200 <koz_> terminateProcessMaybe :P
2020-09-17 21:50:46 +0200 <sm[m]> discourageProcess
2020-09-17 21:50:48 +0200 <geekosaur> was just about to point out it does terminateProcess and then forkIO-s the following waitForProcess, so in fact it's not cleaned up synchronously at all
2020-09-17 21:51:00 +0200shafox(~shafox@106.51.234.111) (Remote host closed the connection)
2020-09-17 21:51:04 +0200 <koz_> sm[m]:
2020-09-17 21:51:11 +0200 <koz_> kindlySuggestProcessDie
2020-09-17 21:51:13 +0200 <nineonine> this is quite deceiving
2020-09-17 21:51:33 +0200 <koz_> nineonine: Not much we can do about it. Unkillable processes are possible, and Haskell can't really save you.
2020-09-17 21:51:33 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece)
2020-09-17 21:51:43 +0200 <koz_> (I had this happen many times due to dodgy drivers)
2020-09-17 21:51:48 +0200 <geekosaur> ^
2020-09-17 21:51:53 +0200 <koz_> (ended up with a process even the _OS_ couldn't kill)
2020-09-17 21:51:58 +0200 <nineonine> makes sense, my hopes were too high!
2020-09-17 21:52:22 +0200 <davean> well, what OS - a processing being killable or not is an OS thing and some OSes do guarrentee they can
2020-09-17 21:52:27 +0200 <nineonine> so I guess this is an OS quirk
2020-09-17 21:52:32 +0200 <davean> its specificly POSIXy systems that usually have an issue with it.
2020-09-17 21:52:35 +0200 <Boarders> dolio: thanks for your help!
2020-09-17 21:53:02 +0200notzmv(~user@unaffiliated/zmv) (Ping timeout: 260 seconds)
2020-09-17 21:53:25 +0200 <geekosaur> there's also a harder kill than SIGTERM, not that it's guaranteed either — but some processes do ignore SIGTERM for no good reason
2020-09-17 21:53:25 +0200 <sm[m]> btw there's no reason frdg has to install linux on their macbook megaserver I assume
2020-09-17 21:53:29 +0200 <koz_> davean: Well, it was a Linux thing, so yeah. Who guarantees process death?
2020-09-17 21:53:42 +0200 <koz_> sm[m]: No _specific_ reason, no.
2020-09-17 21:53:53 +0200 <koz_> I'd say it's easier for me to self-host on a Linux, but YMMV.
2020-09-17 21:54:09 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz) (Quit: p-core)
2020-09-17 21:54:27 +0200mirrorbird(~psutcliff@2a00:801:44b:8959:8d6c:276b:332b:1c71)
2020-09-17 21:54:28 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz)
2020-09-17 21:54:28 +0200 <monochrom> I think it's easiest if the OS used for compiling is the same OS used for running.
2020-09-17 21:54:31 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 21:54:59 +0200 <monochrom> For example totally don't go "I dev on Windows, deploy on MacOS", that's insanity.
2020-09-17 21:55:51 +0200 <monochrom> You really don't need one more gratuitous variable in your journey.
2020-09-17 21:56:17 +0200geekosaur(42d52102@66.213.33.2) (Remote host closed the connection)
2020-09-17 21:56:33 +0200notzmv``(~user@177.103.86.92)
2020-09-17 21:57:09 +0200 <sm[m]> frdg has an old working macbook and is a bit over their head already, personally for me installing linux on a mac would be a nightmare
2020-09-17 21:57:46 +0200 <koz_> monochrom: Yeah, you're right. I'm merely speaking from my own experience here, and I'm Linux through-and-through.
2020-09-17 21:57:52 +0200 <koz_> (both personally and for work)
2020-09-17 21:58:14 +0200 <sm[m]> getting offtopic here, but I think the real challenge here will be the connectivity (getting through firewalls, setting up dns or static ip)
2020-09-17 21:58:26 +0200 <nineonine> so any idea how can I ensure the process is being killed?
2020-09-17 21:58:32 +0200 <davean> koz_: well its a permissions issue on some OSs (suposibly windows), and others lack the IO hole POSIX systems tend to have (embeded OSs)
2020-09-17 21:58:43 +0200 <nineonine> can I do something nasty like grep by process name and kill it?
2020-09-17 21:58:48 +0200 <nineonine> using shell
2020-09-17 21:58:56 +0200 <koz_> nineonine: That might not necessarily work either.
2020-09-17 21:58:56 +0200 <nineonine> (just in case)
2020-09-17 21:59:00 +0200 <nineonine> doh!
2020-09-17 21:59:02 +0200 <frdg> in the end Ill figure something out. All I want is to avoid pain.
2020-09-17 21:59:08 +0200 <koz_> As I said - I've managed to get an unkillable process even at the OS level.
2020-09-17 21:59:14 +0200 <koz_> (due to bad driver)
2020-09-17 21:59:15 +0200 <nineonine> this is horrible
2020-09-17 21:59:16 +0200 <monochrom> I think it's useful to first find out why the process is not terminating.
2020-09-17 21:59:22 +0200Jesin(~Jesin@pool-72-66-101-18.washdc.fios.verizon.net) (Quit: Leaving)
2020-09-17 21:59:24 +0200 <sm[m]> nineonine: pgrep & pkill are your friends!
2020-09-17 21:59:30 +0200 <davean> nineonine: is that the *kernel* can't kill it
2020-09-17 21:59:37 +0200 <davean> often
2020-09-17 21:59:37 +0200 <sm[m]> oh sorry.. carry on
2020-09-17 21:59:38 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 21:59:44 +0200notzmv`(~user@177.103.86.92) (Ping timeout: 258 seconds)
2020-09-17 21:59:53 +0200 <davean> for example Linux can't kill a process blocked on IO (This is basicly the POSIX OS issue in general)
2020-09-17 21:59:57 +0200 <nineonine> it is pretty hard to reproduce
2020-09-17 22:00:04 +0200incertia(~incertia@d60-65-215-180.col.wideopenwest.com) (Ping timeout: 256 seconds)
2020-09-17 22:00:08 +0200petrus(~petrus@unaffiliated/petrus)
2020-09-17 22:00:21 +0200finkata(~dpetrov@83.222.188.39) (Remote host closed the connection)
2020-09-17 22:00:33 +0200 <sm[m]> frdg: what's more painful, $5/mo or 5-50 hours of system administration :)
2020-09-17 22:00:51 +0200 <monochrom> I don't know if you already know, but if Unix, terminateProcess is just SIGTERM.
2020-09-17 22:00:55 +0200 <davean> nineonine: if you want to generate an unkillable process on POSIX its generally pretty easy using NFS and just removing the server ;)
2020-09-17 22:00:56 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:fcb4:8a4:b249:c1d3)
2020-09-17 22:00:59 +0200incertia(~incertia@d60-65-215-180.col.wideopenwest.com)
2020-09-17 22:01:47 +0200notzmv``notzmv
2020-09-17 22:01:53 +0200notzmv(~user@177.103.86.92) (Changing host)
2020-09-17 22:01:53 +0200notzmv(~user@unaffiliated/zmv)
2020-09-17 22:01:55 +0200 <nineonine> right, that makes sense. the fact that there is no guarantee about terminating the process is quite surprising to me :D
2020-09-17 22:02:04 +0200 <monochrom> Haha NFS brings fond memory.
2020-09-17 22:02:12 +0200 <davean> nineonine: really its the "worse is better" issue
2020-09-17 22:02:32 +0200 <davean> Infact the only OS family I know that has this issue *is* POSIX
2020-09-17 22:02:40 +0200 <davean> I don't know of this being able to happen anywhere else.
2020-09-17 22:03:57 +0200 <monochrom> Old school lab used to be like, every last day of semester, reliably, NFS crashed by overloading, all processes blocked and unkillable, you couldn't even log out. (Because, like, logging out requires checking your home directory for .logout but it's through NFS but NFS is not responding...)
2020-09-17 22:05:11 +0200mariatsji(~mariatsji@2a01:79d:53aa:c66c:fcb4:8a4:b249:c1d3) (Ping timeout: 244 seconds)
2020-09-17 22:05:25 +0200 <sm[m]> there is a way to guarantee termination, and that's to reboot the machine
2020-09-17 22:05:44 +0200 <glguy> cut power; I've had reboots fail :)
2020-09-17 22:05:46 +0200 <sm[m]> right ? or is even that impossible, without a hardware switch ?
2020-09-17 22:06:12 +0200 <sm[m]> ack
2020-09-17 22:07:14 +0200 <monochrom> We students didn't bother to power cycle for many reasons. In this case, turning off would be OK, but turn on would be pointless.
2020-09-17 22:07:33 +0200 <glguy> It would be pretty nifty if having a process stalled on an NFS mount make it so that not even cutting power was enough to kill the process.
2020-09-17 22:07:45 +0200ggole(~ggole@2001:8003:8119:7200:7c4d:5b32:3cf7:fd63) (Quit: Leaving)
2020-09-17 22:07:45 +0200 <glguy> you just were left with a permanently on computer!
2020-09-17 22:08:04 +0200 <monochrom> That's like defy the 2nd law of thermodynamics.
2020-09-17 22:08:14 +0200 <davean> sm[m]: you can't guarrentee a reboot :(
2020-09-17 22:08:17 +0200 <glguy> sure, but we're talking about NFS
2020-09-17 22:08:27 +0200 <monochrom> hahaha OK fine just cause!
2020-09-17 22:08:30 +0200eric(~eric@2804:431:c7d4:402a:218c:8374:598c:5968)
2020-09-17 22:08:44 +0200 <monochrom> "NFS solves the halting problem!"
2020-09-17 22:08:46 +0200 <davean> You know they use to write persistent OSs?
2020-09-17 22:08:57 +0200 <davean> you removed power, you plugged it back in, and it would be exactly where you left it
2020-09-17 22:09:02 +0200 <davean> that was a thing in the 70s
2020-09-17 22:09:12 +0200 <davean> The entire OS was transactional.
2020-09-17 22:09:30 +0200 <davean> There were a few of them, I forget which at this point though
2020-09-17 22:09:54 +0200sm[m]gets itchy for new OSs
2020-09-17 22:10:26 +0200 <monochrom> Well yeah, more seriously you could say "turn off" means use a bit of reserve battery to save state and then turn off.
2020-09-17 22:11:04 +0200 <monochrom> Or even you always have autosave so it's close enough.
2020-09-17 22:11:32 +0200monochromthanks AoE2 DE for having frequent autosave, like only 2 minutes lost in the worst case
2020-09-17 22:11:45 +0200 <davean> Yah no the processes couldn't tell
2020-09-17 22:11:49 +0200 <davean> The memory came back the same.
2020-09-17 22:11:58 +0200hackageuniqueness-periods-vector-examples 0.4.0.0 - Examples of usage for the uniqueness-periods-vector series of packages https://hackage.haskell.org/package/uniqueness-periods-vector-examples-0.4.0.0 (OleksandrZhabenko)
2020-09-17 22:12:04 +0200 <davean> well the same as the last consistent state, which you couldn't have observed past
2020-09-17 22:12:48 +0200coot(~coot@37.30.53.120.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2020-09-17 22:12:49 +0200eric_(~eric@2804:431:c7d4:402a:e9bd:254c:fe89:5831) (Ping timeout: 272 seconds)
2020-09-17 22:13:06 +0200frdg`(~user@pool-71-184-143-249.bstnma.fios.verizon.net)
2020-09-17 22:13:09 +0200mmohammadi9812(~mmohammad@5.238.164.128) (Quit: I quit (╯°□°）╯︵ ┻━┻)
2020-09-17 22:14:10 +0200acarrico(~acarrico@pppoe-209-99-203-201.greenmountainaccess.net)
2020-09-17 22:14:34 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311) (Ping timeout: 260 seconds)
2020-09-17 22:14:35 +0200frdg(~user@pool-71-184-143-249.bstnma.fios.verizon.net) (Ping timeout: 240 seconds)
2020-09-17 22:14:38 +0200notzmv`(~user@177.103.86.92)
2020-09-17 22:15:23 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 22:16:19 +0200juuandyy(~juuandyy@90.166.144.65)
2020-09-17 22:16:27 +0200frdg`(~user@pool-71-184-143-249.bstnma.fios.verizon.net) (Client Quit)
2020-09-17 22:16:28 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2020-09-17 22:16:41 +0200acarrico(~acarrico@pppoe-209-99-203-201.greenmountainaccess.net) (Client Quit)
2020-09-17 22:17:01 +0200acarrico(~acarrico@pppoe-209-99-203-201.greenmountainaccess.net)
2020-09-17 22:18:14 +0200notzmv(~user@unaffiliated/zmv) (Ping timeout: 260 seconds)
2020-09-17 22:20:06 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 22:20:54 +0200machinedgod(~machinedg@d67-193-126-196.home3.cgocable.net)
2020-09-17 22:22:28 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz) (Quit: p-core)
2020-09-17 22:22:49 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz)
2020-09-17 22:23:54 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Quit: Free ZNC ~ Powered by LunarBNC: https://LunarBNC.net)
2020-09-17 22:24:33 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2020-09-17 22:25:02 +0200eric_(~eric@2804:431:c7d4:402a:5d9b:3471:cb46:d9c6)
2020-09-17 22:27:54 +0200bitmagie(~Thunderbi@200116b80679150051a84e8093abf52a.dip.versatel-1u1.de)
2020-09-17 22:28:39 +0200eric(~eric@2804:431:c7d4:402a:218c:8374:598c:5968) (Ping timeout: 272 seconds)
2020-09-17 22:29:29 +0200knupfer(~Thunderbi@mue-88-130-61-060.dsl.tropolys.de) (Quit: knupfer)
2020-09-17 22:29:30 +0200knupfer1(~Thunderbi@200116b82cb61c005dd142b43233f9e3.dip.versatel-1u1.de)
2020-09-17 22:31:40 +0200lembot(~lembot@191.126.227.174)
2020-09-17 22:31:54 +0200knupfer1knupfer
2020-09-17 22:32:51 +0200juuandyy(~juuandyy@90.166.144.65) (Quit: Konversation terminated!)
2020-09-17 22:33:43 +0200juuandyy(~juuandyy@90.166.144.65)
2020-09-17 22:34:53 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Quit: Free ZNC ~ Powered by LunarBNC: https://LunarBNC.net)
2020-09-17 22:35:28 +0200hackagestratosphere 0.59.1 - EDSL for AWS CloudFormation https://hackage.haskell.org/package/stratosphere-0.59.1 (jdreaver)
2020-09-17 22:36:17 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 22:36:28 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece) (Remote host closed the connection)
2020-09-17 22:36:58 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2020-09-17 22:37:01 +0200bitmagie(~Thunderbi@200116b80679150051a84e8093abf52a.dip.versatel-1u1.de) (Quit: bitmagie)
2020-09-17 22:40:21 +0200Jesin(~Jesin@pool-72-66-101-18.washdc.fios.verizon.net)
2020-09-17 22:41:06 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 22:41:17 +0200tomsmeding(~tomsmedin@2a03:b0c0:0:1010::767:3001) (Quit: ZNC 1.7.5 - https://znc.in)
2020-09-17 22:41:53 +0200tomsmeding(~tomsmedin@2a03:b0c0:0:1010::767:3001)
2020-09-17 22:43:30 +0200eric(~eric@2804:431:c7d4:402a:95f4:860f:d661:3a21)
2020-09-17 22:45:13 +0200knupfer(~Thunderbi@200116b82cb61c005dd142b43233f9e3.dip.versatel-1u1.de) (Quit: knupfer)
2020-09-17 22:45:28 +0200knupfer(~Thunderbi@200116b82cb61c0074d6b96e7872775f.dip.versatel-1u1.de)
2020-09-17 22:47:01 +0200eric_(~eric@2804:431:c7d4:402a:5d9b:3471:cb46:d9c6) (Ping timeout: 272 seconds)
2020-09-17 22:50:41 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 22:50:54 +0200mirrorbird(~psutcliff@2a00:801:44b:8959:8d6c:276b:332b:1c71) (Remote host closed the connection)
2020-09-17 22:51:22 +0200mirrorbird(~psutcliff@2a00:801:44b:8959:8d6c:276b:332b:1c71)
2020-09-17 22:52:45 +0200lembot(~lembot@191.126.227.174) (Ping timeout: 240 seconds)
2020-09-17 22:53:22 +0200iteratee(~kyle@162.211.154.4) (Remote host closed the connection)
2020-09-17 22:53:28 +0200hackageesqueleto 3.3.4.0 - Type-safe EDSL for SQL queries on persistent backends. https://hackage.haskell.org/package/esqueleto-3.3.4.0 (parsonsmatt)
2020-09-17 22:53:54 +0200dhouthoo(~dhouthoo@ptr-eiv6509pb4ifhdr9lsd.18120a2.ip6.access.telenet.be) (Quit: WeeChat 2.8)
2020-09-17 22:54:28 +0200hackageRtMidi 0.4.0.0 - Haskell wrapper for RtMidi, the lightweight, cross-platform MIDI I/O library. https://hackage.haskell.org/package/RtMidi-0.4.0.0 (ejconlon)
2020-09-17 22:55:51 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net)
2020-09-17 22:57:22 +0200xff0x_(~fox@2001:1a81:5306:e200:5d84:8198:9ead:fb9f) (Ping timeout: 244 seconds)
2020-09-17 22:57:56 +0200thc202(~thc202@unaffiliated/thc202) (Ping timeout: 240 seconds)
2020-09-17 22:58:19 +0200xff0x_(~fox@2001:1a81:5306:e200:1455:ac5b:134:42e8)
2020-09-17 22:58:37 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz) (Quit: p-core)
2020-09-17 22:58:58 +0200p-core(~Thunderbi@koleje-wifi-0046.koleje.cuni.cz)
2020-09-17 22:59:04 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311)
2020-09-17 23:00:02 +0200davidfischer(~davidfisc@193.56.252.210) ()
2020-09-17 23:00:56 +0200eric_(~eric@2804:431:c7d4:402a:d77:f3e2:c0b:b49a)
2020-09-17 23:01:14 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-09-17 23:03:36 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311) (Client Quit)
2020-09-17 23:04:07 +0200eric(~eric@2804:431:c7d4:402a:95f4:860f:d661:3a21) (Ping timeout: 272 seconds)
2020-09-17 23:05:09 +0200juuandyy(~juuandyy@90.166.144.65) (Quit: Konversation terminated!)
2020-09-17 23:06:38 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Quit: Free ZNC ~ Powered by LunarBNC: https://LunarBNC.net)
2020-09-17 23:06:39 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Ping timeout: 272 seconds)
2020-09-17 23:06:39 +0200danvet(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa) (Ping timeout: 272 seconds)
2020-09-17 23:07:55 +0200 <dumptruckman> what is happening... getting this: `name' is not a (visible) method of class `NamedEntity'
2020-09-17 23:08:16 +0200 <dumptruckman> class NamedEntity a where name :: a -> String
2020-09-17 23:08:23 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2020-09-17 23:08:28 +0200 <dumptruckman> instance NamedEntity Sharable where name (Sharable s) = s
2020-09-17 23:08:38 +0200 <ski> you only exported the type class, not its method
2020-09-17 23:08:43 +0200 <dumptruckman> ohh
2020-09-17 23:09:03 +0200 <ski> use `module Blah (....,NamedEntity (name)) where
2020-09-17 23:09:06 +0200 <ski> '
2020-09-17 23:09:23 +0200 <dumptruckman> sweet, thanks
2020-09-17 23:09:36 +0200 <exodrifter> (or wherever you imported it `import Blah (NamedEntity (name))`)
2020-09-17 23:09:55 +0200 <ski> (that too, if you have an explicit import list)
2020-09-17 23:10:20 +0200 <exodrifter> right, if you have an implicit import like `import Blah`, should be fine.
2020-09-17 23:10:27 +0200Kaivo(~Kaivo@ec2-15-222-231-32.ca-central-1.compute.amazonaws.com) (Ping timeout: 272 seconds)
2020-09-17 23:12:05 +0200eric_(~eric@2804:431:c7d4:402a:d77:f3e2:c0b:b49a) (Remote host closed the connection)
2020-09-17 23:12:27 +0200heatsink(~heatsink@2600:1700:bef1:5e10:b0dc:6c54:247b:ece)
2020-09-17 23:12:35 +0200hyperisco(~hyperisco@d192-186-117-226.static.comm.cgocable.net) (Ping timeout: 246 seconds)
2020-09-17 23:12:38 +0200Kaivo(~Kaivo@104-200-86-99.mc.derytele.com)
2020-09-17 23:13:09 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2020-09-17 23:13:39 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2020-09-17 23:17:02 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2020-09-17 23:17:05 +0200__monty__(~toonn@unaffiliated/toonn)
2020-09-17 23:17:40 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2020-09-17 23:17:46 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 23:18:33 +0200knupfer(~Thunderbi@200116b82cb61c0074d6b96e7872775f.dip.versatel-1u1.de) (Ping timeout: 244 seconds)
2020-09-17 23:21:55 +0200izaki(~izaki@217.146.82.202)
2020-09-17 23:22:19 +0200izakiGuest55194
2020-09-17 23:22:36 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-09-17 23:24:55 +0200rihards(~rihards@balticom-142-78-50.balticom.lv) (Quit: rihards)
2020-09-17 23:25:20 +0200tomsmeding(~tomsmedin@2a03:b0c0:0:1010::767:3001) (Quit: ZNC 1.7.5 - https://znc.in)
2020-09-17 23:25:46 +0200tomsmeding(~tomsmedin@2a03:b0c0:0:1010::767:3001)
2020-09-17 23:28:09 +0200gestone(~gestone@c-73-97-137-216.hsd1.wa.comcast.net)
2020-09-17 23:29:57 +0200ericsagnes(~ericsagne@2405:6580:0:5100:d0ba:8658:2de8:699c)
2020-09-17 23:34:16 +0200nan`(~nan`@unaffiliated/nan/x-5405850)
2020-09-17 23:38:57 +0200nan`(~nan`@unaffiliated/nan/x-5405850) (Ping timeout: 272 seconds)
2020-09-17 23:43:01 +0200DataComputist(~lumeng@static-50-43-26-251.bvtn.or.frontiernet.net) (Quit: Leaving...)
2020-09-17 23:43:36 +0200sfvm(~sfvm@37.228.215.148)
2020-09-17 23:43:44 +0200Nahra(~Nahra@unaffiliated/nahra)
2020-09-17 23:43:46 +0200kenran(~maier@b2b-37-24-119-190.unitymedia.biz)
2020-09-17 23:43:50 +0200exodrifter(~exodrifte@cpe-173-172-173-93.tx.res.rr.com) (Quit: Leaving.)
2020-09-17 23:43:56 +0200gmt(~gmt@pool-71-105-108-44.nycmny.fios.verizon.net)
2020-09-17 23:45:17 +0200Amras(~Amras@unaffiliated/amras0000) (Ping timeout: 272 seconds)
2020-09-17 23:48:26 +0200tomsmeding(~tomsmedin@2a03:b0c0:0:1010::767:3001) (Quit: ZNC 1.7.5 - https://znc.in)
2020-09-17 23:48:48 +0200tomsmeding(~tomsmedin@tomsmeding.com)
2020-09-17 23:49:12 +0200kenran(~maier@b2b-37-24-119-190.unitymedia.biz) (Ping timeout: 272 seconds)
2020-09-17 23:49:54 +0200petrus(~petrus@unaffiliated/petrus) (Quit: WeeChat 2.9)
2020-09-17 23:51:11 +0200Sgeo_(~Sgeo@ool-18b982ad.dyn.optonline.net)
2020-09-17 23:54:48 +0200falafel(~falafel@2605:e000:1527:d491:f090:20fe:cddf:2a1a)
2020-09-17 23:54:54 +0200stiell(~stian@fsf/member/stiell) (Ping timeout: 272 seconds)
2020-09-17 23:54:54 +0200Sgeo(~Sgeo@ool-18b982ad.dyn.optonline.net) (Ping timeout: 272 seconds)
2020-09-17 23:55:12 +0200puffnfresh(~puffnfres@180-150-38-83.b49626.bne.nbn.aussiebb.net) (Ping timeout: 265 seconds)
2020-09-17 23:56:40 +0200Sgeo__(~Sgeo@ool-18b982ad.dyn.optonline.net)
2020-09-17 23:57:03 +0200LKoen(~LKoen@81.255.219.130) (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”)
2020-09-17 23:59:21 +0200stiell(~stian@fsf/member/stiell)
2020-09-17 23:59:38 +0200eric(~eric@2804:431:c7d4:402a:d77:f3e2:c0b:b49a)