| 2024-02-16 00:06:07 +0100 | szkl | (uid110435@id-110435.uxbridge.irccloud.com) |
| 2024-02-16 00:06:55 +0100 | <haskellbridge> | <Jade> mhm |
| 2024-02-16 00:07:00 +0100 | <haskellbridge> | <Jade> thank you |
| 2024-02-16 00:08:27 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) |
| 2024-02-16 00:10:59 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 260 seconds) |
| 2024-02-16 00:12:52 +0100 | <EvanR> | haskell would never be caught using OOP with mutable state. We use IORef in a ReaderT. Totally different |
| 2024-02-16 00:14:44 +0100 | <haskellbridge> | <Jade> I do still think it gives more control, atleast to an extend |
| 2024-02-16 00:14:49 +0100 | <haskellbridge> | <Jade> maybe that's just bias though lol |
| 2024-02-16 00:16:15 +0100 | mizlan | (~mizlan@2607:f010:2e9:b:2111:fd0f:9e73:cbbb) (Remote host closed the connection) |
| 2024-02-16 00:17:42 +0100 | acidjnk | (~acidjnk@p200300d6e737e785eca59ab302ca347d.dip0.t-ipconnect.de) (Ping timeout: 255 seconds) |
| 2024-02-16 00:18:08 +0100 | <c_wraith> | I mean, I wouldn't even call it wrong. Or right. |
| 2024-02-16 00:18:20 +0100 | <c_wraith> | I don't really think mutability and OOP are that closely related |
| 2024-02-16 00:18:32 +0100 | <c_wraith> | We use records of functions instead of OOP. totally different! |
| 2024-02-16 00:20:15 +0100 | <haskellbridge> | <Jade> I officially have a working cache: https://paste.tomsmeding.com/C5xkv1Kh |
| 2024-02-16 00:20:27 +0100 | <haskellbridge> | <Jade> That took way too long and the code is way too ugly, but it works |
| 2024-02-16 00:24:49 +0100 | gmg | (~user@user/gehmehgeh) (Quit: Leaving) |
| 2024-02-16 00:25:47 +0100 | ski | (~ski@ext-1-033.eduroam.chalmers.se) (Ping timeout: 264 seconds) |
| 2024-02-16 00:30:23 +0100 | <Axman6> | Jade: I would make a function which is basicsally State's modify :: (a -> a) -> App a |
| 2024-02-16 00:32:00 +0100 | ski | (~ski@ext-1-033.eduroam.chalmers.se) |
| 2024-02-16 00:32:20 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) (Remote host closed the connection) |
| 2024-02-16 00:32:27 +0100 | <EvanR> | which does what, return the original value? |
| 2024-02-16 00:32:32 +0100 | <EvanR> | or the new value |
| 2024-02-16 00:32:36 +0100 | <Axman6> | returns the new value |
| 2024-02-16 00:32:48 +0100 | <Axman6> | use modify id to get the current state |
| 2024-02-16 00:32:51 +0100 | chiselfu1e | (~chiselfus@user/chiselfuse) |
| 2024-02-16 00:33:22 +0100 | <Axman6> | I'd also define modify' :: (a -> (a,b)) -> App b |
| 2024-02-16 00:40:11 +0100 | TonyStone | (~TonyStone@074-076-057-186.res.spectrum.com) |
| 2024-02-16 00:40:47 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection) |
| 2024-02-16 00:42:10 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) |
| 2024-02-16 00:48:46 +0100 | jargon | (~jargon@13.sub-174-205-175.myvzw.com) (Remote host closed the connection) |
| 2024-02-16 00:49:14 +0100 | jargon | (~jargon@13.sub-174-205-175.myvzw.com) |
| 2024-02-16 00:51:27 +0100 | sudden | (~cat@user/sudden) (Ping timeout: 255 seconds) |
| 2024-02-16 00:55:23 +0100 | Sgeo | (~Sgeo@user/sgeo) |
| 2024-02-16 01:00:29 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds) |
| 2024-02-16 01:03:49 +0100 | sudden | (~cat@user/sudden) |
| 2024-02-16 01:10:36 +0100 | Tuplanolla | (~Tuplanoll@91-159-68-95.elisa-laajakaista.fi) (Quit: Leaving.) |
| 2024-02-16 01:11:59 +0100 | bontaq | (~user@ool-45779c03.dyn.optonline.net) (Ping timeout: 264 seconds) |
| 2024-02-16 01:26:06 +0100 | yoo | (~yo0O0o@user/mobivme) (Ping timeout: 255 seconds) |
| 2024-02-16 01:49:05 +0100 | xff0x | (~xff0x@ai082039.d.east.v6connect.net) (Ping timeout: 252 seconds) |
| 2024-02-16 01:56:33 +0100 | yoo | (~yo0O0o@104.28.226.106) |
| 2024-02-16 01:58:11 +0100 | waleee | (~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 264 seconds) |
| 2024-02-16 01:59:24 +0100 | ski | (~ski@ext-1-033.eduroam.chalmers.se) (Ping timeout: 255 seconds) |
| 2024-02-16 02:00:10 +0100 | yoo | (~yo0O0o@104.28.226.106) (Changing host) |
| 2024-02-16 02:00:10 +0100 | yoo | (~yo0O0o@user/mobivme) |
| 2024-02-16 02:01:09 +0100 | ski | (~ski@ext-1-033.eduroam.chalmers.se) |
| 2024-02-16 02:04:54 +0100 | waleee | (~waleee@h-176-10-144-38.NA.cust.bahnhof.se) |
| 2024-02-16 02:07:12 +0100 | Pozyomka | (~pyon@user/pyon) |
| 2024-02-16 02:09:21 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) |
| 2024-02-16 02:12:44 +0100 | yoo | (~yo0O0o@user/mobivme) (Ping timeout: 252 seconds) |
| 2024-02-16 02:15:46 +0100 | fryguybob | (~fryguybob@024-094-050-022.inf.spectrum.com) (Read error: Connection reset by peer) |
| 2024-02-16 02:16:37 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 264 seconds) |
| 2024-02-16 02:19:35 +0100 | mei | (~mei@user/mei) (Remote host closed the connection) |
| 2024-02-16 02:21:58 +0100 | mei | (~mei@user/mei) |
| 2024-02-16 02:32:03 +0100 | mud | (~mud@user/kadoban) (Quit: quit) |
| 2024-02-16 02:34:57 +0100 | xff0x | (~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) |
| 2024-02-16 02:47:01 +0100 | Lord_of_Life | (~Lord@user/lord-of-life/x-2819915) (Ping timeout: 256 seconds) |
| 2024-02-16 02:47:10 +0100 | jargon | (~jargon@13.sub-174-205-175.myvzw.com) (Read error: Connection reset by peer) |
| 2024-02-16 02:48:54 +0100 | mmhat | (~mmh@p200300f1c70685c4ee086bfffe095315.dip0.t-ipconnect.de) |
| 2024-02-16 02:48:55 +0100 | Lord_of_Life | (~Lord@user/lord-of-life/x-2819915) |
| 2024-02-16 02:48:58 +0100 | mmhat | (~mmh@p200300f1c70685c4ee086bfffe095315.dip0.t-ipconnect.de) (Client Quit) |
| 2024-02-16 02:49:35 +0100 | waleee | (~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 252 seconds) |
| 2024-02-16 02:52:51 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) |
| 2024-02-16 02:58:23 +0100 | igemnace | (~ian@user/igemnace) |
| 2024-02-16 03:02:51 +0100 | existence_ | (~existence@176.254.244.83) |
| 2024-02-16 03:03:31 +0100 | petrichor | (~znc-user@user/petrichor) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2024-02-16 03:04:20 +0100 | petrichor | (~znc-user@user/petrichor) |
| 2024-02-16 03:04:51 +0100 | johnw | (~johnw@69.62.242.138) (Quit: ZNC - http://znc.in) |
| 2024-02-16 03:05:59 +0100 | _3xistence | (~existence@176.254.244.83) (Ping timeout: 268 seconds) |
| 2024-02-16 03:06:36 +0100 | johnw | (~johnw@69.62.242.138) |
| 2024-02-16 03:12:45 +0100 | otto_s | (~user@p5b0449b5.dip0.t-ipconnect.de) (Ping timeout: 255 seconds) |
| 2024-02-16 03:14:14 +0100 | breakpoint | (~pupkey@user/pupkey) |
| 2024-02-16 03:14:35 +0100 | otto_s | (~user@p5de2f7db.dip0.t-ipconnect.de) |
| 2024-02-16 03:15:58 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) (Quit: Client closed) |
| 2024-02-16 03:19:18 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) |
| 2024-02-16 03:24:49 +0100 | son0p | (~ff@191.104.6.115) (Ping timeout: 260 seconds) |
| 2024-02-16 03:31:52 +0100 | Guest|94 | (~Guest|94@114.5.16.104) |
| 2024-02-16 03:34:13 +0100 | dtman34 | (~dtman34@c-76-156-89-180.hsd1.mn.comcast.net) (Quit: ZNC 1.8.2+deb3.1 - https://znc.in) |
| 2024-02-16 03:34:57 +0100 | dtman34 | (~dtman34@2601:447:d000:93c9:cf8:f10e:31e1:643) |
| 2024-02-16 03:39:49 +0100 | Guest|94 | (~Guest|94@114.5.16.104) (Quit: Connection closed) |
| 2024-02-16 03:43:14 +0100 | thegeekinside | (~thegeekin@189.217.83.221) |
| 2024-02-16 03:54:32 +0100 | thegeekinside | (~thegeekin@189.217.83.221) (Remote host closed the connection) |
| 2024-02-16 03:55:01 +0100 | livoreno | (~zmv@user/notzmv) (Ping timeout: 256 seconds) |
| 2024-02-16 03:55:07 +0100 | thegeekinside | (~thegeekin@189.217.83.221) |
| 2024-02-16 03:56:34 +0100 | thegeekinside | (~thegeekin@189.217.83.221) (Remote host closed the connection) |
| 2024-02-16 03:58:17 +0100 | thegeekinside | (~thegeekin@189.217.83.221) |
| 2024-02-16 03:59:13 +0100 | Erutuon | (~Erutuon@user/erutuon) (Ping timeout: 264 seconds) |
| 2024-02-16 04:00:40 +0100 | thegeekinside | (~thegeekin@189.217.83.221) (Remote host closed the connection) |
| 2024-02-16 04:00:52 +0100 | thegeekinside | (~thegeekin@189.217.83.221) |
| 2024-02-16 04:01:29 +0100 | thegeekinside | (~thegeekin@189.217.83.221) (Remote host closed the connection) |
| 2024-02-16 04:01:42 +0100 | thegeekinside | (~thegeekin@189.217.83.221) |
| 2024-02-16 04:02:14 +0100 | petrichor | (~znc-user@user/petrichor) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2024-02-16 04:02:38 +0100 | petrichor | (~znc-user@user/petrichor) |
| 2024-02-16 04:03:13 +0100 | TonyStone | (~TonyStone@074-076-057-186.res.spectrum.com) (Quit: Leaving) |
| 2024-02-16 04:17:58 +0100 | rembo10 | (~rembo10@main.remulis.com) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2024-02-16 04:18:41 +0100 | rembo10 | (~rembo10@main.remulis.com) |
| 2024-02-16 04:19:13 +0100 | jargon | (~jargon@13.sub-174-205-175.myvzw.com) |
| 2024-02-16 04:27:34 +0100 | td_ | (~td@i53870914.versanet.de) (Ping timeout: 264 seconds) |
| 2024-02-16 04:28:57 +0100 | td_ | (~td@i5387091D.versanet.de) |
| 2024-02-16 04:30:56 +0100 | pyooque | (~puke@user/puke) |
| 2024-02-16 04:30:56 +0100 | puke | Guest5559 |
| 2024-02-16 04:30:56 +0100 | Guest5559 | (~puke@user/puke) (Killed (mercury.libera.chat (Nickname regained by services))) |
| 2024-02-16 04:30:56 +0100 | pyooque | puke |
| 2024-02-16 04:45:05 +0100 | machinedgod | (~machinedg@d173-183-246-216.abhsia.telus.net) (Ping timeout: 252 seconds) |
| 2024-02-16 04:50:25 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 255 seconds) |
| 2024-02-16 04:54:58 +0100 | jargon | (~jargon@13.sub-174-205-175.myvzw.com) (Remote host closed the connection) |
| 2024-02-16 04:55:16 +0100 | jargon | (~jargon@13.sub-174-205-175.myvzw.com) |
| 2024-02-16 04:56:03 +0100 | thegeekinside | (~thegeekin@189.217.83.221) (Read error: Connection reset by peer) |
| 2024-02-16 05:00:48 +0100 | jargon | (~jargon@13.sub-174-205-175.myvzw.com) (Remote host closed the connection) |
| 2024-02-16 05:01:11 +0100 | shapr` | (~user@c-24-218-186-89.hsd1.ma.comcast.net) |
| 2024-02-16 05:01:21 +0100 | thegeekinside | (~thegeekin@189.217.83.221) |
| 2024-02-16 05:01:23 +0100 | thegeekinside | (~thegeekin@189.217.83.221) (Read error: Connection reset by peer) |
| 2024-02-16 05:01:54 +0100 | jargon | (~jargon@13.sub-174-205-175.myvzw.com) |
| 2024-02-16 05:03:00 +0100 | shapr | (~user@c-24-218-186-89.hsd1.ma.comcast.net) (Ping timeout: 255 seconds) |
| 2024-02-16 05:04:09 +0100 | tv | (~tv@user/tv) (Ping timeout: 256 seconds) |
| 2024-02-16 05:09:18 +0100 | thegeekinside | (~thegeekin@189.217.83.221) |
| 2024-02-16 05:09:21 +0100 | thegeekinside | (~thegeekin@189.217.83.221) (Read error: Connection reset by peer) |
| 2024-02-16 05:17:35 +0100 | tv | (~tv@user/tv) |
| 2024-02-16 05:24:45 +0100 | Me-me | (~me-me@user/me-me) (Quit: Disconnecting on purpose.) |
| 2024-02-16 05:25:44 +0100 | Me-me | (~me-me@2602:ff16:3:0:1:dc:beef:d00d) |
| 2024-02-16 05:28:23 +0100 | shapr` | (~user@c-24-218-186-89.hsd1.ma.comcast.net) (Ping timeout: 256 seconds) |
| 2024-02-16 05:31:48 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) (Quit: Client closed) |
| 2024-02-16 05:34:23 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) |
| 2024-02-16 05:43:11 +0100 | aforemny | (~aforemny@i59F516E9.versanet.de) |
| 2024-02-16 05:44:01 +0100 | aforemny_ | (~aforemny@2001:9e8:6cf1:d400:fa96:61a3:2d1c:1b12) (Ping timeout: 246 seconds) |
| 2024-02-16 06:04:34 +0100 | phma | (~phma@host-67-44-208-97.hnremote.net) (Read error: Connection reset by peer) |
| 2024-02-16 06:05:31 +0100 | phma | (~phma@2001:5b0:211f:7668:c06b:4bbf:a33c:c0f7) |
| 2024-02-16 06:07:03 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 272 seconds) |
| 2024-02-16 06:08:57 +0100 | michalz | (~michalz@185.246.207.193) |
| 2024-02-16 06:12:17 +0100 | rosco | (~rosco@175.136.156.77) |
| 2024-02-16 06:28:58 +0100 | Square | (~Square@user/square) |
| 2024-02-16 06:30:35 +0100 | Square3 | (~Square4@user/square) (Ping timeout: 264 seconds) |
| 2024-02-16 06:37:25 +0100 | sefidel | (~sefidel@user/sefidel) (Read error: Connection reset by peer) |
| 2024-02-16 06:37:40 +0100 | sefidel | (~sefidel@user/sefidel) |
| 2024-02-16 06:39:58 +0100 | tcard_ | (~tcard@2400:4051:5801:7500:cf17:befc:ff82:5303) (Quit: Leaving) |
| 2024-02-16 06:40:24 +0100 | minigrim0 | (~minigrim0@2a01:4f9:6b:3416:68ba:8dff:fe58:a5ea) (Ping timeout: 256 seconds) |
| 2024-02-16 06:41:14 +0100 | minigrim0 | (~minigrim0@2a01:4f9:6b:3416:68ba:8dff:fe58:a5ea) |
| 2024-02-16 06:42:28 +0100 | tcard | (~tcard@2400:4051:5801:7500:cf17:befc:ff82:5303) |
| 2024-02-16 06:42:34 +0100 | jargon | (~jargon@13.sub-174-205-175.myvzw.com) (Remote host closed the connection) |
| 2024-02-16 06:42:52 +0100 | jargon | (~jargon@13.sub-174-205-175.myvzw.com) |
| 2024-02-16 07:02:06 +0100 | _ht | (~Thunderbi@28-52-174-82.ftth.glasoperator.nl) |
| 2024-02-16 07:03:13 +0100 | mei | (~mei@user/mei) (Ping timeout: 260 seconds) |
| 2024-02-16 07:05:10 +0100 | sroso | (~sroso@user/SrOso) |
| 2024-02-16 07:06:21 +0100 | Unicorn_Princess | (~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection) |
| 2024-02-16 07:12:39 +0100 | Square | (~Square@user/square) (Quit: Leaving) |
| 2024-02-16 07:12:53 +0100 | Square | (~Square@user/square) |
| 2024-02-16 07:30:15 +0100 | <mjrosenb> | Is it just me, or did the either package remove its transformer? |
| 2024-02-16 07:42:47 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) |
| 2024-02-16 07:50:42 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) (Ping timeout: 250 seconds) |
| 2024-02-16 07:55:01 +0100 | oo_miguel | (~Thunderbi@78-11-181-16.static.ip.netia.com.pl) |
| 2024-02-16 07:56:23 +0100 | breakpoint | (~pupkey@user/pupkey) (Quit: Lost terminal) |
| 2024-02-16 07:59:22 +0100 | acidjnk | (~acidjnk@p200300d6e737e768eca59ab302ca347d.dip0.t-ipconnect.de) |
| 2024-02-16 08:06:05 +0100 | takuan | (~takuan@178-116-218-225.access.telenet.be) |
| 2024-02-16 08:10:35 +0100 | Square | (~Square@user/square) (Ping timeout: 256 seconds) |
| 2024-02-16 08:12:42 +0100 | nunggu | (~q@user/nunggu) |
| 2024-02-16 08:17:17 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) |
| 2024-02-16 08:18:05 +0100 | nunggu | (~q@user/nunggu) (Remote host closed the connection) |
| 2024-02-16 08:19:40 +0100 | nunggu | (~q@user/nunggu) |
| 2024-02-16 08:20:55 +0100 | jargon | (~jargon@13.sub-174-205-175.myvzw.com) (Remote host closed the connection) |
| 2024-02-16 08:30:25 +0100 | danse-nr3 | (~danse@151.44.199.109) |
| 2024-02-16 08:30:48 +0100 | sord937 | (~sord937@gateway/tor-sasl/sord937) |
| 2024-02-16 08:33:50 +0100 | chiselfu1e | chiselfuse |
| 2024-02-16 08:38:10 +0100 | lortabac | (~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4) |
| 2024-02-16 08:42:40 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 08:43:55 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 08:45:18 +0100 | jtza8 | (~user@user/jtza8) |
| 2024-02-16 08:49:55 +0100 | rosco | (~rosco@175.136.156.77) (Quit: Lost terminal) |
| 2024-02-16 08:50:57 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer) |
| 2024-02-16 08:52:16 +0100 | euleritian | (~euleritia@dynamic-176-006-185-052.176.6.pool.telefonica.de) |
| 2024-02-16 08:53:21 +0100 | euleritian | (~euleritia@dynamic-176-006-185-052.176.6.pool.telefonica.de) (Read error: Connection reset by peer) |
| 2024-02-16 08:53:38 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-02-16 08:55:37 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-02-16 08:56:58 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Read error: Connection reset by peer) |
| 2024-02-16 08:57:33 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 08:57:55 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer) |
| 2024-02-16 08:58:47 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-02-16 09:01:01 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 09:03:48 +0100 | CiaoSen | (~Jura@2a05:5800:2c6:8e00:e6b9:7aff:fe80:3d03) |
| 2024-02-16 09:05:47 +0100 | jtza8 | (~user@user/jtza8) (Ping timeout: 260 seconds) |
| 2024-02-16 09:05:58 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 264 seconds) |
| 2024-02-16 09:06:24 +0100 | trev | (~trev@user/trev) (Read error: Connection reset by peer) |
| 2024-02-16 09:08:41 +0100 | sord937 | (~sord937@gateway/tor-sasl/sord937) (Remote host closed the connection) |
| 2024-02-16 09:08:47 +0100 | euleritian | (~euleritia@dynamic-176-006-185-052.176.6.pool.telefonica.de) |
| 2024-02-16 09:09:07 +0100 | sord937 | (~sord937@gateway/tor-sasl/sord937) |
| 2024-02-16 09:11:33 +0100 | c_wraith | (~c_wraith@adjoint.us) (Ping timeout: 260 seconds) |
| 2024-02-16 09:11:44 +0100 | c_wraith | (~c_wraith@adjoint.us) |
| 2024-02-16 09:15:39 +0100 | trev | (~trev@user/trev) |
| 2024-02-16 09:32:25 +0100 | fendor | (~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c) |
| 2024-02-16 09:33:50 +0100 | xff0x | (~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 252 seconds) |
| 2024-02-16 09:36:43 +0100 | trev | (~trev@user/trev) (Read error: Connection reset by peer) |
| 2024-02-16 09:36:54 +0100 | econo_ | (uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity) |
| 2024-02-16 09:37:31 +0100 | trev | (~trev@user/trev) |
| 2024-02-16 09:43:25 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) |
| 2024-02-16 09:45:07 +0100 | machinedgod | (~machinedg@d173-183-246-216.abhsia.telus.net) |
| 2024-02-16 09:46:18 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer) |
| 2024-02-16 09:46:23 +0100 | chele | (~chele@user/chele) |
| 2024-02-16 09:53:16 +0100 | dcoutts | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 255 seconds) |
| 2024-02-16 09:58:43 +0100 | ft | (~ft@p508db2e6.dip0.t-ipconnect.de) (Quit: leaving) |
| 2024-02-16 10:02:49 +0100 | pretty_dumm_guy | (trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) |
| 2024-02-16 10:03:31 +0100 | __monty__ | (~toonn@user/toonn) |
| 2024-02-16 10:14:13 +0100 | tzh | (~tzh@c-71-193-181-0.hsd1.or.comcast.net) (Quit: zzz) |
| 2024-02-16 10:16:02 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection) |
| 2024-02-16 10:16:13 +0100 | p3n | (~p3n@217.198.124.246) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2024-02-16 10:16:35 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) |
| 2024-02-16 10:18:12 +0100 | p3n | (~p3n@217.198.124.246) |
| 2024-02-16 10:18:19 +0100 | <tomsmeding> | mjrosenb: https://hackage.haskell.org/package/either-5/changelog |
| 2024-02-16 10:18:37 +0100 | <tomsmeding> | Control.Monad.Trans.Except has been in transformers for ages |
| 2024-02-16 10:25:14 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 10:25:51 +0100 | gehmehgeh | (~user@user/gehmehgeh) |
| 2024-02-16 10:26:57 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 10:27:41 +0100 | Sgeo | (~Sgeo@user/sgeo) (Read error: Connection reset by peer) |
| 2024-02-16 10:31:49 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) |
| 2024-02-16 10:32:49 +0100 | benjaminl | (~benjaminl@user/benjaminl) (Ping timeout: 264 seconds) |
| 2024-02-16 10:35:57 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 10:44:11 +0100 | dcoutts | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) |
| 2024-02-16 10:46:42 +0100 | yoo | (~yo0O0o@104.28.194.106) |
| 2024-02-16 10:46:42 +0100 | yoo | (~yo0O0o@104.28.194.106) (Changing host) |
| 2024-02-16 10:46:42 +0100 | yoo | (~yo0O0o@user/mobivme) |
| 2024-02-16 10:48:25 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 10:56:26 +0100 | nunggu | (~q@user/nunggu) (Quit: nunggu) |
| 2024-02-16 10:57:07 +0100 | yooo | (~yo0O0o@104.28.226.104) |
| 2024-02-16 10:57:35 +0100 | yoo | (~yo0O0o@user/mobivme) (Ping timeout: 264 seconds) |
| 2024-02-16 10:59:06 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 10:59:28 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 11:03:05 +0100 | euleritian | (~euleritia@dynamic-176-006-185-052.176.6.pool.telefonica.de) (Ping timeout: 260 seconds) |
| 2024-02-16 11:03:32 +0100 | euleritian | (~euleritia@77.22.252.56) |
| 2024-02-16 11:11:55 +0100 | rosco | (~rosco@175.136.156.77) |
| 2024-02-16 11:13:35 +0100 | Maxdamantus | (~Maxdamant@user/maxdamantus) (Ping timeout: 272 seconds) |
| 2024-02-16 11:15:00 +0100 | waldo | (~waldo@user/waldo) (Ping timeout: 268 seconds) |
| 2024-02-16 11:17:54 +0100 | Maxdamantus | (~Maxdamant@user/maxdamantus) |
| 2024-02-16 11:20:07 +0100 | waldo | (~waldo@user/waldo) |
| 2024-02-16 11:22:53 +0100 | danse-nr3 | (~danse@151.44.199.109) (Read error: Connection reset by peer) |
| 2024-02-16 11:23:55 +0100 | danse-nr3 | (~danse@151.19.232.78) |
| 2024-02-16 11:28:01 +0100 | waldo | (~waldo@user/waldo) (Ping timeout: 264 seconds) |
| 2024-02-16 11:29:11 +0100 | destituion | (~destituio@2a02:2121:626:f551:8e35:41cf:e501:3ba1) (Ping timeout: 268 seconds) |
| 2024-02-16 11:29:12 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-02-16 11:29:26 +0100 | destituion | (~destituio@85.221.111.174) |
| 2024-02-16 11:33:40 +0100 | yooo | (~yo0O0o@104.28.226.104) (Ping timeout: 246 seconds) |
| 2024-02-16 11:35:06 +0100 | waldo | (~waldo@user/waldo) |
| 2024-02-16 11:38:59 +0100 | danse-nr3 | (~danse@151.19.232.78) (Ping timeout: 264 seconds) |
| 2024-02-16 11:39:30 +0100 | evocatus | (~evocatus@2a02:a210:20c6:1f00:d2c0:b982:94f0:fc66) |
| 2024-02-16 11:39:35 +0100 | <evocatus> | hi! |
| 2024-02-16 11:40:09 +0100 | danse-nr3 | (~danse@151.19.232.78) |
| 2024-02-16 11:40:13 +0100 | <evocatus> | I'm giving a talk at my company Go meetup about main ideas of functional programming |
| 2024-02-16 11:40:47 +0100 | <evocatus> | I'm a fan of LISPs (Clojure mainly) but I would like to know Haskell folks perspective on what would those main ideas be |
| 2024-02-16 11:41:41 +0100 | <evocatus> | thinking about how to distil it into something concise I came up with this: |
| 2024-02-16 11:42:06 +0100 | <evocatus> | in order to maintain readability and being easy to change your code must stay simple |
| 2024-02-16 11:42:26 +0100 | <evocatus> | it means as little coupling things as possible |
| 2024-02-16 11:42:52 +0100 | <evocatus> | which means using truly composable things to construct your programs from |
| 2024-02-16 11:43:15 +0100 | <evocatus> | only true values and pure functions are composable, objects are not |
| 2024-02-16 11:43:25 +0100 | <evocatus> | that's it |
| 2024-02-16 11:44:07 +0100 | <evocatus> | how would you answer this question? |
| 2024-02-16 11:44:19 +0100 | <evocatus> | could you recommend some talks/articles that answer it well? |
| 2024-02-16 11:45:18 +0100 | yoo | (~yo0O0o@104.28.226.106) |
| 2024-02-16 11:45:35 +0100 | igemnace | (~ian@user/igemnace) (Ping timeout: 264 seconds) |
| 2024-02-16 11:49:53 +0100 | benjaminl | (~benjaminl@user/benjaminl) |
| 2024-02-16 11:50:11 +0100 | rscastilho2024 | (rscastilho@189.61.140.215) |
| 2024-02-16 11:50:16 +0100 | CiaoSen | (~Jura@2a05:5800:2c6:8e00:e6b9:7aff:fe80:3d03) (Ping timeout: 255 seconds) |
| 2024-02-16 11:50:31 +0100 | rscastilho2024 | (rscastilho@189.61.140.215) (Remote host closed the connection) |
| 2024-02-16 11:51:52 +0100 | igemnace | (~ian@user/igemnace) |
| 2024-02-16 11:53:58 +0100 | connrs | (~connrs@user/connrs) |
| 2024-02-16 11:58:08 +0100 | connrs | (~connrs@user/connrs) (Client Quit) |
| 2024-02-16 11:58:59 +0100 | connrs | (~connrs@user/connrs) |
| 2024-02-16 12:04:00 +0100 | <ski> | evocatus : being able to reason about (including refactoring) code is important. that is quite a bit easier, with restricting side-effects (including, but not limited to, mutability of state (this point is hard to overstate)). DRY and separation of concerns, taken to its logical conclusion, leads to higher-order operations (and having lexicaly/statically scoped nested functions, and preferably lambdas), |
| 2024-02-16 12:04:07 +0100 | <ski> | which also encourages avoiding side-effects (because it may not be obvious when your callback(s) will be called, and how many times). parallelism and concurrency can also be easier with immutable data. immutable data can also be shared, rather than having expensive precautionary copying -- this is most useful for data consisting of many linked parts, rather than huge chunk |
| 2024-02-16 12:05:07 +0100 | yoo | (~yo0O0o@104.28.226.106) (Ping timeout: 255 seconds) |
| 2024-02-16 12:05:20 +0100 | <ski> | another important thing, imo, is pattern-matching, replacing a maze of nested `if's with something more composable and declarative. (pattern-matching on sum types in FP is dual to message-dispatching on product types ("objects") in OO. both are important ways to structure code, there's a trade-off). generally, trying to build composable and modular APIs, often eDSLs, is important |
| 2024-02-16 12:07:06 +0100 | <tomsmeding> | sum types are such a super power |
| 2024-02-16 12:07:57 +0100 | <tomsmeding> | but clojure being untyped, the world looks slightly different there |
| 2024-02-16 12:08:24 +0100 | waldo | (~waldo@user/waldo) (Quit: waldo) |
| 2024-02-16 12:08:43 +0100 | <evocatus> | it's dynamically typed, not untyped :) |
| 2024-02-16 12:08:48 +0100 | <tomsmeding> | good poin t |
| 2024-02-16 12:10:23 +0100 | <danse-nr3> | i am with ski, referential transparency would be the topic |
| 2024-02-16 12:10:35 +0100 | <evocatus> | we have dynamically and statically typed languages in both camps (Clojure+Haskell vs Python+Go). My question is more about what is the difference between the camps and what an average Go developer can learn from the functional world while still writing in Go |
| 2024-02-16 12:10:49 +0100 | <danse-nr3> | just wrote |
| 2024-02-16 12:11:10 +0100 | <[Leary]> | they can learn to hate go |
| 2024-02-16 12:11:16 +0100 | <danse-nr3> | XD |
| 2024-02-16 12:12:21 +0100 | <ski> | statically typed FP languages tend to have advanced and expressive type systems, with sum types (and some form of product types), with parametric polymorphism (usually with type inference) (often with parametricity, which helps restrict what polymorphic operations can do, so helps with reasoning about polymorphic library operations, and refactoring calls to them). some have type classes, or expressive module |
| 2024-02-16 12:12:27 +0100 | <ski> | systems (including parameterizing modules over other modules, so called "functors"), or higher-order types, or existentials, or higher-rank operations, or indexed sum types ("Generalized Algebraic Data Types"), or things like lightweight (structural typing, no need to predeclare) variant ior record types, e.g. built on row types, &c. |
| 2024-02-16 12:13:10 +0100 | <danse-nr3> | and they enforce referential transparency, which is portable everywhere |
| 2024-02-16 12:13:26 +0100 | rscastilho2024 | (rscastilho@189.61.140.215) |
| 2024-02-16 12:13:39 +0100 | rscastilho2024 | (rscastilho@189.61.140.215) (Remote host closed the connection) |
| 2024-02-16 12:13:43 +0100 | <evocatus> | ski, would you consider Rust or Kotlin functional languages? They have rather advanced type systems (compared to the average level of course) |
| 2024-02-16 12:14:57 +0100 | <ski> | this (in combination with exhaustiveness checking on pattern-matching) can encourage "typeful programming", where you can write ior refactor iow modify code more freely, because you know the type system will catch many of your silly mistakes you make along the way, and often pointing you to other places in the code that needs to be updated, e.g. after updating a type definition, you may be pointed to all |
| 2024-02-16 12:15:03 +0100 | <ski> | pattern-matching that doesn't cover the new case, or hasn't been adapted to handle a modified case appropriately |
| 2024-02-16 12:15:17 +0100 | <probie> | [Leary]: Your average Go developer didn't need to learn anything from the functional world to hate Go |
| 2024-02-16 12:15:24 +0100 | <ski> | non-strictness (implemented as laziness, for efficiency) can help with modularity and separation of concerns, separating the producer of data from filtering, transforming, and consuming it. it can be harder to reason about space (and time) complexity, though |
| 2024-02-16 12:15:25 +0100 | <evocatus> | both Kotlin/Rust supports immutable values, in Rust it's even the default. And I see this as a step forward but is it enough? What is lacking there if any? |
| 2024-02-16 12:15:48 +0100 | euleritian | (~euleritia@77.22.252.56) (Read error: Connection reset by peer) |
| 2024-02-16 12:15:57 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-02-16 12:16:21 +0100 | <danse-nr3> | higher order functions for instance |
| 2024-02-16 12:16:54 +0100 | <danse-nr3> | .oO( wait, they might have those... ) |
| 2024-02-16 12:17:36 +0100 | <evocatus> | probie, you need to hate Go in the right way to not step into the same poop again. I remember how people were enthusiastic about Go in the beginning and if you watch Rob Pike's talk from 2009 where he bashes C++ and Java for their complexity... Go was such a failed promise, that's why people who hate it hate it more than other languages. They don't just dislike it they feel betrayed |
| 2024-02-16 12:17:37 +0100 | <danse-nr3> | i guess i was thinking about higher-order function from a typed haskeller's perspective ... better to read what ski writes :P |
| 2024-02-16 12:19:24 +0100 | <evocatus> | I remember what Bartosz Milewski said answering one of the questions (maybe it was even about Go) - you either have dynamic typing or generics and if you don't now you will have to do it in the future. Lo and behold, after 10 years Go introduced generics (they are half-baked but still) |
| 2024-02-16 12:20:01 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 12:20:05 +0100 | <ski> | even having a relatively comfortable way to do deferred, on-demand, possibly virtual, data structure, in a strict programming language, rather than taking non-strictness as the default, can go quite a way |
| 2024-02-16 12:20:50 +0100 | <danse-nr3> | yeah non-strictness is definitely something to study from haskell ... but advocating for it ain't easy |
| 2024-02-16 12:20:59 +0100 | <ski> | evocatus : in summary, some of the important concepts in FP tend to be : discourage side-effects, encourage immutability. encourage higher-order operations (including local functions with static/lexical scoping. first-class function values). sum types (as well as product types), with pattern-matching. statically typed FP tends to be more advanced and expressive (and comfortable, with type inference), than |
| 2024-02-16 12:21:05 +0100 | <ski> | statically typed imperative languages (although they're learning and adopting some things). non-strictness, or more generally, deferred/incremental/on-demand data structures (like streams, or search trees, &c.) can be helpful |
| 2024-02-16 12:21:37 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 12:21:52 +0100 | <evocatus> | ski, could you elaborate on non-strictness? I'm not sure I completely understand what you mean here |
| 2024-02-16 12:24:25 +0100 | <ski> | evocatus : there tends to be an increased focus on "reasonability" ("predictive power"), which is how easy it is to read & reason about, refactor & modify, existing code, as opposed to "expressivity" ("cavalier power"), which is about how easy it is to express new features, in a *local* way (not requiring trickling/percolating changes into many parts of the code base). btw, side-effects tend to be used for |
| 2024-02-16 12:24:31 +0100 | <ski> | the increased expressivity (while they decrease reasonability) |
| 2024-02-16 12:24:32 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 12:25:29 +0100 | <ski> | evocatus : i wouldn't say Rust is functional, but it heavily borrows some themes from FP (e.g. pattern-matching and sum types) |
| 2024-02-16 12:25:47 +0100 | <ski> | (haven't really looked much at Kotlin .. nor Go that much, fwiw) |
| 2024-02-16 12:25:58 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 12:26:21 +0100 | <danse-nr3> | i would qualify rust as multi-paradigm, as it is not opinionated /against/ functional and partially supports it |
| 2024-02-16 12:26:53 +0100 | lortabac | (~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4) (Ping timeout: 240 seconds) |
| 2024-02-16 12:27:01 +0100 | <evocatus> | Oh, I love this point - "side-effects tend to be used for the increased expressivity while they decrease reasonability" |
| 2024-02-16 12:27:09 +0100 | willsewell | (~willsewel@185.195.232.133) |
| 2024-02-16 12:28:00 +0100 | <ski> | evocatus : dynamically typed FP tends to often have great (procedural, not declarative) debugging facilities, and commonly support for hot code live-swapping (and save and restoration of process images). Lisps tend to often also have nice support for macros, and staged programming, meta-programming |
| 2024-02-16 12:28:17 +0100 | <evocatus> | danse-nr3, I can not articulate it right now but I have a feeling there is something wrong with "partially" supporting FP. It's like going low-carb the benefits appear after certain threshold and it's a quality not quantity change |
| 2024-02-16 12:28:22 +0100 | <ski> | evocatus : apart from the increased focus |
| 2024-02-16 12:30:11 +0100 | <evocatus> | if a language supports FP I can express my ideas well and stay simple but if I use other people's code I have to read it and study and learn what I'm dealing with. If a language ENFORCES FP on the other hand I can pick any library and know it passes immutable data without even looking |
| 2024-02-16 12:30:12 +0100 | <ski> | evocatus : the increased focus on reasonability (while usually also having nice expressivity stuff, like first-class functions), can be seen as a focus on *declarative* programming in general (in addition to the existing procedural interpretation, which is still valid and important, especially for efficiency) |
| 2024-02-16 12:32:03 +0100 | willsewell | (~willsewel@185.195.232.133) (Quit: My MacBook Air has gone to sleep. ZZZzzz…) |
| 2024-02-16 12:32:12 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 12:32:32 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 12:32:50 +0100 | <ski> | Scheme, SML/NJ, Mlton has first-class continuations (a very powerful kind of effect, bit also hard to reason about) as side-effects. Scheme also has hygienic macros, which is basically "lexical scoping for macros" |
| 2024-02-16 12:33:27 +0100 | waleee | (~waleee@h-176-10-144-38.NA.cust.bahnhof.se) |
| 2024-02-16 12:33:39 +0100 | <evocatus> | We lack expressability -> we write huge verbose and intertwined programss -> we lose reasonability -> let's add better types to C++ |
| 2024-02-16 12:34:08 +0100 | rosco | (~rosco@175.136.156.77) (Quit: Lost terminal) |
| 2024-02-16 12:34:34 +0100 | <evocatus> | I value reasonability but I feel like modern mainstream obsession with types (Typescript,Rust,Go,...) is curing symptoms not the root cause. It's still down there. |
| 2024-02-16 12:34:40 +0100 | <ski> | Haskell can express various effects (including continuations), typically as monads or idioms (/ applicative functors). (or arrows ..) this can also be done, in other languages, but with less support from the language and from libraries |
| 2024-02-16 12:42:14 +0100 | sroso | (~sroso@user/SrOso) (Quit: Leaving :)) |
| 2024-02-16 12:44:11 +0100 | tabaqui | (~root@94.58.131.117) |
| 2024-02-16 12:45:53 +0100 | <probie> | evocatus: I have mixed feelings about Go. I hate the language, but on the other hand, the tooling "just works" |
| 2024-02-16 12:46:42 +0100 | <ski> | evocatus : Shriram Krishnamurthi (a Schemer, fwiw), has a nice talk about expressivity, "On the Expressive Power of Programming Languages" in 2019 at <https://www.youtube.com/watch?v=43XaZEn2aLc>, based on the (good) paper by Matthias Felleise of the same title in 1990 at <https://jgbm.github.io/eecs762f19/papers/felleisen.pdf> |
| 2024-02-16 12:47:46 +0100 | <evocatus> | probie, me too. It's my main language (unfortunately). And it works smooth for mundane plumbing problems. But the moment you need to do something on the harder side, interesting and valuable... you start to hate it. |
| 2024-02-16 12:48:13 +0100 | <evocatus> | ski, thanks, I will watch it |
| 2024-02-16 12:48:49 +0100 | <ski> | anyway, imho, people don't (explicitly) talk and think enough about reasonability |
| 2024-02-16 12:50:26 +0100 | <ski> | evocatus : the following paper talks about non-strictness for modularity (and other stuff) |
| 2024-02-16 12:50:29 +0100 | <ski> | @where whyfp |
| 2024-02-16 12:50:30 +0100 | <lambdabot> | "Why Functional Programming Matters" by John Hughes in 1984 at <http://www.cse.chalmers.se/~rjmh/Papers/whyfp.html> |
| 2024-02-16 12:52:06 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 12:53:10 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 12:53:31 +0100 | <danse-nr3> | oh nice i will add it to my list. Always needing reasons to justify non-strictness to people ... |
| 2024-02-16 12:53:33 +0100 | alexherbo2 | (~alexherbo@2a02-8440-3140-beaa-f9e3-2ee2-b871-8703.rev.sfr.net) |
| 2024-02-16 12:54:12 +0100 | <ncf> | ask them to justify strictness instead |
| 2024-02-16 12:55:01 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) (Ping timeout: 264 seconds) |
| 2024-02-16 12:57:35 +0100 | <ski> | you could also check out "Can Programming Be Liberated From the von Neumann Style?" (originally a Turing Award lecture) by John Backus in 1977 at <https://cs.wellesley.edu/~cs251/s19/notes/backus-turing-lecture.pdf>. perhaps also "The Next 700 Programming Languages" by Peter J. Landin in 1965-07 at <https://www.st.cs.uni-saarland.de/edu/seminare/2005/advanced-fp/docs/sweeny.pdf> |
| 2024-02-16 12:57:57 +0100 | <ski> | er, sorry, that last link should be <https://www.cs.cmu.edu/~crary/819-f09/Landin66.pdf> |
| 2024-02-16 12:58:15 +0100 | lortabac | (~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4) |
| 2024-02-16 12:58:38 +0100 | <danse-nr3> | well strictness does not leak |
| 2024-02-16 12:59:05 +0100 | <danse-nr3> | "too hard for my brain" is quite a strong point nowadays |
| 2024-02-16 12:59:21 +0100 | <danse-nr3> | thanks for the other link by the way, sounds great |
| 2024-02-16 13:00:20 +0100 | <danse-nr3> | that is actually "too hard for how cheap i expect engineers to be", but nevermind |
| 2024-02-16 13:00:44 +0100 | <ski> | i was going to say that "The Next Mainstream Programming Languages : A Game Developers's Perspective" (slides) by Tim Sweeney (of Unreal Engine, Epic Games) in 2005 at <https://www.st.cs.uni-saarland.de/edu/seminare/2005/advanced-fp/docs/sweeny.pdf> |
| 2024-02-16 13:01:22 +0100 | <ski> | can possibly also be interesting, as it talks quite a bit about some aspects of FP |
| 2024-02-16 13:01:59 +0100 | <danse-nr3> | title is not appealing though. At least to me, mainstream and quality have diverged long ago |
| 2024-02-16 13:02:04 +0100 | <ski> | evocatus : "could you elaborate on non-strictness? I'm not sure I completely understand what you mean here" -- about what is meant by non-strictness, or about how it can help with composability and modularity ? |
| 2024-02-16 13:03:59 +0100 | <ski> | oh, i perhaps also should've noted that STM (Software Transactional Memory) is greatly helped with absence of side-effects |
| 2024-02-16 13:05:36 +0100 | <evocatus> | ski, about what is meant by non-strictness |
| 2024-02-16 13:06:24 +0100 | <haskellbridge> | <irregularsphere> "too hard for my brain" - statements made up by the utterly deranged |
| 2024-02-16 13:06:26 +0100 | <ski> | .. i've heard people in here say that they prefer Haskell over (say) Python, because they're not smart enough to deal with the latter (all the pervasive side-effects, the often lax attitude to API design, consistency, error reporting, ..) |
| 2024-02-16 13:07:10 +0100 | <danse-nr3> | it's good irony, i should adopt that |
| 2024-02-16 13:08:19 +0100 | <int-e> | @quote variables |
| 2024-02-16 13:08:19 +0100 | <lambdabot> | astrolabe says: calling variables things like ll,kk,tt and dd is a bit cryptic |
| 2024-02-16 13:08:28 +0100 | <int-e> | @quote no.variables |
| 2024-02-16 13:08:29 +0100 | <lambdabot> | cjs says: I have to explain this shit to people. I mean, I start out right, "Hey, you know how you always have these bugs because what you thought was in the variable is not there?" And I get all of |
| 2024-02-16 13:08:29 +0100 | <lambdabot> | these nods of agreement. "Well, I've found a new language that solves that problem." Audience: "Ooooh! How?" Me: "There's no variables!" And then they all start moving away from me slowly.... |
| 2024-02-16 13:08:36 +0100 | <ski> | evocatus : strictness means that in order to determine the answer/result of a function call, you need to determine the result of the actual parameters (the argument expressions). so, if a parameter has no answer (non-termination / infinite looping, or exception, say), then the function call also will have no answer. with non-strictness, you can have a call have an answer, even is an actual parameter in the |
| 2024-02-16 13:08:42 +0100 | <ski> | call doesn't |
| 2024-02-16 13:08:52 +0100 | <haskellbridge> | <irregularsphere> to be fair in favor of the c and rust folk i do think haskell makes it a bit hard to manage your memory |
| 2024-02-16 13:09:26 +0100 | <danse-nr3> | a think they do know what strictness is |
| 2024-02-16 13:09:28 +0100 | <evocatus> | ski, thanks, now I got it |
| 2024-02-16 13:09:36 +0100 | <danse-nr3> | ops maybe not |
| 2024-02-16 13:09:51 +0100 | <danse-nr3> | actually now they do XD |
| 2024-02-16 13:09:54 +0100 | <haskellbridge> | <irregularsphere> ...i wonder if a lambda calculus chip exists |
| 2024-02-16 13:10:07 +0100 | <haskellbridge> | <irregularsphere> (chip that does lambda calculus) |
| 2024-02-16 13:10:25 +0100 | <danse-nr3> | there is a person at #lambdacalculus that once in a while writes a lot about advancements in that area |
| 2024-02-16 13:10:52 +0100 | <ski> | evocatus : strictness and non-strictness are terms in denotational semantics, which talks about "what is the answer", not "how is the answer determined". when we get down to lower levels of implementation (operational/procedural semantics), we can say that call-by-value gives strictness, and call-by-name (passing the argument expression to the operation, letting it decide if, and when, to evaluate it) gives |
| 2024-02-16 13:10:58 +0100 | <ski> | non-strictness. call-by-need (aka laziness) is an optimization on call-by-name, to cache the computed result, so as to not recompute it |
| 2024-02-16 13:12:35 +0100 | <danse-nr3> | sometimes i get to wonder whether call-by-value could be modeled like pull-driven reactive programming |
| 2024-02-16 13:13:09 +0100 | <ski> | Haskell is a non-strict language, but doesn't specify how this to be achieved. it is allowed to e.g. speculatively evaluate other expressions in parallel, if there's available cores or threads, if the system thinks they might be needed later, as long as the behaviour (seen from within the language) (apart from efficiency concerns, per tradition) is indistinguishable from not doing that. typically, |
| 2024-02-16 13:13:15 +0100 | <ski> | non-strictness is implemented in terms of laziness / by-need, though |
| 2024-02-16 13:14:09 +0100 | <danse-nr3> | interesting, i can use call-by-name as a simpler synonym for non-strictness then |
| 2024-02-16 13:14:19 +0100 | <ski> | @quote refreshing.desert |
| 2024-02-16 13:14:19 +0100 | <lambdabot> | chromatic says: My productivity increased when Autrijus told me about Haskell's trace function. He called it a refreshing desert in the oasis of referential transparency. |
| 2024-02-16 13:14:36 +0100 | <evocatus> | I'm familiar with non-strictness in Clojure. It has lazy collections and transducers |
| 2024-02-16 13:14:48 +0100 | <danse-nr3> | meh tracing ... leads to bad code |
| 2024-02-16 13:15:28 +0100 | mmhat | (~mmh@p200300f1c70685c4ee086bfffe095315.dip0.t-ipconnect.de) |
| 2024-02-16 13:15:32 +0100 | <ski> | danse-nr3 : by-name is at the level of operational semantics (the "how", the steps of computation). non-strictness is at the level of denotational semantics (the "what", the end result/answer) |
| 2024-02-16 13:16:12 +0100 | <danse-nr3> | yeah but the two "levels" seem to meet on the same concept there |
| 2024-02-16 13:18:22 +0100 | gaff | (~gaff@49.207.213.246) |
| 2024-02-16 13:19:42 +0100 | jtza8 | (~user@165.255.63.11) |
| 2024-02-16 13:19:42 +0100 | jtza8 | (~user@165.255.63.11) (Changing host) |
| 2024-02-16 13:19:42 +0100 | jtza8 | (~user@user/jtza8) |
| 2024-02-16 13:20:56 +0100 | <ski> | the former is the common way to achieve the latter, yea |
| 2024-02-16 13:21:11 +0100 | Lycurgus | (~georg@user/Lycurgus) (Quit: leaving) |
| 2024-02-16 13:21:32 +0100 | <ski> | (although, iirc, Algol 68 (?) had by-name (as well as by-value, and by-reference) parameters, but no by-need) |
| 2024-02-16 13:21:42 +0100 | <gaff> | (map map) :: [a -> b] -> [[a] -> [b]]. Is there an example usage for this type? |
| 2024-02-16 13:22:24 +0100 | <ski> | `map . map' would be more common, i'd think |
| 2024-02-16 13:22:35 +0100 | <ski> | @type map . map |
| 2024-02-16 13:22:36 +0100 | <lambdabot> | (a -> b) -> [[a]] -> [[b]] |
| 2024-02-16 13:22:39 +0100 | <jackdk> | see also: `foldMap . foldMap`, `traverse . traverse` |
| 2024-02-16 13:22:58 +0100 | tabaqui | (~root@94.58.131.117) (Ping timeout: 255 seconds) |
| 2024-02-16 13:23:03 +0100 | <haskellbridge> | <irregularsphere> ski: by the way, i once had ghci softlock for a while (calculating something) so i checked htop and apparently it maxes out on one core, though changing (probably linux's scheduler) |
| 2024-02-16 13:23:10 +0100 | <haskellbridge> | <irregularsphere> might check threads later |
| 2024-02-16 13:23:21 +0100 | <gaff> | ski: yes. map . map makes sense and poses no problems at all. |
| 2024-02-16 13:23:29 +0100 | tabaqui | (~root@94.58.131.117) |
| 2024-02-16 13:23:33 +0100 | <danse-nr3> | :t fmap fmap |
| 2024-02-16 13:23:34 +0100 | <lambdabot> | (Functor f1, Functor f2) => f1 (a -> b) -> f1 (f2 a -> f2 b) |
| 2024-02-16 13:23:43 +0100 | <ski> | @type foldl . foldl |
| 2024-02-16 13:23:44 +0100 | <lambdabot> | (Foldable t1, Foldable t2) => (b -> a -> b) -> b -> t1 (t2 a) -> b |
| 2024-02-16 13:23:46 +0100 | <ski> | @type flip . foldr . flip . foldr |
| 2024-02-16 13:23:47 +0100 | <lambdabot> | (Foldable t1, Foldable t2) => (a -> c -> c) -> t1 (t2 a) -> c -> c |
| 2024-02-16 13:24:41 +0100 | <haskellbridge> | <irregularsphere> danse-nr3: I haven't written any production (or, any project in) Haskell, but I guess `trace` is akin to printf debugging? |
| 2024-02-16 13:25:26 +0100 | <haskellbridge> | <irregularsphere> Not that it should be included in the final code :P |
| 2024-02-16 13:25:35 +0100 | yoo | (~yo0O0o@104.28.226.105) |
| 2024-02-16 13:26:03 +0100 | <ski> | (which is why OCaml `foldr' takes arguments in a different order) |
| 2024-02-16 13:26:26 +0100 | <ski> | yes, irregularsphere |
| 2024-02-16 13:26:37 +0100 | <danse-nr3> | tracing is quite a common practice in many languages. It works like `print` but does not need to be in IO. Even if you remove it, the code written by troubleshooting with traces stays troublesome |
| 2024-02-16 13:26:42 +0100 | <gaff> | I couldn't come up with a simple example of (map map) usage, though. map map [(+1), (*2), (^2)] :: Num b => [[b] -> [b]] |
| 2024-02-16 13:26:56 +0100 | <ski> | gaff : `[a -> b] -> a -> [b]' is probably more common that your `map map' |
| 2024-02-16 13:26:59 +0100 | <int-e> | > zipWith ($) (map map [(+1),(+2)]) [[1,2],[2,1]] |
| 2024-02-16 13:27:00 +0100 | <lambdabot> | [[2,3],[4,3]] |
| 2024-02-16 13:27:15 +0100 | petrichor | (~znc-user@user/petrichor) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2024-02-16 13:27:53 +0100 | <int-e> | :t \fs xs -> do f <- fs; map f xs |
| 2024-02-16 13:27:54 +0100 | <lambdabot> | [a -> b] -> [a] -> [b] |
| 2024-02-16 13:27:55 +0100 | <haskellbridge> | <irregularsphere> danse-nr3: huh, never knew that |
| 2024-02-16 13:28:04 +0100 | <int-e> | :t \fs xs -> do f <- map map fs; f xs |
| 2024-02-16 13:28:05 +0100 | <lambdabot> | [a -> b] -> [a] -> [b] |
| 2024-02-16 13:28:06 +0100 | <haskellbridge> | <irregularsphere> also yeah i knew it wasn't in io anyway, `unsafePerformIO :: IO a -> a` |
| 2024-02-16 13:28:14 +0100 | <int-e> | :t \fs xs -> do f <- map <$> fs; f xs |
| 2024-02-16 13:28:15 +0100 | <lambdabot> | [a -> b] -> [a] -> [b] |
| 2024-02-16 13:28:16 +0100 | <gaff> | int-e: thnaks. clever solution! that works indeed! |
| 2024-02-16 13:28:58 +0100 | petrichor | (~znc-user@user/petrichor) |
| 2024-02-16 13:29:06 +0100 | <int-e> | (map <$> fs in the list monad is something that might actually come up in refactoring. It won't be *common*. But it feels less artificial than that zipWith thing) |
| 2024-02-16 13:29:13 +0100 | gentauro | (~gentauro@user/gentauro) (Read error: Connection reset by peer) |
| 2024-02-16 13:29:19 +0100 | <haskellbridge> | <irregularsphere> Isn't `[a -> b] -> [a] -> [b]` already `<*>`? |
| 2024-02-16 13:29:37 +0100 | <haskellbridge> | <irregularsphere> since `[]` is an `Applicative` |
| 2024-02-16 13:29:51 +0100 | <gaff> | int-e: I see. |
| 2024-02-16 13:30:58 +0100 | <jtza8> | If Haskell 98 arrays don't need to be defined for each index, is there a simple way to get something like a list of elements in a range of indexes? |
| 2024-02-16 13:31:21 +0100 | <jtza8> | (Just wondering how that works out practically.) |
| 2024-02-16 13:31:22 +0100 | <haskellbridge> | <irregularsphere> gaff: `fs <*> xs` :) |
| 2024-02-16 13:31:35 +0100 | <ski> | > range (-3,3) |
| 2024-02-16 13:31:37 +0100 | <lambdabot> | [-3,-2,-1,0,1,2,3] |
| 2024-02-16 13:31:44 +0100 | <ski> | > range ((0,0),(1,3)) |
| 2024-02-16 13:31:45 +0100 | <lambdabot> | [(0,0),(0,1),(0,2),(0,3),(1,0),(1,1),(1,2),(1,3)] |
| 2024-02-16 13:31:58 +0100 | <ski> | @type inRange |
| 2024-02-16 13:31:59 +0100 | <lambdabot> | Ix a => (a, a) -> a -> Bool |
| 2024-02-16 13:32:05 +0100 | <jtza8> | Ah |
| 2024-02-16 13:32:07 +0100 | <jtza8> | Thanks |
| 2024-02-16 13:32:09 +0100 | <haskellbridge> | <irregularsphere> There's a class `Ix`. |
| 2024-02-16 13:33:07 +0100 | <gaff> | haskellbridge: sure. |
| 2024-02-16 13:33:23 +0100 | <ski> | @let tabulate :: Ix i => (i,i) -> (i -> e) -> Array i e; tabulate ix f = listArray ix [f i | i <- range ix] |
| 2024-02-16 13:33:24 +0100 | <lambdabot> | Defined. |
| 2024-02-16 13:33:56 +0100 | <ski> | > tabulate ((0,0),(1,3)) (uncurry (+)) |
| 2024-02-16 13:33:58 +0100 | <lambdabot> | error: |
| 2024-02-16 13:33:58 +0100 | <lambdabot> | Ambiguous occurrence ‘tabulate’ |
| 2024-02-16 13:33:58 +0100 | <lambdabot> | It could refer to |
| 2024-02-16 13:34:02 +0100 | <ski> | > L.tabulate ((0,0),(1,3)) (uncurry (+)) |
| 2024-02-16 13:34:03 +0100 | <lambdabot> | array ((0,0),(1,3)) [((0,0),0),((0,1),1),((0,2),2),((0,3),3),((1,0),1),((1,1... |
| 2024-02-16 13:34:32 +0100 | gaff | (~gaff@49.207.213.246) () |
| 2024-02-16 13:35:22 +0100 | gentauro | (~gentauro@user/gentauro) |
| 2024-02-16 13:35:29 +0100 | <ski> | @let memoArr :: Ix i => (i,i) -> (i -> e) -> (i -> e); memoArr ix f = (L.tabulate ix f !) |
| 2024-02-16 13:35:30 +0100 | <lambdabot> | Defined. |
| 2024-02-16 13:36:07 +0100 | <haskellbridge> | <irregularsphere> You can enforce strictness without `let`? |
| 2024-02-16 13:36:28 +0100 | <ski> | > let (memoArr (0,12) -> fib12) = \case 0 -> 0; 1 -> 1; n -> fib12 (n-2) + fib12 (n-1) in fib12 12 |
| 2024-02-16 13:36:30 +0100 | <lambdabot> | 144 |
| 2024-02-16 13:36:39 +0100 | <ski> | @type seq |
| 2024-02-16 13:36:40 +0100 | <lambdabot> | a -> b -> b |
| 2024-02-16 13:36:43 +0100 | <ski> | @type ($!) |
| 2024-02-16 13:36:44 +0100 | <lambdabot> | (a -> b) -> a -> b |
| 2024-02-16 13:36:53 +0100 | <ski> | @src ($!) |
| 2024-02-16 13:36:53 +0100 | <lambdabot> | f $! x = x `seq` f x |
| 2024-02-16 13:37:05 +0100 | <ski> | @src foldl' |
| 2024-02-16 13:37:06 +0100 | <lambdabot> | foldl' f a [] = a |
| 2024-02-16 13:37:06 +0100 | <lambdabot> | foldl' f a (x:xs) = let a' = f a x in a' `seq` foldl' f a' xs |
| 2024-02-16 13:37:14 +0100 | <ski> | last equation can also be written as |
| 2024-02-16 13:37:23 +0100 | <haskellbridge> | <irregularsphere> Nevermind, `!`'s for array indexing. |
| 2024-02-16 13:37:44 +0100 | <ski> | foldl' f a (x:xs) = (foldl' f $! f a x) xs |
| 2024-02-16 13:38:17 +0100 | <ski> | or, using `BangPatterns', as |
| 2024-02-16 13:38:32 +0100 | <ski> | foldl' f !a (x:xs) = foldl' f (f a x) xs |
| 2024-02-16 13:40:34 +0100 | <ski> | (that's not *quite* the same, since this one will enforce `a', not `f a x'. but on the next recursive call, the actual parameter will be specified as demanded anyway) |
| 2024-02-16 13:41:19 +0100 | <ski> | irregularsphere : `BangPatterns' uses `!' notation, in patterns, for strictness. there's also already a `!' notation in `data' types |
| 2024-02-16 13:41:58 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 13:42:56 +0100 | <ski> | (btw, the `fib12' example shows how you can memoize (iow do top-down dynamic programming), using an array (immutable, furthermore) as intermediate cache, while keeping the notation rather close to the original implementation that doesn't mention arrays) |
| 2024-02-16 13:43:06 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 13:44:00 +0100 | <jtza8> | The demonstration was useful, thanks. I still have lots to learn. :) |
| 2024-02-16 13:44:29 +0100 | <haskellbridge> | <irregularsphere> I'm amazed. Thanks, ski. |
| 2024-02-16 13:44:39 +0100 | alexherbo2 | (~alexherbo@2a02-8440-3140-beaa-f9e3-2ee2-b871-8703.rev.sfr.net) (Remote host closed the connection) |
| 2024-02-16 13:45:25 +0100 | alexherbo2 | (~alexherbo@63.150.22.93.rev.sfr.net) |
| 2024-02-16 13:46:37 +0100 | <haskellbridge> | <irregularsphere> Wait, isn't there already a memoization method that's high-level? |
| 2024-02-16 13:46:42 +0100 | tabaqui | (~root@94.58.131.117) (Ping timeout: 268 seconds) |
| 2024-02-16 13:46:42 +0100 | <haskellbridge> | <irregularsphere> https://wiki.haskell.org/Memoization |
| 2024-02-16 13:46:44 +0100 | <ski> | (oh, and it's also using `ViewPatterns', in a way that's probably not intended, to avoid naming the intermediate array. you could alternatively e.g. use `memoFix :: Ix i => (i,i) -> ((i -> e) -> (i -> e)) -> (i -> e); memoFix ix ff = f where f = ff (tabulate ix f !)', together with `fib12 = memoFix (0,12) $ \fib -> \case 0 -> 0; 1 -> 1; n -> fib (n-2) + fib (n-1)') |
| 2024-02-16 13:47:19 +0100 | <ski> | (oh, and i'm using `LambdaCase', just for convenience. and with `BlockArguments', you could omit the `$ ') |
| 2024-02-16 13:49:12 +0100 | tabaqui | (~root@94.58.131.117) |
| 2024-02-16 13:49:45 +0100 | <ski> | irregularsphere : one can memoize using different internal data structures for the caching. i used arrays above. one can even use infinite data structures as a cache (although do keep an eye out for space leaks) |
| 2024-02-16 13:50:43 +0100 | <haskellbridge> | <irregularsphere> Ah, so your example is for controlling the data structure used for memoization. |
| 2024-02-16 13:51:25 +0100 | <haskellbridge> | <irregularsphere> I wonder if recursive monadic operations are a good fit for memoization. |
| 2024-02-16 13:51:31 +0100 | <ski> | it's for showcasing a simple example of using (immutable) arrays for memoizing, doing top-down dynamic programming, while keeping the notation relatively lightweight |
| 2024-02-16 13:51:43 +0100 | <haskellbridge> | <irregularsphere> I see. |
| 2024-02-16 13:52:16 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 246 seconds) |
| 2024-02-16 13:53:45 +0100 | euleritian | (~euleritia@dynamic-046-114-090-105.46.114.pool.telefonica.de) |
| 2024-02-16 13:54:03 +0100 | <ski> | if you want to, you could try to do inexact matching of a "pattern" string into a (typically longer) text, where you add one to a cost if you match by removing a character of the pattern, or add one, or replace one, in order to make it match the text. you can solve this, using a two-dimensional immutable array (indexed by pairs of positions in the pattern and in the text), with the method sketched above |
| 2024-02-16 13:55:53 +0100 | <ski> | each element of the array, except at the left and top fringes, will be defined by looking at the element to the left, the element above, and the element above to the left, comparing their costs to select which one you use. you find matches by checking the edge that corresponds to the last position in the pattern |
| 2024-02-16 13:56:34 +0100 | <ski> | well, for monadic memoization, i suppose you do want an idempotent monad, at least |
| 2024-02-16 13:57:16 +0100 | danse-nr3 | (~danse@151.19.232.78) (Read error: Connection reset by peer) |
| 2024-02-16 14:00:41 +0100 | <haskellbridge> | <irregularsphere> what's an idempotent monad, m(m(x)) isomorphic to m(x)? |
| 2024-02-16 14:00:50 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) |
| 2024-02-16 14:01:09 +0100 | <sshine> | what's an irregular sphere? |
| 2024-02-16 14:01:33 +0100 | <haskellbridge> | <irregularsphere> nonexistent conception |
| 2024-02-16 14:07:29 +0100 | <ski> | irregularsphere : here, i mean a monad, for which `liftM2 (,) act act = fmap (\x -> (x,x)) act' -- running `act' two times (together) has the same effect as running it once (and duplicating the result instead) |
| 2024-02-16 14:08:16 +0100 | <ski> | (btw, you could replace `liftM2' by `liftA2', making this applicable to all idioms (/ applicative functors)) |
| 2024-02-16 14:10:38 +0100 | <ncf> | this should be equivalent to join being an isomorphism |
| 2024-02-16 14:10:41 +0100 | <ski> | i suppose you probably also want it to be commutative, `liftA2 (flip (,)) act0 act1 = liftA2 (,) act1 act1' (or `liftA2 . flip = flip . liftA2') ?? |
| 2024-02-16 14:11:38 +0100 | earthy | (~arthurvl@2a02-a469-f5e2-1-83d2-ca43-57a2-dc81.fixed6.kpn.net) (Quit: WeeChat 3.0) |
| 2024-02-16 14:11:40 +0100 | <ski> | (since the action that is cached wouldn't otherwise necessarily just have been repeated multiple times in a row, with no other effects intervening) |
| 2024-02-16 14:12:09 +0100 | <ski> | elaborate, ncf ? |
| 2024-02-16 14:12:40 +0100 | <ncf> | https://ncatlab.org/nlab/show/idempotent+monad |
| 2024-02-16 14:13:13 +0100 | <haskellbridge> | <irregularsphere> ncf: ah, thanks |
| 2024-02-16 14:13:49 +0100 | <ski> | yea, i'm wondering whether that notion coincides with the above one, ncf |
| 2024-02-16 14:14:02 +0100 | <haskellbridge> | <irregularsphere> provable though |
| 2024-02-16 14:14:09 +0100 | <ncf> | (for strong monads, at least) |
| 2024-02-16 14:14:14 +0100 | ski | nods |
| 2024-02-16 14:14:26 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) |
| 2024-02-16 14:14:42 +0100 | <haskellbridge> | <irregularsphere> isn't every haskell monad following monadic rules strong monads |
| 2024-02-16 14:14:49 +0100 | <haskellbridge> | <irregularsphere> or at least that's as far as i can think of |
| 2024-02-16 14:14:53 +0100 | <ncf> | hm, and idempotent strong monads are supposed to be automatically commutative (https://ncatlab.org/nlab/show/idempotent+monad#idempotent_strong_monads_are_commutative) |
| 2024-02-16 14:15:10 +0100 | <ncf> | irregularsphere: yes, all haskell monads are strong/monoidal monads |
| 2024-02-16 14:15:12 +0100 | <ski> | oh, interesting |
| 2024-02-16 14:15:21 +0100 | <haskellbridge> | <irregularsphere> oh my god what is that commutative diagram |
| 2024-02-16 14:15:28 +0100 | <ncf> | er not monoidal |
| 2024-02-16 14:15:59 +0100 | <haskellbridge> | <irregularsphere> *shakes in fear |
| 2024-02-16 14:16:43 +0100 | xff0x | (~xff0x@ai082039.d.east.v6connect.net) |
| 2024-02-16 14:16:58 +0100 | tabaqui | (~root@94.58.131.117) (Ping timeout: 255 seconds) |
| 2024-02-16 14:17:17 +0100 | arthurvl | (~arthurvl@2a02-a469-f5e2-1-83d2-ca43-57a2-dc81.fixed6.kpn.net) |
| 2024-02-16 14:17:20 +0100 | <ski> | (i guess you could more succinctly reformulate the first condition above, as `join . liftA2 = fmap . join', where `join' is the `W' combinator (`W f x = f x x'), being `join' in the environment monad `(rho ->)') |
| 2024-02-16 14:18:14 +0100 | <haskellbridge> | <irregularsphere> what |
| 2024-02-16 14:18:15 +0100 | arthurvl | earthy |
| 2024-02-16 14:19:03 +0100 | tabaqui | (~root@87.201.186.71) |
| 2024-02-16 14:19:27 +0100 | <ski> | hm ? |
| 2024-02-16 14:21:48 +0100 | <ski> | (it doesn't matter if you replace `(,)' above with an arbitrary function `f') |
| 2024-02-16 14:23:09 +0100 | danse-nr3 | (~danse@ge-19-115-6.service.infuturo.it) |
| 2024-02-16 14:23:14 +0100 | rosco | (~rosco@175.136.156.77) |
| 2024-02-16 14:25:39 +0100 | fr33domlover3 | (~fr33domlo@towards.vision) |
| 2024-02-16 14:25:44 +0100 | yoo | (~yo0O0o@104.28.226.105) (Changing host) |
| 2024-02-16 14:25:45 +0100 | yoo | (~yo0O0o@user/mobivme) |
| 2024-02-16 14:26:15 +0100 | jbalint_ | (~jbalint@2600-6c44-117f-e98a-816a-9488-0fb1-07b7.inf6.spectrum.com) (Remote host closed the connection) |
| 2024-02-16 14:26:25 +0100 | jbalint | (~jbalint@071-090-119-177.res.spectrum.com) |
| 2024-02-16 14:26:28 +0100 | <haskellbridge> | <irregularsphere> I'm... already fine with ncf's explanation being `join` is an isomorphism. |
| 2024-02-16 14:26:34 +0100 | kaskal | (~kaskal@213-147-167-18.nat.highway.webapn.at) |
| 2024-02-16 14:26:36 +0100 | <haskellbridge> | <irregularsphere> Thanks, though! |
| 2024-02-16 14:26:46 +0100 | Angelz | (Angelz@2605:6400:30:fc15:9bd1:2217:41cd:bb15) (Ping timeout: 256 seconds) |
| 2024-02-16 14:27:17 +0100 | kaskal- | (~kaskal@2001:4bb8:2c3:39c1:ff3f:d58:4fd9:e10c) (Ping timeout: 256 seconds) |
| 2024-02-16 14:27:20 +0100 | fr33domlover | (~fr33domlo@towards.vision) (Ping timeout: 256 seconds) |
| 2024-02-16 14:27:20 +0100 | fr33domlover3 | fr33domlover |
| 2024-02-16 14:27:47 +0100 | pastly | (~pastly@gateway/tor-sasl/pastly) (Ping timeout: 255 seconds) |
| 2024-02-16 14:28:05 +0100 | pretty_dumm_guy | (trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Ping timeout: 252 seconds) |
| 2024-02-16 14:28:11 +0100 | danse-nr3 | (~danse@ge-19-115-6.service.infuturo.it) (Ping timeout: 264 seconds) |
| 2024-02-16 14:28:11 +0100 | Maxdamantus | (~Maxdamant@user/maxdamantus) (Ping timeout: 264 seconds) |
| 2024-02-16 14:28:23 +0100 | danse-nr3 | (~danse@ge-19-115-6.service.infuturo.it) |
| 2024-02-16 14:28:39 +0100 | Maxdamantus | (~Maxdamant@user/maxdamantus) |
| 2024-02-16 14:29:01 +0100 | pastly | (~pastly@gateway/tor-sasl/pastly) |
| 2024-02-16 14:29:02 +0100 | CiaoSen | (~Jura@2a05:5800:2c6:8e00:e6b9:7aff:fe80:3d03) |
| 2024-02-16 14:29:05 +0100 | <haskellbridge> | <irregularsphere> ski: "what" as in "are these definitions necessarily equivalent" |
| 2024-02-16 14:29:12 +0100 | <haskellbridge> | <irregularsphere> equivalent at all* |
| 2024-02-16 14:29:25 +0100 | pastly | (~pastly@gateway/tor-sasl/pastly) (Remote host closed the connection) |
| 2024-02-16 14:29:52 +0100 | <haskellbridge> | <irregularsphere> goddamnit i'm bridged over irc, can't even edit my messages without annoying people |
| 2024-02-16 14:30:06 +0100 | pastly | (~pastly@gateway/tor-sasl/pastly) |
| 2024-02-16 14:30:45 +0100 | shapr | (~user@c-24-218-186-89.hsd1.ma.comcast.net) |
| 2024-02-16 14:30:47 +0100 | <ski> | irregularsphere : "<ski> yea, i'm wondering whether that notion coincides with the above one, ncf" |
| 2024-02-16 14:31:30 +0100 | jtza8 | (~user@user/jtza8) (ERC 5.4 (IRC client for GNU Emacs 28.2)) |
| 2024-02-16 14:31:43 +0100 | <haskellbridge> | <irregularsphere> no i mean your `join . liftA2 = fmap . join` |
| 2024-02-16 14:32:16 +0100 | <haskellbridge> | <irregularsphere> also, `(->) a` is called an environment monad? |
| 2024-02-16 14:34:14 +0100 | dostoyevsky2 | (~sck@user/dostoyevsky2) (Quit: leaving) |
| 2024-02-16 14:34:28 +0100 | dostoyevsky2 | (~sck@user/dostoyevsky2) |
| 2024-02-16 14:36:49 +0100 | YuutaW | (~YuutaW@mail.yuuta.moe) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2024-02-16 14:37:15 +0100 | YuutaW | (~YuutaW@mail.yuuta.moe) |
| 2024-02-16 14:37:37 +0100 | <haskellbridge> | <irregularsphere> ski: oh, yeah, that |
| 2024-02-16 14:38:02 +0100 | <ski> | irregularsphere : "environment", "input", or "reader" (i've also seen "function", but i don't really like that term). in math, it's often expressed as "pointwise" (e.g. making the linear transformations from a linear/vector space `V' to the scalars `K' (say real numbers) themselves form a vector space, by defining `(f + g) v = f v + g v' and `(k * f) v = k * f v') |
| 2024-02-16 14:40:42 +0100 | <ski> | similarly, "logging"/"summarizing", "output", and "writer" is the same thing. (in math, you can compare with say <https://en.wikipedia.org/wiki/Monoid_ring>, which is like a nondeterministic (due to rings having sums) version) |
| 2024-02-16 14:41:13 +0100 | <ski> | (other possible names for "environment" could be "context" or "configuration") |
| 2024-02-16 14:41:24 +0100 | <haskellbridge> | <irregularsphere> oh it's just another term |
| 2024-02-16 14:41:35 +0100 | destituion | (~destituio@85.221.111.174) (Ping timeout: 268 seconds) |
| 2024-02-16 14:41:47 +0100 | <haskellbridge> | <irregularsphere> ski: i'd better call them by `(->) a` anyway |
| 2024-02-16 14:42:06 +0100 | ski | would probably say `(a ->)' there |
| 2024-02-16 14:42:12 +0100 | Maxdamantus | (~Maxdamant@user/maxdamantus) (Ping timeout: 268 seconds) |
| 2024-02-16 14:42:31 +0100 | Maxdamantus | (~Maxdamant@user/maxdamantus) |
| 2024-02-16 14:42:57 +0100 | <haskellbridge> | <irregularsphere> is this mud of synonyms just to make beginners feel better |
| 2024-02-16 14:43:42 +0100 | <ski> | irregularsphere : anyway, from `join . liftA2 = fmap . join' you get `join (liftA2 (,)) act = fmap (join (,)) act', which becomes `liftA2 (,) act act = fmap (\x -> (x,x)) act' |
| 2024-02-16 14:43:54 +0100 | <haskellbridge> | <irregularsphere> right |
| 2024-02-16 14:48:02 +0100 | <ski> | in the other direction, start from `liftA2 (,) act act = fmap (\x -> (x,x)) act', and (by mapping `uncurry f') get to `fmap (uncurry f) (liftA2 (,) act act) = fmap (uncurry f) (fmap (\x -> (x,x)) act', which is `liftA2 ((uncurry f .) . (,)) act act = fmap (uncurry f . \x -> (x,x)) act', which is `liftA2 f act act = fmap (\x -> f x x) act', which is `join (liftA2 f) act = fmap (join f) act'. this holds for |
| 2024-02-16 14:48:08 +0100 | <ski> | every `act', so by extensionality, `join (liftA2 f) = fmap (join f)' which is `(join . liftA2) f = (fmap . join) f', and extensionality (on `f') again gives `join . liftA2 = fmap . join' |
| 2024-02-16 14:49:35 +0100 | <haskellbridge> | <irregularsphere> is this equivalent to `join` being an isomorphism though |
| 2024-02-16 14:50:42 +0100 | <ski> | irregularsphere : i typically just use the terms "environment"/"input", resp. "summarizing"/"output". "context" and "configuration" would be to further suggest how to think about environment, that it's about propagating/distributing some information "down" a computation (possibly with local override, just like in a process tree, each process will inherit environment variables from its parent, but may |
| 2024-02-16 14:50:48 +0100 | <ski> | override when spawning child processes) |
| 2024-02-16 14:52:39 +0100 | pretty_dumm_guy | (trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) |
| 2024-02-16 14:56:08 +0100 | califax | (~califax@user/califx) (Ping timeout: 255 seconds) |
| 2024-02-16 14:57:58 +0100 | <ski> | irregularsphere : i'm not sure if it's an equivalent notion, that's why i asked about that. the notion at that ncatlab page is about having `T . T = T', monads `T' such that composition is idempotent on them (iow `join (.) T = T'). while the notion i was talking about was that for an idiom (aka applicative functor) `I', whether `(<^>) : I A * I B >---> I (A * B)' (being `liftA2 (,)') is "idempotent" in the |
| 2024-02-16 14:58:04 +0100 | <ski> | sense that `(<^>) . dup = dup . (<^>)' (duplicating the output on the other side, not just the input on the first side), where `dup : A >---> A * A' (being `join (,)') |
| 2024-02-16 14:59:27 +0100 | <ski> | perhaps there's an equivalence here, but i don't really see it, as the two notions start by focusing on different things being "idempotent" ("doing something twice is the same as doing it once") |
| 2024-02-16 14:59:48 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 15:00:14 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-02-16 15:03:17 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 15:03:40 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 15:04:49 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Ping timeout: 260 seconds) |
| 2024-02-16 15:07:34 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 15:07:52 +0100 | ell | (~ellie@user/ellie) (Quit: Ping timeout (120 seconds)) |
| 2024-02-16 15:08:12 +0100 | ell | (~ellie@user/ellie) |
| 2024-02-16 15:10:31 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 15:12:24 +0100 | a51 | (a51@gateway/vpn/protonvpn/a51) |
| 2024-02-16 15:14:16 +0100 | thegeekinside | (~thegeekin@189.217.83.221) |
| 2024-02-16 15:20:20 +0100 | dsrt^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Ping timeout: 252 seconds) |
| 2024-02-16 15:20:58 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-02-16 15:21:40 +0100 | danse-nr3 | (~danse@ge-19-115-6.service.infuturo.it) (Ping timeout: 268 seconds) |
| 2024-02-16 15:22:29 +0100 | mmhat | (~mmh@p200300f1c70685c4ee086bfffe095315.dip0.t-ipconnect.de) (Ping timeout: 272 seconds) |
| 2024-02-16 15:22:51 +0100 | mmhat | (~mmh@p200300f1c7068586ee086bfffe095315.dip0.t-ipconnect.de) |
| 2024-02-16 15:23:04 +0100 | ft | (~ft@p508db2e6.dip0.t-ipconnect.de) |
| 2024-02-16 15:23:31 +0100 | danse-nr3 | (~danse@ge-19-115-6.service.infuturo.it) |
| 2024-02-16 15:24:02 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Remote host closed the connection) |
| 2024-02-16 15:24:37 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-02-16 15:24:39 +0100 | Angelz | (Angelz@Angelz.oddprotocol.org) |
| 2024-02-16 15:25:16 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Remote host closed the connection) |
| 2024-02-16 15:25:28 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-02-16 15:28:01 +0100 | waleee | (~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 264 seconds) |
| 2024-02-16 15:31:19 +0100 | euleritian | (~euleritia@dynamic-046-114-090-105.46.114.pool.telefonica.de) (Ping timeout: 256 seconds) |
| 2024-02-16 15:31:50 +0100 | evocatus | (~evocatus@2a02:a210:20c6:1f00:d2c0:b982:94f0:fc66) (Ping timeout: 268 seconds) |
| 2024-02-16 15:46:04 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 15:47:58 +0100 | destituion | (~destituio@2a02:2121:626:f551:4ac:cbaa:8513:cc79) |
| 2024-02-16 15:48:35 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 15:56:55 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 15:58:24 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 15:59:28 +0100 | alexherbo2 | (~alexherbo@63.150.22.93.rev.sfr.net) (Remote host closed the connection) |
| 2024-02-16 15:59:48 +0100 | alexherbo2 | (~alexherbo@2a02-8440-3140-beaa-19bb-1041-3da4-028d.rev.sfr.net) |
| 2024-02-16 16:04:14 +0100 | dsrt^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) |
| 2024-02-16 16:10:53 +0100 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection) |
| 2024-02-16 16:11:44 +0100 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) |
| 2024-02-16 16:15:20 +0100 | califax | (~califax@user/califx) (Ping timeout: 255 seconds) |
| 2024-02-16 16:16:24 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 16:23:09 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) (Quit: Client closed) |
| 2024-02-16 16:23:25 +0100 | alexherbo2 | (~alexherbo@2a02-8440-3140-beaa-19bb-1041-3da4-028d.rev.sfr.net) (Remote host closed the connection) |
| 2024-02-16 16:23:45 +0100 | alexherbo2 | (~alexherbo@2a02-8440-3140-beaa-19bb-1041-3da4-028d.rev.sfr.net) |
| 2024-02-16 16:25:09 +0100 | Sgeo | (~Sgeo@user/sgeo) |
| 2024-02-16 16:31:40 +0100 | Tuplanolla | (~Tuplanoll@91-159-68-95.elisa-laajakaista.fi) |
| 2024-02-16 16:33:44 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) (Quit: Leaving) |
| 2024-02-16 16:35:15 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) |
| 2024-02-16 16:42:39 +0100 | bontaq | (~user@ool-45779c03.dyn.optonline.net) |
| 2024-02-16 16:44:13 +0100 | mehlon | (~mehlon@user/mehlon) |
| 2024-02-16 16:45:23 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 16:47:07 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 16:50:25 +0100 | rosco | (~rosco@175.136.156.77) (Remote host closed the connection) |
| 2024-02-16 16:50:44 +0100 | evocatus | (~evocatus@2a02:a210:20c6:1f00:d2c0:b982:94f0:fc66) |
| 2024-02-16 16:53:07 +0100 | rosco | (~rosco@175.136.156.77) |
| 2024-02-16 16:53:12 +0100 | notzmv | (~daniel@user/notzmv) |
| 2024-02-16 16:54:52 +0100 | tabaqui | (~root@87.201.186.71) (Read error: Connection reset by peer) |
| 2024-02-16 16:56:48 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) (Quit: Leaving) |
| 2024-02-16 17:04:43 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) |
| 2024-02-16 17:04:46 +0100 | evocatus | (~evocatus@2a02:a210:20c6:1f00:d2c0:b982:94f0:fc66) (Ping timeout: 246 seconds) |
| 2024-02-16 17:09:37 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 17:10:14 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds) |
| 2024-02-16 17:11:06 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2024-02-16 17:11:47 +0100 | mehlon | (~mehlon@user/mehlon) (Remote host closed the connection) |
| 2024-02-16 17:13:56 +0100 | danse-nr3 | (~danse@ge-19-115-6.service.infuturo.it) (Ping timeout: 256 seconds) |
| 2024-02-16 17:16:02 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 17:16:50 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) |
| 2024-02-16 17:18:16 +0100 | notzmv | (~daniel@user/notzmv) (Remote host closed the connection) |
| 2024-02-16 17:20:06 +0100 | notzmv | (~daniel@user/notzmv) |
| 2024-02-16 17:20:38 +0100 | alexherbo2 | (~alexherbo@2a02-8440-3140-beaa-19bb-1041-3da4-028d.rev.sfr.net) (Remote host closed the connection) |
| 2024-02-16 17:20:58 +0100 | alexherbo2 | (~alexherbo@2a02-8440-3140-beaa-19bb-1041-3da4-028d.rev.sfr.net) |
| 2024-02-16 17:21:36 +0100 | Erutuon | (~Erutuon@user/erutuon) |
| 2024-02-16 17:28:14 +0100 | lortabac | (~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4) (Quit: WeeChat 4.1.1) |
| 2024-02-16 17:30:31 +0100 | myxos | (~myxos@065-028-251-121.inf.spectrum.com) (Remote host closed the connection) |
| 2024-02-16 17:31:13 +0100 | myxos | (~myxos@065-028-251-121.inf.spectrum.com) |
| 2024-02-16 17:31:24 +0100 | athan | (~athan@173-042-095-241.biz.spectrum.com) (Quit: Konversation terminated!) |
| 2024-02-16 17:31:47 +0100 | CiaoSen | (~Jura@2a05:5800:2c6:8e00:e6b9:7aff:fe80:3d03) (Ping timeout: 268 seconds) |
| 2024-02-16 17:34:29 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-02-16 17:37:30 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 17:40:26 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 17:40:36 +0100 | alexherbo2 | (~alexherbo@2a02-8440-3140-beaa-19bb-1041-3da4-028d.rev.sfr.net) (Remote host closed the connection) |
| 2024-02-16 17:44:07 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 17:46:56 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 17:51:46 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 17:53:05 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 17:57:29 +0100 | raym | (~ray@user/raym) (Ping timeout: 260 seconds) |
| 2024-02-16 17:59:15 +0100 | raym | (~ray@user/raym) |
| 2024-02-16 17:59:44 +0100 | igemnace | (~ian@user/igemnace) (Quit: WeeChat 4.2.1) |
| 2024-02-16 18:13:25 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 18:14:29 +0100 | target_i | (~target_i@217.175.14.39) |
| 2024-02-16 18:17:38 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 18:21:28 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2024-02-16 18:24:10 +0100 | pavonia | (~user@user/siracusa) (Quit: Bye!) |
| 2024-02-16 18:27:19 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) |
| 2024-02-16 18:28:02 +0100 | gambpang | (~ishipman@12.14.16.242) |
| 2024-02-16 18:29:00 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 18:29:01 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection) |
| 2024-02-16 18:29:44 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) |
| 2024-02-16 18:32:07 +0100 | Square | (~Square@user/square) |
| 2024-02-16 18:34:47 +0100 | machinedgod | (~machinedg@d173-183-246-216.abhsia.telus.net) (Ping timeout: 264 seconds) |
| 2024-02-16 18:36:04 +0100 | Square | (~Square@user/square) (Remote host closed the connection) |
| 2024-02-16 18:37:09 +0100 | Square | (~Square@user/square) |
| 2024-02-16 18:37:42 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 18:37:46 +0100 | xff0x | (~xff0x@ai082039.d.east.v6connect.net) (Ping timeout: 268 seconds) |
| 2024-02-16 18:38:24 +0100 | xff0x | (~xff0x@ai082039.d.east.v6connect.net) |
| 2024-02-16 18:45:39 +0100 | Unicorn_Princess | (~Unicorn_P@user/Unicorn-Princess/x-3540542) |
| 2024-02-16 18:50:51 +0100 | yoo | (~yo0O0o@user/mobivme) (Ping timeout: 272 seconds) |
| 2024-02-16 18:55:27 +0100 | johnw | (~johnw@69.62.242.138) (Ping timeout: 256 seconds) |
| 2024-02-16 18:57:24 +0100 | tzh | (~tzh@c-71-193-181-0.hsd1.or.comcast.net) |
| 2024-02-16 18:59:25 +0100 | rvalue | (~rvalue@user/rvalue) (Ping timeout: 256 seconds) |
| 2024-02-16 19:04:32 +0100 | billchenchina | (~billchenc@2a0d:2580:ff0c:1:e3c9:c52b:a429:5bfe) |
| 2024-02-16 19:06:53 +0100 | rvalue | (~rvalue@user/rvalue) |
| 2024-02-16 19:16:15 +0100 | zer0bitz- | (~zer0bitz@user/zer0bitz) |
| 2024-02-16 19:17:44 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-02-16 19:17:53 +0100 | gambpang | (~ishipman@12.14.16.242) (Remote host closed the connection) |
| 2024-02-16 19:20:19 +0100 | zer0bitz | (~zer0bitz@user/zer0bitz) (Ping timeout: 268 seconds) |
| 2024-02-16 19:22:19 +0100 | chele | (~chele@user/chele) (Remote host closed the connection) |
| 2024-02-16 19:25:17 +0100 | sord937 | (~sord937@gateway/tor-sasl/sord937) (Quit: sord937) |
| 2024-02-16 19:25:42 +0100 | target_i | (~target_i@217.175.14.39) (Quit: leaving) |
| 2024-02-16 19:26:05 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 19:27:38 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 19:33:18 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 19:33:53 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 19:34:39 +0100 | remmie | (ianremsen@tilde.team) (Ping timeout: 255 seconds) |
| 2024-02-16 19:35:03 +0100 | evocatus | (~evocatus@2a02:a210:20c6:1f00:d2c0:b982:94f0:fc66) |
| 2024-02-16 19:40:39 +0100 | __monty__ | (~toonn@user/toonn) (Ping timeout: 256 seconds) |
| 2024-02-16 19:41:33 +0100 | __monty__ | (~toonn@user/toonn) |
| 2024-02-16 19:51:58 +0100 | billchenchina | (~billchenc@2a0d:2580:ff0c:1:e3c9:c52b:a429:5bfe) (Quit: Leaving) |
| 2024-02-16 19:53:07 +0100 | evocatus | (~evocatus@2a02:a210:20c6:1f00:d2c0:b982:94f0:fc66) (Ping timeout: 256 seconds) |
| 2024-02-16 19:55:21 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-02-16 19:57:40 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer) |
| 2024-02-16 19:58:28 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-02-16 20:02:45 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 256 seconds) |
| 2024-02-16 20:03:30 +0100 | evocatus | (~evocatus@2a02:a210:20c6:1f00:d2c0:b982:94f0:fc66) |
| 2024-02-16 20:03:34 +0100 | euleritian | (~euleritia@dynamic-046-114-090-105.46.114.pool.telefonica.de) |
| 2024-02-16 20:07:40 +0100 | remmie | (ianremsen@tilde.team) |
| 2024-02-16 20:09:52 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2024-02-16 20:13:21 +0100 | euleritian | (~euleritia@dynamic-046-114-090-105.46.114.pool.telefonica.de) (Read error: Connection reset by peer) |
| 2024-02-16 20:13:39 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-02-16 20:16:32 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-02-16 20:22:44 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer) |
| 2024-02-16 20:27:45 +0100 | bontaq | (~user@ool-45779c03.dyn.optonline.net) (Remote host closed the connection) |
| 2024-02-16 20:29:54 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2024-02-16 20:30:13 +0100 | rosco | (~rosco@175.136.156.77) (Quit: Lost terminal) |
| 2024-02-16 20:30:55 +0100 | Erutuon | (~Erutuon@user/erutuon) (Ping timeout: 255 seconds) |
| 2024-02-16 20:32:32 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer) |
| 2024-02-16 20:32:59 +0100 | bontaq | (~user@ool-45779c03.dyn.optonline.net) |
| 2024-02-16 20:33:17 +0100 | euleritian | (~euleritia@dynamic-046-114-090-105.46.114.pool.telefonica.de) |
| 2024-02-16 20:33:39 +0100 | euleritian | (~euleritia@dynamic-046-114-090-105.46.114.pool.telefonica.de) (Read error: Connection reset by peer) |
| 2024-02-16 20:33:55 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-02-16 20:34:53 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) |
| 2024-02-16 20:40:03 +0100 | amjoseph | (~amjoseph@static-198-44-128-146.cust.tzulo.com) |
| 2024-02-16 20:42:16 +0100 | julie_pilgrim | (~julie_pil@user/julie-pilgrim/x-1240752) |
| 2024-02-16 20:44:50 +0100 | shailangsa | (~shailangs@host109-152-9-157.range109-152.btcentralplus.com) (Remote host closed the connection) |
| 2024-02-16 20:49:04 +0100 | yoo | (~yo0O0o@104.28.226.106) |
| 2024-02-16 20:49:24 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) (Quit: Client closed) |
| 2024-02-16 20:49:46 +0100 | dcoutts | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 264 seconds) |
| 2024-02-16 20:54:04 +0100 | julie_pilgrim | (~julie_pil@user/julie-pilgrim/x-1240752) (Remote host closed the connection) |
| 2024-02-16 20:54:26 +0100 | mud | (~mud@user/kadoban) |
| 2024-02-16 20:55:58 +0100 | rscastilho2024 | (rscastilho@189.61.140.215) |
| 2024-02-16 20:56:29 +0100 | rscastilho2024 | (rscastilho@189.61.140.215) (Remote host closed the connection) |
| 2024-02-16 20:59:47 +0100 | evocatus | (~evocatus@2a02:a210:20c6:1f00:d2c0:b982:94f0:fc66) (Ping timeout: 259 seconds) |
| 2024-02-16 21:04:28 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Remote host closed the connection) |
| 2024-02-16 21:05:10 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-02-16 21:09:37 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Ping timeout: 255 seconds) |
| 2024-02-16 21:15:48 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) |
| 2024-02-16 21:29:23 +0100 | yoo | (~yo0O0o@104.28.226.106) (Changing host) |
| 2024-02-16 21:29:23 +0100 | yoo | (~yo0O0o@user/mobivme) |
| 2024-02-16 21:37:24 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 21:38:58 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 21:40:24 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-02-16 21:41:22 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 21:41:49 +0100 | waleee | (~waleee@h-176-10-144-38.NA.cust.bahnhof.se) |
| 2024-02-16 21:42:00 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 21:44:54 +0100 | L29Ah | (~L29Ah@wikipedia/L29Ah) () |
| 2024-02-16 21:45:01 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Ping timeout: 272 seconds) |
| 2024-02-16 21:49:17 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-02-16 21:49:47 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 21:50:34 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 21:53:52 +0100 | yoo | (~yo0O0o@user/mobivme) (Remote host closed the connection) |
| 2024-02-16 21:53:59 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Ping timeout: 264 seconds) |
| 2024-02-16 21:54:39 +0100 | yoo | (~yo0O0o@104.28.226.106) |
| 2024-02-16 21:58:39 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-02-16 22:00:54 +0100 | thegeekinside | (~thegeekin@189.217.83.221) (Read error: Connection reset by peer) |
| 2024-02-16 22:04:52 +0100 | thegeekinside | (~thegeekin@189.217.83.221) |
| 2024-02-16 22:04:55 +0100 | thegeekinside | (~thegeekin@189.217.83.221) (Read error: Connection reset by peer) |
| 2024-02-16 22:05:32 +0100 | thegeekinside | (~thegeekin@189.217.83.221) |
| 2024-02-16 22:05:36 +0100 | thegeekinside | (~thegeekin@189.217.83.221) (Read error: Connection reset by peer) |
| 2024-02-16 22:07:26 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-16 22:09:21 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2024-02-16 22:09:50 +0100 | califax | (~califax@user/califx) |
| 2024-02-16 22:12:10 +0100 | thegeekinside | (~thegeekin@189.217.83.221) |
| 2024-02-16 22:12:56 +0100 | earthy | (~arthurvl@2a02-a469-f5e2-1-83d2-ca43-57a2-dc81.fixed6.kpn.net) (Quit: reboot) |
| 2024-02-16 22:21:57 +0100 | L29Ah | (~L29Ah@wikipedia/L29Ah) |
| 2024-02-16 22:23:57 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-02-16 22:24:52 +0100 | _ht | (~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Remote host closed the connection) |
| 2024-02-16 22:25:28 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-02-16 22:31:04 +0100 | machinedgod | (~machinedg@d173-183-246-216.abhsia.telus.net) |
| 2024-02-16 22:34:37 +0100 | yoo | (~yo0O0o@104.28.226.106) (Ping timeout: 264 seconds) |
| 2024-02-16 22:37:50 +0100 | julie_pilgrim | (~julie_pil@user/julie-pilgrim/x-1240752) |
| 2024-02-16 22:38:31 +0100 | natechan | (~nate@c-98-45-158-125.hsd1.ca.comcast.net) |
| 2024-02-16 22:38:36 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2024-02-16 22:41:18 +0100 | dcoutts | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) |
| 2024-02-16 22:45:23 +0100 | thegeekinside | (~thegeekin@189.217.83.221) (Remote host closed the connection) |
| 2024-02-16 22:49:29 +0100 | notzmv | (~daniel@user/notzmv) (Ping timeout: 256 seconds) |
| 2024-02-16 22:57:51 +0100 | notzmv | (~daniel@user/notzmv) |
| 2024-02-16 23:01:02 +0100 | mmhat | (~mmh@p200300f1c7068586ee086bfffe095315.dip0.t-ipconnect.de) (Quit: WeeChat 4.2.1) |
| 2024-02-16 23:01:55 +0100 | <ncf> | ski, irregularsphere: it took me the entire day but here's a proof that "idempotent monad" implies ski's definition https://f.monade.li/o-fwm4.png |
| 2024-02-16 23:02:14 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-02-16 23:02:49 +0100 | notzmv | (~daniel@user/notzmv) (Ping timeout: 264 seconds) |
| 2024-02-16 23:05:18 +0100 | <ncf> | commutativity of the outer diagram says that the map on the left (Tδ = fmap dup) is equal to the composite going around the diagram, which is the categorical translation of join (liftM2 (,)); the diagram uses monad laws, left and right strength laws, the η = Tη definition of idempotence, and naturality of various things |
| 2024-02-16 23:06:17 +0100 | <ncf> | i don't know if the converse implication holds yet |
| 2024-02-16 23:06:32 +0100 | mizlan | (~mizlan@2607:f010:2e9:b:5564:6974:cc47:1879) |
| 2024-02-16 23:08:20 +0100 | Me-me | (~me-me@2602:ff16:3:0:1:dc:beef:d00d) (Quit: Disconnecting on purpose.) |
| 2024-02-16 23:10:04 +0100 | Me-me | (~me-me@user/me-me) |
| 2024-02-16 23:12:47 +0100 | <haskellbridge> | <irregularsphere> ncf: holy, that's dedication |
| 2024-02-16 23:13:53 +0100 | <EvanR> | you don't need to know category theory to use haskell, but it's a side effect |
| 2024-02-16 23:14:56 +0100 | <haskellbridge> | <irregularsphere> thanks so much! will be looking into it |
| 2024-02-16 23:16:05 +0100 | <haskellbridge> | <irregularsphere> EvanR: I usually get confused by multiple definitions to be honest, category theory and its commutative diagrams aid me in understanding Haskell |
| 2024-02-16 23:22:29 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Remote host closed the connection) |
| 2024-02-16 23:22:41 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-02-16 23:22:45 +0100 | michalz | (~michalz@185.246.207.193) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2024-02-16 23:24:59 +0100 | CiaoSen | (~Jura@2a05:5800:2c6:8e00:e6b9:7aff:fe80:3d03) |
| 2024-02-16 23:27:38 +0100 | julie_pilgrim | (~julie_pil@user/julie-pilgrim/x-1240752) (Remote host closed the connection) |
| 2024-02-16 23:27:56 +0100 | shapr` | (~user@c-24-218-186-89.hsd1.ma.comcast.net) |
| 2024-02-16 23:28:45 +0100 | hasktard | (~ohomecham@nat-240.udc.es) |
| 2024-02-16 23:29:06 +0100 | <hasktard> | leave |
| 2024-02-16 23:29:10 +0100 | hasktard | (~ohomecham@nat-240.udc.es) () |
| 2024-02-16 23:29:59 +0100 | jinsun | (~jinsun@user/jinsun) |
| 2024-02-16 23:30:09 +0100 | shapr | (~user@c-24-218-186-89.hsd1.ma.comcast.net) (Ping timeout: 272 seconds) |
| 2024-02-16 23:33:12 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) |
| 2024-02-16 23:36:59 +0100 | julie_pilgrim | (~julie_pil@user/julie-pilgrim/x-1240752) |
| 2024-02-16 23:43:06 +0100 | azr4e1 | (~azr4e1@137.220.68.193) |
| 2024-02-16 23:44:08 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 252 seconds) |
| 2024-02-16 23:45:47 +0100 | fendor | (~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c) (Remote host closed the connection) |
| 2024-02-16 23:50:34 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2024-02-16 23:55:49 +0100 | random-jellyfish | (~developer@2a02:2f04:11e:c600:f8fa:9c1c:904b:436a) |
| 2024-02-16 23:55:49 +0100 | random-jellyfish | (~developer@2a02:2f04:11e:c600:f8fa:9c1c:904b:436a) (Changing host) |
| 2024-02-16 23:55:49 +0100 | random-jellyfish | (~developer@user/random-jellyfish) |
