IRCBrowse

2021/09/07

2021-09-07 00:05:05 +0200vysn(~vysn@user/vysn) (Quit: WeeChat 3.2)
2021-09-07 00:07:57 +0200max22-(~maxime@2a01cb0883359800f259119bb9ba011d.ipv6.abo.wanadoo.fr) (Quit: Leaving)
2021-09-07 00:08:51 +0200michalz(~michalz@185.246.204.97) (Remote host closed the connection)
2021-09-07 00:13:15 +0200chomwitt(~chomwitt@2a02:587:dc16:c800:12c3:7bff:fe6d:d374) (Remote host closed the connection)
2021-09-07 00:14:33 +0200lavaman(~lavaman@98.38.249.169)
2021-09-07 00:15:04 +0200Erutuon(~Erutuon@user/erutuon) (Ping timeout: 252 seconds)
2021-09-07 00:16:41 +0200Erutuon(~Erutuon@user/erutuon)
2021-09-07 00:18:52 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 245 seconds)
2021-09-07 00:19:50 +0200Topsi(~Tobias@dyndsl-095-033-095-030.ewe-ip-backbone.de)
2021-09-07 00:21:00 +0200shapr(~user@pool-100-36-247-68.washdc.fios.verizon.net)
2021-09-07 00:24:53 +0200APic(apic@apic.name) (Read error: Connection reset by peer)
2021-09-07 00:29:40 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 240 seconds)
2021-09-07 00:30:34 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-09-07 00:31:06 +0200benin0369323(~benin@183.82.207.253) (Quit: Ping timeout (120 seconds))
2021-09-07 00:33:04 +0200benin0369323(~benin@183.82.207.253)
2021-09-07 00:36:04 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-07 00:37:14 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2021-09-07 00:38:22 +0200cjb(~cjb@user/cjb)
2021-09-07 00:38:43 +0200benin0369323(~benin@183.82.207.253) (Ping timeout: 252 seconds)
2021-09-07 00:39:54 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2021-09-07 00:41:52 +0200urdh(~urdh@user/urdh) (Ping timeout: 250 seconds)
2021-09-07 00:42:06 +0200APic(apic@apic.name)
2021-09-07 00:44:21 +0200Vajb(~Vajb@hag-jnsbng11-58c3ab-85.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-09-07 00:45:20 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-07 00:45:28 +0200Vajb(~Vajb@hag-jnsbng11-58c3ab-85.dhcp.inet.fi)
2021-09-07 00:48:54 +0200dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be) (Quit: WeeChat 3.2)
2021-09-07 00:49:24 +0200wroathe(~wroathe@user/wroathe) (Read error: Connection reset by peer)
2021-09-07 00:50:49 +0200jonatan(~nate@h85-8-60-194.cust.a3fiber.se) (Ping timeout: 252 seconds)
2021-09-07 00:51:08 +0200jonatan(~nate@h85-8-60-194.cust.a3fiber.se)
2021-09-07 00:54:52 +0200jtomas(~jtomas@95.red-88-11-64.dynamicip.rima-tde.net) (Ping timeout: 250 seconds)
2021-09-07 00:55:32 +0200wroathe(~wroathe@96-88-30-181-static.hfc.comcastbusiness.net)
2021-09-07 00:55:32 +0200wroathe(~wroathe@96-88-30-181-static.hfc.comcastbusiness.net) (Changing host)
2021-09-07 00:55:32 +0200wroathe(~wroathe@user/wroathe)
2021-09-07 00:55:48 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 00:56:11 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 00:56:14 +0200machinedgod(~machinedg@24.105.81.50) (Ping timeout: 256 seconds)
2021-09-07 00:56:40 +0200urdh(~urdh@user/urdh)
2021-09-07 00:59:12 +0200amahl(~amahl@dsl-jklbng12-54fbca-64.dhcp.inet.fi) (Ping timeout: 250 seconds)
2021-09-07 01:05:12 +0200lavaman(~lavaman@98.38.249.169)
2021-09-07 01:06:26 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 256 seconds)
2021-09-07 01:13:55 +0200zaquest(~notzaques@5.128.210.178) (Quit: Leaving)
2021-09-07 01:14:37 +0200nicbk(~nicbk@user/nicbk) (Remote host closed the connection)
2021-09-07 01:17:12 +0200ArctVaulMarsHMPJ(~pjetcetal@2.95.102.85)
2021-09-07 01:19:07 +0200machinedgod(~machinedg@24.105.81.50)
2021-09-07 01:19:10 +0200zaquest(~notzaques@5.128.210.178)
2021-09-07 01:21:08 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-07 01:21:08 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-07 01:21:08 +0200wroathe(~wroathe@user/wroathe)
2021-09-07 01:21:22 +0200pmk(~user@2a02:587:941a:35d9:8f9c:6cb6:67dc:f5e3) (Ping timeout: 245 seconds)
2021-09-07 01:22:01 +0200notzmv(~zmv@user/notzmv) (Read error: Connection reset by peer)
2021-09-07 01:23:40 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 240 seconds)
2021-09-07 01:23:57 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 01:29:53 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 01:30:03 +0200notzmv(~zmv@user/notzmv)
2021-09-07 01:31:15 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 01:31:28 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 01:32:37 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 252 seconds)
2021-09-07 01:32:51 +0200Tuplanolla(~Tuplanoll@91-159-69-50.elisa-laajakaista.fi) (Quit: Leaving.)
2021-09-07 01:32:55 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 01:37:33 +0200vicfred(~vicfred@user/vicfred)
2021-09-07 01:38:44 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 256 seconds)
2021-09-07 01:39:02 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 01:43:37 +0200favonia(~favonia@user/favonia) (Ping timeout: 252 seconds)
2021-09-07 01:48:27 +0200Gurkenglas(~Gurkengla@dslb-090-186-104-237.090.186.pools.vodafone-ip.de) (Ping timeout: 245 seconds)
2021-09-07 01:50:54 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14) (Remote host closed the connection)
2021-09-07 01:54:09 +0200sayola(~vekto@dslb-088-064-186-138.088.064.pools.vodafone-ip.de) (Ping timeout: 248 seconds)
2021-09-07 01:55:51 +0200sayola(~vekto@dslb-088-064-186-138.088.064.pools.vodafone-ip.de)
2021-09-07 01:59:54 +0200alx741(~alx741@181.196.69.81)
2021-09-07 02:01:51 +0200nicbk(~nicbk@user/nicbk)
2021-09-07 02:04:14 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-09-07 02:04:21 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14)
2021-09-07 02:04:55 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14) (Remote host closed the connection)
2021-09-07 02:05:04 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14)
2021-09-07 02:06:40 +0200xsperry(~as@user/xsperry) (Ping timeout: 240 seconds)
2021-09-07 02:06:57 +0200[_](~itchyjunk@user/itchyjunk/x-7353470)
2021-09-07 02:09:28 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 252 seconds)
2021-09-07 02:11:12 +0200srk_(~sorki@user/srk)
2021-09-07 02:11:36 +0200srk(~sorki@user/srk) (Ping timeout: 256 seconds)
2021-09-07 02:13:04 +0200jpds1(~jpds@gateway/tor-sasl/jpds)
2021-09-07 02:14:07 +0200srk_srk
2021-09-07 02:14:58 +0200aarvar(~aaron@2601:602:a080:fa0:c490:e73a:21d7:a4e7) (Ping timeout: 252 seconds)
2021-09-07 02:16:37 +0200jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2021-09-07 02:25:32 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 245 seconds)
2021-09-07 02:25:50 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 02:25:58 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Ping timeout: 252 seconds)
2021-09-07 02:26:56 +0200lbseale(~lbseale@user/ep1ctetus) (Read error: Connection reset by peer)
2021-09-07 02:28:02 +0200srk(~sorki@user/srk) (Ping timeout: 256 seconds)
2021-09-07 02:28:05 +0200srk_(~sorki@user/srk)
2021-09-07 02:31:02 +0200srk_srk
2021-09-07 02:31:30 +0200alx741(~alx741@181.196.69.81) (Ping timeout: 250 seconds)
2021-09-07 02:32:01 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 252 seconds)
2021-09-07 02:34:17 +0200acarrico1(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2021-09-07 02:35:53 +0200mikoto-chan(~mikoto-ch@83.137.2.251) (Read error: Connection reset by peer)
2021-09-07 02:41:35 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 02:41:49 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 02:44:00 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-07 02:44:42 +0200alx741(~alx741@181.196.68.218)
2021-09-07 02:51:59 +0200Guest69(~Guest69@172.104.64.123)
2021-09-07 02:52:40 +0200Guest69(~Guest69@172.104.64.123) (Client Quit)
2021-09-07 02:58:55 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.2.1)
2021-09-07 03:01:56 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 03:02:10 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 03:04:44 +0200vicfred(~vicfred@user/vicfred) (Quit: Leaving)
2021-09-07 03:05:41 +0200euandreh(~euandreh@2804:14c:33:9fe5:2c9d:2885:3ab4:eb30) (Quit: WeeChat 3.2)
2021-09-07 03:05:57 +0200euandreh(~euandreh@2804:14c:33:9fe5:1caf:1d6c:286e:abe2)
2021-09-07 03:09:00 +0200 <ldlework> dsal: what's the book fwiw?
2021-09-07 03:09:49 +0200 <dsal> ldlework: https://leanpub.com/optics-by-example
2021-09-07 03:11:21 +0200 <dsal> It's not a beginning book on Haskell. i.e., helpful if you've comfortable with functors and traversals and stuff.
2021-09-07 03:11:47 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2021-09-07 03:12:19 +0200neurocyte0(~neurocyte@212.232.84.187)
2021-09-07 03:12:19 +0200[_][itchyjunk]
2021-09-07 03:12:19 +0200neurocyte0(~neurocyte@212.232.84.187) (Changing host)
2021-09-07 03:12:19 +0200neurocyte0(~neurocyte@user/neurocyte)
2021-09-07 03:12:55 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2021-09-07 03:13:49 +0200 <mniip> 9.2's RecordDotSyntax should hopefully alleviate some of the more basic issues that lens tries to solve
2021-09-07 03:14:22 +0200neurocyte(~neurocyte@user/neurocyte) (Ping timeout: 252 seconds)
2021-09-07 03:14:22 +0200neurocyte0neurocyte
2021-09-07 03:15:39 +0200 <ldlework> Why is this saying the patterns are non-exhaustive?
2021-09-07 03:15:41 +0200 <ldlework> http://logos.ldlework.com/caps/2021-09-07-01-15-24.png
2021-09-07 03:17:01 +0200 <ldlework> arnt they?
2021-09-07 03:17:18 +0200 <janus> ldlework: because it can't know that arbitrary boolean expressions like that can rule each other out, i think
2021-09-07 03:17:21 +0200 <Cale> ldlework: because it's not clear that b == a, b < a and b > a cover all the possible cases
2021-09-07 03:17:21 +0200 <mniip> it doesn't recognize the guards involving </==/> as exhaustive
2021-09-07 03:17:37 +0200 <Cale> If you used b == a, b < a and otherwise, it should work
2021-09-07 03:17:37 +0200 <mniip> (technically the instance implementing these could be unlawful)
2021-09-07 03:17:37 +0200 <ldlework> heh, thanks for the responses
2021-09-07 03:17:38 +0200 <janus> ldlework: you can rewrite it using case a `compare` b of LT => ... | EQ => ...
2021-09-07 03:17:46 +0200 <mniip> `compare` is the way to go forward with this
2021-09-07 03:17:54 +0200 <ldlework> huh i think i understand
2021-09-07 03:18:07 +0200 <Cale> Or you could use case compare b a of LT -> ...; GT -> ...; EQ -> ...
2021-09-07 03:18:29 +0200 <mniip> you could even use `| LT <- compare a b ... | EQ <- compare a b`
2021-09-07 03:18:36 +0200 <ldlework> that worked
2021-09-07 03:18:36 +0200 <mniip> these would be picked up as exhaustive iirc
2021-09-07 03:18:45 +0200hiruji(~hiruji@user/hiruji) (Quit: ZNC 1.8.2 - https://znc.in)
2021-09-07 03:19:05 +0200hiruji(~hiruji@user/hiruji)
2021-09-07 03:19:16 +0200 <ldlework> Haskell From First Principles needs a new edition :)
2021-09-07 03:19:21 +0200 <Cale> That reads so inefficiently that it's painful, even though I know it's one of the few things GHC will actually do CSE on :)
2021-09-07 03:19:24 +0200 <mniip> debatable
2021-09-07 03:19:33 +0200 <ldlework> heh
2021-09-07 03:20:12 +0200 <mniip> oh maybe it doesn't pick them up as exhaustive
2021-09-07 03:20:57 +0200 <Cale> It really should
2021-09-07 03:21:07 +0200 <ldlework> http://logos.ldlework.com/caps/2021-09-07-01-21-06.png
2021-09-07 03:21:09 +0200 <ldlework> this version worked
2021-09-07 03:21:09 +0200 <mniip> it does if you're matching on a variable
2021-09-07 03:21:18 +0200 <ldlework> but not the guards
2021-09-07 03:21:26 +0200 <Cale> yeah
2021-09-07 03:21:47 +0200 <Cale> mniip: I would have expected them to actually have the same intermediate representation, so that's funny
2021-09-07 03:21:55 +0200 <mniip> `f x y | LT <- k = undefined | EQ <- k = undefined | GT <- k = undefined where k = compare x y`
2021-09-07 03:21:57 +0200 <mniip> this doesn't warn
2021-09-07 03:22:08 +0200 <Cale> There's that thing that converts everything into match trees
2021-09-07 03:22:13 +0200 <mniip> yes
2021-09-07 03:22:13 +0200 <ldlework> I know Copilot is basically universally hated, but it has helped so much guessing at/remembering syntax while learning Haskell
2021-09-07 03:22:18 +0200 <mniip> I expected that to kick in too
2021-09-07 03:22:27 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de)
2021-09-07 03:22:27 +0200 <iqubic> What is Copilot?
2021-09-07 03:22:43 +0200 <ldlework> gpt3 for intellisense basically
2021-09-07 03:22:44 +0200pavonia(~user@user/siracusa)
2021-09-07 03:25:30 +0200 <janus> > compare (0 / 0) (0 / 0)
2021-09-07 03:25:32 +0200 <lambdabot> GT
2021-09-07 03:25:33 +0200 <janus> 👍
2021-09-07 03:26:00 +0200 <mniip> > S.fromList [0/0, 0/0]
2021-09-07 03:26:01 +0200 <lambdabot> fromList [NaN,NaN]
2021-09-07 03:26:30 +0200 <justsomeguy> One thing I like about Haskell is that it doesn't have a lot of syntax. I do forget function names pretty frequently, though.
2021-09-07 03:26:42 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de) (Ping timeout: 245 seconds)
2021-09-07 03:27:10 +0200xff0x(~xff0x@2001:1a81:5209:3600:6986:c057:5fff:c53b) (Ping timeout: 240 seconds)
2021-09-07 03:27:22 +0200zgrep(~zgrep@user/zgrep) (I'm in too many channels.)
2021-09-07 03:27:39 +0200justsomeguyalso hasn't gotten into any language extensions, yet
2021-09-07 03:28:03 +0200 <mniip> even the extensions generally try to be conservative in terms of adding new syntax
2021-09-07 03:28:13 +0200favonia(~favonia@user/favonia)
2021-09-07 03:29:00 +0200xff0x(~xff0x@2001:1a81:5244:5800:ade4:7c8b:9b3b:6271)
2021-09-07 03:30:05 +0200h_(rootvegeta@fsf/member/hays) (Quit: h_)
2021-09-07 03:31:38 +0200hays(rootvegeta@st5ve.com)
2021-09-07 03:32:38 +0200 <janus> justsomeguy: what is your source for haskell not having a lot of syntax?
2021-09-07 03:33:22 +0200 <ldlework> Is Haste any good
2021-09-07 03:33:35 +0200 <janus> ldlework: abandoned, i think. not good
2021-09-07 03:33:37 +0200 <dsal> Does Haskell have a lot of syntax?
2021-09-07 03:33:39 +0200 <ldlework> rip
2021-09-07 03:34:17 +0200 <ldlework> When it comes to MLs it's less about syntax and more about opaque operators :P
2021-09-07 03:34:22 +0200 <iqubic> Is there a way to make a point-free version of "\n -> n > 10"?
2021-09-07 03:34:30 +0200 <janus> dsal: well there are so many ways to write the same thing , doesn't strike me as super minimal. just because people don't write braces doesn't mean it is minimal
2021-09-07 03:34:43 +0200 <iqubic> Is that my thing just "flip (> 10)"?
2021-09-07 03:34:43 +0200 <geekosaur> :t (>10)
2021-09-07 03:34:45 +0200 <lambdabot> (Ord a, Num a) => a -> Bool
2021-09-07 03:35:14 +0200 <janus> and i think of the differences between let..in and where, that doesn't seem minimal. GADTs syntax enabling a superset of regular data type definition
2021-09-07 03:35:25 +0200 <geekosaur> unless you wrote the wrong thing in which case it's (10 >)
2021-09-07 03:35:27 +0200 <dsal> @\pl \n -> n > 10
2021-09-07 03:35:27 +0200 <lambdabot> (> 10)
2021-09-07 03:35:44 +0200 <iqubic> Ah. Right.
2021-09-07 03:35:56 +0200 <janus> many convenience like view patterns and pattern guards, enabling things that you would just need an extra case for if you were to do it without. not minimal
2021-09-07 03:36:03 +0200 <justsomeguy> janus: Source? It's my personal opinion as a new Haskell user.
2021-09-07 03:36:05 +0200 <janus> so that's why i ask for the source, i want to see which metric we are comparing here
2021-09-07 03:36:18 +0200 <iqubic> What I actually want is the point-free version of "\m n -> n > m"
2021-09-07 03:36:30 +0200geekosaurwonders if we're discussingf surface haskell or core
2021-09-07 03:36:44 +0200 <iqubic> @pl \m n -> n > m
2021-09-07 03:36:45 +0200 <lambdabot> flip (>)
2021-09-07 03:36:48 +0200 <iqubic> I see.
2021-09-07 03:37:05 +0200 <dsal> I guess there are extensions... ViewPatterns is only kind of new syntax. Pattern guards are similarly reused in a lot of places, but I don't feel like there's all that much syntax most days.
2021-09-07 03:37:10 +0200 <ldlework> For example, I just looked up a Haskell article on the Reingold-Tilford algorithm of drawing binary trees and the very first snippet in the article uses; >> <|> <$> <*
2021-09-07 03:37:14 +0200 <ldlework> I probably need to slow my roll
2021-09-07 03:37:23 +0200 <justsomeguy> janus: I think in comparison to something like rust or C++ the syntax is pretty minimal. You don't have too many keywords, there are fewer baked-in control flow constructs, etc.
2021-09-07 03:37:33 +0200 <dsal> ldlework: Those are pretty common, but they're still library defined.
2021-09-07 03:37:38 +0200 <geekosaur> I mean, a lot of surface haskell including many of the extensions get converted to the more austere core equivalents
2021-09-07 03:37:51 +0200 <dsal> ldlework: they're just functions, though.
2021-09-07 03:38:05 +0200 <ldlework> dsal: I was just defending the original point that as a newbie the baggage I brought with me isn't doing much good
2021-09-07 03:38:11 +0200 <ldlework> dsal: sure, I clarified above
2021-09-07 03:38:22 +0200 <ldlework> "it's less syntax and more opaque operators, re: MLs"
2021-09-07 03:38:48 +0200 <dsal> Yeah, going slow gets you there faster. Those operators in particular are common enough that you'll rarely write anything without using them. :)
2021-09-07 03:39:08 +0200 <dsal> At least parsers. I don't use <* or even <|> quite as much as >> or <$>
2021-09-07 03:39:18 +0200 <dsal> I can't get very far into a file without <$>
2021-09-07 03:39:26 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 256 seconds)
2021-09-07 03:39:46 +0200 <ldlework> A number of years ago I ported the SML examples from Reppy's Concurrency in ML to F# using Hopac so I have a little experience with very powerful operators
2021-09-07 03:39:55 +0200Topsi(~Tobias@dyndsl-095-033-095-030.ewe-ip-backbone.de) (Read error: Connection reset by peer)
2021-09-07 03:40:01 +0200 <justsomeguy> Whether the syntax seems minimal is a subjective thing, really. (...wait, is there an objective measure?) I bet a scheme or smalltalk programmer would have a pretty different reaction than I did. But I came from the land of curly braces.
2021-09-07 03:40:08 +0200 <ldlework> They're matrix code until you learn them though
2021-09-07 03:41:00 +0200 <dsal> Yeah, coming from, e.g., go, you'll find less syntax and fewer operators and reserved words as part of the language itself.
2021-09-07 03:41:17 +0200 <janus> justsomeguy: if haskell was minimal, tree-sitter would have an easier time supporting all the extensions , right ? ;) https://github.com/tree-sitter/tree-sitter-haskell#supported-language-extensions
2021-09-07 03:41:55 +0200 <janus> there is a rust grammar too, maybe there is some sensible way to compare the two: https://github.com/tree-sitter/tree-sitter-rust
2021-09-07 03:42:09 +0200 <iqubic> Yeah. I havn't used "<*", or "<$" outside of writing parsers.
2021-09-07 03:44:19 +0200 <janus> weird how they don't support RecordWildCards, i would think it would be easy. and it is pretty popular
2021-09-07 03:45:06 +0200 <janus> i guess i don't really know what "parsing" means to tree-sitter. what would they need to do to support OverloadedStrings?
2021-09-07 03:45:13 +0200 <janus> aaah
2021-09-07 03:45:18 +0200 <janus> the minus means not applicable!
2021-09-07 03:45:59 +0200 <janus> but RecordWildCards is surely applicable to parsing? hmm
2021-09-07 03:46:47 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-07 03:50:30 +0200thmprover(~user@047-042-215-236.res.spectrum.com) (Quit: Goodnight, ladies, good night, sweet ladies, good night, good night)
2021-09-07 03:50:48 +0200 <janus> justsomeguy: regarding the control structures, there are not so many, so they are quickly outnumbered by haskell-only counterparts such as "data family" "data instance" "type family" "type instance" "newtype" "mdo"
2021-09-07 03:51:04 +0200alx741(~alx741@181.196.68.218) (Quit: alx741)
2021-09-07 03:51:13 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 252 seconds)
2021-09-07 03:52:56 +0200 <iqubic> What is tree-sitter?
2021-09-07 03:55:16 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-07 03:57:16 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 03:57:33 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 04:00:30 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 04:01:38 +0200 <janus> iqubic: incremental parsing system
2021-09-07 04:03:52 +0200 <sm> continuing the great haskell tradition of baffling naming...
2021-09-07 04:05:31 +0200finn_elija(~finn_elij@user/finn-elija/x-0085643)
2021-09-07 04:05:31 +0200FinnElijaGuest9426
2021-09-07 04:05:31 +0200finn_elijaFinnElija
2021-09-07 04:05:54 +0200 <ldlework> Why is this saying the patterns are incomplete?
2021-09-07 04:05:56 +0200 <ldlework> http://logos.ldlework.com/caps/2021-09-07-02-05-44.png
2021-09-07 04:07:14 +0200 <geekosaur> because [a] matches a 1-character string
2021-09-07 04:07:25 +0200 <geekosaur> leaving longer strings unmatched
2021-09-07 04:08:02 +0200 <geekosaur> if all you're using is 1-character strings, it doesn't know that
2021-09-07 04:08:12 +0200 <ldlework> I see
2021-09-07 04:08:27 +0200Guest9426(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 245 seconds)
2021-09-07 04:08:27 +0200 <janus> is it a confusion because of the type-level/term-level punning?
2021-09-07 04:09:52 +0200 <geekosaur> no, just that the pattern match checker doesn't check what's going on elsewhere so has no idea that there will only be 1-character strings inb use
2021-09-07 04:10:19 +0200 <geekosaur> possibly in that case you just want to use Char instead of String
2021-09-07 04:16:16 +0200 <mniip> iqubic, I have used <* in other contexts
2021-09-07 04:16:26 +0200 <iqubic> What context?
2021-09-07 04:16:29 +0200 <ldlework> geekosaur: that's what I did, thanks for your help
2021-09-07 04:16:41 +0200 <janus> geekosaur: right , i understand why the pattern is incomplete. but let's say the haskell had no punning. then you'd have no '[a]' on line 28. then, what could have inspired ldlework to put '[a]' on line 38?
2021-09-07 04:16:44 +0200 <mniip> if you have an applicative/alternative encoding a coyoneda extension of a boolean formula, of some sort
2021-09-07 04:17:40 +0200td_(~td@muedsl-82-207-238-207.citykom.de) (Ping timeout: 240 seconds)
2021-09-07 04:17:46 +0200 <justsomeguy> janus: Seems like I still have a ton to learn. I've only used vanilla Haskell, without any language extensions so far. (Other than -XOverloadedStrings.)
2021-09-07 04:18:01 +0200 <mniip> data Formula a where { And :: Formula (a -> b) -> Formula a -> Formula b; Or :: Formula a -> Formula a -> Formula a; ... }
2021-09-07 04:18:04 +0200 <geekosaur> oh boy, next thing you know it's coyoneda
2021-09-07 04:18:04 +0200 <mniip> this sorta thing
2021-09-07 04:18:43 +0200 <janus> justsomeguy: the comittee has decided on a list of the most worthy extensions. you can use the list to guide your learning: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0380-ghc2021.rst
2021-09-07 04:19:29 +0200tcard(~tcard@p2307053-ipngn17101hodogaya.kanagawa.ocn.ne.jp) (Quit: Leaving)
2021-09-07 04:19:51 +0200td_(~td@94.134.91.74)
2021-09-07 04:20:01 +0200 <mniip> "most worthy" I disagree
2021-09-07 04:20:13 +0200 <Cale> iqubic: mniip: <$ is also good for quasi-frp stuff like newtype EventHandler a = EventHandler { step :: Event -> (Maybe a, EventHandler a) }
2021-09-07 04:20:40 +0200 <Cale> button $> valueToUseWhenButtonIsClicked
2021-09-07 04:21:00 +0200 <Cale> (also for actual FRP Events)
2021-09-07 04:23:49 +0200tcard(~tcard@p2307053-ipngn17101hodogaya.kanagawa.ocn.ne.jp)
2021-09-07 04:23:51 +0200 <janus> mniip: why would a comittee member vote yes on an extension that they do not consider worthy? what do you consider a reason to vote yes, if it is not worth?
2021-09-07 04:24:46 +0200 <janus> worth is about value judgment, if there was no need for value judgment, there would be no voting
2021-09-07 04:24:46 +0200machinedgod(~machinedg@24.105.81.50) (Ping timeout: 252 seconds)
2021-09-07 04:25:20 +0200 <Cale> That's worthy to be part of the extension set labelled GHC2021, which is intended to be a conservative set of extensions useful as a default
2021-09-07 04:25:30 +0200 <mniip> ^
2021-09-07 04:26:27 +0200 <mniip> TemplateHaskell is not worthy of being a "default" extension, but definitely worthy of being learned if you want to do haskell seriously
2021-09-07 04:27:30 +0200 <Cale> otoh, we're also accumulating extensions lately that I wish didn't exist
2021-09-07 04:27:49 +0200 <Cale> Like RecordDotSyntax and... well basically all the record-related stuff
2021-09-07 04:27:55 +0200 <Cale> and LinearHaskell
2021-09-07 04:27:58 +0200polykernel(~polykerne@user/polykernel) ()
2021-09-07 04:28:14 +0200john2312(~user@114.250.137.142)
2021-09-07 04:28:16 +0200 <mniip> linearhaskell has 0 votes
2021-09-07 04:28:26 +0200 <Cale> Well, of course :)
2021-09-07 04:28:27 +0200 <mniip> unless you mean you don't want linear types to exist at all
2021-09-07 04:28:36 +0200 <c_wraith> Hey, NoFieldSelectors is a perfectly fine extension!
2021-09-07 04:28:53 +0200 <Cale> c_wraith: That one is... okay I guess
2021-09-07 04:29:10 +0200 <Cale> mniip: I mean I'd rather this stuff not exist at all
2021-09-07 04:29:18 +0200 <mniip> how so
2021-09-07 04:29:35 +0200 <Cale> It complicates the language and its implementation for dubious benefit
2021-09-07 04:30:32 +0200pzanco(~Android@2804:14c:3ba1:42d:c022:dfe5:eb2e:987)
2021-09-07 04:30:32 +0200 <Cale> I really don't believe in linear types at all, haven't seen anything remotely close to convincing come out of them, though possibly different substructural restrictions could be useful.
2021-09-07 04:31:31 +0200 <janus> justsomeguy: btw if you wanna live the dangerous life, i can teach you about some dubious avant-garde extensions with only seven votes
2021-09-07 04:32:02 +0200 <Cale> RecordDotSyntax is an ugly mess, and I don't like overloading "." any further than it already is. During the process, there were 8 or 9 different proposals for how to disambiguate RecordDotSyntax-using expressions and a solution was chosen by Condorcet voting.
2021-09-07 04:32:04 +0200 <janus> justsomeguy: you already know about one of them: OverloadingStrings. so you can probably take it
2021-09-07 04:32:32 +0200 <mniip> I feel like there's some sort of deep connection (adjunction?) between linear types and reference borrowing, which I feel like is an important direction in research
2021-09-07 04:32:42 +0200 <mniip> because that gets us safe yet manual memory management
2021-09-07 04:33:15 +0200dajoer(~david@user/gvx)
2021-09-07 04:34:17 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-09-07 04:34:25 +0200dsrt^(~dsrt@68.101.54.227)
2021-09-07 04:34:39 +0200 <Cale> mniip: I think if you could get to something along the lines of Conal's constrained categories stuff, that would be worth doing. I think you're much more likely in general to want something that's affine or some other substructural constraint, rather than perfectly linear, and on top of that, you're probably not going to want a proper subset of Haskell functions exactly. It's important to have the possibility for
2021-09-07 04:34:39 +0200 <Cale> effects.
2021-09-07 04:35:31 +0200 <mniip> right, so you want to intersperse your effect with the memory management and also keep it safe
2021-09-07 04:35:34 +0200 <Cale> The only application of Linear Haskell I've seen that looked remotely practical to me so far was a thing that also used unsafePerformIO.
2021-09-07 04:35:38 +0200 <mniip> which is not always possible
2021-09-07 04:35:40 +0200 <ldlework> cool I wrote a foldTree
2021-09-07 04:35:43 +0200 <ldlework> look at me doing fp
2021-09-07 04:36:03 +0200 <Cale> (and it's not clear that another arrow-ish combinator library wouldn't have done just as well)
2021-09-07 04:36:27 +0200 <mniip> hmmmm
2021-09-07 04:36:29 +0200 <janus> in effects and memory management related news, Daan Leijen and Ningning Xie's talk on Koka is now available: https://www.youtube.com/watch?v=6OFhD_mHtKA "functional but in-place" !
2021-09-07 04:36:40 +0200 <mniip> something inherently cartesian monoidal about monads?
2021-09-07 04:36:50 +0200pzanco(~Android@2804:14c:3ba1:42d:c022:dfe5:eb2e:987) (Quit: -a- IRC for Android 2.1.59)
2021-09-07 04:36:59 +0200 <mniip> while arrows can indeed capture linear arrows
2021-09-07 04:37:28 +0200 <Cale> Maybe it's that every Haskell monad is a strong monad?
2021-09-07 04:37:36 +0200 <Cale> I'm not sure :)
2021-09-07 04:37:49 +0200 <mniip> but also Control.Arrow is a very weird arrow
2021-09-07 04:37:55 +0200 <Cale> Yeah
2021-09-07 04:38:03 +0200 <Cale> I'd like to fix Control.Arrow as well
2021-09-07 04:38:19 +0200 <Cale> and bring it more in line with the definition of a symmetric monoidal category, and break it up into subclasses a little
2021-09-07 04:38:29 +0200 <Cale> (and then fix the proc/do syntax to work with it)
2021-09-07 04:38:46 +0200 <mniip> and the internal language of a symmetric monoidal category is?
2021-09-07 04:38:47 +0200 <mniip> :P
2021-09-07 04:38:48 +0200 <Cale> I haven't found the time to actually do that, since it's been ages since I actually worked with anything arrow-like
2021-09-07 04:38:59 +0200 <mniip> hm
2021-09-07 04:39:02 +0200 <mniip> symmetric monoidal closed
2021-09-07 04:39:12 +0200pzanco(~Android@2804:14c:3ba1:42d:c022:dfe5:eb2e:987)
2021-09-07 04:39:19 +0200pzanco(~Android@2804:14c:3ba1:42d:c022:dfe5:eb2e:987) (Client Quit)
2021-09-07 04:39:28 +0200 <Cale> Well, I just mean relying less on 'arr' and adding in explicit isomorphisms like rAssoc :: a ((u,v),w) (u,(v,w)) etc.
2021-09-07 04:39:55 +0200 <mniip> yeah my main gripe is with arr
2021-09-07 04:40:18 +0200pzanco(~Android@2804:14c:3ba1:42d:c022:dfe5:eb2e:987)
2021-09-07 04:40:19 +0200 <mniip> if you're talking about monoidal cats, (,) has to go too
2021-09-07 04:40:29 +0200 <Cale> The main advantage that Arrow has over Monad is that it explicitly represents binding, so you can potentially do more analysis on your computation before running it.
2021-09-07 04:40:39 +0200 <mniip> and you very quickly go into MPTC/tyfams lad
2021-09-07 04:40:40 +0200gnyeki(~gnyeki@li578-216.members.linode.com)
2021-09-07 04:40:56 +0200 <Cale> Whereas the right argument to >>= is always a black box lambda, both arguments to >>> are things you potentially have control over
2021-09-07 04:41:27 +0200 <Cale> But then when all your basic structural operations are via arr, you're inserting black boxes everywhere and there's no hope of being any smarter
2021-09-07 04:41:47 +0200pzanco(~Android@2804:14c:3ba1:42d:c022:dfe5:eb2e:987) (Client Quit)
2021-09-07 04:42:23 +0200 <Cale> Well, yeah, you can generalise over pairs as well while you're at it, though that actually worries me less in a practical sense than the missing structure
2021-09-07 04:42:31 +0200pzanco(~Android@2804:14c:3ba1:42d:c022:dfe5:eb2e:987)
2021-09-07 04:42:50 +0200 <mniip> land*
2021-09-07 04:46:02 +0200cjb(~cjb@user/cjb) (Quit: rcirc on GNU Emacs 28.0.50)
2021-09-07 04:49:23 +0200awpr(uid446117@id-446117.lymington.irccloud.com)
2021-09-07 04:53:37 +0200pzanco(~Android@2804:14c:3ba1:42d:c022:dfe5:eb2e:987) (Quit: -a- IRC for Android 2.1.59)
2021-09-07 04:54:13 +0200nicbk(~nicbk@user/nicbk) (Quit: nicbk)
2021-09-07 04:54:34 +0200pzanco(~Android@2804:14c:3ba1:42d:c022:dfe5:eb2e:987)
2021-09-07 04:55:26 +0200hexfive(~eric@50.35.83.177)
2021-09-07 04:55:38 +0200 <dsal> justsomeguy: If you like OverloadedStrings, you'll *love* OverloadedLists
2021-09-07 04:56:37 +0200 <xerox> i
2021-09-07 04:56:41 +0200 <dsal> I thought OverloadedLists would be pretty great and tried using it in real code and things stopped compiling with fantastic e3rrors.
2021-09-07 04:57:09 +0200hexfive(~eric@50.35.83.177) (Client Quit)
2021-09-07 04:58:09 +0200 <Cale> OverloadedStrings is important though, since you really want to be using Data.Text a lot of the time
2021-09-07 04:59:39 +0200fvr(uid503686@id-503686.highgate.irccloud.com)
2021-09-07 05:02:14 +0200jespada(~jespada@90.254.245.194) (Ping timeout: 252 seconds)
2021-09-07 05:02:56 +0200pzanco(~Android@2804:14c:3ba1:42d:c022:dfe5:eb2e:987) (Quit: -a- IRC for Android 2.1.59)
2021-09-07 05:04:12 +0200 <lechner> Hi, anyone else getting a certificate error with https://haskell-miso.org/ ?
2021-09-07 05:05:01 +0200jespada(~jespada@90.254.245.194)
2021-09-07 05:07:25 +0200 <dsal> It claims to be trying to steal my data.
2021-09-07 05:07:38 +0200zebrag(~chris@user/zebrag) (Quit: Konversation terminated!)
2021-09-07 05:08:05 +0200 <lechner> that message may be from your browser
2021-09-07 05:09:42 +0200 <janus> % system "echo -ne 'HEAD / HTTP/1.0\r\n\r\n' | nc haskell-miso.org 443"
2021-09-07 05:09:42 +0200 <yahb> janus: /bin/sh: 3: nc: not found; ExitFailure 127
2021-09-07 05:09:54 +0200 <geekosaur> chroome tells me date invslifd i.e. cert expired?
2021-09-07 05:10:09 +0200 <ldlework> Everytime vscode recommends a point-free reduction I think "I never would've thought of that"
2021-09-07 05:10:28 +0200 <geekosaur> yeh, expired 59 days ago
2021-09-07 05:11:09 +0200 <Cale> ldlework: You should also question its wisdom in applying it ;)
2021-09-07 05:12:07 +0200 <Cale> Points-free code *can* be nicer, but it's not always easier to read or to edit
2021-09-07 05:12:33 +0200 <janus> % system "curl --insecure haskell-miso.org"
2021-09-07 05:12:33 +0200 <yahb> janus: /bin/sh: 1: curl: not found; ExitFailure 127
2021-09-07 05:15:09 +0200arkho(~ccc@dynamic-acs-24-112-153-241.zoominternet.net) (Remote host closed the connection)
2021-09-07 05:15:26 +0200arkho(~ccc@dynamic-acs-24-112-153-241.zoominternet.net)
2021-09-07 05:17:39 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 05:17:57 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 05:18:08 +0200 <ldlework> Can someone help me understand what's going on here? http://logos.ldlework.com/caps/2021-09-07-03-17-56.png
2021-09-07 05:18:15 +0200 <Cale> The certificate for haskell-miso.org expired on 2021-07-10.
2021-09-07 05:18:17 +0200 <ldlework> I don't understand where "Seq Char" is coming from.
2021-09-07 05:18:55 +0200 <Cale> You're explicitly using Data.Sequence.length
2021-09-07 05:18:56 +0200 <dsal> ldlework: You're asking for a Seq length.
2021-09-07 05:19:39 +0200 <ldlework> When I remove that it complains that it's ambiguous with Prelude.length
2021-09-07 05:19:56 +0200 <Cale> You probably want to be importing Data.Sequence qualified
2021-09-07 05:20:05 +0200 <Cale> but Prelude.length is the one you want
2021-09-07 05:21:19 +0200 <ldlework> Is the problem actually my use of mapWithIndex that is defined in terms of Seq
2021-09-07 05:21:21 +0200 <Cale> Though... Prelude.length isn't especially cheap to compute, so I'd want to make sure it got computed once for the key and reused
2021-09-07 05:21:30 +0200 <ldlework> Makes sense Cale
2021-09-07 05:22:00 +0200 <Cale> Oh, right, you're using mapWithIndex from Data.Sequence as well
2021-09-07 05:22:35 +0200 <Cale> I suppose you could do that, if you don't mind converting the String back and forth. At least the lookups will be cheaper
2021-09-07 05:23:14 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de)
2021-09-07 05:23:57 +0200Axman6(~Axman6@user/axman6) (Ping timeout: 260 seconds)
2021-09-07 05:24:33 +0200 <Cale> Though, you only do lookups in the key, and there's not much reason to be converting the input string to a Seq
2021-09-07 05:24:59 +0200 <Cale> zipWith (\i c -> ...) [0..] input
2021-09-07 05:26:19 +0200 <ldlework> Cale: you're suggesting that over mapWithIndex?
2021-09-07 05:26:23 +0200 <Cale> Yeah
2021-09-07 05:27:06 +0200 <ldlework> that fixed it heh
2021-09-07 05:27:10 +0200 <ldlework> thank you
2021-09-07 05:27:40 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de) (Ping timeout: 240 seconds)
2021-09-07 05:28:24 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Quit: Leaving)
2021-09-07 05:33:00 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 05:33:18 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 05:33:47 +0200cjb(~cjb@user/cjb)
2021-09-07 05:36:45 +0200aarvar(~aaron@2601:602:a080:fa0:1804:9b51:73a6:32bd)
2021-09-07 05:39:12 +0200 <ldlework> Is there an obvious refactor/unification here? https://gist.github.com/dustinlacewell/a4e877326775198bf1e52243080656e9
2021-09-07 05:43:41 +0200Axman6(~Axman6@user/axman6)
2021-09-07 05:45:13 +0200 <Cale> ldlework: Well, the completely mechanical thing to do is to factor out the function you're applying to j in order to get n
2021-09-07 05:46:05 +0200 <Cale> Turn that into a function parameter, and then define encrypt = crypt nForChar and decrypt = crypt (negate . nForChar)
2021-09-07 05:48:11 +0200 <dsal> ldlework: You shouldn't have any conflict with length... If you intend to use the one from Data.Foldable, you can explicitly hide the one from Prelude, otherwise whatever you're conflicting with probably wasn't imported the best way.
2021-09-07 05:48:23 +0200 <ldlework> Cale: nice
2021-09-07 05:50:34 +0200otto_s(~user@p5b0445ba.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2021-09-07 05:51:09 +0200lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-09-07 05:52:27 +0200otto_s(~user@p5de2f2c9.dip0.t-ipconnect.de)
2021-09-07 05:53:20 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 05:53:34 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 05:53:47 +0200 <ldlework> Cale: that's really nicej
2021-09-07 05:54:35 +0200 <Cale> Yep, that's the advantage of using a functional programming language, you can always factor out similar code
2021-09-07 05:54:58 +0200kjak(~kjak@pool-108-45-56-21.washdc.fios.verizon.net) (Ping timeout: 252 seconds)
2021-09-07 06:03:48 +0200 <janus> ldlework: if you import Data.Seq qualified, you won't need to write Prelude.length
2021-09-07 06:08:01 +0200 <mniip> Data.Seq is one of those modules that's "intended" to be imported qualified
2021-09-07 06:09:08 +0200lavaman(~lavaman@98.38.249.169)
2021-09-07 06:12:01 +0200slowButPresent(~slowButPr@user/slowbutpresent) (Quit: leaving)
2021-09-07 06:22:02 +0200myShoggoth(~myShoggot@97-120-70-214.ptld.qwest.net) (Ping timeout: 250 seconds)
2021-09-07 06:22:50 +0200 <ldlework> making this code vigenere cipher work properly in skipping spaces and the like is tricky
2021-09-07 06:23:12 +0200 <ldlework> I miss F#'s for-loops
2021-09-07 06:23:16 +0200ldleworkducks.
2021-09-07 06:26:11 +0200 <mniip> you could use forM in the state monad you know?
2021-09-07 06:26:38 +0200 <ldlework> I haven't made it that far. Don't mind me, I'm harmlessly teasing.
2021-09-07 06:29:00 +0200 <Cale> ldlework: A list is a loop frozen in time. Just as a loop either doesn't occur because its precondition isn't met, or it consists of a single iteration followed by another loop, a list is either empty or consists of a single element followed by another list.
2021-09-07 06:31:08 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 06:32:43 +0200 <dsal> Haskell has all the loops, but also no loops.
2021-09-07 06:32:49 +0200 <ldlework> hehe
2021-09-07 06:35:00 +0200 <Axman6> for-loops are trash tier control flow
2021-09-07 06:36:10 +0200euandreh(~euandreh@2804:14c:33:9fe5:1caf:1d6c:286e:abe2) (Ping timeout: 240 seconds)
2021-09-07 06:36:13 +0200shapr(~user@pool-100-36-247-68.washdc.fios.verizon.net) (Ping timeout: 252 seconds)
2021-09-07 06:36:48 +0200bens(~bens@www.typius.com) (*.net *.split)
2021-09-07 06:36:48 +0200wolfshappen(~waff@irc.furworks.de) (*.net *.split)
2021-09-07 06:36:48 +0200abrar_(~abrar@static-108-2-152-54.phlapa.fios.verizon.net) (*.net *.split)
2021-09-07 06:36:48 +0200shachaf(~shachaf@user/shachaf) (*.net *.split)
2021-09-07 06:36:48 +0200ajb(~ajb@cupid.whatbox.ca) (*.net *.split)
2021-09-07 06:36:56 +0200shachaf(~shachaf@user/shachaf)
2021-09-07 06:37:01 +0200ajb(~ajb@cupid.whatbox.ca)
2021-09-07 06:37:03 +0200bens(~bens@www.typius.com)
2021-09-07 06:37:04 +0200wolfshappen(~waff@irc.furworks.de)
2021-09-07 06:37:13 +0200abrar_(~abrar@static-108-2-152-54.phlapa.fios.verizon.net)
2021-09-07 06:37:19 +0200euandreh(~euandreh@2804:14c:33:9fe5:ffb9:2324:6d72:6629)
2021-09-07 06:41:15 +0200ircbrowse_tom(~ircbrowse@static.162.49.55.162.clients.your-server.de) (ZNC 1.7.5+deb4 - https://znc.in)
2021-09-07 06:41:40 +0200ircbrowse_tom(~ircbrowse@2a01:4f8:1c1c:9319::1)
2021-09-07 06:41:40 +0200Server+Cnt
2021-09-07 06:41:41 +0200jmct_(sid160793@id-160793.tinside.irccloud.com)
2021-09-07 06:41:42 +0200jjhoo(~jahakala@dsl-trebng21-58c18f-56.dhcp.inet.fi)
2021-09-07 06:41:53 +0200Ram-Z(~Ram-Z@li1814-254.members.linode.com)
2021-09-07 06:41:55 +0200mcfrdy(~mcfrdy@user/mcfrdy)
2021-09-07 06:41:58 +0200Flonk(~Flonk@ec2-52-40-29-25.us-west-2.compute.amazonaws.com)
2021-09-07 06:42:00 +0200bbhoss(sid18216@id-18216.tinside.irccloud.com)
2021-09-07 06:42:16 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2021-09-07 06:42:31 +0200terrorjack(~terrorjac@ec2-54-95-39-30.ap-northeast-1.compute.amazonaws.com)
2021-09-07 06:43:07 +0200shanemikel(~shanemike@desk.roadwar.net)
2021-09-07 06:46:38 +0200 <dsal> I use forever sometimes. But it's nice having names for the actual things we're doing and not just try to think about how to use `for` to do all the things.
2021-09-07 06:48:40 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 06:48:59 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 06:49:01 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Client Quit)
2021-09-07 06:49:20 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 06:51:27 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2021-09-07 06:57:14 +0200SanchayanMaity(sid478177@stonehaven.irccloud.com) (*.net *.split)
2021-09-07 06:57:14 +0200amir(sid22336@user/amir) (*.net *.split)
2021-09-07 06:57:14 +0200ridcully_(~ridcully@p508ac428.dip0.t-ipconnect.de) (*.net *.split)
2021-09-07 06:57:14 +0200smitop(~smitop@user/smitop) (*.net *.split)
2021-09-07 06:57:14 +0200nitrix(~nitrix@user/nitrix) (*.net *.split)
2021-09-07 06:57:14 +0200wagle(~wagle@quassel.wagle.io) (*.net *.split)
2021-09-07 06:57:14 +0200eL_Bart0-(eL_Bart0@dietunichtguten.org) (*.net *.split)
2021-09-07 06:57:14 +0200ziman(~ziman@user/ziman) (*.net *.split)
2021-09-07 06:57:14 +0200hexology(~hexology@user/hexology) (*.net *.split)
2021-09-07 06:57:14 +0200wrengr(~wrengr@56.72.82.34.bc.googleusercontent.com) (*.net *.split)
2021-09-07 06:57:14 +0200stefan-_(~cri@42dots.de) (*.net *.split)
2021-09-07 06:57:14 +0200sm[i](~user@plaintextaccounting/sm) (*.net *.split)
2021-09-07 06:57:14 +0200lambdabot(~lambdabot@haskell/bot/lambdabot) (*.net *.split)
2021-09-07 06:57:14 +0200lep(~lep@94.31.80.176) (*.net *.split)
2021-09-07 06:57:14 +0200justache(~justache@user/justache) (*.net *.split)
2021-09-07 06:57:14 +0200p3n(~p3n@217.198.124.246) (*.net *.split)
2021-09-07 06:57:14 +0200aravk(~aravk@user/aravk) (*.net *.split)
2021-09-07 06:57:14 +0200dragestil_(~quassel@user/dragestil) (*.net *.split)
2021-09-07 06:57:14 +0200tureba(~tureba@tureba.org) (*.net *.split)
2021-09-07 06:57:14 +0200ldlework(~hexeme@user/hexeme) (*.net *.split)
2021-09-07 06:57:14 +0200_________(~nobody@user/noodly) (*.net *.split)
2021-09-07 06:57:14 +0200marienz(~marienz@libera/staff/marienz) (*.net *.split)
2021-09-07 06:57:14 +0200Rembane_(~Rembane@li346-36.members.linode.com) (*.net *.split)
2021-09-07 06:57:14 +0200mikolaj__(~mikon@duch.mimuw.edu.pl) (*.net *.split)
2021-09-07 06:57:14 +0200nshepperd2(~nshepperd@li364-218.members.linode.com) (*.net *.split)
2021-09-07 06:57:14 +0200raoul(~raoul@95.179.203.88) (*.net *.split)
2021-09-07 06:57:14 +0200haveo(~haveo@sl35.iuwt.fr) (*.net *.split)
2021-09-07 06:57:14 +0200niko(~niko@libera/staff/niko) (*.net *.split)
2021-09-07 06:57:14 +0200dkeohane1(~dkeohane@ec2-18-189-29-140.us-east-2.compute.amazonaws.com) (*.net *.split)
2021-09-07 06:57:14 +0200davl(~davl@207.154.228.18) (*.net *.split)
2021-09-07 06:57:14 +0200dragestil(~znc@user/dragestil) (*.net *.split)
2021-09-07 06:57:14 +0200Aleksejs(~Aleksejs@haskell.lv) (*.net *.split)
2021-09-07 06:57:21 +0200haveo(~haveo@sl35.iuwt.fr)
2021-09-07 06:57:22 +0200mikolaj_(~mikon@duch.mimuw.edu.pl)
2021-09-07 06:57:23 +0200Rembane(~Rembane@li346-36.members.linode.com)
2021-09-07 06:57:23 +0200lambdabot(~lambdabot@silicon.int-e.eu)
2021-09-07 06:57:27 +0200tureba(~tureba@tureba.org)
2021-09-07 06:57:27 +0200eL_Bart0(eL_Bart0@dietunichtguten.org)
2021-09-07 06:57:28 +0200Aleksejs(~Aleksejs@haskell.lv)
2021-09-07 06:57:29 +0200wrengr(~wrengr@56.72.82.34.bc.googleusercontent.com)
2021-09-07 06:57:30 +0200SanchayanMaity(sid478177@id-478177.stonehaven.irccloud.com)
2021-09-07 06:57:32 +0200marienz(~marienz@libera/staff/marienz)
2021-09-07 06:57:33 +0200aravk(~aravk@user/aravk)
2021-09-07 06:57:34 +0200wagle(~wagle@quassel.wagle.io)
2021-09-07 06:57:35 +0200ridcully_(~ridcully@p508ac428.dip0.t-ipconnect.de)
2021-09-07 06:57:37 +0200ziman(~ziman@c25-5.condornet.sk)
2021-09-07 06:57:39 +0200lambdabot(~lambdabot@silicon.int-e.eu) (Changing host)
2021-09-07 06:57:39 +0200lambdabot(~lambdabot@haskell/bot/lambdabot)
2021-09-07 06:57:53 +0200nitrix(~nitrix@ns569831.ip-51-79-81.net)
2021-09-07 06:57:55 +0200nshepperd2(~nshepperd@li364-218.members.linode.com)
2021-09-07 06:57:57 +0200lep(~lep@94.31.80.176)
2021-09-07 06:58:01 +0200leplep-
2021-09-07 06:58:03 +0200amir(sid22336@id-22336.stonehaven.irccloud.com)
2021-09-07 06:58:13 +0200stefan-_(~cri@42dots.de)
2021-09-07 06:58:13 +0200dragestil(~quassel@user/dragestil)
2021-09-07 06:58:21 +0200smitop(~smitop@user/smitop)
2021-09-07 06:58:21 +0200raoul(~raoul@95.179.203.88)
2021-09-07 06:58:21 +0200amir(sid22336@id-22336.stonehaven.irccloud.com) (Changing host)
2021-09-07 06:58:21 +0200amir(sid22336@user/amir)
2021-09-07 06:58:27 +0200nitrix(~nitrix@ns569831.ip-51-79-81.net) (Changing host)
2021-09-07 06:58:27 +0200nitrix(~nitrix@user/nitrix)
2021-09-07 06:58:27 +0200justache(~justache@user/justache)
2021-09-07 06:58:34 +0200sm[i](~user@plaintextaccounting/sm)
2021-09-07 06:58:45 +0200hexology(~hexology@user/hexology)
2021-09-07 06:58:45 +0200p3n(~p3n@217.198.124.246)
2021-09-07 06:58:46 +0200hexeme(~hexeme@user/hexeme)
2021-09-07 06:58:48 +0200dragestil_(~znc@user/dragestil)
2021-09-07 06:58:50 +0200davl(~davl@207.154.228.18)
2021-09-07 06:58:52 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-07 06:58:52 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-07 06:58:52 +0200wroathe(~wroathe@user/wroathe)
2021-09-07 06:59:34 +0200dkeohane1(~dkeohane@ec2-18-189-29-140.us-east-2.compute.amazonaws.com)
2021-09-07 07:01:01 +0200dragestil_dragestil`
2021-09-07 07:01:11 +0200mikoto-chan(~mikoto-ch@83.137.2.244)
2021-09-07 07:01:33 +0200dragestil`dragestil_
2021-09-07 07:02:36 +0200_________(~nobody@user/noodly)
2021-09-07 07:03:47 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2021-09-07 07:04:51 +0200APic(apic@apic.name) (Read error: Connection reset by peer)
2021-09-07 07:05:02 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 245 seconds)
2021-09-07 07:06:16 +0200Erutuon(~Erutuon@user/erutuon) (Ping timeout: 256 seconds)
2021-09-07 07:06:42 +0200euandreh(~euandreh@2804:14c:33:9fe5:ffb9:2324:6d72:6629) (Ping timeout: 245 seconds)
2021-09-07 07:08:52 +0200 <hexeme> yes! my cipher replicates the book, finally
2021-09-07 07:09:40 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 256 seconds)
2021-09-07 07:09:57 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 07:12:28 +0200 <hexeme> Is there a way to make `ord 'a'` a named constant?
2021-09-07 07:13:32 +0200 <hexeme> oh it was my capitalization
2021-09-07 07:15:21 +0200michalz(~michalz@185.246.204.101)
2021-09-07 07:17:16 +0200 <dsal> What do you mean "a named constant?"
2021-09-07 07:18:34 +0200 <monochrom> immutable "variable" :)
2021-09-07 07:18:58 +0200 <dsal> Isn't that just `ninetySeven = ord 'a'` ?
2021-09-07 07:19:18 +0200 <monochrom> Yeah. See "oh it was my capitalization".
2021-09-07 07:19:23 +0200 <dsal> Oooh
2021-09-07 07:21:44 +0200 <hexeme> Why doesn't this work: moduloOrdinal = (`mod` 26) . adjustOrdinal
2021-09-07 07:21:52 +0200 <hexeme> it complains mod hasn't enough arguments applied
2021-09-07 07:22:11 +0200 <hexeme> but I thought I was "sectioning" mod so that the output of adjustOrdinal is passed as the first argument
2021-09-07 07:22:15 +0200cjb(~cjb@user/cjb) (Quit: rcirc on GNU Emacs 28.0.50)
2021-09-07 07:24:01 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de)
2021-09-07 07:24:02 +0200 <dsal> What are the types of these things?
2021-09-07 07:24:40 +0200 <dsal> :t (`mod` 26) . adjustOrdinal
2021-09-07 07:24:41 +0200 <lambdabot> error:
2021-09-07 07:24:41 +0200 <lambdabot> Variable not in scope: adjustOrdinal :: a -> c
2021-09-07 07:25:13 +0200 <hexeme> http://logos.ldlework.com/caps/2021-09-07-05-25-11.png
2021-09-07 07:25:38 +0200 <dsal> Ah, well lambdabot gave you the answer. :)
2021-09-07 07:25:55 +0200 <dsal> :t (.)
2021-09-07 07:25:56 +0200 <lambdabot> (b -> c) -> (a -> b) -> a -> c
2021-09-07 07:26:15 +0200hexemescraches his head
2021-09-07 07:27:03 +0200 <hexeme> ohhh
2021-09-07 07:27:08 +0200APic(apic@apic.name)
2021-09-07 07:27:15 +0200 <pavonia> (.) composes functions with one input argument, but adjustOrdignal takes two
2021-09-07 07:27:15 +0200 <hexeme> I didn't apply because to do point free, you have to remove args from the function
2021-09-07 07:27:29 +0200niko(~niko@libera/staff/niko)
2021-09-07 07:27:42 +0200APic(apic@apic.name) (Read error: Connection reset by peer)
2021-09-07 07:28:29 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de) (Ping timeout: 265 seconds)
2021-09-07 07:28:49 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2021-09-07 07:28:52 +0200 <hexeme> reduceOrdinal char = ord char - baseOrdinal
2021-09-07 07:28:54 +0200 <hexeme> adjustOrdinal = (+ amount) . reduceOrdinal
2021-09-07 07:29:20 +0200 <hexeme> oh hmm
2021-09-07 07:31:02 +0200 <hexeme> I'm just curious, is there a way to make this truly point-free or should I not bother?
2021-09-07 07:31:03 +0200 <hexeme> http://logos.ldlework.com/caps/2021-09-07-05-30-36.png
2021-09-07 07:31:06 +0200 <dsal> It's slightly easier if you think of . as a function and not magic concatenation operator. It takes a function (b->c) and a function (a->b) and returns a function (a->c).
2021-09-07 07:31:15 +0200 <dsal> It's a lot easier to work with code that's not in png format. :/
2021-09-07 07:31:42 +0200 <hexeme> haha
2021-09-07 07:31:58 +0200 <hexeme> https://gist.github.com/dustinlacewell/97858ec608a9f6903d92593abd69bba5
2021-09-07 07:32:17 +0200 <hexeme> it'd be cool to see `moduloOrdinal` be defined with no params
2021-09-07 07:32:18 +0200 <dsal> @pl \amount -> (`mod` 26) . adjustOrdinal amount
2021-09-07 07:32:18 +0200 <lambdabot> ((`mod` 26) .) . adjustOrdinal
2021-09-07 07:32:18 +0200myShoggoth(~myShoggot@97-120-70-214.ptld.qwest.net)
2021-09-07 07:32:28 +0200 <dsal> I don't know that I'd call that cool.
2021-09-07 07:32:45 +0200 <hexeme> With respect to seeing what's possible I guess. But alright :)
2021-09-07 07:32:48 +0200 <pavonia> :t (.:)
2021-09-07 07:32:50 +0200 <lambdabot> error:
2021-09-07 07:32:50 +0200 <lambdabot> • Variable not in scope: .:
2021-09-07 07:32:50 +0200 <lambdabot> • Perhaps you meant one of these:
2021-09-07 07:33:23 +0200 <dsal> Making code point free is fine when it's a simple η-reduction.
2021-09-07 07:33:40 +0200 <dsal> @pl \amount -> (+ amount) . reduceOrdinal
2021-09-07 07:33:40 +0200 <lambdabot> (. reduceOrdinal) . (+)
2021-09-07 07:33:54 +0200 <dsal> But you can end up doing gross stuff.
2021-09-07 07:34:20 +0200 <hexeme> What's meant by n-reduction
2021-09-07 07:34:21 +0200jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2021-09-07 07:34:49 +0200 <dsal> eta, not n. When you take the same thing off the end of both sides of the equation.
2021-09-07 07:35:04 +0200 <dsal> @pl \f a -> g a
2021-09-07 07:35:04 +0200 <lambdabot> const g
2021-09-07 07:35:06 +0200 <dsal> heh
2021-09-07 07:35:17 +0200 <dsal> @pl \f a b -> g x b
2021-09-07 07:35:17 +0200 <lambdabot> const (const (g x))
2021-09-07 07:35:20 +0200 <dsal> damnit, pl
2021-09-07 07:35:36 +0200 <dsal> @pl \a b -> g x b
2021-09-07 07:35:36 +0200 <lambdabot> const (g x)
2021-09-07 07:36:14 +0200 <dsal> Anyway, when you define a function that has an argument and then you place that argument directly on the end of your definition, you can remove it from both sides.
2021-09-07 07:36:37 +0200 <hexeme> I see
2021-09-07 07:36:46 +0200jakalx(~jakalx@base.jakalx.net)
2021-09-07 07:36:50 +0200 <dsal> I'm being really dumb with my pl examples.
2021-09-07 07:37:10 +0200APic(apic@apic.name)
2021-09-07 07:37:20 +0200APic(apic@apic.name) (Read error: Connection reset by peer)
2021-09-07 07:37:24 +0200 <dsal> @pl \a1 -> g "something" a1
2021-09-07 07:37:24 +0200 <lambdabot> g "something"
2021-09-07 07:37:29 +0200 <dsal> @pl \a1 a2 -> g "something" a1 a2
2021-09-07 07:37:29 +0200 <lambdabot> g "something"
2021-09-07 07:37:52 +0200 <dsal> But you can get really gross with it
2021-09-07 07:39:10 +0200 <dsal> @pl \ amount -> (`mod` 26) . (\a -> (+ a) . (\char -> ord char - baseOrdinal)) amount
2021-09-07 07:39:10 +0200 <lambdabot> ((`mod` 26) .) . (. flip ((-) . ord) baseOrdinal) . (+)
2021-09-07 07:40:02 +0200max22-(~maxime@2a01cb0883359800332c1af3aa4fc5cd.ipv6.abo.wanadoo.fr)
2021-09-07 07:40:13 +0200 <dsal> :t ((`mod` 26) .) . (. flip ((-) . ord) baseOrdinal) . (+)
2021-09-07 07:40:14 +0200 <lambdabot> error:
2021-09-07 07:40:14 +0200 <lambdabot> Variable not in scope: baseOrdinal :: Int
2021-09-07 07:40:24 +0200 <dsal> :t ((`mod` 26) .) . (. flip ((-) . ord) (ord 'a')) . (+)
2021-09-07 07:40:25 +0200 <lambdabot> Int -> Char -> Int
2021-09-07 07:41:05 +0200 <dsal> > let moduloOrdinal = ((`mod` 26) .) . (. flip ((-) . ord) 97) . (+) in moduloOrdinal 13 'a'
2021-09-07 07:41:06 +0200 <lambdabot> 13
2021-09-07 07:41:21 +0200 <dsal> > let moduloOrdinal = ((`mod` 26) .) . (. flip ((-) . ord) 97) . (+) in moduloOrdinal 13 'd'
2021-09-07 07:41:22 +0200 <lambdabot> 16
2021-09-07 07:41:32 +0200 <dsal> I don't know what this function is supposed to do, but it's perfectly readable.
2021-09-07 07:42:17 +0200 <hexeme> hehe
2021-09-07 07:42:48 +0200 <john2312> in ContT's do-notation, how let k work on a list?
2021-09-07 07:44:06 +0200 <john2312> do { r <- cont $ \k -> k alist } I'd like let k apply on alist's every element, and r is that result, just like what List do
2021-09-07 07:44:07 +0200 <dsal> john2312: a bit confused by the question. do notation is do notation. ContT doesn't do anything special there.
2021-09-07 07:44:29 +0200 <dsal> You want a list monad instead?
2021-09-07 07:44:41 +0200 <john2312> in List, r <- [1,2,3], r will 1 and then 2 then 3, right?
2021-09-07 07:44:46 +0200 <dsal> Or ContT over a list?
2021-09-07 07:44:55 +0200 <john2312> dsal: ContT over a list
2021-09-07 07:46:01 +0200 <dsal> <- isn't let
2021-09-07 07:46:04 +0200slavaqq(~slavaqq@sdmail.sdserver.cz)
2021-09-07 07:46:39 +0200 <dsal> @undo do { r <- [1, 2, 3]; pure r }
2021-09-07 07:46:39 +0200 <lambdabot> [1, 2, 3] >>= \ r -> pure r
2021-09-07 07:46:50 +0200 <dsal> Do you want lift?
2021-09-07 07:47:41 +0200 <john2312> > traverse (\i -> if odd i then Right() else Left i) [1..10]
2021-09-07 07:47:43 +0200 <lambdabot> Left 2
2021-09-07 07:48:12 +0200 <john2312> dsal: I'd like to see how ContT doing the same thing as traverse
2021-09-07 07:49:27 +0200lep-lep
2021-09-07 07:49:36 +0200 <john2312> dsal: lift can lift a List into ContT?
2021-09-07 07:49:54 +0200 <dsal> :t lift
2021-09-07 07:49:55 +0200 <lambdabot> (MonadTrans t, Monad m) => m a -> t m a
2021-09-07 07:51:13 +0200 <john2312> dsal: in ContT do, r <- cont $ \k -> k <$> [1..10] is ok?
2021-09-07 07:51:57 +0200 <john2312> will r be will k 1, then k 2? like what List do?
2021-09-07 07:52:20 +0200 <john2312> lift can help here?
2021-09-07 07:53:01 +0200 <dsal> I'm not completely sure what you getting at there, but if you have a `ContT (List Int)` and you want to do something in the List part, that's what lift is for.
2021-09-07 07:54:03 +0200 <john2312> dsal: i'd like to how ContT doing that same thing just like traverse (\i -> if odd i then Right() else Left i) [1..10]
2021-09-07 07:56:48 +0200 <hexeme> is this built in as a short operator? pipe fa fb = fb fa
2021-09-07 07:57:34 +0200yahb(xsbot@user/mniip/bot/yahb) (Ping timeout: 252 seconds)
2021-09-07 07:59:56 +0200Akronymus(~Akronymus@85.118.189.59)
2021-09-07 08:00:23 +0200 <dsal> john2312: I'm not at a computer for a while, but it should be possible. Not with fmap, though. You'll need to consume the list inside the ContT. fmap can't change shapes
2021-09-07 08:00:34 +0200 <dsal> hexeme: $
2021-09-07 08:00:43 +0200 <dsal> Er, &
2021-09-07 08:00:43 +0200shriekingnoise(~shrieking@186.137.144.80) (Quit: Quit)
2021-09-07 08:00:56 +0200 <dsal> :t (&)
2021-09-07 08:00:57 +0200 <lambdabot> a -> (a -> b) -> b
2021-09-07 08:01:35 +0200 <hexeme> sick
2021-09-07 08:01:54 +0200yahb(xsbot@user/mniip/bot/yahb)
2021-09-07 08:02:10 +0200APic(apic@apic.name)
2021-09-07 08:03:16 +0200APic(apic@apic.name) (Read error: Connection reset by peer)
2021-09-07 08:03:56 +0200 <john2312> I don't know how to consume the list inside the ContT...
2021-09-07 08:04:24 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 08:04:37 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 08:04:56 +0200mikoto-chan(~mikoto-ch@83.137.2.244) (Quit: mikoto-chan)
2021-09-07 08:05:09 +0200 <dsal> I'm guessing it's just lift
2021-09-07 08:07:10 +0200APic(apic@apic.name)
2021-09-07 08:07:52 +0200APic(apic@apic.name) (Read error: Connection reset by peer)
2021-09-07 08:09:31 +0200 <john2312> lift [Int] into ContT Int [] Int?
2021-09-07 08:10:35 +0200lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-09-07 08:11:18 +0200 <dsal> > flip runContT pure (lift [1,2,3] >>= \r -> pure r) :: [Int]
2021-09-07 08:11:20 +0200 <lambdabot> [1,2,3]
2021-09-07 08:11:28 +0200jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2021-09-07 08:11:47 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:9b50:ae6e:a049:784)
2021-09-07 08:11:52 +0200ubert(~Thunderbi@91.141.54.165.wireless.dyn.drei.com)
2021-09-07 08:14:24 +0200 <dibblego> you can delete ">>= \r -> pure r"
2021-09-07 08:15:25 +0200Gurkenglas(~Gurkengla@dslb-090-186-104-237.090.186.pools.vodafone-ip.de)
2021-09-07 08:17:06 +0200arjun(~Srain@user/arjun)
2021-09-07 08:17:51 +0200jakalx(~jakalx@base.jakalx.net)
2021-09-07 08:18:45 +0200 <dsal> Sure, just illustrating. Though I've never actually used ContT, so I'm not quite sure how it does the thing here.
2021-09-07 08:27:31 +0200ubert1(~Thunderbi@91.141.54.165.wireless.dyn.drei.com)
2021-09-07 08:28:10 +0200ubert(~Thunderbi@91.141.54.165.wireless.dyn.drei.com) (Ping timeout: 260 seconds)
2021-09-07 08:28:10 +0200ubert1ubert
2021-09-07 08:28:40 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de)
2021-09-07 08:33:26 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de) (Ping timeout: 252 seconds)
2021-09-07 08:39:14 +0200APic(apic@apic.name)
2021-09-07 08:39:19 +0200fvr(uid503686@id-503686.highgate.irccloud.com) (Quit: Connection closed for inactivity)
2021-09-07 08:39:26 +0200APic(apic@apic.name) (Read error: Connection reset by peer)
2021-09-07 08:39:44 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 08:40:03 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 08:41:24 +0200lavaman(~lavaman@98.38.249.169)
2021-09-07 08:44:14 +0200APic(apic@apic.name)
2021-09-07 08:44:22 +0200APic(apic@apic.name) (Read error: Connection reset by peer)
2021-09-07 08:45:39 +0200kuribas(~user@ptr-25vy0i6t0eunz4pw5nt.18120a2.ip6.access.telenet.be)
2021-09-07 08:46:00 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de)
2021-09-07 08:46:05 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 252 seconds)
2021-09-07 08:49:14 +0200APic(apic@apic.name)
2021-09-07 08:49:28 +0200APic(apic@apic.name) (Read error: Connection reset by peer)
2021-09-07 08:55:07 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 08:55:21 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 09:01:44 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 09:07:50 +0200mc47(~mc47@xmonad/TheMC47)
2021-09-07 09:08:24 +0200jtomas(~jtomas@95.red-88-11-64.dynamicip.rima-tde.net)
2021-09-07 09:09:40 +0200sleblanc(~sleblanc@user/sleblanc) (Ping timeout: 252 seconds)
2021-09-07 09:12:37 +0200cfricke(~cfricke@user/cfricke)
2021-09-07 09:17:33 +0200burnsidesLlama(~burnsides@client-8-65.eduroam.oxuni.org.uk)
2021-09-07 09:19:57 +0200niko(~niko@libera/staff/niko) (Quit: i will be back)
2021-09-07 09:20:17 +0200APic(apic@apic.name)
2021-09-07 09:20:27 +0200APic(apic@apic.name) (Read error: Connection reset by peer)
2021-09-07 09:20:30 +0200o(~niko@libera/staff/niko)
2021-09-07 09:22:31 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-09-07 09:25:17 +0200APic(apic@apic.name)
2021-09-07 09:27:47 +0200anandprabhu(~anandprab@91.73.233.2)
2021-09-07 09:31:00 +0200oniko
2021-09-07 09:33:14 +0200chomwitt(~chomwitt@2a02:587:dc16:c800:12c3:7bff:fe6d:d374)
2021-09-07 09:33:40 +0200arjun(~Srain@user/arjun) (Ping timeout: 265 seconds)
2021-09-07 09:34:27 +0200arjun(~Srain@user/arjun)
2021-09-07 09:36:05 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-09-07 09:38:13 +0200wonko(~wjc@62.115.229.50)
2021-09-07 09:45:26 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 09:57:08 +0200amk(~amk@109.255.169.126) (Remote host closed the connection)
2021-09-07 09:59:42 +0200 <kuribas> yikes, why does cassava NamedRecord use ByteString...
2021-09-07 09:59:58 +0200fendor(~fendor@91.141.66.73.wireless.dyn.drei.com)
2021-09-07 10:05:43 +0200 <dminuoso> kuribas: You have been complaining about cassava for perhaps 18 months now.
2021-09-07 10:05:52 +0200 <dminuoso> Just write your own csv library.
2021-09-07 10:05:54 +0200 <dminuoso> :-)
2021-09-07 10:05:58 +0200hendursa1(~weechat@user/hendursaga)
2021-09-07 10:06:05 +0200 <kuribas> dminuoso: when I take the chance, I'll remove it from our project :)
2021-09-07 10:06:18 +0200 <kuribas> We'll use ods then.
2021-09-07 10:09:07 +0200 <kuribas> Or reduce the usage of cassava to ByteString -> [HashMap Text Text]
2021-09-07 10:09:12 +0200hendursaga(~weechat@user/hendursaga) (Ping timeout: 276 seconds)
2021-09-07 10:09:38 +0200 <mniip> fun fact
2021-09-07 10:09:49 +0200 <mniip> :t \f -> callCC $ \k -> ask >>= \s -> case f s of (s, x) -> local (const s) (k x)
2021-09-07 10:09:50 +0200 <lambdabot> (MonadReader b m, MonadCont m) => (b -> (b, a)) -> m a
2021-09-07 10:10:10 +0200 <mniip> State ~ ContT Reader
2021-09-07 10:10:21 +0200 <kuribas> yeah
2021-09-07 10:11:19 +0200adanwan(~adanwan@gateway/tor-sasl/adanwan)
2021-09-07 10:13:33 +0200anandprabhu(~anandprab@91.73.233.2) (Quit: Leaving)
2021-09-07 10:14:04 +0200gehmehgeh(~user@user/gehmehgeh)
2021-09-07 10:16:13 +0200spruit11(~quassel@2a02:a467:ccd6:1:3c81:60b6:4f21:77d2) (Ping timeout: 252 seconds)
2021-09-07 10:17:32 +0200aarvar(~aaron@2601:602:a080:fa0:1804:9b51:73a6:32bd) (Ping timeout: 245 seconds)
2021-09-07 10:17:55 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Killed (NickServ (GHOST command used by allbery_b)))
2021-09-07 10:17:55 +0200allbery_b(~geekosaur@xmonad/geekosaur)
2021-09-07 10:17:58 +0200allbery_bgeekosaur
2021-09-07 10:18:58 +0200notzmv(~zmv@user/notzmv) (Ping timeout: 252 seconds)
2021-09-07 10:27:54 +0200spruit11(~quassel@2a02:a467:ccd6:1:e578:65a3:833a:6855)
2021-09-07 10:28:11 +0200hnOsmium0001(uid453710@id-453710.stonehaven.irccloud.com) (Quit: Connection closed for inactivity)
2021-09-07 10:28:58 +0200ubert(~Thunderbi@91.141.54.165.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-07 10:32:16 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 252 seconds)
2021-09-07 10:32:25 +0200spruit11(~quassel@2a02:a467:ccd6:1:e578:65a3:833a:6855) (Ping timeout: 260 seconds)
2021-09-07 10:32:35 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 10:38:11 +0200jakalx(~jakalx@base.jakalx.net) ()
2021-09-07 10:38:40 +0200jakalx(~jakalx@base.jakalx.net)
2021-09-07 10:39:12 +0200vysn(~vysn@user/vysn)
2021-09-07 10:40:53 +0200michalz(~michalz@185.246.204.101) (Remote host closed the connection)
2021-09-07 10:41:27 +0200APic(apic@apic.name) (Quit: [TLS] Client upgrade)
2021-09-07 10:41:37 +0200APic(apic@apic.name)
2021-09-07 10:42:10 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 252 seconds)
2021-09-07 10:42:29 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 10:50:33 +0200APic(apic@apic.name) (Quit: Boot tut gut™)
2021-09-07 10:52:35 +0200Ariakenom(~patrik@h-81-170-208-30.A163.corp.bahnhof.se)
2021-09-07 10:53:46 +0200lavaman(~lavaman@98.38.249.169)
2021-09-07 10:54:01 +0200ubert(~Thunderbi@91.141.54.165.wireless.dyn.drei.com)
2021-09-07 10:58:05 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 252 seconds)
2021-09-07 11:00:36 +0200econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2021-09-07 11:01:37 +0200spruit11(~quassel@2a02:a467:ccd6:1:e578:65a3:833a:6855)
2021-09-07 11:06:55 +0200spruit11(~quassel@2a02:a467:ccd6:1:e578:65a3:833a:6855) (Ping timeout: 252 seconds)
2021-09-07 11:07:25 +0200chomwitt(~chomwitt@2a02:587:dc16:c800:12c3:7bff:fe6d:d374) (Ping timeout: 260 seconds)
2021-09-07 11:07:30 +0200aliosablack(~chomwitt@94.66.61.235)
2021-09-07 11:10:21 +0200hololeap_(~hololeap@user/hololeap) (Remote host closed the connection)
2021-09-07 11:10:31 +0200hololeap(~hololeap@user/hololeap)
2021-09-07 11:12:20 +0200flukiluke(~flukiluke@2603:c023:c000:6c7e:8945:ad24:9113:a962) (Remote host closed the connection)
2021-09-07 11:12:31 +0200tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2021-09-07 11:13:31 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-07 11:14:19 +0200dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be)
2021-09-07 11:16:38 +0200neo(~neo3@cpe-292712.ip.primehome.com)
2021-09-07 11:17:02 +0200neoGuest1856
2021-09-07 11:17:11 +0200flukiluke_flukiluke
2021-09-07 11:18:48 +0200Guest1856(~neo3@cpe-292712.ip.primehome.com) (Client Quit)
2021-09-07 11:19:08 +0200spruit11(~quassel@2a02:a467:ccd6:1:e578:65a3:833a:6855)
2021-09-07 11:19:49 +0200slep(~slep@cpc150002-brnt4-2-0-cust437.4-2.cable.virginm.net)
2021-09-07 11:20:19 +0200michalz(~michalz@185.246.204.101)
2021-09-07 11:20:58 +0200slavaqq(~slavaqq@sdmail.sdserver.cz) (Quit: Client closed)
2021-09-07 11:25:27 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 11:25:40 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 11:30:46 +0200jpds1jpds
2021-09-07 11:31:53 +0200pzanco(~Android@187.104.158.159)
2021-09-07 11:32:16 +0200zfnmxt(~zfnmxtzfn@2001:470:69fc:105::2b32) (Changing host)
2021-09-07 11:32:16 +0200zfnmxt(~zfnmxtzfn@user/zfnmxt)
2021-09-07 11:38:10 +0200amahl(~amahl@dsl-jklbng12-54fbca-64.dhcp.inet.fi)
2021-09-07 11:42:40 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Ping timeout: 252 seconds)
2021-09-07 11:43:19 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-09-07 11:52:33 +0200adanwan(~adanwan@gateway/tor-sasl/adanwan) (Ping timeout: 276 seconds)
2021-09-07 11:53:40 +0200xsperry(~as@user/xsperry)
2021-09-07 11:54:29 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14) (Remote host closed the connection)
2021-09-07 11:54:37 +0200amk(~amk@109.255.169.126)
2021-09-07 11:55:50 +0200poljar(~poljar@78-3-12-111.adsl.net.t-com.hr) (Ping timeout: 252 seconds)
2021-09-07 11:59:38 +0200poljar(~poljar@93-139-113-226.adsl.net.t-com.hr)
2021-09-07 12:07:38 +0200bitmapper(uid464869@id-464869.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2021-09-07 12:13:49 +0200slavaqq(~slavaqq@sdmail.sdserver.cz)
2021-09-07 12:15:35 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Remote host closed the connection)
2021-09-07 12:15:51 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 12:18:41 +0200kayprish(~kayprish@cable-188-2-153-140.dynamic.sbb.rs)
2021-09-07 12:18:58 +0200aliosablack(~chomwitt@94.66.61.235) (Ping timeout: 265 seconds)
2021-09-07 12:19:03 +0200chomwitt(~chomwitt@athedsl-369855.home.otenet.gr)
2021-09-07 12:20:09 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 12:20:49 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 12:21:03 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 12:26:08 +0200img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2021-09-07 12:26:10 +0200chomwitt(~chomwitt@athedsl-369855.home.otenet.gr) (Ping timeout: 260 seconds)
2021-09-07 12:26:13 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de) (Ping timeout: 265 seconds)
2021-09-07 12:27:30 +0200img(~img@user/img)
2021-09-07 12:28:37 +0200notzmv(~zmv@user/notzmv)
2021-09-07 12:28:45 +0200ub(~Thunderbi@91.141.54.165.wireless.dyn.drei.com)
2021-09-07 12:29:47 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2021-09-07 12:30:21 +0200slavaqq(~slavaqq@sdmail.sdserver.cz) (Ping timeout: 256 seconds)
2021-09-07 12:32:00 +0200ubert(~Thunderbi@91.141.54.165.wireless.dyn.drei.com) (Ping timeout: 260 seconds)
2021-09-07 12:32:01 +0200ububert
2021-09-07 12:36:50 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de)
2021-09-07 12:37:09 +0200img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2021-09-07 12:38:32 +0200img(~img@user/img)
2021-09-07 12:44:46 +0200chomwitt(~chomwitt@athedsl-351437.home.otenet.gr)
2021-09-07 12:47:21 +0200Akronymus(~Akronymus@85.118.189.59) (Ping timeout: 256 seconds)
2021-09-07 12:52:29 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de) (Ping timeout: 252 seconds)
2021-09-07 12:54:01 +0200adanwan(~adanwan@gateway/tor-sasl/adanwan)
2021-09-07 12:54:08 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-07 12:54:53 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14)
2021-09-07 12:55:33 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 12:59:07 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14) (Ping timeout: 252 seconds)
2021-09-07 12:59:34 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Remote host closed the connection)
2021-09-07 13:00:20 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2021-09-07 13:00:59 +0200alx741(~alx741@181.196.68.218)
2021-09-07 13:03:04 +0200aliosablack(~chomwitt@ppp-94-67-192-178.home.otenet.gr)
2021-09-07 13:03:26 +0200chomwitt(~chomwitt@athedsl-351437.home.otenet.gr) (Ping timeout: 265 seconds)
2021-09-07 13:03:56 +0200TranquilEcho(~grom@user/tranquilecho)
2021-09-07 13:04:03 +0200jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 276 seconds)
2021-09-07 13:04:19 +0200chexum(~quassel@gateway/tor-sasl/chexum)
2021-09-07 13:04:42 +0200chexum_(~quassel@gateway/tor-sasl/chexum) (Ping timeout: 276 seconds)
2021-09-07 13:05:22 +0200 <iqubic> Is there a version of mapMaybe that works with NonEmpty from base?
2021-09-07 13:05:42 +0200jpds(~jpds@gateway/tor-sasl/jpds)
2021-09-07 13:05:51 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-09-07 13:06:10 +0200 <iqubic> specifically I want something of the type "(a -> Maybe b) -> NonEmpty a -> [b]"
2021-09-07 13:06:49 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 13:07:10 +0200qbt(~edun@user/edun)
2021-09-07 13:07:36 +0200 <opqdonut> :t \f -> mapMaybe f . toList
2021-09-07 13:07:37 +0200 <lambdabot> Foldable t => (a -> Maybe b) -> t a -> [b]
2021-09-07 13:07:57 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de)
2021-09-07 13:08:13 +0200 <opqdonut> NonEmpty is Foldable, usually there's no need for a special NonEmpty version of a function
2021-09-07 13:08:24 +0200 <iqubic> Yeah, but doesn't that traverse the list twice?
2021-09-07 13:08:33 +0200 <opqdonut> no, because laziness
2021-09-07 13:08:56 +0200 <opqdonut> assuming that mapMaybe and toList are defined suitably, you'll even get list fusion and the intermediate list won't even get allocated
2021-09-07 13:12:08 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-09-07 13:12:41 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 13:12:53 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-09-07 13:14:10 +0200john2312(~user@114.250.137.142) (Ping timeout: 240 seconds)
2021-09-07 13:21:46 +0200chisui(~chisui@200116b868697b00c8225f803a065f0d.dip.versatel-1u1.de)
2021-09-07 13:22:50 +0200 <chisui> Hey, what are modern haskell solutions for parsing arguments into data? Does something akin to rusts structopts or clap exist?
2021-09-07 13:23:35 +0200 <kaol> Can't go wrong with optparse-applicative.
2021-09-07 13:24:12 +0200 <iqubic> Yeah. I was just about to suggest that.
2021-09-07 13:24:44 +0200 <hpc> base has a getopt module, but optparse-applicative is crazy good
2021-09-07 13:25:40 +0200fendor_(~fendor@77.119.198.92.wireless.dyn.drei.com)
2021-09-07 13:27:46 +0200 <chisui> Oh, wow it also has completion support. Thats wild.
2021-09-07 13:27:50 +0200Akronymus(~Akronymus@85.31.8.180)
2021-09-07 13:28:16 +0200fendor(~fendor@91.141.66.73.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-07 13:29:56 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Remote host closed the connection)
2021-09-07 13:30:09 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 13:31:53 +0200 <dminuoso> optparse-applicative is just very verbose. :)
2021-09-07 13:32:07 +0200 <dminuoso> It's good, but at times I wish there was something that required less typing for minimal problems.
2021-09-07 13:33:13 +0200aliosablack(~chomwitt@ppp-94-67-192-178.home.otenet.gr) (Ping timeout: 252 seconds)
2021-09-07 13:33:38 +0200aman(~aman@user/aman)
2021-09-07 13:35:56 +0200Ariakenom(~patrik@h-81-170-208-30.A163.corp.bahnhof.se) (Ping timeout: 252 seconds)
2021-09-07 13:39:57 +0200 <hpc> i like knowing i can add more options over time without hitting some arbitrary limitation of the underlying library
2021-09-07 13:40:08 +0200 <hpc> and it's not even really that verbose imo
2021-09-07 13:41:08 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 13:41:24 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 13:43:05 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 252 seconds)
2021-09-07 13:43:23 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 13:50:04 +0200pzanco(~Android@187.104.158.159) (Quit: Connection Timed Out)
2021-09-07 13:51:31 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 13:51:54 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 13:52:12 +0200 <tomsmeding> I'm not sure "not having arbitary limits on the number of options" is really the best thing you can say about optparse-applicative :p
2021-09-07 13:54:14 +0200pzanco(~Android@187.104.158.159)
2021-09-07 13:54:38 +0200pzanco(~Android@187.104.158.159) (Client Quit)
2021-09-07 13:54:42 +0200 <lortabac> dminuoso: there is optparse-generic
2021-09-07 13:54:46 +0200 <lortabac> @hackage optparse-generic
2021-09-07 13:54:46 +0200 <lambdabot> https://hackage.haskell.org/package/optparse-generic
2021-09-07 13:56:43 +0200ubert1(~Thunderbi@91.141.54.165.wireless.dyn.drei.com)
2021-09-07 13:57:55 +0200 <hololeap> dminuoso: @hackage optparse-simple
2021-09-07 13:57:56 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2021-09-07 13:58:06 +0200 <hololeap> @hackage optparse-simple
2021-09-07 13:58:06 +0200 <lambdabot> https://hackage.haskell.org/package/optparse-simple
2021-09-07 13:58:29 +0200ubert(~Thunderbi@91.141.54.165.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-07 13:58:29 +0200ubert1ubert
2021-09-07 13:58:50 +0200burnsidesLlama(~burnsides@client-8-65.eduroam.oxuni.org.uk) (Remote host closed the connection)
2021-09-07 13:59:26 +0200burnsidesLlama(~burnsides@dhcp168-020.wadham.ox.ac.uk)
2021-09-07 14:00:40 +0200max22-(~maxime@2a01cb0883359800332c1af3aa4fc5cd.ipv6.abo.wanadoo.fr) (Ping timeout: 260 seconds)
2021-09-07 14:00:43 +0200sleblanc(~sleblanc@user/sleblanc)
2021-09-07 14:01:51 +0200 <merijn> dminuoso: Easy enough to handroll a few custom combinators for the common case of your application
2021-09-07 14:01:55 +0200 <hpc> tomsmeding: limit on complexity
2021-09-07 14:02:08 +0200euandreh(~euandreh@2804:14c:33:9fe5:c3ab:c75d:f803:b354)
2021-09-07 14:02:14 +0200 <hpc> maybe i want to add a whole other mode of operation
2021-09-07 14:02:22 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de) (Ping timeout: 252 seconds)
2021-09-07 14:02:39 +0200 <hpc> "foo add --this-set-of-options" or "foo delete --something-totally-different"
2021-09-07 14:02:39 +0200 <tomsmeding> oh right you were complaining about the simplicity of base's getopt
2021-09-07 14:02:48 +0200 <merijn> tomsmeding: The point is "a relatively minimal CLI is a bit more verbose in optparse, but it scales up from that to arbitrarily complex commandlines"
2021-09-07 14:03:00 +0200 <tomsmeding> yeah
2021-09-07 14:04:48 +0200acidjnk_new3(~acidjnk@p200300d0c72030994532c033362507d1.dip0.t-ipconnect.de)
2021-09-07 14:05:07 +0200myShoggoth(~myShoggot@97-120-70-214.ptld.qwest.net) (Ping timeout: 252 seconds)
2021-09-07 14:05:35 +0200fendor_fendor
2021-09-07 14:06:55 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de)
2021-09-07 14:08:10 +0200acidjnk_new(~acidjnk@p5487d0ba.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2021-09-07 14:08:56 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 252 seconds)
2021-09-07 14:09:13 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 14:14:36 +0200alx741(~alx741@181.196.68.218) (Quit: alx741)
2021-09-07 14:18:46 +0200slowButPresent(~slowButPr@user/slowbutpresent)
2021-09-07 14:19:23 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 252 seconds)
2021-09-07 14:19:41 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 14:20:31 +0200ubert(~Thunderbi@91.141.54.165.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-07 14:21:23 +0200 <dminuoso> merijn: Ideally I want something with a minimalistic interface in the likes of say optparse in python.
2021-09-07 14:21:46 +0200 <dminuoso> With optparse-applicative it seems like Im writing 20 lines for what could be written in 3 instead.
2021-09-07 14:21:51 +0200 <dminuoso> It's just a mild annoyance, not a major issue.
2021-09-07 14:28:13 +0200sleblanc(~sleblanc@user/sleblanc) (Ping timeout: 252 seconds)
2021-09-07 14:29:41 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-09-07 14:34:04 +0200acarrico1acarrico
2021-09-07 14:34:14 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 252 seconds)
2021-09-07 14:34:32 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 14:37:11 +0200 <kuribas> But optparse-applicative is obviously inferior data clojure: https://www.reddit.com/r/programming/comments/pe1zlt/whatever_your_language_you_can_steal_clojures/
2021-09-07 14:37:37 +0200 <kuribas> (because you cannot inspect the generated parser, or something...)
2021-09-07 14:38:28 +0200xff0x(~xff0x@2001:1a81:5244:5800:ade4:7c8b:9b3b:6271) (Ping timeout: 256 seconds)
2021-09-07 14:38:57 +0200adanwan(~adanwan@gateway/tor-sasl/adanwan) (Ping timeout: 276 seconds)
2021-09-07 14:39:44 +0200 <merijn> Easily fixed
2021-09-07 14:39:54 +0200 <merijn> Just picked up the ticket to implement optparse-selective
2021-09-07 14:41:01 +0200 <dminuoso> I started it, looked at optparse-applicative implementation, and then decided it was better to watch Dark Crystal: Age of Resistance instead.
2021-09-07 14:41:33 +0200 <merijn> I dove into it quite a bit and feel I actually understand it well enough now
2021-09-07 14:41:52 +0200 <merijn> But then I realised nobody's paying me and I have enough work already, so fuck that :p
2021-09-07 14:44:04 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-09-07 14:45:09 +0200 <albet70> > flip runContT return $ do { r <- lift [1..6]; when (r == 3) $ return 2; return r }
2021-09-07 14:45:11 +0200 <lambdabot> error:
2021-09-07 14:45:12 +0200 <lambdabot> • Could not deduce (Num ()) arising from the literal ‘2’
2021-09-07 14:45:12 +0200 <lambdabot> from the context: (Enum r, Eq r, Num r)
2021-09-07 14:45:32 +0200 <albet70> err...
2021-09-07 14:46:17 +0200 <tomsmeding> > flip runContT return $ do { r <- lift [1..6]; if r == 3 then return 2 else return r }
2021-09-07 14:46:18 +0200 <lambdabot> [1,2,2,4,5,6]
2021-09-07 14:46:25 +0200 <tomsmeding> :t when
2021-09-07 14:46:26 +0200 <lambdabot> Applicative f => Bool -> f () -> f ()
2021-09-07 14:47:30 +0200 <albet70> could it return immediately when r == 3? make the result is [1,2] not [1,2,3,4,5,6]?
2021-09-07 14:47:44 +0200 <tomsmeding> there is no "early return" with 'return' in haskell
2021-09-07 14:47:47 +0200 <tomsmeding> :t return
2021-09-07 14:47:49 +0200 <lambdabot> Monad m => a -> m a
2021-09-07 14:48:01 +0200 <tomsmeding> 'return' is just a function that injects a value into a monad; it's exactly the same function as:
2021-09-07 14:48:02 +0200 <tomsmeding> :t pure
2021-09-07 14:48:03 +0200 <lambdabot> Applicative f => a -> f a
2021-09-07 14:48:16 +0200 <dminuoso> callCC give you that "early return" :p
2021-09-07 14:48:17 +0200 <tomsmeding> (exactly as in "return = pure" is the default implementation)
2021-09-07 14:48:40 +0200 <albet70> dminuoso, could u do that with callCC?
2021-09-07 14:48:45 +0200 <dminuoso> albet70: Yes.
2021-09-07 14:48:47 +0200 <albet70> that above
2021-09-07 14:48:50 +0200 <dminuoso> Yes.
2021-09-07 14:48:52 +0200 <tomsmeding> right, you might get an early return somehow, but that is then because the monad in question _explicitly_ implemented that, and that's not going to be with 'pure' (also known as 'return')
2021-09-07 14:48:53 +0200 <albet70> how?
2021-09-07 14:49:09 +0200xff0x(~xff0x@2001:1a81:5244:5800:ade4:7c8b:9b3b:6271)
2021-09-07 14:49:28 +0200 <albet70> use Cont to break List
2021-09-07 14:50:18 +0200 <dminuoso> albet70: Well it doesnt quite behave like you'd expect it to.
2021-09-07 14:50:31 +0200 <dminuoso> callCC can be thought of as a pure functional setjmp/longjmp
2021-09-07 14:50:36 +0200 <albet70> would u show me pls
2021-09-07 14:51:15 +0200 <albet70> not jmp, just do early exit
2021-09-07 14:51:58 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 14:52:09 +0200 <albet70> I saw some code like this, forLoop items fn = let contArr = fmap fn items in C.runContT (sequence_ contArr) return
2021-09-07 14:52:13 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 14:52:36 +0200pbrisbin(~patrick@pool-108-16-214-93.phlapa.fios.verizon.net)
2021-09-07 14:52:39 +0200 <albet70> breakOut :: Monad m => C.ContT () m c; breakOut = C.ContT $ \_ -> return ()
2021-09-07 14:53:12 +0200 <albet70> but it uses sequence_ here, that would be meaningless, because traverse can do early exit already
2021-09-07 14:53:30 +0200hays(rootvegeta@st5ve.com) (Quit: hays)
2021-09-07 14:53:56 +0200hays(rootvegeta@st5ve.com)
2021-09-07 14:53:56 +0200hays(rootvegeta@st5ve.com) (Changing host)
2021-09-07 14:53:57 +0200hays(rootvegeta@fsf/member/hays)
2021-09-07 14:53:58 +0200 <albet70> forLoop :: Monad m => [a] -> (a -> C.ContT () m c) -> m ()
2021-09-07 14:54:02 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-07 14:54:44 +0200chomwitt(~chomwitt@2a02:587:dc02:7900:12c3:7bff:fe6d:d374)
2021-09-07 14:55:12 +0200 <dminuoso> Mmm, you'd have to swap ListT (or LogicT) and ContT around, no?
2021-09-07 14:55:21 +0200 <kuribas> albet70: you can use "Either" for early return.
2021-09-07 14:56:03 +0200 <albet70> aha, ListT does exist?
2021-09-07 14:56:20 +0200 <dminuoso> Yeah, e.g.:
2021-09-07 14:56:32 +0200 <dminuoso> https://hackage.haskell.org/package/logict-0.7.1.0/docs/Control-Monad-Logic.html#t:LogicT
2021-09-07 14:56:37 +0200 <albet70> if it does, we can achieve this with ListT?
2021-09-07 14:56:46 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14)
2021-09-07 14:59:58 +0200 <albet70> example?
2021-09-07 15:00:58 +0200 <albet70> kuribas but Either just like Maybe, it still do the whole computation, not break immediately
2021-09-07 15:01:13 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14) (Ping timeout: 252 seconds)
2021-09-07 15:01:17 +0200 <kuribas> albet70: no, it doesn't?
2021-09-07 15:01:28 +0200 <dminuoso> It depends on what order you layer them
2021-09-07 15:01:33 +0200 <dminuoso> If done via transformers
2021-09-07 15:02:44 +0200kayprish(~kayprish@cable-188-2-153-140.dynamic.sbb.rs) (Remote host closed the connection)
2021-09-07 15:02:50 +0200 <albet70> let's back to that callCC stuff, could callCC break that List computation in above code?
2021-09-07 15:03:38 +0200hays(rootvegeta@fsf/member/hays) (Quit: hays)
2021-09-07 15:03:55 +0200 <albet70> > flip runContT return $ do { r <- lift [1..6]; if (r == 3) then return 2 else return r }
2021-09-07 15:03:57 +0200 <lambdabot> [1,2,2,4,5,6]
2021-09-07 15:03:57 +0200hays(rootvegeta@fsf/member/hays)
2021-09-07 15:04:18 +0200 <albet70> let it just return [1,2]
2021-09-07 15:04:19 +0200Ariakenom(~patrik@h-81-170-208-30.A163.corp.bahnhof.se)
2021-09-07 15:06:00 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 260 seconds)
2021-09-07 15:07:54 +0200aman(~aman@user/aman) (Quit: aman)
2021-09-07 15:08:41 +0200 <kuribas> albet70: you're returning a number, how could it then return a list?
2021-09-07 15:10:10 +0200MQ-17J(~MQ-17J@2607:fb90:1d33:949a:dd01:ad33:fd60:12c6)
2021-09-07 15:10:33 +0200 <albet70> because it's type is ContT Int [] Int?
2021-09-07 15:11:40 +0200michalz(~michalz@185.246.204.101) (Ping timeout: 252 seconds)
2021-09-07 15:11:45 +0200 <albet70> within ListT, we can lift print every single item, no need sequence
2021-09-07 15:13:12 +0200 <kuribas> > runStateT $ for_ [1..] $ \x -> do xs <- get; if x > 5 then lift $ Left xs; else put (x:xs)
2021-09-07 15:13:14 +0200 <lambdabot> <[Integer] -> Either [Integer] ((),[Integer])>
2021-09-07 15:13:32 +0200oxide(~lambda@user/oxide)
2021-09-07 15:13:45 +0200 <kuribas> > flip runStateT [] $ for_ [1..] $ \x -> do xs <- get; if x > 5 then lift $ Left xs; else put (x:xs)
2021-09-07 15:13:46 +0200 <lambdabot> Left [5,4,3,2,1]
2021-09-07 15:15:19 +0200 <kuribas> albet70: note that ListT (from transformers) isn't a proper monad.
2021-09-07 15:15:35 +0200 <kuribas> also the List monad probably doesn't short circuit the way you think.
2021-09-07 15:16:34 +0200 <kuribas> continuation monad on top of the list monad is madness...
2021-09-07 15:17:29 +0200michalz(~michalz@185.246.204.41)
2021-09-07 15:19:16 +0200koz(~koz@2404:4408:430f:a900:ca69:658c:ba89:aa9f) (Ping timeout: 252 seconds)
2021-09-07 15:19:38 +0200acidjnk_new(~acidjnk@p5487d0ba.dip0.t-ipconnect.de)
2021-09-07 15:22:19 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 15:22:37 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 15:22:40 +0200acidjnk_new3(~acidjnk@p200300d0c72030994532c033362507d1.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2021-09-07 15:27:04 +0200Sgeo(~Sgeo@user/sgeo)
2021-09-07 15:27:51 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-09-07 15:28:25 +0200arjun_(~Srain@user/arjun)
2021-09-07 15:29:38 +0200alp(~alp@163.172.83.213) (Quit: ZNC 1.8.1 - https://znc.in)
2021-09-07 15:29:39 +0200guibou(~guibou@163.172.83.213) (Quit: ZNC 1.8.1 - https://znc.in)
2021-09-07 15:30:53 +0200arjun(~Srain@user/arjun) (Ping timeout: 252 seconds)
2021-09-07 15:30:54 +0200arjun_arjun
2021-09-07 15:31:58 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-07 15:31:58 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-07 15:31:58 +0200wroathe(~wroathe@user/wroathe)
2021-09-07 15:35:22 +0200Kevin578(~Kevin578@pool-96-237-112-198.bstnma.fios.verizon.net)
2021-09-07 15:39:07 +0200pzanco(~pzanco@2804:14c:3ba1:42d:2204:fff:feff:44a0)
2021-09-07 15:39:18 +0200shriekingnoise(~shrieking@186.137.144.80)
2021-09-07 15:42:22 +0200 <lechner> Hi, in this servant example what does the sole, single quote do, please? https://github.com/sras/servant-examples/blob/master/src/HelloWorld.hs#L44
2021-09-07 15:42:39 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 15:42:53 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 15:43:42 +0200 <geekosaur> marks it as a type-level list
2021-09-07 15:44:05 +0200max22-(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr)
2021-09-07 15:46:15 +0200 <geekosaur> instead of declaring a value-level list's type
2021-09-07 15:47:27 +0200hendursa1(~weechat@user/hendursaga) (Quit: hendursa1)
2021-09-07 15:47:53 +0200hendursaga(~weechat@user/hendursaga)
2021-09-07 15:48:21 +0200 <lechner> it's available even without "TypeOperators" right?
2021-09-07 15:48:25 +0200tddschn(~textual@45.77.71.205)
2021-09-07 15:48:33 +0200 <dminuoso> Yes.
2021-09-07 15:48:36 +0200 <dminuoso> lechner: It's part of DataKinds
2021-09-07 15:49:19 +0200 <dminuoso> Or at least Id expect it to be
2021-09-07 15:49:57 +0200lavaman(~lavaman@98.38.249.169)
2021-09-07 15:52:08 +0200favonia(~favonia@user/favonia) (Ping timeout: 256 seconds)
2021-09-07 15:52:20 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 252 seconds)
2021-09-07 15:53:55 +0200 <lechner> thanks!
2021-09-07 15:54:25 +0200chomwitt(~chomwitt@2a02:587:dc02:7900:12c3:7bff:fe6d:d374) (Ping timeout: 260 seconds)
2021-09-07 15:54:29 +0200 <dminuoso> lechner: The ' essentially lets you distinguish between a lifted and non-lifted constructor.
2021-09-07 15:54:32 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 265 seconds)
2021-09-07 15:55:08 +0200 <dminuoso> for instance:
2021-09-07 15:55:13 +0200 <dminuoso> % :set -XDataKinds
2021-09-07 15:55:13 +0200 <yahb> dminuoso:
2021-09-07 15:55:20 +0200 <dminuoso> % data Color = Red | Blue
2021-09-07 15:55:20 +0200 <yahb> dminuoso:
2021-09-07 15:55:35 +0200 <dminuoso> % type A = '['Red]
2021-09-07 15:55:36 +0200 <yahb> dminuoso: ; <interactive>:43:10: error: parse error on input '
2021-09-07 15:56:36 +0200koz(~koz@121.99.240.58)
2021-09-07 15:57:03 +0200 <dminuoso> % type T = Const Int 'Red
2021-09-07 15:57:03 +0200 <yahb> dminuoso:
2021-09-07 15:57:36 +0200 <dminuoso> lechner: Interestingly here you could have also written `type T = Const Int Red`, because `Red` happens to be unambiguous in the current namespace (it can only refer to the lifted type)
2021-09-07 15:57:41 +0200 <dminuoso> But consider if we also have this present:
2021-09-07 15:57:47 +0200 <dminuoso> % newtype Red = Red Int
2021-09-07 15:57:47 +0200 <yahb> dminuoso:
2021-09-07 15:57:55 +0200 <dminuoso> % type T = Const Int Red
2021-09-07 15:57:55 +0200 <yahb> dminuoso:
2021-09-07 15:58:12 +0200 <dminuoso> Then here `Red` will refer to the newtype Red, but `'Red` would refer to the lifted type from Colour.
2021-09-07 15:58:45 +0200 <dminuoso> ' for type lists is the same thing, as '[] lets GHC disambiguate between the lifted list and non-lifted list
2021-09-07 16:00:40 +0200MQ-17J(~MQ-17J@2607:fb90:1d33:949a:dd01:ad33:fd60:12c6) (Read error: Connection reset by peer)
2021-09-07 16:00:55 +0200zebrag(~chris@user/zebrag)
2021-09-07 16:01:10 +0200MQ-17J(~MQ-17J@35.50.7.10)
2021-09-07 16:02:20 +0200chomwitt(~chomwitt@2a02:587:dc02:7900:12c3:7bff:fe6d:d374)
2021-09-07 16:02:28 +0200 <lechner> why would someone do something like newtype Red = Red Int ?
2021-09-07 16:03:54 +0200 <[exa]> lechner: for example because it may have different typeclass instances than Int
2021-09-07 16:05:01 +0200 <[exa]> it sounds kindof like color, so e.g. Show can print with blood and Num may clamp to 0-255 for 8bit rgb values
2021-09-07 16:05:09 +0200biberu\(~biberu@user/biberu)
2021-09-07 16:06:50 +0200 <lechner> i am just confused by the naming. same with "newtype FirstName = FirstName String" here https://wiki.haskell.org/Type
2021-09-07 16:06:59 +0200adanwan(~adanwan@gateway/tor-sasl/adanwan)
2021-09-07 16:07:05 +0200pzanco(~pzanco@2804:14c:3ba1:42d:2204:fff:feff:44a0) (Quit: Leaving)
2021-09-07 16:08:10 +0200biberu(~biberu@user/biberu) (Ping timeout: 252 seconds)
2021-09-07 16:08:10 +0200biberu\biberu
2021-09-07 16:08:20 +0200alp(~alp@mail.fmap.fr)
2021-09-07 16:09:03 +0200alp(~alp@mail.fmap.fr) (Changing host)
2021-09-07 16:09:03 +0200alp(~alp@user/alp)
2021-09-07 16:10:04 +0200 <dminuoso> lechner: Newtypes are barriers that increase the robustness of your program.
2021-09-07 16:10:17 +0200Dima[m](~reddima10@2001:470:69fc:105::366) ()
2021-09-07 16:10:30 +0200 <dminuoso> Consider you have some function that returns a temperature in degrees celsius, and some function that deposits money onto an account
2021-09-07 16:10:36 +0200 <lechner> i get that, but how can the same label appear on both sides?
2021-09-07 16:10:45 +0200 <dminuoso> If we used Int for both, you could accidentally pass a temperature into the latter function.
2021-09-07 16:10:47 +0200 <dminuoso> Oh
2021-09-07 16:10:50 +0200 <dminuoso> Different namespaces
2021-09-07 16:10:56 +0200 <dminuoso> Types and values live in different namespaces
2021-09-07 16:11:01 +0200 <dminuoso> So they are completely non-ambiguous
2021-09-07 16:11:08 +0200 <maerwald> dminuoso: aren't they poor mans liquid types?
2021-09-07 16:11:09 +0200guibou(~guibou@mail.fmap.fr)
2021-09-07 16:12:33 +0200 <lechner> so in newtype Red = Red Int both "Int" and the first "Red" are types, right?
2021-09-07 16:12:49 +0200 <[exa]> lechner: the first Red is in a language of types, the second Red is in a language of values. You use `x :: Red` to say something has a type (notice: behind :: and with no parameters)
2021-09-07 16:12:58 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-07 16:12:59 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 16:13:12 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 16:13:27 +0200 <[exa]> ...and `Red 1` to make a value of Red type (here, actually, you may view the constructor as a function `Red :: Int -> Red`)
2021-09-07 16:14:24 +0200 <[exa]> so as dminuoso said -- stuff before and after :: is from a completely different language
2021-09-07 16:15:00 +0200 <lechner> i get that too, but i don't understand how the the value (the second "Red") can appear next to a type (the "Int") without anyone being confused about name spaces
2021-09-07 16:15:09 +0200 <[exa]> the only place you mix these now is when specifying the types in the data structure, where you write `Red Int` -- that's a special syntax, kinda mixed language.
2021-09-07 16:15:20 +0200 <[exa]> ah yes you just asked. :]
2021-09-07 16:15:42 +0200 <lechner> how does the compiler know?
2021-09-07 16:15:47 +0200 <[exa]> in fact, if you enable generalized algebraic datatypes, you would write this as `red :: Int -> Red`
2021-09-07 16:16:10 +0200 <[exa]> and the compiler doesn't really "know"-- it's syntax driven. first thing after the `=` is the data constructor, and that's it
2021-09-07 16:16:34 +0200dsrt^(~dsrt@68.101.54.227) (Remote host closed the connection)
2021-09-07 16:16:53 +0200 <[exa]> the pattern is roughly:
2021-09-07 16:17:21 +0200 <[exa]> data Type = Datacons Type Type | Datacons Type Type Type | ...
2021-09-07 16:18:56 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd)
2021-09-07 16:21:02 +0200ubert(~Thunderbi@91.141.65.123.wireless.dyn.drei.com)
2021-09-07 16:23:19 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 16:23:33 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 16:23:37 +0200 <dminuoso> Clint: the language is very dense, yes.
2021-09-07 16:23:41 +0200 <dminuoso> Err lechner
2021-09-07 16:23:52 +0200 <lechner> i'm getting there
2021-09-07 16:23:55 +0200 <dminuoso> lechner: the compiler knows this because we have grammar production rules for it.
2021-09-07 16:24:07 +0200 <dminuoso> However
2021-09-07 16:24:11 +0200 <dminuoso> For learning, you can enable GADTSyntax
2021-09-07 16:24:15 +0200 <dminuoso> Which allows you to write:
2021-09-07 16:24:33 +0200favonia(~favonia@user/favonia)
2021-09-07 16:24:36 +0200 <dminuoso> `data Foo where Con :: Int -> String -> Foo` rather than `data Foo = Con Int String`
2021-09-07 16:24:45 +0200maxime_(~maxime@2a01cb0883359800de1604fd61332a1a.ipv6.abo.wanadoo.fr)
2021-09-07 16:24:46 +0200 <dminuoso> Which is less terse, but more readable
2021-09-07 16:25:33 +0200gentauro(~gentauro@user/gentauro) (Read error: Connection reset by peer)
2021-09-07 16:25:47 +0200 <lechner> in this example https://stackoverflow.com/a/51549110 does the value constructor Person (but not the type Person) appear anywhere except in (Person id name) ?
2021-09-07 16:26:41 +0200 <dminuoso> Nope
2021-09-07 16:27:24 +0200 <dminuoso> Some people also tend to prefix data constructors with Mk, so you might write `data Person = MkPerson Int String`, giving a visual clue of whats a type constructor and whats a data constructor.
2021-09-07 16:27:38 +0200 <dminuoso> Not very common, but you see it from time to time
2021-09-07 16:27:40 +0200max22-(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr) (Ping timeout: 260 seconds)
2021-09-07 16:27:56 +0200 <dminuoso> Especially in examples or learning material
2021-09-07 16:28:25 +0200 <lechner> i think i get it now. in essence, the reuse that i find so confusing is actually meant to synchronize the two name spaces
2021-09-07 16:28:27 +0200Kevin578(~Kevin578@pool-96-237-112-198.bstnma.fios.verizon.net) (Remote host closed the connection)
2021-09-07 16:28:39 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 16:28:50 +0200 <janus> might as well get used to avoiding punning if we're getting dependent types...
2021-09-07 16:28:52 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 16:29:09 +0200vicfred(~vicfred@user/vicfred)
2021-09-07 16:29:11 +0200vicfred(~vicfred@user/vicfred) (Client Quit)
2021-09-07 16:30:15 +0200 <lechner> will that mix the name spaces?
2021-09-07 16:30:38 +0200gentauro(~gentauro@user/gentauro)
2021-09-07 16:31:47 +0200 <janus> lechner: yes
2021-09-07 16:32:02 +0200 <lechner> you will have a revolution
2021-09-07 16:33:16 +0200 <lortabac> lechner: if you are a beginner I'd suggest you to consider values and types as separate things and not worry about the namespace problem
2021-09-07 16:34:13 +0200slack1256(~slack1256@12.0.89.245)
2021-09-07 16:34:42 +0200dajoer(~david@user/gvx) (Quit: leaving)
2021-09-07 16:34:47 +0200 <lortabac> that's a problem that only arises when you enable the DataKinds extension
2021-09-07 16:35:13 +0200 <lortabac> or maybe in the future if one day there is a DependentHaskell extension
2021-09-07 16:35:32 +0200 <lechner> https://int-index.com/posts/haskell-punning
2021-09-07 16:37:04 +0200favonia(~favonia@user/favonia) (Ping timeout: 265 seconds)
2021-09-07 16:38:44 +0200 <EvanR> List a, Pair a b... dunno
2021-09-07 16:39:14 +0200Akronymus(~Akronymus@85.31.8.180) (Quit: Client closed)
2021-09-07 16:39:49 +0200 <EvanR> too bad you just use different colors in the code itself
2021-09-07 16:39:55 +0200 <EvanR> you can't*
2021-09-07 16:41:00 +0200john2312(~user@114.250.137.142)
2021-09-07 16:41:17 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2021-09-07 16:42:16 +0200leplep-
2021-09-07 16:43:21 +0200 <lortabac> someone should come up with a color-sensitive language :D
2021-09-07 16:43:36 +0200kmein(~weechat@user/kmein) (Quit: ciao kakao)
2021-09-07 16:44:14 +0200kmein(~weechat@user/kmein)
2021-09-07 16:44:32 +0200 <janus> lortabac: we have something even better, a language without syntax: http://www.lamdu.org/
2021-09-07 16:44:57 +0200myShoggoth(~myShoggot@97-120-70-214.ptld.qwest.net)
2021-09-07 16:45:41 +0200stefan-_(~cri@42dots.de) (Ping timeout: 252 seconds)
2021-09-07 16:46:15 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de) (Ping timeout: 265 seconds)
2021-09-07 16:48:12 +0200bontaq(~user@ool-45779fe5.dyn.optonline.net) (Remote host closed the connection)
2021-09-07 16:49:08 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de)
2021-09-07 16:49:36 +0200stefan-_(~cri@42dots.de)
2021-09-07 16:51:00 +0200chomwitt(~chomwitt@2a02:587:dc02:7900:12c3:7bff:fe6d:d374) (Ping timeout: 260 seconds)
2021-09-07 16:53:31 +0200asthasr(~asthasr@162.210.28.151)
2021-09-07 16:54:05 +0200Ariakenom(~patrik@h-81-170-208-30.A163.corp.bahnhof.se) (Quit: WeeChat 3.1)
2021-09-07 16:56:39 +0200 <geekosaur> lortabac, does piet not count?
2021-09-07 16:57:05 +0200shapr(~user@pool-100-36-247-68.washdc.fios.verizon.net)
2021-09-07 16:57:36 +0200 <lortabac> geekosaur: nice :) I didn't know this language
2021-09-07 16:58:03 +0200adanwan(~adanwan@gateway/tor-sasl/adanwan) (Ping timeout: 276 seconds)
2021-09-07 16:58:43 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14)
2021-09-07 16:58:53 +0200hnOsmium0001(uid453710@id-453710.stonehaven.irccloud.com)
2021-09-07 16:59:25 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Quit: Leaving)
2021-09-07 16:59:28 +0200neo(~neo3@cpe-292712.ip.primehome.com)
2021-09-07 16:59:50 +0200 <merijn> lortabac: eh
2021-09-07 16:59:51 +0200neoGuest1732
2021-09-07 16:59:55 +0200 <merijn> lortabac: Color-sensitive already exists
2021-09-07 17:00:20 +0200 <merijn> lortabac: https://en.wikipedia.org/wiki/ColorForth
2021-09-07 17:01:34 +0200 <lortabac> when you think you had a crazy idea, there is always someone crazier than you who has even implemented it
2021-09-07 17:03:19 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14) (Ping timeout: 252 seconds)
2021-09-07 17:07:44 +0200ub(~Thunderbi@178.165.164.206.wireless.dyn.drei.com)
2021-09-07 17:07:48 +0200ubert1(~Thunderbi@178.165.164.206.wireless.dyn.drei.com)
2021-09-07 17:07:53 +0200 <dminuoso> 16:28:50 janus | might as well get used to avoiding punning if we're getting dependent types...
2021-09-07 17:08:09 +0200Guest1732neo
2021-09-07 17:08:09 +0200 <dminuoso> Yup, in hindsight having separate namespaces was a poor idea.
2021-09-07 17:08:26 +0200 <dminuoso> Same thing for operators not needing ' anymore. :(
2021-09-07 17:08:38 +0200neoGuest9247
2021-09-07 17:09:09 +0200 <pavonia> How would you enter differently colored text?
2021-09-07 17:09:22 +0200ubert(~Thunderbi@91.141.65.123.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-07 17:09:22 +0200ubert1ubert
2021-09-07 17:09:32 +0200 <geekosaur> editors would have shortcuts for it
2021-09-07 17:09:50 +0200 <geekosaur> much the same way various IRC clients have shortcuts for entering colors
2021-09-07 17:11:41 +0200 <geekosaur> (which I alays have to look up or use the riught click menu for, because I never remember them :)
2021-09-07 17:13:54 +0200 <pavonia> Seems to me the tiny compiling speedup comes with a huge editing slowdown
2021-09-07 17:15:00 +0200 <geekosaur> same could be said of unicode operators
2021-09-07 17:15:17 +0200 <geekosaur> yet e.g. agda uses them
2021-09-07 17:15:53 +0200 <pavonia> Well, who uses Agda anyway? :p
2021-09-07 17:17:49 +0200vysn(~vysn@user/vysn) (Quit: WeeChat 3.2)
2021-09-07 17:18:07 +0200vysn(~vysn@user/vysn)
2021-09-07 17:18:30 +0200 <kuribas> does anyone write practical programs in idris/agda/coq/lean/... ?
2021-09-07 17:18:42 +0200 <kuribas> anything other than a proof?
2021-09-07 17:20:19 +0200cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.2)
2021-09-07 17:20:24 +0200lep-lep
2021-09-07 17:20:55 +0200vysn(~vysn@user/vysn) (Client Quit)
2021-09-07 17:21:12 +0200vysn(~vysn@user/vysn)
2021-09-07 17:21:53 +0200 <kuribas> I suppose haskell is the most "advanced" among practical languages.
2021-09-07 17:22:06 +0200 <[exa]> kuribas: y tho
2021-09-07 17:22:28 +0200 <[exa]> there is some software that is verified using coq programs, which I'd say is practical programming
2021-09-07 17:22:39 +0200 <[exa]> either a compiler or an operating system or something
2021-09-07 17:22:41 +0200 <kuribas> [exa]: it compiles to haskell?
2021-09-07 17:23:25 +0200 <[exa]> L4 microkernel was verified by something too, I guess it was isabelle/hol?
2021-09-07 17:24:25 +0200 <kuribas> what language was it written in?
2021-09-07 17:24:51 +0200 <kuribas> Do they prove it in isabelle/hol, then implement the algorithm in another language?
2021-09-07 17:25:07 +0200vysn(~vysn@user/vysn) (Client Quit)
2021-09-07 17:25:13 +0200 <[exa]> it's written in C and then verified in isabelle afaik
2021-09-07 17:25:21 +0200 <[exa]> there's some magicks around there too
2021-09-07 17:25:24 +0200vysn(~vysn@user/vysn)
2021-09-07 17:25:42 +0200 <[exa]> like, what's wrong with a specialized language for writing tests? :D
2021-09-07 17:26:14 +0200 <[exa]> wow, wiki: The proof is constructed and checked in Isabelle/HOL and comprises over 200,000 lines of proof script to verify 7,500 lines of C.
2021-09-07 17:26:20 +0200vysn(~vysn@user/vysn) (Client Quit)
2021-09-07 17:26:34 +0200 <kuribas> wow
2021-09-07 17:26:37 +0200vysn(~vysn@user/vysn)
2021-09-07 17:27:10 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:9b50:ae6e:a049:784) (Ping timeout: 260 seconds)
2021-09-07 17:27:11 +0200 <[exa]> that's some testing
2021-09-07 17:28:36 +0200libertyprime(~libertypr@118.149.78.102)
2021-09-07 17:28:58 +0200 <libertyprime> hi haskell people. please make one of these!
2021-09-07 17:29:03 +0200 <libertyprime> https://semiosis.github.io/ilambda/
2021-09-07 17:30:16 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14)
2021-09-07 17:31:07 +0200 <[exa]> libertyprime: the code samples there need more comments I'd say
2021-09-07 17:33:18 +0200 <libertyprime> sorry ive been in a real rush with trying to make tooling for openai's codex/gpt3. i am outsourcing to you guys because i know its important
2021-09-07 17:33:42 +0200 <[exa]> no worries
2021-09-07 17:34:05 +0200 <[exa]> the languages that don't "return" stuff are not covered by the paradigm?
2021-09-07 17:34:41 +0200chomwitt(~chomwitt@ppp-94-67-192-178.home.otenet.gr)
2021-09-07 17:35:00 +0200burnsidesLlama(~burnsides@dhcp168-020.wadham.ox.ac.uk) (Remote host closed the connection)
2021-09-07 17:37:14 +0200 <libertyprime> http://semiosis.github.io/posts/imaginary-chimera-languages-with-codex/
2021-09-07 17:37:44 +0200 <libertyprime> codex is a LM which is a representation of all languages in a large vector space
2021-09-07 17:38:04 +0200 <libertyprime> it's probabilistic. the imaginary dimensions allow you to translate, do code gen and make these chimeric languages
2021-09-07 17:38:50 +0200 <libertyprime> but the real value, i think is in keeping your peas and carrots separate, which haskell is good at
2021-09-07 17:39:18 +0200 <libertyprime> a proper interop instead of a pure imaginary ghci , an ilambda library
2021-09-07 17:40:51 +0200 <monochrom> "the program was written in C, the verification was written in Coq" sounds like "Coq is a practical proof language" to me. proof ≠ program.
2021-09-07 17:41:03 +0200 <monochrom> Unpopular opinion: proof ≠ program.
2021-09-07 17:41:27 +0200 <[exa]> monochrom: thats just unpopular :(
2021-09-07 17:41:40 +0200 <monochrom> program is what you actually run.
2021-09-07 17:41:53 +0200 <monochrom> If you don't run your proof, it is not a program.
2021-09-07 17:42:02 +0200 <[exa]> libertyprime: I'm a bit lost. does it have any explanation in already known terms? (without LM and "probabilistic language" etc)
2021-09-07 17:42:31 +0200 <monochrom> I am a formal methods person, I value proofs. All the more reason to acknowledge the difference.
2021-09-07 17:42:32 +0200 <[exa]> monochrom: b...b.but...curry&howard :'(
2021-09-07 17:43:02 +0200 <libertyprime> [exa]: there are some very dense academic papers you can read on prompt engineering and GPT
2021-09-07 17:43:17 +0200 <libertyprime> but IP is very very new
2021-09-07 17:43:27 +0200 <[exa]> link?
2021-09-07 17:43:27 +0200 <monochrom> My personal experience with the ergonomics of writing programs and the ergonomics of writing proof is that they have very different ergonomics.
2021-09-07 17:44:11 +0200 <libertyprime> https://arxiv.org/abs/2107.13586
2021-09-07 17:44:17 +0200 <libertyprime> This is a recent survey on prompting
2021-09-07 17:44:26 +0200bitmapper(uid464869@id-464869.lymington.irccloud.com)
2021-09-07 17:44:37 +0200 <libertyprime> a prompt links a function to a language model
2021-09-07 17:44:58 +0200 <janus> what does it even mean to 'run' a program? if the program contains a value that type that witnesses the poincare conjecture, what would running it do?
2021-09-07 17:45:25 +0200 <monochrom> That experience is consistent with how Coq, Agda, ATS didn't quite catch on as programming languages, and how Haskell, Idris didn't quite catch on as proof languages.
2021-09-07 17:45:27 +0200 <janus> is that why you object to proof=program?
2021-09-07 17:45:49 +0200 <janus> ok
2021-09-07 17:46:01 +0200 <libertyprime> janus: are you eleutherai janus?
2021-09-07 17:46:04 +0200 <monochrom> janus, do you run your OS? do you run your webapp?
2021-09-07 17:46:42 +0200 <janus> if we say that 'running' includes type checking, then surely 'running' a program that contains interesting types does tell you something about what is true
2021-09-07 17:46:43 +0200 <monochrom> What would running your OS do, under your logic?
2021-09-07 17:46:50 +0200lavaman(~lavaman@98.38.249.169)
2021-09-07 17:46:52 +0200Guest9247(~neo3@cpe-292712.ip.primehome.com) (Quit: Leaving)
2021-09-07 17:47:03 +0200 <janus> libertyprime: i don't know what eleutherai is, so i don't know if it is me
2021-09-07 17:47:13 +0200neo1(~neo3@cpe-292712.ip.primehome.com)
2021-09-07 17:47:22 +0200 <libertyprime> [exa]: you wont find anything on IP. but im doing a presentation on it in a month
2021-09-07 17:47:26 +0200 <libertyprime> https://semiosis.github.io/posts/emacsconf-2021-imaginary-programming/
2021-09-07 17:47:50 +0200 <libertyprime> github copilot is an example of it. except its a very very simplistic example of IP
2021-09-07 17:48:04 +0200 <janus> monochrom: well, i thought i was arguing that 'running' isn't really clearly defined. so i don't know if i can say that i am running anything at all :P
2021-09-07 17:48:45 +0200 <janus> maybe it just means electricity is turned to heat? then type checking would also be 'running' :P
2021-09-07 17:50:20 +0200 <janus> it seems like an analogue to 'life'. not clearly defined but still commonly accepted as a term, even by scientists
2021-09-07 17:50:48 +0200 <monochrom> OK, for starters, you are ignoring the fact that 99.999% of the time, the "value" is a function. Perhaps a function that maps a list to its sum. Now I'm going to use that function, give it [3,1,4], and hope to get some answer.
2021-09-07 17:51:01 +0200MQ-17J(~MQ-17J@35.50.7.10) (Ping timeout: 265 seconds)
2021-09-07 17:51:10 +0200landonf(landonf@mac68k.info) (Ping timeout: 240 seconds)
2021-09-07 17:51:21 +0200 <[exa]> libertyprime: well, good luck. :]
2021-09-07 17:51:34 +0200 <monochrom> Your proof did not witness that 8 exists. Your proof witnessed that a function that maps [3,1,4] to 8, [1,4] to 5, etc., exists.
2021-09-07 17:52:07 +0200 <monochrom> But I'm going to use that function, with a parameter that is drawn from an infinite space.
2021-09-07 17:52:09 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14) (Remote host closed the connection)
2021-09-07 17:52:18 +0200 <libertyprime> [exa] thanks. gpt4 is coming out very soon. its important to have a haskell library
2021-09-07 17:52:33 +0200 <libertyprime> i mean, i can make something really lame with my noob haskell skills
2021-09-07 17:52:33 +0200 <monochrom> And this is only the most basic use case.
2021-09-07 17:53:27 +0200 <monochrom> In reality, the "value" is even more interesting than a function. It is an interactive automaton, such as an OS, a webapp, a stdio application, a unix pipe, ...
2021-09-07 17:53:40 +0200 <libertyprime> but please u are welcome to attempt to build yourself. could probably get a codex key if you say you want to work on an ilambda implementation foor the benefit of humanity or something
2021-09-07 17:53:45 +0200 <[exa]> libertyprime: haskell isn't the usual working ground for linguists honestly
2021-09-07 17:54:04 +0200 <libertyprime> [exa] this is nothing to do with linguistics really, it isnt
2021-09-07 17:54:18 +0200 <monochrom> There is indeed the remaining 0.001% of the time when the "value" is just a natural number. That's called Project Euler.
2021-09-07 17:54:29 +0200danasca(~dana@77.227.165.152)
2021-09-07 17:54:37 +0200 <monochrom> Unpopular opinion: Project Euler is not programming either.
2021-09-07 17:54:42 +0200maxime_(~maxime@2a01cb0883359800de1604fd61332a1a.ipv6.abo.wanadoo.fr) (Remote host closed the connection)
2021-09-07 17:55:14 +0200MQ-17J(~MQ-17J@2607:fb90:46:a8a6:384f:d5fd:c3eb:fa6f)
2021-09-07 17:55:19 +0200 <c_wraith> is that unpopular?
2021-09-07 17:55:22 +0200 <[exa]> monochrom: +1, euler is puzzles
2021-09-07 17:55:31 +0200max22-(~maxime@2a01cb088335980060aa426106dec0f1.ipv6.abo.wanadoo.fr)
2021-09-07 17:55:39 +0200 <c_wraith> I thought anyone who read over any of their problems past #10 or so knew that it was a math test.
2021-09-07 17:55:50 +0200 <monochrom> So if you want to pitch "the value exists, it's proven, what's there to run?", pitch it to people who use PE to "learn coding" and tell them there is nothing to run when they ask "but why is my code so slow?"
2021-09-07 17:55:50 +0200favonia(~favonia@user/favonia)
2021-09-07 17:56:21 +0200Vajb(~Vajb@hag-jnsbng11-58c3ab-85.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-09-07 17:57:35 +0200 <[exa]> monochrom: it might be interesting for teaching the phds in number theory and algebra to code[4~
2021-09-07 17:58:01 +0200 <janus> i think maybe i know what you're saying. is it that type checking is just part of a compilation/running pipeline and it makes little sense to run only part of it?
2021-09-07 17:58:20 +0200lbseale(~lbseale@user/ep1ctetus)
2021-09-07 17:58:24 +0200 <janus> if instead of types, i had a program that generated my program, and i claimed it would be sufficient to only run the first, that would make little sense
2021-09-07 17:59:05 +0200 <janus> so is the argument that type checking is not sufficient because the type commonly is not exact enough to prove the statement? like you mention that the type only witnesses that the mapping exists
2021-09-07 17:59:41 +0200maxime_(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr)
2021-09-07 18:00:12 +0200tddschn(~textual@45.77.71.205) (Ping timeout: 265 seconds)
2021-09-07 18:00:28 +0200 <janus> but i don't know if i claimed otherwise. i agree that it makes no difference if you spend the time running a type checker or a runtime system
2021-09-07 18:01:04 +0200 <monochrom> You are running your IRC client. What is it proving? What is it checking?
2021-09-07 18:01:21 +0200 <monochrom> Proving that you exist?
2021-09-07 18:01:41 +0200 <monochrom> Proving that someone else on the Internet also exists?
2021-09-07 18:02:07 +0200 <janus> i don't know how to use the word 'proving' about interactions with the internet, so i don't know if those statements make sense to me
2021-09-07 18:02:29 +0200 <monochrom> How do you explain how the PL research community has two words, "static" and "dynamic"?
2021-09-07 18:02:45 +0200max22-(~maxime@2a01cb088335980060aa426106dec0f1.ipv6.abo.wanadoo.fr) (Ping timeout: 260 seconds)
2021-09-07 18:02:50 +0200 <monochrom> How do you explain how they have a "static semantics" and then a "dynamic semantics"?
2021-09-07 18:03:23 +0200 <monochrom> Stop weaseling out with "I don't know".
2021-09-07 18:04:01 +0200 <monochrom> Either you confirm "I don't know, I withdraw everything I said", or "I know, here is the justification of what I said".
2021-09-07 18:05:16 +0200 <janus> i can't withdraw without understanding why i am wrong. and i can't justify without understanding exactly what needs justification
2021-09-07 18:05:36 +0200 <monochrom> Alternatively if you assert "the OS is not a program, the IRC client is not a program, the web browser is not a program, none of those are being run", I'm also OK with that.
2021-09-07 18:06:12 +0200 <Hecate> monochrom: dynamic semantics is when the behaviour of your programme is created from something during runtime, and you cannot infer what it could possibly do before you run it :D
2021-09-07 18:06:29 +0200 <Hecate> like, a TCP-connected lisp interpreter
2021-09-07 18:06:33 +0200 <Hecate> opened to the Internet
2021-09-07 18:06:34 +0200 <janus> right, i previously stated that 'running' is not well defined to me. why should i make assertions that use ill-defined terms?
2021-09-07 18:06:51 +0200 <monochrom> But you did.
2021-09-07 18:06:51 +0200aliosablack(~chomwitt@2a02:587:dc02:7900:12c3:7bff:fe6d:d374)
2021-09-07 18:07:07 +0200 <Hecate> sounds like a "you" problem, the majority of people have no trouble understanding what "running" a programme means
2021-09-07 18:07:22 +0200 <Hecate> and if I'm not mistaken that is usually the first thing you do after writing your first programme
2021-09-07 18:07:46 +0200libertyprime(~libertypr@118.149.78.102) (Quit: leaving)
2021-09-07 18:07:54 +0200chomwitt(~chomwitt@ppp-94-67-192-178.home.otenet.gr) (Read error: Connection reset by peer)
2021-09-07 18:07:56 +0200favonia(~favonia@user/favonia) (Ping timeout: 265 seconds)
2021-09-07 18:08:26 +0200burnsidesLlama(~burnsides@dhcp168-020.wadham.ox.ac.uk)
2021-09-07 18:08:32 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2021-09-07 18:08:36 +0200 <janus> Hecate: the majority of people have no trouble using ill-defined terms like e.g. 'life', your appeal to the majority cannot sway me
2021-09-07 18:08:52 +0200 <monochrom> Alternatively squared you can assert "the OS is not a program, the IRC client is not a program, the web browser is not a program, none of those are proving/checking anything"
2021-09-07 18:09:07 +0200 <Hecate> janus: again, still sounds like a "you" problem, I have no trouble sleeping at night
2021-09-07 18:09:22 +0200 <janus> Hecate: i have not made any statements about your sleep quality
2021-09-07 18:09:24 +0200econo(uid147250@user/econo)
2021-09-07 18:09:40 +0200 <Hecate> janus: no but you sound like someone who would lose sleep over the definition of the term "sleep" :P
2021-09-07 18:09:40 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14)
2021-09-07 18:09:48 +0200 <monochrom> And you did make assertions about proofs and checks, so don't tell me now you suddenly don't know what proving and checking mean.
2021-09-07 18:09:52 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-09-07 18:10:18 +0200tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2021-09-07 18:10:45 +0200arjun_(~Srain@user/arjun)
2021-09-07 18:10:47 +0200favonia(~favonia@user/favonia)
2021-09-07 18:11:36 +0200 <lechner> I'm having a Magritte moment "Ceci n'est pas une pipe"
2021-09-07 18:12:30 +0200 <monochrom> That's the dual meme to "is this a pigeon?" :)
2021-09-07 18:12:32 +0200 <janus> monochrom: if we accept proofs==programs, we can go either way, either we claim that a web browser is a really bad proof, or we claim that it is no program. or we can reject proofs==programs like you do.
2021-09-07 18:13:16 +0200 <monochrom> "bad" is ill-defined.
2021-09-07 18:13:28 +0200 <monochrom> and "really bad" is really ill-defined.
2021-09-07 18:13:42 +0200 <janus> of course it is subjective, you can ignore it if you like
2021-09-07 18:13:44 +0200arjun(~Srain@user/arjun) (Ping timeout: 265 seconds)
2021-09-07 18:13:45 +0200arjun_arjun
2021-09-07 18:14:01 +0200 <monochrom> And be it recorded that I was not the one who brought up "bad". I only brought up programs, proofs, and web browsers.
2021-09-07 18:14:04 +0200 <monochrom> and running.
2021-09-07 18:14:13 +0200burnsidesLlama(~burnsides@dhcp168-020.wadham.ox.ac.uk) (Ping timeout: 265 seconds)
2021-09-07 18:14:15 +0200pzanco(~pzanco@2804:14c:3ba1:42d:2204:fff:feff:44a0)
2021-09-07 18:14:27 +0200 <lechner> "the quote ... is widely used to express utter confusion" https://knowyourmeme.com/memes/is-this-a-pigeon
2021-09-07 18:14:29 +0200 <janus> is it a bigger sin to use 'bad' than use 'proof'? they are both subjective
2021-09-07 18:14:51 +0200 <monochrom> No I'm just saying if I took up that bait, 10 minutes down the road you would be weaseling out with "'bad" is ill-defined".
2021-09-07 18:15:40 +0200 <lechner> maybe a poem about it would shed more light on the truth
2021-09-07 18:15:50 +0200 <dminuoso> 17:21:53 kuribas | I suppose haskell is the most "advanced" among practical languages.
2021-09-07 18:15:54 +0200 <dminuoso> Depends on what you mean by advanced.
2021-09-07 18:16:38 +0200 <dminuoso> If by "advanced" you mean complicated, C or C++ win by a large margin. Or even Python in terms of having to be very talented in order to write or manage non-trivial code.
2021-09-07 18:16:39 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 18:16:59 +0200 <Hecate> I think it stopped being "the most advanced" with Koka and its effect handlers
2021-09-07 18:17:25 +0200 <kuribas> dminuoso: I was thinking more in an "academic" sense.
2021-09-07 18:17:51 +0200 <dminuoso> Mmm, hard to say.
2021-09-07 18:17:51 +0200 <Hecate> kuribas: from an Academic perspective, OCaml and Haskell are basically at the same level
2021-09-07 18:18:02 +0200 <dminuoso> Haskell in the sense of Haskell2010 is rather simple.
2021-09-07 18:18:14 +0200 <dminuoso> Much of the complicated parts are in the libraries, not the language.
2021-09-07 18:18:44 +0200 <dminuoso> Rust with borrow checking is also not trivial
2021-09-07 18:18:46 +0200 <kuribas> dminuoso: sure, but does anyone actually programin in haskell2010?
2021-09-07 18:19:05 +0200 <monochrom> I sometimes do.
2021-09-07 18:19:11 +0200 <kuribas> dminuoso: true, I didn't consider rust, which is getting pretty popular.
2021-09-07 18:19:19 +0200 <monochrom> At least it's better than Haskell98.
2021-09-07 18:19:43 +0200 <kuribas> does Haskell2010 have multiparam typeclasses?
2021-09-07 18:19:47 +0200 <monochrom> No.
2021-09-07 18:20:34 +0200 <monochrom> But it has pattern guards. :)
2021-09-07 18:20:51 +0200 <Hecate> kuribas: no you need to enable it in GHC, IIRC
2021-09-07 18:21:21 +0200 <dminuoso> Hecate: That's just GHC being weird.
2021-09-07 18:21:32 +0200 <monochrom> When I step outside of Haskell2010, usually it is only because of scoped type variables and exceptions.
2021-09-07 18:21:38 +0200 <dminuoso> And hold on, you dont need to enable pattern guards.
2021-09-07 18:21:40 +0200 <dminuoso> Im very sure
2021-09-07 18:21:48 +0200 <kuribas> monochrom: no multiparam typeclasses?
2021-09-07 18:21:52 +0200 <monochrom> No.
2021-09-07 18:21:53 +0200 <kuribas> monochrom: no generics?
2021-09-07 18:21:54 +0200 <dminuoso> I regularly use them, and I never had to flip on an extension for it.
2021-09-07 18:21:57 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-09-07 18:21:57 +0200 <monochrom> No.
2021-09-07 18:22:17 +0200 <Hecate> dminuoso: I don't understand your point
2021-09-07 18:22:24 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 18:22:44 +0200 <dminuoso> Hecate: Sorry, I got the lines mixed up - caused some confusion.
2021-09-07 18:22:48 +0200 <Hecate> ok no worries
2021-09-07 18:22:50 +0200maxime_(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr) (Quit: Leaving)
2021-09-07 18:23:13 +0200chisui(~chisui@200116b868697b00c8225f803a065f0d.dip.versatel-1u1.de) (Quit: Client closed)
2021-09-07 18:23:19 +0200 <Hecate> dminuoso: I become extremely defensive when people say "oh that's just implementation-specific" when there is only one implementation which is used everywhere :P
2021-09-07 18:23:59 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 18:24:12 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 18:24:45 +0200 <monochrom> Yeah I don't draw that line in all contexts. Only in some contexts when it's reasonable to.
2021-09-07 18:25:42 +0200 <monochrom> A lot of times, to a lot of people who are interested in getting things done, names like "Haskell", "C", "Python" mean what programmers actually do, not what the defining documents say.
2021-09-07 18:26:31 +0200Vajb(~Vajb@hag-jnsbng11-58c3ab-85.dhcp.inet.fi)
2021-09-07 18:27:30 +0200 <kuribas> monochrom: then you never use Vector?
2021-09-07 18:27:41 +0200 <kuribas> as it uses type-families, etc...
2021-09-07 18:27:45 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-09-07 18:28:22 +0200 <Hecate> especially since we said "fuck you" to the definition quite some time ago for Haskell, that C is mostly implementation-specific so the standard isn't worth more than your compiler…
2021-09-07 18:28:33 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 18:28:40 +0200 <kuribas> does having a standard even matter for haskell?
2021-09-07 18:28:41 +0200 <Hecate> Python I can respect the fact that PyPy is an absolute unit when it comes to performance
2021-09-07 18:28:57 +0200 <kuribas> for Python it actually would matter :)
2021-09-07 18:31:09 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Quit: Leaving)
2021-09-07 18:32:33 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-07 18:34:15 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-09-07 18:34:41 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 18:37:45 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2021-09-07 18:38:00 +0200Erutuon(~Erutuon@user/erutuon)
2021-09-07 18:38:19 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-09-07 18:38:44 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-07 18:39:32 +0200 <maerwald> standard matters for any language
2021-09-07 18:40:05 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-07 18:40:16 +0200 <maerwald> unless you have a C++ workflow
2021-09-07 18:40:21 +0200 <maerwald> then it really makes no difference
2021-09-07 18:40:21 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 18:40:33 +0200 <maerwald> the idea is that a language shouldn't grow randomly
2021-09-07 18:40:56 +0200 <maerwald> a standard is likely to enforce some discipline there
2021-09-07 18:41:19 +0200max22-(~maxime@2a01cb0883359800554e78e897c895d5.ipv6.abo.wanadoo.fr)
2021-09-07 18:41:24 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-09-07 18:42:58 +0200 <c_wraith> agh. I just figured out what problem I'm having.
2021-09-07 18:43:02 +0200 <c_wraith> :t callCC
2021-09-07 18:43:04 +0200 <lambdabot> MonadCont m => ((a -> m b) -> m a) -> m a
2021-09-07 18:43:10 +0200 <c_wraith> that's not polymorphic enough! :(
2021-09-07 18:43:35 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-07 18:44:12 +0200 <c_wraith> I want to choose b independently at each use of the function provided
2021-09-07 18:45:37 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-07 18:46:25 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 18:46:57 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-09-07 18:47:00 +0200 <c_wraith> well. When I have time, that's something to experiment on with quick look impredicativity.
2021-09-07 18:47:16 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-07 18:47:22 +0200 <c_wraith> ... nevermind, that just needs a higher-rank type. Not impredicativity
2021-09-07 18:48:54 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Excess Flood)
2021-09-07 18:48:55 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.2.1)
2021-09-07 18:49:14 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-07 18:51:55 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-09-07 18:52:29 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 18:52:44 +0200john2312(~user@114.250.137.142) (Ping timeout: 252 seconds)
2021-09-07 18:53:51 +0200 <awpr> seems to me you can make the more polymorphic version out of the standard one -- callCC (\k -> absurd <$> k _something), or factor that (fmap absurd . k) into a let-binding, or even wrap callCC with type ((forall b. a -> m b) -> m a) -> m a
2021-09-07 18:53:52 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-09-07 18:54:14 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-07 18:56:34 +0200 <monochrom> kuribas: Heh right, I sometimes use vector. But not very often.
2021-09-07 18:57:01 +0200 <awpr> c_wraith: it does seem like a worthwhile convenience for callCC to have, though. I wonder if there's a way for transformers/mtl to add this without interfering with Haskell98 support, e.g. CPP that only enables it on (non-ancient) GHC
2021-09-07 18:57:41 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-07 18:57:58 +0200 <c_wraith> it's not like mtl and transformers try to work on non-ghc these days
2021-09-07 18:58:02 +0200 <monochrom> c_wraith: Congrats on discovering the truth :)
2021-09-07 18:58:32 +0200 <dminuoso> c_wraith: :s/mtl and transformers/anything on hackage/
2021-09-07 18:58:34 +0200 <awpr> yeah I was just poking around at the metadata to figure that out. maybe there's no obstacle to it
2021-09-07 18:58:39 +0200 <c_wraith> I wonder if that'd be a breaking change.
2021-09-07 18:58:41 +0200 <monochrom> The nice thing is that you only need to fix the type sig. The function body is the same.
2021-09-07 18:58:43 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 18:59:00 +0200 <c_wraith> like, if the type change would break any code anywhere relying on it for inference.
2021-09-07 18:59:19 +0200 <monochrom> Yeah it may be a breaking change.
2021-09-07 18:59:33 +0200 <awpr> I suppose it would break instances of using TypeApplications on callCC
2021-09-07 18:59:59 +0200 <monochrom> I think adding a second name is safer than changing the type on the original name.
2021-09-07 19:00:02 +0200 <c_wraith> oh, right. that too.
2021-09-07 19:00:32 +0200 <monochrom> I don't think realistically callCC has been or will be used with type application. :)
2021-09-07 19:00:58 +0200 <c_wraith> you're right, but it feels like there's a danger of becoming php if you go too far that direction. foo, foo_real, foo_real_fixed, etc
2021-09-07 19:01:03 +0200 <dminuoso> TypeApplications has too many issues to be seriously used as part of an API.
2021-09-07 19:01:28 +0200 <awpr> is this perhaps one of those cases where GHC would not complain if a type variable is completely unconstrained?
2021-09-07 19:01:32 +0200 <monochrom> callCC itself is already pretty fringe. And it is not one of those things that gains much from type application. It is not even a type-level programming tool.
2021-09-07 19:02:04 +0200 <awpr> I've never really understood when that can happen, but I've seen it here and there, when working with phantom types
2021-09-07 19:02:15 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 260 seconds)
2021-09-07 19:02:43 +0200kuribas(~user@ptr-25vy0i6t0eunz4pw5nt.18120a2.ip6.access.telenet.be) (Quit: ERC (IRC client for Emacs 26.3))
2021-09-07 19:03:00 +0200 <monochrom> s/php/snoyman/ with his exception-safe
2021-09-07 19:03:37 +0200 <awpr> er, "this" referring to calls to the callback provided by callCC where the result type would be ambiguous. if GHC would be okay with unconstrained types, then you can't be relying on it for inference, because they'd become unconstrained and still be fine
2021-09-07 19:04:00 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-09-07 19:04:14 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-09-07 19:04:17 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 19:05:05 +0200 <awpr> I think I can contrive a case where the non-quantified version of the callback helps GHC choose an instance, so I guess it's not guaranteed to be safe
2021-09-07 19:05:26 +0200 <c_wraith> yeah, that's certainly possible to construct.
2021-09-07 19:07:03 +0200 <c_wraith> I don't think the whole thing really matters all that much, as the typical fix for problems with callCC is "don't use continuations"
2021-09-07 19:07:19 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-09-07 19:08:14 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-07 19:08:30 +0200ub1(~Thunderbi@77.119.174.203.wireless.dyn.drei.com)
2021-09-07 19:08:48 +0200ubert1(~Thunderbi@77.119.174.203.wireless.dyn.drei.com)
2021-09-07 19:08:49 +0200 <c_wraith> I was mostly just poking at it to get a better intuition for what the type says. nothing I did is best expressed using callCC
2021-09-07 19:09:14 +0200ub(~Thunderbi@178.165.164.206.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-07 19:09:50 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-09-07 19:10:22 +0200ubert(~Thunderbi@178.165.164.206.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-07 19:10:23 +0200ubert1ubert
2021-09-07 19:10:24 +0200ub1ub
2021-09-07 19:10:34 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 19:11:53 +0200aman_(~aman@user/aman)
2021-09-07 19:14:31 +0200 <lechner> Lambdu looks super cool, but did the UI improvements require a new language?
2021-09-07 19:15:01 +0200_ht(~quassel@82-169-194-8.biz.kpn.net)
2021-09-07 19:16:20 +0200 <janus> lechner: note that lamdu supports multiple languages for bindings. so a binding can have different names in different langauges. how would you encode that in an existing language?
2021-09-07 19:16:41 +0200 <monochrom> https://xkcd.com/927/
2021-09-07 19:17:00 +0200 <janus> lechner: of course it can be done, it is yet anoth question of compromises. there are other 'structural' langauges, i linked this one because it is implemented in haskell and i think it is the neatest
2021-09-07 19:17:02 +0200aarvar(~aaron@2601:602:a080:fa0:e5a8:13bc:a9e7:fefb)
2021-09-07 19:17:46 +0200 <lechner> janus: the language is neat, or the IDE is neat?
2021-09-07 19:17:48 +0200pzanco(~pzanco@2804:14c:3ba1:42d:2204:fff:feff:44a0) (Quit: Leaving)
2021-09-07 19:17:50 +0200APic(apic@apic.name)
2021-09-07 19:18:00 +0200 <janus> is there an xkcd for "we developed an incompatible implementation of an existing standard" that i can send when people send xkcd 927??
2021-09-07 19:18:44 +0200 <monochrom> I think no. I think I'm pretty safe.
2021-09-07 19:18:59 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-09-07 19:19:19 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 19:19:28 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 265 seconds)
2021-09-07 19:19:34 +0200 <monochrom> But you should interpret it more broadly. Instead of "standard", it could just as well be "language", "implementation", "philosophy".
2021-09-07 19:19:39 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 19:19:49 +0200 <monochrom> So, how about sending 927 back to those who send 927?
2021-09-07 19:20:06 +0200 <monochrom> I send 927 to those who don't send 927 to themselves.
2021-09-07 19:20:37 +0200 <janus> lechner: i think their videos are really neat, i think the animations in the IDE is really neat . i think you still can't make your own data types, so the language probably is incomplete :P
2021-09-07 19:20:54 +0200 <Gurkenglas> monochrom, you're lucky haskell is inconsistent
2021-09-07 19:21:04 +0200 <janus> lechner: but they are building it on their own AST library which i still have to understand... some day https://hackage.haskell.org/package/hypertypes
2021-09-07 19:21:40 +0200 <janus> lechner: the github explains how they build on data types a la carte: https://github.com/lamdu/hypertypes#readme
2021-09-07 19:21:55 +0200MQ-17J(~MQ-17J@2607:fb90:46:a8a6:384f:d5fd:c3eb:fa6f) (Read error: Connection reset by peer)
2021-09-07 19:22:22 +0200 <lechner> janus: i may want that IDE, but I'm lukewarm about learning a new language
2021-09-07 19:22:38 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 19:23:03 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Read error: Connection reset by peer)
2021-09-07 19:23:22 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-09-07 19:23:29 +0200 <lechner> they could so totally build for Haskell what Eclipse was for Java
2021-09-07 19:23:29 +0200 <monochrom> When one day every language is similar to Haskell,
2021-09-07 19:23:45 +0200 <monochrom> we can say "learning a new language is just a matter of picking up new syntax" again!
2021-09-07 19:23:55 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-09-07 19:24:14 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-07 19:24:40 +0200 <janus> lechner: apropos eclipse , did you see https://www.jetbrains.com/mps/ ?
2021-09-07 19:25:32 +0200justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 245 seconds)
2021-09-07 19:27:20 +0200 <raehik> janus: that library looks veeeery interesting, thank you!
2021-09-07 19:29:40 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 260 seconds)
2021-09-07 19:30:13 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 19:31:31 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-07 19:32:11 +0200StefanMeier(~StefanMei@cm56-244-20.liwest.at)
2021-09-07 19:32:54 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-09-07 19:34:44 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-07 19:34:46 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 19:34:59 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 19:35:25 +0200favonia(~favonia@user/favonia) (Ping timeout: 265 seconds)
2021-09-07 19:35:32 +0200 <StefanMeier> hello. i'm having strange issues with ghci on Windows when I terminate a process with control-c. the process seems to still run in the background spamming my inputs.
2021-09-07 19:36:23 +0200 <StefanMeier> Windows 10, platform installed with stack, running "stack ghci", tried in terminal: cmd, git bash, cygwin, msys2, powershell, powershell 7, msys2 + winpty. but nothing works
2021-09-07 19:36:46 +0200xff0x(~xff0x@2001:1a81:5244:5800:ade4:7c8b:9b3b:6271) (Ping timeout: 252 seconds)
2021-09-07 19:37:17 +0200 <StefanMeier> using ghc 9.0.1
2021-09-07 19:37:44 +0200xff0x(~xff0x@2001:1a81:5244:5800:bebc:1a37:2a8f:4a9c)
2021-09-07 19:39:42 +0200burnsidesLlama(~burnsides@dhcp168-020.wadham.ox.ac.uk)
2021-09-07 19:41:19 +0200justsomeguy(~justsomeg@user/justsomeguy)
2021-09-07 19:42:40 +0200qbt(~edun@user/edun) (Ping timeout: 265 seconds)
2021-09-07 19:42:46 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Killed (NickServ (GHOST command used by allbery_b)))
2021-09-07 19:42:46 +0200allbery_b(~geekosaur@xmonad/geekosaur)
2021-09-07 19:42:50 +0200allbery_bgeekosaur
2021-09-07 19:43:05 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 260 seconds)
2021-09-07 19:44:37 +0200qbt(~edun@user/edun)
2021-09-07 19:46:25 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-09-07 19:46:44 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-07 19:48:13 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 19:48:45 +0200 <zzz> that's weird. the process never exits? can you kill it? what terminal are you using?
2021-09-07 19:49:49 +0200 <StefanMeier> apparently it's a "stack ghci" issues. https://github.com/commercialhaskell/stack/issues/4737
2021-09-07 19:49:49 +0200 <StefanMeier> https://github.com/commercialhaskell/stack/issues/610
2021-09-07 19:50:31 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Ping timeout: 252 seconds)
2021-09-07 19:50:35 +0200 <StefanMeier> when I run plain "ghci" and press control-c twice, everything is fine. "stack ghci" and control-c twice produces strange glitches and exits ghci, while keeping the process in the backgorund
2021-09-07 19:50:53 +0200favonia(~favonia@user/favonia)
2021-09-07 19:52:43 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 252 seconds)
2021-09-07 19:53:02 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 19:54:36 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 19:57:39 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 265 seconds)
2021-09-07 19:59:50 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-07 20:00:50 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 20:04:52 +0200fryguybob(~fryguybob@cpe-74-65-31-113.rochester.res.rr.com) (Ping timeout: 256 seconds)
2021-09-07 20:05:27 +0200lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-09-07 20:07:01 +0200StefanMeier(~StefanMei@cm56-244-20.liwest.at) (Quit: Client closed)
2021-09-07 20:07:32 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 252 seconds)
2021-09-07 20:07:57 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 20:11:05 +0200arjun(~Srain@user/arjun) (Remote host closed the connection)
2021-09-07 20:11:19 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-09-07 20:11:43 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-07 20:12:38 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 265 seconds)
2021-09-07 20:12:57 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 20:16:05 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-07 20:16:05 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-07 20:16:05 +0200wroathe(~wroathe@user/wroathe)
2021-09-07 20:20:45 +0200aman_(~aman@user/aman) (Quit: aman_)
2021-09-07 20:21:04 +0200aman(~aman@user/aman)
2021-09-07 20:21:27 +0200fryguybob(~fryguybob@cpe-74-65-17-248.rochester.res.rr.com)
2021-09-07 20:27:20 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de) (Ping timeout: 252 seconds)
2021-09-07 20:28:30 +0200zebrag(~chris@user/zebrag) (Remote host closed the connection)
2021-09-07 20:31:22 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 20:35:35 +0200max22-(~maxime@2a01cb0883359800554e78e897c895d5.ipv6.abo.wanadoo.fr) (Ping timeout: 260 seconds)
2021-09-07 20:36:55 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de)
2021-09-07 20:38:49 +0200slack1256(~slack1256@12.0.89.245) (Remote host closed the connection)
2021-09-07 20:39:09 +0200jess(~jess@libera/staff/jess)
2021-09-07 20:40:11 +0200lbseale(~lbseale@user/ep1ctetus) (Ping timeout: 265 seconds)
2021-09-07 20:40:12 +0200slack1256(~slack1256@12.0.89.245)
2021-09-07 20:40:50 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 260 seconds)
2021-09-07 20:43:26 +0200roboguy_(~roboguy_@cpe-98-156-4-161.kc.res.rr.com)
2021-09-07 20:46:09 +0200MQ-17J(~MQ-17J@8.21.10.6)
2021-09-07 20:48:37 +0200lbseale(~lbseale@user/ep1ctetus)
2021-09-07 20:49:56 +0200no-n(~ed@101.53.218.157)
2021-09-07 20:50:15 +0200no-npony
2021-09-07 20:51:32 +0200jtomas(~jtomas@95.red-88-11-64.dynamicip.rima-tde.net) (Ping timeout: 252 seconds)
2021-09-07 20:51:51 +0200justsomeguy(~justsomeg@user/justsomeguy) (Quit: WeeChat 3.2)
2021-09-07 20:51:55 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de) (Ping timeout: 260 seconds)
2021-09-07 20:52:13 +0200 <maerwald[m]> ghcii?
2021-09-07 20:53:07 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-09-07 20:53:08 +0200lbseale(~lbseale@user/ep1ctetus) (Read error: Connection reset by peer)
2021-09-07 20:53:25 +0200xyh(~xyh@113.92.75.47)
2021-09-07 20:55:06 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 20:55:19 +0200michalz(~michalz@185.246.204.41) (Remote host closed the connection)
2021-09-07 20:55:19 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 20:56:33 +0200jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2021-09-07 20:56:46 +0200oxide(~lambda@user/oxide) (Quit: oxide)
2021-09-07 21:02:47 +0200burnsidesLlama(~burnsides@dhcp168-020.wadham.ox.ac.uk) (Remote host closed the connection)
2021-09-07 21:04:42 +0200roboguy_(~roboguy_@cpe-98-156-4-161.kc.res.rr.com) (Remote host closed the connection)
2021-09-07 21:05:17 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-07 21:06:19 +0200lavaman(~lavaman@98.38.249.169)
2021-09-07 21:07:20 +0200roboguy_(~roboguy_@cpe-98-156-4-161.kc.res.rr.com)
2021-09-07 21:07:41 +0200kenran(~kenran@200116b82b0c2200502f5bd42a0f55ef.dip.versatel-1u1.de)
2021-09-07 21:07:46 +0200 <sm> @StefanMeier:libera.chat: i used to hit that quite often on non windows.. +1 if you've found a repro
2021-09-07 21:07:46 +0200 <lambdabot> Unknown command, try @list
2021-09-07 21:07:54 +0200 <sm> g'day all
2021-09-07 21:08:31 +0200roboguy_(~roboguy_@cpe-98-156-4-161.kc.res.rr.com) (Remote host closed the connection)
2021-09-07 21:08:43 +0200roboguy_(~roboguy_@cpe-98-156-4-161.kc.res.rr.com)
2021-09-07 21:10:47 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 252 seconds)
2021-09-07 21:11:54 +0200 <tomsmeding> sm: you're hitting that on something _other_ than windows?
2021-09-07 21:13:28 +0200pzanco(~pzanco@2804:14c:3ba1:42d:2204:fff:feff:44a0)
2021-09-07 21:14:29 +0200mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be)
2021-09-07 21:14:38 +0200mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be) (Client Quit)
2021-09-07 21:15:05 +0200max22-(~maxime@2a01cb08833598001355d88e505fa1ae.ipv6.abo.wanadoo.fr)
2021-09-07 21:15:13 +0200aarvar(~aaron@2601:602:a080:fa0:e5a8:13bc:a9e7:fefb) (Ping timeout: 252 seconds)
2021-09-07 21:15:28 +0200jakalx(~jakalx@base.jakalx.net)
2021-09-07 21:18:00 +0200pzanco(~pzanco@2804:14c:3ba1:42d:2204:fff:feff:44a0) (Client Quit)
2021-09-07 21:18:23 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de)
2021-09-07 21:19:43 +0200 <c_wraith> huh. I was just thinking about the challenge some people face with learning recursion, when they have trouble tracing the whole thing in their head. we tell them to just make sure it works correctly if it works correctly.
2021-09-07 21:20:23 +0200 <c_wraith> then it hit me - the form of that logic is (works correctly -> works correctly) -> works correctly
2021-09-07 21:20:26 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 21:20:38 +0200 <c_wraith> that's not a coincidence.
2021-09-07 21:20:41 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 21:20:47 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Client Quit)
2021-09-07 21:20:52 +0200 <tomsmeding> no, it is: works(basecase) -> (works(n) -> works(n+1)) -> works, which is induction on N :p
2021-09-07 21:21:04 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 21:22:05 +0200 <tomsmeding> or, well, that should really be the induction principle of whatever data structure you're recursing over, instead of N
2021-09-07 21:23:39 +0200kimjetwav(~user@2607:fea8:235f:9730:2829:edb2:f2b7:f87c)
2021-09-07 21:25:00 +0200 <c_wraith> that's not the general case anyway. the general case is "works correctly on all sub-structures", not just one size down.
2021-09-07 21:25:04 +0200 <tomsmeding> perhaps, instead of teaching people induction, we should teach them writing recursive programs [I'm not being serious]
2021-09-07 21:25:37 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 265 seconds)
2021-09-07 21:26:37 +0200 <tomsmeding> right, though I'm not sure I can think of a recursive function where you actively need to apply strong induction in order to see why it works
2021-09-07 21:27:24 +0200 <c_wraith> Fibonacci?
2021-09-07 21:27:33 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-09-07 21:27:49 +0200 <c_wraith> quick sort.
2021-09-07 21:27:52 +0200neo1(~neo3@cpe-292712.ip.primehome.com) (Ping timeout: 252 seconds)
2021-09-07 21:27:56 +0200 <c_wraith> there are lots of examples.
2021-09-07 21:27:57 +0200aarvar(~aaron@2601:602:a080:fa0:18d6:e186:b364:ee0b)
2021-09-07 21:28:54 +0200 <tomsmeding> hm, right, so this depends on what you consider to be the structure you're recursing over
2021-09-07 21:28:56 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de) (Ping timeout: 252 seconds)
2021-09-07 21:29:15 +0200vysn(~vysn@user/vysn) (Quit: WeeChat 3.2)
2021-09-07 21:29:28 +0200 <tomsmeding> indeed for quick sort the actual tree structure you're folding is quite unnatural to the uninitiated programmer
2021-09-07 21:29:43 +0200vysn(~vysn@user/vysn)
2021-09-07 21:29:45 +0200 <tomsmeding> quick sort is a good example
2021-09-07 21:30:42 +0200lavaman(~lavaman@98.38.249.169)
2021-09-07 21:30:44 +0200 <awpr> I guess the idea is if you think of it as building up proofs that "quicksort works for all arrays of length N", then it's strong induction, but for "quicksort works for _this array_" then it's just structural on subsequences of the array?
2021-09-07 21:31:08 +0200 <tomsmeding> next level up: analyse a recursive function that doesn't have a single parameter that's always smaller in the recursive calls (i.e. a function that would fail standard totality checks in agda/idris/coq)
2021-09-07 21:31:10 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 21:31:27 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 21:31:35 +0200 <c_wraith> 3n+1. not even proven to terminate!
2021-09-07 21:32:07 +0200 <c_wraith> ok, that's not well-founded recursion anymore.
2021-09-07 21:32:26 +0200 <tomsmeding> what does it even mean to "understand" how the recursion works in an implementation of collatz :p
2021-09-07 21:33:21 +0200 <c_wraith> I think it means you get to publish some papers and be internet famous
2021-09-07 21:33:46 +0200 <tomsmeding> awpr: from a suitably ivory-tower perspective, quicksort recurses over a binary tree structure that gives the precise partitioning decisions for this particular array
2021-09-07 21:34:36 +0200 <tomsmeding> but that's not really a useful perspective in practice often
2021-09-07 21:34:40 +0200 <tomsmeding> c_wraith: heh yes
2021-09-07 21:34:48 +0200 <awpr> tomsmeding: yeah, that's what I was getting at, I guess I didn't convey it too well
2021-09-07 21:34:56 +0200 <tomsmeding> right
2021-09-07 21:36:33 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 21:36:48 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 21:37:24 +0200burnsidesLlama(~burnsides@dhcp168-020.wadham.ox.ac.uk)
2021-09-07 21:41:16 +0200asivitz(uid178348@id-178348.tinside.irccloud.com)
2021-09-07 21:41:17 +0200tfeb(~tfb@88.98.95.237)
2021-09-07 21:42:32 +0200roboguy_(~roboguy_@cpe-98-156-4-161.kc.res.rr.com) (Remote host closed the connection)
2021-09-07 21:43:01 +0200burnsidesLlama(~burnsides@dhcp168-020.wadham.ox.ac.uk) (Ping timeout: 265 seconds)
2021-09-07 21:43:20 +0200roboguy_(~roboguy_@cpe-98-156-4-161.kc.res.rr.com)
2021-09-07 21:44:26 +0200aman(~aman@user/aman) (Quit: aman)
2021-09-07 21:45:55 +0200wonko(~wjc@62.115.229.50) (Ping timeout: 265 seconds)
2021-09-07 21:47:42 +0200roboguy_(~roboguy_@cpe-98-156-4-161.kc.res.rr.com) (Remote host closed the connection)
2021-09-07 21:47:54 +0200roboguy_(~roboguy_@cpe-98-156-4-161.kc.res.rr.com)
2021-09-07 21:48:44 +0200roboguy__(~roboguy_@cpe-98-156-4-161.kc.res.rr.com)
2021-09-07 21:48:45 +0200roboguy_(~roboguy_@cpe-98-156-4-161.kc.res.rr.com) (Read error: Connection reset by peer)
2021-09-07 21:52:11 +0200wrengr(~wrengr@56.72.82.34.bc.googleusercontent.com) (Quit: leaving)
2021-09-07 21:52:12 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 265 seconds)
2021-09-07 21:52:28 +0200wrengr(~wrengr@56.72.82.34.bc.googleusercontent.com)
2021-09-07 21:54:20 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 260 seconds)
2021-09-07 21:59:28 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-07 21:59:28 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-07 21:59:28 +0200wroathe(~wroathe@user/wroathe)
2021-09-07 21:59:46 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Ping timeout: 252 seconds)
2021-09-07 22:00:45 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-07 22:05:24 +0200juhp(~juhp@128.106.188.220) (Ping timeout: 250 seconds)
2021-09-07 22:06:31 +0200_ht(~quassel@82-169-194-8.biz.kpn.net) (Remote host closed the connection)
2021-09-07 22:08:00 +0200juhp(~juhp@128.106.188.220)
2021-09-07 22:08:06 +0200tfeb(~tfb@88.98.95.237) (Quit: died)
2021-09-07 22:08:15 +0200tfeb(~tfb@88.98.95.237)
2021-09-07 22:08:37 +0200pony(~ed@101.53.218.157) (WeeChat 2.8)
2021-09-07 22:08:47 +0200hiruji(~hiruji@user/hiruji) (Ping timeout: 245 seconds)
2021-09-07 22:10:21 +0200hiruji(~hiruji@user/hiruji)
2021-09-07 22:10:52 +0200mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be)
2021-09-07 22:12:17 +0200roboguy__(~roboguy_@cpe-98-156-4-161.kc.res.rr.com) ()
2021-09-07 22:15:53 +0200mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be) (Ping timeout: 265 seconds)
2021-09-07 22:16:41 +0200 <lechner> Hi, for a newbie reimplementing a Node website in Haskell, is there a reason to prefer scotty over servant?
2021-09-07 22:17:15 +0200mikoto-chan(~mikoto-ch@83.137.2.243)
2021-09-07 22:17:16 +0200 <slack1256> Scotty is easier to set up and work with.
2021-09-07 22:17:22 +0200 <dsal> What's a Node website?
2021-09-07 22:17:50 +0200 <geekosaur> node.js?
2021-09-07 22:17:50 +0200 <slack1256> nodejs backend I think.k
2021-09-07 22:17:50 +0200 <dsal> I've meant to learn servant a few times, but I always do scotty like a plebe.
2021-09-07 22:17:57 +0200 <lechner> dsal: http://expressjs.com/
2021-09-07 22:18:03 +0200 <dsal> Like ghcjs?
2021-09-07 22:18:39 +0200 <xsperry> I always used scotty as well. what's the advantage of servant?
2021-09-07 22:18:41 +0200 <slack1256> dsal: https://en.wikipedia.org/wiki/Node.js
2021-09-07 22:18:53 +0200 <dsal> Ooh. I missed "re" in that initial question and it was very confusing for me.
2021-09-07 22:19:01 +0200 <dsal> xsperry: servant does a lot of really neat type magic.
2021-09-07 22:19:14 +0200 <lechner> slack1256: for debian, i can only send server-generated content. too many folks with text browsers
2021-09-07 22:19:29 +0200zer0bitz_(~zer0bitz@dsl-hkibng31-58c384-213.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-09-07 22:19:59 +0200 <slack1256> Servant can be used to describe the endpoint of a http interface. So you can say "On this endpoing, only json put queries allowed and they should have this format". It is cool but not world changing for me, at least when prototyping.
2021-09-07 22:20:07 +0200 <lechner> servant does some cool stuff and may make it easier to implement an existing JSON query interface
2021-09-07 22:20:08 +0200 <dsal> I've mostly avoided writing anything in node.js, but scotty is easy to understand and get started with. I've done pretty neat stuff with it.
2021-09-07 22:20:30 +0200ub(~Thunderbi@77.119.174.203.wireless.dyn.drei.com) (Read error: Connection reset by peer)
2021-09-07 22:20:46 +0200ub(~Thunderbi@77.119.174.203.wireless.dyn.drei.com)
2021-09-07 22:21:03 +0200 <lechner> okay, maybe i'll give scotty a shot
2021-09-07 22:21:11 +0200 <dsal> Give scotty the shotty
2021-09-07 22:21:32 +0200 <lechner> dsal: you used blaze or lucid?
2021-09-07 22:21:39 +0200 <dsal> Nah.
2021-09-07 22:21:47 +0200 <lechner> <> ?
2021-09-07 22:21:59 +0200 <dsal> The only thing I've got an actual UX in is in elm.
2021-09-07 22:22:05 +0200 <lechner> i see
2021-09-07 22:22:07 +0200 <dsal> The backend just does JSON and static.
2021-09-07 22:22:30 +0200 <lechner> is elm stil your favorite?
2021-09-07 22:22:39 +0200 <slack1256> I would not be that concerned of choosing the "right" library. You can always rewrite an API from scotty to servant. Both libraries make clear what should be translated between the two.
2021-09-07 22:22:40 +0200fryguybob(~fryguybob@cpe-74-65-17-248.rochester.res.rr.com) (Ping timeout: 265 seconds)
2021-09-07 22:22:45 +0200 <dsal> I wouldn't say elm has ever been my favorite, but elm is pretty good at what elm is good at.
2021-09-07 22:24:16 +0200 <lechner> i probably can't use either, but what about RFP, Miso or Purescript?
2021-09-07 22:25:15 +0200ub(~Thunderbi@77.119.174.203.wireless.dyn.drei.com) (Ping timeout: 260 seconds)
2021-09-07 22:25:39 +0200 <dsal> I've had a good time with purescript recently.
2021-09-07 22:25:54 +0200 <dsal> I used it to replace a bunch of gross JS in a Google Sheets thing.
2021-09-07 22:26:33 +0200 <dsal> elm is much more limited in what it does and can do in a good way if you're doing the stuff it's good at.
2021-09-07 22:26:39 +0200 <lechner> with halogen?
2021-09-07 22:27:00 +0200MQ-17J(~MQ-17J@8.21.10.6) (Ping timeout: 260 seconds)
2021-09-07 22:29:15 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 22:29:44 +0200tfeb(~tfb@88.98.95.237) (Remote host closed the connection)
2021-09-07 22:29:57 +0200 <dsal> I don't know what halogen is, so probably not.
2021-09-07 22:30:19 +0200 <dsal> Oh, no. This is just backend junk for a spreadsheet. No UI components.
2021-09-07 22:30:22 +0200 <lechner> no worries, thanks to everyone!
2021-09-07 22:30:38 +0200 <lechner> dsal: thanks!
2021-09-07 22:30:52 +0200 <lechner> as always
2021-09-07 22:31:54 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Quit: amitnjha)
2021-09-07 22:32:03 +0200 <dsal> The spreadsheet is the UI. The scripts run on a timer and get new data to update the spreadsheet automatically.
2021-09-07 22:32:09 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 22:32:15 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com) (Client Quit)
2021-09-07 22:32:23 +0200vysn(~vysn@user/vysn) (Quit: WeeChat 3.2)
2021-09-07 22:32:30 +0200amitnjha(~amit@024-216-124-116.res.spectrum.com)
2021-09-07 22:32:40 +0200vysn(~vysn@user/vysn)
2021-09-07 22:33:50 +0200gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2021-09-07 22:33:52 +0200Kaiepi(~Kaiepi@156.34.44.192)
2021-09-07 22:34:16 +0200Kaipi(~Kaiepi@156.34.44.192) (Ping timeout: 252 seconds)
2021-09-07 22:34:25 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 252 seconds)
2021-09-07 22:34:59 +0200kjak(~kjak@pool-108-45-56-21.washdc.fios.verizon.net)
2021-09-07 22:35:13 +0200slack1256(~slack1256@12.0.89.245) (Remote host closed the connection)
2021-09-07 22:36:11 +0200 <lechner> Can 'let' take two lvalues? https://github.com/eckyputrady/haskell-scotty-realworld-example-app/blob/master/src/Lib.hs#L34
2021-09-07 22:36:12 +0200 <sm> sounds nice!
2021-09-07 22:37:08 +0200 <geekosaur> lechner: that defines a local function
2021-09-07 22:37:10 +0200ubert(~Thunderbi@77.119.174.203.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-07 22:37:28 +0200 <sm> dsal, you are one of the few haskellers I hear regularly building practical projects - good to hear
2021-09-07 22:37:45 +0200 <sm> "real-world" practical
2021-09-07 22:37:49 +0200kenran(~kenran@200116b82b0c2200502f5bd42a0f55ef.dip.versatel-1u1.de) (Quit: WeeChat info:version)
2021-09-07 22:38:36 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 265 seconds)
2021-09-07 22:38:55 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 22:41:07 +0200ubert(~Thunderbi@77.119.174.203.wireless.dyn.drei.com)
2021-09-07 22:42:23 +0200 <lechner> geekosaur: even without 'in' ?
2021-09-07 22:42:24 +0200Unhammer(~Unhammer@user/unhammer) (Ping timeout: 256 seconds)
2021-09-07 22:43:32 +0200zebrag(~chris@user/zebrag)
2021-09-07 22:44:52 +0200 <geekosaur> it's in a do expression, so yes
2021-09-07 22:45:05 +0200 <geekosaur> it desugars to the let-in style
2021-09-07 22:45:52 +0200troydm(~troydm@host-176-37-124-197.b025.la.net.ua) (Ping timeout: 252 seconds)
2021-09-07 22:45:52 +0200 <lechner> okay, finally i'm getting something
2021-09-07 22:46:36 +0200aravk(~aravk@user/aravk) (Remote host closed the connection)
2021-09-07 22:47:30 +0200 <lechner> geekosaur: but isn't 'runner' missing an argument in the next line? https://github.com/eckyputrady/haskell-scotty-realworld-example-app/blob/master/src/Lib.hs#L35
2021-09-07 22:47:41 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2021-09-07 22:48:17 +0200 <geekosaur> that just means HTTP.main expects a function, which it presumably provides a parameter to
2021-09-07 22:48:30 +0200 <geekosaur> my guess is it accepts a connection and calls runner on it
2021-09-07 22:49:22 +0200 <lechner> i should have remembered that "functions are first-class citizens"
2021-09-07 22:49:29 +0200 <lechner> geekosaur: thanks!
2021-09-07 22:49:43 +0200 <geekosaur> and the definition of runner seems to support that
2021-09-07 22:50:20 +0200cheater(~Username@user/cheater) (Ping timeout: 252 seconds)
2021-09-07 22:52:20 +0200 <lechner> okay, i have one more for today: What's up with all the 'deriving' clauses, please? If it is automatic, why isn't everything derived by default?
2021-09-07 22:52:52 +0200 <sm> it's not free.. it can produce a lot of code
2021-09-07 22:53:06 +0200 <sm> and every class doesn't make sense for every type
2021-09-07 22:53:24 +0200 <lechner> i see
2021-09-07 22:53:47 +0200cheater(~Username@user/cheater)
2021-09-07 22:53:47 +0200Skyfire(~pyon@user/pyon) (Quit: brb)
2021-09-07 22:54:01 +0200 <c_wraith> I do pretty much throw Eq, Ord, and Show on everything that doesn't contain a function explicitly, though
2021-09-07 22:54:09 +0200Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2021-09-07 22:54:09 +0200Skyfire(~pyon@user/pyon)
2021-09-07 22:54:20 +0200 <c_wraith> they just are too useful for debugging to leave out
2021-09-07 22:54:24 +0200 <sm> same
2021-09-07 22:54:31 +0200 <asivitz> lechner: for large projects, you might even consider removing derivings that you don't really need to save on compile times. but that doesn't happen often
2021-09-07 22:54:52 +0200 <dsal> sm: Thanks! :) It's my goto language. I am real world haskell.
2021-09-07 22:55:19 +0200 <lechner> i just did a double take on GOTO
2021-09-07 22:55:20 +0200 <sm> dsal++
2021-09-07 22:55:45 +0200 <dsal> lechner: scheme is my call/cc language
2021-09-07 22:55:55 +0200unit73e(~emanuel@2001:818:e8dd:7c00:32b5:c2ff:fe6b:5291)
2021-09-07 22:56:10 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 240 seconds)
2021-09-07 22:56:10 +0200Lord_of_Life_Lord_of_Life
2021-09-07 22:56:46 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14) (Remote host closed the connection)
2021-09-07 22:56:46 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Read error: Connection reset by peer)
2021-09-07 22:57:08 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 22:57:36 +0200 <asivitz> Data.Vector.modify seems weird to me. why wouldn't the ST argument be last? I'd expect it to be nearly always larger and more cumbersome than the vector argument. and on top of that, I can't use `flip` because of impredicative polymorphism (I think!)
2021-09-07 22:57:39 +0200 <dsal> One cool thing I did in my scotty web app thing was have a MonadLogger thing that would log to a tchan, and then a web handler that would start websockets and send the logged events to the browser. Then the elm code had a handler for the inbound messages that would put up little toasties for log messages.
2021-09-07 22:57:53 +0200 <c_wraith> dsal: hah. did you see my complaint about the type of mtl's callCC this morning?
2021-09-07 22:58:09 +0200 <dsal> c_wraith: Someone was talking about it last night, but I've still never actually used ContT
2021-09-07 22:58:31 +0200ikex(ash@user/ikex) (Ping timeout: 252 seconds)
2021-09-07 22:58:58 +0200Pickchea(~private@user/pickchea)
2021-09-07 22:59:02 +0200Tuplanolla(~Tuplanoll@91-159-69-50.elisa-laajakaista.fi)
2021-09-07 22:59:27 +0200ikex(ash@user/ikex)
2021-09-07 22:59:29 +0200 <lechner> you folks are real pros. thanks for indulging my questions!
2021-09-07 22:59:41 +0200 <dsal> Oh, that's not even the thing people were talking about last night.
2021-09-07 22:59:47 +0200troydm(~troydm@host-176-37-124-197.b025.la.net.ua)
2021-09-07 22:59:55 +0200ec_(~ec@gateway/tor-sasl/ec)
2021-09-07 23:00:10 +0200aliosablack(~chomwitt@2a02:587:dc02:7900:12c3:7bff:fe6d:d374) (Read error: Connection reset by peer)
2021-09-07 23:01:21 +0200chomwitt(~chomwitt@ppp-94-67-192-178.home.otenet.gr)
2021-09-07 23:01:25 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 260 seconds)
2021-09-07 23:01:26 +0200aegon(~mike@174.127.249.180)
2021-09-07 23:01:55 +0200ubert(~Thunderbi@77.119.174.203.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-07 23:01:56 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-07 23:03:45 +0200 <lechner> due to the '$' it is not possible to define this local function partially (without 'app') before it is used in the next line, right? https://github.com/eckyputrady/haskell-scotty-realworld-example-app/blob/master/src/Lib.hs#L34
2021-09-07 23:05:37 +0200 <monochrom> @remember dsal scheme is my call/cc language
2021-09-07 23:05:37 +0200 <lambdabot> Nice!
2021-09-07 23:05:54 +0200MQ-17J(~MQ-17J@2607:fb90:46:a8a6:384f:d5fd:c3eb:fa6f)
2021-09-07 23:06:06 +0200 <unit73e> hello. If you're interested I've been doing an SDL2 lazyfoo: https://gitlab.com/unit73e/lazyfoo-examples
2021-09-07 23:06:19 +0200MQ-17J(~MQ-17J@2607:fb90:46:a8a6:384f:d5fd:c3eb:fa6f) (Read error: Connection reset by peer)
2021-09-07 23:06:33 +0200 <unit73e> it's similar to the one in SDL2 project but the comments are similar to the lazyfoo tutorial and has some more examples
2021-09-07 23:06:44 +0200 <dsal> @pl \app -> flip runReaderT (pgEnv, jwtEnv) $ unAppT app
2021-09-07 23:06:44 +0200 <lambdabot> flip runReaderT (pgEnv, jwtEnv) . unAppT
2021-09-07 23:06:57 +0200 <kaol> asivitz: That follows the same pattern that all the folding, filtering and searching higher order functions for Data.Vector do.
2021-09-07 23:06:59 +0200 <dsal> Not sure why they did that, lechner
2021-09-07 23:07:08 +0200 <Clint> better than combining fax and xanadu
2021-09-07 23:07:22 +0200 <Clint> er, wrong window
2021-09-07 23:07:36 +0200 <unit73e> I'm still kind of noob though so you will probably see code that isn't really the best
2021-09-07 23:07:37 +0200 <hexeme> If you have functions foo and bar, how do you pass bar to foo, if foo takes additional arguments?
2021-09-07 23:07:53 +0200 <hexeme> foo bar a b < this wants to call (bar a b)
2021-09-07 23:08:35 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 23:08:57 +0200 <dsal> hexeme: Can you give a bit more context. What are the types?
2021-09-07 23:09:03 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 265 seconds)
2021-09-07 23:09:16 +0200 <lechner> dsal: thanks!
2021-09-07 23:09:19 +0200 <asivitz> kaol: I wish they were all changed :( am I the weird one here? not sure if my style is unconventional. But I'd rather use block arguments and just hang my filter/fold/update off the end of the line and not have to use parens around it
2021-09-07 23:09:37 +0200 <unit73e> hexeme, I guess `foo` is supposed to have 3 arguments? a function a and b?
2021-09-07 23:09:43 +0200 <hexeme> unit73e: exactly
2021-09-07 23:09:49 +0200 <dsal> hexeme: `foo bar a b` does not mean `foo (bar a b)`
2021-09-07 23:09:53 +0200 <hexeme> I want to pass 3 arguments to foo
2021-09-07 23:10:04 +0200 <sm> nice unit73e, sounds good to add to sdl2 docs
2021-09-07 23:10:14 +0200 <hexeme> Hmm OK maybe I'm reading the error wrong.
2021-09-07 23:10:17 +0200 <dsal> hexeme: do you want to pass the function, or the result of the function?
2021-09-07 23:10:37 +0200 <lechner> also, what's the error?
2021-09-07 23:10:43 +0200 <hexeme> Ah OK, pebkac
2021-09-07 23:10:49 +0200 <hexeme> I was just confused sorry.
2021-09-07 23:10:55 +0200 <hexeme> Thanks
2021-09-07 23:11:16 +0200 <dsal> Being confused is one of the states of learning.
2021-09-07 23:11:23 +0200 <maerwald> hmm, stack clones git repos, tars them up and then puts them into an sqlite database with its own tree-hashing algorithm
2021-09-07 23:12:46 +0200 <maerwald> something that could have been solved easier with a git bare checkout
2021-09-07 23:13:06 +0200 <monochrom> asivitz: I see your point, but one day if you engage in "map g . filter pred . modify f" you may enjoy the status quo order.
2021-09-07 23:13:29 +0200 <monochrom> To be sure, I don't have statistics to say what's more common.
2021-09-07 23:15:05 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 252 seconds)
2021-09-07 23:15:23 +0200 <monochrom> But yeah if you try "flip modify" you run into predicativity.
2021-09-07 23:15:25 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 23:15:48 +0200 <asivitz> ah ok, that's fair. I still think I'd like it changed, just guessing at my overall usage, but you're right in pipelines it makes sense that way
2021-09-07 23:16:52 +0200fendor(~fendor@77.119.198.92.wireless.dyn.drei.com) (Remote host closed the connection)
2021-09-07 23:17:32 +0200 <monochrom> Sometimes I am a fan of "why not provide both versions".
2021-09-07 23:18:00 +0200 <monochrom> Some other times I realize "OK but naming both is hard" and give up. :)
2021-09-07 23:18:17 +0200 <monochrom> And the renaming times, ironically...
2021-09-07 23:18:23 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2021-09-07 23:18:25 +0200 <monochrom> @quote monochrom pointless.debate
2021-09-07 23:18:25 +0200 <lambdabot> monochrom says: All pointless debates can be settled by going polymorphic.
2021-09-07 23:18:53 +0200 <kaol> import flip Data.Vector -- Let's not have this language construct
2021-09-07 23:19:36 +0200 <monochrom> Hey let's comply with Wadler's law and argue over syntax!
2021-09-07 23:19:57 +0200 <monochrom> I say that it should be "import flipped Data.Vector"!
2021-09-07 23:21:08 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2021-09-07 23:21:50 +0200 <hexeme> i refactored my code an introduced a logic error
2021-09-07 23:21:57 +0200 <hexeme> been starting at it, wont jump out at me lol
2021-09-07 23:21:59 +0200mikoto-chan(~mikoto-ch@83.137.2.243) (Read error: Connection reset by peer)
2021-09-07 23:22:14 +0200 <hexeme> i guess i will refactor it further and test each of the functions
2021-09-07 23:22:35 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 265 seconds)
2021-09-07 23:23:00 +0200 <monochrom> Yeah automatically correct refactoring algorithms would be nice...
2021-09-07 23:23:15 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-07 23:23:58 +0200xyh(~xyh@113.92.75.47) (Quit: WeeChat 3.2)
2021-09-07 23:24:05 +0200 <maerwald> there's wingman
2021-09-07 23:24:12 +0200 <maerwald> which has strategies
2021-09-07 23:24:35 +0200mikoto-chan(~mikoto-ch@83.137.2.243)
2021-09-07 23:24:50 +0200 <hexeme> I've found JetBrains' Resharper, does an impressive job with C#.
2021-09-07 23:25:26 +0200 <monochrom> Ironically, automatically correct obfuscation algorithms are a solved problem. Brought to you by Patrick Cousot no less, the guy who brought you abstract interpretation.
2021-09-07 23:25:44 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 23:30:06 +0200 <dsal> @hoogle a -> Maybe b -> Either a b
2021-09-07 23:30:07 +0200 <lambdabot> Data.Either.Combinators maybeToRight :: b -> Maybe a -> Either b a
2021-09-07 23:30:07 +0200 <lambdabot> Rebase.Prelude maybeToRight :: () => b -> Maybe a -> Either b a
2021-09-07 23:30:07 +0200 <lambdabot> Network.Haskoin.Util maybeToEither :: b -> Maybe a -> Either b a
2021-09-07 23:30:19 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com) (Ping timeout: 265 seconds)
2021-09-07 23:33:58 +0200MQ-17J(~MQ-17J@d14-69-206-129.try.wideopenwest.com)
2021-09-07 23:34:04 +0200 <hexeme> that's a cool feature
2021-09-07 23:34:36 +0200 <hpc> @hackage hoogle
2021-09-07 23:34:36 +0200 <lambdabot> https://hackage.haskell.org/package/hoogle
2021-09-07 23:34:39 +0200 <hpc> @where hoogle
2021-09-07 23:34:40 +0200 <lambdabot> https://hoogle.haskell.org
2021-09-07 23:34:44 +0200 <hpc> it's quite nice
2021-09-07 23:34:53 +0200 <dsal> I'm reading some code someone else wrote and just wrote that function and wondered what other people call it.
2021-09-07 23:34:56 +0200 <dsal> (web hoogle didn't work)
2021-09-07 23:35:09 +0200Gurkenglas(~Gurkengla@dslb-090-186-104-237.090.186.pools.vodafone-ip.de) (Ping timeout: 265 seconds)
2021-09-07 23:35:12 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-07 23:35:12 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-07 23:35:12 +0200wroathe(~wroathe@user/wroathe)
2021-09-07 23:35:36 +0200 <dsal> `maybeToRight` seems a little odd. How about `youMaybeRight`
2021-09-07 23:35:45 +0200hololeap_(~hololeap@user/hololeap)
2021-09-07 23:36:25 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-09-07 23:36:30 +0200hololeap(~hololeap@user/hololeap) (Ping timeout: 276 seconds)
2021-09-07 23:39:52 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2021-09-07 23:39:56 +0200hexology(~hexology@user/hexology) (Quit: hex on you ...)
2021-09-07 23:40:25 +0200falafel(~falafel@2603-8000-d801-2d68-1d6d-bf72-eba2-a20e.res6.spectrum.com)
2021-09-07 23:41:30 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de)
2021-09-07 23:42:26 +0200 <monochrom> maybeToEither, justToRight
2021-09-07 23:43:09 +0200 <hpc> unsafeCoerce
2021-09-07 23:46:16 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de) (Ping timeout: 265 seconds)
2021-09-07 23:46:50 +0200nicbk(~nicbk@user/nicbk)
2021-09-07 23:46:51 +0200 <hexeme> is there a tool that will run a .hs file but really, only all the comments inside it
2021-09-07 23:46:56 +0200 <hexeme> like a doctest kinda deal
2021-09-07 23:47:16 +0200 <monochrom> left adjoint of the forgetful natural transformation from Either to Maybe >:)
2021-09-07 23:47:49 +0200 <geekosaur> @hackage doctest
2021-09-07 23:47:49 +0200 <lambdabot> https://hackage.haskell.org/package/doctest
2021-09-07 23:47:57 +0200 <hexeme> Well, there it is.
2021-09-07 23:48:20 +0200danasca(~dana@77.227.165.152) (Quit: Konversation terminated!)
2021-09-07 23:50:34 +0200jtomas(~jtomas@95.red-88-11-64.dynamicip.rima-tde.net)
2021-09-07 23:52:46 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:51c9:9325:5764:1e14)
2021-09-07 23:53:14 +0200m1dnight(~christoph@188.ip-51-91-158.eu) (Ping timeout: 256 seconds)
2021-09-07 23:54:46 +0200m1dnight(~christoph@188.ip-51-91-158.eu)
2021-09-07 23:55:21 +0200hendursaga(~weechat@user/hendursaga) (Ping timeout: 276 seconds)
2021-09-07 23:56:44 +0200lstor_(~lstor@user/lstor)
2021-09-07 23:56:47 +0200statusfa1led(~statusfai@statusfailed.com)
2021-09-07 23:56:56 +0200hendursaga(~weechat@user/hendursaga)
2021-09-07 23:57:17 +0200statusfailed(~statusfai@statusfailed.com) (Ping timeout: 240 seconds)
2021-09-07 23:57:17 +0200lstor(~lstor@user/lstor) (Ping timeout: 240 seconds)
2021-09-07 23:59:10 +0200fryguybob(~fryguybob@cpe-74-65-17-248.rochester.res.rr.com)