| 2023-02-03 00:02:18 +0100 | dsrt^ | (~tj99@c-24-30-76-89.hsd1.ga.comcast.net) |
| 2023-02-03 00:04:48 +0100 | freeside | (~mengwong@103.252.202.170) |
| 2023-02-03 00:09:10 +0100 | king_gs | (~Thunderbi@2806:103e:29:34e5:e14a:21d9:ac2e:2240) |
| 2023-02-03 00:09:20 +0100 | motherfsck | (~motherfsc@user/motherfsck) (Ping timeout: 248 seconds) |
| 2023-02-03 00:09:34 +0100 | freeside | (~mengwong@103.252.202.170) (Ping timeout: 260 seconds) |
| 2023-02-03 00:22:49 +0100 | motherfsck | (~motherfsc@user/motherfsck) |
| 2023-02-03 00:25:09 +0100 | freeside | (~mengwong@103.252.202.170) |
| 2023-02-03 00:32:05 +0100 | motherfsck | (~motherfsc@user/motherfsck) (Quit: quit) |
| 2023-02-03 00:34:21 +0100 | epolanski | (uid312403@2a03:5180:f:1::4:c453) (Quit: Connection closed for inactivity) |
| 2023-02-03 00:43:11 +0100 | motherfsck | (~motherfsc@user/motherfsck) |
| 2023-02-03 00:43:20 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) |
| 2023-02-03 00:44:52 +0100 | Sauvin | (~sauvin@user/Sauvin) (Remote host closed the connection) |
| 2023-02-03 00:45:32 +0100 | Sauvin | (~sauvin@user/Sauvin) |
| 2023-02-03 00:55:10 +0100 | [itchyjunk] | (~itchyjunk@user/itchyjunk/x-7353470) |
| 2023-02-03 01:03:20 +0100 | pavonia | (~user@user/siracusa) |
| 2023-02-03 01:05:22 +0100 | zero | yin |
| 2023-02-03 01:05:33 +0100 | kitzman | (~kitzman@user/dekenevs) (Quit: C-x C-c) |
| 2023-02-03 01:13:58 +0100 | Kuttenbrunzer | (~Kuttenbru@2a02:8108:8b80:1d48::315c) (Quit: Where is it) |
| 2023-02-03 01:19:06 +0100 | jargon | (~jargon@174-22-223-224.phnx.qwest.net) |
| 2023-02-03 01:23:49 +0100 | acidjnk_new3 | (~acidjnk@p200300d6e715c415c5e18632e1ef72b2.dip0.t-ipconnect.de) (Ping timeout: 252 seconds) |
| 2023-02-03 01:24:11 +0100 | <Axman6> | juri_: could compensated arithmetic be useful? Ed has the compensated package whicht akes care of tracking the error of calculations and doesn't need to do all maths twice (just close to it) |
| 2023-02-03 01:24:35 +0100 | freeside | (~mengwong@103.252.202.170) (Ping timeout: 260 seconds) |
| 2023-02-03 01:24:40 +0100 | Axman6 | double double FOIL and trouble... |
| 2023-02-03 01:27:39 +0100 | freeside | (~mengwong@103.252.202.170) |
| 2023-02-03 01:29:40 +0100 | turlando | (~turlando@user/turlando) (Quit: No Ping reply in 180 seconds.) |
| 2023-02-03 01:30:55 +0100 | turlando | (~turlando@user/turlando) |
| 2023-02-03 01:35:12 +0100 | merijn | (~merijn@86-86-29-250.fixed.kpn.net) |
| 2023-02-03 01:39:27 +0100 | merijn | (~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds) |
| 2023-02-03 01:40:29 +0100 | zebrag | (~chris@user/zebrag) |
| 2023-02-03 01:43:15 +0100 | king_gs | (~Thunderbi@2806:103e:29:34e5:e14a:21d9:ac2e:2240) (Ping timeout: 260 seconds) |
| 2023-02-03 01:49:15 +0100 | king_gs | (~Thunderbi@187.201.2.248) |
| 2023-02-03 01:52:14 +0100 | zeenk | (~zeenk@2a02:2f04:a214:1e00::7fe) (Quit: Konversation terminated!) |
| 2023-02-03 01:59:20 +0100 | codaraxis | (~codaraxis@user/codaraxis) (Ping timeout: 246 seconds) |
| 2023-02-03 02:01:20 +0100 | ddellacosta | (~ddellacos@86.106.143.219) |
| 2023-02-03 02:03:34 +0100 | caryhartline | (~caryhartl@2600:1700:2d0:8d30:a932:353f:91f2:f048) |
| 2023-02-03 02:04:18 +0100 | Tuplanolla | (~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) (Quit: Leaving.) |
| 2023-02-03 02:08:31 +0100 | thongpv | (~thongpv87@14.179.159.25) |
| 2023-02-03 02:10:51 +0100 | zebrag | (~chris@user/zebrag) (Quit: Konversation terminated!) |
| 2023-02-03 02:12:54 +0100 | troydm | (~troydm@user/troydm) |
| 2023-02-03 02:12:55 +0100 | king_gs | (~Thunderbi@187.201.2.248) (Read error: Connection reset by peer) |
| 2023-02-03 02:13:11 +0100 | king_gs | (~Thunderbi@2806:103e:29:34e5:c1c4:cdf:cabc:3345) |
| 2023-02-03 02:21:01 +0100 | turlando | (~turlando@user/turlando) (Ping timeout: 252 seconds) |
| 2023-02-03 02:21:41 +0100 | turlando | (~turlando@user/turlando) |
| 2023-02-03 02:36:31 +0100 | xff0x | (~xff0x@2405:6580:b080:900:195f:ac6f:f6a2:3431) (Ping timeout: 248 seconds) |
| 2023-02-03 02:40:04 +0100 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 260 seconds) |
| 2023-02-03 02:40:48 +0100 | mei | (~mei@user/mei) (Ping timeout: 248 seconds) |
| 2023-02-03 02:41:17 +0100 | ec | (~ec@gateway/tor-sasl/ec) (Ping timeout: 255 seconds) |
| 2023-02-03 02:42:25 +0100 | ec | (~ec@gateway/tor-sasl/ec) |
| 2023-02-03 02:42:38 +0100 | wroathe | (~wroathe@207-153-38-140.fttp.usinternet.com) |
| 2023-02-03 02:42:38 +0100 | wroathe | (~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host) |
| 2023-02-03 02:42:38 +0100 | wroathe | (~wroathe@user/wroathe) |
| 2023-02-03 02:44:09 +0100 | mei | (~mei@user/mei) |
| 2023-02-03 02:47:47 +0100 | cods | (~fred@82-65-232-44.subs.proxad.net) (Ping timeout: 252 seconds) |
| 2023-02-03 02:47:59 +0100 | cods | (~fred@82-65-232-44.subs.proxad.net) |
| 2023-02-03 02:49:59 +0100 | gurkenglas | (~gurkengla@dynamic-046-114-182-034.46.114.pool.telefonica.de) (Ping timeout: 252 seconds) |
| 2023-02-03 02:54:02 +0100 | enoq | (~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) |
| 2023-02-03 02:56:58 +0100 | yrlnry | (~yrlnry@2600:4040:738e:5400:87d:f2d:382e:ac3d) (Read error: Connection reset by peer) |
| 2023-02-03 02:58:17 +0100 | yrlnry | (~yrlnry@2600:4040:738e:5400:87d:f2d:382e:ac3d) |
| 2023-02-03 03:00:52 +0100 | bilegeek | (~bilegeek@2600:1008:b065:4d4e:37b2:1ed7:a9d0:2c6f) |
| 2023-02-03 03:04:22 +0100 | Guest75 | (~Guest75@178.141.149.12) |
| 2023-02-03 03:19:17 +0100 | xff0x | (~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) |
| 2023-02-03 03:20:03 +0100 | Lord_of_Life | (~Lord@user/lord-of-life/x-2819915) (Ping timeout: 252 seconds) |
| 2023-02-03 03:20:43 +0100 | Lord_of_Life | (~Lord@user/lord-of-life/x-2819915) |
| 2023-02-03 03:28:34 +0100 | vgtw | (~vgtw@user/vgtw) |
| 2023-02-03 03:31:34 +0100 | disco-dave[m] | (~disco-dav@2001:470:69fc:105::2:1892) |
| 2023-02-03 03:35:46 +0100 | rembo10 | (~rembo10@main.remulis.com) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2023-02-03 03:36:05 +0100 | rembo10 | (~rembo10@main.remulis.com) |
| 2023-02-03 03:43:24 +0100 | vgtw | (~vgtw@user/vgtw) (Quit: ZNC - https://znc.in) |
| 2023-02-03 03:44:09 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) |
| 2023-02-03 03:45:28 +0100 | vgtw | (~vgtw@user/vgtw) |
| 2023-02-03 03:47:32 +0100 | mechap | (~mechap@user/mechap) (Ping timeout: 246 seconds) |
| 2023-02-03 03:49:09 +0100 | vgtw | (~vgtw@user/vgtw) (Client Quit) |
| 2023-02-03 03:49:14 +0100 | enoq | (~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) (Quit: enoq) |
| 2023-02-03 03:49:43 +0100 | mechap | (~mechap@user/mechap) |
| 2023-02-03 03:50:37 +0100 | vgtw | (~vgtw@user/vgtw) |
| 2023-02-03 03:56:57 +0100 | gehmehgeh | (~user@user/gehmehgeh) |
| 2023-02-03 03:58:56 +0100 | razetime | (~Thunderbi@117.193.4.182) |
| 2023-02-03 03:59:05 +0100 | jimmy2shoots | (~igloo@071-085-131-232.res.spectrum.com) |
| 2023-02-03 03:59:14 +0100 | jimmy2shoots | (~igloo@071-085-131-232.res.spectrum.com) (Client Quit) |
| 2023-02-03 03:59:35 +0100 | gmg | (~user@user/gehmehgeh) (Ping timeout: 255 seconds) |
| 2023-02-03 04:09:55 +0100 | td_ | (~td@i53870916.versanet.de) (Ping timeout: 252 seconds) |
| 2023-02-03 04:11:56 +0100 | td_ | (~td@i5387090B.versanet.de) |
| 2023-02-03 04:22:42 +0100 | pragma- | (~chaos@user/pragmatic-chaos) |
| 2023-02-03 04:24:13 +0100 | wroathe | (~wroathe@user/wroathe) (Ping timeout: 252 seconds) |
| 2023-02-03 04:29:54 +0100 | jero98772 | (~jero98772@2800:484:1d80:d8ce:9815:cfda:3661:17bb) (Remote host closed the connection) |
| 2023-02-03 04:34:03 +0100 | Guest75 | (~Guest75@178.141.149.12) (Ping timeout: 260 seconds) |
| 2023-02-03 04:36:29 +0100 | mikoto-chan | (~mikoto-ch@2001:999:60c:3d81:b055:1b0d:b7c7:2a51) |
| 2023-02-03 04:37:44 +0100 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija))) |
| 2023-02-03 04:37:44 +0100 | finn_elija | (~finn_elij@user/finn-elija/x-0085643) |
| 2023-02-03 04:37:44 +0100 | finn_elija | FinnElija |
| 2023-02-03 04:40:10 +0100 | renatofdds | (~user@user/renatofdds) |
| 2023-02-03 04:42:49 +0100 | jargon | (~jargon@174-22-223-224.phnx.qwest.net) (Remote host closed the connection) |
| 2023-02-03 04:43:06 +0100 | Midjak | (~Midjak@82.66.147.146) (Quit: This computer has gone to sleep) |
| 2023-02-03 04:45:01 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:b571:9acb:283f:a733) |
| 2023-02-03 04:48:49 +0100 | mikoto-chan | (~mikoto-ch@2001:999:60c:3d81:b055:1b0d:b7c7:2a51) (Ping timeout: 252 seconds) |
| 2023-02-03 04:50:47 +0100 | mikoto-chan | (~mikoto-ch@85-76-133-194-nat.elisa-mobile.fi) |
| 2023-02-03 04:53:50 +0100 | renatofdds | (~user@user/renatofdds) () |
| 2023-02-03 04:54:53 +0100 | johnw | (~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net) (Quit: ZNC - http://znc.in) |
| 2023-02-03 04:55:06 +0100 | [itchyjunk] | (~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer) |
| 2023-02-03 04:55:17 +0100 | bilegeek | (~bilegeek@2600:1008:b065:4d4e:37b2:1ed7:a9d0:2c6f) (Quit: Leaving) |
| 2023-02-03 04:58:27 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:b571:9acb:283f:a733) (Remote host closed the connection) |
| 2023-02-03 04:59:20 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:b571:9acb:283f:a733) |
| 2023-02-03 05:12:42 +0100 | opticblast | (~Thunderbi@172.58.80.152) (Quit: opticblast) |
| 2023-02-03 05:12:59 +0100 | opticblast | (~Thunderbi@172.58.82.233) |
| 2023-02-03 05:13:55 +0100 | opticblast | (~Thunderbi@172.58.82.233) (Read error: Connection reset by peer) |
| 2023-02-03 05:14:19 +0100 | opticblast | (~Thunderbi@172.58.82.233) |
| 2023-02-03 05:29:11 +0100 | falafel | (~falafel@2607:fb91:1449:aea0:14d8:1ad5:a3d2:34a) |
| 2023-02-03 05:32:49 +0100 | king_gs | (~Thunderbi@2806:103e:29:34e5:c1c4:cdf:cabc:3345) (Ping timeout: 252 seconds) |
| 2023-02-03 05:35:31 +0100 | merijn | (~merijn@86.86.29.250) |
| 2023-02-03 05:40:07 +0100 | merijn | (~merijn@86.86.29.250) (Ping timeout: 252 seconds) |
| 2023-02-03 05:42:39 +0100 | king_gs | (~Thunderbi@187.201.2.248) |
| 2023-02-03 05:43:27 +0100 | hounded | (~hounded@2603-7000-da43-eccc-0000-0000-0000-0cec.res6.spectrum.com) (Quit: Leaving) |
| 2023-02-03 05:43:27 +0100 | hounded_woodstoc | (~hounded@2603-7000-da43-eccc-0000-0000-0000-0cec.res6.spectrum.com) (Quit: Leaving) |
| 2023-02-03 06:10:21 +0100 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) |
| 2023-02-03 06:11:00 +0100 | king_gs | (~Thunderbi@187.201.2.248) (Read error: Connection reset by peer) |
| 2023-02-03 06:11:44 +0100 | king_gs | (~Thunderbi@2806:103e:29:34e5:acd5:8705:774f:5c3a) |
| 2023-02-03 06:11:59 +0100 | Unicorn_Princess | (~Unicorn_P@user/Unicorn-Princess/x-3540542) (Quit: Leaving) |
| 2023-02-03 06:17:04 +0100 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 260 seconds) |
| 2023-02-03 06:18:28 +0100 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) |
| 2023-02-03 06:39:34 +0100 | bgs | (~bgs@212-85-160-171.dynamic.telemach.net) |
| 2023-02-03 06:44:32 +0100 | motherfsck | (~motherfsc@user/motherfsck) (Ping timeout: 248 seconds) |
| 2023-02-03 06:54:39 +0100 | thongpv | (~thongpv87@14.179.159.25) (Ping timeout: 248 seconds) |
| 2023-02-03 06:58:35 +0100 | motherfsck | (~motherfsc@user/motherfsck) |
| 2023-02-03 07:02:44 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds) |
| 2023-02-03 07:05:59 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) |
| 2023-02-03 07:06:39 +0100 | opticblast | (~Thunderbi@172.58.82.233) (Ping timeout: 260 seconds) |
| 2023-02-03 07:09:30 +0100 | waleee | (~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) |
| 2023-02-03 07:16:50 +0100 | Lycurgus | (~juan@user/Lycurgus) |
| 2023-02-03 07:29:29 +0100 | takuan | (~takuan@178-116-218-225.access.telenet.be) |
| 2023-02-03 07:31:16 +0100 | trev_ | (~trev@109-252-35-99.nat.spd-mgts.ru) |
| 2023-02-03 07:38:39 +0100 | falafel | (~falafel@2607:fb91:1449:aea0:14d8:1ad5:a3d2:34a) (Ping timeout: 255 seconds) |
| 2023-02-03 07:41:28 +0100 | bgs | (~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection) |
| 2023-02-03 07:42:51 +0100 | Inst | (~Inst@2601:6c4:4081:54f0:6ca9:ab81:4dc0:f885) (Read error: Connection reset by peer) |
| 2023-02-03 07:43:13 +0100 | Inst | (~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240) |
| 2023-02-03 07:43:48 +0100 | kenran | (~user@user/kenran) |
| 2023-02-03 07:45:15 +0100 | michalz | (~michalz@185.246.207.217) |
| 2023-02-03 07:48:08 +0100 | falafel | (~falafel@2607:fb91:1449:aea0:14d8:1ad5:a3d2:34a) |
| 2023-02-03 07:49:00 +0100 | jao | (~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) (Ping timeout: 255 seconds) |
| 2023-02-03 07:56:18 +0100 | Guest75 | (~Guest75@178.141.149.12) |
| 2023-02-03 07:58:26 +0100 | Varoo | (~Varoo@117.203.246.41) |
| 2023-02-03 08:03:27 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2023-02-03 08:08:26 +0100 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 255 seconds) |
| 2023-02-03 08:08:37 +0100 | falafel | (~falafel@2607:fb91:1449:aea0:14d8:1ad5:a3d2:34a) (Ping timeout: 252 seconds) |
| 2023-02-03 08:09:43 +0100 | king_gs | (~Thunderbi@2806:103e:29:34e5:acd5:8705:774f:5c3a) (Ping timeout: 252 seconds) |
| 2023-02-03 08:10:49 +0100 | Lycurgus | (~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz) |
| 2023-02-03 08:10:49 +0100 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) |
| 2023-02-03 08:12:39 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2023-02-03 08:16:10 +0100 | troydm | (~troydm@user/troydm) (Ping timeout: 252 seconds) |
| 2023-02-03 08:21:30 +0100 | johnw | (~johnw@2600:1700:cf00:db0:44e6:2d71:3c2a:1669) |
| 2023-02-03 08:26:10 +0100 | lortabac | (~lortabac@2a01:e0a:541:b8f0:da1d:7c03:5fef:8e2d) |
| 2023-02-03 08:30:52 +0100 | <sm> | what would you think is better: |
| 2023-02-03 08:30:52 +0100 | <sm> | `data Date = ExactDate Day | FlexDate Day` or |
| 2023-02-03 08:30:52 +0100 | <sm> | `data Date = Date Day Bool` ? |
| 2023-02-03 08:32:32 +0100 | <dminuoso> | sm: The first. |
| 2023-02-03 08:32:39 +0100 | <dminuoso> | Or hold on |
| 2023-02-03 08:32:41 +0100 | <dminuoso> | Or you can do: |
| 2023-02-03 08:32:54 +0100 | <dminuoso> | `data DateMode = Exact | Flex` and `data Date = Date Day DateMode` |
| 2023-02-03 08:33:16 +0100 | <dminuoso> | sm: I tend to favour `data Date = ExactDate Day | FlexDate Day` *if* I have optics around already. |
| 2023-02-03 08:33:39 +0100 | <dminuoso> | Because you can conjure up an unsafe lens into that day more easily |
| 2023-02-03 08:34:55 +0100 | <dminuoso> | sm: https://gist.github.com/dminuoso/e30354344fe15998c283e28d16fcd99c |
| 2023-02-03 08:38:18 +0100 | <dminuoso> | Without optics, it really depends on your access type. Separate constructors increases the likelihood that consumer sites discriminate the mode (if that is frequently important). With a singular constructor accessing the day is a bit faster and potentially more convenient, but you can also just use a `getDay :: Date -> Day` function, even with view patterns if you like this in a pattern match |
| 2023-02-03 08:38:19 +0100 | <dminuoso> | position |
| 2023-02-03 08:39:59 +0100 | motherfsck | (~motherfsc@user/motherfsck) (Ping timeout: 260 seconds) |
| 2023-02-03 08:40:37 +0100 | <sm> | dminuoso: that all made sense until your paste. Lost me there! |
| 2023-02-03 08:43:56 +0100 | <dminuoso> | sm: In your case it would be: day :: Lens Date Day; day = unsafeSingular (_ExactDate `failingT` _FlexDate) |
| 2023-02-03 08:44:01 +0100 | <dminuoso> | Sorry, *Lens' |
| 2023-02-03 08:44:36 +0100 | <dminuoso> | This can be useful if you you have a large, possibly nested, sum type in which some particular structure appears along every constructor |
| 2023-02-03 08:46:15 +0100 | <dminuoso> | i.e. if in its true sums of products representation, each summand would have a field of that type |
| 2023-02-03 08:47:16 +0100 | <sm> | ok.. types are relatively small and lens not much used in this project, I'll keep it simple. I'm not sure which of these (three) simple types is preferable. It doesn't matter much, but it's going to be a lot of edits so hope I pick the right one |
| 2023-02-03 08:48:27 +0100 | <dminuoso> | sm: I would just remove `data Date = Date Day Bool` entirely from the options |
| 2023-02-03 08:48:35 +0100 | danza | (~francesco@151.53.13.66) (Ping timeout: 252 seconds) |
| 2023-02-03 08:48:46 +0100 | <dminuoso> | It's very tedious inband signalling, where the value of bool says absolutely nothing about its provenance |
| 2023-02-03 08:49:03 +0100 | <sm> | ok, Date Day DateMode looks good then |
| 2023-02-03 08:49:31 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2023-02-03 08:51:10 +0100 | <sm> | I could argue it both ways, Bool or DateMode. No matter |
| 2023-02-03 08:51:18 +0100 | <sm> | thanks! |
| 2023-02-03 08:53:05 +0100 | gurkenglas | (~gurkengla@dynamic-046-114-182-034.46.114.pool.telefonica.de) |
| 2023-02-03 08:53:15 +0100 | <dminuoso> | sm: Sure, on a theoretic level DateMode suffers from boolean blindness as well, but assuming some very rudimentary discipline where dont copy the world with functions like `filterX :: (a -> DateMode) -> [a] -> [a]`, then the meaning of `FlexMode` should usualy be clear |
| 2023-02-03 08:53:36 +0100 | <dminuoso> | especially if you limit the places where you generate such values to some domain specific code |
| 2023-02-03 08:54:34 +0100 | <dminuoso> | a True can mean anything, maybe two strings are equal, or maybe one list is larger than the other (or the other way?!) |
| 2023-02-03 08:55:21 +0100 | motherfsck | (~motherfsc@user/motherfsck) |
| 2023-02-03 08:56:59 +0100 | <sm> | the codebase and context are small here |
| 2023-02-03 08:57:22 +0100 | Varoo | (~Varoo@117.203.246.41) (Ping timeout: 252 seconds) |
| 2023-02-03 08:57:41 +0100 | <sm> | actually my original doubt was are any of these worse storage- or laziness-wise ? |
| 2023-02-03 08:57:55 +0100 | <sm> | or are they all roughly equivalent ? |
| 2023-02-03 08:58:39 +0100 | <sm> | I mean, is the two-constructor ADT equivalent to the single constructor one. I'm guessing so |
| 2023-02-03 08:59:25 +0100 | <dminuoso> | sm: well, they can encode different things with respect to lazyness of course. |
| 2023-02-03 08:59:36 +0100 | <dminuoso> | with the one-constructor version the date mode can be kept lazy |
| 2023-02-03 08:59:42 +0100 | <dminuoso> | *not lazy |
| 2023-02-03 08:59:59 +0100 | <dminuoso> | because to extract the date, you have to discriminate on the date mode first (via constructor selection) |
| 2023-02-03 09:00:29 +0100 | codaraxis | (~codaraxis@user/codaraxis) |
| 2023-02-03 09:00:47 +0100 | <dminuoso> | other than that, the two-constructor form is the true sums of products representation of the one-constructor + nested nullary form |
| 2023-02-03 09:00:55 +0100 | kassouni | (~kassouni@2601:646:400:68b0:f5a4:b4c5:300f:d7b8) |
| 2023-02-03 09:01:09 +0100 | danza | (~francesco@151.35.43.42) |
| 2023-02-03 09:01:32 +0100 | <dminuoso> | (or I guess just "sums of products") |
| 2023-02-03 09:02:19 +0100 | <dminuoso> | On a technical level, it seems that even with the outer-two-constructor form you should be able to extract the Day without discriminating the constructor |
| 2023-02-03 09:03:56 +0100 | <dminuoso> | But as far as I know, we dont have an explicit way to describe this access, such as `f :: Date -> T; f (_ day) = ...` |
| 2023-02-03 09:04:16 +0100 | codaraxis__ | (~codaraxis@user/codaraxis) |
| 2023-02-03 09:05:09 +0100 | codaraxis__ | (~codaraxis@user/codaraxis) (Remote host closed the connection) |
| 2023-02-03 09:06:55 +0100 | danza | (~francesco@151.35.43.42) (Ping timeout: 248 seconds) |
| 2023-02-03 09:07:39 +0100 | sm | makes it real obvious: |
| 2023-02-03 09:07:39 +0100 | sm | data Date = Date Day ExactOrFlex |
| 2023-02-03 09:07:39 +0100 | sm | data ExactOrFlex = Exact | Flex |
| 2023-02-03 09:08:00 +0100 | codaraxis | (~codaraxis@user/codaraxis) (Ping timeout: 248 seconds) |
| 2023-02-03 09:10:22 +0100 | Sgeo | (~Sgeo@user/sgeo) (Read error: Connection reset by peer) |
| 2023-02-03 09:11:18 +0100 | coot | (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) |
| 2023-02-03 09:12:33 +0100 | troydm | (~troydm@user/troydm) |
| 2023-02-03 09:16:15 +0100 | emmanuelux | (~emmanuelu@user/emmanuelux) |
| 2023-02-03 09:20:14 +0100 | danza | (~francesco@151.37.98.0) |
| 2023-02-03 09:20:16 +0100 | shriekingnoise | (~shrieking@186.137.175.87) (Ping timeout: 248 seconds) |
| 2023-02-03 09:25:28 +0100 | razetime | (~Thunderbi@117.193.4.182) (Ping timeout: 252 seconds) |
| 2023-02-03 09:27:13 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:b571:9acb:283f:a733) (Remote host closed the connection) |
| 2023-02-03 09:30:52 +0100 | gnalzo | (~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) |
| 2023-02-03 09:31:48 +0100 | <sm> | what silly mistake am I making here, which I can't figure out from docs ? |
| 2023-02-03 09:31:48 +0100 | <sm> | instance Functor Date where fmap f (Date d ef) = Date (f d) ef |
| 2023-02-03 09:31:48 +0100 | <sm> | "Expected kind ‘* -> *’, but ‘Date’ has kind ‘*’, In the first argument of ‘Functor’, namely ‘Date’" |
| 2023-02-03 09:32:37 +0100 | <c_wraith> | The error message sort of says it all |
| 2023-02-03 09:32:51 +0100 | <c_wraith> | Only type constructors that take an argument can be an instance of Functor |
| 2023-02-03 09:33:16 +0100 | <c_wraith> | The Date type doesn't have a type argument, so it can't be an instance of Functor |
| 2023-02-03 09:33:35 +0100 | <sm> | bah |
| 2023-02-03 09:33:49 +0100 | <sm> | thank you |
| 2023-02-03 09:36:07 +0100 | juri__ | (~juri@79.140.120.190) |
| 2023-02-03 09:37:11 +0100 | sloorush | (~sloorush@52.187.184.81) (Quit: ZNC 1.7.5+deb4 - https://znc.in) |
| 2023-02-03 09:37:53 +0100 | juri_ | (~juri@84-19-175-179.pool.ovpn.com) (Ping timeout: 246 seconds) |
| 2023-02-03 09:41:14 +0100 | freeside | (~mengwong@103.252.202.170) (Ping timeout: 260 seconds) |
| 2023-02-03 09:42:00 +0100 | juri__ | (~juri@79.140.120.190) (Read error: Connection reset by peer) |
| 2023-02-03 09:43:29 +0100 | razetime | (~Thunderbi@117.193.4.182) |
| 2023-02-03 09:44:04 +0100 | ft | (~ft@p4fc2a257.dip0.t-ipconnect.de) (Quit: leaving) |
| 2023-02-03 09:45:36 +0100 | tzh | (~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz) |
| 2023-02-03 09:45:57 +0100 | freeside | (~mengwong@103.252.202.170) |
| 2023-02-03 09:47:42 +0100 | akegalj | (~akegalj@93-139-137-183.adsl.net.t-com.hr) |
| 2023-02-03 09:53:49 +0100 | avicenzi | (~avicenzi@2a00:ca8:a1f:b004::c32) |
| 2023-02-03 09:56:29 +0100 | freeside | (~mengwong@103.252.202.170) (Ping timeout: 252 seconds) |
| 2023-02-03 09:57:46 +0100 | juri_ | (~juri@84-19-175-179.pool.ovpn.com) |
| 2023-02-03 10:00:12 +0100 | JhonPedroza[m] | (~jfpedroza@2001:470:69fc:105::2:e2a4) (Quit: You have been kicked for being idle) |
| 2023-02-03 10:01:06 +0100 | thongpv | (~thongpv87@14.179.159.25) |
| 2023-02-03 10:01:47 +0100 | merijn | (~merijn@86-86-29-250.fixed.kpn.net) |
| 2023-02-03 10:05:55 +0100 | acidjnk_new3 | (~acidjnk@p200300d6e715c4384c61433e25d9b335.dip0.t-ipconnect.de) |
| 2023-02-03 10:10:35 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2023-02-03 10:14:06 +0100 | kassouni | (~kassouni@2601:646:400:68b0:f5a4:b4c5:300f:d7b8) (Quit: My Mac has gone to sleep. ZZZzzz…) |
| 2023-02-03 10:14:43 +0100 | Guest75 | (~Guest75@178.141.149.12) (Ping timeout: 260 seconds) |
| 2023-02-03 10:15:45 +0100 | freeside | (~mengwong@103.252.202.170) |
| 2023-02-03 10:16:49 +0100 | danza | (~francesco@151.37.98.0) (Ping timeout: 260 seconds) |
| 2023-02-03 10:17:36 +0100 | kassouni | (~kassouni@2601:646:400:68b0:18dc:d2:c373:8213) |
| 2023-02-03 10:20:04 +0100 | EvanR_ | (~EvanR@user/evanr) |
| 2023-02-03 10:20:15 +0100 | EvanR | (~EvanR@user/evanr) (Ping timeout: 252 seconds) |
| 2023-02-03 10:20:28 +0100 | gurkenglas | (~gurkengla@dynamic-046-114-182-034.46.114.pool.telefonica.de) (Ping timeout: 252 seconds) |
| 2023-02-03 10:22:11 +0100 | kassouni | (~kassouni@2601:646:400:68b0:18dc:d2:c373:8213) (Client Quit) |
| 2023-02-03 10:23:44 +0100 | lisbeths | (uid135845@id-135845.lymington.irccloud.com) |
| 2023-02-03 10:23:56 +0100 | mmhat | (~mmh@p200300f1c707be79ee086bfffe095315.dip0.t-ipconnect.de) |
| 2023-02-03 10:27:42 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:b571:9acb:283f:a733) |
| 2023-02-03 10:30:03 +0100 | danza | (~francesco@37.102.50.60) |
| 2023-02-03 10:31:59 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:b571:9acb:283f:a733) (Ping timeout: 252 seconds) |
| 2023-02-03 10:32:26 +0100 | MajorBiscuit | (~MajorBisc@145.94.153.3) |
| 2023-02-03 10:33:07 +0100 | econo | (uid147250@user/econo) (Quit: Connection closed for inactivity) |
| 2023-02-03 10:41:41 +0100 | kassouni | (~kassouni@2601:646:400:68b0:f5a4:b4c5:300f:d7b8) |
| 2023-02-03 10:47:57 +0100 | kuribas | (~user@ptr-17d51emhfv4hfc1jc5w.18120a2.ip6.access.telenet.be) |
| 2023-02-03 10:55:26 +0100 | teo | (~teo@user/teo) |
| 2023-02-03 11:04:15 +0100 | zeenk | (~zeenk@2a02:2f04:a214:1e00::7fe) |
| 2023-02-03 11:05:14 +0100 | xff0x | (~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 260 seconds) |
| 2023-02-03 11:11:10 +0100 | __monty__ | (~toonn@user/toonn) |
| 2023-02-03 11:23:07 +0100 | thongpv | (~thongpv87@14.179.159.25) (Ping timeout: 248 seconds) |
| 2023-02-03 11:23:35 +0100 | chele | (~chele@user/chele) |
| 2023-02-03 11:27:42 +0100 | raehik | (~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) |
| 2023-02-03 11:28:48 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:f424:933a:fcd6:76ad) |
| 2023-02-03 11:31:03 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2023-02-03 11:33:12 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:f424:933a:fcd6:76ad) (Ping timeout: 252 seconds) |
| 2023-02-03 11:37:39 +0100 | razetime | (~Thunderbi@117.193.4.182) (Quit: See You Space Cowboy) |
| 2023-02-03 12:04:32 +0100 | kitzman | (~kitzman@user/dekenevs) |
| 2023-02-03 12:07:12 +0100 | gnalzo | (~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8) |
| 2023-02-03 12:11:58 +0100 | caryhartline | (~caryhartl@2600:1700:2d0:8d30:a932:353f:91f2:f048) (Quit: caryhartline) |
| 2023-02-03 12:12:08 +0100 | kassouni | (~kassouni@2601:646:400:68b0:f5a4:b4c5:300f:d7b8) (Quit: My Mac has gone to sleep. ZZZzzz…) |
| 2023-02-03 12:12:58 +0100 | kassouni | (~kassouni@2601:646:400:68b0:18dc:d2:c373:8213) |
| 2023-02-03 12:13:36 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) (Ping timeout: 248 seconds) |
| 2023-02-03 12:18:15 +0100 | mc47 | (~mc47@xmonad/TheMC47) |
| 2023-02-03 12:18:57 +0100 | mikoto-chan | (~mikoto-ch@85-76-133-194-nat.elisa-mobile.fi) (Quit: WeeChat 3.6) |
| 2023-02-03 12:26:27 +0100 | freeside_ | (~mengwong@103.252.202.170) |
| 2023-02-03 12:26:27 +0100 | mmhat | (~mmh@p200300f1c707be79ee086bfffe095315.dip0.t-ipconnect.de) (Quit: WeeChat 3.8) |
| 2023-02-03 12:27:14 +0100 | freeside | (~mengwong@103.252.202.170) (Ping timeout: 246 seconds) |
| 2023-02-03 13:01:20 +0100 | xff0x | (~xff0x@2405:6580:b080:900:e7c5:c7:8d46:6e81) |
| 2023-02-03 13:04:00 +0100 | freeside_ | (~mengwong@103.252.202.170) (Ping timeout: 260 seconds) |
| 2023-02-03 13:14:23 +0100 | ubert | (~Thunderbi@p548c8ef0.dip0.t-ipconnect.de) (Read error: Connection reset by peer) |
| 2023-02-03 13:18:33 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2023-02-03 13:18:39 +0100 | freeside | (~mengwong@103.252.202.170) |
| 2023-02-03 13:23:13 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2023-02-03 13:27:57 +0100 | waleee | (~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Quit: WeeChat 3.8) |
| 2023-02-03 13:29:05 +0100 | waleee | (~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) |
| 2023-02-03 13:30:34 +0100 | <merijn> | hmm, I see random-fu has a Categorical distribution for weighted sampling, but it doesn't really do sampling without replacement. Anyone happen to know any algorithms for implementing sampling without replacement on top of that? |
| 2023-02-03 13:33:38 +0100 | <maerwald[m]> | merijn: did you know d_type is not portable? |
| 2023-02-03 13:34:25 +0100 | <merijn> | ENOCONTEXT |
| 2023-02-03 13:35:26 +0100 | <maerwald[m]> | JFS just returns DT_UNKNOWN |
| 2023-02-03 13:35:51 +0100 | <merijn> | I don't even know what JFS is? |
| 2023-02-03 13:36:11 +0100 | <maerwald[m]> | Journaling filesystem's |
| 2023-02-03 13:36:49 +0100 | <merijn> | I feel there's a whole lotta implicit context to this question/comment that I'm too tired/distracted to infer :) |
| 2023-02-03 13:36:57 +0100 | <maerwald[m]> | It's older than ext2 |
| 2023-02-03 13:37:16 +0100 | <maerwald[m]> | merijn: my application is busted on JFS, lol |
| 2023-02-03 13:37:28 +0100 | <merijn> | ok, so JFS is a specific filesystem and I'm assuming this is some posix compat horror story? :p |
| 2023-02-03 13:37:28 +0100 | bgs | (~bgs@212-85-160-171.dynamic.telemach.net) |
| 2023-02-03 13:37:43 +0100 | <maerwald[m]> | And we just had a PR in unix to add DirType to the API |
| 2023-02-03 13:38:16 +0100 | <maerwald[m]> | Except now your app only works on some filesystems |
| 2023-02-03 13:39:06 +0100 | <maerwald[m]> | Now I need a separate syscall for every file... |
| 2023-02-03 13:39:06 +0100 | mrmonday | (~robert@what.i.hope.is.not.a.tabernaevagant.es) (Quit: .) |
| 2023-02-03 13:39:10 +0100 | coot | (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot) |
| 2023-02-03 13:39:51 +0100 | jeetelongname | (~jeet@148.197.248.56) |
| 2023-02-03 13:41:00 +0100 | mrmonday | (~robert@what.i.hope.is.not.a.tabernaevagant.es) |
| 2023-02-03 13:42:04 +0100 | kassouni | (~kassouni@2601:646:400:68b0:18dc:d2:c373:8213) (Quit: My Mac has gone to sleep. ZZZzzz…) |
| 2023-02-03 13:43:25 +0100 | __monty__ | (~toonn@user/toonn) (Ping timeout: 268 seconds) |
| 2023-02-03 13:44:02 +0100 | <merijn> | maerwald[m]: After consulting religious scripture I've got even worse news for you |
| 2023-02-03 13:44:36 +0100 | <merijn> | maerwald[m]: Only d_ino and d_name are required (and thus portable) according to posix.1 |
| 2023-02-03 13:44:45 +0100 | <merijn> | Everything else is implementation defined |
| 2023-02-03 13:47:52 +0100 | akegalj | (~akegalj@93-139-137-183.adsl.net.t-com.hr) (Quit: leaving) |
| 2023-02-03 13:51:53 +0100 | <maerwald[m]> | So how would you deal with it at runtime |
| 2023-02-03 13:53:40 +0100 | <maerwald[m]> | I'm not sure there's a sensible mechanism |
| 2023-02-03 13:53:49 +0100 | jeetelongname | (~jeet@148.197.248.56) (Ping timeout: 260 seconds) |
| 2023-02-03 13:53:51 +0100 | <merijn> | You don't |
| 2023-02-03 13:54:10 +0100 | <merijn> | You gotta handle it at compile time for autoconf misery :p |
| 2023-02-03 13:54:21 +0100 | coot | (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) |
| 2023-02-03 13:54:49 +0100 | <kuribas> | the joy of unhygienic macros. |
| 2023-02-03 13:54:52 +0100 | <maerwald[m]> | This is not compile time. |
| 2023-02-03 13:55:10 +0100 | <maerwald[m]> | I don't compile my app against JFS :P |
| 2023-02-03 13:55:21 +0100 | <merijn> | maerwald[m]: oh, you mean how to handle DT_UNKNOWN? |
| 2023-02-03 13:55:23 +0100 | <maerwald[m]> | It just returns nonsense for d_type |
| 2023-02-03 13:56:07 +0100 | <maerwald[m]> | Yeah, it's normally used to know when the stream is done |
| 2023-02-03 13:57:05 +0100 | <merijn> | I mean, maybe that's just a bug in the kernel module for JFS :p |
| 2023-02-03 13:57:16 +0100 | <merijn> | Either way, I don't see how you can really "handle" it |
| 2023-02-03 13:59:57 +0100 | L29Ah[x] | (~L29Ah@wikipedia/L29Ah) (Ping timeout: 256 seconds) |
| 2023-02-03 14:07:07 +0100 | yrlnry | (~yrlnry@2600:4040:738e:5400:87d:f2d:382e:ac3d) (Remote host closed the connection) |
| 2023-02-03 14:08:15 +0100 | yrlnry | (~yrlnry@pool-108-36-173-41.phlapa.fios.verizon.net) |
| 2023-02-03 14:16:18 +0100 | rekahsoft | (~rekahsoft@bras-base-orllon1122w-grc-05-174-88-194-86.dsl.bell.ca) |
| 2023-02-03 14:17:57 +0100 | danza | (~francesco@37.102.50.60) (Ping timeout: 268 seconds) |
| 2023-02-03 14:21:02 +0100 | freeside | (~mengwong@103.252.202.170) (Ping timeout: 246 seconds) |
| 2023-02-03 14:22:39 +0100 | kuribas | (~user@ptr-17d51emhfv4hfc1jc5w.18120a2.ip6.access.telenet.be) (Ping timeout: 248 seconds) |
| 2023-02-03 14:27:53 +0100 | <maerwald> | merijn: I'm guessing musl shoves some compatibility code over the filesystem thing |
| 2023-02-03 14:28:21 +0100 | <maerwald> | or is it the kernel deciding |
| 2023-02-03 14:28:34 +0100 | <maerwald> | because I build against musl |
| 2023-02-03 14:30:38 +0100 | Guest|50 | (~Guest|50@128.243.2.19) |
| 2023-02-03 14:30:44 +0100 | danza | (~francesco@37.102.50.60) |
| 2023-02-03 14:31:07 +0100 | <mauke> | wait, d_ino is standard? |
| 2023-02-03 14:31:18 +0100 | <mauke> | I thought only the name was reliable |
| 2023-02-03 14:32:10 +0100 | <maerwald> | jeez |
| 2023-02-03 14:33:11 +0100 | Guest|50 | (~Guest|50@128.243.2.19) (Client Quit) |
| 2023-02-03 14:36:17 +0100 | freeside | (~mengwong@103.252.202.170) |
| 2023-02-03 14:38:40 +0100 | waleee | (~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 248 seconds) |
| 2023-02-03 14:39:50 +0100 | <geekosaur> | I recall that being an issue with reiserfs because it used a large hash for d_ino which wasn't POSIX compatible |
| 2023-02-03 14:40:57 +0100 | freeside | (~mengwong@103.252.202.170) (Ping timeout: 252 seconds) |
| 2023-02-03 14:42:04 +0100 | freeside | (~mengwong@103.252.202.170) |
| 2023-02-03 14:43:39 +0100 | trev_ | (~trev@109-252-35-99.nat.spd-mgts.ru) (Remote host closed the connection) |
| 2023-02-03 14:45:39 +0100 | maerwald | waiting for jail jokes |
| 2023-02-03 14:47:06 +0100 | <geekosaur> | "beats your wife" jokes, and SuSE dropped it like a hot potato after having all but switched to it |
| 2023-02-03 14:51:59 +0100 | freeside | (~mengwong@103.252.202.170) (Ping timeout: 248 seconds) |
| 2023-02-03 14:56:28 +0100 | jero98772 | (~jero98772@2800:484:1d80:d8ce:9815:cfda:3661:17bb) |
| 2023-02-03 15:01:31 +0100 | FragByte | (~christian@user/fragbyte) (Quit: Quit) |
| 2023-02-03 15:01:49 +0100 | FragByte | (~christian@user/fragbyte) |
| 2023-02-03 15:05:13 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2023-02-03 15:05:47 +0100 | FragByte | (~christian@user/fragbyte) (Client Quit) |
| 2023-02-03 15:05:55 +0100 | rekahsoft | (~rekahsoft@bras-base-orllon1122w-grc-05-174-88-194-86.dsl.bell.ca) (Remote host closed the connection) |
| 2023-02-03 15:06:36 +0100 | rekahsoft | (~rekahsoft@bras-base-orllon1122w-grc-05-174-88-194-86.dsl.bell.ca) |
| 2023-02-03 15:06:46 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) (Quit: = "") |
| 2023-02-03 15:08:14 +0100 | L29Ah | (~L29Ah@wikipedia/L29Ah) |
| 2023-02-03 15:10:26 +0100 | <jean-paul[m]> | Given a record constructor and a list of string/value pairs, is there a way to process the list in order - or should I just build a Map and pull fields out of it (either in the order the constructor requires or pull them all out and use the record syntax to call it)? |
| 2023-02-03 15:11:48 +0100 | Midjak | (~Midjak@82.66.147.146) |
| 2023-02-03 15:15:41 +0100 | elevenkb | (~elevenkb@105.184.125.233) |
| 2023-02-03 15:16:27 +0100 | akegalj | (~akegalj@89-164-123-86.dsl.iskon.hr) |
| 2023-02-03 15:20:28 +0100 | freeside | (~mengwong@103.252.202.170) |
| 2023-02-03 15:22:01 +0100 | elevenkb | (~elevenkb@105.184.125.233) (Quit: Client closed) |
| 2023-02-03 15:23:52 +0100 | <maerwald> | merijn: https://paste.tomsmeding.com/tQhp7pfA |
| 2023-02-03 15:24:55 +0100 | <maerwald> | that works if we always get DT_UNKNOWN for unsupported d_type |
| 2023-02-03 15:25:02 +0100 | <maerwald> | I'm not sure where that is defined though |
| 2023-02-03 15:25:10 +0100 | freeside | (~mengwong@103.252.202.170) (Ping timeout: 268 seconds) |
| 2023-02-03 15:25:50 +0100 | freeside | (~mengwong@103.252.202.170) |
| 2023-02-03 15:26:36 +0100 | coot | (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot) |
| 2023-02-03 15:41:44 +0100 | <merijn> | jean-paul[m]: You can use sortOn |
| 2023-02-03 15:41:57 +0100 | <merijn> | :t sortOn |
| 2023-02-03 15:41:58 +0100 | <lambdabot> | Ord b => (a -> b) -> [a] -> [a] |
| 2023-02-03 15:42:41 +0100 | <jean-paul[m]> | True. My ordering is pretty arbitrary, I guess the sort function would be as ugly as what I have to do w/o it. |
| 2023-02-03 15:42:43 +0100 | <merijn> | jean-paul[m]: oh, wait, you mean strings corresponding to record fields? |
| 2023-02-03 15:42:54 +0100 | <jean-paul[m]> | no, there's a mapping |
| 2023-02-03 15:43:17 +0100 | <merijn> | ok, then you need to be a bit more specific about what exactly you wanna do, because it's unclear to me |
| 2023-02-03 15:43:22 +0100 | <jean-paul[m]> | I'm probably prematurely optimizing, it's easy enough to just build a Map and then lookup stuff in it |
| 2023-02-03 15:43:55 +0100 | <jean-paul[m]> | https://gist.github.com/exarkun/11fdedc5a3854a5f598c07696a0b906e is what I have now |
| 2023-02-03 15:43:55 +0100 | tomku | (~tomku@user/tomku) (Read error: Connection reset by peer) |
| 2023-02-03 15:47:35 +0100 | <jean-paul[m]> | I thought maybe instead of building the map I could handle each tuple as it came somehow (but I see lots of things that get in the way of that working, so I asked) |
| 2023-02-03 15:48:43 +0100 | szkl | (uid110435@id-110435.uxbridge.irccloud.com) |
| 2023-02-03 15:49:31 +0100 | tomku | (~tomku@user/tomku) |
| 2023-02-03 15:51:33 +0100 | yrlnry | (~yrlnry@pool-108-36-173-41.phlapa.fios.verizon.net) (Read error: Connection reset by peer) |
| 2023-02-03 15:52:52 +0100 | <Profpatsch> | What’s the easiest way to use Data.Data to say “check recursively whether all subfields of type T in a value use a specific constructor of T |
| 2023-02-03 15:52:52 +0100 | Joao003 | (~Joao003@2804:840:8312:3400:bc73:fa44:9f4e:9fda) |
| 2023-02-03 15:54:35 +0100 | <Profpatsch> | So something like data T = A T | B T gfold (\case { A t -> gfold t; B _ -> All False }) (val :: T) |
| 2023-02-03 15:54:45 +0100 | wroathe | (~wroathe@user/wroathe) |
| 2023-02-03 15:54:56 +0100 | yrlnry | (~yrlnry@2600:4040:738e:5400:87d:f2d:382e:ac3d) |
| 2023-02-03 15:55:18 +0100 | <Profpatsch> | should return Sum True iff all Ts are A recursively |
| 2023-02-03 15:57:14 +0100 | jonathanx | (~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) (Ping timeout: 268 seconds) |
| 2023-02-03 15:57:28 +0100 | <Profpatsch> | Give it another constructor C so it is finite |
| 2023-02-03 15:58:43 +0100 | <Profpatsch> | maybe https://hackage.haskell.org/package/generics-sop-0.5.1.2/docs/Generics-SOP.html#v:hcfoldMap |
| 2023-02-03 16:00:26 +0100 | <[Leary]> | jean-paul[m]: There are various things you could do, but they'd mostly be for the worse. One option would be to write a `parseExtensionField :: (B.ByteString, B.Bytestring) -> URIExtension -> Either String URIExtension` and use it to fold down your list over some default record. |
| 2023-02-03 16:02:03 +0100 | <Profpatsch> | Oh I think gmapQ wtih a function to Bool and then `and` the result |
| 2023-02-03 16:02:43 +0100 | lisbeths | (uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity) |
| 2023-02-03 16:04:04 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2023-02-03 16:05:16 +0100 | <Profpatsch> | no that’s not it, it’s a forall Data d |
| 2023-02-03 16:05:28 +0100 | <jean-paul[m]> | [Leary]: Thanks. I think I see how that could work. I think I would probably also need to track what had been filled as I fold because mostly there aren't sensible defaults so missing fields should be errors. Feels like a bunch more bookkeeping, I'll let the computer do the work for now. |
| 2023-02-03 16:07:29 +0100 | hounded | (~hounded@2603-7000-da43-eccc-0000-0000-0000-0cec.res6.spectrum.com) |
| 2023-02-03 16:07:41 +0100 | <merijn> | jean-paul[m]: So, this is for a parser? |
| 2023-02-03 16:07:43 +0100 | wroathe | (~wroathe@user/wroathe) (Ping timeout: 248 seconds) |
| 2023-02-03 16:07:49 +0100 | hounded_woodstoc | (~hounded@2603-7000-da43-eccc-0000-0000-0000-0cec.res6.spectrum.com) |
| 2023-02-03 16:08:00 +0100 | <jean-paul[m]> | merijn: yes |
| 2023-02-03 16:08:17 +0100 | wroathe | (~wroathe@207-153-38-140.fttp.usinternet.com) |
| 2023-02-03 16:08:17 +0100 | wroathe | (~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host) |
| 2023-02-03 16:08:17 +0100 | wroathe | (~wroathe@user/wroathe) |
| 2023-02-03 16:08:39 +0100 | <merijn> | jean-paul[m]: Not sure if it exactly fits your use case, but parser-combinators has Control.Monad.Permutation for parsing any permutation of a fixed number of fields |
| 2023-02-03 16:08:40 +0100 | coot | (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) |
| 2023-02-03 16:08:46 +0100 | <jean-paul[m]> | an earlier stage pulled a bunch of netstring-encoded pairs out of a ByteString |
| 2023-02-03 16:08:56 +0100 | Lycurgus | (~juan@user/Lycurgus) |
| 2023-02-03 16:09:00 +0100 | <merijn> | https://hackage.haskell.org/package/parser-combinators-1.3.0/docs/Control-Monad-Permutations.html |
| 2023-02-03 16:12:59 +0100 | wroathe | (~wroathe@user/wroathe) (Ping timeout: 252 seconds) |
| 2023-02-03 16:13:31 +0100 | <[Leary]> | jean-paul[m]: There are nice tricks with "higher kinded data" for this kind of thing. You can have a `base :: YourRecord Maybe` where every field is Nothing, then map pairs to `base{field=Just value}` and lift <|> over the type to combine them all. |
| 2023-02-03 16:15:56 +0100 | <merijn> | [Leary]: Like Permutation? ;) |
| 2023-02-03 16:17:13 +0100 | ft | (~ft@p4fc2a257.dip0.t-ipconnect.de) |
| 2023-02-03 16:21:58 +0100 | Joao003 | (~Joao003@2804:840:8312:3400:bc73:fa44:9f4e:9fda) (Quit: Leaving) |
| 2023-02-03 16:22:11 +0100 | thongpv | (~thongpv87@2402:9d80:368:85a6:1abd:cb53:feec:3e50) |
| 2023-02-03 16:23:32 +0100 | Varoo | (~Varoo@117.203.246.41) |
| 2023-02-03 16:23:36 +0100 | <Profpatsch> | Ah I can solve it with a fix (\f d -> case cast d of { A t -> f t; B _ -> False; C -> True }) |
| 2023-02-03 16:23:59 +0100 | <Profpatsch> | err and add a Just around everything and Nothing means it’s not of type T |
| 2023-02-03 16:24:41 +0100 | <Profpatsch> | fix (\f d -> case cast d of { JUst (A t) -> f t; Just (B _ )-> False; Just C -> True; Nothing -> True }) |
| 2023-02-03 16:25:45 +0100 | Lycurgus | (~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz) |
| 2023-02-03 16:29:45 +0100 | Varoo | (~Varoo@117.203.246.41) (Read error: Connection reset by peer) |
| 2023-02-03 16:30:32 +0100 | freeside | (~mengwong@103.252.202.170) (Ping timeout: 268 seconds) |
| 2023-02-03 16:30:41 +0100 | segfaultfizzbuzz | (~segfaultf@108.211.201.53) |
| 2023-02-03 16:31:05 +0100 | <segfaultfizzbuzz> | what are the major factors which drive the need for out-of-order execution in a program? |
| 2023-02-03 16:31:27 +0100 | varoo | (~varoo@117.203.246.41) |
| 2023-02-03 16:32:03 +0100 | zebrag | (~chris@user/zebrag) |
| 2023-02-03 16:35:16 +0100 | Sgeo | (~Sgeo@user/sgeo) |
| 2023-02-03 16:36:17 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) |
| 2023-02-03 16:36:52 +0100 | matijja | (~matijja@193.77.181.201) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2023-02-03 16:37:25 +0100 | <merijn> | segfaultfizzbuzz: In general? Load balancing |
| 2023-02-03 16:38:09 +0100 | <merijn> | and/or latency hiding, although you can argue those two are two different perspectives on the same thing |
| 2023-02-03 16:38:32 +0100 | kuribas | (~user@ptr-17d51en5pcqxlnvqlnm.18120a2.ip6.access.telenet.be) |
| 2023-02-03 16:39:01 +0100 | <segfaultfizzbuzz> | load balancing across cores...? |
| 2023-02-03 16:39:19 +0100 | <segfaultfizzbuzz> | what, how can latency be "hid"? |
| 2023-02-03 16:40:45 +0100 | matijja | (~matijja@193.77.181.201) |
| 2023-02-03 16:41:12 +0100 | shriekingnoise | (~shrieking@186.137.175.87) |
| 2023-02-03 16:42:24 +0100 | raehik | (~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 260 seconds) |
| 2023-02-03 16:43:34 +0100 | <merijn> | segfaultfizzbuzz: Depends a bit on where the question comes from :p That's true "in general", but if this is secretly a laziness question, then that has different answers :p |
| 2023-02-03 16:44:24 +0100 | <segfaultfizzbuzz> | ha ok |
| 2023-02-03 16:47:12 +0100 | <merijn> | Laziness is (often) implemented in ways the result in "execution out of order", but the *goal* is non-strictness. On the other hand, there is "out of order" behaviour in many strict settings too |
| 2023-02-03 16:47:26 +0100 | yrlnry | (~yrlnry@2600:4040:738e:5400:87d:f2d:382e:ac3d) (Quit: Leaving...) |
| 2023-02-03 16:48:15 +0100 | danza | (~francesco@37.102.50.60) (Ping timeout: 248 seconds) |
| 2023-02-03 16:50:07 +0100 | <kuribas> | I am implementing Union in my sql library. It just occurs to me that the difficulty aren't the types, it's building a consistent model. |
| 2023-02-03 16:50:34 +0100 | <kuribas> | The ease of dynamic languages is that they don't require consistency, so appear simpler. |
| 2023-02-03 16:50:58 +0100 | <kuribas> | At least, assuming people get past the initial learning curve. |
| 2023-02-03 16:51:27 +0100 | tessier_ | (~treed@98.171.210.130) (Ping timeout: 265 seconds) |
| 2023-02-03 16:51:29 +0100 | use-value | (~Thunderbi@2a00:23c6:8a03:2f01:e5a0:a2ae:d060:9326) (Quit: use-value) |
| 2023-02-03 16:51:48 +0100 | <kuribas> | Same with dependent types. Once you understand curry-howard, reasoning about DT isn't that hard, at least not harder than a complicated type level haskell program. |
| 2023-02-03 16:51:51 +0100 | <kuribas> | easier I'd say. |
| 2023-02-03 16:52:21 +0100 | <kuribas> | If I get "stuck" with the types, it's just because I don't have a consistent model in my mind. |
| 2023-02-03 16:53:00 +0100 | tessier | (~treed@98.171.210.130) |
| 2023-02-03 16:53:25 +0100 | <kuribas> | And after adding "spec" to a clojure program, it looks exactly like a typed haskell program, with all the redundancy that they complain about. |
| 2023-02-03 16:53:25 +0100 | waleee | (~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) |
| 2023-02-03 16:53:29 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) (Ping timeout: 255 seconds) |
| 2023-02-03 16:54:35 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) |
| 2023-02-03 16:58:32 +0100 | freeside | (~mengwong@103.252.202.170) |
| 2023-02-03 16:59:25 +0100 | <jean-paul[m]> | sounds right. |
| 2023-02-03 16:59:49 +0100 | <segfaultfizzbuzz> | merijn: hmm ok |
| 2023-02-03 17:01:03 +0100 | <Profpatsch> | ergh my solution above is wrong, it doesn’t recurse in the nothing case |
| 2023-02-03 17:01:49 +0100 | irrgit | (~irrgit@86.106.90.226) |
| 2023-02-03 17:01:50 +0100 | danza | (~francesco@37.102.116.190) |
| 2023-02-03 17:02:18 +0100 | <Profpatsch> | I think what I want is Lens.template |
| 2023-02-03 17:03:10 +0100 | freeside | (~mengwong@103.252.202.170) (Ping timeout: 260 seconds) |
| 2023-02-03 17:03:50 +0100 | mechap | (~mechap@user/mechap) (Ping timeout: 268 seconds) |
| 2023-02-03 17:05:17 +0100 | mechap | (~mechap@user/mechap) |
| 2023-02-03 17:08:38 +0100 | freeside | (~mengwong@103.252.202.170) |
| 2023-02-03 17:09:33 +0100 | ystael | (~ystael@user/ystael) |
| 2023-02-03 17:11:45 +0100 | analoq | (~yashi@user/dies) |
| 2023-02-03 17:13:18 +0100 | finsternis | (~X@23.226.237.192) (Read error: Connection reset by peer) |
| 2023-02-03 17:16:40 +0100 | roconnor | (~quassel@coq/roconnor) |
| 2023-02-03 17:20:49 +0100 | troydm | (~troydm@user/troydm) (Ping timeout: 252 seconds) |
| 2023-02-03 17:21:14 +0100 | lortabac | (~lortabac@2a01:e0a:541:b8f0:da1d:7c03:5fef:8e2d) (Quit: WeeChat 2.8) |
| 2023-02-03 17:24:59 +0100 | dsrt^ | (~tj99@c-24-30-76-89.hsd1.ga.comcast.net) (Remote host closed the connection) |
| 2023-02-03 17:28:23 +0100 | avicenzi | (~avicenzi@2a00:ca8:a1f:b004::c32) (Ping timeout: 264 seconds) |
| 2023-02-03 17:30:42 +0100 | <segfaultfizzbuzz> | okay so if i decompile a random binary program, can i decompile into any language? can i decompile into haskell? |
| 2023-02-03 17:33:24 +0100 | <darkling> | Probably not easily. I'd imagine that ghc-compiled code looks very different to, say, g++-compiled code, and your decompiler is going to have real problems producing something usable or understandable if it's expecting one and gets the other. |
| 2023-02-03 17:34:09 +0100 | MajorBiscuit | (~MajorBisc@145.94.153.3) (Quit: WeeChat 3.6) |
| 2023-02-03 17:34:34 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Read error: Connection reset by peer) |
| 2023-02-03 17:35:09 +0100 | <segfaultfizzbuzz> | decompilation "always" targets C? |
| 2023-02-03 17:35:51 +0100 | <segfaultfizzbuzz> | i think part of what i am thinking is that there is a lot of attention dedicated to what is the best language to compile into machine code, but i don't see a lot of discussion of the opposite direction |
| 2023-02-03 17:35:52 +0100 | <darkling> | It's a nice easy target. You can probably find decompilers for other languages if you look hard enough. |
| 2023-02-03 17:36:10 +0100 | <segfaultfizzbuzz> | and i mean that as a constraint for the design of a language |
| 2023-02-03 17:36:25 +0100 | <segfaultfizzbuzz> | constraint or guideline or somesuch |
| 2023-02-03 17:37:13 +0100 | zebrag | (~chris@user/zebrag) (Quit: Konversation terminated!) |
| 2023-02-03 17:37:19 +0100 | <merijn> | segfaultfizzbuzz: decompilation doesn't really exist |
| 2023-02-03 17:37:31 +0100 | <segfaultfizzbuzz> | merijn: elaborate plz? |
| 2023-02-03 17:37:39 +0100 | <merijn> | It's just "trying to invent code that would compile to something resembling this assembly" |
| 2023-02-03 17:38:00 +0100 | <merijn> | The more predictable the "X -> assembly" mapping is, the easier you can invent a conceivable mapping in reverse |
| 2023-02-03 17:38:25 +0100 | <segfaultfizzbuzz> | right along with guidelines like "make the code cognitively easy to interpret" and "make the code fairly compact" |
| 2023-02-03 17:38:30 +0100 | <merijn> | But considering there's infinitely many (at least, hypothetically) languages and program sequence that can result in the same assembly |
| 2023-02-03 17:38:47 +0100 | <merijn> | you have know way of reallying knowing what the origin was |
| 2023-02-03 17:39:01 +0100 | oldfashionedcow | (~Rahul_San@user/oldfashionedcow) (Quit: WeeChat 3.8) |
| 2023-02-03 17:39:01 +0100 | use-value | (~Thunderbi@2a00:23c6:8a03:2f01:4054:34b8:499a:7d46) |
| 2023-02-03 17:39:16 +0100 | <merijn> | But the mapping from Haskell to assembly is pretty complicated and hard to predict, so reversing "to haskell" is kinda hard |
| 2023-02-03 17:43:55 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) (Ping timeout: 252 seconds) |
| 2023-02-03 17:44:11 +0100 | <darkling> | It's hard enough going to C. And then harder understanding what the code's actually about when you don't have any variable or function names... |
| 2023-02-03 17:44:45 +0100 | <segfaultfizzbuzz> | ok but you can probably start by digging through common C libraries and matching stuff up,... |
| 2023-02-03 17:45:02 +0100 | <segfaultfizzbuzz> | you can probably get like 50+% of most stuff like that |
| 2023-02-03 17:45:25 +0100 | <darkling> | Oh, it's possible to work out what's happening eventually, but the semantics of the code is very much a human-mediated things. |
| 2023-02-03 17:45:29 +0100 | <darkling> | s/things/thing/ |
| 2023-02-03 17:45:49 +0100 | <geekosaur> | you should study decompilation of games, which has been going on for decades. you'll find out just how hard this really is |
| 2023-02-03 17:46:13 +0100 | <darkling> | Or even just try decompiling something yourself, by hand. :) |
| 2023-02-03 17:46:22 +0100 | <segfaultfizzbuzz> | ok, is there a specific game you would suggest looking at? super mario? |
| 2023-02-03 17:47:22 +0100 | <segfaultfizzbuzz> | darkling: yeah i still haven't wrapped my head around what "semantics" is |
| 2023-02-03 17:47:22 +0100 | <geekosaur> | https://www.hklaw.com/en/insights/publications/2022/03/decompiling-zelda-an-introduction-to-unders… for example |
| 2023-02-03 17:47:37 +0100 | <darkling> | Try BBC Elite. There's already a decompiled version of it, with full annotations and commentsm so you can check afterwards how close you were. :) |
| 2023-02-03 17:48:02 +0100 | <darkling> | segfaultfizzbuzz: semantics is what the code *means*. It's the human understanding of what it's doing. |
| 2023-02-03 17:48:48 +0100 | <segfaultfizzbuzz> | geekosaur: haha from a law firm |
| 2023-02-03 17:49:03 +0100 | <segfaultfizzbuzz> | yes i have difficulty understanding what meaning is as silly as that sounds |
| 2023-02-03 17:49:28 +0100 | <segfaultfizzbuzz> | i have realized that a lot of people seem to suppose that humans have supernatural powers whereas i don't feel this is true |
| 2023-02-03 17:49:37 +0100 | <darkling> | Not just "I've got a loop and it's adds this thing from this array to that thing from that array", but "I'm adding two vectors together to offset my 3D model into the enemy's position in the game model" |
| 2023-02-03 17:50:06 +0100 | <darkling> | ^^ example of semantic understanding |
| 2023-02-03 17:50:26 +0100 | cheater_ | (~Username@user/cheater) |
| 2023-02-03 17:50:53 +0100 | <segfaultfizzbuzz> | okay but "semantic canonicalization" can take care of a lot of that ...? |
| 2023-02-03 17:51:04 +0100 | kenran` | (~user@user/kenran) |
| 2023-02-03 17:51:09 +0100 | <segfaultfizzbuzz> | there are only so many types and there are only so many desirable operations to perform on those types |
| 2023-02-03 17:51:35 +0100 | <segfaultfizzbuzz> | like in engineering, everything is an oscillator but with many different names and coefficients |
| 2023-02-03 17:51:38 +0100 | Unicorn_Princess | (~Unicorn_P@user/Unicorn-Princess/x-3540542) |
| 2023-02-03 17:52:13 +0100 | <darkling> | Try it. |
| 2023-02-03 17:52:43 +0100 | kenran | (~user@user/kenran) (Ping timeout: 252 seconds) |
| 2023-02-03 17:52:59 +0100 | cheater | (~Username@user/cheater) (Ping timeout: 264 seconds) |
| 2023-02-03 17:53:02 +0100 | cheater_ | cheater |
| 2023-02-03 17:57:44 +0100 | kenran` | (~user@user/kenran) (Remote host closed the connection) |
| 2023-02-03 17:58:08 +0100 | szkl | (uid110435@id-110435.uxbridge.irccloud.com) (Quit: Connection closed for inactivity) |
| 2023-02-03 18:00:08 +0100 | sammelweis | (~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.) |
| 2023-02-03 18:01:16 +0100 | sammelweis | (~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) |
| 2023-02-03 18:02:59 +0100 | <segfaultfizzbuzz> | i guess this also goes to show, if you get a binary you can't really have any idea what it does lol |
| 2023-02-03 18:03:26 +0100 | kurbus | (~kurbus@user/kurbus) |
| 2023-02-03 18:05:38 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) |
| 2023-02-03 18:06:39 +0100 | <geekosaur> | indeed. especially if it does things like patching its own code on the fly (or allows an attacker to do so via e.g. overflowing the stack) |
| 2023-02-03 18:07:07 +0100 | <segfaultfizzbuzz> | lol |
| 2023-02-03 18:07:47 +0100 | <segfaultfizzbuzz> | are there legitimate uses of self-modifying programs? |
| 2023-02-03 18:08:04 +0100 | Profpatsch | (~Profpatsc@static.88-198-193-255.clients.your-server.de) (Quit: WeeChat 3.7.1) |
| 2023-02-03 18:08:11 +0100 | <segfaultfizzbuzz> | maybe some kind of copy protection or something? |
| 2023-02-03 18:08:32 +0100 | trev_ | (~trev@109.252.35.99) |
| 2023-02-03 18:09:17 +0100 | __monty__ | (~toonn@user/toonn) |
| 2023-02-03 18:09:48 +0100 | <segfaultfizzbuzz> | just ran across this quote "The first $400 million High NA tool will be completed at ASML in the first half of 2023." -- wow that's an expensive machine lol |
| 2023-02-03 18:09:52 +0100 | freeside | (~mengwong@103.252.202.170) (Ping timeout: 248 seconds) |
| 2023-02-03 18:09:52 +0100 | werneta | (~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Remote host closed the connection) |
| 2023-02-03 18:10:06 +0100 | <geekosaur> | games used to do it a lot to save on memory |
| 2023-02-03 18:10:29 +0100 | <segfaultfizzbuzz> | geekosaur: i suppose we could say in the modern era here |
| 2023-02-03 18:10:50 +0100 | danza | (~francesco@37.102.116.190) (Ping timeout: 260 seconds) |
| 2023-02-03 18:10:59 +0100 | <geekosaur> | it's avoided these days in part because it's hard to understand the result |
| 2023-02-03 18:11:36 +0100 | <darkling> | Also busts the instruction cache in ways you don't really want to do these days. |
| 2023-02-03 18:12:17 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) (Ping timeout: 268 seconds) |
| 2023-02-03 18:15:26 +0100 | <segfaultfizzbuzz> | seems like stamping out self modifying code would be a good thing for an operating system design (or maybe that can be set up in silicon...?) |
| 2023-02-03 18:16:43 +0100 | <geekosaur> | largely done already |
| 2023-02-03 18:16:51 +0100 | <segfaultfizzbuzz> | oh? |
| 2023-02-03 18:17:04 +0100 | <geekosaur> | I don't think many OSes give you a writable text/code segment these days |
| 2023-02-03 18:17:24 +0100 | <segfaultfizzbuzz> | ha |
| 2023-02-03 18:17:37 +0100 | <geekosaur> | and likewise tend to disable execution out of data segments |
| 2023-02-03 18:18:30 +0100 | razetime | (~Thunderbi@117.193.4.182) |
| 2023-02-03 18:19:19 +0100 | razetime | (~Thunderbi@117.193.4.182) (Remote host closed the connection) |
| 2023-02-03 18:20:35 +0100 | <segfaultfizzbuzz> | is there a mechanism by which i can safely allow my application users to write haskell code and use it with my haskell application? |
| 2023-02-03 18:22:05 +0100 | bontaq | (~user@ool-45779fe5.dyn.optonline.net) |
| 2023-02-03 18:22:31 +0100 | freeside | (~mengwong@103.252.202.170) |
| 2023-02-03 18:22:43 +0100 | danza | (~francesco@151.74.157.188) |
| 2023-02-03 18:23:03 +0100 | chele | (~chele@user/chele) (Remote host closed the connection) |
| 2023-02-03 18:23:47 +0100 | thongpv | (~thongpv87@2402:9d80:368:85a6:1abd:cb53:feec:3e50) (Read error: Connection reset by peer) |
| 2023-02-03 18:23:58 +0100 | <analoq> | i'm having some trouble parsing a json dict with aeson for which i do not know the keynames. i found some approaches but they were rather old and didn't look very concise. what it comes down to is "https://dpaste.com/57AJDXQRS.txt" |
| 2023-02-03 18:27:41 +0100 | <analoq> | initially i thought i could simply describe this a la `data MyJson = {easilyParsableDict}` and magically get a hash map, but that's not going to happen apparently |
| 2023-02-03 18:30:27 +0100 | king_gs | (~Thunderbi@187.201.2.248) |
| 2023-02-03 18:34:06 +0100 | jao | (~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) |
| 2023-02-03 18:36:40 +0100 | <geekosaur> | I thought you could just parse it to a Value which has a HashMap inside it? |
| 2023-02-03 18:38:08 +0100 | king_gs | (~Thunderbi@187.201.2.248) (Quit: king_gs) |
| 2023-02-03 18:38:18 +0100 | mechap | (~mechap@user/mechap) (Quit: WeeChat 3.8) |
| 2023-02-03 18:40:00 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:f424:933a:fcd6:76ad) |
| 2023-02-03 18:40:58 +0100 | freeside | (~mengwong@103.252.202.170) (Ping timeout: 252 seconds) |
| 2023-02-03 18:42:55 +0100 | <sm> | segfaultfizzbuzz: not really |
| 2023-02-03 18:43:38 +0100 | <sm> | you can let them write (unsafe) haskell scripts which call your code as a library |
| 2023-02-03 18:43:44 +0100 | gehmehgeh | (~user@user/gehmehgeh) (Remote host closed the connection) |
| 2023-02-03 18:43:51 +0100 | <segfaultfizzbuzz> | ha that's not happening |
| 2023-02-03 18:44:33 +0100 | gehmehgeh | (~user@user/gehmehgeh) |
| 2023-02-03 18:44:40 +0100 | <sm> | there's also https://hackage.haskell.org/package/hint which looks actually maintained |
| 2023-02-03 18:45:29 +0100 | <segfaultfizzbuzz> | sm: interesting |
| 2023-02-03 18:45:31 +0100 | bhall | (~brunohall@138.199.22.101) (Ping timeout: 265 seconds) |
| 2023-02-03 18:45:50 +0100 | <sm> | and there's an embedded lua interpreter that allows scripting with lua (pandoc does this) |
| 2023-02-03 18:46:39 +0100 | <segfaultfizzbuzz> | i kinda don't like lua and javascript ,i am wondering if there is something more haskelly i can use, like maybe elm |
| 2023-02-03 18:47:37 +0100 | <sm> | yes there's elm and purescript |
| 2023-02-03 18:47:55 +0100 | <segfaultfizzbuzz> | but then i don't want them to write format C:\ in elm |
| 2023-02-03 18:48:05 +0100 | bhall | (~brunohall@138.199.22.101) |
| 2023-02-03 18:48:56 +0100 | <sm> | not embedded in your haskell app though |
| 2023-02-03 18:49:56 +0100 | <segfaultfizzbuzz> | sm: hmm? |
| 2023-02-03 18:49:59 +0100 | <monochrom> | This is where you find that the very intuitive ("intuitive") "not arbitrary code, some security is in order" translates to a million lines of code because "not arbitrary" is vague and entails a million corner cases. |
| 2023-02-03 18:51:28 +0100 | <segfaultfizzbuzz> | haha so basically i need to use ai ;-P |
| 2023-02-03 18:55:16 +0100 | danza | (~francesco@151.74.157.188) (Ping timeout: 252 seconds) |
| 2023-02-03 18:56:36 +0100 | <segfaultfizzbuzz> | i think the moment that ai starts to become the basis of computer security will be the moment i go back to pen and paper |
| 2023-02-03 18:56:47 +0100 | freeside | (~mengwong@103.252.202.170) |
| 2023-02-03 18:58:55 +0100 | econo | (uid147250@user/econo) |
| 2023-02-03 19:00:51 +0100 | merijn | (~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 256 seconds) |
| 2023-02-03 19:01:27 +0100 | [itchyjunk] | (~itchyjunk@user/itchyjunk/x-7353470) |
| 2023-02-03 19:08:13 +0100 | akegalj | (~akegalj@89-164-123-86.dsl.iskon.hr) (Quit: leaving) |
| 2023-02-03 19:09:00 +0100 | <tomsmeding> | analoq: as geekosaur said, parse it to a Value (from Data.Aeson) |
| 2023-02-03 19:09:26 +0100 | <analoq> | tomsmeding: ty i'll look into that |
| 2023-02-03 19:10:05 +0100 | <tomsmeding> | analoq: you don't get a straight HashMap for peculiar reasons, but Data.Aeson.KeyMap has all the methods you need |
| 2023-02-03 19:14:36 +0100 | jonathanx | (~jonathan@94.234.101.18) |
| 2023-02-03 19:16:52 +0100 | <geekosaur> | "peculiar"? I thought it was the HashMap lost key ordering, which may be significant? |
| 2023-02-03 19:17:12 +0100 | varoo | (~varoo@117.203.246.41) (Quit: Probably got disconnect dure to unstable internet) |
| 2023-02-03 19:17:29 +0100 | <tomsmeding> | geekosaur: wasn't it related to hashmap dossing, like the one and only cve in aeson? |
| 2023-02-03 19:17:38 +0100 | varoo | (~varoo@2401:4900:5d26:fa0:9796:d49e:2797:1d1c) |
| 2023-02-03 19:17:57 +0100 | <geekosaur> | I would expect that fix to be to HashMap since it would also affect other consumers |
| 2023-02-03 19:19:55 +0100 | falafel | (~falafel@2607:fb91:143f:e47f:6cd4:3764:846a:ef34) |
| 2023-02-03 19:20:34 +0100 | teo | (~teo@user/teo) (Ping timeout: 252 seconds) |
| 2023-02-03 19:20:41 +0100 | falafel | (~falafel@2607:fb91:143f:e47f:6cd4:3764:846a:ef34) (Read error: Connection reset by peer) |
| 2023-02-03 19:21:06 +0100 | falafel | (~falafel@2607:fb91:143f:e47f:6cd4:3764:846a:ef34) |
| 2023-02-03 19:22:37 +0100 | <geekosaur> | segfaultfizzbuzz, re AI in computer security, pretty sure that began several decades ago (Firewall-1, back in the 90s even) |
| 2023-02-03 19:23:28 +0100 | <segfaultfizzbuzz> | geekosaur: "basis of" |
| 2023-02-03 19:24:12 +0100 | <segfaultfizzbuzz> | but yeah i should probably go to office depot and get some pens |
| 2023-02-03 19:24:26 +0100 | <jean-paul[m]> | "AI in the 90s" didn't mean the same thing as "AI" means now (like "AI in the 70s" didn't mean the same thing as ...) |
| 2023-02-03 19:24:37 +0100 | <segfaultfizzbuzz> | clarification: office depot or officemax |
| 2023-02-03 19:24:55 +0100 | <segfaultfizzbuzz> | i don't buy pens at staples though their bic pens are much worse than the officemax bic pens |
| 2023-02-03 19:24:59 +0100 | <tomsmeding> | geekosaur: https://frasertweedale.github.io/blog-fp/posts/2021-10-12-aeson-hash-flooding-protection.html |
| 2023-02-03 19:25:13 +0100 | tzh | (~tzh@c-24-21-73-154.hsd1.or.comcast.net) |
| 2023-02-03 19:25:17 +0100 | <tomsmeding> | this is the only decent explanation with context that I've seen, see also the cs-syd link at the top for explanation on the vulnerability |
| 2023-02-03 19:26:29 +0100 | falafel | (~falafel@2607:fb91:143f:e47f:6cd4:3764:846a:ef34) (Ping timeout: 255 seconds) |
| 2023-02-03 19:26:35 +0100 | jonathanx | (~jonathan@94.234.101.18) (Ping timeout: 264 seconds) |
| 2023-02-03 19:26:47 +0100 | merijn | (~merijn@c-001-001-010.client.esciencecenter.eduvpn.nl) |
| 2023-02-03 19:27:12 +0100 | <geekosaur> | interesting |
| 2023-02-03 19:27:25 +0100 | <tomsmeding> | I dunno why the fix isn't in HashMap, as you said |
| 2023-02-03 19:27:34 +0100 | <tomsmeding> | apparently the fix is to switch to Map? |
| 2023-02-03 19:27:50 +0100 | <tomsmeding> | and they made the thing opaque to facilitate future changes or something? |
| 2023-02-03 19:27:50 +0100 | varoo | (~varoo@2401:4900:5d26:fa0:9796:d49e:2797:1d1c) (Read error: Connection reset by peer) |
| 2023-02-03 19:27:54 +0100 | <geekosaur> | so I saw. that sounds somewhat odd to me |
| 2023-02-03 19:28:12 +0100 | <tomsmeding> | I guess the standard fix for this is to randomise the hash, which is somewhat awkward in haskell |
| 2023-02-03 19:28:15 +0100 | <tomsmeding> | maybe that's why they did this |
| 2023-02-03 19:28:54 +0100 | <tomsmeding> | though a `{-# NOINLINE seed #-} seed :: Int ; seed = unsafePerformIO randomIO` isn't too bad |
| 2023-02-03 19:28:55 +0100 | varoo | (~varoo@117.203.246.41) |
| 2023-02-03 19:30:12 +0100 | <geekosaur> | but you need to apply it to the Hashable class's instances |
| 2023-02-03 19:30:32 +0100 | <tomsmeding> | oh of course |
| 2023-02-03 19:30:36 +0100 | jonathanx | (~jonathan@94.234.101.18) |
| 2023-02-03 19:30:38 +0100 | <tomsmeding> | that ain't gonna fly |
| 2023-02-03 19:30:38 +0100 | jonathanx | (~jonathan@94.234.101.18) (Read error: Connection reset by peer) |
| 2023-02-03 19:32:04 +0100 | jonathanx | (~jonathan@178.174.176.109) |
| 2023-02-03 19:32:27 +0100 | merijn | (~merijn@c-001-001-010.client.esciencecenter.eduvpn.nl) (Ping timeout: 268 seconds) |
| 2023-02-03 19:32:36 +0100 | <geekosaur> | especially that `Int` instance which just returns the value |
| 2023-02-03 19:32:59 +0100 | <tomsmeding> | though I suspect just xor'ing in the seed at the end could be fine if the hash is then `mod`'ed with some odd prime |
| 2023-02-03 19:33:12 +0100 | varoo | (~varoo@117.203.246.41) (Client Quit) |
| 2023-02-03 19:33:22 +0100 | <tomsmeding> | but maybe that's weak for some reason |
| 2023-02-03 19:35:17 +0100 | kurbus | (~kurbus@user/kurbus) (Quit: Client closed) |
| 2023-02-03 19:40:50 +0100 | kassouni | (~kassouni@2601:646:400:68b0:f5a4:b4c5:300f:d7b8) |
| 2023-02-03 19:42:34 +0100 | gurkenglas | (~gurkengla@dynamic-046-114-179-193.46.114.pool.telefonica.de) |
| 2023-02-03 19:43:26 +0100 | <tomsmeding> | segfaultfizzbuzz: consider Dhall |
| 2023-02-03 19:43:38 +0100 | <tomsmeding> | never used it, but it may accidentally be what you want |
| 2023-02-03 19:44:15 +0100 | <segfaultfizzbuzz> | tomsmeding: i will take a look thanks |
| 2023-02-03 19:44:45 +0100 | <segfaultfizzbuzz> | seems weird that "my application needs to be programmable" is not a first-line concern for languages/ecosystems |
| 2023-02-03 19:45:09 +0100 | <tomsmeding> | applications don't typically need to be programmable :p |
| 2023-02-03 19:45:42 +0100 | <tomsmeding> | applications are typically intended to be used by non-programmers, and the ones that aren't are instead architected as modular components that the user can script together manually |
| 2023-02-03 19:46:05 +0100 | <tomsmeding> | of course this doesn't cover all applications, but for those it seems the industry has settled on lua being acceptable :p |
| 2023-02-03 19:46:19 +0100 | <tomsmeding> | or not caring that the user can shoot themselves in the foot with IO |
| 2023-02-03 19:49:29 +0100 | gnalzo | (~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) |
| 2023-02-03 19:50:25 +0100 | L29Ah | (~L29Ah@wikipedia/L29Ah) (Read error: Connection reset by peer) |
| 2023-02-03 19:50:43 +0100 | <sm> | "safe languages" are not a common concern generally |
| 2023-02-03 19:50:59 +0100 | <segfaultfizzbuzz> | i like the ease of writing correct code with elm and think my users could probably make it work |
| 2023-02-03 19:51:14 +0100 | <segfaultfizzbuzz> | like it's not that hard for amateurs, i think |
| 2023-02-03 19:51:17 +0100 | <sm> | and when they are, apps usually implement their own |
| 2023-02-03 19:51:37 +0100 | <sm> | (a DSL) |
| 2023-02-03 19:51:45 +0100 | <glguy> | I rather like exposing Lua as my app's scripting language |
| 2023-02-03 19:51:48 +0100 | <segfaultfizzbuzz> | sm: what? backends don't run code...? |
| 2023-02-03 19:52:03 +0100 | <segfaultfizzbuzz> | i would totally use an elm-lua if someone made it lol |
| 2023-02-03 19:52:33 +0100 | <sm> | no, backends don't run arbitrary user code usually |
| 2023-02-03 19:54:01 +0100 | <sm> | for obviously reasons.... this is 2023 not 1970 :) |
| 2023-02-03 19:54:13 +0100 | <sm> | s/obviously/obvious/ |
| 2023-02-03 19:54:46 +0100 | <tomsmeding> | sm: but then segfaultfizzbuzz would say, but why don't they run user code in a safe language?? |
| 2023-02-03 19:55:50 +0100 | <tomsmeding> | the only instance I know of an application that runs user code where effects need to be controlled is PC games |
| 2023-02-03 19:56:01 +0100 | <tomsmeding> | and in practice they apparently either use lua or implement their own |
| 2023-02-03 19:56:06 +0100 | <sm> | some do run custom DSLs they have implemented. I'm not thinking of a common "safe" language that's common across apps |
| 2023-02-03 19:56:15 +0100 | <tomsmeding> | lua? |
| 2023-02-03 19:56:39 +0100 | <sm> | is that safe ? I don't see web apps running user lua |
| 2023-02-03 19:56:41 +0100 | <tomsmeding> | I thought you could configure the lua interpreter to just not put any IO stuff in the top-level environment, effectively disallowing any IO |
| 2023-02-03 19:56:52 +0100 | <segfaultfizzbuzz> | i mean a "programmable backend" sounds like essential functionality, then you can have a safe language, have a sandbox, or maybe if you are really serious use some kind of hardware isolation, like execute a lambda on another bit of hardware or something |
| 2023-02-03 19:57:27 +0100 | <tomsmeding> | segfaultfizzbuzz: I'm confused -- you _either_ have a safe language, _or_ sandbox + etc., right? |
| 2023-02-03 19:57:40 +0100 | <tomsmeding> | https://play-haskell.tomsmeding.com exists |
| 2023-02-03 19:57:43 +0100 | <sm> | yes, lua seems safe enough for use in desktop apps at least |
| 2023-02-03 19:57:44 +0100 | <tomsmeding> | it uses sandboxing |
| 2023-02-03 19:57:51 +0100 | <segfaultfizzbuzz> | uh, i suppose you could combine those |
| 2023-02-03 19:57:59 +0100 | <tomsmeding> | but the entire point of that playground is to _allow_ full haskell |
| 2023-02-03 19:58:19 +0100 | <tomsmeding> | segfaultfizzbuzz: you could, but it would be unnecessary |
| 2023-02-03 19:58:25 +0100 | <segfaultfizzbuzz> | i mean aren't there like mom and pop web hosting companies that let you submit php scripts which they run dynamically? |
| 2023-02-03 19:58:29 +0100 | <tomsmeding> | the point of using a safe language is to not need a sandbox, right? |
| 2023-02-03 19:58:34 +0100 | <tomsmeding> | segfaultfizzbuzz: yes, they sandbox |
| 2023-02-03 19:58:39 +0100 | <segfaultfizzbuzz> | i don't know if that is still practiced |
| 2023-02-03 19:58:42 +0100 | <tomsmeding> | very much |
| 2023-02-03 19:58:46 +0100 | <sm> | segfaultfizzbuzz: hell no |
| 2023-02-03 19:58:55 +0100 | <[exa]> | segfaultfizzbuzz: they host dockers now |
| 2023-02-03 19:58:56 +0100 | <segfaultfizzbuzz> | sm: dynamic php from the webhost is dead? |
| 2023-02-03 19:59:18 +0100 | <tomsmeding> | https://www.one.com/en/hosting/php |
| 2023-02-03 19:59:30 +0100 | <tomsmeding> | not sure how many people use this, but it's very much not dead |
| 2023-02-03 19:59:42 +0100 | <sm> | you can upload php scripts to a web hosting account you own and are legally responsible for, sure. You can't run your own php on someone else's web app generally |
| 2023-02-03 19:59:44 +0100 | <[exa]> | segfaultfizzbuzz: safely putting people's php insanities into a nice opaque box is a step forward |
| 2023-02-03 19:59:47 +0100 | zeenk | (~zeenk@2a02:2f04:a214:1e00::7fe) (Quit: Konversation terminated!) |
| 2023-02-03 20:00:02 +0100 | <tomsmeding> | oh right |
| 2023-02-03 20:00:23 +0100 | kassouni | (~kassouni@2601:646:400:68b0:f5a4:b4c5:300f:d7b8) (Quit: My Mac has gone to sleep. ZZZzzz…) |
| 2023-02-03 20:00:37 +0100 | <sm> | you can probably do it within limits in specialised places like repl.it |
| 2023-02-03 20:01:01 +0100 | <tomsmeding> | (which uses sandboxing) |
| 2023-02-03 20:01:22 +0100 | <segfaultfizzbuzz> | ok well someone was questioning whether it was "worthwhile" to have a programmable backend, and i think it is fairly self-evident that the answer to this question is yes, but i would entertain counterarguments to that |
| 2023-02-03 20:01:53 +0100 | <tomsmeding> | segfaultfizzbuzz: define "backend" |
| 2023-02-03 20:02:10 +0100 | <tomsmeding> | as in, what purposes do you have in mind |
| 2023-02-03 20:02:37 +0100 | <segfaultfizzbuzz> | well for example a user might want to define a custom dashboard |
| 2023-02-03 20:02:44 +0100 | <segfaultfizzbuzz> | and then allow other people on a system to use it |
| 2023-02-03 20:02:53 +0100 | <segfaultfizzbuzz> | i could have some kind of very constrained list of options |
| 2023-02-03 20:03:04 +0100 | <segfaultfizzbuzz> | but at some point you cross a threshold, and you say ok, just write a program |
| 2023-02-03 20:03:05 +0100 | merijn | (~merijn@86.86.29.250) |
| 2023-02-03 20:03:27 +0100 | ardell | (~ardell@user/ardell) |
| 2023-02-03 20:03:29 +0100 | <sm> | yes indeed. Haskell would be too much power for that use case |
| 2023-02-03 20:04:02 +0100 | <sm> | you'd probably provide your own DashboardScript |
| 2023-02-03 20:04:22 +0100 | <segfaultfizzbuzz> | sm: but then,... why would that be a "language" unto itself |
| 2023-02-03 20:04:52 +0100 | <segfaultfizzbuzz> | it will need a type system and control flow and all that, and it's not like i would invent all of that myself |
| 2023-02-03 20:05:25 +0100 | oldfashionedcow | (~Rahul_San@user/oldfashionedcow) |
| 2023-02-03 20:05:30 +0100 | <segfaultfizzbuzz> | i would probably (?) mostly just define a variety of return types which are acceptable (?) and a few other things,... |
| 2023-02-03 20:05:37 +0100 | <mauke> | https://en.wikipedia.org/wiki/Inner-platform_effect |
| 2023-02-03 20:06:15 +0100 | <darkling> | Yeah, it's rare that you actually need that kind of power in user configuration. |
| 2023-02-03 20:06:54 +0100 | <sm> | I question whether dashboard building requires a type system, but of course YMMV |
| 2023-02-03 20:06:55 +0100 | <darkling> | For the dashboard example, we've got Grafana at work. I don't think we've needed anything more than the MS log query language or SQL. |
| 2023-02-03 20:07:07 +0100 | <segfaultfizzbuzz> | mauke: i recognize and appreciate this phenomenon, but i don't think that this is accurate |
| 2023-02-03 20:08:01 +0100 | merijn | (~merijn@86.86.29.250) (Ping timeout: 252 seconds) |
| 2023-02-03 20:08:03 +0100 | <segfaultfizzbuzz> | i suppose another take on this is that once you need programmability then you need a programmer and not a general user |
| 2023-02-03 20:08:29 +0100 | <sm> | will there be an existing language you can reuse, that can be made safe enough and usable enough for your users at acceptable cost ? Yes maybe, lua might be one. Is there a functional haskell-like one ? Not sure, elm, purescript and dhall have been suggested, I suspect only dhall is suitable for embedding |
| 2023-02-03 20:09:09 +0100 | <tomsmeding> | dhall's entire point is to be embedded, right? The only things someone could hold against it for this purpose are 1. totality and 2. ability to do web requests (not sure if you can turn this off) |
| 2023-02-03 20:10:04 +0100 | gurkenglas | (~gurkengla@dynamic-046-114-179-193.46.114.pool.telefonica.de) (Ping timeout: 260 seconds) |
| 2023-02-03 20:10:13 +0100 | <segfaultfizzbuzz> | 2 is almost certainly a dealbreaker |
| 2023-02-03 20:10:24 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) |
| 2023-02-03 20:10:26 +0100 | <segfaultfizzbuzz> | yeah i actually think i may have identified something novel and useful here |
| 2023-02-03 20:10:45 +0100 | gurkenglas | (~gurkengla@dynamic-046-114-179-193.46.114.pool.telefonica.de) |
| 2023-02-03 20:10:50 +0100 | <tomsmeding> | for the dashboard example it would need to run in the browser though |
| 2023-02-03 20:11:11 +0100 | <tomsmeding> | no reason you cannot also create an interpreter for your new SFFB language in JS though |
| 2023-02-03 20:11:34 +0100 | <segfaultfizzbuzz> | on a related note do languages (haskell, dhall) provide any method of accounting for resource usage, so i can say "this function may not use more than 10 seconds of compute time, and if it tries to then kill it" |
| 2023-02-03 20:11:55 +0100 | <sm> | in practical terms, you almost always want a custom language constrained to your use case simply for usabliity |
| 2023-02-03 20:11:59 +0100 | <tomsmeding> | segfaultfizzbuzz: https://hackage.haskell.org/package/base-4.17.0.0/docs/System-Timeout.html#v:timeout |
| 2023-02-03 20:12:19 +0100 | <segfaultfizzbuzz> | tomsmeding: nice, thanks |
| 2023-02-03 20:12:25 +0100 | <tomsmeding> | though the FFI throws a wrench in that, see the haddocks |
| 2023-02-03 20:12:51 +0100 | <glguy> | dhall's being total deosn't mean it won't consume more resources than you're willing to give it, and it's complicated enough to write something like a a function that produces the list of perfect numbers from 1 to N |
| 2023-02-03 20:13:09 +0100 | <glguy> | but the restrictions mean that your programs are probably more confusing than they would have been to achieve the same results |
| 2023-02-03 20:13:35 +0100 | <glguy> | it's not clear to me what itch it scratches |
| 2023-02-03 20:14:18 +0100 | <sm> | +1 |
| 2023-02-03 20:17:56 +0100 | <tomsmeding> | maybe the point is that writing something that takes a lot of computation is unnatural in dhall? |
| 2023-02-03 20:18:32 +0100 | <segfaultfizzbuzz> | another thing i was thinking was allowing my users to compile webassembly (eg in the browser) and upload that, and then i would run the webassembly... |
| 2023-02-03 20:18:55 +0100 | <segfaultfizzbuzz> | that would separate the problem of deciding on a particular language, i think, although i'm not quite sure how webassembly would interface to my application |
| 2023-02-03 20:18:55 +0100 | <tomsmeding> | segfaultfizzbuzz: if you allow that, just let them run javascript |
| 2023-02-03 20:19:26 +0100 | <tomsmeding> | though you may the right that wasm itself doesn't get to do any IO... |
| 2023-02-03 20:19:32 +0100 | <tomsmeding> | *you may be right |
| 2023-02-03 20:20:11 +0100 | <tomsmeding> | compile GHC to webassembly, put that on your webpage, let your users write haskell, compile that to wasm using in-browser GHC, then run that |
| 2023-02-03 20:20:20 +0100 | <tomsmeding> | /s because GHC will be gigabytes of wasm |
| 2023-02-03 20:20:33 +0100 | <tomsmeding> | and /s because, y'know, wtf |
| 2023-02-03 20:21:04 +0100 | <[exa]> | tomsmeding: honestly you'd be better off just running an x86 vm with a linux with ghc |
| 2023-02-03 20:21:16 +0100 | <tomsmeding> | :'') |
| 2023-02-03 20:21:38 +0100 | <tomsmeding> | https://bellard.org/jslinux/ |
| 2023-02-03 20:21:46 +0100 | <[exa]> | precisely that one. |
| 2023-02-03 20:22:14 +0100 | <tomsmeding> | I mean, nobody else has the right combination of stupidity and genius to build that |
| 2023-02-03 20:22:33 +0100 | <segfaultfizzbuzz> | haha |
| 2023-02-03 20:23:05 +0100 | <tomsmeding> | mind, "stupidity" only to the extent that it is worth questioning whether you _should_ |
| 2023-02-03 20:23:14 +0100 | <segfaultfizzbuzz> | so basically https://www.youtube.com/watch?v=qybUFnY7Y8w |
| 2023-02-03 20:24:06 +0100 | <tomsmeding> | more like https://www.youtube.com/watch?v=uNjxe8ShM-8 |
| 2023-02-03 20:24:14 +0100 | <segfaultfizzbuzz> | music kinda sucks tho sorry lol |
| 2023-02-03 20:24:26 +0100 | <segfaultfizzbuzz> | lol |
| 2023-02-03 20:24:40 +0100 | mvk | (~mvk@2607:fea8:5caa:ac00::f944) |
| 2023-02-03 20:26:33 +0100 | <sm> | https://github.com/dbohdan/embedded-scripting-languages |
| 2023-02-03 20:27:12 +0100 | <segfaultfizzbuzz> | tomsmeding: i dare you to be the first to compile haskell to powerpoint https://www.youtube.com/watch?v=LArkm4v5mWA |
| 2023-02-03 20:28:00 +0100 | <tomsmeding> | that is hilarious, I didn't know about pptcc |
| 2023-02-03 20:28:47 +0100 | <segfaultfizzbuzz> | the laziest powerpoint is where you make the slides while you are presenting |
| 2023-02-03 20:29:08 +0100 | <tomsmeding> | that's called a blackboard talk |
| 2023-02-03 20:29:47 +0100 | <tomsmeding> | that "good first issue" tag on this one is just great https://github.com/TomWildenhain/pptcc/issues/4 |
| 2023-02-03 20:29:48 +0100 | <darkling> | Just use an OHP. :) |
| 2023-02-03 20:30:45 +0100 | <segfaultfizzbuzz> | haha |
| 2023-02-03 20:31:00 +0100 | <segfaultfizzbuzz> | haha how to delete someone else's github repository lol |
| 2023-02-03 20:31:10 +0100 | oldfashionedcow | (~Rahul_San@user/oldfashionedcow) (Quit: WeeChat 3.8) |
| 2023-02-03 20:31:28 +0100 | oldfashionedcow | (~Rahul_San@user/oldfashionedcow) |
| 2023-02-03 20:31:33 +0100 | <tomsmeding> | segfaultfizzbuzz: I do wonder whether pptcc can handle indirect jumps through a register |
| 2023-02-03 20:31:41 +0100 | <tomsmeding> | ghc is quite keen on generating those instructions |
| 2023-02-03 20:33:05 +0100 | gurkenglas | (~gurkengla@dynamic-046-114-179-193.46.114.pool.telefonica.de) (Ping timeout: 255 seconds) |
| 2023-02-03 20:33:09 +0100 | <segfaultfizzbuzz> | tomsmeding: i dont know what that means. historically i was afraid of learning x86 asm because i thought ISAs would have a very high churn rate... empirically this has turn out to be mostly false |
| 2023-02-03 20:33:12 +0100 | <segfaultfizzbuzz> | *turned |
| 2023-02-03 20:33:21 +0100 | <tomsmeding> | segfaultfizzbuzz: jmp (*rax) |
| 2023-02-03 20:33:41 +0100 | <tomsmeding> | i.e. jump to the address given by the value of a register |
| 2023-02-03 20:34:21 +0100 | <tomsmeding> | any kind of dynamic dispatch usually compiles to this, including e.g. virtual calls in C++ |
| 2023-02-03 20:34:35 +0100 | <tomsmeding> | and thunks are kind of the epitome of dynamic dispatch |
| 2023-02-03 20:35:45 +0100 | <sm> | that embedded-scripting-languages list is great, recommended |
| 2023-02-03 20:36:08 +0100 | <segfaultfizzbuzz> | yeah i am browsing |
| 2023-02-03 20:36:31 +0100 | sm | went down a few rabbit holes |
| 2023-02-03 20:37:38 +0100 | <tomsmeding> | > optional, optimistic (succeed-by-default) static type checking |
| 2023-02-03 20:37:41 +0100 | <tomsmeding> | what is that supposed to mean :p |
| 2023-02-03 20:39:06 +0100 | <segfaultfizzbuzz> | succeed by default lol |
| 2023-02-03 20:39:20 +0100 | <segfaultfizzbuzz> | that's part of the compile by default paradigm |
| 2023-02-03 20:39:46 +0100 | <sm> | "a simple, but convenient scripting language that integrated well with Rust." - we need that for Haskell |
| 2023-02-03 20:40:47 +0100 | <sm> | have needed it for ever. An on ramp to full Haskell |
| 2023-02-03 20:40:56 +0100 | <segfaultfizzbuzz> | sm: tbh i think the haskell community should rebuild from scratch with rust integration as a first design principle |
| 2023-02-03 20:41:19 +0100 | <tomsmeding> | segfaultfizzbuzz: the Rust type system is not very compatible with Haskell's |
| 2023-02-03 20:41:22 +0100 | <segfaultfizzbuzz> | and be more assertive about what the language is defined as |
| 2023-02-03 20:41:37 +0100 | <segfaultfizzbuzz> | tomsmeding: the question then is whether it is irreconcilable rather than whether it is compatible today |
| 2023-02-03 20:42:15 +0100 | <sm> | that certainly might happen but it won't be called haskell |
| 2023-02-03 20:43:49 +0100 | <segfaultfizzbuzz> | then call it lleksah and make a voice assistant with it |
| 2023-02-03 20:45:01 +0100 | <segfaultfizzbuzz> | do away with all of this language extension stuff and don't be afraid to be opinionated about how to write code |
| 2023-02-03 20:46:16 +0100 | <sm> | tomsmeding: I tried to find out what "optional, optimistic (succeed-by-default) static type checking" means, beats me too :) |
| 2023-02-03 20:46:53 +0100 | <sm> | segfaultfizzbuzz: Elm is the extreme of that isn't it |
| 2023-02-03 20:47:11 +0100 | <segfaultfizzbuzz> | WHAT https://dreamix-video-editing.github.io/ |
| 2023-02-03 20:48:59 +0100 | troydm | (~troydm@user/troydm) |
| 2023-02-03 20:50:17 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds) |
| 2023-02-03 20:50:43 +0100 | <tomsmeding> | sm: this, presumably, but unclear what the actual semantics of this are https://github.com/PistonDevelopers/dyon/issues/236 |
| 2023-02-03 20:51:56 +0100 | __monty__ | (~toonn@user/toonn) (Quit: leaving) |
| 2023-02-03 20:52:07 +0100 | <sm> | interesting |
| 2023-02-03 20:52:39 +0100 | <sm> | more: https://www.piston.rs/dyon-tutorial/types.html |
| 2023-02-03 20:53:20 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) |
| 2023-02-03 20:53:33 +0100 | <segfaultfizzbuzz> | unfortunately gluon seems kinda abandoned (??) |
| 2023-02-03 20:55:28 +0100 | mechap | (~mechap@user/mechap) |
| 2023-02-03 20:56:13 +0100 | <tomsmeding> | sm: this is wacky https://www.piston.rs/dyon-tutorial/in-types.html |
| 2023-02-03 20:56:29 +0100 | <tomsmeding> | "I wanted channels but hacked them in in a dumb way"? |
| 2023-02-03 20:57:19 +0100 | <sm> | woah |
| 2023-02-03 20:59:35 +0100 | trev_ | (~trev@109.252.35.99) (Remote host closed the connection) |
| 2023-02-03 20:59:38 +0100 | <glguy> | That makes me think of https://en.wikipedia.org/wiki/COMEFROM |
| 2023-02-03 20:59:57 +0100 | <tomsmeding> | glguy: it did for me to, but then I realised it's really a channels implementation, not a control flow construct |
| 2023-02-03 21:00:01 +0100 | <tomsmeding> | the syntax is just wacky |
| 2023-02-03 21:00:18 +0100 | <segfaultfizzbuzz> | lol comefrom comes with a time machine? |
| 2023-02-03 21:01:12 +0100 | <segfaultfizzbuzz> | lol and DONT instruction |
| 2023-02-03 21:01:24 +0100 | <tomsmeding> | @hackage acme-dont |
| 2023-02-03 21:01:24 +0100 | <lambdabot> | https://hackage.haskell.org/package/acme-dont |
| 2023-02-03 21:02:10 +0100 | <glguy> | > C-INTERCAL also provides the COME FROM instruction, written DO COME FROM (line); CLC-INTERCAL and the most recent C-INTERCAL versions also provide computed COME FROM (DO COME FROM expression) and NEXT FROM, which is like COME FROM but also saves a return address on the NEXT STACK.[4] |
| 2023-02-03 21:02:12 +0100 | <lambdabot> | <hint>:1:51: error: parse error on input ‘,’ |
| 2023-02-03 21:02:13 +0100 | <sm> | it's quite interesting to see how a tricky statically typed language like rust has been adapted for scripting |
| 2023-02-03 21:02:18 +0100 | <glguy> | I need to wrap my head around computed come from now |
| 2023-02-03 21:02:51 +0100 | <tomsmeding> | glguy: put an irc colour reset byte before the > to make lambdabot skip it |
| 2023-02-03 21:02:52 +0100 | <segfaultfizzbuzz> | sm: if there was a nice wasm interface it would be great for compiling to wasm |
| 2023-02-03 21:05:01 +0100 | Sciencentistguy1 | (~sciencent@hacksoc/ordinary-member) |
| 2023-02-03 21:06:09 +0100 | <monochrom> | tomsmeding: Oh haha great trick |
| 2023-02-03 21:06:38 +0100 | <tomsmeding> | I'm surprised noone has yet asked me how I did that |
| 2023-02-03 21:06:41 +0100 | Sciencentistguy | (~sciencent@hacksoc/ordinary-member) (Ping timeout: 252 seconds) |
| 2023-02-03 21:06:41 +0100 | Sciencentistguy1 | Sciencentistguy |
| 2023-02-03 21:07:07 +0100 | <geekosaur> | I figured it immediately |
| 2023-02-03 21:07:17 +0100 | <tomsmeding> | right maybe I shouldn't be surprised |
| 2023-02-03 21:07:27 +0100 | <monochrom> | Hey good idea for @ too |
| 2023-02-03 21:07:58 +0100 | <juri_> | how do you do, fellow haskellers! |
| 2023-02-03 21:08:33 +0100 | <segfaultfizzbuzz> | juri_: hello there |
| 2023-02-03 21:08:38 +0100 | <sm> | > I thought a space worked |
| 2023-02-03 21:08:46 +0100 | <tomsmeding> | it does, but it shows up |
| 2023-02-03 21:08:53 +0100 | <tomsmeding> | can't have imperfections like that |
| 2023-02-03 21:09:12 +0100 | <segfaultfizzbuzz> | juri_: https://en.wikipedia.org/wiki/File:Obiwan1.jpg |
| 2023-02-03 21:09:15 +0100 | <sm> | yessir, quite right |
| 2023-02-03 21:09:29 +0100 | <sm> | god forbid anyone should fix lambdabot |
| 2023-02-03 21:09:50 +0100 | <tomsmeding> | sm: how do you fix lambdabot for this |
| 2023-02-03 21:10:34 +0100 | <sm> | I would switch to a different char, > is too common for indicating quotes |
| 2023-02-03 21:10:56 +0100 | <tomsmeding> | » or just use this |
| 2023-02-03 21:11:50 +0100 | <sm> | ! ARGS would work well |
| 2023-02-03 21:12:00 +0100 | <tomsmeding> | also standard bot char |
| 2023-02-03 21:12:20 +0100 | <mauke> | no, this is a literate channel |
| 2023-02-03 21:14:00 +0100 | <darkling> | So you pipe the channel to weave to get the discussion, and to tangle to get the code? :) |
| 2023-02-03 21:15:46 +0100 | <tomsmeding> | isn't a literate document typically suppose to be coherent |
| 2023-02-03 21:20:45 +0100 | <darkling> | Ocelot pipe cleaner? |
| 2023-02-03 21:24:53 +0100 | <tomsmeding> | when I search that, I get "Including results for 'best pipe cleaners'" |
| 2023-02-03 21:25:11 +0100 | <tomsmeding> | not sure how "ocelot" is seen as a typo for "best" |
| 2023-02-03 21:25:27 +0100 | <darkling> | I mean, ocelots *are* the best... |
| 2023-02-03 21:31:20 +0100 | Tuplanolla | (~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) |
| 2023-02-03 21:34:05 +0100 | merijn | (~merijn@c-001-001-010.client.esciencecenter.eduvpn.nl) |
| 2023-02-03 21:43:21 +0100 | <jonathanx> | I'm using recursion-schemes, and have multiple algebras (let's say 3) that each fit inside of a cata. I want to combine them, and fold my datastructure in 3 distinct ways with the same fold. How do I go about this? My first thought was to upgrade to a zygomorphism, but that "only" give me the different values for the "children" of my tree-like data structure. I'm probably missing something basic.. |
| 2023-02-03 21:50:24 +0100 | <tomsmeding> | jonathanx: 'Base t' is a Functor |
| 2023-02-03 21:50:33 +0100 | <tomsmeding> | (assuming 'Recursive t') |
| 2023-02-03 21:51:00 +0100 | <tomsmeding> | if f1 and f2 are algebras, then '\x -> (f1 (fst <$> x), f2 (snd <$> x))' is also an algebra |
| 2023-02-03 21:51:33 +0100 | <tomsmeding> | there is probably some cute generalisation of this, my instinct says Representable but that's probably wrong, and not sure if you _should_ |
| 2023-02-03 21:52:21 +0100 | <tomsmeding> | :t \f1 f2 -> \x -> (f1 (fst <$> x), f2 (snd <$> x)) |
| 2023-02-03 21:52:22 +0100 | <lambdabot> | Functor f => (f a1 -> a2) -> (f b1 -> b2) -> f (a1, b1) -> (a2, b2) |
| 2023-02-03 21:54:14 +0100 | <tomsmeding> | @pl \x -> (f1 (fmap fst x), f2 (fmap snd x)) |
| 2023-02-03 21:54:14 +0100 | <lambdabot> | ap ((,) . f1 . fmap fst) (f2 . fmap snd) |
| 2023-02-03 21:54:23 +0100 | segfaultfizzbuzz | (~segfaultf@108.211.201.53) (Ping timeout: 248 seconds) |
| 2023-02-03 21:54:26 +0100 | <tomsmeding> | meh this one is nicer |
| 2023-02-03 21:54:28 +0100 | <tomsmeding> | :t \f1 f2 -> liftA2 (,) (f1 . fmap fst) (f2 . fmap snd) |
| 2023-02-03 21:54:29 +0100 | <lambdabot> | Functor f => (f b1 -> a) -> (f b2 -> b3) -> f (b1, b2) -> (a, b3) |
| 2023-02-03 21:54:39 +0100 | L29Ah | (~L29Ah@wikipedia/L29Ah) |
| 2023-02-03 21:55:26 +0100 | kassouni | (~kassouni@2601:646:400:68b0:18dc:d2:c373:8213) |
| 2023-02-03 21:56:40 +0100 | oldfashionedcow | username233 |
| 2023-02-03 21:56:45 +0100 | username233 | username234 |
| 2023-02-03 21:56:55 +0100 | username234 | oldfashionedcow |
| 2023-02-03 22:01:35 +0100 | kassouni | (~kassouni@2601:646:400:68b0:18dc:d2:c373:8213) (Quit: My Mac has gone to sleep. ZZZzzz…) |
| 2023-02-03 22:01:39 +0100 | sammelweis | (~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.) |
| 2023-02-03 22:02:39 +0100 | Hammdist | (~Hammdist@67.169.114.135) |
| 2023-02-03 22:02:55 +0100 | ddellacosta | (~ddellacos@86.106.143.219) (Ping timeout: 248 seconds) |
| 2023-02-03 22:02:56 +0100 | sammelweis | (~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) |
| 2023-02-03 22:07:08 +0100 | merijn | (~merijn@c-001-001-010.client.esciencecenter.eduvpn.nl) (Ping timeout: 255 seconds) |
| 2023-02-03 22:12:42 +0100 | <jonathanx> | right, so smash them into a tuple basically? Makes sense. |
| 2023-02-03 22:12:57 +0100 | <tomsmeding> | I mean, it's what going to happen anyway |
| 2023-02-03 22:13:07 +0100 | <tomsmeding> | I'm not sure if it makes sense to make this a StrictPair |
| 2023-02-03 22:13:14 +0100 | <tomsmeding> | data StrictPair a b = StrictPair !a !b |
| 2023-02-03 22:13:45 +0100 | <tomsmeding> | if things don't inline that might give a minor performance increase |
| 2023-02-03 22:18:56 +0100 | mvk | (~mvk@2607:fea8:5caa:ac00::f944) (Ping timeout: 248 seconds) |
| 2023-02-03 22:20:23 +0100 | segfaultfizzbuzz | (~segfaultf@108.211.201.53) |
| 2023-02-03 22:26:04 +0100 | phma | (~phma@host-67-44-208-156.hnremote.net) (Read error: Connection reset by peer) |
| 2023-02-03 22:26:05 +0100 | <segfaultfizzbuzz> | so semantics maps language (or is it understanding?) to like... what happens in RAM or something? or maybe to "program observables" (light switch ends up turning on, when i look in the database some entry is there)? |
| 2023-02-03 22:26:58 +0100 | _leo___ | (~emmanuelu@user/emmanuelux) |
| 2023-02-03 22:27:02 +0100 | phma | (~phma@2001:5b0:210d:59b8:b6b0:7ecf:e3da:b5e5) |
| 2023-02-03 22:27:56 +0100 | <geekosaur> | intent to implementation, I'd say |
| 2023-02-03 22:28:00 +0100 | <darkling> | Semantics at its simplest would be, I've written x+y in my code -- what is that actually doing? Is it adding two numbers together? Is it concatenating two strings? Is it merging two sets? |
| 2023-02-03 22:28:41 +0100 | <mauke> | generally? semantics = meaning |
| 2023-02-03 22:29:04 +0100 | <segfaultfizzbuzz> | what is meaning lol |
| 2023-02-03 22:29:11 +0100 | <darkling> | I just gave an example... |
| 2023-02-03 22:29:50 +0100 | <segfaultfizzbuzz> | so is it internal (steps taken) or outcome-based (list ends up sorted)? |
| 2023-02-03 22:30:04 +0100 | emmanuelux | (~emmanuelu@user/emmanuelux) (Ping timeout: 260 seconds) |
| 2023-02-03 22:30:31 +0100 | <mauke> | oh, like operational semantics vs. denotational semantics? |
| 2023-02-03 22:31:04 +0100 | <jackdk> | would you like big-step operational semantics, small step operational semantics, or denotational semantics, or some other type that I've not heard of? |
| 2023-02-03 22:31:27 +0100 | EvanR_ | EvanR |
| 2023-02-03 22:31:27 +0100 | <EvanR> | if you map the program to "what steps the cpu takes" or something, that's filed under operational semantics |
| 2023-02-03 22:31:27 +0100 | EvanR | (~EvanR@user/evanr) (Remote host closed the connection) |
| 2023-02-03 22:31:41 +0100 | EvanR | (~EvanR@user/evanr) |
| 2023-02-03 22:34:52 +0100 | Natch | (~natch@c-9e07225c.038-60-73746f7.bbcust.telenor.se) (Remote host closed the connection) |
| 2023-02-03 22:36:08 +0100 | esph | (~weechat@user/esph) (Ping timeout: 252 seconds) |
| 2023-02-03 22:41:06 +0100 | Natch | (~natch@c-9e07225c.038-60-73746f7.bbcust.telenor.se) |
| 2023-02-03 22:43:31 +0100 | segfaultfizzbuzz | (~segfaultf@108.211.201.53) (Ping timeout: 252 seconds) |
| 2023-02-03 22:45:41 +0100 | segfaultfizzbuzz | (~segfaultf@108.211.201.53) |
| 2023-02-03 22:46:24 +0100 | opticblast | (~Thunderbi@172.58.82.233) |
| 2023-02-03 22:46:48 +0100 | ardell | (~ardell@user/ardell) (Quit: Konversation terminated!) |
| 2023-02-03 22:48:19 +0100 | <tomsmeding> | segfaultfizzbuzz: whatever meaning you wish -- operational semantics is how to execute the program, denotational semantics is a variant that describes how to map the program into sets and functions (roughly) |
| 2023-02-03 22:48:54 +0100 | <tomsmeding> | but if you design some program analysis that computes, say, one number from a program, then that analysis can also be called a semantics |
| 2023-02-03 22:49:07 +0100 | <tomsmeding> | because it really is one possible meaning for the program text (the syntax) |
| 2023-02-03 22:52:28 +0100 | <monochrom> | Generally, semantics maps programs to whatever you think you already understand. |
| 2023-02-03 22:53:29 +0100 | <monochrom> | The first corollary being different people from different backgrounds will choose different targets. This is why there are so many semantics. |
| 2023-02-03 22:54:41 +0100 | <monochrom> | It is not all that different from "what's the meaning of English". |
| 2023-02-03 22:55:11 +0100 | takuan | (~takuan@178-116-218-225.access.telenet.be) (Ping timeout: 248 seconds) |
| 2023-02-03 22:55:33 +0100 | gnalzo | (~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8) |
| 2023-02-03 22:55:39 +0100 | <monochrom> | If someone asks you "what does 'car' mean?" you explain in terms of what they already know. Or at least you think you do that. |
| 2023-02-03 22:56:10 +0100 | <darkling> | Anyone want to talk semiotics? ;) |
| 2023-02-03 22:57:18 +0100 | <EvanR> | game semantics |
| 2023-02-03 22:57:47 +0100 | segfaultfizzbuzz | (~segfaultf@108.211.201.53) (Ping timeout: 252 seconds) |
| 2023-02-03 22:58:02 +0100 | <monochrom> | https://mail.haskell.org/pipermail/haskell-cafe/2011-January/088315.html |
| 2023-02-03 22:59:04 +0100 | CAT_S | (apic@brezn3.muc.ccc.de) (Read error: Connection reset by peer) |
| 2023-02-03 22:59:06 +0100 | merijn | (~merijn@c-001-001-010.client.esciencecenter.eduvpn.nl) |
| 2023-02-03 23:03:39 +0100 | merijn | (~merijn@c-001-001-010.client.esciencecenter.eduvpn.nl) (Ping timeout: 252 seconds) |
| 2023-02-03 23:04:11 +0100 | segfaultfizzbuzz | (~segfaultf@108.211.201.53) |
| 2023-02-03 23:04:13 +0100 | <segfaultfizzbuzz> | (pardon the disconnect :) ) |
| 2023-02-03 23:05:06 +0100 | kitzman | (~kitzman@user/dekenevs) (Quit: C-x C-c) |
| 2023-02-03 23:07:45 +0100 | kitzman | (~kitzman@user/dekenevs) |
| 2023-02-03 23:08:41 +0100 | <segfaultfizzbuzz> | "a semantic" is a program invariant, perhaps? |
| 2023-02-03 23:08:55 +0100 | bilegeek | (~bilegeek@2600:1008:b024:9ac8:31f:a878:7a7e:b80e) |
| 2023-02-03 23:11:02 +0100 | <dminuoso> | segfaultfizzbuzz: I think talking about semantics in general can be incredibly vague. |
| 2023-02-03 23:11:07 +0100 | <dminuoso> | Let's pick a concrete example. |
| 2023-02-03 23:12:02 +0100 | <dminuoso> | Often, operational semantics maps programs to steps taken on an abstract machine. |
| 2023-02-03 23:12:07 +0100 | <segfaultfizzbuzz> | dminuoso: right the combination of that and sematics being apparently incredibly important is why i am asking about this |
| 2023-02-03 23:12:16 +0100 | <segfaultfizzbuzz> | dminuoso: along with the definition of the abstract machine...? |
| 2023-02-03 23:12:20 +0100 | <dminuoso> | Right |
| 2023-02-03 23:12:48 +0100 | <dminuoso> | So operational semantics would entail first defining some kind of abstract machine, its behavior, some rules that govern it maybe - often this is done in a vague and suggestive fashion |
| 2023-02-03 23:12:56 +0100 | <segfaultfizzbuzz> | are they a "projection" of the program or intended to be an "isomorphism" of the program? |
| 2023-02-03 23:14:07 +0100 | <dminuoso> | As for operational semantics, I would say just a mapping (i.e. function), given that its trivial in most programming languages to map two different programs to the exact same operational steps |
| 2023-02-03 23:14:38 +0100 | <dminuoso> | In haskell it could be something mundane as say `let a = 1; b = 2 in ...` vs `let b = 2; a = 1 in ...` |
| 2023-02-03 23:14:49 +0100 | CAT_S | (apic@brezn3.muc.ccc.de) |
| 2023-02-03 23:15:09 +0100 | <dminuoso> | Which is clearly two different expressions, and yet they will map to the same operational behavior |
| 2023-02-03 23:15:28 +0100 | <dminuoso> | well "clearly different" at least on a textual input level, anyhow |
| 2023-02-03 23:15:45 +0100 | <segfaultfizzbuzz> | ah right because programs aren't canonicalized--you can't tell if two functions do the same thing |
| 2023-02-03 23:16:01 +0100 | <segfaultfizzbuzz> | but with semantics,... maybe you can, or you can more easily tell whether two functions do the same thing? |
| 2023-02-03 23:16:10 +0100 | <segfaultfizzbuzz> | *can't **easily** tell |
| 2023-02-03 23:16:14 +0100 | <dminuoso> | ideally dont talk about "semantics" without prefixing it with some qualifier |
| 2023-02-03 23:16:30 +0100 | <segfaultfizzbuzz> | like quantum semantics |
| 2023-02-03 23:16:46 +0100 | <dminuoso> | 23:16:01 segfaultfizzbuzz | but with semantics,... maybe you can, or you can more easily tell whether two functions do the same thing? |
| 2023-02-03 23:16:49 +0100 | <dminuoso> | Ah yes, absolutely! |
| 2023-02-03 23:16:54 +0100 | <dminuoso> | Depending on the semantics |
| 2023-02-03 23:17:01 +0100 | <segfaultfizzbuzz> | so semantics are "more canonicalized" than programs |
| 2023-02-03 23:17:05 +0100 | <dminuoso> | denotational semantics can be a tool you can utilize to that end, *exactly* |
| 2023-02-03 23:17:11 +0100 | <dminuoso> | Do you know what denotational semantics are? |
| 2023-02-03 23:17:30 +0100 | <segfaultfizzbuzz> | i have seen the term thrown around, but this post here makes me think it is talking about category theory |
| 2023-02-03 23:17:36 +0100 | <dminuoso> | So in denotational semantics you map programs to mathematical objects. |
| 2023-02-03 23:17:45 +0100 | <dminuoso> | The cool thing now is |
| 2023-02-03 23:17:52 +0100 | <segfaultfizzbuzz> | and the five or so times i have tried to read about category theory, all i see is renamed graph theory with specific graph rules which i don't find to be very interesting and my eyes cross |
| 2023-02-03 23:18:02 +0100 | <dminuoso> | If you can show that a given function truthfully maps to a mathematical object, you can infer properties back |
| 2023-02-03 23:18:30 +0100 | <segfaultfizzbuzz> | so it's a math-decompiler for functions |
| 2023-02-03 23:18:45 +0100 | <dminuoso> | sure, and if you do this as a programmer yourself, its called denotational design |
| 2023-02-03 23:18:57 +0100 | <dminuoso> | where you design functions, maybe an entire api, while mapping things to mathematical objects |
| 2023-02-03 23:18:59 +0100 | <dminuoso> | its not complicated either |
| 2023-02-03 23:19:02 +0100 | <dminuoso> | https://www.youtube.com/watch?v=bmKYiUOEo2A |
| 2023-02-03 23:19:11 +0100 | <dminuoso> | Is a great talk from conal elliott I think you might find enjoyable |
| 2023-02-03 23:19:12 +0100 | <segfaultfizzbuzz> | but you "cannot write a program with only semantics"? |
| 2023-02-03 23:19:19 +0100 | <dminuoso> | "with only semantics" |
| 2023-02-03 23:19:23 +0100 | <dminuoso> | doesnt really seem to make sense |
| 2023-02-03 23:19:44 +0100 | <EvanR> | maybe you mean write a program with NO semantics xD |
| 2023-02-03 23:19:50 +0100 | <segfaultfizzbuzz> | well the "best" programming language would be canonicalized |
| 2023-02-03 23:19:55 +0100 | <EvanR> | this is kind of what you can do in category theory |
| 2023-02-03 23:20:04 +0100 | <dminuoso> | what do you mean by "canonicalized"? |
| 2023-02-03 23:20:16 +0100 | <segfaultfizzbuzz> | i can write several different implementations of the same function |
| 2023-02-03 23:20:22 +0100 | <segfaultfizzbuzz> | but i don't really care about this, i care about what the function does |
| 2023-02-03 23:20:47 +0100 | <EvanR> | there's always some kind of concrete thing to compare against |
| 2023-02-03 23:20:49 +0100 | <darkling> | That's the (denotational?) semantics of the function. |
| 2023-02-03 23:21:02 +0100 | <dminuoso> | segfaultfizzbuzz: thinking in terms of what a function *does* goes into operational semantics |
| 2023-02-03 23:21:20 +0100 | <EvanR> | e.g. what is "what the function does", is it a set of associative pairs defining the function. That itself is some concrete thing |
| 2023-02-03 23:21:23 +0100 | <dminuoso> | because "doing something" usually implies some kind of steps on a machine, say instructions on a cpu, steps on an abstract machine, something along these lines |
| 2023-02-03 23:21:32 +0100 | <segfaultfizzbuzz> | understood, the question was "what do you mean by canonicalized?" and my answer to this is that ideally there would be a very strong one-to-one correspondence between a function and what it performed |
| 2023-02-03 23:21:40 +0100 | <segfaultfizzbuzz> | whereas ordinarily this is many-to-one |
| 2023-02-03 23:22:26 +0100 | <dminuoso> | mmm, are you talking about a "do one thing well" kind of philosophy? |
| 2023-02-03 23:22:27 +0100 | <segfaultfizzbuzz> | dminuoso: i mean i'm not aware of a purpose for absolutely unconditionally pure programs, unless you are some kind of meditation expert |
| 2023-02-03 23:23:10 +0100 | <EvanR> | in haskell you don't need impure programs, so you can get the benefits of pure programs any time |
| 2023-02-03 23:23:20 +0100 | <segfaultfizzbuzz> | dminuoso: sorry i didn't mean to get sidetracked on this issue, except maybe for the question of why a programming language would deviate from the most abstract possible semantics |
| 2023-02-03 23:23:56 +0100 | <mauke> | the most abstract possible semantics is () |
| 2023-02-03 23:25:36 +0100 | <segfaultfizzbuzz> | mauke: sounds like that would be good for a meditation app or something |
| 2023-02-03 23:25:46 +0100 | coot | (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot) |
| 2023-02-03 23:31:55 +0100 | <segfaultfizzbuzz> | ok i will disappear for a little but will be checking whatever folks say |
| 2023-02-03 23:32:26 +0100 | <dminuoso> | segfaultfizzbuzz: Do give the talk from Conal Elliott I linked above a try |
| 2023-02-03 23:32:39 +0100 | <dminuoso> | It might be helpful to get an idea of what denotational design is |
| 2023-02-03 23:32:56 +0100 | <segfaultfizzbuzz> | i glanced at it, i will try to watch it later. interesting that "functional" was a preceding term |
| 2023-02-03 23:33:02 +0100 | <dminuoso> | It's one of finer and easier examples, because both the source code and the mathematical models involved are *very* simple |
| 2023-02-03 23:33:13 +0100 | <dminuoso> | So it should be great for a wide audience |
| 2023-02-03 23:35:07 +0100 | <dminuoso> | There's also a bunch of tools that let you go the other way around, where you just describe a mathematical model, and then have a tool extract code for you that satisfies that mathematical model. |
| 2023-02-03 23:35:27 +0100 | <dminuoso> | So this idea of denotational design can in both directions |
| 2023-02-03 23:37:06 +0100 | pragma- | (~chaos@user/pragmatic-chaos) (Bye!) |
| 2023-02-03 23:37:44 +0100 | kuribas | (~user@ptr-17d51en5pcqxlnvqlnm.18120a2.ip6.access.telenet.be) (Quit: ERC (IRC client for Emacs 27.1)) |
| 2023-02-03 23:40:37 +0100 | gurkenglas | (~gurkengla@dynamic-046-114-179-193.46.114.pool.telefonica.de) |
| 2023-02-03 23:40:50 +0100 | sammelweis | (~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.) |
| 2023-02-03 23:40:58 +0100 | sammelweis | (~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) |
| 2023-02-03 23:42:19 +0100 | Lycurgus | (~juan@user/Lycurgus) |
| 2023-02-03 23:42:53 +0100 | Hammdist | (~Hammdist@67.169.114.135) (Quit: Client closed) |
| 2023-02-03 23:43:29 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) |
| 2023-02-03 23:44:57 +0100 | enthropy | (~enthropy@66.7.90.250) |
| 2023-02-03 23:46:23 +0100 | segfaultfizzbuzz | (~segfaultf@108.211.201.53) (Ping timeout: 248 seconds) |
| 2023-02-03 23:48:21 +0100 | <geekosaur> | btw,mauke was a bit extreme but serious. if you abstract away too much, your program won't solve the problem, it'll only solve something that is missing too many details to be useful |
| 2023-02-03 23:48:43 +0100 | <geekosaur> | flip side, abstract away too little and you're doing something the computer ought to be doing for you |
| 2023-02-03 23:51:15 +0100 | <geekosaur> | Haskell has staked out a part of the abstraction space where as much as possible we say what but not how . many other languages prefer to make it easier for you to express the how in various ways |
| 2023-02-03 23:53:51 +0100 | bgs | (~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection) |
| 2023-02-03 23:55:04 +0100 | michalz | (~michalz@185.246.207.217) (Remote host closed the connection) |
| 2023-02-03 23:57:31 +0100 | mvk | (~mvk@2607:fea8:5caa:ac00::f944) |
