| 2024-01-28 00:00:10 +0100 | mcfilib | (uid302703@user/mcfilib) (Quit: Connection closed for inactivity) |
| 2024-01-28 00:01:53 +0100 | michalz | (~michalz@185.246.207.200) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2024-01-28 00:04:55 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer) |
| 2024-01-28 00:05:22 +0100 | nicos | (~nsm@host98.181-4-190.telecom.net.ar) (Ping timeout: 276 seconds) |
| 2024-01-28 00:09:35 +0100 | takuan | (~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection) |
| 2024-01-28 00:10:01 +0100 | nicos | (~nsm@186.143.136.122) |
| 2024-01-28 00:22:07 +0100 | target_i | (~target_i@217.175.14.39) (Quit: leaving) |
| 2024-01-28 00:24:00 +0100 | jargon | (~jargon@211.sub-174-205-230.myvzw.com) |
| 2024-01-28 00:25:04 +0100 | athan | (~athan@173-042-095-241.biz.spectrum.com) (Ping timeout: 268 seconds) |
| 2024-01-28 00:30:01 +0100 | zetef | (~quassel@5.2.182.98) (Remote host closed the connection) |
| 2024-01-28 00:32:22 +0100 | <haskellbridge> | 15<Jade> It doesn't "really" call `load` |
| 2024-01-28 00:33:19 +0100 | <haskellbridge> | 15<Jade> I think it does recompile "properly" if I understand the effects of the `GhcMonad` correctly, but it sneakily calls `afterLoad` which is otherwise only used for things that *actually* load |
| 2024-01-28 00:35:03 +0100 | [itchyjunk] | (~itchyjunk@user/itchyjunk/x-7353470) |
| 2024-01-28 00:38:57 +0100 | [_] | (~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 260 seconds) |
| 2024-01-28 00:39:40 +0100 | athan | (~athan@173-042-095-241.biz.spectrum.com) |
| 2024-01-28 00:39:59 +0100 | <haskellbridge> | 15<Jade> correction, I don't think it does reload: https://paste.tomsmeding.com/XsffXpWv |
| 2024-01-28 00:42:19 +0100 | nicos | (~nsm@186.143.136.122) (Read error: Connection reset by peer) |
| 2024-01-28 00:43:34 +0100 | nicos | (~nsm@2800:2131:5400:883:28f6:1624:5755:79b0) |
| 2024-01-28 00:45:02 +0100 | <geekosaur> | then I'd look to see if `afterLoad` is what resets CAFs etc. |
| 2024-01-28 00:45:32 +0100 | <haskellbridge> | 15<Jade> yes it is, and that's why I was so confused as to why `check` uses it |
| 2024-01-28 00:45:56 +0100 | <haskellbridge> | 15<Jade> because it doesn't seem like `check` would need to reset CAFs |
| 2024-01-28 00:46:48 +0100 | <haskellbridge> | 15<Jade> unless the intention of check is to reload, but then it falls short on that end - something doesn't seem right here |
| 2024-01-28 00:49:53 +0100 | samhh_ | (7569f027cf@2a03:6000:1812:100::e4) |
| 2024-01-28 00:50:10 +0100 | sprout_ | sprout |
| 2024-01-28 00:50:36 +0100 | gmg | (~user@user/gehmehgeh) (Quit: Leaving) |
| 2024-01-28 00:50:53 +0100 | acidjnk_new | (~acidjnk@p200300d6e737e7740dc421a1b52e3505.dip0.t-ipconnect.de) (Ping timeout: 240 seconds) |
| 2024-01-28 00:52:21 +0100 | Axman6 | (~Axman6@user/axman6) (Remote host closed the connection) |
| 2024-01-28 00:54:00 +0100 | <geekosaur> | I wonder if the recompile changes things in such a way that e.g. background threads need to be killed |
| 2024-01-28 00:56:08 +0100 | Axman6 | (~Axman6@user/axman6) |
| 2024-01-28 00:57:51 +0100 | CiaoSen | (~Jura@2a05:5800:287:6f00:ca4b:d6ff:fec1:99da) (Ping timeout: 256 seconds) |
| 2024-01-28 01:08:34 +0100 | ell | (~ellie@user/ellie) (Quit: Leaving) |
| 2024-01-28 01:08:48 +0100 | average | (uid473595@user/average) |
| 2024-01-28 01:23:23 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) |
| 2024-01-28 01:31:10 +0100 | dsrt^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Ping timeout: 276 seconds) |
| 2024-01-28 01:34:01 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 264 seconds) |
| 2024-01-28 01:36:27 +0100 | dsrt^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) |
| 2024-01-28 01:40:30 +0100 | wlhn | (~wenzel@dl5rzs8hfxtxc2s075t2y-3.rev.dnainternet.fi) (Remote host closed the connection) |
| 2024-01-28 01:43:14 +0100 | wlhn | (~wenzel@dl5rzs8hfxtxc2s075t2y-3.rev.dnainternet.fi) |
| 2024-01-28 02:04:04 +0100 | Goodbye_Vincent | (cyvahl@freakshells.net) (Ping timeout: 256 seconds) |
| 2024-01-28 02:14:14 +0100 | Goodbye_Vincent | (cyvahl@freakshells.net) |
| 2024-01-28 02:14:53 +0100 | alexherbo2 | (~alexherbo@2a02-8440-3141-1388-ed74-c0ff-9a4e-09db.rev.sfr.net) (Remote host closed the connection) |
| 2024-01-28 02:17:03 +0100 | ulvarrefr | (~user@188.124.56.153) (Ping timeout: 256 seconds) |
| 2024-01-28 02:19:50 +0100 | ulvarrefr | (~user@188.124.56.153) |
| 2024-01-28 02:20:41 +0100 | Goodbye_Vincent | (cyvahl@freakshells.net) (Ping timeout: 252 seconds) |
| 2024-01-28 02:22:55 +0100 | dsrt^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Ping timeout: 246 seconds) |
| 2024-01-28 02:36:25 +0100 | Lord_of_Life | (~Lord@user/lord-of-life/x-2819915) (Ping timeout: 268 seconds) |
| 2024-01-28 02:37:56 +0100 | Lord_of_Life | (~Lord@user/lord-of-life/x-2819915) |
| 2024-01-28 02:40:08 +0100 | dsrt^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) |
| 2024-01-28 03:25:56 +0100 | TonyStone | (~TonyStone@074-076-057-186.res.spectrum.com) |
| 2024-01-28 03:36:43 +0100 | gorignak | (~gorignak@user/gorignak) |
| 2024-01-28 03:39:13 +0100 | Lycurgus | (~georg@user/Lycurgus) |
| 2024-01-28 03:48:18 +0100 | Lycurgus | (~georg@user/Lycurgus) (Quit: leaving) |
| 2024-01-28 03:48:33 +0100 | average | (uid473595@user/average) (Quit: Connection closed for inactivity) |
| 2024-01-28 03:49:18 +0100 | Tuplanolla | (~Tuplanoll@91-159-68-95.elisa-laajakaista.fi) (Quit: Leaving.) |
| 2024-01-28 03:52:22 +0100 | dsrt^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Ping timeout: 255 seconds) |
| 2024-01-28 03:55:06 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) |
| 2024-01-28 04:00:51 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 260 seconds) |
| 2024-01-28 04:02:30 +0100 | dsrt^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) |
| 2024-01-28 04:05:02 +0100 | op_4 | (~tslil@user/op-4/x-9116473) (Remote host closed the connection) |
| 2024-01-28 04:05:31 +0100 | op_4 | (~tslil@user/op-4/x-9116473) |
| 2024-01-28 04:08:40 +0100 | euleritian | (~euleritia@dynamic-176-001-007-110.176.1.pool.telefonica.de) |
| 2024-01-28 04:11:47 +0100 | euleritian | (~euleritia@dynamic-176-001-007-110.176.1.pool.telefonica.de) (Read error: Connection reset by peer) |
| 2024-01-28 04:12:04 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-01-28 04:14:58 +0100 | TonyStone | (~TonyStone@074-076-057-186.res.spectrum.com) (Quit: Leaving) |
| 2024-01-28 04:16:45 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 256 seconds) |
| 2024-01-28 04:33:21 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-01-28 04:33:47 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) (Ping timeout: 255 seconds) |
| 2024-01-28 04:36:12 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) |
| 2024-01-28 04:48:21 +0100 | td_ | (~td@i5387092D.versanet.de) (Ping timeout: 256 seconds) |
| 2024-01-28 04:50:06 +0100 | td_ | (~td@i53870912.versanet.de) |
| 2024-01-28 04:51:02 +0100 | phma | (~phma@host-67-44-208-13.hnremote.net) (Read error: Connection reset by peer) |
| 2024-01-28 04:52:35 +0100 | phma | (~phma@host-67-44-208-69.hnremote.net) |
| 2024-01-28 04:59:37 +0100 | [itchyjunk] | (~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection) |
| 2024-01-28 04:59:41 +0100 | dsrt^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Ping timeout: 240 seconds) |
| 2024-01-28 05:04:55 +0100 | mima | (~mmh@aftr-62-216-211-171.dynamic.mnet-online.de) (Ping timeout: 256 seconds) |
| 2024-01-28 05:45:42 +0100 | phma | (~phma@host-67-44-208-69.hnremote.net) (Read error: Connection reset by peer) |
| 2024-01-28 05:47:52 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-01-28 05:48:34 +0100 | bilegeek | (~bilegeek@2600:1008:b025:7f9c:3e2e:c9eb:66d4:c8c2) |
| 2024-01-28 05:49:03 +0100 | phma | (~phma@host-67-44-208-25.hnremote.net) |
| 2024-01-28 05:54:40 +0100 | aforemny | (~aforemny@2001:9e8:6cdf:ca00:229d:373b:2363:176f) |
| 2024-01-28 05:54:59 +0100 | aforemny_ | (~aforemny@i59F516CF.versanet.de) (Ping timeout: 268 seconds) |
| 2024-01-28 06:01:03 +0100 | dfii^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) |
| 2024-01-28 06:05:37 +0100 | lisbeths | (uid135845@id-135845.lymington.irccloud.com) |
| 2024-01-28 06:06:47 +0100 | Unicorn_Princess | (~Unicorn_P@user/Unicorn-Princess/x-3540542) |
| 2024-01-28 06:23:12 +0100 | hammond | (proscan@user/hammond2) |
| 2024-01-28 06:25:10 +0100 | Ram-Z | (~Ram-Z@li1814-254.members.linode.com) (Ping timeout: 260 seconds) |
| 2024-01-28 06:30:02 +0100 | Ram-Z | (~Ram-Z@li1814-254.members.linode.com) |
| 2024-01-28 06:34:25 +0100 | <euleritian> | Hey! Is there a dictionary somewhere to translate between Haskell types and the surrounding language and Python type hints and their use of words? For example, in the Python world noone says 'polymorphic type', |
| 2024-01-28 06:34:54 +0100 | <euleritian> | they talk about 'indexed types'. |
| 2024-01-28 06:37:41 +0100 | <euleritian> | At least I think that the concepts correspond to each other. A translation dictionary would be super helpful! |
| 2024-01-28 06:43:23 +0100 | Lycurgus | (~georg@user/Lycurgus) |
| 2024-01-28 06:44:09 +0100 | Goodbye_Vincent | (cyvahl@freakshells.net) |
| 2024-01-28 06:44:39 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Remote host closed the connection) |
| 2024-01-28 07:05:38 +0100 | igemnace | (~ian@user/igemnace) (Read error: Connection reset by peer) |
| 2024-01-28 07:06:07 +0100 | igemnace | (~ian@user/igemnace) |
| 2024-01-28 07:10:09 +0100 | dtman34 | (~dtman34@c-76-156-89-180.hsd1.mn.comcast.net) (Ping timeout: 256 seconds) |
| 2024-01-28 07:13:22 +0100 | Lycurgus | (~georg@user/Lycurgus) (Quit: leaving) |
| 2024-01-28 07:16:51 +0100 | dtman34 | (~dtman34@2601:447:d000:93c9:27e9:54c2:8285:dbbb) |
| 2024-01-28 07:18:07 +0100 | <mauke> | euleritian: indexed type sounds more like something of kind * -> *, i.e. a parameterized type |
| 2024-01-28 07:18:23 +0100 | <mauke> | that's not the same as, say, (Integral a) => a |
| 2024-01-28 07:18:29 +0100 | <mauke> | which is polymorphic |
| 2024-01-28 07:20:14 +0100 | Axman6 | (~Axman6@user/axman6) (Ping timeout: 244 seconds) |
| 2024-01-28 07:20:59 +0100 | Axman6 | (~Axman6@user/axman6) |
| 2024-01-28 08:00:05 +0100 | takuan | (~takuan@178-116-218-225.access.telenet.be) |
| 2024-01-28 08:09:08 +0100 | <EvanR> | unfortunately polymorphic types rarely get any love in the gradually typed world |
| 2024-01-28 08:09:33 +0100 | <EvanR> | actually I can't think of any examples |
| 2024-01-28 08:27:27 +0100 | <euleritian> | Maybe Python Protocols correspond to polymorphic types? https://docs.python.org/3/library/typing.html#typing.Protocol |
| 2024-01-28 08:29:31 +0100 | Rumham347 | (~Rumham347@2601:1c0:8301:6330:65b1:ec2b:aae7:e7a2) |
| 2024-01-28 08:30:46 +0100 | <haskellbridge> | 15<Jade> that seems to relate to duck-typing, I don't think so |
| 2024-01-28 08:33:04 +0100 | acidjnk_new | (~acidjnk@p200300d6e737e757707a4813492609fb.dip0.t-ipconnect.de) |
| 2024-01-28 08:33:34 +0100 | <euleritian> | A protocol makes sure that a Python class has certain methods, so you can use it whenever you need a certain interface. Similarly, a polymorphic type like (Integral a) => a makes sure that you have toInteger and the integer division functions available. |
| 2024-01-28 08:33:36 +0100 | lisbeths | (uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity) |
| 2024-01-28 08:36:07 +0100 | <[Leary]> | `forall a. Integral a => a` is the (monomorphic) type of a polymorphic /value/. A 'polymorphic type' would have a kind of the form `forall k. ...`. |
| 2024-01-28 08:40:08 +0100 | Rumham347 | (~Rumham347@2601:1c0:8301:6330:65b1:ec2b:aae7:e7a2) (Quit: Client closed) |
| 2024-01-28 08:40:35 +0100 | rosco | (~rosco@175.136.156.77) |
| 2024-01-28 08:41:50 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 252 seconds) |
| 2024-01-28 08:50:30 +0100 | rosco | (~rosco@175.136.156.77) (Quit: Lost terminal) |
| 2024-01-28 08:59:42 +0100 | <phma> | How do I make a progress indicator for a pure function that processes a list using a parallel strategy and returns statistics? |
| 2024-01-28 09:02:53 +0100 | rosco | (~rosco@175.136.156.77) |
| 2024-01-28 09:16:59 +0100 | _d0t | (~{-d0t-}@user/-d0t-/x-7915216) (Remote host closed the connection) |
| 2024-01-28 09:17:19 +0100 | <c_wraith> | phma: the only way for a pure function to report state is to return a constructor which guards the state report and the rest of the expression |
| 2024-01-28 09:17:47 +0100 | _d0t | (~{-d0t-}@user/-d0t-/x-7915216) |
| 2024-01-28 09:18:28 +0100 | <c_wraith> | phma: getting it to work usefully will require understanding GHC's evaluation model |
| 2024-01-28 09:19:13 +0100 | Square2 | (~Square@user/square) (Ping timeout: 256 seconds) |
| 2024-01-28 09:20:12 +0100 | bilegeek_ | (~bilegeek@2600:1008:b028:9a06:9d5:fa73:783:1418) |
| 2024-01-28 09:20:44 +0100 | <phma> | I've seen the ProgressBar package, but it talks about performing a unit of work, which doesn't make sense because the function is parallelized. |
| 2024-01-28 09:21:14 +0100 | <c_wraith> | you can still have units of work, but they'll end up being more complex. |
| 2024-01-28 09:22:25 +0100 | bilegeek | (~bilegeek@2600:1008:b025:7f9c:3e2e:c9eb:66d4:c8c2) (Ping timeout: 276 seconds) |
| 2024-01-28 09:22:31 +0100 | <phma> | Can a pure function take a callback as an argument, where the callback outputs progress? |
| 2024-01-28 09:22:48 +0100 | <c_wraith> | not while being pure |
| 2024-01-28 09:24:10 +0100 | bilegeek__ | (~bilegeek@2600:1008:b043:b7e8:f800:f483:98e4:845c) |
| 2024-01-28 09:25:47 +0100 | econo_ | (uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity) |
| 2024-01-28 09:27:10 +0100 | bilegeek_ | (~bilegeek@2600:1008:b028:9a06:9d5:fa73:783:1418) (Ping timeout: 260 seconds) |
| 2024-01-28 09:27:57 +0100 | <phma> | As a first step, can I take the function, which is of type Fractional a => Wring -> ([a],[a]), and make it return IO ([a],[a]), so that I can then pass a callback to it? |
| 2024-01-28 09:33:31 +0100 | <c_wraith> | doing that will make parallel computation stop working usefully. |
| 2024-01-28 09:34:47 +0100 | <c_wraith> | you really need to understand how GHC evaluation works |
| 2024-01-28 09:36:07 +0100 | coot | (~coot@89-69-206-216.dynamic.chello.pl) |
| 2024-01-28 09:36:49 +0100 | <phma> | so how does it work? |
| 2024-01-28 09:43:20 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:5014:5b74:113d:d036) (Remote host closed the connection) |
| 2024-01-28 09:45:07 +0100 | <c_wraith> | that's way too big of a question to just answer offhand. Also, I'm going to sleep. https://apfelmus.nfshost.com/blog/2013/08/21-space-invariants.html is a reasonable starting point, though it's probably only going to get you started. |
| 2024-01-28 09:53:04 +0100 | <phma> | I found https://stackoverflow.com/questions/66923101/adding-a-progress-bar-to-parallel-code-haskell , but it's not much help. |
| 2024-01-28 09:59:26 +0100 | _ht | (~Thunderbi@28-52-174-82.ftth.glasoperator.nl) |
| 2024-01-28 10:14:25 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:68b4:9268:598c:5a47) |
| 2024-01-28 10:20:17 +0100 | wheatengineer | (~frederik@p200300f63f1f9f0000ee046486e62fc9.dip0.t-ipconnect.de) |
| 2024-01-28 10:22:49 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer) |
| 2024-01-28 10:23:44 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-01-28 10:32:11 +0100 | wheatengineer | (~frederik@p200300f63f1f9f0000ee046486e62fc9.dip0.t-ipconnect.de) (Ping timeout: 268 seconds) |
| 2024-01-28 10:35:14 +0100 | jacob | (~jacob@2600:1700:b780:5150:bb2a:5c0e:a8eb:cf7) |
| 2024-01-28 10:39:16 +0100 | czy | (~user@114.226.59.181) |
| 2024-01-28 10:41:31 +0100 | jacob | (~jacob@2600:1700:b780:5150:bb2a:5c0e:a8eb:cf7) (Quit: Konversation terminated!) |
| 2024-01-28 10:44:49 +0100 | acidjnk_new | (~acidjnk@p200300d6e737e757707a4813492609fb.dip0.t-ipconnect.de) (Ping timeout: 246 seconds) |
| 2024-01-28 10:52:38 +0100 | fansly | (~fansly@182.0.134.232) |
| 2024-01-28 11:07:36 +0100 | fansly | (~fansly@182.0.134.232) (Read error: Connection reset by peer) |
| 2024-01-28 11:08:55 +0100 | fansly | (~fansly@2001:448a:2010:476e:c9c:17f1:874c:ee93) |
| 2024-01-28 11:10:31 +0100 | Tuplanolla | (~Tuplanoll@91-159-68-95.elisa-laajakaista.fi) |
| 2024-01-28 11:24:47 +0100 | mei | (~mei@user/mei) |
| 2024-01-28 11:26:47 +0100 | gmg | (~user@user/gehmehgeh) |
| 2024-01-28 11:29:23 +0100 | trev | (~trev@user/trev) |
| 2024-01-28 11:36:12 +0100 | trev | (~trev@user/trev) (Quit: trev) |
| 2024-01-28 11:36:24 +0100 | infinity0 | (~infinity0@pwned.gg) |
| 2024-01-28 11:40:12 +0100 | <haskellbridge> | 15<Jade> I was under the impression that `Show` was intended for use with `Read` and not for pretty printing / user facing stuff (?) |
| 2024-01-28 11:40:13 +0100 | <haskellbridge> | 15<Jade> Why does `IOException` have a show instance that seems to do just that? |
| 2024-01-28 11:41:06 +0100 | tzh | (~tzh@c-71-193-181-0.hsd1.or.comcast.net) (Quit: zzz) |
| 2024-01-28 11:41:12 +0100 | causal | (~eric@50.35.85.7) |
| 2024-01-28 11:41:41 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) (Ping timeout: 240 seconds) |
| 2024-01-28 11:42:29 +0100 | <Hecate> | Jade: because God hates us |
| 2024-01-28 11:42:38 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) (Ping timeout: 255 seconds) |
| 2024-01-28 11:42:45 +0100 | <Hecate> | this is precisely why I created https://flora.pm/packages/@hackage/text-display |
| 2024-01-28 11:43:47 +0100 | infinity0 | (~infinity0@pwned.gg) (Remote host closed the connection) |
| 2024-01-28 11:44:39 +0100 | <[Leary]> | Show is for producing output to help the programmer understand the precise value being shown. Being consistent with Haskell syntax is a good way to do so, but is secondary. Round-tripping with Read is tertiary. |
| 2024-01-28 11:44:47 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) |
| 2024-01-28 11:45:53 +0100 | infinity0 | (~infinity0@pwned.gg) |
| 2024-01-28 11:45:55 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) |
| 2024-01-28 11:51:44 +0100 | dibblego | (~dibblego@haskell/developer/dibblego) (Ping timeout: 268 seconds) |
| 2024-01-28 11:52:43 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer) |
| 2024-01-28 11:52:53 +0100 | dibblego | (~dibblego@122-199-1-93.ip4.superloop.au) |
| 2024-01-28 11:52:53 +0100 | dibblego | (~dibblego@122-199-1-93.ip4.superloop.au) (Changing host) |
| 2024-01-28 11:52:53 +0100 | dibblego | (~dibblego@haskell/developer/dibblego) |
| 2024-01-28 11:55:06 +0100 | <tomsmeding> | Hecate: logo is cool, but I'm not sure if it was _necessary_ :p |
| 2024-01-28 11:55:37 +0100 | mima | (~mmh@aftr-62-216-211-12.dynamic.mnet-online.de) |
| 2024-01-28 11:56:12 +0100 | <Hecate> | tomsmeding: my brother is a graphist, I commission him for a bunch of stuff :P |
| 2024-01-28 11:56:22 +0100 | <tomsmeding> | https://github.com/haskell-text/text-display/blob/59b3eb4bb1043b69c361f7386871e457b6f16751/src/Dat… 'An arbitrary Bytestrings' |
| 2024-01-28 11:56:28 +0100 | <tomsmeding> | cool cool :) |
| 2024-01-28 11:57:42 +0100 | <Hecate> | damnit haha |
| 2024-01-28 11:58:01 +0100 | <Rembane> | Breaking the law! Breaking the law! |
| 2024-01-28 11:58:35 +0100 | <int-e> | Jade: as often with these things there's some history here... the displayException method didn't exist before base 4.8.0.0 |
| 2024-01-28 11:58:51 +0100 | <int-e> | So all exceptions where printed through their Show instance. |
| 2024-01-28 11:58:56 +0100 | <int-e> | *were |
| 2024-01-28 11:59:55 +0100 | trev | (~trev@user/trev) |
| 2024-01-28 12:00:04 +0100 | <int-e> | And it's risky change these things after the fact. Sure, the base library will hopefully print exceptions with `displayException` now, but people may be catching and printing exceptions for logging in a lot of other places and then parse the log files and... it'll be a mess. |
| 2024-01-28 12:00:33 +0100 | <int-e> | And the type doesn't even have a Read instance anyway. |
| 2024-01-28 12:00:57 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) |
| 2024-01-28 12:02:38 +0100 | bilegeek__ | (~bilegeek@2600:1008:b043:b7e8:f800:f483:98e4:845c) (Quit: Leaving) |
| 2024-01-28 12:02:43 +0100 | Zmzi | (~rscastilh@user/Zmzi) |
| 2024-01-28 12:03:31 +0100 | Zmzi | (~rscastilh@user/Zmzi) (Remote host closed the connection) |
| 2024-01-28 12:05:00 +0100 | [itchyjunk] | (~itchyjunk@user/itchyjunk/x-7353470) |
| 2024-01-28 12:07:00 +0100 | wlhn | (~wenzel@dl5rzs8hfxtxc2s075t2y-3.rev.dnainternet.fi) (Remote host closed the connection) |
| 2024-01-28 12:10:47 +0100 | xff0x | (~xff0x@ai085147.d.east.v6connect.net) (Ping timeout: 264 seconds) |
| 2024-01-28 12:12:33 +0100 | xff0x | (~xff0x@178.255.149.135) |
| 2024-01-28 12:19:39 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer) |
| 2024-01-28 12:26:23 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) |
| 2024-01-28 12:29:37 +0100 | fansly | (~fansly@2001:448a:2010:476e:c9c:17f1:874c:ee93) (Ping timeout: 276 seconds) |
| 2024-01-28 12:30:57 +0100 | fansly | (~fansly@103.3.221.236) |
| 2024-01-28 12:43:08 +0100 | wlhn | (~wenzel@82-181-36-183.bb.dnainternet.fi) |
| 2024-01-28 12:46:07 +0100 | <kaol> | I wish there was an option to turn using Show a warning. Using type application or scoped type variable would make it go away. It would have saved me from plenty of footguns. |
| 2024-01-28 12:46:22 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer) |
| 2024-01-28 12:47:10 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-01-28 12:57:31 +0100 | fansly | (~fansly@103.3.221.236) (Ping timeout: 260 seconds) |
| 2024-01-28 12:58:21 +0100 | fansly | (~fansly@2001:448a:2010:476e:c9c:17f1:874c:ee93) |
| 2024-01-28 13:00:04 +0100 | lightandlight | (sid135476@id-135476.helmsley.irccloud.com) (Quit: Connection closed for inactivity) |
| 2024-01-28 13:01:37 +0100 | mrmr15533 | (~mrmr@user/mrmr) (Quit: Bye, See ya later!) |
| 2024-01-28 13:07:07 +0100 | mrmr15533 | (~mrmr@user/mrmr) |
| 2024-01-28 13:08:51 +0100 | xff0x | (~xff0x@178.255.149.135) (Ping timeout: 256 seconds) |
| 2024-01-28 13:10:51 +0100 | xff0x | (~xff0x@ai085147.d.east.v6connect.net) |
| 2024-01-28 13:25:11 +0100 | <tomsmeding> | applying 'show' to the wrong thing? |
| 2024-01-28 13:25:16 +0100 | <tomsmeding> | what are you using it for |
| 2024-01-28 13:25:25 +0100 | Unicorn_Princess | (~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection) |
| 2024-01-28 13:29:45 +0100 | ht_ | (~Thunderbi@194.110.115.23) |
| 2024-01-28 13:29:58 +0100 | Miroboru | (~myrvoll@178-164-114.82.3p.ntebredband.no) |
| 2024-01-28 13:31:23 +0100 | _ht | (~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Ping timeout: 256 seconds) |
| 2024-01-28 13:31:23 +0100 | ht_ | _ht |
| 2024-01-28 13:31:23 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer) |
| 2024-01-28 13:31:36 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-01-28 13:31:45 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer) |
| 2024-01-28 13:32:37 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-01-28 13:33:19 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer) |
| 2024-01-28 13:33:58 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-01-28 13:36:48 +0100 | ht_ | (~Thunderbi@194.110.115.55) |
| 2024-01-28 13:38:19 +0100 | _ht | (~Thunderbi@194.110.115.23) (Ping timeout: 256 seconds) |
| 2024-01-28 13:38:19 +0100 | ht_ | _ht |
| 2024-01-28 13:41:30 +0100 | fansly | (~fansly@2001:448a:2010:476e:c9c:17f1:874c:ee93) (Ping timeout: 260 seconds) |
| 2024-01-28 13:41:53 +0100 | fansly | (~fansly@103.3.221.236) |
| 2024-01-28 13:42:45 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer) |
| 2024-01-28 13:43:28 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-01-28 13:45:29 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer) |
| 2024-01-28 13:46:20 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-01-28 14:03:47 +0100 | Sgeo | (~Sgeo@user/sgeo) (Read error: Connection reset by peer) |
| 2024-01-28 14:06:10 +0100 | fansly | (~fansly@103.3.221.236) (Ping timeout: 255 seconds) |
| 2024-01-28 14:07:01 +0100 | fansly | (~fansly@2001:448a:2010:476e:c9c:17f1:874c:ee93) |
| 2024-01-28 14:17:29 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 260 seconds) |
| 2024-01-28 14:18:31 +0100 | euleritian | (~euleritia@dynamic-046-114-193-095.46.114.pool.telefonica.de) |
| 2024-01-28 14:38:59 +0100 | phma | (~phma@host-67-44-208-25.hnremote.net) (Read error: Connection reset by peer) |
| 2024-01-28 14:39:08 +0100 | szkl | (uid110435@id-110435.uxbridge.irccloud.com) |
| 2024-01-28 14:40:16 +0100 | phma | (phma@2001:5b0:212a:bae8:aa84:1310:c00c:b4dd) |
| 2024-01-28 14:53:47 +0100 | acidjnk_new | (~acidjnk@p200300d6e737e75650bac55cadf07511.dip0.t-ipconnect.de) |
| 2024-01-28 14:55:38 +0100 | Silver_X | (~Silver_X@182.178.246.17) |
| 2024-01-28 14:58:23 +0100 | Silver_X | (~Silver_X@182.178.246.17) (Remote host closed the connection) |
| 2024-01-28 15:03:05 +0100 | igemnace | (~ian@user/igemnace) (Read error: Connection reset by peer) |
| 2024-01-28 15:09:06 +0100 | Silver_X | (~Silver_X@182.178.246.17) |
| 2024-01-28 15:11:50 +0100 | tt1231 | (~tt123@2603-6010-8700-4a81-219f-50d3-618a-a6ee.res6.spectrum.com) (Quit: The Lounge - https://thelounge.chat) |
| 2024-01-28 15:13:28 +0100 | tt1231 | (~tt123@2603-6010-8700-4a81-219f-50d3-618a-a6ee.res6.spectrum.com) |
| 2024-01-28 15:16:57 +0100 | zetef | (~quassel@95.77.17.251) |
| 2024-01-28 15:18:37 +0100 | haasn` | (~nand@haasn.dev) |
| 2024-01-28 15:21:19 +0100 | zetef_ | (~quassel@86.124.177.222) |
| 2024-01-28 15:21:28 +0100 | igemnace | (~ian@user/igemnace) |
| 2024-01-28 15:22:11 +0100 | zetef | (~quassel@95.77.17.251) (Ping timeout: 264 seconds) |
| 2024-01-28 15:22:42 +0100 | Silver_X | (~Silver_X@182.178.246.17) (Remote host closed the connection) |
| 2024-01-28 15:23:06 +0100 | Silver_X | (~Silver_X@182.178.246.17) |
| 2024-01-28 15:23:49 +0100 | zetef_ | (~quassel@86.124.177.222) (Read error: Connection reset by peer) |
| 2024-01-28 15:24:03 +0100 | zetef | (~quassel@95.77.17.251) |
| 2024-01-28 15:27:38 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) (Ping timeout: 255 seconds) |
| 2024-01-28 15:28:38 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) |
| 2024-01-28 15:29:53 +0100 | califax | (~califax@user/califx) (Ping timeout: 255 seconds) |
| 2024-01-28 15:30:28 +0100 | califax | (~califax@user/califx) |
| 2024-01-28 15:31:15 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-01-28 15:33:56 +0100 | ChaiTRex | (~ChaiTRex@user/chaitrex) (Ping timeout: 255 seconds) |
| 2024-01-28 15:34:33 +0100 | ChaiTRex | (~ChaiTRex@user/chaitrex) |
| 2024-01-28 15:38:33 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-01-28 15:38:51 +0100 | califax | (~califax@user/califx) |
| 2024-01-28 15:39:08 +0100 | eggplant_ | (~Eggplanta@2600:1700:38c5:d800:24d0:730b:131f:e5b3) |
| 2024-01-28 15:39:41 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-01-28 15:40:02 +0100 | califax | (~califax@user/califx) |
| 2024-01-28 15:41:08 +0100 | <sprout> | [Leary]: nice |
| 2024-01-28 15:42:15 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:68b4:9268:598c:5a47) (Ping timeout: 260 seconds) |
| 2024-01-28 15:44:08 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer) |
| 2024-01-28 15:44:25 +0100 | Silver_X | (~Silver_X@182.178.246.17) (Remote host closed the connection) |
| 2024-01-28 15:44:37 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) |
| 2024-01-28 15:50:01 +0100 | target_i | (~target_i@217.175.14.39) |
| 2024-01-28 15:51:37 +0100 | crook1389 | (uid581388@id-581388.ilkley.irccloud.com) |
| 2024-01-28 15:55:17 +0100 | shapr | (~user@c-24-218-186-89.hsd1.ma.comcast.net) (Ping timeout: 240 seconds) |
| 2024-01-28 15:59:23 +0100 | Natch | (~natch@c-9e07225c.038-60-73746f7.bbcust.telenor.se) (Ping timeout: 264 seconds) |
| 2024-01-28 16:04:00 +0100 | Natch | (~natch@c-9e07225c.038-60-73746f7.bbcust.telenor.se) |
| 2024-01-28 16:05:03 +0100 | ChaiTRex | (~ChaiTRex@user/chaitrex) (Remote host closed the connection) |
| 2024-01-28 16:05:35 +0100 | ChaiTRex | (~ChaiTRex@user/chaitrex) |
| 2024-01-28 16:06:14 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer) |
| 2024-01-28 16:10:50 +0100 | eggplant_ | (~Eggplanta@2600:1700:38c5:d800:24d0:730b:131f:e5b3) (Ping timeout: 260 seconds) |
| 2024-01-28 16:17:13 +0100 | ht_ | (~Thunderbi@28-52-174-82.ftth.glasoperator.nl) |
| 2024-01-28 16:18:53 +0100 | _ht | (~Thunderbi@194.110.115.55) (Ping timeout: 252 seconds) |
| 2024-01-28 16:18:54 +0100 | ht_ | _ht |
| 2024-01-28 16:22:52 +0100 | Zmzi | (rscastilho@user/Zmzi) |
| 2024-01-28 16:37:58 +0100 | Guest70 | (~Guest70@72.142.115.10) |
| 2024-01-28 16:39:10 +0100 | Guest70 | (~Guest70@72.142.115.10) (Client Quit) |
| 2024-01-28 16:39:42 +0100 | Guest70 | (~Guest70@72.142.115.10) |
| 2024-01-28 16:40:04 +0100 | ell | (~ellie@user/ellie) |
| 2024-01-28 16:40:32 +0100 | zetef | (~quassel@95.77.17.251) (Remote host closed the connection) |
| 2024-01-28 16:41:13 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:24d0:730b:131f:e5b3) |
| 2024-01-28 16:49:06 +0100 | <Guest70> | How can Haskell, with its foundation in lambda calculus, be applied to make artificial life simulations (tips/advice?) |
| 2024-01-28 16:50:24 +0100 | a51 | (a51@gateway/vpn/protonvpn/a51) (Quit: WeeChat 4.2.1) |
| 2024-01-28 16:57:17 +0100 | <Rembane> | Guest70: What's an artificial life simulation? |
| 2024-01-28 17:02:23 +0100 | remedan | (~remedan@ip-94-112-0-18.bb.vodafone.cz) (Ping timeout: 264 seconds) |
| 2024-01-28 17:03:32 +0100 | remedan | (~remedan@ip-94-112-0-18.bb.vodafone.cz) |
| 2024-01-28 17:05:51 +0100 | szkl | (uid110435@id-110435.uxbridge.irccloud.com) (Quit: Connection closed for inactivity) |
| 2024-01-28 17:07:13 +0100 | <Guest70> | Artificial life simulation recreates biology digitally, emphasizing emergent behaviors from interactions among programmed agents in a dynamic environment. It captures the dynamic and adaptive essence of life through computational rules. Though ideally, the environment itself gives rise to such agents |
| 2024-01-28 17:08:10 +0100 | fansly | (~fansly@2001:448a:2010:476e:c9c:17f1:874c:ee93) (Remote host closed the connection) |
| 2024-01-28 17:10:20 +0100 | <Guest70> | I've come across the idea that the properties of lambda calculus share similarities with the behavior of RNA and ribosomes in terms of replication |
| 2024-01-28 17:10:54 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2024-01-28 17:11:41 +0100 | <Guest70> | ex. Y combinator |
| 2024-01-28 17:14:04 +0100 | <Guest70> | If you know of any such projects that use Haskell, that would be swell :) |
| 2024-01-28 17:14:55 +0100 | euleritian | (~euleritia@dynamic-046-114-193-095.46.114.pool.telefonica.de) (Read error: Connection reset by peer) |
| 2024-01-28 17:15:13 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-01-28 17:16:18 +0100 | <ski> | hm, i don't really know about any such projects, in any language |
| 2024-01-28 17:17:20 +0100 | <ski> | perhaps some sort of forward-chaining logic programming systems (e.g. CHR), or maybe genetic programming, could be interesting, though |
| 2024-01-28 17:18:28 +0100 | <ski> | (it's hard to answer, because it's hard to get a grip of what you're actually after, more concretely. most of what you said is rather vague, general) |
| 2024-01-28 17:19:14 +0100 | econo_ | (uid147250@id-147250.tinside.irccloud.com) |
| 2024-01-28 17:21:25 +0100 | michalz | (~michalz@185.246.207.201) |
| 2024-01-28 17:21:56 +0100 | Unicorn_Princess | (~Unicorn_P@user/Unicorn-Princess/x-3540542) |
| 2024-01-28 17:22:46 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 276 seconds) |
| 2024-01-28 17:23:13 +0100 | fansly | (~fansly@2001:448a:2010:476e:c9c:17f1:874c:ee93) |
| 2024-01-28 17:23:20 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-01-28 17:23:30 +0100 | <Guest70> | Your point is quite valid! I appreciate your feedback on forward-chaining logic programming, I'll explore there further. The concept is largely inspired by a book "Free Agents" by Kevin J. Mitchell, wherein the epilogue conveys a speculative view on Artificial Intelligence arising from *an intelligence* rather than nodes *possessing intelligence* |
| 2024-01-28 17:23:30 +0100 | <Guest70> | Leading up to this point, the origin of life is discussed at length. So, it is understandably vague indeed. |
| 2024-01-28 17:30:49 +0100 | <ski> | if you're more generally interested in AI stuff, i would also suggest looking into Prolog systems (backward-chaining logic programming), e.g. the book "Prolog: Programming for Artificial Intelligence" by Ivan Bratko, or "The Art of Prolog" by Leon Sterling,Ehud Shapiro. there's also a lot of AI literature in the Lisps, see e.g. |
| 2024-01-28 17:30:54 +0100 | <ski> | @where AIMA |
| 2024-01-28 17:30:54 +0100 | <lambdabot> | "Artificial Intelligence: A Modern Approach" by Stuart Russell,Peter Norvig in 1995,2003,2009-12-11 at <http://aima.cs.berkeley.edu/>,<https://people.eecs.berkeley.edu/~russell/aima1e.html> (1st ed.) |
| 2024-01-28 17:30:56 +0100 | <ski> | @where PAIP |
| 2024-01-28 17:30:57 +0100 | <lambdabot> | "Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp" by Peter Norvig in 1992 at <http://www.norvig.com/paip.html>,<http://www.norvig.com/paip/README.html>,<https://github. |
| 2024-01-28 17:30:57 +0100 | <lambdabot> | com/norvig/paip-lisp> |
| 2024-01-28 17:33:51 +0100 | <Guest70> | Wow, thanks again! Another avenue to explore :) |
| 2024-01-28 17:35:34 +0100 | <ski> | on the Y combinator, i believe some of the classic "Lambda The Ultimate" papers, goes a bit into that (in a Lisp context) |
| 2024-01-28 17:36:02 +0100 | <ski> | (not really connecting it with genetic self-replication, though, just how to do recursion with it) |
| 2024-01-28 17:37:23 +0100 | <ski> | ("hm, i don't really know about any such projects, in any language" -- if you had any example of the kind of thing you were looking for, in another language or context, that might help somewhat to better getting a grip of what you're looking for, more specifically. or perhaps not, if it's too unfamiliar to denizens of this channel) |
| 2024-01-28 17:38:26 +0100 | <ski> | btw, CHR is "Constraint Handling Rules". there are CHR implementations for Prolog systems (another reason why you might want to look into Prolog, and logic programming more generally) |
| 2024-01-28 17:40:25 +0100 | <ski> | logic programming is an approach to programming that focuses heavily on logic and relations/predicates (as opposed to expressions and functions), to express computation. very simply stated, you write down logical facts and rules expressing your program (or knowledge base), and then the system reasons logically with these |
| 2024-01-28 17:41:25 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-01-28 17:42:18 +0100 | <ski> | forward-chaining means that if you have a rule "If A, then B.", then the system will, if "A" is known, make use of this rule to reason that "B" must also be the case. you reason from antecedents/premisses to consequents/conclusions. this can e.g. model reasoning from new events happening (or becoming known) to intermediate knowledge forms, ultimately to actions that should be taken or results that should be |
| 2024-01-28 17:42:24 +0100 | <ski> | presented |
| 2024-01-28 17:45:15 +0100 | <ski> | backward-chaining means that if you have a rule "If A, then B.", equivalently "B, if A.", then the system will, if asked to check/determine if "A" is true / make "A" true, reduce this problem *goal* "B" to the subgoal "A", and then further try to reason backwards from that to see if it holds, or can be made to hold. you ask queries/questions to the systems, which are the initial goals. while solving these, |
| 2024-01-28 17:45:21 +0100 | <ski> | variables/unknowns in the query may become known/instantiated/initialized as a result of the deduction process trying to establish the goal, and those found values for variables will then be presented as a solution to the user (if using the system interactively). a query can possibly have multiple, alternative solutions, as well |
| 2024-01-28 17:47:48 +0100 | <ski> | operationally/procedurally, a query/goal that is atomic, that is consists of a single relation/predicate call with parameters, can be thought of more or less as a procedure (of function returning `void'), where some parameters are input, and some parameters are output. which are input vs. output may differ in different calls to the same predicate, though, it depends on how much upfront information you |
| 2024-01-28 17:47:54 +0100 | <ski> | provide to the call. also, since there can be multiple (or zero) solutions, there's also built-in backtracking in the system to handle this (unlike procedures in most imperative programming languages) |
| 2024-01-28 17:49:39 +0100 | <ski> | er .. in the backward-chaining case, i meant to say "\"If A, then B.\", equivalently \"B, if A.\", then the system will, if asked to check/determine if \"B\" is true / make "B" true, reduce this problem *goal* "B" to the subgoal \"A\"" -- point being that with forward-chaining, we move operationally from "A" to "B", but with backward-chaining we move from "B" to "A" |
| 2024-01-28 17:52:04 +0100 | <ski> | e.g. if you ask a Prolog system the following query |
| 2024-01-28 17:52:57 +0100 | <ski> | ?- append(Prefix,_,[2,3,5,7]),sum_list(Prefix,Sum),between(4,14,Sum). |
| 2024-01-28 17:53:31 +0100 | <ski> | in words : find a `Prefix' of the list `[2,3,5,7]' such that its `Sum' is between `4' and `14' |
| 2024-01-28 17:53:39 +0100 | <ski> | the system will answer with |
| 2024-01-28 17:53:59 +0100 | Zmzi | (rscastilho@user/Zmzi) (Ping timeout: 264 seconds) |
| 2024-01-28 17:54:05 +0100 | <ski> | Prefix = [2,3],Sum = 5 |
| 2024-01-28 17:54:42 +0100 | <ski> | as a possible solution, and if you press `;' (meaning "or", that is "are there any alternative solutions ?"), it will also compute for you |
| 2024-01-28 17:54:48 +0100 | <ski> | Prefix = [2,3,5],Sum = 10 |
| 2024-01-28 17:55:10 +0100 | <ski> | and if you press `;' again, it will answer "no" or "false", to indicate that there are no more solutions |
| 2024-01-28 17:56:56 +0100 | <ski> | `append(Front,Back,List)' expresses the relation that `Front' concatenated with `Back' is the `List'. `sum_list(Numbers,Sum)' expresses the relation that the sum of the numbers in the list `Numbers' is `Sum'. and `between(Lo,Hi,N)' here is roughly a shorthand for `Lo =< N,N =< Hi' (except it also restricts the numbers involved to be integers) |
| 2024-01-28 17:57:17 +0100 | raym | (~ray@user/raym) (Ping timeout: 260 seconds) |
| 2024-01-28 17:58:14 +0100 | <ski> | (and `_' means "don't care"/"no information". used here to ignore the suffix corresponding to the found prefix) |
| 2024-01-28 17:58:16 +0100 | raym | (~ray@user/raym) |
| 2024-01-28 17:58:34 +0100 | Zmzi | (~rscastilh@user/Zmzi) |
| 2024-01-28 17:59:19 +0100 | <ski> | operationally, the call to append/3 will have five alternative solutions, `Prefix = []',`Prefix = [2]',`Prefix = [2,3]',`Prefix = [2,3,5]',`Prefix = [2,3,5,7]'. these will all be tried, one at a time, upon backtracking (internal backtracking, or when you press `;' at the solution promt), unless you decide to abort the search, or decide that the current solution is enough |
| 2024-01-28 18:00:07 +0100 | <Guest70> | The detailed insights into forward-chaining, backward-chaining, and logic programming, with examples, have been invaluable! In the context of the query ?- append(Front,Back,List), sum_list(Numbers,Sum), between(Lo,Hi,N).', where append(Front,Back,List)' expresses concatenation, sum_list(Numbers,Sum)' expresses the sum of numbers, and |
| 2024-01-28 18:00:07 +0100 | <Guest70> | between(Lo,Hi,N)' sets a range with integers, could you elaborate on how these relations work together in the query? Specifically, how does the system navigate through the constraints imposed by append,' sum_list,' and between' to generate solutions like Prefix = [2,3], Sum = 5andPrefix = [2,3,5], Sum = 10'? I'm curious about the interplay of these |
| 2024-01-28 18:00:08 +0100 | <Guest70> | relations and how the system arrives at multiple solutions before eventually signaling 'no' or 'false.' Regarding your earlier question about examples in another language or context, the Tierra project by Thomas S. Ray, which simulates evolution and self-replication in a digital environment, could serve as a concrete illustration. If you have more |
| 2024-01-28 18:00:08 +0100 | <Guest70> | insights or examples, I'm keen to explore further. Your expertise is greatly appreciated in helping me grasp these concepts. |
| 2024-01-28 18:01:37 +0100 | rvalue | (~rvalue@user/rvalue) (Ping timeout: 264 seconds) |
| 2024-01-28 18:02:49 +0100 | <ski> | on first try, `Prefix = []', and then the sum_list/2 call gives us the solution `Sum = 0', but the between/3 call fails (no solutions), causing backtracking (backward execution of the program), to try to find the last point at which there might've been alternative solutions. the sum_list/2 call here had just one, so we go back to the append/3 call, resume it (try to) find an alternative solutions, which is |
| 2024-01-28 18:02:55 +0100 | <ski> | `Prefix = [2]'. but that also fails the between/3 test, so we'll ping-pong between the *generator* append/3 and the test between/3 here a few times, until we find `Prefix = [2,3]' which satisfies the test. then, if we press `;', `Prefix = [2,3,5]' also satisfies the test. finally, `Prefix = [2,3,5,7]' also fails the test, and now there's no more solutions for the append/3 call, so we "hit the wall", trying |
| 2024-01-28 18:03:01 +0100 | <ski> | to backtrack to the left of this call, and the whole query fails finally, having exhausted all solutions, terminating execution of it |
| 2024-01-28 18:03:18 +0100 | <ski> | at any point, if we're satisfied with a solution, we can skip generating the potential remaining ones |
| 2024-01-28 18:05:41 +0100 | <Guest70> | Then, in this iterative process, how does the system manage the decision to explore alternatives for each call? Are there specific conditions or criteria that trigger backtracking, and how does the system decide when to terminate the backtracking process? |
| 2024-01-28 18:05:43 +0100 | <ski> | note that (by desing), Prolog is rather simplistic, naïve, in how it goes about executing a logic program. it will try a conjunction ("AND") sequence (individual conjuncts separated by commas) in order, from left-to-right, not trying any fancy execution-out-of-order (except, maybe, as a result of high-level optimizations) |
| 2024-01-28 18:06:09 +0100 | <ski> | it will also try alternative clauses collectively defining a predicate/relation, in the order given |
| 2024-01-28 18:06:14 +0100 | <ski> | e.g. append/3 is defined as : |
| 2024-01-28 18:06:29 +0100 | <ski> | append([ ],Ys, Ys ). |
| 2024-01-28 18:06:45 +0100 | <ski> | er |
| 2024-01-28 18:06:48 +0100 | <ski> | append([ ],Ys, Ys ). |
| 2024-01-28 18:06:54 +0100 | <ski> | append([X|Xs],Ys,[X|XsYs]) :- append(Xs,Ys,XsYs). |
| 2024-01-28 18:07:09 +0100 | <ski> | the `:-' means "if", so this reads as : |
| 2024-01-28 18:07:24 +0100 | <ski> | the concatenation of the empty list with a list `Ys' can be the list `Ys' |
| 2024-01-28 18:08:21 +0100 | <ski> | the concatenation of a list with `X' in front of a tail list `Xs', with a list `Ys', can be a list with `X' in front of the list `XsYs', *if* the concatenation of `Xs' with `Ys' can be `XsYs' |
| 2024-01-28 18:09:21 +0100 | <ski> | "could you elaborate on how these relations work together in the query? Specifically, how does the system navigate through the constraints imposed [..]" -- did i answer this question satisfactorially ? |
| 2024-01-28 18:11:09 +0100 | <ski> | (btw, there's no difference between "no" and "false", in this context. most traditional Prolog systems will say "no" (or "No", or perhaps also with a full stop), but some have changed to replying with "false", in order to give a more "logical" answer. this is just a minor user interface detail, though. if there's no variables to report values for, in a solution, the system will repory "yes" (or "true") |
| 2024-01-28 18:11:15 +0100 | <ski> | instead) |
| 2024-01-28 18:11:41 +0100 | rvalue | (~rvalue@user/rvalue) |
| 2024-01-28 18:12:29 +0100 | <ski> | "the Tierra project by Thomas S. Ray, which simulates evolution and self-replication in a digital environment, could serve as a concrete illustration." -- being <https://tomray.me/tierra/> ? |
| 2024-01-28 18:12:39 +0100 | <ski> | i've never heard of that one before, but ty |
| 2024-01-28 18:13:27 +0100 | <Guest70> | Yes, your explanation about Prolog's execution strategy and the example with append/3 offered a clear illustration! It's interesting to see how Prolog, by design, follows a straightforward left-to-right approach without sophisticated out-of-order execution |
| 2024-01-28 18:14:21 +0100 | <ski> | oh, and the above examples were merely to give you a little taste of Prolog, and logic programming in general, to try to help you see if it sounds interesting, and help you see a little bit better what the terms "forward-chaining" and "backward-chaining", which i used, might actually mean, in practice |
| 2024-01-28 18:15:26 +0100 | <ski> | .. although, i guess i didn't really explicate backward-chaining in the example really, just backtracking. backward-chaining would e.g. happen internally to the append/3 goal, reducing the problem of finding a prefix to the given four-element list to finding prefices to lists of fewer elements, until we reach the empty list |
| 2024-01-28 18:18:06 +0100 | <ski> | "how does the system manage the decision to explore alternatives for each call?" -- each time a predicate is called, where there could possibly be more solutions than the branch/alternative/clause currently explored, the system pushes information (a "choice-point") about this, to a stack (not the regular predicate call stack, a separate one). then, whenever a call fails (either because it had no solutions to |
| 2024-01-28 18:18:12 +0100 | <ski> | begin with, or because its solutions have been exhausted), the system jumps to the latest choice-point, reinstating that computation context (including resetting variables which had become known/instantiated/initialized, since, back to unknown/uninstantiated/uninitialized state) |
| 2024-01-28 18:20:23 +0100 | <ski> | each predicate call (and each goal (e.g. query) in general), will generate a sequence of solutions, one at a time. each solution consists of instantiating some variables to more known states of information. after a solution of a call has been found, we immediately go "to the right" in the conjunction sequence, and try the next goal (so, in general, the sequence of commas correspond to "loop nesting" in |
| 2024-01-28 18:20:29 +0100 | <ski> | ordinary languages. however e.g. sum_list/2 does not generate more than one solution, so there's no extra nesting for that, effectively) |
| 2024-01-28 18:21:30 +0100 | <ski> | only if the "goals to the right" fail (have exhausted their solutions) do we come back to the present goal/call, asking it generate its next alternative solution. so we ping-pong back and forth. when the call has no more solutions, we fail, continuing execution to the left (backtracking) |
| 2024-01-28 18:22:05 +0100 | <ski> | "Are there specific conditions or criteria that trigger backtracking" -- when a goal fails, iow when it exhausts its solutions |
| 2024-01-28 18:22:25 +0100 | ph88 | (~ph88@ip5b403f30.dynamic.kabel-deutschland.de) |
| 2024-01-28 18:22:47 +0100 | manwithluck | (manwithluc@gateway/vpn/protonvpn/manwithluck) (Ping timeout: 256 seconds) |
| 2024-01-28 18:23:19 +0100 | manwithluck | (manwithluc@gateway/vpn/protonvpn/manwithluck) |
| 2024-01-28 18:24:01 +0100 | <ski> | "and how does the system decide when to terminate the backtracking process?" -- either when there's no more solutions to genreate; or when the user doesn't press `;' at the top-level interactor (to indicate search for the next top-level solution) (it's also possible to commit to a current local solution, inside the program, although generally you want to be quite careful with that, since that can easily, if |
| 2024-01-28 18:24:07 +0100 | <ski> | used incorrectly, destroy the declarative/logical meaning of the program, so you can't reason logically about it, only operationally/procedurally) |
| 2024-01-28 18:26:16 +0100 | <ski> | bacause of its built-in backtracking, Prolog is great for search and explore problems, where you may have to try multiple alternatives, and may not be sure to begin with which may be fruitful in the end |
| 2024-01-28 18:27:46 +0100 | stef204 | (~stef204@user/stef204) |
| 2024-01-28 18:28:09 +0100 | <ski> | it's also nice that, not too seldom (restricted partially by the strict left-to-right execution order), a predicate can be used both "forwards,backwards,sideways", e.g. append/3 (the two lines i gave above) can be used to concatenate two lists, to try to match a given prefix to a list, getting back a corresponding suffix on match, as well as to try to split a list in two in all possible ways (what i did |
| 2024-01-28 18:28:15 +0100 | <ski> | above) |
| 2024-01-28 18:28:51 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 260 seconds) |
| 2024-01-28 18:30:06 +0100 | <ski> | logic programming is programming with logic and relations |
| 2024-01-28 18:30:17 +0100 | <ski> | functional programming is programming with expressions and functions |
| 2024-01-28 18:31:06 +0100 | <ski> | both are examples of declarative programming, where you're not only reasoning on a procedural/operational level (the "how"), but also at a higher declarative level (the "what") |
| 2024-01-28 18:32:52 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-01-28 18:33:22 +0100 | <Guest70> | I see, this exploration of Prolog and logic programming quite fascinating. In the context of digital dynamic systems, it strikes me that Prolog's approach could be useful for exploring initial states and potential trajectories, especially in scenarios where the range of possibilities isn't predetermined |
| 2024-01-28 18:33:39 +0100 | <ski> | (we don't have to think about the backtracking details with choice-points, and instantiation / uninstantiation, all the time, when programming, we can reason logically about the program, to understand it better, or to refactor it. we do still need the operational/procedural reasoning, to gauge efficiency and performance .. especially basic things like nontermination (and run-time instantiation fault), |
| 2024-01-28 18:33:45 +0100 | <ski> | however) |
| 2024-01-28 18:35:29 +0100 | <ski> | i recall chatting with someone who used Prolog to handle bringing up and down services on a server. Prolog expressed dependencies between services (this service needs those, in order to function) and how to bring them up (and down), with fallback approaches specified if one approach didn't work. aiui, Prolog's backtracking came in quite handy for that |
| 2024-01-28 18:36:43 +0100 | <ski> | there's also a whole lot of AI stuff related to Prolog. automatically generating (coherent) stories. "Semantic Web" stuff. scheduling of industrial processes. &c. |
| 2024-01-28 18:38:13 +0100 | <ski> | there's a channel, ##prolog, if want to explore it more |
| 2024-01-28 18:39:23 +0100 | <ski> | anyway, in summary : i dunno whether logic programming is quite what you asked about (although i wouldn't be too surprised if someone had explored something along those lines, in Prolog, or perhaps a Lisp). however, you might still find it an interesting topic to widen your views and knowledge with |
| 2024-01-28 18:40:16 +0100 | <ski> | (oh, and hope i'm not overwhelming you too much with verbiage ..) |
| 2024-01-28 18:41:57 +0100 | <Guest70> | You have given me quite a lot to work with haha |
| 2024-01-28 18:42:00 +0100 | <Guest70> | But I am not any less grateful! |
| 2024-01-28 18:42:47 +0100 | <ski> | .. btw, Prolog is old, and has lots of warts and annoyances. but it's still, probably, one of the best ways to get into logic programming, if for nothing else, then because most of the literature is expressed in terms of Prolog, or Prolog-like systems |
| 2024-01-28 18:44:28 +0100 | <ski> | Mercury (see the channel #mercury) is another, more modern, logic programming language, that adds a lot of useful conveniences and checks to it. e.g. it can often, automatically, reorder goals in conjunctions, in order to satisfy demands of data (what is currently known), which Prolog doesn't do (thereby making predicates more useful in multiple modes) |
| 2024-01-28 18:46:20 +0100 | <ski> | you might be interested in reading these two responses in a mailing list discussion : "Re: Mercury in academic teaching?" by Richard A. O'Keefe at <https://www.mercurylang.org/list-archives/users/2006-October/004000.html> (2006-10-09),<https://www.mercurylang.org/list-archives/users/2006-October/004011.html> (2006-10-10) |
| 2024-01-28 18:46:48 +0100 | <ski> | the points expressed (about teaching and learning programming languages) are relevant to more than just Mercury and Prolog |
| 2024-01-28 18:47:50 +0100 | Square2 | (~Square@user/square) |
| 2024-01-28 18:49:29 +0100 | <Guest70> | What a wealth of info! I ought to digest it all |
| 2024-01-28 18:51:10 +0100 | rosco | (~rosco@175.136.156.77) (Remote host closed the connection) |
| 2024-01-28 18:51:30 +0100 | <Guest70> | There's certainly a strong underlying connection to my initial inquiry |
| 2024-01-28 18:53:47 +0100 | ski | had to reread those O'Keefe posts again, just because of how great they are |
| 2024-01-28 18:57:48 +0100 | <ski> | (to clarify, while Prolog does strict left-to-right execution, Mercury doesn't, because it can (automatically) reorder (if it determines so, afaik only at compile-time though). you *can*, *explicitly*, code alternative orders in Prolog as well. but it doesn't really happen automatically (unless, *maybe*, with some high-level optimizations, which i haven't tried / looked into. but this is hard, because Prolog |
| 2024-01-28 18:57:54 +0100 | <ski> | has side-effects (which generally should not be automatically reordered). Mercury doesn't, it expresses them as effects, no "side" to it. btw, Mercury is also, in some ways, less flexible, than Prolog, due to its improved static (compile-time) checking)) |
| 2024-01-28 18:58:10 +0100 | <ski> | Oz is yet another logic programming language, used in the (great) book |
| 2024-01-28 18:58:13 +0100 | <ski> | @where CTM |
| 2024-01-28 18:58:13 +0100 | <lambdabot> | "Concepts, Techniques, and Models of Computer Programming", by Peter Van Roy,Seif Haridi, at <http://www.info.ucl.ac.be/~pvr/book.html> |
| 2024-01-28 19:00:41 +0100 | <ski> | (the book is kind-of similar to SICP ("Structure and Interpretation of Computer Programs", which uses Scheme to explain various basic programming and CS stuff). it explains various different programming paradigm, starting from a core that is logic programming (without backtracking), then adding functional programming, procedural programming, object-oriented programming, concurrency (including declarative |
| 2024-01-28 19:00:47 +0100 | <ski> | concurrency, with data-flow variables), possibly also some about distributed computing, constraint programming (and backtracking)) |
| 2024-01-28 19:01:55 +0100 | <ski> | <https://www.info.ucl.ac.be/~pvr/paradigmsDIAGRAMeng201.pdf> is an interesting taxonomy of programming paradigms on that site, btw |
| 2024-01-28 19:02:26 +0100 | coot | (~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot) |
| 2024-01-28 19:03:10 +0100 | <Guest70> | Wow that's a really cool visual |
| 2024-01-28 19:04:47 +0100 | <ski> | (right, i see distributed programming in the table of contents) |
| 2024-01-28 19:04:53 +0100 | <ski> | (<https://www.info.ucl.ac.be/~pvr/booktoc.pdf>) |
| 2024-01-28 19:06:02 +0100 | <ski> | if you'd like to try a Prolog, there's a whole bunch to choose from. SWI-Prolog might be one of the more userfriendly, easier for beginners to use, though |
| 2024-01-28 19:06:40 +0100 | <ski> | (there are some more that are marketed as being user-friendly or welcoming to beginners, i think (Amzi! ? Ciao ?), but i haven't tried them that much) |
| 2024-01-28 19:09:08 +0100 | <Guest70> | Ok, I think I'll give SWI-Prolog a whirl |
| 2024-01-28 19:09:33 +0100 | <Guest70> | Thanks again |
| 2024-01-28 19:16:09 +0100 | qqq | (~qqq@92.43.167.61) |
| 2024-01-28 19:19:16 +0100 | <ski> | some intros,books on Prolog : "Learn Prolog Now!" <http://lpn.swi-prolog.org/lpnpage.php?pageid=online>,<https://www.let.rug.nl/bos/lpn/>, "The Power of Prolog" <https://www.metalevel.at/prolog>, "prolog :- tutorial" <https://saksagan.ceng.metu.edu.tr/courses/ceng242/documents/prolog/jrfisher/contents.html>, "Amzi!" <http://www.amzi.com/articles/prolog_books_tutorials.htm>, "Prolog for Software Engineering" |
| 2024-01-28 19:19:22 +0100 | <ski> | <https://www.cs.auckland.ac.nz/~j-hamer/07.363/prolog-for-se.html>, "An Introduction to Language Processing using Perl and Prolog" <https://archive.org/details/introductiontola0000nugu>, "P99: Ninety-Nine Prolog Problems" <https://www.ic.unicamp.br/~meidanis/courses/mc336/2009s2/prolog/problemas/>, "Prolog Programming - A First Course" <https://courses.cs.washington.edu/courses/cse341/03sp/brna.pdf>, some |
| 2024-01-28 19:19:28 +0100 | <ski> | links to tutorials <https://hix.dev/tutorials/prolog>, "Introduction to Prolog for Mathematicians" <http://www.j-paine.org/prolog/mathnotes/files/contents.html>, "comp.lang.prolog FAQ" <http://www.logic.at/prolog/faq/faq.html> |
| 2024-01-28 19:20:58 +0100 | <ski> | "Programming in Prolog" by W.F. Clocksin and C.S. Mellish is a classical intro textbook. but that "The Art of Prolog" one i mentioned, as well as "Prolog: Programming for Artificial Intelligence", also starts with relatively thorough intros to Prolog |
| 2024-01-28 19:22:11 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2024-01-28 19:22:12 +0100 | remedan | (~remedan@ip-94-112-0-18.bb.vodafone.cz) (Read error: Connection reset by peer) |
| 2024-01-28 19:22:20 +0100 | <ski> | Guest70 ^ |
| 2024-01-28 19:24:16 +0100 | remedan | (~remedan@ip-94-112-0-18.bb.vodafone.cz) |
| 2024-01-28 19:24:23 +0100 | <Guest70> | Awesome 👍👍 I'll take a look |
| 2024-01-28 19:25:21 +0100 | <ski> | (i have a file with a bunch of resources on logic programming .. although i haven't went through it in a while, so some of the links were dead, had to search for new places (some of) them could be found at, right now) |
| 2024-01-28 19:25:26 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:24d0:730b:131f:e5b3) (Remote host closed the connection) |
| 2024-01-28 19:25:48 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:24d0:730b:131f:e5b3) |
| 2024-01-28 19:30:35 +0100 | tzh | (~tzh@c-71-193-181-0.hsd1.or.comcast.net) |
| 2024-01-28 19:33:28 +0100 | laman1 | (~laman@rego.ai) |
| 2024-01-28 19:38:59 +0100 | stef204 | (~stef204@user/stef204) (Quit: WeeChat 4.2.1) |
| 2024-01-28 19:39:54 +0100 | <ski> | (oh, and you're welcome) |
| 2024-01-28 19:40:31 +0100 | <EvanR> | C++ appears nowhere on that chart, and haskell appears multiple times. I like it |
| 2024-01-28 19:41:19 +0100 | crook1389 | (uid581388@id-581388.ilkley.irccloud.com) (Quit: Connection closed for inactivity) |
| 2024-01-28 19:41:30 +0100 | <ski> | "When a language is mentioned under a paradigm, it means that part of the language is intended (by its designers) to support the paradigm without interference from other paradigms. It does not mean that there is a perfect fit between the language and the paradigm. It is not enough that libraries have been written in the language to support the paradigm. The language's kernel language should support the |
| 2024-01-28 19:41:36 +0100 | <ski> | paradigm. When there is a family of related languages, usually only one member of the family is mentioned to avoid clutter. The absence of a language does not imply any kind of value judgment." |
| 2024-01-28 19:42:32 +0100 | <ski> | "Axes that are orthogonal to this chart are typing, aspects, and domain-specificity. Typing is not completely orthogonal: it has some effect on expressiveness. Aspects should be completely orthogonal, since they are part of a program's specification. A domain-specific language should be definable in any paradigm (except when the domain needs a particular concept)." |
| 2024-01-28 19:43:08 +0100 | <ski> | "Metaprogramming is another way to increase the expressiveness of a language. The term covers many different approaches, [..] Syntactic extensibility and kernel language tinkering in particular are orthogonal to this chart. Some languages, such as Scheme, are flexible enough to implement many paradigms in almost native fashion. This flexibility is not shown in the chart." |
| 2024-01-28 19:43:17 +0100 | shapr | (~user@c-24-218-186-89.hsd1.ma.comcast.net) |
| 2024-01-28 19:43:45 +0100 | <EvanR> | saw that |
| 2024-01-28 19:44:34 +0100 | Guest69 | (~Guest69@42.60.167.58) |
| 2024-01-28 19:45:24 +0100 | Lycurgus | (~georg@user/Lycurgus) |
| 2024-01-28 19:46:03 +0100 | <ski> | (that figure appears to be from the article "Programming Paradigms for Dummies: What Every Programmer Should Know" <https://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf>, i suppose it's a chapter in the book) |
| 2024-01-28 19:47:46 +0100 | <Guest69> | @help |
| 2024-01-28 19:47:46 +0100 | <lambdabot> | help <command>. Ask for help for <command>. Try 'list' for all commands |
| 2024-01-28 19:48:06 +0100 | <ski> | what're you looking for help with, Guest69 ? |
| 2024-01-28 19:49:39 +0100 | <Guest69> | oh, was playing around with point-free transformation, I read on the Wiki that I can use lambdabot here for some experimentation with @pl. |
| 2024-01-28 19:49:40 +0100 | <Guest69> | but I didn't expect the commands output to be public lawl |
| 2024-01-28 19:49:59 +0100 | <geekosaur> | you can talk to lambdabot in PM |
| 2024-01-28 19:50:21 +0100 | <Guest69> | ah, thanks a lot. New to IRC as well, so cheers guys |
| 2024-01-28 19:50:34 +0100 | <geekosaur> | also, https://github.com/lambdabot/lambdabot/pull/205/files |
| 2024-01-28 19:51:00 +0100 | <ski> | well, to experiment with lambdabot, you can type in |
| 2024-01-28 19:51:21 +0100 | <ski> | /msg lambdabot @help pointless |
| 2024-01-28 19:51:27 +0100 | duncan_ | (~duncan@sithean.tor.scot) |
| 2024-01-28 19:51:34 +0100 | <ski> | /msg lambdabot @pointless \x -> x |
| 2024-01-28 19:51:56 +0100 | duncan | (~duncan@user/duncan) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2024-01-28 19:51:57 +0100 | <ski> | /msg lambdabot @pl toUppers str = map toUpper str |
| 2024-01-28 19:51:59 +0100 | <ski> | or start with |
| 2024-01-28 19:52:07 +0100 | <ski> | /query lambdabot |
| 2024-01-28 19:52:42 +0100 | <ski> | if there's some particular query you'd like to ask about, or demonstrate to the channel, you're welcome to do so, publically |
| 2024-01-28 19:53:41 +0100 | <Guest69> | yea, I'm able to get it working in the DM with the bot, thanks for the tip. |
| 2024-01-28 19:53:44 +0100 | <ski> | Guest70 : it's also possible to install lambdabot locally (and, iirc, to get it integrated into the interactor, GHCi .. i haven't tried that, though) |
| 2024-01-28 19:53:46 +0100 | stef204 | (~stef204@user/stef204) |
| 2024-01-28 19:53:53 +0100 | <ski> | Guest70 : oh, and welcome to IRC ! |
| 2024-01-28 19:54:36 +0100 | <geekosaur> | goa was badly bitrotted last time I looked, sadly |
| 2024-01-28 19:55:27 +0100 | <ski> | most important point to newbies : people tend to stay connected to IRC, while doing other stuff, perhaps checking once in a while if anything happens. therefore, you may have to wait a while before someone may read your message, and possibly respond. so, be patient, and don't disconnect a few minutes after announcing your presence. i'd suggest at least half an hour (preferably more) |
| 2024-01-28 19:55:33 +0100 | <ski> | Guest70 ^ |
| 2024-01-28 19:55:52 +0100 | <geekosaur> | don't you mean guest69? |
| 2024-01-28 19:55:58 +0100 | <ski> | er .. i do |
| 2024-01-28 19:56:02 +0100 | <ski> | Guest69 ^ |
| 2024-01-28 19:58:25 +0100 | <ski> | Guest69 : also, it's generally better to be upfront with what you're wondering about, preferably providing details. many people are loathe to announce their presence, unless they feel reasonably assured they have a chance of contributing usefully. (it's generally also better to ask in channel, than in private, so that more people can get a chance to answer, and so that lurkers can learn). so don't "Ask to |
| 2024-01-28 19:58:31 +0100 | <ski> | ask". some people also don't bother responding to plain greetings, but may respond to an actual inquiry |
| 2024-01-28 19:59:22 +0100 | <ski> | (that might be the most important things to know about IRC culture, and how technical (as opposed to social) channels tend to work, for an IRC newbie) |
| 2024-01-28 20:02:07 +0100 | ski | should go get some tea .. |
| 2024-01-28 20:03:33 +0100 | <Guest70> | Good to know, and I'll give the lambdabot integration a try 👍 |
| 2024-01-28 20:05:24 +0100 | <ski> | (do note that i accidentally mis-completed Guest69 as Guest70, in the last exchange above. if you type out the first few characters of someone's nickname, and then press the `<Tab>' key, most IRC clients will try to complete the nickname for you. but with multiple nicknames starting the same way, there's a risk of mis-completion, as you saw) |
| 2024-01-28 20:07:32 +0100 | sudden | (~cat@user/sudden) (Ping timeout: 268 seconds) |
| 2024-01-28 20:10:58 +0100 | Lycurgus | (~georg@user/Lycurgus) (Quit: leaving) |
| 2024-01-28 20:12:55 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-01-28 20:13:46 +0100 | trev | (~trev@user/trev) (Quit: trev) |
| 2024-01-28 20:14:17 +0100 | oo_miguel | (~Thunderbi@78-11-179-96.static.ip.netia.com.pl) (Ping timeout: 252 seconds) |
| 2024-01-28 20:14:25 +0100 | sudden | (~cat@user/sudden) |
| 2024-01-28 20:23:10 +0100 | Guest70 | (~Guest70@72.142.115.10) (Ping timeout: 250 seconds) |
| 2024-01-28 20:23:43 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) |
| 2024-01-28 20:25:46 +0100 | Guest69 | (~Guest69@42.60.167.58) (Quit: Client closed) |
| 2024-01-28 20:27:30 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 260 seconds) |
| 2024-01-28 20:37:13 +0100 | dfii^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Ping timeout: 255 seconds) |
| 2024-01-28 20:40:36 +0100 | johnw | (~johnw@69.62.242.138) (Quit: ZNC - http://znc.in) |
| 2024-01-28 20:41:08 +0100 | johnw | (~johnw@69.62.242.138) |
| 2024-01-28 20:41:18 +0100 | <ski> | @where existential-antipattern |
| 2024-01-28 20:41:18 +0100 | <lambdabot> | "Haskell Antipattern: Existential Typeclass" by Luke Palmer at <http://lukepalmer.wordpress.com/2010/01/24/haskell-antipattern-existential-typeclass/> |
| 2024-01-28 20:41:19 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) (Remote host closed the connection) |
| 2024-01-28 20:41:24 +0100 | <ski> | @where+ existential-antipattern "Haskell Antipattern: Existential Typeclass" by Luke Palmer at <https://web.archive.org/web/20220121105027/https://lukepalmer.wordpress.com/2010/01/24/haskell-ant…> |
| 2024-01-28 20:41:24 +0100 | <lambdabot> | I will never forget. |
| 2024-01-28 20:42:06 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) |
| 2024-01-28 20:42:41 +0100 | euleritian | (~euleritia@77.22.252.56) |
| 2024-01-28 20:52:30 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-01-28 20:57:16 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Ping timeout: 276 seconds) |
| 2024-01-28 20:58:16 +0100 | <shapr> | @where am i |
| 2024-01-28 20:58:17 +0100 | <lambdabot> | I know nothing about am. |
| 2024-01-28 20:58:20 +0100 | <shapr> | @where shapr |
| 2024-01-28 20:58:20 +0100 | <lambdabot> | I run to hug and cuddle shapr |
| 2024-01-28 20:58:24 +0100 | shapr | blushes |
| 2024-01-28 20:58:26 +0100 | <shapr> | aw, so nice |
| 2024-01-28 20:58:39 +0100 | <shapr> | @where+ shapr https://www.scannedinavian.com/ |
| 2024-01-28 20:58:39 +0100 | <lambdabot> | Nice! |
| 2024-01-28 20:58:43 +0100 | <shapr> | @where shapr |
| 2024-01-28 20:58:44 +0100 | <lambdabot> | https://www.scannedinavian.com/ |
| 2024-01-28 20:58:45 +0100 | <shapr> | yay |
| 2024-01-28 21:04:50 +0100 | Sgeo | (~Sgeo@user/sgeo) |
| 2024-01-28 21:04:56 +0100 | <Hecate> | heya shapr |
| 2024-01-28 21:09:40 +0100 | euleritian | (~euleritia@77.22.252.56) (Read error: Connection reset by peer) |
| 2024-01-28 21:10:24 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-01-28 21:11:11 +0100 | Zmzi | (~rscastilh@user/Zmzi) (Remote host closed the connection) |
| 2024-01-28 21:11:39 +0100 | Zmzi | (~rscastilh@189.61.140.215) |
| 2024-01-28 21:11:54 +0100 | dfii^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) |
| 2024-01-28 21:13:36 +0100 | Zmzi | (~rscastilh@189.61.140.215) (Remote host closed the connection) |
| 2024-01-28 21:19:44 +0100 | ph88 | (~ph88@ip5b403f30.dynamic.kabel-deutschland.de) (Quit: Leaving) |
| 2024-01-28 21:25:49 +0100 | nicos | (~nsm@2800:2131:5400:883:28f6:1624:5755:79b0) (Ping timeout: 255 seconds) |
| 2024-01-28 21:25:58 +0100 | nicos | (~nsm@186.141.199.187) |
| 2024-01-28 21:30:13 +0100 | mobivme | (~mobivme@130.105.134.60) |
| 2024-01-28 21:37:13 +0100 | <shapr> | salut Hecate |
| 2024-01-28 21:37:17 +0100 | Guest70 | (~Guest70@72.142.115.10) |
| 2024-01-28 21:45:40 +0100 | fansly | (~fansly@2001:448a:2010:476e:c9c:17f1:874c:ee93) (Remote host closed the connection) |
| 2024-01-28 21:52:31 +0100 | fansly | (~fansly@2001:448a:2010:476e:c9c:17f1:874c:ee93) |
| 2024-01-28 22:02:22 +0100 | fansly | (~fansly@2001:448a:2010:476e:c9c:17f1:874c:ee93) (Remote host closed the connection) |
| 2024-01-28 22:05:03 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) (Remote host closed the connection) |
| 2024-01-28 22:05:43 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) |
| 2024-01-28 22:06:10 +0100 | mobivme | (~mobivme@130.105.134.60) (Ping timeout: 276 seconds) |
| 2024-01-28 22:09:27 +0100 | Guest70 | (~Guest70@72.142.115.10) (Quit: Client closed) |
| 2024-01-28 22:10:18 +0100 | <Rembane> | Tjenare Hecate och shapr! |
| 2024-01-28 22:10:29 +0100 | fansly | (~fansly@2001:448a:2010:476e:c9c:17f1:874c:ee93) |
| 2024-01-28 22:13:37 +0100 | ft | (~ft@p508dbda4.dip0.t-ipconnect.de) (Ping timeout: 246 seconds) |
| 2024-01-28 22:15:22 +0100 | ft | (~ft@p3e9bcb1e.dip0.t-ipconnect.de) |
| 2024-01-28 22:21:47 +0100 | <shapr> | tjenare Rembane, hur mår du? |
| 2024-01-28 22:22:22 +0100 | Erutuon | (~Erutuon@user/erutuon) |
| 2024-01-28 22:23:00 +0100 | <Rembane> | shapr: Jag mår bra, jag har precis kodat ett konstigt spel till Global Game Jam 2024, hur mår du? |
| 2024-01-28 22:27:20 +0100 | <shapr> | mår bra, skriver SQL just nu, har an intervju i morgon |
| 2024-01-28 22:27:45 +0100 | <shapr> | men också vill forstår lite mer av https://github.com/l-adic/stalk |
| 2024-01-28 22:27:58 +0100 | <shapr> | Haskell and zero knowledge proofs! |
| 2024-01-28 22:31:03 +0100 | <Rembane> | Roligt! :D |
| 2024-01-28 22:35:13 +0100 | nicos | (~nsm@186.141.199.187) (Read error: Connection reset by peer) |
| 2024-01-28 22:36:27 +0100 | nicos | (~nsm@2800:2131:5400:883:28f6:1624:5755:79b0) |
| 2024-01-28 22:37:41 +0100 | Guest70 | (~Guest70@72.142.116.21) |
| 2024-01-28 22:38:37 +0100 | fansly | (~fansly@2001:448a:2010:476e:c9c:17f1:874c:ee93) (Ping timeout: 268 seconds) |
| 2024-01-28 22:41:17 +0100 | Guest70 | (~Guest70@72.142.116.21) (Client Quit) |
| 2024-01-28 22:41:53 +0100 | fansly | (~fansly@103.3.221.236) |
| 2024-01-28 22:43:15 +0100 | <monochrom> | https://discourse.haskell.org/t/proposal-for-multiline-string-literals-accepted/8664 |
| 2024-01-28 22:43:22 +0100 | <monochrom> | That should be pretty nice. |
| 2024-01-28 22:48:16 +0100 | acidjnk_new | (~acidjnk@p200300d6e737e75650bac55cadf07511.dip0.t-ipconnect.de) (Ping timeout: 246 seconds) |
| 2024-01-28 22:50:52 +0100 | Erutuon | (~Erutuon@user/erutuon) (Ping timeout: 255 seconds) |
| 2024-01-28 23:00:48 +0100 | target_i | (~target_i@217.175.14.39) (Quit: leaving) |
| 2024-01-28 23:00:48 +0100 | igemnace | (~ian@user/igemnace) (Read error: Connection reset by peer) |
| 2024-01-28 23:03:08 +0100 | <ski> | > "abc\ \def" |
| 2024-01-28 23:03:09 +0100 | <lambdabot> | "abcdef" |
| 2024-01-28 23:03:31 +0100 | <ski> | (also with other whitespace, including newlines and tabs) |
| 2024-01-28 23:05:51 +0100 | <ski> | ah, i see SPJ pointed to string gaps in the report |
| 2024-01-28 23:09:32 +0100 | aljazmc | (~aljazmc@user/aljazmc) (Quit: Leaving) |
| 2024-01-28 23:15:28 +0100 | _ht | (~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Remote host closed the connection) |
| 2024-01-28 23:16:07 +0100 | takuan | (~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection) |
| 2024-01-28 23:17:48 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) |
| 2024-01-28 23:18:13 +0100 | igemnace | (~ian@user/igemnace) |
| 2024-01-28 23:23:07 +0100 | michalz | (~michalz@185.246.207.201) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2024-01-28 23:26:48 +0100 | Unicorn_Princess | (~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection) |
| 2024-01-28 23:40:41 +0100 | bobby | (~bob@user/yeahitsme) (Ping timeout: 256 seconds) |
| 2024-01-28 23:42:49 +0100 | <monochrom> | String gap works, but here documents are even better. :) |
| 2024-01-28 23:54:35 +0100 | [_] | (~itchyjunk@user/itchyjunk/x-7353470) |
| 2024-01-28 23:57:55 +0100 | [itchyjunk] | (~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 246 seconds) |
| 2024-01-28 23:59:28 +0100 | <mauke> | here-docs are two-dimensional syntax that can be "fun" to parse |