IRCBrowse

2023/10/21

2023-10-21 00:00:56 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-10-21 00:02:33 +0200nickiminjaj(~nickiminj@user/laxhh) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-10-21 00:03:51 +0200bastelfreak(bastelfrea@libera/staff/VoxPupuli.bastelfreak)
2023-10-21 00:04:24 +0200bastelfreak(bastelfrea@libera/staff/VoxPupuli.bastelfreak) (Client Quit)
2023-10-21 00:04:38 +0200bastelfreak(bastelfrea@libera/staff/VoxPupuli.bastelfreak)
2023-10-21 00:04:59 +0200 <_d0t> ohai! How do I force ghc to use specific package database? I tried setting GHC_PACKAGE_PATH, -no-*-package-db options, etc, but my GHC custom build still tries to use the wrong one.
2023-10-21 00:05:04 +0200notzmv(~zmv@user/notzmv) (Ping timeout: 245 seconds)
2023-10-21 00:05:47 +0200bilegeek(~bilegeek@2600:1008:b06b:9a73:e45e:f9df:6e0b:4afb)
2023-10-21 00:06:02 +0200acidjnk_new(~acidjnk@p200300d6e72b9391d1b8c4ed720c4872.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-10-21 00:06:31 +0200johnw(~johnw@69.62.242.138)
2023-10-21 00:12:18 +0200 <geekosaur> I'm not sure you can; it has to use the package database that was installed as part of the custom ghc, because it has wired-in references to specific packages
2023-10-21 00:12:34 +0200 <geekosaur> you can't switch them to a different one
2023-10-21 00:12:58 +0200 <_d0t> actually, i did strace and it seems to look up the right package database, but then it loads Prelude.hi from a different installation.
2023-10-21 00:14:00 +0200 <_d0t> oh never mind, i'm a big dummy. The package database points to wrong packages somehow.
2023-10-21 00:27:53 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Ping timeout: 258 seconds)
2023-10-21 00:34:49 +0200vglfr(~vglfr@37.73.16.154)
2023-10-21 00:40:52 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 272 seconds)
2023-10-21 00:48:34 +0200[_](~itchyjunk@user/itchyjunk/x-7353470)
2023-10-21 00:51:56 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 248 seconds)
2023-10-21 01:05:03 +0200Vajb(~Vajb@207.61.167.122)
2023-10-21 01:09:46 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-10-21 01:11:53 +0200Vajb(~Vajb@207.61.167.122) (Ping timeout: 260 seconds)
2023-10-21 01:12:58 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:e1a3:648c:fb34:72ec)
2023-10-21 01:17:02 +0200Pickchea(~private@user/pickchea)
2023-10-21 01:17:08 +0200Pickchea(~private@user/pickchea) (Remote host closed the connection)
2023-10-21 01:18:58 +0200nickiminjaj(~nickiminj@188.146.126.78)
2023-10-21 01:18:58 +0200nickiminjaj(~nickiminj@188.146.126.78) (Changing host)
2023-10-21 01:18:58 +0200nickiminjaj(~nickiminj@user/laxhh)
2023-10-21 01:19:32 +0200gmg(~user@user/gehmehgeh) (Quit: Leaving)
2023-10-21 01:23:28 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:e1a3:648c:fb34:72ec) (Ping timeout: 258 seconds)
2023-10-21 01:28:09 +0200nickiminjaj(~nickiminj@user/laxhh) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-10-21 01:38:55 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 01:39:26 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-10-21 01:43:37 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 252 seconds)
2023-10-21 01:44:10 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 252 seconds)
2023-10-21 01:50:02 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 01:54:58 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 272 seconds)
2023-10-21 02:00:05 +0200CiaoSen(~Jura@2a05:5800:282:6600:664b:f0ff:fe37:9ef) (Ping timeout: 240 seconds)
2023-10-21 02:00:27 +0200Vajb(~Vajb@207.61.167.122)
2023-10-21 02:01:08 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 02:02:29 +0200califax(~califax@user/califx) (Remote host closed the connection)
2023-10-21 02:03:36 +0200califax(~califax@user/califx)
2023-10-21 02:05:06 +0200Vajb(~Vajb@207.61.167.122) (Ping timeout: 272 seconds)
2023-10-21 02:05:27 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 240 seconds)
2023-10-21 02:12:01 +0200solution(~solution@87-97-30-205.pool.digikabel.hu) (K-Lined)
2023-10-21 02:12:26 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 02:14:04 +0200solution(~solution@213-197-76-92.pool.digikabel.hu)
2023-10-21 02:16:58 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 255 seconds)
2023-10-21 02:19:37 +0200pixelmonk(~pixelmonk@173.46.79.26) (Quit: WeeChat 4.1.0)
2023-10-21 02:24:46 +0200notzmv(~zmv@user/notzmv)
2023-10-21 02:28:19 +0200solution(~solution@213-197-76-92.pool.digikabel.hu) (Quit: leaving)
2023-10-21 02:39:09 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 02:43:58 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 258 seconds)
2023-10-21 02:49:03 +0200Guest82(~Guest82@2600:4040:5078:d200:f0f4:2f68:dfcc:7aee)
2023-10-21 02:49:05 +0200waleee(~waleee@2001:9b0:21c:e600:f2f3:f744:435d:137c) (Ping timeout: 240 seconds)
2023-10-21 02:50:05 +0200Guest82(~Guest82@2600:4040:5078:d200:f0f4:2f68:dfcc:7aee) (Client Quit)
2023-10-21 02:50:50 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 02:52:23 +0200rosco(~rosco@gbk-48-6.tm.net.my)
2023-10-21 02:55:22 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 255 seconds)
2023-10-21 02:59:10 +0200Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-10-21 02:59:41 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 260 seconds)
2023-10-21 03:00:32 +0200Lord_of_Life_Lord_of_Life
2023-10-21 03:02:36 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 03:11:11 +0200otto_s(~user@p5b0443cb.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-10-21 03:12:47 +0200otto_s(~user@p5b044cbd.dip0.t-ipconnect.de)
2023-10-21 03:17:35 +0200rosco(~rosco@gbk-48-6.tm.net.my) (Ping timeout: 255 seconds)
2023-10-21 03:18:04 +0200rosco(~rosco@gbk-48-6.tm.net.my)
2023-10-21 03:18:50 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-10-21 03:19:12 +0200phma(phma@2001:5b0:210f:118:12d5:66dc:e6c4:4af1) (Read error: Connection reset by peer)
2023-10-21 03:19:39 +0200phma(phma@2001:5b0:210f:118:12d5:66dc:e6c4:4af1)
2023-10-21 03:27:06 +0200JuanDaugherty(~juan@user/JuanDaugherty)
2023-10-21 03:30:18 +0200Pozyomka(~pyon@user/pyon) (Quit: Pozyomka, my beloved: https://i.imgur.com/BMmVfTq.png)
2023-10-21 03:31:31 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:e1a3:648c:fb34:72ec)
2023-10-21 03:33:48 +0200_________(~nobody@user/noodly) (Ping timeout: 258 seconds)
2023-10-21 03:42:15 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.5)
2023-10-21 03:44:15 +0200billchenchina(~billchenc@103.152.35.21)
2023-10-21 03:49:40 +0200rosco(~rosco@gbk-48-6.tm.net.my) (Ping timeout: 255 seconds)
2023-10-21 03:51:10 +0200JuanDaugherty(~juan@user/JuanDaugherty) (Quit: JuanDaugherty)
2023-10-21 03:55:13 +0200ystael(~ystael@user/ystael) (Ping timeout: 260 seconds)
2023-10-21 03:59:04 +0200 <Inst> can i ask a quick question about Parsec?
2023-10-21 03:59:12 +0200 <Inst> Parsec can't resume parsing after incomplete input, right?
2023-10-21 03:59:37 +0200sm(~sm@plaintextaccounting/sm)
2023-10-21 04:16:14 +0200rosco(~rosco@gbk-48-6.tm.net.my)
2023-10-21 04:16:40 +0200 <EvanR> you might be able to defensively save and yield the parser state if early EOF is encountered, which sounds like a hack. attoparsec API allows resuming directly
2023-10-21 04:17:23 +0200Pozyomka(~pyon@user/pyon)
2023-10-21 04:25:21 +0200 <Inst> i'm thinking about joke solutions to the exact parser problem, which bodigrim seems to be indicating isn't really necessary
2023-10-21 04:25:39 +0200 <Inst> one joke solution is simply to feed data to the parser at the same time you're logging it
2023-10-21 04:26:07 +0200 <Inst> then once data is yielded, tuple together the parser output and the log
2023-10-21 04:26:26 +0200 <Inst> WriterT ParserT, eh?
2023-10-21 04:26:40 +0200 <EvanR> :k WriterT
2023-10-21 04:26:40 +0200 <lambdabot> * -> (* -> *) -> * -> *
2023-10-21 04:27:23 +0200finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-10-21 04:27:23 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-10-21 04:27:23 +0200finn_elijaFinnElija
2023-10-21 04:27:30 +0200 <Inst> spiritually
2023-10-21 04:29:29 +0200 <EvanR> attoparsec supports Text now so
2023-10-21 04:32:02 +0200rosco(~rosco@gbk-48-6.tm.net.my) (Ping timeout: 272 seconds)
2023-10-21 04:32:17 +0200td_(~td@i5387091B.versanet.de) (Ping timeout: 255 seconds)
2023-10-21 04:33:57 +0200td_(~td@i5387091E.versanet.de)
2023-10-21 04:35:42 +0200 <haskellbridge> <I​nst> i mean, something done over the existing cabal parser
2023-10-21 04:35:48 +0200 <haskellbridge> <I​nst> it's a "peasant" solution
2023-10-21 04:40:17 +0200Vajb(~Vajb@207.61.167.122)
2023-10-21 04:44:18 +0200L29Ah(~L29Ah@wikipedia/L29Ah) ()
2023-10-21 04:45:24 +0200L29Ah(~L29Ah@wikipedia/L29Ah)
2023-10-21 04:57:02 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:e1a3:648c:fb34:72ec) (Remote host closed the connection)
2023-10-21 04:57:19 +0200eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-10-21 05:13:01 +0200sm(~sm@plaintextaccounting/sm) (Quit: sm)
2023-10-21 05:13:51 +0200sm(~sm@plaintextaccounting/sm)
2023-10-21 05:17:15 +0200aforemny_(~aforemny@i59F516C8.versanet.de)
2023-10-21 05:17:27 +0200aforemny(~aforemny@2001:9e8:6cea:d00:75b1:1f0b:5b86:9d9f) (Ping timeout: 240 seconds)
2023-10-21 05:20:18 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-10-21 05:20:48 +0200L29Ah(~L29Ah@wikipedia/L29Ah) (Ping timeout: 272 seconds)
2023-10-21 05:21:04 +0200danza_(~francesco@151.47.125.134)
2023-10-21 05:36:37 +0200random-jellyfish(~random-je@user/random-jellyfish)
2023-10-21 05:37:14 +0200 <random-jellyfish> are transformer neural networks pure functions?
2023-10-21 05:37:53 +0200Vajb(~Vajb@207.61.167.122) (Ping timeout: 260 seconds)
2023-10-21 05:38:13 +0200 <random-jellyfish> or do they need to modify some global state?
2023-10-21 05:39:12 +0200 <danza_> any stateful computation can be modeled in terms of pure functions, but i am not familiar with transformer networks
2023-10-21 05:40:58 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-10-21 05:41:15 +0200 <random-jellyfish> I don't underatand how in context learning works, where is the learned information from one prompt stored so that it can be used with the next prompt?
2023-10-21 05:41:38 +0200 <random-jellyfish> are the some internal parameters that get changed with each prompt?
2023-10-21 05:42:01 +0200 <EvanR> passing and returning state can also be modeled as taking the entire history of the dialog as argument
2023-10-21 05:42:21 +0200 <EvanR> (and not returning the updated state because it's redundant)
2023-10-21 05:42:34 +0200 <random-jellyfish> EvanR: yeah that was the other scenario I was thinking about
2023-10-21 05:43:27 +0200 <random-jellyfish> so when I talk to chatgpt with every prompt I send the entire history of the dialog is sent all over again?
2023-10-21 05:43:54 +0200 <danza_> i doubt chatgpt is purely functional
2023-10-21 05:44:05 +0200 <EvanR> probably not but they could have done it that way if no one cared about performance
2023-10-21 05:44:25 +0200 <random-jellyfish> and the learned information is "stored" in the replies it gives me?
2023-10-21 05:44:44 +0200 <random-jellyfish> the openai python api seems to work that way
2023-10-21 05:44:45 +0200 <EvanR> the learned information would not be stored, but derived from history every time
2023-10-21 05:44:52 +0200 <danza_> there are probably more efficient ways to do purely functional machine learning
2023-10-21 05:45:45 +0200 <danza_> functional does not mean there is no state
2023-10-21 05:45:59 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-10-21 05:46:00 +0200 <random-jellyfish> I looked at the transformer nn architecture, I can't find any mutable state
2023-10-21 05:46:17 +0200 <random-jellyfish> the changes happen during backpropagation training
2023-10-21 05:46:20 +0200 <EvanR> i thought the NN itself is the state
2023-10-21 05:46:33 +0200 <random-jellyfish> but in inference mode the weights remain unchanged
2023-10-21 05:46:54 +0200 <random-jellyfish> yet it can still "learn" stuff during inference
2023-10-21 05:47:10 +0200 <EvanR> maybe old questions are provided as input like you said
2023-10-21 05:47:20 +0200 <EvanR> if there's really no other changes
2023-10-21 05:47:31 +0200 <danza_> if it learns, there ought to be some change
2023-10-21 05:48:01 +0200 <random-jellyfish> yeah I think so too, most likely, it's the history
2023-10-21 05:48:10 +0200 <EvanR> not necessarily, since part of NN is predicting what you might even ask next
2023-10-21 05:48:30 +0200 <danza_> oh i see what you mean
2023-10-21 05:49:22 +0200 <EvanR> "are transformer neural networks pure functions" is a great question, I don't know. But the answer would answer everything we discussed up to this point
2023-10-21 05:49:57 +0200 <danza_> maybe we can distinguish between learning and training here then
2023-10-21 05:50:37 +0200 <danza_> it's a strange question. A model or an algorithm can be expressed as pure functions or functions with side effects, that's unrelated
2023-10-21 05:52:24 +0200 <danza_> (or call the others "impure" so that they cannot be mistaken with monadic pure functions)
2023-10-21 05:52:40 +0200 <random-jellyfish> I think learning is the more general term and it includes training
2023-10-21 05:53:03 +0200 <random-jellyfish> learning implies some accumulation of information
2023-10-21 05:53:29 +0200 <danza_> well a trained network can learn about a dialogue without that affecting its training from what you said (weights not changing)
2023-10-21 05:53:37 +0200 <random-jellyfish> training implies accumulating information by changing some parameters
2023-10-21 05:54:15 +0200 <random-jellyfish> changing aka fine tuning
2023-10-21 05:57:05 +0200lisbeths(uid135845@id-135845.lymington.irccloud.com)
2023-10-21 05:58:20 +0200 <danza_> anyways, to go in the direction of your question, i think often for machine learning mutable data structures are used, probably for efficiency
2023-10-21 06:00:43 +0200sm(~sm@plaintextaccounting/sm) (Quit: sm)
2023-10-21 06:01:11 +0200 <random-jellyfish> yeah performance oriented implementations you have all the state and weigths preallocated and they will get changed on the fly during inference and training
2023-10-21 06:01:35 +0200Vajb(~Vajb@207.61.167.122)
2023-10-21 06:01:44 +0200 <random-jellyfish> you don't want any garbage collection of billion element matrices at runtime lol
2023-10-21 06:03:30 +0200 <danza_> i think immutable implementations of big matrices do not throw them away at each change, but i don't know the details
2023-10-21 06:05:26 +0200Inst(~Inst@120.244.192.250) (Ping timeout: 255 seconds)
2023-10-21 06:05:45 +0200 <EvanR> big matrix, you want to reuse an old big matrix you no longer are using
2023-10-21 06:05:49 +0200 <EvanR> to store results
2023-10-21 06:08:31 +0200 <danza_> yep
2023-10-21 06:09:29 +0200 <danza_> i am not very familiar with haskell idioms for mutability. STM?
2023-10-21 06:11:19 +0200 <EvanR> IOVector xD
2023-10-21 06:11:31 +0200 <EvanR> ffi to fortran
2023-10-21 06:13:20 +0200 <danza_> oh there are a lot of libraries with efficient matrices ... in this channel they chat a lot about accelerate recently. I was wondering about a simple abstraction that works in the general case
2023-10-21 06:16:04 +0200Sciencentistguy(~sciencent@hacksoc/ordinary-member) (Quit: Ping timeout (120 seconds))
2023-10-21 06:16:22 +0200Sciencentistguy(~sciencent@hacksoc/ordinary-member)
2023-10-21 06:17:45 +0200 <[Leary]> danza_: ST.
2023-10-21 06:18:29 +0200 <danza_> oh that is it then. Thanks [Leary] ... i seldom do mutability these days
2023-10-21 06:19:00 +0200 <random-jellyfish> BLAS and LAPACK are great for linear algebra...if only their functions didn't look like assembly language instructions
2023-10-21 06:19:36 +0200 <danza_> do they have symbolic facilities? I usually think of python or R for linear algebra
2023-10-21 06:21:35 +0200 <random-jellyfish> I think BLAS and Lapack are the backend of most open source linear algebra libs
2023-10-21 06:22:13 +0200 <danza_> i don't think python nor R (nor Julia) would use them as a backend
2023-10-21 06:22:53 +0200 <random-jellyfish> numpy uses them for sure, not sure about Julia and R
2023-10-21 06:23:52 +0200 <danza_> oh cool, i thought numpy had its own implementations
2023-10-21 06:24:08 +0200 <danza_> lemme check the project
2023-10-21 06:24:12 +0200 <random-jellyfish> nah, even Julia uses them I see
2023-10-21 06:24:45 +0200 <random-jellyfish> some libs use Intel's mkl, but mkl is closed source
2023-10-21 06:25:32 +0200 <danza_> wow. These projects are so buried behind other frontends
2023-10-21 06:26:48 +0200 <danza_> turns out we are all running on fortran
2023-10-21 06:27:28 +0200 <danza_> thanks random-jellyfish, that was instructive
2023-10-21 06:28:32 +0200 <random-jellyfish> danza_: no problem
2023-10-21 06:31:49 +0200sabino(~sabino@user/sabino) (Quit: Lambda _ -> x)
2023-10-21 06:34:33 +0200gawen(~gawen@user/gawen) (Quit: cya)
2023-10-21 06:35:54 +0200gawen(~gawen@user/gawen)
2023-10-21 06:40:57 +0200bilegeek(~bilegeek@2600:1008:b06b:9a73:e45e:f9df:6e0b:4afb) (Quit: Leaving)
2023-10-21 06:41:09 +0200rgw(~R@2605:a601:a0df:5600:41e1:fde1:f907:ea46) (Quit: rgw)
2023-10-21 06:46:05 +0200danza__(~francesco@151.35.100.193)
2023-10-21 06:46:29 +0200danza_(~francesco@151.47.125.134) (Read error: Connection reset by peer)
2023-10-21 06:47:10 +0200billchenchina(~billchenc@103.152.35.21) (Read error: Connection reset by peer)
2023-10-21 06:50:43 +0200_________(~nobody@user/noodly)
2023-10-21 06:56:14 +0200[_](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-10-21 07:02:25 +0200hiyori(~hiyori@user/hiyori) (Quit: Ping timeout (120 seconds))
2023-10-21 07:20:16 +0200danza__(~francesco@151.35.100.193) (Ping timeout: 255 seconds)
2023-10-21 07:26:58 +0200Vajb(~Vajb@207.61.167.122) (Ping timeout: 260 seconds)
2023-10-21 07:35:20 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2023-10-21 07:37:55 +0200harveypwca(~harveypwc@2601:246:c280:6a90:837d:db39:3eea:f7db)
2023-10-21 07:40:34 +0200danza__(~francesco@151.35.100.193)
2023-10-21 07:59:27 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-10-21 08:01:24 +0200 <hololeap> GHC.IO.Encoding.getFileSystemEncoding returns `IO TextEncoding`, but how would I use that to convert a ByteString to a String?
2023-10-21 08:02:31 +0200 <danza__> interesting question. I thought text encoding was specific to files
2023-10-21 08:04:38 +0200 <hololeap> I'm trying to use linux-inotify, and currently I need to convert the ByteString returned by `name` to a FilePath (String): https://hackage.haskell.org/package/linux-inotify-0.3.0.2/docs/System-Linux-Inotify.html#t:Event
2023-10-21 08:04:53 +0200 <hololeap> it says: The proper Haskell interpretation of this seems to be to use getFileSystemEncoding and then unpack it to a String or decode it using the text package.
2023-10-21 08:06:03 +0200 <danza__> i see it is a path
2023-10-21 08:08:05 +0200 <danza__> this seems a bit convoluted
2023-10-21 08:08:35 +0200 <danza__> mkTextDecoder here https://downloads.haskell.org/~ghc/9.4.2/docs/libraries/base-4.17.0.0/GHC-IO-Encoding.html#t:TextE…
2023-10-21 08:09:20 +0200 <danza__> TextDecoder is just an alias for BufferCodec https://downloads.haskell.org/~ghc/9.4.2/docs/libraries/base-4.17.0.0/GHC-IO-Encoding.html
2023-10-21 08:10:03 +0200 <danza__> and there is an `encode` on BufferCodec that works also for decoding if you read the types
2023-10-21 08:10:24 +0200 <hololeap> I might end up just using Data.Text.Encoding.decodeUtf8
2023-10-21 08:11:17 +0200 <danza__> hehe yes probably easier ... i haven't even finished the chain of functions i think ...
2023-10-21 08:11:27 +0200 <hololeap> danza__: the problem is that the GHC module is using some Buffer wrapper as opposed to the more familiar ByteString and String types
2023-10-21 08:12:04 +0200 <danza__> yeah i am also not familiar with those types
2023-10-21 08:12:38 +0200 <hololeap> there's basically 0% chance that the paths will be anything other than ASCII so decodeUtf8 should be safe
2023-10-21 08:13:10 +0200 <hololeap> but I wanted to see if anyone knew what the linux-inotify docs were trying to say
2023-10-21 08:13:38 +0200 <danza__> the docs sound like they are not sure either...
2023-10-21 08:14:30 +0200 <danza__> anyways it depends on whether you are coding for yourself or you plan to release that i guess
2023-10-21 08:14:50 +0200 <hololeap> I plan on releasing it, but it's definitely not critical software
2023-10-21 08:15:04 +0200Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-10-21 08:15:30 +0200 <hololeap> if someone hits an issue with decoding on their system I can go back and look at this
2023-10-21 08:26:35 +0200sm(~sm@plaintextaccounting/sm)
2023-10-21 08:28:05 +0200rosco(~rosco@gbk-48-6.tm.net.my)
2023-10-21 08:28:16 +0200[Leary](~Leary]@user/Leary/x-0910699) (Remote host closed the connection)
2023-10-21 08:32:34 +0200[Leary](~Leary]@user/Leary/x-0910699)
2023-10-21 08:36:42 +0200lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-10-21 08:40:22 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 255 seconds)
2023-10-21 08:42:05 +0200euleritian(~euleritia@dynamic-046-114-205-113.46.114.pool.telefonica.de)
2023-10-21 08:50:00 +0200euleritian(~euleritia@dynamic-046-114-205-113.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-10-21 08:50:18 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-10-21 08:51:25 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-10-21 08:59:18 +0200 <[Leary]> hololeap: The advice there looks outdated; this `ByteString` probably ought to be an `OsPath`. If you run it through `fromBytes` (exposed internals, not sure if there's a better option) then you can use `decodeFS` or `decodeWith`.
2023-10-21 08:59:52 +0200Square(~Square@user/square)
2023-10-21 09:05:32 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Remote host closed the connection)
2023-10-21 09:06:29 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-10-21 09:08:40 +0200eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-10-21 09:16:39 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 240 seconds)
2023-10-21 09:18:26 +0200 <danza__> maybe poke the maintainers with an issue about that doc then hololeap, if you don't mind
2023-10-21 09:25:58 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-10-21 09:26:09 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-10-21 09:30:31 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-10-21 09:30:57 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-10-21 09:31:08 +0200fendor(~fendor@2a02:8388:1640:be00:aab:1226:f274:5021)
2023-10-21 09:33:10 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-10-21 09:33:10 +0200idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-10-21 09:33:32 +0200CiaoSen(~Jura@2a05:5800:2bf:4500:664b:f0ff:fe37:9ef)
2023-10-21 09:33:36 +0200acidjnk_new(~acidjnk@p200300d6e72b93737dc6e69178877b3f.dip0.t-ipconnect.de)
2023-10-21 09:33:41 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-10-21 09:42:29 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-10-21 09:44:30 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:e1a3:648c:fb34:72ec)
2023-10-21 09:47:25 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-10-21 09:52:25 +0200lortabac(~lortabac@ip-185-104-138-41.ptr.icomera.net)
2023-10-21 09:55:01 +0200lortabac(~lortabac@ip-185-104-138-41.ptr.icomera.net) (Client Quit)
2023-10-21 10:07:52 +0200Flow(~none@gentoo/developer/flow) (Ping timeout: 258 seconds)
2023-10-21 10:10:15 +0200 <Square> can I make a newtype of Int and keep Num instances for arithmetic and relational operators?
2023-10-21 10:10:29 +0200 <Square> ...easily
2023-10-21 10:11:47 +0200 <Square> oh, found it. GeneralizedNewtypeDeriving
2023-10-21 10:12:21 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-10-21 10:14:31 +0200nickiminjaj(~nickiminj@188.146.126.78)
2023-10-21 10:14:31 +0200nickiminjaj(~nickiminj@188.146.126.78) (Changing host)
2023-10-21 10:14:31 +0200nickiminjaj(~nickiminj@user/laxhh)
2023-10-21 10:14:38 +0200Guest7(~Guest7@2603-7000-4b42-1100-7984-deb8-b762-75ca.res6.spectrum.com)
2023-10-21 10:15:11 +0200 <Guest7> Hello, how to extract the Shape of a Tree, and be able to reconstruct it again with a list of values and a Shape?
2023-10-21 10:15:39 +0200Flow(~none@gentoo/developer/flow)
2023-10-21 10:16:34 +0200 <danza__> are you referring to a precise Tree type Guest7? Would you mind pasting the link here?
2023-10-21 10:16:36 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 260 seconds)
2023-10-21 10:16:58 +0200 <Guest7> Yes, but I was wonderting is there is one solution for all
2023-10-21 10:17:00 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-10-21 10:17:02 +0200Jackneill(~Jackneill@20014C4E1E0E6F0085D71214A6273985.dsl.pool.telekom.hu)
2023-10-21 10:17:26 +0200econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-10-21 10:17:43 +0200gmg(~user@user/gehmehgeh)
2023-10-21 10:18:12 +0200harveypwca(~harveypwc@2601:246:c280:6a90:837d:db39:3eea:f7db) (Quit: Leaving)
2023-10-21 10:19:05 +0200 <danza__> there is probably a solution for all Tree and Shape, once we will know which Tree and Shape are you talking about
2023-10-21 10:19:16 +0200 <[Leary]> You can do this for an arbitrary Traversable, which most trees are. The real question is, why would you want to?
2023-10-21 10:21:51 +0200Vq(~vq@90-225-115-195-no122.tbcn.telia.com) (Ping timeout: 260 seconds)
2023-10-21 10:22:17 +0200Vq(~vq@90-225-115-195-no122.tbcn.telia.com)
2023-10-21 10:26:09 +0200 <Guest7> https://github.com/smoge/haskMus/blob/main/src/Music/Time/Rtm.hs
2023-10-21 10:27:09 +0200 <Guest7> data RtmValue
2023-10-21 10:27:10 +0200 <Guest7>   = RtmNote Int
2023-10-21 10:27:10 +0200 <Guest7>   | RtmRest Int
2023-10-21 10:27:11 +0200 <Guest7>   | RtmLeaf Int RtmProportions
2023-10-21 10:27:11 +0200 <Guest7>   deriving (Eq, Ord, Show)
2023-10-21 10:27:12 +0200 <Guest7> data RtmProportions =
2023-10-21 10:27:12 +0200 <Guest7>   RtmProportions [RtmValue]
2023-10-21 10:27:13 +0200 <Guest7>   deriving (Eq, Ord, Show)
2023-10-21 10:31:13 +0200cpressey(~cpressey@host-92-10-146-234.as13285.net)
2023-10-21 10:31:39 +0200 <danza__> thanks. I find no Tree nor Shape there
2023-10-21 10:32:00 +0200 <danza__> ArrayShape maybe?
2023-10-21 10:34:16 +0200 <Guest7> it's a tree like structure, nested. What is ArrayShape? APL inspired Array?
2023-10-21 10:37:52 +0200 <danza__> not sure, just the thing i found in your code that was closer to the Shape type you mentioned
2023-10-21 10:38:30 +0200 <danza__> so yes, types are shaped like trees, but you mentioned Tree and Shape and uppercase like that they seem types
2023-10-21 10:39:03 +0200 <Guest7> Yes, do you know implementation of Shape representing the structure of a tree-like structure?
2023-10-21 10:42:11 +0200 <danza__> usually i would get that with a parametric type. If you have ... i will play with the interpreter a bit
2023-10-21 10:42:37 +0200 <danza__> % data Value i = Note i | Rest i | Leaf i Char
2023-10-21 10:42:38 +0200 <yahb2> <no output>
2023-10-21 10:42:51 +0200 <danza__> i used `Char` instead of `Proportions`
2023-10-21 10:43:30 +0200 <danza__> well in that case i guess you have the "shape" outside the tree
2023-10-21 10:45:12 +0200 <Guest7> I was trying something like this:
2023-10-21 10:45:12 +0200 <Guest7> -- >>> rtm = RtmProportions [RtmNote 5, RtmLeaf 2 (RtmProportions [RtmNote 6, RtmRest 4]), RtmRest 3]
2023-10-21 10:45:13 +0200 <Guest7> -- >>> toRtmArray rtm
2023-10-21 10:45:13 +0200 <Guest7> -- RtmArray [5,2,6,-4,-3] (Vector [Scalar,Vector [Scalar,Vector [Scalar,Scalar]],Scalar])
2023-10-21 10:46:35 +0200danza_(~francesco@151.43.123.193)
2023-10-21 10:46:37 +0200 <Guest7> makes sense?
2023-10-21 10:46:44 +0200danza__(~francesco@151.35.100.193) (Read error: Connection reset by peer)
2023-10-21 10:47:39 +0200 <[Leary]> The best representation of the structure of a tree is the tree itself.
2023-10-21 10:49:05 +0200 <danza_> seems to make sense anyway, why not, depends what you want to achieve
2023-10-21 10:51:01 +0200 <Guest7> Yes, but it's not working correctly. I was wondering if there is a better way to do, or a library to help with this.
2023-10-21 10:51:17 +0200Pickchea(~private@user/pickchea)
2023-10-21 10:54:27 +0200 <Rembane> Guest7: What's the intended behaviour? And what's the actual behaviour?
2023-10-21 10:55:47 +0200rosco(~rosco@gbk-48-6.tm.net.my) (Quit: Lost terminal)
2023-10-21 10:56:29 +0200Guest7(~Guest7@2603-7000-4b42-1100-7984-deb8-b762-75ca.res6.spectrum.com) (Quit: Client closed)
2023-10-21 11:08:31 +0200tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net) (Quit: zzz)
2023-10-21 11:08:58 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-10-21 11:11:38 +0200chexum(~quassel@gateway/tor-sasl/chexum)
2023-10-21 11:12:52 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-10-21 11:14:43 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 255 seconds)
2023-10-21 11:18:24 +0200phma(phma@2001:5b0:210f:118:12d5:66dc:e6c4:4af1) (Read error: Connection reset by peer)
2023-10-21 11:19:15 +0200phma(phma@2001:5b0:210d:e0f8:4b17:f518:800e:b47e)
2023-10-21 11:25:05 +0200ubert1(~Thunderbi@91.141.58.4.wireless.dyn.drei.com)
2023-10-21 11:26:43 +0200Square(~Square@user/square) (Ping timeout: 260 seconds)
2023-10-21 11:26:50 +0200ubert(~Thunderbi@77.119.196.197.wireless.dyn.drei.com) (Ping timeout: 258 seconds)
2023-10-21 11:26:50 +0200ubert1ubert
2023-10-21 11:39:36 +0200yoyofreeman(~yoyofreem@176.97.76.178) (Remote host closed the connection)
2023-10-21 11:40:17 +0200yoyofreeman(~yoyofreem@176.97.76.178)
2023-10-21 11:40:30 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 255 seconds)
2023-10-21 11:41:13 +0200euleritian(~euleritia@dynamic-046-114-109-096.46.114.pool.telefonica.de)
2023-10-21 11:43:25 +0200xigua(~xigua@user/xigua) (Remote host closed the connection)
2023-10-21 11:43:59 +0200xigua(~xigua@user/xigua)
2023-10-21 11:50:12 +0200random-jellyfish(~random-je@user/random-jellyfish) (Ping timeout: 240 seconds)
2023-10-21 11:55:14 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2023-10-21 12:05:13 +0200Maxdamantus(~Maxdamant@user/maxdamantus) (Ping timeout: 260 seconds)
2023-10-21 12:06:38 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-10-21 12:10:00 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Remote host closed the connection)
2023-10-21 12:10:18 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-10-21 12:10:23 +0200TheCatCollective(NyaaTheKit@user/calculuscat) (Quit: Meow Meow Meow Meow Meow Meow Meow Meow)
2023-10-21 12:14:11 +0200Maxdamantus(~Maxdamant@user/maxdamantus)
2023-10-21 12:14:50 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-10-21 12:15:28 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 255 seconds)
2023-10-21 12:17:54 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-10-21 12:20:07 +0200acidjnk_new(~acidjnk@p200300d6e72b93737dc6e69178877b3f.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-10-21 12:21:20 +0200vglfr(~vglfr@37.73.16.154) (Ping timeout: 272 seconds)
2023-10-21 12:29:36 +0200danza_(~francesco@151.43.123.193) (Ping timeout: 260 seconds)
2023-10-21 12:30:46 +0200haskl(~haskl@user/haskl) (Read error: Connection reset by peer)
2023-10-21 12:33:05 +0200haskl(~haskl@user/haskl)
2023-10-21 12:57:36 +0200simendsjo(~user@84.211.91.241)
2023-10-21 12:58:36 +0200simendsj`(~user@84.211.91.241)
2023-10-21 13:00:42 +0200simendsjo(~user@84.211.91.241) (Remote host closed the connection)
2023-10-21 13:00:42 +0200simendsj`(~user@84.211.91.241) (Remote host closed the connection)
2023-10-21 13:01:34 +0200simendsjo(~user@84.211.91.241)
2023-10-21 13:01:43 +0200vglfr(~vglfr@37.73.16.154)
2023-10-21 13:07:47 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-10-21 13:12:06 +0200Vajb(~Vajb@207.61.167.122)
2023-10-21 13:36:35 +0200Vajb(~Vajb@207.61.167.122) (Ping timeout: 240 seconds)
2023-10-21 13:44:00 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-10-21 13:48:46 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-10-21 13:50:10 +0200roger_(~roger@122.162.144.48)
2023-10-21 13:50:37 +0200 <roger_> hi!
2023-10-21 13:52:46 +0200idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.0.5)
2023-10-21 13:53:10 +0200roger_(~roger@122.162.144.48) (Quit: Lost terminal)
2023-10-21 13:55:43 +0200arahael(~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net)
2023-10-21 14:03:05 +0200acidjnk_new(~acidjnk@p200300d6e72b93737dc6e69178877b3f.dip0.t-ipconnect.de)
2023-10-21 14:04:43 +0200finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-10-21 14:04:43 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-10-21 14:04:43 +0200finn_elijaFinnElija
2023-10-21 14:16:38 +0200fweht(uid404746@id-404746.lymington.irccloud.com)
2023-10-21 14:26:52 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 255 seconds)
2023-10-21 14:31:56 +0200todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-10-21 14:35:07 +0200yoyofreeman(~yoyofreem@176.97.76.178) (Remote host closed the connection)
2023-10-21 14:35:48 +0200yoyofreeman(~yoyofreem@176.97.76.178)
2023-10-21 14:42:13 +0200nickiminjaj(~nickiminj@user/laxhh) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-10-21 14:49:35 +0200sm(~sm@plaintextaccounting/sm) (Quit: sm)
2023-10-21 14:54:36 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:e1a3:648c:fb34:72ec) (Ping timeout: 248 seconds)
2023-10-21 15:06:39 +0200alphacentauri(alphacenta@gateway/vpn/protonvpn/alphacentauri)
2023-10-21 15:07:31 +0200arahael(~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-10-21 15:08:36 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-10-21 15:09:26 +0200Square(~Square@user/square)
2023-10-21 15:13:38 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-10-21 15:15:08 +0200vglfr(~vglfr@37.73.16.154) (Remote host closed the connection)
2023-10-21 15:15:43 +0200vglfr(~vglfr@37.73.16.154)
2023-10-21 15:17:00 +0200vglfr(~vglfr@37.73.16.154) (Remote host closed the connection)
2023-10-21 15:17:46 +0200vglfr(~vglfr@37.73.16.154)
2023-10-21 15:20:00 +0200JuanDaugherty(~juan@user/JuanDaugherty)
2023-10-21 15:22:37 +0200vglfr(~vglfr@37.73.16.154) (Remote host closed the connection)
2023-10-21 15:23:02 +0200vglfr(~vglfr@37.73.16.154)
2023-10-21 15:34:06 +0200Lycurgus(~jdaughert@user/Lycurgus)
2023-10-21 15:34:13 +0200ystael(~ystael@user/ystael)
2023-10-21 15:40:15 +0200Lycurgus(~jdaughert@user/Lycurgus) (Quit: leaving)
2023-10-21 15:41:03 +0200simendsjo(~user@84.211.91.241) (Ping timeout: 260 seconds)
2023-10-21 15:43:27 +0200Pozyomka(~pyon@user/pyon) (Quit: Pozyomka, my beloved: https://i.imgur.com/BMmVfTq.png)
2023-10-21 15:44:03 +0200CiaoSen(~Jura@2a05:5800:2bf:4500:664b:f0ff:fe37:9ef) (Ping timeout: 258 seconds)
2023-10-21 15:45:52 +0200Lycurgus(~Ren@user/Lycurgus)
2023-10-21 15:46:45 +0200Lycurgus(~Ren@user/Lycurgus) (Client Quit)
2023-10-21 15:48:01 +0200JuanDaugherty(~juan@user/JuanDaugherty) (Quit: JuanDaugherty)
2023-10-21 15:48:37 +0200emmanuelux(~emmanuelu@user/emmanuelux)
2023-10-21 15:49:30 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-10-21 16:12:04 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Remote host closed the connection)
2023-10-21 16:13:02 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-10-21 16:22:49 +0200L29Ah(~L29Ah@wikipedia/L29Ah)
2023-10-21 16:29:40 +0200ystael(~ystael@user/ystael) (Ping timeout: 258 seconds)
2023-10-21 16:37:25 +0200nickiminjaj(~nickiminj@188.146.126.78)
2023-10-21 16:37:25 +0200nickiminjaj(~nickiminj@188.146.126.78) (Changing host)
2023-10-21 16:37:25 +0200nickiminjaj(~nickiminj@user/laxhh)
2023-10-21 16:42:46 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-10-21 16:43:32 +0200eL_Bart0(eL_Bart0@dietunichtguten.org) (Quit: Restarting)
2023-10-21 16:44:54 +0200eL_Bart0(eL_Bart0@dietunichtguten.org)
2023-10-21 16:45:52 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-10-21 16:48:45 +0200fendor(~fendor@2a02:8388:1640:be00:aab:1226:f274:5021) (Remote host closed the connection)
2023-10-21 16:50:08 +0200 <yin> how do i write (λpq.ppq) and (λpq.pqp) in haskell>
2023-10-21 16:50:17 +0200 <yin> ?
2023-10-21 16:50:21 +0200fendor(~fendor@2a02:8388:1640:be00:aab:1226:f274:5021)
2023-10-21 16:50:42 +0200 <tromp> p p q won't typee-check
2023-10-21 16:50:48 +0200 <yin> no it won't
2023-10-21 16:51:30 +0200 <yin> iiuc it's because i would need some kind of recursive type?
2023-10-21 16:51:31 +0200 <tromp> of course you could have data Lambda = Abs ... | App ... | Var ...
2023-10-21 16:52:16 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:49ec:9442:e7af:3828)
2023-10-21 16:53:20 +0200 <[Leary]> % :t \p q -> p p q
2023-10-21 16:53:21 +0200 <yahb2> <interactive>:1:11: error: ; • Couldn't match expected type ‘t’ with actual type ‘t -> t1 -> t2’ ; ‘t’ is a rigid type variable bound by ; the inferred type of it :: (t -> t1 -> t...
2023-10-21 16:53:33 +0200 <[Leary]> % newtype T a b = T{ ($$) :: T a b -> a -> b }
2023-10-21 16:53:33 +0200 <yahb2> <no output>
2023-10-21 16:53:44 +0200pavonia(~user@user/siracusa) (Quit: Bye!)
2023-10-21 16:53:47 +0200 <[Leary]> % :t \p q -> (p $$ p) q
2023-10-21 16:53:47 +0200 <yahb2> \p q -> (p $$ p) q :: forall {a} {b}. T a b -> a -> b
2023-10-21 16:55:38 +0200 <yin> i don't think i can wrap my head around that by myself
2023-10-21 16:55:40 +0200 <yin> let me try
2023-10-21 17:01:18 +0200 <[Leary]> yin: `T t1 t2` is a solution (sans wrappers) to the equation `t = t -> t1 -> t2` that the type checker is complaining about being unable to solve.
2023-10-21 17:02:05 +0200rgw(~R@2605:a601:a0df:5600:5007:462b:c57d:9381)
2023-10-21 17:03:11 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:49ec:9442:e7af:3828) (Ping timeout: 272 seconds)
2023-10-21 17:07:19 +0200 <yin> what about \p q -> p q p ?
2023-10-21 17:08:21 +0200 <[Leary]> % :t \p q -> p q p
2023-10-21 17:08:21 +0200 <yahb2> <interactive>:1:13: error: ; • Couldn't match expected type ‘t1’ ; with actual type ‘t -> t1 -> t2’ ; ‘t1’ is a rigid type variable bound by ; the inferred type ...
2023-10-21 17:09:07 +0200 <[Leary]> So for this, you want to solve `t1 = t -> t1 -> t2` instead.
2023-10-21 17:12:43 +0200 <yin> ok let me try to figure it out
2023-10-21 17:16:47 +0200 <yin> [Leary]: https://paste.jrvieira.com/1697901399353 ?
2023-10-21 17:17:29 +0200P1RATEZ(piratez@user/p1ratez)
2023-10-21 17:17:54 +0200moni(~moni@cpe-174-106-185-141.ec.res.rr.com) (Remote host closed the connection)
2023-10-21 17:18:43 +0200 <yin> oh, no
2023-10-21 17:18:55 +0200 <yin> should be `a -> AND a b -> b`
2023-10-21 17:18:56 +0200 <yin> right?
2023-10-21 17:20:16 +0200 <yin> https://paste.jrvieira.com/1697901614713
2023-10-21 17:22:27 +0200 <[Leary]> Looks right to me.
2023-10-21 17:24:47 +0200 <yin> i can just do `newtype T a b = T { ($$) :: T a b -> T a b -> T a b }` ?
2023-10-21 17:27:34 +0200 <int-e> You can, but how do you ever inspect such a value?
2023-10-21 17:27:43 +0200 <[Leary]> Err. You can do `newtype LC = LC (LC -> LC)` (which your type is equivalent to) and indeed encode arbitrary lambda calculus terms, but good luck doing anything useful with this representation.
2023-10-21 17:30:04 +0200 <int-e> You can inject exceptions (using unsafePerformIO) and get some insight into such terms but it gets very convoluted quickly.
2023-10-21 17:32:59 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 245 seconds)
2023-10-21 17:38:40 +0200 <[Leary]> % lcfix :: (a -> a) -> a; lcfix = unsafeCoerce $ LC \f -> (LC \x -> f $$ (x $$ x)) $$ (LC \x -> f $$ (x $$ x))
2023-10-21 17:38:41 +0200 <yahb2> <interactive>:9:51: error: ; Unexpected lambda expression in function application: ; \ f -> (LC \ x -> f $$ (x $$ x)) $$ (LC \ x -> f $$ (x $$ x)) ; You could write it with parenthe...
2023-10-21 17:38:51 +0200 <[Leary]> % :set -BlockArguments
2023-10-21 17:38:52 +0200 <yahb2> Some flags have not been recognized: -BlockArguments
2023-10-21 17:38:55 +0200 <[Leary]> % :set -XBlockArguments
2023-10-21 17:38:56 +0200 <yahb2> <no output>
2023-10-21 17:38:58 +0200 <[Leary]> % lcfix :: (a -> a) -> a; lcfix = unsafeCoerce $ LC \f -> (LC \x -> f $$ (x $$ x)) $$ (LC \x -> f $$ (x $$ x))
2023-10-21 17:38:58 +0200 <yahb2> <no output>
2023-10-21 17:39:07 +0200 <[Leary]> % lcfix (\lucas a b -> a:lucas b (a + b)) 0 1
2023-10-21 17:39:07 +0200 <yahb2> [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,3908...
2023-10-21 17:39:19 +0200 <[Leary]> Correction: when there's a will, there's a way.
2023-10-21 17:39:27 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 17:40:01 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:49ec:9442:e7af:3828)
2023-10-21 17:41:46 +0200audio(~audio@user/audio)
2023-10-21 17:42:35 +0200euleritian(~euleritia@dynamic-046-114-109-096.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-10-21 17:42:54 +0200euleritian(~euleritia@77.22.252.56)
2023-10-21 17:44:05 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 240 seconds)
2023-10-21 17:44:58 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 17:45:29 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-10-21 17:45:38 +0200 <yin> nice
2023-10-21 17:49:35 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 240 seconds)
2023-10-21 17:50:10 +0200 <yin> % lcfix' :: (a -> a) -> a; lcfix' = unsafeCoerce $ LC \f -> (LC \x -> x $$ x) $$ (LC \x -> f $$ (x $$ x))
2023-10-21 17:50:11 +0200 <yahb2> <no output>
2023-10-21 17:50:16 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-10-21 17:50:31 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 17:50:34 +0200 <yin> % lcfix' (\lucas a b -> a:lucas b (a + b)) 0 1
2023-10-21 17:50:34 +0200 <yahb2> [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,3908...
2023-10-21 17:51:37 +0200euleritian(~euleritia@77.22.252.56) (Ping timeout: 255 seconds)
2023-10-21 17:53:32 +0200 <yin> % lcfix' (\lucas a b -> a:lucas b (a + b)) 2 1 -- for consistency
2023-10-21 17:53:32 +0200 <yahb2> [2,1,3,4,7,11,18,29,47,76,123,199,322,521,843,1364,2207,3571,5778,9349,15127,24476,39603,64079,103682,167761,271443,439204,710647,1149851,1860498,3010349,4870847,7881196,12752043,20633239,33385282,...
2023-10-21 17:55:04 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 245 seconds)
2023-10-21 17:55:47 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-10-21 17:56:04 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 17:58:22 +0200Vajb(~Vajb@207.61.167.122)
2023-10-21 17:58:47 +0200 <audio> i was here years ago and remember you guys being interesting people
2023-10-21 17:58:50 +0200 <audio> is that still the case?
2023-10-21 18:00:26 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 246 seconds)
2023-10-21 18:01:36 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 18:03:23 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 260 seconds)
2023-10-21 18:04:14 +0200myme(~myme@2a01:799:d60:e400:9f43:ca0d:9ecf:24fd)
2023-10-21 18:06:02 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 246 seconds)
2023-10-21 18:07:21 +0200Vajb(~Vajb@207.61.167.122) (Ping timeout: 260 seconds)
2023-10-21 18:07:46 +0200 <monochrom> I think I am still interesting, and more interesting than before. >:)
2023-10-21 18:08:08 +0200 <dolio> Hmm, I don't know...
2023-10-21 18:08:21 +0200sm(~sm@plaintextaccounting/sm)
2023-10-21 18:08:33 +0200 <monochrom> Self assessments need to be biased!
2023-10-21 18:09:32 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 256 seconds)
2023-10-21 18:13:01 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 18:14:13 +0200qqq(~qqq@92.43.167.61) (Remote host closed the connection)
2023-10-21 18:14:29 +0200 <shapr> @quote
2023-10-21 18:14:29 +0200 <lambdabot> mauke_ says: sin x / n = six / 1 = 6
2023-10-21 18:14:33 +0200 <shapr> audio: maybe?
2023-10-21 18:14:49 +0200 <shapr> audio: what do you consider interesting?
2023-10-21 18:17:33 +0200myme(~myme@2a01:799:d60:e400:9f43:ca0d:9ecf:24fd) (Quit: WeeChat 4.0.5)
2023-10-21 18:17:48 +0200myme(~myme@2a01:799:d60:e400:9f43:ca0d:9ecf:24fd)
2023-10-21 18:22:36 +0200Xe(~cadey@perl/impostor/xe) (Ping timeout: 248 seconds)
2023-10-21 18:22:58 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 272 seconds)
2023-10-21 18:24:40 +0200Xe(~cadey@perl/impostor/xe)
2023-10-21 18:25:40 +0200Nixkernal(~Nixkernal@115.16.194.178.dynamic.wline.res.cust.swisscom.ch) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-10-21 18:26:17 +0200Nixkernal(~Nixkernal@115.16.194.178.dynamic.wline.res.cust.swisscom.ch)
2023-10-21 18:28:21 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 260 seconds)
2023-10-21 18:29:35 +0200euleritian(~euleritia@77.22.252.56)
2023-10-21 18:29:43 +0200 <yin> how do i import the list type when i have NoImplicitPrelude?
2023-10-21 18:31:48 +0200 <monochrom> I think the list type is always there as syntax. I haven't checked.
2023-10-21 18:33:47 +0200euleritian(~euleritia@77.22.252.56) (Ping timeout: 255 seconds)
2023-10-21 18:37:11 +0200 <yin> you're right it seems
2023-10-21 18:42:08 +0200erisco_(~erisco@d24-141-66-165.home.cgocable.net)
2023-10-21 18:44:30 +0200erisco(~erisco@d24-141-66-165.home.cgocable.net) (Ping timeout: 272 seconds)
2023-10-21 18:44:30 +0200erisco_erisco
2023-10-21 18:45:27 +0200kraftwerk28(~kraftwerk@164.92.219.160) (Ping timeout: 240 seconds)
2023-10-21 18:46:17 +0200Yumemi(~Yumemi@chamoin.net) (Ping timeout: 240 seconds)
2023-10-21 18:46:23 +0200kraftwerk28(~kraftwerk@164.92.219.160)
2023-10-21 18:46:34 +0200Yumemi(~Yumemi@2001:bc8:47a0:1b14::1)
2023-10-21 18:46:42 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Remote host closed the connection)
2023-10-21 18:46:56 +0200waleee(~waleee@2001:9b0:21c:e600:f2f3:f744:435d:137c)
2023-10-21 18:47:00 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-10-21 18:48:24 +0200califax(~califax@user/califx) (Remote host closed the connection)
2023-10-21 18:49:27 +0200califax(~califax@user/califx)
2023-10-21 18:52:14 +0200__monty__(~toonn@user/toonn)
2023-10-21 18:56:39 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Ping timeout: 240 seconds)
2023-10-21 18:58:45 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2023-10-21 19:01:57 +0200Vajb(~Vajb@207.61.167.122)
2023-10-21 19:07:38 +0200todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-10-21 19:14:37 +0200 <Unicorn_Princess> hmmm... what's the consensus on prefixing query functions with verbs? like `isEven` vs `even`, or `takeFirstWord` vs `firstWord`?
2023-10-21 19:14:59 +0200 <Unicorn_Princess> the versions without verbs seem more elegant and concise, but i suspect it leads to confusion...
2023-10-21 19:15:35 +0200 <geekosaur> :t even
2023-10-21 19:15:36 +0200 <lambdabot> Integral a => a -> Bool
2023-10-21 19:15:43 +0200 <geekosaur> base likes the prefix-less ones
2023-10-21 19:16:10 +0200kanto(~kantokuen@user/kantokuen) (Remote host closed the connection)
2023-10-21 19:16:37 +0200kantokuen(~kantokuen@user/kantokuen)
2023-10-21 19:16:37 +0200 <geekosaur> well, that's not entirely true, but I think the exceptions are when the unprefixed ones don't work
2023-10-21 19:16:46 +0200 <geekosaur> :t Data.Maybe.isNothing
2023-10-21 19:16:47 +0200 <lambdabot> Maybe a -> Bool
2023-10-21 19:17:41 +0200 <Unicorn_Princess> System.Directory and .FilePath mostly use the prefixed ones
2023-10-21 19:18:28 +0200 <Unicorn_Princess> i often want to name variables/parameters the same as unprefixed functions, too
2023-10-21 19:20:59 +0200nucranium(~nucranium@2a02:8010:6173:0:7d81:65c5:a598:8bba)
2023-10-21 19:21:14 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-10-21 19:21:18 +0200tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net)
2023-10-21 19:24:20 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-10-21 19:24:39 +0200audio(~audio@user/audio) ()
2023-10-21 19:25:38 +0200 <EvanR> Unicorn_Princess, I brought this up at some point. Functions aren't always verbs
2023-10-21 19:25:48 +0200 <EvanR> haskell has lots of parts of speech
2023-10-21 19:26:39 +0200 <EvanR> maybe IO actions are always verbs because imperative programming
2023-10-21 19:27:10 +0200 <dolio> They aren't.
2023-10-21 19:28:39 +0200 <Unicorn_Princess> unrelated, if i installed my haskell stuff with ghcup, do i still need to run `cabal update`? and if i don't specify a version in mypackage.cabal, what determines which version it uses, or which are available? i notice i'm not always getting the latest that is on hackage
2023-10-21 19:29:01 +0200 <mauke> open, put, get, close
2023-10-21 19:29:05 +0200 <mauke> imperative
2023-10-21 19:29:21 +0200 <dolio> directoryContents
2023-10-21 19:29:32 +0200 <EvanR> open could be an adjective and fork could be a noun xD
2023-10-21 19:29:41 +0200 <ncf> isn't it getDirectoryContents
2023-10-21 19:29:43 +0200 <mauke> square root, even, ord, chr -- declarative
2023-10-21 19:29:46 +0200 <dolio> Oh, is it?
2023-10-21 19:30:01 +0200todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-10-21 19:30:12 +0200 <ncf> i like that adverbs modify verbs, i.e. atomically :: STM a → IO a
2023-10-21 19:30:19 +0200 <EvanR> ^
2023-10-21 19:30:24 +0200 <sclv> Unicorn_Princess: `cabal update` should be run to update the _hackage index_ -- ghcup runs it for you on install, but you need to run it periodically to update the view of hackage.
2023-10-21 19:30:35 +0200 <mauke> atomically is badly named and should be something like runSTM
2023-10-21 19:30:41 +0200califax(~califax@user/califx) (Remote host closed the connection)
2023-10-21 19:31:02 +0200 <EvanR> atomically rocks
2023-10-21 19:31:08 +0200 <sclv> the version used is determined by cabal running a solver that attempts to use the latest compatible version with otherwise-constrained libraries -- e.g. the version of base that is builtin to the ghc you have installed, etc.
2023-10-21 19:31:16 +0200 <mauke> alternatively, STM should be renamed to Atomically or something
2023-10-21 19:31:39 +0200 <sclv> `run` is usually reserved for functions of the form `m a -> a`
2023-10-21 19:31:50 +0200 <sclv> or which take some other arguments, but eventually yield something of that form
2023-10-21 19:32:02 +0200 <mauke> :t runReaderT
2023-10-21 19:32:03 +0200 <lambdabot> ReaderT r m a -> r -> m a
2023-10-21 19:32:27 +0200 <Unicorn_Princess> sclv, thanks!
2023-10-21 19:32:38 +0200califax(~califax@user/califx)
2023-10-21 19:32:43 +0200 <haskellbridge> <I​nst> I'd see functions as verbs and non-function values as nouns.
2023-10-21 19:32:46 +0200 <mauke> the point is that there is no way to run an STM computation non-atomically
2023-10-21 19:33:05 +0200 <mauke> but the existence of 'atomically' suggests that there is
2023-10-21 19:33:09 +0200 <haskellbridge> <I​nst> You can noun a verb by wrapping it in a newtype, or putting it into a container.
2023-10-21 19:33:10 +0200 <geekosaur> note that that also works in the other direction, you can specify a timestamp to `cabal update` to set the Hackage view to the one current at that time
2023-10-21 19:34:12 +0200 <haskellbridge> <I​nst> verb a noun with const? :)
2023-10-21 19:35:01 +0200 <sclv> :t flip runReader
2023-10-21 19:35:02 +0200 <lambdabot> r -> Reader r c -> c
2023-10-21 19:35:05 +0200 <sclv> :-P
2023-10-21 19:36:22 +0200 <EvanR> but also atomically emphasizes that you are running the action atomically while runSTM doesn't as much, though it contains a T for transaction it's not as in-your-face
2023-10-21 19:36:48 +0200 <EvanR> and atomic stuff should be in your face!
2023-10-21 19:37:30 +0200friendshipaka(~Friendshi@user/Friendship) (Ping timeout: 255 seconds)
2023-10-21 19:38:32 +0200 <mauke> for me it had the opposite effect
2023-10-21 19:39:34 +0200 <mauke> because I was relying on atomicity when putting together critical parts of my STM actions, but I couldn't find a way to use 'atomically' in STM because it would only return IO
2023-10-21 19:39:41 +0200target_i(~target_i@217.175.14.39)
2023-10-21 19:40:04 +0200 <mauke> so I kept worrying that someone might inadvertently use my actions non-atomically and break invariants
2023-10-21 19:40:28 +0200 <mauke> until I realized that 'atomically' is misnamed and the part that guarantees atomicity is STM itself, not the run function
2023-10-21 19:43:12 +0200 <haskellbridge> <I​nst> if then else vs guards for only 1 cond: which is better on function definition level?
2023-10-21 19:44:53 +0200Vajb(~Vajb@207.61.167.122) (Ping timeout: 260 seconds)
2023-10-21 19:47:21 +0200 <EvanR> I only use if then else if it's very small and readable
2023-10-21 19:53:19 +0200idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-10-21 19:55:36 +0200 <monochrom> Every case is different.
2023-10-21 19:56:51 +0200 <monochrom> I am not afraid of choosing one way that looks nice here-and-now, and changing to the other way in the future if there needs change.
2023-10-21 19:58:03 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 20:02:08 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-10-21 20:02:58 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 260 seconds)
2023-10-21 20:03:45 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 20:04:39 +0200nucranium(~nucranium@2a02:8010:6173:0:7d81:65c5:a598:8bba) (Ping timeout: 245 seconds)
2023-10-21 20:05:42 +0200stilgart(~Christoph@chezlefab.net) (Quit: leaving)
2023-10-21 20:05:52 +0200stilgart(~Christoph@chezlefab.net)
2023-10-21 20:08:37 +0200P1RATEZ(piratez@user/p1ratez) (Remote host closed the connection)
2023-10-21 20:08:48 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 260 seconds)
2023-10-21 20:09:41 +0200wroathe(~wroathe@50.205.197.50)
2023-10-21 20:09:41 +0200wroathe(~wroathe@50.205.197.50) (Changing host)
2023-10-21 20:09:41 +0200wroathe(~wroathe@user/wroathe)
2023-10-21 20:13:26 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2023-10-21 20:13:47 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-10-21 20:14:41 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 20:19:46 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 260 seconds)
2023-10-21 20:19:51 +0200fweht(uid404746@id-404746.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-10-21 20:20:24 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 20:24:37 +0200sm(~sm@plaintextaccounting/sm) (Quit: sm)
2023-10-21 20:24:56 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 255 seconds)
2023-10-21 20:25:58 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 20:30:36 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 255 seconds)
2023-10-21 20:31:30 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 20:33:19 +0200cpressey(~cpressey@host-92-10-146-234.as13285.net) (Ping timeout: 248 seconds)
2023-10-21 20:35:15 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-10-21 20:35:56 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 248 seconds)
2023-10-21 20:43:52 +0200Sgeo(~Sgeo@user/sgeo)
2023-10-21 20:48:50 +0200cpressey(~cpressey@host-92-21-194-169.as13285.net)
2023-10-21 20:53:01 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 260 seconds)
2023-10-21 20:53:29 +0200falafel(~falafel@62.175.113.194.dyn.user.ono.com)
2023-10-21 20:54:01 +0200 <haskellbridge> <I​nst> If then else still has utility if you're writing a pure expression, for instance, putStrLn (if foo == bar then "OK" else "Error")
2023-10-21 20:54:26 +0200 <haskellbridge> <I​nst> or that could be written as putStrLn $ if foo == bar then "OK" else "Error"
2023-10-21 20:55:03 +0200 <haskellbridge> <I​nst> Also, why is coerce unreliable?
2023-10-21 20:55:35 +0200 <haskellbridge> <I​nst> I'm trying to get it to open a newtype, but it turns out it can't figure out how to coerce into Vector (Vector Bool) for a for_ HOF, and requires type annotations
2023-10-21 20:55:59 +0200 <EvanR> the parentheses version looks much better from here
2023-10-21 20:56:28 +0200 <EvanR> if then else works fine on IO actions
2023-10-21 20:56:35 +0200 <EvanR> also
2023-10-21 20:56:46 +0200 <mauke> % putStrLn if 1 == 2 then "OK" else "Error"
2023-10-21 20:56:46 +0200 <yahb2> Error
2023-10-21 20:57:18 +0200 <EvanR> mind blown
2023-10-21 20:57:27 +0200 <mauke> blog arguments
2023-10-21 20:57:30 +0200Inst(~Inst@120.244.192.250)
2023-10-21 20:57:52 +0200 <Inst> % {-# LANGUAGE BlockArguments #-}
2023-10-21 20:57:53 +0200 <yahb2> <no output>
2023-10-21 20:58:10 +0200 <Inst> % putStrLn if 1 == 2 then "OK" else "Error"
2023-10-21 20:58:11 +0200 <yahb2> Error
2023-10-21 20:58:30 +0200 <monochrom> Unpopular opinion: MultiwayIf is also pretty nifty.
2023-10-21 20:58:47 +0200 <Inst> ^^^
2023-10-21 20:58:51 +0200 <monochrom> It looks like guards but it's an expression.
2023-10-21 20:59:22 +0200 <mauke> % [putStrLn "OK", putStrLn "Error"] !! fromEnum (1 == 2) -- who needs if
2023-10-21 20:59:22 +0200 <yahb2> OK
2023-10-21 20:59:50 +0200 <monochrom> Ugh haha
2023-10-21 21:00:05 +0200 <EvanR> install aviary and use combinators
2023-10-21 21:00:19 +0200 <Inst> newConway | 0 `elem` [cols, rows] = conway | otherwise = ...
2023-10-21 21:00:27 +0200 <monochrom> Darn I have also needed a {false,true}->{0,1} function and I forgot that fromEnum does it. :)
2023-10-21 21:00:34 +0200monochromgoes change his code!
2023-10-21 21:00:51 +0200 <mauke> % [putStrLn "OK", putStrLn "Error"] !! unsafeCoerce (1 == 2) -- who needs fromEnum
2023-10-21 21:00:52 +0200 <yahb2> *** Exception: Prelude.!!: index too large
2023-10-21 21:00:54 +0200 <mauke> aww
2023-10-21 21:01:09 +0200 <mauke> right, I forgot
2023-10-21 21:01:29 +0200 <EvanR> so I dare ask how that was supposed to work
2023-10-21 21:01:57 +0200 <mauke> it works in C!
2023-10-21 21:02:10 +0200 <Inst> you just made me crash my GHCI :(
2023-10-21 21:02:19 +0200 <EvanR> I don't know how that explains it or if it even is true xD
2023-10-21 21:02:35 +0200 <monochrom> Ah I see, I wanted the 0 and 1 to be Double.
2023-10-21 21:03:10 +0200 <EvanR> !! [0.0, 1.0] !! fromEnum (1 == 2)
2023-10-21 21:03:16 +0200 <EvanR> or something
2023-10-21 21:03:27 +0200 <mauke> newtype Bool = Bool Double; true = Bool 1; false = Bool 0
2023-10-21 21:03:38 +0200 <Inst> % unsafeCoerce True :: Int
2023-10-21 21:03:39 +0200 <yahb2> -576460205259816976
2023-10-21 21:03:49 +0200 <Inst> % unsafeCoerce True :: Word
2023-10-21 21:03:49 +0200 <yahb2> 17870283868449734640
2023-10-21 21:03:57 +0200 <Inst> % unsafeCoerce True :: Int
2023-10-21 21:03:58 +0200 <yahb2> -576460205259816976
2023-10-21 21:04:20 +0200 <EvanR> you can't handle the truth
2023-10-21 21:04:55 +0200 <EvanR> (with unsafeCoerce)
2023-10-21 21:05:42 +0200 <monochrom> An Insecure Truth
2023-10-21 21:05:53 +0200 <mauke> % unsafeCoerce False :: Maybe ()
2023-10-21 21:05:54 +0200 <yahb2> Nothing
2023-10-21 21:06:00 +0200 <mauke> ah, that looks promising
2023-10-21 21:06:05 +0200 <monochrom> @quote monochrom unsafeCoerce
2023-10-21 21:06:05 +0200 <lambdabot> monochrom says: isTrue = (unsafeCoerce :: Either a b -> Bool) . (unsafeCoerce :: Maybe c -> Either a b) . (unsafeCoerce :: Bool -> Maybe c)
2023-10-21 21:07:19 +0200 <mauke> % maybe (putStrLn "Error") (\ ~()-> putStrLn "OK") (unsafeCoerce (1 == 2))
2023-10-21 21:07:19 +0200 <yahb2> Error
2023-10-21 21:07:24 +0200Lycurgus(~georg@user/Lycurgus)
2023-10-21 21:10:39 +0200 <EvanR> :t coerce
2023-10-21 21:10:40 +0200 <lambdabot> error:
2023-10-21 21:10:40 +0200 <lambdabot> • Variable not in scope: coerce
2023-10-21 21:10:40 +0200 <lambdabot> • Perhaps you meant ‘coerced’ (imported from Control.Lens)
2023-10-21 21:11:01 +0200 <tomsmeding> % :t Data.Coerce.coerce
2023-10-21 21:12:03 +0200JuanDaugherty(~juan@user/JuanDaugherty)
2023-10-21 21:12:16 +0200 <EvanR> Inst, it's a -> b, it can easily fail to infer a or b due to ambiguity if there's no other type information around. Luckily there's no defaulting
2023-10-21 21:13:02 +0200 <monochrom> % maybe (putStrLn "Error") (\ ~()-> putStrLn "OK") (unsafeCoerce (1 == 1))
2023-10-21 21:13:02 +0200 <yahb2> OK
2023-10-21 21:13:20 +0200 <monochrom> That is awesome and awful at the same time. :)
2023-10-21 21:13:26 +0200 <tomsmeding> % maybe (putStrLn "Error") (\(Just _) -> putStrLn "OK") (unsafeCoerce (1 == 1))
2023-10-21 21:13:26 +0200 <yahb2> /workdir/entry.sh: line 6: 4 Segmentation fault (core dumped) ghcup --offline run -- ghci Yahb2Defs.hs 2>&1
2023-10-21 21:13:30 +0200 <tomsmeding> :D
2023-10-21 21:13:33 +0200 <tomsmeding> % 42
2023-10-21 21:13:34 +0200 <yahb2> Oops, something went wrong
2023-10-21 21:13:35 +0200 <tomsmeding> % 42
2023-10-21 21:13:36 +0200 <yahb2> 42
2023-10-21 21:13:41 +0200 <tomsmeding> okay it's alive again
2023-10-21 21:14:11 +0200 <tomsmeding> I love how that shell output just ends up in irc -- it makes sense given how the thing is set up
2023-10-21 21:14:34 +0200 <EvanR> you cause yahb2 to shatter into a million pieces. Then they liquid metal reformed via advanced-for-the-time special effects
2023-10-21 21:15:37 +0200 <monochrom> Sorry!
2023-10-21 21:16:06 +0200 <tomsmeding> monochrom: why are you apologising?
2023-10-21 21:16:20 +0200 <monochrom> For inspiring how to crash yahb2 :)
2023-10-21 21:16:24 +0200 <tomsmeding> :p
2023-10-21 21:16:51 +0200 <mauke> https://infosec.exchange/@barubary/111271784359087322
2023-10-21 21:17:17 +0200 <monochrom> :)
2023-10-21 21:17:39 +0200 <tomsmeding> I wonder why they specifically called out haskell
2023-10-21 21:17:59 +0200 <EvanR> and that's why we have the sense of => backwards in type class / instance definitions
2023-10-21 21:18:15 +0200 <monochrom> But Bool's <= is stricter than necessary. False `implies` undefined could be True rather than bottoming out.
2023-10-21 21:18:50 +0200 <tomsmeding> hence they should have used C or JS or whatever as an example, where that's not an issue :p
2023-10-21 21:18:55 +0200 <monochrom> I think because other languages either have no real Bool or do not order Bool.
2023-10-21 21:18:58 +0200 <EvanR> > False <= True
2023-10-21 21:18:59 +0200 <lambdabot> True
2023-10-21 21:19:03 +0200 <EvanR> > False <= undefined
2023-10-21 21:19:05 +0200 <lambdabot> *Exception: Prelude.undefined
2023-10-21 21:19:15 +0200 <EvanR> yeah but should False really be ordered earlier than bottom
2023-10-21 21:19:34 +0200 <EvanR> "who ordered that"
2023-10-21 21:19:36 +0200 <geekosaur> it's not ordering, it's laziness
2023-10-21 21:19:43 +0200 <monochrom> No, in C both 1 and -1 (and 2 and -2 and...) are true. You don't have a reliable false <= true.
2023-10-21 21:19:53 +0200 <monochrom> You don't even have true == true heh
2023-10-21 21:19:55 +0200 <tomsmeding> #include <stdbool.h>
2023-10-21 21:19:57 +0200 <EvanR> "False <= undefined could be True"
2023-10-21 21:20:03 +0200 <tomsmeding> monochrom: you have true == true
2023-10-21 21:20:19 +0200 <geekosaur> yes, because you only need to see the Fslse
2023-10-21 21:20:20 +0200 <tomsmeding> you just don't have that !!x && !!y implies x == y
2023-10-21 21:20:28 +0200 <geekosaur> *False
2023-10-21 21:20:28 +0200 <EvanR> it could also be False
2023-10-21 21:20:31 +0200 <monochrom> Right OK.
2023-10-21 21:21:23 +0200 <monochrom> && and || are already conditionally non-strict in the 2nd argument. I would implement implies to be like that too.
2023-10-21 21:21:47 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-10-21 21:21:51 +0200 <monochrom> I don't mean everyone should accept it, but socially many people may expect it.
2023-10-21 21:21:52 +0200 <geekosaur> that's my take as well
2023-10-21 21:22:14 +0200 <geekosaur> once you see the first argument is False, you don't care about the second
2023-10-21 21:22:19 +0200 <tomsmeding> !a || b is lazy enough
2023-10-21 21:22:30 +0200 <mauke> why shouldn't minBound <= _ = True everywhere?
2023-10-21 21:22:35 +0200 <monochrom> I hate !a || b :)
2023-10-21 21:22:43 +0200 <tomsmeding> doesn't handle 'undefined => True', but then neither ooes (||)
2023-10-21 21:22:45 +0200 <tomsmeding> *does
2023-10-21 21:23:22 +0200JuanDaugherty(~juan@user/JuanDaugherty) (Quit: JuanDaugherty)
2023-10-21 21:24:13 +0200 <monochrom> mauke: Along the same line, why shouldn't 0 * _ = 0 almost everywhere? :)
2023-10-21 21:26:02 +0200 <mauke> > undefined ^ 0
2023-10-21 21:26:04 +0200 <lambdabot> 1
2023-10-21 21:26:09 +0200 <monochrom> <3
2023-10-21 21:26:24 +0200 <mauke> > undefined ^ 0 <3
2023-10-21 21:26:26 +0200 <lambdabot> True
2023-10-21 21:26:33 +0200 <monochrom> :(
2023-10-21 21:27:18 +0200 <tomsmeding> :p
2023-10-21 21:32:42 +0200idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.0.5)
2023-10-21 21:33:25 +0200 <EvanR> :[]
2023-10-21 21:33:39 +0200 <tomsmeding> Ö
2023-10-21 21:33:50 +0200 <mauke> ö_ö
2023-10-21 21:35:35 +0200vglfr(~vglfr@37.73.16.154) (Read error: Connection reset by peer)
2023-10-21 21:38:38 +0200falafel(~falafel@62.175.113.194.dyn.user.ono.com) (Ping timeout: 260 seconds)
2023-10-21 21:46:59 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-10-21 21:49:11 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 21:51:58 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 272 seconds)
2023-10-21 21:52:22 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-10-21 21:57:01 +0200Lycurgus(~georg@user/Lycurgus) (Quit: leaving)
2023-10-21 21:59:34 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 272 seconds)
2023-10-21 22:04:53 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-10-21 22:11:41 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 22:13:53 +0200ystael(~ystael@user/ystael)
2023-10-21 22:16:32 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 255 seconds)
2023-10-21 22:17:23 +0200wroathe(~wroathe@user/wroathe) (Quit: leaving)
2023-10-21 22:21:13 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-10-21 22:22:40 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 22:26:15 +0200ystael(~ystael@user/ystael) (Ping timeout: 240 seconds)
2023-10-21 22:29:03 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 240 seconds)
2023-10-21 22:30:17 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.5)
2023-10-21 22:31:04 +0200Square(~Square@user/square) (Ping timeout: 255 seconds)
2023-10-21 22:31:37 +0200Vajb(~Vajb@207.61.167.122)
2023-10-21 22:34:05 +0200hpc(~juzz@ip98-169-35-163.dc.dc.cox.net) (Ping timeout: 255 seconds)
2023-10-21 22:35:49 +0200hpc(~juzz@ip98-169-35-163.dc.dc.cox.net)
2023-10-21 22:36:27 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 22:37:59 +0200myme(~myme@2a01:799:d60:e400:9f43:ca0d:9ecf:24fd) (Quit: WeeChat 4.0.5)
2023-10-21 22:41:07 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 258 seconds)
2023-10-21 22:43:15 +0200myme(~myme@2a01:799:d60:e400:9f43:ca0d:9ecf:24fd)
2023-10-21 22:48:20 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 256 seconds)
2023-10-21 22:49:44 +0200Square(~Square@user/square)
2023-10-21 22:50:59 +0200gmg(~user@user/gehmehgeh) (Quit: Leaving)
2023-10-21 22:52:11 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Remote host closed the connection)
2023-10-21 22:52:33 +0200dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-10-21 22:52:49 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 22:56:34 +0200[exa](~exa@srv3n.blesmrt.net) (Remote host closed the connection)
2023-10-21 22:57:16 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 248 seconds)
2023-10-21 23:01:19 +0200alphacentauri(alphacenta@gateway/vpn/protonvpn/alphacentauri) (Quit: WeeChat 4.1.0)
2023-10-21 23:01:56 +0200ChaiTRex(~ChaiTRex@user/chaitrex) (Ping timeout: 256 seconds)
2023-10-21 23:02:31 +0200alphacentauri(alphacenta@gateway/vpn/protonvpn/alphacentauri)
2023-10-21 23:03:04 +0200ChaiTRex(~ChaiTRex@user/chaitrex)
2023-10-21 23:06:06 +0200alphacen1(~alphacent@modemcable048.127-56-74.mc.videotron.ca)
2023-10-21 23:07:58 +0200alphacentauri(alphacenta@gateway/vpn/protonvpn/alphacentauri) (Ping timeout: 272 seconds)
2023-10-21 23:08:14 +0200alphacen1(~alphacent@modemcable048.127-56-74.mc.videotron.ca) (Client Quit)
2023-10-21 23:09:32 +0200Jackneill(~Jackneill@20014C4E1E0E6F0085D71214A6273985.dsl.pool.telekom.hu) (Ping timeout: 255 seconds)
2023-10-21 23:09:43 +0200dhruvasagar(~dhruvasag@49.207.194.211)
2023-10-21 23:10:02 +0200fendor(~fendor@2a02:8388:1640:be00:aab:1226:f274:5021) (Remote host closed the connection)
2023-10-21 23:13:56 +0200vglfr(~vglfr@138.199.53.246)
2023-10-21 23:14:50 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-10-21 23:17:08 +0200Pickchea(~private@user/pickchea)
2023-10-21 23:17:08 +0200Vajb(~Vajb@207.61.167.122) (Read error: Connection reset by peer)
2023-10-21 23:18:10 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-10-21 23:18:31 +0200sm(~sm@plaintextaccounting/sm)
2023-10-21 23:19:22 +0200dhruvasagar(~dhruvasag@49.207.194.211) (Ping timeout: 272 seconds)
2023-10-21 23:21:13 +0200myme(~myme@2a01:799:d60:e400:9f43:ca0d:9ecf:24fd) (Quit: WeeChat 4.0.5)
2023-10-21 23:25:16 +0200vglfr(~vglfr@138.199.53.246) (Ping timeout: 260 seconds)
2023-10-21 23:25:50 +0200vglfr(~vglfr@88.155.246.162)
2023-10-21 23:30:05 +0200vglfr(~vglfr@88.155.246.162) (Ping timeout: 240 seconds)
2023-10-21 23:30:38 +0200myme(~myme@2a01:799:d60:e400:9f43:ca0d:9ecf:24fd)
2023-10-21 23:31:08 +0200vglfr(~vglfr@88.155.246.162)
2023-10-21 23:33:12 +0200vglfr(~vglfr@88.155.246.162) (Read error: Connection reset by peer)
2023-10-21 23:40:34 +0200falafel(~falafel@62.175.113.194.dyn.user.ono.com)
2023-10-21 23:46:28 +0200 <Unicorn_Princess> hm. when chaining pure and monadic computations, e.g. to modify a file with `readFile file <&> fixContents >>= writeFile file`, one has to mix a bunch of different chaining operators, i.e. <&> and >>= in this case. i there some category theory magic that can simplify this? the conduit package looks promising
2023-10-21 23:46:35 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-10-21 23:53:51 +0200 <ncf> i'm not sure what kind of simplification you're after, but note that you can reassociate that to >>=/>>> instead of <&>/>>=
2023-10-21 23:53:56 +0200alphacentauri(alphacenta@gateway/vpn/protonvpn/alphacentauri)
2023-10-21 23:56:15 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2023-10-21 23:56:52 +0200 <Unicorn_Princess> https://github.com/snoyberg/conduit#readme has nice examples for what i have in mind
2023-10-21 23:57:29 +0200 <Unicorn_Princess> how would i jam >>> in there btw? i know very little about arrows
2023-10-21 23:58:29 +0200 <ncf> readFile file >>= (fixContents >>> writeFile file)
2023-10-21 23:58:47 +0200 <ncf> where (>>>) = flip (.)
2023-10-21 23:59:41 +0200 <geekosaur> I think that's essentially the one from Control.Category, not the one from Control.Arrow