2023-09-09 00:01:31 +0200 | coot | (~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot) |
2023-09-09 00:04:35 +0200 | raym | (~ray@user/raym) (Server closed connection) |
2023-09-09 00:04:51 +0200 | raym | (~ray@user/raym) |
2023-09-09 00:19:02 +0200 | son0p | (~ff@186.121.39.74) (Quit: Bye) |
2023-09-09 00:22:39 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-09-09 00:25:02 +0200 | sinbad | (~sinbad@user/sinbad) () |
2023-09-09 00:25:30 +0200 | azimut | (~azimut@gateway/tor-sasl/azimut) (Ping timeout: 246 seconds) |
2023-09-09 00:27:03 +0200 | sm | (~sm@plaintextaccounting/sm) (Ping timeout: 248 seconds) |
2023-09-09 00:31:15 +0200 | aaronv | (~aaronv@user/aaronv) |
2023-09-09 00:37:11 +0200 | libertyprime | (~libertypr@203.96.203.44) (Ping timeout: 246 seconds) |
2023-09-09 00:37:12 +0200 | ulysses4ever | (~artem@2601:249:4380:8950:f474:e3f8:9806:671) (Read error: Connection reset by peer) |
2023-09-09 00:37:20 +0200 | ulysses4ever | (~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 +0200 | FinnElija | (~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 +0200 | libertyprime | (~libertypr@203.96.203.44) |
2023-09-09 00:56:08 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-09-09 01:00:07 +0200 | falafel | (~falafel@62.175.113.194.dyn.user.ono.com) (Ping timeout: 248 seconds) |
2023-09-09 01:00:49 +0200 | sm | (~sm@plaintextaccounting/sm) (Ping timeout: 258 seconds) |
2023-09-09 01:01:00 +0200 | Pickchea | (~private@user/pickchea) (Quit: Leaving) |
2023-09-09 01:01:26 +0200 | wroathe | (~wroathe@user/wroathe) (Ping timeout: 246 seconds) |
2023-09-09 01:01:57 +0200 | son0p | (~ff@186.121.39.74) |
2023-09-09 01:03:46 +0200 | caryhartline | (~caryhartl@168.182.58.169) |
2023-09-09 01:08:43 +0200 | cyphase | (~cyphase@user/cyphase) (Ping timeout: 255 seconds) |
2023-09-09 01:10:41 +0200 | cyphase | (~cyphase@user/cyphase) |
2023-09-09 01:11:18 +0200 | Chioque | (~mansur@88.125.49.60.jb03-home.tm.net.my) |
2023-09-09 01:13:17 +0200 | Tuplanolla | (~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Quit: Leaving.) |
2023-09-09 01:13:22 +0200 | caryhartline | (~caryhartl@168.182.58.169) (Quit: caryhartline) |
2023-09-09 01:18:12 +0200 | Chioque | (~mansur@88.125.49.60.jb03-home.tm.net.my) (Quit: WeeChat 4.0.4) |
2023-09-09 01:19:19 +0200 | cptaffe | (~ZNC@99-47-99-155.lightspeed.ltrkar.sbcglobal.net) |
2023-09-09 01:22:01 +0200 | cptaffe | (~ZNC@99-47-99-155.lightspeed.ltrkar.sbcglobal.net) (Client Quit) |
2023-09-09 01:22:01 +0200 | cpt\iphone | (~ZNC@2600:1700:f08:111f::18e7) (Quit: ZNC 1.8.2 - https://znc.in) |
2023-09-09 01:22:01 +0200 | cpt\macbook | (~ZNC@2600:1700:f08:111f::18e7) (Quit: ZNC 1.8.2 - https://znc.in) |
2023-09-09 01:22:23 +0200 | cpt\iphone | (~iPhone@99-47-99-155.lightspeed.ltrkar.sbcglobal.net) |
2023-09-09 01:22:54 +0200 | cptaffe | (~ZNC@2600:1700:f08:111f::18e7) |
2023-09-09 01:23:02 +0200 | gmg | (~user@user/gehmehgeh) (Quit: Leaving) |
2023-09-09 01:23:49 +0200 | cpt\iphone | (~iPhone@99-47-99-155.lightspeed.ltrkar.sbcglobal.net) (Client Quit) |
2023-09-09 01:23:53 +0200 | cptaffe | (~ZNC@2600:1700:f08:111f::18e7) (Client Quit) |
2023-09-09 01:23:55 +0200 | cptaffe- | (~ZNC@99-47-99-155.lightspeed.ltrkar.sbcglobal.net) |
2023-09-09 01:24:22 +0200 | arahael | (~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 +0200 | cptaffe- | cptaffe |
2023-09-09 01:27:19 +0200 | cyphase | (~cyphase@user/cyphase) (Ping timeout: 248 seconds) |
2023-09-09 01:28:36 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-09-09 01:32:06 +0200 | cyphase | (~cyphase@user/cyphase) |
2023-09-09 01:32:24 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds) |
2023-09-09 01:32:24 +0200 | JordiGH | (~jordi@user/jordigh) (Ping timeout: 246 seconds) |
2023-09-09 01:33:43 +0200 | stites | (~stites@130.44.147.204) (Ping timeout: 248 seconds) |
2023-09-09 01:34:15 +0200 | sm | (~sm@plaintextaccounting/sm) (Ping timeout: 248 seconds) |
2023-09-09 01:35:12 +0200 | stites | (~stites@2607:fb91:dc9:6ccd:6a4b:9556:1e53:57eb) |
2023-09-09 01:37:38 +0200 | powderhorn | (~powderhor@207-153-12-54.static.fttp.usinternet.com) (Ping timeout: 245 seconds) |
2023-09-09 01:38:21 +0200 | danza_ | (~francesco@151.43.250.219) |
2023-09-09 01:43:35 +0200 | stefan-_ | (~cri@42dots.de) (Server closed connection) |
2023-09-09 01:43:51 +0200 | stefan-_ | (~cri@42dots.de) |
2023-09-09 01:47:56 +0200 | stites | (~stites@2607:fb91:dc9:6ccd:6a4b:9556:1e53:57eb) (Read error: Connection reset by peer) |
2023-09-09 01:48:16 +0200 | stites | (~stites@130.44.147.204) |
2023-09-09 01:49:53 +0200 | danza__ | (~francesco@151.37.121.223) |
2023-09-09 01:52:27 +0200 | stites | (~stites@130.44.147.204) (Ping timeout: 245 seconds) |
2023-09-09 01:52:27 +0200 | danza_ | (~francesco@151.43.250.219) (Ping timeout: 245 seconds) |
2023-09-09 01:52:40 +0200 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) |
2023-09-09 01:52:41 +0200 | stites | (~stites@2607:fb91:dc9:6ccd:6a4b:9556:1e53:57eb) |
2023-09-09 01:52:55 +0200 | aaronv | (~aaronv@user/aaronv) (Ping timeout: 248 seconds) |
2023-09-09 01:53:39 +0200 | Lord_of_Life_ | (~Lord@user/lord-of-life/x-2819915) |
2023-09-09 01:54:00 +0200 | stites | (~stites@2607:fb91:dc9:6ccd:6a4b:9556:1e53:57eb) (Read error: Connection reset by peer) |
2023-09-09 01:54:32 +0200 | stites | (~stites@130.44.147.204) |
2023-09-09 01:54:52 +0200 | Lord_of_Life | (~Lord@user/lord-of-life/x-2819915) (Ping timeout: 258 seconds) |
2023-09-09 01:54:59 +0200 | Lord_of_Life_ | Lord_of_Life |
2023-09-09 02:02:06 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-09-09 02:06:45 +0200 | sm | (~sm@plaintextaccounting/sm) (Ping timeout: 258 seconds) |
2023-09-09 02:11:04 +0200 | aaronv | (~aaronv@user/aaronv) |
2023-09-09 02:15:51 +0200 | danza__ | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 02:35:47 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-09-09 02:37:21 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds) |
2023-09-09 02:38:49 +0200 | caryhartline | (~caryhartl@168.182.58.169) |
2023-09-09 02:40:23 +0200 | sm | (~sm@plaintextaccounting/sm) (Ping timeout: 248 seconds) |
2023-09-09 02:42:03 +0200 | bilegeek | (~bilegeek@2600:1008:b06c:4343:3be3:cb40:aeb0:813f) |
2023-09-09 02:46:27 +0200 | JordiGH | (~jordi@user/jordigh) |
2023-09-09 02:47:39 +0200 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection) |
2023-09-09 02:48:18 +0200 | ddellacosta | (~ddellacos@ool-44c738de.dyn.optonline.net) (Quit: WeeChat 4.0.3) |
2023-09-09 02:48:23 +0200 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) |
2023-09-09 02:49:04 +0200 | ddellacosta | (~ddellacos@ool-44c738de.dyn.optonline.net) |
2023-09-09 02:50:36 +0200 | Unode | (~Unode@fg-ext-220.embl.de) (Server closed connection) |
2023-09-09 02:50:49 +0200 | Unode | (~Unode@fg-ext-220.embl.de) |
2023-09-09 02:51:46 +0200 | jmdaemon | (~jmdaemon@user/jmdaemon) |
2023-09-09 02:51:52 +0200 | wroathe | (~wroathe@207-153-38-140.fttp.usinternet.com) |
2023-09-09 02:51:52 +0200 | wroathe | (~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host) |
2023-09-09 02:51:52 +0200 | wroathe | (~wroathe@user/wroathe) |
2023-09-09 02:56:52 +0200 | Guest12 | (~Guest12@187.83.249.216.dyn.smithville.net) |
2023-09-09 03:10:20 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 03:11:29 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-09-09 03:14:00 +0200 | segfaultfizzbuzz | (~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 +0200 | sm | (~sm@plaintextaccounting/sm) (Ping timeout: 258 seconds) |
2023-09-09 03:16:20 +0200 | absence | (torgeihe@hildring.pvv.ntnu.no) (Server closed connection) |
2023-09-09 03:16:28 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 03:16:31 +0200 | absence | (torgeihe@hildring.pvv.ntnu.no) |
2023-09-09 03:18:55 +0200 | mysl | (~mysl@user/mysl) (Quit: Lost terminal) |
2023-09-09 03:19:51 +0200 | td_ | (~td@i53870905.versanet.de) (Ping timeout: 248 seconds) |
2023-09-09 03:21:52 +0200 | td_ | (~td@i53870933.versanet.de) |
2023-09-09 03:23:03 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 248 seconds) |
2023-09-09 03:24:03 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) |
2023-09-09 03:28:55 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 248 seconds) |
2023-09-09 03:29:18 +0200 | libertyprime | (~libertypr@203.96.203.44) (Ping timeout: 246 seconds) |
2023-09-09 03:29:29 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-09-09 03:29:46 +0200 | _xor0 | _xor |
2023-09-09 03:30:43 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 03:33:43 +0200 | sm | (~sm@plaintextaccounting/sm) (Ping timeout: 248 seconds) |
2023-09-09 03:37:12 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 255 seconds) |
2023-09-09 03:37:22 +0200 | todi | (~todi@p4fd1ab34.dip0.t-ipconnect.de) (Ping timeout: 244 seconds) |
2023-09-09 03:37:50 +0200 | stackdroid18 | (14094@de1.hashbang.sh) |
2023-09-09 03:37:51 +0200 | todi | (~todi@p5dca5c94.dip0.t-ipconnect.de) |
2023-09-09 03:40:24 +0200 | libertyprime | (~libertypr@203.96.203.44) |
2023-09-09 03:50:15 +0200 | otto_s | (~user@p5de2ff65.dip0.t-ipconnect.de) (Ping timeout: 258 seconds) |
2023-09-09 03:51:53 +0200 | otto_s | (~user@p4ff27ce7.dip0.t-ipconnect.de) |
2023-09-09 03:52:03 +0200 | stackdroid18 | (14094@de1.hashbang.sh) (Quit: hasta la vista... tchau!) |
2023-09-09 03:56:43 +0200 | aaronv | (~aaronv@user/aaronv) (Ping timeout: 240 seconds) |
2023-09-09 04:00:14 +0200 | aaronv | (~aaronv@user/aaronv) |
2023-09-09 04:03:07 +0200 | finn_elija | (~finn_elij@user/finn-elija/x-0085643) |
2023-09-09 04:03:07 +0200 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija))) |
2023-09-09 04:03:07 +0200 | finn_elija | FinnElija |
2023-09-09 04:04:05 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-09-09 04:04:18 +0200 | Guest12 | (~Guest12@187.83.249.216.dyn.smithville.net) (Quit: Client closed) |
2023-09-09 04:08:17 +0200 | ystael | (~ystael@user/ystael) (Ping timeout: 245 seconds) |
2023-09-09 04:10:28 +0200 | szkl | (uid110435@id-110435.uxbridge.irccloud.com) |
2023-09-09 04:10:48 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1030:d66f:8de7:984f) (Remote host closed the connection) |
2023-09-09 04:11:07 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1030:d66f:8de7:984f) |
2023-09-09 04:13:38 +0200 | sm | (~sm@plaintextaccounting/sm) (Ping timeout: 258 seconds) |
2023-09-09 04:13:45 +0200 | bratwurst | (~blaadsfa@S010610561191f5d6.lb.shawcable.net) |
2023-09-09 04:17:04 +0200 | ripspin | (~chatzilla@1.145.242.125) |
2023-09-09 04:17:08 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) |
2023-09-09 04:20:28 +0200 | bratwurst | (~blaadsfa@S010610561191f5d6.lb.shawcable.net) (Ping timeout: 248 seconds) |
2023-09-09 04:20:36 +0200 | JordiGH | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 04:26:42 +0200 | libertyprime | (~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 +0200 | Ranhir | (~Ranhir@157.97.53.139) (Server closed connection) |
2023-09-09 04:29:03 +0200 | Ranhir | (~Ranhir@157.97.53.139) |
2023-09-09 04:29:25 +0200 | waleee | (~waleee@h-176-10-137-138.na.cust.bahnhof.se) (Ping timeout: 250 seconds) |
2023-09-09 04:33:19 +0200 | thaumavorio | (~thaumavor@thaumavor.io) (Quit: ZNC 1.8.2 - https://znc.in) |
2023-09-09 04:33:29 +0200 | heath3 | (~heath@user/heath) (Server closed connection) |
2023-09-09 04:33:48 +0200 | heath3 | (~heath@user/heath) |
2023-09-09 04:34:31 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds) |
2023-09-09 04:34:37 +0200 | thaumavorio | (~thaumavor@thaumavor.io) |
2023-09-09 04:36:45 +0200 | segfaultfizzbuzz | (~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 +0200 | Guest72 | (~Guest72@24.42.148.102) |
2023-09-09 04:41:37 +0200 | Guest72 | (~Guest72@24.42.148.102) (Client Quit) |
2023-09-09 04:44:35 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-09-09 04:48:54 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 04:50:20 +0200 | td_ | (~td@i53870933.versanet.de) (Ping timeout: 246 seconds) |
2023-09-09 04:52:29 +0200 | td_ | (~td@i5387093E.versanet.de) |
2023-09-09 04:52:57 +0200 | sm | (~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 +0200 | libertyprime | (~libertypr@203.96.203.44) |
2023-09-09 05:03:17 +0200 | <geekosaur> | they can revoke tenure |
2023-09-09 05:03:50 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 05:08:27 +0200 | ddellacosta | (~ddellacos@ool-44c738de.dyn.optonline.net) (Ping timeout: 258 seconds) |
2023-09-09 05:10:17 +0200 | ddellacosta | (~ddellacos@ool-44c738de.dyn.optonline.net) |
2023-09-09 05:17:15 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 05:19:19 +0200 | nate2 | (~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 +0200 | arahael | (~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 +0200 | aforemny_ | (~aforemny@2001:9e8:6cc4:ca00:285c:4ef6:5a4b:f825) |
2023-09-09 05:32:51 +0200 | aforemny | (~aforemny@i59F516ED.versanet.de) (Ping timeout: 246 seconds) |
2023-09-09 05:34:31 +0200 | AmyMalik | MelanieMalik |
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 +0200 | hiredman | (~hiredman@frontier1.downey.family) (Server closed connection) |
2023-09-09 06:01:35 +0200 | GoldsteinQ | (~goldstein@goldstein.rs) (Server closed connection) |
2023-09-09 06:01:55 +0200 | captnemo | (~captnemo@193.32.127.239) |
2023-09-09 06:01:55 +0200 | GoldsteinQ | (~goldstein@goldstein.rs) |
2023-09-09 06:01:58 +0200 | captnemo | (~captnemo@193.32.127.239) (Client Quit) |
2023-09-09 06:04:23 +0200 | bilegeek | (~bilegeek@2600:1008:b06c:4343:3be3:cb40:aeb0:813f) (Quit: Leaving) |
2023-09-09 06:11:35 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 248 seconds) |
2023-09-09 06:13:00 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 06:17:59 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds) |
2023-09-09 06:21:17 +0200 | wroathe | (~wroathe@user/wroathe) (Ping timeout: 258 seconds) |
2023-09-09 06:31:51 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 06:33:21 +0200 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 250 seconds) |
2023-09-09 06:43:01 +0200 | seeg123456 | (~seeg12345@64.176.64.83) (Quit: Gateway shutdown) |
2023-09-09 06:43:02 +0200 | robobub | (uid248673@id-248673.uxbridge.irccloud.com) |
2023-09-09 06:50:13 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 240 seconds) |
2023-09-09 06:53:32 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 06:54:06 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-09-09 06:55:46 +0200 | migas6 | (~migas@astra4961.startdedicated.net) (Quit: Ping timeout (120 seconds)) |
2023-09-09 06:56:04 +0200 | migas | (~migas@astra4961.startdedicated.net) |
2023-09-09 06:57:42 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 255 seconds) |
2023-09-09 06:57:45 +0200 | hgolden | (~hgolden@2603-8000-9d00-3ed1-fc05-5499-f77c-fbe5.res6.spectrum.com) (Remote host closed the connection) |
2023-09-09 07:01:44 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 07:03:01 +0200 | erty | (~user@user/aeroplane) |
2023-09-09 07:04:06 +0200 | takuan | (~takuan@178-116-218-225.access.telenet.be) |
2023-09-09 07:07:50 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 07:08:44 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Read error: Connection reset by peer) |
2023-09-09 07:09:29 +0200 | hgolden | (~hgolden@2603-8000-9d00-3ed1-fc05-5499-f77c-fbe5.res6.spectrum.com) |
2023-09-09 07:14:23 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 07:14:51 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 07:17:45 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 07:19:20 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds) |
2023-09-09 07:23:52 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 07:24:46 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Read error: Connection reset by peer) |
2023-09-09 07:27:45 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 07:30:06 +0200 | hiredman | (~hiredman@frontier1.downey.family) |
2023-09-09 07:30:54 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 07:31:41 +0200 | aaronv | (~aaronv@user/aaronv) (Ping timeout: 246 seconds) |
2023-09-09 07:31:46 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Read error: Connection reset by peer) |
2023-09-09 07:32:06 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 255 seconds) |
2023-09-09 07:34:14 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 07:37:54 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 07:40:07 +0200 | libertyprime | (~libertypr@203.96.203.44) (Ping timeout: 248 seconds) |
2023-09-09 07:41:47 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 07:47:55 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 07:48:48 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Read error: Connection reset by peer) |
2023-09-09 07:49:05 +0200 | aaronv | (~aaronv@user/aaronv) |
2023-09-09 07:51:19 +0200 | aaronv | (~aaronv@user/aaronv) (Client Quit) |
2023-09-09 07:51:54 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds) |
2023-09-09 07:54:55 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 07:55:48 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 08:01:31 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 08:01:55 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 08:02:49 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 08:04:49 +0200 | idgaen | (~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) |
2023-09-09 08:06:06 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 255 seconds) |
2023-09-09 08:08:56 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 08:09:50 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 08:15:57 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 08:16:45 +0200 | azimut | (~azimut@gateway/tor-sasl/azimut) |
2023-09-09 08:16:50 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 08:20:02 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 08:22:57 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 08:31:51 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 08:34:34 +0200 | caryhartline | (~caryhartl@168.182.58.169) (Quit: caryhartline) |
2023-09-09 08:37:58 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 08:38:15 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds) |
2023-09-09 08:43:51 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 08:49:58 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 08:50:52 +0200 | tstat | (~tstat@user/tstat) (Server closed connection) |
2023-09-09 08:51:11 +0200 | tstat | (~tstat@user/tstat) |
2023-09-09 08:53:33 +0200 | acidjnk | (~acidjnk@p200300d6e7072f47b0cfe67efeb6b056.dip0.t-ipconnect.de) |
2023-09-09 08:54:03 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 08:56:34 +0200 | sm | (~sm@plaintextaccounting/sm) (Quit: sm) |
2023-09-09 08:56:37 +0200 | ripspin | (~chatzilla@1.145.242.125) (Remote host closed the connection) |
2023-09-09 08:57:46 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 09:02:24 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-09-09 09:06:23 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 09:09:50 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 09:10:10 +0200 | ent | (entgod@kapsi.fi) (Server closed connection) |
2023-09-09 09:10:24 +0200 | ent | (entgod@kapsi.fi) |
2023-09-09 09:11:19 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds) |
2023-09-09 09:13:24 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 09:13:47 +0200 | coot | (~coot@89-69-206-216.dynamic.chello.pl) |
2023-09-09 09:16:26 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) |
2023-09-09 09:17:05 +0200 | fendor | (~fendor@2a02:8388:1640:be00:c785:45ab:c70:9d3f) |
2023-09-09 09:17:59 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 09:21:12 +0200 | nate2 | (~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 +0200 | lisbeths | (uid135845@id-135845.lymington.irccloud.com) |
2023-09-09 09:23:14 +0200 | Tuplanolla | (~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) |
2023-09-09 09:26:47 +0200 | arahael | (~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 +0200 | jackneill__ | (~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 +0200 | albet70 | (~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 +0200 | idgaen | (~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.0.2) |
2023-09-09 09:43:18 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds) |
2023-09-09 09:44:55 +0200 | segfaultfizzbuzz | (~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 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 10:04:16 +0200 | CiaoSen | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 10:15:40 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 250 seconds) |
2023-09-09 10:15:52 +0200 | albet70 | (~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 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 10:27:19 +0200 | neptun | (neptun@2607:5300:60:5910:dcad:beff:feef:5bc) (Server closed connection) |
2023-09-09 10:27:33 +0200 | neptun | (neptun@2607:5300:60:5910:dcad:beff:feef:5bc) |
2023-09-09 10:27:35 +0200 | gmg | (~user@user/gehmehgeh) |
2023-09-09 10:29:28 +0200 | emmanuelux | (~emmanuelu@user/emmanuelux) |
2023-09-09 10:29:38 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 10:32:54 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 10:33:48 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 244 seconds) |
2023-09-09 10:48:27 +0200 | tzh | (~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz) |
2023-09-09 10:51:32 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds) |
2023-09-09 10:52:26 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 10:53:13 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 10:53:23 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 10:53:54 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 11:09:29 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 11:09:48 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 11:12:20 +0200 | mrmr15 | (~mrmr@user/mrmr) |
2023-09-09 11:12:44 +0200 | mrmr1 | (~mrmr@user/mrmr) (Read error: Connection reset by peer) |
2023-09-09 11:12:44 +0200 | mrmr15 | mrmr1 |
2023-09-09 11:14:17 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds) |
2023-09-09 11:17:00 +0200 | Sgeo | (~Sgeo@user/sgeo) (Read error: Connection reset by peer) |
2023-09-09 11:19:14 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 11:20:35 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1030:d66f:8de7:984f) (Remote host closed the connection) |
2023-09-09 11:22:02 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 11:23:12 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 11:23:28 +0200 | segfaultfizzbuzz | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds) |
2023-09-09 11:41:54 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 11:42:09 +0200 | albet70 | (~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 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
2023-09-09 11:53:15 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1030:d66f:8de7:984f) |
2023-09-09 11:54:16 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 11:54:16 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-09-09 11:58:33 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 246 seconds) |
2023-09-09 12:01:18 +0200 | erty | (~user@user/aeroplane) (ERC 5.4 (IRC client for GNU Emacs 28.2)) |
2023-09-09 12:04:38 +0200 | sm | (~sm@plaintextaccounting/sm) (Quit: sm) |
2023-09-09 12:12:05 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 12:13:31 +0200 | mysl | (~mysl@user/mysl) |
2023-09-09 12:15:16 +0200 | elevenkb | (~elevenkb@105.226.98.41) |
2023-09-09 12:15:28 +0200 | elevenkb | (~elevenkb@105.226.98.41) (Client Quit) |
2023-09-09 12:16:42 +0200 | chiselfuse | (~chiselfus@user/chiselfuse) (Ping timeout: 246 seconds) |
2023-09-09 12:17:16 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds) |
2023-09-09 12:18:01 +0200 | chiselfuse | (~chiselfus@user/chiselfuse) |
2023-09-09 12:24:23 +0200 | CiaoSen | (~Jura@2a05:5800:2b2:1b00:664b:f0ff:fe37:9ef) (Ping timeout: 248 seconds) |
2023-09-09 12:29:38 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 12:37:00 +0200 | L29Ah | (~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 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 12:44:20 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) |
2023-09-09 12:44:23 +0200 | emmanuelux | (~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer) |
2023-09-09 12:44:50 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 246 seconds) |
2023-09-09 12:45:27 +0200 | RSCASTILHO | (~RSCASTILH@187.40.124.54) |
2023-09-09 12:47:19 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds) |
2023-09-09 12:49:22 +0200 | RSCASTILHO | (~RSCASTILH@187.40.124.54) () |
2023-09-09 12:50:16 +0200 | todi | (~todi@p5dca5c94.dip0.t-ipconnect.de) (Ping timeout: 255 seconds) |
2023-09-09 12:51:34 +0200 | todi | (~todi@p5dca5c94.dip0.t-ipconnect.de) |
2023-09-09 12:56:17 +0200 | tv | (~tv@user/tv) (Quit: derp) |
2023-09-09 12:56:33 +0200 | tv | (~tv@user/tv) |
2023-09-09 13:04:10 +0200 | wootehfoot | (~wootehfoo@user/wootehfoot) |
2023-09-09 13:05:45 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 13:10:30 +0200 | tomboy65 | (~tomboy64@user/tomboy64) (Ping timeout: 255 seconds) |
2023-09-09 13:10:47 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds) |
2023-09-09 13:11:22 +0200 | siers | (~ij@user/ij) (Server closed connection) |
2023-09-09 13:11:43 +0200 | siers | (~ij@user/ij) |
2023-09-09 13:17:16 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 13:17:28 +0200 | coot | (~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot) |
2023-09-09 13:18:12 +0200 | nate2 | (~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 +0200 | tomboy64 | (~tomboy64@user/tomboy64) |
2023-09-09 13:22:13 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds) |
2023-09-09 13:22:54 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 246 seconds) |
2023-09-09 13:22:59 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) (Ping timeout: 246 seconds) |
2023-09-09 13:26:51 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 13:30:54 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-09-09 13:31:31 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 13:31:37 +0200 | sm | (~sm@plaintextaccounting/sm) (Client Quit) |
2023-09-09 13:35:04 +0200 | phma | (~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 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 245 seconds) |
2023-09-09 13:39:35 +0200 | dcoutts | (~duncan@82-69-94-207.dsl.in-addr.zen.co.uk) |
2023-09-09 13:41:24 +0200 | sefidel | (~sefidel@user/sefidel) (Remote host closed the connection) |
2023-09-09 13:42:02 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 245 seconds) |
2023-09-09 13:42:10 +0200 | sefidel | (~sefidel@user/sefidel) |
2023-09-09 13:43:22 +0200 | coot | (~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 +0200 | phma | (~phma@2001:5b0:2144:6b88:455e:8c61:7388:36ab) |
2023-09-09 13:45:20 +0200 | emmanuelux_ | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 14:04:54 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds) |
2023-09-09 14:05:29 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer) |
2023-09-09 14:05:48 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) |
2023-09-09 14:19:53 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 14:22:41 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 14:23:53 +0200 | _leo___ | (~emmanuelu@user/emmanuelux) |
2023-09-09 14:24:47 +0200 | Lycurgus | (~juan@user/Lycurgus) |
2023-09-09 14:26:52 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) (Ping timeout: 248 seconds) |
2023-09-09 14:27:00 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 255 seconds) |
2023-09-09 14:31:35 +0200 | conjunctive | (sid433686@id-433686.helmsley.irccloud.com) (Server closed connection) |
2023-09-09 14:31:45 +0200 | conjunctive | (sid433686@id-433686.helmsley.irccloud.com) |
2023-09-09 14:34:18 +0200 | Lycurgus | (~juan@user/Lycurgus) (Quit: Tschüss) |
2023-09-09 14:37:17 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds) |
2023-09-09 14:38:13 +0200 | Taneb | (~Taneb@2001:41c8:51:10d:aaaa:0:aaaa:0) (Server closed connection) |
2023-09-09 14:38:27 +0200 | Taneb | (~Taneb@runciman.hacksoc.org) |
2023-09-09 14:44:30 +0200 | Guest13 | (~Guest17@49.140.189.123) |
2023-09-09 14:45:50 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) |
2023-09-09 14:47:27 +0200 | tromp | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 15:01:11 +0200 | Guest13 | (~Guest17@49.140.189.123) (Quit: Client closed) |
2023-09-09 15:03:45 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
2023-09-09 15:05:33 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 250 seconds) |
2023-09-09 15:10:56 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer) |
2023-09-09 15:11:19 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) |
2023-09-09 15:12:58 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 15:12:58 +0200 | ezzieygu1wuf | (~Unknown@user/ezzieyguywuf) (Ping timeout: 258 seconds) |
2023-09-09 15:14:57 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 15:16:36 +0200 | waleee | (~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) |
2023-09-09 15:17:11 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 248 seconds) |
2023-09-09 15:19:35 +0200 | Adeon | (sid418992@id-418992.lymington.irccloud.com) (Server closed connection) |
2023-09-09 15:19:44 +0200 | Adeon | (sid418992@id-418992.lymington.irccloud.com) |
2023-09-09 15:19:54 +0200 | szkl | (uid110435@id-110435.uxbridge.irccloud.com) (Quit: Connection closed for inactivity) |
2023-09-09 15:20:15 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds) |
2023-09-09 15:28:49 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 15:29:14 +0200 | nvaxplus | (~nvaxplus@user/nvaxplus) |
2023-09-09 15:32:00 +0200 | <nvaxplus> | join #offtopia |
2023-09-09 15:32:04 +0200 | nvaxplus | (~nvaxplus@user/nvaxplus) () |
2023-09-09 15:34:03 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds) |
2023-09-09 15:34:30 +0200 | stites | (~stites@130.44.147.204) (Ping timeout: 246 seconds) |
2023-09-09 15:35:19 +0200 | stites | (~stites@2607:fb91:dc6:4800:fbd5:4720:a3b4:a0d2) |
2023-09-09 15:37:25 +0200 | <carbolymer> | no |
2023-09-09 15:37:30 +0200 | arahael | (~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 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer) |
2023-09-09 15:42:15 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds) |
2023-09-09 15:44:31 +0200 | mjs2600_ | (~mjs2600@c-174-169-225-239.hsd1.vt.comcast.net) |
2023-09-09 15:44:36 +0200 | mjs2600 | (~mjs2600@c-174-169-225-239.hsd1.vt.comcast.net) (Read error: Connection reset by peer) |
2023-09-09 15:44:41 +0200 | L29Ah | (~L29Ah@wikipedia/L29Ah) |
2023-09-09 15:44:59 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
2023-09-09 15:45:48 +0200 | mysl | (~mysl@user/mysl) (Ping timeout: 248 seconds) |
2023-09-09 15:47:38 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 15:47:56 +0200 | mysl | (~mysl@user/mysl) |
2023-09-09 15:48:50 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 15:52:00 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 246 seconds) |
2023-09-09 15:52:54 +0200 | ripspin | (~chatzilla@1.145.231.215) |
2023-09-09 15:52:55 +0200 | CiaoSen | (~Jura@2a05:5800:2b2:1b00:664b:f0ff:fe37:9ef) |
2023-09-09 15:53:31 +0200 | wootehfoot | (~wootehfoo@user/wootehfoot) (Quit: Leaving) |
2023-09-09 15:53:45 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds) |
2023-09-09 15:56:49 +0200 | wootehfoot | (~wootehfoo@user/wootehfoot) |
2023-09-09 15:58:47 +0200 | jmdaemon | (~jmdaemon@user/jmdaemon) (Ping timeout: 248 seconds) |
2023-09-09 16:00:43 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 16:01:54 +0200 | Buliarous | (~gypsydang@46.232.210.139) (Server closed connection) |
2023-09-09 16:02:03 +0200 | Buliarous | (~gypsydang@46.232.210.139) |
2023-09-09 16:02:31 +0200 | jespada | (~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) (Quit: Textual IRC Client: www.textualapp.com) |
2023-09-09 16:03:03 +0200 | waleee | (~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 248 seconds) |
2023-09-09 16:03:41 +0200 | wootehfoot | (~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer) |
2023-09-09 16:04:47 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) |
2023-09-09 16:05:16 +0200 | waleee | (~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) |
2023-09-09 16:05:32 +0200 | arahael | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 16:17:15 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds) |
2023-09-09 16:17:59 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 16:23:06 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds) |
2023-09-09 16:24:21 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
2023-09-09 16:28:43 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 16:31:03 +0200 | Natch | (~natch@c-9e07225c.038-60-73746f7.bbcust.telenor.se) (Read error: Connection reset by peer) |
2023-09-09 16:31:33 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer) |
2023-09-09 16:31:48 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) |
2023-09-09 16:32:54 +0200 | blomberg | (~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 +0200 | arahael | (~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 +0200 | tromp | (~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 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 16:36:35 +0200 | arahael | (~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 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 250 seconds) |
2023-09-09 16:41:31 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | Natch | (~natch@c-9e07225c.038-60-73746f7.bbcust.telenor.se) |
2023-09-09 16:52:38 +0200 | <mauke> | why? |
2023-09-09 16:52:59 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) (Ping timeout: 250 seconds) |
2023-09-09 17:01:22 +0200 | stites | (~stites@2607:fb91:dc6:4800:fbd5:4720:a3b4:a0d2) (Read error: Connection reset by peer) |
2023-09-09 17:01:41 +0200 | stites | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds) |
2023-09-09 17:05:20 +0200 | arahael | (~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 +0200 | iteratee | (~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 +0200 | iteratee | (~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 +0200 | arahael | (~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 +0200 | tromp | (~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 +0200 | coot | (~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 +0200 | arahael | (~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 +0200 | tromp | (~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 +0200 | azimut | (~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 +0200 | nate2 | (~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 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) |
2023-09-09 17:21:41 +0200 | segfaultfizzbuzz | (~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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | nate2 | (~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 +0200 | tromp | (~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 +0200 | Everything | (~Everythin@static.208.206.21.65.clients.your-server.de) (Server closed connection) |
2023-09-09 17:28:54 +0200 | Everything | (~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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | emmanuelux_ | (~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 +0200 | arahael | (~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 +0200 | coot | (~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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | marienz | (~marienz@libera/staff/marienz) (Server closed connection) |
2023-09-09 17:55:45 +0200 | marienz | (~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 +0200 | CiaoSen | (~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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | mud | (~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 +0200 | waleee | (~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 +0200 | arahael | (~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 +0200 | machinedgod | (~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 +0200 | random-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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | eggplantade | (~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 +0200 | eggplantade | (~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) |
2023-09-09 18:21:52 +0200 | random-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 +0200 | arahael | (~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 +0200 | pavonia | (~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 +0200 | emmanuelux_ | (~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 +0200 | sinbad | (~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 +0200 | cafkafk_ | (~cafkafk@fsf/member/cafkafk) (Remote host closed the connection) |
2023-09-09 18:29:34 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | cafkafk_ | (~cafkafk@fsf/member/cafkafk) |
2023-09-09 18:35:20 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 18:37:13 +0200 | wroathe | (~wroathe@50.205.197.50) |
2023-09-09 18:37:13 +0200 | wroathe | (~wroathe@50.205.197.50) (Changing host) |
2023-09-09 18:37:13 +0200 | wroathe | (~wroathe@user/wroathe) |
2023-09-09 18:38:31 +0200 | billchenchina | (~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 +0200 | ripspin | (~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 +0200 | mmhat | (~mmh@p200300f1c7178a73ee086bfffe095315.dip0.t-ipconnect.de) |
2023-09-09 18:39:21 +0200 | mmhat | (~mmh@p200300f1c7178a73ee086bfffe095315.dip0.t-ipconnect.de) (Client Quit) |
2023-09-09 18:39:32 +0200 | tromp | (~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 +0200 | cafkafk_ | (~cafkafk@fsf/member/cafkafk) (Ping timeout: 246 seconds) |
2023-09-09 18:40:22 +0200 | arahael | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 18:42:51 +0200 | machinedgod | (~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 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Quit: segfaultfizzbuzz) |
2023-09-09 18:46:39 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds) |
2023-09-09 18:47:20 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 18:49:36 +0200 | Guest76 | (~Guest76@212.3.193.144) |
2023-09-09 18:52:05 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds) |
2023-09-09 18:54:41 +0200 | azimut | (~azimut@gateway/tor-sasl/azimut) |
2023-09-09 18:56:52 +0200 | _leo___ | (~emmanuelu@user/emmanuelux) |
2023-09-09 18:56:59 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer) |
2023-09-09 18:58:49 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 19:01:35 +0200 | hongminhee | (sid295@id-295.tinside.irccloud.com) (Server closed connection) |
2023-09-09 19:01:44 +0200 | hongminhee | (sid295@id-295.tinside.irccloud.com) |
2023-09-09 19:04:55 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds) |
2023-09-09 19:06:10 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 19:07:24 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) |
2023-09-09 19:08:28 +0200 | meejah | (~meejah@rutas.meejah.ca) (Server closed connection) |
2023-09-09 19:08:37 +0200 | meejah | (~meejah@rutas.meejah.ca) |
2023-09-09 19:12:23 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds) |
2023-09-09 19:13:17 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 19:18:13 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 244 seconds) |
2023-09-09 19:19:36 +0200 | cafkafk_ | (~cafkafk@fsf/member/cafkafk) |
2023-09-09 19:20:07 +0200 | eggplantade | (~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection) |
2023-09-09 19:20:41 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
2023-09-09 19:22:43 +0200 | eggplantade | (~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 +0200 | Guest76 | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 19:25:06 +0200 | cafkafk_ | (~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 +0200 | arahael | (~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 +0200 | emmanuelux_ | (~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 +0200 | arahael | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 250 seconds) |
2023-09-09 19:42:11 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 19:42:14 +0200 | cafkafk_ | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds) |
2023-09-09 19:47:51 +0200 | eggplant_ | (~Eggplanta@2600:1700:38c5:d800:18df:787d:85fc:cca8) |
2023-09-09 19:47:55 +0200 | arahael | (~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 +0200 | eggplantade | (~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 +0200 | arahael | (~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 +0200 | cafkafk_ | (~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 +0200 | arahael | (~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 +0200 | tzh | (~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 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
2023-09-09 20:01:31 +0200 | cafkafk_ | (~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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | mud | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds) |
2023-09-09 20:10:35 +0200 | dolio | (~dolio@130.44.134.54) (Server closed connection) |
2023-09-09 20:10:51 +0200 | dolio | (~dolio@130.44.134.54) |
2023-09-09 20:13:41 +0200 | aaronv | (~aaronv@user/aaronv) |
2023-09-09 20:16:42 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 20:17:06 +0200 | eggplant_ | (~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 +0200 | arahael | (~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 +0200 | wootehfoot | (~wootehfoo@user/wootehfoot) |
2023-09-09 20:22:29 +0200 | arahael | (~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 +0200 | tromp | (~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 +0200 | tromp | (~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 +0200 | arahael | (~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 +0200 | Sgeo | (~Sgeo@user/sgeo) |
2023-09-09 20:34:15 +0200 | arahael | (~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 +0200 | eggplantade | (~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 +0200 | danza__ | (~francesco@151.44.164.112) |
2023-09-09 20:38:55 +0200 | <EvanR> | let <equations> in <expr> |
2023-09-09 20:39:13 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | caasih | (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 +0200 | caasih | (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 +0200 | danza__ | (~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 +0200 | arahael | (~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> | <mauke> 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 +0200 | artem | (~artem@2601:249:4380:8950:f474:e3f8:9806:671) |
2023-09-09 20:47:29 +0200 | ulysses4ever | (~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> | <mauke> 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 +0200 | hays | (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> | <mauke> 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> | <mauke> "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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 20:51:37 +0200 | tromp | (~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> | <mauke> 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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | danza__ | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds) |
2023-09-09 21:02:27 +0200 | wroathe | (~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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
2023-09-09 21:13:27 +0200 | arahael | (~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 +0200 | hays | (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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 21:20:30 +0200 | Lycurgus | (~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 +0200 | nate2 | (~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 +0200 | lisbeths | (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 +0200 | danza__ | (~francesco@151.44.164.112) (Remote host closed the connection) |
2023-09-09 21:25:12 +0200 | arahael | (~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 +0200 | danza__ | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 21:26:12 +0200 | nate2 | (~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 +0200 | Lycurgus | (~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 +0200 | danza__ | (~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 +0200 | danza__ | (~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 +0200 | arahael | (~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 +0200 | segfaultfizzbuzz | (~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 +0200 | arahael | (~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 +0200 | segfaultfizzbuzz | (~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 +0200 | pavonia | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds) |
2023-09-09 21:42:52 +0200 | robbert-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 +0200 | robbert-vdh | (~robbert@robbertvanderhelm.nl) |
2023-09-09 21:43:27 +0200 | arahael | (~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 +0200 | takuan | (~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 +0200 | danza__ | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 248 seconds) |
2023-09-09 21:54:59 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 21:59:49 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 250 seconds) |
2023-09-09 22:00:38 +0200 | arahael | (~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 +0200 | billchenchina | (~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 +0200 | arahael | (~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 +0200 | geekosaur | *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 +0200 | jackneill__ | (~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 +0200 | arahael | (~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 +0200 | cafkafk_ | (~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 +0200 | cafkafk_ | (~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 +0200 | arahael | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 22:25:16 +0200 | segfaultfizzbuzz | (~segfaultf@12.172.217.142) (Ping timeout: 248 seconds) |
2023-09-09 22:28:42 +0200 | arahael | (~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 +0200 | libertyprime | (~libertypr@203.96.203.44) |
2023-09-09 22:34:04 +0200 | L29Ah | (~L29Ah@wikipedia/L29Ah) () |
2023-09-09 22:35:23 +0200 | <EvanR> | x = 4 is an equation |
2023-09-09 22:35:24 +0200 | arahael | (~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 +0200 | L29Ah | (~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 +0200 | libertyprime | (~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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | int-e | shrugs |
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 +0200 | arahael | (~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 +0200 | ulysses4ever | (~artem@2601:249:4380:8950:f474:e3f8:9806:671) |
2023-09-09 22:51:27 +0200 | artem | (~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 +0200 | tromp | (~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 +0200 | arahael | (~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 +0200 | artem | (~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 +0200 | ulysses4ever | (~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 +0200 | artem | (~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 +0200 | arahael | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 23:06:06 +0200 | wroathe | (~wroathe@50.205.197.50) |
2023-09-09 23:06:06 +0200 | wroathe | (~wroathe@50.205.197.50) (Changing host) |
2023-09-09 23:06:06 +0200 | wroathe | (~wroathe@user/wroathe) |
2023-09-09 23:07:24 +0200 | cptaffe | (~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 +0200 | cptaffe | (~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 +0200 | tromp | (~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 +0200 | cptaffe | (~ZNC@2600:1700:f08:111f::18e7) (Client Quit) |
2023-09-09 23:13:53 +0200 | cptaffe | (~ZNC@99-47-99-155.lightspeed.ltrkar.sbcglobal.net) |
2023-09-09 23:14:31 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | cptaffe | (~ZNC@99-47-99-155.lightspeed.ltrkar.sbcglobal.net) (Quit: ZNC 1.8.2 - https://znc.in) |
2023-09-09 23:20:05 +0200 | acidjnk | (~acidjnk@p200300d6e7072f47b0cfe67efeb6b056.dip0.t-ipconnect.de) (Ping timeout: 246 seconds) |
2023-09-09 23:20:51 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 250 seconds) |
2023-09-09 23:20:55 +0200 | stites | (~stites@130.44.147.204) (Ping timeout: 248 seconds) |
2023-09-09 23:21:04 +0200 | stites | (~stites@2607:fb91:dcf:4896:22a5:6d79:f786:b171) |
2023-09-09 23:21:14 +0200 | cptaffe | (~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 +0200 | adamCS | (~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 +0200 | adamCS | (~adamCS@ec2-34-207-160-255.compute-1.amazonaws.com) |
2023-09-09 23:27:38 +0200 | arahael | (~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 +0200 | tromp | (~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 +0200 | machinedgod | (~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 +0200 | arahael | (~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 +0200 | tromp | (~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 +0200 | fendor | (~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 +0200 | arahael | (~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 +0200 | leah2 | (~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 +0200 | waleee | (~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 +0200 | superryn | (~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 +0200 | arahael | (~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 +0200 | arahael | (~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 +0200 | blomberg | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 246 seconds) |
2023-09-09 23:53:16 +0200 | aaronv | (~aaronv@user/aaronv) (Ping timeout: 248 seconds) |
2023-09-09 23:54:22 +0200 | coot | (~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 +0200 | stites | (~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 +0200 | stites | (~stites@2603:3005:b69:4100:afa0:f7be:6ecd:53f2) |
2023-09-09 23:57:33 +0200 | mhatta | (~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 +0200 | arahael | (~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) |
2023-09-09 23:58:35 +0200 | nek0 | (~nek0@2a01:4f8:222:2b41::12) (Server closed connection) |
2023-09-09 23:58:46 +0200 | mhatta | (~mhatta@www21123ui.sakura.ne.jp) |
2023-09-09 23:58:49 +0200 | nek0 | (~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 |