IRCBrowse

2023/09/09

2023-09-09 00:01:31 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-09-09 00:04:35 +0200raym(~ray@user/raym) (Server closed connection)
2023-09-09 00:04:51 +0200raym(~ray@user/raym)
2023-09-09 00:19:02 +0200son0p(~ff@186.121.39.74) (Quit: Bye)
2023-09-09 00:22:39 +0200sm(~sm@plaintextaccounting/sm)
2023-09-09 00:25:02 +0200sinbad(~sinbad@user/sinbad) ()
2023-09-09 00:25:30 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 246 seconds)
2023-09-09 00:27:03 +0200sm(~sm@plaintextaccounting/sm) (Ping timeout: 248 seconds)
2023-09-09 00:31:15 +0200aaronv(~aaronv@user/aaronv)
2023-09-09 00:37:11 +0200libertyprime(~libertypr@203.96.203.44) (Ping timeout: 246 seconds)
2023-09-09 00:37:12 +0200ulysses4ever(~artem@2601:249:4380:8950:f474:e3f8:9806:671) (Read error: Connection reset by peer)
2023-09-09 00:37:20 +0200ulysses4ever(~artem@c-73-103-90-145.hsd1.in.comcast.net)
2023-09-09 00:41:48 +0200 <jackdk> It will instead crash your program if `findCabalFile` executes and generates a `Nothing`
2023-09-09 00:42:37 +0200 <geekosaur> the original probably did as well though
2023-09-09 00:42:54 +0200 <geekosaur> doesn't fail in IO throw?
2023-09-09 00:43:25 +0200 <geekosaur> % fail "foo"
2023-09-09 00:43:26 +0200 <yahb2> *** Exception: user error (foo)
2023-09-09 00:45:48 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 246 seconds)
2023-09-09 00:47:41 +0200 <jackdk> True, but the type system no longer forces you to care. I suppose you can consider that a good thing, or not.
2023-09-09 00:53:22 +0200libertyprime(~libertypr@203.96.203.44)
2023-09-09 00:56:08 +0200sm(~sm@plaintextaccounting/sm)
2023-09-09 01:00:07 +0200falafel(~falafel@62.175.113.194.dyn.user.ono.com) (Ping timeout: 248 seconds)
2023-09-09 01:00:49 +0200sm(~sm@plaintextaccounting/sm) (Ping timeout: 258 seconds)
2023-09-09 01:01:00 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-09-09 01:01:26 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 246 seconds)
2023-09-09 01:01:57 +0200son0p(~ff@186.121.39.74)
2023-09-09 01:03:46 +0200caryhartline(~caryhartl@168.182.58.169)
2023-09-09 01:08:43 +0200cyphase(~cyphase@user/cyphase) (Ping timeout: 255 seconds)
2023-09-09 01:10:41 +0200cyphase(~cyphase@user/cyphase)
2023-09-09 01:11:18 +0200Chioque(~mansur@88.125.49.60.jb03-home.tm.net.my)
2023-09-09 01:13:17 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Quit: Leaving.)
2023-09-09 01:13:22 +0200caryhartline(~caryhartl@168.182.58.169) (Quit: caryhartline)
2023-09-09 01:18:12 +0200Chioque(~mansur@88.125.49.60.jb03-home.tm.net.my) (Quit: WeeChat 4.0.4)
2023-09-09 01:19:19 +0200cptaffe(~ZNC@99-47-99-155.lightspeed.ltrkar.sbcglobal.net)
2023-09-09 01:22:01 +0200cptaffe(~ZNC@99-47-99-155.lightspeed.ltrkar.sbcglobal.net) (Client Quit)
2023-09-09 01:22:01 +0200cpt\iphone(~ZNC@2600:1700:f08:111f::18e7) (Quit: ZNC 1.8.2 - https://znc.in)
2023-09-09 01:22:01 +0200cpt\macbook(~ZNC@2600:1700:f08:111f::18e7) (Quit: ZNC 1.8.2 - https://znc.in)
2023-09-09 01:22:23 +0200cpt\iphone(~iPhone@99-47-99-155.lightspeed.ltrkar.sbcglobal.net)
2023-09-09 01:22:54 +0200cptaffe(~ZNC@2600:1700:f08:111f::18e7)
2023-09-09 01:23:02 +0200gmg(~user@user/gehmehgeh) (Quit: Leaving)
2023-09-09 01:23:49 +0200cpt\iphone(~iPhone@99-47-99-155.lightspeed.ltrkar.sbcglobal.net) (Client Quit)
2023-09-09 01:23:53 +0200cptaffe(~ZNC@2600:1700:f08:111f::18e7) (Client Quit)
2023-09-09 01:23:55 +0200cptaffe-(~ZNC@99-47-99-155.lightspeed.ltrkar.sbcglobal.net)
2023-09-09 01:24:22 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 01:24:58 +0200 <EvanR> crash early, crash often
2023-09-09 01:25:35 +0200 <institor> crash override
2023-09-09 01:26:19 +0200cptaffe-cptaffe
2023-09-09 01:27:19 +0200cyphase(~cyphase@user/cyphase) (Ping timeout: 248 seconds)
2023-09-09 01:28:36 +0200sm(~sm@plaintextaccounting/sm)
2023-09-09 01:32:06 +0200cyphase(~cyphase@user/cyphase)
2023-09-09 01:32:24 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 01:32:24 +0200JordiGH(~jordi@user/jordigh) (Ping timeout: 246 seconds)
2023-09-09 01:33:43 +0200stites(~stites@130.44.147.204) (Ping timeout: 248 seconds)
2023-09-09 01:34:15 +0200sm(~sm@plaintextaccounting/sm) (Ping timeout: 248 seconds)
2023-09-09 01:35:12 +0200stites(~stites@2607:fb91:dc9:6ccd:6a4b:9556:1e53:57eb)
2023-09-09 01:37:38 +0200powderhorn(~powderhor@207-153-12-54.static.fttp.usinternet.com) (Ping timeout: 245 seconds)
2023-09-09 01:38:21 +0200danza_(~francesco@151.43.250.219)
2023-09-09 01:43:35 +0200stefan-_(~cri@42dots.de) (Server closed connection)
2023-09-09 01:43:51 +0200stefan-_(~cri@42dots.de)
2023-09-09 01:47:56 +0200stites(~stites@2607:fb91:dc9:6ccd:6a4b:9556:1e53:57eb) (Read error: Connection reset by peer)
2023-09-09 01:48:16 +0200stites(~stites@130.44.147.204)
2023-09-09 01:49:53 +0200danza__(~francesco@151.37.121.223)
2023-09-09 01:52:27 +0200stites(~stites@130.44.147.204) (Ping timeout: 245 seconds)
2023-09-09 01:52:27 +0200danza_(~francesco@151.43.250.219) (Ping timeout: 245 seconds)
2023-09-09 01:52:40 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-09-09 01:52:41 +0200stites(~stites@2607:fb91:dc9:6ccd:6a4b:9556:1e53:57eb)
2023-09-09 01:52:55 +0200aaronv(~aaronv@user/aaronv) (Ping timeout: 248 seconds)
2023-09-09 01:53:39 +0200Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-09-09 01:54:00 +0200stites(~stites@2607:fb91:dc9:6ccd:6a4b:9556:1e53:57eb) (Read error: Connection reset by peer)
2023-09-09 01:54:32 +0200stites(~stites@130.44.147.204)
2023-09-09 01:54:52 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 258 seconds)
2023-09-09 01:54:59 +0200Lord_of_Life_Lord_of_Life
2023-09-09 02:02:06 +0200sm(~sm@plaintextaccounting/sm)
2023-09-09 02:06:45 +0200sm(~sm@plaintextaccounting/sm) (Ping timeout: 258 seconds)
2023-09-09 02:11:04 +0200aaronv(~aaronv@user/aaronv)
2023-09-09 02:15:51 +0200danza__(~francesco@151.37.121.223) (Ping timeout: 248 seconds)
2023-09-09 02:23:41 +0200 <hammond> there is composition and there is also decomposition.
2023-09-09 02:24:28 +0200 <hammond> im reading refactoring and it's almost about breaking up large functions into smaller ones.
2023-09-09 02:32:47 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 02:35:47 +0200sm(~sm@plaintextaccounting/sm)
2023-09-09 02:37:21 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 02:38:49 +0200caryhartline(~caryhartl@168.182.58.169)
2023-09-09 02:40:23 +0200sm(~sm@plaintextaccounting/sm) (Ping timeout: 248 seconds)
2023-09-09 02:42:03 +0200bilegeek(~bilegeek@2600:1008:b06c:4343:3be3:cb40:aeb0:813f)
2023-09-09 02:46:27 +0200JordiGH(~jordi@user/jordigh)
2023-09-09 02:47:39 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-09-09 02:48:18 +0200ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net) (Quit: WeeChat 4.0.3)
2023-09-09 02:48:23 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-09-09 02:49:04 +0200ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net)
2023-09-09 02:50:36 +0200Unode(~Unode@fg-ext-220.embl.de) (Server closed connection)
2023-09-09 02:50:49 +0200Unode(~Unode@fg-ext-220.embl.de)
2023-09-09 02:51:46 +0200jmdaemon(~jmdaemon@user/jmdaemon)
2023-09-09 02:51:52 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-09-09 02:51:52 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-09-09 02:51:52 +0200wroathe(~wroathe@user/wroathe)
2023-09-09 02:56:52 +0200Guest12(~Guest12@187.83.249.216.dyn.smithville.net)
2023-09-09 03:10:20 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 03:11:29 +0200sm(~sm@plaintextaccounting/sm)
2023-09-09 03:14:00 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 03:14:21 +0200 <segfaultfizzbuzz> i asked google bard to make a lockfree DAG in haskell, and it piped back some code and then said "This data structure is lockfree because all of the operations are implemented using STM, which guarantees that they are thread-safe. "
2023-09-09 03:14:37 +0200 <EvanR> smart
2023-09-09 03:14:53 +0200 <segfaultfizzbuzz> jobs r safe right
2023-09-09 03:15:14 +0200 <segfaultfizzbuzz> if not maybe i should work on my ramen making skills or something
2023-09-09 03:16:08 +0200sm(~sm@plaintextaccounting/sm) (Ping timeout: 258 seconds)
2023-09-09 03:16:20 +0200absence(torgeihe@hildring.pvv.ntnu.no) (Server closed connection)
2023-09-09 03:16:28 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 03:16:31 +0200absence(torgeihe@hildring.pvv.ntnu.no)
2023-09-09 03:18:55 +0200mysl(~mysl@user/mysl) (Quit: Lost terminal)
2023-09-09 03:19:51 +0200td_(~td@i53870905.versanet.de) (Ping timeout: 248 seconds)
2023-09-09 03:21:52 +0200td_(~td@i53870933.versanet.de)
2023-09-09 03:23:03 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 248 seconds)
2023-09-09 03:24:03 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-09 03:28:55 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 248 seconds)
2023-09-09 03:29:18 +0200libertyprime(~libertypr@203.96.203.44) (Ping timeout: 246 seconds)
2023-09-09 03:29:29 +0200sm(~sm@plaintextaccounting/sm)
2023-09-09 03:29:46 +0200_xor0_xor
2023-09-09 03:30:43 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 03:33:43 +0200sm(~sm@plaintextaccounting/sm) (Ping timeout: 248 seconds)
2023-09-09 03:37:12 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 255 seconds)
2023-09-09 03:37:22 +0200todi(~todi@p4fd1ab34.dip0.t-ipconnect.de) (Ping timeout: 244 seconds)
2023-09-09 03:37:50 +0200stackdroid18(14094@de1.hashbang.sh)
2023-09-09 03:37:51 +0200todi(~todi@p5dca5c94.dip0.t-ipconnect.de)
2023-09-09 03:40:24 +0200libertyprime(~libertypr@203.96.203.44)
2023-09-09 03:50:15 +0200otto_s(~user@p5de2ff65.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-09-09 03:51:53 +0200otto_s(~user@p4ff27ce7.dip0.t-ipconnect.de)
2023-09-09 03:52:03 +0200stackdroid18(14094@de1.hashbang.sh) (Quit: hasta la vista... tchau!)
2023-09-09 03:56:43 +0200aaronv(~aaronv@user/aaronv) (Ping timeout: 240 seconds)
2023-09-09 04:00:14 +0200aaronv(~aaronv@user/aaronv)
2023-09-09 04:03:07 +0200finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-09-09 04:03:07 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-09-09 04:03:07 +0200finn_elijaFinnElija
2023-09-09 04:04:05 +0200sm(~sm@plaintextaccounting/sm)
2023-09-09 04:04:18 +0200Guest12(~Guest12@187.83.249.216.dyn.smithville.net) (Quit: Client closed)
2023-09-09 04:08:17 +0200ystael(~ystael@user/ystael) (Ping timeout: 245 seconds)
2023-09-09 04:10:28 +0200szkl(uid110435@id-110435.uxbridge.irccloud.com)
2023-09-09 04:10:48 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:1030:d66f:8de7:984f) (Remote host closed the connection)
2023-09-09 04:11:07 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:1030:d66f:8de7:984f)
2023-09-09 04:13:38 +0200sm(~sm@plaintextaccounting/sm) (Ping timeout: 258 seconds)
2023-09-09 04:13:45 +0200bratwurst(~blaadsfa@S010610561191f5d6.lb.shawcable.net)
2023-09-09 04:17:04 +0200ripspin(~chatzilla@1.145.242.125)
2023-09-09 04:17:08 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-09 04:20:28 +0200bratwurst(~blaadsfa@S010610561191f5d6.lb.shawcable.net) (Ping timeout: 248 seconds)
2023-09-09 04:20:36 +0200JordiGH(~jordi@user/jordigh) (Remote host closed the connection)
2023-09-09 04:22:32 +0200 <monochrom> No job is safe.
2023-09-09 04:23:32 +0200 <monochrom> Make no mistake. Just because you know that an LLM gives a wrong answer don't mean that your employer will agree with you.
2023-09-09 04:24:34 +0200 <monochrom> There is a reason flatearthers and antivaxxers exist. There is a reason homeopathy is actually profittable.
2023-09-09 04:26:24 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 04:26:42 +0200libertyprime(~libertypr@203.96.203.44) (Ping timeout: 246 seconds)
2023-09-09 04:26:49 +0200 <monochrom> Meanwhile science-based medical professionals are dropping out, indicating that they are not paid enough and so not even remotely close to being half profittable.
2023-09-09 04:26:59 +0200 <monochrom> Generally, if you are honest, your job is not safe.
2023-09-09 04:28:35 +0200Ranhir(~Ranhir@157.97.53.139) (Server closed connection)
2023-09-09 04:29:03 +0200Ranhir(~Ranhir@157.97.53.139)
2023-09-09 04:29:25 +0200waleee(~waleee@h-176-10-137-138.na.cust.bahnhof.se) (Ping timeout: 250 seconds)
2023-09-09 04:33:19 +0200thaumavorio(~thaumavor@thaumavor.io) (Quit: ZNC 1.8.2 - https://znc.in)
2023-09-09 04:33:29 +0200heath3(~heath@user/heath) (Server closed connection)
2023-09-09 04:33:48 +0200heath3(~heath@user/heath)
2023-09-09 04:34:31 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 04:34:37 +0200thaumavorio(~thaumavor@thaumavor.io)
2023-09-09 04:36:45 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 04:37:19 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-09-09 04:40:28 +0200Guest72(~Guest72@24.42.148.102)
2023-09-09 04:41:37 +0200Guest72(~Guest72@24.42.148.102) (Client Quit)
2023-09-09 04:44:35 +0200sm(~sm@plaintextaccounting/sm)
2023-09-09 04:48:54 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 04:50:20 +0200td_(~td@i53870933.versanet.de) (Ping timeout: 246 seconds)
2023-09-09 04:52:29 +0200td_(~td@i5387093E.versanet.de)
2023-09-09 04:52:57 +0200sm(~sm@plaintextaccounting/sm) (Ping timeout: 246 seconds)
2023-09-09 05:02:52 +0200 <EvanR> unless you're tenured?
2023-09-09 05:03:13 +0200libertyprime(~libertypr@203.96.203.44)
2023-09-09 05:03:17 +0200 <geekosaur> they can revoke tenure
2023-09-09 05:03:50 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 05:08:27 +0200ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net) (Ping timeout: 258 seconds)
2023-09-09 05:10:17 +0200ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net)
2023-09-09 05:17:15 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 05:19:19 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 248 seconds)
2023-09-09 05:20:39 +0200 <EvanR> *they can't fire all of us*
2023-09-09 05:21:39 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 05:29:19 +0200 <monochrom> The bar for revoking tenure is extremely high.
2023-09-09 05:29:56 +0200 <probie> they just need to lower the bar first
2023-09-09 05:31:45 +0200 <monochrom> Academia moves much more slowly than industry about this. One of the rare cases that an echo chamber actually has benefits: the profs themselves make the rules, so of course they make the rules to favour their tenure keeping!
2023-09-09 05:32:34 +0200 <monochrom> Sadly politicians and parliaments work the same way. >:)
2023-09-09 05:32:35 +0200aforemny_(~aforemny@2001:9e8:6cc4:ca00:285c:4ef6:5a4b:f825)
2023-09-09 05:32:51 +0200aforemny(~aforemny@i59F516ED.versanet.de) (Ping timeout: 246 seconds)
2023-09-09 05:34:31 +0200AmyMalikMelanieMalik
2023-09-09 05:36:04 +0200 <segfaultfizzbuzz> can somebody please please get the programmers are also human guy to mock haskellers
2023-09-09 05:37:30 +0200 <monochrom> Space, the final delimiter.
2023-09-09 05:40:50 +0200 <segfaultfizzbuzz> not a bad start
2023-09-09 05:41:05 +0200 <segfaultfizzbuzz> these are the voyages of the typesafe enterprise?
2023-09-09 05:49:35 +0200hiredman(~hiredman@frontier1.downey.family) (Server closed connection)
2023-09-09 06:01:35 +0200GoldsteinQ(~goldstein@goldstein.rs) (Server closed connection)
2023-09-09 06:01:55 +0200captnemo(~captnemo@193.32.127.239)
2023-09-09 06:01:55 +0200GoldsteinQ(~goldstein@goldstein.rs)
2023-09-09 06:01:58 +0200captnemo(~captnemo@193.32.127.239) (Client Quit)
2023-09-09 06:04:23 +0200bilegeek(~bilegeek@2600:1008:b06c:4343:3be3:cb40:aeb0:813f) (Quit: Leaving)
2023-09-09 06:11:35 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 248 seconds)
2023-09-09 06:13:00 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 06:17:59 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 06:21:17 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 258 seconds)
2023-09-09 06:31:51 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 06:33:21 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 250 seconds)
2023-09-09 06:43:01 +0200seeg123456(~seeg12345@64.176.64.83) (Quit: Gateway shutdown)
2023-09-09 06:43:02 +0200robobub(uid248673@id-248673.uxbridge.irccloud.com)
2023-09-09 06:50:13 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 240 seconds)
2023-09-09 06:53:32 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 06:54:06 +0200sm(~sm@plaintextaccounting/sm)
2023-09-09 06:55:46 +0200migas6(~migas@astra4961.startdedicated.net) (Quit: Ping timeout (120 seconds))
2023-09-09 06:56:04 +0200migas(~migas@astra4961.startdedicated.net)
2023-09-09 06:57:42 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 255 seconds)
2023-09-09 06:57:45 +0200hgolden(~hgolden@2603-8000-9d00-3ed1-fc05-5499-f77c-fbe5.res6.spectrum.com) (Remote host closed the connection)
2023-09-09 07:01:44 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 07:03:01 +0200erty(~user@user/aeroplane)
2023-09-09 07:04:06 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2023-09-09 07:07:50 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 07:08:44 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Read error: Connection reset by peer)
2023-09-09 07:09:29 +0200hgolden(~hgolden@2603-8000-9d00-3ed1-fc05-5499-f77c-fbe5.res6.spectrum.com)
2023-09-09 07:14:23 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 07:14:51 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 07:17:45 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 07:19:20 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 07:23:52 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 07:24:46 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Read error: Connection reset by peer)
2023-09-09 07:27:45 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 07:30:06 +0200hiredman(~hiredman@frontier1.downey.family)
2023-09-09 07:30:54 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 07:31:41 +0200aaronv(~aaronv@user/aaronv) (Ping timeout: 246 seconds)
2023-09-09 07:31:46 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Read error: Connection reset by peer)
2023-09-09 07:32:06 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 255 seconds)
2023-09-09 07:34:14 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 07:37:54 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 07:40:07 +0200libertyprime(~libertypr@203.96.203.44) (Ping timeout: 248 seconds)
2023-09-09 07:41:47 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 07:47:55 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 07:48:48 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Read error: Connection reset by peer)
2023-09-09 07:49:05 +0200aaronv(~aaronv@user/aaronv)
2023-09-09 07:51:19 +0200aaronv(~aaronv@user/aaronv) (Client Quit)
2023-09-09 07:51:54 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 07:54:55 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 07:55:48 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 08:01:31 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 08:01:55 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 08:02:49 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 08:04:49 +0200idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-09-09 08:06:06 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 255 seconds)
2023-09-09 08:08:56 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 08:09:50 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 08:15:57 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 08:16:45 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-09-09 08:16:50 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 08:20:02 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 08:22:57 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 08:31:51 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 08:34:34 +0200caryhartline(~caryhartl@168.182.58.169) (Quit: caryhartline)
2023-09-09 08:37:58 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 08:38:15 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 08:43:51 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 08:49:58 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 08:50:52 +0200tstat(~tstat@user/tstat) (Server closed connection)
2023-09-09 08:51:11 +0200tstat(~tstat@user/tstat)
2023-09-09 08:53:33 +0200acidjnk(~acidjnk@p200300d6e7072f47b0cfe67efeb6b056.dip0.t-ipconnect.de)
2023-09-09 08:54:03 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 08:56:34 +0200sm(~sm@plaintextaccounting/sm) (Quit: sm)
2023-09-09 08:56:37 +0200ripspin(~chatzilla@1.145.242.125) (Remote host closed the connection)
2023-09-09 08:57:46 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 09:02:24 +0200sm(~sm@plaintextaccounting/sm)
2023-09-09 09:06:23 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 09:09:50 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 09:10:10 +0200ent(entgod@kapsi.fi) (Server closed connection)
2023-09-09 09:10:24 +0200ent(entgod@kapsi.fi)
2023-09-09 09:11:19 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 09:13:24 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 09:13:47 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-09-09 09:16:26 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-09 09:17:05 +0200fendor(~fendor@2a02:8388:1640:be00:c785:45ab:c70:9d3f)
2023-09-09 09:17:59 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 09:21:12 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 245 seconds)
2023-09-09 09:22:20 +0200 <carbolymer> any ideas how to shrink OpenUnion into a narrower list of types? https://stackoverflow.com/questions/77071242/how-to-shrink-an-union-type-in-haskell
2023-09-09 09:22:59 +0200lisbeths(uid135845@id-135845.lymington.irccloud.com)
2023-09-09 09:23:14 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-09-09 09:26:47 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 09:27:01 +0200 <probie> carbolymer: does it have to have that exact type signature?
2023-09-09 09:28:39 +0200jackneill__(~Jackneill@20014C4E1E101A00392465011B960A73.dsl.pool.telekom.hu)
2023-09-09 09:29:18 +0200 <carbolymer> probie: nah, just shrinked union
2023-09-09 09:29:30 +0200 <carbolymer> probie: I guess that constraint is a formality
2023-09-09 09:29:46 +0200 <carbolymer> maybe redundant
2023-09-09 09:32:10 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 09:36:10 +0200 <lisbeths> None of the lambda calculus exercises on codewars are in pure lambda calculus
2023-09-09 09:36:15 +0200 <lisbeths> it is upsetting
2023-09-09 09:36:54 +0200 <lisbeths> these exercises should use the church encoding
2023-09-09 09:37:41 +0200 <lisbeths> they are just ordinary haskell exercised with *extra* lambdas
2023-09-09 09:38:46 +0200idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.0.2)
2023-09-09 09:43:18 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 09:44:55 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 248 seconds)
2023-09-09 09:51:54 +0200 <probie> carbolymer: https://paste.tomsmeding.com/KvbVvfWS should do the job (if at the point of use all types are known)
2023-09-09 09:54:12 +0200 <carbolymer> probie: looks good. Thanks a lot! I'll try it out later!
2023-09-09 09:59:58 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 10:04:16 +0200CiaoSen(~Jura@2a05:5800:2b2:1b00:664b:f0ff:fe37:9ef)
2023-09-09 10:08:36 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-09-09 10:10:27 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 10:15:40 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 250 seconds)
2023-09-09 10:15:52 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 10:21:18 +0200 <[Leary]> lisbeths: That's upsetting indeed! I wrote up a bunch of LC exercises a few years back but never got around to putting them anywhere---if that changes any time soon, I'll send you a link. They're not very inventive though, mostly just building basic tools with which to build slightly less basic tools.
2023-09-09 10:22:52 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 10:27:19 +0200neptun(neptun@2607:5300:60:5910:dcad:beff:feef:5bc) (Server closed connection)
2023-09-09 10:27:33 +0200neptun(neptun@2607:5300:60:5910:dcad:beff:feef:5bc)
2023-09-09 10:27:35 +0200gmg(~user@user/gehmehgeh)
2023-09-09 10:29:28 +0200emmanuelux(~emmanuelu@user/emmanuelux)
2023-09-09 10:29:38 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 10:32:54 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 10:33:48 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 244 seconds)
2023-09-09 10:48:27 +0200tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2023-09-09 10:51:32 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-09 10:52:26 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 10:53:13 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 10:53:23 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 10:53:54 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 11:09:29 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 11:09:48 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 11:12:20 +0200mrmr15(~mrmr@user/mrmr)
2023-09-09 11:12:44 +0200mrmr1(~mrmr@user/mrmr) (Read error: Connection reset by peer)
2023-09-09 11:12:44 +0200mrmr15mrmr1
2023-09-09 11:14:17 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 11:17:00 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-09-09 11:19:14 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 11:20:35 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:1030:d66f:8de7:984f) (Remote host closed the connection)
2023-09-09 11:22:02 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 11:23:12 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 11:23:28 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 258 seconds)
2023-09-09 11:33:31 +0200 <albet70> there's too few articles about alex and happy, is there a good tutorial about them?
2023-09-09 11:39:34 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-09-09 11:40:43 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-09 11:41:54 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 11:42:09 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 11:48:46 +0200 <Rembane> albet70: I've only seen a "this is how you get started"-article.
2023-09-09 11:50:30 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-09 11:53:15 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:1030:d66f:8de7:984f)
2023-09-09 11:54:16 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 11:54:16 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-09 11:58:33 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 246 seconds)
2023-09-09 12:01:18 +0200erty(~user@user/aeroplane) (ERC 5.4 (IRC client for GNU Emacs 28.2))
2023-09-09 12:04:38 +0200sm(~sm@plaintextaccounting/sm) (Quit: sm)
2023-09-09 12:12:05 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 12:13:31 +0200mysl(~mysl@user/mysl)
2023-09-09 12:15:16 +0200elevenkb(~elevenkb@105.226.98.41)
2023-09-09 12:15:28 +0200elevenkb(~elevenkb@105.226.98.41) (Client Quit)
2023-09-09 12:16:42 +0200chiselfuse(~chiselfus@user/chiselfuse) (Ping timeout: 246 seconds)
2023-09-09 12:17:16 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 12:18:01 +0200chiselfuse(~chiselfus@user/chiselfuse)
2023-09-09 12:24:23 +0200CiaoSen(~Jura@2a05:5800:2b2:1b00:664b:f0ff:fe37:9ef) (Ping timeout: 248 seconds)
2023-09-09 12:29:38 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 12:37:00 +0200L29Ah(~L29Ah@wikipedia/L29Ah) (Ping timeout: 255 seconds)
2023-09-09 12:38:39 +0200 <dminuoso> institor: Never underestimate the importance of cache, indeed.
2023-09-09 12:38:47 +0200 <dminuoso> Oh. I was scrolled back a few days it seems!
2023-09-09 12:39:14 +0200 <carbolymer> keep em conversations going
2023-09-09 12:40:30 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 12:44:20 +0200emmanuelux_(~emmanuelu@user/emmanuelux)
2023-09-09 12:44:23 +0200emmanuelux(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-09-09 12:44:50 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 246 seconds)
2023-09-09 12:45:27 +0200RSCASTILHO(~RSCASTILH@187.40.124.54)
2023-09-09 12:47:19 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 12:49:22 +0200RSCASTILHO(~RSCASTILH@187.40.124.54) ()
2023-09-09 12:50:16 +0200todi(~todi@p5dca5c94.dip0.t-ipconnect.de) (Ping timeout: 255 seconds)
2023-09-09 12:51:34 +0200todi(~todi@p5dca5c94.dip0.t-ipconnect.de)
2023-09-09 12:56:17 +0200tv(~tv@user/tv) (Quit: derp)
2023-09-09 12:56:33 +0200tv(~tv@user/tv)
2023-09-09 13:04:10 +0200wootehfoot(~wootehfoo@user/wootehfoot)
2023-09-09 13:05:45 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 13:10:30 +0200tomboy65(~tomboy64@user/tomboy64) (Ping timeout: 255 seconds)
2023-09-09 13:10:47 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 13:11:22 +0200siers(~ij@user/ij) (Server closed connection)
2023-09-09 13:11:43 +0200siers(~ij@user/ij)
2023-09-09 13:17:16 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 13:17:28 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-09-09 13:18:12 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-09 13:20:21 +0200_leo___(~emmanuelu@user/emmanuelux)
2023-09-09 13:21:50 +0200tomboy64(~tomboy64@user/tomboy64)
2023-09-09 13:22:13 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 13:22:54 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 246 seconds)
2023-09-09 13:22:59 +0200emmanuelux_(~emmanuelu@user/emmanuelux) (Ping timeout: 246 seconds)
2023-09-09 13:26:51 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 13:30:54 +0200sm(~sm@plaintextaccounting/sm)
2023-09-09 13:31:31 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 13:31:37 +0200sm(~sm@plaintextaccounting/sm) (Client Quit)
2023-09-09 13:35:04 +0200phma(~phma@2001:5b0:210f:2a18:ec08:5fa6:cd25:140c) (Read error: Connection reset by peer)
2023-09-09 13:35:41 +0200 <[exa]> albet70: tbh I didn't see much good ones, but I'd expect a lot of articles about flex&bison would port quite easily
2023-09-09 13:35:47 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 245 seconds)
2023-09-09 13:39:35 +0200dcoutts(~duncan@82-69-94-207.dsl.in-addr.zen.co.uk)
2023-09-09 13:41:24 +0200sefidel(~sefidel@user/sefidel) (Remote host closed the connection)
2023-09-09 13:42:02 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 245 seconds)
2023-09-09 13:42:10 +0200sefidel(~sefidel@user/sefidel)
2023-09-09 13:43:22 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-09-09 13:44:02 +0200 <carbolymer> probie: works, thanks a lot!
2023-09-09 13:44:10 +0200phma(~phma@2001:5b0:2144:6b88:455e:8c61:7388:36ab)
2023-09-09 13:45:20 +0200emmanuelux_(~emmanuelu@user/emmanuelux)
2023-09-09 13:45:33 +0200_leo___(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-09-09 14:00:15 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 14:04:54 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 14:05:29 +0200emmanuelux_(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-09-09 14:05:48 +0200emmanuelux_(~emmanuelu@user/emmanuelux)
2023-09-09 14:19:53 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 14:22:41 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 14:23:53 +0200_leo___(~emmanuelu@user/emmanuelux)
2023-09-09 14:24:47 +0200Lycurgus(~juan@user/Lycurgus)
2023-09-09 14:26:52 +0200emmanuelux_(~emmanuelu@user/emmanuelux) (Ping timeout: 248 seconds)
2023-09-09 14:27:00 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 255 seconds)
2023-09-09 14:31:35 +0200conjunctive(sid433686@id-433686.helmsley.irccloud.com) (Server closed connection)
2023-09-09 14:31:45 +0200conjunctive(sid433686@id-433686.helmsley.irccloud.com)
2023-09-09 14:34:18 +0200Lycurgus(~juan@user/Lycurgus) (Quit: Tschüss)
2023-09-09 14:37:17 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 14:38:13 +0200Taneb(~Taneb@2001:41c8:51:10d:aaaa:0:aaaa:0) (Server closed connection)
2023-09-09 14:38:27 +0200Taneb(~Taneb@runciman.hacksoc.org)
2023-09-09 14:44:30 +0200Guest13(~Guest17@49.140.189.123)
2023-09-09 14:45:50 +0200emmanuelux_(~emmanuelu@user/emmanuelux)
2023-09-09 14:47:27 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-09 14:48:36 +0200_leo___(~emmanuelu@user/emmanuelux) (Ping timeout: 255 seconds)
2023-09-09 15:00:45 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 15:01:11 +0200Guest13(~Guest17@49.140.189.123) (Quit: Client closed)
2023-09-09 15:03:45 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-09 15:05:33 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 250 seconds)
2023-09-09 15:10:56 +0200emmanuelux_(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-09-09 15:11:19 +0200emmanuelux_(~emmanuelu@user/emmanuelux)
2023-09-09 15:12:58 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 15:12:58 +0200ezzieygu1wuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 258 seconds)
2023-09-09 15:14:57 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 15:16:36 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-09-09 15:17:11 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 248 seconds)
2023-09-09 15:19:35 +0200Adeon(sid418992@id-418992.lymington.irccloud.com) (Server closed connection)
2023-09-09 15:19:44 +0200Adeon(sid418992@id-418992.lymington.irccloud.com)
2023-09-09 15:19:54 +0200szkl(uid110435@id-110435.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-09-09 15:20:15 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-09 15:28:49 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 15:29:14 +0200nvaxplus(~nvaxplus@user/nvaxplus)
2023-09-09 15:32:00 +0200 <nvaxplus> join #offtopia
2023-09-09 15:32:04 +0200nvaxplus(~nvaxplus@user/nvaxplus) ()
2023-09-09 15:34:03 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 15:34:30 +0200stites(~stites@130.44.147.204) (Ping timeout: 246 seconds)
2023-09-09 15:35:19 +0200stites(~stites@2607:fb91:dc6:4800:fbd5:4720:a3b4:a0d2)
2023-09-09 15:37:25 +0200 <carbolymer> no
2023-09-09 15:37:30 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 15:37:49 +0200_leo___(~emmanuelu@user/emmanuelux)
2023-09-09 15:38:09 +0200emmanuelux_(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-09-09 15:42:15 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 15:44:31 +0200mjs2600_(~mjs2600@c-174-169-225-239.hsd1.vt.comcast.net)
2023-09-09 15:44:36 +0200mjs2600(~mjs2600@c-174-169-225-239.hsd1.vt.comcast.net) (Read error: Connection reset by peer)
2023-09-09 15:44:41 +0200L29Ah(~L29Ah@wikipedia/L29Ah)
2023-09-09 15:44:59 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-09 15:45:48 +0200mysl(~mysl@user/mysl) (Ping timeout: 248 seconds)
2023-09-09 15:47:38 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 15:47:56 +0200mysl(~mysl@user/mysl)
2023-09-09 15:48:50 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 15:52:00 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 246 seconds)
2023-09-09 15:52:54 +0200ripspin(~chatzilla@1.145.231.215)
2023-09-09 15:52:55 +0200CiaoSen(~Jura@2a05:5800:2b2:1b00:664b:f0ff:fe37:9ef)
2023-09-09 15:53:31 +0200wootehfoot(~wootehfoo@user/wootehfoot) (Quit: Leaving)
2023-09-09 15:53:45 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 15:56:49 +0200wootehfoot(~wootehfoo@user/wootehfoot)
2023-09-09 15:58:47 +0200jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 248 seconds)
2023-09-09 16:00:43 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 16:01:54 +0200Buliarous(~gypsydang@46.232.210.139) (Server closed connection)
2023-09-09 16:02:03 +0200Buliarous(~gypsydang@46.232.210.139)
2023-09-09 16:02:31 +0200jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) (Quit: Textual IRC Client: www.textualapp.com)
2023-09-09 16:03:03 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 248 seconds)
2023-09-09 16:03:41 +0200wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2023-09-09 16:04:47 +0200emmanuelux_(~emmanuelu@user/emmanuelux)
2023-09-09 16:05:16 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-09-09 16:05:32 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 16:07:34 +0200_leo___(~emmanuelu@user/emmanuelux) (Ping timeout: 244 seconds)
2023-09-09 16:09:31 +0200 <glguy> albet70: I don't know any articles but I have examples. What kinds of things are you looking to learn if an article did exist?
2023-09-09 16:12:12 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 16:17:15 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 16:17:59 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 16:23:06 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 16:24:21 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-09 16:28:43 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 16:31:03 +0200Natch(~natch@c-9e07225c.038-60-73746f7.bbcust.telenor.se) (Read error: Connection reset by peer)
2023-09-09 16:31:33 +0200emmanuelux_(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-09-09 16:31:48 +0200emmanuelux_(~emmanuelu@user/emmanuelux)
2023-09-09 16:32:54 +0200blomberg(~default_u@59.99.23.99)
2023-09-09 16:33:00 +0200 <blomberg> hi
2023-09-09 16:33:18 +0200 <blomberg> i can't change my list as a database issue
2023-09-09 16:33:18 +0200 <glguy> Hi
2023-09-09 16:33:28 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-09 16:33:29 +0200 <blomberg> i prefer using list as a db
2023-09-09 16:33:48 +0200 <blomberg> i don't have a literal db ofc, just a thought exercise
2023-09-09 16:34:24 +0200 <blomberg> i have a list of flowers and their characteristics , say in a database in a list ,,now how to change them.
2023-09-09 16:34:40 +0200 <blomberg> now i need mutation?
2023-09-09 16:35:19 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-09 16:35:27 +0200 <probie> Return a new list with changed items
2023-09-09 16:36:25 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 16:36:35 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 16:37:02 +0200 <geekosaur> monads sound scary but are actually quite simple
2023-09-09 16:37:05 +0200 <geekosaur> whoops
2023-09-09 16:37:20 +0200 <geekosaur> focus not following eyes…
2023-09-09 16:38:27 +0200 <[exa]> blomberg: why not have a `Map String SomeCharacteristic` or so? lists ain't very good for storing "named" information
2023-09-09 16:40:54 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 250 seconds)
2023-09-09 16:41:31 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-09 16:42:18 +0200 <blomberg> [exa]:list can storing arbitrary info using nesting
2023-09-09 16:43:06 +0200 <blomberg> probie: l has changed then?
2023-09-09 16:44:25 +0200 <blomberg> probie:how can i just return a new list and not save it in a variable; l=f();now i returned the new list but l has changed
2023-09-09 16:44:37 +0200 <[exa]> blomberg: is it still going to type well with arbitrary nesting?
2023-09-09 16:44:48 +0200 <mauke> are you in the right channel?
2023-09-09 16:45:18 +0200 <blomberg> geekosaur: so we need monads for that. mauke type what
2023-09-09 16:45:40 +0200 <blomberg> changing a list is my problem
2023-09-09 16:45:49 +0200 <mauke> no, it isn't
2023-09-09 16:46:01 +0200 <blomberg> database always changes
2023-09-09 16:46:07 +0200 <blomberg> but list=db
2023-09-09 16:46:12 +0200 <geekosaur> blomberg, my comment was intended for elsewhere and not related to your question
2023-09-09 16:46:21 +0200 <mauke> is this python?
2023-09-09 16:46:46 +0200 <[exa]> blomberg: what does your app look like now?
2023-09-09 16:46:53 +0200 <blomberg> i am asking what's the haskell way
2023-09-09 16:47:08 +0200 <mauke> stop trying to change things
2023-09-09 16:47:22 +0200 <blomberg> to change variables list
2023-09-09 16:47:40 +0200 <geekosaur> passing the list around to where it's needed, instead of using mutable variables. (you can get mutable variables in IO or ST but you usually don't actually need them)
2023-09-09 16:47:48 +0200 <blomberg> but db changes with time; it's not my fault
2023-09-09 16:47:56 +0200 <[exa]> blomberg: you can just replace the item
2023-09-09 16:48:03 +0200 <blomberg> how
2023-09-09 16:48:04 +0200 <mauke> there is no time, either
2023-09-09 16:48:09 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 16:48:16 +0200 <[exa]> blomberg: typically you would have a list with [("flower1", something), ("flower2", something_else)]
2023-09-09 16:48:45 +0200 <geekosaur> monads make that passing easier but are not necessary
2023-09-09 16:48:48 +0200 <[exa]> blomberg: then there are nice functions for removing e.g. the "flower2" entry from the list and adding another
2023-09-09 16:48:51 +0200 <geekosaur> (specifically State)
2023-09-09 16:49:33 +0200 <[exa]> blomberg: and you keep the changing list together with your code structure all the time, so that you don't need the mutability
2023-09-09 16:50:20 +0200 <blomberg> [exa]:"keep changing list together" - what is meant
2023-09-09 16:51:05 +0200 <[exa]> blomberg: that you don't make a "global variable" with the list but pass it around as it changes
2023-09-09 16:51:40 +0200 <blomberg> geekosaur: how can i pass the list around to where it's neeeded - it now has a variable name reference attached to it
2023-09-09 16:52:02 +0200 <mauke> ? ??
2023-09-09 16:52:28 +0200 <blomberg> "pass it around" is too vague
2023-09-09 16:52:37 +0200Natch(~natch@c-9e07225c.038-60-73746f7.bbcust.telenor.se)
2023-09-09 16:52:38 +0200 <mauke> why?
2023-09-09 16:52:59 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 16:53:11 +0200 <blomberg> because i can't read their minds mauke
2023-09-09 16:53:45 +0200 <mauke> what does it mean to attach "a varaible name reference"?
2023-09-09 16:54:28 +0200 <blomberg> mauke: a global variable is the name attached to it; so how can i avoid that using passing it around
2023-09-09 16:54:45 +0200 <mauke> why do you have a global variable?
2023-09-09 16:54:48 +0200 <mauke> use a local variable
2023-09-09 16:55:21 +0200 <blomberg> hmm
2023-09-09 16:55:58 +0200 <mauke> and pass it to functions as a parameter
2023-09-09 16:56:10 +0200 <geekosaur[c]> You do things in functions. Instead of mutable variables you have function parameters that change with each call, and a result that likewise changes. So your list is a parameter
2023-09-09 16:56:12 +0200 <blomberg> ok then where will i store the list, and access it? access is global
2023-09-09 16:56:34 +0200 <mauke> access is not global
2023-09-09 16:56:44 +0200 <mauke> access is wherever you access it, which is a specific point in your code
2023-09-09 16:57:20 +0200 <blomberg> so the flower list is in a function ?? now it's inside i can't scope is different
2023-09-09 16:58:15 +0200 <blomberg> it's a storage issue it's not transient that i can pass it to a function and then just get a return value, because of storage and access
2023-09-09 16:58:19 +0200_leo___(~emmanuelu@user/emmanuelux)
2023-09-09 16:58:47 +0200 <mauke> you're not making sense
2023-09-09 16:58:52 +0200 <blomberg> flower is a name that is accessible in global scope, that's the problem, if it's inside funcTION I CANT
2023-09-09 16:58:59 +0200 <mauke> exactly
2023-09-09 16:59:04 +0200 <mauke> that's not a problem, that's the solution
2023-09-09 16:59:08 +0200 <mauke> stop using a global variable
2023-09-09 16:59:25 +0200 <mauke> if a function needs access to it, pass it as a parameter
2023-09-09 16:59:30 +0200 <blomberg> yes i will then`I LOST FLOWER VARIABLE
2023-09-09 16:59:36 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 16:59:42 +0200 <mauke> how are you losing parameters?
2023-09-09 17:00:15 +0200 <blomberg> ? because parameters need to be fed via global variables
2023-09-09 17:00:22 +0200 <mauke> that makes no sense
2023-09-09 17:00:24 +0200 <mauke> > (\thing -> "the thing is " <> show thing) 42
2023-09-09 17:00:25 +0200 <lambdabot> "the thing is 42"
2023-09-09 17:01:16 +0200emmanuelux_(~emmanuelu@user/emmanuelux) (Ping timeout: 250 seconds)
2023-09-09 17:01:22 +0200stites(~stites@2607:fb91:dc6:4800:fbd5:4720:a3b4:a0d2) (Read error: Connection reset by peer)
2023-09-09 17:01:41 +0200stites(~stites@130.44.147.204)
2023-09-09 17:02:48 +0200 <blomberg> 42 is not the "name"
2023-09-09 17:03:07 +0200 <mauke> true, but irrelevant
2023-09-09 17:03:15 +0200 <blomberg> bro what if i have a database of flowers then how it's a value
2023-09-09 17:03:27 +0200 <mauke> I don't know; that was your idea
2023-09-09 17:03:39 +0200 <blomberg> look i explained to you the problem 10 times, and you are beggining to troll me
2023-09-09 17:03:44 +0200 <mauke> > (\thing -> "the thing is " <> show thing) ["daisy", "daisy", "rose"]
2023-09-09 17:03:46 +0200 <lambdabot> "the thing is [\"daisy\",\"daisy\",\"rose\"]"
2023-09-09 17:03:57 +0200 <mauke> here's a list of flowers
2023-09-09 17:03:58 +0200 <mauke> or "database"
2023-09-09 17:04:16 +0200 <blomberg> yes that's a value that's a value and i can get a new value out
2023-09-09 17:04:25 +0200 <blomberg> i know that
2023-09-09 17:04:31 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 17:05:20 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 17:05:25 +0200 <blomberg> but my database variable is flower ??? and that's a name, so name is static but the values are changing
2023-09-09 17:05:31 +0200 <blomberg> that's the problem
2023-09-09 17:05:34 +0200 <mauke> it can't be changing
2023-09-09 17:05:37 +0200 <mauke> this is haskell
2023-09-09 17:05:59 +0200 <mauke> "how do I do the thing that is impossible?" is not a sensible question
2023-09-09 17:06:01 +0200 <blomberg> looks like you have not thought and don't care about real life
2023-09-09 17:06:33 +0200 <blomberg> "how do i avoid the mutation in a db list" - is a sensible one
2023-09-09 17:06:35 +0200 <mauke> I know, real life is all about flower databases and lists that magically change values
2023-09-09 17:07:00 +0200 <[exa]> blomberg: haskell was explicitly designed to avoid changey things when programming, to reach better goals. There are ways to do that (e.g. State monad) but these still just simulate the changes in immutable environment
2023-09-09 17:07:33 +0200 <mauke> if you start with a global variable like 'flowers = [...]', there's nowhere to go
2023-09-09 17:07:56 +0200 <geekosaur> blomberg, you are fixated on a single model for databases. there are other models that you are steadfastly refusing to consider
2023-09-09 17:08:10 +0200 <blomberg> mauke: yes, so where should i "store" the "value"
2023-09-09 17:08:32 +0200 <[exa]> blomberg: to store the value, you create a list that contains the value
2023-09-09 17:08:32 +0200 <[exa]> done
2023-09-09 17:08:36 +0200 <mauke> blomberg: I already told you
2023-09-09 17:08:43 +0200 <mauke> and you said I was trolling
2023-09-09 17:08:48 +0200 <mauke> so ... :shrug:
2023-09-09 17:09:19 +0200 <[exa]> blomberg: btw what's your previous programming language? (it might be easier to bridge this from a common ground)
2023-09-09 17:09:22 +0200 <blomberg> you said store inside local variable inside a function, now it's gone! function terminated
2023-09-09 17:09:27 +0200iteratee(~kyle@162.218.222.207) (Server closed connection)
2023-09-09 17:09:31 +0200 <blomberg> [exa]:python
2023-09-09 17:09:33 +0200 <[exa]> blomberg: it's not gone if the function returns it
2023-09-09 17:09:37 +0200iteratee(~kyle@162.218.222.207)
2023-09-09 17:09:59 +0200 <[exa]> ah nice. you can do the same in python without ever using a global variable
2023-09-09 17:10:21 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 17:10:34 +0200 <blomberg> [exa]: but .... i want to be able to type flower as a user and get the db, all i got is the value
2023-09-09 17:10:44 +0200 <blomberg> their is no reference
2023-09-09 17:10:52 +0200 <blomberg> via name
2023-09-09 17:10:53 +0200 <mauke> haskell doesn't have references
2023-09-09 17:10:57 +0200 <geekosaur> in xmonad, we pass the global state (XState) everywhere, using the State monad to simplify the code but it can be done without, just always pass the state as a parameter and return the new state as a result
2023-09-09 17:10:59 +0200 <[exa]> that's good, references are shady
2023-09-09 17:11:25 +0200 <[exa]> technically the "flower" name is the reference
2023-09-09 17:11:33 +0200 <[exa]> because it allows you to both reach your value, and change it
2023-09-09 17:11:37 +0200 <mauke> <blomberg> you said store inside local variable inside a function, now it's gone! function terminated <- so don't have the function terminate
2023-09-09 17:12:03 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-09 17:12:07 +0200 <[exa]> good approach too ^
2023-09-09 17:12:28 +0200 <mauke> returning is optional
2023-09-09 17:14:59 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-09-09 17:16:08 +0200 <blomberg> how is returning optional
2023-09-09 17:16:41 +0200 <mauke> just ... don't
2023-09-09 17:16:48 +0200 <blomberg> example
2023-09-09 17:16:52 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 17:17:16 +0200 <mauke> > let foo n = foo (n + 1) in foo 0
2023-09-09 17:17:23 +0200 <lambdabot> mueval-core: Time limit exceeded
2023-09-09 17:17:58 +0200 <mauke> > let foo flowers = foo ("daisy" : flowers) in foo []
2023-09-09 17:18:06 +0200 <lambdabot> mueval-core: Time limit exceeded
2023-09-09 17:18:06 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-09 17:18:08 +0200 <mauke> (pushing daisies)
2023-09-09 17:18:20 +0200 <[exa]> blomberg: here try this example: https://paste.tomsmeding.com/TE0UxL1b -- a complete listy database with user commands
2023-09-09 17:18:35 +0200 <[exa]> you can enter stuff like "set flower 10" and "get flower"
2023-09-09 17:19:06 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 246 seconds)
2023-09-09 17:19:51 +0200 <[exa]> blomberg: btw haskell has no stack that would overflow; actually if you have a function that doesn't return, calling it causes the information about the caller to disappear because it's no longer needed
2023-09-09 17:19:56 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-09 17:20:05 +0200 <[exa]> blomberg: so calling infinitely is perfectly OK and quite useful
2023-09-09 17:21:18 +0200emmanuelux_(~emmanuelu@user/emmanuelux)
2023-09-09 17:21:41 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 17:21:47 +0200_leo___(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-09-09 17:21:58 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 244 seconds)
2023-09-09 17:22:09 +0200 <blomberg> are you talking about mauke code or some other
2023-09-09 17:22:34 +0200 <[exa]> blomberg: check the link I posted
2023-09-09 17:22:42 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 17:24:12 +0200 <[exa]> segfaultfizzbuzz: re STG stuff we talked some time ago, I wanted to make the stuff clear for myself so actually implemented a tiny thing here https://gitea.blesmrt.net/exa/uskel
2023-09-09 17:24:33 +0200 <segfaultfizzbuzz> [exa]: awesome
2023-09-09 17:24:46 +0200 <[exa]> it is "spineful" but the only difference from spineless is that the "case" thunks and argument packs would be cared of by another stack
2023-09-09 17:24:55 +0200 <[exa]> and I don't want to manage that stuff in assembly
2023-09-09 17:25:00 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-09-09 17:25:36 +0200 <[exa]> especially not when the x86 push instruction is SO NICELY abused for making thunkgs
2023-09-09 17:26:02 +0200 <[exa]> and also no gc yet which is what I wanted to try next :D
2023-09-09 17:26:50 +0200 <blomberg> [exa]:will the paste link expire when?
2023-09-09 17:26:50 +0200 <segfaultfizzbuzz> nice,...
2023-09-09 17:27:09 +0200 <segfaultfizzbuzz> i probably can't understand the assembly but i will try to read it
2023-09-09 17:27:21 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-09 17:28:40 +0200 <blomberg> [exa]:when you said calling infinitenly is perfectly ok, did you mean your code or just plain infinite recursion
2023-09-09 17:28:45 +0200Everything(~Everythin@static.208.206.21.65.clients.your-server.de) (Server closed connection)
2023-09-09 17:28:54 +0200Everything(~Everythin@static.208.206.21.65.clients.your-server.de)
2023-09-09 17:29:26 +0200 <[exa]> blomberg: plain infinite recursion -- as long as your memory use stays checked, you can recurse as much as you want
2023-09-09 17:30:24 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 17:31:40 +0200 <segfaultfizzbuzz> i don't even know how to read this
2023-09-09 17:31:51 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 17:31:56 +0200 <segfaultfizzbuzz> unfortunately
2023-09-09 17:32:28 +0200 <segfaultfizzbuzz> i see like .thunkcode apply
2023-09-09 17:32:34 +0200 <[exa]> segfaultfizzbuzz: ok in short, I use %rbp as "pointer to current thunk" and %rsi as "continuation argument". Because I don't have the spiney stack, there are 2 "kinds" of thunk, one kind is the normal one as in haskell (you jump to its code with %rbp pointing to it, it will evaluate, change itself in place, and jump to the continuation you gave it in %rsi), the other kind is a "case" thunk which expects a
2023-09-09 17:32:40 +0200 <[exa]> forced value so that it can continue the computation (this comes in %rsi instd. of the continuation)
2023-09-09 17:34:31 +0200 <segfaultfizzbuzz> i am looking at for example .thunkcode apply
2023-09-09 17:35:11 +0200 <[exa]> segfaultfizzbuzz: this is a good starter https://gitea.blesmrt.net/exa/uskel/src/branch/master/print_123.s it makes 2 integer values for 100 (address goes to %r11) and 23 (address saved to %r12), then it makes a thunk that would add the 2 values (addr in %r11), another thunk that would print the result, and starts the evaluation with %rsi ("continuation" in this case) pointing to something that will exit
2023-09-09 17:35:11 +0200 <segfaultfizzbuzz> i guess apply is a program counter or something? i don't really read asm
2023-09-09 17:35:17 +0200 <[exa]> the process
2023-09-09 17:35:53 +0200 <segfaultfizzbuzz> i don't understand how "function arguments" work here
2023-09-09 17:35:58 +0200 <[exa]> the .thunkcode is a macro that wraps the code with a few annotation values that are used for guessing the thunk types (and would later be used for the GC)
2023-09-09 17:36:27 +0200 <blomberg> 7
2023-09-09 17:36:39 +0200 <segfaultfizzbuzz> there are no function arguments in this, everything is passed through the registers, i think?
2023-09-09 17:36:43 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-09 17:36:44 +0200 <[exa]> https://gitea.blesmrt.net/exa/uskel/src/branch/master/print_123.s#L17 -- e.g. this says "make me a thunk that computes function plus, 2 arguments, argument addresses are now in r11 and r12, and save the resulting thunk address to r11"
2023-09-09 17:36:49 +0200 <segfaultfizzbuzz> that or you have to manually set memory addresses...?
2023-09-09 17:37:08 +0200 <[exa]> yeah all arguments and everything are in addresses
2023-09-09 17:37:33 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 17:37:39 +0200 <[exa]> and when evaluating a thunk, you can "see" all off your arguments by examining the thunk
2023-09-09 17:37:43 +0200 <segfaultfizzbuzz> $plus is ... a string or a type defined somewhere or something?
2023-09-09 17:37:54 +0200 <blomberg> [exa]: send me more code to change the db and update it
2023-09-09 17:38:05 +0200 <[exa]> blomberg: left out for the reader as an exercise
2023-09-09 17:38:19 +0200 <blomberg> set rm get dump cmd [exa] ok
2023-09-09 17:38:44 +0200 <blomberg> but exercise is good , not my haskell
2023-09-09 17:38:59 +0200 <blomberg> i don't even know what is <> in mauke code
2023-09-09 17:39:11 +0200 <[exa]> blomberg: btw not sure about the timeout I put on my paste
2023-09-09 17:39:14 +0200 <[exa]> better save it
2023-09-09 17:39:20 +0200 <[exa]> <> is a monoid glue
2023-09-09 17:39:27 +0200 <[exa]> > "a" <> "b"
2023-09-09 17:39:28 +0200 <lambdabot> "ab"
2023-09-09 17:39:44 +0200 <[exa]> > ["a"] <> ["b"]
2023-09-09 17:39:45 +0200 <lambdabot> ["a","b"]
2023-09-09 17:39:49 +0200 <[exa]> glues stuff together
2023-09-09 17:40:08 +0200 <[exa]> segfaultfizzbuzz: $plus is the address of the plus thunk code
2023-09-09 17:40:10 +0200 <blomberg> > (\thing -> "the thing is " <> show thing) ["daisy", "diasy", "rose]
2023-09-09 17:40:12 +0200 <lambdabot> <hint>:1:69: error:
2023-09-09 17:40:12 +0200 <lambdabot> lexical error in string/character literal at end of input
2023-09-09 17:40:39 +0200 <[exa]> blomberg: you are missing a " and a map
2023-09-09 17:40:55 +0200 <probie> :t \x -> "foo" <> x
2023-09-09 17:40:56 +0200 <lambdabot> [Char] -> [Char]
2023-09-09 17:40:57 +0200_leo___(~emmanuelu@user/emmanuelux)
2023-09-09 17:41:00 +0200emmanuelux_(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-09-09 17:41:01 +0200 <[exa]> segfaultfizzbuzz: anyway the arguments are taken from the thunk e.g. here: https://gitea.blesmrt.net/exa/uskel/src/branch/master/fibs.s#L12
2023-09-09 17:41:02 +0200 <probie> :t \x -> "foo" ++ x
2023-09-09 17:41:03 +0200 <lambdabot> [Char] -> [Char]
2023-09-09 17:41:04 +0200 <mauke> don't need map
2023-09-09 17:42:09 +0200 <[exa]> segfaultfizzbuzz: %rbp points to the thunk in memory, first 2 words there are infoptr and "arity", and the 3rd and 4th are the 2 arguments it has, you take them out as 020(%rbp) and 030(%rbp)
2023-09-09 17:42:28 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-09 17:43:27 +0200 <[exa]> anyway yeah it's a hack on a hack but I actually somehow like it
2023-09-09 17:44:03 +0200 <blomberg> > (\thing -> "the thing is " <> show thing) ["daisy", "daisy", "rose"]
2023-09-09 17:44:05 +0200 <lambdabot> "the thing is [\"daisy\",\"daisy\",\"rose\"]"
2023-09-09 17:44:36 +0200 <blomberg> > (\thing -> "the thing is " <> show thing) ["daisy", "daisy", "rose]
2023-09-09 17:44:37 +0200 <lambdabot> <hint>:1:69: error:
2023-09-09 17:44:37 +0200 <lambdabot> lexical error in string/character literal at end of input
2023-09-09 17:44:46 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-09-09 17:45:07 +0200 <blomberg> ok missing "rose"
2023-09-09 17:45:12 +0200 <[exa]> blomberg: btw you can open a PM to lambdabot and evaluate stuff privately before you are sure there are no errors
2023-09-09 17:45:15 +0200 <segfaultfizzbuzz> [exa]: my original goal was sort of the opposite of this,...
2023-09-09 17:45:51 +0200 <segfaultfizzbuzz> [exa]: i wanted to write the simplest haskelly abstract machine, this is a concrete machine,... which is good
2023-09-09 17:45:55 +0200 <blomberg> [exa]: ok i also learnt state monad and xmonad is hell
2023-09-09 17:46:01 +0200 <[exa]> segfaultfizzbuzz: probably unrelated to the goal, just wanted to throw this to you in case it helps :D
2023-09-09 17:46:10 +0200 <[exa]> blomberg: state is pretty easy tbh
2023-09-09 17:46:17 +0200 <[exa]> blomberg: just needs some practice
2023-09-09 17:46:21 +0200 <segfaultfizzbuzz> [exa]: well yeah thanks i was just a bit worried that you thought this was what i was talking about
2023-09-09 17:46:37 +0200 <[exa]> haha no
2023-09-09 17:46:56 +0200 <[exa]> btw I actually fished out a pretty old paper with a much smoother explanation of the whole thing, lemme google
2023-09-09 17:47:19 +0200 <blomberg> [exa]: what's your cmd to set rm get dump
2023-09-09 17:47:19 +0200 <segfaultfizzbuzz> why in assembly are the register names fixed like this, why not redefine them based on the uh "function" or "most recent jump location?" or i don't even know
2023-09-09 17:48:34 +0200 <[exa]> segfaultfizzbuzz: https://dl.acm.org/doi/pdf/10.1145/99370.99385
2023-09-09 17:48:50 +0200 <[exa]> segfaultfizzbuzz: the registers are set by the CPU you use, no way to change them
2023-09-09 17:49:03 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 17:49:09 +0200 <[exa]> you can rename them with macros or so, which would be a good practice I'd say, but too lazy
2023-09-09 17:49:40 +0200 <[exa]> blomberg: what does that mean
2023-09-09 17:49:51 +0200 <segfaultfizzbuzz> but the registers could be "locally renamed" so that their meaning within a uh, context or whatever you want to call it could be more meaningful,... same for these other things which you are manually explaining,...
2023-09-09 17:50:08 +0200 <[exa]> yeah good point
2023-09-09 17:50:11 +0200 <[exa]> as I said, I was too lazy
2023-09-09 17:50:53 +0200 <[exa]> (unfortunately some of these aren't often possible, in x86 registers tend to have magic meanings)
2023-09-09 17:51:20 +0200 <segfaultfizzbuzz> primop2_ret_int ...? return something...?
2023-09-09 17:51:24 +0200 <mauke> %ax is the axxumulator, %bx is the bxxumulator, etc
2023-09-09 17:51:56 +0200 <segfaultfizzbuzz> i have deliberately avoided assembly,...
2023-09-09 17:52:20 +0200 <[exa]> segfaultfizzbuzz: that's a macro that generates the "returning part" of a primitive operation definition that simply returns an integer
2023-09-09 17:52:41 +0200 <[exa]> (btw I find assembly much easier than base TeX)
2023-09-09 17:53:27 +0200 <segfaultfizzbuzz> yeah well this is why i consider myself a bad programmer, or maybe not a programmer
2023-09-09 17:53:43 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 240 seconds)
2023-09-09 17:54:13 +0200 <segfaultfizzbuzz> ok,... but that macro isn't defined in the macros file
2023-09-09 17:54:30 +0200 <[exa]> yeah it's in primops.s afaik
2023-09-09 17:54:34 +0200 <segfaultfizzbuzz> and,... i am trying to read the thunkto macro and can't make sense of it,...
2023-09-09 17:54:43 +0200 <[exa]> which line?
2023-09-09 17:54:43 +0200 <segfaultfizzbuzz> i think i will end up wasting your time trying to decipher this
2023-09-09 17:54:47 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 17:54:48 +0200 <blomberg> [exa]:? how to use your functions
2023-09-09 17:55:02 +0200 <segfaultfizzbuzz> .macro thunkto reg:req,args:vararg
2023-09-09 17:55:14 +0200 <[exa]> blomberg: run the program, and type "set xxx 10" as a first line into it, and "dump" on a second line
2023-09-09 17:55:19 +0200 <segfaultfizzbuzz> i see pushq,... does asm have data structures or something?
2023-09-09 17:55:35 +0200marienz(~marienz@libera/staff/marienz) (Server closed connection)
2023-09-09 17:55:45 +0200marienz(~marienz@libera/staff/marienz)
2023-09-09 17:56:22 +0200 <[exa]> segfaultfizzbuzz: ah this. the .thunkto is a recursive macro. Basically by calling `.thunkto register, a, b, c, d` it does `pushq d; pushq c; pushq b; pushq a; mov %rsp, register`
2023-09-09 17:56:44 +0200 <[exa]> so basically pushes whatever you put there in memory conveniently and saves a pointer to that to a register of your choice
2023-09-09 17:57:02 +0200 <segfaultfizzbuzz> also it says armasm somewhere but i think you said this was x86...?
2023-09-09 17:57:11 +0200CiaoSen(~Jura@2a05:5800:2b2:1b00:664b:f0ff:fe37:9ef) (Ping timeout: 248 seconds)
2023-09-09 17:57:24 +0200 <[exa]> normally people use push/pop for managing the C-like stacks, I just don't have one so I can use push to make data easily
2023-09-09 17:57:48 +0200 <segfaultfizzbuzz> does asm have a queue data structure...?
2023-09-09 17:57:53 +0200 <[exa]> no
2023-09-09 17:58:22 +0200 <segfaultfizzbuzz> then pushq is...?
2023-09-09 17:58:23 +0200 <[exa]> it's directly for CPU, there's no data structures
2023-09-09 17:58:30 +0200 <[exa]> just memory and registers
2023-09-09 17:58:47 +0200 <segfaultfizzbuzz> ... i assume it has something to do with a queue...?
2023-09-09 17:59:09 +0200 <[exa]> pushq %reg does: 1] decrease %rsp by 8 2] copy whatever is in %reg into memory at address %rsp
2023-09-09 17:59:33 +0200 <geekosaur> q means quad iirc
2023-09-09 17:59:43 +0200 <[exa]> qword or so, yes
2023-09-09 17:59:48 +0200 <geekosaur> asm needs sized operations
2023-09-09 17:59:51 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 17:59:52 +0200 <albet70> glguy , scheme
2023-09-09 18:00:22 +0200 <geekosaur> pushb?, pushw, pushd, pushq
2023-09-09 18:00:37 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 18:00:39 +0200 <segfaultfizzbuzz> ... i mean, this is trying to make a stack, i guess...?
2023-09-09 18:00:40 +0200_leo___(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-09-09 18:00:42 +0200 <geekosaur> byte word doubleword quadword
2023-09-09 18:00:51 +0200_leo___(~emmanuelu@user/emmanuelux)
2023-09-09 18:00:59 +0200 <EvanR> nibble
2023-09-09 18:01:10 +0200 <[exa]> segfaultfizzbuzz: no stack, just using the stacky instruction to copy the data to memory without having to compute the addresses myself with more instructions
2023-09-09 18:01:12 +0200 <EvanR> not sure about name for half-nibble
2023-09-09 18:01:19 +0200 <[exa]> hibble
2023-09-09 18:01:32 +0200 <segfaultfizzbuzz> i mean okay arguably the thunk/thunkto part of this is by far the most important and it is totally uncommented
2023-09-09 18:01:38 +0200 <[exa]> (actually bibit)
2023-09-09 18:01:54 +0200 <EvanR> bibbit
2023-09-09 18:02:07 +0200 <geekosaur> x86 and similar don't really do sub-byte. DEC processors used to do 3-bit subwords
2023-09-09 18:02:10 +0200 <EvanR> bitbit
2023-09-09 18:02:47 +0200 <EvanR> (Bit,Bit)
2023-09-09 18:02:52 +0200 <segfaultfizzbuzz> ifnb?
2023-09-09 18:05:21 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 18:05:44 +0200 <[exa]> segfaultfizzbuzz: that's the assembler macro syntax
2023-09-09 18:06:27 +0200 <[exa]> like here https://sourceware.org/binutils/docs-2.41/as/If.html
2023-09-09 18:07:08 +0200 <[exa]> segfaultfizzbuzz: btw if you don't like macros it might make more sense if you just read the result, `make` and `objdump -S somebinary`
2023-09-09 18:07:58 +0200 <segfaultfizzbuzz> i don't even know what it means to assemble or not assemble something
2023-09-09 18:08:32 +0200 <geekosaur> it just converts the textual format of cpu instructions into the binary format, expanding macros (when supported) as it goes
2023-09-09 18:08:57 +0200 <segfaultfizzbuzz> i will make an attempt at reading this but it is very difficult, it would be like i explained something to you in french and you need to go learn french for the first time
2023-09-09 18:09:43 +0200 <geekosaur> you will find that it is in fact a very simple language
2023-09-09 18:10:01 +0200 <segfaultfizzbuzz> okay so the thunkto recursively thunks all of its arguments
2023-09-09 18:10:01 +0200mud(~mud@user/kadoban)
2023-09-09 18:10:18 +0200 <segfaultfizzbuzz> and thunking is this pushq operation,... which i think is a stack essentially...?
2023-09-09 18:10:57 +0200 <segfaultfizzbuzz> and then after thunking all of the arguments, it changes the program counter to point at the first thunk
2023-09-09 18:11:07 +0200 <[exa]> people tended to use memory for stacking things so much that this (decrease and move) instruction combination got its own instruction and was named "push" for obvious reasons :]
2023-09-09 18:11:36 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 258 seconds)
2023-09-09 18:11:45 +0200 <[exa]> segfaultfizzbuzz: yeah something like that. You can check the `enter` macro, that does the thing
2023-09-09 18:11:51 +0200 <geekosaur> once the concept was invented, at least (see Algol)
2023-09-09 18:12:05 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 18:12:17 +0200 <segfaultfizzbuzz> why decrease %rsp by 8? everything is 64 bit here right? wouldn't it be decrease by 4...?
2023-09-09 18:12:28 +0200 <[exa]> 64bit values have 8 bytes
2023-09-09 18:12:32 +0200 <probie> the "q" in the instruction just means quadword (64-bits) and "d" means doubleword (32-bits). A "word" is 16 bits because x86 was originally a 16-bit instruction set
2023-09-09 18:12:36 +0200 <segfaultfizzbuzz> ay my bad right
2023-09-09 18:12:39 +0200 <geekosaur> divide 64 bits by 8 bits per byte
2023-09-09 18:12:49 +0200 <segfaultfizzbuzz> sorry i think my head is still in the 32 bit era lol
2023-09-09 18:12:55 +0200 <[exa]> btw I found the octal notation too good not to use for the offsets
2023-09-09 18:13:13 +0200 <[exa]> 000(%reg), 010(%reg), 020(%reg) <3
2023-09-09 18:13:20 +0200 <probie> so any time you see an x86 op ending with "q" think 64 bits, and "d" think 32 bits
2023-09-09 18:14:27 +0200 <segfaultfizzbuzz> offsets...?
2023-09-09 18:15:12 +0200 <[exa]> (%reg) means "memory at the register value", and some instructions also accept encoding like 123(%reg) which means "memory at the address of (register value + 123)"
2023-09-09 18:15:13 +0200 <segfaultfizzbuzz> okay yeah i am lost reading this
2023-09-09 18:15:20 +0200 <segfaultfizzbuzz> not having types hurts my head too
2023-09-09 18:15:23 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-09-09 18:15:35 +0200 <segfaultfizzbuzz> like just the thunkto .. $plus ..
2023-09-09 18:15:41 +0200 <[exa]> segfaultfizzbuzz: yeah, sadly this can't have types, computers don't have types
2023-09-09 18:15:42 +0200random-jellyfish(~random-je@user/random-jellyfish)
2023-09-09 18:15:46 +0200 <segfaultfizzbuzz> does $plus expand into multiple arguments?
2023-09-09 18:16:18 +0200 <[exa]> no it expands to the address of the "plus" label
2023-09-09 18:16:28 +0200 <[exa]> basically it becomes a function pointer for plus (if you like C)
2023-09-09 18:16:42 +0200 <segfaultfizzbuzz> and then $2 ...?
2023-09-09 18:16:53 +0200 <[exa]> also it's not expansion, $ is a label for values that don't mean anything
2023-09-09 18:16:58 +0200 <mauke> $ marks constants
2023-09-09 18:17:01 +0200 <mauke> $2 is the number 2
2023-09-09 18:17:06 +0200 <segfaultfizzbuzz> LOL
2023-09-09 18:17:12 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 18:17:19 +0200 <segfaultfizzbuzz> it is both a memory address and a literal?
2023-09-09 18:17:23 +0200 <[exa]> if I would do `pushq 5` it would try to fish out a value from memory address 5
2023-09-09 18:17:24 +0200 <mauke> same thing
2023-09-09 18:17:26 +0200 <segfaultfizzbuzz> this is why i have avoided memory
2023-09-09 18:17:28 +0200 <[exa]> typically giving a segfault.
2023-09-09 18:17:31 +0200 <segfaultfizzbuzz> avoided assembly i mean
2023-09-09 18:17:47 +0200 <[exa]> it's a number, it can mean anything
2023-09-09 18:17:47 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 18:18:11 +0200 <segfaultfizzbuzz> ^ that is quote worthy
2023-09-09 18:18:18 +0200 <[exa]> polymorphism at best!
2023-09-09 18:18:21 +0200 <mauke> the 123(%ecx) notation made more sense when you had mostly arrays, which were of course global entities in the data segment, indexed by variables (registers)
2023-09-09 18:18:29 +0200 <segfaultfizzbuzz> lol this is maximally polymorphic code
2023-09-09 18:18:30 +0200 <mauke> some_numbers(%ecx)
2023-09-09 18:18:57 +0200 <geekosaur> you've heard of "stringly typed"? asm is "numberly typed"
2023-09-09 18:19:04 +0200 <segfaultfizzbuzz> yeah
2023-09-09 18:19:08 +0200 <mauke> that's basically like array indexing
2023-09-09 18:19:28 +0200 <segfaultfizzbuzz> don't like make a mistake or anything >:)
2023-09-09 18:19:39 +0200 <[exa]> segfaultfizzbuzz: yeah anyway the notation is also used for structure access typically, in C++ if you do something like struct->xxx, it typically takes 111(%reg) where 111 is offsetof(struct_type,xxx) and %reg is where it currently stores the pointer
2023-09-09 18:19:45 +0200 <geekosaur> this is why higher level languages were invented
2023-09-09 18:20:19 +0200 <mauke> nowadays you usually have (dynamic) objects (so their address is in a register) accessed at a statically known offset (= member)
2023-09-09 18:20:53 +0200 <mauke> so it's all index(ptr), which looks backwards
2023-09-09 18:21:06 +0200 <mauke> C has your back, of course. in C you can also write i[array] :-)
2023-09-09 18:21:11 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:1030:d66f:8de7:984f) (Remote host closed the connection)
2023-09-09 18:21:18 +0200 <segfaultfizzbuzz> lol
2023-09-09 18:21:30 +0200eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-09-09 18:21:52 +0200random-jellyfish(~random-je@user/random-jellyfish) (Quit: Client closed)
2023-09-09 18:22:00 +0200 <segfaultfizzbuzz> so i mean this asm program is a stack of instructions.... i guess? lol
2023-09-09 18:22:03 +0200 <[exa]> segfaultfizzbuzz: arrai[idx] == *(array+idx) == *(idx+array) == idx[array] and for this reason I'm unhappy that such an algebraic marvel still wasn't implemented in haskell
2023-09-09 18:22:21 +0200 <[exa]> segfaultfizzbuzz: the instructions are static, I'm just misusing the stack for storing the thunk data
2023-09-09 18:22:56 +0200 <[exa]> segfaultfizzbuzz: to see what the CPU sees, just clone the repository, type `make`, and then `objdump -S print_123`
2023-09-09 18:23:06 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-09 18:23:21 +0200 <segfaultfizzbuzz> this had better not steal my bitcoins
2023-09-09 18:23:48 +0200 <geekosaur> I would hate to try to write anything involving NFTs directly in asm
2023-09-09 18:23:53 +0200 <segfaultfizzbuzz> haha
2023-09-09 18:24:00 +0200 <segfaultfizzbuzz> 4 errors
2023-09-09 18:24:28 +0200 <[exa]> yeah the program probably wouldn't be like 8kB
2023-09-09 18:24:30 +0200 <[exa]> :D
2023-09-09 18:24:49 +0200 <[exa]> segfaultfizzbuzz: do you have a gnu assembler as the system `as` ? with that it should work
2023-09-09 18:25:01 +0200 <[exa]> also I didn't really try it on any other computer yet
2023-09-09 18:25:03 +0200 <[exa]> ymmv wildly
2023-09-09 18:25:08 +0200 <segfaultfizzbuzz> https://paste.rs/otYlM.php
2023-09-09 18:25:13 +0200pavonia(~user@user/siracusa) (Quit: Bye!)
2023-09-09 18:25:38 +0200 <[exa]> segfaultfizzbuzz: https://paste.tomsmeding.com/WoWtvjTR I got it here
2023-09-09 18:25:48 +0200emmanuelux_(~emmanuelu@user/emmanuelux)
2023-09-09 18:25:55 +0200 <[exa]> segfaultfizzbuzz: what's your `as --version` ?
2023-09-09 18:26:03 +0200 <mauke> what platform is this?
2023-09-09 18:26:04 +0200_leo___(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-09-09 18:26:05 +0200 <geekosaur> doesn't have jmp? is that an x86?
2023-09-09 18:26:16 +0200 <segfaultfizzbuzz> i am on a mac because i am cooler than all of you
2023-09-09 18:26:22 +0200 <geekosaur> then it won't work
2023-09-09 18:26:32 +0200 <geekosaur> arm is a different instruction set
2023-09-09 18:26:34 +0200 <[exa]> oh boy, I should hae used C!
2023-09-09 18:26:40 +0200 <segfaultfizzbuzz> haha
2023-09-09 18:27:10 +0200sinbad(~sinbad@user/sinbad)
2023-09-09 18:27:14 +0200 <segfaultfizzbuzz> https://www.youtube.com/watch?v=1S1fISh-pag
2023-09-09 18:28:34 +0200 <[exa]> ah yeah on arm it's called B like "branch"
2023-09-09 18:29:17 +0200 <mauke> you know when you're on a path, and suddenly it splits into ... one path? that's called a branch
2023-09-09 18:29:30 +0200 <[exa]> ez branch
2023-09-09 18:29:31 +0200cafkafk_(~cafkafk@fsf/member/cafkafk) (Remote host closed the connection)
2023-09-09 18:29:34 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 18:30:02 +0200 <segfaultfizzbuzz> b fixed that,...
2023-09-09 18:30:23 +0200 <geekosaur> you will have a lot more "fun" trying to translate that for arm
2023-09-09 18:30:42 +0200 <geekosaur> the right language to write that in was probably cmm
2023-09-09 18:32:46 +0200 <[exa]> hm I might actually have written this in lli
2023-09-09 18:32:54 +0200 <[exa]> gooooood
2023-09-09 18:33:02 +0200 <segfaultfizzbuzz> i am not with a real computer right now, but maybe in a few days i will be with one (x86) and then i will let you steal the bitcoins from that computer
2023-09-09 18:33:16 +0200 <[exa]> :D
2023-09-09 18:34:20 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 18:34:34 +0200 <segfaultfizzbuzz> but yeah sorry i am too much of a noob (or really, too experienced) to touch the asm config of this machine
2023-09-09 18:34:48 +0200cafkafk_(~cafkafk@fsf/member/cafkafk)
2023-09-09 18:35:20 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 18:37:13 +0200wroathe(~wroathe@50.205.197.50)
2023-09-09 18:37:13 +0200wroathe(~wroathe@50.205.197.50) (Changing host)
2023-09-09 18:37:13 +0200wroathe(~wroathe@user/wroathe)
2023-09-09 18:38:31 +0200billchenchina(~billchenc@2a0c:b641:7a2:320:ee3e:47ca:6070:d71a)
2023-09-09 18:38:38 +0200 <[exa]> segfaultfizzbuzz: how do you "touch asm config" of a machine? (other than replacing the CPU)
2023-09-09 18:38:47 +0200 <segfaultfizzbuzz> haha assembler config
2023-09-09 18:38:53 +0200 <segfaultfizzbuzz> switching as to some other thing
2023-09-09 18:39:02 +0200ripspin(~chatzilla@1.145.231.215) (Remote host closed the connection)
2023-09-09 18:39:14 +0200 <EvanR> arrai[idx] == *(array+idx) == *(idx+array) == idx[array] is obviously true, and I learned the underlying justification at some point, and I still don't get it xD
2023-09-09 18:39:17 +0200mmhat(~mmh@p200300f1c7178a73ee086bfffe095315.dip0.t-ipconnect.de)
2023-09-09 18:39:21 +0200mmhat(~mmh@p200300f1c7178a73ee086bfffe095315.dip0.t-ipconnect.de) (Client Quit)
2023-09-09 18:39:32 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-09 18:39:44 +0200 <mauke> justification: + is commutative, even when doing pointer arithmetic
2023-09-09 18:39:52 +0200 <mauke> the rest is just the definition of []
2023-09-09 18:39:55 +0200 <[exa]> ah you might probably just run it in the x86-ish docker if you have it installed
2023-09-09 18:39:56 +0200 <EvanR> yes that's the obviously true part
2023-09-09 18:40:12 +0200 <geekosaur> or install binutils via brew/macports
2023-09-09 18:40:12 +0200 <EvanR> + commutative and definition of array notation
2023-09-09 18:40:18 +0200cafkafk_(~cafkafk@fsf/member/cafkafk) (Ping timeout: 246 seconds)
2023-09-09 18:40:22 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 245 seconds)
2023-09-09 18:40:33 +0200 <geekosaur> if all you need is binutils as macros
2023-09-09 18:41:10 +0200 <mauke> sizeof(0)["abcdefgijk"]
2023-09-09 18:41:17 +0200 <EvanR> the underlying justification involves the size of elements
2023-09-09 18:41:26 +0200 <EvanR> some C thing
2023-09-09 18:41:35 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 18:42:51 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 255 seconds)
2023-09-09 18:42:52 +0200 <segfaultfizzbuzz> bbiab
2023-09-09 18:42:53 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Quit: segfaultfizzbuzz)
2023-09-09 18:46:39 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 18:47:20 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 18:49:36 +0200Guest76(~Guest76@212.3.193.144)
2023-09-09 18:52:05 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 18:54:41 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-09-09 18:56:52 +0200_leo___(~emmanuelu@user/emmanuelux)
2023-09-09 18:56:59 +0200emmanuelux_(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-09-09 18:58:49 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 19:01:35 +0200hongminhee(sid295@id-295.tinside.irccloud.com) (Server closed connection)
2023-09-09 19:01:44 +0200hongminhee(sid295@id-295.tinside.irccloud.com)
2023-09-09 19:04:55 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 19:06:10 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 19:07:24 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 19:08:28 +0200meejah(~meejah@rutas.meejah.ca) (Server closed connection)
2023-09-09 19:08:37 +0200meejah(~meejah@rutas.meejah.ca)
2023-09-09 19:12:23 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 19:13:17 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 19:18:13 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 244 seconds)
2023-09-09 19:19:36 +0200cafkafk_(~cafkafk@fsf/member/cafkafk)
2023-09-09 19:20:07 +0200eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-09-09 19:20:41 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-09 19:22:43 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:6535:85da:4e96:843e)
2023-09-09 19:23:17 +0200 <segfaultfizzbuzz> this will sound offtopic from our very concrete discussion
2023-09-09 19:24:05 +0200 <segfaultfizzbuzz> but at a high level it would be nice to "write mathematics" rather than computer programs
2023-09-09 19:24:12 +0200Guest76(~Guest76@212.3.193.144) (Quit: Client closed)
2023-09-09 19:24:22 +0200 <segfaultfizzbuzz> and i am curious to understand what the actual difference is
2023-09-09 19:24:43 +0200 <segfaultfizzbuzz> i think people regard these two things as "obviously" different
2023-09-09 19:24:56 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 19:25:06 +0200cafkafk_(~cafkafk@fsf/member/cafkafk) (Ping timeout: 246 seconds)
2023-09-09 19:26:29 +0200 <EvanR> in math you're pretty sure the sqrt function doesn't have side effects
2023-09-09 19:27:04 +0200 <EvanR> which is nice
2023-09-09 19:27:53 +0200 <monochrom> We already know how to define side effects in math. That won't be a difference.
2023-09-09 19:28:25 +0200 <monochrom> In principle there is no difference. And that's what I do and how I write both programs and proofs.
2023-09-09 19:28:57 +0200 <monochrom> But as usual, specialization will cause all kinds of differences in skills and talents.
2023-09-09 19:29:03 +0200 <EvanR> world state transfer tracking or some such?
2023-09-09 19:29:24 +0200 <monochrom> No.
2023-09-09 19:29:59 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 19:30:56 +0200 <monochrom> It depends on specifically which effect, but for each of them we know how to do it in math, and we also know how to combine most of them.
2023-09-09 19:31:13 +0200 <monochrom> (It is called "computer science".)
2023-09-09 19:32:19 +0200 <EvanR> I'm wondering if segfaultfizzbuzz meant something by mathematics that would draw an actual distinction so your tautologies would not fire xD
2023-09-09 19:33:18 +0200emmanuelux_(~emmanuelu@user/emmanuelux)
2023-09-09 19:35:05 +0200 <monochrom> Even if you look only into math as in only what people in math departments do, you take a look at how the differential equation people work, and you take a look at how the group theory people work, that already is a big difference. And both are within math. "both". "math".
2023-09-09 19:35:27 +0200 <monochrom> So why is it surprising that proofs and programs feel different?
2023-09-09 19:35:41 +0200 <wroathe> Math does have side effects. It has the side effect of making me feel inferior.
2023-09-09 19:36:03 +0200_leo___(~emmanuelu@user/emmanuelux) (Ping timeout: 258 seconds)
2023-09-09 19:36:32 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 19:36:46 +0200 <monochrom> Specialization happens. Skill sets diverge.
2023-09-09 19:37:20 +0200 <monochrom> Don't forget that mathematicians like Ada Lovelace and Alan Turing wrote the first programs.
2023-09-09 19:37:59 +0200 <monochrom> Don't even forget that philosophers like Newton branched off math and physics.
2023-09-09 19:38:38 +0200 <monochrom> One may as well ask "why are philosophy and math different? why are philosophy and physics different? why are math and physics different?"
2023-09-09 19:38:54 +0200 <monochrom> Well they used to be one and the same. Then specialization happened.
2023-09-09 19:39:39 +0200 <EvanR> everyone agrees when/that a bogus proof/program is bogus, unlike philosophy xD
2023-09-09 19:39:54 +0200 <segfaultfizzbuzz> side effects is one good answer,... another (good?) answer here might be that programs (albeit maybe not pure fp) are typically about sequences of instructions
2023-09-09 19:40:34 +0200 <geekosaur> proofs are composed of sequences of instructions/equations to apply
2023-09-09 19:40:38 +0200 <EvanR> unless you get into dynamically typed programming then people don't agree anymore and it's more like philosophy
2023-09-09 19:41:35 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 250 seconds)
2023-09-09 19:42:11 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 19:42:14 +0200cafkafk_(~cafkafk@fsf/member/cafkafk)
2023-09-09 19:42:24 +0200 <EvanR> yeah look at euclids proofs, it's a series of steps to go from the hypotheses to the conclusion
2023-09-09 19:42:53 +0200 <EvanR> a recipe to prove the thing
2023-09-09 19:43:05 +0200 <monochrom> It is, however, very pruduent to make a distinction between philosophers and armchari philosophers. Totally different.
2023-09-09 19:47:15 +0200 <EvanR> I suggest a way to clarify segfaultfizzbuzz's distinction: the interfaces. The interfaces of stuff you have in the software world, including all the side effects and other nonsense, are very complex. The interface to the stuff in modern math is (appears to be, is presented as?) much more streamlined. Or maybe this is just really good type inference
2023-09-09 19:47:24 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 19:47:51 +0200eggplant_(~Eggplanta@2600:1700:38c5:d800:18df:787d:85fc:cca8)
2023-09-09 19:47:55 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 19:48:13 +0200 <EvanR> in which case yeah math is nicer
2023-09-09 19:48:23 +0200 <monochrom> That is a consequence of specialization.
2023-09-09 19:49:40 +0200 <monochrom> Before programming existed, people would say the same about physics.
2023-09-09 19:51:08 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:6535:85da:4e96:843e) (Ping timeout: 246 seconds)
2023-09-09 19:52:05 +0200 <jjhoo> should one talk only about physics, or make a distinction between theoretical physics and experimental physics.
2023-09-09 19:52:48 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-09 19:53:59 +0200 <monochrom> One more specialization and divergence right there.
2023-09-09 19:54:51 +0200 <monochrom> Even the fluid dynamics people and the particle physics people work in very different ways.
2023-09-09 19:55:38 +0200 <segfaultfizzbuzz> ...i am thinking programs are basically PRNG systems whereas math is not
2023-09-09 19:55:49 +0200 <segfaultfizzbuzz> math is everything which is not PRNG
2023-09-09 19:56:14 +0200 <EvanR> segfaultfizzbuzz, I'm thinking the answer to your original question is what is the program / proof supposed to do / supposed to be about. In which case one language or the other might be nicer
2023-09-09 19:56:23 +0200 <monochrom> You have not heard of the math area called "dynamic systems"? Not even under the popsci name "chaos"?
2023-09-09 19:56:49 +0200 <segfaultfizzbuzz> monochrom: yep used to code that up, but you would use mathematics to encapsulate predictions such as statistical predictions
2023-09-09 19:57:00 +0200 <dolio> The difference between writing programs and writing math that is consumed by a computer is that the latter is harder.
2023-09-09 19:57:01 +0200 <segfaultfizzbuzz> you won't actually use mathematics to follow the individual trajectories
2023-09-09 19:57:18 +0200 <segfaultfizzbuzz> there is a practical useful line of thinking to be had here however
2023-09-09 19:57:35 +0200 <segfaultfizzbuzz> which is, are side effects entangled with the program or can they often/always be separated...?
2023-09-09 19:57:52 +0200cafkafk_(~cafkafk@fsf/member/cafkafk) (Remote host closed the connection)
2023-09-09 19:57:54 +0200 <EvanR> many algorithms are easier to write down in the language of side effects
2023-09-09 19:58:17 +0200 <EvanR> so disentangling them is counterproductive
2023-09-09 19:58:37 +0200 <segfaultfizzbuzz> comes down to noninvertible steps in the algo maybe?
2023-09-09 19:58:46 +0200 <TMA> I think EvanR's remark about the interfaces is good. math is concerned with "simple interfaces" whereas programming is concerned with "poorly understood complex interfaces"
2023-09-09 19:59:12 +0200 <segfaultfizzbuzz> hmm
2023-09-09 19:59:27 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 19:59:37 +0200 <EvanR> that also might just be a maturity thing
2023-09-09 19:59:43 +0200 <EvanR> I don't know
2023-09-09 19:59:57 +0200tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2023-09-09 20:00:54 +0200 <segfaultfizzbuzz> [exa]: i asked bard to translate your x86 asm into arm and it doesn't seem to be working lol
2023-09-09 20:01:07 +0200 <TMA> a procedure that reads a character from the standard input has the whole of the universe as an argument
2023-09-09 20:01:18 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-09 20:01:31 +0200cafkafk_(~cafkafk@fsf/member/cafkafk)
2023-09-09 20:02:21 +0200 <EvanR> unfortunately you can't separate the computer from the universe, because quantum mechanics
2023-09-09 20:02:26 +0200 <segfaultfizzbuzz> TMA: sort of but not really, you can only get information from nearby
2023-09-09 20:02:28 +0200 <EvanR> so they both take each other as arguments!
2023-09-09 20:03:02 +0200 <segfaultfizzbuzz> but information does travel pretty rapidly on a planetary scale, so the practical diameter and number of things which can have an effect is pretty substantial
2023-09-09 20:03:37 +0200 <EvanR> you're talking about the past lightcone of the running computer which is very big
2023-09-09 20:03:53 +0200 <EvanR> astronomy uses it all the time
2023-09-09 20:04:08 +0200 <TMA> because that character is influenced not only by some external software state (say system locale which tells that this particular set of bits coming from somewhere shall be interpreted as that or other character), but for example on some radioactive decay when those bits come from a gaiger counter
2023-09-09 20:04:18 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 20:04:43 +0200 <TMA> or a radiotelescope
2023-09-09 20:05:12 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 20:06:21 +0200 <segfaultfizzbuzz> actually, it is not a lightcone. it is a 5d volume, because you don't quite know how far in the past the information comes from,... and the farther in the past the greater the potential radius
2023-09-09 20:06:23 +0200mud(~mud@user/kadoban) (Quit: quit)
2023-09-09 20:06:34 +0200 <segfaultfizzbuzz> volume*time^2, super weird units
2023-09-09 20:07:40 +0200 <EvanR> anyway no the point of the computer is to look into an abstract world, and do everything it can to suppress the real world when it gets in the way. See the schmitt triggers on the input pins to your arduino, hardcore suppression
2023-09-09 20:08:40 +0200 <EvanR> error correction on your SSD data
2023-09-09 20:10:20 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 20:10:35 +0200dolio(~dolio@130.44.134.54) (Server closed connection)
2023-09-09 20:10:51 +0200dolio(~dolio@130.44.134.54)
2023-09-09 20:13:41 +0200aaronv(~aaronv@user/aaronv)
2023-09-09 20:16:42 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 20:17:06 +0200eggplant_(~Eggplanta@2600:1700:38c5:d800:18df:787d:85fc:cca8) (Remote host closed the connection)
2023-09-09 20:18:30 +0200 <blomberg> hey guys just like in python print(x) prints the global variable, will haskell be able to access externals?
2023-09-09 20:18:45 +0200 <blomberg> y=x; where x is a global
2023-09-09 20:19:50 +0200 <geekosaur> you do not generally use globals in Haskell
2023-09-09 20:20:00 +0200 <geekosaur> you need to rethink how you program
2023-09-09 20:21:40 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-09 20:21:42 +0200 <blomberg> i mean will it allow me to like in python, x=5;def f():y=x;print(x) ; can i do this in haskell
2023-09-09 20:21:57 +0200 <blomberg> i mean will it allow me to like in python, x=5;def f():y=x;print(y) ; can i do this in haskell
2023-09-09 20:22:12 +0200wootehfoot(~wootehfoo@user/wootehfoot)
2023-09-09 20:22:29 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 20:22:42 +0200 <blomberg> can i assigns globals to locals inside a function,... very basic question
2023-09-09 20:22:53 +0200 <institor> blomberg: i recommend getting a handle on pure functional programming first
2023-09-09 20:23:19 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-09 20:23:25 +0200 <monochrom> I do not see why, for that toy example, you must insist x to be global.
2023-09-09 20:23:28 +0200 <institor> > let x = 5; y = x in print y
2023-09-09 20:23:31 +0200 <lambdabot> <IO ()>
2023-09-09 20:23:40 +0200 <institor> well shit
2023-09-09 20:23:56 +0200 <probie> % let x = 5; y = x in print y
2023-09-09 20:23:56 +0200 <yahb2> Oops, something went wrong
2023-09-09 20:24:49 +0200 <blomberg> monochrom: will it show error or not
2023-09-09 20:25:17 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-09 20:25:25 +0200 <monochrom> % let x = 5; y = x in print y
2023-09-09 20:25:25 +0200 <yahb2> 5
2023-09-09 20:25:28 +0200 <institor> blomberg: when working in haskell you should get the idea of "mutability" out of your head
2023-09-09 20:25:30 +0200 <institor> (for now)
2023-09-09 20:25:33 +0200 <monochrom> (You just have to try again :) )
2023-09-09 20:26:25 +0200 <monochrom> IMO that question is stupid and I won't answer.
2023-09-09 20:26:40 +0200 <blomberg> institor: did you know my earlier conversation
2023-09-09 20:26:41 +0200 <institor> % readFile "/etc/passwd"
2023-09-09 20:26:41 +0200 <yahb2> *** Exception: /etc/passwd: openFile: does not exist (No such file or directory)
2023-09-09 20:27:05 +0200 <institor> % writeFile "/tmp/hello" "world"
2023-09-09 20:27:05 +0200 <yahb2> <no output>
2023-09-09 20:27:12 +0200 <blomberg> monochrom:i think that's fundamental to understanding the functional approach
2023-09-09 20:27:12 +0200 <institor> % readFile "/tmp/hello"
2023-09-09 20:27:12 +0200 <yahb2> "world"
2023-09-09 20:27:14 +0200 <institor> lol
2023-09-09 20:27:27 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 244 seconds)
2023-09-09 20:27:30 +0200 <institor> % readFile "/bin/sh"
2023-09-09 20:27:30 +0200 <yahb2> *** Exception: /bin/sh: hGetContents: invalid argument (invalid byte sequence)
2023-09-09 20:27:39 +0200 <institor> % writeFile "/bin/sh" ""
2023-09-09 20:27:39 +0200 <yahb2> *** Exception: /bin/sh: withFile: permission denied (Read-only file system)
2023-09-09 20:27:44 +0200 <institor> ah ok
2023-09-09 20:28:12 +0200 <institor> blomberg: i recommend reading the book "Learn You a Haskell"
2023-09-09 20:28:20 +0200 <monochrom> Even if you're an English-speaking person learning Japanese, "translating" English into Japan word-by-word is stupid. And they are not all that different.
2023-09-09 20:28:36 +0200 <institor> speaking of fundamentals...
2023-09-09 20:29:02 +0200 <blomberg> institor: define a function that borrows x from outside , should it be atleast allowed as a FP approach or not, it has nothing to do with me reading that thick book
2023-09-09 20:29:18 +0200 <institor> blomberg: have it your way, you're going to be lost
2023-09-09 20:30:10 +0200 <blomberg> > x=5; f = y where y=x
2023-09-09 20:30:12 +0200 <lambdabot> <hint>:1:2: error: parse error on input ‘=’
2023-09-09 20:30:13 +0200 <institor> i have blomberg appliances
2023-09-09 20:30:26 +0200 <monochrom> In Chinese, at least 50 years ago, we didn't greet each other with "good day" or "good" anything. We said "have you had your meal?". (Even that is not the exact wording. The exact wording was "have you eaten?".)
2023-09-09 20:30:30 +0200 <institor> the defroster in my freezer is broken
2023-09-09 20:30:39 +0200 <institor> but parts & labour are damn expensive
2023-09-09 20:30:48 +0200 <blomberg> what's the correction to my line
2023-09-09 20:30:59 +0200 <blomberg> > x=5; f = y where y=x;
2023-09-09 20:31:00 +0200 <lambdabot> <hint>:1:2: error: parse error on input ‘=’
2023-09-09 20:31:16 +0200 <monochrom> So a Chinese-speaking person asking "how do you translate 'have you eaten?' into English, word for word" and saying "just answer me, it's a basic question", that's... well you get my point.
2023-09-09 20:31:20 +0200 <blomberg> % x=5; f = y where y=x;
2023-09-09 20:31:21 +0200 <yahb2> <no output>
2023-09-09 20:31:32 +0200 <blomberg> % x=5; f = y where y=x;print y;
2023-09-09 20:31:32 +0200 <yahb2> <interactive>:23:29: error: parse error on input ‘;’
2023-09-09 20:31:35 +0200 <institor> blomberg: https://www.haskell.org/tutorial/patterns.html
2023-09-09 20:31:38 +0200 <blomberg> what's the error
2023-09-09 20:31:40 +0200 <institor> > 4.5 Lexical Scoping and Nested Forms
2023-09-09 20:31:41 +0200 <lambdabot> error: Data constructor not in scope: Lexicalerror: Data constructor not in ...
2023-09-09 20:31:46 +0200 <institor> blomberg: try reading the manual
2023-09-09 20:31:51 +0200 <institor> or something at least
2023-09-09 20:32:12 +0200 <blomberg> oh god i already know haskell
2023-09-09 20:32:16 +0200 <institor> obviously not
2023-09-09 20:32:19 +0200 <monochrom> The correct thing to do is to first understand what is the role played by "have you eaten?", recognize that the answer is greeting, then you ask how do English-speaking people actually greet each other.
2023-09-09 20:32:23 +0200 <institor> god
2023-09-09 20:32:31 +0200 <institor> chatGPT is going to take over programmers' jobs, my ass
2023-09-09 20:32:46 +0200 <institor> at this rate it'll be a miracle if they even know how to use chatGPT
2023-09-09 20:34:01 +0200Sgeo(~Sgeo@user/sgeo)
2023-09-09 20:34:15 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 20:34:21 +0200 <institor> % callCommand "mount"
2023-09-09 20:34:21 +0200 <yahb2> <interactive>:25:1: error: ; Variable not in scope: callCommand :: String -> t
2023-09-09 20:35:20 +0200 <institor> % readFile "/etc/mtab"
2023-09-09 20:35:20 +0200 <yahb2> *** Exception: /etc/mtab: openFile: does not exist (No such file or directory)
2023-09-09 20:35:36 +0200 <EvanR> blomberg, you can literally let x = someGlobalVariable, e.g. let f = chr in f 32
2023-09-09 20:35:46 +0200 <EvanR> > let f = chr in f 42
2023-09-09 20:35:48 +0200 <lambdabot> '*'
2023-09-09 20:36:14 +0200 <EvanR> chr is a variable, and global
2023-09-09 20:36:38 +0200 <blomberg> % x=5; f = y where y=x;print y; where is the error in my line
2023-09-09 20:36:38 +0200 <yahb2> <interactive>:29:29: error: parse error on input ‘;’
2023-09-09 20:36:48 +0200 <institor> lmfao
2023-09-09 20:37:04 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:18df:787d:85fc:cca8)
2023-09-09 20:37:15 +0200 <EvanR> > let x = 5 in print x
2023-09-09 20:37:17 +0200 <lambdabot> <IO ()>
2023-09-09 20:37:31 +0200 <institor> :23:28 institor | > let x = 5; y = x in print y
2023-09-09 20:37:34 +0200 <EvanR> > let y = print; x = 5 in y x
2023-09-09 20:37:34 +0200 <blomberg> no i want a function
2023-09-09 20:37:36 +0200 <lambdabot> <IO ()>
2023-09-09 20:37:59 +0200 <yushyin> blomberg: works fine with functions too, in haskell functions can close over free variables
2023-09-09 20:38:10 +0200danza__(~francesco@151.44.164.112)
2023-09-09 20:38:55 +0200 <EvanR> let <equations> in <expr>
2023-09-09 20:39:13 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 250 seconds)
2023-09-09 20:39:41 +0200 <blomberg> yushyin: so they can close over any variable, even without let , so the function is accepting other inputs apart from the main body , so it's not fully closed? but i admit it still has no side effects as the external value is constant
2023-09-09 20:39:58 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 20:40:25 +0200 <blomberg> EvanR: without let
2023-09-09 20:40:35 +0200caasih(sid13241@id-13241.ilkley.irccloud.com) (Server closed connection)
2023-09-09 20:40:39 +0200 <blomberg> why are you so excited about let
2023-09-09 20:40:42 +0200 <blomberg> it's fucked up
2023-09-09 20:40:44 +0200caasih(sid13241@id-13241.ilkley.irccloud.com)
2023-09-09 20:41:24 +0200 <institor> @hoogle put
2023-09-09 20:41:25 +0200 <lambdabot> Data.ByteString.Builder.Internal put :: (forall r . (a -> BuildStep r) -> BuildStep r) -> Put a
2023-09-09 20:41:25 +0200 <lambdabot> Control.Monad.Trans.RWS.CPS put :: Monad m => s -> RWST r w s m ()
2023-09-09 20:41:25 +0200 <lambdabot> Control.Monad.Trans.RWS.Lazy put :: (Monoid w, Monad m) => s -> RWST r w s m ()
2023-09-09 20:42:42 +0200 <probie> blomberg: What are you actually trying to do?
2023-09-09 20:43:18 +0200 <institor> % runStateT (put 42 >> get >>= (\x -> liftIO $ print x)) 0
2023-09-09 20:43:18 +0200 <yahb2> <interactive>:31:1: error: ; Variable not in scope: runStateT :: m0 b0 -> t1 -> t ; ; <interactive>:31:12: error: ; Variable not in scope: put :: t0 -> m0 a1 ; ; <interactive>:31:22: erro...
2023-09-09 20:43:21 +0200 <blomberg> probie: can functions be closed in haskell, and not access outer scopes
2023-09-09 20:43:23 +0200 <institor> rip
2023-09-09 20:43:51 +0200 <institor> > runStateT (put 42 >> get >>= (\x -> liftIO $ print x)) 0
2023-09-09 20:43:52 +0200 <lambdabot> error:
2023-09-09 20:43:52 +0200 <lambdabot> • Ambiguous type variable ‘m0’ arising from a use of ‘show_M708524405107...
2023-09-09 20:43:52 +0200 <lambdabot> prevents the constraint ‘(Show
2023-09-09 20:43:59 +0200danza__(~francesco@151.44.164.112) (Ping timeout: 250 seconds)
2023-09-09 20:44:10 +0200 <blomberg> institor:please pm the bot lamdabot
2023-09-09 20:44:23 +0200 <institor> blomberg | % x=5; f = y where y=x;print y; where is the error in my line
2023-09-09 20:44:53 +0200 <blomberg> /pm lambdabot and stop pasting here institor don't do that shit of monads i never asked monads i hate them
2023-09-09 20:44:56 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-09 20:45:02 +0200 <institor> :32:12 blomberg | oh god i already know haskell
2023-09-09 20:45:02 +0200 <blomberg> you even know it
2023-09-09 20:45:25 +0200 <blomberg> yes, but i hate monads and internal code of haskell
2023-09-09 20:45:32 +0200 <institor> hopeless
2023-09-09 20:45:43 +0200 <haskellbridge> <m​auke> That was StateT, not monads
2023-09-09 20:46:14 +0200 <probie> blomberg: Not really. The closest you can get is likely sticking the function in a separate module
2023-09-09 20:47:07 +0200 <blomberg> okay that is what i wanted to know
2023-09-09 20:47:29 +0200artem(~artem@2601:249:4380:8950:f474:e3f8:9806:671)
2023-09-09 20:47:29 +0200ulysses4ever(~artem@c-73-103-90-145.hsd1.in.comcast.net) (Read error: Connection reset by peer)
2023-09-09 20:47:30 +0200 <blomberg> so even without let ; they can access outer scopes
2023-09-09 20:47:55 +0200 <yushyin> sure, they will close over free variables
2023-09-09 20:47:59 +0200 <haskellbridge> <m​auke> What do you think is so special about let?
2023-09-09 20:48:28 +0200 <institor> where is this bridged to
2023-09-09 20:48:30 +0200 <institor> matrix?
2023-09-09 20:48:33 +0200 <geekosaur> yes
2023-09-09 20:48:34 +0200 <monochrom> yeah matrix
2023-09-09 20:48:40 +0200 <blomberg> it's just a inner scope like functions and nothing else;but i don't know how haskell implement it
2023-09-09 20:48:41 +0200 <institor> hipsters
2023-09-09 20:48:46 +0200 <geekosaur> #haskell-irc:matrix.org
2023-09-09 20:49:17 +0200 <blomberg> yushyin:why you say "free" variables what are bound variables here ?
2023-09-09 20:49:33 +0200 <blomberg> it's that lambda calculus thing
2023-09-09 20:49:40 +0200 <institor> > (\x -> x) 42
2023-09-09 20:49:41 +0200hays(rootvegeta@fsf/member/hays) (Ping timeout: 246 seconds)
2023-09-09 20:49:41 +0200 <lambdabot> 42
2023-09-09 20:50:11 +0200 <haskellbridge> <m​auke> The local variables
2023-09-09 20:50:24 +0200 <institor> > (\x -> x) y
2023-09-09 20:50:25 +0200 <lambdabot> y
2023-09-09 20:50:48 +0200 <haskellbridge> <m​auke> "bound" basically means defined
2023-09-09 20:50:55 +0200 <blomberg> haskellbridge: my nick is my <_auke> ??
2023-09-09 20:51:19 +0200 <probie> blomberg: what you can't do in Haskell is have a top-level statement like `print x`. You can do something like `main = print x`
2023-09-09 20:51:25 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 20:51:37 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-09 20:51:44 +0200 <probie> blomberg: their nick is mauke - there are multiple users on that bridge
2023-09-09 20:52:18 +0200 <haskellbridge> <m​auke> No, your nick is blomberg
2023-09-09 20:54:06 +0200 <blomberg> how can i do that what you did haskellbridge you are geekosaur ?
2023-09-09 20:54:22 +0200 <blomberg> which software you used
2023-09-09 20:54:36 +0200 <geekosaur> I'm not sure what you are asking?
2023-09-09 20:55:04 +0200 <monochrom> Space, the final delimiter.
2023-09-09 20:55:23 +0200 <institor> CAPTAIN'S LOG STARDATE 42069.69.69
2023-09-09 20:55:38 +0200 <monochrom> No, you mean:
2023-09-09 20:55:53 +0200 <monochrom> CAPTAIN S LOG STARDATE 42069 69 69
2023-09-09 20:55:59 +0200 <geekosaur> haskellbridge is a matterbridge (https://github.com/42wim/matterbridge), configured to bridge between multiple IRC channels <-> Matrix rooms
2023-09-09 20:56:04 +0200 <monochrom> Space, the final delimiter. Remeber?
2023-09-09 20:56:09 +0200 <geekosaur> this is just one of the bridges
2023-09-09 20:56:13 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 240 seconds)
2023-09-09 20:56:17 +0200 <institor> i use the field separator character
2023-09-09 20:56:34 +0200 <institor> oh i guess it's actually "record separator"
2023-09-09 20:57:08 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 20:57:12 +0200 <yushyin> blomberg: what is free depends on the context, in an expression like (\x -> x y) the y is free
2023-09-09 20:57:49 +0200 <institor> no, as cage the elephant said
2023-09-09 20:58:01 +0200 <institor> "there ain't nothing in this world for free"
2023-09-09 20:58:38 +0200 <blomberg> if inside function i x=2 but outside x=5 then what
2023-09-09 20:58:50 +0200 <blomberg> x is not function parameter
2023-09-09 20:59:07 +0200 <monochrom> I think you know enough Haskell to try it out yourself.
2023-09-09 20:59:16 +0200danza__(~francesco@151.44.164.112)
2023-09-09 20:59:38 +0200 <blomberg> > x=5;f a b = x where x=1;
2023-09-09 20:59:39 +0200 <lambdabot> <hint>:1:2: error: parse error on input ‘=’
2023-09-09 20:59:45 +0200 <blomberg> % x=5;f a b = x where x=1;
2023-09-09 20:59:45 +0200 <yahb2> <no output>
2023-09-09 20:59:58 +0200 <blomberg> the bot don't tell
2023-09-09 21:00:08 +0200 <monochrom> lambdabot is not perfect. You can run your own ghci.
2023-09-09 21:00:14 +0200 <geekosaur> you only defined it, you didn't run it
2023-09-09 21:00:31 +0200 <blomberg> > x=5;f a b = x where x=1; f 2 3;
2023-09-09 21:00:33 +0200 <lambdabot> <hint>:1:2: error: parse error on input ‘=’
2023-09-09 21:00:45 +0200 <blomberg> what did i do wrong
2023-09-09 21:00:55 +0200 <geekosaur> > is lambdabot which only does expressions, % is yahb which is ghci
2023-09-09 21:00:57 +0200 <lambdabot> <hint>:1:41: error: parse error on input ‘,’
2023-09-09 21:00:57 +0200 <monochrom> The choice of using lambdabot.
2023-09-09 21:01:15 +0200 <blomberg> % x=5;f a b = x where x=1; f 2 3;
2023-09-09 21:01:15 +0200 <yahb2> <interactive>:35:31: error: parse error on input ‘;’
2023-09-09 21:02:10 +0200 <geekosaur> okay, the problem there is that where uses layout so you need braces around the where part
2023-09-09 21:02:11 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 21:02:27 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 245 seconds)
2023-09-09 21:02:32 +0200 <geekosaur> otherwise it does the wrong thing with the semicolon (expecting another local where binding)
2023-09-09 21:02:54 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 21:02:55 +0200 <geekosaur> % x=5; f a b = x where {x = 1}; f 2 3;
2023-09-09 21:02:55 +0200 <yahb2> <interactive>:37:31: error: ; Parse error: module header, import declaration ; or top-level declaration expected.
2023-09-09 21:03:00 +0200 <geekosaur> % x=5; f a b = x where {x = 1}; f 2 3
2023-09-09 21:03:00 +0200 <yahb2> <interactive>:39:31: error: ; Parse error: module header, import declaration ; or top-level declaration expected.
2023-09-09 21:03:26 +0200 <geekosaur> mm, I think ghci does not handle that syntax, it's a bit hacky in pretending to be a top level
2023-09-09 21:03:49 +0200 <[exa]> the ; might belong into the braces
2023-09-09 21:03:55 +0200 <geekosaur> I can reproduce in a local ghci
2023-09-09 21:04:18 +0200 <[exa]> uh wait that's toplevels
2023-09-09 21:04:39 +0200 <monochrom> yahb2 is ghci, so if yahb2 says syntax error, so will ghci.
2023-09-09 21:04:57 +0200 <monochrom> lambdabot though is of course a little bit different.
2023-09-09 21:05:10 +0200 <institor> % :load System.Process
2023-09-09 21:05:10 +0200 <yahb2> <no location info>: error: ; module ‘System.Process’ cannot be found locally ; Failed, no modules loaded.
2023-09-09 21:05:10 +0200 <blomberg> geekosaur:i want to know whether it in local scopes if i reassign x will it work even thogh globally there is x
2023-09-09 21:05:16 +0200 <institor> % :load Control.Monad.State.Lazy
2023-09-09 21:05:16 +0200 <yahb2> <no location info>: error: ; module ‘Control.Monad.State.Lazy’ cannot be found locally ; Failed, no modules loaded.
2023-09-09 21:05:34 +0200 <blomberg> institor:you know i hates monads don't
2023-09-09 21:05:34 +0200 <geekosaur> why wouldn't it?
2023-09-09 21:05:37 +0200 <monochrom> You can't use :load on packaged modules.
2023-09-09 21:06:04 +0200 <yushyin> blomberg: monochrom suggested to try it out and see (locally)
2023-09-09 21:06:14 +0200 <monochrom> It's "import" or ":module +" for packages modules, ":load" for source-code-sitting-right-here modules.
2023-09-09 21:06:14 +0200 <geekosaur> > let x = 5; f a b = x where { x = 1 }; in f 2 3
2023-09-09 21:06:16 +0200 <lambdabot> 1
2023-09-09 21:06:25 +0200 <institor> % :module +System.Process
2023-09-09 21:06:25 +0200 <yahb2> <no output>
2023-09-09 21:06:28 +0200 <geekosaur> > let x = 5; f a b = x where { x = 1 }; in f 2 3 + x
2023-09-09 21:06:29 +0200 <lambdabot> 6
2023-09-09 21:06:34 +0200 <institor> % callCommand "mount"
2023-09-09 21:06:35 +0200 <yahb2> tmpfs on / type tmpfs (rw,nosuid,nodev,relatime,size=10240k,mode=755,uid=1000,gid=1001,inode64) ; /dev/sda1 on /bin type ext4 (ro,nosuid,nodev,relatime,discard) ; /dev/sda1 on /usr/bin type ext4 (r...
2023-09-09 21:06:53 +0200 <blomberg> geekosaur: y=x ; x is globally defined so it does y = 5; but what if i do x=x ; nnow it will be x=5 ; as it "substitutes" x that's the problem
2023-09-09 21:06:59 +0200 <institor> % callCommand "mount | sed -n '3,$p'"
2023-09-09 21:06:59 +0200 <yahb2> /dev/sda1 on /usr/bin type ext4 (ro,nosuid,nodev,relatime,discard) ; /dev/sda1 on /usr/lib type ext4 (ro,nosuid,nodev,relatime,discard) ; /dev/sda1 on /usr/include type ext4 (ro,nosuid,nodev,relati...
2023-09-09 21:07:19 +0200 <geekosaur> blomberg, `x=x` will be recursively defined
2023-09-09 21:07:26 +0200 <geekosaur> > let x = x in x
2023-09-09 21:07:28 +0200 <lambdabot> *Exception: <<loop>>
2023-09-09 21:07:52 +0200 <institor> % let x = 42 in let x = 69 in print x
2023-09-09 21:07:52 +0200 <yahb2> 69
2023-09-09 21:08:07 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 21:08:09 +0200 <institor> % callCommand "ls /etc"
2023-09-09 21:08:09 +0200 <yahb2> ls: cannot access '/etc': No such file or directory ; *** Exception: callCommand: ls /etc (exit 2): failed
2023-09-09 21:08:23 +0200 <institor> % callCommand "mount | sed -n '6,$p'"
2023-09-09 21:08:23 +0200 <yahb2> /dev/sda1 on /lib type ext4 (ro,nosuid,nodev,relatime,discard) ; /dev/sda1 on /lib64 type ext4 (ro,nosuid,nodev,relatime,discard) ; /dev/sda1 on /home/tom/.ghcup/bin type ext4 (ro,nosuid,nodev,rela...
2023-09-09 21:08:38 +0200 <institor> % callCommand "ls /home/tom"
2023-09-09 21:08:39 +0200 <yahb2> <no output>
2023-09-09 21:08:39 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 21:08:41 +0200 <yushyin> can we stop this yahb2 spam? oO
2023-09-09 21:08:47 +0200 <blomberg> no no but it does a textual replacement in expressions, so y=x+1 ... and so on
2023-09-09 21:09:06 +0200 <institor> % let x = 42 in let x = x + 2 in print x
2023-09-09 21:09:06 +0200 <blomberg> since x is not a function at the RHS but an expression
2023-09-09 21:09:08 +0200 <yahb2> <timeout>
2023-09-09 21:09:12 +0200 <institor> heh
2023-09-09 21:10:58 +0200 <institor> % callCommand "mount | sed -n '9,$p'"
2023-09-09 21:10:58 +0200 <yahb2> <interactive>:5:1: error: ; Variable not in scope: callCommand :: String -> t
2023-09-09 21:11:05 +0200 <institor> % :module +System.Process
2023-09-09 21:11:05 +0200 <yahb2> <no output>
2023-09-09 21:11:07 +0200 <institor> % callCommand "mount | sed -n '9,$p'"
2023-09-09 21:11:07 +0200 <yahb2> /dev/sda1 on /home/tom/.ghcup/ghc type ext4 (ro,nosuid,nodev,relatime,discard) ; /dev/sda1 on /home/tom/.ghcup/cache type ext4 (ro,nosuid,nodev,relatime,discard) ; /dev/sda1 on /workdir type ext4 (...
2023-09-09 21:11:14 +0200 <monochrom> institor: You should do those in PM.
2023-09-09 21:12:53 +0200 <geekosaur> institor: /query yahb2
2023-09-09 21:13:10 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-09 21:13:27 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 21:13:33 +0200 <[exa]> segfaultfizzbuzz: LLMs are good for languages, not for programs :D
2023-09-09 21:14:10 +0200 <monochrom> That doesn't matter in the long run, based on experience with spreadsheets.
2023-09-09 21:14:56 +0200 <[exa]> rofl
2023-09-09 21:15:06 +0200 <monochrom> Spreadsheets are good for lots of numbers and arithmetic on them. Look how people actually use it for everything else ranging from databases to programming.
2023-09-09 21:15:06 +0200 <mauke> are they good for languages?
2023-09-09 21:15:19 +0200hays(rootvegeta@fsf/member/hays)
2023-09-09 21:16:17 +0200 <monochrom> Before you know it, people will ignore you when you say "LLMs are good for languages, not for truth and fact-checking".
2023-09-09 21:16:42 +0200 <geekosaur> they aloready do
2023-09-09 21:16:50 +0200 <blomberg> chatGPT is offtopic i have a serious question about recursion
2023-09-09 21:17:01 +0200 <mauke> better ask to ask, first
2023-09-09 21:17:10 +0200 <mauke> </sarcasm>
2023-09-09 21:17:52 +0200 <blomberg> x=5; f a b = x where x=x+1 ; versus
2023-09-09 21:18:01 +0200 <blomberg> x=5; f a b = y where y=x+1
2023-09-09 21:18:29 +0200 <blomberg> x=5; f a b = x where x=1
2023-09-09 21:18:55 +0200 <mauke> it's the first one
2023-09-09 21:18:59 +0200 <blomberg> now in these 3 situations in all of them it should behave like an expression,
2023-09-09 21:19:00 +0200 <[exa]> blomberg: in the first case the definition x=5 is neglected; it is equivalent to `z=5; f a b = x where x=x+1`
2023-09-09 21:19:20 +0200 <mauke> none of those are expressions, so I'm not sure what "it" is
2023-09-09 21:19:24 +0200 <[exa]> blomberg: local definitions shadow everything including their own contents
2023-09-09 21:19:56 +0200 <monochrom> Where is the recursion?
2023-09-09 21:20:03 +0200 <blomberg> wow that's dope monochrom x=x+1
2023-09-09 21:20:09 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 21:20:30 +0200Lycurgus(~juan@user/Lycurgus)
2023-09-09 21:21:05 +0200 <blomberg> [exa]: so x=x+1 ; the LHS is equiv to a function not a variable
2023-09-09 21:21:22 +0200 <blomberg> but in other cases it was a variable,?
2023-09-09 21:21:25 +0200 <[exa]> blomberg: these are the same, both are values
2023-09-09 21:21:28 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-09 21:21:56 +0200 <mauke> "a function not a variable" is a category error
2023-09-09 21:22:30 +0200lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-09-09 21:22:40 +0200 <institor> (\f -> f 42) (+ 2)
2023-09-09 21:22:45 +0200 <institor> % (\f -> f 42) (+ 2)
2023-09-09 21:22:45 +0200 <yahb2> 44
2023-09-09 21:22:48 +0200 <blomberg> but y=x+1 here x is a substituted value, in x=x+1 => x=5+1 ; you just do "text" replacement
2023-09-09 21:23:23 +0200 <blomberg> [exa]:if the RHS of x=x+1 is a value then it will do substitution x=5+1
2023-09-09 21:23:40 +0200 <mauke> I don't know of any Haskell implementation that does text replacement
2023-09-09 21:23:45 +0200 <integral> if you're doing text replacement, they you need to know that sometimes you have to rename variables
2023-09-09 21:23:47 +0200 <mauke> functions are values
2023-09-09 21:23:49 +0200 <yushyin> whatever this 'text' replacment is, it is not the semantic of the haskell language
2023-09-09 21:23:52 +0200 <blomberg> the x is "calling it's previous definition as a function"
2023-09-09 21:24:05 +0200 <blomberg> that function call is occuring ; so x is a function!!
2023-09-09 21:24:11 +0200 <probie> No, because the `x` that is referred to on the LHS in `x=x+1` is the one you're currently defining (i.e the one on the RHS), not one in an outer scope. Bindings in Haskell are recursive, there is no separate `letrec`
2023-09-09 21:24:14 +0200 <[exa]> blomberg: unevaluated values are values too
2023-09-09 21:24:51 +0200 <erisco> blomberg, sounds like you're working with some Haskell code?
2023-09-09 21:24:53 +0200 <blomberg> integral: you are right
2023-09-09 21:25:02 +0200danza__(~francesco@151.44.164.112) (Remote host closed the connection)
2023-09-09 21:25:12 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 21:25:21 +0200 <probie> > let ones = 1:ones in take 10 ones
2023-09-09 21:25:23 +0200 <lambdabot> [1,1,1,1,1,1,1,1,1,1]
2023-09-09 21:25:26 +0200danza__(~francesco@151.44.164.112)
2023-09-09 21:25:29 +0200 <blomberg> but it's scope is outer; integral look at previous conversation, so it wasn't predefined in the local scope
2023-09-09 21:26:11 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 21:26:12 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-09-09 21:26:13 +0200 <blomberg> probie: ones is a function not a variable
2023-09-09 21:26:24 +0200Lycurgus(~juan@user/Lycurgus) (Quit: Tschüss)
2023-09-09 21:27:16 +0200 <probie> blomberg: It's not a function. It's a (lifted) value
2023-09-09 21:27:27 +0200 <blomberg> the actual reason i got it; it's because of reassignment as integral said, it looks like that so it's made a functional call
2023-09-09 21:27:31 +0200 <monochrom> Can we disagree on a more important question instead?
2023-09-09 21:28:11 +0200 <integral> I don't think what I said was very relevant
2023-09-09 21:28:30 +0200 <blomberg> integral what's your take on it
2023-09-09 21:28:45 +0200 <blomberg> it looked like a reassignment hence the issue
2023-09-09 21:29:09 +0200 <mauke> thank god you already know haskell so we don't have to argue over basics
2023-09-09 21:29:20 +0200 <blomberg> but x=10 ; too looks like reassignment and that is surprisingly not prohibited
2023-09-09 21:29:21 +0200danza__(~francesco@151.44.164.112) (Remote host closed the connection)
2023-09-09 21:29:31 +0200 <probie> blomberg: is x a function in `x = 1 + 2`?
2023-09-09 21:29:35 +0200 <yushyin> it's not reassignment, lol
2023-09-09 21:29:45 +0200danza__(~francesco@151.44.164.112)
2023-09-09 21:29:57 +0200 <blomberg> mauke:? is that sarcasam or you just saying that i know
2023-09-09 21:29:57 +0200 <erisco> blomberg, what code were you working on that lead you to join #haskell? I'd like to take a look at it
2023-09-09 21:30:08 +0200 <mauke> blomberg: heavy sarcasm
2023-09-09 21:30:42 +0200 <monochrom> "fundamentals of FP"
2023-09-09 21:31:00 +0200 <integral> variable binding isn't much like assignment at all, imho
2023-09-09 21:31:01 +0200 <institor> :28:12 institor | blomberg: i recommend reading the book "Learn You a Haskell"
2023-09-09 21:31:03 +0200 <institor> :28:35 institor | speaking of fundamentals...
2023-09-09 21:31:05 +0200 <monochrom> There is a reason I brought up "armchair philosophers" a while ago.
2023-09-09 21:31:09 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 21:32:06 +0200 <institor> wow that was an hour ago
2023-09-09 21:32:08 +0200 <institor> time to go
2023-09-09 21:34:19 +0200 <blomberg> yushyin: x is not a function in `x = 1 + 2`
2023-09-09 21:34:54 +0200 <blomberg> but if something does recursion like in `x = x + 1` instead all i get is heavy sarcasm from monochrom
2023-09-09 21:35:09 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 258 seconds)
2023-09-09 21:35:10 +0200 <blomberg> monochrom: is a bad man
2023-09-09 21:36:22 +0200 <blomberg> yushyin: integral [exa] if something does recursion isn't it a function
2023-09-09 21:36:26 +0200 <yushyin> the `x` in `x = x + 1` is `x = x + 1` but it doesn't have the type of a function
2023-09-09 21:36:43 +0200 <[exa]> blomberg: no
2023-09-09 21:37:05 +0200 <[exa]> blomberg: you never saw recursive values in python?
2023-09-09 21:37:27 +0200 <blomberg> [exa]:i have ?? only function do those in python
2023-09-09 21:37:37 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 21:37:54 +0200 <mauke> > let { ones = 1 : ones } in ones -- as seen before. this is a list, not a function
2023-09-09 21:37:55 +0200 <lambdabot> [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1...
2023-09-09 21:37:56 +0200 <[exa]> blomberg: ok and why is that?
2023-09-09 21:37:59 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142)
2023-09-09 21:38:14 +0200 <blomberg> then what is the type in x=x+1
2023-09-09 21:38:26 +0200 <mauke> Int
2023-09-09 21:38:30 +0200 <blomberg> what determines a function type in haskell
2023-09-09 21:38:48 +0200 <geekosaur> having parameters
2023-09-09 21:38:54 +0200 <blomberg> right
2023-09-09 21:39:29 +0200 <geekosaur> in the case of `x=x+11`, the type is resolved as Integer because of the `+1` and type defaulting
2023-09-09 21:39:37 +0200 <blomberg> that's what i was thinking but it's just in haskell, x=x+1 undergoes recursion so outside haskell it's a function... using logic , it's a language thing
2023-09-09 21:39:57 +0200 <mauke> I don't know any language where 'x=x+1' is a function
2023-09-09 21:41:02 +0200 <blomberg> mauke: your list example was good
2023-09-09 21:41:20 +0200 <[exa]> blomberg: what I wanted to say, in python the values are super restricted so you need recursion. In haskell the values can recurse themselves without being actual functions. The intermediate step (something that behaves like a function but is already parameterless value) is called a thunk
2023-09-09 21:41:20 +0200 <blomberg> ones was a list of 1,1, so yeah
2023-09-09 21:41:32 +0200pavonia(~user@user/siracusa)
2023-09-09 21:41:38 +0200 <[exa]> blomberg: suggest googling the 'thunk' concept, I think wiki has a good article on that
2023-09-09 21:41:45 +0200 <blomberg> [exa]: great point
2023-09-09 21:41:47 +0200 <mauke> don't need thunks for recursive data
2023-09-09 21:42:04 +0200 <blomberg> it's like BNF grammar recursion
2023-09-09 21:42:22 +0200 <mauke> const struct node x = { 42, &x }; // is a perfectly cromulent C definition
2023-09-09 21:42:41 +0200 <EvanR> hey look, OOP
2023-09-09 21:42:47 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 21:42:52 +0200robbert-vdh(~robbert@robbertvanderhelm.nl) (Server closed connection)
2023-09-09 21:42:54 +0200 <institor> don't insult C like that
2023-09-09 21:43:17 +0200robbert-vdh(~robbert@robbertvanderhelm.nl)
2023-09-09 21:43:27 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 21:43:45 +0200 <monochrom> don't insult OOP like that >:)
2023-09-09 21:44:17 +0200 <mauke> don't.
2023-09-09 21:44:25 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-09-09 21:44:26 +0200 <geekosaur> let's insult both at once? I give you Xt
2023-09-09 21:45:06 +0200 <[exa]> blomberg: other view, to have something "unevaluated" in python you need a parameterless function to keep it from evaluating until you call it. In haskell, parameterless function are indistinguishable from values, and because of laziness you don't hit the problem with having to keep it explicitly unevaluated.
2023-09-09 21:45:30 +0200danza__(~francesco@151.44.164.112) (Ping timeout: 246 seconds)
2023-09-09 21:45:56 +0200 <[exa]> blomberg: apart of that, functions are values too, and to keep the dictionary useful people call "values that can accept parameters" functions
2023-09-09 21:46:11 +0200 <[exa]> blomberg: please try to use this ^ haskell naming in #haskell channel :]
2023-09-09 21:48:28 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 21:54:59 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 21:59:49 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 250 seconds)
2023-09-09 22:00:38 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 22:02:52 +0200 <blomberg> x |x<2=1;|otherwise = 2; this is another case in which it's returning without arguments and "looks" superficially like a function
2023-09-09 22:03:15 +0200 <mauke> that ; is technically wrong
2023-09-09 22:03:24 +0200 <mauke> but yes
2023-09-09 22:04:06 +0200 <[exa]> blomberg: yeah, a thunk which evaluates forever
2023-09-09 22:04:52 +0200 <blomberg> this one doesn't
2023-09-09 22:05:10 +0200billchenchina(~billchenc@2a0c:b641:7a2:320:ee3e:47ca:6070:d71a) (Quit: Leaving)
2023-09-09 22:05:16 +0200 <[exa]> blomberg: how come?
2023-09-09 22:05:29 +0200 <mauke> because neither 1 nor 2 loops
2023-09-09 22:05:35 +0200 <mauke> er
2023-09-09 22:05:38 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 22:05:39 +0200 <mauke> no, I'm wrong
2023-09-09 22:05:40 +0200 <blomberg> it does
2023-09-09 22:05:49 +0200 <mauke> sorry, I misread the guard
2023-09-09 22:05:56 +0200 <blomberg> mauke:i realized before you... this show i know haskell
2023-09-09 22:06:06 +0200 <yushyin> wow
2023-09-09 22:06:07 +0200 <monochrom> I once wrote some code like that and it took me 5 minutes to realize why it hanged.
2023-09-09 22:06:08 +0200geekosaur*eyeroll*
2023-09-09 22:06:17 +0200 <[exa]> haskell = learned
2023-09-09 22:06:18 +0200 <[exa]> next!
2023-09-09 22:06:20 +0200 <mauke> You rolled a 3.
2023-09-09 22:06:36 +0200 <EvanR> *raises hand* why does it loop what is this shenanigan
2023-09-09 22:06:56 +0200 <mauke> EvanR: let x = if x < 2 then 1 else 2
2023-09-09 22:07:19 +0200 <EvanR> oh
2023-09-09 22:07:50 +0200 <monochrom> OK I'm in good company. :)
2023-09-09 22:07:53 +0200 <EvanR> x=1 and x=2 both solve it!
2023-09-09 22:08:34 +0200 <EvanR> haskell is broken
2023-09-09 22:08:39 +0200 <mauke> UP TACK
2023-09-09 22:08:57 +0200 <EvanR> that too
2023-09-09 22:09:42 +0200 <monochrom> Actually Ralf Hinze noticed and pointed out the connection between non-termination and having more than one solutions.
2023-09-09 22:09:57 +0200jackneill__(~Jackneill@20014C4E1E101A00392465011B960A73.dsl.pool.telekom.hu) (Ping timeout: 245 seconds)
2023-09-09 22:10:30 +0200 <geekosaur> "the following sentence is true. the preceding sentence is false."
2023-09-09 22:12:09 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 22:13:07 +0200 <blomberg> x=5; f a b = (g x) ; x=1 ; --after calling (g x) function can i assign x via some haskell syntax and hopefully get an error
2023-09-09 22:13:50 +0200 <blomberg> the above code is a semantic wish to first call g x as a parameter and then assign x
2023-09-09 22:14:28 +0200 <mauke> "can i assign" <- no
2023-09-09 22:14:33 +0200 <mauke> this is haskell
2023-09-09 22:14:51 +0200cafkafk_(~cafkafk@fsf/member/cafkafk) (Ping timeout: 246 seconds)
2023-09-09 22:15:02 +0200[_________](~oos95GWG@user/oos95GWG) (Server closed connection)
2023-09-09 22:15:12 +0200 <EvanR> in before blomberg does exactly that in GHCI proving you all wrong!
2023-09-09 22:15:17 +0200 <mauke> heh
2023-09-09 22:15:21 +0200[_________](~oos95GWG@user/oos95GWG)
2023-09-09 22:15:21 +0200 <geekosaur> that looks like something which ghci would accept because it shadows the old `x`, but a compiled program would reject as a redefinition
2023-09-09 22:15:29 +0200 <mauke> EvanR: can't be, they hate monads
2023-09-09 22:15:30 +0200 <mauke> and let
2023-09-09 22:15:38 +0200 <geekosaur> % :set -Werror=name-shadowing
2023-09-09 22:15:38 +0200 <yahb2> <no output>
2023-09-09 22:16:05 +0200 <EvanR> one weird trick to reassign variables, haskell will hate this
2023-09-09 22:16:05 +0200 <geekosaur> % g x = x + 1
2023-09-09 22:16:05 +0200 <yahb2> <no output>
2023-09-09 22:16:13 +0200cafkafk_(~cafkafk@fsf/member/cafkafk)
2023-09-09 22:16:16 +0200 <geekosaur> % x=5; f a b = (g x) ; x=1
2023-09-09 22:16:16 +0200 <yahb2> <interactive>:41:22: error: ; Multiple declarations of ‘x’ ; Declared at: <interactive>:41:1 ; <interactive>:41:22
2023-09-09 22:16:59 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 244 seconds)
2023-09-09 22:17:09 +0200 <int-e> % x | x <- x = x where x = 42
2023-09-09 22:17:09 +0200 <yahb2> <interactive>:43:5: error: [-Wname-shadowing, -Werror=name-shadowing] ; This binding for ‘x’ shadows the existing binding ; bound at <interactive>:43:22 ; ; <interactive>:43:22: error: [...
2023-09-09 22:17:29 +0200 <mauke> ; ;
2023-09-09 22:18:16 +0200 <geekosaur> right, not on the same line though (re my getting an actual error)
2023-09-09 22:18:24 +0200 <geekosaur> ghci is a bit weird
2023-09-09 22:18:39 +0200 <geekosaur> :set -wname-binding
2023-09-09 22:18:44 +0200 <geekosaur> % :set -wname-binding
2023-09-09 22:18:44 +0200 <yahb2> Some flags have not been recognized: -wname-binding
2023-09-09 22:18:52 +0200 <geekosaur> % :set -Wno-name-binding
2023-09-09 22:18:52 +0200 <yahb2> <no location info>: warning: [-Wunrecognised-warning-flags] ; unrecognised warning flag: -Wno-name-binding
2023-09-09 22:19:03 +0200 <geekosaur> % :set -wname-shadowinging
2023-09-09 22:19:04 +0200 <yahb2> Some flags have not been recognized: -wname-shadowinging
2023-09-09 22:19:11 +0200 <geekosaur> damn I'm doing good today
2023-09-09 22:19:14 +0200 <geekosaur> % :set -wname-shadowing
2023-09-09 22:19:14 +0200 <yahb2> Some flags have not been recognized: -wname-shadowing
2023-09-09 22:19:18 +0200 <blomberg> x=5; f a b = (g x) ; x=1; -- geekosaur is x=1 outside the function scope.. then x=1 should give an error
2023-09-09 22:19:22 +0200 <geekosaur> % :set -Wno-name-shadowing
2023-09-09 22:19:23 +0200 <yahb2> <no output>
2023-09-09 22:19:28 +0200 <monochrom> Is it -W instead of -w ?
2023-09-09 22:19:34 +0200 <monochrom> heh ok
2023-09-09 22:20:01 +0200 <geekosaur> I was thinking like gcc where -W makes it a warning and -w makes it not a warning, but ghc uses -Wno- instead
2023-09-09 22:20:14 +0200 <geekosaur> just trying to save a couple characters
2023-09-09 22:21:22 +0200 <blomberg> if inside a function i call (g x) can i then reassign x as it was the first assignment in the local scope
2023-09-09 22:21:54 +0200 <geekosaur> but once you are outside the function you are back in the global scope, where x is already defined so you get an error
2023-09-09 22:22:09 +0200 <geekosaur> [09 20:16:16] <yahb2> <interactive>:41:22: error: ; Multiple declarations of ‘x’ ; Declared at: <interactive>:41:1 ; <interactive>:41:22
2023-09-09 22:22:15 +0200 <mauke> "can i then reassign" <- no, this is haskell
2023-09-09 22:22:46 +0200 <blomberg> mauke:inside the function after feeding x as a parameter to g which is some other function
2023-09-09 22:22:50 +0200 <geekosaur> if you do it on multiple lines, though, it "works" because the new "x" shadows the old one. but "f" still uses the value that was in scope at the time
2023-09-09 22:22:58 +0200 <EvanR> > let x = 4 in let x = 5 in x
2023-09-09 22:22:59 +0200 <lambdabot> 5
2023-09-09 22:23:04 +0200 <blomberg> it is language dependent behaviour
2023-09-09 22:23:15 +0200 <mauke> blomberg: we don't have assignment
2023-09-09 22:23:18 +0200 <mauke> except in class
2023-09-09 22:23:56 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 22:25:16 +0200segfaultfizzbuzz(~segfaultf@12.172.217.142) (Ping timeout: 248 seconds)
2023-09-09 22:28:42 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 245 seconds)
2023-09-09 22:30:42 +0200 <blomberg> mauke: then what do you have if not assignment
2023-09-09 22:31:02 +0200 <mauke> binding
2023-09-09 22:31:53 +0200 <geekosaur> which is read-only, unlike assignment: once bound, forever it has that value
2023-09-09 22:32:30 +0200 <Rembane> This makes it possible to use equational reasoning which is quite useful.
2023-09-09 22:33:17 +0200libertyprime(~libertypr@203.96.203.44)
2023-09-09 22:34:04 +0200L29Ah(~L29Ah@wikipedia/L29Ah) ()
2023-09-09 22:35:23 +0200 <EvanR> x = 4 is an equation
2023-09-09 22:35:24 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 22:35:48 +0200 <EvanR> unlike in C
2023-09-09 22:36:06 +0200 <mauke> still directional, though. can't say 4 = x
2023-09-09 22:36:21 +0200 <EvanR> > let 4 = 5 in 4
2023-09-09 22:36:22 +0200 <lambdabot> 4
2023-09-09 22:36:30 +0200 <EvanR> you're right
2023-09-09 22:36:35 +0200 <EvanR> I think
2023-09-09 22:36:43 +0200 <mauke> > let 4 = x in x
2023-09-09 22:36:44 +0200 <lambdabot> x
2023-09-09 22:36:52 +0200 <EvanR> makes sense
2023-09-09 22:37:14 +0200 <EvanR> > let 4 = 4 in 4
2023-09-09 22:37:15 +0200 <lambdabot> 4
2023-09-09 22:37:20 +0200 <EvanR> :thumbsup:
2023-09-09 22:38:03 +0200L29Ah(~L29Ah@wikipedia/L29Ah)
2023-09-09 22:39:09 +0200 <blomberg> so inside a function if i make another functional call (g x) but use x as a parameter and then bind x=1; will it work
2023-09-09 22:39:34 +0200 <EvanR> depends on what you mean by "and then"
2023-09-09 22:39:36 +0200 <integral> "and then"?
2023-09-09 22:39:51 +0200 <blomberg> use where or some trick
2023-09-09 22:39:51 +0200libertyprime(~libertypr@203.96.203.44) (Ping timeout: 248 seconds)
2023-09-09 22:40:02 +0200 <EvanR> it's also trivially testable by you
2023-09-09 22:40:16 +0200 <blomberg> but i don't have ghci
2023-09-09 22:40:24 +0200 <mauke> there's online REPLs
2023-09-09 22:40:43 +0200 <monochrom> There is https://play.haskell.org/
2023-09-09 22:40:48 +0200 <mauke> https://tio.run/#haskell
2023-09-09 22:40:48 +0200 <blomberg> ahh
2023-09-09 22:41:51 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 22:42:25 +0200 <EvanR> or private message lambdabot
2023-09-09 22:42:32 +0200 <blomberg> so functional syntax doesn't allow binding after a nested functional call like inside f there is g
2023-09-09 22:42:57 +0200 <blomberg> and after (g x) x=1
2023-09-09 22:43:02 +0200 <EvanR> > sqrt(let x = sqrt 2 in x)
2023-09-09 22:43:03 +0200 <lambdabot> 1.189207115002721
2023-09-09 22:43:26 +0200 <blomberg> via some trick using where
2023-09-09 22:43:33 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 22:45:00 +0200 <blomberg> EvanR:inside function f ; not (f ( ...)) not inside arguments
2023-09-09 22:45:07 +0200 <blomberg> > sqrt(2)
2023-09-09 22:45:09 +0200 <lambdabot> 1.4142135623730951
2023-09-09 22:45:25 +0200 <blomberg> why is this prefix notation working
2023-09-09 22:45:31 +0200 <mauke> > (sqrt)2
2023-09-09 22:45:32 +0200 <lambdabot> 1.4142135623730951
2023-09-09 22:45:44 +0200 <blomberg> ok
2023-09-09 22:45:46 +0200 <mauke> the parentheses are redundant but harmless
2023-09-09 22:46:20 +0200 <int-e> > sqrt 2 -- you have this, with extra (redundant) parentheses
2023-09-09 22:46:21 +0200 <lambdabot> 1.4142135623730951
2023-09-09 22:46:23 +0200 <mauke> the syntax for function application is putting two terms next to each other
2023-09-09 22:46:32 +0200 <int-e> > ((sqrt) (2))
2023-09-09 22:46:34 +0200 <lambdabot> 1.4142135623730951
2023-09-09 22:46:35 +0200int-eshrugs
2023-09-09 22:47:38 +0200 <monochrom> > sqrt$2
2023-09-09 22:47:39 +0200 <lambdabot> 1.4142135623730951
2023-09-09 22:47:49 +0200 <monochrom> "spreadsheet syntax"
2023-09-09 22:48:10 +0200 <integral> > sqrt `id` 2
2023-09-09 22:48:11 +0200 <lambdabot> 1.4142135623730951
2023-09-09 22:48:13 +0200 <int-e> > sqrt (1 + 1) -- I'd actually never omit this space except for silly things (obfuscation and golfing)
2023-09-09 22:48:18 +0200 <lambdabot> 1.4142135623730951
2023-09-09 22:49:01 +0200 <monochrom> You can save some space and be like sqrt`id`2, too
2023-09-09 22:49:14 +0200 <int-e> To avoid the overlap with the f(x,y,z) function application syntax in various other languages that Haskell doesn't have.
2023-09-09 22:49:17 +0200 <mauke> > sqrt1+1
2023-09-09 22:49:18 +0200 <monochrom> One more example:
2023-09-09 22:49:18 +0200 <lambdabot> 1.4142135623730951
2023-09-09 22:49:25 +0200 <monochrom> > length"abc"
2023-09-09 22:49:26 +0200 <lambdabot> 3
2023-09-09 22:49:37 +0200 <EvanR> ok that missing space really derailed everything thanks blomberg
2023-09-09 22:49:59 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 22:50:10 +0200 <mauke> can't be derailed if you never were on track.jpg
2023-09-09 22:50:32 +0200 <int-e> is this why cars are so popular
2023-09-09 22:50:33 +0200 <monochrom> What is there to derail?
2023-09-09 22:51:27 +0200ulysses4ever(~artem@2601:249:4380:8950:f474:e3f8:9806:671)
2023-09-09 22:51:27 +0200artem(~artem@2601:249:4380:8950:f474:e3f8:9806:671) (Read error: Connection reset by peer)
2023-09-09 22:51:46 +0200 <blomberg> what is there to thank, unless it's a joke
2023-09-09 22:54:25 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-09 22:55:02 +0200 <blomberg> EvanR: did you mean derail the conversation ?
2023-09-09 22:55:31 +0200 <blomberg> i am always on track
2023-09-09 22:56:53 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 22:59:38 +0200 <blomberg> x=5;f a b = z+x where z=(g x) x=1 ; -- can i do that
2023-09-09 23:00:19 +0200artem(~artem@73.145.240.162)
2023-09-09 23:00:38 +0200 <blomberg> x=5;f a b = z+x where x=1 z=(g x) ; -- order reversed
2023-09-09 23:01:09 +0200 <EvanR> try it and see
2023-09-09 23:01:19 +0200 <mauke> .code.tio.hs:4:6: error: Variable not in scope: g
2023-09-09 23:01:22 +0200 <blomberg> i mean is it functional the first one
2023-09-09 23:01:26 +0200 <blomberg> conceptually
2023-09-09 23:01:33 +0200 <mauke> blomberg: https://tio.run/##y0gszk7Nyfn/v8LWlCtNIVEhScFWoUq7gktBoTwjtSgVSFfZaqQrVGgCWRW2hlxcuYmZeUA1RaklpUV5Chqa//8DAA
2023-09-09 23:01:39 +0200 <blomberg> since i called x as a parameter but didn't assign it
2023-09-09 23:01:59 +0200ulysses4ever(~artem@2601:249:4380:8950:f474:e3f8:9806:671) (Ping timeout: 246 seconds)
2023-09-09 23:02:01 +0200 <EvanR> your code doesn't even compile
2023-09-09 23:02:12 +0200 <EvanR> fix it and try again
2023-09-09 23:04:14 +0200 <blomberg> g a = a; x=5;f a b = z+x where z=(g x) x=1 -- [1 of 1] Compiling Main ( .code.tio.hs, .code.tio.o )
2023-09-09 23:04:14 +0200artem(~artem@73.145.240.162) (Read error: Connection reset by peer)
2023-09-09 23:04:16 +0200 <blomberg> Linking .bin.tio ...
2023-09-09 23:04:28 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-09 23:04:51 +0200 <blomberg> main = return () --what's that
2023-09-09 23:04:57 +0200 <blomberg> is it repl specific
2023-09-09 23:05:11 +0200 <mauke> that's the main program
2023-09-09 23:05:17 +0200 <geekosaur> it's because tio is not actually a repl, it rquires a program
2023-09-09 23:05:19 +0200 <mauke> tio isn't a repl
2023-09-09 23:05:27 +0200 <blomberg> so let me guess, it loops to main start of the file
2023-09-09 23:05:33 +0200 <mauke> wat
2023-09-09 23:05:35 +0200 <geekosaur> so if you're just testing to see if something compiles you must supply a dummy program that does nothing
2023-09-09 23:05:57 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 23:06:06 +0200wroathe(~wroathe@50.205.197.50)
2023-09-09 23:06:06 +0200wroathe(~wroathe@50.205.197.50) (Changing host)
2023-09-09 23:06:06 +0200wroathe(~wroathe@user/wroathe)
2023-09-09 23:07:24 +0200cptaffe(~ZNC@99-47-99-155.lightspeed.ltrkar.sbcglobal.net) (Quit: ZNC 1.8.2 - https://znc.in)
2023-09-09 23:07:56 +0200 <blomberg> https://tio.run/##DYqxDoAgDAX3fsUbIU5qHPsxmBQwIgNqbPh57HR3yeVwn1LKGAkBjEDKG0Xz3apPSsCXpYmxs0tQb6Y8k4tYsHq6wlFtbfK8rcL5MX4
2023-09-09 23:08:14 +0200cptaffe(~ZNC@2600:1700:f08:111f::18e7)
2023-09-09 23:08:44 +0200 <mauke> you can't just put a random expression in a file like that
2023-09-09 23:08:52 +0200 <mauke> a haskell file is a module. a module is a sequence of declarations
2023-09-09 23:09:07 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Remote host closed the connection)
2023-09-09 23:09:15 +0200 <blomberg> Parse error: module header, import declaration ; -- i didn't import anything
2023-09-09 23:09:34 +0200 <mauke> exactly
2023-09-09 23:09:42 +0200 <mauke> if you did, it wouldn't be an error
2023-09-09 23:10:02 +0200 <blomberg> ??
2023-09-09 23:10:26 +0200 <mauke> the full message reads: "module header, import declaration or top-level declaration expected."
2023-09-09 23:10:45 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-09 23:10:46 +0200 <blomberg> what's the fix
2023-09-09 23:10:46 +0200 <mauke> meaning, you can only put those three things at the top level of a module
2023-09-09 23:10:53 +0200 <mauke> depends on what you were trying to do
2023-09-09 23:11:03 +0200 <geekosaur> I thought you claimed to know Haskell
2023-09-09 23:11:05 +0200 <blomberg> it's called not helping
2023-09-09 23:11:17 +0200 <blomberg> ofc i know everything except fixing it
2023-09-09 23:11:30 +0200 <mauke> oh, then you won't need my help
2023-09-09 23:11:35 +0200 <mauke> and here I almost sent you https://tio.run/##DYo7CoAwEAX7PcUrDVYqlnuYFfLDGCQKLrl83GpmYJI8py9ljAgBQ0h5p2B@WPVZCfiSb97YeYpQZ6a8EF2Sqz13y/XFFLBic2P8
2023-09-09 23:12:58 +0200cptaffe(~ZNC@2600:1700:f08:111f::18e7) (Client Quit)
2023-09-09 23:13:53 +0200cptaffe(~ZNC@99-47-99-155.lightspeed.ltrkar.sbcglobal.net)
2023-09-09 23:14:31 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 23:15:16 +0200 <blomberg> thx for your
2023-09-09 23:15:18 +0200 <blomberg> main = print (f 2 3)
2023-09-09 23:15:46 +0200 <blomberg> isn't that repl code or in real haskell file too it works
2023-09-09 23:15:55 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 23:16:50 +0200 <EvanR> a cool guy move is to import your module into ghci then type: main
2023-09-09 23:16:54 +0200 <EvanR> to run your program from ghci
2023-09-09 23:17:08 +0200 <EvanR> redefining and shadowing main stops you from doing that
2023-09-09 23:17:49 +0200 <EvanR> don't be uncool
2023-09-09 23:18:19 +0200 <blomberg> hey i can return z+x but why not the list [z x]
2023-09-09 23:18:33 +0200 <blomberg> https://tio.run/##y0gszk7Nyfn/P10hUcFWIZGrwtbUgCsNyEkCcqOrFCpiuRQUyjNSi1KBdJWtRrpCha6RgSaQU2FraMzFlZuYmQdUWVCUmVeioJGmYKRgrPn/PwA
2023-09-09 23:18:55 +0200 <EvanR> [z,x]
2023-09-09 23:19:01 +0200 <EvanR> [1,2,3,4]
2023-09-09 23:19:15 +0200 <EvanR> z x is function application
2023-09-09 23:19:38 +0200 <blomberg> ahh sorry i learnt haskell perfectly with your answer
2023-09-09 23:20:00 +0200cptaffe(~ZNC@99-47-99-155.lightspeed.ltrkar.sbcglobal.net) (Quit: ZNC 1.8.2 - https://znc.in)
2023-09-09 23:20:05 +0200acidjnk(~acidjnk@p200300d6e7072f47b0cfe67efeb6b056.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-09-09 23:20:51 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 250 seconds)
2023-09-09 23:20:55 +0200stites(~stites@130.44.147.204) (Ping timeout: 248 seconds)
2023-09-09 23:21:04 +0200stites(~stites@2607:fb91:dcf:4896:22a5:6d79:f786:b171)
2023-09-09 23:21:14 +0200cptaffe(~ZNC@2600:1700:f08:111f::18e7)
2023-09-09 23:25:00 +0200 <blomberg> the crazy part in haskell is i can do z=(g x) first then x=13 and it works as if order doesn't matter
2023-09-09 23:25:04 +0200 <blomberg> that's like nuts
2023-09-09 23:25:45 +0200adamCS(~adamCS@ec2-34-207-160-255.compute-1.amazonaws.com) (Server closed connection)
2023-09-09 23:25:49 +0200 <blomberg> it's like it's running simultaneously
2023-09-09 23:26:01 +0200adamCS(~adamCS@ec2-34-207-160-255.compute-1.amazonaws.com)
2023-09-09 23:27:38 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 23:27:59 +0200 <blomberg> where does it simultaneously
2023-09-09 23:28:28 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-09 23:28:40 +0200 <geekosaur> order does not in fact matter; bindings are solved as a group
2023-09-09 23:28:42 +0200 <blomberg> i was expect x to be fetched from the outer scope
2023-09-09 23:28:50 +0200 <geekosaur> that never happens
2023-09-09 23:29:00 +0200 <blomberg> is it a functional thing that bindings are nuts
2023-09-09 23:29:06 +0200 <blomberg> and now it's fucked
2023-09-09 23:29:30 +0200 <blomberg> geekosaur: it happens if no bindings for x exist
2023-09-09 23:29:47 +0200 <geekosaur> a binding exists, it just textually follows
2023-09-09 23:29:58 +0200 <geekosaur> bindings are solved as a group, not in some kind of order
2023-09-09 23:29:59 +0200 <EvanR> defining stuff out of order is a feature in many languages
2023-09-09 23:30:25 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-09-09 23:30:49 +0200 <blomberg> could it be in order and be pure FP
2023-09-09 23:31:25 +0200 <geekosaur> you could write them in order, sure. the question is, what order would you use with mutually recursive functions/values?
2023-09-09 23:31:48 +0200 <blomberg> geekosaur: if a binding exists then that's a reassignment
2023-09-09 23:31:57 +0200 <geekosaur> at least one of them has to be used before being defined, if you process them in textual order
2023-09-09 23:32:04 +0200 <geekosaur> there is no reassignment
2023-09-09 23:32:39 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-09 23:33:52 +0200 <blomberg> how could order of mutually recursive functions be different
2023-09-09 23:34:15 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-09 23:34:56 +0200 <geekosaur> that's for you to answer (literally, it's what I asked you: "the question is, …")
2023-09-09 23:35:28 +0200 <blomberg> my code is not mutually recursive
2023-09-09 23:35:34 +0200 <blomberg> no idea what code you had in mind
2023-09-09 23:36:10 +0200 <geekosaur> I was explaining why haskell has no order in definitions
2023-09-09 23:36:29 +0200 <geekosaur> you could not write mutually recursive definitions if it did
2023-09-09 23:36:52 +0200 <blomberg> yes, i couldn't grasp and imagine it myself what you are saying
2023-09-09 23:37:29 +0200fendor(~fendor@2a02:8388:1640:be00:c785:45ab:c70:9d3f) (Remote host closed the connection)
2023-09-09 23:37:36 +0200 <EvanR> > let onezero = 1:zeroone; zeroone = 0:onezero in onezero
2023-09-09 23:37:37 +0200 <lambdabot> [1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0...
2023-09-09 23:37:58 +0200 <EvanR> > let onezero = 1:zeroone; zeroone = 0:onezero in zeroone
2023-09-09 23:37:59 +0200 <lambdabot> [0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1...
2023-09-09 23:38:40 +0200 <geekosaur> note thatthe above works because of (1) laziness (2) both `onezero` and `zeroone` produce a partial result before recursing
2023-09-09 23:38:40 +0200 <EvanR> > let onezero = 1:zeroone; zeroone = 0:onezero in zipWith (+) onezero zeroone
2023-09-09 23:38:42 +0200 <lambdabot> [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1...
2023-09-09 23:39:10 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 23:39:14 +0200 <int-e> > iterate (1-) 0
2023-09-09 23:39:16 +0200 <lambdabot> [0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1...
2023-09-09 23:39:31 +0200 <geekosaur> this is the secret to productive self- or mutual recursion in Haskell
2023-09-09 23:39:51 +0200leah2(~leah@vuxu.org) (Ping timeout: 260 seconds)
2023-09-09 23:39:56 +0200 <EvanR> godammit geekosaur you told him the secret
2023-09-09 23:40:42 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-09-09 23:40:57 +0200 <EvanR> and (3) you don't have to write the definitions in order, because here you can't
2023-09-09 23:42:33 +0200 <blomberg> but it's true only inside where outside it, how can i use x even before defined!!
2023-09-09 23:43:08 +0200 <geekosaur> you're still stuck on stuff having to be defined in order. did we not just tell you why that doesn't work?
2023-09-09 23:43:15 +0200 <blomberg> where z=(g x) x=13
2023-09-09 23:43:25 +0200superryn(~superryn@47.186.178.98)
2023-09-09 23:43:33 +0200 <blomberg> imagine z=(g x); x=13
2023-09-09 23:44:00 +0200 <EvanR> javascript has the same thing, kind of
2023-09-09 23:44:22 +0200 <EvanR> you can define stuff later, after it's used
2023-09-09 23:44:36 +0200 <geekosaur> as long as it's defined in the same group of bindings
2023-09-09 23:45:19 +0200 <geekosaur> well, that's not true, in a haskell source file you can put something at the bottom and the thing using it at the top, the compiler sorts it out
2023-09-09 23:45:27 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds)
2023-09-09 23:45:37 +0200 <geekosaur> why should you the programmer have to care? let the compiler figure it out
2023-09-09 23:45:43 +0200 <EvanR> also many tutorials and explainers do the same thing. Talk about something before it's defined or explained
2023-09-09 23:46:02 +0200 <EvanR> sometimes saying "which will be covered in more detail below" or some such
2023-09-09 23:46:16 +0200 <blomberg> this is fucked it's making a fucking call before i even defined x
2023-09-09 23:46:42 +0200 <EvanR> your notion of time is defined by the orientation of your monitor?
2023-09-09 23:46:48 +0200 <EvanR> interesting
2023-09-09 23:46:56 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 23:47:34 +0200 <EvanR> gaming rig time machine
2023-09-09 23:49:26 +0200 <geekosaur> there are very, very few things in haskell which require you to stick to some specific order
2023-09-09 23:49:53 +0200 <geekosaur> aside from things like template haskell where it's run while the source file is being read so only the stuff above the splice is known yet
2023-09-09 23:50:17 +0200 <geekosaur> but for most things the compiler reads the whole file and then figures out how it all fits together
2023-09-09 23:50:35 +0200 <geekosaur> the programmer should not have to do that busywork, that's what we have computers for 🙂
2023-09-09 23:51:04 +0200 <EvanR> blomberg, python and ruby are odd ones out here, because they equate definitions with running actual code to store references in things
2023-09-09 23:51:14 +0200blomberg(~default_u@59.99.23.99) (Ping timeout: 258 seconds)
2023-09-09 23:51:18 +0200 <EvanR> most languages ...
2023-09-09 23:51:51 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds)
2023-09-09 23:53:16 +0200aaronv(~aaronv@user/aaronv) (Ping timeout: 248 seconds)
2023-09-09 23:54:22 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-09-09 23:55:17 +0200 <geekosaur> it's a distinction between "scripting languages" which evaluate as they go and "compiled languages" (not the best term, but the most common one here) which treat an entire source file as a group and can therefore build up pieces that are out of order
2023-09-09 23:56:44 +0200 <institor> javascript is compiled
2023-09-09 23:56:49 +0200 <geekosaur> ("compiled languages" there is a bad term because there's also "interpreted" vs. "compiled", but there are interpreted languages which still work on a source-file-unit basis and compiled languages which nevertheless evaluate in source file order)
2023-09-09 23:57:06 +0200 <EvanR> also javascript definitions can be out of order
2023-09-09 23:57:11 +0200stites(~stites@2607:fb91:dcf:4896:22a5:6d79:f786:b171) (Read error: Connection reset by peer)
2023-09-09 23:57:17 +0200 <EvanR> so not a contradiction!
2023-09-09 23:57:30 +0200 <geekosaur> it's all quite complicated how things like this interact
2023-09-09 23:57:32 +0200stites(~stites@2603:3005:b69:4100:afa0:f7be:6ecd:53f2)
2023-09-09 23:57:33 +0200mhatta(~mhatta@www21123ui.sakura.ne.jp) (Remote host closed the connection)
2023-09-09 23:57:40 +0200 <geekosaur> and even then there are various exceptions 🙂
2023-09-09 23:57:47 +0200arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-09 23:58:35 +0200nek0(~nek0@2a01:4f8:222:2b41::12) (Server closed connection)
2023-09-09 23:58:46 +0200mhatta(~mhatta@www21123ui.sakura.ne.jp)
2023-09-09 23:58:49 +0200nek0(~nek0@2a01:4f8:222:2b41::12)
2023-09-09 23:59:18 +0200 <yushyin> well, that was an interesting episode of #haskell
2023-09-09 23:59:31 +0200 <geekosaur> in particular, while haskell is generally compiled, there are two different ways to interpret it: with something like hugs or runghc, or ghci / ghc -e
2023-09-09 23:59:32 +0200 <yushyin> in a way