IRCBrowse

2023/06/26

2023-06-26 00:08:10 +0200fendor(~fendor@2a02:8388:1640:be00:7aca:a77a:4a28:631a) (Remote host closed the connection)
2023-06-26 00:12:31 +0200ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2023-06-26 00:15:44 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 240 seconds)
2023-06-26 00:18:26 +0200dost^(~dost@c-71-204-38-59.hsd1.ga.comcast.net) (Ping timeout: 250 seconds)
2023-06-26 00:18:26 +0200hdggxin(~hdggxin@122.175.41.19) (Ping timeout: 250 seconds)
2023-06-26 00:21:35 +0200acidjnk(~acidjnk@p200300d6e7072f58d4f02286a979ebfa.dip0.t-ipconnect.de) (Ping timeout: 264 seconds)
2023-06-26 00:21:52 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-06-26 00:26:15 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0) (Remote host closed the connection)
2023-06-26 00:27:17 +0200hdggxin(~hdggxin@122.175.41.19)
2023-06-26 00:27:32 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-06-26 00:29:31 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl)
2023-06-26 00:29:47 +0200mmhat(~mmh@p200300f1c74b7d41ee086bfffe095315.dip0.t-ipconnect.de) (Ping timeout: 245 seconds)
2023-06-26 00:30:10 +0200mmhat(~mmh@p200300f1c74b7df3ee086bfffe095315.dip0.t-ipconnect.de)
2023-06-26 00:31:57 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-06-26 00:33:32 +0200nut(~finn@rul16-h01-176-151-21-224.dsl.sta.abo.bbox.fr) (Ping timeout: 245 seconds)
2023-06-26 00:34:25 +0200bontaq(~user@ool-45779b84.dyn.optonline.net)
2023-06-26 00:36:35 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl) (Ping timeout: 264 seconds)
2023-06-26 00:36:37 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-06-26 00:41:24 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-06-26 00:41:56 +0200 <segfaultfizzbuzz> "We also show how we can generically derive a map function over any polynomial data type that is fully in-place and uses neither heap- nor stack space." https://www.microsoft.com/en-us/research/uploads/prod/2023/05/fbip.pdf
2023-06-26 00:41:58 +0200hsiktas[m](~hsiktasm]@2001:470:69fc:105::30d4)
2023-06-26 00:42:10 +0200 <segfaultfizzbuzz> what is the third alternative to the heap and the stack
2023-06-26 00:46:08 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 240 seconds)
2023-06-26 00:46:51 +0200migas(~migas@astra4961.startdedicated.net) (Quit: The Lounge - https://thelounge.github.io)
2023-06-26 00:47:11 +0200migas(~migas@astra4961.startdedicated.net)
2023-06-26 00:48:40 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-06-26 00:50:10 +0200 <segfaultfizzbuzz> i guess they are saying that whatever is being operated on has already been allocated, and the mutate that space?
2023-06-26 00:50:14 +0200Midjak(~Midjak@82.66.147.146) (Quit: This computer has gone to sleep)
2023-06-26 00:50:39 +0200spacenautx(~spacenaut@user/spacenautx) (Quit: WeeChat 3.8)
2023-06-26 00:51:14 +0200troydm(~troydm@user/troydm) (Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset)
2023-06-26 00:51:36 +0200 <dolio> Presumably it re-uses the space from the structure you fed in.
2023-06-26 00:51:48 +0200troydm(~troydm@user/troydm)
2023-06-26 00:52:00 +0200 <dolio> Because the map is consuming the original structure.
2023-06-26 00:52:25 +0200 <segfaultfizzbuzz> doesn't make sense, what if i want to map a binary number to a randomly generated midjourney image of either a dog or a cat eating spagetti?
2023-06-26 00:52:43 +0200 <segfaultfizzbuzz> 1 bit of space somehow becomes a one megabyte jpeg?
2023-06-26 00:53:15 +0200 <dolio> map is the function `(a -> b) -> F a -> F b`
2023-06-26 00:55:50 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0)
2023-06-26 00:56:28 +0200Cale(~cale@cpe80d04ade0a03-cm80d04ade0a01.cpe.net.cable.rogers.com) (Remote host closed the connection)
2023-06-26 00:57:57 +0200ai5lk(~ai5lk@209-188-121-236.taosnet.com)
2023-06-26 00:59:47 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 245 seconds)
2023-06-26 01:02:08 +0200 <monochrom> There are many "you know what I mean" there that becomes very long and boring when spelled out.
2023-06-26 01:02:24 +0200 <monochrom> Firstly add "extra", i.e., "does not use extra space".
2023-06-26 01:02:41 +0200 <monochrom> Secondally add "apart from a small O(1) amount".
2023-06-26 01:02:58 +0200 <monochrom> Thirdly add "apart from what the a->b function adds".
2023-06-26 01:03:26 +0200 <monochrom> There may be a fourthly but I haven't found one.
2023-06-26 01:03:31 +0200 <monochrom> For now. :)
2023-06-26 01:10:08 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Quit: Leaving.)
2023-06-26 01:21:35 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 260 seconds)
2023-06-26 01:32:26 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-06-26 01:32:26 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-06-26 01:32:26 +0200wroathe(~wroathe@user/wroathe)
2023-06-26 01:41:02 +0200nyc(~nyc@user/nyc) (Ping timeout: 245 seconds)
2023-06-26 01:47:34 +0200mauke_(~mauke@user/mauke)
2023-06-26 01:48:24 +0200oljenkins(~philipp@p5dec4bb3.dip0.t-ipconnect.de) (Server closed connection)
2023-06-26 01:48:39 +0200oljenkins(~philipp@p5dec4bb3.dip0.t-ipconnect.de)
2023-06-26 01:49:47 +0200mauke(~mauke@user/mauke) (Ping timeout: 264 seconds)
2023-06-26 01:49:47 +0200mauke_mauke
2023-06-26 01:58:33 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 246 seconds)
2023-06-26 02:02:34 +0200migas(~migas@astra4961.startdedicated.net) (Quit: The Lounge - https://thelounge.github.io)
2023-06-26 02:03:17 +0200migas(~migas@astra4961.startdedicated.net)
2023-06-26 02:03:50 +0200ai5lk(~ai5lk@209-188-121-236.taosnet.com) (Quit: WeeChat 3.8)
2023-06-26 02:07:42 +0200gurkenglas(~gurkengla@dynamic-046-114-165-003.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-06-26 02:08:08 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 240 seconds)
2023-06-26 02:08:32 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-06-26 02:14:52 +0200chiselfuse(~chiselfus@user/chiselfuse) (Remote host closed the connection)
2023-06-26 02:15:24 +0200chiselfuse(~chiselfus@user/chiselfuse)
2023-06-26 02:15:37 +0200oo_miguel(~Thunderbi@78-11-179-96.static.ip.netia.com.pl) (Ping timeout: 245 seconds)
2023-06-26 02:23:51 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-06-26 02:29:00 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 252 seconds)
2023-06-26 02:32:42 +0200bontaq(~user@ool-45779b84.dyn.optonline.net) (Ping timeout: 245 seconds)
2023-06-26 02:36:13 +0200Guest59(~Guest59@116.88.135.68)
2023-06-26 02:42:20 +0200falafel(~falafel@2607:fb91:86c:d890:9962:f260:f358:d40)
2023-06-26 02:45:05 +0200aforemny_(~aforemny@2001:9e8:6cf9:2000:2f46:f521:c777:24fd) (Ping timeout: 246 seconds)
2023-06-26 02:46:41 +0200falafel(~falafel@2607:fb91:86c:d890:9962:f260:f358:d40) (Read error: Connection reset by peer)
2023-06-26 02:51:23 +0200bratwurst(~dfadsva@2604:3d09:207f:f650::38e4) (Quit: Leaving)
2023-06-26 02:55:23 +0200aforemny(~aforemny@2001:9e8:6cd1:4a00:8861:d64a:a85d:46b5)
2023-06-26 02:58:21 +0200Guest59(~Guest59@116.88.135.68) (Quit: Client closed)
2023-06-26 03:10:19 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-06-26 03:11:29 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-06-26 03:15:15 +0200koolazer(~koo@user/koolazer) (Server closed connection)
2023-06-26 03:15:32 +0200koolazer(~koo@user/koolazer)
2023-06-26 03:17:20 +0200mmhat(~mmh@p200300f1c74b7df3ee086bfffe095315.dip0.t-ipconnect.de) (Quit: WeeChat 3.8)
2023-06-26 03:17:30 +0200justsomeguy(~justsomeg@user/justsomeguy) (Quit: WeeChat 3.6)
2023-06-26 03:17:36 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-06-26 03:21:18 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 250 seconds)
2023-06-26 03:27:32 +0200xff0x(~xff0x@2405:6580:b080:900:2989:814e:3688:2bc9) (Ping timeout: 240 seconds)
2023-06-26 03:37:02 +0200arrowhead(~arrowhead@2603-7000-9b3f-6934-113b-52a3-c542-4d62.res6.spectrum.com)
2023-06-26 03:37:14 +0200nyc(~nyc@2603-7000-a106-2fb5-0000-0000-0000-1f21.res6.spectrum.com)
2023-06-26 03:37:32 +0200arrowhead(~arrowhead@2603-7000-9b3f-6934-113b-52a3-c542-4d62.res6.spectrum.com) ()
2023-06-26 03:53:36 +0200jero98772(~jero98772@2800:484:1d7f:5d36::3) (Remote host closed the connection)
2023-06-26 04:14:49 +0200xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-06-26 04:16:04 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-06-26 04:21:21 +0200trev(~trev@user/trev)
2023-06-26 04:22:36 +0200connrs(~connrs@user/connrs) (Quit: ZNC 1.8.2 - https://znc.in)
2023-06-26 04:22:53 +0200connrs(~connrs@user/connrs)
2023-06-26 04:22:57 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-06-26 04:24:53 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-06-26 04:24:53 +0200finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-06-26 04:24:53 +0200finn_elijaFinnElija
2023-06-26 04:30:26 +0200td_(~td@i53870908.versanet.de) (Ping timeout: 246 seconds)
2023-06-26 04:32:14 +0200td_(~td@i53870921.versanet.de)
2023-06-26 04:33:16 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-06-26 04:36:31 +0200phma(phma@2001:5b0:211f:2f08:d5:59c5:25af:c289) (Read error: Connection reset by peer)
2023-06-26 04:36:56 +0200phma(phma@2001:5b0:211f:2f08:2fbf:64bb:cfdf:aec3)
2023-06-26 04:38:26 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-06-26 04:41:33 +0200Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Quit: Leaving)
2023-06-26 04:57:01 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-06-26 04:59:54 +0200phma(phma@2001:5b0:211f:2f08:2fbf:64bb:cfdf:aec3) (Read error: Connection reset by peer)
2023-06-26 05:00:18 +0200phma(~phma@host-67-44-208-160.hnremote.net)
2023-06-26 05:19:32 +0200fiddlerwoaroof_fiddlerwoaroof
2023-06-26 05:19:47 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-06-26 05:32:11 +0200aforemny_(~aforemny@i59F516C6.versanet.de)
2023-06-26 05:33:35 +0200aforemny(~aforemny@2001:9e8:6cd1:4a00:8861:d64a:a85d:46b5) (Ping timeout: 264 seconds)
2023-06-26 05:41:56 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-06-26 06:00:27 +0200actioninja(~actioninj@user/actioninja) (Quit: see ya mane)
2023-06-26 06:00:53 +0200actioninja(~actioninj@user/actioninja)
2023-06-26 06:06:21 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-06-26 06:08:56 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 240 seconds)
2023-06-26 06:09:21 +0200sleym(~sleym@user/sleym)
2023-06-26 06:12:01 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-06-26 06:16:22 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 250 seconds)
2023-06-26 06:26:28 +0200Square2(~Square@user/square)
2023-06-26 06:30:12 +0200 <Square2> Is it possible to invoke "f :: forall a. SomeClass a => a" wo specifying what "a" is. Instead just use functions of "SomeClass" ?
2023-06-26 06:36:44 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 250 seconds)
2023-06-26 06:38:11 +0200 <Axman6> how would the compiler know which instance to use if it doesn't know what a is?
2023-06-26 06:41:36 +0200 <Square2> Axman6, Beats me. I hoped magic would kick in.
2023-06-26 06:42:09 +0200 <Square2> thanks for your reply. Now I know its not possible at least.
2023-06-26 06:44:07 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-06-26 06:44:20 +0200pierrot(~pi@user/pierrot) (Server closed connection)
2023-06-26 06:44:39 +0200pierrot(~pi@user/pierrot)
2023-06-26 06:46:46 +0200Square2(~Square@user/square) (Ping timeout: 252 seconds)
2023-06-26 06:50:40 +0200 <Axman6> you can write algorithms generic in SomeClass, and let the user choose which instance they want though
2023-06-26 07:05:46 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 250 seconds)
2023-06-26 07:07:28 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-06-26 07:08:32 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2023-06-26 07:15:43 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-06-26 07:16:44 +0200jbalint(~jbalint@071-090-119-177.res.spectrum.com) (Ping timeout: 240 seconds)
2023-06-26 07:20:04 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 250 seconds)
2023-06-26 07:24:07 +0200chromoblob(~user@37.113.180.121)
2023-06-26 07:27:38 +0200Guest52(~Guest28@KD111099018012.ppp-bb.dion.ne.jp)
2023-06-26 07:28:28 +0200jbalint(~jbalint@071-090-119-177.res.spectrum.com)
2023-06-26 07:30:02 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 250 seconds)
2023-06-26 07:30:33 +0200Guest52(~Guest28@KD111099018012.ppp-bb.dion.ne.jp) (Client Quit)
2023-06-26 07:35:38 +0200harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67)
2023-06-26 07:35:41 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net)
2023-06-26 07:37:20 +0200titibandit(~titibandi@user/titibandit)
2023-06-26 07:38:59 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-06-26 07:40:00 +0200hippoid(~hippoid@user/hippoid) (Ping timeout: 250 seconds)
2023-06-26 07:40:46 +0200hippoid(~hippoid@c-98-213-162-40.hsd1.il.comcast.net)
2023-06-26 07:40:59 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net) (Ping timeout: 240 seconds)
2023-06-26 07:47:45 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 260 seconds)
2023-06-26 07:50:23 +0200chromoblob(~user@37.113.180.121) (Ping timeout: 264 seconds)
2023-06-26 07:51:24 +0200chromoblob(~user@37.113.180.121)
2023-06-26 07:52:04 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-06-26 07:56:17 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl)
2023-06-26 07:56:26 +0200kyuri(~kyuri@KD111099018012.ppp-bb.dion.ne.jp)
2023-06-26 07:57:16 +0200abrantesasf(~abrantesa@179.217.48.72) (Remote host closed the connection)
2023-06-26 07:58:47 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net)
2023-06-26 07:59:33 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-06-26 08:01:11 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl) (Ping timeout: 264 seconds)
2023-06-26 08:01:35 +0200bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-06-26 08:03:35 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-06-26 08:13:45 +0200acidjnk(~acidjnk@p200300d6e7072f355d50cb0f60b9d9c7.dip0.t-ipconnect.de)
2023-06-26 08:14:29 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-06-26 08:15:18 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net)
2023-06-26 08:21:19 +0200kyuri1(~kyuri@210.160.217.2)
2023-06-26 08:21:52 +0200kyuri(~kyuri@KD111099018012.ppp-bb.dion.ne.jp) ()
2023-06-26 08:28:01 +0200michalz(~michalz@185.246.207.201)
2023-06-26 08:28:38 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-06-26 08:33:57 +0200nut(~nut@rul16-h01-176-151-21-224.dsl.sta.abo.bbox.fr)
2023-06-26 08:36:30 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-06-26 08:49:47 +0200hpc(~juzz@ip98-169-35-163.dc.dc.cox.net) (Ping timeout: 245 seconds)
2023-06-26 08:51:43 +0200hpc(~juzz@ip98-169-35-163.dc.dc.cox.net)
2023-06-26 08:52:23 +0200 <jade[m]> <Square2> "Is it possible to invoke "f..." <- you could use a newtype wrapper around some structure
2023-06-26 08:56:02 +0200nyc(~nyc@2603-7000-a106-2fb5-0000-0000-0000-1f21.res6.spectrum.com) (Ping timeout: 245 seconds)
2023-06-26 08:57:41 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-06-26 08:58:24 +0200chele(~chele@user/chele)
2023-06-26 09:01:59 +0200Guest9511(~finn@176-151-21-224.abo.bbox.fr)
2023-06-26 09:06:17 +0200Guest9511(~finn@176-151-21-224.abo.bbox.fr) (Ping timeout: 258 seconds)
2023-06-26 09:06:48 +0200mcglk(~mcglk@131.191.19.145) (Remote host closed the connection)
2023-06-26 09:10:08 +0200shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 250 seconds)
2023-06-26 09:11:30 +0200hugo(znc@verdigris.lysator.liu.se) (Ping timeout: 240 seconds)
2023-06-26 09:13:10 +0200euandreh(~Thunderbi@189.6.18.7) (Ping timeout: 250 seconds)
2023-06-26 09:15:30 +0200cfricke(~cfricke@user/cfricke)
2023-06-26 09:15:50 +0200 <dminuoso> Is there a simple/small graph library to represent and work with DAGs? In particular, I would like to zip around the graph and traverse in or outbound edges.
2023-06-26 09:16:12 +0200hugo(znc@verdigris.lysator.liu.se)
2023-06-26 09:18:22 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net) (Ping timeout: 250 seconds)
2023-06-26 09:18:35 +0200sleym(~sleym@user/sleym) (Quit: sleym)
2023-06-26 09:18:56 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-06-26 09:19:50 +0200jespada(~jespada@207.188.139.183)
2023-06-26 09:20:58 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:e56:50b4:8cbc:f250)
2023-06-26 09:28:18 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-06-26 09:29:23 +0200taupiqueur(~taupiqueu@2a02-842a-8180-4601-08a1-ddae-00eb-83a7.rev.sfr.net) (Ping timeout: 264 seconds)
2023-06-26 09:29:55 +0200 <Axman6> a graph zipper?
2023-06-26 09:30:07 +0200tom__(~tom@2a00:23c8:970c:4801:5b6a:e81b:79dc:f684)
2023-06-26 09:30:08 +0200 <Axman6> I only know of fgl, and have never used it
2023-06-26 09:30:48 +0200oo_miguel(~Thunderbi@78-11-179-96.static.ip.netia.com.pl)
2023-06-26 09:30:49 +0200fendor(~fendor@2a02:8388:1640:be00:7aca:a77a:4a28:631a)
2023-06-26 09:34:24 +0200tom_(~tom@host81-151-255-71.range81-151.btcentralplus.com) (Ping timeout: 250 seconds)
2023-06-26 09:36:15 +0200euandreh(~Thunderbi@189.6.18.7)
2023-06-26 09:37:06 +0200doyougnu(~doyougnu@45.46.170.68) (Quit: ZNC 1.8.2 - https://znc.in)
2023-06-26 09:37:27 +0200doyougnu(~doyougnu@45.46.170.68)
2023-06-26 09:37:31 +0200econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-06-26 09:38:14 +0200mncheck-m(~mncheck@193.224.205.254) (Remote host closed the connection)
2023-06-26 09:38:14 +0200 <dminuoso> Mmm, fgl I had not considered. I will take a deeper look at it
2023-06-26 09:38:37 +0200 <dminuoso> I like thjat its really low on dependencies. :)
2023-06-26 09:39:04 +0200tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2023-06-26 09:39:36 +0200kyuri1(~kyuri@210.160.217.2) (Quit: Leaving.)
2023-06-26 09:40:16 +0200kyuri(~kyuri@210.160.217.2)
2023-06-26 09:40:18 +0200gehmehgeh(~user@user/gehmehgeh)
2023-06-26 09:40:30 +0200euandreh(~Thunderbi@189.6.18.7) (Ping timeout: 240 seconds)
2023-06-26 09:40:56 +0200hugo(znc@verdigris.lysator.liu.se) (Ping timeout: 260 seconds)
2023-06-26 09:42:04 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-06-26 09:42:43 +0200hisa383(~hisa38@104-181-102-238.lightspeed.wepbfl.sbcglobal.net)
2023-06-26 09:44:22 +0200hisa38(~hisa38@104-181-102-238.lightspeed.wepbfl.sbcglobal.net) (Ping timeout: 250 seconds)
2023-06-26 09:44:22 +0200hisa383hisa38
2023-06-26 09:44:27 +0200 <int-e> Unless I need a specific algorithm, I often find it easier to just define an ad-hoc graph type.
2023-06-26 09:44:35 +0200euandreh(~Thunderbi@189.6.18.7)
2023-06-26 09:44:46 +0200mncheck(~mncheck@193.224.205.254)
2023-06-26 09:50:36 +0200hugo(znc@verdigris.lysator.liu.se)
2023-06-26 09:51:33 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net)
2023-06-26 09:56:23 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-06-26 09:57:20 +0200Guest9511(~finn@176-151-21-224.abo.bbox.fr)
2023-06-26 09:57:46 +0200Pickchea(~private@user/pickchea)
2023-06-26 09:58:17 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Remote host closed the connection)
2023-06-26 09:59:29 +0200aforemny_aforemny
2023-06-26 10:03:56 +0200nschoe(~q@141.101.51.197)
2023-06-26 10:06:30 +0200euandreh(~Thunderbi@189.6.18.7) (Ping timeout: 240 seconds)
2023-06-26 10:10:09 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net)
2023-06-26 10:13:34 +0200kyuri(~kyuri@210.160.217.2) ()
2023-06-26 10:14:28 +0200jespada(~jespada@207.188.139.183) (Quit: Textual IRC Client: www.textualapp.com)
2023-06-26 10:14:34 +0200euandreh(~Thunderbi@189.6.18.7)
2023-06-26 10:15:43 +0200harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67) (Quit: Leaving)
2023-06-26 10:16:50 +0200misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-06-26 10:19:04 +0200euandreh(~Thunderbi@189.6.18.7) (Ping timeout: 252 seconds)
2023-06-26 10:21:49 +0200euandreh(~Thunderbi@189.6.18.7)
2023-06-26 10:26:24 +0200euandreh(~Thunderbi@189.6.18.7) (Ping timeout: 252 seconds)
2023-06-26 10:32:06 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-06-26 10:34:25 +0200misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 240 seconds)
2023-06-26 10:34:48 +0200jespada(~jespada@207.188.139.183)
2023-06-26 10:36:22 +0200euandreh(~Thunderbi@189.6.18.7)
2023-06-26 10:39:47 +0200gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2023-06-26 10:41:00 +0200euandreh(~Thunderbi@189.6.18.7) (Ping timeout: 260 seconds)
2023-06-26 10:42:58 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0) (Remote host closed the connection)
2023-06-26 10:43:05 +0200cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.8)
2023-06-26 10:45:43 +0200enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7)
2023-06-26 10:45:55 +0200CiaoSen(~Jura@2a05:5800:2ac:6500:664b:f0ff:fe37:9ef)
2023-06-26 10:58:08 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 240 seconds)
2023-06-26 10:58:25 +0200CiaoSen(~Jura@2a05:5800:2ac:6500:664b:f0ff:fe37:9ef) (Quit: CiaoSen)
2023-06-26 10:59:12 +0200euandreh(~Thunderbi@189.6.18.7)
2023-06-26 10:59:32 +0200danse-nr3(~francesco@ge-19-116-153.service.infuturo.it)
2023-06-26 11:00:45 +0200CiaoSen(~Jura@2a05:5800:2ac:6500:664b:f0ff:fe37:9ef)
2023-06-26 11:05:58 +0200merijn(~merijn@145.94.126.249)
2023-06-26 11:08:17 +0200ericson2314(~ericson23@2001:470:69fc:105::70c) (Remote host closed the connection)
2023-06-26 11:10:20 +0200misterfish(~misterfis@87.215.131.102)
2023-06-26 11:10:57 +0200mmhat(~mmh@p200300f1c74b7df3ee086bfffe095315.dip0.t-ipconnect.de)
2023-06-26 11:11:30 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net) (Ping timeout: 252 seconds)
2023-06-26 11:11:34 +0200daemon_(uid606752@id-606752.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-06-26 11:11:38 +0200mmhat(~mmh@p200300f1c74b7df3ee086bfffe095315.dip0.t-ipconnect.de) (Client Quit)
2023-06-26 11:11:55 +0200merijn(~merijn@145.94.126.249) (Ping timeout: 260 seconds)
2023-06-26 11:14:59 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl)
2023-06-26 11:16:55 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-06-26 11:18:10 +0200 <jackdk> dminuoso: https://hackage.haskell.org/package/algebraic-graphs is based off a cool paper
2023-06-26 11:18:49 +0200Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-06-26 11:19:16 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 250 seconds)
2023-06-26 11:19:28 +0200danse-nr3(~francesco@ge-19-116-153.service.infuturo.it) (Read error: Connection reset by peer)
2023-06-26 11:19:34 +0200danse-nr3_(~francesco@151.35.43.168)
2023-06-26 11:21:25 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 240 seconds)
2023-06-26 11:21:42 +0200Lord_of_Life_Lord_of_Life
2023-06-26 11:24:45 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2023-06-26 11:28:48 +0200cfricke(~cfricke@user/cfricke)
2023-06-26 11:33:59 +0200titiband1t(~titibandi@user/titibandit)
2023-06-26 11:39:07 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-06-26 11:40:27 +0200titiband1t(~titibandi@user/titibandit) (Remote host closed the connection)
2023-06-26 11:43:29 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0)
2023-06-26 11:45:36 +0200danse-nr3_(~francesco@151.35.43.168) (Ping timeout: 252 seconds)
2023-06-26 11:47:33 +0200ft(~ft@p508db151.dip0.t-ipconnect.de) (Quit: leaving)
2023-06-26 11:48:05 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0) (Ping timeout: 260 seconds)
2023-06-26 11:50:01 +0200danse-nr3_(~francesco@151.35.43.168)
2023-06-26 11:50:09 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-06-26 11:50:32 +0200dcoutts_(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-06-26 11:53:36 +0200nschoe(~q@141.101.51.197) (Quit: Switching off)
2023-06-26 11:54:05 +0200yaroot_(~yaroot@2400:4052:ac0:d900:1cf4:2aff:fe51:c04c)
2023-06-26 11:54:15 +0200yaroot(~yaroot@p2782030-ipngn7701souka.saitama.ocn.ne.jp) (Ping timeout: 246 seconds)
2023-06-26 11:54:15 +0200yaroot_yaroot
2023-06-26 11:57:24 +0200merijn(~merijn@145.94.126.249)
2023-06-26 11:57:35 +0200Guest9511(~finn@176-151-21-224.abo.bbox.fr) (Ping timeout: 264 seconds)
2023-06-26 11:57:35 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net)
2023-06-26 12:00:55 +0200Feuermagier(~Feuermagi@user/feuermagier) (Remote host closed the connection)
2023-06-26 12:01:12 +0200Feuermagier(~Feuermagi@user/feuermagier)
2023-06-26 12:01:47 +0200drdo(~drdo@bl8-153-185.dsl.telepac.pt) (Quit: Ping timeout (120 seconds))
2023-06-26 12:02:00 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net) (Ping timeout: 240 seconds)
2023-06-26 12:02:07 +0200drdo(~drdo@bl8-153-185.dsl.telepac.pt)
2023-06-26 12:03:57 +0200xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 245 seconds)
2023-06-26 12:05:52 +0200CiaoSen(~Jura@2a05:5800:2ac:6500:664b:f0ff:fe37:9ef) (Ping timeout: 240 seconds)
2023-06-26 12:10:24 +0200merijn(~merijn@145.94.126.249) (Ping timeout: 250 seconds)
2023-06-26 12:10:25 +0200kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-06-26 12:10:52 +0200__monty__(~toonn@user/toonn)
2023-06-26 12:13:16 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl)
2023-06-26 12:18:04 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-06-26 12:18:52 +0200hackyhacker(~hackyhack@2a05:f480:1400:24b2:5400:4ff:fe76:a8f3) (Server closed connection)
2023-06-26 12:19:33 +0200hackyhacker(~hackyhack@2a05:f480:1400:24b2:5400:4ff:fe76:a8f3)
2023-06-26 12:22:05 +0200Unode(~Unode@fg-ext-220.embl.de) (Server closed connection)
2023-06-26 12:22:48 +0200Unode(~Unode@fg-ext-220.embl.de)
2023-06-26 12:23:32 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl) (Ping timeout: 245 seconds)
2023-06-26 12:23:48 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net)
2023-06-26 12:24:51 +0200CiaoSen(~Jura@2a05:5800:2ac:6500:664b:f0ff:fe37:9ef)
2023-06-26 12:33:08 +0200merijn(~merijn@145.94.126.249)
2023-06-26 12:35:33 +0200bontaq(~user@ool-45779b84.dyn.optonline.net)
2023-06-26 12:38:44 +0200merijn(~merijn@145.94.126.249) (Ping timeout: 240 seconds)
2023-06-26 12:40:41 +0200cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.8)
2023-06-26 12:44:51 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0)
2023-06-26 12:45:00 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl)
2023-06-26 12:46:34 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-06-26 12:49:23 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0) (Ping timeout: 258 seconds)
2023-06-26 12:50:42 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl) (Ping timeout: 250 seconds)
2023-06-26 12:53:58 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl)
2023-06-26 12:57:08 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:e56:50b4:8cbc:f250) (Ping timeout: 240 seconds)
2023-06-26 12:59:47 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl) (Ping timeout: 245 seconds)
2023-06-26 13:02:45 +0200romes[m](~romesmatr@2001:470:69fc:105::2:1660) (Server closed connection)
2023-06-26 13:02:57 +0200romes[m](~romesmatr@2001:470:69fc:105::2:1660)
2023-06-26 13:06:05 +0200shriekingnoise(~shrieking@186.137.175.87)
2023-06-26 13:06:33 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-06-26 13:07:33 +0200xff0x(~xff0x@ai098135.d.east.v6connect.net)
2023-06-26 13:10:44 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-06-26 13:15:37 +0200akadude[m](~akadudema@2001:470:69fc:105::2:5bf7) (Server closed connection)
2023-06-26 13:15:49 +0200akadude[m](~akadudema@2001:470:69fc:105::2:5bf7)
2023-06-26 13:18:30 +0200fweht(uid404746@id-404746.lymington.irccloud.com)
2023-06-26 13:20:59 +0200mxs(~mxs@user/mxs) (Ping timeout: 264 seconds)
2023-06-26 13:22:20 +0200APic(apic@apic.name) (Ping timeout: 250 seconds)
2023-06-26 13:23:41 +0200infinity0(~infinity0@pwned.gg) (Remote host closed the connection)
2023-06-26 13:24:04 +0200danse-nr3_(~francesco@151.35.43.168) (Ping timeout: 250 seconds)
2023-06-26 13:25:39 +0200Guest9511(~finn@176-151-21-224.abo.bbox.fr)
2023-06-26 13:26:35 +0200infinity0(~infinity0@pwned.gg)
2023-06-26 13:27:42 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net) (Ping timeout: 245 seconds)
2023-06-26 13:27:59 +0200nut(~nut@rul16-h01-176-151-21-224.dsl.sta.abo.bbox.fr) (Ping timeout: 240 seconds)
2023-06-26 13:31:42 +0200marinelli[m](~marinelli@2001:470:69fc:105::2d8) (Server closed connection)
2023-06-26 13:31:56 +0200marinelli[m](~marinelli@2001:470:69fc:105::2d8)
2023-06-26 13:43:58 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-06-26 13:51:35 +0200ceoltb^(~ceoltb@24.125.210.85)
2023-06-26 13:58:54 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net)
2023-06-26 13:58:59 +0200Inst_(~Inst@2601:6c4:4081:2fc0:61ec:e42a:c603:c093) (Ping timeout: 240 seconds)
2023-06-26 14:00:49 +0200Inst(~Inst@c-76-101-10-131.hsd1.fl.comcast.net)
2023-06-26 14:00:56 +0200gurkenglas(~gurkengla@dynamic-046-114-164-153.46.114.pool.telefonica.de)
2023-06-26 14:02:48 +0200Inst(~Inst@c-76-101-10-131.hsd1.fl.comcast.net) (Read error: Connection reset by peer)
2023-06-26 14:03:15 +0200Inst(~Inst@c-76-101-10-131.hsd1.fl.comcast.net)
2023-06-26 14:05:09 +0200thblt(~thblt@user/thblt)
2023-06-26 14:06:21 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-06-26 14:06:21 +0200titibandit(~titibandi@user/titibandit) (Read error: Connection reset by peer)
2023-06-26 14:06:39 +0200titibandit(~titibandi@user/titibandit)
2023-06-26 14:08:42 +0200Sciencentistguy4(~sciencent@hacksoc/ordinary-member)
2023-06-26 14:08:44 +0200danse-nr3_(~francesco@151.35.48.183)
2023-06-26 14:10:20 +0200Sciencentistguy(~sciencent@hacksoc/ordinary-member) (Ping timeout: 240 seconds)
2023-06-26 14:10:20 +0200Sciencentistguy4Sciencentistguy
2023-06-26 14:13:14 +0200nyc(~nyc@2603-7000-a106-2fb5-0000-0000-0000-1f21.res6.spectrum.com)
2023-06-26 14:13:55 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-06-26 14:14:22 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:9e3f:72b6:b558:f53d)
2023-06-26 14:15:41 +0200 <thblt> I came accross this syntax in safe-money: newtype Dense (currency :: Symbol) = Dense Rational. I understand that it means that the Dense type is specialized per currency (so you can't add USD to EUR). But what is this syntax? Type families?
2023-06-26 14:17:40 +0200 <jade[m]> the hint GHC gives is to enable DataKinds which makes it compile
2023-06-26 14:18:28 +0200gurkenglas(~gurkengla@dynamic-046-114-164-153.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-06-26 14:18:32 +0200 <jade[m]> since that extension doesn't imply any other it seems like that's the one
2023-06-26 14:19:26 +0200 <dminuoso> The hint does nto enable DataKinds, its merely a kind annotation.
2023-06-26 14:20:06 +0200 <thblt> thanks!
2023-06-26 14:20:13 +0200 <dminuoso> thblt: If you wrote `newtype Dense currency = Dense Rational` something like `Dense Int` or `Dense Maybe` (with PolyKinds) would be valid
2023-06-26 14:20:26 +0200 <thblt> dminuoso: I think jade[m] meant ghc's suggestion when compiling this as is
2023-06-26 14:20:30 +0200 <dminuoso> Symbol constrains type parameters to those types of type Symbol
2023-06-26 14:20:44 +0200 <jade[m]> thblt: yep
2023-06-26 14:20:50 +0200 <dminuoso> Such that you can write `Dense "dollar"` in a type
2023-06-26 14:21:36 +0200 <dminuoso> thblt: At any rate, the technical term of what this is used for is "phantom types"
2023-06-26 14:22:10 +0200 <dminuoso> You could utilize them in type families too, but I cant think of a useful scenario in this particular example
2023-06-26 14:22:52 +0200 <dminuoso> phantom types with `symbols` - which is a kind of uninhabited types that you can use as annotations in phantom types.
2023-06-26 14:23:07 +0200 <thblt> Ha, thanks, makes sense. I knew about those in data, but I didn't think they'd work with newtype.
2023-06-26 14:23:25 +0200 <dminuoso> thblt: Consider that newtype gets erased completely at compile time.
2023-06-26 14:23:37 +0200 <dminuoso> If anything it would be the other way around.
2023-06-26 14:23:43 +0200 <thblt> Yes, it's obvious in hindsight :)
2023-06-26 14:25:55 +0200Midjak(~Midjak@82.66.147.146)
2023-06-26 14:26:08 +0200cfricke(~cfricke@user/cfricke)
2023-06-26 14:26:58 +0200cfricke(~cfricke@user/cfricke) (Client Quit)
2023-06-26 14:27:07 +0200cfricke(~cfricke@user/cfricke)
2023-06-26 14:32:17 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-06-26 14:35:59 +0200Guest9511(~finn@176-151-21-224.abo.bbox.fr) (Ping timeout: 264 seconds)
2023-06-26 14:39:02 +0200danse-nr3_(~francesco@151.35.48.183) (Ping timeout: 252 seconds)
2023-06-26 14:39:27 +0200caubert(~caubert@user/caubert) (Quit: WeeChat 3.8)
2023-06-26 14:41:22 +0200smalltalkman(uid545680@id-545680.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-06-26 14:42:39 +0200Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-06-26 14:43:27 +0200caubert(~caubert@user/caubert)
2023-06-26 14:46:48 +0200nschoe(~q@141.101.51.197)
2023-06-26 15:03:18 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net) (Ping timeout: 250 seconds)
2023-06-26 15:05:01 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-06-26 15:18:26 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-06-26 15:19:10 +0200fendor(~fendor@2a02:8388:1640:be00:7aca:a77a:4a28:631a) (Remote host closed the connection)
2023-06-26 15:22:42 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 245 seconds)
2023-06-26 15:23:38 +0200fendor(~fendor@2a02:8388:1640:be00:7aca:a77a:4a28:631a)
2023-06-26 15:30:29 +0200siraben(~siraben@user/siraben)
2023-06-26 15:31:02 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net)
2023-06-26 15:35:05 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net) (Ping timeout: 246 seconds)
2023-06-26 15:42:58 +0200yaroot(~yaroot@2400:4052:ac0:d900:1cf4:2aff:fe51:c04c) (Read error: Connection reset by peer)
2023-06-26 15:43:13 +0200yaroot(~yaroot@p3274042-ipngn2701souka.saitama.ocn.ne.jp)
2023-06-26 15:43:34 +0200infinity0(~infinity0@pwned.gg) (Remote host closed the connection)
2023-06-26 15:45:40 +0200infinity0(~infinity0@pwned.gg)
2023-06-26 15:49:56 +0200mizlan(~mizlan@c-73-63-223-227.hsd1.ca.comcast.net)
2023-06-26 15:52:17 +0200ripspin(~chatzilla@1.145.163.38)
2023-06-26 15:53:33 +0200infinity0_(~infinity0@pwned.gg)
2023-06-26 15:53:34 +0200infinity0(~infinity0@pwned.gg) (Killed (zirconium.libera.chat (Nickname regained by services)))
2023-06-26 15:53:34 +0200infinity0_infinity0
2023-06-26 15:58:01 +0200sm[i](~smi]@plaintextaccounting/sm)
2023-06-26 15:58:15 +0200infinity0(~infinity0@pwned.gg) (Remote host closed the connection)
2023-06-26 16:00:21 +0200infinity0(~infinity0@pwned.gg)
2023-06-26 16:03:50 +0200ddellacosta(~ddellacos@146.70.185.136) (Quit: WeeChat 3.8)
2023-06-26 16:03:56 +0200Lycurgus(~juan@user/Lycurgus)
2023-06-26 16:03:58 +0200mxs(~mxs@user/mxs)
2023-06-26 16:04:29 +0200APic(apic@apic.name)
2023-06-26 16:04:33 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-06-26 16:04:34 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-06-26 16:04:34 +0200wroathe(~wroathe@user/wroathe)
2023-06-26 16:05:17 +0200sm[i](~smi]@plaintextaccounting/sm) (Ping timeout: 246 seconds)
2023-06-26 16:07:26 +0200titibandit(~titibandi@user/titibandit) (Read error: Connection reset by peer)
2023-06-26 16:07:29 +0200ystael(~ystael@user/ystael)
2023-06-26 16:09:05 +0200ddellacosta(~ddellacos@146.70.171.100)
2023-06-26 16:10:47 +0200YuutaW(~YuutaW@mail.yuuta.moe) (Ping timeout: 246 seconds)
2023-06-26 16:12:35 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 264 seconds)
2023-06-26 16:13:28 +0200titibandit(~titibandi@user/titibandit)
2023-06-26 16:14:35 +0200YuutaW(~YuutaW@mail.yuuta.moe)
2023-06-26 16:18:56 +0200gurkenglas(~gurkengla@dynamic-046-114-164-153.46.114.pool.telefonica.de)
2023-06-26 16:20:07 +0200hrberg(~quassel@171.79-160-161.customer.lyse.net) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-06-26 16:20:30 +0200hrberg(~quassel@171.79-160-161.customer.lyse.net)
2023-06-26 16:20:48 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-06-26 16:21:01 +0200titibandit(~titibandi@user/titibandit) (Remote host closed the connection)
2023-06-26 16:23:29 +0200thegeekinside(~thegeekin@189.217.90.138)
2023-06-26 16:24:34 +0200Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-06-26 16:26:23 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-06-26 16:31:01 +0200geranim0(~geranim0@modemcable182.140-177-173.mc.videotron.ca)
2023-06-26 16:43:15 +0200Muon(~muon@2a09:bac5:bec4:1923::281:6b)
2023-06-26 16:45:46 +0200gemmaro`(~gemmaro@240f:74:d1f0:1:ba1:e787:c9e:b1dc)
2023-06-26 16:48:14 +0200mxs(~mxs@user/mxs) (Ping timeout: 246 seconds)
2023-06-26 16:49:47 +0200APic(apic@apic.name) (Ping timeout: 264 seconds)
2023-06-26 16:51:58 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-06-26 16:55:02 +0200pavonia(~user@user/siracusa) (Quit: Bye!)
2023-06-26 16:58:34 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 250 seconds)
2023-06-26 17:01:13 +0200gemmaro`(~gemmaro@240f:74:d1f0:1:ba1:e787:c9e:b1dc) (Killed buffer)
2023-06-26 17:01:51 +0200Sgeo(~Sgeo@user/sgeo)
2023-06-26 17:02:31 +0200ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2023-06-26 17:04:00 +0200nschoe(~q@141.101.51.197) (Ping timeout: 246 seconds)
2023-06-26 17:11:41 +0200YuutaW(~YuutaW@mail.yuuta.moe) (Ping timeout: 246 seconds)
2023-06-26 17:13:14 +0200fendor(~fendor@2a02:8388:1640:be00:7aca:a77a:4a28:631a) (Remote host closed the connection)
2023-06-26 17:15:05 +0200YuutaW(~YuutaW@mail.yuuta.moe)
2023-06-26 17:17:16 +0200econo_(uid147250@id-147250.tinside.irccloud.com)
2023-06-26 17:21:14 +0200whatsupdoc(uid509081@id-509081.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-06-26 17:21:30 +0200tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2023-06-26 17:23:46 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-06-26 17:27:12 +0200Guest17(~Guest17@2804:14c:5b61:81fe:8c6b:125b:f65c:e13b)
2023-06-26 17:27:16 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-06-26 17:28:55 +0200 <Guest17> I have posted a question on stackoverflow about parse error. If someone could help me I'm will be grateful.
2023-06-26 17:28:56 +0200 <Guest17> https://stackoverflow.com/questions/76557896/parse-error-possiby-identation-or-mismatch-brackets
2023-06-26 17:30:44 +0200 <geekosaur> I see several problems; the parse error(s) are likely missing `do`s after `then`s
2023-06-26 17:31:17 +0200 <geekosaur> I also suspect you're missing parentheses in `mountTree`
2023-06-26 17:31:18 +0200 <jade[m]> and in one of the if's you also have a let binding without any meaning that may be missing an in?
2023-06-26 17:31:38 +0200 <geekosaur> `return` is not a keyword in Haskell
2023-06-26 17:31:57 +0200 <int-e> there's also the lone "tree = mountTree(intitialPath)" in the final do block
2023-06-26 17:31:58 +0200 <jade[m]> I would suggest writing many more smaller functions to compose and not trying to do imperative-ish nesting of conditionals
2023-06-26 17:32:38 +0200 <Guest17> Same error for both
2023-06-26 17:32:55 +0200 <Guest17> ok jade[m] i will attempt to do that.
2023-06-26 17:33:07 +0200 <int-e> Guest17: yeah this looks like you should write something smaller and simpler first
2023-06-26 17:33:36 +0200 <Guest17> yep, but what is this error? I can found it in this code.
2023-06-26 17:33:41 +0200 <geekosaur> it also looks a lot like you're expecting `do` to turn Haskell into "normal" imperative code, which it doesn't
2023-06-26 17:33:48 +0200 <int-e> If you load a file in `ghci` you can test simple functions without having a main function.
2023-06-26 17:34:21 +0200 <geekosaur> you don't show the actual error or any line numbers
2023-06-26 17:34:32 +0200 <jade[m]> furthermore length(some_list) == 0 just screams for a pattern match
2023-06-26 17:35:02 +0200 <geekosaur> but after almost every `then` you have more than one line, which means you need `then do`
2023-06-26 17:36:02 +0200 <Guest17> i will add the `then do`. Trying to load result i na  parse error,,
2023-06-26 17:36:40 +0200 <jade[m]> :r!
2023-06-26 17:36:55 +0200 <geekosaur> also function invocations do not work as `f(a, b, c)`, but as `f a b c`
2023-06-26 17:36:56 +0200 <jade[m]> that will defer errors
2023-06-26 17:37:22 +0200 <jade[m]> and I would try to just avoid if in general as the way you use it is kind of just an antipattern
2023-06-26 17:37:22 +0200 <geekosaur> and what's that bare `leaf + 1`?
2023-06-26 17:37:36 +0200int-esuspects "leaf++"
2023-06-26 17:37:45 +0200 <int-e> (but in another language)
2023-06-26 17:37:53 +0200 <Guest17> ops, dir + 1.
2023-06-26 17:38:18 +0200 <Guest17> i'm attempet to read the dir tree
2023-06-26 17:38:22 +0200 <jade[m]> I would assume they are thinking that haskell is "just like any other imperative language"
2023-06-26 17:38:26 +0200cfricke(~cfricke@user/cfricke) (Ping timeout: 250 seconds)
2023-06-26 17:38:45 +0200 <jade[m]> besides it actually being fundamentally different
2023-06-26 17:39:11 +0200 <jade[m]> in haskell you can't have statements - you just have expressions that you compose with funcitons
2023-06-26 17:39:27 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:9e3f:72b6:b558:f53d) (Quit: WeeChat 2.8)
2023-06-26 17:39:33 +0200 <Guest17> yep
2023-06-26 17:39:48 +0200 <jade[m]> do just gives the illusion that such things exist in haskell
2023-06-26 17:40:02 +0200 <int-e> @undo do x <- act1; y <- act2 x; let z = x+y; return z
2023-06-26 17:40:02 +0200 <lambdabot> <unknown>.hs:1:49:Parse error: EOF
2023-06-26 17:40:11 +0200 <int-e> ah right
2023-06-26 17:40:16 +0200 <int-e> @undo do x <- act1; y <- act2 x; let { z = x+y }; return z
2023-06-26 17:40:16 +0200 <lambdabot> act1 >>= \ x -> act2 x >>= \ y -> let { z = x + y} in return z
2023-06-26 17:41:20 +0200APic(apic@apic.name)
2023-06-26 17:41:35 +0200 <int-e> The thing is, `do` is "just" syntactic sugar for an ordinary Haskell expression with some weird operator (>>= and >> (not present in the example))
2023-06-26 17:42:27 +0200 <int-e> It doesn't magically give you mutation powers (assignment of variables).
2023-06-26 17:43:54 +0200 <Guest17> i dones't mutate, i control the variables. should i assign to another variable? On de sedgewick book exercice one works perfectly.
2023-06-26 17:43:54 +0200 <Guest17> so I do the same on this algorithm.
2023-06-26 17:44:14 +0200 <Guest17> i will study ```>>=```and ``>>`` operators
2023-06-26 17:44:36 +0200jespada(~jespada@207.188.139.183) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-06-26 17:45:12 +0200 <geekosaur> thye won't help you here
2023-06-26 17:45:30 +0200 <Guest17> ohh ok
2023-06-26 17:45:44 +0200 <geekosaur> which means `do` won't helo you here either
2023-06-26 17:45:54 +0200 <geekosaur> *help
2023-06-26 17:46:16 +0200 <jade[m]> what helped me grasp haskell better is to just avoid do
2023-06-26 17:46:23 +0200 <jade[m]> use explicit `>>=`
2023-06-26 17:46:38 +0200 <jade[m]> because it doesn't hide the true identity
2023-06-26 17:46:53 +0200dsrt^(~dsrt@24.125.210.85)
2023-06-26 17:47:49 +0200Tuplanolla(~Tuplanoll@91.159.68.236)
2023-06-26 17:48:45 +0200 <ski> Guest17 : there is no variable assignment, in Haskell
2023-06-26 17:49:47 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 245 seconds)
2023-06-26 17:50:56 +0200mxs(~mxs@user/mxs)
2023-06-26 17:51:37 +0200 <ski> .. so much wrong here that it's hard to know where to start
2023-06-26 17:51:49 +0200 <Guest17> ski you can assign values from IO to and variables using <- and mutating the declared. by the nature of haskell he will keep then immutable generating anotther variable in the haskell compiled code. How do not compile i can correct the errors
2023-06-26 17:52:02 +0200 <ski> "you can assign values from IO to and variables using <- and mutating the declared" -- no
2023-06-26 17:52:14 +0200 <Guest17> so it's what?
2023-06-26 17:52:16 +0200 <ski> there's no mutation there
2023-06-26 17:52:28 +0200 <Guest17> yep, only variable assignment
2023-06-26 17:52:31 +0200 <ski> primariList <- getDirectoryContests(primariList)
2023-06-26 17:52:36 +0200 <ski> this is not mutation
2023-06-26 17:52:46 +0200 <ski> it's just declarring a new variable, which shadows the old one
2023-06-26 17:52:47 +0200 <geekosaur> that passes a parameter to the rest of the do block
2023-06-26 17:53:19 +0200 <Guest17> someone have a example of a tree to me to start?
2023-06-26 17:53:30 +0200 <Guest17> or where i can find it
2023-06-26 17:53:49 +0200 <ski> data Tree a = Node a [Tree a]
2023-06-26 17:54:01 +0200 <Guest17> i'm using tuples
2023-06-26 17:54:30 +0200 <Guest17> let the Node type to work in another hour
2023-06-26 17:54:43 +0200 <jade[m]> hm?
2023-06-26 17:55:00 +0200 <Guest17> jade[m] responding to the ski
2023-06-26 17:55:00 +0200misterfish(~misterfis@87.215.131.102) (Ping timeout: 260 seconds)
2023-06-26 17:55:17 +0200 <Guest17> *answering
2023-06-26 17:55:19 +0200 <jade[m]> yeah but I don't understand the response
2023-06-26 17:55:23 +0200 <jade[m]> trees are recursive by nature
2023-06-26 17:55:29 +0200 <jade[m]> so how can you use a tuple?
2023-06-26 17:55:29 +0200 <ski> it's unclear what you're attempting to do, in your code, Guest17
2023-06-26 17:55:52 +0200 <Guest17> by using a recursion.
2023-06-26 17:56:07 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-06-26 17:56:26 +0200 <ski> newetype Tree a = Node (a,[Tree a]) -- variant, using pairs, which are tuples
2023-06-26 17:56:37 +0200rburkholder(~blurb@96.45.2.121) (Server closed connection)
2023-06-26 17:56:59 +0200rburkholder(~blurb@96.45.2.121)
2023-06-26 17:57:26 +0200 <ski> Guest17 : what is the intent of `toScan[leaf] = []' ?
2023-06-26 17:57:26 +0200 <Guest17> ski I'm attempt to create a garbage collector for my node modules using haskell. this algorithm is was alredy writed in JS, now I'm attempt to do with haskell
2023-06-26 17:57:29 +0200 <jade[m]> yeah but I don't see why you'd do that
2023-06-26 17:57:39 +0200 <Guest17> scan a folders
2023-06-26 17:58:00 +0200 <Guest17> *scan folders
2023-06-26 17:58:26 +0200 <jade[m]> ok, but translating from an imperative algorithm to a functional one usually isn't that straightforward
2023-06-26 17:58:40 +0200 <jade[m]> usually the functional one will be easier, but you need to think about the problem at hand
2023-06-26 17:59:36 +0200 <ski> `Either IO [FilePath] String' also looks quite wrong. i'd suspect you either meant `Either (IO [FilePath]) String', `IO (Either [FilePath] String)', or `ExceptT [FilePath] IO String'
2023-06-26 18:00:20 +0200YuutaW(~YuutaW@mail.yuuta.moe) (Ping timeout: 240 seconds)
2023-06-26 18:00:25 +0200 <Guest17> Either IO [FilePath] String the program receive a string when it ends
2023-06-26 18:00:44 +0200 <ski> `Either IO [FilePath] String' is a kind error
2023-06-26 18:00:54 +0200 <ski> `Either' doesn't take three type parameters. it takes two
2023-06-26 18:01:05 +0200 <Guest17> he is taking to
2023-06-26 18:01:09 +0200 <Guest17> Either a b
2023-06-26 18:01:12 +0200 <ski> @kind Either IO [FilePath] String
2023-06-26 18:01:13 +0200 <lambdabot> error:
2023-06-26 18:01:14 +0200 <lambdabot> • Expected kind ‘* -> k0’, but ‘Either IO [FilePath]’ has kind ‘*’
2023-06-26 18:01:14 +0200 <lambdabot> • In the type ‘Either IO [FilePath] String’
2023-06-26 18:01:21 +0200 <ski> @kind Either (IO [FilePath]) String
2023-06-26 18:01:22 +0200 <lambdabot> *
2023-06-26 18:01:31 +0200 <ski> @kind IO (Either [FilePath] String)
2023-06-26 18:01:31 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-06-26 18:01:32 +0200 <lambdabot> *
2023-06-26 18:01:40 +0200 <Guest17> ahh ok
2023-06-26 18:01:45 +0200 <ski> @kind ExceptT [FilePath] IO String
2023-06-26 18:01:46 +0200 <lambdabot> *
2023-06-26 18:02:33 +0200 <jade[m]> but usually you don't need these hugs monad constructs or even transformers for small programs like you are talking about
2023-06-26 18:02:36 +0200 <ski> (the last two alternatives are basically the same thing, apart from some extra dress-up of the last version. the first alternative is different .. and, i suspect, not what you intended)
2023-06-26 18:03:07 +0200 <ski> yea. the main question here is why you wrote `Either IO [FilePath] String' to begin with
2023-06-26 18:03:23 +0200 <Guest17> i have corrected this error
2023-06-26 18:03:54 +0200 <jade[m]> (I used to do all this exact stuff so I feel the pain)
2023-06-26 18:04:01 +0200YuutaW(~YuutaW@mail.yuuta.moe)
2023-06-26 18:04:36 +0200 <ski> "a garbage collector for my node modules using haskell" -- are you garbage-collecting files in the file system ?
2023-06-26 18:05:11 +0200 <Guest17> cleanning the node_modules from my projecsts a installing it again when necessary
2023-06-26 18:05:32 +0200 <ski> by running some external (JS-related) programs, from Haskell ?
2023-06-26 18:05:42 +0200 <jade[m]> sound like you can do this with a small bash script and find -r lol
2023-06-26 18:05:48 +0200 <Guest17> ski yep
2023-06-26 18:06:20 +0200 <ski> why did you think of using `Either' at all ?
2023-06-26 18:06:24 +0200 <Guest17> jade[m]to leran more of hsakell i decided to do this. have some  time i don't study haskell
2023-06-26 18:06:52 +0200mxs(~mxs@user/mxs) (Ping timeout: 240 seconds)
2023-06-26 18:06:59 +0200 <jade[m]> ah alright
2023-06-26 18:08:04 +0200 <Guest17> i will research more and come back here.
2023-06-26 18:08:22 +0200 <ski> you don't want to talk through your code ?
2023-06-26 18:08:40 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-06-26 18:09:06 +0200APic(apic@apic.name) (Ping timeout: 246 seconds)
2023-06-26 18:10:54 +0200 <Guest17> More research is needed. Principle to work with Node type.
2023-06-26 18:10:55 +0200 <Guest17> iwill research in trees with haskell
2023-06-26 18:11:02 +0200 <Guest17> this will do some help for me
2023-06-26 18:11:40 +0200 <ski> do you really need to use a tree type ?
2023-06-26 18:13:03 +0200 <Guest17> no, but can grow my kwnoledge
2023-06-26 18:13:34 +0200 <Guest17> when was said to do more functional
2023-06-26 18:13:56 +0200 <Guest17> i will need to research for examples.
2023-06-26 18:15:16 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0)
2023-06-26 18:16:26 +0200 <ski> perhaps getting a textbook could help
2023-06-26 18:16:36 +0200 <Guest17> ok
2023-06-26 18:16:54 +0200 <Guest17> have one in mind?
2023-06-26 18:19:45 +0200kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Remote host closed the connection)
2023-06-26 18:20:18 +0200hyiltiz(~user@2620:149:13d1:100::5df)
2023-06-26 18:23:21 +0200 <int-e> @where rwh
2023-06-26 18:23:21 +0200 <lambdabot> http://www.realworldhaskell.org/blog/ http://book.realworldhaskell.org/read/
2023-06-26 18:23:24 +0200 <int-e> @where lyah
2023-06-26 18:23:24 +0200 <lambdabot> http://www.learnyouahaskell.com/
2023-06-26 18:23:32 +0200 <ski> @where PiH
2023-06-26 18:23:32 +0200 <lambdabot> "Programming in Haskell" by Graham Hutton in 2007-01-15,2016-09-01 at <http://www.cs.nott.ac.uk/~pszgmh/pih.html>
2023-06-26 18:23:52 +0200 <int-e> . o ( just stay away from the "gentle introduction" )
2023-06-26 18:24:20 +0200 <ski> (unless you're already familiar with functional programming .. which doesn't appear to be the case, here)
2023-06-26 18:24:42 +0200 <ncf> i'm surprised by how rarely the wikibook is recommended... is there anything wrong with it?
2023-06-26 18:24:44 +0200 <geekosaur> of the three, I prefer the Hutton. but if you don't want to or can't spend money on it, the Haskell Wikibook is okay
2023-06-26 18:24:49 +0200 <geekosaur> @where wikibook
2023-06-26 18:24:49 +0200 <lambdabot> http://en.wikibooks.org/wiki/Haskell
2023-06-26 18:25:08 +0200 <hyiltiz> Has anyone have any experience with the `padic` package by sergey?
2023-06-26 18:25:24 +0200 <geekosaur> it's just nowhere near as good as Hutton's. but I consider it much better than LYAH
2023-06-26 18:26:01 +0200chele(~chele@user/chele) (Remote host closed the connection)
2023-06-26 18:26:03 +0200 <ncf> i should probably read the Hutton and adjust my recommendation list then :)
2023-06-26 18:26:19 +0200elain4(~textual@static-71-251-226-194.rcmdva.fios.verizon.net)
2023-06-26 18:26:23 +0200oac_(~oac@pool-141-157-210-244.nycmny.fios.verizon.net)
2023-06-26 18:28:29 +0200Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-06-26 18:28:49 +0200Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-06-26 18:29:23 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 246 seconds)
2023-06-26 18:32:25 +0200elain4(~textual@static-71-251-226-194.rcmdva.fios.verizon.net) (Ping timeout: 240 seconds)
2023-06-26 18:35:20 +0200Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Ping timeout: 246 seconds)
2023-06-26 18:35:52 +0200Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-06-26 18:36:40 +0200 <Guest17> thanks folks. When I could help anyone I'm leaving. Thanks for the recomendations.
2023-06-26 18:37:10 +0200Guest17(~Guest17@2804:14c:5b61:81fe:8c6b:125b:f65c:e13b) (Quit: Client closed)
2023-06-26 18:39:43 +0200nick3(~nick@wsip-174-78-110-18.pn.at.cox.net)
2023-06-26 18:40:02 +0200gmg(~user@user/gehmehgeh)
2023-06-26 18:41:18 +0200elain4(~textual@static-71-251-226-194.rcmdva.fios.verizon.net)
2023-06-26 18:41:47 +0200nut(~nut@176-151-21-224.abo.bbox.fr)
2023-06-26 18:42:41 +0200jinsl(~jinsl@2408:8207:2558:8870:211:32ff:fec8:6aea) (Ping timeout: 246 seconds)
2023-06-26 18:44:59 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 264 seconds)
2023-06-26 18:45:12 +0200CiaoSen(~Jura@2a05:5800:2ac:6500:664b:f0ff:fe37:9ef) (Ping timeout: 245 seconds)
2023-06-26 18:55:45 +0200wootehfoot(~wootehfoo@user/wootehfoot)
2023-06-26 18:57:44 +0200dmj`(sid72307@id-72307.hampstead.irccloud.com) (Server closed connection)
2023-06-26 18:58:10 +0200dmj`(sid72307@id-72307.hampstead.irccloud.com)
2023-06-26 18:58:25 +0200elain4(~textual@static-71-251-226-194.rcmdva.fios.verizon.net) (Ping timeout: 240 seconds)
2023-06-26 19:06:30 +0200Guest9511(~finn@rul16-h01-176-151-21-224.dsl.sta.abo.bbox.fr)
2023-06-26 19:06:47 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-06-26 19:11:45 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-06-26 19:20:35 +0200 <jade[m]> is there a nice overview for what parser combinator library is useful for what?
2023-06-26 19:20:48 +0200 <jade[m]> because it seems like they all basically do the same with minor differences
2023-06-26 19:27:16 +0200remedan(~remedan@ip-94-112-0-18.bb.vodafone.cz) (Quit: Bye!)
2023-06-26 19:28:11 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 246 seconds)
2023-06-26 19:29:14 +0200CiaoSen(~Jura@2a05:5800:2ac:6500:664b:f0ff:fe37:9ef)
2023-06-26 19:38:17 +0200 <geekosaur> what seems to be, is
2023-06-26 19:38:46 +0200 <geekosaur> there are some differences, for example attoparsec is well designed for streaming input
2023-06-26 19:39:59 +0200 <geekosaur> but by and large you get the same thing from all of them these days
2023-06-26 19:40:29 +0200 <geekosaur> at one point trifecta produced the best error messages, but then megaparsec upped its game in response
2023-06-26 19:43:47 +0200CiaoSen(~Jura@2a05:5800:2ac:6500:664b:f0ff:fe37:9ef) (Ping timeout: 264 seconds)
2023-06-26 19:45:56 +0200user363627(~user@146.70.198.100)
2023-06-26 19:47:23 +0200YuutaW(~YuutaW@mail.yuuta.moe) (Ping timeout: 264 seconds)
2023-06-26 19:48:49 +0200YuutaW(~YuutaW@2404:f4c0:f9c3:502::100:17b7)
2023-06-26 19:49:09 +0200remedan(~remedan@ip-94-112-0-18.bb.vodafone.cz)
2023-06-26 19:49:24 +0200 <user363627> what's a recommended way to install haskell-language-server for the latest stack snapshot?
2023-06-26 19:50:56 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Ping timeout: 240 seconds)
2023-06-26 19:51:25 +0200jinsl(~jinsl@2408:8207:2550:b730:211:32ff:fec8:6aea)
2023-06-26 19:52:46 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-06-26 19:57:09 +0200ec(~ec@gateway/tor-sasl/ec)
2023-06-26 19:57:16 +0200 <user363627> oh there's a ghcup these days
2023-06-26 19:58:26 +0200 <chreekat> bingo
2023-06-26 19:59:17 +0200taupiqueur(~taupiqueu@2a02:8440:2241:b894:997:4e3:5b13:10b2)
2023-06-26 20:00:43 +0200tromp(~textual@92.110.219.57)
2023-06-26 20:05:34 +0200oac_(~oac@pool-141-157-210-244.nycmny.fios.verizon.net) (Quit: oac_)
2023-06-26 20:06:20 +0200oac_(~oac@141.157.210.244)
2023-06-26 20:09:03 +0200whatsupdoc(uid509081@id-509081.hampstead.irccloud.com)
2023-06-26 20:10:08 +0200Pickchea(~private@user/pickchea)
2023-06-26 20:11:10 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-06-26 20:11:24 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-06-26 20:12:46 +0200ripspin(~chatzilla@1.145.163.38) (Remote host closed the connection)
2023-06-26 20:15:41 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-06-26 20:17:56 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0) (Remote host closed the connection)
2023-06-26 20:21:46 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2023-06-26 20:27:23 +0200wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2023-06-26 20:30:18 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0)
2023-06-26 20:32:13 +0200 <EvanR> attoparsec is more convenient for parsing Word8 stream, megaparsec seems more convenient for parsing text. Supposedly you can reconfigure the token types but I never succeeded
2023-06-26 20:33:24 +0200 <geekosaur> you can but you need to provide your own convenience wrappers
2023-06-26 20:34:14 +0200nshepperd(nshepperd@2600:3c03::f03c:92ff:fe28:92c9) (Server closed connection)
2023-06-26 20:34:21 +0200 <geekosaur> this does make a certain amount of sense because they'll tend to depend on how they're being used; otherwise you just get a harder to use binary/cereal
2023-06-26 20:34:32 +0200nshepperd(nshepperd@2600:3c03::f03c:92ff:fe28:92c9)
2023-06-26 20:38:01 +0200 <EvanR> for megaparsec you have to implement Stream, and now I see there's already an instance for Ord a => Stream [a], did not investigate that
2023-06-26 20:38:14 +0200 <EvanR> I wonder what the Ord is for
2023-06-26 20:39:30 +0200 <tomsmeding> perhaps to be able to use it as a key for a Map somewhere
2023-06-26 20:39:31 +0200 <EvanR> the instance doesn't seem to need it
2023-06-26 20:41:22 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0) (Remote host closed the connection)
2023-06-26 20:42:28 +0200 <EvanR> oh, the class requires it
2023-06-26 20:42:37 +0200 <Hecate> Stream, VisualStream & TraversableStream
2023-06-26 20:43:40 +0200ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2023-06-26 20:44:29 +0200ec(~ec@gateway/tor-sasl/ec)
2023-06-26 20:47:11 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0)
2023-06-26 20:49:35 +0200 <EvanR> and once you do all that, how do you form a new primitive Parsec(T) to start writing the parser
2023-06-26 20:50:01 +0200nasrudin__(~nasrudin_@45.152.182.251)
2023-06-26 20:51:41 +0200 <EvanR> use the newtype wrapper which takes a State s e -> (a -> State s e -> Hints (Token s) -> m b) -> (ParseError s e -> State s e -> m b) -> (a -> State s e -> Hints (Token s) -> m b) -> (ParseError s e -> State s e -> m b) -> m b ?
2023-06-26 20:52:24 +0200 <jade[m]> Jesus that's a bunch
2023-06-26 20:52:55 +0200 <EvanR> high octane Reader monad xD
2023-06-26 20:54:22 +0200Square2(~Square@user/square)
2023-06-26 20:54:41 +0200 <EvanR> ParsecT $ \s cok cerr eok eerr -> _
2023-06-26 20:56:19 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-06-26 20:56:25 +0200__monty__(~toonn@user/toonn)
2023-06-26 20:56:52 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 240 seconds)
2023-06-26 20:57:28 +0200smoge(~smoge@2603-7000-4b42-1100-dda0-def4-e62f-c2ea.res6.spectrum.com)
2023-06-26 20:57:40 +0200 <smoge> How can I make it work for all kinds of nested lists?
2023-06-26 20:57:40 +0200 <smoge> ghci> read "[[1]]" :: [[Int]]
2023-06-26 20:57:41 +0200 <smoge> [[1]]
2023-06-26 20:57:41 +0200 <smoge> ghci> read "[[1], [1, 2]]" :: [[Int]]
2023-06-26 20:57:42 +0200 <smoge> [[1],[1,2]]
2023-06-26 20:57:42 +0200 <smoge> ghci> read "[[1], [1, [2]]]" :: [[Int]]
2023-06-26 20:57:43 +0200 <smoge> *** Exception: Prelude.read: no parse
2023-06-26 20:57:43 +0200 <smoge> ghci> read "[[1], [1, [2]]]" :: [[[Int]]]
2023-06-26 20:57:44 +0200 <smoge> *** Exception: Prelude.read: no parse
2023-06-26 20:58:03 +0200 <xerox> :t [1,[2]]
2023-06-26 20:58:04 +0200 <lambdabot> (Num a, Num [a]) => [[a]]
2023-06-26 20:58:29 +0200 <EvanR> use a tree instead of a list
2023-06-26 20:58:37 +0200 <xerox> not really a value
2023-06-26 20:58:40 +0200 <hpc> :t [False, [True, False]] -- a bit more clear
2023-06-26 20:58:41 +0200 <lambdabot> error:
2023-06-26 20:58:41 +0200 <lambdabot> • Couldn't match expected type ‘Bool’ with actual type ‘[Bool]’
2023-06-26 20:58:42 +0200 <lambdabot> • In the expression: [True, False]
2023-06-26 20:59:01 +0200 <smoge> I just want to use lisp lists and convert into haskell lists of lists, regardless of their structure
2023-06-26 20:59:27 +0200 <EvanR> define a proper data type to represent lisp lists
2023-06-26 20:59:57 +0200 <EvanR> or more likely, a lisp value which might be a list
2023-06-26 21:00:13 +0200 <smoge> listStringToHaskell "(1 (2 (3 4) 5) 6)"
2023-06-26 21:00:14 +0200 <smoge> -- Returns: -- [1,[2,[3,4],5],6]
2023-06-26 21:00:21 +0200 <dsal> These kinds of things are a bit easier if you look at the types first.
2023-06-26 21:00:23 +0200 <hpc> lisp lists are trees
2023-06-26 21:00:27 +0200 <smoge> How to do it to work with any lisp list?
2023-06-26 21:00:31 +0200 <smoge> yes
2023-06-26 21:00:51 +0200 <EvanR> yeah it can't be a haskell list because haskell lists elements are all the same type
2023-06-26 21:00:53 +0200 <hpc> don't be fooled by the name - it's like how python's "lists" are just its word for the array data structure
2023-06-26 21:01:01 +0200 <hpc> even in the 50s they were naming things poorly :D
2023-06-26 21:01:22 +0200 <smoge> So I need to parse and create a tree. No way around it?
2023-06-26 21:01:36 +0200 <hpc> yeah
2023-06-26 21:01:52 +0200 <EvanR> data Lisp = List [Lisp] | Symbol String | Number Double | Boolean Bool | ...
2023-06-26 21:02:27 +0200 <ncf> more like data SExp = Nil | Cons SExp SExp | Atom ...
2023-06-26 21:02:31 +0200 <hpc> personally i would cut it off at List/Symbol
2023-06-26 21:02:46 +0200 <ncf> (1 . 2) = Cons (Atom 1) (Atom 2)
2023-06-26 21:03:00 +0200 <ncf> (1 2) = Cons (Atom 1) (Cons (Atom 2) Nil)
2023-06-26 21:03:07 +0200 <ncf> you can probably define an IsList instance
2023-06-26 21:03:08 +0200 <smoge> I tried that, it returns something like  Right (List [Number 1,List [Number 2,List [Number 3,Number (-4)]],Number 5,List [Number 6,List [Number 7,List [Number 8,List [Number (-9),Number 10]]]]])
2023-06-26 21:03:09 +0200 <smoge> How do I use it afterward? I goit a bit confused at this point
2023-06-26 21:03:22 +0200 <EvanR> what do you want to do with it
2023-06-26 21:03:40 +0200 <EvanR> ncf's version might be more lispy
2023-06-26 21:05:23 +0200 <smoge> I want to iterate through the list, to transform it into music rhythm structures
2023-06-26 21:05:41 +0200 <smoge> maybe my mind is too imperative still
2023-06-26 21:05:51 +0200 <ncf> oh you're probably fine with lists instead of cons cells then
2023-06-26 21:06:03 +0200 <EvanR> to iterate through the tree, you can write a recursive algorithm
2023-06-26 21:06:36 +0200 <dsal> Though most things you'd need to do through the tree are already done and you can just reuse them.
2023-06-26 21:06:50 +0200 <smoge> What is this " Right", all parsers return this? How to I deal with it later?
2023-06-26 21:06:59 +0200bbhoss(sid18216@id-18216.tinside.irccloud.com) ()
2023-06-26 21:06:59 +0200 <dsal> Right is a constructor of Either
2023-06-26 21:07:02 +0200 <EvanR> data Either a b = Left a | Right b
2023-06-26 21:07:17 +0200 <EvanR> use pattern matching to detect which case you get
2023-06-26 21:07:24 +0200 <smoge> ok
2023-06-26 21:07:29 +0200 <EvanR> Right means right and Left means parse error
2023-06-26 21:07:53 +0200 <EvanR> in this case
2023-06-26 21:09:02 +0200 <EvanR> pattern matching it also the basic way to iterate through a (haskell) list, a list is either the empty list or some element and some list tail
2023-06-26 21:11:23 +0200Guest97(~Guest97@2a00:23c4:31cc:a301:5093:416:b7a8:251f)
2023-06-26 21:11:50 +0200Guest97(~Guest97@2a00:23c4:31cc:a301:5093:416:b7a8:251f) (Client Quit)
2023-06-26 21:14:26 +0200 <TMA> I thought it is usually the other way around. Left result, Right error
2023-06-26 21:14:27 +0200 <smoge> Something like
2023-06-26 21:14:27 +0200 <smoge> getTree :: Either String Value -> Maybe [Int]
2023-06-26 21:14:28 +0200 <smoge> getTree (Right (List xs)) = Just (extractTree xs)
2023-06-26 21:14:29 +0200 <smoge> getTree _                 = Nothing
2023-06-26 21:14:29 +0200 <smoge> ??
2023-06-26 21:14:49 +0200 <jean-paul[m]> TMA: It isn't.
2023-06-26 21:14:56 +0200 <jean-paul[m]> Here's a mnemonic for you. Right is right.
2023-06-26 21:15:17 +0200 <jean-paul[m]> (oops EvanR said it already)
2023-06-26 21:15:37 +0200 <dsal> smoge: that's almost `fmap extractTree` if you didn't want it to throw away the error.
2023-06-26 21:16:12 +0200taupiqueur(~taupiqueu@2a02:8440:2241:b894:997:4e3:5b13:10b2) (Ping timeout: 240 seconds)
2023-06-26 21:16:30 +0200 <smoge> getTree :: Either String Value -> Maybe [Int]
2023-06-26 21:16:31 +0200 <smoge> getTree (Right (List xs)) = Just xs
2023-06-26 21:16:31 +0200 <smoge> getTree _                 = Nothing
2023-06-26 21:16:32 +0200 <dsal> @hoogle Either a b -> Maybe b
2023-06-26 21:16:33 +0200 <lambdabot> Data.Either.Combinators rightToMaybe :: Either a b -> Maybe b
2023-06-26 21:16:34 +0200 <lambdabot> Data.Either.Extra eitherToMaybe :: Either a b -> Maybe b
2023-06-26 21:16:34 +0200 <lambdabot> Extra eitherToMaybe :: Either a b -> Maybe b
2023-06-26 21:16:59 +0200Guest9511(~finn@rul16-h01-176-151-21-224.dsl.sta.abo.bbox.fr) (Ping timeout: 240 seconds)
2023-06-26 21:17:01 +0200 <dsal> smoge: You're doing two different things here. It might be better to think of them separately.
2023-06-26 21:17:09 +0200 <smoge> ok
2023-06-26 21:17:22 +0200 <dsal> One thing is converting the `Either String Value` to `Maybe Value`. The other is doing a `Value -> X`
2023-06-26 21:18:34 +0200 <dsal> You might as well keep the `Either` unless you have a really good reason to throw away errors.
2023-06-26 21:20:12 +0200 <dsal> Both `Either` and `Maybe` are functors, so you can use `fmap` to just ignore them and work on the `Value -> X` part.
2023-06-26 21:20:26 +0200 <smoge> oh
2023-06-26 21:20:26 +0200 <EvanR> one way is to handle the parse error immediately in your program, otherwise continue with the non-error
2023-06-26 21:20:43 +0200 <EvanR> esp if you don't expect to have any failures past that point
2023-06-26 21:20:54 +0200oac_(~oac@141.157.210.244) (Quit: oac_)
2023-06-26 21:21:07 +0200misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-06-26 21:21:36 +0200oac(~oac@141.157.210.244)
2023-06-26 21:21:38 +0200 <EvanR> case parseTheThing str of Left msg -> crashAndBurn msg; Right value -> mainLoop value
2023-06-26 21:22:15 +0200 <jade[m]> can you please provide an implementation of crashAndBurn
2023-06-26 21:22:22 +0200 <jade[m]> i'd like to see that
2023-06-26 21:22:29 +0200 <EvanR> halt and catch fire
2023-06-26 21:22:49 +0200 <TMA> jean-paul[m]: It got it somehow mixed. I thought of it as an extension to Maybe, which is usually described as data Maybe a = Just a | Nothing adding another type parameter for the error and becoming data Either a b = Left a | Right b
2023-06-26 21:22:54 +0200gurkenglas(~gurkengla@dynamic-046-114-164-153.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-06-26 21:23:15 +0200 <EvanR> data Maybe a = Nothing | Just a? xD
2023-06-26 21:23:20 +0200 <smoge>  So no need to have this?
2023-06-26 21:23:21 +0200 <smoge>   Left err          -> Left $ show err
2023-06-26 21:23:21 +0200 <smoge>   Right proportions -> Right proportions
2023-06-26 21:23:25 +0200 <jean-paul[m]> withCString says "the Haskell string may not contain any NUL characters". What if it does?
2023-06-26 21:23:30 +0200 <dsal> TMA: it gets clear when you try to do make a functor instance.
2023-06-26 21:24:04 +0200 <TMA> EvanR: if that would be the usual way to introduced, then yes, that confusion would go away
2023-06-26 21:24:09 +0200 <smoge> Better?
2023-06-26 21:24:10 +0200 <smoge>   Left err          -> Left $ show err
2023-06-26 21:24:10 +0200 <EvanR> smoge, think of the case as dispatching the Left or Right and going in two independent directions
2023-06-26 21:24:10 +0200 <smoge>   Right proportions -> Right proportions
2023-06-26 21:24:20 +0200 <smoge>   Left err          -> Left $ show err
2023-06-26 21:24:21 +0200 <smoge>   Right proportions -> Just proportions
2023-06-26 21:24:31 +0200 <EvanR> rewrapping with Left and Right is possible not unnecessary here
2023-06-26 21:24:41 +0200 <EvanR> what
2023-06-26 21:24:48 +0200 <EvanR> possible but unnecessary here
2023-06-26 21:25:11 +0200 <mauke> jean-paul[m]: then your C string gets cut off
2023-06-26 21:25:18 +0200ec_(~ec@gateway/tor-sasl/ec)
2023-06-26 21:25:24 +0200 <dsal> smoge: it's not clear what you're trying to do. But worrying about what Either is doing is probably slowing your progress. You can write your code assuming you have whatever `Value` is and just `fmap` it.
2023-06-26 21:25:27 +0200 <EvanR> my suggestion was assuming you were handling the parse error in IO before going on
2023-06-26 21:25:29 +0200 <smoge> Ok, but I'm still confused what I can write after Right XXXX ->
2023-06-26 21:25:42 +0200 <EvanR> anything that type checks
2023-06-26 21:25:50 +0200 <smoge> ok oh
2023-06-26 21:26:06 +0200 <EvanR> if you want to return Maybe [Int], then I guess the only option is Nothing
2023-06-26 21:26:25 +0200 <EvanR> otherwise you'd be making up some numbers, since the parse failed
2023-06-26 21:26:27 +0200 <jean-paul[m]> mauke: okay. could be worse.
2023-06-26 21:27:17 +0200 <EvanR> assume you will handle the parse failure somehow and write your main code assuming you have a Value
2023-06-26 21:27:25 +0200 <EvanR> figure out how to connect it later
2023-06-26 21:28:08 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 240 seconds)
2023-06-26 21:28:37 +0200 <EvanR> TMA,
2023-06-26 21:28:39 +0200 <EvanR> @src Maybe
2023-06-26 21:28:39 +0200 <lambdabot> data Maybe a = Nothing | Just a
2023-06-26 21:29:16 +0200 <smoge> Ok, any guide that I could read about it?
2023-06-26 21:29:40 +0200 <smoge> Also, I'm trying to "rotate a tree". How can I get started with that? For eample:
2023-06-26 21:29:40 +0200 <smoge> (1 ( 2 (3 -4)) 5 ( 6 (7 ( 8 (-9 10)))))
2023-06-26 21:29:41 +0200 <smoge> (2 ( 3 (-4 5)) 6 ( 7 (8 ( -9 (10 1)))))
2023-06-26 21:29:41 +0200 <smoge> (3 ( -4 (5 6)) 7 ( 8 (-9( 10 (1 2)))))
2023-06-26 21:30:04 +0200 <mauke> .oO( logrotate )
2023-06-26 21:30:17 +0200 <TMA> EvanR: The tutorials I have encountered had it the other way around
2023-06-26 21:30:26 +0200 <dsal> You can do that with biplate, but… I'm not sure you're ready for that.
2023-06-26 21:30:53 +0200falafel(~falafel@2607:fb91:86c:d890:7062:4878:f4c6:58e7)
2023-06-26 21:31:06 +0200 <mauke> > Nothing < Just ()
2023-06-26 21:31:07 +0200 <lambdabot> True
2023-06-26 21:32:22 +0200 <EvanR> i question writing Just a first because when you inductively define a data structure or whatever, you probably want a base case like Nothing to start with
2023-06-26 21:32:27 +0200 <smoge> Ok, but could I some code that does something similar, just to have a sense?
2023-06-26 21:32:29 +0200 <EvanR> @src List
2023-06-26 21:32:29 +0200 <lambdabot> Source not found. And you call yourself a Rocket Scientist!
2023-06-26 21:32:33 +0200 <EvanR> @src []
2023-06-26 21:32:33 +0200 <lambdabot> data [] a = [] | a : [a]
2023-06-26 21:33:41 +0200 <EvanR> smoge, are you sure an arbitrary tree is the best structure for this. What other operations are you expecting to do
2023-06-26 21:34:09 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0) (Remote host closed the connection)
2023-06-26 21:34:10 +0200 <EvanR> rotate would be easier as a list, or a Data.Sequence
2023-06-26 21:34:15 +0200 <dsal> If you're treating it like a list, a list might be easier. Because rotating a list is trivial, but rotating a tree is probably a lot of work.
2023-06-26 21:34:18 +0200 <smoge> https://support.ircam.fr/docs/om/om6-manual/co/RT1.html
2023-06-26 21:34:48 +0200 <smoge> rotate tree, substitute a leaf with a branch (subdivision)
2023-06-26 21:34:59 +0200 <EvanR> a list of measures, each of which is divided somehow
2023-06-26 21:35:07 +0200taupiqueur(~taupiqueu@2a02-8440-2241-6bd3-291b-5a44-8bad-c57d.rev.sfr.net)
2023-06-26 21:35:19 +0200 <EvanR> maybe
2023-06-26 21:36:37 +0200 <dsal> The way I'd do this might be a bit difficult to understand right away.
2023-06-26 21:36:49 +0200 <smoge> yes, the idea is to manipulate the tree, each measure is also a subtree
2023-06-26 21:37:06 +0200 <dsal> I'm not even sure how easy it'd be to get a typesafe measure. I kind of want to try now. heh.
2023-06-26 21:37:38 +0200 <EvanR> dependent types to the 'rescue'? xD
2023-06-26 21:37:44 +0200ec_(~ec@gateway/tor-sasl/ec) (Ping timeout: 240 seconds)
2023-06-26 21:37:45 +0200 <smoge> I was trying to have a project to learn haskell, but maybe that's too hard.
2023-06-26 21:37:59 +0200 <smoge> but if I go back to python, I will never learn haskell :)
2023-06-26 21:38:02 +0200 <EvanR> choice of data structure is definitely key to doing things easily in haskell
2023-06-26 21:38:22 +0200gurkenglas(~gurkengla@dynamic-046-114-164-153.46.114.pool.telefonica.de)
2023-06-26 21:38:40 +0200 <EvanR> but it takes experience to know what kind of data structures are out there
2023-06-26 21:38:46 +0200 <smoge> Yes, in this case, is there a specific kind of tree that would be easier to work?
2023-06-26 21:38:55 +0200 <dsal> Not fully dependent, but you can have a type of Measure that has a division count and you could imagine a Measure made up of `Division 1 <+> Division 1 <+> Division 1 <+> Division 1`- I don't know that you can have fractional literals, though.
2023-06-26 21:38:57 +0200 <EvanR> that depends entirely on the operations you need
2023-06-26 21:40:15 +0200 <dsal> Doing it without type safety would be pretty straightforward. A Subdivision contains a list of subdivisions and the subdivision lengths are expected to add up to your measure length.
2023-06-26 21:40:35 +0200 <smoge>  <+> is being used to represent some kind of binary operation on Division (tree)  values? substitution?
2023-06-26 21:41:24 +0200 <EvanR> dsal looks like they are just constructing the data, not doing anything with it
2023-06-26 21:42:11 +0200 <dsal> Yeah, so you would imagine adding a `a <+> b` where `a, b :: Division (1/8)` and the result would be `Division (1/4)` and a measure would have type `Division 1`. So you wouldn't be able to stick an eight note into a measure and have it compile.
2023-06-26 21:42:20 +0200 <EvanR> anyway, if you just want to rotate, you can use a list of rational numbers
2023-06-26 21:42:26 +0200 <dsal> EvanR: Yeah, I'm just looking at this page and trying to figure out how I might push stuff into the type system.
2023-06-26 21:43:12 +0200 <EvanR> then each division can be subdivided arbitrarily
2023-06-26 21:43:16 +0200 <dsal> The "easiest" way to rotate is biplate, but that's going to leave you completely baffled. A zipper might help. But the structure is just kind of not good at that. You could have a parallel structure.
2023-06-26 21:43:22 +0200tromp(~textual@92.110.219.57) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-06-26 21:43:58 +0200 <smoge> Does it make any sense?
2023-06-26 21:43:58 +0200 <smoge> rotate :: Tree a -> Tree a
2023-06-26 21:43:59 +0200 <smoge> rotate (Node [a, Node [b, c], d])    = Node [b, Node [a, c], d]
2023-06-26 21:44:00 +0200 <smoge> rotate (Node [a, Node [b, c, d], e]) = Node [Node [a, b], c, Node [d, e]]
2023-06-26 21:44:00 +0200 <smoge> rotate (Node xs)                     = Node (map rotate xs)
2023-06-26 21:44:00 +0200 <smoge> rotate t                             = t
2023-06-26 21:44:10 +0200 <EvanR> are you assuming a specific configuration
2023-06-26 21:44:27 +0200 <EvanR> is the first element always a number and not a subtree
2023-06-26 21:44:32 +0200 <smoge> yes... I can't figure out artitrary structures
2023-06-26 21:46:14 +0200 <smoge> maybe just rotate a flattened list and populate a new tree with the old structure... ?
2023-06-26 21:46:24 +0200trev(~trev@user/trev) (Quit: trev)
2023-06-26 21:47:12 +0200 <EvanR> do you need arbitrary levels? Or is it just 2 levels
2023-06-26 21:47:50 +0200 <smoge> arbitrary, because each measure will be unique structure
2023-06-26 21:48:22 +0200 <EvanR> is the idea to take a measure and map it to note times?
2023-06-26 21:48:43 +0200 <EvanR> that wouldn't require putting the tree structure back
2023-06-26 21:49:24 +0200 <EvanR> I'm half curious what python would do to help you out of this xD
2023-06-26 21:49:56 +0200 <smoge> the Ideia is that you separate the duration of the measure and a tree that describes how time is divided following  a (simple or nested) proportion
2023-06-26 21:50:30 +0200 <EvanR> yeah that's representing something, but then what
2023-06-26 21:50:42 +0200 <EvanR> draw a picture, play a song or
2023-06-26 21:50:53 +0200 <EvanR> edit it with an editor
2023-06-26 21:51:14 +0200 <smoge> it can be divided into four equal parts (1 1 1 1), or the second element can be subdivided into 3 parts (1 (1 (1 1 1) 1 1)
2023-06-26 21:51:26 +0200 <smoge> that's the lisp data structure
2023-06-26 21:51:47 +0200 <smoge> (1 (1 (1 1 1)) 1 1)
2023-06-26 21:51:57 +0200 <EvanR> what would (1 2 1 1) mean
2023-06-26 21:52:07 +0200 <EvanR> 5 parts?
2023-06-26 21:52:24 +0200falafel(~falafel@2607:fb91:86c:d890:7062:4878:f4c6:58e7) (Remote host closed the connection)
2023-06-26 21:52:48 +0200falafel(~falafel@2607:fb91:86c:d890:5415:7177:e51d:b764)
2023-06-26 21:53:56 +0200 <smoge> Would mean 4 durations, the second is twice as long. The durations, in this case, would be adjusted to fir the same measure. Probably a "tuplet" 5-in-the-time-of-4
2023-06-26 21:54:09 +0200 <smoge> fit
2023-06-26 21:54:10 +0200 <probie> If I remember from the docs last time this what brought up, `(1 2 1 1)` means that in one unit of time (determined by context), there are 4 notes, with the second being twice as long as the other 3
2023-06-26 21:54:26 +0200 <probie> s/what brought up/was brought up/
2023-06-26 21:54:37 +0200 <smoge> yeah that's correct
2023-06-26 21:54:47 +0200Typedfern(~Typedfern@60.red-83-37-32.dynamicip.rima-tde.net) (Ping timeout: 245 seconds)
2023-06-26 21:54:49 +0200 <EvanR> ok that's the same as what I was thinking
2023-06-26 21:54:59 +0200 <EvanR> same measure, divided into 5 parts, second note takes two of them
2023-06-26 21:55:08 +0200ec_(~ec@gateway/tor-sasl/ec)
2023-06-26 21:56:11 +0200 <smoge> yes. The idea is that you can manipulate the "proportions" in abstract, since they could be, for example, applied to another measure (longer of shorter) etc
2023-06-26 21:56:41 +0200 <smoge> the idea is that you can do different kinds of rhythm variations with this data structure
2023-06-26 21:56:57 +0200 <EvanR> so what does the rotate operation represent, or is it like the act of playing through the measure before looping
2023-06-26 21:57:39 +0200 <smoge> but if haskell don't like changing the structure at all by default, maybe there is an alternative way to do it
2023-06-26 21:58:22 +0200 <smoge> the rotation operation creates a new rhythm inside the measure, it's one of the most abstract, actually
2023-06-26 21:59:00 +0200 <EvanR> alright, discarding what I was thinking. So you want to edit a piece of your tree
2023-06-26 21:59:12 +0200 <geekosaur> art of the fugue?
2023-06-26 22:00:07 +0200 <ncf> contrapuntal functor
2023-06-26 22:00:33 +0200 <ncf> parametric polyrhythm
2023-06-26 22:00:36 +0200 <ncf> etc.
2023-06-26 22:00:36 +0200 <EvanR> MonadFugueState
2023-06-26 22:00:37 +0200 <smoge> yes, I want to take of one number and replace with a subdivision. or find all combination of a set of numbers that the sum is always x, etc
2023-06-26 22:00:39 +0200ft(~ft@p508db151.dip0.t-ipconnect.de)
2023-06-26 22:00:42 +0200 <smoge> all sorts of things
2023-06-26 22:00:58 +0200 <EvanR> ok haskell can do that
2023-06-26 22:01:22 +0200 <EvanR> on the first part, the key is specifying which place you want to make the edit at
2023-06-26 22:01:36 +0200 <probie> Prelude in C--?
2023-06-26 22:01:47 +0200chromoblob(~user@37.113.180.121) (Ping timeout: 264 seconds)
2023-06-26 22:01:52 +0200 <jade[m]> huh?
2023-06-26 22:02:17 +0200 <EvanR> you could use a sort of path like xpath, or upgrade to zippers. A zipper is like a cursor into your structure where you want to make an edit
2023-06-26 22:02:30 +0200 <smoge> can you point out some material that might shed some light?
2023-06-26 22:02:56 +0200 <EvanR> but if you never editing any haskell data structure before, maybe start by writing a function to edit a list
2023-06-26 22:02:57 +0200 <smoge> zipper sounds like it, I think
2023-06-26 22:03:18 +0200titibandit(~titibandi@user/titibandit)
2023-06-26 22:03:51 +0200 <smoge> ok, I'll practice with lists first
2023-06-26 22:03:58 +0200 <EvanR> everything I read about zippers is confusing, maybe someone has a good resource. But it's probably considered more advanced
2023-06-26 22:04:18 +0200S11001001(sid42510@id-42510.ilkley.irccloud.com) (Server closed connection)
2023-06-26 22:04:28 +0200S11001001(sid42510@id-42510.ilkley.irccloud.com)
2023-06-26 22:04:51 +0200 <EvanR> very pedestrian, non-zipper list editor would have type (a -> a) -> Int -> [a] -> [a]
2023-06-26 22:05:15 +0200 <geekosaur> https://hackage.haskell.org/package/xmonad-0.17.2/docs/XMonad-StackSet.html#g:2 might be more approachable than other descriptions
2023-06-26 22:06:09 +0200 <geekosaur> since it doesn't go on and on about derivatives and one-hole contexts and such
2023-06-26 22:06:32 +0200 <jade[m]> https://wiki.haskell.org/Zipper
2023-06-26 22:06:32 +0200 <jade[m]> uses a tree as an example, if that is desirable
2023-06-26 22:09:22 +0200 <smoge> thank you!
2023-06-26 22:09:39 +0200Typedfern(~Typedfern@60.red-83-37-32.dynamicip.rima-tde.net)
2023-06-26 22:09:43 +0200geekosauropens, since list zippers he understands but has yet to wrap his head around how you zipper a tree
2023-06-26 22:11:39 +0200Techcable(~Techcable@user/Techcable)
2023-06-26 22:11:48 +0200 <EvanR> haha xmonad mentions mcbride derivative paper but doesn't put a link
2023-06-26 22:12:08 +0200 <EvanR> that's the only only zipper thing I actually understood
2023-06-26 22:12:11 +0200 <dolio> A list is a unary tree. So a zipper stores the node values above you, a focused value, and the list below you.
2023-06-26 22:12:26 +0200Techcable(~Techcable@user/Techcable) (Remote host closed the connection)
2023-06-26 22:12:40 +0200tromp(~textual@92.110.219.57)
2023-06-26 22:12:41 +0200 <dolio> A zipper for a binary tree stores the node values and branches you didn't follow above you, a focused value, and the tree below you.
2023-06-26 22:14:08 +0200 <dolio> Or ditch the 'focused value' part since it makes zippers undefined for empty structures.
2023-06-26 22:14:19 +0200Techcable(~Techcable@user/Techcable)
2023-06-26 22:15:19 +0200 <geekosaur> hm, I just checked and didn't see a good "primary" link for it, while filing a doc bug
2023-06-26 22:18:41 +0200 <geekosaur> researchgate claims you have to request an official copy from Conor, although various other outlets provide copies of it (notably strictlypositive.org)
2023-06-26 22:19:16 +0200 <dolio> If you get it from there, you are requesting it from Conor. :þ
2023-06-26 22:19:51 +0200 <jade[m]> ime finding papers is always a pain
2023-06-26 22:19:56 +0200 <jade[m]> so many paywalls and stuff
2023-06-26 22:26:09 +0200 <geekosaur> anyway I filed a doc bug, we should at least mention the title, if not provide a link
2023-06-26 22:27:15 +0200 <geekosaur> also while poking at this I found out the zipper page on the haskell wiki has a dead link (http://www.cs.nott.ac.uk/~ctm/)
2023-06-26 22:29:47 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-06-26 22:32:17 +0200taupiqueur(~taupiqueu@2a02-8440-2241-6bd3-291b-5a44-8bad-c57d.rev.sfr.net) (Ping timeout: 245 seconds)
2023-06-26 22:33:24 +0200user363627(~user@146.70.198.100) (Quit: Konversation terminated!)
2023-06-26 22:34:40 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0)
2023-06-26 22:37:17 +0200dipper(~dipper@203.168.26.139) (Ping timeout: 245 seconds)
2023-06-26 22:38:57 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:21c4:bb57:30a:20d0) (Ping timeout: 245 seconds)
2023-06-26 22:43:20 +0200chromoblob(~user@37.113.180.121)
2023-06-26 22:44:50 +0200titibandit(~titibandi@user/titibandit) (Remote host closed the connection)
2023-06-26 22:47:15 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-06-26 22:47:50 +0200chromoblob(~user@37.113.180.121) (Ping timeout: 250 seconds)
2023-06-26 22:49:20 +0200edwardk(sid47016@haskell/developer/edwardk) (Server closed connection)
2023-06-26 22:49:30 +0200edwardk(sid47016@haskell/developer/edwardk)
2023-06-26 22:51:50 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-06-26 22:53:44 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-06-26 22:55:11 +0200codaraxis(~codaraxis@user/codaraxis)
2023-06-26 22:58:33 +0200tromp(~textual@92.110.219.57) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-06-26 23:03:23 +0200__________(~nobody@user/noodly)
2023-06-26 23:04:11 +0200_________(~nobody@user/noodly) (Ping timeout: 264 seconds)
2023-06-26 23:06:54 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-06-26 23:07:58 +0200Guest9511(~finn@rul16-h01-176-151-21-224.dsl.sta.abo.bbox.fr)
2023-06-26 23:08:43 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-06-26 23:08:49 +0200danse-nr3(~francesco@151.35.32.192)
2023-06-26 23:10:12 +0200nut(~nut@176-151-21-224.abo.bbox.fr) (Ping timeout: 245 seconds)
2023-06-26 23:10:38 +0200___________________
2023-06-26 23:10:47 +0200 <janus> geekosaur: i fixed the link, thanks
2023-06-26 23:11:43 +0200 <janus> it doesn't actually seem to have had any papers on it though
2023-06-26 23:11:46 +0200 <janus> how rare
2023-06-26 23:13:07 +0200 <janus> but there are just tons of dead links on the haskell wiki
2023-06-26 23:13:39 +0200 <janus> it's amazing how the archive.is person/team had the foresight to archive these ten years ago
2023-06-26 23:13:52 +0200 <janus> somehow i find a lot more stuff archived with them than at the Internet Archive
2023-06-26 23:13:57 +0200 <janus> and the interface is better too
2023-06-26 23:14:28 +0200 <janus> there just to be a big discussion at Wikipedia where people would be afraid of using archive.is because it wasn't established like the Internet Archive
2023-06-26 23:14:45 +0200 <janus> we really should archive the archive...
2023-06-26 23:15:58 +0200 <darkling> Multiple copies is good.
2023-06-26 23:21:20 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Ping timeout: 240 seconds)
2023-06-26 23:23:47 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-06-26 23:32:24 +0200extor(~extor@ns3018124.ip-149-202-82.eu) (Remote host closed the connection)
2023-06-26 23:35:08 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-06-26 23:36:50 +0200falafel(~falafel@2607:fb91:86c:d890:5415:7177:e51d:b764) (Ping timeout: 258 seconds)
2023-06-26 23:37:46 +0200enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) (Quit: enoq)
2023-06-26 23:40:38 +0200smoge(~smoge@2603-7000-4b42-1100-dda0-def4-e62f-c2ea.res6.spectrum.com) (Ping timeout: 246 seconds)
2023-06-26 23:40:45 +0200siraben(~siraben@user/siraben) (Server closed connection)
2023-06-26 23:43:55 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-06-26 23:45:35 +0200Square2(~Square@user/square) (Ping timeout: 264 seconds)
2023-06-26 23:47:20 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-06-26 23:48:38 +0200catch22(~catch22@2406:3400:418:d7e0:67c:16ff:fe3e:b769)
2023-06-26 23:49:29 +0200kupi(uid212005@id-212005.hampstead.irccloud.com)
2023-06-26 23:51:58 +0200nick3(~nick@wsip-174-78-110-18.pn.at.cox.net) (Ping timeout: 252 seconds)
2023-06-26 23:53:05 +0200michalz(~michalz@185.246.207.201) (Remote host closed the connection)
2023-06-26 23:55:21 +0200bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-06-26 23:56:57 +0200gmg(~user@user/gehmehgeh) (Quit: Leaving)