IRCBrowse

2023/10/24

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 +0200Pickchea(~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 +0200sord937(~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 +0200yoyofreeman(~yoyofreem@176.97.76.178)
2023-10-24 00:08:37 +0200yoyofreeman(~yoyofreem@176.97.76.178) (Max SendQ exceeded)
2023-10-24 00:09:18 +0200yoyofreeman(~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 +0200acidjnk_new(~acidjnk@p200300d6e72b935208de20f4829382c8.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-10-24 00:10:20 +0200falafel(~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 +0200gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2023-10-24 00:14:05 +0200target_i(~target_i@217.175.14.39) (Quit: leaving)
2023-10-24 00:14:12 +0200Sgeo(~Sgeo@user/sgeo)
2023-10-24 00:15:00 +0200notzmv(~zmv@user/notzmv) (Ping timeout: 240 seconds)
2023-10-24 00:19:31 +0200vglfr(~vglfr@88.155.140.136) (Read error: Connection reset by peer)
2023-10-24 00:21:52 +0200Lycurgus(~georg@user/Lycurgus)
2023-10-24 00:26:08 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-10-24 00:32:41 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-10-24 00:34:12 +0200falafel(~falafel@62.175.113.194.dyn.user.ono.com) (Ping timeout: 240 seconds)
2023-10-24 00:35:13 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-10-24 00:37:10 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-10-24 00:39:18 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Client Quit)
2023-10-24 00:40:29 +0200Lycurgus(~georg@user/Lycurgus) (Quit: leaving)
2023-10-24 00:51:28 +0200Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-10-24 00:54:39 +0200Square(~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 +0200random-jellyfish(~tiber@2a02:2f04:11e:c600:d86:8764:b7a3:4444)
2023-10-24 01:04:14 +0200random-jellyfish(~tiber@2a02:2f04:11e:c600:d86:8764:b7a3:4444) (Changing host)
2023-10-24 01:04:14 +0200random-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 +0200chomwitt(~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 +0200falafel(~falafel@62.175.113.194.dyn.user.ono.com)
2023-10-24 01:09:46 +0200random-jellyfish(~tiber@user/random-jellyfish) (Ping timeout: 252 seconds)
2023-10-24 01:10:26 +0200arahael(~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net)
2023-10-24 01:14:47 +0200aljazmc_(~aljazmc@user/aljazmc)
2023-10-24 01:15:15 +0200dcoutts_(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-10-24 01:16:54 +0200aljazmc(~aljazmc@user/aljazmc) (Remote host closed the connection)
2023-10-24 01:17:27 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 240 seconds)
2023-10-24 01:19:30 +0200JuanDaugherty(~juan@user/JuanDaugherty)
2023-10-24 01:24:25 +0200chomwitt(~chomwitt@2a02:587:7a1a:8700:1ac0:4dff:fedb:a3f1)
2023-10-24 01:26:42 +0200Lycurgus(~georg@user/Lycurgus)
2023-10-24 01:29:00 +0200chomwitt(~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 +0200falafel(~falafel@62.175.113.194.dyn.user.ono.com) (Ping timeout: 255 seconds)
2023-10-24 01:33:11 +0200emmanuelux(~emmanuelu@user/emmanuelux) (Ping timeout: 255 seconds)
2023-10-24 01:38:26 +0200emmanuelux(~emmanuelu@user/emmanuelux)
2023-10-24 01:39:48 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Ping timeout: 240 seconds)
2023-10-24 01:40:28 +0200JuanDaugherty(~juan@user/JuanDaugherty) (Quit: JuanDaugherty)
2023-10-24 01:47:49 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.5)
2023-10-24 01:50:36 +0200emmanuelux(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-10-24 01:52:23 +0200Raito_Bezarius(~Raito@wireguard/tunneler/raito-bezarius) (Ping timeout: 258 seconds)
2023-10-24 01:52:26 +0200emmanuelux(~emmanuelu@user/emmanuelux)
2023-10-24 01:53:07 +0200Luj(~Luj@2a01:e0a:5f9:9681:5880:c9ff:fe9f:3dfb) (Ping timeout: 264 seconds)
2023-10-24 01:54:03 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f)
2023-10-24 01:58:56 +0200Luj(~Luj@2a01:e0a:5f9:9681:5880:c9ff:fe9f:3dfb)
2023-10-24 01:59:17 +0200santiagopim(~user@90.167.66.131) (Ping timeout: 255 seconds)
2023-10-24 02:04:39 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f) (Ping timeout: 258 seconds)
2023-10-24 02:05:43 +0200Raito_Bezarius(~Raito@wireguard/tunneler/raito-bezarius)
2023-10-24 02:07:56 +0200bliminse(~bliminse@user/bliminse) (Ping timeout: 260 seconds)
2023-10-24 02:13:18 +0200arahael(~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net) (Ping timeout: 260 seconds)
2023-10-24 02:14:56 +0200Raito_Bezarius(~Raito@wireguard/tunneler/raito-bezarius) (Ping timeout: 255 seconds)
2023-10-24 02:15:23 +0200Luj(~Luj@2a01:e0a:5f9:9681:5880:c9ff:fe9f:3dfb) (Ping timeout: 258 seconds)
2023-10-24 02:20:13 +0200Raito_Bezarius(~Raito@wireguard/tunneler/raito-bezarius)
2023-10-24 02:20:38 +0200Luj(~Luj@2a01:e0a:5f9:9681:5880:c9ff:fe9f:3dfb)
2023-10-24 02:24:14 +0200notzmv(~zmv@user/notzmv)
2023-10-24 02:24:42 +0200bliminse(~bliminse@user/bliminse)
2023-10-24 02:27:47 +0200dudek(~dudek@185.150.236.168) (Read error: Connection reset by peer)
2023-10-24 02:28:02 +0200ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net) (Ping timeout: 258 seconds)
2023-10-24 02:31:22 +0200bliminse(~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 +0200bliminse(~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 +0200pavonia(~user@user/siracusa)
2023-10-24 03:01:00 +0200Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-10-24 03:01:22 +0200Lycurgus(~georg@user/Lycurgus) (Quit: leaving)
2023-10-24 03:01:27 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 240 seconds)
2023-10-24 03:02:25 +0200Lord_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 +0200otto_s(~user@p5b044a8c.dip0.t-ipconnect.de) (Ping timeout: 264 seconds)
2023-10-24 03:08:44 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-10-24 03:09:00 +0200otto_s(~user@p4ff279af.dip0.t-ipconnect.de)
2023-10-24 03:10:56 +0200CiaoSen(~Jura@2a05:5800:2cd:b800:664b:f0ff:fe37:9ef) (Ping timeout: 260 seconds)
2023-10-24 03:13:48 +0200nate2(~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 +0200cece(~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 +0200eggplantade(~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 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-10-24 04:08:05 +0200finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-10-24 04:08:05 +0200finn_elijaFinnElija
2023-10-24 04:11:08 +0200xff0x(~xff0x@ai101218.d.east.v6connect.net) (Ping timeout: 255 seconds)
2023-10-24 04:12:22 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 252 seconds)
2023-10-24 04:20:05 +0200ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net)
2023-10-24 04:23:29 +0200Katarushisu16(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net)
2023-10-24 04:24:38 +0200Inst(~Inst@120.244.192.250) (Ping timeout: 255 seconds)
2023-10-24 04:25:03 +0200Katarushisu1(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) (Ping timeout: 240 seconds)
2023-10-24 04:25:03 +0200Katarushisu16Katarushisu1
2023-10-24 04:26:58 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f) (Remote host closed the connection)
2023-10-24 04:27:14 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f)
2023-10-24 04:29:45 +0200megaTherion_(~therion@unix.io)
2023-10-24 04:29:48 +0200megaTherion(~therion@unix.io) (Ping timeout: 240 seconds)
2023-10-24 04:29:52 +0200megaTherion_megaTherion
2023-10-24 04:36:04 +0200ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 256 seconds)
2023-10-24 04:37:53 +0200ec(~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 +0200waleee(~waleee@2001:9b0:21c:e600:f2f3:f744:435d:137c) (Ping timeout: 240 seconds)
2023-10-24 04:46:42 +0200Pseudonym(~IceChat95@203.214.86.172)
2023-10-24 04:49:06 +0200td_(~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 +0200td_(~td@i53870916.versanet.de)
2023-10-24 04:56:47 +0200xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-10-24 05:11:36 +0200isekaijin(~user@user/isekaijin) (Quit: brb)
2023-10-24 05:12:14 +0200isekaijin(~user@user/isekaijin)
2023-10-24 05:12:28 +0200aforemny(~aforemny@2001:9e8:6cc2:e900:a0d4:78f3:5fb4:bb3c)
2023-10-24 05:13:38 +0200aforemny_(~aforemny@2001:9e8:6cdc:d800:4073:3320:51a8:3861) (Ping timeout: 258 seconds)
2023-10-24 05:14:07 +0200qqq(~qqq@92.43.167.61) (Remote host closed the connection)
2023-10-24 05:24:55 +0200cece(~Thunderbi@103.28.91.210) (Remote host closed the connection)
2023-10-24 05:25:10 +0200cece(~Thunderbi@103.28.91.210)
2023-10-24 05:33:01 +0200dnb^(~cd@76.145.193.217)
2023-10-24 05:50:18 +0200szkl(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 +0200rosco(~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 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-10-24 06:38:47 +0200billchenchina(~billchenc@103.152.35.21)
2023-10-24 06:39:38 +0200juri__(~juri@79.140.115.166)
2023-10-24 06:40:04 +0200rosco(~rosco@yp-150-69.tm.net.my) (Quit: Lost terminal)
2023-10-24 06:40:21 +0200juri_(~juri@84-19-175-187.pool.ovpn.com) (Ping timeout: 260 seconds)
2023-10-24 06:44:09 +0200lambdap2371(~lambdap@static.167.190.119.168.clients.your-server.de) (Quit: lambdap2371)
2023-10-24 06:44:55 +0200lambdap2371(~lambdap@static.167.190.119.168.clients.your-server.de)
2023-10-24 06:58:22 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2023-10-24 06:58:51 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Read error: Connection reset by peer)
2023-10-24 06:59:34 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2023-10-24 07:01:45 +0200cece(~Thunderbi@103.28.91.210) (Remote host closed the connection)
2023-10-24 07:10:16 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-10-24 07:14:44 +0200td_(~td@i53870916.versanet.de) (Ping timeout: 255 seconds)
2023-10-24 07:15:00 +0200nate2(~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 +0200td_(~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 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Ping timeout: 260 seconds)
2023-10-24 07:27:05 +0200michalz(~michalz@185.246.207.221)
2023-10-24 07:29:19 +0200chomwitt(~chomwitt@2a02:587:7a1a:8700:1ac0:4dff:fedb:a3f1)
2023-10-24 07:32:09 +0200albet70(~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 +0200cece(~Thunderbi@e2e-32-47.ssdcloudindia.net)
2023-10-24 07:43:45 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-10-24 07:44:15 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-10-24 07:44:43 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-10-24 07:45:28 +0200CrunchyFlakes(~CrunchyFl@ip92348280.dynamic.kabel-deutschland.de)
2023-10-24 07:49:40 +0200raym(~ray@user/raym)
2023-10-24 07:55:47 +0200rgw(~R@2605:a601:a0df:5600:f816:aa41:2408:8443) (Read error: Connection reset by peer)
2023-10-24 07:56:29 +0200billchenchina(~billchenc@103.152.35.21) (Remote host closed the connection)
2023-10-24 08:00:31 +0200Pseudonym(~IceChat95@203.214.86.172) (Quit: When the chips are down, the buffalo is empty)
2023-10-24 08:08:42 +0200yaroot(~yaroot@p3477236-ipngn9802souka.saitama.ocn.ne.jp) (Remote host closed the connection)
2023-10-24 08:09:19 +0200yaroot(~yaroot@p3477236-ipngn9802souka.saitama.ocn.ne.jp)
2023-10-24 08:30:17 +0200idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-10-24 08:31:21 +0200lisbeths(uid135845@id-135845.lymington.irccloud.com)
2023-10-24 08:34:06 +0200fendor(~fendor@2a02:8388:1640:be00:aab:1226:f274:5021)
2023-10-24 08:35:36 +0200chele(~chele@user/chele)
2023-10-24 08:35:52 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2023-10-24 08:37:15 +0200elkcl_(~elkcl@broadband-95-84-226-240.ip.moscow.rt.ru)
2023-10-24 08:38:47 +0200elkcl(~elkcl@broadband-95-84-226-240.ip.moscow.rt.ru) (Ping timeout: 255 seconds)
2023-10-24 08:38:48 +0200elkcl_elkcl
2023-10-24 08:40:01 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-10-24 08:40:13 +0200danza(~francesco@151.37.205.77)
2023-10-24 08:41:54 +0200acidjnk_new(~acidjnk@p200300d6e72b9364ac51bf6edb979c24.dip0.t-ipconnect.de)
2023-10-24 08:42:07 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-10-24 08:52:41 +0200Jackneill(~Jackneill@20014C4E1E0E6F00C66CC838C6CE2C28.dsl.pool.telekom.hu)
2023-10-24 08:57:15 +0200random-jellyfish(~tiber@2a02:2f04:11e:c600:d86:8764:b7a3:4444)
2023-10-24 08:57:15 +0200random-jellyfish(~tiber@2a02:2f04:11e:c600:d86:8764:b7a3:4444) (Changing host)
2023-10-24 08:57:15 +0200random-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 +0200vglfr(~vglfr@88.155.140.136)
2023-10-24 09:06:10 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:877:6f13:9fe8:2e06)
2023-10-24 09:07:55 +0200vglfr(~vglfr@88.155.140.136) (Read error: Connection reset by peer)
2023-10-24 09:08:16 +0200vglfr(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 +0200danza(~francesco@151.37.205.77) (Ping timeout: 240 seconds)
2023-10-24 09:22:33 +0200CiaoSen(~Jura@2a05:5800:2a5:2200:664b:f0ff:fe37:9ef)
2023-10-24 09:33:24 +0200vglfr(vglfr@gateway/vpn/protonvpn/vglfr) (Ping timeout: 245 seconds)
2023-10-24 09:33:49 +0200vglfr(~vglfr@88.155.140.136)
2023-10-24 09:34:30 +0200Square3(~Square4@user/square)
2023-10-24 09:37:51 +0200danse-nr3_(~francesco@151.37.210.148)
2023-10-24 09:39:03 +0200sord937(~sord937@gateway/tor-sasl/sord937)
2023-10-24 09:42:05 +0200rosco(~rosco@yp-150-69.tm.net.my)
2023-10-24 09:45:36 +0200gmg(~user@user/gehmehgeh)
2023-10-24 09:51:41 +0200mrmr155(~mrmr@user/mrmr) (Ping timeout: 255 seconds)
2023-10-24 09:52:09 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f) (Remote host closed the connection)
2023-10-24 09:52:44 +0200eggplantade(~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 +0200vglfr(~vglfr@88.155.140.136) (Read error: Connection reset by peer)
2023-10-24 09:53:50 +0200vglfr(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 +0200eggplantade(~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 +0200helge_(~textual@h-158-174-186-9.NA.cust.bahnhof.se)
2023-10-24 09:59:17 +0200sm(~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> <s​m> why are y'all thinking matrix is involved
2023-10-24 10:14:59 +0200mrmr155(~mrmr@user/mrmr)
2023-10-24 10:15:02 +0200 <int-e> [needsinfo]
2023-10-24 10:15:03 +0200int-eshrugs
2023-10-24 10:16:28 +0200vglfr(vglfr@gateway/vpn/protonvpn/vglfr) (Ping timeout: 258 seconds)
2023-10-24 10:16:56 +0200vglfr(~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 +0200Sgeo(~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 +0200stiell_(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2023-10-24 10:27:00 +0200stiell_(~stiell@gateway/tor-sasl/stiell)
2023-10-24 10:32:57 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f)
2023-10-24 10:38:30 +0200stiell_(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2023-10-24 10:39:03 +0200stiell_(~stiell@gateway/tor-sasl/stiell)
2023-10-24 10:39:57 +0200gmg(~user@user/gehmehgeh) (Quit: Leaving)
2023-10-24 10:54:04 +0200econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-10-24 10:55:01 +0200tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net) (Quit: zzz)
2023-10-24 11:04:45 +0200rosco(~rosco@yp-150-69.tm.net.my) (Quit: Lost terminal)
2023-10-24 11:04:57 +0200rosco(~rosco@yp-150-69.tm.net.my)
2023-10-24 11:05:42 +0200yoyofreeman(~yoyofreem@176.97.76.178) (Read error: Connection reset by peer)
2023-10-24 11:06:55 +0200yoyofreeman(~yoyofreem@176.97.76.178)
2023-10-24 11:11:47 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-10-24 11:16:06 +0200fweht(uid404746@id-404746.lymington.irccloud.com)
2023-10-24 11:16:31 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-10-24 11:22:45 +0200kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-10-24 11:25:12 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 256 seconds)
2023-10-24 11:25:52 +0200ubert1(~Thunderbi@91.141.40.172.wireless.dyn.drei.com)
2023-10-24 11:26:44 +0200ubert(~Thunderbi@91.141.50.28.wireless.dyn.drei.com) (Ping timeout: 246 seconds)
2023-10-24 11:26:45 +0200ubert1ubert
2023-10-24 11:27:52 +0200billchenchina(~billchenc@113.57.152.160)
2023-10-24 11:28:33 +0200rosco(~rosco@yp-150-69.tm.net.my) (Quit: Lost terminal)
2023-10-24 11:28:46 +0200rosco(~rosco@yp-150-69.tm.net.my)
2023-10-24 11:30:39 +0200billchenchina-(~billchenc@2a0c:b641:7a2:230::10)
2023-10-24 11:33:11 +0200billchenchina(~billchenc@113.57.152.160) (Ping timeout: 260 seconds)
2023-10-24 11:40:43 +0200arahael(~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net)
2023-10-24 11:47:18 +0200Unicorn_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 +0200sord937(~sord937@gateway/tor-sasl/sord937) (Remote host closed the connection)
2023-10-24 11:48:38 +0200sord937(~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 +0200pyooque(~puke@user/puke)
2023-10-24 11:50:01 +0200puke(~puke@user/puke) (Killed (lithium.libera.chat (Nickname regained by services)))
2023-10-24 11:50:01 +0200pyooquepuke
2023-10-24 11:50:06 +0200santiagopim(~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 +0200Inst(~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 +0200fendor(~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 +0200emmanuelux(~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 +0200yoyofreeman(~yoyofreem@176.97.76.178) (Read error: Connection reset by peer)
2023-10-24 12:03:23 +0200yoyofreeman(~yoyofreem@176.97.76.178)
2023-10-24 12:03:49 +0200ft(~ft@p4fc2a529.dip0.t-ipconnect.de) (Quit: leaving)
2023-10-24 12:05:13 +0200yoyofreeman(~yoyofreem@176.97.76.178) (Remote host closed the connection)
2023-10-24 12:08:38 +0200xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 272 seconds)
2023-10-24 12:09:48 +0200sm(~sm@plaintextaccounting/sm) (Quit: sm)
2023-10-24 12:18:59 +0200lortabac(~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 +0200santiagopim(~user@90.167.66.131) (Remote host closed the connection)
2023-10-24 12:30:50 +0200santiagopim(~user@90.167.66.131)
2023-10-24 12:31:59 +0200jjhoo(~jahakala@user/jjhoo) (Ping timeout: 255 seconds)
2023-10-24 12:36:46 +0200CiaoSen(~Jura@2a05:5800:2a5:2200:664b:f0ff:fe37:9ef) (Ping timeout: 258 seconds)
2023-10-24 12:38:50 +0200billchenchina-(~billchenc@2a0c:b641:7a2:230::10) (Remote host closed the connection)
2023-10-24 12:47:54 +0200kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Ping timeout: 272 seconds)
2023-10-24 12:59:09 +0200yoyofreeman(~yoyofreem@176.97.76.178)
2023-10-24 13:07:19 +0200xff0x(~xff0x@2405:6580:b080:900:ecc3:b543:f7a2:f485)
2023-10-24 13:08:56 +0200jjhoo(~jahakala@user/jjhoo)
2023-10-24 13:25:46 +0200CiaoSen(~Jura@2a05:5800:2a5:2200:664b:f0ff:fe37:9ef)
2023-10-24 13:29:35 +0200CrunchyFlakes(~CrunchyFl@ip92348280.dynamic.kabel-deutschland.de) (Quit: ZNC 1.8.2 - https://znc.in)
2023-10-24 13:31:44 +0200CrunchyFlakes(~CrunchyFl@ip92348280.dynamic.kabel-deutschland.de)
2023-10-24 13:39:06 +0200danse-nr3__(~francesco@151.35.159.184)
2023-10-24 13:39:13 +0200danse-nr3_(~francesco@151.37.210.148) (Read error: Connection reset by peer)
2023-10-24 13:40:31 +0200hololeap(~quassel@user/hololeap) (Quit: Bye)
2023-10-24 13:40:58 +0200lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-10-24 13:41:07 +0200xff0x(~xff0x@2405:6580:b080:900:ecc3:b543:f7a2:f485) (Ping timeout: 264 seconds)
2023-10-24 13:41:41 +0200hololeap(~quassel@user/hololeap)
2023-10-24 13:42:36 +0200xff0x(~xff0x@ai101218.d.east.v6connect.net)
2023-10-24 13:43:06 +0200helge_(~textual@h-158-174-186-9.NA.cust.bahnhof.se) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-10-24 13:43:24 +0200danse-nr3__(~francesco@151.35.159.184) (Ping timeout: 240 seconds)
2023-10-24 13:43:34 +0200helge_(~textual@h-158-174-186-9.NA.cust.bahnhof.se)
2023-10-24 13:44:18 +0200chomwitt(~chomwitt@2a02:587:7a1a:8700:1ac0:4dff:fedb:a3f1) (Remote host closed the connection)
2023-10-24 13:45:36 +0200helge_(~textual@h-158-174-186-9.NA.cust.bahnhof.se) (Client Quit)
2023-10-24 13:46:00 +0200Lycurgus(~georg@user/Lycurgus)
2023-10-24 13:46:57 +0200lisbeths(uid135845@id-135845.lymington.irccloud.com)
2023-10-24 13:46:57 +0200helge_(~textual@h-158-174-186-9.NA.cust.bahnhof.se)
2023-10-24 13:51:40 +0200enoq(~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 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 260 seconds)
2023-10-24 13:55:35 +0200hololeap(~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 +0200hololeap(~quassel@user/hololeap)
2023-10-24 13:58:00 +0200czy(~user@180.116.80.17)
2023-10-24 13:58:06 +0200helge_(~textual@h-158-174-186-9.NA.cust.bahnhof.se) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-10-24 13:58:35 +0200kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-10-24 14:02:38 +0200Lycurgus(~georg@user/Lycurgus) (Quit: leaving)
2023-10-24 14:02:40 +0200czy(~user@180.116.80.17) (Quit: ERC 5.6-git (IRC client for GNU Emacs 30.0.50))
2023-10-24 14:06:52 +0200fendor(~fendor@2a02:8388:1640:be00:aab:1226:f274:5021)
2023-10-24 14:09:39 +0200sm(~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 +0200califax(~califax@user/califx) (Remote host closed the connection)
2023-10-24 14:20:12 +0200califax(~califax@user/califx)
2023-10-24 14:20:35 +0200cece(~Thunderbi@e2e-32-47.ssdcloudindia.net) (Ping timeout: 240 seconds)
2023-10-24 14:21:20 +0200cece(~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 +0200czy(~user@180.116.80.17)
2023-10-24 14:28:08 +0200aljazmc_(~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 +0200aljazmc(~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 +0200chomwitt(~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 +0200danse-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 +0200idgaen(~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 +0200cece(~Thunderbi@e2e-32-47.ssdcloudindia.net) (Remote host closed the connection)
2023-10-24 14:40:24 +0200cece(~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 +0200AlexZenon(~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 +0200AlexNoo(~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 +0200Inst(~Inst@120.244.192.250) (Read error: Connection reset by peer)
2023-10-24 14:52:46 +0200Inst(~Inst@120.244.192.250)
2023-10-24 14:54:08 +0200sm(~sm@plaintextaccounting/sm) (Quit: sm)
2023-10-24 14:54:45 +0200Inst_(~Inst@120.244.192.250)
2023-10-24 14:56:50 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-10-24 14:57:05 +0200Inst(~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 +0200enoq(~enoq@2a05:1141:1e6:3b00:c958:a45e:c4e0:3650) (Remote host closed the connection)
2023-10-24 15:03:18 +0200arahael(~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 +0200Inst_Inst
2023-10-24 15:12:56 +0200kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Quit: ERC (IRC client for Emacs 27.1))
2023-10-24 15:13:00 +0200AlexNoo(~AlexNoo@178.34.162.116)
2023-10-24 15:13:19 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-10-24 15:18:02 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-10-24 15:19:19 +0200CO2(CO2@gateway/vpn/protonvpn/co2)
2023-10-24 15:23:26 +0200vglfr(~vglfr@88.155.140.136) (Ping timeout: 255 seconds)
2023-10-24 15:27:38 +0200AlexZenon(~alzenon@178.34.162.116)
2023-10-24 15:36:54 +0200helge_(~textual@h-158-174-186-9.NA.cust.bahnhof.se)
2023-10-24 15:37:01 +0200CiaoSen(~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 +0200CO2(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 +0200bitdex(~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 +0200ubert(~Thunderbi@91.141.40.172.wireless.dyn.drei.com) (Ping timeout: 255 seconds)
2023-10-24 15:52:16 +0200 <haskellbridge> <m​auke> I'm still fine with Perl 🤷
2023-10-24 15:52:37 +0200 <haskellbridge> <m​auke> It's just an entirely different way of thinking
2023-10-24 15:53:22 +0200cece(~Thunderbi@e2e-32-47.ssdcloudindia.net) (Quit: cece)
2023-10-24 15:53:26 +0200 <haskellbridge> <m​auke> But at least I still have all the weird symbols like <$> and %~
2023-10-24 15:59:17 +0200ubert(~Thunderbi@91.141.40.172.wireless.dyn.drei.com)
2023-10-24 16:01:28 +0200vglfr(~vglfr@88.155.140.136)
2023-10-24 16:03:00 +0200xff0x(~xff0x@ai101218.d.east.v6connect.net) (Ping timeout: 258 seconds)
2023-10-24 16:05:03 +0200xff0x(~xff0x@178.255.149.135)
2023-10-24 16:06:14 +0200yoyofreeman(~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 +0200gehmehgeh(~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 +0200xff0x(~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 +0200xff0x(~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 +0200notzmv(~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 +0200int-eshrugs
2023-10-24 16:29:14 +0200 <int-e> I think that's as much as I care.
2023-10-24 16:29:23 +0200helge_(~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 +0200santiagopim(~user@90.167.66.131) (Remote host closed the connection)
2023-10-24 16:33:47 +0200nyc(~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 +0200sm(~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 +0200idgaen(~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 +0200CO2(~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 +0200Maxdamantus(~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 +0200Maxdamantus(~Maxdamant@user/maxdamantus)
2023-10-24 16:45:00 +0200 <tomsmeding> no, Data.Map
2023-10-24 16:45:08 +0200thyriaen(~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 +0200tromp(~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 +0200czy(~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 +0200tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net)
2023-10-24 16:59:25 +0200econo_(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 +0200xff0x(~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 +0200xff0x(~xff0x@ai101218.d.east.v6connect.net)
2023-10-24 17:10:44 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-10-24 17:21:07 +0200santiagopim(~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 +0200chomwitt(~chomwitt@2a02:587:7a1a:8700:1ac0:4dff:fedb:a3f1) (Remote host closed the connection)
2023-10-24 17:27:58 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-10-24 17:29:17 +0200emmanuelux(~emmanuelu@user/emmanuelux)
2023-10-24 17:29:34 +0200azimut(~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 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-10-24 17:32:33 +0200gmg(~user@user/gehmehgeh)
2023-10-24 17:32:37 +0200danse-nr3(~francesco@151.35.159.184) (Ping timeout: 252 seconds)
2023-10-24 17:33:32 +0200gehmehgeh(~user@user/gehmehgeh) (Ping timeout: 256 seconds)
2023-10-24 17:33:47 +0200vglfr(~vglfr@88.155.140.136) (Read error: Connection reset by peer)
2023-10-24 17:34:07 +0200vglfr(vglfr@gateway/vpn/protonvpn/vglfr)
2023-10-24 17:40:58 +0200lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-10-24 17:43:40 +0200thyriaen(~thyriaen@2a01:aea0:dd4:7550:6245:cbff:fe9f:48b1) (Remote host closed the connection)
2023-10-24 17:44:29 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:9d17:6d56:150b:424f) (Remote host closed the connection)
2023-10-24 17:44:49 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:484c:e1ac:4235:81cd)
2023-10-24 17:45:31 +0200danse-nr3(~francesco@151.35.215.38)
2023-10-24 17:47:40 +0200waleee(~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 +0200vglfr(vglfr@gateway/vpn/protonvpn/vglfr) (Ping timeout: 258 seconds)
2023-10-24 17:50:29 +0200vglfr(~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 +0200chele(~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 +0200waleee(~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 +0200int-eruns
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 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-10-24 18:16:10 +0200segfaultfizzbuzz(~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 +0200vglfr(~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 +0200vglfr(~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 +0200machinedgod(~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 +0200FinnElija(~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 +0200FinnElija(~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 +0200ChaiTRex(~ChaiTRex@user/chaitrex) (Ping timeout: 256 seconds)
2023-10-24 18:29:08 +0200notzmv(~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 +0200ChaiTRex(~ChaiTRex@user/chaitrex)
2023-10-24 18:30:56 +0200 <Inst> "Are Millenials Killing the Avocado Industry?"
2023-10-24 18:31:36 +0200tromp(~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 +0200rgw(~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 +0200juri__(~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 +0200juri_(~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 +0200CiaoSen(~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 +0200danse-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 +0200Square(~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 +0200danse-nr3(~francesco@151.35.215.38)
2023-10-24 18:53:00 +0200maxfan8(~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 +0200Square3(~Square4@user/square) (Ping timeout: 272 seconds)
2023-10-24 18:55:58 +0200segfaultfizzbuzz(~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 +0200segfaultfizzbuzz(~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 +0200vglfr(~vglfr@138.199.53.249) (Ping timeout: 255 seconds)
2023-10-24 19:07:23 +0200vglfr(~vglfr@88.155.140.136)
2023-10-24 19:08:33 +0200sm(~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 +0200nate2(~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 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 248 seconds)
2023-10-24 19:19:41 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-10-24 19:20:33 +0200sm(~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 +0200fweht(uid404746@id-404746.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-10-24 19:38:52 +0200tromp(~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 +0200danse-nr3(~francesco@151.35.215.38) (Remote host closed the connection)
2023-10-24 19:41:24 +0200rosco(~rosco@yp-150-69.tm.net.my) (Quit: Lost terminal)
2023-10-24 19:41:36 +0200mmhat(~mmh@p200300f1c71907a1ee086bfffe095315.dip0.t-ipconnect.de)
2023-10-24 19:41:45 +0200danse-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 +0200Rembanehasn't opened it yet
2023-10-24 19:45:01 +0200Rembanehas 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 +0200wootehfoot(~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 +0200segfaultfizzbuzz(~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 +0200segfaultfizzbuzz(~segfaultf@23-93-74-212.fiber.dynamic.sonic.net)
2023-10-24 19:53:59 +0200segfaultfizzbuzz(~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 +0200mmhat(~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 +0200wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2023-10-24 19:59:05 +0200qqq(~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 +0200ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2023-10-24 20:17:21 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:484c:e1ac:4235:81cd) (Remote host closed the connection)
2023-10-24 20:17:37 +0200maxfan8(~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 +0200Pickchea(~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 +0200ChaiTRex(~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 +0200Chai-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 +0200ChaiTRex(~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 +0200tromp(~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 +0200travgm(~travgm@2600:100e:a121:4094:f9fb:7cac:5660:4910)
2023-10-24 20:43:09 +0200travgm(~travgm@2600:100e:a121:4094:f9fb:7cac:5660:4910) (Changing host)
2023-10-24 20:43:09 +0200travgm(~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> <s​m> 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 +0200eggplantade(~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 +0200AlexZenon(~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 +0200tromp(~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 +0200AlexZenon(~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 +0200sm(~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 +0200eggplantade(~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 +0200azimut_(~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 +0200azimut(~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 +0200yaroot(~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 +0200dcoutts_(~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 +0200yaroot(~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 +0200azimut_(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2023-10-24 21:06:52 +0200dcoutts_(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-10-24 21:07:10 +0200azimut(~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 +0200waleee(~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 +0200tromp(~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 +0200danse-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 +0200Feuermagier(~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 +0200eggplantade(~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 +0200phma(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 +0200waleee(~waleee@2001:9b0:21c:e600:f2f3:f744:435d:137c) (Ping timeout: 260 seconds)
2023-10-24 21:39:32 +0200random-jellyfish(~tiber@user/random-jellyfish) (Ping timeout: 255 seconds)
2023-10-24 21:39:32 +0200michalz(~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 +0200phma(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 +0200waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se)
2023-10-24 21:41:10 +0200danza(~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 +0200danza_(~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 +0200danza(~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 +0200Chai-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 +0200ChaiTRex(~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 +0200stiell_(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2023-10-24 21:54:03 +0200stiell_(~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 +0200acidjnk_new(~acidjnk@p200300d6e72b9364ac51bf6edb979c24.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-10-24 21:55:02 +0200tromp(~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 +0200sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2023-10-24 22:03:48 +0200eL_Bart0(eL_Bart0@dietunichtguten.org) (Ping timeout: 240 seconds)
2023-10-24 22:04:03 +0200eL_Bart0(eL_Bart0@dietunichtguten.org)
2023-10-24 22:04:21 +0200dcoutts_(~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 +0200tromp(~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 +0200idgaen(~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 +0200danza_(~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 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-10-24 22:25:02 +0200tromp(~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 +0200yoyofreeman(~yoyofreem@176.97.76.178)
2023-10-24 22:38:12 +0200tromp(~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 +0200mrmonday(~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 +0200mrmonday(~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 +0200tromp(~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 +0200John_Ivan_(~John_Ivan@user/john-ivan/x-1515935)
2023-10-24 22:56:29 +0200CiaoSen(~Jura@2a05:5800:2a5:2200:664b:f0ff:fe37:9ef) (Ping timeout: 255 seconds)
2023-10-24 22:56:59 +0200emmanuelux_(~emmanuelu@user/emmanuelux)
2023-10-24 22:57:20 +0200emmanuelux(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-10-24 22:58:43 +0200danza_(~francesco@151.37.194.27)
2023-10-24 22:58:46 +0200John_Ivan(~John_Ivan@user/john-ivan/x-1515935) (Ping timeout: 252 seconds)
2023-10-24 22:59:18 +0200emmanuelux_(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-10-24 22:59:28 +0200emmanuelux_(~emmanuelu@user/emmanuelux)
2023-10-24 23:00:46 +0200danse-nr3(~francesco@151.37.194.27)
2023-10-24 23:01:04 +0200Guest5(~Guest5@5-157-196-109.itvmedia.pl)
2023-10-24 23:03:14 +0200travgm(~travgm@fsf/member/travgm) (Read error: Connection reset by peer)
2023-10-24 23:03:20 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 256 seconds)
2023-10-24 23:04:40 +0200emmanuelux_(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-10-24 23:09:10 +0200Guest5(~Guest5@5-157-196-109.itvmedia.pl) (Quit: Client closed)
2023-10-24 23:11:51 +0200Square(~Square@user/square) (Read error: Connection reset by peer)
2023-10-24 23:12:29 +0200Square3(~Square4@user/square)
2023-10-24 23:12:59 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-10-24 23:15:44 +0200dcoutts_(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-10-24 23:16:22 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-10-24 23:18:32 +0200danse-nr3(~francesco@151.37.194.27) (Ping timeout: 255 seconds)
2023-10-24 23:19:25 +0200fendor(~fendor@2a02:8388:1640:be00:aab:1226:f274:5021) (Remote host closed the connection)
2023-10-24 23:21:20 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-10-24 23:22:18 +0200danza_(~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 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-10-24 23:42:20 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-10-24 23:42:55 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-10-24 23:42:56 +0200Guest74(~Guest75@5-157-196-109.itvmedia.pl)
2023-10-24 23:43:42 +0200vglfr(~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 +0200krit(~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 +0200krit(~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 +0200suntzu(~krit@072-238-128-073.res.spectrum.com)
2023-10-24 23:53:17 +0200suntzu(~krit@072-238-128-073.res.spectrum.com) (Client Quit)
2023-10-24 23:55:52 +0200emmanuelux(~emmanuelu@user/emmanuelux)