2023-10-24 00:00:19 +0200 | <Inst> | on Arch, at least, the compatibility issues with ghc packages are legendary |
2023-10-24 00:00:33 +0200 | <Inst> | if you say, want Agda, the better way to do it is not to download Agda via pacman, but cabal install agda |
2023-10-24 00:00:51 +0200 | <monochrom> | E.g., to build and install the hscolour exe, it's "cabal install hscolour". |
2023-10-24 00:00:57 +0200 | Pickchea | (~private@user/pickchea) (Quit: Leaving) |
2023-10-24 00:01:38 +0200 | <EvanR> | cabal install is finicky because arch exists, no |
2023-10-24 00:02:01 +0200 | <EvanR> | case in point, I'm not on arch and it works |
2023-10-24 00:03:38 +0200 | <Inst> | I mean in reference to monochrom |
2023-10-24 00:05:40 +0200 | <Unicorn_Princess> | what exactly will `cabal install` do for an exe, is it The Way, and how can I then un-do whatever it is that cabal install would do? |
2023-10-24 00:05:49 +0200 | <yushyin> | even installing some tools (written in haskell) with pacman is fine, if you *do not* use it for dev-stuff. do all your dev-related stuff with a different toolchain installed via ghcup and it works fine. /me used to use arch. |
2023-10-24 00:05:53 +0200 | <Unicorn_Princess> | make it globally available in bash? |
2023-10-24 00:06:34 +0200 | sord937 | (~sord937@gateway/tor-sasl/sord937) (Quit: sord937) |
2023-10-24 00:06:36 +0200 | <monochrom> | Yes for exe "cabal install" is The Way. |
2023-10-24 00:06:58 +0200 | <Inst> | can't uninstall, though, but iirc, you can override :) |
2023-10-24 00:07:44 +0200 | <monochrom> | If disk space is not a concern, only conerned about getting rid of something on PATH, then just delete the file from ~/.cabal/bin or ~/.local/bin I forgot which and it keeps changing. |
2023-10-24 00:08:04 +0200 | <monochrom> | You can dig into ~/.cabal/store to free up disk space. |
2023-10-24 00:08:36 +0200 | yoyofreeman | (~yoyofreem@176.97.76.178) |
2023-10-24 00:08:37 +0200 | yoyofreeman | (~yoyofreem@176.97.76.178) (Max SendQ exceeded) |
2023-10-24 00:09:18 +0200 | yoyofreeman | (~yoyofreem@176.97.76.178) |
2023-10-24 00:10:10 +0200 | <EvanR> | uninstall is a thing debian and red hat tried to sell, but it takes a lot of engineering to support that |
2023-10-24 00:10:11 +0200 | acidjnk_new | (~acidjnk@p200300d6e72b935208de20f4829382c8.dip0.t-ipconnect.de) (Ping timeout: 246 seconds) |
2023-10-24 00:10:20 +0200 | falafel | (~falafel@62.175.113.194.dyn.user.ono.com) |
2023-10-24 00:10:29 +0200 | <EvanR> | meanwhile slackware continued to just delete the exe if you really wanted to xD |
2023-10-24 00:10:34 +0200 | <EvanR> | manually |
2023-10-24 00:10:51 +0200 | <Unicorn_Princess> | what have i waded into :S |
2023-10-24 00:11:30 +0200 | <EvanR> | you know who should invest in the off boarding experience, like every subscription based website, not package managers |
2023-10-24 00:13:12 +0200 | gehmehgeh | (~user@user/gehmehgeh) (Quit: Leaving) |
2023-10-24 00:14:05 +0200 | target_i | (~target_i@217.175.14.39) (Quit: leaving) |
2023-10-24 00:14:12 +0200 | Sgeo | (~Sgeo@user/sgeo) |
2023-10-24 00:15:00 +0200 | notzmv | (~zmv@user/notzmv) (Ping timeout: 240 seconds) |
2023-10-24 00:19:31 +0200 | vglfr | (~vglfr@88.155.140.136) (Read error: Connection reset by peer) |
2023-10-24 00:21:52 +0200 | Lycurgus | (~georg@user/Lycurgus) |
2023-10-24 00:26:08 +0200 | [itchyjunk] | (~itchyjunk@user/itchyjunk/x-7353470) |
2023-10-24 00:32:41 +0200 | coot | (~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot) |
2023-10-24 00:34:12 +0200 | falafel | (~falafel@62.175.113.194.dyn.user.ono.com) (Ping timeout: 240 seconds) |
2023-10-24 00:35:13 +0200 | coot | (~coot@89-69-206-216.dynamic.chello.pl) |
2023-10-24 00:37:10 +0200 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) |
2023-10-24 00:39:18 +0200 | coot | (~coot@89-69-206-216.dynamic.chello.pl) (Client Quit) |
2023-10-24 00:40:29 +0200 | Lycurgus | (~georg@user/Lycurgus) (Quit: leaving) |
2023-10-24 00:51:28 +0200 | Unicorn_Princess | (~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection) |
2023-10-24 00:54:39 +0200 | Square | (~Square@user/square) (Ping timeout: 240 seconds) |
2023-10-24 01:01:12 +0200 | <yin> | is haskellbridge matrix? |
2023-10-24 01:01:33 +0200 | <yushyin> | yes |
2023-10-24 01:04:14 +0200 | random-jellyfish | (~tiber@2a02:2f04:11e:c600:d86:8764:b7a3:4444) |
2023-10-24 01:04:14 +0200 | random-jellyfish | (~tiber@2a02:2f04:11e:c600:d86:8764:b7a3:4444) (Changing host) |
2023-10-24 01:04:14 +0200 | random-jellyfish | (~tiber@user/random-jellyfish) |
2023-10-24 01:04:20 +0200 | <geekosaur> | it's the #haskell-irc room on matrix; the #haskell room does not want to be bridged |
2023-10-24 01:07:23 +0200 | chomwitt | (~chomwitt@2a02:587:7a1a:8700:1ac0:4dff:fedb:a3f1) (Quit: Leaving) |
2023-10-24 01:09:15 +0200 | <yin> | the marvels of technology |
2023-10-24 01:09:31 +0200 | falafel | (~falafel@62.175.113.194.dyn.user.ono.com) |
2023-10-24 01:09:46 +0200 | random-jellyfish | (~tiber@user/random-jellyfish) (Ping timeout: 252 seconds) |
2023-10-24 01:10:26 +0200 | arahael | (~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net) |
2023-10-24 01:14:47 +0200 | aljazmc_ | (~aljazmc@user/aljazmc) |
2023-10-24 01:15:15 +0200 | dcoutts_ | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) |
2023-10-24 01:16:54 +0200 | aljazmc | (~aljazmc@user/aljazmc) (Remote host closed the connection) |
2023-10-24 01:17:27 +0200 | dcoutts | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 240 seconds) |
2023-10-24 01:19:30 +0200 | JuanDaugherty | (~juan@user/JuanDaugherty) |
2023-10-24 01:24:25 +0200 | chomwitt | (~chomwitt@2a02:587:7a1a:8700:1ac0:4dff:fedb:a3f1) |
2023-10-24 01:26:42 +0200 | Lycurgus | (~georg@user/Lycurgus) |
2023-10-24 01:29:00 +0200 | chomwitt | (~chomwitt@2a02:587:7a1a:8700:1ac0:4dff:fedb:a3f1) (Ping timeout: 240 seconds) |
2023-10-24 01:32:04 +0200 | <monochrom> | EvanR: Oh hey I didn't think of that. I thought I was good at seeing economics and disincentives. :) |
2023-10-24 01:32:11 +0200 | falafel | (~falafel@62.175.113.194.dyn.user.ono.com) (Ping timeout: 255 seconds) |
2023-10-24 01:33:11 +0200 | emmanuelux | (~emmanuelu@user/emmanuelux) (Ping timeout: 255 seconds) |
2023-10-24 01:38:26 +0200 | emmanuelux | (~emmanuelu@user/emmanuelux) |
2023-10-24 01:39:48 +0200 | Tuplanolla | (~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Ping timeout: 240 seconds) |
2023-10-24 01:40:28 +0200 | JuanDaugherty | (~juan@user/JuanDaugherty) (Quit: JuanDaugherty) |
2023-10-24 01:47:49 +0200 | pretty_dumm_guy | (trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.5) |
2023-10-24 01:50:36 +0200 | emmanuelux | (~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer) |
2023-10-24 01:52:23 +0200 | Raito_Bezarius | (~Raito@wireguard/tunneler/raito-bezarius) (Ping timeout: 258 seconds) |
2023-10-24 01:52:26 +0200 | emmanuelux | (~emmanuelu@user/emmanuelux) |
2023-10-24 01:53:07 +0200 | Luj | (~Luj@2a01:e0a:5f9:9681:5880:c9ff:fe9f:3dfb) (Ping timeout: 264 seconds) |
2023-10-24 01:54:03 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f) |
2023-10-24 01:58:56 +0200 | Luj | (~Luj@2a01:e0a:5f9:9681:5880:c9ff:fe9f:3dfb) |
2023-10-24 01:59:17 +0200 | santiagopim | (~user@90.167.66.131) (Ping timeout: 255 seconds) |
2023-10-24 02:04:39 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f) (Ping timeout: 258 seconds) |
2023-10-24 02:05:43 +0200 | Raito_Bezarius | (~Raito@wireguard/tunneler/raito-bezarius) |
2023-10-24 02:07:56 +0200 | bliminse | (~bliminse@user/bliminse) (Ping timeout: 260 seconds) |
2023-10-24 02:13:18 +0200 | arahael | (~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net) (Ping timeout: 260 seconds) |
2023-10-24 02:14:56 +0200 | Raito_Bezarius | (~Raito@wireguard/tunneler/raito-bezarius) (Ping timeout: 255 seconds) |
2023-10-24 02:15:23 +0200 | Luj | (~Luj@2a01:e0a:5f9:9681:5880:c9ff:fe9f:3dfb) (Ping timeout: 258 seconds) |
2023-10-24 02:20:13 +0200 | Raito_Bezarius | (~Raito@wireguard/tunneler/raito-bezarius) |
2023-10-24 02:20:38 +0200 | Luj | (~Luj@2a01:e0a:5f9:9681:5880:c9ff:fe9f:3dfb) |
2023-10-24 02:24:14 +0200 | notzmv | (~zmv@user/notzmv) |
2023-10-24 02:24:42 +0200 | bliminse | (~bliminse@user/bliminse) |
2023-10-24 02:27:47 +0200 | dudek | (~dudek@185.150.236.168) (Read error: Connection reset by peer) |
2023-10-24 02:28:02 +0200 | ddellacosta | (~ddellacos@ool-44c738de.dyn.optonline.net) (Ping timeout: 258 seconds) |
2023-10-24 02:31:22 +0200 | bliminse | (~bliminse@user/bliminse) (Ping timeout: 255 seconds) |
2023-10-24 02:31:40 +0200 | <Inst> | here's a more amusing question EvanR |
2023-10-24 02:32:01 +0200 | <Inst> | do you consider [IO ()] pure or impure? :) |
2023-10-24 02:32:24 +0200 | <Inst> | in this case, it's actually [[IO ()]] |
2023-10-24 02:33:07 +0200 | bliminse | (~bliminse@user/bliminse) |
2023-10-24 02:33:51 +0200 | <geekosaur> | pure until `sequenceA`d |
2023-10-24 02:34:09 +0200 | <Inst> | https://inventwithpython.com/bigbookpython/project77.html |
2023-10-24 02:34:10 +0200 | <Inst> | trying this |
2023-10-24 02:34:21 +0200 | <Inst> | sequenceA_, in this case |
2023-10-24 02:34:38 +0200 | <Inst> | the hard part is figuring out how to draw the displays |
2023-10-24 02:34:58 +0200 | <Inst> | especially since, to spice up the plain-jane Py, I'm adding ansi-terminal for color |
2023-10-24 02:35:13 +0200 | <EvanR> | Inst, I've been disagreeing with all your uses of impure |
2023-10-24 02:35:21 +0200 | <EvanR> | you're considering IO impure |
2023-10-24 02:35:51 +0200 | <Inst> | technically Haskell IO is pure because it's only evaluated via main IO action combination or unsafePerformIO |
2023-10-24 02:36:04 +0200 | <Inst> | afaik only unsafePerformIO is strictly impure, no? |
2023-10-24 02:36:15 +0200 | <geekosaur> | more precisely, it's pure instructions to an impure mutating runtime |
2023-10-24 02:36:34 +0200 | <Inst> | but is [[IO ()]] in IO? :) |
2023-10-24 02:37:44 +0200 | <exarkun> | no |
2023-10-24 02:38:47 +0200 | <Inst> | the problem is that since I'm using ansi-terminal to imbue colors, I can't have the data directly... oh, I can build a recipe and store it in a list of lists |
2023-10-24 02:39:16 +0200 | <exarkun> | yes. and that's presumably what those IO ()s are. but you could have a more legible recipe. |
2023-10-24 02:40:30 +0200 | <monochrom> | I do not have a context-free notion of "pure" vs "impure". |
2023-10-24 02:41:04 +0200 | <monochrom> | In some contexts, it is helpful to say that Int is pure, IO Int is impure. |
2023-10-24 02:41:07 +0200 | <EvanR> | pure data, pure code, apparently it has grown legs |
2023-10-24 02:41:14 +0200 | <monochrom> | This doesn't work in other contexts. |
2023-10-24 02:41:20 +0200 | <EvanR> | from the idea of pure and impure function |
2023-10-24 02:41:27 +0200 | <Inst> | hmmm, this is actually arguing for interpreters |
2023-10-24 02:41:44 +0200 | <geekosaur> | next you'll be using free monads |
2023-10-24 02:41:46 +0200 | <monochrom> | False dichotomies are what people invent when they want to procrastinate getting things done. |
2023-10-24 02:42:02 +0200 | <Inst> | i discovered sequenceA and sequenceA_ last year |
2023-10-24 02:42:13 +0200 | <Inst> | I've always wanted to be able to do IO or IO equivalents through a list |
2023-10-24 02:42:40 +0200 | <monochrom> | What always works is you look at the real problem and you choose a theory that works best for that problem. |
2023-10-24 02:42:43 +0200 | <Inst> | with the implication that the list would be manipulatable and combinable as though it were lisp |
2023-10-24 02:43:05 +0200 | <geekosaur> | yep, you're well on the way |
2023-10-24 02:43:12 +0200 | <monochrom> | As opposed to going to twitter and having pointless arguments over what counts as referentially transparent. |
2023-10-24 02:43:24 +0200 | <monochrom> | (Hint: It comes down to what counts as equality.) |
2023-10-24 02:43:58 +0200 | <Inst> | it'd be awfully satirical if this weren't an FP / Dijkstran CS community |
2023-10-24 02:44:05 +0200 | <Inst> | "it depends on what the meaning of is, is" |
2023-10-24 02:44:22 +0200 | <geekosaur> | I'm glad I wasn't the only one who flashed to that 🙂 |
2023-10-24 02:45:16 +0200 | <Inst> | https://slate.com/news-and-politics/1998/09/bill-clinton-and-the-meaning-of-is.html <-- origin, hope it's old enough not to be political |
2023-10-24 02:46:57 +0200 | <geekosaur> | some of us are old enough to remember when that happened |
2023-10-24 02:47:36 +0200 | <Inst> | iirc Dijkstra tried to replace inference with equivalence, no? |
2023-10-24 02:48:20 +0200 | <monochrom> | s/iirc/iiuc/ and not really. |
2023-10-24 02:49:42 +0200 | <Inst> | What branch of mathematics is discussing the meaning of the term equality / equivalence? |
2023-10-24 02:49:53 +0200 | <Inst> | I recall seeing on CCC a joke based around that concept |
2023-10-24 02:50:08 +0200 | <Inst> | implication, not inference |
2023-10-24 02:50:12 +0200 | <Inst> | https://inference-review.com/article/the-man-who-carried-computer-science-on-his-shoulders |
2023-10-24 02:51:22 +0200 | pavonia | (~user@user/siracusa) |
2023-10-24 03:01:00 +0200 | Lord_of_Life_ | (~Lord@user/lord-of-life/x-2819915) |
2023-10-24 03:01:22 +0200 | Lycurgus | (~georg@user/Lycurgus) (Quit: leaving) |
2023-10-24 03:01:27 +0200 | Lord_of_Life | (~Lord@user/lord-of-life/x-2819915) (Ping timeout: 240 seconds) |
2023-10-24 03:02:25 +0200 | Lord_of_Life_ | Lord_of_Life |
2023-10-24 03:02:52 +0200 | <Inst> | https://www.quantamagazine.org/with-category-theory-mathematics-escapes-from-equality-20191010/ |
2023-10-24 03:04:51 +0200 | _xor | (~xor@72.49.199.93) (Read error: Connection reset by peer) |
2023-10-24 03:07:01 +0200 | _xor | (~xor@72.49.199.93) |
2023-10-24 03:07:31 +0200 | otto_s | (~user@p5b044a8c.dip0.t-ipconnect.de) (Ping timeout: 264 seconds) |
2023-10-24 03:08:44 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) |
2023-10-24 03:09:00 +0200 | otto_s | (~user@p4ff279af.dip0.t-ipconnect.de) |
2023-10-24 03:10:56 +0200 | CiaoSen | (~Jura@2a05:5800:2cd:b800:664b:f0ff:fe37:9ef) (Ping timeout: 260 seconds) |
2023-10-24 03:13:48 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 248 seconds) |
2023-10-24 03:22:47 +0200 | <yin> | monochrom: did someone go on twitter and started a discussion on what counts as referentially transparent? |
2023-10-24 03:23:02 +0200 | <yin> | and did i have something to do with it? |
2023-10-24 03:23:06 +0200 | <monochrom> | I don't know. Hypothetical. :) |
2023-10-24 03:23:15 +0200 | <yin> | aw |
2023-10-24 03:23:32 +0200 | <monochrom> | No, you didn't have anything to do with it. |
2023-10-24 03:24:06 +0200 | <monochrom> | I saw that kind of discussion though a long time ago on haskell-cafe and maybe newsgroups. |
2023-10-24 03:24:23 +0200 | <yin> | i was thinking on my `zero = num_ 0` example earlier |
2023-10-24 03:24:42 +0200 | <monochrom> | Very disappointed because the gist was everyone clearly had a different definition of equality but no one realized it. |
2023-10-24 03:25:06 +0200 | <yin> | equality is not as simple as it seems |
2023-10-24 03:25:11 +0200 | <monochrom> | Right. |
2023-10-24 03:25:36 +0200 | <monochrom> | After you know, you also know it is not worth arguing. Just use the right defn for the right problem. |
2023-10-24 03:26:19 +0200 | <monochrom> | But this is why we have fun politics with left vs right, right? |
2023-10-24 03:26:35 +0200 | <yin> | that would solve almost all arguments i have with people in real life |
2023-10-24 03:26:37 +0200 | <monochrom> | Both sides wonder "why does the other side hate freedom?" |
2023-10-24 03:26:49 +0200 | <monochrom> | @quote monochrom polymorphic |
2023-10-24 03:26:49 +0200 | <lambdabot> | monochrom says: All pointless debates can be settled by going polymorphic. |
2023-10-24 03:27:36 +0200 | <Inst> | What does polymorphic mean in that context? And what's the pun on pointless? |
2023-10-24 03:29:09 +0200 | <yin> | monochrom: there's a joke waiting to be made about pointless debates and no arguments there |
2023-10-24 03:29:22 +0200 | <monochrom> | hahahaha |
2023-10-24 03:30:07 +0200 | <monochrom> | No argument can win a pointless debate? :) |
2023-10-24 03:30:48 +0200 | <jackdk> | The debates about point-free code certainly go on forever |
2023-10-24 03:31:39 +0200 | <yin> | the system is fixed |
2023-10-24 03:32:52 +0200 | <geekosaur> | > fix system |
2023-10-24 03:32:53 +0200 | <lambdabot> | error: Variable not in scope: system :: a -> a |
2023-10-24 03:34:02 +0200 | <Inst> | what would the semantics be if Haskell had first-class modules? |
2023-10-24 03:34:13 +0200 | <Inst> | > fix System.IO |
2023-10-24 03:34:15 +0200 | <lambdabot> | error: |
2023-10-24 03:34:15 +0200 | <lambdabot> | Not in scope: data constructor ‘System.IO’ |
2023-10-24 03:34:15 +0200 | <lambdabot> | No module named ‘System’ is imported. |
2023-10-24 03:34:59 +0200 | cece | (~Thunderbi@103.28.91.210) |
2023-10-24 03:35:31 +0200 | <geekosaur> | probably similar to those of SML/NJ? |
2023-10-24 03:35:50 +0200 | <Inst> | I mean if you were able to fix a first class module on itself? |
2023-10-24 03:36:10 +0200 | <geekosaur> | sounds like an infinite type to me |
2023-10-24 03:40:39 +0200 | <probie> | What's the distinction between a module and a record? |
2023-10-24 03:41:20 +0200 | <geekosaur> | types can't be values in Haskell (at least, not yet) |
2023-10-24 03:41:22 +0200 | <probie> | I guess in Haskell quite a lot, since one can't make new types anywhere but at the top level |
2023-10-24 03:41:33 +0200 | <geekosaur> | > fix system |
2023-10-24 03:41:35 +0200 | <lambdabot> | "*Exception: *Exception: *Exception: *Exception: *Exception: *Exception: *Ex... |
2023-10-24 03:44:54 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f) |
2023-10-24 03:48:26 +0200 | <yin> | you rascal |
2023-10-24 03:56:38 +0200 | <EvanR> | it's been a while since I've seen anyone bring up referential transparent, used right or used wrong |
2023-10-24 03:57:37 +0200 | <EvanR> | probie, in idris, nothing |
2023-10-24 03:58:00 +0200 | <EvanR> | er, wait, no they are distinct in idris |
2023-10-24 04:00:12 +0200 | <Inst> | > fix error |
2023-10-24 04:00:13 +0200 | <lambdabot> | "*Exception: *Exception: *Exception: *Exception: *Exception: *Exception: *Ex... |
2023-10-24 04:03:42 +0200 | <geekosaur> | ideally I'd have defined my own instead of reusing `error` 😛 |
2023-10-24 04:05:26 +0200 | <geekosaur> | > fix (\e -> "Error: " ++ e) |
2023-10-24 04:05:28 +0200 | <lambdabot> | "Error: Error: Error: Error: Error: Error: Error: Error: Error: Error: Error... |
2023-10-24 04:08:05 +0200 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija))) |
2023-10-24 04:08:05 +0200 | finn_elija | (~finn_elij@user/finn-elija/x-0085643) |
2023-10-24 04:08:05 +0200 | finn_elija | FinnElija |
2023-10-24 04:11:08 +0200 | xff0x | (~xff0x@ai101218.d.east.v6connect.net) (Ping timeout: 255 seconds) |
2023-10-24 04:12:22 +0200 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 252 seconds) |
2023-10-24 04:20:05 +0200 | ddellacosta | (~ddellacos@ool-44c738de.dyn.optonline.net) |
2023-10-24 04:23:29 +0200 | Katarushisu16 | (~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) |
2023-10-24 04:24:38 +0200 | Inst | (~Inst@120.244.192.250) (Ping timeout: 255 seconds) |
2023-10-24 04:25:03 +0200 | Katarushisu1 | (~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) (Ping timeout: 240 seconds) |
2023-10-24 04:25:03 +0200 | Katarushisu16 | Katarushisu1 |
2023-10-24 04:26:58 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f) (Remote host closed the connection) |
2023-10-24 04:27:14 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f) |
2023-10-24 04:29:45 +0200 | megaTherion_ | (~therion@unix.io) |
2023-10-24 04:29:48 +0200 | megaTherion | (~therion@unix.io) (Ping timeout: 240 seconds) |
2023-10-24 04:29:52 +0200 | megaTherion_ | megaTherion |
2023-10-24 04:36:04 +0200 | ec | (~ec@gateway/tor-sasl/ec) (Ping timeout: 256 seconds) |
2023-10-24 04:37:53 +0200 | ec | (~ec@gateway/tor-sasl/ec) |
2023-10-24 04:43:39 +0200 | <jackdk> | > fix ('A':) |
2023-10-24 04:43:41 +0200 | <lambdabot> | "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA... |
2023-10-24 04:44:35 +0200 | waleee | (~waleee@2001:9b0:21c:e600:f2f3:f744:435d:137c) (Ping timeout: 240 seconds) |
2023-10-24 04:46:42 +0200 | Pseudonym | (~IceChat95@203.214.86.172) |
2023-10-24 04:49:06 +0200 | td_ | (~td@i5387090D.versanet.de) (Ping timeout: 258 seconds) |
2023-10-24 04:50:54 +0200 | [itchyjunk] | (~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection) |
2023-10-24 04:51:02 +0200 | td_ | (~td@i53870916.versanet.de) |
2023-10-24 04:56:47 +0200 | xff0x | (~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) |
2023-10-24 05:11:36 +0200 | isekaijin | (~user@user/isekaijin) (Quit: brb) |
2023-10-24 05:12:14 +0200 | isekaijin | (~user@user/isekaijin) |
2023-10-24 05:12:28 +0200 | aforemny | (~aforemny@2001:9e8:6cc2:e900:a0d4:78f3:5fb4:bb3c) |
2023-10-24 05:13:38 +0200 | aforemny_ | (~aforemny@2001:9e8:6cdc:d800:4073:3320:51a8:3861) (Ping timeout: 258 seconds) |
2023-10-24 05:14:07 +0200 | qqq | (~qqq@92.43.167.61) (Remote host closed the connection) |
2023-10-24 05:24:55 +0200 | cece | (~Thunderbi@103.28.91.210) (Remote host closed the connection) |
2023-10-24 05:25:10 +0200 | cece | (~Thunderbi@103.28.91.210) |
2023-10-24 05:33:01 +0200 | dnb^ | (~cd@76.145.193.217) |
2023-10-24 05:50:18 +0200 | szkl | (uid110435@id-110435.uxbridge.irccloud.com) (Quit: Connection closed for inactivity) |
2023-10-24 05:50:38 +0200 | <albet70> | mtl or transformers which should I use? |
2023-10-24 05:52:43 +0200 | rosco | (~rosco@yp-150-69.tm.net.my) |
2023-10-24 05:53:30 +0200 | <jackdk> | mtl is a set of convenience typeclasses built atop transformers. |
2023-10-24 05:54:00 +0200 | <albet70> | why 2 :: IO Int not work? |
2023-10-24 05:54:31 +0200 | <jackdk> | There is no instance `Num (IO Int)` |
2023-10-24 05:55:54 +0200 | <albet70> | how to construct IO type since there's no IO constructor |
2023-10-24 05:56:01 +0200 | <c_wraith> | huh. I just realized that's sort of related to why GHC 9 introduced the Code type for typed template haskell. |
2023-10-24 05:57:33 +0200 | <albet70> | oh, return |
2023-10-24 06:00:39 +0200 | <jackdk> | `pure` is the modern name for `return`, though I'm not sure if the monad-of-no-return proposal will ever happen. |
2023-10-24 06:05:28 +0200 | _ht | (~Thunderbi@28-52-174-82.ftth.glasoperator.nl) |
2023-10-24 06:11:43 +0200 | <probie> | I'm sure the monad-of-no-return proposal will happen shortly after we end with a `Pointed` typeclass so we can continue having two names for the same thing |
2023-10-24 06:12:25 +0200 | <probie> | s/end with ... typeclass/end up with/ |
2023-10-24 06:23:23 +0200 | <jackdk> | and then we can tidy up arrows/profunctors |
2023-10-24 06:28:27 +0200 | <EvanR> | :t pure 2 |
2023-10-24 06:28:28 +0200 | <lambdabot> | (Applicative f, Num a) => f a |
2023-10-24 06:28:49 +0200 | <EvanR> | f a I say. f a! |
2023-10-24 06:29:19 +0200 | <EvanR> | (may specialize to IO Int) |
2023-10-24 06:31:13 +0200 | <EvanR> | monad of no return won't delete return from existence right |
2023-10-24 06:31:24 +0200 | <EvanR> | doesn't help with that |
2023-10-24 06:32:23 +0200 | <monochrom> | I think it just moves return out of the class, make it a top-level function "return = pure". I haven't really checked. |
2023-10-24 06:32:25 +0200 | <EvanR> | we won't be able to shake our cane at novice haskellers who know only pure and yell back in my day it was called return! And it was mildly acceptable! |
2023-10-24 06:32:48 +0200 | <monochrom> | Heh but I don't miss the name "return". |
2023-10-24 06:33:22 +0200 | <monochrom> | Meanwhile, meaningful names that are misleading are human nature, there won't be any shortage of new ones in the future. |
2023-10-24 06:33:57 +0200 | <monochrom> | Consider "test pollution". |
2023-10-24 06:34:25 +0200 | <monochrom> | Even "RAII". |
2023-10-24 06:36:45 +0200 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) |
2023-10-24 06:38:47 +0200 | billchenchina | (~billchenc@103.152.35.21) |
2023-10-24 06:39:38 +0200 | juri__ | (~juri@79.140.115.166) |
2023-10-24 06:40:04 +0200 | rosco | (~rosco@yp-150-69.tm.net.my) (Quit: Lost terminal) |
2023-10-24 06:40:21 +0200 | juri_ | (~juri@84-19-175-187.pool.ovpn.com) (Ping timeout: 260 seconds) |
2023-10-24 06:44:09 +0200 | lambdap2371 | (~lambdap@static.167.190.119.168.clients.your-server.de) (Quit: lambdap2371) |
2023-10-24 06:44:55 +0200 | lambdap2371 | (~lambdap@static.167.190.119.168.clients.your-server.de) |
2023-10-24 06:58:22 +0200 | takuan | (~takuan@178-116-218-225.access.telenet.be) |
2023-10-24 06:58:51 +0200 | takuan | (~takuan@178-116-218-225.access.telenet.be) (Read error: Connection reset by peer) |
2023-10-24 06:59:34 +0200 | takuan | (~takuan@178-116-218-225.access.telenet.be) |
2023-10-24 07:01:45 +0200 | cece | (~Thunderbi@103.28.91.210) (Remote host closed the connection) |
2023-10-24 07:10:16 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) |
2023-10-24 07:14:44 +0200 | td_ | (~td@i53870916.versanet.de) (Ping timeout: 255 seconds) |
2023-10-24 07:15:00 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 240 seconds) |
2023-10-24 07:15:30 +0200 | <albet70> | eitherResult :: Either String () <- xxx why Type signatures are only allowed in patterns with ScopedTypeVariables |
2023-10-24 07:16:32 +0200 | td_ | (~td@i53870938.versanet.de) |
2023-10-24 07:17:31 +0200 | <albet70> | how to declare a type in left of <- in do notation? |
2023-10-24 07:18:04 +0200 | <albet70> | 2 :: Int <- return 2 :: IO Int |
2023-10-24 07:21:58 +0200 | <mauke> | (2 :: Int) <- ..., but needs a language extension |
2023-10-24 07:25:16 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Ping timeout: 260 seconds) |
2023-10-24 07:27:05 +0200 | michalz | (~michalz@185.246.207.221) |
2023-10-24 07:29:19 +0200 | chomwitt | (~chomwitt@2a02:587:7a1a:8700:1ac0:4dff:fedb:a3f1) |
2023-10-24 07:32:09 +0200 | albet70 | (~xxx@2400:8902::f03c:92ff:fe60:98d8) |
2023-10-24 07:37:21 +0200 | _ht | (~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Remote host closed the connection) |
2023-10-24 07:39:46 +0200 | cece | (~Thunderbi@e2e-32-47.ssdcloudindia.net) |
2023-10-24 07:43:45 +0200 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection) |
2023-10-24 07:44:15 +0200 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) |
2023-10-24 07:44:43 +0200 | azimut | (~azimut@gateway/tor-sasl/azimut) |
2023-10-24 07:45:28 +0200 | CrunchyFlakes | (~CrunchyFl@ip92348280.dynamic.kabel-deutschland.de) |
2023-10-24 07:49:40 +0200 | raym | (~ray@user/raym) |
2023-10-24 07:55:47 +0200 | rgw | (~R@2605:a601:a0df:5600:f816:aa41:2408:8443) (Read error: Connection reset by peer) |
2023-10-24 07:56:29 +0200 | billchenchina | (~billchenc@103.152.35.21) (Remote host closed the connection) |
2023-10-24 08:00:31 +0200 | Pseudonym | (~IceChat95@203.214.86.172) (Quit: When the chips are down, the buffalo is empty) |
2023-10-24 08:08:42 +0200 | yaroot | (~yaroot@p3477236-ipngn9802souka.saitama.ocn.ne.jp) (Remote host closed the connection) |
2023-10-24 08:09:19 +0200 | yaroot | (~yaroot@p3477236-ipngn9802souka.saitama.ocn.ne.jp) |
2023-10-24 08:30:17 +0200 | idgaen | (~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) |
2023-10-24 08:31:21 +0200 | lisbeths | (uid135845@id-135845.lymington.irccloud.com) |
2023-10-24 08:34:06 +0200 | fendor | (~fendor@2a02:8388:1640:be00:aab:1226:f274:5021) |
2023-10-24 08:35:36 +0200 | chele | (~chele@user/chele) |
2023-10-24 08:35:52 +0200 | pretty_dumm_guy | (trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) |
2023-10-24 08:37:15 +0200 | elkcl_ | (~elkcl@broadband-95-84-226-240.ip.moscow.rt.ru) |
2023-10-24 08:38:47 +0200 | elkcl | (~elkcl@broadband-95-84-226-240.ip.moscow.rt.ru) (Ping timeout: 255 seconds) |
2023-10-24 08:38:48 +0200 | elkcl_ | elkcl |
2023-10-24 08:40:01 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
2023-10-24 08:40:13 +0200 | danza | (~francesco@151.37.205.77) |
2023-10-24 08:41:54 +0200 | acidjnk_new | (~acidjnk@p200300d6e72b9364ac51bf6edb979c24.dip0.t-ipconnect.de) |
2023-10-24 08:42:07 +0200 | coot | (~coot@89-69-206-216.dynamic.chello.pl) |
2023-10-24 08:52:41 +0200 | Jackneill | (~Jackneill@20014C4E1E0E6F00C66CC838C6CE2C28.dsl.pool.telekom.hu) |
2023-10-24 08:57:15 +0200 | random-jellyfish | (~tiber@2a02:2f04:11e:c600:d86:8764:b7a3:4444) |
2023-10-24 08:57:15 +0200 | random-jellyfish | (~tiber@2a02:2f04:11e:c600:d86:8764:b7a3:4444) (Changing host) |
2023-10-24 08:57:15 +0200 | random-jellyfish | (~tiber@user/random-jellyfish) |
2023-10-24 08:59:06 +0200 | <dminuoso> | albet70: The motivating part is being able to write `(a :: t) <- ...; ` and being able to use `t` in subsequent do statements. |
2023-10-24 08:59:42 +0200 | <dminuoso> | So that's what this extension is for. The fact that you can use `(2 :: Int) <- ...` is an added benefit. |
2023-10-24 09:00:18 +0200 | <dminuoso> | In hindsight this is all terribly inconvenient. I feel like the behavior of ScopedTypeVariables should have been the default. |
2023-10-24 09:04:57 +0200 | vglfr | (~vglfr@88.155.140.136) |
2023-10-24 09:06:10 +0200 | lortabac | (~lortabac@2a01:e0a:541:b8f0:877:6f13:9fe8:2e06) |
2023-10-24 09:07:55 +0200 | vglfr | (~vglfr@88.155.140.136) (Read error: Connection reset by peer) |
2023-10-24 09:08:16 +0200 | vglfr | (vglfr@gateway/vpn/protonvpn/vglfr) |
2023-10-24 09:15:05 +0200 | <lisbeths> | pls tell the owner of lambdabot that #lambdacalculus is an officially registered server |
2023-10-24 09:15:36 +0200 | <lisbeths> | we would like to ask access to a bot designed to evaluate lambda expressions |
2023-10-24 09:20:12 +0200 | danza | (~francesco@151.37.205.77) (Ping timeout: 240 seconds) |
2023-10-24 09:22:33 +0200 | CiaoSen | (~Jura@2a05:5800:2a5:2200:664b:f0ff:fe37:9ef) |
2023-10-24 09:33:24 +0200 | vglfr | (vglfr@gateway/vpn/protonvpn/vglfr) (Ping timeout: 245 seconds) |
2023-10-24 09:33:49 +0200 | vglfr | (~vglfr@88.155.140.136) |
2023-10-24 09:34:30 +0200 | Square3 | (~Square4@user/square) |
2023-10-24 09:37:51 +0200 | danse-nr3_ | (~francesco@151.37.210.148) |
2023-10-24 09:39:03 +0200 | sord937 | (~sord937@gateway/tor-sasl/sord937) |
2023-10-24 09:42:05 +0200 | rosco | (~rosco@yp-150-69.tm.net.my) |
2023-10-24 09:45:36 +0200 | gmg | (~user@user/gehmehgeh) |
2023-10-24 09:51:41 +0200 | mrmr155 | (~mrmr@user/mrmr) (Ping timeout: 255 seconds) |
2023-10-24 09:52:09 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f) (Remote host closed the connection) |
2023-10-24 09:52:44 +0200 | eggplantade | (~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) |
2023-10-24 09:53:18 +0200 | <int-e> | ? ChanServ knows nothing about it. |
2023-10-24 09:53:29 +0200 | vglfr | (~vglfr@88.155.140.136) (Read error: Connection reset by peer) |
2023-10-24 09:53:50 +0200 | vglfr | (vglfr@gateway/vpn/protonvpn/vglfr) |
2023-10-24 09:54:02 +0200 | <dminuoso> | I have a feeling this is about matrix |
2023-10-24 09:57:18 +0200 | eggplantade | (~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 258 seconds) |
2023-10-24 09:57:40 +0200 | <tomsmeding> | dminuoso: they're asking from irc though |
2023-10-24 09:57:41 +0200 | helge_ | (~textual@h-158-174-186-9.NA.cust.bahnhof.se) |
2023-10-24 09:59:17 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-10-24 10:00:56 +0200 | <dminuoso> | tomsmeding: Who knows. Maybe they (somewhat correctly) assume that the lambdabot responsible person can be found here? |
2023-10-24 10:01:49 +0200 | <tomsmeding> | being explicit is good, then, I guess :p |
2023-10-24 10:02:05 +0200 | <int-e> | dminuoso: that would be me |
2023-10-24 10:03:45 +0200 | <int-e> | Well. Maybe not... is there a dedicated lambdabot on Matrix? That wouldn't be mine. |
2023-10-24 10:08:51 +0200 | <probie> | If it's on matrix, can't they bridge it with no involvement from anyone? Or do none of the bridges handle talking directly to users? |
2023-10-24 10:12:56 +0200 | <haskellbridge> | <sm> why are y'all thinking matrix is involved |
2023-10-24 10:14:59 +0200 | mrmr155 | (~mrmr@user/mrmr) |
2023-10-24 10:15:02 +0200 | <int-e> | [needsinfo] |
2023-10-24 10:15:03 +0200 | int-e | shrugs |
2023-10-24 10:16:28 +0200 | vglfr | (vglfr@gateway/vpn/protonvpn/vglfr) (Ping timeout: 258 seconds) |
2023-10-24 10:16:56 +0200 | vglfr | (~vglfr@88.155.140.136) |
2023-10-24 10:19:16 +0200 | <int-e> | Sorry, ChanServ does know about it. I can't type ("#lamdbacalculus" isn't known) |
2023-10-24 10:20:33 +0200 | <int-e> | (That doesn't even look wrong to me, somehow. :-/ ) |
2023-10-24 10:20:50 +0200 | <tomsmeding> | int-e: try pronouncing it :p |
2023-10-24 10:21:22 +0200 | <tomsmeding> | assuming your mother tongue is English, that'll be a challenge |
2023-10-24 10:21:23 +0200 | <int-e> | tomsmeding: lam-da-cal-cu-lus |
2023-10-24 10:22:02 +0200 | <tomsmeding> | ah, the reasoning being "b is silent in lambda so it's also silent in lamdba" |
2023-10-24 10:22:06 +0200 | <int-e> | It's german and the b is silent there too. |
2023-10-24 10:22:42 +0200 | <int-e> | tomsmeding: I mean, you have a point. It does look wrong when I try to parse syllables. |
2023-10-24 10:22:46 +0200 | <tomsmeding> | :p |
2023-10-24 10:23:02 +0200 | Sgeo | (~Sgeo@user/sgeo) (Read error: Connection reset by peer) |
2023-10-24 10:25:23 +0200 | <int-e> | lisbeths: Done now. Sorry for the confusion above. |
2023-10-24 10:26:28 +0200 | stiell_ | (~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection) |
2023-10-24 10:27:00 +0200 | stiell_ | (~stiell@gateway/tor-sasl/stiell) |
2023-10-24 10:32:57 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f) |
2023-10-24 10:38:30 +0200 | stiell_ | (~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection) |
2023-10-24 10:39:03 +0200 | stiell_ | (~stiell@gateway/tor-sasl/stiell) |
2023-10-24 10:39:57 +0200 | gmg | (~user@user/gehmehgeh) (Quit: Leaving) |
2023-10-24 10:54:04 +0200 | econo_ | (uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity) |
2023-10-24 10:55:01 +0200 | tzh | (~tzh@c-71-193-181-0.hsd1.or.comcast.net) (Quit: zzz) |
2023-10-24 11:04:45 +0200 | rosco | (~rosco@yp-150-69.tm.net.my) (Quit: Lost terminal) |
2023-10-24 11:04:57 +0200 | rosco | (~rosco@yp-150-69.tm.net.my) |
2023-10-24 11:05:42 +0200 | yoyofreeman | (~yoyofreem@176.97.76.178) (Read error: Connection reset by peer) |
2023-10-24 11:06:55 +0200 | yoyofreeman | (~yoyofreem@176.97.76.178) |
2023-10-24 11:11:47 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) |
2023-10-24 11:16:06 +0200 | fweht | (uid404746@id-404746.lymington.irccloud.com) |
2023-10-24 11:16:31 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds) |
2023-10-24 11:22:45 +0200 | kuribas | (~user@ip-188-118-57-242.reverse.destiny.be) |
2023-10-24 11:25:12 +0200 | azimut | (~azimut@gateway/tor-sasl/azimut) (Ping timeout: 256 seconds) |
2023-10-24 11:25:52 +0200 | ubert1 | (~Thunderbi@91.141.40.172.wireless.dyn.drei.com) |
2023-10-24 11:26:44 +0200 | ubert | (~Thunderbi@91.141.50.28.wireless.dyn.drei.com) (Ping timeout: 246 seconds) |
2023-10-24 11:26:45 +0200 | ubert1 | ubert |
2023-10-24 11:27:52 +0200 | billchenchina | (~billchenc@113.57.152.160) |
2023-10-24 11:28:33 +0200 | rosco | (~rosco@yp-150-69.tm.net.my) (Quit: Lost terminal) |
2023-10-24 11:28:46 +0200 | rosco | (~rosco@yp-150-69.tm.net.my) |
2023-10-24 11:30:39 +0200 | billchenchina- | (~billchenc@2a0c:b641:7a2:230::10) |
2023-10-24 11:33:11 +0200 | billchenchina | (~billchenc@113.57.152.160) (Ping timeout: 260 seconds) |
2023-10-24 11:40:43 +0200 | arahael | (~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net) |
2023-10-24 11:47:18 +0200 | Unicorn_Princess | (~Unicorn_P@user/Unicorn-Princess/x-3540542) |
2023-10-24 11:48:11 +0200 | <Unicorn_Princess> | oh, regarding the quality if haskell tooling, don't worry about it too much guys. i come from the land of c++ and the horrors of cmake, and compared to that cabal is nirvana |
2023-10-24 11:48:19 +0200 | sord937 | (~sord937@gateway/tor-sasl/sord937) (Remote host closed the connection) |
2023-10-24 11:48:38 +0200 | sord937 | (~sord937@gateway/tor-sasl/sord937) |
2023-10-24 11:48:47 +0200 | <kuribas> | \o/ |
2023-10-24 11:49:16 +0200 | <kuribas> | I've been saying this before, haskell tooling sucks, but not more than other tooling. |
2023-10-24 11:49:27 +0200 | <Hecate> | \o/ |
2023-10-24 11:49:38 +0200 | <kuribas> | And I might say the same about type system complexity. Man typescript has a complex type system. |
2023-10-24 11:50:01 +0200 | pyooque | (~puke@user/puke) |
2023-10-24 11:50:01 +0200 | puke | (~puke@user/puke) (Killed (lithium.libera.chat (Nickname regained by services))) |
2023-10-24 11:50:01 +0200 | pyooque | puke |
2023-10-24 11:50:06 +0200 | santiagopim | (~user@90.167.66.131) |
2023-10-24 11:51:52 +0200 | <Unicorn_Princess> | and again c++ makes everything look good compared to templates |
2023-10-24 11:51:58 +0200 | <Unicorn_Princess> | everything else* |
2023-10-24 11:52:03 +0200 | <kuribas> | I hear many people (even haskellers) claim that dependent types are complicated, but in the end they only add two constructs to the type system (existential and universal quantification). |
2023-10-24 11:52:07 +0200 | <Unicorn_Princess> | except C's void* >_> |
2023-10-24 11:52:27 +0200 | <kuribas> | void* is just 'Any' |
2023-10-24 11:52:36 +0200 | <kuribas> | well, unsafe Any |
2023-10-24 11:52:43 +0200 | <Unicorn_Princess> | i.e. the worst possible type. for everything |
2023-10-24 11:53:05 +0200 | <Unicorn_Princess> | it is "simple" tho, there's that |
2023-10-24 11:53:23 +0200 | <kuribas> | Any isn't a type really. |
2023-10-24 11:53:30 +0200 | <kuribas> | It's just "turn off the type checker". |
2023-10-24 11:54:06 +0200 | Inst | (~Inst@120.244.192.250) |
2023-10-24 11:54:25 +0200 | <kuribas> | Or you could think of it as a dependent pair, together with an implicit check and a partial function. |
2023-10-24 11:55:24 +0200 | fendor | (~fendor@2a02:8388:1640:be00:aab:1226:f274:5021) (Ping timeout: 240 seconds) |
2023-10-24 11:55:32 +0200 | <Unicorn_Princess> | i think of it as a CVE in its larval stage |
2023-10-24 11:56:39 +0200 | <kuribas> | However, in Python Any is not checked at the place where you convert it, it just propagates through until it crashes some primitive function. |
2023-10-24 11:57:22 +0200 | <kuribas> | In a properly designed language with "Any", I would expect it to do a check at the place where it is casted. |
2023-10-24 11:58:13 +0200 | emmanuelux | (~emmanuelu@user/emmanuelux) (Quit: au revoir) |
2023-10-24 12:02:38 +0200 | <tomsmeding> | kuribas: I don't think saying "dependent types aren't complicated, they only add two constructs to the type system" is quite honest :p |
2023-10-24 12:02:43 +0200 | yoyofreeman | (~yoyofreem@176.97.76.178) (Read error: Connection reset by peer) |
2023-10-24 12:03:23 +0200 | yoyofreeman | (~yoyofreem@176.97.76.178) |
2023-10-24 12:03:49 +0200 | ft | (~ft@p4fc2a529.dip0.t-ipconnect.de) (Quit: leaving) |
2023-10-24 12:05:13 +0200 | yoyofreeman | (~yoyofreem@176.97.76.178) (Remote host closed the connection) |
2023-10-24 12:08:38 +0200 | xff0x | (~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 272 seconds) |
2023-10-24 12:09:48 +0200 | sm | (~sm@plaintextaccounting/sm) (Quit: sm) |
2023-10-24 12:18:59 +0200 | lortabac | (~lortabac@2a01:e0a:541:b8f0:877:6f13:9fe8:2e06) (Quit: WeeChat 2.8) |
2023-10-24 12:19:49 +0200 | __monty__ | (~toonn@user/toonn) |
2023-10-24 12:29:53 +0200 | santiagopim | (~user@90.167.66.131) (Remote host closed the connection) |
2023-10-24 12:30:50 +0200 | santiagopim | (~user@90.167.66.131) |
2023-10-24 12:31:59 +0200 | jjhoo | (~jahakala@user/jjhoo) (Ping timeout: 255 seconds) |
2023-10-24 12:36:46 +0200 | CiaoSen | (~Jura@2a05:5800:2a5:2200:664b:f0ff:fe37:9ef) (Ping timeout: 258 seconds) |
2023-10-24 12:38:50 +0200 | billchenchina- | (~billchenc@2a0c:b641:7a2:230::10) (Remote host closed the connection) |
2023-10-24 12:47:54 +0200 | kuribas | (~user@ip-188-118-57-242.reverse.destiny.be) (Ping timeout: 272 seconds) |
2023-10-24 12:59:09 +0200 | yoyofreeman | (~yoyofreem@176.97.76.178) |
2023-10-24 13:07:19 +0200 | xff0x | (~xff0x@2405:6580:b080:900:ecc3:b543:f7a2:f485) |
2023-10-24 13:08:56 +0200 | jjhoo | (~jahakala@user/jjhoo) |
2023-10-24 13:25:46 +0200 | CiaoSen | (~Jura@2a05:5800:2a5:2200:664b:f0ff:fe37:9ef) |
2023-10-24 13:29:35 +0200 | CrunchyFlakes | (~CrunchyFl@ip92348280.dynamic.kabel-deutschland.de) (Quit: ZNC 1.8.2 - https://znc.in) |
2023-10-24 13:31:44 +0200 | CrunchyFlakes | (~CrunchyFl@ip92348280.dynamic.kabel-deutschland.de) |
2023-10-24 13:39:06 +0200 | danse-nr3__ | (~francesco@151.35.159.184) |
2023-10-24 13:39:13 +0200 | danse-nr3_ | (~francesco@151.37.210.148) (Read error: Connection reset by peer) |
2023-10-24 13:40:31 +0200 | hololeap | (~quassel@user/hololeap) (Quit: Bye) |
2023-10-24 13:40:58 +0200 | lisbeths | (uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity) |
2023-10-24 13:41:07 +0200 | xff0x | (~xff0x@2405:6580:b080:900:ecc3:b543:f7a2:f485) (Ping timeout: 264 seconds) |
2023-10-24 13:41:41 +0200 | hololeap | (~quassel@user/hololeap) |
2023-10-24 13:42:36 +0200 | xff0x | (~xff0x@ai101218.d.east.v6connect.net) |
2023-10-24 13:43:06 +0200 | helge_ | (~textual@h-158-174-186-9.NA.cust.bahnhof.se) (Quit: My MacBook has gone to sleep. ZZZzzz…) |
2023-10-24 13:43:24 +0200 | danse-nr3__ | (~francesco@151.35.159.184) (Ping timeout: 240 seconds) |
2023-10-24 13:43:34 +0200 | helge_ | (~textual@h-158-174-186-9.NA.cust.bahnhof.se) |
2023-10-24 13:44:18 +0200 | chomwitt | (~chomwitt@2a02:587:7a1a:8700:1ac0:4dff:fedb:a3f1) (Remote host closed the connection) |
2023-10-24 13:45:36 +0200 | helge_ | (~textual@h-158-174-186-9.NA.cust.bahnhof.se) (Client Quit) |
2023-10-24 13:46:00 +0200 | Lycurgus | (~georg@user/Lycurgus) |
2023-10-24 13:46:57 +0200 | lisbeths | (uid135845@id-135845.lymington.irccloud.com) |
2023-10-24 13:46:57 +0200 | helge_ | (~textual@h-158-174-186-9.NA.cust.bahnhof.se) |
2023-10-24 13:51:40 +0200 | enoq | (~enoq@2a05:1141:1e6:3b00:c958:a45e:c4e0:3650) |
2023-10-24 13:53:17 +0200 | <enoq> | regarding Monads & Co: it feels like having strongly typed I/O or error checking sort of infects almost everything in your code, similar to how async in JS or checked Exceptions in Java (escape hatch via unchecked exceptions) make you build APIs that throw errors/are async by default |
2023-10-24 13:54:20 +0200 | <enoq> | I know that there are trade offs with regards to unchecked exceptions vs Result types/checked exceptions, but how much of a benefit has each been in your experience? |
2023-10-24 13:55:03 +0200 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 260 seconds) |
2023-10-24 13:55:35 +0200 | hololeap | (~quassel@user/hololeap) (Quit: Bye) |
2023-10-24 13:56:05 +0200 | <enoq> | as in: how much of an impact does having Monads + the Monad Transformer pain been in comparison to languages that don't have I/O or Result types baked in |
2023-10-24 13:56:39 +0200 | hololeap | (~quassel@user/hololeap) |
2023-10-24 13:58:00 +0200 | czy | (~user@180.116.80.17) |
2023-10-24 13:58:06 +0200 | helge_ | (~textual@h-158-174-186-9.NA.cust.bahnhof.se) (Quit: My MacBook has gone to sleep. ZZZzzz…) |
2023-10-24 13:58:35 +0200 | kuribas | (~user@ip-188-118-57-242.reverse.destiny.be) |
2023-10-24 14:02:38 +0200 | Lycurgus | (~georg@user/Lycurgus) (Quit: leaving) |
2023-10-24 14:02:40 +0200 | czy | (~user@180.116.80.17) (Quit: ERC 5.6-git (IRC client for GNU Emacs 30.0.50)) |
2023-10-24 14:06:52 +0200 | fendor | (~fendor@2a02:8388:1640:be00:aab:1226:f274:5021) |
2023-10-24 14:09:39 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-10-24 14:11:17 +0200 | <jackdk> | Working with Either(Result) is significantly easier than it initially appears, because Functor and Applicative provide such a good toolkit for lifting pure functions across Eithers (as well as many many other data types) |
2023-10-24 14:12:16 +0200 | <jackdk> | I definitely had the "oh dear this is gonna infect everything" reaction when I started playing with IO or Either or whatever but it's a much better story than it first appears (when the only tool I had was `do`-notation) |
2023-10-24 14:19:49 +0200 | califax | (~califax@user/califx) (Remote host closed the connection) |
2023-10-24 14:20:12 +0200 | califax | (~califax@user/califx) |
2023-10-24 14:20:35 +0200 | cece | (~Thunderbi@e2e-32-47.ssdcloudindia.net) (Ping timeout: 240 seconds) |
2023-10-24 14:21:20 +0200 | cece | (~Thunderbi@e2e-32-47.ssdcloudindia.net) |
2023-10-24 14:21:21 +0200 | <arahael> | jackdk: It certainly makes you wonder how other developers deal with null all the time. |
2023-10-24 14:22:31 +0200 | <Unicorn_Princess> | they just formally verify the absence of null with a proof assistance, surely |
2023-10-24 14:22:37 +0200 | <Unicorn_Princess> | assistant* |
2023-10-24 14:23:03 +0200 | <arahael> | Quite often they reject such tools. :( |
2023-10-24 14:23:24 +0200 | <fendor> | exception driven development |
2023-10-24 14:23:26 +0200 | <arahael> | Because dealing with all the warnings or errors is such a "nuisance". |
2023-10-24 14:23:31 +0200 | <arahael> | fendor: Literally. |
2023-10-24 14:23:41 +0200 | czy | (~user@180.116.80.17) |
2023-10-24 14:28:08 +0200 | aljazmc_ | (~aljazmc@user/aljazmc) (Remote host closed the connection) |
2023-10-24 14:29:29 +0200 | <kuribas> | tomsmeding: well, relatively speaking. I think learning dependent types from scratch is easier than learning haskell with all it ad-hoc extensions... |
2023-10-24 14:31:55 +0200 | <tomsmeding> | kuribas: perhaps, although the difference is that with haskell there are some intermediate steps, before having learned the entire thing, where you already know enough to do something useful |
2023-10-24 14:32:07 +0200 | <tomsmeding> | the conceptual leap from zero to dependent types is not to be underestimated |
2023-10-24 14:32:24 +0200 | <kuribas> | tomsmeding: true, but you could learn idris without the dependently typed part, no? |
2023-10-24 14:32:27 +0200 | aljazmc | (~aljazmc@user/aljazmc) |
2023-10-24 14:32:33 +0200 | <tomsmeding> | true, but would you be able to do anything useful |
2023-10-24 14:32:42 +0200 | <tomsmeding> | surely the standard library uses dependency all over the place |
2023-10-24 14:33:07 +0200 | <kuribas> | yeah, tail is total in idris. |
2023-10-24 14:33:13 +0200 | chomwitt | (~chomwitt@2a02:587:7a1a:8700:1ac0:4dff:fedb:a3f1) |
2023-10-24 14:33:15 +0200 | <tomsmeding> | at least in haskell you can write a lot of programs in what is essentially Haskell98 if you were so inclined |
2023-10-24 14:33:21 +0200 | <kuribas> | not sure if you could understand tail "intuitively"... |
2023-10-24 14:34:15 +0200 | <tomsmeding> | kuribas: is there any rendered stdlib docs for idris? |
2023-10-24 14:34:54 +0200 | <tomsmeding> | right I found 'tail' in the source tree, it takes an extrinsic non-emptiness proof |
2023-10-24 14:35:12 +0200 | <kuribas> | tomsmeding: https://idris2docs.sinyax.net/ |
2023-10-24 14:35:18 +0200 | <tomsmeding> | as a beginner to FP you don't want to deal with proofs just yet |
2023-10-24 14:35:58 +0200 | <tomsmeding> | searching for "tail" gives me the function I want like on the second page -- that search result ranking algorithm could have some work :p |
2023-10-24 14:36:04 +0200 | <tomsmeding> | but thanks, that's what I was looking for |
2023-10-24 14:37:18 +0200 | <kuribas> | well, in practice DT aren't that easy ... But neither is advance typescript, or Python... |
2023-10-24 14:37:33 +0200 | <tomsmeding> | neither is _advanced_ typescript, or python |
2023-10-24 14:37:40 +0200 | <kuribas> | yeah |
2023-10-24 14:37:43 +0200 | <tomsmeding> | my point is that there also is _basic_ TS / Py / Hs |
2023-10-24 14:37:47 +0200 | <tomsmeding> | there is no "basic DT" :p |
2023-10-24 14:37:53 +0200 | <tomsmeding> | that's why DT is considered difficult, I think |
2023-10-24 14:38:16 +0200 | <tomsmeding> | the number of typing rules you need to add to STLC is irrelevant to conceptual difficulty of working with the system |
2023-10-24 14:38:24 +0200 | <tomsmeding> | in practice |
2023-10-24 14:38:29 +0200 | <arahael> | I think just being different, is bad enough. |
2023-10-24 14:38:41 +0200 | <tomsmeding> | it is, but it's more than that |
2023-10-24 14:38:56 +0200 | danse-nr3 | (~francesco@151.35.159.184) |
2023-10-24 14:39:07 +0200 | <kuribas> | tomsmeding: I was considering creating a language with light dependent types. That is without partial evaluation, normalisation, and requiring proofs. |
2023-10-24 14:39:22 +0200 | idgaen | (~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.0.5) |
2023-10-24 14:39:49 +0200 | <kuribas> | tomsmeding: so you can apply functions to types at type level (in phantom types), but not prove correctness. |
2023-10-24 14:40:11 +0200 | cece | (~Thunderbi@e2e-32-47.ssdcloudindia.net) (Remote host closed the connection) |
2023-10-24 14:40:24 +0200 | cece | (~Thunderbi@e2e-32-47.ssdcloudindia.net) |
2023-10-24 14:40:54 +0200 | <tomsmeding> | so syntactically, functions are defined at simultaneously the value level and at the type level, but you don't have Pi (i.e. later types in a function signature cannot depend on earlier arguments)? |
2023-10-24 14:41:09 +0200 | AlexZenon | (~alzenon@178.34.162.116) (Quit: ;-) |
2023-10-24 14:41:37 +0200 | <tomsmeding> | I'm not sure you can call that "dependent types", more like a strong and possibly convenient type-level computation syntax |
2023-10-24 14:41:39 +0200 | <kuribas> | my idea was to allow passing type level values to value level, but not the other way. |
2023-10-24 14:41:46 +0200 | <tomsmeding> | ah |
2023-10-24 14:41:47 +0200 | <kuribas> | So you cannot depend on a value directly. |
2023-10-24 14:41:52 +0200 | <tomsmeding> | isn't that already System F |
2023-10-24 14:41:58 +0200 | <kuribas> | yeah, could be. |
2023-10-24 14:42:19 +0200 | <kuribas> | But I'd allow global values in the type level. |
2023-10-24 14:42:27 +0200 | AlexNoo | (~AlexNoo@178.34.162.116) (Quit: Leaving) |
2023-10-24 14:42:45 +0200 | <kuribas> | As long as they are known at typecheck time. |
2023-10-24 14:42:53 +0200 | <tomsmeding> | kuribas: https://en.wikipedia.org/wiki/Lambda_cube |
2023-10-24 14:43:35 +0200 | Inst | (~Inst@120.244.192.250) (Read error: Connection reset by peer) |
2023-10-24 14:52:46 +0200 | Inst | (~Inst@120.244.192.250) |
2023-10-24 14:54:08 +0200 | sm | (~sm@plaintextaccounting/sm) (Quit: sm) |
2023-10-24 14:54:45 +0200 | Inst_ | (~Inst@120.244.192.250) |
2023-10-24 14:56:50 +0200 | azimut | (~azimut@gateway/tor-sasl/azimut) |
2023-10-24 14:57:05 +0200 | Inst | (~Inst@120.244.192.250) (Ping timeout: 246 seconds) |
2023-10-24 14:57:59 +0200 | <enoq> | jackdk, thanks, great to hear! |
2023-10-24 15:02:23 +0200 | enoq | (~enoq@2a05:1141:1e6:3b00:c958:a45e:c4e0:3650) (Remote host closed the connection) |
2023-10-24 15:03:18 +0200 | arahael | (~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net) (Ping timeout: 260 seconds) |
2023-10-24 15:03:34 +0200 | <kuribas> | tomsmeding: I think the biggest problem with trying to use idris for practical programming is that is a very rough, not that it has dependent types. |
2023-10-24 15:04:21 +0200 | <kuribas> | tomsmeding: if tail gives you problems, you can use tail' : List a -> Maybe (List a) |
2023-10-24 15:04:33 +0200 | <tomsmeding> | ah right |
2023-10-24 15:04:58 +0200 | <Inst_> | kuribas: this is why, while I'm a noob and in the simple haskell camp much of the time, I still want ergonomic dependent types for its simplifying power |
2023-10-24 15:05:50 +0200 | <kuribas> | yeah, just try adding type level functionality to servant. |
2023-10-24 15:05:58 +0200 | <kuribas> | It's very complex. |
2023-10-24 15:07:05 +0200 | Inst_ | Inst |
2023-10-24 15:12:56 +0200 | kuribas | (~user@ip-188-118-57-242.reverse.destiny.be) (Quit: ERC (IRC client for Emacs 27.1)) |
2023-10-24 15:13:00 +0200 | AlexNoo | (~AlexNoo@178.34.162.116) |
2023-10-24 15:13:19 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) |
2023-10-24 15:18:02 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds) |
2023-10-24 15:19:19 +0200 | CO2 | (CO2@gateway/vpn/protonvpn/co2) |
2023-10-24 15:23:26 +0200 | vglfr | (~vglfr@88.155.140.136) (Ping timeout: 255 seconds) |
2023-10-24 15:27:38 +0200 | AlexZenon | (~alzenon@178.34.162.116) |
2023-10-24 15:36:54 +0200 | helge_ | (~textual@h-158-174-186-9.NA.cust.bahnhof.se) |
2023-10-24 15:37:01 +0200 | CiaoSen | (~Jura@2a05:5800:2a5:2200:664b:f0ff:fe37:9ef) (Ping timeout: 260 seconds) |
2023-10-24 15:41:06 +0200 | <Inst> | lol, I'm doing all these Python projects from Al Sweigart's book in Haskell, and it's degenerating into me thinking "hmmm, this UI sucks, or the parser is too lenient, gotta stuff on 40 different Haskelly improvements" |
2023-10-24 15:44:53 +0200 | CO2 | (CO2@gateway/vpn/protonvpn/co2) (Quit: WeeChat 4.1.0) |
2023-10-24 15:47:14 +0200 | <danse-nr3> | i think most devs do not realise that functional design is deeply different from object-oriented design |
2023-10-24 15:47:15 +0200 | <Unicorn_Princess> | like the leaf cannot return to its branch after falling, so can a person not return to python after seeing haskell |
2023-10-24 15:48:08 +0200 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) (Quit: = "") |
2023-10-24 15:48:10 +0200 | <danse-nr3> | nor to any other language to that extent. Haskell is a trap for devs! |
2023-10-24 15:48:28 +0200 | ubert | (~Thunderbi@91.141.40.172.wireless.dyn.drei.com) (Ping timeout: 255 seconds) |
2023-10-24 15:52:16 +0200 | <haskellbridge> | <mauke> I'm still fine with Perl 🤷 |
2023-10-24 15:52:37 +0200 | <haskellbridge> | <mauke> It's just an entirely different way of thinking |
2023-10-24 15:53:22 +0200 | cece | (~Thunderbi@e2e-32-47.ssdcloudindia.net) (Quit: cece) |
2023-10-24 15:53:26 +0200 | <haskellbridge> | <mauke> But at least I still have all the weird symbols like <$> and %~ |
2023-10-24 15:59:17 +0200 | ubert | (~Thunderbi@91.141.40.172.wireless.dyn.drei.com) |
2023-10-24 16:01:28 +0200 | vglfr | (~vglfr@88.155.140.136) |
2023-10-24 16:03:00 +0200 | xff0x | (~xff0x@ai101218.d.east.v6connect.net) (Ping timeout: 258 seconds) |
2023-10-24 16:05:03 +0200 | xff0x | (~xff0x@178.255.149.135) |
2023-10-24 16:06:14 +0200 | yoyofreeman | (~yoyofreem@176.97.76.178) (Remote host closed the connection) |
2023-10-24 16:07:47 +0200 | <Inst> | also, first time i've used IO semigroup instance |
2023-10-24 16:08:49 +0200 | <Inst> | also a bit tempted to make an IO instance of IsString :) |
2023-10-24 16:09:22 +0200 | <geekosaur> | IsString instances that can fail are no bueno |
2023-10-24 16:10:51 +0200 | <Inst> | instance IsString (IO String) where fromString = pure |
2023-10-24 16:11:01 +0200 | <Inst> | okay, orphan isntance time :) |
2023-10-24 16:13:32 +0200 | gehmehgeh | (~user@user/gehmehgeh) |
2023-10-24 16:13:37 +0200 | <int-e> | . o O ( Just don't come to use for help when you get lost in the ensuing type errors. ) |
2023-10-24 16:13:48 +0200 | <int-e> | meh, use -> us |
2023-10-24 16:14:31 +0200 | xff0x | (~xff0x@178.255.149.135) (Ping timeout: 252 seconds) |
2023-10-24 16:15:12 +0200 | <Inst> | i'm using System.Random, which is why I'm using it |
2023-10-24 16:15:24 +0200 | <Inst> | unless there's a better way to set up an array of headlines with randoms? |
2023-10-24 16:16:17 +0200 | xff0x | (~xff0x@2405:6580:b080:900:ecc3:b543:f7a2:f485) |
2023-10-24 16:16:48 +0200 | <yin> | am i the only one who passes an infinite random list around as state? |
2023-10-24 16:17:02 +0200 | <yin> | and calls it a day? |
2023-10-24 16:17:03 +0200 | notzmv | (~zmv@user/notzmv) (Ping timeout: 240 seconds) |
2023-10-24 16:17:09 +0200 | <int-e> | There are worse things than replicateM 42 (randomRIO (1,23)) |
2023-10-24 16:17:26 +0200 | <int-e> | yin: You're not the only one :) |
2023-10-24 16:19:04 +0200 | <yin> | initStdGen and randomRs is all i need |
2023-10-24 16:19:58 +0200 | <int-e> | Of course ideally I don't have random numbers at all :-P |
2023-10-24 16:20:10 +0200 | <Unicorn_Princess> | hm. what is the _intention_ behind `cabal repl`? note i'm not asking how it works, but how it's intended to be used. like, when should i prefer calling `cabal repl`, and when just `ghci`? |
2023-10-24 16:20:31 +0200 | <geekosaur> | ghci can't see things in the cabal store |
2023-10-24 16:20:32 +0200 | <Unicorn_Princess> | (assuming either can technically accomplish the given task) |
2023-10-24 16:20:43 +0200 | <geekosaur> | (unloess yo uuse --lib, but that causes other problems) |
2023-10-24 16:20:59 +0200 | <Unicorn_Princess> | cabal store as in hackage? |
2023-10-24 16:21:07 +0200 | <Unicorn_Princess> | and local equivalents? |
2023-10-24 16:21:21 +0200 | <geekosaur> | cabal store as in where cabal installs libraries |
2023-10-24 16:21:56 +0200 | <int-e> | `cabal repl` should also set the right source path if you have several haskell-source-dirs (which is sometimes useful for platform-dependent stuff) |
2023-10-24 16:21:59 +0200 | <geekosaur> | it does *not* install libraries in an exposed place; that's what cabal v1 got wrong and led to "cabal hell" when more than one version of a library was exposed |
2023-10-24 16:22:44 +0200 | <Unicorn_Princess> | i'm confused. 'cabal store' sounds uh... "exposed"? if, as you say, `cabal repl` can "see" stuff in it |
2023-10-24 16:23:19 +0200 | <geekosaur> | cabal repl sees only what is exposed via the cabal file and the resulting build plan, which is consistent |
2023-10-24 16:23:22 +0200 | <int-e> | "exposed" is a status of packages in ghc's package database... packages that are visible to ghc(i) by default |
2023-10-24 16:23:57 +0200 | <geekosaur> | (cabal will refuse to solve inconsistent build plans, such as one that simultaneously depends on two different versions of a package) |
2023-10-24 16:23:59 +0200 | <int-e> | neo-cabal leaves all packages hidden (not exposed). |
2023-10-24 16:24:47 +0200 | <Unicorn_Princess> | hmmm... thanks, i think things are starting to clear up |
2023-10-24 16:25:06 +0200 | <Inst> | https://inventwithpython.com/bigbookpython/project11.html |
2023-10-24 16:25:09 +0200 | <Inst> | here's the original code |
2023-10-24 16:26:16 +0200 | <Inst> | the headline listing is ugly |
2023-10-24 16:26:21 +0200 | <Inst> | and global variables can be considered ugly |
2023-10-24 16:29:02 +0200 | <int-e> | lines 38..55 could be another random.choice() |
2023-10-24 16:29:03 +0200 | int-e | shrugs |
2023-10-24 16:29:14 +0200 | <int-e> | I think that's as much as I care. |
2023-10-24 16:29:23 +0200 | helge_ | (~textual@h-158-174-186-9.NA.cust.bahnhof.se) (Quit: Textual IRC Client: www.textualapp.com) |
2023-10-24 16:29:25 +0200 | <Inst> | if I'm doing junk isntancing, might as well instance IsString b => Either a b into IsString |
2023-10-24 16:30:22 +0200 | <danse-nr3> | basically `cabal repl` is the shortcut to import libraries from your cabal project Unicorn_Princess, how else would you do? Run `ghci` and then load individual files? |
2023-10-24 16:31:43 +0200 | <danse-nr3> | a cabal project can also be in a sandbox and have different visibility from system packages |
2023-10-24 16:32:12 +0200 | santiagopim | (~user@90.167.66.131) (Remote host closed the connection) |
2023-10-24 16:33:47 +0200 | nyc | (~nyc@user/nyc) |
2023-10-24 16:34:41 +0200 | <Unicorn_Princess> | ah see, i'm not using it to load a haskell project, but as a shell for ad-hoc scripting, to avoid bash. so i can `ghci -i/path/to/my/helper/library`, or i can `cabal repl` and tell it in the cabal.project file which packages to require and where they are (my current plan, that i'm working on atm). since the latter lets me use any package from the cabal store, which i understand means roughly the same way of getting packages |
2023-10-24 16:34:41 +0200 | <Unicorn_Princess> | as in a project, and seems hygienic, that's what i'm going with, even if it's a bit more config files littered around |
2023-10-24 16:35:08 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-10-24 16:35:24 +0200 | <nyc> | I've been googling a bit. Is there a convenient way to figure out if system data types e.g. Data.Set, Data.Map et al are tripping over degenerate cases & behaviour? |
2023-10-24 16:37:16 +0200 | idgaen | (~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) |
2023-10-24 16:40:59 +0200 | <tomsmeding> | nyc: what do you mean with "degenerate" here? |
2023-10-24 16:42:45 +0200 | <tomsmeding> | Inst: what's wrong with wrapping 'pure' around stuff :p |
2023-10-24 16:43:04 +0200 | <nyc> | tomsmeding: Something like a balanced binary tree ending up leaning pretty close to a linked list or similar. |
2023-10-24 16:43:15 +0200 | CO2 | (~CO2@modemcable048.127-56-74.mc.videotron.ca) |
2023-10-24 16:43:24 +0200 | <tomsmeding> | nyc: don't the operations have their worst-case complexity indicated? |
2023-10-24 16:43:28 +0200 | <tomsmeding> | I thought 'containers' was pretty consistent in that |
2023-10-24 16:43:31 +0200 | Maxdamantus | (~Maxdamant@user/maxdamantus) (Ping timeout: 264 seconds) |
2023-10-24 16:43:44 +0200 | <tomsmeding> | in the haddocks |
2023-10-24 16:43:57 +0200 | <Unicorn_Princess> | i guess there's value i knowing how close to their worst-case your actual data brings them |
2023-10-24 16:44:10 +0200 | <Inst> | tomsmeding: well, it's a joke, toy project |
2023-10-24 16:44:17 +0200 | <tomsmeding> | Unicorn_Princess: it's stuff like O(log(n)) for Map.insert |
2023-10-24 16:44:19 +0200 | <Inst> | I want to abuse the hell out of overloaded strings, I guess |
2023-10-24 16:44:25 +0200 | <Inst> | I'm thinking about abusing num instances in the future |
2023-10-24 16:44:25 +0200 | <tomsmeding> | you aren't going to be _better_ than that either |
2023-10-24 16:44:38 +0200 | <tomsmeding> | @hackage acme-php |
2023-10-24 16:44:38 +0200 | <lambdabot> | https://hackage.haskell.org/package/acme-php |
2023-10-24 16:44:49 +0200 | <Inst> | everytime you mention Map, I think HashMap? |
2023-10-24 16:44:55 +0200 | <Inst> | from unordered-containers? |
2023-10-24 16:44:59 +0200 | Maxdamantus | (~Maxdamant@user/maxdamantus) |
2023-10-24 16:45:00 +0200 | <tomsmeding> | no, Data.Map |
2023-10-24 16:45:08 +0200 | thyriaen | (~thyriaen@2a01:aea0:dd4:7550:6245:cbff:fe9f:48b1) |
2023-10-24 16:45:08 +0200 | <nyc> | tomsmeding: Just any sort of visibility into what's happening with the structure. How big it is, how close to the worst case etc. would be good here. |
2023-10-24 16:45:16 +0200 | <Inst> | I mean that shouldn't HashMap have better complexitiy for insert? |
2023-10-24 16:45:31 +0200 | <[Leary]> | nyc: There are debugging helpers: https://hackage.haskell.org/package/containers-0.7/docs/Data-Map-Lazy.html#g:30 |
2023-10-24 16:45:45 +0200 | <tomsmeding> | nyc: for Data.Map and Data.Set, the structure is a balanced binary tree -- those things are pretty stable, the worst case is pretty close to the best case |
2023-10-24 16:45:53 +0200 | <tomsmeding> | Inst: this is a pure language |
2023-10-24 16:46:11 +0200 | <tomsmeding> | if you have mutation, hash maps can be significantly better than tree maps |
2023-10-24 16:46:47 +0200 | <tomsmeding> | without mutation, hash maps can still be better but only if comparison is expensive enough that it's worth hashing once and building the tree with that |
2023-10-24 16:46:53 +0200 | <nyc> | tomsmeding: It could be that repetitive operations and cache and TLB effects are significant. |
2023-10-24 16:46:59 +0200 | <tomsmeding> | nyc: this is a pure language |
2023-10-24 16:47:02 +0200 | <tomsmeding> | :p |
2023-10-24 16:47:05 +0200 | <tomsmeding> | data structures are persistent |
2023-10-24 16:47:22 +0200 | <tomsmeding> | a hash map is _not_ going to be a long vector with stuff like quadratic indexing |
2023-10-24 16:47:31 +0200 | <tomsmeding> | then insert would be O(n), to copy the vector |
2023-10-24 16:47:56 +0200 | <tomsmeding> | Data.HashMap.Strict.insert is O(log n) |
2023-10-24 16:48:05 +0200 | <tomsmeding> | does that fit your intuitive idea of a hash map? |
2023-10-24 16:48:17 +0200 | <Inst> | iirc there are some benchmarks that show Data.HashMap.Strict murders Data.Map.Strict... |
2023-10-24 16:48:26 +0200 | <tomsmeding> | depends on your comparison function |
2023-10-24 16:48:51 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
2023-10-24 16:48:55 +0200 | <tomsmeding> | and whether you can sensibly hash in the first place, sometimes |
2023-10-24 16:49:17 +0200 | <nyc> | tomsmeding: Even before purity, just automatic memory management makes visibility into what's happening with the cache and TLB somewhat awkward. I'm all ears for tools to help diagnose where the issues could be, though. |
2023-10-24 16:49:23 +0200 | <tomsmeding> | unordered-containers can use intmaps internally, so that helps, but still |
2023-10-24 16:49:28 +0200 | <Inst> | huh |
2023-10-24 16:49:29 +0200 | <Inst> | https://github.com/haskell-perf/dictionaries |
2023-10-24 16:49:45 +0200 | <Inst> | IntMap is the big winner, ironically |
2023-10-24 16:49:48 +0200 | <tomsmeding> | nyc: do you have performance issues that you're investigating? |
2023-10-24 16:49:54 +0200 | <tomsmeding> | Inst: IntMap can only handle integers as keys |
2023-10-24 16:50:07 +0200 | <tomsmeding> | if you have a map with integers as keys, obviously the dedicated implementation for integer keys wins :p |
2023-10-24 16:50:25 +0200 | <int-e> | Int, specifically. |
2023-10-24 16:50:33 +0200 | <tomsmeding> | right, Int even |
2023-10-24 16:51:22 +0200 | <Inst> | It's more surprising because IntMap is just a TreeMap / Map with Int keys, no? It's implying that Haskell hashmaps are ridiculously unperformant. |
2023-10-24 16:51:57 +0200 | <tomsmeding> | isn't IntMap a PATRICIA tree or what was it |
2023-10-24 16:52:18 +0200 | <tomsmeding> | and isn't HashMap basically IntMap + hashing beforehand |
2023-10-24 16:52:19 +0200 | czy | (~user@180.116.80.17) (Remote host closed the connection) |
2023-10-24 16:52:22 +0200 | <int-e> | pretty much (a trie) |
2023-10-24 16:52:29 +0200 | <tomsmeding> | I can hardly imagine there to be a faster implementation |
2023-10-24 16:52:35 +0200 | <int-e> | Not sure about HashMap |
2023-10-24 16:52:50 +0200 | <tomsmeding> | like, if HashMap is faster than that, why is IntMap not HashMap minus the hashing |
2023-10-24 16:53:31 +0200 | <dolio> | I think they've diverged on the details. |
2023-10-24 16:53:34 +0200 | <int-e> | There's a chance that flattening the tree a bit (having nodes with a higher branching factor than just 2) would be helpful to reduce cache pressure. Impossible to predict though. |
2023-10-24 16:53:52 +0200 | <tomsmeding> | for sure. But that would apply to IntMap and HashMap equally |
2023-10-24 16:54:11 +0200 | <int-e> | Right |
2023-10-24 16:55:31 +0200 | <Unicorn_Princess> | i find only 3 indirect references to sandboxes on https://cabal.readthedocs.io/ - are they deprecated? (i have no idea what they are) |
2023-10-24 16:56:01 +0200 | <dolio> | Yes. |
2023-10-24 16:56:11 +0200 | <Unicorn_Princess> | so i can safely ignore them, great, thanks |
2023-10-24 16:56:52 +0200 | <danse-nr3> | i think they are deprecated because cabal v2 always sandboxes? |
2023-10-24 16:57:11 +0200 | tzh | (~tzh@c-71-193-181-0.hsd1.or.comcast.net) |
2023-10-24 16:59:25 +0200 | econo_ | (uid147250@id-147250.tinside.irccloud.com) |
2023-10-24 17:00:05 +0200 | <geekosaur> | sandboxes were removed in 3.0. cabal v2 always sandboxes |
2023-10-24 17:00:56 +0200 | <dolio> | Well, the new way doesn't require that only a single version of each package can be installed in the 'store' at any time. So you don't need sandboxes to have per directory/project stores. |
2023-10-24 17:01:40 +0200 | <dolio> | Now the store just keeps track of many versions of packages built against many other versions of their dependencies, potentially. |
2023-10-24 17:02:23 +0200 | xff0x | (~xff0x@2405:6580:b080:900:ecc3:b543:f7a2:f485) (Ping timeout: 246 seconds) |
2023-10-24 17:03:35 +0200 | <Inst> | hmmm, you know, the entire py program design is stupid |
2023-10-24 17:03:53 +0200 | <Inst> | i can just get a select function that selects what i need |
2023-10-24 17:04:37 +0200 | xff0x | (~xff0x@ai101218.d.east.v6connect.net) |
2023-10-24 17:10:44 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
2023-10-24 17:21:07 +0200 | santiagopim | (~user@90.167.66.131) |
2023-10-24 17:25:04 +0200 | <EvanR> | Inst, IntMap is more efficient than Map Int |
2023-10-24 17:26:44 +0200 | <Inst> | the reason it's an IntMap instead of a Map a is because there's some properties that can only be guaranteed by Int, and thus render the real representation of IntMap as ungeneralizable? |
2023-10-24 17:27:47 +0200 | chomwitt | (~chomwitt@2a02:587:7a1a:8700:1ac0:4dff:fedb:a3f1) (Remote host closed the connection) |
2023-10-24 17:27:58 +0200 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) |
2023-10-24 17:29:17 +0200 | emmanuelux | (~emmanuelu@user/emmanuelux) |
2023-10-24 17:29:34 +0200 | azimut | (~azimut@gateway/tor-sasl/azimut) (Ping timeout: 256 seconds) |
2023-10-24 17:30:21 +0200 | <EvanR> | it's two different data structures, and the one IntMap uses can exploit the packing of 64 Bools into an Int for great justice |
2023-10-24 17:30:38 +0200 | <EvanR> | there are tries for other situations on hackage, like bytestring-trie |
2023-10-24 17:32:31 +0200 | azimut | (~azimut@gateway/tor-sasl/azimut) |
2023-10-24 17:32:33 +0200 | gmg | (~user@user/gehmehgeh) |
2023-10-24 17:32:37 +0200 | danse-nr3 | (~francesco@151.35.159.184) (Ping timeout: 252 seconds) |
2023-10-24 17:33:32 +0200 | gehmehgeh | (~user@user/gehmehgeh) (Ping timeout: 256 seconds) |
2023-10-24 17:33:47 +0200 | vglfr | (~vglfr@88.155.140.136) (Read error: Connection reset by peer) |
2023-10-24 17:34:07 +0200 | vglfr | (vglfr@gateway/vpn/protonvpn/vglfr) |
2023-10-24 17:40:58 +0200 | lisbeths | (uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity) |
2023-10-24 17:43:40 +0200 | thyriaen | (~thyriaen@2a01:aea0:dd4:7550:6245:cbff:fe9f:48b1) (Remote host closed the connection) |
2023-10-24 17:44:29 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f) (Remote host closed the connection) |
2023-10-24 17:44:49 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:484c:e1ac:4235:81cd) |
2023-10-24 17:45:31 +0200 | danse-nr3 | (~francesco@151.35.215.38) |
2023-10-24 17:47:40 +0200 | waleee | (~waleee@2001:9b0:21c:e600:f2f3:f744:435d:137c) |
2023-10-24 17:48:58 +0200 | _ht | (~Thunderbi@28-52-174-82.ftth.glasoperator.nl) |
2023-10-24 17:49:57 +0200 | vglfr | (vglfr@gateway/vpn/protonvpn/vglfr) (Ping timeout: 258 seconds) |
2023-10-24 17:50:29 +0200 | vglfr | (~vglfr@88.155.140.136) |
2023-10-24 17:55:37 +0200 | <John_Ivan> | is anyone else's "cabal install simplehttp" failing? |
2023-10-24 17:57:55 +0200 | <Inst> | why is it failing? |
2023-10-24 17:58:37 +0200 | <c_wraith> | well, there doesn't seem to be a package with that name on hackage |
2023-10-24 17:58:57 +0200 | <Inst> | if you want the simpleHTTP function, that's in network-conduit |
2023-10-24 17:59:14 +0200 | <Inst> | http-conduit, excuse me |
2023-10-24 17:59:24 +0200 | <c_wraith> | but "cabal install" is never the command you want to install libraries |
2023-10-24 17:59:31 +0200 | <Inst> | would be in Network.HTTP.Conduit, although it's advised that you screw around with Network.HTTP.Simple instead |
2023-10-24 18:00:05 +0200 | <c_wraith> | In fact, you shouldn't think of installing libraries as a concept at all. Instead you should think of declaring what libraries you need, and letting cabal handle the details. |
2023-10-24 18:00:14 +0200 | <John_Ivan> | seems http-conduit was the right package. thank you. |
2023-10-24 18:00:30 +0200 | chele | (~chele@user/chele) (Remote host closed the connection) |
2023-10-24 18:00:33 +0200 | <John_Ivan> | c_wraith, right. I have a cabal file declaring them. |
2023-10-24 18:00:37 +0200 | <John_Ivan> | it just wasn't found |
2023-10-24 18:00:39 +0200 | <c_wraith> | ah, ok. |
2023-10-24 18:00:51 +0200 | <John_Ivan> | thanks |
2023-10-24 18:04:54 +0200 | <Inst> | randomRIO btw is actually discouraged at least according to System.Random docs |
2023-10-24 18:05:44 +0200 | <Inst> | oh ffs, this interface is a pain |
2023-10-24 18:06:28 +0200 | <monochrom> | It is not too bad. :) |
2023-10-24 18:07:25 +0200 | <monochrom> | Between having to append the "g" in "x <- uniform (0,1) g" and incurring one more dependency, I choose the former. |
2023-10-24 18:08:15 +0200 | waleee | (~waleee@2001:9b0:21c:e600:f2f3:f744:435d:137c) (Ping timeout: 240 seconds) |
2023-10-24 18:08:59 +0200 | <int-e> | Hmm I don't see any actual reason for this discouragement. |
2023-10-24 18:09:07 +0200 | <Inst> | iirc, that doesn't actually work |
2023-10-24 18:09:10 +0200 | <Inst> | https://hackage.haskell.org/package/random-1.2.1.1/docs/System-Random.html#v:uniform |
2023-10-24 18:09:28 +0200 | <geekosaur> | my recollection is all the things that use a hidden generator in IO are discouraged |
2023-10-24 18:09:40 +0200 | <Inst> | uniform :: (RandomGen g, Uniform a) => g -> (a, g) |
2023-10-24 18:09:53 +0200 | <geekosaur> | you should seed and use your own generator instead |
2023-10-24 18:09:54 +0200 | <Inst> | you mean uniformR, right? |
2023-10-24 18:09:55 +0200 | <monochrom> | OK uniformRM (0,1) g |
2023-10-24 18:10:12 +0200 | <int-e> | geekosaur: So "uniformRM (2020, 2100) globalStdGen :: IO Int" is preferred because it mentions globalStdGen explicitly? |
2023-10-24 18:10:54 +0200 | <geekosaur> | it's better because you're explicit about it, but it's still iirc less performant than using a local Random state monad |
2023-10-24 18:11:10 +0200 | <geekosaur> | because it's having to indirect through an IORef |
2023-10-24 18:11:35 +0200 | <int-e> | Sure. I can see that, but when I just want a dozen random numbers I don't care about that. |
2023-10-24 18:12:12 +0200 | <Inst> | randomRIO is a relatively good interface |
2023-10-24 18:12:26 +0200 | <EvanR> | I use randomRIO all the time |
2023-10-24 18:12:29 +0200 | <int-e> | And it's fine to have preferences. But that doesn't make randomRIO a *bad* interface. |
2023-10-24 18:12:42 +0200 | <int-e> | In my book at elast. |
2023-10-24 18:13:06 +0200 | <monochrom> | Perhaps I am dense and facetious and don't see the difference, but this is why I put "randomRIO is discouraged" and "cabal install --lib is discouraged" in the same bin, along with all of "best practices" and "code smells", the lot of them. |
2023-10-24 18:13:20 +0200 | <c_wraith> | I do think it's weird that the new System.Random.Stateful interface uses *both* polymorphism over a monadic interface and passing some kind of gen value. |
2023-10-24 18:13:36 +0200 | <monochrom> | I am an extreme it-depends-ist. :) |
2023-10-24 18:13:51 +0200 | <Unicorn_Princess> | fence-sitter! |
2023-10-24 18:14:07 +0200 | <int-e> | monochrom: I can think of circumstances where I'm on board with that point of view. |
2023-10-24 18:14:10 +0200 | int-e | runs |
2023-10-24 18:14:36 +0200 | <c_wraith> | Like... Why are you polytypic over the monad type *and* passing some kind of generator token? Is this solely to handle some kind of nested use case? |
2023-10-24 18:14:45 +0200 | <Unicorn_Princess> | i prefer extremist dogmatism. hence haskell >_> |
2023-10-24 18:14:48 +0200 | <monochrom> | I can admit that in reality I only choose "--lib" 10% of the time and be careful about it, etc. But it is not going to be 0. |
2023-10-24 18:15:03 +0200 | Tuplanolla | (~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) |
2023-10-24 18:16:10 +0200 | segfaultfizzbuzz | (~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) |
2023-10-24 18:16:53 +0200 | <segfaultfizzbuzz> | can i get some color on the phenomenon of what it means to read a paper? for example i came across this paper from the internets today: https://www.cs.ox.ac.uk/people/daniel.james/iso/iso.pdf |
2023-10-24 18:17:11 +0200 | _xor5 | (~xor@72.49.199.93) |
2023-10-24 18:17:11 +0200 | <monochrom> | Yes the interface is weird. It is an attempt at unifying IO (which needs you to say g) and State (which doesn't). So insist on saying g, but make it a phatom unit type for State. |
2023-10-24 18:17:39 +0200 | <monochrom> | Some years ago, I disliked it. Now, I tolerate it. |
2023-10-24 18:18:01 +0200 | <c_wraith> | Honestly, 10% sounds *really high* for --lib |
2023-10-24 18:18:08 +0200 | _xor5 | (~xor@72.49.199.93) (Read error: Connection reset by peer) |
2023-10-24 18:18:11 +0200 | <dolio> | Yeah. |
2023-10-24 18:18:21 +0200 | <monochrom> | That's my use case. |
2023-10-24 18:18:30 +0200 | <danse-nr3> | here is my color segfaultfizzbuzz ... i will add it to the pile of stuff to study that monotonically increases. Stressed dev's color |
2023-10-24 18:18:48 +0200 | <monochrom> | I am not a dev. I am a teacher and a self-learn student and a hobbyist. |
2023-10-24 18:18:50 +0200 | _xor | (~xor@72.49.199.93) (Ping timeout: 255 seconds) |
2023-10-24 18:18:54 +0200 | <segfaultfizzbuzz> | my questions are what it would mean to have "read" the paper |
2023-10-24 18:19:10 +0200 | <[exa]> | segfaultfizzbuzz: you may or may not understand what the author wanted to convey |
2023-10-24 18:19:49 +0200 | <segfaultfizzbuzz> | quite often the general topic area is interesting but the actual content tends to be too detailed |
2023-10-24 18:19:55 +0200 | _xor | (~xor@72.49.199.93) |
2023-10-24 18:20:06 +0200 | <segfaultfizzbuzz> | do you retain the detailed content of the paper when you read? |
2023-10-24 18:20:19 +0200 | <[exa]> | not really |
2023-10-24 18:20:44 +0200 | <c_wraith> | monochrom: but what are you doing where cabal repl or cabal run with appropriate -b arguments doesn't work? |
2023-10-24 18:21:01 +0200 | <monochrom> | Does it matter? |
2023-10-24 18:21:01 +0200 | <segfaultfizzbuzz> | for example, we might ask for this paper, do you remember the next day, a week later, a year later the definition of a "representable set-valued functor" from (19) ? |
2023-10-24 18:21:13 +0200 | <danse-nr3> | papers come from a scientifical background. Science is heavily siloed. They tend to be meaningful for who is advanced in an area |
2023-10-24 18:21:24 +0200 | <c_wraith> | In the sense that cabal should be fixed to handle those use cases, yes |
2023-10-24 18:21:29 +0200 | <[exa]> | segfaultfizzbuzz: for most papers I get some intuition about the result, some tech about how they did the proof or so, maybe some extras (like stupid jokes, if present) but that's it. The rest is for machines |
2023-10-24 18:22:02 +0200 | <segfaultfizzbuzz> | by machines you mean people implementing the paper...? |
2023-10-24 18:22:27 +0200 | <[exa]> | ah yes and then the poor people who decide to implement the thing. :D |
2023-10-24 18:22:27 +0200 | _xor | (~xor@72.49.199.93) (Read error: Connection reset by peer) |
2023-10-24 18:22:31 +0200 | <ncf> | segfaultfizzbuzz: you eventually remember it after having seen it enough times (representable functors are very important in category theory, so they come up often) |
2023-10-24 18:22:37 +0200 | <segfaultfizzbuzz> | i feel like if i was to actually attempt to read and understand every line of this paper might might take several months |
2023-10-24 18:22:37 +0200 | <[exa]> | but there you usually go with the paper in hand for the reference |
2023-10-24 18:22:45 +0200 | <John_Ivan> | Hmm. I seem to get the following linking errors after pulling in http-conduit and bytestring. I guess there's nothing that can be done? https://i.imgur.com/zdPV9RP.png |
2023-10-24 18:22:51 +0200 | vglfr | (~vglfr@88.155.140.136) (Read error: Connection reset by peer) |
2023-10-24 18:22:58 +0200 | <[exa]> | segfaultfizzbuzz: yeah that may be the case sometimes |
2023-10-24 18:23:14 +0200 | vglfr | (~vglfr@138.199.53.249) |
2023-10-24 18:23:15 +0200 | <John_Ivan> | seems like some dependency of those 2, deep down, is failing. |
2023-10-24 18:23:17 +0200 | <segfaultfizzbuzz> | i do like the general idea of emphasizing type isomorphism over type equality |
2023-10-24 18:23:46 +0200 | <danse-nr3> | John_Ivan, try to install the dependencies by themselves for better troubleshooting. Look up the errors |
2023-10-24 18:24:14 +0200 | _xor | (~xor@72.49.199.93) |
2023-10-24 18:24:15 +0200 | <dolio> | Representable set-valued functors are one of the ways of presenting almost everything in category theory. |
2023-10-24 18:24:22 +0200 | <[exa]> | segfaultfizzbuzz: esp. for folks new to the topics, interrupting and referring to textbooks or other papers is common. normally if you switch scientific topic it is expected that you'll spend a few months just chewing through papers to catch up on what the stuff is about |
2023-10-24 18:24:34 +0200 | <John_Ivan> | I will but I suspect I won't have much luck. Better change the network library. |
2023-10-24 18:24:50 +0200 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 258 seconds) |
2023-10-24 18:25:00 +0200 | <Inst> | okay, idiocy achieved |
2023-10-24 18:25:02 +0200 | <Inst> | [liamzy@liamachine 11.ClickbaitHeadLineGenerator]$ cabal run ClickbaitGen.hs |
2023-10-24 18:25:03 +0200 | <Inst> | Without This Robot, Robots Could Kill You This Year |
2023-10-24 18:25:23 +0200 | <segfaultfizzbuzz> | lol clickbait headline generator? lol lol |
2023-10-24 18:25:24 +0200 | <monochrom> | I don't like the prospect that nondetermistically something decides to download things. I prefer to deterministically pre-download and I choose when to download. |
2023-10-24 18:25:37 +0200 | <EvanR> | I can't even click on this clickbait |
2023-10-24 18:25:41 +0200 | <dolio> | I will say, though, there are a lot of people who say they've "read" a paper, but I'd disagree. :þ |
2023-10-24 18:25:46 +0200 | <dolio> | Including academics, I think. |
2023-10-24 18:26:31 +0200 | <Inst> | does Haskell have a chatGPT interface yet? |
2023-10-24 18:26:41 +0200 | <monochrom> | "cabal freeze" exists but I don't always need a "project". |
2023-10-24 18:27:02 +0200 | <segfaultfizzbuzz> | Inst: lol lol lol |
2023-10-24 18:27:14 +0200 | <[exa]> | Inst: c'mon people are still busy scrolling through ghc error messages, we don't need another generator :D |
2023-10-24 18:27:45 +0200 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection) |
2023-10-24 18:28:00 +0200 | <EvanR> | chatGPT takes generating ghc error messages to the next level |
2023-10-24 18:28:08 +0200 | <Inst> | i actually have a big flaw insofar as i think the damn thing is caching and there's insufficient randomness |
2023-10-24 18:28:08 +0200 | <Inst> | :( |
2023-10-24 18:28:09 +0200 | _xor | (~xor@72.49.199.93) (Read error: Connection reset by peer) |
2023-10-24 18:28:28 +0200 | FinnElija | (~finn_elij@user/finn-elija/x-0085643) |
2023-10-24 18:28:31 +0200 | <monochrom> | There are other personal preferences such as having a one-shot inclination and despising the fake-project idea of cabal run. |
2023-10-24 18:28:46 +0200 | <monochrom> | or cabal script |
2023-10-24 18:28:48 +0200 | <EvanR> | every time you run the program, it reseeds the generator, which can mess up the randomness especially with the StdGen I used a while back |
2023-10-24 18:29:04 +0200 | ChaiTRex | (~ChaiTRex@user/chaitrex) (Ping timeout: 256 seconds) |
2023-10-24 18:29:08 +0200 | notzmv | (~zmv@user/notzmv) |
2023-10-24 18:29:16 +0200 | <monochrom> | There will be no point fixing cabal to suit my use case and preference. It is not the point of cabal. |
2023-10-24 18:29:32 +0200 | ChaiTRex | (~ChaiTRex@user/chaitrex) |
2023-10-24 18:30:56 +0200 | <Inst> | "Are Millenials Killing the Avocado Industry?" |
2023-10-24 18:31:36 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Read error: Connection reset by peer) |
2023-10-24 18:31:53 +0200 | _xor | (~xor@72.49.199.93) |
2023-10-24 18:32:08 +0200 | <segfaultfizzbuzz> | lol Inst is a genius... is Inst a bot? |
2023-10-24 18:32:23 +0200 | <Inst> | I'll show code in a bit |
2023-10-24 18:32:49 +0200 | <Inst> | it's a port of this: https://inventwithpython.com/bigbookpython/project11.html |
2023-10-24 18:33:02 +0200 | <Inst> | I still have undefineds somewhere, because I need to clone some of the headline functionality |
2023-10-24 18:34:12 +0200 | rgw | (~R@2605:a601:a0df:5600:15e8:6c08:c6f6:7379) |
2023-10-24 18:34:51 +0200 | <monochrom> | There is also no point wiping out the name "ghci" from the surface of the Earth. |
2023-10-24 18:35:06 +0200 | <segfaultfizzbuzz> | Inst: can you guide it to make haskell clickbait? |
2023-10-24 18:35:55 +0200 | <EvanR> | who is wiping out ghci |
2023-10-24 18:36:08 +0200 | <Inst> | stack repl and cabal repl -b |
2023-10-24 18:36:12 +0200 | <monochrom> | Everyone who promotes "always use cabal repl"? |
2023-10-24 18:36:34 +0200 | <Inst> | it'd be better to upgrade ghci to be more useful, but I somehow get the feeling all the tooling ideas people have will suck up 2-3 years of the entire Haskell community's time |
2023-10-24 18:37:04 +0200 | <segfaultfizzbuzz> | Make your program COMPOSABLE with these 8 HOT MONAD TUTORIALS |
2023-10-24 18:37:37 +0200 | <int-e> | segfaultfizzbuzz: Top 10 reasons why you are a terrible person. |
2023-10-24 18:37:46 +0200 | <Inst> | current version |
2023-10-24 18:37:47 +0200 | <Inst> | https://paste.tomsmeding.com/U0WIPjDz |
2023-10-24 18:38:10 +0200 | <EvanR> | upgrade ghci to be even more useful? sounds great |
2023-10-24 18:38:11 +0200 | <geekosaur> | and it's wrong anyway, "compiling to categories" would be that 😛 |
2023-10-24 18:38:46 +0200 | <Inst> | monochrom: are you part of a edu-haskellers group? Not that I'd be qualified for one, not in the former industry, but it'd be interesting what you folks might want in terms of ecosystem / tooling improvements |
2023-10-24 18:38:53 +0200 | <segfaultfizzbuzz> | Your girlfriend won't believe you used ALL 80 of these TOP LANGUAGE EXTENSIONS with GHC |
2023-10-24 18:39:06 +0200 | <monochrom> | I don't think it would be wise to merge ghci and cabal. In Rust, Go, Lean, ... they all keep compiler and lib-chaser separate. There may be a good reason. |
2023-10-24 18:39:22 +0200 | <monochrom> | No I haven't heard of edu-haskellers. |
2023-10-24 18:39:24 +0200 | juri__ | (~juri@79.140.115.166) (Ping timeout: 258 seconds) |
2023-10-24 18:39:46 +0200 | <EvanR> | I feel like many languages have a 20% programming language 80% "tooling" brain burden, and haskell is kind of there. Why do we need more |
2023-10-24 18:39:58 +0200 | <monochrom> | What improvement? I think the current state is fine. |
2023-10-24 18:40:11 +0200 | <Inst> | well, it was an indefinite article, but it'd be nice if someone would try to get such a program back up, like, you could try to pick up the folks at Chennai, the folks at UChicago, the folks at Chalmers, Zhongshan, etc... |
2023-10-24 18:40:52 +0200 | <sclv> | the path forward imho is exposing increasingly more stable ghc-api to the point which people can easily write ghci-like things making use of it |
2023-10-24 18:41:02 +0200 | juri_ | (~juri@84-19-175-187.pool.ovpn.com) |
2023-10-24 18:41:07 +0200 | <segfaultfizzbuzz> | i asked a language model to do this and it came up with: "Haskell: The Secret Weapon Of The World's Top Tech Companies - And Now It Can Be Yours Too!" lol |
2023-10-24 18:41:10 +0200 | <sclv> | then we can have a lot of experimentation with augmented super-repls |
2023-10-24 18:41:11 +0200 | <Inst> | utop clone would be fun :) |
2023-10-24 18:41:34 +0200 | <Inst> | Meta + Google, who else? :) |
2023-10-24 18:42:10 +0200 | CiaoSen | (~Jura@2a05:5800:2a5:2200:664b:f0ff:fe37:9ef) |
2023-10-24 18:42:16 +0200 | <segfaultfizzbuzz> | haha, a language model: "Haskell: The language that's so pure, it's practically a religion!" |
2023-10-24 18:44:50 +0200 | <Inst> | hmmm, see, this is why porting stuff from Py is a bad idea. I'm somehow thinking this clickbait generator could be a library. :( |
2023-10-24 18:44:58 +0200 | <monochrom> | I feel like it is not funny because I don't know what prompt you entered. For all I know it is just parroting your prompt, so it was you not the computer who came up with that. |
2023-10-24 18:45:14 +0200 | <segfaultfizzbuzz> | i asked it to make dumb spammy haskell clickbait titles |
2023-10-24 18:45:30 +0200 | <segfaultfizzbuzz> | i cherrypicked these out of a few dozen |
2023-10-24 18:45:46 +0200 | <monochrom> | This is also related to how people just ask "I got an error, what should I do?" without thinking even for a second that maybe the source code and the error message cannot be telepathed. |
2023-10-24 18:46:08 +0200 | <Inst> | I mean I already have virtually an EDSL written up, just need to wrap IO to prevent the instance IsString (IO String) from contaminating everything else |
2023-10-24 18:46:48 +0200 | <EvanR> | I am anecdotally gathering that many people are aware that haskell is a purely functional programming language, but don't know that pure is specifically referring to purity of functions, and think it might be some kind of superlative with an idiosycratic meaning internal to haskell |
2023-10-24 18:47:18 +0200 | <monochrom> | A library would not come with a person that knows how to do quality control and cherrypick. |
2023-10-24 18:48:05 +0200 | <monochrom> | EvanR: Do you know how they interepret "purely"? |
2023-10-24 18:48:24 +0200 | <EvanR> | "purely" ? no |
2023-10-24 18:48:43 +0200 | <monochrom> | Perhaps they don't interpret it at all. |
2023-10-24 18:48:44 +0200 | <EvanR> | oh I said purely |
2023-10-24 18:48:50 +0200 | <monochrom> | Yeah :) |
2023-10-24 18:49:14 +0200 | <EvanR> | one possibility is that haskell is just a functional programming language and not so called Multi Paradigm Language like rust calls itself |
2023-10-24 18:49:38 +0200 | <segfaultfizzbuzz> | rust is purely multi paaradigm |
2023-10-24 18:49:40 +0200 | <monochrom> | That actually could be right. :) |
2023-10-24 18:50:02 +0200 | danse-nr3 | (~francesco@151.35.215.38) (Remote host closed the connection) |
2023-10-24 18:50:12 +0200 | <EvanR> | I'm a hardcore multi-paradigm coder |
2023-10-24 18:50:20 +0200 | <EvanR> | I only do multi-paradigm |
2023-10-24 18:52:03 +0200 | <Inst> | tbh the purely functional programming language is deceptive marketing, but it's useful for Haskell; friends who get taught imperative Haskell first lose interest quickly |
2023-10-24 18:52:37 +0200 | <monochrom> | Well you always play to the tool's strength, and only do that. |
2023-10-24 18:52:39 +0200 | Square | (~Square@user/square) |
2023-10-24 18:52:41 +0200 | <EvanR> | functions in haskell are literally pure functions, so that's correct marketing |
2023-10-24 18:52:45 +0200 | danse-nr3 | (~francesco@151.35.215.38) |
2023-10-24 18:53:00 +0200 | maxfan8 | (~max@2a01:4f8:192:5356::2) (Ping timeout: 240 seconds) |
2023-10-24 18:53:08 +0200 | <monochrom> | I have seen student try to write Python in Haskell style too. I criticiszed that and gave a low mark. |
2023-10-24 18:53:27 +0200 | <Inst> | awww, that's cute :( |
2023-10-24 18:54:32 +0200 | <monochrom> | As in: In Haskell you do ADT and pattern matching. So in Python the student used isinstanceof. |
2023-10-24 18:55:43 +0200 | <tomsmeding> | "OO languages also have ADTs, you use objects and inheritance" seems to be a persistent myth |
2023-10-24 18:55:52 +0200 | Square3 | (~Square4@user/square) (Ping timeout: 272 seconds) |
2023-10-24 18:55:58 +0200 | segfaultfizzbuzz | (~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 255 seconds) |
2023-10-24 18:56:21 +0200 | <monochrom> | Well, it would be perfect if inheritance was actually used in this case. :) |
2023-10-24 18:56:52 +0200 | segfaultfizzbuzz | (~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) |
2023-10-24 18:56:52 +0200 | <monochrom> | or rather s/used/exploited/ |
2023-10-24 18:56:56 +0200 | <segfaultfizzbuzz> | monochrom: yeah, can you tell that i write rust code? ;-) |
2023-10-24 18:57:35 +0200 | <monochrom> | If you use isinstanceof everywhere instead of overriding methods in a subclass, you are missing the point of the language. |
2023-10-24 18:59:04 +0200 | <tomsmeding> | true |
2023-10-24 18:59:31 +0200 | <monochrom> | The general underlying myth though is "if S1 and S2 both solve problem P, then S1 and S2 are similar, even the same". |
2023-10-24 18:59:32 +0200 | <mauke> | as Larry Wall once said: "Q. Why is this so clumsy? A. The trick is to use Perl's strengths rather than its weaknesses." |
2023-10-24 19:00:12 +0200 | <monochrom> | You can use a class hierarchy to solve a certain problem. You can also use ADT to solve the same problem. They are opposite approaches, literally. That is fine. |
2023-10-24 19:00:28 +0200 | <monochrom> | And it is actually true of a large class of problems. |
2023-10-24 19:00:47 +0200 | <monochrom> | But people just leap "same problem therefore same solution". |
2023-10-24 19:01:24 +0200 | <monochrom> | Just look at how people really want to say "Haskell type classes similar to Java interfaces". |
2023-10-24 19:01:30 +0200 | <mauke> | extrinsic equality |
2023-10-24 19:01:52 +0200 | <monochrom> | They address the same problem. But they came from oppposite angles. |
2023-10-24 19:06:01 +0200 | vglfr | (~vglfr@138.199.53.249) (Ping timeout: 255 seconds) |
2023-10-24 19:07:23 +0200 | vglfr | (~vglfr@88.155.140.136) |
2023-10-24 19:08:33 +0200 | sm | (~sm@plaintextaccounting/sm) (Quit: sm) |
2023-10-24 19:10:06 +0200 | <elevenkb> | monochrom: Please explicate the way in which objects + inheritance and ADTs are opposite approaches... e.g. if there's a cool categorical duality there I'd love to know about it. |
2023-10-24 19:11:52 +0200 | <tomsmeding> | elevenkb: look up "the expression problem" |
2023-10-24 19:12:13 +0200 | <monochrom> | ADTs are closed, class hierarchies are open. ADTs are initial algebras, objects are final coalgebras. |
2023-10-24 19:12:25 +0200 | <tomsmeding> | (yes, despite the generic-sounding name, that will get you hits) |
2023-10-24 19:13:25 +0200 | <EvanR> | the expression problem needs a better name |
2023-10-24 19:13:27 +0200 | <elevenkb> | tomsmeding: doh! i'd heard of that name... thanks for reminding me about it. |
2023-10-24 19:13:38 +0200 | <EvanR> | I can think of many problems involving expressions |
2023-10-24 19:13:58 +0200 | <danse-nr3> | i agree |
2023-10-24 19:14:00 +0200 | <tomsmeding> | and also of many _other_ problems involving expression |
2023-10-24 19:14:10 +0200 | <monochrom> | I'm sure the expression problem covers them all. :) |
2023-10-24 19:14:11 +0200 | <elevenkb> | monochrom: doesn't laziness mean that Haskell's ADTs are better thought of as final coalgebras though? |
2023-10-24 19:14:15 +0200 | <tomsmeding> | (two levels of ambiguity there) |
2023-10-24 19:14:50 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) |
2023-10-24 19:14:59 +0200 | <EvanR> | was the expression problem born from the late 80s OOP era because that would explain it |
2023-10-24 19:15:06 +0200 | <EvanR> | early 90s |
2023-10-24 19:15:15 +0200 | <monochrom> | Only if one can also justify that eagerness implies that objects are better thought of as initial algebras. >:D |
2023-10-24 19:16:11 +0200 | <ncf> | isn't Hask algebraically compact or something |
2023-10-24 19:16:29 +0200 | <ncf> | meaning initial algebras and final coalgebras coincide |
2023-10-24 19:17:19 +0200 | <danse-nr3> | something |
2023-10-24 19:17:51 +0200 | <ncf> | (by Hask i mean... idk, ωCpo?) |
2023-10-24 19:18:50 +0200 | <ncf> | seems like it |
2023-10-24 19:19:40 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 248 seconds) |
2023-10-24 19:19:41 +0200 | machinedgod | (~machinedg@d198-53-218-113.abhsia.telus.net) |
2023-10-24 19:20:33 +0200 | sm | (~sm@plaintextaccounting/sm) |
2023-10-24 19:21:09 +0200 | <danse-nr3> | sorry, the other day someone in #math said that category theory was the "trust me bro" of maths, i just wanted to follow the style :P |
2023-10-24 19:23:58 +0200 | <Rembane> | danse-nr3: You need the proper t-shirt for that to hold. :) |
2023-10-24 19:31:19 +0200 | <dolio> | Laziness doesn't really have anything to do with it. |
2023-10-24 19:31:25 +0200 | <dolio> | General recursion does. |
2023-10-24 19:33:01 +0200 | <Unicorn_Princess> | i made a local .tar.gz repository as per https://cabal.readthedocs.io/en/stable/config.html#local-no-index-repositories , but then i had trouble getting the cabal repl to load my package in that repository ("cannot satisfy package" and zero extra info, even with -v). then i tried to see if a normal project could load my local package, and indeed it could. then i tried it in the repl again, and this time it worked. i suspect |
2023-10-24 19:33:01 +0200 | <Unicorn_Princess> | there was maybe an implicitly called `cabal update` or something similar that i happened to run that made it work? |
2023-10-24 19:33:37 +0200 | <elevenkb> | discussion is reminding me of this paper: https://link.springer.com/content/pdf/10.1007/978-3-030-17184-1_5.pdf |
2023-10-24 19:36:45 +0200 | fweht | (uid404746@id-404746.lymington.irccloud.com) (Quit: Connection closed for inactivity) |
2023-10-24 19:38:52 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
2023-10-24 19:40:09 +0200 | <Unicorn_Princess> | i'm barely on page 2 and i'm already dizzy. how many degrees in what would i need to grok that? |
2023-10-24 19:41:21 +0200 | danse-nr3 | (~francesco@151.35.215.38) (Remote host closed the connection) |
2023-10-24 19:41:24 +0200 | rosco | (~rosco@yp-150-69.tm.net.my) (Quit: Lost terminal) |
2023-10-24 19:41:36 +0200 | mmhat | (~mmh@p200300f1c71907a1ee086bfffe095315.dip0.t-ipconnect.de) |
2023-10-24 19:41:45 +0200 | danse-nr3 | (~francesco@151.35.215.38) |
2023-10-24 19:43:56 +0200 | <ncf> | degrees do not confere understanding |
2023-10-24 19:44:14 +0200 | <ncf> | oops that's not a word |
2023-10-24 19:44:22 +0200 | <geekosaur> | "confer" |
2023-10-24 19:44:26 +0200 | <ncf> | thanks |
2023-10-24 19:44:29 +0200 | <tomsmeding> | degrees do sometimes give requisite background knowledge |
2023-10-24 19:44:42 +0200 | <Rembane> | Maybe the paper isn't very good at explaining the thing they want to explain. |
2023-10-24 19:44:45 +0200 | Rembane | hasn't opened it yet |
2023-10-24 19:45:01 +0200 | Rembane | has prejudices about papers |
2023-10-24 19:45:28 +0200 | <tomsmeding> | the introduction is a bit lofty and pulls together a number of related topics in mathematics, in order (I guess) to give a variety of readers a tidbit that they can relate to |
2023-10-24 19:45:44 +0200 | <Unicorn_Princess> | ah yes. #relatable |
2023-10-24 19:46:05 +0200 | <tomsmeding> | but because their selection of topics is biased to the abstract side, more... pedestrian programmers have trouble getting wtf is going on :) |
2023-10-24 19:46:18 +0200 | <EvanR> | I find it hard to follow and I think I get codata already xD |
2023-10-24 19:46:49 +0200 | <tomsmeding> | I did a very small amount of playing around with codata in agda and after a bit of tinkering it seemed understandable enough |
2023-10-24 19:46:56 +0200 | <tomsmeding> | I have no idea what they are on about with polarity |
2023-10-24 19:47:25 +0200 | <tomsmeding> | funny that SPJ is an author |
2023-10-24 19:47:37 +0200 | <tomsmeding> | I feel like he wouldn't have approved of that introduction, but maybe I'm wrong :p |
2023-10-24 19:48:22 +0200 | wootehfoot | (~wootehfoo@user/wootehfoot) |
2023-10-24 19:48:36 +0200 | <tomsmeding> | ooh there's fraktur (pdf page 20) |
2023-10-24 19:48:37 +0200 | <Rembane> | Maybe it was the mirror dimension SPJ that OKed it? coSPJ perhaps? |
2023-10-24 19:48:43 +0200 | <tomsmeding> | then it's surely a good paper |
2023-10-24 19:48:48 +0200 | <tomsmeding> | lol |
2023-10-24 19:49:16 +0200 | <Rembane> | Pretty! |
2023-10-24 19:49:23 +0200 | <tomsmeding> | ah they implemented stuff in a ghc fork |
2023-10-24 19:49:30 +0200 | <tomsmeding> | surely that's where Simon came in |
2023-10-24 19:49:43 +0200 | <Unicorn_Princess> | you know you're in scary territory when greek letters aren't arcane enough to convey meaning |
2023-10-24 19:51:46 +0200 | segfaultfizzbuzz | (~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Ping timeout: 255 seconds) |
2023-10-24 19:52:19 +0200 | <dolio> | The introduction is kind of funny, because mathematicians say that computer scientists have a much better handle on codata, because it gets ignored in algebra and such. |
2023-10-24 19:52:30 +0200 | segfaultfizzbuzz | (~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) |
2023-10-24 19:53:59 +0200 | segfaultfizzbuzz | (~segfaultf@23-93-74-212.fiber.dynamic.sonic.net) (Client Quit) |
2023-10-24 19:54:32 +0200 | <elevenkb> | sorry to disrupt the discussion on the paper: is it on topic to ask for career advice in the Haskell industry here? |
2023-10-24 19:55:18 +0200 | <ncf> | i'm not sure the "church encodings are codata" bit makes sense to me |
2023-10-24 19:55:37 +0200 | mmhat | (~mmh@p200300f1c71907a1ee086bfffe095315.dip0.t-ipconnect.de) (Quit: WeeChat 4.1.0) |
2023-10-24 19:55:54 +0200 | <dolio> | Yeah. I mean, if they are, it's kind of trivial because it isn't a recursive definition. |
2023-10-24 19:56:02 +0200 | <ncf> | ye |
2023-10-24 19:56:11 +0200 | <geekosaur> | elevenkb, it's on topic but I'm not sure how much help you'll get here. I'd try Reddit or the Discourse |
2023-10-24 19:56:26 +0200 | <monochrom> | Unicorn_Princess: My config has "repository my-local-repository\n url: file+noindex:///home/trebla/.cabal/my-local-repository". Then under /home/trebla/.cabal/my-local-repository/ I have my tarball. |
2023-10-24 19:56:34 +0200 | <elevenkb> | geekosaur: thanks. |
2023-10-24 19:57:18 +0200 | <monochrom> | I bet the directory can be anywhere (not necessarily under .cabal) as long as you have absolute paths. |
2023-10-24 19:59:02 +0200 | <Unicorn_Princess> | monochrom, pretty much equivalent here. as said, it -does- work, but at first it didn't. i suspect there was something similar to `cabal update` that made it work. that, or gnomes |
2023-10-24 19:59:04 +0200 | wootehfoot | (~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer) |
2023-10-24 19:59:05 +0200 | qqq | (~qqq@92.43.167.61) |
2023-10-24 20:00:27 +0200 | <Inst> | this is... insane |
2023-10-24 20:00:35 +0200 | <tomsmeding> | yes |
2023-10-24 20:00:45 +0200 | <monochrom> | Yeah I think a one-time "cabal update" is required. |
2023-10-24 20:00:52 +0200 | <Inst> | https://paste.tomsmeding.com/5dZqcv8r |
2023-10-24 20:03:33 +0200 | <EvanR> | what |
2023-10-24 20:03:44 +0200 | <EvanR> | why doesn't that have a function type |
2023-10-24 20:04:08 +0200 | <EvanR> | oh, it's an as pattern |
2023-10-24 20:04:12 +0200 | <geekosaur> | yeh |
2023-10-24 20:04:16 +0200 | <geekosaur> | looks weird to me |
2023-10-24 20:04:40 +0200 | <monochrom> | Oh, I see why it's insane. Turn on OverloadedList and then list patterns are OK for Vector... |
2023-10-24 20:05:12 +0200 | <Inst> | no, I mean, I never knew this would work |
2023-10-24 20:05:34 +0200 | <monochrom> | Well, I guess we are all saying none of us knew. :) |
2023-10-24 20:05:54 +0200 | <EvanR> | p@(x,y) = (y + 1, 9) |
2023-10-24 20:06:25 +0200 | <monochrom> | Who needs PatternSynonyms when we can have OverloadedAnythingThatHasPatterns instead. |
2023-10-24 20:06:50 +0200 | <Inst> | this is ironically way too close to OOP, no? |
2023-10-24 20:06:57 +0200 | <EvanR> | OverloadedOverloading |
2023-10-24 20:07:07 +0200 | <Rembane> | OverloadedAllTheThings! |
2023-10-24 20:07:11 +0200 | <tomsmeding> | Inst: it's not OOP as long as there are no methods and no inheritance |
2023-10-24 20:07:16 +0200 | <monochrom> | I don't know. OOP does not have a monopoly on overloading though. |
2023-10-24 20:07:33 +0200 | <monochrom> | Likewise FP does not have a monopoly on ADTs. |
2023-10-24 20:07:43 +0200 | <tomsmeding> | Overly Overloaded Programming |
2023-10-24 20:08:23 +0200 | <monochrom> | correlation vs causation, as usual |
2023-10-24 20:08:30 +0200 | <EvanR> | Inst, a similar "trick" to define a large record in terms of it's own fields is to do let self = MkRecord formula formula formula formula ... in, in each formula you can access self |
2023-10-24 20:08:43 +0200 | <EvanR> | its own fields* |
2023-10-24 20:08:46 +0200 | <EvanR> | itself |
2023-10-24 20:09:11 +0200 | <EvanR> | it's dangerously close to OOP |
2023-10-24 20:09:44 +0200 | <tomsmeding> | OOP without mutable fields? |
2023-10-24 20:09:55 +0200 | <EvanR> | well that was featured in Theory of Objects |
2023-10-24 20:09:58 +0200 | <tomsmeding> | bundle an IORef in there for state, _then_ you have OOP |
2023-10-24 20:10:04 +0200 | <EvanR> | objects which return an updated version of itself |
2023-10-24 20:10:10 +0200 | <monochrom> | Not very usable but it's legal. :) |
2023-10-24 20:10:36 +0200 | <EvanR> | you can encode a state machine for example |
2023-10-24 20:12:56 +0200 | <EvanR> | even if self is not recursively creating new versions of itself, maybe it saves spaces defining terms because you don't need an additional where clause |
2023-10-24 20:14:06 +0200 | <Inst> | https://github.com/liamzee/big-book-of-small-haskell-projects/blob/master/11.ClickbaitHeadLineGene… |
2023-10-24 20:15:38 +0200 | <EvanR> | you could save a line and some space by using mapM_ instead of traverse_ there |
2023-10-24 20:16:02 +0200 | <Inst> | i just like traverse okay ;_; |
2023-10-24 20:16:30 +0200 | <Inst> | the only real need is to get rid of IO String :( |
2023-10-24 20:16:36 +0200 | <EvanR> | you're using OverloadedStrings but then everything is just String |
2023-10-24 20:17:19 +0200 | ChaiTRex | (~ChaiTRex@user/chaitrex) (Remote host closed the connection) |
2023-10-24 20:17:21 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:484c:e1ac:4235:81cd) (Remote host closed the connection) |
2023-10-24 20:17:37 +0200 | maxfan8 | (~max@2a01:4f8:192:5356::2) |
2023-10-24 20:17:46 +0200 | <EvanR> | you're using IO to get randomness, which is probably the easiest way unless you want to totally restructure the program |
2023-10-24 20:18:32 +0200 | Pickchea | (~private@user/pickchea) |
2023-10-24 20:18:50 +0200 | <Inst> | the problem is the semigroup used to get the string prototypes |
2023-10-24 20:18:51 +0200 | <EvanR> | *oops, you're using OverloadedStrings so you can use string literals as IO actions without putting `pure' |
2023-10-24 20:18:55 +0200 | <EvanR> | bad, gross |
2023-10-24 20:19:19 +0200 | <danse-nr3> | elevenkb, there is no industry, there is no career, look for a different language :P |
2023-10-24 20:19:46 +0200 | <elevenkb> | danse-nr3: sad! that's what i get for "avoiding popularity at all costs." |
2023-10-24 20:19:53 +0200 | <elevenkb> | there's always clojure tbqh. |
2023-10-24 20:19:57 +0200 | <elevenkb> | also looking at rust. |
2023-10-24 20:20:16 +0200 | <Inst> | Serokell is hiring, but they probably want senior engineers, from what I undesrtand from Clojure-land, it's all senior engineer positions |
2023-10-24 20:20:23 +0200 | <Inst> | Serokell is a Haskell firm |
2023-10-24 20:20:33 +0200 | <Inst> | Mercury hires juniors, but they prefer to hire non-Haskellers afaik |
2023-10-24 20:20:40 +0200 | <Inst> | and train them |
2023-10-24 20:20:43 +0200 | <[exa]> | Inst: why vectors there when you're only picking out a single item on each run? |
2023-10-24 20:20:56 +0200 | <Inst> | I am? :( |
2023-10-24 20:21:09 +0200 | <[exa]> | (as far as I understood it) |
2023-10-24 20:21:13 +0200 | <elevenkb> | if I could finish the last year of undergrad (which in my country is a separate degree with separate funding).... then maybe Standard Chartered would hire me. |
2023-10-24 20:21:17 +0200 | <[exa]> | (maybe I'm reading it wrong) |
2023-10-24 20:21:19 +0200 | ChaiTRex | (~ChaiTRex@user/chaitrex) |
2023-10-24 20:21:27 +0200 | <elevenkb> | i have a math + physics degree but only did 3/4 years of each. |
2023-10-24 20:21:32 +0200 | <Inst> | there's a replicateM_ somewhere |
2023-10-24 20:21:46 +0200 | <Inst> | on the inputLoop |
2023-10-24 20:22:02 +0200 | <monochrom> | I am doubtful (without checking, heh) that Rust has more jobs than Haskell. |
2023-10-24 20:22:12 +0200 | <elevenkb> | Inst: thanks for the pointers. |
2023-10-24 20:22:26 +0200 | <EvanR> | even if you select 10 things from the vectors each run, the vectors probably aren't helping over list |
2023-10-24 20:22:39 +0200 | <EvanR> | with the size of those lists |
2023-10-24 20:22:58 +0200 | <monochrom> | Oh! Is this NeoHaskell? :) |
2023-10-24 20:23:02 +0200 | <Inst> | Rust should, afaik, it's picked up, lots of mainstream companies want Rustacaeans |
2023-10-24 20:23:06 +0200 | <EvanR> | oof |
2023-10-24 20:23:29 +0200 | <monochrom> | You know, "use vector instead of []" |
2023-10-24 20:23:43 +0200 | <Inst> | idgi, I have a V.! somewhere |
2023-10-24 20:23:59 +0200 | <Inst> | O(n) vs O(1) even for very small quantities |
2023-10-24 20:24:06 +0200 | Chai-T-Rex | (~ChaiTRex@user/chaitrex) |
2023-10-24 20:24:17 +0200 | <Inst> | you can, in theory, ask for 10k clickbait titles |
2023-10-24 20:24:18 +0200 | <EvanR> | uh |
2023-10-24 20:24:48 +0200 | <Unicorn_Princess> | O(sqrt n), due to speed of light and planar memory architecture |
2023-10-24 20:25:07 +0200 | <monochrom> | "we don't talk about that" :) |
2023-10-24 20:25:15 +0200 | <EvanR> | depends on how small the speed of light is |
2023-10-24 20:25:20 +0200 | <EvanR> | is it very small |
2023-10-24 20:25:27 +0200 | ChaiTRex | (~ChaiTRex@user/chaitrex) (Remote host closed the connection) |
2023-10-24 20:25:36 +0200 | <monochrom> | Large enough so that: |
2023-10-24 20:25:42 +0200 | <monochrom> | @quote monochrom einstein |
2023-10-24 20:25:42 +0200 | <lambdabot> | monochrom says: einstein's theory implies that haskell cannot be faster than c |
2023-10-24 20:27:16 +0200 | <Inst> | so, wait, should I be using list instead of vector at this scale? |
2023-10-24 20:27:23 +0200 | <Inst> | because the O(n) operations will add up eventually |
2023-10-24 20:27:43 +0200 | <Inst> | then again, it's probably the randomness interface that's really causing the problem |
2023-10-24 20:27:53 +0200 | <monochrom> | To be honest, I haven't checked carefully enough to say. Was just tangentials. |
2023-10-24 20:28:18 +0200 | <EvanR> | looking up words from a list of 10 words probably isn't the bottleneck |
2023-10-24 20:28:22 +0200 | <monochrom> | However, in general, there is >70% chance the beginner makes the wrong choice. |
2023-10-24 20:29:06 +0200 | <Inst> | it's the print to screen that's the problem, nad for this to be actually useful, you'd want it to print to disk |
2023-10-24 20:29:48 +0200 | <Inst> | tbh, I should just convert everything to Text instead |
2023-10-24 20:30:14 +0200 | <EvanR> | before optimizing I would go over it with a style, understandability, idiomaticness pass |
2023-10-24 20:30:32 +0200 | <EvanR> | like IsString to do pure "foo" is silly |
2023-10-24 20:31:34 +0200 | <EvanR> | esp if it's "a book" that people will look at and try to convince me haskell sucks later because of xD |
2023-10-24 20:31:53 +0200 | <Inst> | well, it's just an adaptation of someone else's book |
2023-10-24 20:32:19 +0200 | <Inst> | what is really wrong with IsString, other than it's in IO? |
2023-10-24 20:32:21 +0200 | <EvanR> | accomplishing the same goal as the other book is one thing, doing it in a weird way without a disclaimer is another |
2023-10-24 20:32:26 +0200 | <Inst> | I mean, I was more thinking about wrapping IO in something else |
2023-10-24 20:32:42 +0200 | <EvanR> | IO goes at the outside the program not the deepest level |
2023-10-24 20:33:18 +0200 | <Inst> | I'm familiar with the general "Imperative Shell, Functional Core" model |
2023-10-24 20:33:42 +0200 | <Inst> | Let me go unhide my ... ummm, code of highly inferior quality, that is unreadable because of inept performance optimization |
2023-10-24 20:34:29 +0200 | <EvanR> | yeah "it has to be this way because performance" might be valid at some point but not this point |
2023-10-24 20:35:10 +0200 | <Inst> | https://github.com/liamzee/ThatsTornIt |
2023-10-24 20:35:23 +0200 | <Inst> | sloc 1750 lines, parallelized, albeit not well :( |
2023-10-24 20:35:37 +0200 | <Inst> | takes 4 hours, or is it 20, to run? |
2023-10-24 20:36:04 +0200 | <Inst> | if you're talking about a purity issue: |
2023-10-24 20:36:04 +0200 | <Inst> | https://github.com/liamzee/ThatsTornIt/blob/master/app/Main.hs |
2023-10-24 20:36:08 +0200 | <Inst> | that is all the IO it does |
2023-10-24 20:36:52 +0200 | <Inst> | so it should be like, what, 99% out of IO? |
2023-10-24 20:37:50 +0200 | <[exa]> | let's make a specialized monad for this problem! |
2023-10-24 20:37:54 +0200 | <EvanR> | on the multiple nested wheres full of functions, be on the look out for inner functions which don't close over anything and might be genuinely useful and so pulled out to the top level |
2023-10-24 20:38:16 +0200 | <[exa]> | (spoiler: only needs a specialized monoid) |
2023-10-24 20:39:12 +0200 | <Inst> | EvanR: that old project was where I developed the where abuse habit |
2023-10-24 20:39:34 +0200 | <Unicorn_Princess> | i've narrowed it down. to make a local package (as in https://cabal.readthedocs.io/en/stable/config.html#local-no-index-repositories) usable by `cabal repl`, one must 1) place the .tar.gz package into the repository, and 2) `cabal build` a project that depends on this package. what is it that `cabal build` does that makes packages usable from the repl? |
2023-10-24 20:39:39 +0200 | <Inst> | because I was chasing performance, and I built all the closures to avoid having to pass data via functions |
2023-10-24 20:40:22 +0200 | <EvanR> | if it doesn't close over anything it's likely you didn't build a closure at all |
2023-10-24 20:40:37 +0200 | <EvanR> | probably gets lifted out by ghc for you |
2023-10-24 20:40:47 +0200 | <Inst> | are we talking about ThatsTornIt or my current toy? |
2023-10-24 20:40:53 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
2023-10-24 20:41:21 +0200 | <Unicorn_Princess> | (`cabal update` didn't help) |
2023-10-24 20:41:35 +0200 | <EvanR> | I saw 100 multi-nested wheres and then recalled your 2D maze runner |
2023-10-24 20:43:08 +0200 | travgm | (~travgm@2600:100e:a121:4094:f9fb:7cac:5660:4910) |
2023-10-24 20:43:09 +0200 | travgm | (~travgm@2600:100e:a121:4094:f9fb:7cac:5660:4910) (Changing host) |
2023-10-24 20:43:09 +0200 | travgm | (~travgm@fsf/member/travgm) |
2023-10-24 20:43:24 +0200 | <monochrom> | Unicorn_Princess: Interesting. You're right. Darn. |
2023-10-24 20:43:47 +0200 | <Inst> | in the 2D maze runner, the closures are more used as a means of code organization |
2023-10-24 20:43:50 +0200 | <Inst> | i.e, "poor man's object" |
2023-10-24 20:44:19 +0200 | <haskellbridge> | <sm> beware.. such things can make debugging hard |
2023-10-24 20:44:35 +0200 | <Inst> | the structure was, more, it takes 400 ms on an old Xeon workstation processor (v5 1505) to process the single data, but when it's computing splits in Blackjack |
2023-10-24 20:44:46 +0200 | <EvanR> | by default you should put such functions at the top level so at least you can test them in ghci |
2023-10-24 20:44:47 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:484c:e1ac:4235:81cd) |
2023-10-24 20:45:39 +0200 | <Inst> | yeah that was why I was looking for wherez (TH to drag out where clauses and convert terms there into arguments) for this kind of testing use, except that reify is still broken :( |
2023-10-24 20:46:01 +0200 | <Inst> | it takes about 25 ms per evaluation within the closure, though |
2023-10-24 20:47:00 +0200 | <Inst> | welp, that doesn't make sense, iirc, it should be evaluating about 100m base conditions, and the TTI is horrible code, as in, it takes up around 48 gb of ram to run :( |
2023-10-24 20:47:38 +0200 | <EvanR> | I wouldn't jump to conclusions about whether passing values normally or through a closure is faster. Unless you're using the closure as a sort of cache |
2023-10-24 20:47:51 +0200 | <Inst> | as a sort of cache? |
2023-10-24 20:48:15 +0200 | <EvanR> | saving an evaluated value to be used many times |
2023-10-24 20:49:12 +0200 | <Inst> | yup :) |
2023-10-24 20:49:28 +0200 | <monochrom> | Unicorn_Princess: Err no, -b works. I wonder if you just had a syntax error (I did). -bfoo-0.1 would be wrong syntax, -b'foo>=0.1' (for example) would be right. |
2023-10-24 20:49:46 +0200 | <Inst> | hmmm, easy way to fix the Maze is just to drag out State Stdgen, no? |
2023-10-24 20:50:28 +0200 | <Unicorn_Princess> | -b? -b where, to what? also no syntax error - i repeated the exact same text line in the repl to load it, by going back in history with up-arrow |
2023-10-24 20:51:12 +0200 | <Unicorn_Princess> | ah, `cabal repl -b'thenewpackage'`? |
2023-10-24 20:51:19 +0200 | <monochrom> | cabal repl -b'foo >= 0.1' |
2023-10-24 20:51:29 +0200 | AlexZenon | (~alzenon@178.34.162.116) (Ping timeout: 255 seconds) |
2023-10-24 20:51:42 +0200 | <Unicorn_Princess> | yeah i did it via `:set -package foo` once inside the repl |
2023-10-24 20:51:54 +0200 | <EvanR> | Inst, what is wrong with the maze and why is StdGen involved |
2023-10-24 20:53:27 +0200 | <monochrom> | Oh derp! I just realized that I forgot the meaning of PVP. I had a version number 0.5.1 but it should be 0.5.0.1. :) |
2023-10-24 20:53:53 +0200 | <Unicorn_Princess> | so what does -b do? `cabal help b` says unrecognized command |
2023-10-24 20:54:13 +0200 | <geekosaur> | -b is not a command, it's an option. short for --build-depends |
2023-10-24 20:54:23 +0200 | <monochrom> | cabal repl --help |
2023-10-24 20:54:40 +0200 | <Inst> | erm, not Maze |
2023-10-24 20:54:46 +0200 | <Inst> | the Clickbait gen |
2023-10-24 20:55:02 +0200 | <geekosaur> | also yes, you can defeat sandboxing with -package. you get to keep alll the pieces if this gets you a diamond dependency or etc, |
2023-10-24 20:55:30 +0200 | <EvanR> | yeah the maze and the clickbait as it stands can probably be greatly deflated |
2023-10-24 20:55:30 +0200 | <Unicorn_Princess> | ah i see. the .tar.gz files in the repository contain only source |
2023-10-24 20:55:51 +0200 | <geekosaur> | ideally cabal will build it for you if you have the build depends right |
2023-10-24 20:55:53 +0200 | <Inst> | why do you think clickbait can be deflated? |
2023-10-24 20:55:57 +0200 | <Inst> | I already tried cleaning it up a few times |
2023-10-24 20:55:58 +0200 | <Inst> | :( |
2023-10-24 20:56:26 +0200 | <Unicorn_Princess> | geekosaur, also what do you mean 'yes'? are you under the illusion i knew what i was doing when i did :set -package foo? |
2023-10-24 20:56:34 +0200 | <rgw> | i'm curious, how did people in here get started with haskell? |
2023-10-24 20:57:12 +0200 | <danse-nr3> | rgw, how did you? |
2023-10-24 20:57:21 +0200 | <monochrom> | I was on comp.lang.functional and kept hearing about Haskell. |
2023-10-24 20:57:30 +0200 | <rgw> | programming in haskell by hutton (2nd ed) |
2023-10-24 20:57:31 +0200 | <geekosaur> | rgw, the Gentle Introduction back in late 2006 |
2023-10-24 20:57:33 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
2023-10-24 20:57:47 +0200 | <geekosaur> | after hearing about it as staff at Carnegie Mellon |
2023-10-24 20:57:53 +0200 | <rgw> | saw the youtube lessons first, went to the book halfway through |
2023-10-24 20:57:53 +0200 | <monochrom> | I liked SML so I went to comp.lang.functional |
2023-10-24 20:57:55 +0200 | <geekosaur> | then got sucked in by xmonad 🙂 |
2023-10-24 20:58:11 +0200 | AlexZenon | (~alzenon@178.34.162.116) |
2023-10-24 20:58:15 +0200 | <monochrom> | I heard of SML from the theorem prover HOL4. |
2023-10-24 20:58:20 +0200 | <danse-nr3> | "the book"? Haskell has a bible now |
2023-10-24 20:58:31 +0200 | <rgw> | read through the latter parts of learn you a haskell |
2023-10-24 20:58:41 +0200 | <monochrom> | I needed HOL4 because I was doing formal methods, albeit for imperative programming. |
2023-10-24 20:59:12 +0200 | <monochrom> | But I liked Lisp a bit too, even before that. |
2023-10-24 20:59:33 +0200 | <monochrom> | Scheme is objectively better but I hadn't heard of it back then. |
2023-10-24 21:00:00 +0200 | <yushyin> | rgw: script from classes at university |
2023-10-24 21:00:04 +0200 | <rgw> | danse-nr3, i meant the book by hutton, he has a class on youtube as weell |
2023-10-24 21:00:11 +0200 | <rgw> | the book is more indepth |
2023-10-24 21:00:24 +0200 | <monochrom> | I joined formal methods because I was tired of off-by-1 errors etc. |
2023-10-24 21:00:38 +0200 | <danse-nr3> | i see thanks for the explanation |
2023-10-24 21:00:59 +0200 | <rgw> | i think it has its problems, but it was a nice introduction |
2023-10-24 21:01:31 +0200 | <monochrom> | Oh! You mean the first tutorials. OK Gentle for me too. |
2023-10-24 21:01:56 +0200 | <rgw> | did you just jump into programming with it right after? |
2023-10-24 21:02:24 +0200 | <monochrom> | No. |
2023-10-24 21:02:41 +0200 | <monochrom> | But I never jumped into programming right after, for any language. |
2023-10-24 21:02:54 +0200 | <monochrom> | Unless "20 lines" counts. |
2023-10-24 21:03:11 +0200 | sm | (~sm@plaintextaccounting/sm) (Quit: sm) |
2023-10-24 21:03:23 +0200 | <monochrom> | Not for BASIC. Not for C. Not for Pascal. Not for Perl. |
2023-10-24 21:03:24 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:484c:e1ac:4235:81cd) (Read error: Connection reset by peer) |
2023-10-24 21:03:36 +0200 | <rgw> | so what then? |
2023-10-24 21:03:56 +0200 | <monochrom> | Incubating myself until I can write real code? |
2023-10-24 21:04:15 +0200 | <rgw> | well, i mean what does that look like? |
2023-10-24 21:04:55 +0200 | <monochrom> | https://norvig.com/21-days.html |
2023-10-24 21:05:49 +0200 | <monochrom> | It looks like I can build small things but not quite big things. |
2023-10-24 21:05:56 +0200 | azimut_ | (~azimut@gateway/tor-sasl/azimut) |
2023-10-24 21:05:59 +0200 | <geekosaur> | I jumped straight into C and Perl, went more slowly into other languages |
2023-10-24 21:06:02 +0200 | azimut | (~azimut@gateway/tor-sasl/azimut) (Ping timeout: 256 seconds) |
2023-10-24 21:06:04 +0200 | <monochrom> | But it grows every day. (Or I grow every day.) |
2023-10-24 21:06:11 +0200 | yaroot | (~yaroot@p3477236-ipngn9802souka.saitama.ocn.ne.jp) (Read error: Connection reset by peer) |
2023-10-24 21:06:30 +0200 | <rgw> | well, i think haskell is different in that way |
2023-10-24 21:06:31 +0200 | dcoutts_ | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Remote host closed the connection) |
2023-10-24 21:06:35 +0200 | <danse-nr3> | makes sense for a single author to build small things. Teams build big things |
2023-10-24 21:06:35 +0200 | yaroot | (~yaroot@2400:4052:ac0:d900:1cf4:2aff:fe51:c04c) |
2023-10-24 21:06:38 +0200 | <monochrom> | I simply don't feel the rush to "I need to write 3kloc now. If I can't it's the fault of the tutorial." |
2023-10-24 21:06:41 +0200 | <rgw> | i don't think many people are 'forced' to learn haskell to use it *now* |
2023-10-24 21:06:48 +0200 | <Inst> | hmmm, this actually isn't so bad |
2023-10-24 21:06:52 +0200 | azimut_ | (~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection) |
2023-10-24 21:06:52 +0200 | dcoutts_ | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) |
2023-10-24 21:07:10 +0200 | azimut | (~azimut@gateway/tor-sasl/azimut) |
2023-10-24 21:07:57 +0200 | <Inst> | i can relatively easily refactor all my code to use a state generator inside the state monadic type instead of using IO |
2023-10-24 21:07:58 +0200 | <rgw> | (also why i think javascript gets a really bad rep) |
2023-10-24 21:08:01 +0200 | <Inst> | \o/ |
2023-10-24 21:08:04 +0200 | <danse-nr3> | when newcomers gets into an haskell projects, they might feel 'forced' to learn a lot *now* |
2023-10-24 21:08:51 +0200 | <Unicorn_Princess> | apologies for the wall of text. correct me if i'm wrong: because the .tar.gz repo contains only source, before the packages in it can be used they must be built. if a cabal package depends on them (as in lists them in its build-depends), it'll build them during its `cabal build` step, using whatever versions of transitive dependencies that work. to load those packages in the repl requires that they had already been built. so |
2023-10-24 21:08:51 +0200 | <Unicorn_Princess> | `:set -package mylocalpackage` in the repl tries to load built artefacts, and this only works if, by pure chance, those artifacts are compatible with whatever else the current repl is using. on the other hand, `cabal repl --build-depends'mylocalpackage'` will actually run cabal's resolver and build it if possible. so one must always use this method to guarantee the package can be used. did I get that right? |
2023-10-24 21:09:21 +0200 | <monochrom> | ghci ≠ cabal |
2023-10-24 21:09:47 +0200 | <monochrom> | :set belongs to ghci. It doesn't chase dependencies or auto-build. |
2023-10-24 21:10:18 +0200 | <Unicorn_Princess> | yes. i meant :set inside the ghci repl, launched via `cabal repl` |
2023-10-24 21:10:33 +0200 | <monochrom> | cabal repl is the one who makes sure the libraries are built, then ghci can just load them. |
2023-10-24 21:10:34 +0200 | waleee | (~waleee@2001:9b0:21c:e600:f2f3:f744:435d:137c) |
2023-10-24 21:11:12 +0200 | <EvanR> | rgw, it's basically somewhat crippled and bizarrely behaving-at-times scheme with C syntax, what's not to like |
2023-10-24 21:11:20 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
2023-10-24 21:11:39 +0200 | <monochrom> | But with cabal repl -b, you won't need :set -package |
2023-10-24 21:12:04 +0200 | <EvanR> | oh, without proper tail recursion |
2023-10-24 21:12:07 +0200 | <monochrom> | or rather, cabal repl -b already does that for you when it hands over to ghci |
2023-10-24 21:12:37 +0200 | <Unicorn_Princess> | it gives all the dependencies listed in -b over to ghci to include, right |
2023-10-24 21:12:51 +0200 | <Unicorn_Princess> | i.e. it doesn't just build them |
2023-10-24 21:13:34 +0200 | <rgw> | EvanR, that's what i mean, people see the c syntax and immediately assume they know what they're dealing with, instead of treating it like a new language |
2023-10-24 21:14:01 +0200 | <monochrom> | Add -v to see how many kloc of "-package foo" cabal repl gives to ghci :) |
2023-10-24 21:14:07 +0200 | <rgw> | i find having certain expectations can really ruin anything |
2023-10-24 21:14:32 +0200 | <EvanR> | a lot is said about the experience of complete noobs when trying to use technology X |
2023-10-24 21:14:46 +0200 | danse-nr3 | (~francesco@151.35.215.38) (Ping timeout: 260 seconds) |
2023-10-24 21:15:02 +0200 | <EvanR> | if most of your user base in complete noobs I guess that makes sense, but then there are other problems |
2023-10-24 21:15:27 +0200 | <Unicorn_Princess> | what's the syntax for -b/--build-depends if I want to give multiple packages? comma-separated? i.e. -b'foo,bar,baz'? and exact same for the --build-depends alias? |
2023-10-24 21:15:28 +0200 | <rgw> | i don't think anybody treats learning haskell the same as javascript |
2023-10-24 21:15:31 +0200 | <monochrom> | When I learn, I start with a clean slate. Almost no assumptions. Even could be said I set up a VM in my head. |
2023-10-24 21:15:39 +0200 | <EvanR> | more should be said about the competent experienced person doing real work experience |
2023-10-24 21:15:42 +0200 | <rgw> | yeah, i try to do the same |
2023-10-24 21:15:45 +0200 | <monochrom> | But I'm inhuman. It is not how humans learn. |
2023-10-24 21:15:51 +0200 | <monochrom> | Well so down with humans. |
2023-10-24 21:16:10 +0200 | <rgw> | it's just pattern recognition gone wild i think |
2023-10-24 21:16:23 +0200 | <monochrom> | No. |
2023-10-24 21:16:34 +0200 | <monochrom> | Humans want to claim credits without doing the work. |
2023-10-24 21:16:38 +0200 | <rgw> | your brain thinks it's seen it already before, so doesn't want to learn it again |
2023-10-24 21:16:57 +0200 | <EvanR> | something about how C syntax is required for language success, regardless of semantics. If that's the case, your concerns aren't well founded? xD |
2023-10-24 21:17:34 +0200 | <EvanR> | somehow "pseudo code" looks nothing like C and is very persistent |
2023-10-24 21:17:43 +0200 | <monochrom> | So as a special case, it would be really nice if one assumes that the thing to learn is just the same as what they already know, therefore there is nothing new to learn, therefore can claim "I learned this!" without working. |
2023-10-24 21:18:07 +0200 | <monochrom> | Just look at average programmers' CVs. |
2023-10-24 21:18:30 +0200 | <rgw> | EvanR, who says C syntax is required for success? |
2023-10-24 21:18:47 +0200 | <EvanR> | it's a defacto law of programming languages, most corporate languages |
2023-10-24 21:19:09 +0200 | <monochrom> | Unicorn_Princess: Multiple -b's. :) |
2023-10-24 21:19:15 +0200 | Feuermagier | (~Feuermagi@user/feuermagier) (Ping timeout: 258 seconds) |
2023-10-24 21:19:30 +0200 | <rgw> | i thought you were referring to something i said |
2023-10-24 21:19:33 +0200 | <EvanR> | javascripts syntax was changed at the last minute, as the story goes |
2023-10-24 21:19:48 +0200 | <monochrom> | Hrm. I think I heard of that... |
2023-10-24 21:19:57 +0200 | <Rembane> | It was a scheme until then right? |
2023-10-24 21:20:30 +0200 | <EvanR> | if yes they also must had disabled proper tail recursion at the last minute xD |
2023-10-24 21:21:25 +0200 | <monochrom> | In general, to gain success in the usual sense, you exploit human flaws to your advantage, and recognize that technical objective merits are irrelevant. |
2023-10-24 21:21:56 +0200 | <Rembane> | EvanR: I would love JS with TCO. |
2023-10-24 21:22:35 +0200 | <EvanR> | I think that was one reason I got into haskell, JS couldn't do scheme-like recursion |
2023-10-24 21:23:00 +0200 | <EvanR> | didn't know how it applies in haskell yet, but I knew "it worked" |
2023-10-24 21:23:45 +0200 | <Unicorn_Princess> | monochrom, thanks |
2023-10-24 21:23:49 +0200 | <rgw> | if you're doing frontend things you kinda have to use js |
2023-10-24 21:24:26 +0200 | <monochrom> | Yeah, I think in the JS case, they had the monopoly in that domain, they could have used any syntax or even semantics they liked. |
2023-10-24 21:24:32 +0200 | <EvanR> | I would be ok with that, but now there's the latest framework of the week for typescript |
2023-10-24 21:25:12 +0200 | <rgw> | it all turns into javascript in the end |
2023-10-24 21:25:13 +0200 | <monochrom> | But the benefit of C syntax is reducing the chance of getting ridiculed as "not real programmers". Just look at Python and PHP. |
2023-10-24 21:25:13 +0200 | <EvanR> | so people are using whatever framework, and are vaguely aware of typescript, based on javascript |
2023-10-24 21:25:34 +0200 | <EvanR> | rgw, unless it's webasm |
2023-10-24 21:25:46 +0200 | <rgw> | yeah, if it ever gets traction |
2023-10-24 21:26:33 +0200 | <rgw> | and depends on how well chromium/firefox keep up with the implementation |
2023-10-24 21:26:52 +0200 | <EvanR> | yeah I can't wait to write the frontend in web asm |
2023-10-24 21:27:02 +0200 | <EvanR> | and the backend in rust |
2023-10-24 21:27:35 +0200 | <rgw> | i don't know how much i would actually want webasm to be successful |
2023-10-24 21:27:37 +0200 | <EvanR> | and the graphics in vulkan |
2023-10-24 21:27:44 +0200 | <rgw> | the average js code is already a mess |
2023-10-24 21:27:57 +0200 | <rgw> | and the potential exploits |
2023-10-24 21:28:44 +0200 | <rgw> | i'd honestly love it if pages could just go back to straight html if more functionality is not needed |
2023-10-24 21:30:50 +0200 | <darkling> | There's utterly ridiculous amounts of reinvention of the wheel going on in that ecosystem. |
2023-10-24 21:30:54 +0200 | <Inst> | that said EvanR |
2023-10-24 21:30:55 +0200 | <Inst> | https://github.com/liamzee/big-book-of-small-haskell-projects/blob/master/11.ClickbaitHeadLineGene… |
2023-10-24 21:30:59 +0200 | <Inst> | I'm much happier with the IO out |
2023-10-24 21:31:15 +0200 | <darkling> | So many things that there's an entire pile of JS/TS badly reimplementing basic functionality. |
2023-10-24 21:32:03 +0200 | <EvanR> | Inst, you seem to want to implement IsString any time you apply a function to a String |
2023-10-24 21:32:10 +0200 | <EvanR> | instead of just applying a function |
2023-10-24 21:32:30 +0200 | <rgw> | the whole node ecosystem is ridiculous |
2023-10-24 21:32:42 +0200 | <monochrom> | Web devs are given quad-head 4K screens, 500TB RAM, 200PB NVMe. They only have to impress their bosses, whose computers are 10x beefier. Do they ever have any incentive to save resources on their designs? |
2023-10-24 21:33:04 +0200 | <EvanR> | I think the intention for IsString is so you can use string literals for types which are... in some sense a string. Not random number generators or MD5 sums or rot13 |
2023-10-24 21:33:08 +0200 | <Inst> | Because the alternative is more verbose? |
2023-10-24 21:33:20 +0200 | <EvanR> | wrong place to eliminate the verbosity |
2023-10-24 21:33:37 +0200 | <monochrom> | Their bosses in turn are detached MBAs. Do they have incentives to care how it is like for the rest of us? |
2023-10-24 21:33:46 +0200 | <Inst> | the other idea I had was to set it up as Either a Text |
2023-10-24 21:34:13 +0200 | <Inst> | then have a function convert out the either a Foldable t => t (Either a Text) |
2023-10-24 21:34:56 +0200 | <EvanR> | you might be in a phase of "haskell has a thing, I should figure out a way to use it" |
2023-10-24 21:35:20 +0200 | <EvanR> | instead of taking the most direct route to the goal |
2023-10-24 21:35:45 +0200 | eggplantade | (~Eggplanta@2600:1700:38c5:d800:484c:e1ac:4235:81cd) |
2023-10-24 21:36:01 +0200 | <Inst> | the problem is, when I thought up the py, with uncontrolled effects and dynamic typing, the obvious was to clean it up was to create more data structures for prompts and responses |
2023-10-24 21:36:17 +0200 | <Inst> | then just index them |
2023-10-24 21:36:41 +0200 | <Inst> | in the original code, each of the headlines was a function |
2023-10-24 21:37:36 +0200 | <EvanR> | uncontrolled effects = everything is an IO action. That would be simpler than what you're doing. Dynamic types = the Dynamic type, which would be unidiomatic but would express any given insanely written python. If the python used sane types, then use those types in haskell |
2023-10-24 21:38:13 +0200 | <Inst> | tbh at the scripting scale I don't really see the problem with "everything in IO" |
2023-10-24 21:38:27 +0200 | <EvanR> | but a book using haskell for this should probably rethink all of it |
2023-10-24 21:38:49 +0200 | phma | (phma@2001:5b0:212a:ca38:321f:39d3:cfb3:6c89) (Read error: Connection reset by peer) |
2023-10-24 21:38:51 +0200 | <Inst> | it's less a book, and more an open project repository for people who want to translate or reimplement the Py versions |
2023-10-24 21:39:15 +0200 | <EvanR> | ideally less pythonically |
2023-10-24 21:39:16 +0200 | waleee | (~waleee@2001:9b0:21c:e600:f2f3:f744:435d:137c) (Ping timeout: 260 seconds) |
2023-10-24 21:39:32 +0200 | random-jellyfish | (~tiber@user/random-jellyfish) (Ping timeout: 255 seconds) |
2023-10-24 21:39:32 +0200 | michalz | (~michalz@185.246.207.221) (Remote host closed the connection) |
2023-10-24 21:39:37 +0200 | <Inst> | i think you'd take issue with rampant global variables, right? |
2023-10-24 21:39:42 +0200 | phma | (phma@2001:5b0:210f:1b08:8de9:836f:9645:4508) |
2023-10-24 21:39:46 +0200 | <Inst> | one thing I kept on thinking of was wrapping the globals as functions |
2023-10-24 21:40:14 +0200 | <Inst> | on the other hand, that kills the modularity |
2023-10-24 21:40:30 +0200 | <monochrom> | When in the context of teaching and learning, I take issue with doing things only one way. |
2023-10-24 21:41:05 +0200 | waleee | (~waleee@h-176-10-137-138.NA.cust.bahnhof.se) |
2023-10-24 21:41:10 +0200 | danza | (~francesco@151.35.215.38) |
2023-10-24 21:41:11 +0200 | <monochrom> | Learn doing it with global variables. Learn doing it without global variables. Learn the pros and cons. Now you have a larger toolbox. |
2023-10-24 21:41:36 +0200 | <Inst> | but what's the alternative to global variables? |
2023-10-24 21:41:46 +0200 | <EvanR> | I sometimes try to write a haskell program with global variables |
2023-10-24 21:41:50 +0200 | <EvanR> | it always ends up worse |
2023-10-24 21:42:04 +0200 | <monochrom> | Local variables. Passing parameters. Hell even objects. |
2023-10-24 21:42:09 +0200 | <Inst> | instinctively, what I'd want to do is to push the global variables into the closure |
2023-10-24 21:42:15 +0200 | <Inst> | of the headlines |
2023-10-24 21:42:31 +0200 | <ddellacosta> | I feel like I use ReaderT as basically a big bag of global variables |
2023-10-24 21:42:33 +0200 | <darkling> | Objects are just a slightly smaller scope to use global variables in. :) |
2023-10-24 21:43:36 +0200 | <darkling> | You still get the problems of shared but otherwise uncontrolled variable access between functions. |
2023-10-24 21:43:44 +0200 | <monochrom> | Recall that the OO people make a big fuss about "oriented" vs "based". You know what, "object-based" fits Haskell surprisingly well. |
2023-10-24 21:44:28 +0200 | <monochrom> | And OO people who are honest actually now have object-based tendencies instead, e.g., almost flat class hierarchy. |
2023-10-24 21:44:28 +0200 | <Inst> | readerT, heh |
2023-10-24 21:44:41 +0200 | danza_ | (~francesco@151.37.196.80) |
2023-10-24 21:44:44 +0200 | <EvanR> | makeObject x y z = self where self = MkObject ... ... ... |
2023-10-24 21:45:19 +0200 | <darkling> | One of these days, I'm going to learn Smalltalk and find out what proper OO is. :) |
2023-10-24 21:45:26 +0200 | <monochrom> | :) |
2023-10-24 21:46:00 +0200 | <darkling> | Although I've done a decent chunk of erlang, so maybe I've already got some of it. |
2023-10-24 21:46:24 +0200 | <Inst> | yes, because if we're honest about all of it, ADTs are just doubly immutable objects, unless you want them to be singly immutable :) |
2023-10-24 21:46:38 +0200 | <darkling> | (And my plan for this year's AoC is FORTH-79) |
2023-10-24 21:46:45 +0200 | <Inst> | well, values of an ADT :) |
2023-10-24 21:47:09 +0200 | danza | (~francesco@151.35.215.38) (Ping timeout: 245 seconds) |
2023-10-24 21:48:22 +0200 | <Inst> | tbh immutable probably doesn't even mean anything in a Haskell context, no? |
2023-10-24 21:49:07 +0200 | <EvanR> | look in the Data.Array docs you'll find two kinds of array, mutable and immutable |
2023-10-24 21:49:24 +0200 | <Inst> | same with Vector |
2023-10-24 21:49:57 +0200 | Chai-T-Rex | (~ChaiTRex@user/chaitrex) (Quit: Chai-T-Rex) |
2023-10-24 21:49:59 +0200 | <Inst> | my point is more that immutability is so pervasive in Haskell the concept loses meaning because it lacks an opposite to define itself by |
2023-10-24 21:50:37 +0200 | ChaiTRex | (~ChaiTRex@user/chaitrex) |
2023-10-24 21:50:54 +0200 | <Inst> | EvanR: but what would you suggest to put ClickbaitGen on a diet? |
2023-10-24 21:51:13 +0200 | <Inst> | all of the "let's do it right" or "use the correct abstractions" mechanisms bloat the code |
2023-10-24 21:52:57 +0200 | <EvanR> | use list, use String, use IO, use mapM_, use fmap isntead of <$>, remove the StateT, remove the Arrows, remove the Text, |
2023-10-24 21:53:06 +0200 | <EvanR> | instead of <&> |
2023-10-24 21:53:25 +0200 | <EvanR> | just if you want to reduce the size of code |
2023-10-24 21:53:25 +0200 | stiell_ | (~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection) |
2023-10-24 21:54:03 +0200 | stiell_ | (~stiell@gateway/tor-sasl/stiell) |
2023-10-24 21:54:15 +0200 | <Inst> | sigh :( |
2023-10-24 21:54:19 +0200 | <EvanR> | maybe in a separate "vanilla" file |
2023-10-24 21:54:25 +0200 | acidjnk_new | (~acidjnk@p200300d6e72b9364ac51bf6edb979c24.dip0.t-ipconnect.de) (Ping timeout: 252 seconds) |
2023-10-24 21:55:02 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
2023-10-24 21:55:04 +0200 | <Inst> | I didn't realize that mapM_ was more idiomatic than traverse_ |
2023-10-24 21:55:11 +0200 | <EvanR> | IsString paraphenalia is taking up more space than it is saving, even if it wasn't also questionably using IsString |
2023-10-24 21:55:20 +0200 | <Inst> | the plus side is that it's exposed on prelude |
2023-10-24 21:55:23 +0200 | <EvanR> | it's just that mapM_ doesn't require an import |
2023-10-24 21:55:47 +0200 | <int-e> | mapM_ has also been around for way longer than traverse_ |
2023-10-24 21:55:57 +0200 | <Inst> | it's restricted to monad, but tbh, the concept is nice, apparently in a lot of mainstream languages they don't use a map(f,literal) idiom to trigger effects |
2023-10-24 21:56:02 +0200 | <Inst> | it's usually literal.map(f) |
2023-10-24 21:56:46 +0200 | <Inst> | mapM_ is restricted to monad, though |
2023-10-24 21:56:54 +0200 | <EvanR> | which is where you are using it |
2023-10-24 21:56:57 +0200 | <Inst> | I got trained to use <> instead of ++ |
2023-10-24 21:57:06 +0200 | <EvanR> | <> also works on list |
2023-10-24 21:57:11 +0200 | <EvanR> | and is in prelude |
2023-10-24 21:57:16 +0200 | <Inst> | I know, only case where it doesn't work |
2023-10-24 21:57:21 +0200 | <Inst> | is when <> has the wrong precedence |
2023-10-24 21:57:26 +0200 | <Inst> | ++ works well with : |
2023-10-24 21:57:43 +0200 | <EvanR> | > [1,2,3] <> repeat 4 |
2023-10-24 21:57:44 +0200 | <Inst> | how else would you do the list / vector of headlines? |
2023-10-24 21:57:45 +0200 | <lambdabot> | [1,2,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4... |
2023-10-24 21:57:56 +0200 | <EvanR> | > ([1,2,3] <> repeat 4) <> repeat 5 |
2023-10-24 21:57:57 +0200 | <lambdabot> | [1,2,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4... |
2023-10-24 21:58:00 +0200 | <EvanR> | hmm |
2023-10-24 21:58:03 +0200 | <Inst> | hmmm, you could write it as a list |
2023-10-24 21:58:07 +0200 | <Inst> | but then again, that's isString abuse |
2023-10-24 21:58:11 +0200 | <Inst> | write is as a list, fold |
2023-10-24 21:58:19 +0200 | <EvanR> | make a list of strings |
2023-10-24 22:01:35 +0200 | <int-e> | . o O ( a tangle ) |
2023-10-24 22:02:37 +0200 | sord937 | (~sord937@gateway/tor-sasl/sord937) (Quit: sord937) |
2023-10-24 22:03:48 +0200 | eL_Bart0 | (eL_Bart0@dietunichtguten.org) (Ping timeout: 240 seconds) |
2023-10-24 22:04:03 +0200 | eL_Bart0 | (eL_Bart0@dietunichtguten.org) |
2023-10-24 22:04:21 +0200 | dcoutts_ | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 260 seconds) |
2023-10-24 22:04:48 +0200 | <Inst> | ugh, here's the interesting problem, i have do notation literals |
2023-10-24 22:04:53 +0200 | <Inst> | ffff, type accounting :( |
2023-10-24 22:05:03 +0200 | _ht | (~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht) |
2023-10-24 22:05:33 +0200 | <EvanR> | what's a do notation literal |
2023-10-24 22:06:05 +0200 | <Inst> | i stuffed do notation into a list of strings |
2023-10-24 22:07:51 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
2023-10-24 22:08:01 +0200 | <Inst> | i literally have if then else in lists in a conway program |
2023-10-24 22:08:20 +0200 | <Inst> | [ foo | True] <> ... might actually work better there |
2023-10-24 22:08:20 +0200 | <EvanR> | there is nothing wrong with that |
2023-10-24 22:08:39 +0200 | <Inst> | the problem is that it screws up the list's typing |
2023-10-24 22:09:30 +0200 | idgaen | (~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.0.5) |
2023-10-24 22:10:35 +0200 | <Inst> | because part of the Vector is in [RndState a], other parts are in... oh wait, sequence :D |
2023-10-24 22:11:26 +0200 | _xor | (~xor@72.49.199.93) (Read error: Connection reset by peer) |
2023-10-24 22:11:58 +0200 | _xor | (~xor@72.49.199.93) |
2023-10-24 22:12:09 +0200 | danza_ | (~francesco@151.37.196.80) (Ping timeout: 258 seconds) |
2023-10-24 22:13:16 +0200 | <EvanR> | list and Vector both can only have 1 element type, uniform throughout, there's no part this part that |
2023-10-24 22:16:13 +0200 | <Inst> | i know, but i wrote the literals in a certain fashion |
2023-10-24 22:16:26 +0200 | <Inst> | i also know of others who prefer fold over a list of strings / text |
2023-10-24 22:21:10 +0200 | Pickchea | (~private@user/pickchea) (Quit: Leaving) |
2023-10-24 22:25:02 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
2023-10-24 22:37:55 +0200 | <Unicorn_Princess> | starting a repl with `cabal repl -bsomepackage` takes a few seconds to resolve dependencies and such. is there a way to speed it up? |
2023-10-24 22:38:05 +0200 | yoyofreeman | (~yoyofreem@176.97.76.178) |
2023-10-24 22:38:12 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
2023-10-24 22:38:29 +0200 | <Unicorn_Princess> | (even without the -b it's not that fast compared to bare ghci) |
2023-10-24 22:38:39 +0200 | <geekosaur> | the main slowdown is parsing pkg-config output for use in the solver, there's work going on to cache that instead of redoing it every time |
2023-10-24 22:39:40 +0200 | <geekosaur> | https://github.com/haskell/cabal/pull/9360 |
2023-10-24 22:39:55 +0200 | <Unicorn_Princess> | and if i didn't need the flexibility? like, compile my own variant of ghci that has the extra modules pre-loaded? |
2023-10-24 22:40:04 +0200 | mrmonday | (~robert@what.i.hope.is.not.a.tabernaevagant.es) (Quit: .) |
2023-10-24 22:40:33 +0200 | <geekosaur> | one of us is not talking about the same thing… |
2023-10-24 22:40:51 +0200 | <Unicorn_Princess> | or both of us ;) |
2023-10-24 22:41:38 +0200 | <geekosaur> | the solver's still going to run since that's much of the point of cabal. and the solver still needs to know about pkg-config because C package availability and versions can affect solver plans |
2023-10-24 22:41:52 +0200 | mrmonday | (~robert@what.i.hope.is.not.a.tabernaevagant.es) |
2023-10-24 22:42:03 +0200 | <geekosaur> | building your own ghci will not help with this (and may not help at all since ghci is ghc --interactive) |
2023-10-24 22:42:09 +0200 | <Unicorn_Princess> | well my goal is to get ghci going with a few extra libraries loaded - libraries i know ahead of time. i could recompile the wholething if the libraries changed |
2023-10-24 22:42:31 +0200 | <Unicorn_Princess> | s/if/when |
2023-10-24 22:44:14 +0200 | <Unicorn_Princess> | well, i guess i can live with the slowdown |
2023-10-24 22:50:04 +0200 | <Square> | is there a way to specify what import should be done when starting a repl using cabal? |
2023-10-24 22:50:10 +0200 | <Square> | imports* |
2023-10-24 22:50:33 +0200 | <Square> | ...so you don't have to start every session importing things. |
2023-10-24 22:51:35 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
2023-10-24 22:52:33 +0200 | <geekosaur> | .ghci file? |
2023-10-24 22:52:58 +0200 | <geekosaur> | https://downloads.haskell.org/ghc/9.8.1/docs/users_guide/ghci.html#the-ghci-files |
2023-10-24 22:53:37 +0200 | <Square> | oh nice. thanks |
2023-10-24 22:55:39 +0200 | John_Ivan_ | (~John_Ivan@user/john-ivan/x-1515935) |
2023-10-24 22:56:29 +0200 | CiaoSen | (~Jura@2a05:5800:2a5:2200:664b:f0ff:fe37:9ef) (Ping timeout: 255 seconds) |
2023-10-24 22:56:59 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) |
2023-10-24 22:57:20 +0200 | emmanuelux | (~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer) |
2023-10-24 22:58:43 +0200 | danza_ | (~francesco@151.37.194.27) |
2023-10-24 22:58:46 +0200 | John_Ivan | (~John_Ivan@user/john-ivan/x-1515935) (Ping timeout: 252 seconds) |
2023-10-24 22:59:18 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer) |
2023-10-24 22:59:28 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) |
2023-10-24 23:00:46 +0200 | danse-nr3 | (~francesco@151.37.194.27) |
2023-10-24 23:01:04 +0200 | Guest5 | (~Guest5@5-157-196-109.itvmedia.pl) |
2023-10-24 23:03:14 +0200 | travgm | (~travgm@fsf/member/travgm) (Read error: Connection reset by peer) |
2023-10-24 23:03:20 +0200 | azimut | (~azimut@gateway/tor-sasl/azimut) (Ping timeout: 256 seconds) |
2023-10-24 23:04:40 +0200 | emmanuelux_ | (~emmanuelu@user/emmanuelux) (Quit: au revoir) |
2023-10-24 23:09:10 +0200 | Guest5 | (~Guest5@5-157-196-109.itvmedia.pl) (Quit: Client closed) |
2023-10-24 23:11:51 +0200 | Square | (~Square@user/square) (Read error: Connection reset by peer) |
2023-10-24 23:12:29 +0200 | Square3 | (~Square4@user/square) |
2023-10-24 23:12:59 +0200 | takuan | (~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection) |
2023-10-24 23:15:44 +0200 | dcoutts_ | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) |
2023-10-24 23:16:22 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) |
2023-10-24 23:18:32 +0200 | danse-nr3 | (~francesco@151.37.194.27) (Ping timeout: 255 seconds) |
2023-10-24 23:19:25 +0200 | fendor | (~fendor@2a02:8388:1640:be00:aab:1226:f274:5021) (Remote host closed the connection) |
2023-10-24 23:21:20 +0200 | nate2 | (~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds) |
2023-10-24 23:22:18 +0200 | danza_ | (~francesco@151.37.194.27) (Ping timeout: 258 seconds) |
2023-10-24 23:26:43 +0200 | [itchyjunk] | (~itchyjunk@user/itchyjunk/x-7353470) |
2023-10-24 23:35:40 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
2023-10-24 23:42:20 +0200 | coot | (~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot) |
2023-10-24 23:42:55 +0200 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
2023-10-24 23:42:56 +0200 | Guest74 | (~Guest75@5-157-196-109.itvmedia.pl) |
2023-10-24 23:43:42 +0200 | vglfr | (~vglfr@88.155.140.136) (Read error: Connection reset by peer) |
2023-10-24 23:44:06 +0200 | <Guest74> | hi. is there any way to search the logs (https://ircbrowse.tomsmeding.com/browse/lchaskell) for messages by specific nickname? |
2023-10-24 23:45:01 +0200 | krit | (~krit@072-238-128-073.res.spectrum.com) |
2023-10-24 23:46:23 +0200 | <geekosaur> | not currently, search functionality is disabled because it requires full-text indexing as currently implemented and nobody has cycles to rewrite it |
2023-10-24 23:47:12 +0200 | krit | (~krit@072-238-128-073.res.spectrum.com) (Client Quit) |
2023-10-24 23:50:09 +0200 | <Guest74> | i see, i was just interested in messages by specific user, thanks |
2023-10-24 23:52:50 +0200 | suntzu | (~krit@072-238-128-073.res.spectrum.com) |
2023-10-24 23:53:17 +0200 | suntzu | (~krit@072-238-128-073.res.spectrum.com) (Client Quit) |
2023-10-24 23:55:52 +0200 | emmanuelux | (~emmanuelu@user/emmanuelux) |