| 2023-01-18 00:05:53 +0100 | Volt_ | (~Volt_@c-73-167-118-200.hsd1.ma.comcast.net) |
| 2023-01-18 00:07:41 +0100 | <romes[m]> | Hi, I've got a cabal related question: |
| 2023-01-18 00:07:41 +0100 | <romes[m]> | I want to distribute games built with my engine to multiple platforms. Starting with MacOS, I want to copy the executable to a particular spot in the .app directory hierarchy. Besides copying the executable, I want to run something akin to `install_name_tool -change @rpath/libvulkan.1.dylib @executable_path/../Frameworks/libvulkan.1.dylib` and I want to copy `libvulkan.1.version.dylib`, `libMoltenVk.dylib` to and create a symlink from |
| 2023-01-18 00:07:41 +0100 | <romes[m]> | `libvulkan.1.dylib to libvulkan.1.version.dylib` in that hierarchy directory. Should this be done with cabal, or should I create an external tool with a library like Shake? |
| 2023-01-18 00:08:37 +0100 | <romes[m]> | I was also wondering whether it's possible to only run that at a "release" stage, while normal builds don't require that packaging step |
| 2023-01-18 00:08:59 +0100 | <c_wraith> | that sounds a bit out of scope for cabal |
| 2023-01-18 00:14:56 +0100 | fizbin_ | (~fizbin@user/fizbin) |
| 2023-01-18 00:15:14 +0100 | king_gs | (~Thunderbi@2806:103e:29:27ee:5edc:3ca0:b7bb:dc8a) |
| 2023-01-18 00:15:14 +0100 | king_gs | (~Thunderbi@2806:103e:29:27ee:5edc:3ca0:b7bb:dc8a) (Client Quit) |
| 2023-01-18 00:15:25 +0100 | <Axman6> | yeah a makefile would be my starting point for that |
| 2023-01-18 00:21:05 +0100 | Joao003 | (~Joao003@2804:840:8311:d200:a956:d19c:27e1:d97d) |
| 2023-01-18 00:21:20 +0100 | <Joao003> | hi |
| 2023-01-18 00:30:50 +0100 | fizbin_ | (~fizbin@user/fizbin) (Ping timeout: 256 seconds) |
| 2023-01-18 00:34:36 +0100 | __monty__ | (~toonn@user/toonn) (Quit: leaving) |
| 2023-01-18 00:36:33 +0100 | zmt00 | (~zmt00@user/zmt00) |
| 2023-01-18 00:44:52 +0100 | Guest|7 | (~Guest|7@ip2-197.halifax.rwth-aachen.de) (Quit: Connection closed) |
| 2023-01-18 00:46:49 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) |
| 2023-01-18 00:51:32 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 265 seconds) |
| 2023-01-18 00:54:23 +0100 | <romes[m]> | Indeed, it does look a bit out of scope for cabal |
| 2023-01-18 00:54:37 +0100 | <romes[m]> | I'm going to leave the distributing aspect out of cabal and use a dedicated tool :) |
| 2023-01-18 00:55:07 +0100 | <romes[m]> | But I'm still questioning myself on "what's the scope of cabal" |
| 2023-01-18 00:55:32 +0100 | <jackdk> | I would personally write a Nix expression to do the final swizzling and rearrangement |
| 2023-01-18 00:57:31 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:e4d3:d382:a4fe:296c) |
| 2023-01-18 00:58:40 +0100 | <monochrom> | The scope of cabal is building (and the dependency chasing you need for building). Possibly even narrower, building in the context of work in progress, not even building for the purpose of finishing, distributing, or deploying. |
| 2023-01-18 01:00:19 +0100 | <monochrom> | "cabal install" wants to be building for installing a finished product, but you can clearly see that it is unfair to ask end users to compile source code from scratch. |
| 2023-01-18 01:01:21 +0100 | laalyn | (~laalyn@c-73-241-126-7.hsd1.ca.comcast.net) |
| 2023-01-18 01:01:39 +0100 | <monochrom> | xmonad is OK with it because xmonad's config files are Haskell source code and requires end users to compile it anyway. |
| 2023-01-18 01:02:36 +0100 | <monochrom> | I wouldn't be surprised if cabal was designed for the xmonad model right from day one. |
| 2023-01-18 01:04:06 +0100 | waleee | (~waleee@h-176-10-137-138.NA.cust.bahnhof.se) (Ping timeout: 272 seconds) |
| 2023-01-18 01:05:27 +0100 | <hpc> | monochrom: the distinction you're looking for there i think is "building" vs "packaging" |
| 2023-01-18 01:05:33 +0100 | <hpc> | like gcc vs rpmbuild |
| 2023-01-18 01:05:38 +0100 | <hpc> | or maybe make vs rpmbuild |
| 2023-01-18 01:06:00 +0100 | <monochrom> | yeah |
| 2023-01-18 01:07:17 +0100 | <Joao003> | monochrom what is your problem |
| 2023-01-18 01:09:24 +0100 | <monochrom> | No, what is your problem? |
| 2023-01-18 01:10:42 +0100 | <Joao003> | didnt ask |
| 2023-01-18 01:10:47 +0100 | waleee | (~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) |
| 2023-01-18 01:11:33 +0100 | <mauke> | ? you literally did ask |
| 2023-01-18 01:12:32 +0100 | <hpc> | how can problems be real if questions aren't real? |
| 2023-01-18 01:13:11 +0100 | <Joao003> | i didnt ask for my problem lol |
| 2023-01-18 01:13:32 +0100 | <mauke> | no, that was monochrom. pay attention |
| 2023-01-18 01:13:37 +0100 | <geekosaur> | romes[m] asked a question before you joined |
| 2023-01-18 01:14:22 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) |
| 2023-01-18 01:14:46 +0100 | <romes[m]> | <hpc> "or maybe make vs rpmbuild" <- That's a good analogy |
| 2023-01-18 01:14:51 +0100 | <Joao003> | you code in haskell? name all builtins in prelude /s |
| 2023-01-18 01:15:20 +0100 | <EvanR> | there aren't any |
| 2023-01-18 01:15:20 +0100 | <romes[m]> | 0 |
| 2023-01-18 01:15:21 +0100 | <geekosaur> | enough |
| 2023-01-18 01:15:31 +0100 | ChanServ | +o geekosaur |
| 2023-01-18 01:15:45 +0100 | <Joao003> | wth geekosaur |
| 2023-01-18 01:16:57 +0100 | <Joao003> | guys |
| 2023-01-18 01:17:21 +0100 | <Joao003> | % let alternatingCaps = zipWith ($) (cycle [toUpper, toLower]) |
| 2023-01-18 01:17:21 +0100 | <yahb2> | <no output> |
| 2023-01-18 01:17:44 +0100 | <Joao003> | % alternatingCaps "look at this" |
| 2023-01-18 01:17:44 +0100 | <yahb2> | "LoOk aT ThIs" |
| 2023-01-18 01:25:59 +0100 | waleee | (~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Ping timeout: 246 seconds) |
| 2023-01-18 01:28:48 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) |
| 2023-01-18 01:33:09 +0100 | waleee | (~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) |
| 2023-01-18 01:34:18 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 256 seconds) |
| 2023-01-18 01:41:08 +0100 | Sgeo_ | (~Sgeo@user/sgeo) |
| 2023-01-18 01:42:51 +0100 | Sgeo | (~Sgeo@user/sgeo) (Ping timeout: 260 seconds) |
| 2023-01-18 01:44:06 +0100 | fizbin_ | (~fizbin@user/fizbin) |
| 2023-01-18 01:44:48 +0100 | fizbin__ | (~fizbin@user/fizbin) |
| 2023-01-18 01:45:04 +0100 | pagnol | (~user@213-205-209-87.ftth.glasoperator.nl) (Ping timeout: 256 seconds) |
| 2023-01-18 01:48:49 +0100 | fizbin_ | (~fizbin@user/fizbin) (Ping timeout: 260 seconds) |
| 2023-01-18 01:56:56 +0100 | wroathe | (~wroathe@207-153-38-140.fttp.usinternet.com) |
| 2023-01-18 01:56:56 +0100 | wroathe | (~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host) |
| 2023-01-18 01:56:56 +0100 | wroathe | (~wroathe@user/wroathe) |
| 2023-01-18 02:10:34 +0100 | fizbin__ | (~fizbin@user/fizbin) (Ping timeout: 256 seconds) |
| 2023-01-18 02:10:45 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) |
| 2023-01-18 02:10:47 +0100 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection) |
| 2023-01-18 02:12:07 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2023-01-18 02:12:56 +0100 | califax | (~califax@user/califx) |
| 2023-01-18 02:15:40 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 272 seconds) |
| 2023-01-18 02:16:55 +0100 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
| 2023-01-18 02:20:03 +0100 | fizbin__ | (~fizbin@user/fizbin) |
| 2023-01-18 02:21:53 +0100 | talismanick | (~talismani@campus-021-055.ucdavis.edu) |
| 2023-01-18 02:26:00 +0100 | <talismanick> | If I wanted to munge data in Git packfiles or SQLite files, which libraries offer the least resistance? cereal? |
| 2023-01-18 02:27:32 +0100 | <talismanick> | (for the latter, I'd let SQLite handle it & call using rel8 or Esqueleto, but that's not the point here) |
| 2023-01-18 02:30:52 +0100 | xff0x_ | (~xff0x@ai084091.d.east.v6connect.net) (Ping timeout: 272 seconds) |
| 2023-01-18 02:32:03 +0100 | Xeroine | (~Xeroine@user/xeroine) (Quit: ZNC 1.8.2+deb2+b1 - https://znc.in) |
| 2023-01-18 02:36:55 +0100 | Xeroine | (~Xeroine@user/xeroine) |
| 2023-01-18 02:37:35 +0100 | boxscape_ | (~boxscape_@81.191.27.107) (Ping timeout: 256 seconds) |
| 2023-01-18 02:37:44 +0100 | <jackdk> | talismanick: I would generally use cereal for binary wrangling yea. Note that you don't have to use the `Serialize` class and can call `runGet` or whatever on a decoder of type `Get a`. (I generally don't like serialisation typeclasses, but put up with them). `binary` has a bad instance for `Double` so I generally avoid it. |
| 2023-01-18 02:38:04 +0100 | <jackdk> | talismanick: another option is to parse with something like `attoparsec` and build using bytestring builders |
| 2023-01-18 02:38:30 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:e4d3:d382:a4fe:296c) (Ping timeout: 255 seconds) |
| 2023-01-18 02:39:13 +0100 | <talismanick> | jackdk: Thanks for the advice. I actually took the 2nd approach, but working with bytestrings feels rickety in a rather unHaskell way |
| 2023-01-18 02:39:14 +0100 | <jackdk> | talismanick: I tend to favour the former option e.g. https://git.sr.ht/~jack/codec-hostile-waters/tree/master/item/src/Codec/Game/HostileWaters/Mng.hs |
| 2023-01-18 02:39:34 +0100 | <talismanick> | (the first time I tried binary parsing in Haskell) |
| 2023-01-18 02:40:32 +0100 | <talismanick> | jackdk: So, not a fan of, say, Aeson? Preferred alternative to that? |
| 2023-01-18 02:41:55 +0100 | <talismanick> | or approach, generally - I don't imagine there is anything comparable to Aeson in programmer-hours of effort expended |
| 2023-01-18 02:42:30 +0100 | <jackdk> | talismanick: I use aeson and suck it up. But I make heavy use of newtype wrappers to ensure serialisation instances live at the serialisation boundary instead of on core types (this has bitten me in _every_ project of nontrivial size), and sometimes use https://hackage.haskell.org/package/ban-instance on core types to prevent accidental instances. |
| 2023-01-18 02:43:19 +0100 | <talismanick> | Interesting. I'll be studying that, then. |
| 2023-01-18 02:43:31 +0100 | <jackdk> | talismanick: Having predictable code for my colleagues is more important than re-inventing the JSON wheel, but if I needed something that aeson couldn't do (e.g., knowing the lexical order of keys within an object) I would probably teach myself https://hackage.haskell.org/package/waargonaut |
| 2023-01-18 02:45:42 +0100 | troydm | (~troydm@user/troydm) (Ping timeout: 256 seconds) |
| 2023-01-18 02:48:30 +0100 | razetime | (~Thunderbi@117.193.4.54) |
| 2023-01-18 02:50:14 +0100 | fizbin__ | (~fizbin@user/fizbin) (Ping timeout: 256 seconds) |
| 2023-01-18 02:52:59 +0100 | juri_ | (~juri@84-19-175-179.pool.ovpn.com) (Ping timeout: 260 seconds) |
| 2023-01-18 02:53:02 +0100 | <jackdk> | talismanick: Sometimes typeclass-driven encoding/decoding is necessary (e.g., when doing servant-style typelevel stuff), which is why I suggested a separate tag type parameter on waargonaut's JsonEncode class. |
| 2023-01-18 02:53:38 +0100 | raehik | (~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 256 seconds) |
| 2023-01-18 02:54:41 +0100 | talismanick | (~talismani@campus-021-055.ucdavis.edu) (Ping timeout: 255 seconds) |
| 2023-01-18 02:57:52 +0100 | wroathe | (~wroathe@user/wroathe) (Ping timeout: 268 seconds) |
| 2023-01-18 03:01:27 +0100 | geekosaur | -o geekosaur |
| 2023-01-18 03:01:37 +0100 | rembo10 | (~rembo10@main.remulis.com) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2023-01-18 03:03:38 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) |
| 2023-01-18 03:03:43 +0100 | waleee | (~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Ping timeout: 252 seconds) |
| 2023-01-18 03:03:45 +0100 | rembo10 | (~rembo10@main.remulis.com) |
| 2023-01-18 03:04:17 +0100 | thongpv | (~thongpv87@2001:ee0:5577:f0d0:fe01:28c6:d263:9ebf) (Remote host closed the connection) |
| 2023-01-18 03:04:36 +0100 | thongpv | (~thongpv87@2001:ee0:5577:f0d0:3e07:3355:d9d1:6eb5) |
| 2023-01-18 03:07:42 +0100 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 252 seconds) |
| 2023-01-18 03:10:00 +0100 | talismanick | (~talismani@campus-021-055.ucdavis.edu) |
| 2023-01-18 03:10:12 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 268 seconds) |
| 2023-01-18 03:11:58 +0100 | xff0x_ | (~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) |
| 2023-01-18 03:12:46 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) |
| 2023-01-18 03:16:23 +0100 | mizlan | (~mizlan@131.179.76.14) |
| 2023-01-18 03:19:08 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 256 seconds) |
| 2023-01-18 03:20:06 +0100 | jelewis2 | (~lewisje@2001:470:1f11:14e:1753:f4c6:e607:e65f) |
| 2023-01-18 03:22:36 +0100 | use-value | (~Thunderbi@2a00:23c6:8a03:2f01:c1c3:e297:674c:356d) (Remote host closed the connection) |
| 2023-01-18 03:22:55 +0100 | use-value | (~Thunderbi@2a00:23c6:8a03:2f01:c1c3:e297:674c:356d) |
| 2023-01-18 03:23:31 +0100 | lewisje | (~lewisje@2001:470:1f11:14e:6808:94ac:b726:e7c2) (Ping timeout: 252 seconds) |
| 2023-01-18 03:30:05 +0100 | thegeekinside | (~thegeekin@189.217.82.244) (Read error: Connection reset by peer) |
| 2023-01-18 03:31:45 +0100 | bgs | (~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection) |
| 2023-01-18 03:31:47 +0100 | talismanick | (~talismani@campus-021-055.ucdavis.edu) (Ping timeout: 268 seconds) |
| 2023-01-18 03:37:59 +0100 | jackhill | (~jackhill@kalessin.dragonsnail.net) (Ping timeout: 264 seconds) |
| 2023-01-18 03:38:58 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) (Ping timeout: 256 seconds) |
| 2023-01-18 03:39:11 +0100 | mizlan | (~mizlan@131.179.76.14) (Ping timeout: 268 seconds) |
| 2023-01-18 03:40:55 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) |
| 2023-01-18 03:41:48 +0100 | codaraxis | (~codaraxis@user/codaraxis) (Ping timeout: 256 seconds) |
| 2023-01-18 03:43:51 +0100 | jinsun__ | (~jinsun@user/jinsun) |
| 2023-01-18 03:43:51 +0100 | jinsun | Guest7600 |
| 2023-01-18 03:43:51 +0100 | Guest7600 | (~jinsun@user/jinsun) (Killed (cadmium.libera.chat (Nickname regained by services))) |
| 2023-01-18 03:43:51 +0100 | jinsun__ | jinsun |
| 2023-01-18 03:55:34 +0100 | nehsou^ | (~nehsou@76.145.190.81) (Remote host closed the connection) |
| 2023-01-18 04:06:34 +0100 | dsrt^ | (~dsrt@76.145.190.81) |
| 2023-01-18 04:10:55 +0100 | eggplantade | (~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) |
| 2023-01-18 04:13:17 +0100 | codaraxis | (~codaraxis@user/codaraxis) |
| 2023-01-18 04:14:25 +0100 | <anatta> | how do you feel about expressions going in multiple directions? |
| 2023-01-18 04:14:55 +0100 | mizlan | (~mizlan@2607:f010:2e9:21:c62:66e9:fe12:84f6) |
| 2023-01-18 04:15:47 +0100 | eggplantade | (~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 264 seconds) |
| 2023-01-18 04:16:13 +0100 | <anatta> | like this: myParser = Constructor <$> (spaces *> otherParser <* spaces) |
| 2023-01-18 04:16:56 +0100 | <glguy> | Constructor <$ spaces <*> otherParser <* spaces |
| 2023-01-18 04:17:16 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1812:9885:2ce4:4618) |
| 2023-01-18 04:18:06 +0100 | <anatta> | hm, yeah, maybe that's better |
| 2023-01-18 04:18:56 +0100 | <anatta> | to me that still reads both ways because <*> goes LTR in my head, but it's possible I'm just not used to it |
| 2023-01-18 04:19:54 +0100 | <glguy> | all the <$ <$> <* <*> *> operators associate left, so you just have to read the whole thing left to right to see what's been accumulated |
| 2023-01-18 04:20:53 +0100 | bilegeek | (~bilegeek@2600:1008:b047:ba16:b1d1:7621:aa43:a7a4) |
| 2023-01-18 04:21:57 +0100 | <Axman6> | glguy: huh, I'd never thought of doing that, that's neat |
| 2023-01-18 04:23:35 +0100 | segfaultfizzbuzz | (~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 264 seconds) |
| 2023-01-18 04:25:46 +0100 | instantaphex | (~jb@c-73-171-252-84.hsd1.fl.comcast.net) |
| 2023-01-18 04:33:04 +0100 | hgolden | (~hgolden@cpe-172-251-233-141.socal.res.rr.com) (Remote host closed the connection) |
| 2023-01-18 04:35:35 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds) |
| 2023-01-18 04:35:38 +0100 | barzo | (~hd@31.223.41.44) (Ping timeout: 256 seconds) |
| 2023-01-18 04:38:25 +0100 | superbil | (~superbil@1-34-176-171.hinet-ip.hinet.net) (Ping timeout: 268 seconds) |
| 2023-01-18 04:38:38 +0100 | <anatta> | on closer inspection I think I find my version easier to read |
| 2023-01-18 04:39:36 +0100 | mizlan | (~mizlan@2607:f010:2e9:21:c62:66e9:fe12:84f6) (Ping timeout: 256 seconds) |
| 2023-01-18 04:40:47 +0100 | scoopahdoopah | (~quassel@050-089-109-059.res.spectrum.com) |
| 2023-01-18 04:41:13 +0100 | superbil | (~superbil@1-34-176-171.hinet-ip.hinet.net) |
| 2023-01-18 04:41:58 +0100 | jmorris | (uid537181@id-537181.uxbridge.irccloud.com) |
| 2023-01-18 04:41:58 +0100 | razetime | (~Thunderbi@117.193.4.54) (Ping timeout: 272 seconds) |
| 2023-01-18 04:42:23 +0100 | chexum | (~quassel@gateway/tor-sasl/chexum) (Quit: No Ping reply in 180 seconds.) |
| 2023-01-18 04:42:30 +0100 | <monochrom> | :) |
| 2023-01-18 04:43:46 +0100 | chexum | (~quassel@gateway/tor-sasl/chexum) |
| 2023-01-18 04:45:04 +0100 | terrorjack | (~terrorjac@2a01:4f8:1c1e:4e8c::) (Quit: The Lounge - https://thelounge.chat) |
| 2023-01-18 04:45:46 +0100 | <glguy> | anatta: another minor topic, and this might not apply to your actual case if this is a synthetic example, but when building up a parser-combinator parser you'd generally only trim spaces off at the end of each thing |
| 2023-01-18 04:46:30 +0100 | terrorjack | (~terrorjac@2a01:4f8:1c1e:4e8c::) |
| 2023-01-18 04:47:03 +0100 | <monochrom> | In that case, Constructor <$> (openParen *> term <* closeParen) happens all the time. |
| 2023-01-18 04:47:22 +0100 | <glguy> | then it can be better to go with things like: between openP closeP ... |
| 2023-01-18 04:47:25 +0100 | <monochrom> | Alternatively openParen *> (Constrcutor <$> term) <* closeParen |
| 2023-01-18 04:47:28 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) |
| 2023-01-18 04:47:37 +0100 | <glguy> | or to name the wrapper for things that are between parentheses, rather than to repeat the pattern |
| 2023-01-18 04:47:40 +0100 | <anatta> | glguy: In this case it was mathematical expressions, and I couldn't figure out where to put the spaces, so I just put them around the integers |
| 2023-01-18 04:47:57 +0100 | <monochrom> | There is also whitespaces *> foo <* eof |
| 2023-01-18 04:48:04 +0100 | <anatta> | I figured you wouldn't get spaces between operators and parentheses |
| 2023-01-18 04:48:14 +0100 | <anatta> | so I thought it might be good enough |
| 2023-01-18 04:48:36 +0100 | <anatta> | (it wasn't that serious though, so I didn't really think *a lot* about it) |
| 2023-01-18 04:48:41 +0100 | <glguy> | the standard thing would be what monochom said at the outside and then every integer parser and token parser eats trailing spaces |
| 2023-01-18 04:49:06 +0100 | <anatta> | I see |
| 2023-01-18 04:49:18 +0100 | <Axman6> | and then your top level parser can be spaces *> expr |
| 2023-01-18 04:49:31 +0100 | <anatta> | what about when you generate the parsers automatically? |
| 2023-01-18 04:49:38 +0100 | <glguy> | this starts to matter in parser combinator libraries like megaparsec and parsec where they are optimized to prune alternatives as soon as any characters are consumed |
| 2023-01-18 04:49:52 +0100 | <Axman6> | just follow the rule that each parser handles its own trailing whitespace and things get easier |
| 2023-01-18 04:49:58 +0100 | <glguy> | You'd especially do it this way when generating them automatically so that your automatic generation scheme is likely to work |
| 2023-01-18 04:50:09 +0100 | <anatta> | like, I don't have access to the operator parsers |
| 2023-01-18 04:50:11 +0100 | <glguy> | less chance for someone to carefully think about where to add them |
| 2023-01-18 04:50:18 +0100 | <anatta> | so I can't add whitespace to them |
| 2023-01-18 04:50:58 +0100 | <glguy> | Oh, well I'm sure someone could contrive an example where you'd have to add extra whitespace handling |
| 2023-01-18 04:51:10 +0100 | <Axman6> | generally if you're using somethat creates it for you, you'll be able to provide a token lexer |
| 2023-01-18 04:51:26 +0100 | <Axman6> | something that* |
| 2023-01-18 04:51:33 +0100 | <anatta> | sec, I can't remember what it was called and I'm at the wrong computer, let me find it |
| 2023-01-18 04:51:46 +0100 | <Axman6> | and each token takes care of its own trailing whitespace |
| 2023-01-18 04:51:51 +0100 | finn_elija | (~finn_elij@user/finn-elija/x-0085643) |
| 2023-01-18 04:51:51 +0100 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija))) |
| 2023-01-18 04:51:51 +0100 | finn_elija | FinnElija |
| 2023-01-18 04:52:10 +0100 | <anatta> | I was using this: |
| 2023-01-18 04:52:12 +0100 | <anatta> | https://hackage.haskell.org/package/parsec-3.1.16.1/docs/Text-Parsec-Expr.html |
| 2023-01-18 04:52:24 +0100 | <anatta> | with the buildExpressionParser |
| 2023-01-18 04:52:52 +0100 | <glguy> | you'd definitely use trailing whitespace parsing in this case |
| 2023-01-18 04:53:03 +0100 | <glguy> | because parsec relies on that for efficient parsing |
| 2023-01-18 04:53:17 +0100 | <monochrom> | buildExpressionParser honours the skip-trailing-spaces convention. |
| 2023-01-18 04:53:56 +0100 | <anatta> | hmhm, so I could just do e.g. |
| 2023-01-18 04:54:09 +0100 | <anatta> | expr = buildExpressionParser table term; term = parens expr <|> int |
| 2023-01-18 04:54:20 +0100 | <anatta> | and if my int parser only skips trailing spaces |
| 2023-01-18 04:54:23 +0100 | <anatta> | it's fine? |
| 2023-01-18 04:54:38 +0100 | <monochrom> | Your parens also need to skip trailing whitespaces. |
| 2023-01-18 04:54:39 +0100 | <Axman6> | sounds likely |
| 2023-01-18 04:54:46 +0100 | <monochrom> | But that's it. |
| 2023-01-18 04:54:57 +0100 | <Axman6> | each lexeme needs to skip spaces |
| 2023-01-18 04:55:28 +0100 | td_ | (~td@83.135.9.4) (Ping timeout: 256 seconds) |
| 2023-01-18 04:56:41 +0100 | <anatta> | hmhm, I'll play around with it a bit - I'm more used to writing a grammar and generating the parsers from that so this is interesting |
| 2023-01-18 04:56:57 +0100 | td_ | (~td@83.135.9.57) |
| 2023-01-18 04:57:28 +0100 | <Axman6> | often writing your parser will end up looking very much like a grammar anyway |
| 2023-01-18 05:00:09 +0100 | <anatta> | but you get "free lexing" if you just run alex/happy on your BNF grammar :p |
| 2023-01-18 05:02:38 +0100 | phma_ | (~phma@host-67-44-208-74.hnremote.net) |
| 2023-01-18 05:06:22 +0100 | phma | (phma@2001:5b0:211c:1148:cd31:3368:6dc4:8d0d) (Ping timeout: 252 seconds) |
| 2023-01-18 05:06:23 +0100 | <anatta> | anyway, I'll sleep on it - glguy, monochrom, Axman6: thanks for patiently explaining stuff to me =) |
| 2023-01-18 05:06:36 +0100 | azimut_ | (~azimut@gateway/tor-sasl/azimut) |
| 2023-01-18 05:07:14 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection) |
| 2023-01-18 05:11:31 +0100 | instantaphex | (~jb@c-73-171-252-84.hsd1.fl.comcast.net) (Quit: Lost terminal) |
| 2023-01-18 05:12:19 +0100 | <Axman6> | Sleep well! |
| 2023-01-18 05:15:50 +0100 | oldfashionedcow | (~Rahul_San@user/oldfashionedcow) (Quit: WeeChat 3.7.1) |
| 2023-01-18 05:30:43 +0100 | bilegeek | (~bilegeek@2600:1008:b047:ba16:b1d1:7621:aa43:a7a4) (Quit: Leaving) |
| 2023-01-18 05:34:50 +0100 | razetime | (~Thunderbi@117.193.4.54) |
| 2023-01-18 05:45:16 +0100 | <Inst_> | go actually has a lot to admire |
| 2023-01-18 05:45:27 +0100 | <Inst_> | not in the sense of the language, but the on-boarding materials |
| 2023-01-18 05:45:42 +0100 | Inst_ | Inst |
| 2023-01-18 05:46:04 +0100 | <Inst> | very nice interactive tutorials |
| 2023-01-18 05:46:20 +0100 | <Inst> | i guess Python and Go are the languages to study for onboarding |
| 2023-01-18 05:46:39 +0100 | <Inst> | https://go.dev/tour/welcome/1 |
| 2023-01-18 05:46:42 +0100 | <Inst> | we have tryhaskell.org |
| 2023-01-18 05:49:06 +0100 | sammelweis | (~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Quit: No Ping reply in 180 seconds.) |
| 2023-01-18 05:50:13 +0100 | sammelweis | (~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) |
| 2023-01-18 05:50:42 +0100 | hgolden | (~hgolden@cpe-172-251-233-141.socal.res.rr.com) |
| 2023-01-18 05:52:26 +0100 | <maerwald[m]> | Inst: https://play-haskell.tomsmeding.com/play |
| 2023-01-18 05:53:50 +0100 | <Inst> | this is shit |
| 2023-01-18 05:53:58 +0100 | <Inst> | why isn't Haskell.org linking this? |
| 2023-01-18 05:54:31 +0100 | <Inst> | they're still linked to tryhaskell.org via their playground |
| 2023-01-18 05:55:49 +0100 | phma_ | phma |
| 2023-01-18 05:55:57 +0100 | <Inst> | by shit, i mean, it's shit than haskell.org isn't linking or cloning it |
| 2023-01-18 05:57:32 +0100 | <dsal> | go has a team incentivized to make people want to use go on production systems. |
| 2023-01-18 05:57:59 +0100 | tsandstr | (~user@2601:18b:8100:7300::524) |
| 2023-01-18 05:59:18 +0100 | <energizer> | introductory tutorial aint the same thing as production systems |
| 2023-01-18 05:59:21 +0100 | <tsandstr> | Quick question about parser combinators (I am playing with attoparsec). Is there an idiomatic way to write a parser which skips over *all* whitespace that it encounters? I can't help but feel like there is a better way than to scatter `skipSpaces` on every other line |
| 2023-01-18 06:00:01 +0100 | <tsandstr> | I have laso thought about something like `sequence (intersperse skipSpace steps)` where `steps` is a list of parsers, but this feels ugly |
| 2023-01-18 06:00:20 +0100 | <Inst> | yeah, but Haskell has HF |
| 2023-01-18 06:00:28 +0100 | <Inst> | also, HF should want to clone The Go Programming Language |
| 2023-01-18 06:00:45 +0100 | <Inst> | erm, port it to Haskell, they at least have SPJ on board |
| 2023-01-18 06:01:04 +0100 | <Inst> | unless Addison Wesley trademarked "The foo Programming Language" |
| 2023-01-18 06:01:35 +0100 | Volt_ | (~Volt_@c-73-167-118-200.hsd1.ma.comcast.net) (Quit: ) |
| 2023-01-18 06:02:05 +0100 | Volt_ | (~Volt_@c-73-167-118-200.hsd1.ma.comcast.net) |
| 2023-01-18 06:03:20 +0100 | azimut_ | (~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds) |
| 2023-01-18 06:04:33 +0100 | <tsandstr> | Should I maybe define my own monad type with a bind operator that shoves a skipSpace in between everything? Or is that nonsense? |
| 2023-01-18 06:06:12 +0100 | acidjnk | (~acidjnk@p200300d6e715c4916947822429b47882.dip0.t-ipconnect.de) |
| 2023-01-18 06:07:39 +0100 | troydm | (~troydm@user/troydm) |
| 2023-01-18 06:11:09 +0100 | meinside | (uid24933@id-24933.helmsley.irccloud.com) |
| 2023-01-18 06:13:11 +0100 | <dsal> | tsandstr: You generally parse an item with a "lexeme" that eats space after a token so the next token is ready to be parsed. |
| 2023-01-18 06:15:00 +0100 | <tsandstr> | dsal: So, I would have some sort of function `keyword :: String -> Parser ()` that does something like `keyword s = string s <* skipSpace` |
| 2023-01-18 06:15:31 +0100 | laalyn | (~laalyn@c-73-241-126-7.hsd1.ca.comcast.net) (Quit: Client closed) |
| 2023-01-18 06:16:26 +0100 | <tsandstr> | Or am I oversimplifying? |
| 2023-01-18 06:19:42 +0100 | razetime | (~Thunderbi@117.193.4.54) (Quit: See You Space Cowboy) |
| 2023-01-18 06:20:39 +0100 | Xeroine | (~Xeroine@user/xeroine) (Ping timeout: 260 seconds) |
| 2023-01-18 06:22:33 +0100 | Xeroine | (~Xeroine@user/xeroine) |
| 2023-01-18 06:31:48 +0100 | jao | (~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) (Ping timeout: 256 seconds) |
| 2023-01-18 06:36:40 +0100 | <Inst> | https://play-haskell.tomsmeding.com |
| 2023-01-18 06:36:42 +0100 | <Inst> | what is this? |
| 2023-01-18 06:36:56 +0100 | <Inst> | or rather, what's the advantage of the mergesort algorithm used here over other mergesorts? |
| 2023-01-18 06:43:08 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 256 seconds) |
| 2023-01-18 06:47:26 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) (Ping timeout: 255 seconds) |
| 2023-01-18 06:51:45 +0100 | jmorris | (uid537181@id-537181.uxbridge.irccloud.com) (Quit: Connection closed for inactivity) |
| 2023-01-18 06:54:40 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) |
| 2023-01-18 07:01:56 +0100 | <dsal> | tsandstr: https://hackage.haskell.org/package/megaparsec-9.3.0/docs/Text-Megaparsec-Byte-Lexer.html#v:lexeme |
| 2023-01-18 07:04:16 +0100 | <dsal> | So you'd `lexeme keyword` where you needed a keyword and didn't care about eating stuff after it. Your lexeme function decides how space should be eaten in that context. |
| 2023-01-18 07:04:32 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds) |
| 2023-01-18 07:06:46 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) |
| 2023-01-18 07:10:07 +0100 | <Jadesheit[m]> | `foo = (/ 2) . (pred >>= (*))` is this readable? Why or why not? |
| 2023-01-18 07:10:41 +0100 | acidjnk | (~acidjnk@p200300d6e715c4916947822429b47882.dip0.t-ipconnect.de) (Ping timeout: 246 seconds) |
| 2023-01-18 07:10:41 +0100 | <glguy> | better to just write: foo x = (x * (x-1))/2 |
| 2023-01-18 07:13:02 +0100 | <Jadesheit[m]> | yeah, I know how it expands, I'm just wondering whether it is readable |
| 2023-01-18 07:13:05 +0100 | titibandit1 | (~titibandi@xdsl-81-173-160-143.nc.de) |
| 2023-01-18 07:14:05 +0100 | <glguy> | I'd consider it strictly worse than writing it out directly |
| 2023-01-18 07:14:26 +0100 | <glguy> | and lots of Haskellers won't know what it does without expending some effort |
| 2023-01-18 07:15:38 +0100 | bgs | (~bgs@212-85-160-171.dynamic.telemach.net) |
| 2023-01-18 07:22:37 +0100 | <Jadesheit[m]> | lets imagine a situation where we had x * (x - 1) alone |
| 2023-01-18 07:22:56 +0100 | <Jadesheit[m]> | would you consider `foo = pred >>= (*)` to be worse still? |
| 2023-01-18 07:23:14 +0100 | <Jadesheit[m]> | (looking for a genuine answer, not trying to argue) |
| 2023-01-18 07:25:20 +0100 | <dsal> | It depends on your goals, I guess. What's your goal here? If it's "write the most readable code" then I don't think that's helping. |
| 2023-01-18 07:25:56 +0100 | <Jadesheit[m]> | yeah, that makes sense |
| 2023-01-18 07:25:58 +0100 | <Jadesheit[m]> | thank you |
| 2023-01-18 07:26:41 +0100 | thongpv | (~thongpv87@2001:ee0:5577:f0d0:3e07:3355:d9d1:6eb5) (Remote host closed the connection) |
| 2023-01-18 07:27:05 +0100 | thongpv | (~thongpv87@2001:ee0:5577:f0d0:346e:4e3b:9993:32a8) |
| 2023-01-18 07:30:49 +0100 | takuan | (~takuan@178-116-218-225.access.telenet.be) |
| 2023-01-18 07:42:36 +0100 | kenran | (~user@user/kenran) |
| 2023-01-18 07:44:43 +0100 | kenran | (~user@user/kenran) (Remote host closed the connection) |
| 2023-01-18 07:46:02 +0100 | tomku | (~tomku@user/tomku) (Ping timeout: 256 seconds) |
| 2023-01-18 07:47:34 +0100 | tomku | (~tomku@user/tomku) |
| 2023-01-18 07:47:43 +0100 | gmg | (~user@user/gehmehgeh) |
| 2023-01-18 07:53:31 +0100 | talismanick | (~talismani@2601:200:c181:4c40::1be2) |
| 2023-01-18 08:08:08 +0100 | trev | (~trev@user/trev) |
| 2023-01-18 08:11:06 +0100 | vykt | (~vykt@92.40.124.204.threembb.co.uk) |
| 2023-01-18 08:11:15 +0100 | lortabac | (~lortabac@2a01:e0a:541:b8f0:5001:9128:80c0:62b0) |
| 2023-01-18 08:11:28 +0100 | <vykt> | I know next to nothing about Haskell. What is it good for? |
| 2023-01-18 08:12:01 +0100 | <vykt> | I've been considering learning it because functional programming sounds cool. |
| 2023-01-18 08:17:10 +0100 | <jackdk> | Haskell is my favourite general-purpose programming language, because I think FP is a great paradigm for solving problems. Professionally, I use it mostly for back-end web services |
| 2023-01-18 08:22:08 +0100 | <dsal> | Yeah, I use Haskell for any programming I need to do. I use at work for moving money around. |
| 2023-01-18 08:22:15 +0100 | <dsal> | Haskell's nice because of all the things you can make not work. |
| 2023-01-18 08:26:11 +0100 | <jackdk> | vykt: what do you think of when you say "functional programming", and do you have any questions that could help us focus our responses? |
| 2023-01-18 08:32:18 +0100 | laalyn | (~laalyn@c-73-241-126-7.hsd1.ca.comcast.net) |
| 2023-01-18 08:32:44 +0100 | <[exa]> | vykt: we had this brainstorming session here a few years back finding widely-used software written in haskell, check out the logs (see topic) |
| 2023-01-18 08:33:05 +0100 | <c_wraith> | I think Haskell is probably best for writing software. It's not great for building swimming pools or raising cattle. |
| 2023-01-18 08:33:21 +0100 | <[exa]> | vykt: anyway everyone's favorite is I guess pandoc, parsing and manipulating even really complicated syntax structures is moreless straightforward in haskell |
| 2023-01-18 08:34:49 +0100 | <[exa]> | vykt: ...at least compared to the usual gymnastics you're forced to do in mainstream languages for parsing stuff |
| 2023-01-18 08:35:34 +0100 | mbuf | (~Shakthi@49.204.129.175) |
| 2023-01-18 08:35:49 +0100 | <c_wraith> | Within the software realm, I think haskell pays off best when you intend to work on a product that you maintain long-term. That's where its advantages pay off the most. (They pay off in other places too, but not all of them, and not to the same extent) |
| 2023-01-18 08:37:24 +0100 | <jackdk> | I do think it's really good for quick hacky stuff, because you can avoid hacking up footguns |
| 2023-01-18 08:37:48 +0100 | <c_wraith> | Oh, I can reintroduce all those footguns very quickly. :P |
| 2023-01-18 08:38:16 +0100 | <c_wraith> | It's when I care *not* to that things go best :) |
| 2023-01-18 08:39:39 +0100 | <[exa]> | yeah and the workflow "omgomg dep update broke things" --> "trivially fix the 10 type errors that compiler reported" --> "all okay" |
| 2023-01-18 08:39:46 +0100 | <[exa]> | (reliably) |
| 2023-01-18 08:43:12 +0100 | coot | (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) |
| 2023-01-18 08:46:10 +0100 | <vykt> | Thanks for the replies guys. |
| 2023-01-18 08:46:20 +0100 | <vykt> | jackdk: No idea yet, I'm going into it blind. |
| 2023-01-18 08:47:18 +0100 | mmhat | (~mmh@p200300f1c7123cecee086bfffe095315.dip0.t-ipconnect.de) |
| 2023-01-18 08:47:57 +0100 | <jackdk> | To me, functional programming means programming with pure functions: functions that have no side-effects, and whose outputs depend only on their inputs. Because Haskell takes this idea extremely seriously, there are a lot of consequences to this idea, and it can take a while to shake off old instincts about how to solve problems. |
| 2023-01-18 09:10:22 +0100 | <maerwald[m]> | That's the theory |
| 2023-01-18 09:10:55 +0100 | int-index | (~Vladislav@2a00:1370:8178:5994:bd51:c650:be55:9635) |
| 2023-01-18 09:12:10 +0100 | shriekingnoise | (~shrieking@186.137.175.87) (Ping timeout: 256 seconds) |
| 2023-01-18 09:12:29 +0100 | Volt_ | (~Volt_@c-73-167-118-200.hsd1.ma.comcast.net) (Quit: ) |
| 2023-01-18 09:13:11 +0100 | Volt_ | (~Volt_@c-73-167-118-200.hsd1.ma.comcast.net) |
| 2023-01-18 09:14:56 +0100 | kee | (~~kee@user/wizzwizz4) (Ping timeout: 272 seconds) |
| 2023-01-18 09:16:23 +0100 | sterni | (~lukas@user/sterni) (Ping timeout: 264 seconds) |
| 2023-01-18 09:19:34 +0100 | enoq | (~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) |
| 2023-01-18 09:21:35 +0100 | razetime | (~Thunderbi@117.193.4.54) |
| 2023-01-18 09:23:25 +0100 | mmhat | (~mmh@p200300f1c7123cecee086bfffe095315.dip0.t-ipconnect.de) (Quit: WeeChat 3.8) |
| 2023-01-18 09:25:14 +0100 | <merijn> | c_wraith: It also pays off with codebases you don't touch intermittently for over a year :p |
| 2023-01-18 09:25:35 +0100 | <c_wraith> | is that not what maintenance is? :P |
| 2023-01-18 09:27:13 +0100 | Sgeo_ | (~Sgeo@user/sgeo) (Read error: Connection reset by peer) |
| 2023-01-18 09:29:01 +0100 | CiaoSen | (~Jura@p200300c95723a5002a3a4dfffe84dbd5.dip0.t-ipconnect.de) |
| 2023-01-18 09:31:55 +0100 | nschoe | (~q@141.101.51.197) |
| 2023-01-18 09:33:40 +0100 | <maerwald[m]> | The worst code I've ever worked with was written in Haskell. The above mentioned concepts don't shield from poor engineering. Rather they can enable good engineering |
| 2023-01-18 09:34:16 +0100 | <maerwald[m]> | These days I'm more interested in what good engineering is and less in languages |
| 2023-01-18 09:34:29 +0100 | kee | (~~kee@user/wizzwizz4) |
| 2023-01-18 09:35:20 +0100 | <merijn> | @quote Unknown in.any.language |
| 2023-01-18 09:35:21 +0100 | <lambdabot> | Unknown says: Real programmers can write assembly code in any language. :-) |
| 2023-01-18 09:35:52 +0100 | <merijn> | maerwald[m]: Well, if I'm the one responsible for doing good engineering, I care about languages which make that easier ;) |
| 2023-01-18 09:41:21 +0100 | fserucas | (~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7) |
| 2023-01-18 09:44:35 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) |
| 2023-01-18 09:48:50 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 252 seconds) |
| 2023-01-18 09:49:33 +0100 | <lortabac> | maerwald[m]: theoretically I agree with you, but in practice I consistently find that my Haskell code is easier to maintain that my code written in other languages |
| 2023-01-18 09:49:44 +0100 | <lortabac> | *than my code |
| 2023-01-18 09:50:47 +0100 | <lortabac> | I have too much empirical evidence to dismiss this as a coincidence |
| 2023-01-18 09:51:11 +0100 | <int-index> | maerwald[m]: what is good engineering? do you have books or other resources on this topic, either language agnostic or applicable in Haskell? |
| 2023-01-18 09:51:21 +0100 | boxscape_ | (~boxscape_@81.191.27.107) |
| 2023-01-18 09:52:59 +0100 | <merijn> | int-index: If I (or maerwald[m] or anyone else) knew how to explicitly quantify and/or teach "good engineering" most of the world's software wouldn't be so terrible ;) |
| 2023-01-18 09:53:28 +0100 | laalyn | (~laalyn@c-73-241-126-7.hsd1.ca.comcast.net) (Quit: Client closed) |
| 2023-01-18 09:54:46 +0100 | ft | (~ft@p4fc2a257.dip0.t-ipconnect.de) (Quit: leaving) |
| 2023-01-18 09:54:55 +0100 | <int-index> | merijn: not asking for a formal definition or a tutorial, but surely there must be case studies, examples and counterexamples |
| 2023-01-18 09:55:07 +0100 | <int-index> | if the concept exists, we should be able to observe it |
| 2023-01-18 09:55:18 +0100 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) |
| 2023-01-18 09:56:28 +0100 | gmg | (~user@user/gehmehgeh) (Quit: Leaving) |
| 2023-01-18 09:59:09 +0100 | <energizer> | int-index: there are lots of people who claim to know how to identify and reproduce it. whether they're correct is more of a question |
| 2023-01-18 09:59:13 +0100 | <merijn> | good engineering is like porn...I know it when I see it ;) |
| 2023-01-18 10:00:41 +0100 | kuttenbrunzer | (~kuttenbru@2a02:8108:8b80:1d48:a105:a414:232d:e96d) |
| 2023-01-18 10:01:39 +0100 | kuttenbrunzer | (~kuttenbru@2a02:8108:8b80:1d48:a105:a414:232d:e96d) (Read error: Connection reset by peer) |
| 2023-01-18 10:08:28 +0100 | tzh | (~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz) |
| 2023-01-18 10:09:01 +0100 | razetime | (~Thunderbi@117.193.4.54) (Remote host closed the connection) |
| 2023-01-18 10:11:19 +0100 | titibandit1 | (~titibandi@xdsl-81-173-160-143.nc.de) (Remote host closed the connection) |
| 2023-01-18 10:12:10 +0100 | talismanick | (~talismani@2601:200:c181:4c40::1be2) (Ping timeout: 252 seconds) |
| 2023-01-18 10:13:56 +0100 | thongpv | (~thongpv87@2001:ee0:5577:f0d0:346e:4e3b:9993:32a8) (Ping timeout: 256 seconds) |
| 2023-01-18 10:15:00 +0100 | romesrf | (~romes@192.22.63.94.rev.vodafone.pt) |
| 2023-01-18 10:19:42 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1812:9885:2ce4:4618) (Remote host closed the connection) |
| 2023-01-18 10:25:39 +0100 | <Guillaum[m]> | I have an interesting (well, from my point of view ;) problem. I do have a ByteStream (let say a Stream from streaming) which is only composed of pure operation (i.e. no stored internal effects). I do have a retry strategy (retry (useMyStream myStream)) where "retry" just indefinitely retry until the operation useMyStream succeed. Unfortunately, this retry strategy realizes the complete stream in memory (which is unfortunate, it uses 10 |
| 2023-01-18 10:25:39 +0100 | <Guillaum[m]> | GiB of RAM as a linked list of small ByteString, so it kills my ram and GC efficency). Is there a way to "split" a reference (to myStream), so the consumer (useMyStream) will unfold lazyly the stream in O(1) memory, and the remaining reference will keep a "lazy" reference to the rest of the stream. |
| 2023-01-18 10:28:28 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) |
| 2023-01-18 10:32:41 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 246 seconds) |
| 2023-01-18 10:34:45 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) |
| 2023-01-18 10:35:57 +0100 | avicenzi | (~avicenzi@2a00:ca8:a1f:b004::c32) |
| 2023-01-18 10:36:48 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2023-01-18 10:37:35 +0100 | califax | (~califax@user/califx) |
| 2023-01-18 10:39:18 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) (Ping timeout: 260 seconds) |
| 2023-01-18 10:40:20 +0100 | pagnol | (~user@213-205-209-87.ftth.glasoperator.nl) |
| 2023-01-18 10:42:22 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2023-01-18 10:44:07 +0100 | califax | (~califax@user/califx) |
| 2023-01-18 10:51:13 +0100 | MajorBiscuit | (~MajorBisc@145.94.179.130) |
| 2023-01-18 10:52:39 +0100 | alt-romes | (~romes@192.22.63.94.rev.vodafone.pt) |
| 2023-01-18 10:55:23 +0100 | romesrf | (~romes@192.22.63.94.rev.vodafone.pt) (Ping timeout: 248 seconds) |
| 2023-01-18 11:02:22 +0100 | <maerwald[m]> | int-index: don't have books. But there are recurring topics. I believe it's a lot about the ways you think about programs. Composition, control flow, abstraction layers, boundaries, effects, complexity, ... |
| 2023-01-18 11:03:13 +0100 | <maerwald[m]> | Programmers usually build up intuition about these through negative (not positive) experience imo |
| 2023-01-18 11:06:02 +0100 | <int-index> | I'll read yours if you write one :-) |
| 2023-01-18 11:07:39 +0100 | Unicorn_Princess | (~Unicorn_P@user/Unicorn-Princess/x-3540542) |
| 2023-01-18 11:09:33 +0100 | opticblast | (~Thunderbi@secure-165.caltech.edu) |
| 2023-01-18 11:09:34 +0100 | <int-index> | The list of topics is interesting, but it doesn't tell me what you think counts as good (or bad) engineering with regards to those topics. |
| 2023-01-18 11:10:02 +0100 | xff0x_ | (~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 256 seconds) |
| 2023-01-18 11:10:39 +0100 | <maerwald[m]> | Yeah, I think we often go the wrong route trying to be very technical about metrics, like cyclomatic complexity |
| 2023-01-18 11:10:40 +0100 | <maerwald[m]> | When in the end it's the programmer with his brain who needs to get it |
| 2023-01-18 11:11:25 +0100 | <maerwald[m]> | Seeing the program as a form of communication as well |
| 2023-01-18 11:14:43 +0100 | <lortabac> | perhaps some parts of what constitues good engineering are actually measurable |
| 2023-01-18 11:15:00 +0100 | <int-index> | I've got some opinions on how code should or shouldn't be written, but I can't really tell if I have a feel for good engineering or if I just have... opinions. |
| 2023-01-18 11:15:08 +0100 | <lortabac> | for example measuring how long it takes for a newcomer to understand the code |
| 2023-01-18 11:15:41 +0100 | <int-index> | So you say that you're more interested in good engineering than languages, which is why I was hoping I could cross check my opinions against the ones of someone who actually put some thougts into what makes engineering good |
| 2023-01-18 11:16:13 +0100 | <maerwald[m]> | Lots of thoughts, mostly unstructured though |
| 2023-01-18 11:16:32 +0100 | troydm | (~troydm@user/troydm) (Ping timeout: 272 seconds) |
| 2023-01-18 11:16:54 +0100 | <merijn> | same :p |
| 2023-01-18 11:17:22 +0100 | panovia | (~user@user/siracusa) (Quit: Bye!) |
| 2023-01-18 11:18:43 +0100 | <maerwald[m]> | https://www.cs.vu.nl/~wanf/pubs/wodes22-storm_surge_barrier.pdf |
| 2023-01-18 11:18:44 +0100 | ubert1 | (~Thunderbi@2a02:8109:abc0:6434:774d:958d:e54d:fb2f) |
| 2023-01-18 11:18:54 +0100 | <maerwald[m]> | One of my favorites on this topic |
| 2023-01-18 11:19:15 +0100 | <merijn> | ah, that's the one about the Deltawerken, right? |
| 2023-01-18 11:20:11 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1812:9885:2ce4:4618) |
| 2023-01-18 11:20:31 +0100 | <maerwald[m]> | Don't know. But they had to approach the thing differently than a crazy blockchain startup |
| 2023-01-18 11:21:13 +0100 | <maerwald[m]> | I think good engineering always cryztallizes when safety or security is involved |
| 2023-01-18 11:21:15 +0100 | <merijn> | ah, yeah, that seems to be a shorter version of the longer report |
| 2023-01-18 11:22:30 +0100 | <maerwald[m]> | E.g. the LANGSEC project that tried to define how to think of program input |
| 2023-01-18 11:23:01 +0100 | <maerwald[m]> | And what it even means for a program to be "secure" |
| 2023-01-18 11:23:24 +0100 | __monty__ | (~toonn@user/toonn) |
| 2023-01-18 11:23:40 +0100 | <maerwald[m]> | Maybe ChatGPT can answer all that and we'll go back watching Netflix. |
| 2023-01-18 11:24:37 +0100 | <dminuoso> | Im already working to connect ChatGPT to Slack and Emacs, so I can just kickback and bingewatch Stargate SG1 all over again while getting paaid. |
| 2023-01-18 11:24:43 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1812:9885:2ce4:4618) (Ping timeout: 248 seconds) |
| 2023-01-18 11:25:13 +0100 | <merijn> | dminuoso: Did you watch The Orville yet? |
| 2023-01-18 11:25:22 +0100 | <dminuoso> | Of course, best Star Trek since TNG |
| 2023-01-18 11:25:28 +0100 | <maerwald[m]> | ChatGPT will be writing the script for the next SG episode too |
| 2023-01-18 11:25:51 +0100 | <merijn> | It's on my list, but so far I couldn't be arsed to get access to it :p |
| 2023-01-18 11:25:54 +0100 | <maerwald[m]> | We've covered input and output |
| 2023-01-18 11:26:06 +0100 | <maerwald[m]> | Cycle completed |
| 2023-01-18 11:26:16 +0100 | <dminuoso> | merijn: It's more Star Trek than most Star Trek series. It's that good. |
| 2023-01-18 11:26:20 +0100 | <merijn> | It's looking very much like a "yarrrrrr!" situation |
| 2023-01-18 11:27:00 +0100 | <dminuoso> | maerwald[m]: Cunning. |
| 2023-01-18 11:28:08 +0100 | thongpv | (~thongpv87@2001:ee0:5577:f0d0:60c4:8c39:337d:f64b) |
| 2023-01-18 11:28:08 +0100 | <dminuoso> | https://hackage.haskell.org/package/base-4.17.0.0/docs/Data-Tuple.html#t:Solo |
| 2023-01-18 11:28:12 +0100 | <dminuoso> | Huh I just learned today this exists. |
| 2023-01-18 11:28:41 +0100 | <dminuoso> | I guess that makes `Only` obsolete? |
| 2023-01-18 11:28:43 +0100 | scoopahdoopah | (~quassel@050-089-109-059.res.spectrum.com) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.) |
| 2023-01-18 11:29:01 +0100 | <dminuoso> | Ah not quite, thats a newtype rather than data. |
| 2023-01-18 11:29:12 +0100 | gnalzo | (~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) |
| 2023-01-18 11:30:25 +0100 | bitdex_ | (~bitdex@gateway/tor-sasl/bitdex) |
| 2023-01-18 11:31:50 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds) |
| 2023-01-18 11:34:45 +0100 | <jackdk> | I just built ghc 8.10.7 and 9.2.4 for unimportant cross-compilation reasons, and the 9.2.4 build is so much faster. Mad props to whoever worked on that. |
| 2023-01-18 11:36:29 +0100 | MajorBiscuit | (~MajorBisc@145.94.179.130) (Ping timeout: 256 seconds) |
| 2023-01-18 11:37:07 +0100 | zmt01 | (~zmt00@user/zmt00) |
| 2023-01-18 11:38:56 +0100 | zmt00 | (~zmt00@user/zmt00) (Ping timeout: 256 seconds) |
| 2023-01-18 11:48:58 +0100 | mei | (~mei@user/mei) (Killed (calcium.libera.chat (Nickname regained by services))) |
| 2023-01-18 11:49:03 +0100 | mei | (~mei@user/mei) |
| 2023-01-18 11:52:39 +0100 | jespada_ | (~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) |
| 2023-01-18 11:53:05 +0100 | jao | (~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) |
| 2023-01-18 11:53:30 +0100 | zaquest | (~notzaques@5.130.79.72) (Remote host closed the connection) |
| 2023-01-18 11:54:51 +0100 | zaquest | (~notzaques@5.130.79.72) |
| 2023-01-18 11:56:11 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 248 seconds) |
| 2023-01-18 12:05:59 +0100 | alt-romes | (~romes@192.22.63.94.rev.vodafone.pt) (Ping timeout: 260 seconds) |
| 2023-01-18 12:09:11 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) (Ping timeout: 255 seconds) |
| 2023-01-18 12:11:41 +0100 | jespada_ | (~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) (Quit: ZNC 1.7.2+deb3 - https://znc.in) |
| 2023-01-18 12:12:22 +0100 | xff0x_ | (~xff0x@2405:6580:b080:900:686d:5028:75b2:f9bc) |
| 2023-01-18 12:14:14 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) |
| 2023-01-18 12:14:59 +0100 | Midjak | (~Midjak@82.66.147.146) |
| 2023-01-18 12:21:20 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) (Ping timeout: 255 seconds) |
| 2023-01-18 12:22:00 +0100 | thongpv | (~thongpv87@2001:ee0:5577:f0d0:60c4:8c39:337d:f64b) (Remote host closed the connection) |
| 2023-01-18 12:22:19 +0100 | thongpv | (~thongpv87@2001:ee0:5577:f0d0:649d:906:73a0:f4eb) |
| 2023-01-18 12:22:23 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) |
| 2023-01-18 12:23:03 +0100 | raehik | (~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) |
| 2023-01-18 12:27:15 +0100 | Felipe_ | (~Joao003@2804:840:8311:d200:c41b:789b:8754:5281) |
| 2023-01-18 12:27:21 +0100 | Felipe_ | (~Joao003@2804:840:8311:d200:c41b:789b:8754:5281) (Client Quit) |
| 2023-01-18 12:27:28 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) |
| 2023-01-18 12:28:42 +0100 | Joao003 | (~Joao003@2804:840:8311:d200:a956:d19c:27e1:d97d) (Remote host closed the connection) |
| 2023-01-18 12:29:29 +0100 | Joao003 | (~Joao003@2804:840:8311:d200:c41b:789b:8754:5281) |
| 2023-01-18 12:44:00 +0100 | bgs | (~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection) |
| 2023-01-18 12:44:53 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) |
| 2023-01-18 12:45:09 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2023-01-18 12:45:58 +0100 | juri_ | (~juri@84-19-175-179.pool.ovpn.com) |
| 2023-01-18 12:46:25 +0100 | pagnol | (~user@213-205-209-87.ftth.glasoperator.nl) (Remote host closed the connection) |
| 2023-01-18 12:46:38 +0100 | pagnol | (~user@213-205-209-87.ftth.glasoperator.nl) |
| 2023-01-18 12:46:48 +0100 | califax | (~califax@user/califx) |
| 2023-01-18 12:49:08 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) (Ping timeout: 255 seconds) |
| 2023-01-18 12:52:14 +0100 | beteigeuze | (~Thunderbi@a79-169-109-107.cpe.netcabo.pt) |
| 2023-01-18 12:56:34 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 256 seconds) |
| 2023-01-18 13:00:48 +0100 | <lortabac> | maerwald[m]: if you are around... what was the trick to have multiple instances of HLS each with its own GHC version? |
| 2023-01-18 13:01:19 +0100 | <lortabac> | I remember you told me to launch my editor with some env var |
| 2023-01-18 13:01:57 +0100 | <lortabac> | it was something like 'GHC_VERSION=9.2.5 vim' |
| 2023-01-18 13:08:38 +0100 | glguy | (~glguy@libera/staff-emeritus/glguy) (Ping timeout: 272 seconds) |
| 2023-01-18 13:09:36 +0100 | glguy | (~glguy@libera/staff-emeritus/glguy) |
| 2023-01-18 13:10:16 +0100 | glguy | (~glguy@libera/staff-emeritus/glguy) (Read error: Connection reset by peer) |
| 2023-01-18 13:10:57 +0100 | glguy | (~glguy@libera/staff-emeritus/glguy) |
| 2023-01-18 13:13:18 +0100 | leah2 | (~leah@vuxu.org) (Ping timeout: 260 seconds) |
| 2023-01-18 13:13:34 +0100 | perrierjouet | (~perrier-j@modemcable048.127-56-74.mc.videotron.ca) (Quit: WeeChat 3.8) |
| 2023-01-18 13:14:58 +0100 | perrierjouet | (~perrier-j@modemcable048.127-56-74.mc.videotron.ca) |
| 2023-01-18 13:19:17 +0100 | leah2 | (~leah@vuxu.org) |
| 2023-01-18 13:27:00 +0100 | <maerwald> | lortabac: what exactly are you trying to do? |
| 2023-01-18 13:27:13 +0100 | <maerwald> | are you using ghcup? |
| 2023-01-18 13:27:43 +0100 | gnalzo | (~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8) |
| 2023-01-18 13:27:55 +0100 | <lortabac> | maerwald: I have two projects, using two different GHC versions |
| 2023-01-18 13:28:11 +0100 | <lortabac> | I want to be able to work on both on them at the same time (in two editor instances of course) |
| 2023-01-18 13:28:19 +0100 | <lortabac> | yes I use ghcup |
| 2023-01-18 13:28:43 +0100 | <maerwald> | lortabac: haskell-language-server-wrapper should figure that out on its own |
| 2023-01-18 13:28:52 +0100 | <maerwald> | so use that as the LSP executable |
| 2023-01-18 13:28:59 +0100 | <lortabac> | I use it |
| 2023-01-18 13:29:01 +0100 | <maerwald> | and? |
| 2023-01-18 13:29:23 +0100 | <lortabac> | it calls the default 'ghc' command, which is a link to a specific version |
| 2023-01-18 13:29:24 +0100 | <maerwald> | is the ghc version set in cabal.project? |
| 2023-01-18 13:29:39 +0100 | <maerwald> | with-compiler: ghc-9.4.4 |
| 2023-01-18 13:29:53 +0100 | <lortabac> | ah right, I can also set it in cabal.project |
| 2023-01-18 13:30:04 +0100 | <maerwald> | otherwise: ghcup run --ghc 9.4.4 -- vim |
| 2023-01-18 13:30:30 +0100 | <lortabac> | oh maybe that's what you had told me |
| 2023-01-18 13:31:03 +0100 | <lortabac> | setting the version in cabal.project is probably simpler |
| 2023-01-18 13:31:25 +0100 | <Axman6> | jackdk: GHC's performance over the last few years has improved a lot, I feel 8.10 was probably a low (high?) point in compilation times and a lot of effort has gone into the little constant factor changes that add up (hoping that my LLVM work at the moment will be one of those such changes for the very few people who need LLVM compilation) |
| 2023-01-18 13:32:41 +0100 | econo | (uid147250@user/econo) (Quit: Connection closed for inactivity) |
| 2023-01-18 13:32:42 +0100 | <maerwald> | lortabac: if you want to set it as part of the startup script you should do: ghcup --offline run -q --ghc 9.4.4 -- <command> |
| 2023-01-18 13:32:51 +0100 | <maerwald> | that will be fast without network calls |
| 2023-01-18 13:33:42 +0100 | <lortabac> | maerwald: thanks |
| 2023-01-18 13:37:19 +0100 | jao | (~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) (Ping timeout: 252 seconds) |
| 2023-01-18 13:37:24 +0100 | jakalx | (~jakalx@base.jakalx.net) (Error from remote client) |
| 2023-01-18 13:45:53 +0100 | MajorBiscuit | (~MajorBisc@145.94.179.130) |
| 2023-01-18 13:48:57 +0100 | beteigeuze | (~Thunderbi@a79-169-109-107.cpe.netcabo.pt) (Remote host closed the connection) |
| 2023-01-18 13:49:21 +0100 | beteigeuze | (~Thunderbi@a79-169-109-107.cpe.netcabo.pt) |
| 2023-01-18 13:49:59 +0100 | bitdex_ | (~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds) |
| 2023-01-18 13:50:56 +0100 | coot | (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot) |
| 2023-01-18 13:51:52 +0100 | Teacup | (~teacup@user/teacup) (Quit: Teacup) |
| 2023-01-18 13:52:04 +0100 | bitdex_ | (~bitdex@gateway/tor-sasl/bitdex) |
| 2023-01-18 13:55:56 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) |
| 2023-01-18 14:00:34 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 272 seconds) |
| 2023-01-18 14:08:24 +0100 | jakalx | (~jakalx@base.jakalx.net) |
| 2023-01-18 14:13:01 +0100 | coot | (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) |
| 2023-01-18 14:13:48 +0100 | notzmv | (~zmv@user/notzmv) (Read error: Connection reset by peer) |
| 2023-01-18 14:16:36 +0100 | troydm | (~troydm@user/troydm) |
| 2023-01-18 14:17:32 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) |
| 2023-01-18 14:18:55 +0100 | notzmv | (~zmv@user/notzmv) |
| 2023-01-18 14:21:37 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) |
| 2023-01-18 14:23:04 +0100 | kuttenbrunzer | (~kuttenbru@2a02:8108:8b80:1d48:f5dc:d5b8:d2d1:f55c) |
| 2023-01-18 14:23:59 +0100 | johnjaye | (~pi@173.209.64.74) (Ping timeout: 246 seconds) |
| 2023-01-18 14:25:29 +0100 | jespada | (~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) (Remote host closed the connection) |
| 2023-01-18 14:26:07 +0100 | jespada | (~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) |
| 2023-01-18 14:26:24 +0100 | johnjaye | (~pi@173.209.64.74) |
| 2023-01-18 14:27:05 +0100 | Teacup | (~teacup@user/teacup) |
| 2023-01-18 14:28:31 +0100 | Teacup | (~teacup@user/teacup) (Client Quit) |
| 2023-01-18 14:28:53 +0100 | Teacup | (~teacup@user/teacup) |
| 2023-01-18 14:29:33 +0100 | Joao003 | (~Joao003@2804:840:8311:d200:c41b:789b:8754:5281) (Quit: Leaving) |
| 2023-01-18 14:32:17 +0100 | jpds | (~jpds@gateway/tor-sasl/jpds) (Ping timeout: 255 seconds) |
| 2023-01-18 14:32:45 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 260 seconds) |
| 2023-01-18 14:34:17 +0100 | jpds | (~jpds@gateway/tor-sasl/jpds) |
| 2023-01-18 14:40:25 +0100 | bitdex_ | (~bitdex@gateway/tor-sasl/bitdex) (Quit: = "") |
| 2023-01-18 14:52:03 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 265 seconds) |
| 2023-01-18 14:59:30 +0100 | <jean-paul[m]> | Doing FFI to a C API with an output parameter, my Haskell code doesn't see the new value of the output - https://gist.github.com/exarkun/dd5dc9303ad8bc708369b4594baab741 - outputSizes is 0x0 before and after the call to zfec_encode. Did I do something wrong in the Haskell code? |
| 2023-01-18 15:00:23 +0100 | <jean-paul[m]> | Uhh I read the point before the call, oops :( Thanks. |
| 2023-01-18 15:00:39 +0100 | <Axman6> | Glad we could help! |
| 2023-01-18 15:01:04 +0100 | <dminuoso> | Axman6: You were supposed to get unwarranted gratitude tomorrow. It's my turn today. |
| 2023-01-18 15:02:22 +0100 | <Axman6> | I couldn't've done it without you dminuoso, you even get a double contraction for it |
| 2023-01-18 15:02:36 +0100 | <dminuoso> | Beautiful |
| 2023-01-18 15:04:32 +0100 | <Axman6> | jean-paul[m]: this is good news though, you have truly internalised the idea that the value of things should never change - you'll make a poor economist, but an excellent Haskeller |
| 2023-01-18 15:04:50 +0100 | <jean-paul[m]> | :) |
| 2023-01-18 15:06:15 +0100 | <Axman6> | A Haskeller knows the value of everything, eventually, and the cost of none |
| 2023-01-18 15:12:08 +0100 | kuttenbrunzer | (~kuttenbru@2a02:8108:8b80:1d48:f5dc:d5b8:d2d1:f55c) (Read error: Connection reset by peer) |
| 2023-01-18 15:16:06 +0100 | dsrt^ | (~dsrt@76.145.190.81) (Remote host closed the connection) |
| 2023-01-18 15:16:43 +0100 | thegeekinside | (~thegeekin@189.217.82.244) |
| 2023-01-18 15:18:02 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) |
| 2023-01-18 15:22:32 +0100 | thegeekinside | (~thegeekin@189.217.82.244) (Remote host closed the connection) |
| 2023-01-18 15:22:44 +0100 | thegeekinside | (~thegeekin@189.217.82.244) |
| 2023-01-18 15:22:48 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 268 seconds) |
| 2023-01-18 15:23:52 +0100 | <Axman6> | Guillaum[m]: Can you share some more concrete code? I think I understand, but I have a feeling the answer if going to be that you'll need to take care of sharing references yourself |
| 2023-01-18 15:25:19 +0100 | jonathanx_ | (~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) |
| 2023-01-18 15:25:36 +0100 | jonathanx | (~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) (Ping timeout: 256 seconds) |
| 2023-01-18 15:30:36 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) |
| 2023-01-18 15:31:10 +0100 | chele | (~chele@user/chele) |
| 2023-01-18 15:37:02 +0100 | angelz | Dunno |
| 2023-01-18 15:39:01 +0100 | <int-index> | Axman6: since you're working on LLVM perf, could you take a look at https://gitlab.haskell.org/ghc/ghc/-/merge_requests/9728? It may (or may not) improve the performance of CmmToLlvm |
| 2023-01-18 15:42:23 +0100 | vektor | (~vektor@IP-045136170253.dynamic.medianet-world.de) |
| 2023-01-18 15:44:23 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2023-01-18 15:46:22 +0100 | califax | (~califax@user/califx) |
| 2023-01-18 15:47:42 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) |
| 2023-01-18 15:50:26 +0100 | kadoban | (~kadoban@user/kadoban) |
| 2023-01-18 15:52:05 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) (Ping timeout: 260 seconds) |
| 2023-01-18 15:53:16 +0100 | <Cheery> | I'm looking for some reading. Anyone knows where to look? |
| 2023-01-18 15:53:43 +0100 | <Cheery> | interested about programming languages, category theory, type theory |
| 2023-01-18 15:55:11 +0100 | <stefan-_> | Cheery, https://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface/ |
| 2023-01-18 15:55:26 +0100 | <anatta> | depends on your level - but for programming languages I liked the dragon book |
| 2023-01-18 15:55:32 +0100 | <anatta> | https://www.amazon.com/Compilers-Principles-Techniques-Tools-2nd/dp/0321486811 |
| 2023-01-18 15:55:49 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) |
| 2023-01-18 15:55:56 +0100 | <dminuoso> | "Types and Programming Languages" by pierce is a great book on type theory and a touch on programming languages. |
| 2023-01-18 15:56:30 +0100 | <dminuoso> | I didnt quite like the dragon book though |
| 2023-01-18 15:56:34 +0100 | <Cheery> | I've read these all through. TAPL I supposed could read through again. |
| 2023-01-18 15:57:05 +0100 | kurbus | (~kurbus@user/kurbus) |
| 2023-01-18 15:57:54 +0100 | <Axman6> | int-index: yeah I saw you'd done that - I would love to but I still haven't been able to find out how to measure performance of GHC, the performance metrics seem to be some kind of black art that I can't get it to compare different runs ever |
| 2023-01-18 15:58:09 +0100 | pagnol | (~user@213-205-209-87.ftth.glasoperator.nl) (Ping timeout: 255 seconds) |
| 2023-01-18 15:59:18 +0100 | <Cheery> | anything really hard reading that goes beyond all this? |
| 2023-01-18 16:00:10 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 256 seconds) |
| 2023-01-18 16:00:41 +0100 | <geekosaur> | HoTT, if you want really hard 🙂 |
| 2023-01-18 16:01:06 +0100 | <geekosaur> | @where hott |
| 2023-01-18 16:01:06 +0100 | <lambdabot> | http://homotopytypetheory.org/book/ |
| 2023-01-18 16:01:47 +0100 | <Cheery> | I've read it to about halfway and stalled. I could read it. |
| 2023-01-18 16:02:07 +0100 | <Cheery> | I liked "Conceptual Mathematics: A First Introduction to Categories", I found it from baez' list. |
| 2023-01-18 16:02:14 +0100 | <Cheery> | https://math.ucr.edu/home/baez/topos.html |
| 2023-01-18 16:03:18 +0100 | <Cheery> | Well if I loosen the conditions I've given, eg. leaving plt, category theory, type theory aside, would you then have recommendations? |
| 2023-01-18 16:04:17 +0100 | <Axman6> | Hacker's Delight is always a delight to read - a long way from what you seem to be after though |
| 2023-01-18 16:05:51 +0100 | <Cheery> | looks fun. |
| 2023-01-18 16:09:04 +0100 | inversed | (~inversed@bcdcac82.skybroadband.com) (Ping timeout: 252 seconds) |
| 2023-01-18 16:09:12 +0100 | mikoto-chan | (~mikoto-ch@164.5.249.78) |
| 2023-01-18 16:09:24 +0100 | <Axman6> | whenever I'm writing something that's performance critical and I have a feeling there's a branchless implementation, I'll head there. so many fun tricks |
| 2023-01-18 16:10:04 +0100 | <Axman6> | I used some similar ideas in the previous attempt to make text use utf-8, and made some of the functions 100x faster |
| 2023-01-18 16:11:55 +0100 | [itchyjunk] | (~itchyjunk@user/itchyjunk/x-7353470) |
| 2023-01-18 16:13:50 +0100 | Feuermagier | (~Feuermagi@user/feuermagier) (Read error: Connection reset by peer) |
| 2023-01-18 16:15:21 +0100 | inversed | (~inversed@bcdcac82.skybroadband.com) |
| 2023-01-18 16:15:22 +0100 | <anatta> | I looked up Hacker's Delight on wikipedia, and in the list of "Further reading" they had this which sounds like a hit piece: |
| 2023-01-18 16:15:26 +0100 | <anatta> | Anderson, Sean Eron, ed. (2009-11-26) [1997]. "Bit Twiddling Hacks" (...) |
| 2023-01-18 16:16:09 +0100 | shriekingnoise | (~shrieking@186.137.175.87) |
| 2023-01-18 16:16:36 +0100 | Axman6 | is a bit twiddling hack |
| 2023-01-18 16:17:59 +0100 | kuribas | (~user@ip-188-118-57-242.reverse.destiny.be) |
| 2023-01-18 16:18:47 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) |
| 2023-01-18 16:24:49 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1812:9885:2ce4:4618) |
| 2023-01-18 16:25:04 +0100 | Sgeo | (~Sgeo@user/sgeo) |
| 2023-01-18 16:25:29 +0100 | <int-e> | . o O ( oh god, was that an innuendo all along ) |
| 2023-01-18 16:26:19 +0100 | nilcdr | (~nilcdr@user/nilcdr) |
| 2023-01-18 16:29:31 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1812:9885:2ce4:4618) (Ping timeout: 260 seconds) |
| 2023-01-18 16:31:59 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) (Ping timeout: 255 seconds) |
| 2023-01-18 16:32:40 +0100 | chiselfuse | (~chiselfus@user/chiselfuse) |
| 2023-01-18 16:39:14 +0100 | kurbus | (~kurbus@user/kurbus) (Quit: Client closed) |
| 2023-01-18 16:41:36 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) |
| 2023-01-18 16:41:54 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 260 seconds) |
| 2023-01-18 16:44:00 +0100 | razetime | (~Thunderbi@117.193.4.54) |
| 2023-01-18 16:50:50 +0100 | MajorBiscuit | (~MajorBisc@145.94.179.130) (Quit: WeeChat 3.6) |
| 2023-01-18 16:52:52 +0100 | Arsen | (arsen@managarm/dev/Arsen) (Changing host) |
| 2023-01-18 16:52:52 +0100 | Arsen | (arsen@gentoo/developer/managarm.dev.Arsen) |
| 2023-01-18 16:55:37 +0100 | gnalzo | (~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) |
| 2023-01-18 16:59:29 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) (Ping timeout: 256 seconds) |
| 2023-01-18 16:59:57 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) |
| 2023-01-18 17:00:28 +0100 | enoq | (~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) (Quit: enoq) |
| 2023-01-18 17:03:16 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) |
| 2023-01-18 17:04:06 +0100 | <raehik> | Every time I write docs I google this, so I feel I should ask once and for all: what is the name for the `ReqClass a` in `instance ReqClass a => MainClass a where`? |
| 2023-01-18 17:04:26 +0100 | <geekosaur> | constraint |
| 2023-01-18 17:04:41 +0100 | <raehik> | pfft. oh my god I'm dumb |
| 2023-01-18 17:04:42 +0100 | <dminuoso> | raehik: It's called contextof the instance declaration. |
| 2023-01-18 17:04:48 +0100 | <dminuoso> | *context of the instance declaration |
| 2023-01-18 17:04:54 +0100 | <raehik> | ohhhh but that's interesting, I keep thinking context |
| 2023-01-18 17:05:18 +0100 | <dminuoso> | See https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/instances.html#instance-declarations-and-r… |
| 2023-01-18 17:05:55 +0100 | <dminuoso> | Similarly https://www.haskell.org/onlinereport/haskell2010/haskellch4.html#x10-630004.1 |
| 2023-01-18 17:06:15 +0100 | <raehik> | thanks dminuoso, geekosaur |
| 2023-01-18 17:06:23 +0100 | Lycurgus | (~juan@user/Lycurgus) |
| 2023-01-18 17:06:29 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2023-01-18 17:07:08 +0100 | <dminuoso> | geekosaur's answer is still correct, but a constraint in instance declaration or class definition has that special name. |
| 2023-01-18 17:07:18 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) |
| 2023-01-18 17:07:40 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) |
| 2023-01-18 17:08:43 +0100 | <raehik> | right. much happier with them than "superclass" which I keep thinking. some day I'll shake the rest of the OOP out |
| 2023-01-18 17:08:52 +0100 | lortabac | (~lortabac@2a01:e0a:541:b8f0:5001:9128:80c0:62b0) (Quit: WeeChat 2.8) |
| 2023-01-18 17:08:57 +0100 | <dminuoso> | superclass is also a thing. |
| 2023-01-18 17:09:30 +0100 | <geekosaur> | although I prefer "prerequisite" |
| 2023-01-18 17:09:36 +0100 | <dminuoso> | For a `class C a`, if `C a` appears as context for a class `D a`, then C is a superclass of D. |
| 2023-01-18 17:09:36 +0100 | angelz | webmaster |
| 2023-01-18 17:09:50 +0100 | <dminuoso> | There's a bunch of associated typing rules for that even |
| 2023-01-18 17:09:56 +0100 | freeside | (~mengwong@bb115-66-48-84.singnet.com.sg) (Ping timeout: 272 seconds) |
| 2023-01-18 17:10:40 +0100 | cheater_ | (~Username@user/cheater) |
| 2023-01-18 17:10:58 +0100 | <dminuoso> | (ah well, its actually way more tricky than the previous statement, but its a good initial rough estimate) |
| 2023-01-18 17:12:17 +0100 | <dminuoso> | Anyway, for the typing rules if you know `Ord a`, then that implies `Eq a` |
| 2023-01-18 17:13:50 +0100 | cheater | (~Username@user/cheater) (Ping timeout: 256 seconds) |
| 2023-01-18 17:13:57 +0100 | cheater_ | cheater |
| 2023-01-18 17:18:23 +0100 | vektor | (~vektor@IP-045136170253.dynamic.medianet-world.de) (Quit: Client closed) |
| 2023-01-18 17:19:14 +0100 | Volt_ | (~Volt_@c-73-167-118-200.hsd1.ma.comcast.net) (Remote host closed the connection) |
| 2023-01-18 17:23:28 +0100 | thongpv | (~thongpv87@2001:ee0:5577:f0d0:649d:906:73a0:f4eb) (Ping timeout: 256 seconds) |
| 2023-01-18 17:24:34 +0100 | nilcdr | (~nilcdr@user/nilcdr) (Read error: Connection reset by peer) |
| 2023-01-18 17:26:31 +0100 | mei | (~mei@user/mei) (Quit: mei) |
| 2023-01-18 17:27:02 +0100 | Lycurgus | (~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz) |
| 2023-01-18 17:27:31 +0100 | kronicmage | (user90047@neotame.csclub.uwaterloo.ca) (Quit: WeeChat 3.0.1) |
| 2023-01-18 17:27:45 +0100 | kronicmage | (user37946@neotame.csclub.uwaterloo.ca) |
| 2023-01-18 17:28:39 +0100 | mc47 | (~mc47@xmonad/TheMC47) |
| 2023-01-18 17:32:09 +0100 | chele | (~chele@user/chele) (Quit: Leaving) |
| 2023-01-18 17:38:15 +0100 | thyriaen | (~thyriaen@2a01:aea0:dd4:4bae:6245:cbff:fe9f:48b1) |
| 2023-01-18 17:39:42 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) (Ping timeout: 272 seconds) |
| 2023-01-18 17:42:01 +0100 | myxokephale_ | (~myxokepha@cpe-65-28-251-121.cinci.res.rr.com) |
| 2023-01-18 17:42:14 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 272 seconds) |
| 2023-01-18 17:43:10 +0100 | myxokephale | (~myxokepha@cpe-65-28-251-121.cinci.res.rr.com) (Ping timeout: 252 seconds) |
| 2023-01-18 17:44:18 +0100 | int-index-r | (~Vladislav@2a00:1370:8178:5994:6490:ec14:6af:3fa6) |
| 2023-01-18 17:44:48 +0100 | jao | (~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) |
| 2023-01-18 17:48:11 +0100 | int-index | (~Vladislav@2a00:1370:8178:5994:bd51:c650:be55:9635) (Ping timeout: 264 seconds) |
| 2023-01-18 17:48:20 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) |
| 2023-01-18 17:48:25 +0100 | hounded | (~hounded@2603-7000-da43-eccc-0000-0000-0000-0cec.res6.spectrum.com) |
| 2023-01-18 17:48:32 +0100 | hounded_woodstoc | (~hounded@2603-7000-da43-eccc-0000-0000-0000-0cec.res6.spectrum.com) |
| 2023-01-18 17:49:15 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1812:9885:2ce4:4618) |
| 2023-01-18 17:51:39 +0100 | oldfashionedcow | (~Rahul_San@user/oldfashionedcow) |
| 2023-01-18 17:52:39 +0100 | ridcully | (~ridcully@p508acd69.dip0.t-ipconnect.de) (Remote host closed the connection) |
| 2023-01-18 17:52:51 +0100 | ridcully | (~ridcully@p508acd69.dip0.t-ipconnect.de) |
| 2023-01-18 17:55:06 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) |
| 2023-01-18 17:57:13 +0100 | kadoban | (~kadoban@user/kadoban) () |
| 2023-01-18 17:57:13 +0100 | razetime | (~Thunderbi@117.193.4.54) (Quit: See You Space Cowboy) |
| 2023-01-18 18:00:03 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 268 seconds) |
| 2023-01-18 18:00:19 +0100 | acidjnk | (~acidjnk@p200300d6e715c4131152733c544888a6.dip0.t-ipconnect.de) |
| 2023-01-18 18:01:05 +0100 | stiell_ | (~stiell@gateway/tor-sasl/stiell) (Ping timeout: 255 seconds) |
| 2023-01-18 18:01:20 +0100 | <zwro> | wait, is Eq or Ord the superclass? |
| 2023-01-18 18:01:32 +0100 | <geekosaur> | Eq |
| 2023-01-18 18:01:34 +0100 | <dminuoso> | Eq is the superclass of Ord |
| 2023-01-18 18:01:52 +0100 | <zwro> | all is well then |
| 2023-01-18 18:03:11 +0100 | <mauke> | all Ords are Eqs, but not all Eqs are Ords |
| 2023-01-18 18:03:12 +0100 | <mauke> | and some Eqs are more Eq than others |
| 2023-01-18 18:03:17 +0100 | acidjnk_new | (~acidjnk@p200300d6e715c41381da8d03356c8335.dip0.t-ipconnect.de) |
| 2023-01-18 18:03:35 +0100 | Joao003 | (~Joao003@2804:840:8311:d200:c41b:789b:8754:5281) |
| 2023-01-18 18:03:56 +0100 | acidjnk_new | (~acidjnk@p200300d6e715c41381da8d03356c8335.dip0.t-ipconnect.de) (Read error: Connection reset by peer) |
| 2023-01-18 18:04:34 +0100 | <zwro> | that's a classy joke |
| 2023-01-18 18:05:21 +0100 | <Joao003> | what's the topic of the conversation here |
| 2023-01-18 18:05:47 +0100 | <geekosaur> | [18 17:01:20] <zwro> wait, is Eq or Ord the superclass? |
| 2023-01-18 18:05:56 +0100 | <mauke> | (specifically, the Eq instance for floating point numbers is a bit dodgy) |
| 2023-01-18 18:06:17 +0100 | acidjnk | (~acidjnk@p200300d6e715c4131152733c544888a6.dip0.t-ipconnect.de) (Ping timeout: 246 seconds) |
| 2023-01-18 18:06:19 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1812:9885:2ce4:4618) (Remote host closed the connection) |
| 2023-01-18 18:06:24 +0100 | <geekosaur> | discussing `class Eq a => Ord a where …` aka "superclass" constraints/contexts |
| 2023-01-18 18:07:38 +0100 | acidjnk | (~acidjnk@p200300d6e715c41325fe13a78d721b6b.dip0.t-ipconnect.de) |
| 2023-01-18 18:07:40 +0100 | <zwro> | fixed point good, floating baaaad |
| 2023-01-18 18:08:19 +0100 | tzh | (~tzh@c-24-21-73-154.hsd1.wa.comcast.net) |
| 2023-01-18 18:08:41 +0100 | trev | (~trev@user/trev) (Remote host closed the connection) |
| 2023-01-18 18:09:41 +0100 | ubert1 | (~Thunderbi@2a02:8109:abc0:6434:774d:958d:e54d:fb2f) (Quit: ubert1) |
| 2023-01-18 18:09:41 +0100 | <Rembane> | What's the fix point of floating point? And what's the point really? (Sorrysorrysorrysorry) |
| 2023-01-18 18:10:22 +0100 | <anatta> | there was someone in the haskell discord the other day who was using floating point numbers as mcgyvered tuples and was upset that they got rounding errors |
| 2023-01-18 18:10:24 +0100 | <zwro> | > fix ("sorry" <>) |
| 2023-01-18 18:10:26 +0100 | <lambdabot> | "sorrysorrysorrysorrysorrysorrysorrysorrysorrysorrysorrysorrysorrysorrysorry... |
| 2023-01-18 18:12:00 +0100 | <Joao003> | > fix (1 <>) |
| 2023-01-18 18:12:02 +0100 | <lambdabot> | error: |
| 2023-01-18 18:12:02 +0100 | <lambdabot> | • Ambiguous type variable ‘a0’ arising from a use of ‘show_M461655175536... |
| 2023-01-18 18:12:02 +0100 | <lambdabot> | prevents the constraint ‘(Show a0)’ from being solved. |
| 2023-01-18 18:12:17 +0100 | <Joao003> | > fix ("Hello, World!" <>) |
| 2023-01-18 18:12:19 +0100 | <lambdabot> | "Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, Wor... |
| 2023-01-18 18:12:20 +0100 | <zwro> | Joao003: use (:) |
| 2023-01-18 18:12:28 +0100 | <Joao003> | > fix (1 (:)) |
| 2023-01-18 18:12:30 +0100 | <lambdabot> | error: |
| 2023-01-18 18:12:30 +0100 | <lambdabot> | • Could not deduce (Num ((a0 -> [a0] -> [a0]) -> a1 -> a1)) |
| 2023-01-18 18:12:30 +0100 | <lambdabot> | (maybe you haven't applied a function to enough arguments?) |
| 2023-01-18 18:12:40 +0100 | <zwro> | like this: |
| 2023-01-18 18:12:41 +0100 | <Joao003> | > fix (1 :) |
| 2023-01-18 18:12:42 +0100 | <lambdabot> | [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1... |
| 2023-01-18 18:12:47 +0100 | <zwro> | yup |
| 2023-01-18 18:12:59 +0100 | <Joao003> | > "Hello, " <> "World!" |
| 2023-01-18 18:13:01 +0100 | <lambdabot> | "Hello, World!" |
| 2023-01-18 18:13:10 +0100 | <mauke> | > iterate sort [0/0, 1, 2, 0/0, 0, 5] |
| 2023-01-18 18:13:13 +0100 | <lambdabot> | [[NaN,1.0,2.0,NaN,0.0,5.0],[0.0,5.0,NaN,1.0,2.0,NaN],[NaN,0.0,1.0,2.0,NaN,5.... |
| 2023-01-18 18:13:49 +0100 | <anatta> | now listen here |
| 2023-01-18 18:13:50 +0100 | <Joao003> | > repeat 1 |
| 2023-01-18 18:13:53 +0100 | <lambdabot> | [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1... |
| 2023-01-18 18:14:12 +0100 | <zwro> | mauke: that's cruel |
| 2023-01-18 18:14:25 +0100 | <Joao003> | <> is for string so it's for lists also |
| 2023-01-18 18:14:28 +0100 | <Joao003> | right |
| 2023-01-18 18:14:39 +0100 | <anatta> | <> is generalized ++ |
| 2023-01-18 18:14:40 +0100 | <Joao003> | > [1, 2, 3] <> [4, 5, 6] |
| 2023-01-18 18:14:42 +0100 | <lambdabot> | [1,2,3,4,5,6] |
| 2023-01-18 18:14:59 +0100 | <Joao003> | > [1, 2, 3] ++ [4, 5, 6] |
| 2023-01-18 18:15:00 +0100 | <lambdabot> | [1,2,3,4,5,6] |
| 2023-01-18 18:15:09 +0100 | <Joao003> | for me they're all the same |
| 2023-01-18 18:15:25 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) |
| 2023-01-18 18:15:27 +0100 | <anatta> | :t (++) |
| 2023-01-18 18:15:28 +0100 | <lambdabot> | [a] -> [a] -> [a] |
| 2023-01-18 18:15:33 +0100 | <anatta> | :t (<>) |
| 2023-01-18 18:15:35 +0100 | <lambdabot> | Semigroup a => a -> a -> a |
| 2023-01-18 18:16:01 +0100 | <mauke> | > Just "do it" <> Just "dance" |
| 2023-01-18 18:16:03 +0100 | <lambdabot> | Just "do itdance" |
| 2023-01-18 18:16:28 +0100 | <Joao003> | > Just "do it" ++ Just " dance" |
| 2023-01-18 18:16:30 +0100 | <lambdabot> | error: |
| 2023-01-18 18:16:30 +0100 | <lambdabot> | • Couldn't match expected type ‘[a]’ |
| 2023-01-18 18:16:30 +0100 | <lambdabot> | with actual type ‘Maybe [Char]’ |
| 2023-01-18 18:16:35 +0100 | <Joao003> | obviously doesn't work |
| 2023-01-18 18:16:44 +0100 | vykt | (~vykt@92.40.124.204.threembb.co.uk) (Ping timeout: 246 seconds) |
| 2023-01-18 18:16:57 +0100 | opticblast | (~Thunderbi@secure-165.caltech.edu) (Quit: opticblast) |
| 2023-01-18 18:17:13 +0100 | <Joao003> | > Left "will this" <> Right "work?" |
| 2023-01-18 18:17:15 +0100 | <lambdabot> | Right "work?" |
| 2023-01-18 18:17:16 +0100 | opticblast | (~Thunderbi@secure-165.caltech.edu) |
| 2023-01-18 18:17:22 +0100 | <Joao003> | oh it picked right |
| 2023-01-18 18:17:31 +0100 | <Joao003> | > Left "will this" <> Left "work?" |
| 2023-01-18 18:17:33 +0100 | <lambdabot> | Left "work?" |
| 2023-01-18 18:17:44 +0100 | <Joao003> | it pick the rightmost one |
| 2023-01-18 18:17:49 +0100 | <anatta> | > (++) <$> Just "part 1" <*> Just "part 2" |
| 2023-01-18 18:17:51 +0100 | <lambdabot> | Just "part 1part 2" |
| 2023-01-18 18:18:21 +0100 | <mauke> | > 1 <> 2 <> 3 :: Sum Int |
| 2023-01-18 18:18:23 +0100 | <lambdabot> | Sum {getSum = 6} |
| 2023-01-18 18:18:26 +0100 | jonathanx_ | (~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) (Quit: Leaving) |
| 2023-01-18 18:18:33 +0100 | <Joao003> | > (++) <$> Left "left and " <*> Right "right" |
| 2023-01-18 18:18:34 +0100 | <lambdabot> | Left "left and " |
| 2023-01-18 18:18:36 +0100 | <mauke> | > 1 <> 2 <> 3 :: Product Int |
| 2023-01-18 18:18:38 +0100 | <lambdabot> | Product {getProduct = 6} |
| 2023-01-18 18:18:48 +0100 | <Joao003> | spooky |
| 2023-01-18 18:18:48 +0100 | vykt | (~vykt@92.40.125.229.threembb.co.uk) |
| 2023-01-18 18:18:56 +0100 | <zwro> | Joao003: You can think of Left and Right as False and True and (<>) as (||) |
| 2023-01-18 18:19:23 +0100 | <zwro> | but annotated |
| 2023-01-18 18:19:40 +0100 | <zwro> | it shortcircuits |
| 2023-01-18 18:19:55 +0100 | <zwro> | False || x = x |
| 2023-01-18 18:19:57 +0100 | <Joao003> | > (Right "right and " >>= (++)) "left" |
| 2023-01-18 18:19:58 +0100 | <cstm[m]> | > Just "do it" <*> pure (<>) <*> Just "dance" |
| 2023-01-18 18:19:59 +0100 | <lambdabot> | error: |
| 2023-01-18 18:19:59 +0100 | <lambdabot> | • Couldn't match expected type ‘[Char] -> t’ |
| 2023-01-18 18:19:59 +0100 | <lambdabot> | with actual type ‘Either a0 b0’ |
| 2023-01-18 18:20:00 +0100 | <lambdabot> | error: |
| 2023-01-18 18:20:00 +0100 | <lambdabot> | • Couldn't match type ‘[Char]’ |
| 2023-01-18 18:20:01 +0100 | <lambdabot> | with ‘(a0 -> a0 -> a0) -> [Char] -> b’ |
| 2023-01-18 18:20:05 +0100 | <mauke> | wait, Proxy has a Monoid instance? |
| 2023-01-18 18:20:09 +0100 | <mauke> | that's a bit sus |
| 2023-01-18 18:20:22 +0100 | <Joao003> | "sus" amogus moment |
| 2023-01-18 18:20:43 +0100 | <cstm[m]> | > (<>) <$> Just "do it" <*> Just "dance" |
| 2023-01-18 18:20:45 +0100 | <lambdabot> | Just "do itdance" |
| 2023-01-18 18:21:04 +0100 | <Joao003> | > (Right "right and " >>= (<>)) Left "left" |
| 2023-01-18 18:21:06 +0100 | <lambdabot> | error: |
| 2023-01-18 18:21:06 +0100 | <lambdabot> | • Couldn't match expected type ‘(a1 -> Either a1 b1) |
| 2023-01-18 18:21:06 +0100 | <lambdabot> | -> [Char] -> t’ |
| 2023-01-18 18:21:11 +0100 | <Joao003> | > (Right "right and " >>= (<>))"left" |
| 2023-01-18 18:21:13 +0100 | <lambdabot> | error: |
| 2023-01-18 18:21:13 +0100 | <lambdabot> | • Couldn't match expected type ‘[Char] -> t’ |
| 2023-01-18 18:21:13 +0100 | <lambdabot> | with actual type ‘Either a0 b0’ |
| 2023-01-18 18:21:34 +0100 | <zwro> | Joao003: you can /msg lambdabot directly to avoid spamming the channel |
| 2023-01-18 18:21:55 +0100 | titibandit1 | (~titibandi@xdsl-81-173-160-143.nc.de) |
| 2023-01-18 18:22:00 +0100 | <Joao003> | zwro: me forgetting ghci exists: |
| 2023-01-18 18:22:10 +0100 | <anatta> | Joao003: there is also <|> in Control.Applicative as another OR |
| 2023-01-18 18:22:23 +0100 | <Joao003> | too many or gates |
| 2023-01-18 18:22:31 +0100 | <anatta> | let's see if this works |
| 2023-01-18 18:22:33 +0100 | <anatta> | @let import Control.Applicative |
| 2023-01-18 18:22:35 +0100 | <lambdabot> | Defined. |
| 2023-01-18 18:22:54 +0100 | <anatta> | > Nothing <|> Just "Something" |
| 2023-01-18 18:22:56 +0100 | <lambdabot> | Just "Something" |
| 2023-01-18 18:22:57 +0100 | <Joao003> | :t (|) |
| 2023-01-18 18:22:59 +0100 | <lambdabot> | error: parse error on input ‘)’ |
| 2023-01-18 18:23:15 +0100 | <Joao003> | :t (<|>) |
| 2023-01-18 18:23:17 +0100 | <lambdabot> | Alternative f => f a -> f a -> f a |
| 2023-01-18 18:23:45 +0100 | <Joao003> | > Left "not cool" <|> Right "cool" |
| 2023-01-18 18:23:47 +0100 | <lambdabot> | Right "cool" |
| 2023-01-18 18:24:07 +0100 | <Joao003> | > Left "not cool" <|> Left "not cool" |
| 2023-01-18 18:24:09 +0100 | <lambdabot> | Left "not cool" |
| 2023-01-18 18:24:23 +0100 | <Joao003> | or with alternatives |
| 2023-01-18 18:25:15 +0100 | <zwro> | > Left 0 <|> Left 1 <|> Right 7 <|> Left 2 |
| 2023-01-18 18:25:17 +0100 | <lambdabot> | error: |
| 2023-01-18 18:25:17 +0100 | <lambdabot> | • Ambiguous type variable ‘a0’ arising from a use of ‘show_M745715984621... |
| 2023-01-18 18:25:17 +0100 | <lambdabot> | prevents the constraint ‘(Show a0)’ from being solved. |
| 2023-01-18 18:25:43 +0100 | zwro | sigh |
| 2023-01-18 18:25:46 +0100 | <cstm[m]> | > Left (0 :: Int) <|> Left 1 <|> Right 7 <|> Left 2 |
| 2023-01-18 18:25:48 +0100 | <lambdabot> | error: |
| 2023-01-18 18:25:48 +0100 | <lambdabot> | • Could not deduce (Control.Monad.Trans.Error.Error Int) |
| 2023-01-18 18:25:48 +0100 | <lambdabot> | arising from a use of ‘<|>’ |
| 2023-01-18 18:26:08 +0100 | <Joao003> | how do you make the * send messages |
| 2023-01-18 18:26:25 +0100 | <cstm[m]> | @zwro: It's because it can't deduce what the right branch is I think. |
| 2023-01-18 18:26:25 +0100 | <lambdabot> | Unknown command, try @list |
| 2023-01-18 18:26:48 +0100 | <cstm[m]> | so you have to do something like : |
| 2023-01-18 18:26:48 +0100 | <cstm[m]> | > (Left 0 :: Either Int ()) <|> Left 1 <|> Right 7 <|> Left 2 |
| 2023-01-18 18:26:50 +0100 | <lambdabot> | error: |
| 2023-01-18 18:26:50 +0100 | <lambdabot> | • No instance for (Control.Monad.Trans.Error.Error Int) |
| 2023-01-18 18:26:50 +0100 | <lambdabot> | arising from a use of ‘<|>’ |
| 2023-01-18 18:26:55 +0100 | <dminuoso> | % :t (<|>) |
| 2023-01-18 18:26:55 +0100 | <yahb2> | <interactive>:1:1: error: ; • Variable not in scope: <|> ; • Perhaps you meant one of these: ; ‘<*>’ (imported from Prelude), ‘<>’ (imported from Prelude), ; ‘<$>’ (imported... |
| 2023-01-18 18:27:00 +0100 | <dminuoso> | :t (<|>) |
| 2023-01-18 18:27:01 +0100 | <lambdabot> | Alternative f => f a -> f a -> f a |
| 2023-01-18 18:27:16 +0100 | <Joao003> | % import Control.Applicative |
| 2023-01-18 18:27:17 +0100 | <yahb2> | <no output> |
| 2023-01-18 18:27:26 +0100 | <Joao003> | % :t (<|>) |
| 2023-01-18 18:27:26 +0100 | <yahb2> | (<|>) :: Alternative f => f a -> f a -> f a |
| 2023-01-18 18:27:37 +0100 | <dminuoso> | The Alternative instance is not from base |
| 2023-01-18 18:28:01 +0100 | <Joao003> | dminuoso: yahb2 is separate from lambdabot |
| 2023-01-18 18:28:11 +0100 | <dminuoso> | I know |
| 2023-01-18 18:29:00 +0100 | <Joao003> | wait does this work |
| 2023-01-18 18:29:05 +0100 | <Joao003> | @let one = 1 in one |
| 2023-01-18 18:29:05 +0100 | <lambdabot> | Parse failed: Parse error: in |
| 2023-01-18 18:29:05 +0100 | <dminuoso> | It just looks like there is some kind of `instance Control.Monad.Trans.Error.Error e => Alternative (Either e)` |
| 2023-01-18 18:29:08 +0100 | <Joao003> | oh |
| 2023-01-18 18:29:11 +0100 | <dminuoso> | Whatever that typeclass is. |
| 2023-01-18 18:29:41 +0100 | <zwro> | wait |
| 2023-01-18 18:29:58 +0100 | <zwro> | > (Left 0 :: Either Int Int) <|> (Left 1 :: Either Int Int) |
| 2023-01-18 18:30:00 +0100 | <lambdabot> | error: |
| 2023-01-18 18:30:00 +0100 | <lambdabot> | • No instance for (Control.Monad.Trans.Error.Error Int) |
| 2023-01-18 18:30:00 +0100 | <lambdabot> | arising from a use of ‘<|>’ |
| 2023-01-18 18:30:02 +0100 | remedan | (~remedan@144.76.104.133) (Ping timeout: 265 seconds) |
| 2023-01-18 18:30:16 +0100 | <zwro> | oh well |
| 2023-01-18 18:30:21 +0100 | nek0 | (~nek0@2a01:4f8:222:2b41::12) (Quit: The Lounge - https://thelounge.chat) |
| 2023-01-18 18:30:24 +0100 | <dminuoso> | Like I said. :) |
| 2023-01-18 18:30:34 +0100 | <dminuoso> | The problem isnt the Right type, its the left type. |
| 2023-01-18 18:30:44 +0100 | <dminuoso> | I just dont know what that `Error` typeclass is |
| 2023-01-18 18:31:29 +0100 | <dminuoso> | :k Control.Monad.Trans.Error.Error |
| 2023-01-18 18:31:30 +0100 | <lambdabot> | * -> Constraint |
| 2023-01-18 18:31:36 +0100 | <cstm[m]> | Actually There is no `Alternative` instance defined for Either - that's why. https://hackage.haskell.org/package/base-4.17.0.0/docs/Control-Applicative.html#t:Alternative |
| 2023-01-18 18:31:48 +0100 | <cstm[m]> | :info Alternative |
| 2023-01-18 18:31:49 +0100 | <Joao003> | oh i guess it's failing so it's returning error and there's no error |
| 2023-01-18 18:31:51 +0100 | <anatta> | it shouldn't be |
| 2023-01-18 18:31:51 +0100 | <dminuoso> | cstm[m]: You cant determine that from that page. |
| 2023-01-18 18:31:53 +0100 | mbuf | (~Shakthi@49.204.129.175) (Quit: Leaving) |
| 2023-01-18 18:31:56 +0100 | <anatta> | but it seems like it is here |
| 2023-01-18 18:32:00 +0100 | <dminuoso> | cstm[m]: lambdabot has an orphan instance, clearly. |
| 2023-01-18 18:32:21 +0100 | <zwro> | but it worked before |
| 2023-01-18 18:32:35 +0100 | <zwro> | > Left "not cool" <|> Left "not cool" |
| 2023-01-18 18:32:36 +0100 | <cstm[m]> | @dminuoso: why not? Instances are there under the typeclass. |
| 2023-01-18 18:32:36 +0100 | <lambdabot> | Unknown command, try @list |
| 2023-01-18 18:32:37 +0100 | <lambdabot> | Left "not cool" |
| 2023-01-18 18:32:44 +0100 | <dminuoso> | zwro: yes, note now: |
| 2023-01-18 18:32:52 +0100 | <dminuoso> | :t Left "not cool" <|> Left "not cool" |
| 2023-01-18 18:32:53 +0100 | <lambdabot> | Either [Char] a |
| 2023-01-18 18:32:54 +0100 | <cstm[m]> | > :info Alternative |
| 2023-01-18 18:32:56 +0100 | <lambdabot> | <hint>:1:1: error: parse error on input ‘:’ |
| 2023-01-18 18:33:13 +0100 | <dminuoso> | zwro: And presumably an `instance Control.Monad.Trans.Error.Error [Char]`, or on `[a]` exists |
| 2023-01-18 18:33:21 +0100 | tsandstr | (~user@2601:18b:8100:7300::524) (Killed buffer) |
| 2023-01-18 18:33:25 +0100 | <mauke> | cstm: *some* instances are there under the typeclass |
| 2023-01-18 18:33:27 +0100 | <dminuoso> | cstm[m]: only the typeclass instances known in that package. |
| 2023-01-18 18:33:45 +0100 | <dminuoso> | cstm[m]: hackage doesnt feed hackage wide information into haddock. |
| 2023-01-18 18:33:49 +0100 | <zwro> | well, ghci is giving me `No instance for (Alternative (Either String)) ...` |
| 2023-01-18 18:33:53 +0100 | <Joao003> | guys |
| 2023-01-18 18:33:55 +0100 | <zwro> | so idk what the hell is going on |
| 2023-01-18 18:33:58 +0100 | <dminuoso> | the haddock is, mostly, just on a per-package basis. |
| 2023-01-18 18:34:01 +0100 | <anatta> | yeah I can't run it locally either |
| 2023-01-18 18:34:04 +0100 | <dminuoso> | zwro: yes, your ghci is not lambdabot |
| 2023-01-18 18:34:16 +0100 | <Joao003> | you can use maxBound / minBound to determine if the user's machine is 32-bit or 64-bit |
| 2023-01-18 18:34:24 +0100 | <cstm[m]> | Yes - but instances for types provided by base are always implemented in any library. |
| 2023-01-18 18:34:36 +0100 | <cstm[m]> | @dminuoso:libera.chat: ^^ |
| 2023-01-18 18:34:36 +0100 | <lambdabot> | Unknown command, try @list |
| 2023-01-18 18:34:42 +0100 | <mauke> | Joao003: no, you can't (in general) |
| 2023-01-18 18:35:11 +0100 | <mauke> | I mean, you probably can with how Int is currently implemented in ghc |
| 2023-01-18 18:35:21 +0100 | <Joao003> | if the compiler is 32-bit / 64-bit |
| 2023-01-18 18:35:25 +0100 | <mauke> | but I don't think that's a formal requirement |
| 2023-01-18 18:35:55 +0100 | <Joao003> | my comp is 64-bit so it's appearing as approximately 9 quintillion |
| 2023-01-18 18:36:09 +0100 | <zwro> | > (maxBound :: Int) == 9223372036854775807 -- lol |
| 2023-01-18 18:36:11 +0100 | <lambdabot> | True |
| 2023-01-18 18:36:45 +0100 | <Joao003> | > maxBound :: Integer -- doesn't exist (probably) |
| 2023-01-18 18:36:46 +0100 | <lambdabot> | error: |
| 2023-01-18 18:36:46 +0100 | <lambdabot> | • No instance for (Bounded Integer) |
| 2023-01-18 18:36:46 +0100 | <lambdabot> | arising from a use of ‘maxBound’ |
| 2023-01-18 18:37:07 +0100 | <Joao003> | see the difference between int and integer |
| 2023-01-18 18:37:22 +0100 | <mauke> | > (maxBound :: Int32) == 9223372036854775807 |
| 2023-01-18 18:37:23 +0100 | <lambdabot> | False |
| 2023-01-18 18:37:28 +0100 | dequbed | (~dequbed@banana-new.kilobyte22.de) (Quit: bye!) |
| 2023-01-18 18:37:32 +0100 | <glguy> | % GHC.Platform.Host.hostPlatformArch |
| 2023-01-18 18:37:32 +0100 | <yahb2> | ArchX86_64 |
| 2023-01-18 18:37:46 +0100 | coot | (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot) |
| 2023-01-18 18:37:47 +0100 | <glguy> | There's the GHC-specific way to check |
| 2023-01-18 18:37:51 +0100 | <Joao003> | > GHC.Platform.Host.hostPlatformArch |
| 2023-01-18 18:37:52 +0100 | <lambdabot> | error: |
| 2023-01-18 18:37:53 +0100 | <lambdabot> | Not in scope: ‘GHC.Platform.Host.hostPlatformArch’ |
| 2023-01-18 18:37:53 +0100 | <lambdabot> | No module named ‘GHC.Platform.Host’ is imported. |
| 2023-01-18 18:38:08 +0100 | <glguy> | lambdabot doesn't expose that |
| 2023-01-18 18:38:28 +0100 | Feuermagier | (~Feuermagi@user/feuermagier) |
| 2023-01-18 18:38:31 +0100 | <zwro> | none of this is confusing at all |
| 2023-01-18 18:38:32 +0100 | <Joao003> | yahb2 is running on arch |
| 2023-01-18 18:38:37 +0100 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) (Remote host closed the connection) |
| 2023-01-18 18:38:38 +0100 | <Joao003> | x86_64 |
| 2023-01-18 18:38:50 +0100 | <Joao003> | if you wanna know my pc is x64 |
| 2023-01-18 18:39:07 +0100 | jonathanx | (~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) |
| 2023-01-18 18:39:15 +0100 | jonathanx | (~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) (Client Quit) |
| 2023-01-18 18:39:22 +0100 | <mauke> | > (-1 :: Int32) == 9223372036854775807 |
| 2023-01-18 18:39:24 +0100 | <lambdabot> | True |
| 2023-01-18 18:39:50 +0100 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) |
| 2023-01-18 18:39:54 +0100 | <Joao003> | > (-1 :: Int64) == 2147483647 |
| 2023-01-18 18:39:56 +0100 | <lambdabot> | False |
| 2023-01-18 18:40:07 +0100 | <Joao003> | > (-1 :: Int64) == (2147483647 :: Int32) |
| 2023-01-18 18:40:09 +0100 | <lambdabot> | error: |
| 2023-01-18 18:40:09 +0100 | <lambdabot> | • Couldn't match expected type ‘Int64’ with actual type ‘Int32’ |
| 2023-01-18 18:40:09 +0100 | <lambdabot> | • In the second argument of ‘(==)’, namely ‘(2147483647 :: Int32)’ |
| 2023-01-18 18:40:31 +0100 | dequbed | (~dequbed@banana-new.kilobyte22.de) |
| 2023-01-18 18:40:31 +0100 | <zwro> | Joao003: ArchX86_64 is not a reference to the Arch Linux distro |
| 2023-01-18 18:40:39 +0100 | <Joao003> | ik |
| 2023-01-18 18:40:45 +0100 | <zwro> | oh ok |
| 2023-01-18 18:40:59 +0100 | kuribas | (~user@ip-188-118-57-242.reverse.destiny.be) (Remote host closed the connection) |
| 2023-01-18 18:41:19 +0100 | <Joao003> | :k a -> a -> a |
| 2023-01-18 18:41:20 +0100 | <lambdabot> | error: Not in scope: type variable ‘a’ |
| 2023-01-18 18:41:28 +0100 | <Joao003> | NOT IN SCOPE 3X |
| 2023-01-18 18:41:51 +0100 | <Joao003> | guys is there a function to extract out of a monad |
| 2023-01-18 18:41:54 +0100 | <geekosaur> | surprised it didn't jam them all into one line like it usually does |
| 2023-01-18 18:42:07 +0100 | <geekosaur> | not unless the monad provides one |
| 2023-01-18 18:42:26 +0100 | barzo | (~hd@31.223.41.44) |
| 2023-01-18 18:42:31 +0100 | <geekosaur> | in particular the only way to get something "out of" IO is (>>=) |
| 2023-01-18 18:42:34 +0100 | CiaoSen | (~Jura@p200300c95723a5002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 252 seconds) |
| 2023-01-18 18:42:40 +0100 | mmhat | (~mmh@p200300f1c7123cecee086bfffe095315.dip0.t-ipconnect.de) |
| 2023-01-18 18:42:42 +0100 | <Joao003> | you have either id id for Either |
| 2023-01-18 18:42:50 +0100 | <anatta> | fromMaybe |
| 2023-01-18 18:42:53 +0100 | zwro | thinks comonads |
| 2023-01-18 18:43:23 +0100 | <zwro> | :t extract |
| 2023-01-18 18:43:24 +0100 | <lambdabot> | error: Variable not in scope: extract |
| 2023-01-18 18:43:32 +0100 | <Joao003> | > let extractEither = either id id in extractEither (Right 3) |
| 2023-01-18 18:43:34 +0100 | <lambdabot> | 3 |
| 2023-01-18 18:43:53 +0100 | <[exa]> | Joao003: there is no "generic" one (imagine e.g. extracting stuff from Const) |
| 2023-01-18 18:44:07 +0100 | <Joao003> | imagine extracting values from Lists |
| 2023-01-18 18:44:13 +0100 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 252 seconds) |
| 2023-01-18 18:44:18 +0100 | oldfashionedcow | (~Rahul_San@user/oldfashionedcow) (Ping timeout: 272 seconds) |
| 2023-01-18 18:44:20 +0100 | nek0 | (~nek0@2a01:4f8:222:2b41::12) |
| 2023-01-18 18:44:30 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) (Ping timeout: 256 seconds) |
| 2023-01-18 18:44:59 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) |
| 2023-01-18 18:45:00 +0100 | <anatta> | there are lots of immoral ways of extracting from lists though |
| 2023-01-18 18:45:14 +0100 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) |
| 2023-01-18 18:45:33 +0100 | <zwro> | :t Control.Comonad.extract |
| 2023-01-18 18:45:35 +0100 | <lambdabot> | Control.Comonad.Comonad w => w a -> a |
| 2023-01-18 18:45:55 +0100 | Tuplanolla | (~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) |
| 2023-01-18 18:46:42 +0100 | <anatta> | :t head |
| 2023-01-18 18:46:43 +0100 | <lambdabot> | [a] -> a |
| 2023-01-18 18:46:46 +0100 | <anatta> | :t (!!) |
| 2023-01-18 18:46:48 +0100 | <lambdabot> | [a] -> Int -> a |
| 2023-01-18 18:46:54 +0100 | <anatta> | so sad |
| 2023-01-18 18:47:45 +0100 | <Joao003> | > head' = (!! 0) in head' [1..3] |
| 2023-01-18 18:47:47 +0100 | <lambdabot> | <hint>:1:7: error: parse error on input ‘=’ |
| 2023-01-18 18:47:52 +0100 | <Joao003> | > let head' = (!! 0) in head' [1..3] |
| 2023-01-18 18:47:55 +0100 | <lambdabot> | 1 |
| 2023-01-18 18:48:33 +0100 | <anatta> | you can write |
| 2023-01-18 18:48:45 +0100 | <anatta> | > [1..3] !! 0 |
| 2023-01-18 18:48:46 +0100 | <lambdabot> | 1 |
| 2023-01-18 18:49:01 +0100 | <anatta> | but the question is whether you should |
| 2023-01-18 18:49:09 +0100 | <anatta> | !! is partial |
| 2023-01-18 18:49:35 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) (Ping timeout: 255 seconds) |
| 2023-01-18 18:49:59 +0100 | <anatta> | > [1..3] !! 3 |
| 2023-01-18 18:50:01 +0100 | <lambdabot> | *Exception: Prelude.!!: index too large |
| 2023-01-18 18:50:19 +0100 | <anatta> | you might get crashes |
| 2023-01-18 18:50:22 +0100 | <Joao003> | > [1..] !! 1000000 |
| 2023-01-18 18:50:24 +0100 | <lambdabot> | 1000001 |
| 2023-01-18 18:50:31 +0100 | <Joao003> | > [1..] !! 1000000000000000000000000000000000000 |
| 2023-01-18 18:50:33 +0100 | <lambdabot> | *Exception: Prelude.!!: negative index |
| 2023-01-18 18:50:44 +0100 | <Joao003> | wth int wraparound |
| 2023-01-18 18:51:00 +0100 | <Joao003> | > [1..] !! (1000000000000000000000000000000000000 :: Integer) |
| 2023-01-18 18:51:03 +0100 | <lambdabot> | error: |
| 2023-01-18 18:51:03 +0100 | <lambdabot> | • Couldn't match expected type ‘Int’ with actual type ‘Integer’ |
| 2023-01-18 18:51:03 +0100 | <lambdabot> | • In the second argument of ‘(!!)’, namely |
| 2023-01-18 18:51:07 +0100 | <Joao003> | lol |
| 2023-01-18 18:51:29 +0100 | <Joao003> | > [1..] !! (1000000000000000000000000000000000000 :: Int128) |
| 2023-01-18 18:51:31 +0100 | <lambdabot> | error: |
| 2023-01-18 18:51:31 +0100 | <lambdabot> | Not in scope: type constructor or class ‘Int128’ |
| 2023-01-18 18:51:31 +0100 | <lambdabot> | Perhaps you meant one of these: |
| 2023-01-18 18:51:51 +0100 | Joao003 | (~Joao003@2804:840:8311:d200:c41b:789b:8754:5281) (Quit: Leaving) |
| 2023-01-18 18:51:52 +0100 | thyriaen | (~thyriaen@2a01:aea0:dd4:4bae:6245:cbff:fe9f:48b1) (Ping timeout: 256 seconds) |
| 2023-01-18 18:52:57 +0100 | oldfashionedcow | (~Rahul_San@user/oldfashionedcow) |
| 2023-01-18 18:57:53 +0100 | nschoe | (~q@141.101.51.197) (Quit: Switching off) |
| 2023-01-18 18:58:58 +0100 | econo | (uid147250@user/econo) |
| 2023-01-18 18:59:35 +0100 | segfaultfizzbuzz | (~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) |
| 2023-01-18 19:00:31 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1812:9885:2ce4:4618) |
| 2023-01-18 19:00:56 +0100 | kurbus | (~kurbus@user/kurbus) |
| 2023-01-18 19:02:22 +0100 | zwro | (~z@user/zero) (Ping timeout: 252 seconds) |
| 2023-01-18 19:06:15 +0100 | myxokephale_ | (~myxokepha@cpe-65-28-251-121.cinci.res.rr.com) (Remote host closed the connection) |
| 2023-01-18 19:06:32 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) |
| 2023-01-18 19:06:57 +0100 | myxokephale | (~myxokepha@cpe-65-28-251-121.cinci.res.rr.com) |
| 2023-01-18 19:08:39 +0100 | codaraxis | (~codaraxis@user/codaraxis) (Ping timeout: 260 seconds) |
| 2023-01-18 19:12:27 +0100 | akegalj | (~akegalj@141-136-136-225.dsl.iskon.hr) |
| 2023-01-18 19:15:17 +0100 | zero | (~z@user/zero) |
| 2023-01-18 19:17:56 +0100 | mmhat | (~mmh@p200300f1c7123cecee086bfffe095315.dip0.t-ipconnect.de) (Ping timeout: 256 seconds) |
| 2023-01-18 19:18:19 +0100 | mmhat | (~mmh@p200300f1c7123ce0ee086bfffe095315.dip0.t-ipconnect.de) |
| 2023-01-18 19:19:59 +0100 | beteigeuze | (~Thunderbi@a79-169-109-107.cpe.netcabo.pt) (Ping timeout: 260 seconds) |
| 2023-01-18 19:21:35 +0100 | Joao003 | (~Joao003@2804:840:8311:d200:c41b:789b:8754:5281) |
| 2023-01-18 19:21:42 +0100 | bgs | (~bgs@212-85-160-171.dynamic.telemach.net) |
| 2023-01-18 19:23:43 +0100 | <EvanR> | !! is only partial if you pass in the wrong input relative to the list |
| 2023-01-18 19:23:51 +0100 | <EvanR> | it's only illegal if you get caught |
| 2023-01-18 19:24:39 +0100 | <EvanR> | sounds stupid but this is how dynamically typed real life cubical programming even works |
| 2023-01-18 19:27:02 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds) |
| 2023-01-18 19:27:25 +0100 | [itchyjunk] | (~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection) |
| 2023-01-18 19:27:43 +0100 | [itchyjunk] | (~itchyjunk@user/itchyjunk/x-7353470) |
| 2023-01-18 19:31:26 +0100 | <anatta> | I prefer dropping n and pattern matching |
| 2023-01-18 19:32:30 +0100 | kurbus | (~kurbus@user/kurbus) (Quit: Client closed) |
| 2023-01-18 19:32:45 +0100 | <anatta> | but it's not a hard rule, I just lean towards it |
| 2023-01-18 19:33:52 +0100 | <EvanR> | when !! would work (because there's proof you used it right), it's more succint than drop + pattern match. If there is no proof, drop + pattern match is still wrong |
| 2023-01-18 19:33:58 +0100 | stiell_ | (~stiell@gateway/tor-sasl/stiell) |
| 2023-01-18 19:34:10 +0100 | <EvanR> | since you have to deal with the "impossible" empty case |
| 2023-01-18 19:38:48 +0100 | <anatta> | Yes, but it forces you to think about and specify what you want, and it's not really less code if you have to wrap !! in checks anyway |
| 2023-01-18 19:39:03 +0100 | <anatta> | I dunno, I think it's neater |
| 2023-01-18 19:40:06 +0100 | <EvanR> | I'm only talking about cases where !! doesn't require checks |
| 2023-01-18 19:40:19 +0100 | <EvanR> | actually in cases where putting checks would be nonsense |
| 2023-01-18 19:41:10 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 256 seconds) |
| 2023-01-18 19:42:07 +0100 | <EvanR> | as an example, the algorithm explicitly creates a list of size n, then creates i which must be less than n, then indexes into the list with i. |
| 2023-01-18 19:43:32 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) |
| 2023-01-18 19:43:35 +0100 | <EvanR> | (also i >= 0. All by virtue of the algorithm an not an explicit check. And the proof is on this napkin. Because we don't have the type system for it) |
| 2023-01-18 19:47:05 +0100 | <anatta> | as I said, it's not a hard rule for me - but I'd say I have seen more code with partial functions I think should have been avoided than I have seen code I think would have been better with more partial functions |
| 2023-01-18 19:47:26 +0100 | <Hecate> | https://nullprogram.com/blog/2023/01/18/ |
| 2023-01-18 19:47:31 +0100 | <Hecate> | ah, another standard arrives |
| 2023-01-18 19:48:00 +0100 | Rembane | waves appropriate xkcd strip around |
| 2023-01-18 19:48:00 +0100 | beteigeuze | (~Thunderbi@bl14-81-220.dsl.telepac.pt) |
| 2023-01-18 19:48:01 +0100 | barzo | (~hd@31.223.41.44) (Ping timeout: 252 seconds) |
| 2023-01-18 19:48:05 +0100 | <Hecate> | exactly |
| 2023-01-18 19:48:13 +0100 | <Hecate> | didn't we have a discussion about pkg-config lately btw? |
| 2023-01-18 19:48:32 +0100 | oldfashionedcow | (~Rahul_San@user/oldfashionedcow) (Ping timeout: 256 seconds) |
| 2023-01-18 19:49:39 +0100 | <geekosaur> | yep |
| 2023-01-18 19:50:48 +0100 | avicenzi | (~avicenzi@2a00:ca8:a1f:b004::c32) (Ping timeout: 256 seconds) |
| 2023-01-18 19:51:25 +0100 | remedan | (~remedan@144.76.104.133) |
| 2023-01-18 19:54:03 +0100 | barzo | (~hd@31.223.41.44) |
| 2023-01-18 19:54:42 +0100 | mmhat | (~mmh@p200300f1c7123ce0ee086bfffe095315.dip0.t-ipconnect.de) (Quit: WeeChat 3.8) |
| 2023-01-18 19:54:58 +0100 | <geekosaur> | so this is not so much another standard as it is a reimplementation of an existing one |
| 2023-01-18 19:55:22 +0100 | <geekosaur> | (seriously, I had no idea the implementation of pkg-config was so baroque) |
| 2023-01-18 19:59:25 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1812:9885:2ce4:4618) (Remote host closed the connection) |
| 2023-01-18 20:02:38 +0100 | <EvanR> | build systems ;_; |
| 2023-01-18 20:02:44 +0100 | gmg | (~user@user/gehmehgeh) |
| 2023-01-18 20:04:30 +0100 | ix | (~ix@2a02:8010:674f:0:d65d:64ff:fe52:5efe) |
| 2023-01-18 20:05:05 +0100 | jero98772 | (~jero98772@2800:484:1d80:d8ce:3490:26c5:1782:da8c) |
| 2023-01-18 20:05:48 +0100 | <mauke> | <Hecate> "https://nullprogram.com/blog/202..." <- I'm not at the end yet, but I don't really like the code in there |
| 2023-01-18 20:06:48 +0100 | <mauke> | for example, #define SIZEOF(x) (Size)(sizeof(x)) uses parens where you don't need them, but is missing parens where you do need them |
| 2023-01-18 20:06:49 +0100 | <mauke> | this is like C macro 101 |
| 2023-01-18 20:07:04 +0100 | <dminuoso> | cstm[m]: Sure, and Im saying the instance in lambdabot comes from some module outside of `base`. |
| 2023-01-18 20:07:34 +0100 | titibandit1 | (~titibandi@xdsl-81-173-160-143.nc.de) (Remote host closed the connection) |
| 2023-01-18 20:08:02 +0100 | <dminuoso> | re pkg-config, I think its one of the saner standards I wish more packages would adhere to. |
| 2023-01-18 20:08:07 +0100 | irrgit__ | (~irrgit@89.47.234.74) |
| 2023-01-18 20:08:13 +0100 | <mauke> | similarly, the `S` macro only works (= produces correct code) with string literals, but makes no attempt to verify this (it could have used `"" s ""` in its body) |
| 2023-01-18 20:10:56 +0100 | ix | (~ix@2a02:8010:674f:0:d65d:64ff:fe52:5efe) (Read error: Connection reset by peer) |
| 2023-01-18 20:11:08 +0100 | ix | (~ix@2a02:8010:674f:0:d65d:64ff:fe52:5efe) |
| 2023-01-18 20:11:19 +0100 | irrgit_ | (~irrgit@146.70.27.250) (Ping timeout: 260 seconds) |
| 2023-01-18 20:11:46 +0100 | beteigeuze | (~Thunderbi@bl14-81-220.dsl.telepac.pt) (Ping timeout: 256 seconds) |
| 2023-01-18 20:13:54 +0100 | <voidzero> | the book get programming with haskell - work through a huge chapter on how to process binary data aand in the end the code doesn't even work and there's no way to find out where the problem is |
| 2023-01-18 20:13:59 +0100 | <voidzero> | i am so fed up with this stupid book |
| 2023-01-18 20:14:05 +0100 | <voidzero> | it is so full of sloppy errors |
| 2023-01-18 20:14:12 +0100 | voidzero | bangs head to desk |
| 2023-01-18 20:14:14 +0100 | Cale | (~cale@cpef48e38ee8583-cm30b7d4b3fc20.cpe.net.cable.rogers.com) (Ping timeout: 272 seconds) |
| 2023-01-18 20:14:24 +0100 | <Hecate> | oh that's not good |
| 2023-01-18 20:14:32 +0100 | <Hecate> | voidzero: have you checked the errata for the book btw? |
| 2023-01-18 20:14:40 +0100 | <Hecate> | I believe there's a system at Manning to report such things |
| 2023-01-18 20:14:55 +0100 | Guest45 | (~Guest45@94.120.126.185) |
| 2023-01-18 20:15:04 +0100 | <voidzero> | Yeah. There's a forum where you can do that. It's filled to the brim with bugs, errors and whatnot |
| 2023-01-18 20:15:11 +0100 | <voidzero> | do they not have editors and proofreaders? |
| 2023-01-18 20:15:18 +0100 | Cale | (~cale@cpef48e38ee8583-cm30b7d4b3fc20.cpe.net.cable.rogers.com) |
| 2023-01-18 20:15:22 +0100 | <Hecate> | holy shit |
| 2023-01-18 20:16:40 +0100 | <voidzero> | it goes from ridiculous stuff like ligatures not working - like the character 'fi' so everywhere where there is a certain font and they have 'find', it looks like 'â–¡nd' |
| 2023-01-18 20:16:50 +0100 | <voidzero> | in the print version that is |
| 2023-01-18 20:17:24 +0100 | <Hecate> | wow I'm really to discover this about the book |
| 2023-01-18 20:17:47 +0100 | <voidzero> | to working through an entire chapter on how to combine T.Text with B.ByteString and then later referring to BC.ByteString out of nowhere (sloppy), and ending up compiling code that, when executes, gives the following error |
| 2023-01-18 20:17:50 +0100 | Guest45 | (~Guest45@94.120.126.185) (Client Quit) |
| 2023-01-18 20:17:53 +0100 | <voidzero> | *** Exception: Cannot decode byte '\xcc': Data.Text.Internal.Encoding.decodeUtf8: Invalid UTF-8 stream |
| 2023-01-18 20:18:36 +0100 | <voidzero> | it's ever so slightly annoyink :) |
| 2023-01-18 20:18:44 +0100 | <voidzero> | </rant> |
| 2023-01-18 20:18:57 +0100 | <voidzero> | is there a way in ghci to trace functions? |
| 2023-01-18 20:19:36 +0100 | trev | (~trev@user/trev) |
| 2023-01-18 20:19:41 +0100 | <opqdonut> | yeah the ghci debugger is pretty nice |
| 2023-01-18 20:19:57 +0100 | <geekosaur> | https://downloads.haskell.org/ghc/9.4.1/docs/users_guide/ghci.html#tracing-and-history |
| 2023-01-18 20:20:12 +0100 | <opqdonut> | https://downloads.haskell.org/ghc/latest/docs/users_guide/ghci.html#the-ghci-debugger |
| 2023-01-18 20:20:15 +0100 | <opqdonut> | beat me to it |
| 2023-01-18 20:21:11 +0100 | <voidzero> | thanks |
| 2023-01-18 20:21:47 +0100 | <geekosaur> | there's also the ghc-vis package which plugs into ghci to visualize evaluation |
| 2023-01-18 20:22:06 +0100 | <voidzero> | the example in the book has you stream a binary MARC file ('60s library data) and process it, output it to a html file |
| 2023-01-18 20:22:41 +0100 | <voidzero> | but I just tried to process one single record to prevent the exception - and even the single record doesn't print to html |
| 2023-01-18 20:23:20 +0100 | <voidzero> | at this point I kinda feel like daffy duck bouncing off screen screaming cuckoo until the credits roll |
| 2023-01-18 20:25:25 +0100 | oldfashionedcow | (~Rahul_San@user/oldfashionedcow) |
| 2023-01-18 20:25:32 +0100 | <voidzero> | because it took me 4 hours to type everything over by hand |
| 2023-01-18 20:26:13 +0100 | <EvanR> | voidzero, if you can, use utf8 decoder that returns an Either and doesn't assume input is valid utf8 |
| 2023-01-18 20:26:39 +0100 | <EvanR> | unless you have a proof lying around that it is valid for some reason |
| 2023-01-18 20:26:40 +0100 | <mauke> | or better, don't decode binary data as utf-8 text? |
| 2023-01-18 20:28:09 +0100 | <voidzero> | Yes I've seen that said before so I was a bit uncertain. But the book said, "MARC records are in a binary format that also makes heavy use of Unicode to properly store character encodings" |
| 2023-01-18 20:28:38 +0100 | <EvanR> | well... sounds like that doesn't count as proof |
| 2023-01-18 20:28:50 +0100 | <voidzero> | "To use MARC records, you have to be careful about separating when you’re working with bytes from when you’re working with text. This is a perfect problem to explore all you’ve learned in this unit!" :)) |
| 2023-01-18 20:28:57 +0100 | <opqdonut> | when I was writing my course I was kind of wishing for a tool that would let me write a source file and tests for it, and then somehow declaratively embed certain definitions or parts inside the text |
| 2023-01-18 20:29:15 +0100 | <EvanR> | yeah so so parts of the data are supposedly UTF-8, but even then, you don't really know |
| 2023-01-18 20:29:20 +0100 | <EvanR> | some parts* |
| 2023-01-18 20:29:26 +0100 | <mauke> | that sounds like literate programming |
| 2023-01-18 20:29:29 +0100 | <opqdonut> | literate programming is great when it's ok to be code-first, but I wanted to concentrate on the text and just ensure my examples were consistent |
| 2023-01-18 20:29:30 +0100 | <voidzero> | Agree. You don't really know. |
| 2023-01-18 20:29:56 +0100 | <opqdonut> | I mean, for a blog post, literate programming is great, for introductory material, maybe a bit less great |
| 2023-01-18 20:30:08 +0100 | <mauke> | huh? |
| 2023-01-18 20:30:43 +0100 | <mauke> | how is literate programming code-first? |
| 2023-01-18 20:31:10 +0100 | <opqdonut> | you need to "show" all the code, and it's usually also done in the same order as the code |
| 2023-01-18 20:31:27 +0100 | <mauke> | that's not literate programming, then |
| 2023-01-18 20:31:28 +0100 | <opqdonut> | and it can be difficult to have multiple versions of the same function (and to still test them all) |
| 2023-01-18 20:31:47 +0100 | <[exa]> | mauke: in some languages they have comments converted to text, not code blocks converted to code |
| 2023-01-18 20:31:54 +0100 | <opqdonut> | yeah I guess with knuth's stuff (weave? what was it?) you could present the code out-of-order, but with your typical .lhs it's very ordered |
| 2023-01-18 20:32:12 +0100 | <geekosaur> | weave and tangle |
| 2023-01-18 20:32:23 +0100 | <mauke> | I wouldn't call .lhs literate programming |
| 2023-01-18 20:32:42 +0100 | <opqdonut> | ok then |
| 2023-01-18 20:33:12 +0100 | <mauke> | Knuth was all about didactic presentation, which almost necessarily means "out of order" for the code |
| 2023-01-18 20:33:20 +0100 | <opqdonut> | yeah |
| 2023-01-18 20:43:21 +0100 | CiaoSen | (~Jura@p200300c95723a5002a3a4dfffe84dbd5.dip0.t-ipconnect.de) |
| 2023-01-18 20:45:06 +0100 | panovia | (~user@user/siracusa) |
| 2023-01-18 20:45:46 +0100 | mikoto-chan | (~mikoto-ch@164.5.249.78) (Ping timeout: 256 seconds) |
| 2023-01-18 20:47:50 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) (Ping timeout: 260 seconds) |
| 2023-01-18 20:50:49 +0100 | mei | (~mei@user/mei) |
| 2023-01-18 20:51:29 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) |
| 2023-01-18 20:53:07 +0100 | uics | (~uics@91.150.188.137) |
| 2023-01-18 20:53:11 +0100 | tremon | (~tremon@83-85-213-108.cable.dynamic.v4.ziggo.nl) |
| 2023-01-18 20:53:23 +0100 | uics | (~uics@91.150.188.137) (#haskell) |
| 2023-01-18 20:56:58 +0100 | <Joao003> | .lhs is more of a "comment without --" style |
| 2023-01-18 20:57:08 +0100 | ub | (~Thunderbi@146.70.116.178) |
| 2023-01-18 20:58:37 +0100 | ubert | (~Thunderbi@p200300ecdf264e0169c651b6116f6648.dip0.t-ipconnect.de) (Ping timeout: 256 seconds) |
| 2023-01-18 20:59:22 +0100 | <voidzero> | ok I found someone who published their source code to the same module so now I can compare |
| 2023-01-18 20:59:48 +0100 | <voidzero> | if it was my bad then I will admit it and eat crow np |
| 2023-01-18 20:59:54 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1812:9885:2ce4:4618) |
| 2023-01-18 21:00:23 +0100 | ubert | (~Thunderbi@146.70.116.146) |
| 2023-01-18 21:01:38 +0100 | ub | (~Thunderbi@146.70.116.178) (Ping timeout: 256 seconds) |
| 2023-01-18 21:02:26 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) |
| 2023-01-18 21:03:48 +0100 | <voidzero> | at least their code does output the right html so it is starting to look like it |
| 2023-01-18 21:03:56 +0100 | voidzero | gets his napkin |
| 2023-01-18 21:04:05 +0100 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:1812:9885:2ce4:4618) (Ping timeout: 246 seconds) |
| 2023-01-18 21:12:19 +0100 | <voidzero> | got it. The book has yet another typo that caused it to fail |
| 2023-01-18 21:12:20 +0100 | <voidzero> | phew |
| 2023-01-18 21:12:23 +0100 | voidzero | releases the crow |
| 2023-01-18 21:12:35 +0100 | <voidzero> | fly bird fly |
| 2023-01-18 21:12:58 +0100 | raehik | (~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 256 seconds) |
| 2023-01-18 21:14:01 +0100 | <mauke> | what was the typo? |
| 2023-01-18 21:19:32 +0100 | PianoMan54 | (~Guest5@81.78.231.0) |
| 2023-01-18 21:20:23 +0100 | <Hecate> | or an idiom |
| 2023-01-18 21:21:00 +0100 | thyriaen | (~thyriaen@2a01:aea0:dd4:4bae:6245:cbff:fe9f:48b1) |
| 2023-01-18 21:21:51 +0100 | <voidzero> | getDirectory record = B.take directoryLength afterLeader where directoryLength = getDirectoryLength record ; afterLeader = B.drop leaderLength record |
| 2023-01-18 21:22:10 +0100 | <voidzero> | here, afterLeader is the culprit, it should be afterLeader B.drop directoryLength record |
| 2023-01-18 21:23:39 +0100 | PianoMan54 | (~Guest5@81.78.231.0) (Quit: Client closed) |
| 2023-01-18 21:31:54 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) (Remote host closed the connection) |
| 2023-01-18 21:32:28 +0100 | ft | (~ft@p4fc2a257.dip0.t-ipconnect.de) |
| 2023-01-18 21:32:30 +0100 | trev | (~trev@user/trev) (Remote host closed the connection) |
| 2023-01-18 21:32:32 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) |
| 2023-01-18 21:33:08 +0100 | <Joao003> | (>>=) :: [a] -> (a -> [b]) -> [b] is just concatMap |
| 2023-01-18 21:35:56 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 272 seconds) |
| 2023-01-18 21:36:50 +0100 | int-index-r | (~Vladislav@2a00:1370:8178:5994:6490:ec14:6af:3fa6) (Quit: Konversation terminated!) |
| 2023-01-18 21:36:59 +0100 | gentauro | (~gentauro@user/gentauro) (Read error: Connection reset by peer) |
| 2023-01-18 21:38:16 +0100 | <mauke> | flip concatMap, but yes |
| 2023-01-18 21:38:24 +0100 | caryhartline | (~caryhartl@2603-8080-6a0e-8d88-8c3d-f560-b5e7-981d.res6.spectrum.com) |
| 2023-01-18 21:40:03 +0100 | Joao003 | (~Joao003@2804:840:8311:d200:c41b:789b:8754:5281) (Quit: Leaving) |
| 2023-01-18 21:42:00 +0100 | Joao003 | (~Joao003@2804:840:8311:d200:c41b:789b:8754:5281) |
| 2023-01-18 21:42:13 +0100 | <monochrom> | Yes this inspired the name "flatMap". |
| 2023-01-18 21:42:39 +0100 | gentauro | (~gentauro@user/gentauro) |
| 2023-01-18 21:45:32 +0100 | mei | (~mei@user/mei) (Quit: mei) |
| 2023-01-18 21:46:10 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) (Ping timeout: 260 seconds) |
| 2023-01-18 21:50:32 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) |
| 2023-01-18 21:51:29 +0100 | Joao003 | (~Joao003@2804:840:8311:d200:c41b:789b:8754:5281) (Read error: Connection reset by peer) |
| 2023-01-18 21:52:22 +0100 | remedan_ | (~remedan@ip-89-177-74-251.bb.vodafone.cz) |
| 2023-01-18 21:54:26 +0100 | mikoto-chan | (~mikoto-ch@164.5.249.78) |
| 2023-01-18 21:56:14 +0100 | vykt | (~vykt@92.40.125.229.threembb.co.uk) (Ping timeout: 268 seconds) |
| 2023-01-18 21:56:33 +0100 | gnalzo | (~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8) |
| 2023-01-18 21:57:42 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) (Ping timeout: 255 seconds) |
| 2023-01-18 21:58:01 +0100 | vykt | (~vykt@92.40.125.142.threembb.co.uk) |
| 2023-01-18 22:00:11 +0100 | <dsal> | I like `foldMap` |
| 2023-01-18 22:00:51 +0100 | Guest53 | (~Guest53@2600:1700:80:4ec0:1cec:2236:2eaa:ca5c) |
| 2023-01-18 22:02:03 +0100 | <EvanR> | :t foldMap |
| 2023-01-18 22:02:04 +0100 | <lambdabot> | (Foldable t, Monoid m) => (a -> m) -> t a -> m |
| 2023-01-18 22:02:35 +0100 | <EvanR> | :t (>>=) |
| 2023-01-18 22:02:36 +0100 | <lambdabot> | Monad m => m a -> (a -> m b) -> m b |
| 2023-01-18 22:03:12 +0100 | <EvanR> | :t join |
| 2023-01-18 22:03:13 +0100 | <lambdabot> | Monad m => m (m a) -> m a |
| 2023-01-18 22:03:27 +0100 | <EvanR> | joinMap |
| 2023-01-18 22:04:01 +0100 | <EvanR> | except flat is better than join |
| 2023-01-18 22:04:06 +0100 | Guest53 | (~Guest53@2600:1700:80:4ec0:1cec:2236:2eaa:ca5c) (Client Quit) |
| 2023-01-18 22:05:29 +0100 | opticblast | (~Thunderbi@secure-165.caltech.edu) (Ping timeout: 268 seconds) |
| 2023-01-18 22:07:50 +0100 | gmg | (~user@user/gehmehgeh) (Quit: Leaving) |
| 2023-01-18 22:09:16 +0100 | Bocaneri | (~sauvin@user/Sauvin) |
| 2023-01-18 22:09:41 +0100 | Bocaneri | Guest5498 |
| 2023-01-18 22:10:03 +0100 | remedan | (~remedan@144.76.104.133) (Read error: Connection reset by peer) |
| 2023-01-18 22:10:05 +0100 | <voidzero> | Ok, looks like I was wrong on my issue again |
| 2023-01-18 22:10:12 +0100 | <voidzero> | I'm gonna give this another look after some good sleep |
| 2023-01-18 22:10:17 +0100 | <voidzero> | that crow might come back to haunt me |
| 2023-01-18 22:11:54 +0100 | Sauvin | (~sauvin@user/Sauvin) (Ping timeout: 256 seconds) |
| 2023-01-18 22:12:48 +0100 | remedan | (~remedan@144.76.104.133) |
| 2023-01-18 22:15:52 +0100 | remedan | (~remedan@144.76.104.133) (Read error: Connection reset by peer) |
| 2023-01-18 22:16:28 +0100 | <voidzero> | ok. I was wrong. I don't know what happened. |
| 2023-01-18 22:16:33 +0100 | <voidzero> | come 'ere crow |
| 2023-01-18 22:19:37 +0100 | <geekosaur> | go get that sleep |
| 2023-01-18 22:21:32 +0100 | mikoto-chan | (~mikoto-ch@164.5.249.78) (Read error: Connection reset by peer) |
| 2023-01-18 22:22:03 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) |
| 2023-01-18 22:22:45 +0100 | <EvanR> | threadDelay (8 * 3600 * 1000000) |
| 2023-01-18 22:24:10 +0100 | phma_ | (phma@2001:5b0:211f:9e88:7b45:ac5a:b196:43f5) |
| 2023-01-18 22:25:55 +0100 | phma | (~phma@host-67-44-208-74.hnremote.net) (Read error: Connection reset by peer) |
| 2023-01-18 22:26:35 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) (Ping timeout: 248 seconds) |
| 2023-01-18 22:29:17 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) |
| 2023-01-18 22:30:07 +0100 | thyriaen | (~thyriaen@2a01:aea0:dd4:4bae:6245:cbff:fe9f:48b1) (Remote host closed the connection) |
| 2023-01-18 22:37:24 +0100 | Lord_of_Life | (~Lord@user/lord-of-life/x-2819915) (Ping timeout: 256 seconds) |
| 2023-01-18 22:38:12 +0100 | Lord_of_Life | (~Lord@user/lord-of-life/x-2819915) |
| 2023-01-18 22:43:12 +0100 | coot | (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) |
| 2023-01-18 22:44:08 +0100 | <JonathanWatson[m> | is there any way to use this datatype from generics-sop where the kind l is not Type? |
| 2023-01-18 22:44:12 +0100 | JonathanWatson[m | uploaded an image: (13KiB) < https://libera.ems.host/_matrix/media/v3/download/matrix.org/zYgyubIFxwLDBArYgiLPYWLM/image.png > |
| 2023-01-18 22:44:31 +0100 | <JonathanWatson[m> | newtype ((f :: l -> Type) :.: (g :: k -> l)) (p :: k) |
| 2023-01-18 22:45:24 +0100 | bgs | (~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection) |
| 2023-01-18 22:45:36 +0100 | <JonathanWatson[m> | typically you get the functor by giving a type constructor like Maybe but then I think you always end up with Type on the right |
| 2023-01-18 22:46:17 +0100 | <JonathanWatson[m> | and you can't use type families because I don't think type families can be partially applied |
| 2023-01-18 22:46:35 +0100 | <JonathanWatson[m> | but maybe you can do something with promotion? |
| 2023-01-18 22:50:32 +0100 | Umeaboy | (~Umeaboy@94-255-145-133.cust.bredband2.com) |
| 2023-01-18 22:50:47 +0100 | <JonathanWatson[m> | Ok yeah I think you can use things like 'Just |
| 2023-01-18 22:51:07 +0100 | mc47 | (~mc47@xmonad/TheMC47) (Remote host closed the connection) |
| 2023-01-18 22:53:55 +0100 | fserucas | (~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7) (Ping timeout: 252 seconds) |
| 2023-01-18 22:54:04 +0100 | mei | (~mei@user/mei) |
| 2023-01-18 22:54:35 +0100 | <Umeaboy> | Hi! I would like some help to resolve this issue if possible: https://pastebin.com/i2xAtzHc |
| 2023-01-18 22:54:47 +0100 | <Umeaboy> | I used ghcup to install cabal. |
| 2023-01-18 22:55:30 +0100 | <geekosaur> | "/usr/bin/ld.gold: error: cannot find -lgmp" |
| 2023-01-18 22:55:36 +0100 | <geekosaur> | install the system gmp package |
| 2023-01-18 22:55:42 +0100 | <Umeaboy> | OK. |
| 2023-01-18 22:55:46 +0100 | <Umeaboy> | I'll do that. |
| 2023-01-18 22:56:27 +0100 | <geekosaur> | (devel ppackage if your system makes such distinctions; on my ubuntu system it's libgmp-dev) |
| 2023-01-18 22:56:53 +0100 | <monochrom> | ghcup would have detected your linux distro and pointed out the exact package name for that. |
| 2023-01-18 22:57:23 +0100 | <monochrom> | But humans have selective vision and selective memory to block out that. |
| 2023-01-18 22:59:09 +0100 | <Umeaboy> | geekosaur: https://pastebin.com/R3CMEpKL |
| 2023-01-18 22:59:26 +0100 | <Umeaboy> | So libgmp-devel it is. |
| 2023-01-18 22:59:34 +0100 | <monochrom> | Yeah. |
| 2023-01-18 23:00:15 +0100 | <Umeaboy> | monochrom: Well, full distro support for Mageia isn't added yet. I've begun to add it to the docs, but that's it. |
| 2023-01-18 23:00:32 +0100 | <monochrom> | OK fair. Sorry. |
| 2023-01-18 23:01:31 +0100 | <geekosaur> | the downside of tools that try to figure that stuff out for you |
| 2023-01-18 23:01:38 +0100 | <Umeaboy> | Yeah. |
| 2023-01-18 23:01:51 +0100 | <geekosaur> | it'll be out of date again next week when the next 10 linux distros come out 🙂 |
| 2023-01-18 23:02:08 +0100 | <monochrom> | GPT is supposed to help... |
| 2023-01-18 23:03:00 +0100 | akegalj | (~akegalj@141-136-136-225.dsl.iskon.hr) (Quit: leaving) |
| 2023-01-18 23:03:17 +0100 | johnw | (~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net) (Quit: ZNC - http://znc.in) |
| 2023-01-18 23:03:17 +0100 | jwiegley | (~jwiegley@2600:1700:cf00:db0:3c2b:7b2b:9a29:78) (Quit: ZNC - http://znc.in) |
| 2023-01-18 23:03:34 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) |
| 2023-01-18 23:05:42 +0100 | johnw | (~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net) |
| 2023-01-18 23:09:43 +0100 | biberu | (~biberu@user/biberu) (Read error: Connection reset by peer) |
| 2023-01-18 23:12:36 +0100 | biberu | (~biberu@user/biberu) |
| 2023-01-18 23:16:15 +0100 | Unicorn_Princess | (~Unicorn_P@user/Unicorn-Princess/x-3540542) (Quit: Leaving) |
| 2023-01-18 23:17:19 +0100 | <Umeaboy> | I thought that the configure script would find ghc since it's added to PATH. |
| 2023-01-18 23:17:38 +0100 | <Umeaboy> | Hmmmmmmmmm. Apparently it isn't. |
| 2023-01-18 23:17:53 +0100 | <Umeaboy> | Strange install behavior from ghcup. |
| 2023-01-18 23:18:13 +0100 | <Umeaboy> | I did choose Y to add it to PATH when asked. |
| 2023-01-18 23:19:01 +0100 | <Umeaboy> | All I see in ~/.bashrc is: [ -f "/home/kristoffer/.ghcup/env" ] && source "/home/kristoffer/.ghcup/env" # ghcup-env |
| 2023-01-18 23:19:32 +0100 | <monochrom> | That takes effect in new shell sessions. |
| 2023-01-18 23:20:03 +0100 | <monochrom> | You can also check the content of /home/kristoffer/.ghcup/env to see if it's doing the right thing. |
| 2023-01-18 23:20:06 +0100 | johnw | (~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net) (Quit: ZNC - http://znc.in) |
| 2023-01-18 23:20:37 +0100 | johnw | (~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net) |
| 2023-01-18 23:20:53 +0100 | <monochrom> | You can also use bash command "type ghc" to see if a shell session has it. |
| 2023-01-18 23:24:27 +0100 | <jackdk> | And/or run `. ~/.ghcup/env` to source it into your current shell |
| 2023-01-18 23:25:28 +0100 | titibandit1 | (~titibandi@xdsl-81-173-160-143.nc.de) |
| 2023-01-18 23:26:08 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) (Ping timeout: 252 seconds) |
| 2023-01-18 23:28:16 +0100 | caryhartline | (~caryhartl@2603-8080-6a0e-8d88-8c3d-f560-b5e7-981d.res6.spectrum.com) (Remote host closed the connection) |
| 2023-01-18 23:31:28 +0100 | [Leary] | (~Leary]@user/Leary/x-0910699) (Remote host closed the connection) |
| 2023-01-18 23:31:36 +0100 | [Leary] | (~Leary]@user/Leary/x-0910699) |
| 2023-01-18 23:34:38 +0100 | CiaoSen | (~Jura@p200300c95723a5002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 256 seconds) |
| 2023-01-18 23:36:12 +0100 | tremon | (~tremon@83-85-213-108.cable.dynamic.v4.ziggo.nl) (Quit: getting boxed in) |
| 2023-01-18 23:36:20 +0100 | CiaoSen | (~Jura@p200300c9572d4e002a3a4dfffe84dbd5.dip0.t-ipconnect.de) |
| 2023-01-18 23:37:52 +0100 | merijn | (~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 252 seconds) |
| 2023-01-18 23:38:34 +0100 | coot | (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot) |
| 2023-01-18 23:38:39 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) |
| 2023-01-18 23:41:22 +0100 | phma_ | phma |
| 2023-01-18 23:41:38 +0100 | CiaoSen | (~Jura@p200300c9572d4e002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 255 seconds) |
| 2023-01-18 23:43:00 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) (Ping timeout: 255 seconds) |
| 2023-01-18 23:57:19 +0100 | mizlan | (~mizlan@2607:f010:2a7:1005:cca3:e028:1e9b:60c9) |
| 2023-01-18 23:59:58 +0100 | oldfashionedcow | GeneralKenobi |
