IRCBrowse

2021/10/20

2021-10-20 00:00:02 +0200burnsidesLlama(~burnsides@dhcp168-039.wadham.ox.ac.uk)
2021-10-20 00:00:40 +0200Midjak(~Midjak@82-65-111-221.subs.proxad.net) (Quit: This computer has gone to sleep)
2021-10-20 00:00:45 +0200jess(~jess@libera/staff/jess) (Quit: Lost terminal)
2021-10-20 00:00:51 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 00:01:10 +0200jess(~jess@libera/staff/jess)
2021-10-20 00:02:00 +0200max22-(~maxime@2a01cb0883359800342ef13833bd6f3b.ipv6.abo.wanadoo.fr) (Quit: Leaving)
2021-10-20 00:04:34 +0200burnsidesLlama(~burnsides@dhcp168-039.wadham.ox.ac.uk) (Ping timeout: 260 seconds)
2021-10-20 00:07:02 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-10-20 00:07:44 +0200aln448(~aln448@2a00:23c7:3480:b700:fdb9:39e2:1024:88b1) (Quit: Client closed)
2021-10-20 00:08:09 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:9105:355e:98db:81cc) (Remote host closed the connection)
2021-10-20 00:11:00 +0200ph88(~ph88@2a02:8109:9e00:7e5c::3d56)
2021-10-20 00:11:57 +0200meltedbrain_y2k(~tekserf@94.73.36.197) (Read error: Connection reset by peer)
2021-10-20 00:13:56 +0200 <janus> mcbride is still active: https://github.com/pigworker
2021-10-20 00:17:03 +0200k60(~k60@broadband-95-84-168-218.ip.moscow.rt.ru) (Quit: k60)
2021-10-20 00:17:07 +0200 <shapr> What's the status of GHC on M1 macs? Does anyone know if it's fully supported?
2021-10-20 00:17:40 +0200 <shapr> Is there anything more recent than https://www.haskell.org/ghc/blog/20210309-apple-m1-story.html ?
2021-10-20 00:17:40 +0200 <geekosaur> via llvm only in 8.10.7, to be fully supported in 9.2.1
2021-10-20 00:17:41 +0200 <dsal> shapr: I was able to build most of my projects.
2021-10-20 00:17:49 +0200 <shapr> dsal: most?
2021-10-20 00:17:57 +0200 <shapr> We have a 500kloc codebase, most worries me
2021-10-20 00:18:10 +0200 <dsal> The latest stack LTS has an older `network` library. I didn't go through and redo them all.
2021-10-20 00:18:18 +0200 <dsal> But my gopro project has all the deps and that one worked.
2021-10-20 00:18:30 +0200 <dsal> /Users/dustin/.local/bin/gopro: Mach-O 64-bit executable arm64
2021-10-20 00:19:33 +0200 <dsal> `network` was the only thing I tripped up on, and it was already fixed.
2021-10-20 00:19:39 +0200 <dsal> Also, there are a bunch of annoying warnings while stuff builds.
2021-10-20 00:20:38 +0200 <dsal> I just found out I can replace my mac with one that's about the same size, but with 10 cores and 64GB of RAM…
2021-10-20 00:23:13 +0200gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2021-10-20 00:24:49 +0200 <shapr> dsal: thanks for the info
2021-10-20 00:25:28 +0200 <dsal> I switched my nix over two days ago to try that, so it's fresh on my mind. :)
2021-10-20 00:26:26 +0200 <dsal> I switched it back, though. It's a little annoying to override `network` just for that.
2021-10-20 00:28:19 +0200 <shapr> dsal: are you using ghc 8.10.7 ? or ghc 9?
2021-10-20 00:31:35 +0200Megant(megant@user/megant)
2021-10-20 00:33:31 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:9105:355e:98db:81cc)
2021-10-20 00:33:48 +0200Midjak(~Midjak@82-65-111-221.subs.proxad.net)
2021-10-20 00:34:05 +0200Null_A(~null_a@2601:645:8700:2290:a94b:e46c:6690:e477) (Remote host closed the connection)
2021-10-20 00:34:19 +0200Midjak(~Midjak@82-65-111-221.subs.proxad.net) (Read error: Connection reset by peer)
2021-10-20 00:34:39 +0200 <dsal> I just ran stack LTS-18.13
2021-10-20 00:35:33 +0200 <dsal> LTS 18.13 for ghc-8.10.7
2021-10-20 00:35:44 +0200 <dsal> I may have tried a nightly. I'll do that real quick and see what happens.
2021-10-20 00:36:38 +0200 <dsal> It's downloading 9.0.1… Nothing can go wrong now.
2021-10-20 00:39:22 +0200slack1256(~slack1256@45.4.2.52)
2021-10-20 00:40:00 +0200theproffesor(~theproffe@user/theproffesor) (Ping timeout: 268 seconds)
2021-10-20 00:42:47 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 00:42:51 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.3)
2021-10-20 00:46:34 +0200slack1256(~slack1256@45.4.2.52) (Ping timeout: 260 seconds)
2021-10-20 00:47:47 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-10-20 00:48:20 +0200vicfred(~vicfred@user/vicfred)
2021-10-20 00:49:18 +0200brainfreeze(~brainfree@2a03:1b20:4:f011::20d)
2021-10-20 00:51:23 +0200ArtVandelayer(~ArtVandel@ip174-68-147-20.lv.lv.cox.net) (Ping timeout: 264 seconds)
2021-10-20 00:52:04 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2021-10-20 00:54:14 +0200voldial(~user@195.179.201.175) (Changing host)
2021-10-20 00:54:14 +0200voldial(~user@user/voldial)
2021-10-20 00:57:56 +0200tomsmeding(~tomsmedin@tomsmeding.com) (Ping timeout: 265 seconds)
2021-10-20 00:58:37 +0200beaky(~beaky@198.211.118.219) (Ping timeout: 252 seconds)
2021-10-20 00:59:00 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae) (Ping timeout: 258 seconds)
2021-10-20 00:59:14 +0200quintasan(~quassel@quintasan.pl) (Ping timeout: 265 seconds)
2021-10-20 00:59:23 +0200Dykam(Dykam@dykam.nl) (Ping timeout: 265 seconds)
2021-10-20 00:59:31 +0200synthmeat(~synthmeat@user/synthmeat) (Ping timeout: 268 seconds)
2021-10-20 00:59:34 +0200voldial(~user@user/voldial) (WeeChat 1.6)
2021-10-20 01:00:35 +0200dsrt^(~dsrt@68.101.53.15)
2021-10-20 01:02:42 +0200 <shapr> dsal: is it still downloading?
2021-10-20 01:04:08 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae)
2021-10-20 01:04:30 +0200zebrag(~chris@user/zebrag) (Quit: Konversation terminated!)
2021-10-20 01:09:04 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae) (Ping timeout: 252 seconds)
2021-10-20 01:09:37 +0200alzgh(~alzgh@user/alzgh) (Remote host closed the connection)
2021-10-20 01:09:57 +0200alzgh(~alzgh@user/alzgh)
2021-10-20 01:10:02 +0200 <Cajun> so im looking into a small project of changing a program from a pretty unorganized mtl stack (abusing a lot of state changing stuff) to some effect system and im wondering which library is the library of choice? fused-effects, polysemy, and freer-simple all look like good options
2021-10-20 01:11:08 +0200 <Cajun> s/?/.
2021-10-20 01:13:30 +0200lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-10-20 01:18:27 +0200 <oak-> I think polysemy had some problems with performance in the past (if that is a concern), but I'm not sure if it is already fixed. I think in the past it needed some GHC-patch
2021-10-20 01:19:05 +0200elmoloko(~Adium@2600:6c64:4a7f:faa6:2863:d742:7416:5b9e) (Quit: Leaving.)
2021-10-20 01:19:57 +0200 <ph88> I have a function [b] -> (Maybe a, [b]) what helper function can i use to keep my function running on [b] (using the output again as input) until i find Nothing and then returning ([Just a], [b]). I don't think i can use a normal foldl' here because the input is determined from the output of previous call
2021-10-20 01:21:07 +0200 <geekosaur> unfoldr?
2021-10-20 01:23:10 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae)
2021-10-20 01:23:49 +0200 <Cajun> well what inspired the project was this (https://reasonablypolymorphic.com/blog/porting-to-polysemy/index.html) post, and it seems like a very interesting system. i have no performance concerns (as long as it can still work at ~13fps in a console window, not a high bar)
2021-10-20 01:27:25 +0200Tuplanolla(~Tuplanoll@91-159-69-50.elisa-laajakaista.fi) (Quit: Leaving.)
2021-10-20 01:27:41 +0200synthmeat(~synthmeat@user/synthmeat)
2021-10-20 01:27:45 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae) (Ping timeout: 258 seconds)
2021-10-20 01:27:54 +0200tomsmeding(~tomsmedin@tomsmeding.com)
2021-10-20 01:28:29 +0200quintasan(~quassel@quintasan.pl)
2021-10-20 01:28:41 +0200 <ph88> geekosaur, that function looks pretty neat thanks
2021-10-20 01:36:47 +0200hexology(~hexology@user/hexology)
2021-10-20 01:39:14 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae)
2021-10-20 01:42:01 +0200ArtVandelayer(~ArtVandel@ip174-68-147-20.lv.lv.cox.net)
2021-10-20 01:42:10 +0200beaky(~beaky@2a03:b0c0:0:1010::1e:a001)
2021-10-20 01:43:43 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae) (Ping timeout: 252 seconds)
2021-10-20 01:43:58 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae)
2021-10-20 01:44:13 +0200lavaman(~lavaman@98.38.249.169)
2021-10-20 01:47:16 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Read error: Connection reset by peer)
2021-10-20 01:48:49 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2021-10-20 01:49:01 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 265 seconds)
2021-10-20 01:49:37 +0200pragma-(~chaos@user/pragmatic-chaos)
2021-10-20 01:49:41 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae) (Ping timeout: 245 seconds)
2021-10-20 01:50:06 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-20 01:52:29 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae)
2021-10-20 01:52:42 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Quit: Lost terminal)
2021-10-20 01:53:10 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-10-20 01:54:06 +0200pragma-(~chaos@user/pragmatic-chaos) (Client Quit)
2021-10-20 01:54:38 +0200 <dsal> shapr: oops. it broke because of libs. Got a call. Gonna try again.
2021-10-20 01:55:35 +0200pragma-(~chaos@user/pragmatic-chaos)
2021-10-20 01:55:51 +0200 <dsal> Oh yes. I remember now.
2021-10-20 01:55:59 +0200 <shapr> dsal: oh?
2021-10-20 01:56:43 +0200 <dsal> Pages of this sort of thing: https://usercontent.irccloud-cdn.com/file/sZpPstHP/errs.png
2021-10-20 01:56:52 +0200ystael(~ystael@user/ystael) (Ping timeout: 252 seconds)
2021-10-20 01:58:02 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae) (Ping timeout: 258 seconds)
2021-10-20 01:58:31 +0200ystael(~ystael@user/ystael)
2021-10-20 01:59:39 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Ping timeout: 265 seconds)
2021-10-20 02:01:26 +0200 <shapr> dsal: sounds like ghc 9 is not ready on M1 mac?
2021-10-20 02:01:41 +0200 <dsal> Yeah, didn't go well in my attempt.
2021-10-20 02:02:14 +0200 <shapr> so, ghc 8.10.7 on M1 mac, as long as you're using a newer version of networking if stack is involved
2021-10-20 02:02:36 +0200 <shapr> but not yet ghc 9 on M1 mac
2021-10-20 02:05:40 +0200 <dsal> Yeah, I've not had any problem with 8.10.7
2021-10-20 02:06:12 +0200 <dsal> Other than https://github.com/haskell/network/pull/510
2021-10-20 02:07:14 +0200unit73e(~emanuel@2001:818:e8dd:7c00:32b5:c2ff:fe6b:5291) (Ping timeout: 258 seconds)
2021-10-20 02:08:25 +0200abhixec(~abhixec@c-67-169-139-16.hsd1.ca.comcast.net) (Quit: leaving)
2021-10-20 02:10:13 +0200 <geekosaur> my u7nderstanding is 9.0.1 if it has any support at all is badly broken, and you need a newer 9.2 than the existing prerelease to get a working one
2021-10-20 02:10:38 +0200 <geekosaur> 8.10.7 aside from libs that need updates works, but goes via llvm instead of native code
2021-10-20 02:11:02 +0200 <shapr> geekosaur: thanks for the info
2021-10-20 02:11:36 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-20 02:11:36 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-20 02:11:36 +0200wroathe(~wroathe@user/wroathe)
2021-10-20 02:11:41 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Remote host closed the connection)
2021-10-20 02:12:06 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-20 02:12:35 +0200 <geekosaur> they had a lot of trouble getting the new sized stuff working, since apple's aarch64 abi requires things be passed as their actual sizes and not "rounded up" to a word like standard aarch64 or indeed most other abis
2021-10-20 02:12:42 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2021-10-20 02:12:59 +0200myShoggoth(~myShoggot@97-120-70-214.ptld.qwest.net) (Ping timeout: 264 seconds)
2021-10-20 02:13:35 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 264 seconds)
2021-10-20 02:13:41 +0200Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2021-10-20 02:14:17 +0200myShoggoth(~myShoggot@97-120-70-214.ptld.qwest.net)
2021-10-20 02:14:59 +0200Lord_of_Life_Lord_of_Life
2021-10-20 02:15:38 +0200emf(~emf@2620:10d:c090:400::5:c0de) (Quit: emf)
2021-10-20 02:16:14 +0200 <dsal> Oh weird.
2021-10-20 02:23:20 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Ping timeout: 258 seconds)
2021-10-20 02:23:31 +0200alx741(~alx741@186.178.109.50) (Quit: alx741)
2021-10-20 02:24:00 +0200MQ-17J(~MQ-17J@8.21.10.23)
2021-10-20 02:24:11 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae)
2021-10-20 02:25:13 +0200alx741(~alx741@186.178.109.50)
2021-10-20 02:25:43 +0200lavaman(~lavaman@98.38.249.169)
2021-10-20 02:28:49 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae) (Ping timeout: 252 seconds)
2021-10-20 02:30:10 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 260 seconds)
2021-10-20 02:30:59 +0200MQ-17J(~MQ-17J@8.21.10.23) (Ping timeout: 264 seconds)
2021-10-20 02:33:54 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-20 02:33:59 +0200myShoggoth(~myShoggot@97-120-70-214.ptld.qwest.net) (Ping timeout: 264 seconds)
2021-10-20 02:40:39 +0200fluffyballoon(~user@131.93.208.196)
2021-10-20 02:44:09 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 02:47:55 +0200theproffesor(~theproffe@2601:282:847f:8010::be7d)
2021-10-20 02:47:55 +0200theproffesor(~theproffe@2601:282:847f:8010::be7d) (Changing host)
2021-10-20 02:47:55 +0200theproffesor(~theproffe@user/theproffesor)
2021-10-20 02:49:25 +0200kupi(uid212005@id-212005.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-10-20 02:53:47 +0200ArtVandelayer(~ArtVandel@ip174-68-147-20.lv.lv.cox.net) (Ping timeout: 265 seconds)
2021-10-20 03:06:16 +0200acidjnk_new(~acidjnk@pd9e0b933.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2021-10-20 03:06:50 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Ping timeout: 265 seconds)
2021-10-20 03:06:55 +0200alzgh(~alzgh@user/alzgh) (Remote host closed the connection)
2021-10-20 03:08:44 +0200alzgh(~alzgh@user/alzgh)
2021-10-20 03:09:51 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-20 03:10:06 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 258 seconds)
2021-10-20 03:10:53 +0200Guest372(~xxx@47.245.54.240) (Remote host closed the connection)
2021-10-20 03:11:54 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2021-10-20 03:11:59 +0200Guest372(~xxx@47.245.54.240)
2021-10-20 03:12:57 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-10-20 03:13:01 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2021-10-20 03:13:06 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-10-20 03:14:11 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Ping timeout: 264 seconds)
2021-10-20 03:14:28 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-20 03:14:57 +0200alzgh(~alzgh@user/alzgh) (Remote host closed the connection)
2021-10-20 03:17:46 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 258 seconds)
2021-10-20 03:21:30 +0200segfaultfizzbuzz(~segfaultf@135-180-0-138.static.sonic.net) (Ping timeout: 260 seconds)
2021-10-20 03:22:26 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Ping timeout: 260 seconds)
2021-10-20 03:22:43 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-20 03:23:04 +0200k60(~k60@broadband-95-84-168-218.ip.moscow.rt.ru)
2021-10-20 03:26:32 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-20 03:26:32 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-20 03:26:32 +0200wroathe(~wroathe@user/wroathe)
2021-10-20 03:27:12 +0200mmhat(~mmh@55d45bcb.access.ecotel.net) (Quit: WeeChat 3.3)
2021-10-20 03:28:13 +0200peterhil(~peterhil@dsl-hkibng32-54fb56-2.dhcp.inet.fi)
2021-10-20 03:28:14 +0200gentauro(~gentauro@user/gentauro) (Read error: Connection reset by peer)
2021-10-20 03:28:33 +0200gentauro(~gentauro@user/gentauro)
2021-10-20 03:30:50 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 260 seconds)
2021-10-20 03:30:56 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Ping timeout: 245 seconds)
2021-10-20 03:31:13 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-20 03:35:09 +0200Cajun(~Cajun@user/cajun) (Quit: Client closed)
2021-10-20 03:37:37 +0200jespada(~jespada@2803:9800:9842:7a62:5d33:6404:2aef:9813) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-10-20 03:38:34 +0200slack1256(~slack1256@45.4.2.52)
2021-10-20 03:45:53 +0200Hima(~Hima_Bind@49.204.226.177)
2021-10-20 03:50:34 +0200_xor(~xor@72.49.199.147) (Read error: Connection reset by peer)
2021-10-20 03:52:23 +0200_xor(~xor@72.49.199.147)
2021-10-20 03:52:37 +0200 <Hima> hi there! I am quiet new here, please let me know if do something against code of conduct, I just want to know if anyone know how can i join #haskell-gsoc channel which is on freenode? I think it's no more on freenode.
2021-10-20 03:53:21 +0200 <Axman6> if it's anywhere, it should be here on libera - have you tried joining #freenode-gsoc?
2021-10-20 03:53:30 +0200 <Axman6> uh, #haskell-gsoc
2021-10-20 03:53:37 +0200 <Hima> no i will join rn
2021-10-20 03:53:46 +0200 <Hima> oh yes i did
2021-10-20 03:53:57 +0200 <Axman6> looks like it's not a thing
2021-10-20 03:54:05 +0200 <Hima> there's no one, and i am the op so i think it's no more the official room
2021-10-20 03:54:21 +0200 <Axman6> yeah it was created by you joining it (I did the same thing)
2021-10-20 03:54:41 +0200xff0x(~xff0x@2001:1a81:5338:8400:382c:44d1:e85b:95f9) (Ping timeout: 245 seconds)
2021-10-20 03:55:19 +0200 <Hima> haha, but they mentioned to join "There is also a relatively active IRC channel called #haskell-gsoc on freenode where you can ask for help."
2021-10-20 03:55:37 +0200 <Axman6> that was in the before times
2021-10-20 03:55:52 +0200 <Hima> by the way is this Haskell's official server?
2021-10-20 03:56:09 +0200 <Hima> yes, axman6 got it.
2021-10-20 03:56:20 +0200 <Axman6> well, it's where the freenode channel moved, so I guess so...
2021-10-20 03:56:37 +0200xff0x(~xff0x@2001:1a81:5213:b200:9d6e:5b31:ca1b:5892)
2021-10-20 03:56:48 +0200 <Axman6> I don't know who deems something official
2021-10-20 03:57:02 +0200 <Hima> okay
2021-10-20 03:57:23 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Ping timeout: 264 seconds)
2021-10-20 04:03:25 +0200myShoggoth(~myShoggot@97-120-85-195.ptld.qwest.net)
2021-10-20 04:05:03 +0200Hima(~Hima_Bind@49.204.226.177) ()
2021-10-20 04:11:41 +0200burnsidesLlama(~burnsides@dhcp168-039.wadham.ox.ac.uk)
2021-10-20 04:12:12 +0200fluffyballoon(~user@131.93.208.196) (Ping timeout: 258 seconds)
2021-10-20 04:12:37 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-20 04:17:02 +0200burnsidesLlama(~burnsides@dhcp168-039.wadham.ox.ac.uk) (Ping timeout: 260 seconds)
2021-10-20 04:17:30 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Ping timeout: 260 seconds)
2021-10-20 04:20:30 +0200k60(~k60@broadband-95-84-168-218.ip.moscow.rt.ru) (Quit: k60)
2021-10-20 04:20:38 +0200slack1256(~slack1256@45.4.2.52) (Ping timeout: 258 seconds)
2021-10-20 04:20:46 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-20 04:27:33 +0200myShoggoth(~myShoggot@97-120-85-195.ptld.qwest.net) (Ping timeout: 265 seconds)
2021-10-20 04:35:21 +0200 <sm> yes, it's the official IRC channel. there's also a matrix channel, slack channels, etc.
2021-10-20 04:36:03 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 276 seconds)
2021-10-20 04:37:33 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2021-10-20 04:43:01 +0200td_(~td@muedsl-82-207-238-089.citykom.de) (Ping timeout: 265 seconds)
2021-10-20 04:43:05 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Remote host closed the connection)
2021-10-20 04:43:58 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2021-10-20 04:44:24 +0200td_(~td@94.134.91.144)
2021-10-20 04:45:58 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 260 seconds)
2021-10-20 04:47:54 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2021-10-20 04:50:03 +0200 <DigitalKiwi> in my (github sponsors (1/10x dev gimmick)) contract it says i get 10k/mo for being in the channel but they haven't paid :( been here >10 years so back pay should be substantial if they do!
2021-10-20 04:50:29 +0200 <DigitalKiwi> https://github.com/sponsors/Kiwi/
2021-10-20 04:51:51 +0200 <DigitalKiwi> in haskell foundation slack too should be living large any day now!
2021-10-20 04:52:10 +0200myShoggoth(~myShoggot@97-120-85-195.ptld.qwest.net)
2021-10-20 04:58:03 +0200trillp(~trillp@69.233.98.238)
2021-10-20 04:58:58 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Ping timeout: 258 seconds)
2021-10-20 05:02:31 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae)
2021-10-20 05:03:40 +0200lbseale(~lbseale@user/ep1ctetus) (Read error: Connection reset by peer)
2021-10-20 05:05:25 +0200ArtVandelayer(~ArtVandel@ip174-68-147-20.lv.lv.cox.net)
2021-10-20 05:07:24 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae) (Ping timeout: 258 seconds)
2021-10-20 05:07:50 +0200alx741(~alx741@186.178.109.50) (Quit: alx741)
2021-10-20 05:10:50 +0200pragma-(~chaos@user/pragmatic-chaos) (Bye!)
2021-10-20 05:13:32 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Read error: Connection reset by peer)
2021-10-20 05:13:46 +0200lavaman(~lavaman@98.38.249.169)
2021-10-20 05:14:14 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 05:18:21 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-20 05:18:23 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 264 seconds)
2021-10-20 05:19:10 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae)
2021-10-20 05:23:43 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae) (Ping timeout: 252 seconds)
2021-10-20 05:27:32 +0200econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2021-10-20 05:33:07 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer)
2021-10-20 05:35:30 +0200falafel(~falafel@2603-8000-d800-688c-c469-52c4-b20d-779e.res6.spectrum.com)
2021-10-20 05:36:42 +0200stengah(~stengah@user/stengah)
2021-10-20 05:39:13 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 258 seconds)
2021-10-20 05:48:58 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 05:54:23 +0200myShoggoth(~myShoggot@97-120-85-195.ptld.qwest.net) (Ping timeout: 264 seconds)
2021-10-20 06:03:22 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae)
2021-10-20 06:08:01 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae) (Ping timeout: 245 seconds)
2021-10-20 06:14:33 +0200unit73e(~emanuel@2001:818:e8dd:7c00:32b5:c2ff:fe6b:5291)
2021-10-20 06:14:43 +0200monochrom(trebla@216.138.220.146) (Quit: NO CARRIER)
2021-10-20 06:15:05 +0200 <conjunctive> Hi, does anyone have an example on how to parse a 32-bit float in BE from a ByteString with Attoparsec?
2021-10-20 06:17:11 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-20 06:17:11 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-20 06:17:11 +0200wroathe(~wroathe@user/wroathe)
2021-10-20 06:17:52 +0200 <pavonia> Workaround: Parse 4 bytes and feed the result to the appropriate Data.Binary.Get function
2021-10-20 06:18:56 +0200fawful(~guy@c-76-104-217-93.hsd1.wa.comcast.net) (Quit: WeeChat 3.2)
2021-10-20 06:19:11 +0200 <pavonia> conjunctive: Or even better, use https://hackage.haskell.org/package/attoparsec-binary-0.2/docs/Data-Attoparsec-Binary.html
2021-10-20 06:23:58 +0200boxscape_(~boxscape_@p54a3581e.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2021-10-20 06:24:58 +0200bitmapper(uid464869@id-464869.lymington.irccloud.com)
2021-10-20 06:26:43 +0200 <conjunctive> Hmm I don't see any float-specific functions in attoparsec-binary. I know there's a way to use scientific and convert to a float afterwards, but was hoping to find something more direct.
2021-10-20 06:26:56 +0200[Kalisto](~nico@user/kalisto/x-8968079) (Ping timeout: 265 seconds)
2021-10-20 06:27:19 +0200mbuf(~Shakthi@122.178.207.237)
2021-10-20 06:29:32 +0200monochrom(trebla@216.138.220.146)
2021-10-20 06:30:59 +0200falafel(~falafel@2603-8000-d800-688c-c469-52c4-b20d-779e.res6.spectrum.com) (Ping timeout: 264 seconds)
2021-10-20 06:33:14 +0200[Kalisto](~nico@user/kalisto/x-8968079)
2021-10-20 06:33:25 +0200coot(~coot@37.30.48.91.nat.umts.dynamic.t-mobile.pl)
2021-10-20 06:38:19 +0200falafel(~falafel@2603-8000-d800-688c-c469-52c4-b20d-779e.res6.spectrum.com)
2021-10-20 06:38:54 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae)
2021-10-20 06:39:58 +0200trillp(~trillp@69.233.98.238) ()
2021-10-20 06:44:01 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae) (Ping timeout: 252 seconds)
2021-10-20 06:45:45 +0200 <pavonia> Oh floats, sorry
2021-10-20 06:46:39 +0200 <conjunctive> no worries! appreciate the suggestion :)
2021-10-20 06:47:37 +0200 <pavonia> Looks like Data.Binary just does a casting from Int to Float internally with the read bytes: https://hackage.haskell.org/package/binary-0.10.0.0/docs/src/Data.Binary.FloatCast.html#wordToFloat
2021-10-20 06:47:56 +0200 <pavonia> So it should be easy to adapt this for attoparsec
2021-10-20 06:54:23 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 264 seconds)
2021-10-20 07:00:33 +0200 <dsal> Man. Amazonka changed a lot.
2021-10-20 07:00:43 +0200 <dsal> The changelog doesn't do it justice.
2021-10-20 07:03:16 +0200NataSa23F(~KELEBEK@188.119.58.106)
2021-10-20 07:05:05 +0200unit73e(~emanuel@2001:818:e8dd:7c00:32b5:c2ff:fe6b:5291) (Ping timeout: 258 seconds)
2021-10-20 07:08:38 +0200aa(~douglasco@200.146.85.128.static.gvt.net.br)
2021-10-20 07:08:53 +0200ChaiTRex(~ChaiTRex@user/chaitrex) (Quit: ChaiTRex)
2021-10-20 07:09:25 +0200NataSa23F(~KELEBEK@188.119.58.106) (K-Lined)
2021-10-20 07:10:40 +0200ChaiTRex(~ChaiTRex@user/chaitrex)
2021-10-20 07:11:08 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-20 07:11:08 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-20 07:11:08 +0200wroathe(~wroathe@user/wroathe)
2021-10-20 07:11:34 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae)
2021-10-20 07:12:23 +0200douglascorrea_io(~douglasco@200.146.85.128.static.gvt.net.br) (Ping timeout: 264 seconds)
2021-10-20 07:14:17 +0200jlamothe(~jlamothe@198.251.61.229) (Ping timeout: 258 seconds)
2021-10-20 07:15:46 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 260 seconds)
2021-10-20 07:15:49 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae) (Ping timeout: 258 seconds)
2021-10-20 07:17:35 +0200[Kalisto]_(~nico@user/kalisto/x-8968079)
2021-10-20 07:17:38 +0200[Kalisto](~nico@user/kalisto/x-8968079) (Ping timeout: 260 seconds)
2021-10-20 07:17:55 +0200Hecateis the proud parent of a newborn library https://github.com/Kleidukos/display/
2021-10-20 07:22:19 +0200Moyst_(~moyst@user/moyst)
2021-10-20 07:24:10 +0200peterhil(~peterhil@dsl-hkibng32-54fb56-2.dhcp.inet.fi) (Ping timeout: 260 seconds)
2021-10-20 07:24:43 +0200Moyst(~moyst@user/moyst) (Ping timeout: 252 seconds)
2021-10-20 07:24:43 +0200 <awpr> nice, that sounds like the perfect complement to `portray`
2021-10-20 07:25:10 +0200 <awpr> user-facing, pretty, and not Haskell syntax, vs. developer-facing, pretty, and Haskell syntax
2021-10-20 07:32:12 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-20 07:32:12 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-20 07:32:12 +0200wroathe(~wroathe@user/wroathe)
2021-10-20 07:36:54 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 258 seconds)
2021-10-20 07:37:50 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2021-10-20 07:38:10 +0200remexre(~nathan@user/remexre) (Quit: WeeChat 3.1)
2021-10-20 07:38:19 +0200remexre(~nathan@207-153-38-50.fttp.usinternet.com)
2021-10-20 07:39:06 +0200remexre(~nathan@207-153-38-50.fttp.usinternet.com) (Client Quit)
2021-10-20 07:39:23 +0200remexre(~remexre@user/remexre)
2021-10-20 07:40:34 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 07:43:02 +0200Cajun(~Cajun@user/cajun)
2021-10-20 07:45:10 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 07:49:17 +0200lavaman(~lavaman@98.38.249.169)
2021-10-20 07:54:02 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 260 seconds)
2021-10-20 07:55:48 +0200mei(~mei@user/mei)
2021-10-20 08:00:52 +0200Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de)
2021-10-20 08:01:20 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2021-10-20 08:02:40 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2021-10-20 08:09:58 +0200fendor(~fendor@91.141.32.154.wireless.dyn.drei.com)
2021-10-20 08:13:17 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 08:13:37 +0200slowButPresent(~slowButPr@user/slowbutpresent) (Quit: leaving)
2021-10-20 08:18:06 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-10-20 08:21:46 +0200falafel(~falafel@2603-8000-d800-688c-c469-52c4-b20d-779e.res6.spectrum.com) (Ping timeout: 245 seconds)
2021-10-20 08:22:40 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2021-10-20 08:25:13 +0200stiell(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2021-10-20 08:26:28 +0200stiell(~stiell@gateway/tor-sasl/stiell)
2021-10-20 08:28:58 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Quit: ZNC - https://znc.in)
2021-10-20 08:29:13 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2021-10-20 08:32:19 +0200michalz(~michalz@185.246.204.93)
2021-10-20 08:36:27 +0200max22-(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr)
2021-10-20 08:43:54 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:8daf:444e:9c84:5148)
2021-10-20 08:47:22 +0200rkrishnan(~user@2402:e280:215c:2cd:d6b1:e062:567:7a9c)
2021-10-20 08:49:39 +0200dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be)
2021-10-20 08:51:46 +0200jonathanx(~jonathan@dyn-8-sc.cdg.chalmers.se) (Ping timeout: 245 seconds)
2021-10-20 08:52:45 +0200gehmehgeh(~user@user/gehmehgeh)
2021-10-20 08:57:20 +0200ircbrowse_tom(~ircbrowse@2a01:4f8:1c1c:9319::1) (ZNC 1.7.5+deb4 - https://znc.in)
2021-10-20 08:57:34 +0200ircbrowse_tom_(~ircbrowse@static.162.49.55.162.clients.your-server.de)
2021-10-20 08:57:36 +0200Server+Cnt
2021-10-20 08:57:56 +0200amir_(sid22336@user/amir)
2021-10-20 08:58:02 +0200ikex1(ash@user/ikex)
2021-10-20 08:58:06 +0200davl(~davl@207.154.228.18)
2021-10-20 08:58:20 +0200amir_Guest6318
2021-10-20 08:58:22 +0200mei(~mei@user/mei) (Read error: Connection reset by peer)
2021-10-20 08:58:30 +0200codolio(~dolio@130.44.130.54)
2021-10-20 08:59:02 +0200mei(~mei@user/mei)
2021-10-20 08:59:15 +0200jonathanx(~jonathan@178.174.176.109)
2021-10-20 08:59:34 +0200piele_(~piele@tbonesteak.creativeserver.net)
2021-10-20 09:00:10 +0200platz_(~platz@40.122.118.113)
2021-10-20 09:00:12 +0200Tordek_(tordek@triton.blinkenshell.org)
2021-10-20 09:00:17 +0200opqdonut_(opqdonut@pseudo.fixme.fi)
2021-10-20 09:00:22 +0200some02_(~cat@h-98-128-128-173.A351.priv.bahnhof.se)
2021-10-20 09:00:34 +0200ski_(~ski@remote12.chalmers.se)
2021-10-20 09:00:39 +0200Rembane_(~Rembane@li346-36.members.linode.com)
2021-10-20 09:00:42 +0200nckx_(~nckx@tobias.gr)
2021-10-20 09:01:07 +0200urdh_(~urdh@user/urdh)
2021-10-20 09:03:05 +0200sm[i]_(~user@li229-222.members.linode.com)
2021-10-20 09:05:19 +0200acowley_(~acowley@c-68-83-22-43.hsd1.nj.comcast.net)
2021-10-20 09:07:59 +0200brainfreeze(~brainfree@2a03:1b20:4:f011::20d) (Quit: Leaving)
2021-10-20 09:09:03 +0200coot(~coot@37.30.48.91.nat.umts.dynamic.t-mobile.pl) (Read error: Connection reset by peer)
2021-10-20 09:09:50 +0200ikex(~ash@user/ikex) (Ping timeout: 260 seconds)
2021-10-20 09:09:50 +0200Franciman(~Franciman@mx1.fracta.dev) (Ping timeout: 260 seconds)
2021-10-20 09:09:50 +0200davl_(~davl@207.154.228.18) (Ping timeout: 260 seconds)
2021-10-20 09:09:50 +0200ircbrowse_tom(~ircbrowse@2a01:4f8:1c1c:9319::1) (Ping timeout: 260 seconds)
2021-10-20 09:09:50 +0200kosmikus[m](~andresloe@2001:470:69fc:105::95d) (Ping timeout: 260 seconds)
2021-10-20 09:09:50 +0200monadfritz[m](~ahdytmatr@2001:470:69fc:105::e1f1) (Ping timeout: 260 seconds)
2021-10-20 09:09:50 +0200stoicswe[m](~deadlette@2001:470:69fc:105::d277) (Ping timeout: 260 seconds)
2021-10-20 09:09:50 +0200ikex1ikex
2021-10-20 09:09:50 +0200Orbstheorem(~orbstheor@2001:470:69fc:105::a56) (Ping timeout: 260 seconds)
2021-10-20 09:09:50 +0200kevin[m]1(~pnotequal@2001:470:69fc:105::a54) (Ping timeout: 260 seconds)
2021-10-20 09:09:50 +0200schuelermine[m](~schuelerm@user/schuelermine) (Ping timeout: 260 seconds)
2021-10-20 09:09:50 +0200carmysilna(~brightly-@2001:470:69fc:105::2190) (Ping timeout: 260 seconds)
2021-10-20 09:09:50 +0200dolio(~dolio@130.44.130.54) (Ping timeout: 260 seconds)
2021-10-20 09:09:50 +0200amir(sid22336@user/amir) (Ping timeout: 260 seconds)
2021-10-20 09:09:50 +0200jonrh(sid5185@ilkley.irccloud.com) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200opqdonut(opqdonut@pseudo.fixme.fi) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200Tordek(tordek@triton.blinkenshell.org) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200some02(~cat@h-98-128-128-173.A351.priv.bahnhof.se) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200deni(~deni@mail.denibertovic.com) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200Unhammer(~Unhammer@user/unhammer) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200platz(~platz@user/platz) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200nckx(~nckx@tobias.gr) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200ski(~ski@remote12.chalmers.se) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200acowley(~acowley@c-68-83-22-43.hsd1.nj.comcast.net) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200oak-(~oakuniver@2001:470:69fc:105::fcd) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200ixlun(~ixlun@2001:470:69fc:105::41b3) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200moats(~oats@user/oats) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200dextaa(~DV@user/dextaa) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200piele(~piele@tbonesteak.creativeserver.net) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200superbil(~superbil@1-34-176-171.hinet-ip.hinet.net) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200urdh(~urdh@user/urdh) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200sm[i](~user@plaintextaccounting/sm) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200Rembane(~Rembane@li346-36.members.linode.com) (Ping timeout: 260 seconds)
2021-10-20 09:09:51 +0200niko(~niko@libera/staff/niko) (Ping timeout: 615 seconds)
2021-10-20 09:09:51 +0200Guest6318amir
2021-10-20 09:09:51 +0200jonrh_jonrh
2021-10-20 09:09:51 +0200dextaa3dextaa
2021-10-20 09:09:51 +0200nckx_nckx
2021-10-20 09:09:51 +0200urdh_urdh
2021-10-20 09:10:17 +0200tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2021-10-20 09:10:21 +0200Franciman(~Franciman@mx1.fracta.dev)
2021-10-20 09:10:42 +0200ArctVaulMarsHMPJ(~pjetcetal@2.95.44.252)
2021-10-20 09:10:50 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-10-20 09:10:52 +0200ArctVaulMarsHMPJ(~pjetcetal@2.95.44.252) (Read error: Connection reset by peer)
2021-10-20 09:11:38 +0200deni(~deni@mail.denibertovic.com)
2021-10-20 09:11:45 +0200niko(~niko@libera/staff/niko)
2021-10-20 09:11:48 +0200stoicswe[m](~deadlette@2001:470:69fc:105::d277)
2021-10-20 09:11:59 +0200Unhammer(~Unhammer@user/unhammer)
2021-10-20 09:12:02 +0200deniGuest9608
2021-10-20 09:12:03 +0200ubert(~Thunderbi@91.141.37.135.wireless.dyn.drei.com)
2021-10-20 09:12:21 +0200stengah(~stengah@user/stengah) (Ping timeout: 258 seconds)
2021-10-20 09:12:43 +0200superbil(~superbil@1-34-176-171.hinet-ip.hinet.net)
2021-10-20 09:13:28 +0200schuelermine[m](~schuelerm@user/schuelermine)
2021-10-20 09:13:32 +0200Orbstheorem(~orbstheor@2001:470:69fc:105::a56)
2021-10-20 09:13:52 +0200kevin[m]1(~pnotequal@2001:470:69fc:105::a54)
2021-10-20 09:14:20 +0200coot(~coot@37.30.48.91.nat.umts.dynamic.t-mobile.pl)
2021-10-20 09:14:21 +0200monadfritz[m](~ahdytmatr@2001:470:69fc:105::e1f1)
2021-10-20 09:15:02 +0200ubert1(~Thunderbi@91.141.37.135.wireless.dyn.drei.com)
2021-10-20 09:15:50 +0200kosmikus[m](~andresloe@2001:470:69fc:105::95d)
2021-10-20 09:15:54 +0200carmysilna(~brightly-@2001:470:69fc:105::2190)
2021-10-20 09:16:42 +0200moats(~oats@user/oats)
2021-10-20 09:17:03 +0200oak-(~oakuniver@2001:470:69fc:105::fcd)
2021-10-20 09:18:03 +0200burnsidesLlama(~burnsides@dhcp168-039.wadham.ox.ac.uk)
2021-10-20 09:18:11 +0200ixlun(~ixlun@2001:470:69fc:105::41b3)
2021-10-20 09:22:58 +0200ArctVaulMarsHMPJ(~pjetcetal@2.95.44.252)
2021-10-20 09:23:28 +0200ArctVaulMarsHMPJ(~pjetcetal@2.95.44.252) (Remote host closed the connection)
2021-10-20 09:24:19 +0200chele(~chele@user/chele)
2021-10-20 09:26:49 +0200sprout(~quassel@2a02:a467:ccd6:1:75c6:cb1e:9970:92ae)
2021-10-20 09:30:29 +0200 <DigitalKiwi> Hecate: can you write kommissar with it
2021-10-20 09:32:40 +0200o1lo01ol1o(~o1lo01ol1@2001:8a0:6d7a:df01:d1f9:60a1:52fb:92f3) (Ping timeout: 258 seconds)
2021-10-20 09:33:31 +0200natechan(~nate@108-233-125-227.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 265 seconds)
2021-10-20 09:36:22 +0200o1lo01ol1o(~o1lo01ol1@2001:8a0:6d7a:df01:d1f9:60a1:52fb:92f3)
2021-10-20 09:37:55 +0200vicfred(~vicfred@user/vicfred) (Quit: Leaving)
2021-10-20 09:39:03 +0200cfricke(~cfricke@user/cfricke)
2021-10-20 09:41:29 +0200o1lo01ol1o(~o1lo01ol1@2001:8a0:6d7a:df01:d1f9:60a1:52fb:92f3) (Ping timeout: 258 seconds)
2021-10-20 09:42:59 +0200renzhi(~xp@2607:fa49:6500:b100::6e7f) (Ping timeout: 264 seconds)
2021-10-20 09:43:40 +0200cfricke(~cfricke@user/cfricke) (Ping timeout: 260 seconds)
2021-10-20 09:46:09 +0200 <dminuoso> Axman6: So what do you want to know about our SDN compiler?
2021-10-20 09:47:36 +0200 <dminuoso> It's nothing fancy. Very broadly you configure some edge port to be in some L3 or L2 domain in our DCIM/IPAM tool (netbox), and our haskell program takes the entire description, turns it into intermediate representations, does some graph things, validates certain properties, turns into vendor agnostic specification, which are turned into vendor specific configurations.
2021-10-20 09:47:49 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 09:47:59 +0200 <dminuoso> All under the assumption that we have a semantic underlay
2021-10-20 09:48:30 +0200 <dminuoso> And then we throw that into the entirety of our core network, run `ifreload -a`, and then go on with our coffee.
2021-10-20 09:55:05 +0200phma_(~phma@host-67-44-209-75.hnremote.net)
2021-10-20 09:56:30 +0200o1lo01ol1o(~o1lo01ol1@2001:8a0:6d7a:df01:d1f9:60a1:52fb:92f3)
2021-10-20 09:57:15 +0200absence(torgeihe@hildring.pvv.ntnu.no) (Quit: Changing server)
2021-10-20 09:57:35 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:9105:355e:98db:81cc) (Remote host closed the connection)
2021-10-20 09:57:46 +0200cfricke(~cfricke@user/cfricke)
2021-10-20 09:58:10 +0200absence(torgeihe@hildring.pvv.ntnu.no)
2021-10-20 09:58:21 +0200absence(torgeihe@hildring.pvv.ntnu.no) (Client Quit)
2021-10-20 09:58:44 +0200phma(~phma@host-67-44-209-75.hnremote.net) (Ping timeout: 258 seconds)
2021-10-20 10:06:00 +0200jlamothe(~jlamothe@198.251.61.229)
2021-10-20 10:06:50 +0200fef(~thedawn@user/thedawn)
2021-10-20 10:09:17 +0200hendursa1(~weechat@user/hendursaga)
2021-10-20 10:12:45 +0200hendursaga(~weechat@user/hendursaga) (Ping timeout: 276 seconds)
2021-10-20 10:17:29 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-10-20 10:17:30 +0200burnsidesLlama(~burnsides@dhcp168-039.wadham.ox.ac.uk) (Remote host closed the connection)
2021-10-20 10:17:54 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-10-20 10:23:21 +0200 <Franciman> do you know of any wiki written in haskell?
2021-10-20 10:24:30 +0200kayprish(~kayprish@46.240.130.158)
2021-10-20 10:26:16 +0200acidjnk_new(~acidjnk@p200300d0c703cb955960125781424a48.dip0.t-ipconnect.de)
2021-10-20 10:26:56 +0200shriekingnoise(~shrieking@186.137.144.80) (Quit: Quit)
2021-10-20 10:28:52 +0200enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7)
2021-10-20 10:34:03 +0200mei(~mei@user/mei) (Read error: Connection reset by peer)
2021-10-20 10:35:10 +0200hnOsmium0001(uid453710@id-453710.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-10-20 10:38:17 +0200Teacup(~teacup@user/teacup) (Ping timeout: 265 seconds)
2021-10-20 10:38:46 +0200coot(~coot@37.30.48.91.nat.umts.dynamic.t-mobile.pl) (Ping timeout: 260 seconds)
2021-10-20 10:40:17 +0200 <dhouthoo> Franciman: gitit
2021-10-20 10:40:38 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 10:41:02 +0200 <Franciman> dhouthoo: https://en.wikipedia.org/wiki/Gitit_(software) <- ?
2021-10-20 10:41:43 +0200 <dhouthoo> yes
2021-10-20 10:41:51 +0200 <Franciman> thanks
2021-10-20 10:42:01 +0200 <Franciman> I freaking love the image of the dog with the freesbie
2021-10-20 10:42:04 +0200 <Franciman> T.T
2021-10-20 10:42:21 +0200kuribas(~user@ptr-25vy0i7zawtky0bq46n.18120a2.ip6.access.telenet.be)
2021-10-20 10:43:02 +0200 <kuribas> isn't there a point where you abolish the combinatory cleverness, and just write something slightly verbose, but easy to write?
2021-10-20 10:43:25 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 10:44:06 +0200bitmapper(uid464869@id-464869.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2021-10-20 10:44:33 +0200Teacup(~teacup@user/teacup)
2021-10-20 10:45:51 +0200__monty__(~toonn@user/toonn)
2021-10-20 10:49:02 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 10:58:01 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:9105:355e:98db:81cc)
2021-10-20 11:00:32 +0200burnsidesLlama(~burnsides@dhcp168-039.wadham.ox.ac.uk)
2021-10-20 11:00:34 +0200zaquest(~notzaques@5.128.210.178) (Remote host closed the connection)
2021-10-20 11:02:31 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:9105:355e:98db:81cc) (Ping timeout: 252 seconds)
2021-10-20 11:02:39 +0200zaquest(~notzaques@5.128.210.178)
2021-10-20 11:05:11 +0200 <kuribas> concise code can be elegant, but for production I sometimes just want it to work.
2021-10-20 11:05:21 +0200 <kuribas> Even if there is a potentially much more clever solution.
2021-10-20 11:06:50 +0200phma(~phma@host-67-44-209-75.hnremote.net)
2021-10-20 11:10:02 +0200acidjnk_new(~acidjnk@p200300d0c703cb955960125781424a48.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2021-10-20 11:10:02 +0200phma_(~phma@host-67-44-209-75.hnremote.net) (Ping timeout: 260 seconds)
2021-10-20 11:16:00 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 11:16:24 +0200acidjnk_new(~acidjnk@p200300d0c703cb955960125781424a48.dip0.t-ipconnect.de)
2021-10-20 11:20:46 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 258 seconds)
2021-10-20 11:20:48 +0200o1lo01ol1o(~o1lo01ol1@2001:8a0:6d7a:df01:d1f9:60a1:52fb:92f3) (Remote host closed the connection)
2021-10-20 11:21:24 +0200o1lo01ol1o(~o1lo01ol1@2001:8a0:6d7a:df01:d1f9:60a1:52fb:92f3)
2021-10-20 11:21:36 +0200stengah(~stengah@user/stengah)
2021-10-20 11:25:56 +0200o1lo01ol1o(~o1lo01ol1@2001:8a0:6d7a:df01:d1f9:60a1:52fb:92f3) (Ping timeout: 245 seconds)
2021-10-20 11:26:28 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2021-10-20 11:26:52 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2021-10-20 11:28:32 +0200o1lo01ol1o(~o1lo01ol1@2001:8a0:6d7a:df01:d1f9:60a1:52fb:92f3)
2021-10-20 11:31:55 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 11:32:12 +0200o1lo01ol1o(~o1lo01ol1@2001:8a0:6d7a:df01:d1f9:60a1:52fb:92f3) (Remote host closed the connection)
2021-10-20 11:35:04 +0200some02_(~cat@h-98-128-128-173.A351.priv.bahnhof.se) ()
2021-10-20 11:36:50 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 11:39:43 +0200 <Inst> Can I ask a question about Haskell?
2021-10-20 11:39:52 +0200 <Inst> How good is the Haskell library support?
2021-10-20 11:44:28 +0200sudden(~cat@user/sudden)
2021-10-20 11:44:40 +0200 <kuribas> Do you mean if there are many libraries?
2021-10-20 11:51:09 +0200 <Inst> I want to use Haskell as a general purpose language, i.e, do most of my programming in Haskell
2021-10-20 11:51:33 +0200 <yushyin> https://github.com/Gabriel439/post-rfc/blob/main/sotu.md maybe this helps
2021-10-20 11:51:34 +0200 <Inst> it'd have to beat C++ and Python / Javascript for general purpose programming, i.e, C++ gets picked up
2021-10-20 11:51:52 +0200 <Inst> for performance, Javascript for web development
2021-10-20 11:52:00 +0200 <Inst> Thanks
2021-10-20 11:52:05 +0200 <kuribas> Inst: why would it?
2021-10-20 11:52:39 +0200 <Inst> I just want to have a use case for Haskell
2021-10-20 11:52:40 +0200 <maerwald> beating C++ and python ecosystem isn't what Haskell can offer
2021-10-20 11:52:55 +0200 <kuribas> Inst: you use haskell because you want good performance and robustness.
2021-10-20 11:53:38 +0200 <kuribas> Inst: neither C++ or Python give you robustness, and Python is only performant if you use C library bindings.
2021-10-20 11:54:00 +0200 <maerwald> python can satisfy high-performance applications
2021-10-20 11:54:21 +0200 <maerwald> kuribas: well, same goes for haskell
2021-10-20 11:54:45 +0200 <Inst> I want to reasonably do most of my code in Haskell
2021-10-20 11:54:52 +0200 <maerwald> e.g. I just switched from yaml (where the core is C) to HsYAML (pure haskell) and the performance got 10 times worse
2021-10-20 11:55:00 +0200 <Inst> erm, be justified if I opt to be primarily a Haskell programmer
2021-10-20 11:55:15 +0200 <troydm> trying to write a stack.yml file for an existing haskell project and I'm having trouble compiling it with issues like
2021-10-20 11:55:26 +0200 <troydm> Cabal-simple_mPHDZzAJ_3.2.1.0_ghc-8.10.7: The program 'c2hs' version >=0.15 is
2021-10-20 11:55:40 +0200 <kuribas> Inst: if it's for hobby, then haskell could be all you need.
2021-10-20 11:55:45 +0200 <troydm> isn't c2hs part of ghc distribution in Haskell and should be added to PATH?
2021-10-20 11:56:00 +0200 <Inst> kuribas: that's sort of the argument I'm making and getting lots of pushback on
2021-10-20 11:56:14 +0200 <Inst> that Haskell is an ideal hobbyist / non-professional language
2021-10-20 11:56:37 +0200 <kuribas> Inst: it's not ideal IMO. Python is better for hobbyists.
2021-10-20 11:56:59 +0200 <Inst> except Python doesn't produce robust code except with extensive testing?
2021-10-20 11:57:16 +0200 <kuribas> Which is usually not a priority for hobbyists.
2021-10-20 11:57:40 +0200 <maerwald> troydm: no it isn't
2021-10-20 11:57:49 +0200 <Inst> should it be a priority?
2021-10-20 11:58:08 +0200 <maerwald> troydm: hsc2hs is
2021-10-20 11:58:20 +0200 <lortabac> if it's a hobby, you can do whatever you want
2021-10-20 11:58:21 +0200 <troydm> ./snapshots/x86_64-linux-tinfo6/a9e764900658a3a32616042d51034aed40b88e23187d2aa53933d7c0f2be2a09/8.10.7/bin/c2hs
2021-10-20 11:58:29 +0200 <troydm> it's from .stack dir
2021-10-20 11:58:31 +0200 <kuribas> Inst: by definition of "hobbyist", there isn't. You do what you want as long as you enjoy it.
2021-10-20 11:58:33 +0200 <lortabac> just use whatever language you feel like using
2021-10-20 11:58:37 +0200 <troydm> so program itself is installed
2021-10-20 11:58:45 +0200 <maerwald> troydm: so?
2021-10-20 11:58:55 +0200 <lortabac> I do all my hobby projects in Prolog, just because I can
2021-10-20 11:59:01 +0200 <maerwald> c2hs is not part of ghc distribution
2021-10-20 11:59:16 +0200 <maerwald> what stack does is something orthogonal
2021-10-20 11:59:20 +0200 <Inst> also, a question
2021-10-20 11:59:29 +0200 <Inst> how much faster is Haskell to develop in
2021-10-20 11:59:33 +0200 <Inst> compared to other languages?
2021-10-20 11:59:42 +0200 <maerwald> Inst: usually slower in the beginning
2021-10-20 11:59:56 +0200 <kuribas> Inst: I'd say faster when you experienced, slower when you start out.
2021-10-20 11:59:57 +0200 <troydm> maerwald: okey so how do I make it so it would be dependency and added to PATH during compilation?
2021-10-20 12:00:10 +0200 <maerwald> troydm: add it to build-depends in your cabal file
2021-10-20 12:00:32 +0200 <maerwald> https://cabal.readthedocs.io/en/latest/cabal-package.html?highlight=build-tool#pkg-field-build-too…
2021-10-20 12:00:34 +0200 <kuribas> Inst: also, it's only faster if you count testing and quality assurance. Often people get out programs quickly, which then are full of bugs.
2021-10-20 12:00:58 +0200 <Inst> put another way, say a manager has the brainpower needed to get good at haskell
2021-10-20 12:01:14 +0200 <maerwald> when all I do is *prototype*, then I don't have a difference of number in bugs, no matter wheter I use Haskell, python or rust
2021-10-20 12:01:33 +0200 <maerwald> when I maintain a project for a longer period of time, then that number becomes different across languages
2021-10-20 12:01:34 +0200 <Inst> does haskell have a use-case, i.e, if s/he wants the IT department to recycle his or her code
2021-10-20 12:01:46 +0200 <Inst> it's less likely to be garbage that has to be completely reimplemented?
2021-10-20 12:01:52 +0200 <troydm> what's the difference between hsc2hs and c2hs?
2021-10-20 12:02:22 +0200 <troydm> I see that hsc2hs is listed as build-tools
2021-10-20 12:02:35 +0200 <troydm> so it seems like it should actually work, but it's not
2021-10-20 12:02:37 +0200 <maerwald> Inst: I don't understand the question
2021-10-20 12:02:49 +0200 <kuribas> Inst: it forces you to think about program structure and state, so yes :)
2021-10-20 12:02:55 +0200 <yushyin> troydm: http://blog.ezyang.com/2010/06/the-haskell-preprocessor-hierarchy/
2021-10-20 12:03:19 +0200 <kuribas> Inst: as in, you either produce something that is well structured, or you give up in tears.
2021-10-20 12:03:22 +0200 <Inst> maerwald: let's say someone is a hobbyist programmer, but they're working for a small organization that doesn't have development resources out the wazoo
2021-10-20 12:03:28 +0200 <maerwald> Haskell doesn't solve your engineering problems if you have poor engineers
2021-10-20 12:03:31 +0200 <troydm> yushyin: okey, this suddenly gotten weirdly complicated
2021-10-20 12:03:51 +0200 <kuribas> maerwald: haskell doesn't solve any engineering problem.
2021-10-20 12:04:04 +0200 <kuribas> It just provide tools and means to abstract your engineering problem.
2021-10-20 12:04:16 +0200 <kuribas> It assumes you have solved the problem already.
2021-10-20 12:04:30 +0200 <maerwald> invest in good engineers, then let them worry about language choice
2021-10-20 12:04:45 +0200 <kuribas> With the abstractions you can structure it in a nice way that makes the business logic more clear.
2021-10-20 12:05:07 +0200 <Inst> they end up producing the initial code for a project before IT takes over
2021-10-20 12:05:36 +0200 <maerwald> Inst: write the code in the simplest possible language if non-programmers or devops have to take it over
2021-10-20 12:05:37 +0200 <yushyin> troydm: It is not complicated, but gives a good overview. It is not a long read.
2021-10-20 12:05:43 +0200 <Inst> i see
2021-10-20 12:06:07 +0200Guest2920(~Guest29@net-93-151-133-175.cust.dsl.teletu.it)
2021-10-20 12:06:07 +0200 <Inst> yeah, the problem with this use case is assuming the It department knows Haskell and can evaluate whether the code can be reused or if it has to be junked
2021-10-20 12:06:20 +0200 <Inst> more likely it'll be junked because the IT department doesn't know Haskell and can't properly evaluate it
2021-10-20 12:07:02 +0200 <maerwald> then it's a bad choice
2021-10-20 12:10:13 +0200 <troydm> yushyin: thx, I think i've got it without reading entire article, but I'll read it later anyway when I'll have time
2021-10-20 12:10:42 +0200 <kuribas> Inst: haskell is a hard sell unless several people are in on it.
2021-10-20 12:11:34 +0200 <maerwald> if you introduce Haskell to a company you better stay there for a year at least... everything else is irresponsible, imo
2021-10-20 12:12:06 +0200 <maerwald> not something you experiment and let others pick up
2021-10-20 12:12:52 +0200 <maerwald> I did that with coconut once (a python dialect) and I'm confident they still hate me
2021-10-20 12:13:51 +0200 <maerwald> well, that was because someone before me did that with me... rewrote something in Scala and then let the new joiner pick up the pieces
2021-10-20 12:14:03 +0200 <maerwald> so I kept the tradition
2021-10-20 12:14:11 +0200 <kuribas> maerwald: I am allowed to write haskell now "because it makes me happy".
2021-10-20 12:14:25 +0200 <kuribas> maerwal: I'll probably need to rewrite it once it's done.
2021-10-20 12:14:38 +0200 <kuribas> But fine be me :)
2021-10-20 12:15:07 +0200 <Inst> well, thanks for entertaining the troll (me)
2021-10-20 12:15:08 +0200Instsighs
2021-10-20 12:15:16 +0200 <kuribas> I am just wondering how I can rewrite my nice batching effect in clojure.
2021-10-20 12:15:19 +0200 <maerwald> when I'm working for someone, I don't write code for myself, so my first thought when doing anything is: "who comes after me?"
2021-10-20 12:15:25 +0200 <kuribas> Inst: that didn't sound like trolling.
2021-10-20 12:15:30 +0200 <Inst> the only good thing i can say is that the haskell materials i've been exposed to right now
2021-10-20 12:15:42 +0200 <Inst> seem better written than the equivalent C++ material
2021-10-20 12:16:13 +0200 <maerwald> and even in open source, I'm starting to shift away from writing code for myself, because that usually means I'm the only one maintaining anything
2021-10-20 12:16:13 +0200 <kuribas> it's not such a great idea to introduce haskell in a company, unless the majority is enthousiastic.
2021-10-20 12:16:50 +0200 <kuribas> Much better would be to teach them how to write clean java/JS/whatever.
2021-10-20 12:17:00 +0200 <kuribas> Using the principles learned from haskell.
2021-10-20 12:17:04 +0200 <yushyin> golang
2021-10-20 12:18:29 +0200 <maerwald> Yeah, you can do great functional code in TypeScript
2021-10-20 12:19:05 +0200dut(~dut@user/dut)
2021-10-20 12:19:18 +0200 <Inst> my shtick, kuribas, is trying to convince people that
2021-10-20 12:19:22 +0200 <Inst> we should replace Python with Haskell
2021-10-20 12:19:27 +0200 <Inst> for hobbyists
2021-10-20 12:19:39 +0200 <maerwald> why convince anyone?
2021-10-20 12:19:45 +0200 <Inst> to grow the Haskell community
2021-10-20 12:20:18 +0200 <maerwald> Inst: does your employer pay you for that?
2021-10-20 12:20:52 +0200 <LiaoTao> Inst, I don't think it's that easy to make Haskell appealing to the lowest common denominator of programmers
2021-10-20 12:21:02 +0200 <LiaoTao> Purely because of terminology, category theory and historical reasons
2021-10-20 12:21:19 +0200dut(~dut@user/dut) (Read error: Connection reset by peer)
2021-10-20 12:21:42 +0200dut(~dut@user/dut)
2021-10-20 12:21:52 +0200burnsidesLlama(~burnsides@dhcp168-039.wadham.ox.ac.uk) (Remote host closed the connection)
2021-10-20 12:22:13 +0200dut(~dut@user/dut) (Client Quit)
2021-10-20 12:23:19 +0200 <kuribas> Inst: we don't need to grow the Haskell community.
2021-10-20 12:26:07 +0200ArctVaulMarsHMPJ(~pjetcetal@2.95.44.252)
2021-10-20 12:26:16 +0200ArctVaulMarsHMPJ(~pjetcetal@2.95.44.252) (Remote host closed the connection)
2021-10-20 12:27:07 +0200k60(~k60@broadband-95-84-168-218.ip.moscow.rt.ru)
2021-10-20 12:29:08 +0200 <Inst> That's to say, the language is academic, its target audience is to provide a unified language for computer science researchers, and that people like me are unnecessary?
2021-10-20 12:29:46 +0200 <Inst> That it's nice that Target and Goldmach Sachs (iirc) have Haskell-based applications running on their business platforms, but they're strictly unnecessary?
2021-10-20 12:34:51 +0200Guest13(~Guest13@cust190-dsl55.idnet.net)
2021-10-20 12:35:59 +0200acidjnk_new3(~acidjnk@p200300d0c703cb959894c42690fc4f0f.dip0.t-ipconnect.de)
2021-10-20 12:36:08 +0200 <kuribas> Inst: no language is necessary, you can just use assembly for everything if you want.
2021-10-20 12:36:09 +0200 <Inst> LiaoTao: well, I meet LCD requirements because I'm currently a non-programmer and I don't know cat theory nor do I have the intellectual apparatus needed to know category theory at this time
2021-10-20 12:36:20 +0200 <dminuoso> Say I have some `f :: IO (Maybe T)`, and inside of that I hold some `Maybe S` in my hand. How can I elegantly lift/apply some `S -> IO T` to that?
2021-10-20 12:36:38 +0200CiaoSen(~Jura@p200300c95730dd002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2021-10-20 12:36:43 +0200 <dminuoso> Is there some kind of lift1 for MaybeT?
2021-10-20 12:39:21 +0200acidjnk_new(~acidjnk@p200300d0c703cb955960125781424a48.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2021-10-20 12:42:07 +0200 <Inst> LiaoTao: not necessarily LCD, but perhaps non-programmers. I am telling people I know to go learn Haskell, even people with no prior programming background, on the belief that it has a valid hobbyist use case.
2021-10-20 12:42:19 +0200 <dminuoso> I mean I can do something like `runMaybeT $ do { r <- MaybeT foo; lift (g r) }`
2021-10-20 12:42:29 +0200 <dminuoso> Perhaps that's really what I want mmm
2021-10-20 12:44:52 +0200peterhil(~peterhil@dsl-hkibng32-54fb56-2.dhcp.inet.fi)
2021-10-20 12:47:34 +0200stengah(~stengah@user/stengah) (Ping timeout: 260 seconds)
2021-10-20 12:47:53 +0200 <maerwald> starting to learn and use a language for ego reasons (growing, reinformecent that you can take challenges etc) is great... but having that influence decisions in industry is a controversial thing
2021-10-20 12:48:28 +0200rond_(~rond_@2a02:a31a:a23c:f480:2fd7:e087:5546:a438)
2021-10-20 12:48:33 +0200kayprish(~kayprish@46.240.130.158) (Read error: Connection reset by peer)
2021-10-20 12:49:13 +0200mmhat(~mmh@55d4469f.access.ecotel.net)
2021-10-20 12:49:32 +0200enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) (Quit: enoq)
2021-10-20 12:50:46 +0200 <maerwald> and learning is absolutely about ego
2021-10-20 12:50:55 +0200 <maerwald> no negative connotation there
2021-10-20 12:52:15 +0200 <kuribas> Inst: you cannot do everything, you need to pick your own hobbies.
2021-10-20 12:52:41 +0200 <kuribas> Inst: would you like someone telling you that you absolutely need to learn gardening?
2021-10-20 12:52:56 +0200 <maerwald> only if you live in the UK
2021-10-20 12:53:12 +0200 <Inst> w/e, i'm effectively trolling right now, back to my textbooks. I'm a bit disappointed, but if this is how the Haskell community thinks, it's noted.
2021-10-20 12:53:42 +0200 <kuribas> Inst: I am not "the haskell community" :)
2021-10-20 12:54:05 +0200 <maerwald> Inst: the Haskell Foundation wants to broaden Haskell adoption in industry
2021-10-20 12:54:11 +0200 <maerwald> it sounds like that aligns with your goals
2021-10-20 12:54:26 +0200 <Inst> I'm more interested in broadening Haskell adoption overall, not necessarily in industry
2021-10-20 12:54:31 +0200 <maerwald> I'm still alienated by that goal, but it's a fair game
2021-10-20 12:54:31 +0200 <kuribas> But to think that you need to convert everyone to use something, in order to enjoy it yourself, is not very productive.
2021-10-20 12:54:32 +0200burnsidesLlama(~burnsides@dhcp168-039.wadham.ox.ac.uk)
2021-10-20 12:54:34 +0200 <Franciman> my goal is to have a programming language strongly focused on wikis
2021-10-20 12:54:42 +0200 <Franciman> that's what my language is going to do
2021-10-20 12:54:47 +0200 <Franciman> be in symbiosis with the wiki
2021-10-20 12:54:49 +0200 <Inst> kuribas: how familiar are you with the concept of ecosystem?
2021-10-20 12:55:07 +0200 <Franciman> Inst: imho no language today has a good wiki
2021-10-20 12:55:10 +0200 <kuribas> Inst: as in biological?
2021-10-20 12:55:14 +0200 <Franciman> and it is not integrated in the language
2021-10-20 12:55:18 +0200 <Franciman> my language is doing it
2021-10-20 12:55:22 +0200 <Inst> more like social and economic
2021-10-20 12:55:33 +0200 <Franciman> is it broadening?
2021-10-20 12:55:41 +0200 <Inst> i guess you guys are more oriented toward the quality of the ecosystem, i.e, the people who hang around are like-minded, civil, and highly educated
2021-10-20 12:55:52 +0200 <Inst> trying to broaden the ecosystem perhaps sounds like "Success at All Costs"
2021-10-20 12:56:18 +0200 <Franciman> no the HF is going in that road you like
2021-10-20 12:56:20 +0200 <Franciman> don't worry
2021-10-20 12:56:29 +0200 <Franciman> have you read their mission and vision?
2021-10-20 12:56:34 +0200 <Franciman> I find many common words
2021-10-20 12:56:45 +0200 <Franciman> w-wait i find the suitable links for you to read
2021-10-20 12:56:46 +0200 <kuribas> I am only interested in "broadening the ecosystem" as far as that improve the quality of the tooling.
2021-10-20 12:57:23 +0200 <Inst> An independent, non-profit organization dedicated to broadening the adoption of Haskell, by supporting its ecosystem of tools, libraries, education, and research.
2021-10-20 12:57:29 +0200 <Franciman> Inst: https://haskell.foundation/vision/
2021-10-20 12:57:33 +0200 <Inst> i'm already on their site
2021-10-20 12:57:37 +0200 <Franciman> oh nice
2021-10-20 12:57:45 +0200 <maerwald> Franciman: well, better than no Haskell Foundation
2021-10-20 12:57:57 +0200 <Franciman> ?
2021-10-20 12:58:25 +0200 <maerwald> I mean... although I don't completely agree with that vision, I think it's fair that they follow that.
2021-10-20 12:58:34 +0200stengah(~stengah@user/stengah)
2021-10-20 12:58:34 +0200 <Franciman> ah not judging that no
2021-10-20 12:58:37 +0200 <maerwald> there will be positive side effects
2021-10-20 12:58:42 +0200 <Franciman> I just said that Inst could be satisfied
2021-10-20 12:58:45 +0200 <Franciman> by the HF
2021-10-20 12:59:05 +0200burnsidesLlama(~burnsides@dhcp168-039.wadham.ox.ac.uk) (Ping timeout: 260 seconds)
2021-10-20 12:59:08 +0200 <Inst> there will also be negative ones, i.e, kiddies running around with bad manners, more bad code entering the ecosystem, etc
2021-10-20 12:59:49 +0200 <maerwald> not sure... current industry that uses Haskell isn't that bad
2021-10-20 13:00:09 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:9105:355e:98db:81cc)
2021-10-20 13:00:14 +0200 <maerwald> but I'm not holding my breath for them to fix our problems
2021-10-20 13:00:42 +0200alx741(~alx741@186.178.109.50)
2021-10-20 13:00:43 +0200 <Franciman> what haskell is not fixing is that it is not becoming a wiki based language. But we can't blame anyone for that
2021-10-20 13:00:52 +0200 <Franciman> I just write my wiki based language and see how it goes
2021-10-20 13:01:27 +0200 <kuribas> Inst: scala is an example of what happens if you try to make a language that is both popular and cutting edge: a big mess.
2021-10-20 13:01:31 +0200 <Franciman> it can't make everyone happy
2021-10-20 13:01:37 +0200 <kuribas> Not that haskell isn't a big mess :)
2021-10-20 13:01:50 +0200 <Inst> kuribas: I just don't see why being popular has to be against being cutting edge.
2021-10-20 13:02:09 +0200 <kuribas> Inst: just look at scala
2021-10-20 13:02:09 +0200 <Inst> If someone wants to compromise "Avoid Success at All Costs", they can just fork the language.
2021-10-20 13:02:17 +0200 <maerwald> kuribas: with DH and linear types... it'll become a big mess soon. But there will always be a subset of maintainers that keep being sane and use it sparingly.
2021-10-20 13:02:18 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2021-10-20 13:02:28 +0200 <Inst> The language and its philosophy is fine as is; the language designers do not need to design the language to appeal to the masses.
2021-10-20 13:02:31 +0200 <Franciman> one difficult matter is that being cutting edge could mean less stability
2021-10-20 13:02:40 +0200 <Franciman> while mainstream means you want realiability as a company
2021-10-20 13:02:53 +0200 <Inst> I'm just saying expanding the ecosystem can be done without having to cut corners; the effort being made is in evangelization and education, as opposed to dumbing down Haskell.
2021-10-20 13:03:06 +0200 <Inst> Or making it ugly, for that matter.
2021-10-20 13:03:15 +0200 <kuribas> But haskell is messy because it is getting old, and accumulating features it wasn't designed for (dependent types).
2021-10-20 13:03:20 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2021-10-20 13:03:39 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-10-20 13:03:44 +0200 <kuribas> Inst: trying to make haskell by telling people they have to use it is not very productive.
2021-10-20 13:03:57 +0200 <Inst> I don't think it's "forcing" people to use it.
2021-10-20 13:04:11 +0200 <Inst> Just telling them Haskell is interesting, it's cool, and I tihnk you're smart enough to learn it, is what I have more in mind.
2021-10-20 13:04:15 +0200 <Franciman> Inst: sorry I didn't quite understand what you mean
2021-10-20 13:04:33 +0200 <Franciman> you mean broadening haskell usage, right?
2021-10-20 13:04:34 +0200 <maerwald> using haskell in industry isn't that much better than any other language, because it's widely known amongst managers that you can "iterate quickly" on Haskell codebases
2021-10-20 13:04:35 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:9105:355e:98db:81cc) (Ping timeout: 264 seconds)
2021-10-20 13:04:37 +0200 <maerwald> so the pressure is real
2021-10-20 13:04:59 +0200 <Franciman> also haskell can be very solid on some things, and super brittle on others
2021-10-20 13:05:02 +0200 <Franciman> if you are not experienced
2021-10-20 13:05:04 +0200 <Inst> I see.
2021-10-20 13:05:05 +0200 <Franciman> you can fall so easily
2021-10-20 13:05:08 +0200 <Franciman> lol
2021-10-20 13:05:15 +0200 <Inst> I just got confused a bit by the hype etc surrounding Haskell
2021-10-20 13:05:17 +0200 <Franciman> but that is getting very much better now
2021-10-20 13:05:17 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-10-20 13:05:24 +0200 <Franciman> it is getting better
2021-10-20 13:05:29 +0200 <Franciman> the ecosystem is getting much better
2021-10-20 13:05:29 +0200jespada(~jespada@2803:9800:9842:7a62:5d33:6404:2aef:9813)
2021-10-20 13:05:42 +0200 <Franciman> we even have a language server implementation
2021-10-20 13:05:52 +0200 <Franciman> there are plenty of great libraries
2021-10-20 13:05:56 +0200 <Franciman> for doing webserver etc
2021-10-20 13:06:23 +0200 <Inst> If, say, a firm decides to mandate haskell development (and haskell isn't optimal for all use cases), that's up to them, based on their use-case, Haskell's propensities, and the capabilities of their existing staff.
2021-10-20 13:06:49 +0200 <Inst> I'm not saying force everyone to use haskell, unless there's an existing business case for having multi-language programmers work in haskell as opposed to other languages
2021-10-20 13:06:59 +0200dsrt^(~dsrt@68.101.53.15) (Ping timeout: 264 seconds)
2021-10-20 13:08:20 +0200pavonia(~user@user/siracusa) (Quit: Bye!)
2021-10-20 13:08:21 +0200 <maerwald> Good Haskellers are rather expensive. There are a couple interesting startups that do Haskell, but the real space lies in fintech, where they have enough bucks for the star engineers and let them do their thing.
2021-10-20 13:08:48 +0200 <maerwald> And some companies absolutely pick haskell for both a) marketing and b) access to smart engineers.
2021-10-20 13:09:58 +0200 <maerwald> If you're a green startup in sweden with european wages... you'll maybe get a few students before they leave for the big bucks.
2021-10-20 13:10:23 +0200 <maerwald> something to consider when you wanna introduce haskell to your company :p
2021-10-20 13:11:30 +0200 <Inst> I have an idea for a start-up based around wearables, i.e, intersection of technology and fashion.
2021-10-20 13:11:40 +0200 <Inst> It's probably at least a few years before I can implement
2021-10-20 13:11:59 +0200 <maerwald> I want to write a dating app in Haskell. It's gonna be great.
2021-10-20 13:12:06 +0200AlexNoo_(~AlexNoo@178.34.160.45)
2021-10-20 13:12:19 +0200 <Inst> You're mocking me?
2021-10-20 13:12:42 +0200 <Inst> I don't see a particular use case for Haskell in such an environment, though, since it'd more likely be based around an Android ecosystem.
2021-10-20 13:12:49 +0200 <maerwald> I mean... I had the idea when I was drunk, but with some funding I might actually do it :p
2021-10-20 13:12:55 +0200Guest|41(~Guest|41@31-187-0-247.dynamic.upc.ie)
2021-10-20 13:13:07 +0200 <Inst> On the other hand, knowing Haskell might be good as a way to attract good developers.
2021-10-20 13:13:08 +0200 <maerwald> until I burned through the cash
2021-10-20 13:13:09 +0200 <Franciman> maerwald: a dating app for haskellers?
2021-10-20 13:13:31 +0200 <Franciman> a wiki can do it better
2021-10-20 13:13:38 +0200 <Franciman> collaborating to a wiki gets the best dates out
2021-10-20 13:13:47 +0200 <maerwald> Franciman: nah, an FRP based frontend that's snappy and reliable
2021-10-20 13:14:31 +0200Alex_test(~al_test@94.233.240.148) (Ping timeout: 252 seconds)
2021-10-20 13:14:34 +0200 <Inst> maerwald: I'd be orienting the firm in China
2021-10-20 13:14:35 +0200 <maerwald> I've also been thinking for a long time about the "misclick" problem... how can a UI minimize misclicks
2021-10-20 13:14:49 +0200 <maerwald> reducing animations sure, but there's more
2021-10-20 13:14:52 +0200 <Inst> whatever happened to radial menus?
2021-10-20 13:15:00 +0200stengah(~stengah@user/stengah) (Ping timeout: 258 seconds)
2021-10-20 13:15:03 +0200kupi(uid212005@id-212005.hampstead.irccloud.com)
2021-10-20 13:15:04 +0200AlexZenon(~alzenon@94.233.240.148) (Ping timeout: 252 seconds)
2021-10-20 13:15:27 +0200 <Inst> maerwald: you can probably remove misclicks via a click + mouse gesture combo
2021-10-20 13:15:34 +0200AlexNoo(~AlexNoo@94.233.240.148) (Ping timeout: 252 seconds)
2021-10-20 13:16:02 +0200alzgh(~alzgh@user/alzgh)
2021-10-20 13:16:07 +0200 <LiaoTao> That sounds like a surefire way to make everyone hate your UI
2021-10-20 13:16:52 +0200 <Inst> I mean a lot of apps require swipes already.
2021-10-20 13:17:28 +0200 <maerwald> you still want animations, but you could e.g. detect that your finger (pre-touch detection) switched context during an animation and have thresholds that block an action under certain circumstances
2021-10-20 13:18:28 +0200 <maerwald> I mean, you still need to support mass-swipes etc, so it's not an easy problem
2021-10-20 13:19:12 +0200mzan(~quassel@mail.asterisell.com)
2021-10-20 13:19:21 +0200 <maerwald> and that technology could be somewhat extended to websites... I hate it when I click and due to an element that just finished loading, the layout changed and I hit some random button
2021-10-20 13:19:54 +0200Alex_test(~al_test@178.34.160.45)
2021-10-20 13:19:58 +0200AlexZenon(~alzenon@178.34.160.45)
2021-10-20 13:20:03 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 13:20:37 +0200 <Inst> Only matters if you're on a slow system; I have a decent connection and a decent workstation computer
2021-10-20 13:20:46 +0200 <Inst> sometimes I wish loading might be actually slower
2021-10-20 13:21:45 +0200 <maerwald> one idea on the desktop would be to block layout changes as long as the mouse is moving
2021-10-20 13:22:03 +0200 <maerwald> but that'll need more refinement
2021-10-20 13:23:17 +0200 <Franciman> Inst: are you on reddit too?
2021-10-20 13:24:22 +0200 <Inst> that post is mine
2021-10-20 13:25:09 +0200 <Franciman> which post?
2021-10-20 13:25:51 +0200 <Franciman> ah found
2021-10-20 13:26:04 +0200 <Franciman> Instrume, I-I had seen Inst somewhere else
2021-10-20 13:26:37 +0200 <Inst> I'm dropping the issue, I wrote an e-mail to HF about whether or not it'd be viable to try to espouse Haskell among non-programmers.
2021-10-20 13:26:57 +0200 <Franciman> it sure is a great idea
2021-10-20 13:27:09 +0200 <Inst> the average person is both smarter and dumber than you think, i.e, with the right education, they can do incredible things, but at the same time they often have really dumb ideas
2021-10-20 13:28:10 +0200 <Franciman> yeah people are interesting
2021-10-20 13:28:29 +0200 <Franciman> being dumb can just be a lack of something
2021-10-20 13:28:52 +0200 <Franciman> I wish we didn't have mass teaching as the only method
2021-10-20 13:28:55 +0200 <Franciman> it is good
2021-10-20 13:29:11 +0200 <Franciman> but treating anybody as a individual can get a lot of benefits
2021-10-20 13:29:53 +0200 <LiaoTao> On the other hand some people are just plain dumb and can't be taught skills like extrapolation from known data.
2021-10-20 13:29:54 +0200 <Franciman> Inst: i recall projects teaching functional languages as first language
2021-10-20 13:30:27 +0200 <Inst> LiaoTao: was it Xun Zi or Mencius?
2021-10-20 13:30:45 +0200 <LiaoTao> Inst, LiaoTao
2021-10-20 13:30:46 +0200 <Inst> I forget, via Feng Youlan, some people are born sages, some are utterly incorrigible, most people are somewhere in between
2021-10-20 13:31:00 +0200 <Inst> and thus educable
2021-10-20 13:31:21 +0200 <Franciman> that's always the swingers being the most important
2021-10-20 13:31:38 +0200jgeerds(~jgeerds@55d4da80.access.ecotel.net)
2021-10-20 13:32:10 +0200 <lortabac> I'm pretty sure dumb people don't exist, find something they are really interested in and they'll surprise you
2021-10-20 13:32:25 +0200 <Inst> umm, people with real physiological disabilities
2021-10-20 13:32:35 +0200 <Inst> someone with a chromosomal abnormality, for instance
2021-10-20 13:32:42 +0200 <lortabac> ok that's a different problem
2021-10-20 13:33:03 +0200 <Franciman> even in that case, let them be happy, and they'll find a way to be accomplished
2021-10-20 13:33:09 +0200 <LiaoTao> lortabac, That's a very generous view and not something I've been able to corroborate with reality
2021-10-20 13:33:13 +0200 <LiaoTao> Which is sad, but nevertheless
2021-10-20 13:33:38 +0200 <lortabac> think of how much intelligence it takes to do things like driving, yet most people can do it
2021-10-20 13:34:22 +0200 <LiaoTao> Someone more glib would ask you to take a look at your average roundabout during peak traffic hours
2021-10-20 13:34:56 +0200 <lortabac> anyway it's offtopic
2021-10-20 13:35:20 +0200 <LiaoTao> Right
2021-10-20 13:35:43 +0200 <Franciman> let's get back about how wiki as documentation is cool
2021-10-20 13:36:22 +0200 <lortabac> Franciman: welcome to 1990 :P
2021-10-20 13:36:30 +0200 <Franciman> *.*
2021-10-20 13:36:41 +0200Francimanputs eiffel65 on
2021-10-20 13:36:53 +0200hpcputs portlandia on :D
2021-10-20 13:36:59 +0200 <Franciman> *.*
2021-10-20 13:37:05 +0200LiaoTaoputs macarena on
2021-10-20 13:37:14 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Ping timeout: 258 seconds)
2021-10-20 13:37:21 +0200 <hpc> they didn't call it a wiki until 2005
2021-10-20 13:42:35 +0200 <Inst> @franciman: apparently there's a school in India that does Haskell first, Oxford does Haskell first, Haskell is included in first languages at Imperial College, Cambridge (at least sometimes) does Haskell first
2021-10-20 13:42:35 +0200 <lambdabot> Unknown command, try @list
2021-10-20 13:43:52 +0200off^(~off@68.101.53.15)
2021-10-20 13:44:30 +0200 <Inst> https://wiki.haskell.org/Haskell_in_education
2021-10-20 13:44:58 +0200 <Franciman> uh a wiki
2021-10-20 13:45:06 +0200 <Franciman> ty
2021-10-20 13:45:59 +0200Guest|41(~Guest|41@31-187-0-247.dynamic.upc.ie) (Ping timeout: 264 seconds)
2021-10-20 13:47:04 +0200 <LiaoTao> Some adventurous CS lecturer at Chalmers uses Haskell too
2021-10-20 13:48:26 +0200 <LiaoTao> We suddenly had lots of applications with Haskell on the resume, and I thought "Darn, maybe finally the year of FP is upon us", but as it turns out they had all just used it for a university course
2021-10-20 13:48:41 +0200 <sshine> they use Haskell on the 1st MSc course at University of Copenhagen. they used to use SML for the 1st BSc course, but I think they switched to F# now.
2021-10-20 13:51:27 +0200lavaman(~lavaman@98.38.249.169)
2021-10-20 13:53:41 +0200acidjnk_new(~acidjnk@pd9e0b933.dip0.t-ipconnect.de)
2021-10-20 13:54:21 +0200 <kuribas> Why don't they teach dependent types?
2021-10-20 13:54:43 +0200 <sshine> kuribas, imagine what that would make people feel when they get their first job.
2021-10-20 13:55:08 +0200max22-(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr) (Ping timeout: 265 seconds)
2021-10-20 13:55:24 +0200 <dminuoso> kuribas: You have plenty cassava experience right?
2021-10-20 13:55:39 +0200 <dminuoso> Is there a way to have cassava mention the column name a particular field couldn't be parsed in?
2021-10-20 13:56:10 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 260 seconds)
2021-10-20 13:56:33 +0200 <dminuoso> It's quite frustrating to just get some: Failed reading: conversion error: expected Int, got "" (not enough input)
2021-10-20 13:56:47 +0200acidjnk_new3(~acidjnk@p200300d0c703cb959894c42690fc4f0f.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2021-10-20 13:56:55 +0200 <kuribas> dminuoso: https://github.com/haskell-hvr/cassava/pull/197
2021-10-20 13:57:11 +0200 <dminuoso> I knew I was asking the right person. :-)
2021-10-20 13:57:12 +0200 <dminuoso> Cheers
2021-10-20 13:57:35 +0200 <kuribas> I didn't get any update on this PR sadly...
2021-10-20 13:57:46 +0200jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2021-10-20 13:57:56 +0200jakalx(~jakalx@base.jakalx.net)
2021-10-20 13:58:46 +0200 <dminuoso> kuribas: It's also frustrating that none of these FromField instances do a BS.null check
2021-10-20 13:59:01 +0200 <kuribas> dminuoso: yeah
2021-10-20 13:59:49 +0200 <kuribas> I am considering reimplementing most of the functionality, and just using cassava as "ByteString -> [Map Text Text]"
2021-10-20 14:00:07 +0200 <dminuoso> Well it should be ByteString for general use
2021-10-20 14:00:09 +0200 <dminuoso> But yeah
2021-10-20 14:00:28 +0200 <dminuoso> I mean there's an alternate way
2021-10-20 14:00:35 +0200 <dminuoso> You can also parse into tuples of bytestrings
2021-10-20 14:01:04 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-10-20 14:01:37 +0200 <kuribas> Isn't csv utf8?
2021-10-20 14:02:00 +0200 <dminuoso> kuribas: But really it seems the best way is to have cassava parse into `data RecordRaw = RecordRaw { rawSalary :: ByteString, rawName :: ByteString }`, with some matching `data Record = Record { salary :: Int, name :: Text }`, and then write some generic code turning RecordRaw into Record, producing legigble errors..
2021-10-20 14:02:06 +0200 <dminuoso> csv isnt even well defined really
2021-10-20 14:02:36 +0200 <dminuoso> There's a lot of programs that rapidly produce latin encoded csvs instead
2021-10-20 14:02:48 +0200 <dminuoso> SqlDeveloper is very liberal
2021-10-20 14:02:53 +0200 <dminuoso> Pretty sure Excel is as well
2021-10-20 14:03:38 +0200burnsidesLlama(~burnsides@dhcp168-039.wadham.ox.ac.uk)
2021-10-20 14:07:44 +0200 <kuribas> dminuoso: but then I have to make a Raw* record for each of my records?
2021-10-20 14:08:44 +0200 <dminuoso> Bah you know what, I think what Ill do
2021-10-20 14:08:47 +0200 <dminuoso> got a better idea
2021-10-20 14:11:36 +0200 <kuribas> make a new csv library?
2021-10-20 14:12:45 +0200 <kuribas> you could copy the low level parsing stuff from cassava.
2021-10-20 14:14:09 +0200 <dminuoso> Im going to quickly ruin its performance (not relevant to my case), and simply bolt on variants of (.:)
2021-10-20 14:14:14 +0200 <dminuoso> So I have .:: and .:!
2021-10-20 14:14:34 +0200 <dminuoso> Which would both include field names in errors, and .:! would assert the field be non empty
2021-10-20 14:16:39 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-10-20 14:17:41 +0200Guest13(~Guest13@cust190-dsl55.idnet.net) (Quit: Client closed)
2021-10-20 14:23:11 +0200off^(~off@68.101.53.15) (Ping timeout: 264 seconds)
2021-10-20 14:24:28 +0200 <zincy> Opinions on testing validity of generators in property based testing?
2021-10-20 14:25:56 +0200k60(~k60@broadband-95-84-168-218.ip.moscow.rt.ru) (Ping timeout: 265 seconds)
2021-10-20 14:27:42 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-10-20 14:28:13 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 258 seconds)
2021-10-20 14:30:25 +0200 <kuribas> zincy: add properties which validate your generators.
2021-10-20 14:30:47 +0200 <kuribas> you can get statistics that not all properties are trivial for example.
2021-10-20 14:31:36 +0200 <zincy> cover?
2021-10-20 14:32:10 +0200 <zincy> Yeah so testing your tests is ok in moderation
2021-10-20 14:34:13 +0200 <kuribas> Or I write a property that should fail, then remove it when I see the generator is catching those.
2021-10-20 14:34:39 +0200 <kuribas> Getting the generators right is also important.
2021-10-20 14:37:10 +0200 <zincy> So the coverage combinators for hedgehog are designed to help you get generators right
2021-10-20 14:37:14 +0200 <zincy> very cool
2021-10-20 14:37:35 +0200 <zincy> kuribas: Have you tried the state machine feature?
2021-10-20 14:37:41 +0200 <zincy> Wondering if it is worth a go
2021-10-20 14:37:49 +0200 <kuribas> zincy: no, I just recently learned that it exists.
2021-10-20 14:37:55 +0200Guest2920(~Guest29@net-93-151-133-175.cust.dsl.teletu.it) (Quit: Client closed)
2021-10-20 14:38:07 +0200 <kuribas> I didn't need it yet, but I might in the future.
2021-10-20 14:40:33 +0200xiongxin(~quassel@119.123.103.160)
2021-10-20 14:41:01 +0200 <dminuoso> kuribas: https://gist.github.com/dminuoso/08e7b1aca8bb92fe84345adf3e0f1a10
2021-10-20 14:41:16 +0200 <dminuoso> Here, a dirty drop in solution for all my problems.
2021-10-20 14:41:47 +0200 <kuribas> why is that slow?
2021-10-20 14:42:21 +0200Guest55(~Guest55@78.198.4.122)
2021-10-20 14:42:36 +0200 <dminuoso> That (potentially doubly nested) runParser will defeat the deforestration technique
2021-10-20 14:42:41 +0200 <dminuoso> Parser uses continuations internally
2021-10-20 14:42:45 +0200 <dminuoso> I turn that back into case-of
2021-10-20 14:43:01 +0200 <dminuoso> Bah, I can probably simply break Parser open and use those continuations manually
2021-10-20 14:43:03 +0200 <dminuoso> Maybe I shoulld
2021-10-20 14:43:38 +0200 <dminuoso> Ah wait, its not exported
2021-10-20 14:44:02 +0200 <dminuoso> So yeah, aside of `unsafeCoerce'ing` my way through, this is not going to play nice with large csvs
2021-10-20 14:44:06 +0200 <dminuoso> but the ones I deal with are small anyway
2021-10-20 14:44:56 +0200AlexNoo_AlexNoo
2021-10-20 14:45:50 +0200 <Guest55> Hey, Could someone help me understand the error that i'm having on this simple program: https://paste.tomsmeding.com/LL1aSDyt
2021-10-20 14:46:25 +0200stengah(~stengah@user/stengah)
2021-10-20 14:46:57 +0200 <dminuoso> Guest55: Hey yes.
2021-10-20 14:47:00 +0200xiongxin(~quassel@119.123.103.160) (Read error: Connection reset by peer)
2021-10-20 14:47:00 +0200 <lortabac> Guest55: you apply (.) on things that are not functions
2021-10-20 14:47:03 +0200 <dminuoso> % :t lines
2021-10-20 14:47:04 +0200 <yahb> dminuoso: String -> [String]
2021-10-20 14:47:25 +0200 <dminuoso> Or well, what lortabac said.
2021-10-20 14:47:58 +0200 <lortabac> :t (.)
2021-10-20 14:47:59 +0200 <lambdabot> (b -> c) -> (a -> b) -> a -> c
2021-10-20 14:48:04 +0200xiongxin(~quassel@119.123.100.49)
2021-10-20 14:48:30 +0200 <Guest55> Could you elaborate? (... . lines str) isn't valid?
2021-10-20 14:49:07 +0200 <dminuoso> Guest55: You already applied lines to str.
2021-10-20 14:49:16 +0200 <dminuoso> So the expression `lines str` is of type [String]`
2021-10-20 14:49:50 +0200 <dminuoso> So if we take `f . lines str`, you're trying to compose `f` with .. uh well a list of strings. But if you look at the type of (.) above, you can see that (.) demands its second argument to be a function.
2021-10-20 14:50:37 +0200 <Guest55> Oh I see. So maybe `... . lines $ str` should do it?! And it seems to!
2021-10-20 14:51:10 +0200lbseale(~lbseale@user/ep1ctetus)
2021-10-20 14:51:24 +0200 <Guest55> Thanks dminuoso !
2021-10-20 14:51:34 +0200 <lortabac> alternatively, you can remove 'str' both before and after the =
2021-10-20 14:51:37 +0200mbuf(~Shakthi@122.178.207.237) (Quit: Leaving)
2021-10-20 14:51:50 +0200 <dminuoso> ^- and that would be the idiomatic thing to do, even. :)
2021-10-20 14:52:08 +0200 <Guest55> Ah yes point free style :)
2021-10-20 14:52:51 +0200 <dminuoso> Yeah. Though point free is not the ultimate goal, for simple function composition this is very idiomatic.
2021-10-20 14:53:28 +0200 <Guest55> I see, thanks!
2021-10-20 14:54:04 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 14:54:49 +0200 <lortabac> mixing (.) and ($) works too, but I find it a little confusing
2021-10-20 14:55:44 +0200 <Guest55> Now for the most difficult part (imho), how does one go from the error message to this conclusion? Supposing the error wasn't obvious at first sight, and you had to understand the error message, how would you link it to '.' ? Is it "In the second argument of ‘(.)’, namely ‘lines str’" that gives it away?
2021-10-20 14:56:18 +0200 <Guest55> Personally I was focused on the first part "Possible cause: ‘lines’ is applied to too many arguments"
2021-10-20 14:57:31 +0200 <lortabac> yes, the hint is correct
2021-10-20 14:57:47 +0200 <lortabac> lines is applied to too many arguments (1 instead of zero)
2021-10-20 14:59:05 +0200 <lortabac> unfortunately I don't think there is a simple universal method to understand the error messages
2021-10-20 14:59:17 +0200 <Guest55> Oh I see. GHC knows we're in a '.' composition context and hence knows that lines should have 0 (1 less than normal) argument ?
2021-10-20 14:59:55 +0200 <Guest55> lortabac: Yeah I find most of them quite cryptic, but i'm trying to train myself to understand them better!
2021-10-20 15:01:23 +0200 <lortabac> yes, (.) expects a function as a second argument, but you gave it a function applied to an argument, which resulted in a String
2021-10-20 15:01:51 +0200 <lortabac> so it deduced that you probably shouldn't have applied it
2021-10-20 15:01:52 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:9105:355e:98db:81cc)
2021-10-20 15:02:24 +0200 <lortabac> but remember that these "possible causes" are just hints, they are not right 100% of the times
2021-10-20 15:03:52 +0200 <Guest55> Oh right, there's often more than one solution so the compiler certainly just tries to enumerate them.
2021-10-20 15:04:03 +0200 <Guest55> Thank you very much lortabac !
2021-10-20 15:04:18 +0200AlexZenon(~alzenon@178.34.160.45) (Quit: ;-)
2021-10-20 15:04:22 +0200Alex_test(~al_test@178.34.160.45) (Quit: ;-)
2021-10-20 15:04:26 +0200AlexNoo(~AlexNoo@178.34.160.45) (Quit: Leaving)
2021-10-20 15:05:47 +0200Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de) (Ping timeout: 258 seconds)
2021-10-20 15:06:21 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:9105:355e:98db:81cc) (Ping timeout: 245 seconds)
2021-10-20 15:06:45 +0200mei(~mei@user/mei)
2021-10-20 15:08:05 +0200CiaoSen(~Jura@p200300c95730dd002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2021-10-20 15:08:45 +0200azimut_(~azimut@gateway/tor-sasl/azimut)
2021-10-20 15:10:02 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Quit: ZNC - https://znc.in)
2021-10-20 15:11:09 +0200jgeerds(~jgeerds@55d4da80.access.ecotel.net) (Ping timeout: 258 seconds)
2021-10-20 15:11:37 +0200azimut_(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2021-10-20 15:11:54 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2021-10-20 15:16:05 +0200off^(~off@68.101.53.15)
2021-10-20 15:17:06 +0200_bo(~bo@217.18.216.247)
2021-10-20 15:19:18 +0200slack1256(~slack1256@45.4.2.52)
2021-10-20 15:19:37 +0200Farzad(~FarzadBek@178.131.24.144)
2021-10-20 15:20:32 +0200 <dminuoso> kuribas: But yeah, cassava is not very good in a lot of ways
2021-10-20 15:21:07 +0200 <_bo> Can someone please help me understand how to think about task of splitting string into substrings? I understand concept of maps and reduces, but how do I apply it here?
2021-10-20 15:21:20 +0200renzhi(~xp@2607:fa49:6500:b100::6e7f)
2021-10-20 15:21:38 +0200 <dminuoso> _bo: What's the specific problem you are trying to solve?
2021-10-20 15:21:48 +0200 <_bo> "aaabbba" -> ["aaa", a], this is an example
2021-10-20 15:22:23 +0200 <_bo> dminuoso: If I'm completely transparent: https://www.codewars.com/kata/59c633e7dcc4053512000073
2021-10-20 15:22:30 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Ping timeout: 260 seconds)
2021-10-20 15:22:45 +0200AlexZenon(~alzenon@178.34.160.45)
2021-10-20 15:22:47 +0200MQ-17J(~MQ-17J@2607:fb90:1d89:67a9:1cd1:a18:a57f:e102)
2021-10-20 15:23:00 +0200AlexNoo(~AlexNoo@178.34.160.45)
2021-10-20 15:23:23 +0200 <dminuoso> _bo: Okay, Im really not sure how you come from that kata to the example you provided.
2021-10-20 15:23:31 +0200 <_bo> I thought that I can approach this task by mapping string to sub-arrays of continuous consonants, then just replacing chars with numbers, then just summing sub-arrays and selecting the biggest
2021-10-20 15:23:39 +0200 <dminuoso> But oh well I think I get it.
2021-10-20 15:23:55 +0200 <dminuoso> _bo: Sounds about right.
2021-10-20 15:24:35 +0200 <dminuoso> _bo: You can use `groupBy` from Data.List
2021-10-20 15:24:45 +0200 <dminuoso> Incidentally its non-sorting behavior will fit your usage pattern nicely
2021-10-20 15:25:09 +0200 <_bo> Grouping by "being consonant"? Clever
2021-10-20 15:25:24 +0200 <dminuoso> yeah, it will require additional processing. it's just one of many solutions.
2021-10-20 15:25:45 +0200 <dminuoso> _bo: Am I right in presuming you're just using these katas as ways to learn Haskell?
2021-10-20 15:25:51 +0200 <_bo> But then how do I implement this group myself? I like solving katas without any libraries
2021-10-20 15:26:01 +0200 <dminuoso> groupBy is part of base
2021-10-20 15:26:07 +0200 <dminuoso> % :t groupBy
2021-10-20 15:26:07 +0200 <yahb> dminuoso: (a -> a -> Bool) -> [a] -> [[a]]
2021-10-20 15:26:11 +0200 <dminuoso> % :t Data.List.groupBy
2021-10-20 15:26:11 +0200 <yahb> dminuoso: (a -> a -> Bool) -> [a] -> [[a]]
2021-10-20 15:26:16 +0200Alex_test(~al_test@178.34.160.45)
2021-10-20 15:26:23 +0200 <dminuoso> But if you like, you can just write it yourself
2021-10-20 15:26:30 +0200 <dminuoso> It's a neat little challenge if you dont know how
2021-10-20 15:26:36 +0200 <_bo> Yes, you are 100% correct. I can't write any apps yet, so I'm starting with katas
2021-10-20 15:26:42 +0200 <dminuoso> _bo: at any rate.
2021-10-20 15:26:49 +0200 <dminuoso> _bo: The key primitives you are looking for is this:
2021-10-20 15:26:51 +0200 <dminuoso> % :t span
2021-10-20 15:26:51 +0200 <yahb> dminuoso: (a -> Bool) -> [a] -> ([a], [a])
2021-10-20 15:26:54 +0200 <dminuoso> % :t break
2021-10-20 15:26:54 +0200 <yahb> dminuoso: (a -> Bool) -> [a] -> ([a], [a])
2021-10-20 15:27:02 +0200 <dminuoso> A lot of string processing revolves around these two
2021-10-20 15:27:06 +0200 <dminuoso> Or list processing, rather.
2021-10-20 15:27:23 +0200 <dminuoso> % span (>5) [1,2,3,4,5,6,7]
2021-10-20 15:27:23 +0200 <yahb> dminuoso: ([],[1,2,3,4,5,6,7])
2021-10-20 15:27:28 +0200 <dminuoso> % span (<5) [1,2,3,4,5,6,7]
2021-10-20 15:27:28 +0200 <yahb> dminuoso: ([1,2,3,4],[5,6,7])
2021-10-20 15:27:46 +0200 <_bo> Seems like a takeWhile
2021-10-20 15:28:09 +0200 <dminuoso> Yeah, except `span` will also return the other list
2021-10-20 15:28:34 +0200stengah(~stengah@user/stengah) (Ping timeout: 260 seconds)
2021-10-20 15:28:40 +0200 <dminuoso> So you can simply use `span` in some recursive manner, where you repeatedly work on the second remainder of the tuple
2021-10-20 15:29:38 +0200Profpatsch(~Profpatsc@static.88-198-193-255.clients.your-server.de)
2021-10-20 15:30:00 +0200 <Profpatsch> chaining Wai.Middlewares means the last one receives the request first, right?
2021-10-20 15:30:14 +0200 <dminuoso> Profpatsch: what does "last" mean?
2021-10-20 15:30:14 +0200 <_bo> I see the idea, thanks! Will also try to write span myself
2021-10-20 15:30:24 +0200 <dminuoso> Profpatsch: or "chaining"
2021-10-20 15:30:25 +0200 <Profpatsch> middleware1 . middleware2 should pass the request to 1 first and 2 last
2021-10-20 15:30:29 +0200 <dminuoso> Profpatsch: Yes.
2021-10-20 15:30:32 +0200 <Profpatsch> Ah, okay
2021-10-20 15:30:35 +0200 <dminuoso> Profpatsch: Consider this:
2021-10-20 15:30:38 +0200 <dminuoso> type Middleware = Application -> Application
2021-10-20 15:30:40 +0200 <Profpatsch> I used middleware2 >>> middleware1
2021-10-20 15:30:45 +0200 <dminuoso> And:
2021-10-20 15:30:46 +0200 <Profpatsch> So the order is reversed
2021-10-20 15:30:48 +0200 <dminuoso> type Application = Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived
2021-10-20 15:30:53 +0200 <xsperry> _bo going by the question on codewars link, you don't need group*, just filter, maximum and isConsonant :: Char -> Bool. you can write filter/maximum yourself if you want
2021-10-20 15:31:18 +0200 <dminuoso> xsperry: no, you need either some form of group or span
2021-10-20 15:31:29 +0200 <dminuoso> Or something similar in spirit
2021-10-20 15:31:39 +0200 <Profpatsch> dminuoso: I remember stumbling over this a while ago, thanks for confirming
2021-10-20 15:31:40 +0200 <dminuoso> The task is just poorly phrased
2021-10-20 15:31:56 +0200 <Profpatsch> So i’d use . instead of >>> and the order should be top-to-bottom or left-to-rigth
2021-10-20 15:32:00 +0200 <xsperry> dminuoso, how so? solve("zodiacs") = 26. value of z is 26. filter, maximum, and function that maps consonant to Int is all you need
2021-10-20 15:32:18 +0200acidjnk_new(~acidjnk@pd9e0b933.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2021-10-20 15:32:29 +0200 <dminuoso> xsperry: you take the largest consecutive sequence of consonants, and then add their ascii values together
2021-10-20 15:32:49 +0200 <dminuoso> and the chunk of consequtive consonants with the highest such sum is what this kata is after
2021-10-20 15:32:59 +0200rkrishnan(~user@2402:e280:215c:2cd:d6b1:e062:567:7a9c) (Remote host closed the connection)
2021-10-20 15:33:04 +0200 <xsperry> dminuoso, ah, my mistake. group will be useful then
2021-10-20 15:33:38 +0200 <dminuoso> Profpatsch: Mmm I think you have that the wrong way
2021-10-20 15:34:57 +0200 <dminuoso> Profpatsch: Consider for a second a simple response time logging middleware.
2021-10-20 15:35:08 +0200 <dminuoso> So you might have `profile :: Application -> Application`, or `profile :: Middleware`
2021-10-20 15:35:28 +0200zer0bitz(~zer0bitz@dsl-hkibng31-54fae3-116.dhcp.inet.fi)
2021-10-20 15:35:31 +0200 <dminuoso> You use this by simply applying this to your app `yourApp :: Application`, with `profile yourApp :: Application`
2021-10-20 15:36:17 +0200 <dminuoso> Since this is just a function, composing `profile` with `logging` in `profile . logging` will first apply the logging middleware, and then the profiling middleware.
2021-10-20 15:36:51 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-20 15:36:51 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-20 15:36:51 +0200wroathe(~wroathe@user/wroathe)
2021-10-20 15:36:57 +0200 <dminuoso> Note that the order of middlewares is not necessarily reflecting on the relative order in which effects actually occur.
2021-10-20 15:37:14 +0200 <Profpatsch> logging (profile app)
2021-10-20 15:37:28 +0200 <Profpatsch> Won’t the request be passed to `logging` firts?
2021-10-20 15:37:44 +0200 <dminuoso> Profpatsch: Perhaps its best to simply write a middleware yourself.
2021-10-20 15:37:48 +0200mei(~mei@user/mei) (Read error: Connection reset by peer)
2021-10-20 15:39:10 +0200 <Profpatsch> dminuoso: I have a bunch of self-written middlewares heer
2021-10-20 15:39:19 +0200 <Profpatsch> doesn’t mean I can understand the order in which things run :)
2021-10-20 15:39:36 +0200 <Profpatsch> I mean that would be a prime example of what good Wai documentation should have as an example
2021-10-20 15:39:41 +0200 <dminuoso> Profpatsch: Ah I think there's a mismatch between what you wrote and I understood.
2021-10-20 15:39:44 +0200 <dminuoso> Yes.
2021-10-20 15:40:23 +0200 <dminuoso> The "outer" middleware gets to hook *before* the inner middleware gets a request, and *after* the inner middleware sends a response.
2021-10-20 15:40:42 +0200 <dminuoso> Perhaps "middleware" is a very misleading name, since it's rather like an onion layer
2021-10-20 15:40:51 +0200 <dminuoso> it sits *around* an application, rather than in the middle..
2021-10-20 15:41:01 +0200 <Profpatsch> Yeah.
2021-10-20 15:41:13 +0200 <Profpatsch> Pretty close to just forking wai and improving the docs :)
2021-10-20 15:41:19 +0200 <Profpatsch> I mean I guess why not
2021-10-20 15:41:23 +0200max22-(~maxime@2a01cb0883359800cd1fff3f97961f02.ipv6.abo.wanadoo.fr)
2021-10-20 15:41:32 +0200 <Profpatsch> I did the same to Servant.Foreign https://hackage.haskell.org/package/servant-foreign-0.15.4/docs/Servant-Foreign.html
2021-10-20 15:41:47 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 264 seconds)
2021-10-20 15:42:04 +0200 <dminuoso> Or you can just improve the official documentation?
2021-10-20 15:42:11 +0200 <dminuoso> Im sure if you made a PR, it would be welcomed.
2021-10-20 15:42:57 +0200 <Profpatsch> yep
2021-10-20 15:44:26 +0200tomku(~tomku@user/tomku) (Quit: Lost terminal)
2021-10-20 15:46:18 +0200 <Profpatsch> Okay, I tried it out with badMid a req resp = error "oh no" and logMid a req resp = putStrLn "hi" >> a req resp
2021-10-20 15:46:20 +0200jollygood2(~bc8165b6@217.29.117.252)
2021-10-20 15:46:25 +0200xiongxin(~quassel@119.123.100.49) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2021-10-20 15:46:34 +0200 <Profpatsch> And logMid . badMid prints hi\noh no
2021-10-20 15:46:43 +0200 <Profpatsch> And badMid . logMid only "oh no"
2021-10-20 15:46:50 +0200 <Profpatsch> So the outer one runs “first”
2021-10-20 15:47:06 +0200stengah(~stengah@user/stengah)
2021-10-20 15:47:20 +0200 <Profpatsch> Since all of this is in IO, you can actually determine what is first and what is later :
2021-10-20 15:48:38 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Ping timeout: 260 seconds)
2021-10-20 15:49:11 +0200 <dminuoso> In the absence of forkIO :>
2021-10-20 15:49:44 +0200 <Profpatsch> na na na I can’t hear you
2021-10-20 15:49:57 +0200 <dminuoso> forkIO really ruins a lot of naive interpretations of IO too :(
2021-10-20 15:51:00 +0200 <Profpatsch> I bet terrorjack can tell a story or two about IO and implementing a runtime :P
2021-10-20 15:51:54 +0200stengah(~stengah@user/stengah) (Ping timeout: 260 seconds)
2021-10-20 15:52:54 +0200MQ-17J(~MQ-17J@2607:fb90:1d89:67a9:1cd1:a18:a57f:e102) (Read error: Connection reset by peer)
2021-10-20 15:53:13 +0200MQ-17J(~MQ-17J@35.50.77.148)
2021-10-20 15:54:24 +0200mei(~mei@user/mei)
2021-10-20 15:55:40 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-10-20 15:56:24 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-20 15:56:24 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-20 15:56:24 +0200wroathe(~wroathe@user/wroathe)
2021-10-20 16:00:52 +0200mc47(~mc47@xmonad/TheMC47)
2021-10-20 16:01:13 +0200fef(~thedawn@user/thedawn) (Quit: Leaving)
2021-10-20 16:02:53 +0200 <Profpatsch> lol nobody has touched this documentation since Greg Weber in 2015
2021-10-20 16:03:26 +0200geekosaurthanks you in advance
2021-10-20 16:03:38 +0200 <Profpatsch> Though I don’t understand the existing docstring, at all
2021-10-20 16:03:48 +0200 <Profpatsch> -- string map \[(String, String)\]. A logical type signature for this middleware
2021-10-20 16:03:48 +0200 <geekosaur> every time I hit the documentation for wai I bounce hard :(
2021-10-20 16:03:50 +0200 <Profpatsch> -- might be:
2021-10-20 16:03:53 +0200 <Profpatsch> --
2021-10-20 16:03:54 +0200 <Profpatsch> -- @ loadSession :: ([(String, String)] -> Application) -> Application @
2021-10-20 16:04:08 +0200 <Profpatsch> Why is it left-bracketed
2021-10-20 16:04:37 +0200 <Profpatsch> cause of ([…] -> Req -> Respond -> IO …) -> (Req -> Respond -> IO …)
2021-10-20 16:05:42 +0200lbseale_(~lbseale@user/ep1ctetus)
2021-10-20 16:05:47 +0200 <dminuoso> Profpatsch: Because that's how things are associated?
2021-10-20 16:05:58 +0200 <dminuoso> They are a bit redundant, perhaps some personal style?
2021-10-20 16:06:15 +0200 <dminuoso> That is [(String, String)] -> Application -> Application means the same thing. :)
2021-10-20 16:06:27 +0200 <dminuoso> And yeah, perhaps this is just some refactoring artifact
2021-10-20 16:06:37 +0200 <dminuoso> Perhaps originally this was
2021-10-20 16:06:58 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:8daf:444e:9c84:5148) (Quit: WeeChat 2.8)
2021-10-20 16:07:03 +0200 <Profpatsch> Is it though? a -> b -> b is a -> (b -> b) no?
2021-10-20 16:07:10 +0200 <Profpatsch> Wheras this is (a -> b) -> b
2021-10-20 16:07:14 +0200 <dminuoso> uh hold on
2021-10-20 16:07:24 +0200 <dminuoso> This is embarrassing.
2021-10-20 16:07:26 +0200 <dminuoso> :)
2021-10-20 16:07:35 +0200 <Profpatsch> But yeah, we def need good examples in the docs
2021-10-20 16:07:36 +0200 <dminuoso> Yeah you're right
2021-10-20 16:07:41 +0200 <Profpatsch> That is targeted at haskell newbs
2021-10-20 16:07:47 +0200 <Profpatsch> because that’s who would like to write webservers
2021-10-20 16:07:49 +0200Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de)
2021-10-20 16:08:03 +0200 <Profpatsch> So Wai is in a sense one of the most important Haskell modules
2021-10-20 16:08:07 +0200 <dminuoso> kuribas: Gosh I really hate cassava now. :(
2021-10-20 16:08:15 +0200 <dminuoso> I wish errors worked like this:
2021-10-20 16:08:51 +0200 <dminuoso> a) Id like the option to include the entire row in an error, or b) include some primary key (from the row) in an error
2021-10-20 16:08:54 +0200tomku(~tomku@user/tomku)
2021-10-20 16:08:56 +0200 <dminuoso> Such that you could write:
2021-10-20 16:09:10 +0200lbseale(~lbseale@user/ep1ctetus) (Ping timeout: 260 seconds)
2021-10-20 16:09:39 +0200 <Profpatsch> Can I modify a response with a Middleware? I don’t think so right?
2021-10-20 16:09:45 +0200 <dminuoso> parseRow = do key <- rec .: "key"; context (show key) $ Record key <$> rec .: "foo" <*> rec .: "bar" <*> rec .: "quux"
2021-10-20 16:09:54 +0200 <dminuoso> Profpatsch: Yes you can.
2021-10-20 16:10:13 +0200 <Profpatsch> Oh you can, you just have to create a new (Response -> IO ResponseReceived) and pass it into the next middleware
2021-10-20 16:10:18 +0200 <dminuoso> Indeed.,
2021-10-20 16:10:23 +0200 <dminuoso> It's just very disgusting to do
2021-10-20 16:10:46 +0200 <Profpatsch> So I guess there should be two examples, one how to adjust the Request and one the response
2021-10-20 16:10:54 +0200 <Profpatsch> dminuoso: why is that? e.g. you need it for gzipping
2021-10-20 16:11:06 +0200 <dminuoso> Profpatsch: for that I'd simply put nginx in front
2021-10-20 16:11:09 +0200 <Profpatsch> Iterate over the responseBody chunker and gzip the chunks
2021-10-20 16:11:11 +0200 <dminuoso> Which I'd have in any case for tls termination
2021-10-20 16:11:14 +0200 <dminuoso> and other things
2021-10-20 16:11:15 +0200 <Profpatsch> dminuoso: ah, that’s true
2021-10-20 16:12:10 +0200Sgeo(~Sgeo@user/sgeo)
2021-10-20 16:12:40 +0200razor[m](~razormone@2001:470:69fc:105::f048) ()
2021-10-20 16:12:53 +0200absence(torgeihe@hildring.pvv.ntnu.no)
2021-10-20 16:13:58 +0200 <absence> in a project where "-F -pgmF=record-dot-preprocessor" is added to ghc options in the .cabal file, how can i disable this preprocessor in a specific file using a pragma?
2021-10-20 16:16:27 +0200 <dminuoso> Profpatsch: And regarding modifying the response, the problem is that Response is a very internal type
2021-10-20 16:16:41 +0200 <dminuoso> Profpatsch: So in order to *modify* it, you have to do a lot of highly annoying work
2021-10-20 16:17:54 +0200 <dminuoso> You'd likely use responseToStream, and then some real annoying work starts.
2021-10-20 16:18:20 +0200 <dminuoso> Profpatsch: And btw, wai provides some modifyResponse helper
2021-10-20 16:18:25 +0200 <dminuoso> modifyResponse :: (Response -> Response) -> Middleware
2021-10-20 16:18:34 +0200 <dminuoso> Modifying status and headers is easy
2021-10-20 16:18:38 +0200 <dminuoso> Modifying the body is annoying.
2021-10-20 16:18:51 +0200 <dminuoso> You'd have to create a custom type StreamingBody = (Builder -> IO ()) -> IO () -> IO ()
2021-10-20 16:19:26 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 260 seconds)
2021-10-20 16:20:22 +0200ubert(~Thunderbi@91.141.37.135.wireless.dyn.drei.com) (Remote host closed the connection)
2021-10-20 16:20:40 +0200 <dminuoso> And then using that custom StreamingBody, that would write these chunks into some buffer of your choosing, process it, and then create a separate StreamingBody, and feed those processed chunks into that.
2021-10-20 16:20:56 +0200grfn(sid449115@id-449115.helmsley.irccloud.com) (Ping timeout: 245 seconds)
2021-10-20 16:20:56 +0200ehamberg(sid18208@id-18208.hampstead.irccloud.com) (Ping timeout: 245 seconds)
2021-10-20 16:21:23 +0200kupi(uid212005@id-212005.hampstead.irccloud.com) (Ping timeout: 264 seconds)
2021-10-20 16:21:23 +0200astra`(sid289983@user/amish) (Ping timeout: 264 seconds)
2021-10-20 16:21:41 +0200sclv(sid39734@haskell/developer/sclv) (Ping timeout: 258 seconds)
2021-10-20 16:21:42 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2021-10-20 16:21:46 +0200tritlo(sid58727@user/tritlo) (Ping timeout: 245 seconds)
2021-10-20 16:22:04 +0200amir(sid22336@user/amir) (Ping timeout: 258 seconds)
2021-10-20 16:22:04 +0200jonrh(sid5185@id-5185.ilkley.irccloud.com) (Ping timeout: 258 seconds)
2021-10-20 16:22:12 +0200ubert1(~Thunderbi@91.141.37.135.wireless.dyn.drei.com) (Quit: ubert1)
2021-10-20 16:22:27 +0200elvishjerricco(sid237756@id-237756.helmsley.irccloud.com) (Ping timeout: 258 seconds)
2021-10-20 16:22:35 +0200dmj`(sid72307@id-72307.hampstead.irccloud.com) (Ping timeout: 264 seconds)
2021-10-20 16:22:35 +0200SrPx(sid108780@id-108780.uxbridge.irccloud.com) (Ping timeout: 264 seconds)
2021-10-20 16:22:35 +0200ubert(~Thunderbi@91.141.37.135.wireless.dyn.drei.com)
2021-10-20 16:22:50 +0200 <dminuoso> That separate streaming body/lazy bytestring/builder can then be used to reconstruct a Response via responseLBS/responseStream/responseBuilder
2021-10-20 16:23:11 +0200Boarders(sid425905@id-425905.lymington.irccloud.com) (Ping timeout: 264 seconds)
2021-10-20 16:23:11 +0200etrepum(sid763@id-763.uxbridge.irccloud.com) (Ping timeout: 264 seconds)
2021-10-20 16:23:29 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-10-20 16:23:32 +0200SrPx(sid108780@uxbridge.irccloud.com)
2021-10-20 16:23:40 +0200grfn(sid449115@helmsley.irccloud.com)
2021-10-20 16:23:41 +0200etrepum(sid763@uxbridge.irccloud.com)
2021-10-20 16:23:47 +0200elvishjerricco(sid237756@helmsley.irccloud.com)
2021-10-20 16:23:47 +0200jonrh(sid5185@ilkley.irccloud.com)
2021-10-20 16:23:47 +0200amir(sid22336@user/amir)
2021-10-20 16:23:56 +0200tritlo(sid58727@user/tritlo)
2021-10-20 16:23:56 +0200astra`(sid289983@user/amish)
2021-10-20 16:23:57 +0200dmj`(sid72307@hampstead.irccloud.com)
2021-10-20 16:23:58 +0200kupi(uid212005@hampstead.irccloud.com)
2021-10-20 16:24:00 +0200ehamberg(sid18208@hampstead.irccloud.com)
2021-10-20 16:24:39 +0200kupi(uid212005@hampstead.irccloud.com) (Client Quit)
2021-10-20 16:25:09 +0200sclv(sid39734@haskell/developer/sclv)
2021-10-20 16:25:26 +0200Boarders(sid425905@id-425905.lymington.irccloud.com)
2021-10-20 16:26:04 +0200stengah(~stengah@user/stengah)
2021-10-20 16:26:11 +0200ub(~Thunderbi@91.141.37.135.wireless.dyn.drei.com)
2021-10-20 16:26:28 +0200 <geekosaur> absence, by the time it reads the pragma it's already been through the preprocessor
2021-10-20 16:26:39 +0200coot(~coot@37.30.49.107.nat.umts.dynamic.t-mobile.pl)
2021-10-20 16:26:54 +0200unit73e(~emanuel@2001:818:e8dd:7c00:32b5:c2ff:fe6b:5291)
2021-10-20 16:26:57 +0200shriekingnoise(~shrieking@186.137.144.80)
2021-10-20 16:28:05 +0200 <Profpatsch> dminuoso: yeah, I remember. I think the thing is that it was expected only a server would ever consume the Response type
2021-10-20 16:28:14 +0200 <Profpatsch> So no helpers exist to make consuming it very nice
2021-10-20 16:28:38 +0200 <Profpatsch> I wrote a “pure” Application caller here, I should open source it actually, which is nice in tests
2021-10-20 16:28:44 +0200 <dminuoso> Profpatsch: No, the problem is that the output is streamed.
2021-10-20 16:28:46 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Ping timeout: 260 seconds)
2021-10-20 16:29:02 +0200 <dminuoso> If processing that output was desirable, you'd need an appropriate streaming library
2021-10-20 16:29:06 +0200 <Profpatsch> It just reads the response body chunks into a binary builder and/or an ioref
2021-10-20 16:30:49 +0200pbrisbin(~patrick@pool-173-49-152-45.phlapa.fios.verizon.net) (Ping timeout: 252 seconds)
2021-10-20 16:32:33 +0200pbrisbin(~patrick@199.66.179.206)
2021-10-20 16:33:31 +0200slack1256(~slack1256@45.4.2.52) (Remote host closed the connection)
2021-10-20 16:34:52 +0200jgeerds(~jgeerds@55d4da80.access.ecotel.net)
2021-10-20 16:35:31 +0200 <absence> geekosaur: ah, that's unfortunate, but makes sense. thanks!
2021-10-20 16:36:02 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-20 16:36:02 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-20 16:36:02 +0200wroathe(~wroathe@user/wroathe)
2021-10-20 16:37:19 +0200Inst(~Inst@2601:6c4:4080:3f80:6134:7ceb:5f94:e843) (Remote host closed the connection)
2021-10-20 16:37:36 +0200Inst(~Inst@2601:6c4:4080:3f80:887d:efb8:1cec:d51f)
2021-10-20 16:40:26 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 260 seconds)
2021-10-20 16:41:41 +0200max22-(~maxime@2a01cb0883359800cd1fff3f97961f02.ipv6.abo.wanadoo.fr) (Remote host closed the connection)
2021-10-20 16:42:15 +0200unit73e(~emanuel@2001:818:e8dd:7c00:32b5:c2ff:fe6b:5291) (Remote host closed the connection)
2021-10-20 16:42:40 +0200max22-(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr)
2021-10-20 16:42:59 +0200timCF(~timCF@200-149-20-81.sta.estpak.ee)
2021-10-20 16:46:04 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-10-20 16:48:08 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-10-20 16:48:12 +0200timCF(~timCF@200-149-20-81.sta.estpak.ee) (Quit: leaving)
2021-10-20 16:49:33 +0200hendursa1(~weechat@user/hendursaga) (Quit: hendursa1)
2021-10-20 16:50:05 +0200ub(~Thunderbi@91.141.37.135.wireless.dyn.drei.com) (Ping timeout: 260 seconds)
2021-10-20 16:50:06 +0200iteratee(~kyle@162.218.222.107)
2021-10-20 16:50:12 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-10-20 16:50:45 +0200hendursaga(~weechat@user/hendursaga)
2021-10-20 16:52:29 +0200timCF(~timCF@200-149-20-81.sta.estpak.ee)
2021-10-20 16:52:52 +0200MQ-17J(~MQ-17J@35.50.77.148) (Ping timeout: 252 seconds)
2021-10-20 16:53:34 +0200Nosrep(~archbox@user/nosrep)
2021-10-20 16:54:17 +0200hnOsmium0001(uid453710@id-453710.hampstead.irccloud.com)
2021-10-20 16:54:48 +0200MQ-17J(~MQ-17J@2607:fb90:1d89:67a9:1cd1:a18:a57f:e102)
2021-10-20 16:56:01 +0200 <timCF> Hello! I have a question about Async. When I'm doing high-level `withAsync task inner`, do I need to call `link pid` inside the inner to allow expection from `task` thread propagete immediately to parent thread?
2021-10-20 16:56:42 +0200 <timCF> Of course there is source, but I'm not sure I do fully understand it https://hackage.haskell.org/package/async-2.2.4/docs/src/Control.Concurrent.Async.html#withAsyncUs…
2021-10-20 16:57:59 +0200tinhatcat(~manjaro-g@2620:103:a000:2201:8e4c:af6a:e11c:11a1) (Quit: Leaving)
2021-10-20 17:00:11 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:e2c3:1bcc:edee:e9f1)
2021-10-20 17:00:46 +0200 <_bo> Guys, I'm trying to write my own `span` and the following code gives me ` Occurs check: cannot construct the infinite type: a ~ [a]
2021-10-20 17:00:46 +0200 <_bo> * In the expression: left`: https://gist.github.com/MidasBetankor/84c8951af333a382ed386c7de3529831 can someone see why?
2021-10-20 17:01:40 +0200 <_bo> Tried to think of span as: "it's an array of two sub-arrays, where left one has all values that satisfy predicate and right one has rest of elements after first time predicate misses"
2021-10-20 17:01:45 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Ping timeout: 260 seconds)
2021-10-20 17:02:03 +0200 <_bo> But still can't see what's so infinite about `left` sub-array in the snippet above
2021-10-20 17:03:23 +0200 <Inst> hi, could I have some help?
2021-10-20 17:03:31 +0200 <Franciman> hi Inst ofc
2021-10-20 17:03:31 +0200 <Inst> what does 50 :: Num a => a mean?
2021-10-20 17:03:47 +0200 <Inst> "if a is one of the types of number, then 50 can have type a"
2021-10-20 17:03:51 +0200 <Inst> that's what the textbook says
2021-10-20 17:04:12 +0200 <Inst> the reason it's confusing is because it can be read as "but a might not be a type of number"
2021-10-20 17:04:21 +0200 <Franciman> Num a => a
2021-10-20 17:04:36 +0200 <Inst> on :type 50, which really should just be :t 50
2021-10-20 17:04:54 +0200 <Inst> I'm just wondering what it means mathematically
2021-10-20 17:05:09 +0200 <Inst> if a is within the Set "number"
2021-10-20 17:05:15 +0200 <Inst> but then it's cat theory not set theory
2021-10-20 17:05:46 +0200 <geekosaur> it doesn't mean anything strictly mathematically, it's just a convenience so you don';t have to annotate every numeric literal with its intended type
2021-10-20 17:05:54 +0200 <iteratee> It's programmatic, not mathematic. If there is an active instance of "Num" for a, then 50 can be of type a.
2021-10-20 17:06:28 +0200 <Inst> what is meant by active instance of "num", i.e, by saying active you're implying it can also be inactive
2021-10-20 17:06:44 +0200 <iteratee> It has to be imported somehow.
2021-10-20 17:07:37 +0200 <Inst> so the type has to be declared into the program, but num is a fundamental type of Haskell
2021-10-20 17:07:58 +0200 <Inst> say, let's assume there is some type that's not implemented
2021-10-20 17:08:06 +0200 <Inst> for whatever reason :t gives that type
2021-10-20 17:08:24 +0200 <Inst> but it's stating that the expression will fail if that type isn't active?
2021-10-20 17:09:36 +0200 <iteratee> No. (Num a => a) means that for any type the compiler knows is a Num, the expression can be evaluated as that type.
2021-10-20 17:11:02 +0200 <_bo> > can't see what's so infinite about `left` < Please disregard, figured it out
2021-10-20 17:11:04 +0200 <lambdabot> <hint>:1:43: error: parse error on input ‘<’
2021-10-20 17:11:07 +0200 <Inst> bleh, i'll reread the section, i skimmed it first after i couldn't understand what the "if a is one of the types of number, then 50 can have type a"
2021-10-20 17:12:02 +0200 <iteratee> It's probably easier to understand "IsString" with the OverloadedStrings extension.
2021-10-20 17:12:12 +0200 <iteratee> Num is doing something similar.
2021-10-20 17:12:34 +0200 <monochrom> Inst: I think my http://www.cs.utoronto.ca/~trebla/CSCC24-2021-Summer/04-haskell-types-2.html helps. I am not going to commit to wordings like "set of types" or "set of methods" though (you see the problem?).
2021-10-20 17:13:25 +0200 <iteratee> > 50 :: Rational
2021-10-20 17:13:27 +0200 <lambdabot> 50 % 1
2021-10-20 17:13:33 +0200 <iteratee> > 50 :: Double
2021-10-20 17:13:34 +0200 <lambdabot> 50.0
2021-10-20 17:13:38 +0200 <iteratee> > 50 :: String
2021-10-20 17:13:40 +0200 <lambdabot> error:
2021-10-20 17:13:40 +0200 <lambdabot> • No instance for (Num String) arising from the literal ‘50’
2021-10-20 17:13:40 +0200 <lambdabot> • In the expression: 50 :: String
2021-10-20 17:14:59 +0200 <jollygood2> you could write a (completely silly) Num instance for String, and then 50 :: String would compile. you could also write it for your own, say, bignum type, and you could use numerical literals and all the math operators with it
2021-10-20 17:15:21 +0200 <iteratee> @jollygood2 exactly
2021-10-20 17:15:22 +0200 <lambdabot> Unknown command, try @list
2021-10-20 17:15:53 +0200 <geekosaur> there is such an instance in one of the "acme" packages
2021-10-20 17:16:16 +0200 <geekosaur> there's also an instance for Applicatives that is occasionally loaded into the bot
2021-10-20 17:17:04 +0200MQ-17J(~MQ-17J@2607:fb90:1d89:67a9:1cd1:a18:a57f:e102) (Read error: Connection reset by peer)
2021-10-20 17:17:28 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-20 17:18:34 +0200stengah(~stengah@user/stengah) ()
2021-10-20 17:25:33 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:e2c3:1bcc:edee:e9f1) (Quit: WeeChat 2.8)
2021-10-20 17:25:42 +0200Guest87(~Guest87@211.165.185.81.rev.sfr.net)
2021-10-20 17:26:42 +0200Farzad(~FarzadBek@178.131.24.144) (Ping timeout: 265 seconds)
2021-10-20 17:28:31 +0200 <Guest87> hello, I'm trying to choose a pretty printing library, my requirements are basically a nice way to handle indentation (think JSON). custom formatting for data types would be nice
2021-10-20 17:29:09 +0200Tuplanolla(~Tuplanoll@91-159-69-50.elisa-laajakaista.fi)
2021-10-20 17:29:38 +0200 <Guest87> prettyprinter seems to be the "default" choice?
2021-10-20 17:31:11 +0200 <lyxia> yes
2021-10-20 17:37:10 +0200 <ph88> when i set the max memory option on the runtime system is the garbage collector doing extra effort to clear up memory once the limit is hit ?
2021-10-20 17:39:40 +0200Guest55(~Guest55@78.198.4.122) (Quit: Client closed)
2021-10-20 17:40:29 +0200Null_A(~null_a@2601:645:8700:2290:a94b:e46c:6690:e477)
2021-10-20 17:41:33 +0200emliunix(~emliunix@101.88.126.148) (Remote host closed the connection)
2021-10-20 17:43:12 +0200gehmehgeh(~user@user/gehmehgeh) (Ping timeout: 276 seconds)
2021-10-20 17:43:46 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-10-20 17:43:47 +0200Guest87(~Guest87@211.165.185.81.rev.sfr.net) (Quit: Client closed)
2021-10-20 17:44:26 +0200_ht(~quassel@82-169-194-8.biz.kpn.net)
2021-10-20 17:45:01 +0200gehmehgeh(~user@user/gehmehgeh)
2021-10-20 17:45:03 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:9105:355e:98db:81cc)
2021-10-20 17:45:13 +0200slowButPresent(~slowButPr@user/slowbutpresent)
2021-10-20 17:45:43 +0200lavaman(~lavaman@98.38.249.169)
2021-10-20 17:46:15 +0200emliunix(~emliunix@101.88.126.148)
2021-10-20 17:48:27 +0200tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2021-10-20 17:51:23 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Read error: Connection reset by peer)
2021-10-20 17:52:26 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-20 17:54:06 +0200myShoggoth(~myShoggot@97-120-85-195.ptld.qwest.net)
2021-10-20 17:56:34 +0200 <janus> i would argue 'pretty' is more default since it is in the haskell org?
2021-10-20 17:56:49 +0200rond_(~rond_@2a02:a31a:a23c:f480:2fd7:e087:5546:a438) (Quit: Client closed)
2021-10-20 17:57:17 +0200 <janus> tree-diff uses pretty and i like tree-diff
2021-10-20 17:57:32 +0200 <Franciman> @hackage tree-diff
2021-10-20 17:57:33 +0200pbrisbin(~patrick@199.66.179.206) (Read error: Connection reset by peer)
2021-10-20 17:57:33 +0200 <lambdabot> https://hackage.haskell.org/package/tree-diff
2021-10-20 17:57:43 +0200 <Franciman> so neado
2021-10-20 17:57:46 +0200 <Franciman> tusen takk
2021-10-20 17:57:48 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2021-10-20 17:58:11 +0200emf(~emf@2620:10d:c090:400::5:7558)
2021-10-20 17:58:28 +0200unit73e(~emanuel@2001:818:e8dd:7c00:32b5:c2ff:fe6b:5291)
2021-10-20 17:58:33 +0200ec(~ec@gateway/tor-sasl/ec)
2021-10-20 17:59:27 +0200 <monochrom> pretty has the convenience factor that it comes with GHC.
2021-10-20 17:59:45 +0200 <Franciman> but if you use cabal, that is not so important
2021-10-20 18:00:06 +0200hjulle[m](~hjullemat@2001:470:69fc:105::1dd) (Quit: You have been kicked for being idle)
2021-10-20 18:00:06 +0200dualinverter[m](~dualinver@2001:470:69fc:105::16a7) (Quit: You have been kicked for being idle)
2021-10-20 18:00:14 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Ping timeout: 260 seconds)
2021-10-20 18:01:32 +0200_bo(~bo@217.18.216.247) (Read error: Connection reset by peer)
2021-10-20 18:03:50 +0200pbrisbin(~patrick@pool-173-49-152-45.phlapa.fios.verizon.net)
2021-10-20 18:04:35 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 264 seconds)
2021-10-20 18:05:17 +0200segfaultfizzbuzz(~segfaultf@135-180-0-138.static.sonic.net)
2021-10-20 18:06:28 +0200kupi(uid212005@id-212005.hampstead.irccloud.com)
2021-10-20 18:12:20 +0200Farzad(~FarzadBek@37.49.149.40)
2021-10-20 18:13:42 +0200jgeerds(~jgeerds@55d4da80.access.ecotel.net) (Remote host closed the connection)
2021-10-20 18:15:15 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 18:15:42 +0200hendursaga(~weechat@user/hendursaga) (Ping timeout: 276 seconds)
2021-10-20 18:16:15 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 18:16:54 +0200hgolden(~hgolden2@cpe-172-114-81-123.socal.res.rr.com)
2021-10-20 18:17:11 +0200pooryorick(~pooryoric@87-119-174-173.tll.elisa.ee) (Ping timeout: 246 seconds)
2021-10-20 18:17:12 +0200ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2021-10-20 18:17:23 +0200hendursaga(~weechat@user/hendursaga)
2021-10-20 18:17:36 +0200awth13(~awth13@user/awth13) (Quit: ZNC 1.8.2 - https://znc.in)
2021-10-20 18:17:47 +0200 <dminuoso> To be fair, prettyprinter has a fair lightweight dependency footprint. It's very likely it wont introduce additional transitive dependencies for most projects.
2021-10-20 18:17:51 +0200tommd(~tommd@75-164-130-101.ptld.qwest.net)
2021-10-20 18:18:00 +0200FarzadBekran_(~FarzadBek@37.49.149.40)
2021-10-20 18:18:30 +0200FarzadBekran_(~FarzadBek@37.49.149.40) (Remote host closed the connection)
2021-10-20 18:19:19 +0200pooryorick(~pooryoric@87-119-174-173.tll.elisa.ee)
2021-10-20 18:19:22 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-20 18:19:43 +0200 <dminuoso> And it addresses certain issues that pretty has
2021-10-20 18:20:54 +0200Farzad(~FarzadBek@37.49.149.40) (Ping timeout: 258 seconds)
2021-10-20 18:21:40 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 258 seconds)
2021-10-20 18:22:01 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 18:23:59 +0200ub(~Thunderbi@91.141.37.135.wireless.dyn.drei.com)
2021-10-20 18:24:41 +0200awth13(~awth13@user/awth13)
2021-10-20 18:25:56 +0200ArtVandelayer(~ArtVandel@ip174-68-147-20.lv.lv.cox.net) (Ping timeout: 245 seconds)
2021-10-20 18:27:05 +0200ubert(~Thunderbi@91.141.37.135.wireless.dyn.drei.com) (Quit: ubert)
2021-10-20 18:27:06 +0200ububert
2021-10-20 18:27:18 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 18:27:29 +0200ubert1(~Thunderbi@91.141.37.135.wireless.dyn.drei.com)
2021-10-20 18:28:02 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 18:28:35 +0200ubert(~Thunderbi@91.141.37.135.wireless.dyn.drei.com) (Remote host closed the connection)
2021-10-20 18:28:35 +0200ubert1ubert
2021-10-20 18:30:01 +0200 <Profpatsch> dminuoso: geekosaur https://github.com/yesodweb/wai/pull/858
2021-10-20 18:31:57 +0200 <Profpatsch> Oh how I wish for haddock to have comments haha
2021-10-20 18:32:11 +0200 <Profpatsch> Maybe there is a way to add them via a third-party server and a browser plugin
2021-10-20 18:32:31 +0200 <Profpatsch> The PHP doc comments are such a chaotic good feature
2021-10-20 18:33:22 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 18:33:42 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 18:34:02 +0200coot(~coot@37.30.49.107.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2021-10-20 18:35:57 +0200timCF_(~timCF@m91-129-111-87.cust.tele2.ee)
2021-10-20 18:36:46 +0200emliunix(~emliunix@101.88.126.148) (Remote host closed the connection)
2021-10-20 18:39:37 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-10-20 18:40:12 +0200jumper149(~jumper149@80.240.31.34) (Quit: WeeChat 3.2)
2021-10-20 18:42:29 +0200seer(~delicacie@c-98-208-218-119.hsd1.fl.comcast.net)
2021-10-20 18:42:38 +0200seerInstX1
2021-10-20 18:42:40 +0200 <InstX1> hi guys
2021-10-20 18:42:51 +0200Tuplanolla(~Tuplanoll@91-159-69-50.elisa-laajakaista.fi) (Quit: Leaving.)
2021-10-20 18:42:54 +0200 <InstX1> i got a message back from the Haskell Foundation, some nice resources for non-professional programmers
2021-10-20 18:42:55 +0200 <InstX1> https://github.com/haskellfoundation/HaskellSchool
2021-10-20 18:43:27 +0200 <InstX1> there's also Professor Graham Hutton's lectures on Haskell
2021-10-20 18:43:41 +0200 <InstX1> https://www.youtube.com/watch?v=TdpBqhlgqGI
2021-10-20 18:43:50 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 18:44:31 +0200 <InstX1> They seem to be more concerned about supporting and retaining existing Haskell programmers, though
2021-10-20 18:44:40 +0200 <InstX1> and I can understand why they can make it an emphasis
2021-10-20 18:45:08 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 18:45:56 +0200alzgh(~alzgh@user/alzgh) (Remote host closed the connection)
2021-10-20 18:46:17 +0200alzgh(~alzgh@user/alzgh)
2021-10-20 18:48:29 +0200 <InstX1> they feel like the ecosystem etc and ide isn't sufficient to keep new haskellers, though
2021-10-20 18:48:30 +0200myShoggoth(~myShoggot@97-120-85-195.ptld.qwest.net) (Ping timeout: 260 seconds)
2021-10-20 18:49:21 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 265 seconds)
2021-10-20 18:50:01 +0200xff0x(~xff0x@2001:1a81:5213:b200:9d6e:5b31:ca1b:5892) (Ping timeout: 252 seconds)
2021-10-20 18:50:07 +0200 <unit73e> InstX1, meaning the ecosystem and IDEs are kind of lacking?
2021-10-20 18:50:33 +0200 <InstX1> i can't even get a proper install of the IDE on windows
2021-10-20 18:50:35 +0200 <unit73e> vscode does a good job for beginners imo
2021-10-20 18:50:41 +0200 <InstX1> there used to be a nice setup thing
2021-10-20 18:50:46 +0200xff0x(~xff0x@2001:1a81:5213:b200:3795:60dd:993c:5506)
2021-10-20 18:50:50 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 18:50:54 +0200 <unit73e> hum I don't use windows so I wouldn't know
2021-10-20 18:50:54 +0200 <InstX1> yeah ut beginners need ghci or another interpreter
2021-10-20 18:51:02 +0200myShoggoth(~myShoggot@97-120-85-195.ptld.qwest.net)
2021-10-20 18:51:06 +0200 <unit73e> there's also IntelliJ
2021-10-20 18:51:16 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 18:51:22 +0200 <unit73e> but I feel like vscode does a better job
2021-10-20 18:51:34 +0200 <unit73e> regardless, imo that's the least of a beginners worries
2021-10-20 18:52:09 +0200 <InstX1> textbooks seem fine, i'm really enjoying the basics book written by a guy teaching at cambridge, though
2021-10-20 18:52:20 +0200ec_(~ec@gateway/tor-sasl/ec)
2021-10-20 18:52:33 +0200Cajun(~Cajun@user/cajun) (Quit: Client closed)
2021-10-20 18:52:55 +0200 <InstX1> the problem is, though, is that it seems equivalent to the first third or first half of a proper textbook, monads don't show up in the index
2021-10-20 18:53:03 +0200 <unit73e> doing things different is perhaps the biggest stop gap of all, like having to do IO in an IO monad, or learning that you can't just have state out of nowhere, and so on
2021-10-20 18:53:39 +0200 <unit73e> I think state is the next big problem for new users
2021-10-20 18:54:03 +0200 <unit73e> because you have to carry it around and for imperative programmers that's not a thing
2021-10-20 18:54:09 +0200 <InstX1> the target audience i'm talking about
2021-10-20 18:54:17 +0200 <InstX1> doesn't even know what state is
2021-10-20 18:54:41 +0200 <InstX1> i'm coming from effectively a non-programmer paradigm, so i annoyed people by arguing that haskell should target non-coders etc
2021-10-20 18:55:19 +0200 <unit73e> you do have to start somewhere
2021-10-20 18:55:57 +0200 <yushyin> every time i look into this channel it's the same discussion on and on :D
2021-10-20 18:56:18 +0200 <unit73e> for a non-programmer it doesn't really matter which you choose first I think but haskell is obviously structured differently, by "joining functions"
2021-10-20 18:56:29 +0200cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.3)
2021-10-20 18:56:46 +0200 <unit73e> yushyin, lol yeah. I use it mostly for questions and to show my SDL examples
2021-10-20 18:59:33 +0200 <zincy> Is it normal for Haskell packages to rely on types of other packages? Someone is asking me to "unify" the types with their library and I just don't feel I have the experience to know if it is a good idea or not.
2021-10-20 18:59:48 +0200 <zincy> https://github.com/therewillbecode/poker-maison/issues/20
2021-10-20 19:01:05 +0200 <geekosaur> if you use other packages you generally have to use their types
2021-10-20 19:01:36 +0200 <zincy> Yeah so the question is really should I use this other package then
2021-10-20 19:02:17 +0200 <geekosaur> depends. they're trying to build a poker ecosystem; up to you whether you want to contribute to that ecosystem
2021-10-20 19:02:30 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 19:02:38 +0200 <maerwald> that's where weak types have an advantage... they're more compatible
2021-10-20 19:02:43 +0200 <geekosaur> in general not duplicating effort is a good thing, it's just annoying for existing packages
2021-10-20 19:02:48 +0200 <maerwald> compare lazy bytestring with streaming types
2021-10-20 19:03:43 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 19:04:41 +0200chele(~chele@user/chele) (Remote host closed the connection)
2021-10-20 19:05:25 +0200xff0x(~xff0x@2001:1a81:5213:b200:3795:60dd:993c:5506) (Ping timeout: 260 seconds)
2021-10-20 19:05:57 +0200zebrag(~chris@user/zebrag)
2021-10-20 19:05:59 +0200xff0x(~xff0x@port-92-195-26-90.dynamic.as20676.net)
2021-10-20 19:08:44 +0200ub(~Thunderbi@91.141.37.135.wireless.dyn.drei.com)
2021-10-20 19:09:18 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 19:10:10 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 19:11:44 +0200 <zincy> Cheers!
2021-10-20 19:11:59 +0200wonko(~wjc@62.115.229.50)
2021-10-20 19:12:02 +0200benin(~benin@183.82.179.164)
2021-10-20 19:12:15 +0200ec_(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-20 19:12:45 +0200ec_(~ec@gateway/tor-sasl/ec)
2021-10-20 19:15:14 +0200econo(uid147250@user/econo)
2021-10-20 19:15:20 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 19:16:25 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 19:17:08 +0200ubert(~Thunderbi@91.141.37.135.wireless.dyn.drei.com) (Remote host closed the connection)
2021-10-20 19:19:24 +0200ec_(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-20 19:19:57 +0200cads(~asdf@ip-64-72-99-234.lasvegas.net)
2021-10-20 19:20:19 +0200ub(~Thunderbi@91.141.37.135.wireless.dyn.drei.com) (Ping timeout: 258 seconds)
2021-10-20 19:20:41 +0200suryasiva(~suryasiva@49.206.117.198)
2021-10-20 19:21:45 +0200suryasiva(~suryasiva@49.206.117.198) (Client Quit)
2021-10-20 19:21:54 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 19:21:58 +0200 <cads> hey all, a strong monad M has a strength transform S_A,B : A x SB -> S(AxB) which makes M compatible with the underlying product operation "In one way"
2021-10-20 19:22:27 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 19:23:40 +0200suryasiva(~suryasiva@49.206.117.198)
2021-10-20 19:23:55 +0200 <cads> the strength transform is usually expressed via its components S_(A, B). But what are the two functors that S transforms between?
2021-10-20 19:27:58 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Read error: Connection reset by peer)
2021-10-20 19:28:10 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 19:28:26 +0200aegon(~mike@174.127.249.180)
2021-10-20 19:28:37 +0200 <ManofLetters[m]> are you offending us?
2021-10-20 19:28:50 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 19:28:57 +0200alzgh(~alzgh@user/alzgh) (Remote host closed the connection)
2021-10-20 19:29:18 +0200alzgh(~alzgh@user/alzgh)
2021-10-20 19:29:54 +0200 <cads> ManofLetters[m], no offense is meant, I am trying to understand strong monads because as far as I can tell, they are the "mathy" version of applicative functors
2021-10-20 19:30:38 +0200suryasiva(~suryasiva@49.206.117.198) (Quit: suryasiva)
2021-10-20 19:32:34 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-20 19:33:11 +0200 <awpr> a) looks to me like it's `_1 x M _2` ~> `M (_1 x _2)` (both of those being functors from HaskxHask to Hask); b) applicative <=> lax monoidal functor; and c) all Haskell `Functor`s are "strong" in this way, because `\x fy -> fmap (x,) fx`
2021-10-20 19:33:22 +0200 <ManofLetters[m]> is S_A is a natural transformation with signature S_A : A x SB -> S(AxB), then it's a natural transformation from functor \K . K x S(B_ to functor \K . S(K x B), where is S is, probably, an arbitrary functor
2021-10-20 19:33:41 +0200 <ManofLetters[m]> * \K . K x S(B)
2021-10-20 19:34:07 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 258 seconds)
2021-10-20 19:34:07 +0200 <ManofLetters[m]> and I didn't say what B is and where it's quantified; hmm
2021-10-20 19:34:30 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 258 seconds)
2021-10-20 19:34:40 +0200 <ManofLetters[m]> so probably awpr has a fuller picture
2021-10-20 19:34:42 +0200 <awpr> if we're talking about functor strength, the `M` (which I renamed from `S` should be fixed to the particular functor we have a strength for)
2021-10-20 19:34:56 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 19:35:01 +0200 <awpr> parens in the wrong place, but close enough
2021-10-20 19:35:23 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-20 19:36:29 +0200ec_(~ec@gateway/tor-sasl/ec)
2021-10-20 19:37:31 +0200 <cads> I think I have conflated the notion of Strong Monad, with the notion of a Lax Functor With Strength. The Strong Lax Functor is already an applicative, even if it has no monadic multiplication and unit transforms.
2021-10-20 19:38:04 +0200 <ph88> anyone know if it's possible to get the remainder of the unparsed text with megaparsec ?
2021-10-20 19:39:13 +0200 <ManofLetters[m]> cads: so, for any functor S, the 2-category has S-strength (the functor S is a strong lax functor?), if for any 1-object B, there is a natural transformation from functor \K . K x S(B) to \K . S(K x B) ???
2021-10-20 19:39:21 +0200meltedbrain_y2k(~tekserf@94.73.36.197)
2021-10-20 19:40:06 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 19:40:06 +0200 <ManofLetters[m]> (putting aside Hask)
2021-10-20 19:40:55 +0200 <cads> ManofLetters[m], I can't understand 2-categorical or delooped definitions of strength yet - I am trying to work with the naive "concrete" definition here, which defines the strength transform within the monoidal category itself https://ncatlab.org/nlab/show/strong+monad#concrete_definition
2021-10-20 19:41:07 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 19:41:08 +0200 <ManofLetters[m]> and I guess, in case of Hask, it means that the real Haskell functors can handle free variables quantified somewhere outside
2021-10-20 19:41:23 +0200 <ManofLetters[m]> ok, have fun :)
2021-10-20 19:42:04 +0200 <ManofLetters[m]> (where S(B) would be the free variables)
2021-10-20 19:42:20 +0200 <ManofLetters[m]> (or, rather, B would be the free variables)
2021-10-20 19:44:46 +0200alzgh(~alzgh@user/alzgh) (Remote host closed the connection)
2021-10-20 19:45:06 +0200alzgh(~alzgh@user/alzgh)
2021-10-20 19:45:58 +0200 <cads> One thing we know about the transform: its components are indexed by two objects A, B of the underlying category.
2021-10-20 19:46:41 +0200 <cads> The components of the transform of an ordinary functor have one one index. This suggests that the strength could be a transform on a bifunctor
2021-10-20 19:46:50 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 19:46:54 +0200_xor(~xor@72.49.199.147) (Read error: Connection reset by peer)
2021-10-20 19:47:07 +0200Null_A(~null_a@2601:645:8700:2290:a94b:e46c:6690:e477) (Remote host closed the connection)
2021-10-20 19:47:34 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 19:48:07 +0200 <ManofLetters[m]> if B (or A) is fixed, it's an ordinary functor
2021-10-20 19:48:33 +0200 <awpr> yeah, I wrote that bifunctor earlier
2021-10-20 19:48:56 +0200 <awpr> (a bifunctor is an ordinary functor, just that its source is a product category)
2021-10-20 19:50:00 +0200 <ManofLetters[m]> isn't it usually contravariant on the second argument, though?
2021-10-20 19:50:12 +0200 <awpr> no, that's profunctor, and the first argument
2021-10-20 19:50:19 +0200 <cads> awpr, did you you didn't write the bifunctor's signature? I missed that / could not parse your speech
2021-10-20 19:50:39 +0200 <cads> err s/you didn't//
2021-10-20 19:50:57 +0200 <awpr> I used the admittedly confusing "type expression with holes" notation that pops up in ncatlab a lot
2021-10-20 19:51:05 +0200_xor(~xor@72.49.199.147)
2021-10-20 19:51:08 +0200 <ManofLetters[m]> apparently naming differs between people: https://en.wikipedia.org/wiki/Functor#Bifunctors_and_multifunctors
2021-10-20 19:51:34 +0200 <ManofLetters[m]> afk
2021-10-20 19:52:13 +0200 <cads> I guess the domain of the transform is the bifunctor Prod_H . (1_h x T)
2021-10-20 19:52:59 +0200 <cads> this takes an object A and an TB into the product A x TB
2021-10-20 19:53:13 +0200 <awpr> sorry, got distracted
2021-10-20 19:53:29 +0200zer0bitz_(~zer0bitz@dsl-hkibng31-54fae3-116.dhcp.inet.fi)
2021-10-20 19:53:33 +0200 <cads> and the codomain of the transform is the bifunctor T . Prod_H
2021-10-20 19:53:54 +0200 <cads> taking products A x B into T(A x B)
2021-10-20 19:53:56 +0200 <awpr> `\A B -> A x T B` which is HaskxHask -> Hask
2021-10-20 19:54:15 +0200 <awpr> it's a composition of two functors
2021-10-20 19:54:21 +0200 <cads> correct
2021-10-20 19:54:44 +0200 <cads> can you confirm I have the codomain right?
2021-10-20 19:55:34 +0200 <awpr> looks right, when looking at it as taking product objects to Hask objects
2021-10-20 19:56:11 +0200zer0bitz(~zer0bitz@dsl-hkibng31-54fae3-116.dhcp.inet.fi) (Ping timeout: 264 seconds)
2021-10-20 19:58:27 +0200 <cads> to sum up, we have that a T strength on an H-endofunctor T is a natural transform of type M : (1_H x T);Prod_h -> Prod_h;T, where Prod_H : H^2 -> H is the H product.
2021-10-20 19:58:52 +0200Null_A(~null_a@2601:645:8700:2290:a94b:e46c:6690:e477)
2021-10-20 19:59:33 +0200 <cads> that is way less painful than I thought!
2021-10-20 20:00:51 +0200Cajun(~Cajun@user/cajun)
2021-10-20 20:01:51 +0200 <cads> thanks for the help, awpr ManofLetters[m]. Sorry for the impedance mismatch between category speech and hask speech, and sorry for my difficulty understanding hask-speech. I think awpr as good as gave me this exact answer, but I couldn't really parse it. In that case, sorry for 'catsplaning' this topic, lol
2021-10-20 20:02:38 +0200cads's goal is to improve the nlab and wikipedia entries on strengths, applicatives, and strong monads
2021-10-20 20:06:02 +0200Skyfire(~pyon@user/pyon) (Quit: WeeChat 3.3)
2021-10-20 20:06:39 +0200coot(~coot@37.30.49.107.nat.umts.dynamic.t-mobile.pl)
2021-10-20 20:06:39 +0200 <ManofLetters[m]> a lofty goal
2021-10-20 20:07:38 +0200 <maerwald> strong monads, super monads, ...
2021-10-20 20:07:44 +0200 <maerwald> we have them all
2021-10-20 20:09:22 +0200 <cads> more of a nitpick - those articles all define monadic strength via its components rather than pointing out which functors we are transforming between
2021-10-20 20:09:45 +0200 <cads> A skilled reader like awpr can immediately see that we are transforming between two T-modified versions of the underlying category's product bifunctor
2021-10-20 20:10:06 +0200 <cads> I am going to paint that picture explicitly, for the benefit of readers that can't do that functorial gymnastics just yet
2021-10-20 20:10:54 +0200 <cads> probably gonna piss off the article maintainters because they probably think the translation is trivial.. but it's tripped me up for quite a while, lol
2021-10-20 20:11:35 +0200 <monochrom> That is the same tension between speaking like "x + c*y where the variables are x and y" and speaking like "define f(x,y) = x + c*y".
2021-10-20 20:12:32 +0200 <cads> monochrom, right, in your example we're backgrounding the lambda operator, while in my example we're backgrounding the product bifunctor
2021-10-20 20:13:33 +0200 <monochrom> And between "f :: (Int,a) -> Either a Bool, natural in a and b" and "define F(a) = (Int,a), define G(a) = Either a Bool, so f is natural from F to G"
2021-10-20 20:14:02 +0200ubert(~Thunderbi@91.141.37.135.wireless.dyn.drei.com)
2021-10-20 20:14:04 +0200 <monochrom> s/ and b/
2021-10-20 20:16:35 +0200max22-(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr) (Ping timeout: 260 seconds)
2021-10-20 20:17:45 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 20:20:56 +0200 <cads> I guess there are two ways about it. First we could depend on readers to immediately recognize components of transform between a modified bifunctor, to immediately recognize which bifunctor was modified, and how. Since the choice of bifunctor is 'obvious', and the way that functor is modified is 'apparent', that is the choice the authors have made.
2021-10-20 20:22:21 +0200 <monochrom> On the bright side, it is mechanical.
2021-10-20 20:22:27 +0200hgolden(~hgolden2@cpe-172-114-81-123.socal.res.rr.com) (Remote host closed the connection)
2021-10-20 20:22:41 +0200 <cads> monochrom, mechanical as in "there are these components and they only fit one way"?
2021-10-20 20:23:32 +0200 <monochrom> Also recall that people don't have problem with "∂(x + y*c)/∂y = c" without being told, without even caring about, \x y -> x + y*c.
2021-10-20 20:24:50 +0200 <monochrom> I don't know about only one way. But I know about mechanical.
2021-10-20 20:28:55 +0200 <monochrom> In contrast, there is only one function from programs to "does it halt?", and it is not mechanical.
2021-10-20 20:29:09 +0200 <cads> In the second approach, we mention the M: Prod.(Id, T) -> T.Prod signature. Then we write its action on the component variables, as before.
2021-10-20 20:30:24 +0200 <cads> and I don't think this is so obvious or mechanical, since when I asked about the signature it led to a bunch of hask-handwaving, rather than a clear and simple answer
2021-10-20 20:31:22 +0200 <monochrom> But I don't write like Prod.(Id, T) or T.Prod.
2021-10-20 20:31:44 +0200 <monochrom> I just define, if necessary, F(A,B) = AxTB, G(A,B) = T(AxB).
2021-10-20 20:34:43 +0200haritz(~hrtz@user/haritz) (Ping timeout: 265 seconds)
2021-10-20 20:35:16 +0200Midjak(~Midjak@82-65-111-221.subs.proxad.net)
2021-10-20 20:35:21 +0200tremon(~tremon@217-63-61-89.cable.dynamic.v4.ziggo.nl)
2021-10-20 20:36:06 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 260 seconds)
2021-10-20 20:36:37 +0200 <monochrom> "s :: ∀a,b. a x T b -> T (axb)" is no less readable than "unzip :: ∀a,b. [(a,b)] -> ([a],[b])"
2021-10-20 20:38:22 +0200 <cads> lol, if we applied readability metrics to those senstences, we would find that both sentences are about equally hellish
2021-10-20 20:38:27 +0200hgolden(~hgolden2@cpe-172-114-81-123.socal.res.rr.com)
2021-10-20 20:38:49 +0200 <mrianbloom> Is there an easy way to convert between Massiv and Accelerate host arrays?
2021-10-20 20:39:05 +0200 <monochrom> Um, talk to programmers? Who here finds "unzip :: ∀a,b. [(a,b)] -> ([a],[b])" hellish?
2021-10-20 20:39:45 +0200 <monochrom> In fact, even stronger: Who here finds "unzip :: [].Prob => Prob.([], [])" better?
2021-10-20 20:39:48 +0200 <cads> monochrom, can we agree that programmers are very poor judges of readability, or else they would be making a living writing prose?
2021-10-20 20:40:06 +0200 <monochrom> But prose is not formula.
2021-10-20 20:40:54 +0200 <monochrom> Or how about you? Do you prefer "unzip :: [].Prob => Prob.([], [])"? Seriously?
2021-10-20 20:41:35 +0200 <monochrom> Below this the undertone is "how far do you go in writing functors in pointfree form?"
2021-10-20 20:42:02 +0200haritz(~hrtz@2a02:8010:65b5:0:6009:6384:e3cb:2220)
2021-10-20 20:42:02 +0200haritz(~hrtz@2a02:8010:65b5:0:6009:6384:e3cb:2220) (Changing host)
2021-10-20 20:42:02 +0200haritz(~hrtz@user/haritz)
2021-10-20 20:42:23 +0200cadsis thinking of a readability metric that can judge between a good prose explanation of a function, and a bad formulaic explanation
2021-10-20 20:42:47 +0200 <cads> but the reader is more important than the text and drives the metric
2021-10-20 20:43:59 +0200 <monochrom> The major readers of ncatlab are mathematicians and programmers, neither group appreciating T.Prod.
2021-10-20 20:44:22 +0200zer0bitz_(~zer0bitz@dsl-hkibng31-54fae3-116.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-10-20 20:44:45 +0200 <monochrom> Instead, the mathematician group appreciates leaving "A x T B" as is, and the programmer group appreciates introducing an intermediate "F(A,B) = A x T B".
2021-10-20 20:44:48 +0200max22-(~maxime@2a01cb0883359800fe2c7b136063d78c.ipv6.abo.wanadoo.fr)
2021-10-20 20:44:56 +0200 <cads> monochrom, I appreciate it, though I'll grant that the reason I appreciate it is that before understanding it, I couldn't understand the article
2021-10-20 20:45:44 +0200 <cads> but the reason I couldn't understand the article didn't have to do with that specific definition, but rather inexperience with manipulating bifunctor and their natural transforms
2021-10-20 20:45:51 +0200ec_(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-20 20:47:19 +0200 <cads> Now, if I modify the article to be more explicit about the bifunctor, it would definitely help my former self. But without knowing how representative of other readers my own confusion was, the value I add is dubious.
2021-10-20 20:47:24 +0200kuribas(~user@ptr-25vy0i7zawtky0bq46n.18120a2.ip6.access.telenet.be) (Quit: ERC (IRC client for Emacs 26.3))
2021-10-20 20:47:32 +0200 <cads> I will likely do it, to see if the other editors hate it.
2021-10-20 20:49:35 +0200myShoggoth(~myShoggot@97-120-85-195.ptld.qwest.net) (Ping timeout: 264 seconds)
2021-10-20 20:49:43 +0200 <cads> monochrom, remember when you said that refactoring should not remove important context, just because my inexperience makes the extra context hard to keep track of?
2021-10-20 20:49:48 +0200oats(~thomas@user/oats) (Leaving)
2021-10-20 20:50:27 +0200 <cads> Here I am likely doing the opposite - refactoring to add context or dubious value, again because of inexperience. My inexperience makes me think other readers need that context.
2021-10-20 20:53:20 +0200 <unit73e> I find haskell to be very mathematical
2021-10-20 20:53:20 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 260 seconds)
2021-10-20 20:54:04 +0200 <geekosaur> discrete math helps a bit. CT not necessary, really
2021-10-20 20:54:44 +0200 <monochrom> school algebra skills. or even respect.
2021-10-20 20:55:49 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-10-20 21:00:55 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Ping timeout: 260 seconds)
2021-10-20 21:01:42 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-20 21:03:05 +0200Farzad(~FarzadBek@37.49.149.40)
2021-10-20 21:04:28 +0200mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2021-10-20 21:04:42 +0200 <maerwald> @hoogle respect
2021-10-20 21:04:43 +0200 <lambdabot> Network.AWS.AutoScaling.SetInstanceHealth sihShouldRespectGracePeriod :: Lens' SetInstanceHealth (Maybe Bool)
2021-10-20 21:04:43 +0200 <lambdabot> Ormolu.Printer.Meat.Declaration p_hsDeclsRespectGrouping :: FamilyStyle -> [LHsDecl GhcPs] -> R ()
2021-10-20 21:05:02 +0200 <[exa]> F
2021-10-20 21:05:56 +0200 <cads> monochrom, The other reason I appreciate P(1xT) -> TP is because it better shows the symmetry between the domain and codomain of the transform. It's like the strength lets us "semicommute" an instance of (1xT) left through P to obtain TP, but it only works in this one direction.
2021-10-20 21:06:20 +0200 <cads> I don't see this algebraic "motion" based description as clearly looking (A x TB) -> T(A x B).
2021-10-20 21:07:25 +0200 <[exa]> cads: you can help the readers a bit by avoiding the symmetrical `x` symbol
2021-10-20 21:08:45 +0200Null_A(~null_a@2601:645:8700:2290:a94b:e46c:6690:e477) (Remote host closed the connection)
2021-10-20 21:08:56 +0200 <cads> [exa], how would you do that?
2021-10-20 21:09:53 +0200 <[exa]> (A -x TB) -> T(A -x B) -- looks almost like functions
2021-10-20 21:10:34 +0200 <[exa]> ( btw this might be off, I didn't read much of the scrollback :] )
2021-10-20 21:10:46 +0200Null_A(~null_a@2601:645:8700:2290:a94b:e46c:6690:e477)
2021-10-20 21:11:29 +0200 <cads> I was thinking of using the (A x -) functor, but doing it wasn't going to make things easier to understand
2021-10-20 21:14:44 +0200 <cads> [exa], I don't think you should waste much time on the scroll back, I was picking nits which live on the back of a flea which lives on the back of a verminous plague rat
2021-10-20 21:15:51 +0200ec_(~ec@gateway/tor-sasl/ec)
2021-10-20 21:19:08 +0200 <[exa]> ok good. :D
2021-10-20 21:20:41 +0200Null_A(~null_a@2601:645:8700:2290:a94b:e46c:6690:e477) (Remote host closed the connection)
2021-10-20 21:21:48 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-10-20 21:22:33 +0200guydb89(~guy@98.198.128.24)
2021-10-20 21:23:51 +0200myShoggoth(~myShoggot@97-120-85-195.ptld.qwest.net)
2021-10-20 21:25:07 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Client Quit)
2021-10-20 21:28:45 +0200ec_(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-20 21:29:24 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:5edd:2a99:160f:84d2)
2021-10-20 21:30:13 +0200ec_(~ec@gateway/tor-sasl/ec)
2021-10-20 21:33:59 +0200 <InstX1> i'm so giddy
2021-10-20 21:34:03 +0200 <InstX1> for christ's sake
2021-10-20 21:34:37 +0200 <cads> InstX1, por why?
2021-10-20 21:34:40 +0200 <InstX1> i've tried learning programming with a metric ton of languages, this is the first time i've gotten through so much in so little time
2021-10-20 21:34:52 +0200 <monochrom> Oh congrats.
2021-10-20 21:35:14 +0200 <cads> v. nice!
2021-10-20 21:35:37 +0200 <InstX1> haskell is going significantly faster than the C++ for dummies book I had, and I spent like 2-3 weeks on Stroustrup's intro programming with C++ book
2021-10-20 21:35:41 +0200 <monochrom> Yes one of Haskell's strength (and FP's, and Logo's) is that if imperative programming fails you, Haskell can help.
2021-10-20 21:36:04 +0200 <InstX1> iirc that was why Lisp was big as a teaching language, no?
2021-10-20 21:36:15 +0200 <[exa]> yep
2021-10-20 21:36:16 +0200 <monochrom> Although, I am not sure that Stroustrup's is really all that intro level.
2021-10-20 21:36:38 +0200 <monochrom> Or K&R
2021-10-20 21:36:40 +0200 <InstX1> he has an intro-level book
2021-10-20 21:37:28 +0200 <[exa]> InstX1: the best way to learn c++ is by need, you first learn assembly and then try to save code volume by expressing stuff in the code generators (C, C with RAII, objects, templates, and suddenly you know a pretty practical subset of C++)
2021-10-20 21:37:51 +0200ec_(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-20 21:37:59 +0200 <[exa]> I wouldn't recommend anyone to take serious C++ before knowing a functional language
2021-10-20 21:38:01 +0200 <InstX1> like, for C++, "The C++ Programming Language" (advanced / intermediate), "Programming: Principles and Practice Using C++" (beginner), "A Tour of C++" (iirc, he has a tour book that covers C++17
2021-10-20 21:38:13 +0200 <InstX1> it's more a problem with his style
2021-10-20 21:38:20 +0200 <InstX1> i have an easier C++ for beginners book
2021-10-20 21:38:31 +0200 <InstX1> i could breeze through it, but i'm told that one gives you bad habit
2021-10-20 21:38:32 +0200 <InstX1> s
2021-10-20 21:39:00 +0200 <InstX1> Stroustrup basically treats his intro textbook as if he were giving a lecture
2021-10-20 21:39:11 +0200 <InstX1> unless you were talking about Programming: Principles and Practice @Monochrom
2021-10-20 21:39:14 +0200 <monochrom> But I love lectures.
2021-10-20 21:39:29 +0200 <monochrom> I had "The C++ Programming Language" in mind.
2021-10-20 21:39:47 +0200 <InstX1> i mean more, I know Carnegie Mellon uses his intro book
2021-10-20 21:40:09 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2021-10-20 21:40:32 +0200 <InstX1> it's more, with a textbook, you want to be able to read stuff out of order, skim for key information, and so on
2021-10-20 21:41:07 +0200 <monochrom> There are two sides of "out of order".
2021-10-20 21:41:08 +0200 <InstX1> he just combines ideas and digresses (fruitfully, in an actual lecture setting) so it's hard to parse his stuff
2021-10-20 21:41:41 +0200 <InstX1> i like to read textbooks like a windows file transfer time estimator
2021-10-20 21:41:50 +0200 <InstX1> read ahead, read back, review, etc
2021-10-20 21:42:08 +0200 <[exa]> stop at 99% and try to find the last piece
2021-10-20 21:42:12 +0200 <monochrom> I mean, sometimes it is unrealistic to. Dependencies exist. Intrinsic one.
2021-10-20 21:42:13 +0200 <[exa]> yes, good. :D
2021-10-20 21:42:36 +0200 <monochrom> For example, good luck with "read Functor before type classes", obviously.
2021-10-20 21:43:16 +0200 <monochrom> Foldable and Functor could be in whatever order you like, sure.
2021-10-20 21:43:28 +0200 <InstX1> i'll put in an example, i'm trying to learn classes, etc, but he gives you an introduction to classes in a chapter completely unrelated to classes
2021-10-20 21:43:39 +0200 <monochrom> But good luck with "Foldable before Monoid", too.
2021-10-20 21:43:41 +0200 <[exa]> monochrom: that can be done, with a bit of heresy you can get the idea to e.g. C# people with IFunctor, IFoldable
2021-10-20 21:43:43 +0200 <InstX1> it's well-woven together, arguably a piece of art if treated purely sequentially
2021-10-20 21:43:49 +0200mei(~mei@user/mei) (Ping timeout: 252 seconds)
2021-10-20 21:43:55 +0200Null_A(~null_a@2601:645:8700:2290:a94b:e46c:6690:e477)
2021-10-20 21:44:09 +0200 <InstX1> and when you get to the actual classes chapter
2021-10-20 21:44:19 +0200 <InstX1> you have to know about the introduction, which you can only find via index
2021-10-20 21:44:53 +0200 <monochrom> But the IFunctor interface cannot be expressed in Haskell. (Nor the Functor class in C#.)
2021-10-20 21:45:13 +0200 <monochrom> In a category theory book for mainstream programmers, I would use IFunctor, yes.
2021-10-20 21:45:35 +0200slack1256(~slack1256@45.4.2.52)
2021-10-20 21:45:38 +0200 <monochrom> But in a Haskell book? I'd better talk about things that can be written in Haskell.
2021-10-20 21:46:22 +0200 <monochrom> Fortunately, there is no market for a category theory book for mainstream programmers, so trying to use IFunctor remains hypothetical!
2021-10-20 21:46:28 +0200 <slack1256> Is there a type level `elem` function defined somewhere on base? Just for type level lists.
2021-10-20 21:47:26 +0200 <[exa]> monochrom: well at worst it allows you to motivate the people with something like "see how much this sucks?"
2021-10-20 21:48:45 +0200 <[exa]> the main target is to reduce the gap before the moment when it clicks for as many people as possible
2021-10-20 21:50:03 +0200 <monochrom> OK, the difference is between "functor" and "Functor".
2021-10-20 21:53:09 +0200 <InstX1> by the way, just curious
2021-10-20 21:53:21 +0200 <InstX1> has there been any attempts to teach haskell starting from main / do?
2021-10-20 21:54:02 +0200 <InstX1> i'm also wondering if imperative languages might be more interesting if they were taught starting from abstractions, tbh
2021-10-20 21:54:13 +0200random-jellyfish(~random-je@user/random-jellyfish)
2021-10-20 21:54:34 +0200 <lortabac> slack1256: not in base, AFAIK, but there are several on Hackage
2021-10-20 21:54:38 +0200 <[exa]> (implying imperative languages have reasonable abstractions)
2021-10-20 21:54:42 +0200 <[exa]> InstX1: ^
2021-10-20 21:54:52 +0200Null_A(~null_a@2601:645:8700:2290:a94b:e46c:6690:e477) (Remote host closed the connection)
2021-10-20 21:55:32 +0200 <monochrom> Modula-3 and Ada do.
2021-10-20 21:55:54 +0200 <InstX1> i'd have taken far easier to C++ if they started by teaching classes asap
2021-10-20 21:56:22 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 260 seconds)
2021-10-20 21:57:07 +0200 <monochrom> I have seen 1st-year 1st-language courses teaching classes very early. It's a failure. Students get all the wrong ideas.
2021-10-20 21:57:58 +0200 <monochrom> Then again, that may be in total agreement with "asap", i.e., 1st-year 1st-language early is earlier than "p".
2021-10-20 21:58:10 +0200 <[exa]> ah good point about modula.
2021-10-20 21:58:14 +0200 <InstX1> i guess it depends on the person, #1, #2, then why do we keep on starting haskell with abstractions?
2021-10-20 21:58:32 +0200 <monochrom> But we don't start Haskell with abstractions.
2021-10-20 21:58:38 +0200 <InstX1> or perhaps at an earlier stage, people were trying the Haskell Hello World route
2021-10-20 21:58:44 +0200 <monochrom> Functions? Yes. Abstractions? No.
2021-10-20 21:58:45 +0200 <InstX1> Haskell starts with expressions
2021-10-20 21:58:55 +0200 <monochrom> That is not an abstraction.
2021-10-20 21:59:13 +0200 <monochrom> Not in the "functor is a abstraction" sense.
2021-10-20 21:59:28 +0200 <monochrom> C also starts with expressions.
2021-10-20 21:59:37 +0200 <monochrom> In fact, C has nothing except expressions.
2021-10-20 21:59:51 +0200_ht(~quassel@82-169-194-8.biz.kpn.net) (Remote host closed the connection)
2021-10-20 22:00:14 +0200 <monochrom> printf("hello world\n") is an expression.
2021-10-20 22:00:48 +0200 <monochrom> and also a function call, etc etc. Not so different from Haskell's "double 1.5"
2021-10-20 22:00:48 +0200Null_A(~null_a@2601:645:8700:2290:a94b:e46c:6690:e477)
2021-10-20 22:01:29 +0200 <[exa]> InstX1: I was starting the course with quick practical demystifiers so that people don't consider `do` to be magicks and the typeclass overloading seems natural. Interleaved with samples from gloss.
2021-10-20 22:01:47 +0200 <InstX1> which course?
2021-10-20 22:01:57 +0200 <[exa]> the one I was teaching. :D
2021-10-20 22:01:57 +0200slack1256(~slack1256@45.4.2.52) (Remote host closed the connection)
2021-10-20 22:02:20 +0200 <InstX1> how did that work?
2021-10-20 22:02:41 +0200 <[exa]> anyway, I'm really not sure how to structure the stuff right either. This IMO worked (student feedback was very good)
2021-10-20 22:02:49 +0200 <InstX1> also, i'm curious
2021-10-20 22:03:06 +0200 <InstX1> i wrote some ignorant gobbledegook about how it might be interesting to start with main/do
2021-10-20 22:03:19 +0200 <InstX1> then move into concepts etc and return to make do etc like an imperative language course
2021-10-20 22:03:27 +0200 <InstX1> but one big advantage might be, you go over IO early
2021-10-20 22:03:37 +0200 <InstX1> is haskell very good for image processing?
2021-10-20 22:03:48 +0200 <[exa]> there's an inconvenient balance between doing it right and not boring the usual late-teenagers and early-20ers to death
2021-10-20 22:04:19 +0200 <InstX1> like, one of the annoyances i had with imperative languages is how long it takes for you to get to IO
2021-10-20 22:04:32 +0200 <InstX1> IO-ing a file and then transforming it somehow might be a cool party trick
2021-10-20 22:04:36 +0200 <[exa]> re image processing, I'd say the ecosystem around repa is cool but afaik there's no big community
2021-10-20 22:04:59 +0200 <InstX1> but it'd have to be something haskell is good at and can impress the kiddies
2021-10-20 22:05:01 +0200 <[exa]> anyway you can literally write a function that does something like `interact`, just for an image, and give it to the students
2021-10-20 22:05:07 +0200 <InstX1> when you're dealing with kids, they want to make games
2021-10-20 22:05:09 +0200juhp(~juhp@128.106.188.220) (Ping timeout: 258 seconds)
2021-10-20 22:05:16 +0200 <[exa]> +1, Gloss helps
2021-10-20 22:05:21 +0200 <InstX1> when you're dealing with people who are somewhat older
2021-10-20 22:05:36 +0200 <InstX1> what they really want is file manipulation
2021-10-20 22:06:04 +0200 <InstX1> fastest way to show it's practical might be to have a template for a resume etc or something you want to add to a bunch of MS Word files
2021-10-20 22:06:14 +0200 <[exa]> they sometimes get sold on the fact that `interact $ show . length . lines` won't run out of memory
2021-10-20 22:06:30 +0200 <InstX1> i don't get what it means ::sheepish::
2021-10-20 22:07:07 +0200 <[exa]> for elders it's actually nice to show the monads as overloaded semicolons, they appreciate how much if()s and other repeated nonsense can be saved
2021-10-20 22:08:06 +0200 <[exa]> finally, hardcore compsci people are sold by standard library, namely definitions like this: https://hackage.haskell.org/package/containers-0.6.5.1/docs/src/Data.Graph.html#scc
2021-10-20 22:08:22 +0200juhp(~juhp@128.106.188.220)
2021-10-20 22:10:40 +0200 <InstX1> i see
2021-10-20 22:11:01 +0200fendor(~fendor@91.141.32.154.wireless.dyn.drei.com) (Remote host closed the connection)
2021-10-20 22:11:21 +0200 <InstX1> how hard is it, say, to get to the point where you can IO a jpeg/png, then use haskell to do a cool post-process so that your students can post it onto instagram?
2021-10-20 22:12:15 +0200 <[exa]> comparatively easy
2021-10-20 22:12:51 +0200 <[exa]> you need to know vectors (which is moreless trivial for whoever already did some programming) and e.g. JuicyPixels
2021-10-20 22:13:24 +0200Guest38(~Guest38@pool-100-19-29-41.phlapa.fios.verizon.net)
2021-10-20 22:13:27 +0200 <[exa]> this is full of effects https://github.com/RaphaelJ/friday
2021-10-20 22:13:47 +0200ski_ski
2021-10-20 22:14:32 +0200 <Guest38> @lamb
2021-10-20 22:14:32 +0200 <lambdabot> Unknown command, try @list
2021-10-20 22:14:42 +0200 <Guest38> @lambdabot help
2021-10-20 22:14:42 +0200 <lambdabot> Unknown command, try @list
2021-10-20 22:15:21 +0200jollygood2(~bc8165b6@217.29.117.252) (Quit: http://www.okay.uz/ (Session timeout))
2021-10-20 22:15:38 +0200 <[exa]> Guest38: you can /query lambdabot and try the commands privately
2021-10-20 22:17:38 +0200Guest38(~Guest38@pool-100-19-29-41.phlapa.fios.verizon.net) (Client Quit)
2021-10-20 22:18:17 +0200 <InstX1> what i had more in mind was to figure out how to custom craft an effect based on the more abstract material you were teaching your students
2021-10-20 22:19:03 +0200 <[exa]> nah, really just read the docs of `friday` package
2021-10-20 22:19:31 +0200 <InstX1> no, i mean, have the students custom craft them
2021-10-20 22:19:43 +0200 <[exa]> do they know some of the pixel graphics practice?
2021-10-20 22:20:28 +0200 <[exa]> with juicypixels there's a literal `pixelMap` function they can use to change the colors as they want
2021-10-20 22:20:47 +0200 <[exa]> (ok maybe the name is different)
2021-10-20 22:21:04 +0200 <[exa]> ah nope. https://hackage.haskell.org/package/JuicyPixels-3.3.6/docs/Codec-Picture.html#v:pixelMap
2021-10-20 22:21:26 +0200 <[exa]> the example there is a brightness filter
2021-10-20 22:21:30 +0200acidjnk_new(~acidjnk@p200300d0c703cb959894c42690fc4f0f.dip0.t-ipconnect.de)
2021-10-20 22:23:07 +0200Pdroman_(~Android@93.red-79-156-174.staticip.rima-tde.net)
2021-10-20 22:23:58 +0200wonko(~wjc@62.115.229.50) (Ping timeout: 252 seconds)
2021-10-20 22:25:44 +0200 <InstX1> also, if you might consider my idea, just don't have them do transforms in real time or in demonstrations because if the algorithms produce something unexpected, it might be embarrassing or dangerous on a professional level
2021-10-20 22:26:40 +0200ArctVaulMarsHMPJ(~pjetcetal@128-71-225-36.broadband.corbina.ru)
2021-10-20 22:27:28 +0200ArctVaulMarsHMPJ(~pjetcetal@128-71-225-36.broadband.corbina.ru) (Read error: Connection reset by peer)
2021-10-20 22:27:54 +0200hololeap(~hololeap@user/hololeap) (Ping timeout: 276 seconds)
2021-10-20 22:28:21 +0200hololeap(~hololeap@user/hololeap)
2021-10-20 22:28:36 +0200floridmarshmallo(~nate@pool-100-19-29-41.phlapa.fios.verizon.net)
2021-10-20 22:28:49 +0200 <[exa]> ah like I'd have the students code some dope instagram filters :]
2021-10-20 22:28:54 +0200 <[exa]> could work.
2021-10-20 22:29:09 +0200 <[exa]> might make a good homework
2021-10-20 22:30:15 +0200 <[exa]> why embarassing though? (it's pretty normal that several first versions of what you code may be broken AF)
2021-10-20 22:32:29 +0200 <iteratee> is there a canonical LTR equivalent of $ and $! ?
2021-10-20 22:33:51 +0200 <[exa]> there's `&` but I've got no idea if there's `&!`
2021-10-20 22:34:03 +0200 <aegon> whats a 'cononical' use of lambdaCase? I keep going through a loop of using case, thinking i can clean up the syntax with lambda case, then either realizing i should be using MaybeT instead or that lambda case doesn't save much and makes things harder to read
2021-10-20 22:34:26 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Quit: Lost terminal)
2021-10-20 22:34:35 +0200 <aegon> iteratee: i also got suggested <&> by hlint a little while ago and never considered that it might exist, but its a neat control structure sometimes
2021-10-20 22:34:42 +0200 <geekosaur> usually when you have a single parameter function that would do a case anyway
2021-10-20 22:34:49 +0200floridmarshmallo(~nate@pool-100-19-29-41.phlapa.fios.verizon.net) (Quit: WeeChat 3.0)
2021-10-20 22:35:11 +0200 <geekosaur> so instead of \x -> case x of ... do \case ...
2021-10-20 22:35:31 +0200 <ski> iteratee : one could possibly argue that `$!' at least, and perhaps also `$', ought to be `infixl' ..
2021-10-20 22:35:32 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-10-20 22:35:49 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-10-20 22:35:52 +0200 <iteratee> [exa], what library defines `&`?
2021-10-20 22:35:53 +0200 <aegon> geekosaur: ah, that makes a ton of sense, thanks!
2021-10-20 22:36:20 +0200 <InstX1> exa: accidentally deepfaking yourself
2021-10-20 22:36:23 +0200 <InstX1> or looking like it is
2021-10-20 22:36:29 +0200 <InstX1> accidentally screwing up and getting swastikas
2021-10-20 22:36:29 +0200 <InstX1> etc
2021-10-20 22:37:07 +0200 <ski> (.. i don't care much for `foo x $ bar y z $ blah'. but being able to write e.g. foldl' f z (x:xs) = foldl' f $! f z x $ xs could be nice)
2021-10-20 22:37:40 +0200 <ski> @src foldl'
2021-10-20 22:37:41 +0200 <lambdabot> foldl' f a [] = a
2021-10-20 22:37:41 +0200 <lambdabot> foldl' f a (x:xs) = let a' = f a x in a' `seq` foldl' f a' xs
2021-10-20 22:37:45 +0200 <[exa]> aegon: wow that's neat
2021-10-20 22:37:53 +0200 <[exa]> iteratee: Data.Function i hope?
2021-10-20 22:38:17 +0200 <ski> foldl' f a (x:xs) = (foldl' f $! f a x) xs -- currently, you could write it like this
2021-10-20 22:38:22 +0200 <[exa]> InstX1: ah I thought you're after normal filters, not neural-network madness
2021-10-20 22:38:33 +0200 <InstX1> i'm a non-programmer
2021-10-20 22:38:38 +0200 <InstX1> i just wonder about what could go wrong
2021-10-20 22:38:52 +0200 <InstX1> what i was thinking about was more mandelbrotting stuff
2021-10-20 22:38:55 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Client Quit)
2021-10-20 22:38:58 +0200 <InstX1> or figuring out how to do weird memes via images
2021-10-20 22:39:04 +0200 <InstX1> it's the stuff the kids would like
2021-10-20 22:39:10 +0200 <InstX1> erm, weird memes via filters
2021-10-20 22:39:22 +0200 <InstX1> keeping it "sane" and "professional" is an issue
2021-10-20 22:39:38 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:5edd:2a99:160f:84d2) (Quit: WeeChat 2.8)
2021-10-20 22:39:44 +0200 <[exa]> the best meme filter lately is `convert_to_jpeg -quality 1`
2021-10-20 22:40:00 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-10-20 22:40:01 +0200 <InstX1> lol
2021-10-20 22:40:25 +0200 <[exa]> anyway yeah mandelbrots do work
2021-10-20 22:40:34 +0200 <[exa]> people love diggin in that
2021-10-20 22:40:36 +0200 <InstX1> on instagram a lot of people like to show off their figures, one thing that could go wrong is if the algorithm painted their clothes off, for intsance
2021-10-20 22:40:53 +0200 <InstX1> not that it'd reproduce anatomy, but it'd be close enough to be embarrassing
2021-10-20 22:43:07 +0200 <[exa]> you might be confusing programming with deep NN training now. :D
2021-10-20 22:45:07 +0200 <InstX1> you could have a prompt to specify an area, and accident,s whoops
2021-10-20 22:45:08 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-10-20 22:45:29 +0200 <InstX1> doesn't take anything special, just a region of the wrong color in the wrong place
2021-10-20 22:46:21 +0200 <InstX1> i mean the inevitable stuff with instagram filters is that people might want to show off the filters in class
2021-10-20 22:46:28 +0200lavaman(~lavaman@98.38.249.169)
2021-10-20 22:46:32 +0200 <InstX1> but to have the images curated beforehand
2021-10-20 22:46:36 +0200 <InstX1> is just a good idea
2021-10-20 22:49:39 +0200dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be) (Quit: WeeChat 3.3)
2021-10-20 22:51:00 +0200zebrag(~chris@user/zebrag) (Quit: Konversation terminated!)
2021-10-20 22:51:23 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 264 seconds)
2021-10-20 22:53:08 +0200Farzad(~FarzadBek@37.49.149.40) (Quit: Leaving)
2021-10-20 22:55:00 +0200coot(~coot@37.30.49.107.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2021-10-20 22:55:15 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 260 seconds)
2021-10-20 23:00:06 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2021-10-20 23:05:41 +0200 <monochrom> Oh BTW I don't oppose starting with main, but I would oppose starting with do-notation. Because my students and TAs oppose that, too.
2021-10-20 23:06:38 +0200oats(~thomas@user/oats)
2021-10-20 23:07:02 +0200xcmw(~textual@dyn-72-33-0-245.uwnet.wisc.edu)
2021-10-20 23:07:40 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-20 23:08:30 +0200 <[exa]> monochrom: sometimes there's the uncanny question about "can it read a number and print it back", I'm usually showing that there's `do` to do that easily but with a promise that it's not a side effect and I'm going to demystify it asap
2021-10-20 23:09:09 +0200 <[exa]> IO works kinda nicely there as an eDSL
2021-10-20 23:09:22 +0200ski. o O ( `interact' )
2021-10-20 23:09:47 +0200 <[exa]> ski: oh you!
2021-10-20 23:09:58 +0200 <[exa]> :]
2021-10-20 23:10:16 +0200 <monochrom> That's interesting. I would like to take a look at your approach.
2021-10-20 23:10:30 +0200michalz(~michalz@185.246.204.93) (Remote host closed the connection)
2021-10-20 23:10:45 +0200 <ski> what, you don't like having to juggle around fragile irrefutable patterns / forcing with `case' at the right time ?
2021-10-20 23:10:46 +0200 <[exa]> the slides are in czech, not sure if it helps a lot :D
2021-10-20 23:10:57 +0200 <aegon> whenever i show someone io without do notation they get scared, when i show them do notation they see return and start making all sorts of bad assumptions about whats going on
2021-10-20 23:11:03 +0200 <adamCS> A Pipes question, if anyone is familiar: Streamly has a function IsStream t => fromEffect :: m a -> t m a. I'd like a Pipes equivalent: pipesFromEffect :: m a -> Producer a m () (I guess?). I see "yield :: a -> Producer a m ()" but that's not what I want...
2021-10-20 23:11:12 +0200 <monochrom> At this point though it sounds like you are doing a "1st week: whirlwind tour. 2nd-nth week: properly"
2021-10-20 23:11:19 +0200 <aegon> its rough when the entry point to a hello world is one of the hardest things to grasp coming from imperative land
2021-10-20 23:11:22 +0200 <monochrom> which can work, yeah.
2021-10-20 23:11:58 +0200 <ski> aegon : use applicative combinators, together with `join' ?
2021-10-20 23:12:39 +0200 <[exa]> monochrom: I'm trying to avoid whirlwinds but well, you need to keep the fun going
2021-10-20 23:12:48 +0200 <awpr> adamCS: that sounds like `lift`, I think
2021-10-20 23:13:14 +0200 <awpr> oh, or `yield =<< lift ma`
2021-10-20 23:13:52 +0200 <monochrom> If you teach do-notation, you will eventually have to answer this question: "s <- x" vs "let t = y", why can't I do the other way, "let s = x", "t <- y".
2021-10-20 23:14:11 +0200 <adamCS> awpr: Thanks!
2021-10-20 23:14:23 +0200 <monochrom> And the answer really forces you to go back to >>= and "M Int" vs "Int" anyway.
2021-10-20 23:15:38 +0200 <[exa]> `<-` "removes the IO from the data you want and joins it with the bigger IO around" is a good temporary explanation
2021-10-20 23:15:48 +0200 <[exa]> I'm open to a better one honestly
2021-10-20 23:16:36 +0200 <aegon> ski: i like that, join might side step a lot without being as hand wavy as do notation to a new comer
2021-10-20 23:17:19 +0200Null_A(~null_a@2601:645:8700:2290:a94b:e46c:6690:e477) (Read error: Connection reset by peer)
2021-10-20 23:18:33 +0200 <monochrom> Yikes haha.
2021-10-20 23:19:04 +0200 <monochrom> https://www.vex.net/~trebla/photo/unorganized/IO-String.png
2021-10-20 23:19:45 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-10-20 23:19:50 +0200 <davean> [exa]: I've said things like "Pipes it throuh to the larger IO" or something - though I've only like twice taught people who found this entire thing confusing
2021-10-20 23:20:00 +0200 <davean> No the lack of InstanceSigs in the base language?
2021-10-20 23:20:04 +0200 <davean> That shows up every time
2021-10-20 23:20:09 +0200 <dsal> aegon: Nobody should write `return` in code anymore. Some people disagree with me, of course, but it's confusing.
2021-10-20 23:20:33 +0200 <ski> aegon : i dunno how well it would work, but perhaps one could try it. also, sometimes i find `infixl <*>>; (<*>>) :: Monad m => m (a -> m b) -> (m a -> m b); mamb <*>> ma = mamb >>= (=<< ma) {- = join (mamb <*> ma) -}' useful. to be used like `frob <$> foo <*> bar <*> baz <*>> quux'
2021-10-20 23:21:02 +0200 <ski> monochrom : a pushout ?
2021-10-20 23:21:05 +0200 <[exa]> davean: "sorry guys you just have to do that to get rid of the IO wrap" is actually a tone the students are used to from pythons, so it kindof works but it's not right for sure. :D
2021-10-20 23:21:50 +0200 <monochrom> Yeah a pushout.
2021-10-20 23:21:59 +0200 <davean> [exa]: See that wouldn't fly with the people I end up teaching. They'd be like "But the point is the IO doesn't go away" and I'd get all sorts of shit for that
2021-10-20 23:22:00 +0200 <ski> `InstanceSigs' is quite nice
2021-10-20 23:22:11 +0200 <davean> they're also not students - they're people who already create things on their own
2021-10-20 23:22:33 +0200 <adamCS> awpr: I always forget that underneath it's just a regular monad transformer.
2021-10-20 23:22:35 +0200 <ski> dsal : there's already overloading of other terms, i suppose
2021-10-20 23:22:38 +0200 <ski> (e.g. "functor")
2021-10-20 23:22:43 +0200 <hpc> "you just have to use (.) to get rid of the function"
2021-10-20 23:22:59 +0200 <dsal> ski: Yeah, I was confused by "functor" from o'caml years ago.
2021-10-20 23:23:08 +0200 <ski> @where on-functors
2021-10-20 23:23:08 +0200 <lambdabot> "On Functors" (in C++,Standard ML,Haskell,Prolog) by Peteris Krumins in 2010-05-17 at <http://www.catonmat.net/blog/on-functors/>
2021-10-20 23:23:22 +0200 <davean> [exa]: now when I explain what a primtive type is as a basis vector in the space of Haskell types, they're really happy with it.
2021-10-20 23:23:26 +0200 <davean> its all the people you teach?
2021-10-20 23:24:10 +0200 <ski> davean : or a generator in a group presentation ?
2021-10-20 23:24:24 +0200 <davean> ski: Yah, think I did that one once too
2021-10-20 23:24:50 +0200 <davean> ski: though tehy jump to asking me about (thing that turns out to be sum and product types) when I do the vector space one
2021-10-20 23:25:06 +0200 <davean> They don't start asking me if "data" works the way it does when I say group things
2021-10-20 23:25:13 +0200 <davean> they just don't run as far with it
2021-10-20 23:25:30 +0200 <davean> and I'm nothing if not lazy
2021-10-20 23:25:42 +0200 <davean> I'd prefer they explain how data types work to me than me to them
2021-10-20 23:25:48 +0200 <[exa]> davean: I said it's temporary :D
2021-10-20 23:26:11 +0200 <davean> [exa]: Yah, but I like temporary to be longer than "until I finish saying it" :)
2021-10-20 23:26:14 +0200 <awpr> ski: I knew I'd seen that type signature before, apparently I defined it as `(=*<)`
2021-10-20 23:26:31 +0200 <[exa]> anyway yeah the ADT "algebra" is a great discovery for many people
2021-10-20 23:26:33 +0200 <awpr> :t (=<<)
2021-10-20 23:26:35 +0200 <lambdabot> Monad m => (a -> m b) -> m a -> m b
2021-10-20 23:26:41 +0200 <[exa]> esp. later with zippers
2021-10-20 23:26:54 +0200 <awpr> by analogy to that with an extra layer of `m` on the function, like the Applicative operators have
2021-10-20 23:27:00 +0200Guest9393(~Guest93@2800:2181:4400:27c:dd94:662c:5a7e:2a36)
2021-10-20 23:27:07 +0200jushur(~human@user/jushur) (Quit: ¯\_(ツ)_/¯)
2021-10-20 23:27:15 +0200 <[exa]> (school motto: if in doubt, differentiate it)
2021-10-20 23:27:58 +0200Guest9393(~Guest93@2800:2181:4400:27c:dd94:662c:5a7e:2a36) (Client Quit)
2021-10-20 23:29:11 +0200ski. o O ( "We will encourage you to develop the three great virtues of a programmer: laziness, impatience, and hubris. --Larry Wall and Randal L Schwartz" -- "The Swine Before Perl" (talk/presentation) by Shriram Krishnamurthi in 2001-11 at <https://cs.brown.edu/~sk/Publications/Talks/SwineBeforePerl/> )
2021-10-20 23:30:56 +0200 <ski> awpr : i came up with it years ago. i guess others have also encountered a desire for it (or maybe recalling me mentioning it previously in here) .. imho, it'd be nice to have in `Control.Monad' or something
2021-10-20 23:31:12 +0200Null_A(~null_a@2601:645:8700:2290:a94b:e46c:6690:e477)
2021-10-20 23:31:38 +0200Pdroman_(~Android@93.red-79-156-174.staticip.rima-tde.net) (Quit: -a- IRC for Android 2.1.39)
2021-10-20 23:31:38 +0200 <awpr> +1, I like that it lets monadic computations have an "applicative-style" expression form
2021-10-20 23:33:05 +0200 <ski> the `<*>>' is intended to look like a regular `<*>', except that the whole shebang is then wrapped in a `join', so that the initial function returns an action that'll be performed in the same go
2021-10-20 23:33:30 +0200 <Inst> sorry about that, this is one of the reasons i'm attracted to haskell as a future hobbyist; i get panicky and think of all sorts of terrible edge cases and ways things can go wrong, anyways, headed to sleep
2021-10-20 23:35:10 +0200 <awpr> yeah, I think I see the meaning behind that name. personally I see it being more closely related to `=<<`, but I'm not strongly opinionated about it
2021-10-20 23:35:30 +0200ubert(~Thunderbi@91.141.37.135.wireless.dyn.drei.com) (Ping timeout: 260 seconds)
2021-10-20 23:35:52 +0200 <ski> (for two effectful parameters, it's `frob <$> foo <**> bar'. for just one, it'll have to be `frob =<< foo' .. of course, one could also have the operation be effectfully computed, like `frob <*> foo <*>> bar' or `frob <*>> foo')
2021-10-20 23:36:41 +0200 <ski> (s/<**>/<*>>/)
2021-10-20 23:43:40 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 258 seconds)
2021-10-20 23:52:16 +0200hyiltiz(~quassel@31.220.5.250)
2021-10-20 23:53:04 +0200jgeerds(~jgeerds@55d4da80.access.ecotel.net)
2021-10-20 23:54:50 +0200xcmw(~textual@dyn-72-33-0-245.uwnet.wisc.edu) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-10-20 23:56:40 +0200gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2021-10-20 23:59:41 +0200zebrag(~chris@user/zebrag)