IRCBrowse

2022/01/26

2022-01-26 00:00:13 +0100 <tomsmeding> I knew this existed in some form, just forgot the name ;)
2022-01-26 00:00:17 +0100 <SrPx> anyway, I realized mergesort is terrible for already sorted lists
2022-01-26 00:00:28 +0100 <SrPx> so I have no idea why quacksort is faster than sort for truly random lists
2022-01-26 00:00:54 +0100 <SrPx> the whole point was to make it faster by making it more likely for deep calls to be already sorted
2022-01-26 00:01:10 +0100 <SrPx> so yea idk what is going on and i need to go :pp
2022-01-26 00:01:12 +0100 <SrPx> thanks though, was fun
2022-01-26 00:07:17 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba) (Remote host closed the connection)
2022-01-26 00:08:13 +0100Henson(~kvirc@107-179-133-201.cpe.teksavvy.com) (Ping timeout: 240 seconds)
2022-01-26 00:08:15 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2022-01-26 00:09:08 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net)
2022-01-26 00:10:17 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2022-01-26 00:12:24 +0100rtsn(~nstr@user/rtsn) (Quit: Lost terminal)
2022-01-26 00:15:25 +0100machinedgod(~machinedg@24.105.81.50) (Ping timeout: 240 seconds)
2022-01-26 00:16:42 +0100alp(~alp@user/alp)
2022-01-26 00:17:15 +0100 <tomsmeding> SrPx: quacksort infinite loops if the first element of the list is maximal
2022-01-26 00:17:26 +0100 <tomsmeding> because then everything ends up in the first bucket ;)
2022-01-26 00:17:43 +0100 <tomsmeding> yay quickcheck
2022-01-26 00:19:19 +0100 <SrPx> lol!
2022-01-26 00:19:23 +0100 <SrPx> good catch
2022-01-26 00:19:47 +0100 <SrPx> the algorithm only would really make sense if `p` is a reasonable pivot
2022-01-26 00:20:02 +0100 <SrPx> now, the question is, would it still be faster on random lists if that's the case?
2022-01-26 00:20:18 +0100 <SrPx> i have no idea, but I posted it here just in case anyone wants to play with the algo: https://stackoverflow.com/questions/70856865/why-quacksort-is-2x-faster-than-data-lists-sort-for-r…
2022-01-26 00:22:43 +0100 <monochrom> If you pick your pivot uniformly randomly, or equivalently the list is a random shuffle so if you pick your pivot by deterministic position-in-list it's as good as random, then there are two theorems that apply:
2022-01-26 00:23:05 +0100 <monochrom> 1. The expected time is Θ(n lg n)
2022-01-26 00:23:30 +0100 <monochrom> 2. With high probability the worst-case time is Θ(n lg n).
2022-01-26 00:24:53 +0100 <monochrom> More precise statement for #2: If you accept a larger constant multiplier K for the worst-case time K * n lg n, then the probability of making it is also higher.
2022-01-26 00:25:22 +0100 <monochrom> (I forgot the most precise statement i.e. how high the probability is in terms of K.)
2022-01-26 00:27:07 +0100 <monochrom> If it is any consolation, in this the 21st century where every troll and blackhat is out to try to DoS you, the best and only known defense is randomization.
2022-01-26 00:28:49 +0100 <SrPx> isn't that the case for mergesort in general?
2022-01-26 00:29:18 +0100 <monochrom> Heh OK but people complain about mergesort's constant multiplier being large.
2022-01-26 00:29:34 +0100 <monochrom> @quote monochrom performance.freak
2022-01-26 00:29:34 +0100 <lambdabot> monochrom says: Programmers are control freaks, performance freaks, monopoly freaks.
2022-01-26 00:29:41 +0100 <monochrom> Fresh out of the oven today!
2022-01-26 00:30:22 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 00:31:43 +0100 <dsal> OO programmers are super freaks
2022-01-26 00:31:45 +0100AlexNoo_(~AlexNoo@178.34.162.240)
2022-01-26 00:31:49 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba)
2022-01-26 00:31:53 +0100 <monochrom> haha
2022-01-26 00:32:11 +0100 <Axman6> this
2022-01-26 00:33:51 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 256 seconds)
2022-01-26 00:34:57 +0100AlexNoo(~AlexNoo@178.34.150.81) (Ping timeout: 240 seconds)
2022-01-26 00:34:57 +0100Henson(~kvirc@107-179-133-201.cpe.teksavvy.com)
2022-01-26 00:34:59 +0100AlexZenon(~alzenon@178.34.150.81) (Ping timeout: 256 seconds)
2022-01-26 00:34:59 +0100Alex_test(~al_test@178.34.150.81) (Ping timeout: 256 seconds)
2022-01-26 00:35:31 +0100 <EvanR> is superfreak a superclass of freak or a subclass
2022-01-26 00:36:28 +0100 <geekosaur> "yes"
2022-01-26 00:37:03 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net) (Ping timeout: 256 seconds)
2022-01-26 00:37:10 +0100 <monochrom> What does the Dilbert Substitutability Principle say? >:)
2022-01-26 00:37:28 +0100 <tomsmeding> maerwald: isn't your go code wrong for lists of length 3? it does one pass with m=1 and i=0, i doesn't become 2 because 2 !< 3-2, then m doesn't become 2 because 2 !< 3-2, so it... exits, and never looked at the third element of the list?
2022-01-26 00:38:01 +0100 <Axman6> tomsmeding: you could have stopped after the fifth word
2022-01-26 00:38:49 +0100Alex_test(~al_test@178.34.162.240)
2022-01-26 00:38:50 +0100 <tomsmeding> Axman6: hm?
2022-01-26 00:38:56 +0100 <tomsmeding> it's late here, have mercy
2022-01-26 00:38:56 +0100CiaoSen(~Jura@p200300c95737a2002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 250 seconds)
2022-01-26 00:38:59 +0100AlexZenon(~alzenon@178.34.162.240)
2022-01-26 00:39:04 +0100 <monochrom> "isn't your go code wrong" :)
2022-01-26 00:39:07 +0100 <Axman6> "isn't your go code wrong" is usually true :P
2022-01-26 00:39:34 +0100 <tomsmeding> I mean, I'm not a fan of go, but people occasionally write correct code in it :p
2022-01-26 00:40:00 +0100 <monochrom> "isn't your code wrong" for language agnosticity :)
2022-01-26 00:40:08 +0100 <janus> even "isn't _your_ go code" would usually be true :P
2022-01-26 00:40:32 +0100 <tomsmeding> janus: now _that_ one is indeed accurate
2022-01-26 00:40:54 +0100 <monochrom> Is this like a new version of "what does it mean to be a good person?" :)
2022-01-26 00:40:59 +0100 <geekosaur> mine certainly would be (I don't know go, so…)
2022-01-26 00:41:17 +0100 <Axman6> you can defer learning
2022-01-26 00:43:11 +0100 <geekosaur> I'm in no hurry. if anything I want to poke at rust
2022-01-26 00:46:31 +0100 <monochrom> Ugh so today's lesson is "don't mess with sorting algorithms"? Both attempts today prove to be incorrect...
2022-01-26 00:46:52 +0100 <geekosaur> bobblesort :þ
2022-01-26 00:48:29 +0100 <tomsmeding> SrPx: with a really cheap fix for the inconvenient-pivot issue (can certainly be done more efficiently), quacksort is now a little bit slower than Data.List.sort
2022-01-26 00:48:47 +0100 <tomsmeding> but good news, my STArray based bottom-up mergesort is about twice as fast! (but not lazy)
2022-01-26 00:49:08 +0100 <SrPx> ah STArray should really destroy any pure algo
2022-01-26 00:49:12 +0100 <SrPx> how did you fix the pivot?
2022-01-26 00:49:33 +0100 <tomsmeding> https://paste.tomsmeding.com/RVS64Lfd
2022-01-26 00:49:38 +0100 <Axman6> would be interesting to compare to the discromination package's sorting stuff too
2022-01-26 00:49:51 +0100 <tomsmeding> in a really ugly and inefficient way, feel free to improve :p
2022-01-26 00:50:00 +0100 <tomsmeding> Axman6: feel free to incorporate, should be easy
2022-01-26 00:50:04 +0100 <tomsmeding> I'm going to bed :p
2022-01-26 00:50:32 +0100 <Axman6> %! cabal install discrimination
2022-01-26 00:50:32 +0100 <yahb> Axman6: [Segmentation fault]
2022-01-26 00:50:36 +0100 <Axman6> =)
2022-01-26 00:50:42 +0100 <tomsmeding> lolwat
2022-01-26 00:50:52 +0100tomsmedingis afk
2022-01-26 00:50:54 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 00:53:07 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Read error: Connection reset by peer)
2022-01-26 00:53:18 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 00:54:47 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 268 seconds)
2022-01-26 00:55:43 +0100lavaman(~lavaman@98.38.249.169)
2022-01-26 00:55:50 +0100jespada(~jespada@87.74.36.188) (Ping timeout: 250 seconds)
2022-01-26 00:57:22 +0100jespada(~jespada@87.74.36.188)
2022-01-26 00:57:57 +0100soxen(~bob@pool-173-54-217-168.nwrknj.fios.verizon.net) (Ping timeout: 240 seconds)
2022-01-26 00:59:54 +0100 <SrPx> tomsmeding: idk I think if we go the ST route we are kinda giving up on the essence of haskell
2022-01-26 00:59:56 +0100 <SrPx> i like purity
2022-01-26 01:00:17 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-26 01:02:29 +0100 <dsal> ST is awesome.
2022-01-26 01:03:25 +0100 <hpc> purity is just a convenient side-effect of first-class IO :P
2022-01-26 01:03:59 +0100 <SrPx> not sure I agree, I'd rather maintain a mutable mergesort in Rust than how it looks like in Haskell, for example
2022-01-26 01:04:13 +0100 <SrPx> but for pure algorithms, Haskell is just lightyears ahead
2022-01-26 01:04:17 +0100 <SrPx> but I guess it is a matter of taste
2022-01-26 01:04:32 +0100little_mac(~little_ma@2601:410:4300:3ce0:88e2:d81e:ca89:4a84) (Remote host closed the connection)
2022-01-26 01:04:44 +0100 <hpc> SrPx: that was mostly a joke
2022-01-26 01:05:06 +0100 <hpc> but i quite like being able to throw IO actions around without having to do goofy () -> whatever functions
2022-01-26 01:05:16 +0100 <SrPx> I meant that I don't agree ST is so awesome
2022-01-26 01:05:22 +0100 <hpc> oh, yeah
2022-01-26 01:05:26 +0100 <EvanR> SrPx, ST is a pure computation
2022-01-26 01:05:28 +0100 <SrPx> interestingly I do agree with what you said
2022-01-26 01:05:34 +0100little_mac(~little_ma@2601:410:4300:3ce0:e0d9:54a6:eecc:ef77)
2022-01-26 01:05:40 +0100 <hpc> hah
2022-01-26 01:05:49 +0100Erutuon(~Erutuon@user/erutuon) (Ping timeout: 240 seconds)
2022-01-26 01:05:55 +0100 <SrPx> EvanR: it is a pure computation wrapped in 7 layers of obtuse abstractions
2022-01-26 01:05:59 +0100 <hpc> SrPx: try this one on for size, haskell is my favorite imperative language and perl is my favorite functional language
2022-01-26 01:06:07 +0100 <SrPx> to represent an impure computation
2022-01-26 01:06:11 +0100 <EvanR> don't look at how many layers everything else has
2022-01-26 01:06:27 +0100 <EvanR> we want our layers to be air tight, which ST is
2022-01-26 01:06:34 +0100 <EvanR> like everything else pure here
2022-01-26 01:07:00 +0100 <SrPx> I look at the code. The code is just ugly. The kind of thing I'd rather touch than work with in my career
2022-01-26 01:07:16 +0100 <SrPx> perhaps my experience is affected by when I *had* to mess with ST a lot, a few years ago
2022-01-26 01:07:21 +0100 <SrPx> things might be way better by now
2022-01-26 01:07:52 +0100 <EvanR> giving someone, or yourself in the future, a pure function that you can just use and works, even if it uses impurity behind the scenes, is good
2022-01-26 01:08:10 +0100 <EvanR> otoh if someone or yourself in the future has to work on the insides for whatever reason, not so good
2022-01-26 01:08:19 +0100 <EvanR> but that's another story
2022-01-26 01:08:58 +0100 <EvanR> putting lego bricks together to make stuff is fun, messing with molten thermoplastic that lego bricks come from, not so great
2022-01-26 01:09:03 +0100Erutuon(~Erutuon@user/erutuon)
2022-01-26 01:10:22 +0100 <dsal> It's still a container that has specific rules you know things about.
2022-01-26 01:10:25 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17) (Remote host closed the connection)
2022-01-26 01:12:40 +0100 <SrPx> hmmmm
2022-01-26 01:13:21 +0100 <EvanR> an ST value is a container? 🤔
2022-01-26 01:13:33 +0100 <geekosaur> tomsmeding, I just realized that what I gave you will malfunction at the end of a line, although you may not care. /foo($|[^.]|\.($|[^c]|c($|[^o]|o($|[^m]))))/i *now* it's ugly :)
2022-01-26 01:13:53 +0100 <geekosaur> an ST computation is a container
2022-01-26 01:13:53 +0100 <hololeap> something else to note is that ST is a monad and you can run pure code in it just like you can with IO or anything else
2022-01-26 01:14:27 +0100 <geekosaur> within which you can use impurity as long as you don't let it leak out, and the container prevents you from making such leaks
2022-01-26 01:14:45 +0100 <EvanR> interesting take on the containing
2022-01-26 01:14:53 +0100 <dolio> ST is a way of calculating a pure result with an impure method, with a mechanism for ensuring that the impurity is localized. It's not just a pure representation of an impure method like IO.
2022-01-26 01:14:56 +0100 <EvanR> it doesn't contain a result, it contains the state thread
2022-01-26 01:15:07 +0100 <geekosaur> that's more or less what "state thread" means
2022-01-26 01:15:31 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17)
2022-01-26 01:15:38 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2022-01-26 01:15:54 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2022-01-26 01:16:03 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2022-01-26 01:16:36 +0100 <geekosaur> once upon a time I had a script to work those regexes for me since it's pretty mechanical… then came pcre
2022-01-26 01:16:37 +0100 <EvanR> containing in the sense of imprisoning something
2022-01-26 01:17:26 +0100 <EvanR> where as containers package is about eventually letting the things out
2022-01-26 01:17:48 +0100 <geekosaur> well, you are letting something out. just not the impurity with it
2022-01-26 01:17:52 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17) (Remote host closed the connection)
2022-01-26 01:23:32 +0100 <geekosaur> (ironically it was a perl script. perl was around for a while before pcre appeared)
2022-01-26 01:24:02 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2022-01-26 01:25:56 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 01:27:28 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17)
2022-01-26 01:28:20 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 250 seconds)
2022-01-26 01:28:57 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2022-01-26 01:28:57 +0100haskellberryfinn(~nut@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Ping timeout: 240 seconds)
2022-01-26 01:30:00 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 01:30:40 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net)
2022-01-26 01:32:00 +0100ix(~ix@2a02:8010:674f:0:cda6:d05:f0d7:4922) (Remote host closed the connection)
2022-01-26 01:32:09 +0100ix(~ix@2a02:8010:674f:0:cda6:d05:f0d7:4922)
2022-01-26 01:32:18 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17) (Remote host closed the connection)
2022-01-26 01:32:47 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 256 seconds)
2022-01-26 01:33:39 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17)
2022-01-26 01:37:52 +0100Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de) (Ping timeout: 250 seconds)
2022-01-26 01:38:25 +0100lavaman(~lavaman@98.38.249.169)
2022-01-26 01:38:28 +0100Swahili(~Swahili@a95-94-208-187.cpe.netcabo.pt)
2022-01-26 01:38:42 +0100dsrt^(~dsrt@96-86-240-178-static.hfc.comcastbusiness.net)
2022-01-26 01:41:04 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17) (Remote host closed the connection)
2022-01-26 01:41:41 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba) (Remote host closed the connection)
2022-01-26 01:41:52 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba)
2022-01-26 01:42:13 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net) (Ping timeout: 256 seconds)
2022-01-26 01:43:45 +0100justsomeguy(~justsomeg@user/justsomeguy)
2022-01-26 01:44:22 +0100joo-_(~joo-_@fsf/member/joo--) (Ping timeout: 250 seconds)
2022-01-26 01:45:57 +0100Erutuon(~Erutuon@user/erutuon) (Ping timeout: 240 seconds)
2022-01-26 01:46:15 +0100joo-_(~joo-_@80-62-116-31-mobile.dk.customer.tdc.net)
2022-01-26 01:48:18 +0100Midjak(~Midjak@may53-1-78-226-116-92.fbx.proxad.net) (Quit: This computer has gone to sleep)
2022-01-26 01:48:29 +0100romesrf(~romes@44.190.189.46.rev.vodafone.pt)
2022-01-26 01:48:57 +0100 <romesrf> hey everyone
2022-01-26 01:48:57 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 240 seconds)
2022-01-26 01:49:59 +0100 <geekosaur> o/
2022-01-26 01:51:00 +0100Guest44(~Guest44@44.190.189.46.rev.vodafone.pt)
2022-01-26 01:52:11 +0100 <monochrom> ST is like a space telescope that shields noisy infrared from desired infrared signals... >:)
2022-01-26 01:52:33 +0100Gurkenglas(~Gurkengla@dslb-090-186-104-244.090.186.pools.vodafone-ip.de)
2022-01-26 01:52:52 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17)
2022-01-26 01:53:05 +0100 <geekosaur> are st tutorials the new monad tutorials?
2022-01-26 01:53:11 +0100 <romesrf> AHA
2022-01-26 01:53:41 +0100 <romesrf> it'd be good because i haven't gotten into the ST yet, though i do have simon's paper waiting on my bedside table
2022-01-26 01:53:53 +0100 <monochrom> You also have to unfold it like you unwrap a burrito!
2022-01-26 01:55:25 +0100 <romesrf> it's funny i really like burritos but i can't like that <<<<<<analogy>>>>>>
2022-01-26 01:55:44 +0100 <monochrom> It's OK, I'm joking :)
2022-01-26 01:56:12 +0100 <romesrf> i know ;)
2022-01-26 01:56:19 +0100 <geekosaur> late nite on #haskell þ
2022-01-26 01:56:49 +0100 <geekosaur> (well, early night but it feels late to me because I got up several hours earlier than I ought've)
2022-01-26 02:01:20 +0100cyphase(~cyphase@user/cyphase)
2022-01-26 02:02:40 +0100alt-romes(~romes@44.190.189.46.rev.vodafone.pt)
2022-01-26 02:04:19 +0100Guest44(~Guest44@44.190.189.46.rev.vodafone.pt) (Ping timeout: 256 seconds)
2022-01-26 02:04:44 +0100romesrf(~romes@44.190.189.46.rev.vodafone.pt) (Ping timeout: 250 seconds)
2022-01-26 02:08:18 +0100mvk(~mvk@2607:fea8:5cdc:bf00::a2bf)
2022-01-26 02:09:30 +0100Gurkenglas(~Gurkengla@dslb-090-186-104-244.090.186.pools.vodafone-ip.de) (Ping timeout: 250 seconds)
2022-01-26 02:10:26 +0100alt-romes(~romes@44.190.189.46.rev.vodafone.pt) (Quit: WeeChat 3.4)
2022-01-26 02:11:15 +0100alp(~alp@user/alp) (Ping timeout: 268 seconds)
2022-01-26 02:11:42 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2022-01-26 02:12:32 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475) (Ping timeout: 240 seconds)
2022-01-26 02:14:53 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475)
2022-01-26 02:15:37 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2022-01-26 02:15:48 +0100Erutuon(~Erutuon@user/erutuon)
2022-01-26 02:16:37 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net)
2022-01-26 02:17:48 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2022-01-26 02:21:09 +0100 <dsal> EvanR: Yeah, I didn't even think of container as "bucket" as much as "containment." Words are weird.
2022-01-26 02:23:00 +0100xsperry(~xs@user/xsperry)
2022-01-26 02:25:04 +0100cynomys(~cynomys@user/cynomys)
2022-01-26 02:27:01 +0100xkuru(~xkuru@user/xkuru) (Read error: Connection reset by peer)
2022-01-26 02:27:08 +0100 <int-e> The burrito analogy is still brilliant... because it kind of works and I suspect there's pretty unanimous agreement that it fails to capture the essence of monads :P
2022-01-26 02:28:38 +0100 <int-e> (burritos are just leaky containers :-P)
2022-01-26 02:29:27 +0100mcgroin(~mcgroin@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Ping timeout: 256 seconds)
2022-01-26 02:32:33 +0100vysn(~vysn@user/vysn)
2022-01-26 02:33:04 +0100lispy(~lispy4@84.69.59.93)
2022-01-26 02:33:17 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net) (Quit: WeeChat 2.2-dev)
2022-01-26 02:35:37 +0100xsperry(~xs@user/xsperry) (Ping timeout: 240 seconds)
2022-01-26 02:36:29 +0100 <remexre> is there something for reformatting deriving-Show'd values to have "friendlier" whitespace?
2022-01-26 02:39:03 +0100 <ephemient> @hackage pretty-simple
2022-01-26 02:39:03 +0100 <lambdabot> https://hackage.haskell.org/package/pretty-simple
2022-01-26 02:39:49 +0100 <remexre> thanks!
2022-01-26 02:40:37 +0100n3rdy1(~n3rdy1@2600:1700:4570:3480:1b88:50f:dae0:9293) (Ping timeout: 240 seconds)
2022-01-26 02:41:21 +0100yauhsien(~yauhsien@61-231-17-3.dynamic-ip.hinet.net)
2022-01-26 02:43:29 +0100xsperry(~xs@user/xsperry)
2022-01-26 02:44:10 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17) (Remote host closed the connection)
2022-01-26 02:45:06 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17)
2022-01-26 02:45:10 +0100lbseale(~ep1ctetus@user/ep1ctetus)
2022-01-26 02:47:38 +0100 <sm> or
2022-01-26 02:47:38 +0100 <sm> @hackage pretty-show
2022-01-26 02:47:38 +0100 <lambdabot> https://hackage.haskell.org/package/pretty-show
2022-01-26 02:47:42 +0100FroskyArr(~froskyarr@120.239.9.244)
2022-01-26 02:49:20 +0100zaquest(~notzaques@5.130.79.72) (Remote host closed the connection)
2022-01-26 02:50:58 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-26 02:50:58 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-26 02:50:58 +0100wroathe(~wroathe@user/wroathe)
2022-01-26 02:54:22 +0100zaquest(~notzaques@5.130.79.72)
2022-01-26 02:55:40 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com)
2022-01-26 02:58:32 +0100xsperry(~xs@user/xsperry) (Ping timeout: 240 seconds)
2022-01-26 03:00:44 +0100lbseale(~ep1ctetus@user/ep1ctetus) (Read error: Connection reset by peer)
2022-01-26 03:01:41 +0100mmhat(~mmh@55d40230.access.ecotel.net) (Quit: WeeChat 3.4)
2022-01-26 03:01:58 +0100ec(~ec@gateway/tor-sasl/ec)
2022-01-26 03:09:49 +0100deadmarshal(~deadmarsh@95.38.116.147)
2022-01-26 03:12:37 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 240 seconds)
2022-01-26 03:14:13 +0100deadmarshal(~deadmarsh@95.38.116.147) (Ping timeout: 256 seconds)
2022-01-26 03:14:35 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2022-01-26 03:20:41 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.4)
2022-01-26 03:20:57 +0100neurocyte0917090(~neurocyte@user/neurocyte) (Ping timeout: 240 seconds)
2022-01-26 03:21:37 +0100xff0x(~xff0x@2001:1a81:53ac:af00:ba25:4d71:4d47:a3a5) (Ping timeout: 240 seconds)
2022-01-26 03:21:54 +0100 <pfurla-matrix> Does anybody recalls what is the Java/JVM equivalent of MVar?
2022-01-26 03:22:53 +0100x88x88x(~x88x88x@149.28.53.172) (Read error: Connection reset by peer)
2022-01-26 03:23:05 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net) (Ping timeout: 256 seconds)
2022-01-26 03:23:14 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2022-01-26 03:23:27 +0100 <monochrom> The "synchronized" reserved word.
2022-01-26 03:23:52 +0100xff0x(~xff0x@2001:1a81:53ec:e00:db2b:9281:840d:9e3c)
2022-01-26 03:24:06 +0100 <monochrom> OK, there may be something in the library that's closer, but I bet they are based upon "synchronized".
2022-01-26 03:24:23 +0100xsperry(~xs@user/xsperry)
2022-01-26 03:24:33 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2022-01-26 03:25:13 +0100 <monochrom> Well, "synchronized" and the "wait()" method.
2022-01-26 03:25:46 +0100Guest|redshift1(~Guest|red@165.16.48.46)
2022-01-26 03:26:13 +0100soft(~soft@2001:470:69fc:105::c75) (Quit: Client limit exceeded: 20000)
2022-01-26 03:27:43 +0100ec(~ec@gateway/tor-sasl/ec)
2022-01-26 03:29:53 +0100 <pfurla-matrix> yeah, I could do that, but I was hoping something would take care of the synchronized for me already
2022-01-26 03:30:57 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-26 03:32:52 +0100SummerSonw(~The_viole@203.77.49.232)
2022-01-26 03:37:58 +0100ensyde(~ensyde@2600:1700:2050:1040:6816:2795:9c3:9492) (Read error: Connection reset by peer)
2022-01-26 03:41:07 +0100 <int-e> pfurla-matrix: http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Slot.html rather suggests that there's nothing doing that directly in the standard library
2022-01-26 03:41:20 +0100soft(~soft@2001:470:69fc:105::c75)
2022-01-26 03:43:07 +0100 <int-e> and yeah, having language blessed re-entrant monitors built in goes a long way towards explaining that.
2022-01-26 03:43:32 +0100yauhsien(~yauhsien@61-231-17-3.dynamic-ip.hinet.net) (Ping timeout: 240 seconds)
2022-01-26 03:49:36 +0100 <sm> \o/! Someone other than me recommended HTAC.
2022-01-26 03:49:36 +0100 <sm> https://www.reddit.com/r/haskell/comments/sc41tj/learn_haskell_by_doing/hu5x46p
2022-01-26 03:54:51 +0100califax-(~califax@user/califx)
2022-01-26 03:57:22 +0100Guest|redshift1(~Guest|red@165.16.48.46) (Quit: Connection closed)
2022-01-26 03:58:21 +0100califax(~califax@user/califx) (Ping timeout: 276 seconds)
2022-01-26 03:58:21 +0100califax-califax
2022-01-26 04:00:07 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 256 seconds)
2022-01-26 04:08:05 +0100 <ephemient> pfurla-matrix: BlockingQueue of size 1?
2022-01-26 04:08:42 +0100 <pfurla-matrix> ephemient: yeah, that's a good one, I might end up doing exactly that
2022-01-26 04:08:45 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2022-01-26 04:14:16 +0100Swahili(~Swahili@a95-94-208-187.cpe.netcabo.pt) (Remote host closed the connection)
2022-01-26 04:14:17 +0100td_(~td@muedsl-82-207-238-208.citykom.de) (Ping timeout: 256 seconds)
2022-01-26 04:15:55 +0100td_(~td@94.134.91.245)
2022-01-26 04:18:53 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17) (Remote host closed the connection)
2022-01-26 04:35:09 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17)
2022-01-26 04:39:17 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17) (Ping timeout: 240 seconds)
2022-01-26 04:39:31 +0100Adran(~adran@botters/adran) (Quit: Este é o fim.)
2022-01-26 04:40:36 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 276 seconds)
2022-01-26 04:41:08 +0100zebrag(~chris@user/zebrag)
2022-01-26 04:41:29 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17)
2022-01-26 04:41:33 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17) (Remote host closed the connection)
2022-01-26 04:42:01 +0100terrorjack(~terrorjac@2a01:4f8:1c1e:509a::1) (Quit: The Lounge - https://thelounge.chat)
2022-01-26 04:42:05 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17)
2022-01-26 04:42:37 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2022-01-26 04:43:14 +0100terrorjack(~terrorjac@2a01:4f8:1c1e:509a::1)
2022-01-26 04:43:39 +0100zebrag(~chris@user/zebrag) (Client Quit)
2022-01-26 04:46:17 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17) (Ping timeout: 240 seconds)
2022-01-26 04:46:54 +0100Adran(adran@botters/adran)
2022-01-26 04:51:08 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475) (Ping timeout: 250 seconds)
2022-01-26 04:53:10 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475)
2022-01-26 05:01:02 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2022-01-26 05:01:07 +0100yauhsien(~yauhsien@61-231-17-3.dynamic-ip.hinet.net)
2022-01-26 05:04:08 +0100geranim0(~geranim0@d-132-204-221-88.res.umontreal.ca)
2022-01-26 05:05:17 +0100yauhsien(~yauhsien@61-231-17-3.dynamic-ip.hinet.net) (Ping timeout: 240 seconds)
2022-01-26 05:08:24 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-26 05:08:24 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-26 05:08:24 +0100wroathe(~wroathe@user/wroathe)
2022-01-26 05:10:35 +0100 <justsomeguy> So, I was asking myself "How do you measure the complexity of an expression in the pure lambda calculus?", and came across some versions of the lambda calculus that have explicit rules about how to perform reductions, using rewrite rules, and also sometimes using annotations for when to share results of sub-expressions. Has anyone else recently looked into this stuff -- what do you think?
2022-01-26 05:11:31 +0100 <justsomeguy> (I don't really understand the subject, as you can tell, but I think the question is interesting, and it's neat to see so many approaches to coming up with and answer.)
2022-01-26 05:13:43 +0100 <justsomeguy> I mean, maybe I doesn't even make sense to ask how to measure a lambda expression unless I'm talking about a particular implementation of the lambda calculus.
2022-01-26 05:14:11 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17)
2022-01-26 05:14:35 +0100justsomeguybrushes aside his half-baked theory questions and goes back to debugging his crummy hangman game.
2022-01-26 05:15:57 +0100waleee(~waleee@2001:9b0:21d:fc00:398f:b003:b90d:acf4) (Ping timeout: 240 seconds)
2022-01-26 05:16:17 +0100ralu(~ralu@static.211.245.203.116.clients.your-server.de) (Ping timeout: 240 seconds)
2022-01-26 05:18:32 +0100dolio(~dolio@130.44.130.54) (Quit: ZNC 1.8.2 - https://znc.in)
2022-01-26 05:18:57 +0100SummerSonw(~The_viole@203.77.49.232) (Ping timeout: 240 seconds)
2022-01-26 05:20:12 +0100ralu(~ralu@static.211.245.203.116.clients.your-server.de)
2022-01-26 05:21:17 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2022-01-26 05:21:28 +0100 <c_wraith> there is some sort of notion of "steps required to reduce"
2022-01-26 05:21:41 +0100 <c_wraith> There's even theory on minimizing that - optimal evaluation.
2022-01-26 05:22:11 +0100 <c_wraith> (it turns out optimal evaluation isn't really optimal for computers most of the time - it's too expensive to figure out what the optimal approach is)
2022-01-26 05:25:54 +0100 <davean> Just doing it can be better than doing it well
2022-01-26 05:25:58 +0100dolio(~dolio@130.44.130.54)
2022-01-26 05:25:58 +0100img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2022-01-26 05:26:16 +0100img(~img@user/img)
2022-01-26 05:27:23 +0100shriekingnoise(~shrieking@201.231.16.156) (Ping timeout: 256 seconds)
2022-01-26 05:29:29 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-26 05:29:29 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-26 05:29:29 +0100wroathe(~wroathe@user/wroathe)
2022-01-26 05:30:40 +0100Jing(~hedgehog@240e:390:7c53:a7e1:b574:732d:3b12:8f10)
2022-01-26 05:32:17 +0100mvk(~mvk@2607:fea8:5cdc:bf00::a2bf) (Ping timeout: 240 seconds)
2022-01-26 05:32:42 +0100 <justsomeguy> I came across two cool resources... Someone linked to Barry Jay's Closure Calculus. There is also https://researchportal.bath.ac.uk/en/projects/typed-lambda-calculi-with-sharing-and-unsharing. I tried to summarize them, but realized I don't understand them well enought to do that.
2022-01-26 05:34:11 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 256 seconds)
2022-01-26 05:34:29 +0100little_mac(~little_ma@2601:410:4300:3ce0:e0d9:54a6:eecc:ef77) (Remote host closed the connection)
2022-01-26 05:35:31 +0100little_mac(~little_ma@2601:410:4300:3ce0:dc0a:b5a8:5147:7a4f)
2022-01-26 05:39:48 +0100deadmarshal(~deadmarsh@95.38.116.147)
2022-01-26 05:42:46 +0100shriekingnoise(~shrieking@201.231.16.156)
2022-01-26 05:43:09 +0100dut(~dut@user/dut)
2022-01-26 05:46:57 +0100Erutuon(~Erutuon@user/erutuon) (Ping timeout: 240 seconds)
2022-01-26 05:48:28 +0100SummerSonw(~The_viole@203.77.49.232)
2022-01-26 05:49:35 +0100PigDude(~PigDude@159.203.16.199) ()
2022-01-26 05:50:41 +0100 <dsal> Trying out copilot. It wrote this function for me: `sortStringsByNumber = sortBy (compare `on` (read . head . words))`
2022-01-26 05:52:07 +0100shailangsa(~shailangs@host86-185-98-37.range86-185.btcentralplus.com) (Ping timeout: 256 seconds)
2022-01-26 05:53:32 +0100SummerSonw(~The_viole@203.77.49.232) (Ping timeout: 250 seconds)
2022-01-26 05:56:41 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-26 05:57:43 +0100 <dsal> I typed `doesThisHalt` and it just spat out a solution to the halting problem: https://www.irccloud.com/pastebin/CnZCMWic/halting.hs
2022-01-26 05:57:56 +0100 <ephemient> sortOn f is supposedly better than sortBy (comparing f), isn't it? at least the docs say it has better performance
2022-01-26 05:59:09 +0100 <int-e> ephemient: it depends on whether f is cheap or expensive and a bit on how big the results of f are
2022-01-26 05:59:32 +0100 <int-e> (since sortOn will store those results while the list is being sorted)
2022-01-26 06:00:47 +0100p3n(~p3n@217.198.124.246) (Quit: ZNC 1.8.2 - https://znc.in)
2022-01-26 06:01:03 +0100p3n(~p3n@2a00:19a0:3:7c:0:d9c6:7cf6:1)
2022-01-26 06:04:10 +0100 <g> sortBy (comparing snd) would be better than sortOn snd
2022-01-26 06:04:21 +0100vysn(~vysn@user/vysn) (Ping timeout: 268 seconds)
2022-01-26 06:04:26 +0100 <g> Or any other record selector, for example
2022-01-26 06:09:01 +0100bontaq(~user@ool-45779fe5.dyn.optonline.net) (Ping timeout: 240 seconds)
2022-01-26 06:09:34 +0100vglfr(~vglfr@46.96.147.122) (Ping timeout: 250 seconds)
2022-01-26 06:11:08 +0100 <ephemient> sure. I expect sortOn is defined as something like map fst . sortBy (comparing snd) . map (id &&& f) so if sortOn snd were better than sortBy (comparing snd), it would be better to replace that, and again, and again… which would be absurd
2022-01-26 06:11:37 +0100geranim0(~geranim0@d-132-204-221-88.res.umontreal.ca) (Ping timeout: 240 seconds)
2022-01-26 06:12:11 +0100 <ephemient> but in the case of f = read . head . words that copilot learned from somewhere, which would that be?
2022-01-26 06:12:23 +0100 <ephemient> although I guess that might require benchmarking to determine
2022-01-26 06:13:20 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-26 06:13:20 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-26 06:13:20 +0100wroathe(~wroathe@user/wroathe)
2022-01-26 06:13:40 +0100 <ephemient> that `doesThisHalt` is… curious. what kind of code did copilot learn that from
2022-01-26 06:17:03 +0100lionhairdino(~jacoo@121.131.39.82)
2022-01-26 06:17:57 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2022-01-26 06:18:37 +0100 <dsal> It's interesting because it like, does something, I just don't know where `halt` comes from. My first attempt to solve the halting problem, I let it create the signature which it decided should be `:: [Int] -> Bool` and then the implementation was `doesThisHalt xs = (length xs) == (length $ filter (==0) xs)`
2022-01-26 06:25:24 +0100 <int-e> does extended exposure to copilot lead to brain damage?
2022-01-26 06:25:54 +0100 <int-e> (these examples are pretty painful)
2022-01-26 06:27:15 +0100 <dsal> Haha. Yeah. The examples so far have been pretty terrible.
2022-01-26 06:28:05 +0100Erutuon(~Erutuon@user/erutuon)
2022-01-26 06:30:17 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2022-01-26 06:33:59 +0100 <monochrom> Wait, does copilot guess from your meaningful function names?
2022-01-26 06:34:25 +0100 <monochrom> Is it like a marriage of GPT3 and genetic algorithms? >:)
2022-01-26 06:35:07 +0100 <monochrom> Does it understand "awesomeHaskellCompiler"? >:)
2022-01-26 06:35:09 +0100shailangsa(~shailangs@host86-185-98-37.range86-185.btcentralplus.com)
2022-01-26 06:40:40 +0100 <dsal> monochrom: I don't think it thinks that's supposed to do something: `awesomeHaskellCompiler :: Compiler`
2022-01-26 06:41:11 +0100 <int-e> gruesomeHaskellCompiler (short... ah let's just leave it at the long version)
2022-01-26 06:41:41 +0100 <dsal> I changed it to a verb: https://www.irccloud.com/pastebin/oFaoUzPE/compile.hs
2022-01-26 06:42:24 +0100 <EvanR> it is pitch black
2022-01-26 06:42:34 +0100 <monochrom> Haha wait am I seeing it outsourcing the job to ghc?
2022-01-26 06:42:34 +0100 <EvanR> you've been eaten by a gruesome haskell compiler
2022-01-26 06:42:55 +0100 <dsal> monochrom: Yeah, kind of cheating.
2022-01-26 06:42:59 +0100 <monochrom> This is smarter than most students :)
2022-01-26 06:43:02 +0100 <dsal> That's not the kind of cheating I'm trying to do.
2022-01-26 06:44:05 +0100 <monochrom> Sad to say it understands ExceptT and System.Process better than most querents in this channel!
2022-01-26 06:44:06 +0100 <int-e> dsal: what do you want? `compileHaskellCode _ = let _ = "todo" in fix error`
2022-01-26 06:44:55 +0100 <dsal> I wanted it to write hugs.
2022-01-26 06:46:00 +0100 <int-e> hugs are incompatible with current social distancing rules
2022-01-26 06:46:28 +0100 <monochrom> haha
2022-01-26 06:46:33 +0100 <dsal> I asked it to write me a function called "fixedPointOfFunction" and it came up with `fixedPointOfFunction :: (a -> a) -> a -> a; fixedPointOfFunction f x = let x' = f x in if x' == x then x' else fixedPointOfFunction f x'`
2022-01-26 06:47:21 +0100wyrd(~wyrd@gateway/tor-sasl/wyrd) (Ping timeout: 276 seconds)
2022-01-26 06:53:58 +0100wyrd(~wyrd@gateway/tor-sasl/wyrd)
2022-01-26 06:54:07 +0100 <monochrom> That's not bad in the sense of fixed points in real analysis.
2022-01-26 06:54:50 +0100 <int-e> I have written that code, sans the overly polymorphic signature
2022-01-26 06:54:57 +0100cheater(~Username@user/cheater) (Ping timeout: 240 seconds)
2022-01-26 06:56:43 +0100 <int-e> and possibly cosmetic differences, including relying on ghc's opportunistic CSE: stabilize f x | x == f x = x | otherwise = stabilize f (f x)
2022-01-26 06:58:06 +0100little_mac(~little_ma@2601:410:4300:3ce0:dc0a:b5a8:5147:7a4f) (Remote host closed the connection)
2022-01-26 06:59:45 +0100ishutin(~ishutin@84-236-1-73.pool.digikabel.hu) (Ping timeout: 256 seconds)
2022-01-26 07:01:20 +0100ishutin(~ishutin@87-97-82-177.pool.digikabel.hu)
2022-01-26 07:01:55 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 07:02:26 +0100Erutuon(~Erutuon@user/erutuon) (Ping timeout: 250 seconds)
2022-01-26 07:04:17 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 256 seconds)
2022-01-26 07:04:53 +0100 <xerox> :t let g f x = maybe x (g f) (f x) in g -- reminds me of this
2022-01-26 07:04:54 +0100 <lambdabot> (a -> Maybe a) -> a -> a
2022-01-26 07:05:14 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 07:05:20 +0100Erutuon(~Erutuon@user/erutuon)
2022-01-26 07:05:48 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Read error: Connection reset by peer)
2022-01-26 07:06:05 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 07:06:34 +0100bliminse_(~bliminse@host86-188-36-166.range86-188.btcentralplus.com)
2022-01-26 07:06:45 +0100 <ephemient> > let fix f x = y where ys = iterate f x; (y, _):_ = dropWhile (uncurry (/=)) $ zip ys (tail ys) in fix cos 0 -- I vaguely remember something like this happening the other day but don't remember context
2022-01-26 07:06:46 +0100 <lambdabot> 0.7390851332151607
2022-01-26 07:06:55 +0100bliminse(~bliminse@host86-188-36-178.range86-188.btcentralplus.com) (Ping timeout: 256 seconds)
2022-01-26 07:09:17 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 240 seconds)
2022-01-26 07:11:38 +0100 <dsal> GHCI doesn't bring symbols from :{ into scope. Is this normal or am I doing something wrong (other than trying to use :{) ?
2022-01-26 07:12:32 +0100 <monochrom> Works for me.
2022-01-26 07:12:37 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 240 seconds)
2022-01-26 07:12:57 +0100 <monochrom> I entered "f x = x + 1" and "g x = f x + 1" between :{ and :}
2022-01-26 07:13:12 +0100 <monochrom> Outside, f 4 and g 4 give expected answers.
2022-01-26 07:13:48 +0100 <dsal> This ghci is kind of mangled for various reasons. Oh, I have more than one computer. This is the one that has the broken readline thing as well.
2022-01-26 07:14:28 +0100 <monochrom> That's one more moving parts thrown into the wrench or some mixed up metaphor, yeah. :)
2022-01-26 07:16:08 +0100 <dsal> The ghci from ghcup works.
2022-01-26 07:16:37 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 07:17:06 +0100cheater(~Username@user/cheater)
2022-01-26 07:24:49 +0100 <dsal> I'm confused by this data-fix hylomorphism. How does one use this? `:: Functor f => (f b -> b) -> (a -> f a) -> a -> b`
2022-01-26 07:25:24 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475) (Ping timeout: 250 seconds)
2022-01-26 07:26:18 +0100 <dsal> It's supposed to be "anamorphism followed by catamorphism" so I guess the first function is the catamorphism and the second is the anamorphism. But it looks like a ~ b.
2022-01-26 07:27:24 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475)
2022-01-26 07:28:26 +0100emf(~emf@2620:10d:c090:400::5:fe1a)
2022-01-26 07:29:25 +0100 <dsal> That's the same signature recursion-schemes uses.
2022-01-26 07:32:24 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2022-01-26 07:33:09 +0100dut(~dut@user/dut) (Quit: Leaving)
2022-01-26 07:37:58 +0100slowButPresent(~slowButPr@user/slowbutpresent) (Quit: leaving)
2022-01-26 07:39:46 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 07:40:43 +0100 <dsal> I was thinking about going to be early a couple hours ago. Maybe I'll do that instead.
2022-01-26 07:42:18 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 250 seconds)
2022-01-26 07:43:20 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2022-01-26 07:45:07 +0100 <c_wraith> dsal: works just fine when a is not the same type as b. Though... Uh... It's a bit of a funny one.
2022-01-26 07:50:03 +0100 <prasad> :q
2022-01-26 07:50:14 +0100prasad(~user@c-73-170-49-136.hsd1.ca.comcast.net) (Remote host closed the connection)
2022-01-26 07:51:04 +0100_ht(~quassel@2a02:a468:b619:1:8a98:8031:2935:e3fc)
2022-01-26 07:54:40 +0100 <dsal> c_wraith: I'm going to try to understand it in The Future. My `fold . unfoldr f` thing was easy to write, but I want to do sightly better
2022-01-26 07:59:56 +0100mikoto-chan(~mikoto-ch@213.177.151.239)
2022-01-26 08:00:32 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 08:01:03 +0100lispy(~lispy4@84.69.59.93) (Quit: Leaving)
2022-01-26 08:04:21 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 256 seconds)
2022-01-26 08:05:21 +0100azimut_(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 276 seconds)
2022-01-26 08:05:55 +0100alp(~alp@user/alp)
2022-01-26 08:07:00 +0100deadmarshal(~deadmarsh@95.38.116.147) (Ping timeout: 250 seconds)
2022-01-26 08:10:45 +0100xsperry(~xs@user/xsperry) (Read error: Connection reset by peer)
2022-01-26 08:14:08 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-26 08:14:08 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-26 08:14:08 +0100wroathe(~wroathe@user/wroathe)
2022-01-26 08:14:22 +0100mikoto-chan(~mikoto-ch@213.177.151.239) (Ping timeout: 250 seconds)
2022-01-26 08:14:49 +0100deadmarshal(~deadmarsh@95.38.116.147)
2022-01-26 08:14:59 +0100cynomys(~cynomys@user/cynomys) (Remote host closed the connection)
2022-01-26 08:16:22 +0100cfricke(~cfricke@user/cfricke)
2022-01-26 08:19:24 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2022-01-26 08:19:46 +0100gehmehgeh(~user@user/gehmehgeh)
2022-01-26 08:19:47 +0100mbuf(~Shakthi@122.173.242.184)
2022-01-26 08:23:12 +0100michalz(~michalz@185.246.204.37)
2022-01-26 08:23:17 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475) (Ping timeout: 240 seconds)
2022-01-26 08:25:31 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475)
2022-01-26 08:27:32 +0100zmt00(~zmt00@user/zmt00) (Ping timeout: 240 seconds)
2022-01-26 08:30:21 +0100ensyde(~ensyde@2600:1700:2050:1040:3990:b270:fa9e:e455)
2022-01-26 08:32:14 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-26 08:32:37 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:71ea:518b:f248:7591)
2022-01-26 08:35:15 +0100xsperry(~xs@user/xsperry)
2022-01-26 08:38:37 +0100emf(~emf@2620:10d:c090:400::5:fe1a) (Ping timeout: 240 seconds)
2022-01-26 08:39:25 +0100akegalj(~akegalj@141-136-245-236.dsl.iskon.hr)
2022-01-26 08:39:25 +0100little_mac(~little_ma@2601:410:4300:3ce0:45a2:92d3:66c6:d0a1)
2022-01-26 08:41:01 +0100xsperry(~xs@user/xsperry) (Read error: Connection reset by peer)
2022-01-26 08:44:23 +0100xsperry(~xs@user/xsperry)
2022-01-26 08:47:26 +0100Chewt(~hayden@2601:1c0:8101:7310::144a)
2022-01-26 08:51:40 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net)
2022-01-26 08:51:55 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475) (Quit: WeeChat 3.4)
2022-01-26 08:53:59 +0100gioyik(~gioyik@gateway/tor-sasl/gioyik) (Quit: WeeChat 3.3)
2022-01-26 08:54:00 +0100dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be)
2022-01-26 08:54:45 +0100xsperry(~xs@user/xsperry) (Read error: Connection reset by peer)
2022-01-26 08:56:17 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net) (Ping timeout: 256 seconds)
2022-01-26 08:56:21 +0100SummerSonw(~The_viole@203.77.49.232)
2022-01-26 08:56:55 +0100shriekingnoise(~shrieking@201.231.16.156) (Quit: Quit)
2022-01-26 08:58:06 +0100mikoto-chan(~mikoto-ch@84.199.144.235)
2022-01-26 08:59:13 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2022-01-26 08:59:50 +0100cosimone(~user@93-44-185-255.ip98.fastwebnet.it)
2022-01-26 09:01:10 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 250 seconds)
2022-01-26 09:04:26 +0100xsperry(~xs@user/xsperry)
2022-01-26 09:06:05 +0100vysn(~vysn@user/vysn)
2022-01-26 09:06:21 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475)
2022-01-26 09:06:29 +0100coot(~coot@89-64-85-93.dynamic.chello.pl)
2022-01-26 09:08:35 +0100Major_Biscuit(~MajorBisc@86-88-79-148.fixed.kpn.net)
2022-01-26 09:10:42 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:71ea:518b:f248:7591) (Ping timeout: 250 seconds)
2022-01-26 09:11:47 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:23a9:7efc:99f6:4072)
2022-01-26 09:12:49 +0100chele(~chele@user/chele)
2022-01-26 09:14:57 +0100mc47(~mc47@xmonad/TheMC47)
2022-01-26 09:16:20 +0100p3n(~p3n@2a00:19a0:3:7c:0:d9c6:7cf6:1) (Ping timeout: 250 seconds)
2022-01-26 09:16:49 +0100p3n(~p3n@217.198.124.246)
2022-01-26 09:21:39 +0100AlexNoo_AlexNoo
2022-01-26 09:28:35 +0100fef(~thedawn@user/thedawn)
2022-01-26 09:28:59 +0100fendor(~fendor@77.119.167.8.wireless.dyn.drei.com)
2022-01-26 09:30:20 +0100 <dminuoso_> megaparsec question. Let's say I want to parse "foo" are separated by dots with a trailing dot. Naively I tried: thingBetween `sepBy1` chunk ".", but that cant parse `"foo.foo.", as megaparsec will rightfully expect a trailing "foo"
2022-01-26 09:30:56 +0100 <dminuoso_> I can of course parse this as: many (thingBetween <* chunk ".")
2022-01-26 09:31:19 +0100 <dminuoso_> Ah hold on.
2022-01-26 09:31:32 +0100 <dminuoso_> As I was writing the second part of it, I realized I simply need two completely separate parsers.
2022-01-26 09:31:41 +0100 <dminuoso_> Thanks for being a rubber duck.
2022-01-26 09:32:13 +0100 <tomsmeding> dminuoso_: many (thingBetween <* chunk ".") ?
2022-01-26 09:32:18 +0100 <tomsmeding> or some, perhaps
2022-01-26 09:32:38 +0100 <dminuoso_> tomsmeding: No my problem was I wanted to find a way to do both with a leading dot and without.
2022-01-26 09:32:58 +0100 <dminuoso_> But it means I must in one place use `many (thingBetween <* chunk ".")` and `thingBetween `sepBy1` chunk "."` for the other
2022-01-26 09:33:15 +0100 <dminuoso_> In attoparsec I merely used the latter, and it worked out just fine due to backtracking
2022-01-26 09:33:26 +0100 <tomsmeding> "separated by dots with a trailing dot" to me means a dot after each foo
2022-01-26 09:33:37 +0100 <dminuoso_> Sure
2022-01-26 09:34:50 +0100 <tomsmeding> but if you solved your own problem already don't listen to me :)
2022-01-26 09:35:13 +0100jgeerds(~jgeerds@55d4a547.access.ecotel.net)
2022-01-26 09:35:26 +0100 <dminuoso_> Next up I should rewrite this parser with alex/happy.
2022-01-26 09:35:53 +0100ubert1(~Thunderbi@p200300ecdf09940ed781da24ea780c96.dip0.t-ipconnect.de)
2022-01-26 09:36:04 +0100 <dminuoso_> What's the minimal dependency footprint I can bring? Surely I can preexecute alex/happy and just ship the generated lexer/parser files right?
2022-01-26 09:36:52 +0100 <dminuoso_> https://github.com/glguy/config-value looks like it
2022-01-26 09:37:04 +0100Gurkenglas(~Gurkengla@dslb-090-186-104-244.090.186.pools.vodafone-ip.de)
2022-01-26 09:37:32 +0100ph88^(~ph88@ip5f5af71f.dynamic.kabel-deutschland.de) (Ping timeout: 240 seconds)
2022-01-26 09:38:00 +0100xff0x(~xff0x@2001:1a81:53ec:e00:db2b:9281:840d:9e3c) (Ping timeout: 250 seconds)
2022-01-26 09:38:20 +0100Major_Biscuit(~MajorBisc@86-88-79-148.fixed.kpn.net) (Ping timeout: 268 seconds)
2022-01-26 09:39:04 +0100xff0x(~xff0x@2001:1a81:53ec:e00:81a4:7fd8:2f5d:f55d)
2022-01-26 09:44:37 +0100ph88^(~ph88@2a02:8109:9e00:71d0:a803:7e6c:9fe5:13b9)
2022-01-26 09:45:31 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer)
2022-01-26 09:46:24 +0100gentauro(~gentauro@user/gentauro) (Quit: leaving)
2022-01-26 09:48:11 +0100kuribas(~user@ptr-25vy0i9nxqs797laykw.18120a2.ip6.access.telenet.be)
2022-01-26 09:50:21 +0100machinedgod(~machinedg@24.105.81.50)
2022-01-26 09:51:36 +0100sprout(~quassel@2a02:a467:ccd6:1:8844:e45a:1aab:92c2)
2022-01-26 09:53:13 +0100little_mac(~little_ma@2601:410:4300:3ce0:45a2:92d3:66c6:d0a1) (Remote host closed the connection)
2022-01-26 09:54:18 +0100gentauro(~gentauro@user/gentauro)
2022-01-26 09:55:36 +0100sprout_(~quassel@2a02:a467:ccd6:1:5d8f:20db:5ddd:bcf4) (Ping timeout: 268 seconds)
2022-01-26 09:57:02 +0100simmsb(~simmsb@2001:470:69fc:105::1:55c3) (Quit: Client limit exceeded: 20000)
2022-01-26 09:58:13 +0100 <tomsmeding> Axman6: I tried Data.Discrimination.Sorting.sort because I was curious, and it seems it's at roughly the same performance in my test as Data.List.sort
2022-01-26 09:58:21 +0100 <tomsmeding> though the quickcheck tests are MUCH slower for some reasons
2022-01-26 09:58:24 +0100 <tomsmeding> s/.$//
2022-01-26 09:58:27 +0100simmsb(~simmsb@2001:470:69fc:105::1:55c3)
2022-01-26 09:58:35 +0100 <tomsmeding> like, taking 10x as long
2022-01-26 09:58:57 +0100 <tomsmeding> perhaps it has a higher constant factor for short lists? quickcheck only tests lists with lengths [0..99]
2022-01-26 09:59:16 +0100 <tomsmeding> Axman6: actually, not Data.List.sort, but quacksort lol
2022-01-26 10:01:22 +0100Major_Biscuit(~MajorBisc@c-001-019-027.client.tudelft.eduvpn.nl)
2022-01-26 10:05:05 +0100dminuoso_dminuoso
2022-01-26 10:05:14 +0100 <c_wraith> quacksort? Is that like a single pass of bubble sort? "most lists are nearly sorted already, this will be fine!"
2022-01-26 10:05:31 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-26 10:05:59 +0100Midjak(~Midjak@may53-1-78-226-116-92.fbx.proxad.net)
2022-01-26 10:06:07 +0100xkuru(~xkuru@user/xkuru)
2022-01-26 10:06:42 +0100vysn(~vysn@user/vysn) (Ping timeout: 268 seconds)
2022-01-26 10:07:49 +0100max22-(~maxime@lfbn-ren-1-1026-62.w92-139.abo.wanadoo.fr)
2022-01-26 10:09:20 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba) (Remote host closed the connection)
2022-01-26 10:09:35 +0100jle`(~jle`@cpe-23-240-75-236.socal.res.rr.com) (Ping timeout: 256 seconds)
2022-01-26 10:09:48 +0100 <tomsmeding> c_wraith: something written by SrPx last night, bit of a simplistic mix of mergesort and quicksort
2022-01-26 10:10:16 +0100 <tomsmeding> and is slightly slower (~30%) than Data.List.sort in my tests, but I fixed a bug in their code in a really inefficient way
2022-01-26 10:10:34 +0100 <tomsmeding> c_wraith: https://paste.tomsmeding.com/RVS64Lfd
2022-01-26 10:11:07 +0100jle`(~jle`@cpe-23-240-75-236.socal.res.rr.com)
2022-01-26 10:12:47 +0100 <c_wraith> that's the fixed code? That seems to have weird inefficiencies all over
2022-01-26 10:13:02 +0100shailangsa(~shailangs@host86-185-98-37.range86-185.btcentralplus.com) ()
2022-01-26 10:13:23 +0100 <tomsmeding> yeah that's the fixed code
2022-01-26 10:13:59 +0100 <tomsmeding> c_wraith: this was their original code https://gist.github.com/VictorTaelin/2a1cf354ea710f1eae1b6d15281813ca
2022-01-26 10:14:38 +0100 <tomsmeding> (the bug was that if the first element is maximal, all elements fall into one bucket and it loops infinitely)
2022-01-26 10:15:03 +0100 <c_wraith> why are you passing information into quack and place that is always derived exactly the same way from other parameters?
2022-01-26 10:15:15 +0100 <tomsmeding> yeah I dunno
2022-01-26 10:15:24 +0100 <tomsmeding> but I would expect ghc to optimise that one particular thing out
2022-01-26 10:15:39 +0100dminuoso(~dminuoso@static.88-198-218-68.clients.your-server.de) (Changing host)
2022-01-26 10:15:39 +0100dminuoso(~dminuoso@user/dminuoso)
2022-01-26 10:15:57 +0100 <c_wraith> I care less about that and more about how it makes the code harder to read
2022-01-26 10:17:32 +0100allbery_b(~geekosaur@xmonad/geekosaur)
2022-01-26 10:17:32 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Killed (NickServ (GHOST command used by allbery_b)))
2022-01-26 10:17:35 +0100allbery_bgeekosaur
2022-01-26 10:20:15 +0100 <tomsmeding> c_wraith: is quacksort2 here more readable? https://paste.tomsmeding.com/hyJfdqVt
2022-01-26 10:22:24 +0100 <c_wraith> a lot
2022-01-26 10:23:58 +0100caroakhesacaro
2022-01-26 10:29:11 +0100 <c_wraith> also, that looks like it goes O(n^2) on inputs like [9,7,5,3,1,2,4,6,8,10]
2022-01-26 10:30:16 +0100 <tomsmeding> c_wraith: yeah, the naive pivot selection doesn't ensure n log n
2022-01-26 10:30:36 +0100 <tomsmeding> also the benchmark is on random lists, which is quite relevant to interpreting the results
2022-01-26 10:30:56 +0100 <c_wraith> Data.List.sort is O(n) on inputs like that.
2022-01-26 10:32:15 +0100SummerSonw(~The_viole@203.77.49.232) (Ping timeout: 256 seconds)
2022-01-26 10:32:29 +0100cosimone(~user@93-44-185-255.ip98.fastwebnet.it) (Remote host closed the connection)
2022-01-26 10:36:39 +0100haskellberryfinn(~nut@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2022-01-26 10:38:51 +0100flipchan(~filip@user/flipchan)
2022-01-26 10:43:28 +0100 <tomsmeding> c_wraith: benchmarked against inputs like that ([1], [1,2], [3,1,2], [3,1,2,4], etc.), you get the desc-asc ones here: https://tomsmeding.com/f/sorting-comparison-criterion-1.html
2022-01-26 10:43:40 +0100 <tomsmeding> i.e. confirms your observation :p
2022-01-26 10:43:50 +0100 <tomsmeding> hint: click the x-axis on the overview chart to switch to log scale
2022-01-26 10:44:25 +0100 <c_wraith> that's a cool UI
2022-01-26 10:44:34 +0100 <tomsmeding> yeah, criterion is cool
2022-01-26 10:44:43 +0100 <c_wraith> I've never used its HTML output
2022-01-26 10:45:21 +0100 <tomsmeding> if you use criterion's defaultMain, just pass '-o out.html' to the executable
2022-01-26 10:45:29 +0100 <merijn> c_wraith: to be fair, O(n^2) worst case is accurate for quicksort :p
2022-01-26 10:45:42 +0100 <tomsmeding> merijn: not if you have a well-chosen pivot (which this one doesn't)
2022-01-26 10:45:53 +0100 <merijn> *insert my usual rant that the only thing quicksort has going for it is the marketing from it's name*
2022-01-26 10:47:03 +0100 <c_wraith> Oh. Here's what I don't get about that algorithm. The merge should always be doing (++)
2022-01-26 10:47:10 +0100 <tomsmeding> SrPx: https://tomsmeding.com/f/sorting-comparison-criterion-1.html -- also posting this to you in case you're interested
2022-01-26 10:47:32 +0100 <c_wraith> it's a quicksort with a slower string concatenation named "merge"
2022-01-26 10:48:24 +0100 <tomsmeding> that is correct lol
2022-01-26 10:48:49 +0100 <tomsmeding> doesn't do much to its benchmark time though
2022-01-26 10:48:56 +0100 <c_wraith> no, it's not much slower
2022-01-26 10:49:16 +0100 <c_wraith> chasing the pointers costs much more time than the comparisons
2022-01-26 10:50:01 +0100 <tomsmeding> much more, I'm only seeing a 1% improvement or something
2022-01-26 10:50:15 +0100 <tomsmeding> well, maybe 4%
2022-01-26 10:50:46 +0100 <c_wraith> did you actually verify the results are still sorted?
2022-01-26 10:50:59 +0100 <c_wraith> I might have analyzed it incorrectly!
2022-01-26 10:51:04 +0100vglfr(~vglfr@88.155.70.5)
2022-01-26 10:51:30 +0100 <tomsmeding> quickcheck is okay with it
2022-01-26 10:51:48 +0100 <tomsmeding> which isn't a proof, but gives me pretty good confidence
2022-01-26 10:52:01 +0100 <c_wraith> yeah, sounds pretty good
2022-01-26 10:52:19 +0100 <tomsmeding> in case you're interested, combined chart: https://tomsmeding.com/f/sorting-comparison-criterion-2.html
2022-01-26 10:52:57 +0100shailangsa(~shailangs@host86-185-98-37.range86-185.btcentralplus.com)
2022-01-26 10:55:29 +0100OscarH_(~OscarH@90.201.86.195) (Ping timeout: 252 seconds)
2022-01-26 10:58:35 +0100bjourne(~bjourne@2001:6b0:1:1140:42bf:ff4:f8fa:50e5) (Quit: Konversation terminated!)
2022-01-26 10:58:40 +0100Jing(~hedgehog@240e:390:7c53:a7e1:b574:732d:3b12:8f10) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2022-01-26 10:59:12 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2022-01-26 10:59:26 +0100lavaman(~lavaman@98.38.249.169)
2022-01-26 11:00:58 +0100Erutuon(~Erutuon@user/erutuon) (Ping timeout: 268 seconds)
2022-01-26 11:01:31 +0100coot(~coot@89-64-85-93.dynamic.chello.pl) (Quit: coot)
2022-01-26 11:02:00 +0100coot(~coot@89-64-85-93.dynamic.chello.pl)
2022-01-26 11:02:46 +0100SummerSonw(~The_viole@203.77.49.232)
2022-01-26 11:03:16 +0100OscarH(~OscarH@2a02:c7f:a0da:ae00:ba27:ebff:fe84:d2f4)
2022-01-26 11:08:57 +0100ensyde(~ensyde@2600:1700:2050:1040:3990:b270:fa9e:e455) (Ping timeout: 240 seconds)
2022-01-26 11:09:45 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba)
2022-01-26 11:10:40 +0100amk(~amk@109.255.169.126) (Remote host closed the connection)
2022-01-26 11:11:06 +0100michalz(~michalz@185.246.204.37) (Read error: No route to host)
2022-01-26 11:11:40 +0100amk(~amk@109.255.169.126)
2022-01-26 11:12:17 +0100michalz(~michalz@185.246.204.37)
2022-01-26 11:14:02 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba) (Ping timeout: 240 seconds)
2022-01-26 11:14:17 +0100Jing(~hedgehog@240e:390:7c53:a7e1:491:83dc:6241:13db)
2022-01-26 11:16:22 +0100cosimone(~user@93-44-185-255.ip98.fastwebnet.it)
2022-01-26 11:19:39 +0100Midjak(~Midjak@may53-1-78-226-116-92.fbx.proxad.net) (Quit: Leaving)
2022-01-26 11:23:17 +0100mvk(~mvk@2607:fea8:5cdc:bf00::a2bf)
2022-01-26 11:24:30 +0100yauhsien(~yauhsien@61-231-17-3.dynamic-ip.hinet.net)
2022-01-26 11:26:15 +0100ph88^(~ph88@2a02:8109:9e00:71d0:a803:7e6c:9fe5:13b9) (Ping timeout: 268 seconds)
2022-01-26 11:26:28 +0100ph88^(~ph88@ip5f5af71f.dynamic.kabel-deutschland.de)
2022-01-26 11:26:28 +0100aeka(~aeka@user/hiruji) (Quit: ZNC 1.8.2 - https://znc.in)
2022-01-26 11:26:40 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net)
2022-01-26 11:27:57 +0100aeka(~aeka@2606:6080:1001:18:8d41:9604:d435:36b6)
2022-01-26 11:28:37 +0100yauhsien(~yauhsien@61-231-17-3.dynamic-ip.hinet.net) (Ping timeout: 240 seconds)
2022-01-26 11:30:59 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net) (Ping timeout: 256 seconds)
2022-01-26 11:31:56 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-26 11:31:56 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-26 11:31:56 +0100wroathe(~wroathe@user/wroathe)
2022-01-26 11:34:10 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2022-01-26 11:35:18 +0100wyrd(~wyrd@gateway/tor-sasl/wyrd) (Ping timeout: 276 seconds)
2022-01-26 11:36:37 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2022-01-26 11:37:06 +0100wyrd(~wyrd@gateway/tor-sasl/wyrd)
2022-01-26 11:46:17 +0100davros(~davros@host86-184-180-214.range86-184.btcentralplus.com) (Ping timeout: 240 seconds)
2022-01-26 11:47:37 +0100vglfr(~vglfr@88.155.70.5) (Ping timeout: 256 seconds)
2022-01-26 11:49:19 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 256 seconds)
2022-01-26 11:49:34 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2022-01-26 11:51:05 +0100coot(~coot@89-64-85-93.dynamic.chello.pl) (Remote host closed the connection)
2022-01-26 11:51:29 +0100coot(~coot@2a02:a310:e03f:8500:5cc8:47c:8ec0:b827)
2022-01-26 11:54:47 +0100 <kuribas> If haskell is great because of its expressive typesystem, wouldn't idris be better, since the type level is just the language?
2022-01-26 11:55:17 +0100 <kuribas> types are just values, so expressing something in a type is as simple as expressing it in a value.
2022-01-26 11:55:32 +0100 <[exa]> it might be the delicate separation of the concerns that makes it great.
2022-01-26 11:56:11 +0100 <kuribas> haskell?
2022-01-26 11:56:18 +0100 <[exa]> yes
2022-01-26 11:56:29 +0100 <dminuoso> Mmm, is there any alex-mode for emacs?
2022-01-26 11:56:42 +0100 <kuribas> I am not even sure haskell is "great".
2022-01-26 11:57:15 +0100 <dminuoso> kuribas: Counter argument, haskell is great for simple things like highly reusable ADTs such as Maybe.
2022-01-26 11:57:39 +0100 <dminuoso> Simple and elegant ways to define and discriminate on ADTs is what I love most. :)
2022-01-26 11:57:41 +0100 <kuribas> dminuoso: you can have that with dependently typed languages?
2022-01-26 11:57:45 +0100 <dminuoso> Sure you can.
2022-01-26 11:57:51 +0100 <dminuoso> But I dont care for dependently typed things.
2022-01-26 11:57:53 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 11:57:57 +0100 <dminuoso> In fact, I dont leverage the type system much in Haskell
2022-01-26 11:58:26 +0100 <kuribas> dminuoso: how do you make a specification then?
2022-01-26 11:58:37 +0100 <kuribas> it's strictly separate from the code?
2022-01-26 11:58:47 +0100 <dminuoso> Mostly in tests
2022-01-26 11:58:57 +0100 <dminuoso> Or completely separate, yes.
2022-01-26 11:58:58 +0100davros(~davros@host86-184-82-149.range86-184.btcentralplus.com)
2022-01-26 11:59:32 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 240 seconds)
2022-01-26 11:59:56 +0100 <dminuoso> I'd rather have our team able to work on my code, than be the sole maintainer with grand delusions about my code being bug-free.
2022-01-26 12:00:12 +0100 <dminuoso> It's just more productive this way :)
2022-01-26 12:00:18 +0100 <kuribas> bug-free or "correctness" is an illusion.
2022-01-26 12:00:26 +0100 <dminuoso> Indeed
2022-01-26 12:00:59 +0100 <kuribas> Most of that time you get a vague spec, which can be interpreted in many ways.
2022-01-26 12:02:20 +0100 <kuribas> more interesting is "consistent with itself and the rest of the system".
2022-01-26 12:02:44 +0100mikoto-chan(~mikoto-ch@84.199.144.235) (Ping timeout: 250 seconds)
2022-01-26 12:03:11 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 12:04:13 +0100 <kuribas> IMO one of the primary benefits of DT can be to express the API spec in the code, and show it's consistent with the implementation.
2022-01-26 12:04:32 +0100 <kuribas> Like servant, but the spec can be just a value.
2022-01-26 12:05:01 +0100 <kuribas> you could even calculate the spec from another spec :)
2022-01-26 12:06:37 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 240 seconds)
2022-01-26 12:07:16 +0100vglfr(~vglfr@88.155.70.5)
2022-01-26 12:07:16 +0100 <kuribas> Or for exampe to prove that your API matches the database schema.
2022-01-26 12:07:29 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17) (Remote host closed the connection)
2022-01-26 12:07:31 +0100 <kuribas> True you can do this in tests as well.
2022-01-26 12:07:41 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17)
2022-01-26 12:09:58 +0100ekai-zendo[m](~ekai-zend@2001:470:69fc:105::1:7756)
2022-01-26 12:14:34 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2022-01-26 12:15:35 +0100haskellberryfinn(~nut@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Ping timeout: 268 seconds)
2022-01-26 12:17:16 +0100dsrt^(~dsrt@96-86-240-178-static.hfc.comcastbusiness.net) (Remote host closed the connection)
2022-01-26 12:21:32 +0100jgeerds(~jgeerds@55d4a547.access.ecotel.net) (Ping timeout: 240 seconds)
2022-01-26 12:26:28 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2022-01-26 12:30:02 +0100ekai-zendo[m]ekai[m]
2022-01-26 12:30:07 +0100ph88^(~ph88@ip5f5af71f.dynamic.kabel-deutschland.de) (Ping timeout: 256 seconds)
2022-01-26 12:31:28 +0100tubogram4(~tubogram@user/tubogram) (Quit: See ya later!)
2022-01-26 12:34:02 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2022-01-26 12:35:49 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-26 12:41:07 +0100timmot(~timmot@207.148.85.201)
2022-01-26 12:42:03 +0100jakalx(~jakalx@base.jakalx.net) ()
2022-01-26 12:42:48 +0100Gurkenglas(~Gurkengla@dslb-090-186-104-244.090.186.pools.vodafone-ip.de) (Read error: Connection reset by peer)
2022-01-26 12:43:14 +0100Gurkenglas(~Gurkengla@dslb-090-186-104-244.090.186.pools.vodafone-ip.de)
2022-01-26 12:48:19 +0100 <dminuoso> Servant stretches it quite far, honestly. Perhaps OpenAPI with a static code generator is ultimately the most pragmatic thing.
2022-01-26 12:48:38 +0100 <dminuoso> Especially if it could generate client/server stub code, similar to say CORBA IDL compilers
2022-01-26 12:49:29 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2022-01-26 12:49:50 +0100 <dminuoso> Fighting for servant to keep everything inside the type system makes it difficult to extend it. To implement custom combinators you need to have advanced type-level skills and work with large portions of mostly undocumented code.
2022-01-26 12:50:17 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 12:50:20 +0100 <dminuoso> And the diagnostics are quite poor as well - even generic servant suffers from various poor ergonomics.
2022-01-26 12:50:23 +0100 <dminuoso> Not to mention the performance impact.
2022-01-26 12:50:37 +0100 <dminuoso> We have a relatively small servant library, but compiling the servant glue code alone takes over 2 minutes here.
2022-01-26 12:51:42 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Read error: Connection reset by peer)
2022-01-26 12:52:17 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 12:55:03 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 268 seconds)
2022-01-26 12:58:37 +0100vysn(~vysn@user/vysn)
2022-01-26 12:59:49 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 13:02:20 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Read error: Connection reset by peer)
2022-01-26 13:02:32 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 13:03:04 +0100Akiva(~Akiva@user/Akiva) (Ping timeout: 268 seconds)
2022-01-26 13:03:49 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 240 seconds)
2022-01-26 13:06:37 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 240 seconds)
2022-01-26 13:06:57 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2022-01-26 13:08:50 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-26 13:12:04 +0100jakalx(~jakalx@base.jakalx.net)
2022-01-26 13:15:42 +0100yauhsien(~yauhsien@61-231-17-3.dynamic-ip.hinet.net)
2022-01-26 13:16:47 +0100on^(~on@96-86-240-178-static.hfc.comcastbusiness.net)
2022-01-26 13:19:20 +0100geranim0(~geranim0@d-132-204-221-88.res.umontreal.ca)
2022-01-26 13:26:05 +0100Guest52(~Guest52@80-100-97-100.ip.xs4all.nl)
2022-01-26 13:26:30 +0100max22-(~maxime@lfbn-ren-1-1026-62.w92-139.abo.wanadoo.fr) (Ping timeout: 268 seconds)
2022-01-26 13:31:32 +0100ec(~ec@gateway/tor-sasl/ec)
2022-01-26 13:32:44 +0100jgeerds(~jgeerds@55d4a547.access.ecotel.net)
2022-01-26 13:34:39 +0100yauhsien(~yauhsien@61-231-17-3.dynamic-ip.hinet.net) (Remote host closed the connection)
2022-01-26 13:39:49 +0100HotblackDesiato_(~HotblackD@gateway/tor-sasl/hotblackdesiato) (Remote host closed the connection)
2022-01-26 13:40:32 +0100Guest52(~Guest52@80-100-97-100.ip.xs4all.nl) (Ping timeout: 240 seconds)
2022-01-26 13:40:43 +0100 <dminuoso> tomsmeding: Hah I recall why I wanted it this way. So this is a domain label parser (which roughly just produces [String] for each label). I wanted to use: `(label `sepBy` chunk ".") <* chunk "."` as to neatly allow "." to be parsed.
2022-01-26 13:41:33 +0100 <dminuoso> The elegant form would be to rather to pretend that absolute domains are relative domains too, with the final label being empty
2022-01-26 13:41:37 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475) (Ping timeout: 240 seconds)
2022-01-26 13:42:03 +0100 <dminuoso> Which incidentally is the original intent in DNS
2022-01-26 13:42:10 +0100yauhsien(~yauhsien@61-231-17-3.dynamic-ip.hinet.net)
2022-01-26 13:42:21 +0100ph88^(~ph88@ip5f5af71f.dynamic.kabel-deutschland.de)
2022-01-26 13:43:45 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475)
2022-01-26 13:44:24 +0100__monty__(~toonn@user/toonn)
2022-01-26 13:46:37 +0100yauhsien(~yauhsien@61-231-17-3.dynamic-ip.hinet.net) (Ping timeout: 240 seconds)
2022-01-26 13:51:30 +0100kjak(~kjak@pool-108-45-56-21.washdc.fios.verizon.net) (Ping timeout: 250 seconds)
2022-01-26 13:54:23 +0100alp(~alp@user/alp) (Remote host closed the connection)
2022-01-26 13:54:42 +0100alp(~alp@user/alp)
2022-01-26 13:56:09 +0100 <tomsmeding> dminuoso: heh nice hack
2022-01-26 13:56:17 +0100 <tomsmeding> which, as you say, is not actually really a hack
2022-01-26 14:00:11 +0100 <dminuoso> Well it doesnt work with megaparsec anymore
2022-01-26 14:00:42 +0100 <dminuoso> Im kind of curious how to parse an absolute domain name representation into labels, turning "." into the empty list of labels
2022-01-26 14:01:10 +0100HotblackDesiato(~HotblackD@gateway/tor-sasl/hotblackdesiato)
2022-01-26 14:03:00 +0100 <dminuoso> Of course I can special case this with the monadic power, where I first try and parse for `chunk "." *> eof`, and if that fails I fallback to the other logic
2022-01-26 14:03:21 +0100 <dminuoso> But I dislike having to waste those CPU cycles for an edge case nobody will ever use..
2022-01-26 14:04:33 +0100 <tomsmeding> dminuoso: many alphaNum `sepBy1` char '.', then filter on empties?
2022-01-26 14:04:42 +0100 <dminuoso> tomsmeding: That will fail.
2022-01-26 14:04:47 +0100 <tomsmeding> (parsec language, not megaparsec)
2022-01-26 14:04:53 +0100 <tomsmeding> counterexample?
2022-01-26 14:05:08 +0100 <dminuoso> Oh.
2022-01-26 14:05:10 +0100 <dminuoso> Mmm
2022-01-26 14:05:17 +0100 <dminuoso> tomsmeding: Yeah, so here comes the problem
2022-01-26 14:05:46 +0100 <dminuoso> tomsmeding: The label parser cannot be bootstrapped from `many`eable in my acse
2022-01-26 14:06:02 +0100 <dminuoso> Well, strictly speaking I could I guess.
2022-01-26 14:06:13 +0100 <tomsmeding> dminuoso: as long as it will never parse a dot, it's fine, right?
2022-01-26 14:06:20 +0100 <tomsmeding> can wrap it in 'optional' maybe
2022-01-26 14:07:28 +0100 <dminuoso> tomsmeding: So yeah, the ugly truth is domain name representations are not well defined, so strictly speaking I can admit whatever I want.
2022-01-26 14:07:36 +0100 <dminuoso> even a dot in principle is admissable
2022-01-26 14:07:43 +0100 <tomsmeding> that makes no sense
2022-01-26 14:07:43 +0100 <dminuoso> the wire protocol allows for dots inside a domain label
2022-01-26 14:08:09 +0100 <dminuoso> tomsmeding: what you read as `foo.bar.` is just a representation, and that representation is not standardized. equivalently, there's no such standardized input format.
2022-01-26 14:08:10 +0100 <tomsmeding> how is someone going to provide a domain name component containing a dot?
2022-01-26 14:08:17 +0100 <tomsmeding> right
2022-01-26 14:08:21 +0100 <dminuoso> that's for you to decide. maybe escape characters?
2022-01-26 14:08:25 +0100 <tomsmeding> :p
2022-01-26 14:08:37 +0100 <tomsmeding> or punycode
2022-01-26 14:08:45 +0100 <dminuoso> sure
2022-01-26 14:09:08 +0100 <dminuoso> I really want to do this with alex/happy, but they dont work on arbitrary bytestrings.
2022-01-26 14:09:10 +0100 <dminuoso> :(
2022-01-26 14:09:35 +0100 <dminuoso> Perhaps I should just use them, and simply forbid bytesequences outside the ASCII planes.
2022-01-26 14:09:44 +0100 <dminuoso> And then have the alex output turn the labels back into bytestrings
2022-01-26 14:09:48 +0100 <dminuoso> Or *happy rather
2022-01-26 14:10:41 +0100 <dminuoso> tomsmeding: So the problem with your `many` is that I cant allow arbitrary characters (for irrelevant reasons) unless I allow for escape cahracters
2022-01-26 14:10:42 +0100 <tomsmeding> dminuoso: I'm still not sure how exactly your envisioned grammar is different from "label `endBy` char '.'"
2022-01-26 14:11:00 +0100 <dminuoso> Uh hold on
2022-01-26 14:11:06 +0100 <dminuoso> Never seen endBy
2022-01-26 14:11:10 +0100fendor_(~fendor@77.119.174.56.wireless.dyn.drei.com)
2022-01-26 14:11:23 +0100 <tomsmeding> just one of the convenience combinators
2022-01-26 14:11:37 +0100 <tomsmeding> in parsec: endBy p sep = many (do{ x <- p; _ <- sep; return x })
2022-01-26 14:13:27 +0100 <dminuoso> tomsmeding: Oh hah I was thinking about it all wrong.
2022-01-26 14:13:36 +0100fendor(~fendor@77.119.167.8.wireless.dyn.drei.com) (Ping timeout: 250 seconds)
2022-01-26 14:13:38 +0100 <dminuoso> absDomainLabelsP = DomainLabels <$> label `endBy` M.chunk "."
2022-01-26 14:13:39 +0100 <dminuoso> relDomainLabelsP = DomainLabels <$> label `sepBy` M.chunk "."
2022-01-26 14:13:41 +0100 <dminuoso> So simple..
2022-01-26 14:14:09 +0100 <dminuoso> Guess I should use `char` rather than `chunk` as well
2022-01-26 14:15:23 +0100 <tomsmeding> relOrAbsDomainLabelsP = DomainLabels <$> label `sepBy` M.char '.' <* optional (char '.')
2022-01-26 14:15:48 +0100 <tomsmeding> can even case on the optional result to know which one it is :)
2022-01-26 14:16:12 +0100xff0x(~xff0x@2001:1a81:53ec:e00:81a4:7fd8:2f5d:f55d) (Ping timeout: 250 seconds)
2022-01-26 14:16:14 +0100 <dminuoso> For our use case we only ever care about absolute domains anyway
2022-01-26 14:16:22 +0100 <dminuoso> The other one is just added for completeness. :)
2022-01-26 14:17:17 +0100xff0x(~xff0x@2001:1a81:53ec:e00:324f:b25a:5d11:7fc0)
2022-01-26 14:18:32 +0100Major_Biscuit(~MajorBisc@c-001-019-027.client.tudelft.eduvpn.nl) (Ping timeout: 240 seconds)
2022-01-26 14:19:48 +0100TheCoffeMaker(~TheCoffeM@user/thecoffemaker)
2022-01-26 14:24:07 +0100gaff(~gaff@49.207.213.209)
2022-01-26 14:24:28 +0100jgeerds(~jgeerds@55d4a547.access.ecotel.net) (Ping timeout: 268 seconds)
2022-01-26 14:24:28 +0100Clint(~Clint@user/clint) (Ping timeout: 268 seconds)
2022-01-26 14:24:37 +0100TheCoffeMaker(~TheCoffeM@user/thecoffemaker) (Ping timeout: 240 seconds)
2022-01-26 14:24:42 +0100 <dminuoso> tomsmeding: Mmm, the absDomainLabelsP still doesnt parse "."
2022-01-26 14:24:53 +0100 <dminuoso> But I understand why
2022-01-26 14:25:15 +0100Major_Biscuit(~MajorBisc@86-88-79-148.fixed.kpn.net)
2022-01-26 14:25:42 +0100 <gaff> does `read "0b11111111" :: Int` work if you set the "BinaryLiterals" extension? when i tried, it throws an exception in GHCi.
2022-01-26 14:26:31 +0100 <tomsmeding> gaff: I think the BinaryLiterals extension just modifies the syntax that ghc accepts, it doesn't modify the semantics of any library functios
2022-01-26 14:27:13 +0100 <tomsmeding> imagine, if one file in your project has the extension on, and another file has not, would 'read' return two different things in both files? What if you call a function from the other file in one file, which in turn calls read? Madness!
2022-01-26 14:27:34 +0100 <dminuoso> tomsmeding: I have an evil cunning plan.
2022-01-26 14:27:43 +0100 <dminuoso> I will simply prepend a null byte to the original string, and then fixup the grammar
2022-01-26 14:27:56 +0100 <dminuoso> (well put it at the end I mean)
2022-01-26 14:27:58 +0100 <tomsmeding> dminuoso: how does your 'label' parser even look if you're considering this
2022-01-26 14:28:05 +0100 <gaff> tomsmeding: well, `read "0xFF00" :: Int` works ... so why not?
2022-01-26 14:28:17 +0100 <dminuoso> tomsmeding: absDomainLabelsP = DomainLabels <$> label `endBy` M.char (c2w '.') <* M.char 0
2022-01-26 14:28:20 +0100 <tomsmeding> dminuoso: also if you're putting it at the end anyway, what about replacing your detection of that null byte with 'eof'
2022-01-26 14:28:32 +0100 <dminuoso> Sorry hold on
2022-01-26 14:28:33 +0100 <tomsmeding> dminuoso: I meant 'label'
2022-01-26 14:28:34 +0100 <dminuoso> No I meant:
2022-01-26 14:28:43 +0100 <tomsmeding> gaff: because that has always worked :p
2022-01-26 14:28:55 +0100 <dminuoso> tomsmeding: I dont want to use the monadic power
2022-01-26 14:29:06 +0100 <tomsmeding> ah
2022-01-26 14:29:06 +0100 <dminuoso> my honor forbids it
2022-01-26 14:29:18 +0100 <tomsmeding> is there an actual practical reason you don't want to use it?
2022-01-26 14:29:23 +0100 <dminuoso> Not at all
2022-01-26 14:29:26 +0100 <tomsmeding> cool
2022-01-26 14:29:56 +0100 <tomsmeding> still, if you allow choice, then you probably had that null-byte recogniser in an alternative there; just replace that with 'eof'?
2022-01-26 14:29:57 +0100 <geekosaur> "Reading integers
2022-01-26 14:29:57 +0100 <geekosaur> GHC’s implementation of the Read class for integral types accepts hexadecimal and octal literals (the code in the Haskell 98 report doesn’t)."
2022-01-26 14:30:04 +0100 <dminuoso> If I had some formal education in grammar, I would probably just specify a grammar and then match the megaparsec to follow this
2022-01-26 14:30:08 +0100 <geekosaur> nothing about binary literals
2022-01-26 14:30:50 +0100 <gaff> geekosaur: i see ... so why have binary literals?
2022-01-26 14:30:59 +0100 <merijn> gaff: Why not?
2022-01-26 14:30:59 +0100 <tomsmeding> gaff: another way to look at this: 'read' doesn't parse haskell, it parses something that looks like a subset of haskell. By extension that means that if you add a language extensions that modifies ghc's understanding of "haskell", 'read' doesn't change.
2022-01-26 14:31:01 +0100 <dminuoso> geekosaur: Arguably, if GHC modifies what GHC accepts syntactically, the generated Read instances should be altered as well. :p
2022-01-26 14:31:03 +0100 <gaff> what's the extension for?
2022-01-26 14:31:03 +0100 <geekosaur> dunno, I didn't propose them
2022-01-26 14:31:09 +0100 <dminuoso> Of course that's completely unreasonable given the open-world assumption
2022-01-26 14:31:14 +0100 <merijn> gaff: For writing binary numbers as literals?
2022-01-26 14:31:14 +0100 <tomsmeding> % :set -XBinaryLiterals
2022-01-26 14:31:14 +0100 <yahb> tomsmeding:
2022-01-26 14:31:16 +0100 <tomsmeding> % 0b1010
2022-01-26 14:31:17 +0100 <yahb> tomsmeding: 10
2022-01-26 14:31:17 +0100xff0x(~xff0x@2001:1a81:53ec:e00:324f:b25a:5d11:7fc0) (Ping timeout: 240 seconds)
2022-01-26 14:31:39 +0100 <geekosaur> anyone can propose an extension to ghc
2022-01-26 14:31:52 +0100 <tomsmeding> dminuoso: see my argument about two modules having differing extension sets :p
2022-01-26 14:31:58 +0100 <merijn> I mean, wanting to write specific bit patterns is pretty common in programming. Especially when interfacing with binary file formats, network protocols, etc. the ability to directly write bit patterns is kinda convenient
2022-01-26 14:32:05 +0100 <geekosaur> it's more likely to be accepted if it includes an implementation
2022-01-26 14:32:06 +0100 <gaff> dminuoso: i agree with you what you said ... i don't understand the other side of the argument
2022-01-26 14:32:16 +0100 <dminuoso> tomsmeding: I think this is one of those cases where the extension isn't well suited for Haskell. There's clearly a strange and surprising interaction.
2022-01-26 14:32:29 +0100xff0x(~xff0x@2001:1a81:53ec:e00:6733:4fa5:6e13:2687)
2022-01-26 14:32:30 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 14:32:58 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net)
2022-01-26 14:33:07 +0100 <gaff> tomsmeding: by the way, your argument about extensions would all extensions
2022-01-26 14:33:10 +0100 <tomsmeding> evidently it is indeed surprising to some, which makes it surprising overall. Though I personally don't find it surprising that a language syntax modification doesn't change the behaviour of a library function :)
2022-01-26 14:33:13 +0100 <merijn> tbh, I think it's easier to just kill off Read
2022-01-26 14:33:21 +0100 <dminuoso> Read and Show both should be gone.
2022-01-26 14:33:26 +0100 <merijn> Read is just bad, besides moderate convenience benefit while writing
2022-01-26 14:33:29 +0100 <merijn> Show is fine I think
2022-01-26 14:33:34 +0100 <dminuoso> Show should use Text.
2022-01-26 14:33:41 +0100 <merijn> Most bad show instances are a result of people wanting to use Read :p
2022-01-26 14:33:46 +0100 <dminuoso> The amount of showT I use in my code base is absurd.
2022-01-26 14:33:59 +0100ac(~aloiscoch@2001:470:69fc:105::65)
2022-01-26 14:34:02 +0100 <dminuoso> I use Show as poor mans pretty.
2022-01-26 14:36:13 +0100 <gaff> merijn: so writing bit pattersn is important, but reading them is not?
2022-01-26 14:36:44 +0100 <merijn> gaff: Dynamically modifying class instances (like Show) is an absolute nightmare idea. Ideally Haskell Prime (ahaha! Funny, I make it sound like that will ever happen) to include a bunch of the benign numeric literal extension into the report, making them standard, then updating Read to accept them
2022-01-26 14:37:06 +0100 <merijn> gaff: It is. But if you're using Read you're already messing up, so I don't particularly care about Read supporting them.
2022-01-26 14:37:25 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net) (Ping timeout: 256 seconds)
2022-01-26 14:37:26 +0100 <geekosaur> harder these days as modifying Read is libraries committee, not ghc committee, and libraries is much more conservative
2022-01-26 14:37:30 +0100 <merijn> I would actually argue Read not supporing them is "Good (TM)", since it'll hopefull deter people from thinking Read is a remotely sane choice
2022-01-26 14:37:46 +0100frosky_(~froskyarr@120.239.9.244)
2022-01-26 14:37:57 +0100 <kuribas> dminuoso: exactly, servant is painful because you have a different language at type level.
2022-01-26 14:38:10 +0100 <gaff> merijn: so instead of `Read`, what do you use?
2022-01-26 14:38:10 +0100 <kuribas> dminuoso: with DT, you could just do all this at value level.
2022-01-26 14:38:23 +0100 <merijn> gaff: (mega)parsec and attoparsec
2022-01-26 14:38:28 +0100 <gaff> ah
2022-01-26 14:38:34 +0100 <gaff> gee
2022-01-26 14:38:38 +0100 <dminuoso> kuribas: I think this is an equally bad here for this use case.
2022-01-26 14:38:47 +0100 <merijn> gaff: For "one of" numbers there's also the Numeric module in base
2022-01-26 14:38:52 +0100 <dminuoso> This type of problem is better suited to a domain specific language and code generation tools.
2022-01-26 14:38:54 +0100 <geekosaur> read uses a half-assed, slow, ambiguous (but then it tries to hide it) parser
2022-01-26 14:39:05 +0100 <kuribas> dminuoso: well, DT is kind of code generation.
2022-01-26 14:39:22 +0100 <tomsmeding> gaff: suppose I have one module A, that calls 'read "0b10". I have another module B that sets BinaryLiterals and also calls 'read "0b10"'. Furthermore, A defines a function 'foo' that itself calls 'read "0b10"', and B has a function 'bar' that calls A.foo . Should 'bar' succeed?
2022-01-26 14:39:33 +0100 <merijn> gaff: Which has readers for bin, oct, decimal, hex, and even custom versions
2022-01-26 14:39:39 +0100 <dminuoso> merijn: Im slowly thinking we should use less megaparsec and more alex/happy
2022-01-26 14:39:53 +0100 <dminuoso> Im slowly experiencing the wonders of these ancient and almost forgotten tools.
2022-01-26 14:40:00 +0100 <merijn> dminuoso: I don't think it's worth it for most human readable formats
2022-01-26 14:40:12 +0100SwarmCollective(~joseph@2603-6011-bc02-b600-af23-4557-ff2b-bd76.res6.spectrum.com) (Remote host closed the connection)
2022-01-26 14:40:12 +0100eL_Bart0(eL_Bart0@dietunichtguten.org) (Read error: Connection reset by peer)
2022-01-26 14:40:15 +0100 <merijn> dminuoso: alex/happy are *great* if you have a grammar that's set in stone
2022-01-26 14:40:15 +0100 <dminuoso> Predictably high performance and acceptable diagnostics? Yes please.
2022-01-26 14:40:17 +0100FroskyArr(~froskyarr@120.239.9.244) (Ping timeout: 240 seconds)
2022-01-26 14:40:27 +0100pieguy128(~pieguy128@bras-base-mtrlpq5031w-grc-52-65-93-194-105.dsl.bell.ca) (Ping timeout: 256 seconds)
2022-01-26 14:40:33 +0100 <dminuoso> merijn: Maybe that's the problem, people not formally specifying grammars for what they want.
2022-01-26 14:40:34 +0100SwarmCollective(~joseph@2603-6011-bc02-b600-2151-3d00-3640-3cd8.res6.spectrum.com)
2022-01-26 14:40:35 +0100 <merijn> Most time I write a parser in megaparsec, my grammar is *not* set in stone and kinda half-assed
2022-01-26 14:40:40 +0100 <gaff> merijn: yeah, i know. but don't you think haskell should have a `Read`, a better one even if the current stuff has many things amiss?
2022-01-26 14:41:11 +0100 <dminuoso> merijn: Like, have you tried parsing markdown? What is the original markdown syntax even? Who knows, even the reference implementation is bugged with respect to their own examples.
2022-01-26 14:41:12 +0100 <merijn> gaff: The API of Read is just kinda bad for doing anything efficient. Read is *horribly* slow
2022-01-26 14:41:18 +0100 <kuribas> dminuoso: code generation is messy.
2022-01-26 14:41:20 +0100 <merijn> dminuoso: Markdown is just it's own hell
2022-01-26 14:41:27 +0100 <gaff> ok
2022-01-26 14:41:39 +0100 <merijn> dminuoso: I'm thinking more of "parsing output from my own programs"
2022-01-26 14:41:47 +0100 <dminuoso> gaff: Not to mention that Read has absolutely no diagnostics for when it doesnt parse.
2022-01-26 14:42:19 +0100 <gaff> dminuoso: i agree, but i am arguing for a "better" read.
2022-01-26 14:42:19 +0100 <dminuoso> merijn: I tend to define interchange formats (say via JSON). So at least you have a kind of schema inside that.
2022-01-26 14:42:36 +0100 <merijn> dminuoso: Half of the time I'm using megaparsec to parse some ad hoc format my own code outputs somewhere else. Usually simple enough that a "proper grammar" is more work than necessary, but *not* using parser combinators would make the input really annoying to deal with
2022-01-26 14:43:55 +0100pieguy128(~pieguy128@bas1-montreal02-65-92-163-251.dsl.bell.ca)
2022-01-26 14:44:49 +0100 <gaff> thanks everyone
2022-01-26 14:44:56 +0100gaff(~gaff@49.207.213.209) ()
2022-01-26 14:45:59 +0100 <merijn> In general I think the Numeric module is one of those base modules that is more obscure than it should be
2022-01-26 14:46:05 +0100eL_Bart0(eL_Bart0@dietunichtguten.org)
2022-01-26 14:46:32 +0100 <geekosaur> yes
2022-01-26 14:46:39 +0100 <geekosaur> in several senses
2022-01-26 14:48:20 +0100 <dminuoso> Python definitely has an advantage with respect to easing beginners into solving immediate problems by giving them simple tools to parse and and process data.
2022-01-26 14:49:03 +0100 <dminuoso> Not that I prefer it, but from a beginners perspective I can see how Haskell might seem unwieldy when it's not even obvious and simple how to "take a file and process it" given just base.
2022-01-26 14:50:09 +0100 <merijn> Sure.
2022-01-26 14:50:30 +0100 <merijn> It's just one of those things where "what's easy for beginners" and "what is good long term" are not remotely the same
2022-01-26 14:54:41 +0100deadmarshal(~deadmarsh@95.38.116.147) (Ping timeout: 268 seconds)
2022-01-26 14:55:04 +0100deadmarshal(~deadmarsh@95.38.112.231)
2022-01-26 14:56:07 +0100Guest52(~Guest52@80-100-97-100.ip.xs4all.nl)
2022-01-26 14:56:59 +0100tubogram4(~tubogram@user/tubogram)
2022-01-26 14:57:37 +0100 <maerwald> dminuoso: even as a non-beginner, it's confusing
2022-01-26 14:59:33 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 15:01:40 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Read error: Connection reset by peer)
2022-01-26 15:01:59 +0100bontaq(~user@ool-45779fe5.dyn.optonline.net)
2022-01-26 15:02:49 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 15:04:33 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 268 seconds)
2022-01-26 15:05:57 +0100tubogram4(~tubogram@user/tubogram) (Quit: See ya later!)
2022-01-26 15:07:32 +0100pieguy128(~pieguy128@bas1-montreal02-65-92-163-251.dsl.bell.ca) (Ping timeout: 240 seconds)
2022-01-26 15:08:01 +0100tubogram4(~tubogram@user/tubogram)
2022-01-26 15:08:11 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17) (Remote host closed the connection)
2022-01-26 15:08:48 +0100tubogram4(~tubogram@user/tubogram) (Client Quit)
2022-01-26 15:12:48 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net)
2022-01-26 15:13:12 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba)
2022-01-26 15:13:29 +0100tubogram4(~tubogram@user/tubogram)
2022-01-26 15:15:31 +0100tubogram4(~tubogram@user/tubogram) (Client Quit)
2022-01-26 15:15:51 +0100max22-(~maxime@2a01cb0883359800c869e03b4284e26a.ipv6.abo.wanadoo.fr)
2022-01-26 15:16:15 +0100tubogram4(~tubogram@user/tubogram)
2022-01-26 15:16:32 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2022-01-26 15:17:17 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba) (Ping timeout: 240 seconds)
2022-01-26 15:17:18 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net) (Ping timeout: 250 seconds)
2022-01-26 15:18:49 +0100pieguy128(~pieguy128@bas8-montreal02-65-93-195-202.dsl.bell.ca)
2022-01-26 15:18:54 +0100wyrd(~wyrd@gateway/tor-sasl/wyrd) (Ping timeout: 276 seconds)
2022-01-26 15:19:04 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net)
2022-01-26 15:22:05 +0100deadmarshal_(~deadmarsh@95.38.116.86)
2022-01-26 15:22:23 +0100deadmarshal(~deadmarsh@95.38.112.231) (Ping timeout: 256 seconds)
2022-01-26 15:25:08 +0100wyrd(~wyrd@gateway/tor-sasl/wyrd)
2022-01-26 15:27:17 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net) (Ping timeout: 240 seconds)
2022-01-26 15:28:21 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net)
2022-01-26 15:30:58 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 15:32:24 +0100haskellberryfinn(~nut@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2022-01-26 15:32:41 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-26 15:32:41 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-26 15:32:41 +0100wroathe(~wroathe@user/wroathe)
2022-01-26 15:35:23 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 268 seconds)
2022-01-26 15:38:23 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2022-01-26 15:38:50 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-26 15:41:57 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 240 seconds)
2022-01-26 15:43:18 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 250 seconds)
2022-01-26 15:43:21 +0100on^(~on@96-86-240-178-static.hfc.comcastbusiness.net) (Remote host closed the connection)
2022-01-26 15:45:37 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net) (Ping timeout: 256 seconds)
2022-01-26 15:46:24 +0100 <dminuoso> tomsmeding: https://gitlab.com/wobcom/haskell/dns-patterns/-/blob/master/lib/Network/DNS/Pattern.hs#L165-169
2022-01-26 15:46:29 +0100 <dminuoso> I decided to special case it after all.
2022-01-26 15:46:39 +0100shailangsa(~shailangs@host86-185-98-37.range86-185.btcentralplus.com) ()
2022-01-26 15:46:45 +0100 <dminuoso> I feel like this is still cheating, Im looking for something grammatically pleasing
2022-01-26 15:49:13 +0100 <tomsmeding> dminuoso: you can't get around branching on whether you have the root domain somehow, because you have to act differently depending on whether the input starts with a dot (root domain, nothing can come after) or not (non-root domain, must have a label then dot then etc.)
2022-01-26 15:49:34 +0100 <tomsmeding> the branch doesn't need lookahead though, so it's all good :)
2022-01-26 15:50:12 +0100 <dminuoso> tomsmeding: I can get around it if I employ my "append a nul byte" trick though.
2022-01-26 15:50:30 +0100 <tomsmeding> can you?
2022-01-26 15:51:07 +0100SummerSonw(~The_viole@203.77.49.232) (Read error: Connection reset by peer)
2022-01-26 15:52:13 +0100shriekingnoise(~shrieking@201.231.16.156)
2022-01-26 15:52:19 +0100epolanski(uid312403@id-312403.helmsley.irccloud.com)
2022-01-26 15:54:37 +0100mvk(~mvk@2607:fea8:5cdc:bf00::a2bf) (Ping timeout: 240 seconds)
2022-01-26 15:55:15 +0100imalsogreg(~imalsogre@c-73-133-206-117.hsd1.md.comcast.net)
2022-01-26 15:57:53 +0100 <dminuoso> tomsmeding: Yes, given that now my labels permit nul bytes
2022-01-26 15:58:05 +0100 <dminuoso> Or..
2022-01-26 15:58:07 +0100 <dminuoso> mmm.
2022-01-26 15:58:20 +0100 <tomsmeding> you'd need to _prepend_ a nul byte, right?
2022-01-26 15:58:32 +0100 <tomsmeding> that would work
2022-01-26 15:58:43 +0100 <tomsmeding> but I find that uglier than fixing the grammar, which is what you've done now
2022-01-26 15:58:46 +0100 <tomsmeding> but subjective
2022-01-26 15:58:46 +0100 <dminuoso> No it would not
2022-01-26 15:58:51 +0100 <dminuoso> Because I have to get that nul byte out again
2022-01-26 15:58:55 +0100waleee(~waleee@2001:9b0:21d:fc00:398f:b003:b90d:acf4)
2022-01-26 15:59:03 +0100 <tomsmeding> though you could do that with an fmap
2022-01-26 15:59:15 +0100 <dminuoso> an fmap1 really
2022-01-26 15:59:24 +0100 <tomsmeding> fmap1?
2022-01-26 15:59:30 +0100 <dminuoso> Sure, consider this input:
2022-01-26 15:59:40 +0100tomsmedinghas a meeting now but will be back later and see your stuff
2022-01-26 15:59:43 +0100 <dminuoso> "\NUL."
2022-01-26 16:00:05 +0100 <dminuoso> If I prepend a \NUL, this ends up producing DomainLabels ["\NUL\NUL"]
2022-01-26 16:00:08 +0100 <dminuoso> And similarly:
2022-01-26 16:00:22 +0100 <dminuoso> "\NUL.\NUL. would produce DomainLabels ["\NUL\NUL", "\NUL"]
2022-01-26 16:00:36 +0100 <dminuoso> I cant just fmap over the result
2022-01-26 16:00:48 +0100soxen(~bob@pool-173-54-217-168.nwrknj.fios.verizon.net)
2022-01-26 16:00:51 +0100 <dminuoso> I must only drop the first character on the first element
2022-01-26 16:01:10 +0100 <dminuoso> hence `fmap1` (which just maps over the first element)
2022-01-26 16:03:58 +0100dyeplexer(~dyeplexer@user/dyeplexer)
2022-01-26 16:05:02 +0100 <sshine> oh, like 'fmap f (First xs)'? https://hackage.haskell.org/package/base-4.16.0.0/docs/Data-Monoid.html#t:First
2022-01-26 16:06:42 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2022-01-26 16:06:42 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 250 seconds)
2022-01-26 16:09:20 +0100cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.3)
2022-01-26 16:10:05 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net)
2022-01-26 16:11:06 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net) (Client Quit)
2022-01-26 16:12:17 +0100FroskyArr(~froskyarr@203.175.13.219)
2022-01-26 16:12:59 +0100bliminse_bliminse
2022-01-26 16:14:17 +0100frosky_(~froskyarr@120.239.9.244) (Ping timeout: 240 seconds)
2022-01-26 16:14:49 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-26 16:14:49 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-26 16:14:49 +0100wroathe(~wroathe@user/wroathe)
2022-01-26 16:15:27 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net)
2022-01-26 16:15:59 +0100 <kuribas> merijn: there should be a language which is easy for beginners, but also with clear semantics.
2022-01-26 16:16:14 +0100 <dminuoso> kuribas: golang is that.
2022-01-26 16:16:20 +0100 <dminuoso> It's probably part of its success story.
2022-01-26 16:16:44 +0100 <dminuoso> If only it had tools to write scalable software..
2022-01-26 16:17:20 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net) (Remote host closed the connection)
2022-01-26 16:19:16 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 250 seconds)
2022-01-26 16:19:26 +0100akegalj(~akegalj@141-136-245-236.dsl.iskon.hr) (Quit: leaving)
2022-01-26 16:19:48 +0100Sgeo(~Sgeo@user/sgeo)
2022-01-26 16:22:04 +0100 <merijn> kuribas: I'm not sure that's possible, tbh
2022-01-26 16:30:24 +0100gaff(~gaff@49.207.213.209)
2022-01-26 16:31:27 +0100 <gaff> someone suggested a few minutes back that `Numeric` module has function to read binary literals, but i don't see it there.
2022-01-26 16:32:26 +0100 <gaff> `readBin` not there in `Numeric`
2022-01-26 16:32:33 +0100Clint(~Clint@user/clint)
2022-01-26 16:32:59 +0100 <merijn> https://hackage.haskell.org/package/base-4.16.0.0/docs/Numeric.html#v:readBin
2022-01-26 16:33:06 +0100 <merijn> Are you looking at the right version?
2022-01-26 16:34:27 +0100 <gaff> but it is not showing up on GHCi. i am using 8.10.4
2022-01-26 16:34:47 +0100 <merijn> Ah, looks like it's fairly new
2022-01-26 16:35:03 +0100 <merijn> You can use readInt to make your own easily enough, though
2022-01-26 16:35:31 +0100 <gaff> merijn: it is fairly new
2022-01-26 16:35:53 +0100 <gaff> my base is 4.14, the link you have posted, the base version is 4.16
2022-01-26 16:35:56 +0100 <gaff> no wonder
2022-01-26 16:36:13 +0100pooryorick(~pooryoric@87-119-174-173.tll.elisa.ee) (Ping timeout: 240 seconds)
2022-01-26 16:37:07 +0100 <gaff> merijn: thanks a bunch, anyway. nice to know it exists in the future :)
2022-01-26 16:39:53 +0100 <geekosaur> why are you on 8.10.4 instead of 8.10.7? (although 8.10.7 still doesn't have readBin, it does have a number of bugfixes and Apple M1 support)
2022-01-26 16:40:26 +0100 <merijn> geekosaur: Inertia? :p
2022-01-26 16:40:37 +0100waleee(~waleee@2001:9b0:21d:fc00:398f:b003:b90d:acf4) (Ping timeout: 240 seconds)
2022-01-26 16:40:48 +0100 <gaff> geekosaur: i am using an old macbook air laptop, so i am risking a newer version because of my OS.
2022-01-26 16:41:13 +0100 <gaff> sorry, i am not risking a newer version because of my OS
2022-01-26 16:41:43 +0100 <gaff> thanks for the information anyway.
2022-01-26 16:41:45 +0100 <merijn> I mean, how old are we talking?
2022-01-26 16:42:06 +0100 <gaff> gee, 9 years old
2022-01-26 16:42:19 +0100 <gaff> nearly 10 years
2022-01-26 16:42:26 +0100 <merijn> oof, ok, that's more extreme than me :p
2022-01-26 16:42:39 +0100 <gaff> yeah, but it is going well
2022-01-26 16:42:53 +0100alex[m](~alexchete@2001:470:69fc:105::1:1001) (Quit: Client limit exceeded: 20000)
2022-01-26 16:42:57 +0100geekosaurremembers his old macbook air
2022-01-26 16:43:08 +0100 <gaff> 8.10.4 GHC installation was a rollercoster .... so
2022-01-26 16:43:11 +0100alex[m](~alexchete@2001:470:69fc:105::1:1001)
2022-01-26 16:43:12 +0100pooryorick(~pooryoric@87-119-174-173.tll.elisa.ee)
2022-01-26 16:43:31 +0100 <geekosaur> battery eventually went kaput, held onto it for a while and then decided I was never going to use it again and ditched it
2022-01-26 16:44:07 +0100 <gaff> geekosaur: my battery holding well, though. did change one 5 years back.
2022-01-26 16:46:53 +0100 <gaff> thnaks
2022-01-26 16:46:58 +0100gaff(~gaff@49.207.213.209) ()
2022-01-26 16:48:15 +0100prrxddq[m](~prrxddqma@2001:470:69fc:105::1:4f72) (Quit: Client limit exceeded: 20000)
2022-01-26 16:48:46 +0100SridharRatnakuma(~sridmatri@2001:470:69fc:105::1c2) (Quit: Client limit exceeded: 20000)
2022-01-26 16:50:05 +0100slack1256(~slack1256@191.125.227.221)
2022-01-26 16:56:25 +0100haskellberryfinn(~nut@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Quit: WeeChat 3.3)
2022-01-26 16:56:58 +0100soxen(~bob@pool-173-54-217-168.nwrknj.fios.verizon.net) (Ping timeout: 250 seconds)
2022-01-26 16:57:35 +0100haskellberryfinn(~nut@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2022-01-26 17:00:06 +0100FroskyArr(~froskyarr@203.175.13.219) (Remote host closed the connection)
2022-01-26 17:00:30 +0100FroskyArr(~froskyarr@203.175.13.219)
2022-01-26 17:09:24 +0100Guest|81(~Guest|81@49.37.170.120)
2022-01-26 17:09:43 +0100Guest|81(~Guest|81@49.37.170.120) (Client Quit)
2022-01-26 17:12:43 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Quit: WeeChat 3.3)
2022-01-26 17:13:00 +0100justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 250 seconds)
2022-01-26 17:16:16 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2022-01-26 17:18:38 +0100slack1256(~slack1256@191.125.227.221) (Remote host closed the connection)
2022-01-26 17:20:29 +0100yauhsien_(~yauhsien@61-231-17-3.dynamic-ip.hinet.net)
2022-01-26 17:24:24 +0100imalsogreg(~imalsogre@c-73-133-206-117.hsd1.md.comcast.net) (Remote host closed the connection)
2022-01-26 17:24:53 +0100yauhsien_(~yauhsien@61-231-17-3.dynamic-ip.hinet.net) (Ping timeout: 250 seconds)
2022-01-26 17:25:22 +0100imalsogreg(~imalsogre@c-73-133-206-117.hsd1.md.comcast.net)
2022-01-26 17:26:02 +0100qwedfg(~qwedfg@user/qwedfg) (Quit: ZNC - https://znc.in)
2022-01-26 17:28:14 +0100 <tomsmeding> dminuoso: well you have to fmap (in the parser monad) fmap1 (on the list)
2022-01-26 17:28:15 +0100prrxddq[m](~prrxddqma@2001:470:69fc:105::1:4f72)
2022-01-26 17:28:27 +0100SridharRatnakuma(~sridmatri@2001:470:69fc:105::1c2)
2022-01-26 17:28:45 +0100 <tomsmeding> I don't see how _appending_ \NUL would help with making this parse with less choice
2022-01-26 17:29:00 +0100 <tomsmeding> though maybe at this point I'm beating a dead horse :p
2022-01-26 17:29:12 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:23a9:7efc:99f6:4072) (Quit: WeeChat 2.8)
2022-01-26 17:29:28 +0100imalsogreg(~imalsogre@c-73-133-206-117.hsd1.md.comcast.net) (Ping timeout: 250 seconds)
2022-01-26 17:29:52 +0100dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2022-01-26 17:30:30 +0100qwedfg(~qwedfg@user/qwedfg)
2022-01-26 17:31:34 +0100thomas_(~thomas@2a02:a03f:666e:c500:92eb:d341:15bc:3f3d)
2022-01-26 17:32:01 +0100imalsogreg(~imalsogre@c-73-133-206-117.hsd1.md.comcast.net)
2022-01-26 17:34:45 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2022-01-26 17:38:25 +0100ShalokShalom(~ShalokSha@194-118-168-233.hdsl.highway.telekom.at)
2022-01-26 17:38:31 +0100 <ShalokShalom> hi there
2022-01-26 17:38:55 +0100 <ShalokShalom> I read about a new version of Haskell, that has a selection of extensions build in
2022-01-26 17:39:04 +0100 <ShalokShalom> What version is this?
2022-01-26 17:39:57 +0100econo(uid147250@user/econo)
2022-01-26 17:40:31 +0100 <geekosaur> 9.2.1 has -XGHC2021 which turns on a selection of extensions. this extension is enabled by default
2022-01-26 17:41:01 +0100 <ShalokShalom> thanks a lot
2022-01-26 17:41:42 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba)
2022-01-26 17:42:34 +0100ShalokShalom(~ShalokSha@194-118-168-233.hdsl.highway.telekom.at) (Client Quit)
2022-01-26 17:43:28 +0100mbuf(~Shakthi@122.173.242.184) (Quit: Leaving)
2022-01-26 17:45:02 +0100yauhsien_(~yauhsien@61-231-17-3.dynamic-ip.hinet.net)
2022-01-26 17:47:36 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net)
2022-01-26 17:48:08 +0100lbseale(~ep1ctetus@user/ep1ctetus)
2022-01-26 17:48:18 +0100Akiva(~Akiva@user/Akiva)
2022-01-26 17:49:49 +0100o(~niko@libera/staff/niko) (Ping timeout: 633 seconds)
2022-01-26 17:49:50 +0100yauhsien_(~yauhsien@61-231-17-3.dynamic-ip.hinet.net) (Ping timeout: 250 seconds)
2022-01-26 17:51:57 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475) (Ping timeout: 240 seconds)
2022-01-26 17:52:00 +0100myShoggoth(~myShoggot@97-120-67-120.ptld.qwest.net)
2022-01-26 17:54:07 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475)
2022-01-26 17:57:23 +0100zmt00(~zmt00@user/zmt00)
2022-01-26 17:59:20 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba) (Remote host closed the connection)
2022-01-26 18:01:37 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 256 seconds)
2022-01-26 18:02:31 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba)
2022-01-26 18:04:29 +0100mvk(~mvk@2607:fea8:5cdc:bf00::a2bf)
2022-01-26 18:05:06 +0100 <janus> is 9.0.2 more reliable than 9.2.1?
2022-01-26 18:05:19 +0100 <maerwald> probably
2022-01-26 18:07:05 +0100 <geekosaur> certainly more reliable on apple m1, because of late severe bugs found in the native codegen
2022-01-26 18:07:17 +0100lionhairdino(~jacoo@121.131.39.82) (Ping timeout: 240 seconds)
2022-01-26 18:07:39 +0100FroskyArr(~froskyarr@203.175.13.219) (Remote host closed the connection)
2022-01-26 18:07:55 +0100zebrag(~chris@user/zebrag)
2022-01-26 18:08:04 +0100FroskyArr(~froskyarr@203.175.13.219)
2022-01-26 18:11:46 +0100 <c_wraith> It probably still has a lot of the 9.0 new-feature bugs (as opposed to regressions) that 9.2 fixed, though.
2022-01-26 18:12:14 +0100 <ephemient> would ghc-9.2.1 with -fllvm be better than 9.0.2 then? (I don't have an M1, just curious)
2022-01-26 18:12:16 +0100 <c_wraith> If you're not looking for bleeding edge stuff, it's definitely the right choice.
2022-01-26 18:13:01 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2022-01-26 18:13:30 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2022-01-26 18:14:38 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net)
2022-01-26 18:14:45 +0100 <geekosaur> -fllvm is not generally recommended for any platform but apple m1s. the codegen bugs in 9.2.1 only affect m1s
2022-01-26 18:17:43 +0100 <janus> c_wraith: which is definitely the right choice? you seem affirmative but that is inconsistent with ephemient's question
2022-01-26 18:19:34 +0100 <EvanR> to quickly reload a haskell "file", module, that has changed and say use the new version of some top level data value there, would mueval work?
2022-01-26 18:19:41 +0100 <EvanR> some kind of eval solution
2022-01-26 18:19:50 +0100 <geekosaur> 9.0.2 is most recently released and fixes the bugs in 9.0.1. 9.2.1 has several bugs but all of them are in new features in the 9.2 series, so unloess you need those features I'd stick with 9.0.2 or even 8.10.7
2022-01-26 18:20:18 +0100 <geekosaur> (lots of people have not upgraded from 8.10.7 yet)
2022-01-26 18:21:33 +0100 <sclv> with m1 its sort of a bad story all round in my experience. i couldn't get the llvm stuff working right, but also afaik its the only option.
2022-01-26 18:21:34 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2022-01-26 18:22:27 +0100 <sclv> that said, i'm using an m1 and 9.2.1 without llvm because i'm developing and not deploying, so i can live with buggy codegen for a smooth dev experience at the moment :-P
2022-01-26 18:22:56 +0100imalsogreg(~imalsogre@c-73-133-206-117.hsd1.md.comcast.net) (Remote host closed the connection)
2022-01-26 18:23:03 +0100 <c_wraith> janus: I meant 9.0.2 is right unless you need bleeding-edge features that work better (or only exist) in 9.2
2022-01-26 18:23:59 +0100ph88^(~ph88@ip5f5af71f.dynamic.kabel-deutschland.de) (Quit: Leaving)
2022-01-26 18:24:31 +0100 <janus> sclv: do you expect these issues to be resolved by 9.2.2?
2022-01-26 18:24:41 +0100ec(~ec@gateway/tor-sasl/ec)
2022-01-26 18:25:20 +0100emf(~emf@2601:602:9400:8f0:435:b386:5ad4:6eb2)
2022-01-26 18:25:33 +0100 <geekosaur> that's the plan. although they intended to release 9.2.2 by the end of the month, and that's fast approaching :(
2022-01-26 18:26:21 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net) (Ping timeout: 256 seconds)
2022-01-26 18:27:07 +0100 <c_wraith> hackage has finally mostly caught up with 9.2
2022-01-26 18:27:19 +0100 <janus> Olkiluoto 3 is also supposed to be grid-connected at the end of this month :O bad omen o_O
2022-01-26 18:27:27 +0100 <geekosaur> stackage hasn't though
2022-01-26 18:27:40 +0100 <geekosaur> lts is still 8.10.7, nightly 9.0.2
2022-01-26 18:28:14 +0100 <janus> gonna be exciting to see when the first ghc9 lts will come, i don't really understand the decision process
2022-01-26 18:28:42 +0100fef(~thedawn@user/thedawn) (Ping timeout: 276 seconds)
2022-01-26 18:28:46 +0100 <c_wraith> It's almost certain there won't be a 9.x LTS until at least 9.2.2
2022-01-26 18:29:16 +0100 <janus> oh, why? nightly has 3k packages, seems all right
2022-01-26 18:30:09 +0100 <c_wraith> wanting to wait for features to stabilize more than in 9.0, and codegen to stabilize more than in 9.2.1
2022-01-26 18:31:04 +0100 <janus> seems super subjetive, i don't understand how this is even measured
2022-01-26 18:31:30 +0100 <janus> i must be blessed since i am not having problems on 9.0
2022-01-26 18:31:39 +0100 <geekosaur> is there even an objective measure relevant to stackage?
2022-01-26 18:32:32 +0100thomas_(~thomas@2a02:a03f:666e:c500:92eb:d341:15bc:3f3d) (Quit: Leaving)
2022-01-26 18:32:35 +0100 <EvanR> ah mueval seems to be totally sandboxed... is there no way to get at the value that the string represents for the host's purposes
2022-01-26 18:32:43 +0100 <geekosaur> also one relevant issue for 9.x is there is no hls support for either 9.0.2 or 9.2.1 yet, and they're having trouble with that support if I understood discussion in #ghc yesterday correctly
2022-01-26 18:32:49 +0100leibniz(~leibniz@cpc101088-sgyl37-2-0-cust22.18-2.cable.virginm.net)
2022-01-26 18:33:24 +0100 <geekosaur> EvanR, even ghc-api is boxed for that purpose
2022-01-26 18:33:51 +0100 <geekosaur> there are ways to force reloading but they're not easy. most of the easy mechanisms create a completely independent "session"
2022-01-26 18:33:54 +0100 <janus> when lts-18 was released, amazing m1 support and hls support was not a requirement. i don't think it is totally logical that it now would be
2022-01-26 18:34:22 +0100 <leibniz> how do i uninstall haskell
2022-01-26 18:34:23 +0100 <leibniz> ?
2022-01-26 18:34:44 +0100 <janus> aaargh is it you, fog?
2022-01-26 18:34:56 +0100 <geekosaur> if you installed it via your package manager, use your package manager. if you installed via ghcup, use ghcup
2022-01-26 18:35:04 +0100 <EvanR> ghc-api...
2022-01-26 18:35:27 +0100 <maerwald> leibniz: windows?
2022-01-26 18:35:47 +0100 <leibniz> maerwald: yup
2022-01-26 18:35:54 +0100 <maerwald> leibniz: I have a video for you lol
2022-01-26 18:36:08 +0100 <maerwald> https://www.youtube.com/watch?v=bB4fmQiUYPw&t=152s
2022-01-26 18:36:41 +0100 <leibniz> its titled "install" but i want "unistall" it has this also?
2022-01-26 18:36:45 +0100 <maerwald> yes
2022-01-26 18:36:53 +0100 <leibniz> ok thanks
2022-01-26 18:37:23 +0100 <leibniz> janus: is it important?
2022-01-26 18:37:27 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba) (Remote host closed the connection)
2022-01-26 18:37:56 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net)
2022-01-26 18:38:25 +0100 <janus> yes, because a lot of people have already lost confidence in fog, and they deserve to know that they are now spending their time with the same person (with a new name)
2022-01-26 18:39:13 +0100 <leibniz> ah, right, it *is* important
2022-01-26 18:39:29 +0100 <leibniz> so its a lifetime deplatforming?
2022-01-26 18:39:35 +0100 <leibniz> and an associated dox
2022-01-26 18:39:37 +0100 <leibniz> !?
2022-01-26 18:39:45 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2022-01-26 18:39:48 +0100 <leibniz> and this is community ethos!?
2022-01-26 18:40:53 +0100 <EvanR> so ghc API is how mueval, plugins library, all these hot code live code thingies work?
2022-01-26 18:41:08 +0100 <leibniz> are you trying to encourage a form of communication, whereby even if i *associate* with my past code, that other comunity members will start a "pile on" (actually now an *illigal* form of cyberbullying)
2022-01-26 18:41:23 +0100little_mac(~little_ma@2601:410:4300:3ce0:4001:9094:16f1:84ab)
2022-01-26 18:41:50 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2022-01-26 18:41:53 +0100 <c_wraith> janus: well, I've got a sample bit of code that works really nicely on ghc 9.2 but gives "sorry, we didn't implement that yet" errors on GHC 9.0.2 :P
2022-01-26 18:42:11 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2022-01-26 18:42:19 +0100 <leibniz> because if your trying to make that part of the haskell communities standard response to *people*, i would strongly discourage that
2022-01-26 18:43:04 +0100 <leibniz> there have been numerous instances of people accusing each other of being bots, etc.
2022-01-26 18:43:11 +0100 <leibniz> haskell has no place for this behaviour
2022-01-26 18:43:11 +0100vicfred(~vicfred@user/vicfred)
2022-01-26 18:43:19 +0100 <maerwald> leibniz: did you manage to uninstall?
2022-01-26 18:43:53 +0100 <leibniz> i was slightly perturbed, will try to watch the video again. apologies
2022-01-26 18:46:10 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 250 seconds)
2022-01-26 18:46:25 +0100 <leibniz> maerwald: its not clear that if the previous install was not via ghcup, that this install script would work. do you know if thats the case?
2022-01-26 18:46:57 +0100 <maerwald> leibniz: do you have the uninstall script?
2022-01-26 18:47:40 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-26 18:48:59 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2022-01-26 18:49:38 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Quit: WeeChat 3.3)
2022-01-26 18:50:25 +0100zebrag(~chris@user/zebrag) (Quit: Konversation terminated!)
2022-01-26 18:50:37 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2022-01-26 18:51:35 +0100SwarmCollective(~joseph@2603-6011-bc02-b600-2151-3d00-3640-3cd8.res6.spectrum.com) (Remote host closed the connection)
2022-01-26 18:51:58 +0100SwarmCollective(~joseph@2603-6011-bc02-b600-b30f-c0b6-681c-4c69.res6.spectrum.com)
2022-01-26 18:54:48 +0100 <EvanR> System.Eval.Haskell> xy <- eval @((),Char,Bool) "((), 'c', True)" []
2022-01-26 18:54:59 +0100 <EvanR> <command line>: cannot satisfy -package plugins
2022-01-26 18:55:01 +0100 <EvanR> so close xD
2022-01-26 18:55:10 +0100thevishy(~Nishant@2405:201:f005:c007:39ad:8b3b:de67:f2a2) (Quit: Leaving)
2022-01-26 18:56:29 +0100slowButPresent(~slowButPr@user/slowbutpresent)
2022-01-26 18:57:32 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2022-01-26 18:58:32 +0100zebrag(~chris@user/zebrag)
2022-01-26 18:58:39 +0100 <leibniz> maerwald: its busy installing some ancient version of ghc and complaining about not being on the path
2022-01-26 18:58:54 +0100CiaoSen(~Jura@p200300c95737a2002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2022-01-26 18:58:56 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-26 18:59:58 +0100Jing(~hedgehog@240e:390:7c53:a7e1:491:83dc:6241:13db) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2022-01-26 19:01:26 +0100 <[exa]> how much ancient btw?
2022-01-26 19:01:34 +0100 <leibniz> 8.10
2022-01-26 19:01:46 +0100 <leibniz> i had 9.2 before
2022-01-26 19:01:48 +0100 <[exa]> that's not that bad
2022-01-26 19:02:03 +0100 <EvanR> https://i.imgur.com/urwQYaR.png
2022-01-26 19:02:07 +0100 <leibniz> i think there is a breaking change though, i was using the new records dot syntax
2022-01-26 19:02:20 +0100 <EvanR> I'm on 8.10.7
2022-01-26 19:02:25 +0100chele(~chele@user/chele) (Remote host closed the connection)
2022-01-26 19:02:35 +0100 <EvanR> I don't hate it
2022-01-26 19:02:36 +0100 <leibniz> speaking of new features, has anyone had a chance to experiment with linear types much yet?
2022-01-26 19:02:37 +0100dyeplexer(~dyeplexer@user/dyeplexer) (Ping timeout: 240 seconds)
2022-01-26 19:03:46 +0100 <maerwald> leibniz: I don't understand. I thought you want to uninstall
2022-01-26 19:03:48 +0100 <leibniz> hmm, the uninstall script didnt unistall the old version
2022-01-26 19:03:49 +0100 <[exa]> hm the OverloadedRecordDot might be there since 9.2, yes
2022-01-26 19:03:50 +0100 <maerwald> now you're installing?
2022-01-26 19:04:16 +0100 <leibniz> thats how you get the uninstall script according to the video
2022-01-26 19:04:21 +0100 <maerwald> lol
2022-01-26 19:04:30 +0100 <leibniz> i ran the script, and it just removed the ghcup version
2022-01-26 19:04:32 +0100 <leibniz> not much good
2022-01-26 19:04:39 +0100 <maerwald> xD
2022-01-26 19:04:45 +0100 <[exa]> I'd delete it manually tbh
2022-01-26 19:04:53 +0100 <leibniz> seems that way
2022-01-26 19:05:10 +0100 <[exa]> on windows that's the safest way anyway
2022-01-26 19:05:12 +0100 <leibniz> im just not sure how it points to the appdata local repo or wherever it puts all the packages
2022-01-26 19:05:18 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2022-01-26 19:05:22 +0100 <EvanR> I see plugins is old enough that it doesn't understand how cabal works anymore
2022-01-26 19:05:32 +0100 <leibniz> like which cabal and which ghc it uses has always been a total mystery
2022-01-26 19:06:09 +0100 <leibniz> wasnt there some kind of sandbox thing?
2022-01-26 19:06:25 +0100 <leibniz> i dont want to have to resort to stack for everything
2022-01-26 19:06:43 +0100 <EvanR> I still don't have stack
2022-01-26 19:06:47 +0100 <EvanR> for anything
2022-01-26 19:06:57 +0100 <leibniz> but cabal keeps breaking
2022-01-26 19:07:00 +0100 <EvanR> ?
2022-01-26 19:07:05 +0100 <EvanR> not for me
2022-01-26 19:07:29 +0100 <leibniz> probably you dont accidently do terrible things like unregistering base
2022-01-26 19:07:38 +0100 <sclv> don't worry about uninstalling.
2022-01-26 19:07:44 +0100 <sclv> just install a new fresh clean version, full stop
2022-01-26 19:07:47 +0100ec(~ec@gateway/tor-sasl/ec)
2022-01-26 19:07:53 +0100 <sclv> and make sure your path points to it, done
2022-01-26 19:09:39 +0100wyrd(~wyrd@gateway/tor-sasl/wyrd) (Ping timeout: 276 seconds)
2022-01-26 19:09:43 +0100 <leibniz> ahh, ok, now i see some environemtal variables like CABAL_DIR and appdata\cabal\roaming\bin on path
2022-01-26 19:10:11 +0100 <leibniz> i guess i could just go to each of these locations and delete everything
2022-01-26 19:10:29 +0100 <EvanR> I don't need to unregister base since I only use things in cabal isolation
2022-01-26 19:10:30 +0100 <leibniz> i wouldnt want anything it could end up somehow splicing into a newer build
2022-01-26 19:10:57 +0100 <leibniz> EvanR even v2 commands nolonger work, everything is totally broken. idk how
2022-01-26 19:11:12 +0100 <c_wraith> probably because of a belief in uninstalling things
2022-01-26 19:11:28 +0100 <leibniz> this is what i was thinking. that i would have to reinstall windows
2022-01-26 19:11:32 +0100 <EvanR> actually, haskell was the only thing I really had working on windows before I got on this linux lifeboat a few months back
2022-01-26 19:11:44 +0100 <EvanR> uninstall windows xD
2022-01-26 19:12:02 +0100 <leibniz> EvanR: same. haskell forces me to reinstall windows so regularly that no other programs survive
2022-01-26 19:12:04 +0100coot(~coot@2a02:a310:e03f:8500:5cc8:47c:8ec0:b827) (Quit: coot)
2022-01-26 19:12:23 +0100 <leibniz> good language!
2022-01-26 19:12:38 +0100 <EvanR> why would haskell force you to reinstall windows, I dare ask
2022-01-26 19:12:49 +0100 <leibniz> c_wraith 18:11:13
2022-01-26 19:12:49 +0100 <leibniz> probably because of a belief in uninstalling things
2022-01-26 19:12:54 +0100 <leibniz> this kind of logic^
2022-01-26 19:13:01 +0100 <monochrom> For the record, other windows users don't feel forced to reinstall windows for haskell.
2022-01-26 19:13:13 +0100 <leibniz> i cant safely ensure i dodnt delete everything that could cause something to go wrong
2022-01-26 19:13:30 +0100 <leibniz> so its like, one wrong cabal command from total OS disruption
2022-01-26 19:13:36 +0100 <EvanR> um
2022-01-26 19:13:49 +0100 <leibniz> monochrom: probably they dont refuse to use v2 because they are unable to read
2022-01-26 19:14:16 +0100 <leibniz> if there was a "clean reinstall" thing... but i guess thats what stack is for
2022-01-26 19:14:25 +0100 <leibniz> but whenever i mention stack people are like "pah"
2022-01-26 19:15:12 +0100 <leibniz> basically, i think probably if i really carfully see anything haskell related on path, and delete it.. but by that time its easier just to reinstall windows
2022-01-26 19:17:03 +0100 <leibniz> i guess the problem is the ghc team do things like ghcup so they can ensure the install can be reversed. but the chocolatey toolchain is advised via the haskell platform - it should be uninstallable
2022-01-26 19:17:04 +0100MatrixTravelerbo(~voyagert2@2001:470:69fc:105::22) (K-Lined)
2022-01-26 19:17:17 +0100 <leibniz> like, its not as if it were obtained in a totally untoward way
2022-01-26 19:17:23 +0100 <maerwald> leibniz: chocolatey has a uninstall method
2022-01-26 19:17:27 +0100 <sclv> https://docs.chocolatey.org/en-us/choco/commands/uninstall
2022-01-26 19:17:28 +0100 <leibniz> aha!!
2022-01-26 19:17:30 +0100 <leibniz> nice
2022-01-26 19:17:39 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2022-01-26 19:18:20 +0100coot(~coot@89-64-85-93.dynamic.chello.pl)
2022-01-26 19:19:42 +0100 <maerwald> it's a little annoying, because there's a uninstall order to follow
2022-01-26 19:20:26 +0100 <leibniz> hmm, google nolonger sends me to the choco install section when i search for haskell platform
2022-01-26 19:20:31 +0100 <leibniz> now i find ghcup
2022-01-26 19:20:40 +0100 <sm> I don't say pah leibniz . stack has always been great at windows support
2022-01-26 19:20:54 +0100 <leibniz> +1
2022-01-26 19:21:25 +0100 <leibniz> well, if they are going to advise users go via ghcup from now on, then i shouldnt be using chocolatey anymore i guess
2022-01-26 19:21:46 +0100 <leibniz> so if i just reinstall windows and use ghcup from now on at least if i break anything i can reinstall everything easily
2022-01-26 19:21:47 +0100 <maerwald> not sure stack has a uninstaller though on windows?
2022-01-26 19:21:52 +0100 <leibniz> stupid v1 conflicts
2022-01-26 19:22:14 +0100 <leibniz> i cant find how to unsintall via chocolatey
2022-01-26 19:22:32 +0100 <leibniz> neither choco unisntall haskell, or choco unisntall haskell-platform work
2022-01-26 19:22:47 +0100 <maerwald> try 'choco uninstall cabal' first
2022-01-26 19:23:06 +0100 <leibniz> yeah that works
2022-01-26 19:23:15 +0100 <leibniz> and then ghc?
2022-01-26 19:23:19 +0100 <maerwald> yeah
2022-01-26 19:23:24 +0100 <maerwald> that's what I said with uninstall order
2022-01-26 19:23:31 +0100 <leibniz> actually, maybe i dont need to uninstall ghc
2022-01-26 19:23:50 +0100 <maerwald> well, good luck having multiple tools install ghc
2022-01-26 19:23:58 +0100 <leibniz> Unable to uninstall 'cabal 3.6.2.0' because 'ghc 9.2.1, haskell-dev 0.0.1' depend on it
2022-01-26 19:24:06 +0100gehmehgeh(~user@user/gehmehgeh) (Remote host closed the connection)
2022-01-26 19:24:08 +0100 <maerwald> yeah, uninstall ghc first
2022-01-26 19:24:10 +0100 <maerwald> :D
2022-01-26 19:24:38 +0100 <maerwald> chocolatey is really not great at usability
2022-01-26 19:24:46 +0100gehmehgeh(~user@user/gehmehgeh)
2022-01-26 19:24:58 +0100 <leibniz> haskell-dev first, then ghc, then cabal, seems to work
2022-01-26 19:25:08 +0100 <leibniz> (uninstall order)
2022-01-26 19:25:41 +0100 <EvanR> once I used ghcup on windows, everything worked much better. Now I'm using ghcup on ubuntu
2022-01-26 19:25:57 +0100 <EvanR> I also use it on osx
2022-01-26 19:26:01 +0100 <EvanR> full house
2022-01-26 19:26:04 +0100 <leibniz> so now that i have managed to unistall via chocolatey, should i reinstall there too?
2022-01-26 19:26:15 +0100 <leibniz> seems to get the more up to dat ghc version
2022-01-26 19:27:22 +0100 <leibniz> EvanR: ok fine, if thats the way to go ill just do that
2022-01-26 19:27:30 +0100 <leibniz> how to make it get the 9.2.2 though?
2022-01-26 19:27:42 +0100 <EvanR> the UI lets you select ghc version
2022-01-26 19:27:44 +0100 <maerwald> 9.2.2?
2022-01-26 19:28:02 +0100 <leibniz> erp, 9.2.1
2022-01-26 19:28:07 +0100 <maerwald> EvanR: there's no TUI in windows :(
2022-01-26 19:28:24 +0100 <EvanR> ah, however it lets you select
2022-01-26 19:28:29 +0100 <maerwald> leibniz: after installation, open a powershell user session and type 'ghcup install ghc latest'
2022-01-26 19:29:30 +0100Ram-Z(~Ram-Z@li1814-254.members.linode.com) (Quit: ZNC - http://znc.in)
2022-01-26 19:29:36 +0100 <leibniz> the installation get a ghc though, and it takes ages
2022-01-26 19:29:43 +0100 <leibniz> cant i get ghcup without?
2022-01-26 19:29:45 +0100ProfSimm(~ProfSimm@87.227.196.109)
2022-01-26 19:30:00 +0100 <maerwald> yeah
2022-01-26 19:30:01 +0100 <leibniz> https://www.haskell.org/ghcup/
2022-01-26 19:30:08 +0100 <maerwald> you can
2022-01-26 19:30:08 +0100 <leibniz> im pasting that into powershell
2022-01-26 19:30:49 +0100 <leibniz> hmm, but i ran the unistaller and it unistalled everything
2022-01-26 19:31:03 +0100 <leibniz> now i dont have ghcup andymore, and that command installed a ghc last time i ran it
2022-01-26 19:31:10 +0100 <leibniz> so how can i?
2022-01-26 19:31:10 +0100 <maerwald> wait a second
2022-01-26 19:31:30 +0100imalsogreg(~imalsogre@2601:147:300:f930::ee17)
2022-01-26 19:31:47 +0100Ram-Z(Ram-Z@2a01:7e01::f03c:91ff:fe57:d2df)
2022-01-26 19:32:03 +0100 <maerwald> Set-ExecutionPolicy Bypass -Scope Process -Force;[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;Invoke-Command -ScriptBlock ([ScriptBlock]::Create((Invoke-WebRequest https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1 -UseBasicParsing))) -ArgumentList $true, $true
2022-01-26 19:32:05 +0100Akiva(~Akiva@user/Akiva) (Ping timeout: 250 seconds)
2022-01-26 19:32:18 +0100 <maerwald> note the additional ", $true" at the end
2022-01-26 19:32:24 +0100gehmehgeh(~user@user/gehmehgeh) (Ping timeout: 276 seconds)
2022-01-26 19:32:40 +0100coot(~coot@89-64-85-93.dynamic.chello.pl) (Quit: coot)
2022-01-26 19:32:56 +0100 <leibniz> what does that do?
2022-01-26 19:33:14 +0100 <maerwald> that will make it just install ghcup and nothing else
2022-01-26 19:33:20 +0100 <maerwald> so you decide after installation what to install
2022-01-26 19:33:30 +0100 <maerwald> see https://www.haskell.org/ghcup/guide/#basic-usage
2022-01-26 19:33:50 +0100 <leibniz> this is some dark art
2022-01-26 19:33:56 +0100 <leibniz> this extra true flag
2022-01-26 19:34:03 +0100 <leibniz> totally obscure
2022-01-26 19:34:05 +0100 <maerwald> windows powershell makes it extra hard
2022-01-26 19:34:16 +0100gehmehgeh(~user@user/gehmehgeh)
2022-01-26 19:34:18 +0100 <maerwald> there's no other sane way to do this in a single command
2022-01-26 19:34:27 +0100grabb0id[m](~alangmatr@2001:470:69fc:105::b489) (Quit: Client limit exceeded: 20000)
2022-01-26 19:34:32 +0100 <leibniz> choco install ghcup would be good!
2022-01-26 19:34:47 +0100grabb0id[m](~alangmatr@2001:470:69fc:105::b489)
2022-01-26 19:34:54 +0100Tuplanolla(~Tuplanoll@91-159-68-166.elisa-laajakaista.fi)
2022-01-26 19:34:58 +0100 <geekosaur> seems a bit weird to me, using an installer to install an installer
2022-01-26 19:35:44 +0100 <leibniz> ah yeah i guess, to get chocolatey its;
2022-01-26 19:35:46 +0100 <leibniz> Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
2022-01-26 19:35:50 +0100 <EvanR> if you start with neither, if you could conceptually run them on each other to form a yinyang of hypothetical GHCs
2022-01-26 19:35:54 +0100 <leibniz> same gibberish
2022-01-26 19:35:59 +0100 <maerwald> yeah
2022-01-26 19:36:17 +0100 <leibniz> to get python i type pythin in the microsoft store
2022-01-26 19:36:23 +0100 <leibniz> python*
2022-01-26 19:36:35 +0100 <leibniz> its gets pip and everything which you used to have to do seperately in windows
2022-01-26 19:36:44 +0100 <leibniz> they seem to have used the store to their advantage
2022-01-26 19:37:00 +0100 <maerwald> well, how do you get stuff into the windows store?
2022-01-26 19:37:02 +0100 <EvanR> you didn't want to get ghcup and ghc at the same time, you wanted to do it separately
2022-01-26 19:37:28 +0100 <leibniz> maerwald: idk, cross compile it to android, put it on the play store and then migrate it!?!?
2022-01-26 19:37:39 +0100 <leibniz> might be an easier way...
2022-01-26 19:37:44 +0100 <geekosaur> I'm glad I'm not the only one who makes that typo ("pythin")
2022-01-26 19:37:51 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba)
2022-01-26 19:38:13 +0100 <maerwald> android?
2022-01-26 19:38:15 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2022-01-26 19:38:22 +0100 <maerwald> ok, I'll pass
2022-01-26 19:38:34 +0100 <leibniz> EvanR: i guess whatever .msi installer the store runs behind the scenes could basically just get ghcup and then use it to get ghc and cabal and stack
2022-01-26 19:38:42 +0100jgeerds(~jgeerds@55d4a547.access.ecotel.net)
2022-01-26 19:38:50 +0100 <EvanR> pythin, son of python, son of pythong, son of cnut
2022-01-26 19:38:52 +0100 <leibniz> maerwald: i mean, it would be cool to know how to do that
2022-01-26 19:38:53 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net) (Ping timeout: 256 seconds)
2022-01-26 19:39:19 +0100 <leibniz> for the monitization
2022-01-26 19:39:41 +0100 <leibniz> probably if i had been able to publish to the play store i would have long ago escaped this compiler hell
2022-01-26 19:39:44 +0100 <polyphem> maybe reinstall of windows store helps ...
2022-01-26 19:39:49 +0100 <leibniz> lol
2022-01-26 19:40:19 +0100 <EvanR> I don't lose sleep over ghc not having a .msi install experience
2022-01-26 19:40:29 +0100neceve(~quassel@2.26.93.228)
2022-01-26 19:40:48 +0100Ocelot(~ocelot@50-78-208-189-static.hfc.comcastbusiness.net)
2022-01-26 19:40:50 +0100 <maerwald> to publish on windows store you first need to obtain a developer certificate and pay for it
2022-01-26 19:40:50 +0100 <leibniz> it used to though, the regression seems ominous, as if they are actually *losing* personel
2022-01-26 19:41:17 +0100 <leibniz> maerwald: probably they have a python foundation or something
2022-01-26 19:41:25 +0100 <maerwald> and then you pay for a developer account at MS store too
2022-01-26 19:41:28 +0100 <EvanR> I guess I'm lucky not having most of my time occupied with installing and uninstalling things
2022-01-26 19:41:46 +0100 <leibniz> wierd how MS research cant even afford a MS publishers account...
2022-01-26 19:41:55 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba) (Remote host closed the connection)
2022-01-26 19:42:01 +0100 <leibniz> youd think they would fund themselves or something
2022-01-26 19:42:04 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba)
2022-01-26 19:42:42 +0100 <leibniz> EvanR: yes, that
2022-01-26 19:43:23 +0100 <leibniz> i can remember spending hours with msys, mingw and cygwin, trying to build unix things before they finally made wsl
2022-01-26 19:43:34 +0100 <EvanR> on the uninstall front, I've had success just deleting a directory and if I had added env vars at some point, undoing that
2022-01-26 19:43:54 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 268 seconds)
2022-01-26 19:44:18 +0100 <maerwald> given that HF is so excited about windows... maybe they should start creating a dev accounts on MS store and obtain signing certificates
2022-01-26 19:44:31 +0100nvmd(~nvmd@user/nvmd)
2022-01-26 19:44:50 +0100 <maerwald> and talk to python foundation on how they managed to do that
2022-01-26 19:44:54 +0100 <EvanR> in before visual studio includes haskell as one of the new project options? xD
2022-01-26 19:45:23 +0100 <EvanR> haskellution
2022-01-26 19:45:24 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-26 19:45:26 +0100 <polyphem> leibnitz: you said your windows is "clean" apart from ghc , and you have lots of experience with unix-tools , why dont install linux and use ghcup in there, would make abetter dev experience ?
2022-01-26 19:45:33 +0100_xor(~xor@dsl-50-5-233-169.fuse.net) (Read error: Connection reset by peer)
2022-01-26 19:45:58 +0100 <leibniz> i have an install on wsl too
2022-01-26 19:46:04 +0100 <leibniz> there is slight latency
2022-01-26 19:46:10 +0100 <leibniz> i prefer to use the native version
2022-01-26 19:46:16 +0100 <leibniz> also it has issues with the path
2022-01-26 19:46:26 +0100 <leibniz> backslashes in particular
2022-01-26 19:46:53 +0100 <polyphem> switch to a real linux ... i mean
2022-01-26 19:47:02 +0100 <leibniz> i had a script that pplaced things onto the /mnt/c/usr/home directory, so it could use a nix install which required wsl
2022-01-26 19:47:12 +0100 <leibniz> but it would be way better if nix just worked on windows
2022-01-26 19:47:26 +0100 <leibniz> polyphem: i think your missing the point
2022-01-26 19:47:44 +0100 <leibniz> it needs to work for users, so they dont have to abandon their chosen OS!
2022-01-26 19:47:46 +0100_xor(~xor@dsl-50-5-233-169.fuse.net)
2022-01-26 19:47:46 +0100 <polyphem> leibniz: i think you are missing the point
2022-01-26 19:47:56 +0100_xor(~xor@dsl-50-5-233-169.fuse.net) (Read error: Connection reset by peer)
2022-01-26 19:48:07 +0100 <leibniz> sure
2022-01-26 19:48:33 +0100 <polyphem> seems like your chosen Os gives you headache ...
2022-01-26 19:48:38 +0100matijja(~matijja@193.77.181.201) (Quit: ZNC 1.8.1 - https://znc.in)
2022-01-26 19:49:18 +0100 <leibniz> listen, at the point where the community of a language starts accusing the worlds most common opperating system of being the problem in their toolchain, i think that is the point where that language begins to seem stupid to the rest of the world. this is not ok.
2022-01-26 19:49:30 +0100 <yushyin> polyphem: but don't force linux on anyone ...
2022-01-26 19:49:38 +0100ubert1(~Thunderbi@p200300ecdf09940ed781da24ea780c96.dip0.t-ipconnect.de) (Remote host closed the connection)
2022-01-26 19:49:49 +0100 <leibniz> haskell on windows has never been bad
2022-01-26 19:49:58 +0100 <sm> leibniz, you're right. It does seem like a thing the HF could and probably will invest in
2022-01-26 19:50:01 +0100 <leibniz> unix libs on windows are another issue entierly!
2022-01-26 19:50:13 +0100 <geekosaur> polyphem, to be fair ghc's windows story is kinda atrocious. mingw is a hack to try to pretend windows is a unixlike
2022-01-26 19:50:28 +0100matijja(~matijja@193.77.181.201)
2022-01-26 19:50:35 +0100 <leibniz> but now i can just use wsl for things like cblas, so its fine
2022-01-26 19:50:42 +0100 <leibniz> windows, again, to the rescue
2022-01-26 19:50:59 +0100Major_Biscuit(~MajorBisc@86-88-79-148.fixed.kpn.net) (Ping timeout: 256 seconds)
2022-01-26 19:51:01 +0100 <geekosaur> (iirc the haskell foundation wants to hire someone to improve things there)
2022-01-26 19:51:02 +0100 <leibniz> "oh just use bare metal linux" - really though, why?
2022-01-26 19:51:23 +0100quintasan(~quassel@quintasan.pl) (Quit: quintasan)
2022-01-26 19:51:36 +0100 <leibniz> wsl is fine, only sligt latency, and just for things like nix pushes to amazon servers, where the slight latency is no issue
2022-01-26 19:51:40 +0100 <yushyin> wsl(2) is a misnomer, it's not a subsystem anymore
2022-01-26 19:51:43 +0100 <geekosaur> I use bare metal linux because I've been using unixes since 1981. it's still a lousy experience for most people though
2022-01-26 19:51:53 +0100 <polyphem> i heard that leibniz's interest involve haskell and unix-tools and i think he had less headache if he would use a real linux , especially since he stated that his current windos is "clean2 ...
2022-01-26 19:52:02 +0100 <leibniz> maybe for blas opperations its not so great though, i dont want to have to train nets through an OS latency
2022-01-26 19:52:14 +0100 <leibniz> hmm, maybe a bare metal linux wouldnt actually be a bad idea
2022-01-26 19:53:07 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-26 19:53:07 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-26 19:53:07 +0100wroathe(~wroathe@user/wroathe)
2022-01-26 19:53:42 +0100 <leibniz> polyphem: well, since the choco tools are actually capable of an unistall, and now i have ghcup, maybe i wont need to keep reinstalling windows, and can actually have other apps!
2022-01-26 19:53:56 +0100 <geekosaur> I man, I ran Mac for years so I could get the power of unix with a UX that didn't make me want to kill myself
2022-01-26 19:54:12 +0100 <geekosaur> *I mean
2022-01-26 19:54:13 +0100_xor(~xor@dsl-50-5-233-169.fuse.net)
2022-01-26 19:54:46 +0100 <sm> I really don't think you ever need to be reinstalling windows for haskell. Just learn a little more about where things are
2022-01-26 19:55:02 +0100Guest52(~Guest52@80-100-97-100.ip.xs4all.nl) (Ping timeout: 240 seconds)
2022-01-26 19:55:05 +0100 <leibniz> its wierd, the girl upstairs started laughing just as you mentioned suicidal ideations resulting from being an essential dev in fundamentally important technology
2022-01-26 19:55:20 +0100 <leibniz> now she is banging at the floor angrily, id better go
2022-01-26 19:55:51 +0100 <Ocelot> Godspeed.
2022-01-26 19:56:57 +0100leibniz(~leibniz@cpc101088-sgyl37-2-0-cust22.18-2.cable.virginm.net) (Quit: Connection closed)
2022-01-26 19:57:49 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2022-01-26 19:57:58 +0100 <EvanR> alright, so ghc API is a rabbit hole but potentially powerful
2022-01-26 19:58:18 +0100 <EvanR> I guess that's potentially redundant
2022-01-26 19:59:22 +0100nunggu(~q@user/nunggu) (Remote host closed the connection)
2022-01-26 19:59:29 +0100machinedgod(~machinedg@24.105.81.50) (Ping timeout: 256 seconds)
2022-01-26 19:59:52 +0100nunggu(~q@user/nunggu)
2022-01-26 19:59:55 +0100 <monochrom> No, there are many powerless rabbit holes :)
2022-01-26 20:00:13 +0100 <monochrom> And many powerful non-holes.
2022-01-26 20:00:46 +0100 <monochrom> A powerful drill is a powerful co-hole, for example >:)
2022-01-26 20:01:45 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 256 seconds)
2022-01-26 20:01:55 +0100lispy(~lispy4@84.69.59.93)
2022-01-26 20:01:58 +0100_xor(~xor@dsl-50-5-233-169.fuse.net) (Read error: Connection reset by peer)
2022-01-26 20:02:27 +0100 <EvanR> >There is a similar problem for plugins. If a module uses a plugin then depending on the ABI of a plugin is usually not enough. Modules defining plugins expose one identifier plugin :: Plugin and so the ABI does not often change.
2022-01-26 20:02:59 +0100 <maerwald[m]> nix on windows? Like... the worst of both worlds?
2022-01-26 20:03:01 +0100 <EvanR> is this talking about dynamically loaded modules, or compiler plugins
2022-01-26 20:03:16 +0100 <geekosaur> that sounds like compiler plugin abi
2022-01-26 20:03:36 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-26 20:03:44 +0100 <EvanR> oof
2022-01-26 20:03:47 +0100quintasan(~quassel@quintasan.pl)
2022-01-26 20:03:48 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba) (Remote host closed the connection)
2022-01-26 20:04:03 +0100mixfix41(~homefame@user/mixfix41)
2022-01-26 20:04:22 +0100 <EvanR> come on haskell pretend to be a dynamic language
2022-01-26 20:04:43 +0100 <monochrom> @quote monochrom hugs
2022-01-26 20:04:43 +0100 <lambdabot> No quotes match. My mind is going. I can feel it.
2022-01-26 20:04:48 +0100 <monochrom> ugh
2022-01-26 20:04:49 +0100 <geekosaur> if you want module plugins you probably want https://hackage.haskell.org/package/plugins
2022-01-26 20:05:01 +0100 <EvanR> I've been messing with that for the last few hours
2022-01-26 20:05:02 +0100coot(~coot@89-64-85-93.dynamic.chello.pl)
2022-01-26 20:05:07 +0100 <geekosaur> oh
2022-01-26 20:05:12 +0100 <lispy> html is the world's most popular dynamic programming language, consider learning it
2022-01-26 20:05:12 +0100nvmd(~nvmd@user/nvmd) (Quit: Later, nerds.)
2022-01-26 20:05:36 +0100 <EvanR> currently fails to mediate with ghc behind the scenes with a command line error like "unable to satisfy -package plugins"
2022-01-26 20:06:00 +0100 <EvanR> on github, the maintainer says "I don't know how this library works, I just accept pull requests and update hackage"
2022-01-26 20:06:06 +0100 <geekosaur> mm, are you using stack or cabal v2? I think that package expects to be globally installed
2022-01-26 20:06:12 +0100 <monochrom> @quote monochrom runghc
2022-01-26 20:06:12 +0100 <lambdabot> monochrom says: just add #! /usr/bin/runghc to your haskell file. then type errors occur at runtime only.
2022-01-26 20:06:14 +0100 <EvanR> really
2022-01-26 20:06:17 +0100 <monochrom> That. :)
2022-01-26 20:06:42 +0100 <EvanR> globally installed... alright
2022-01-26 20:06:44 +0100ec(~ec@gateway/tor-sasl/ec)
2022-01-26 20:06:50 +0100EvanRtightens belt
2022-01-26 20:06:58 +0100 <geekosaur> cabal install --lib
2022-01-26 20:07:06 +0100 <monochrom> Yeah plugin was in the era of v1. v2 didn't exist.
2022-01-26 20:07:16 +0100 <monochrom> plugins
2022-01-26 20:07:33 +0100_xor(~xor@dsl-50-5-233-169.fuse.net)
2022-01-26 20:07:57 +0100max22-(~maxime@2a01cb0883359800c869e03b4284e26a.ipv6.abo.wanadoo.fr) (Ping timeout: 268 seconds)
2022-01-26 20:09:10 +0100_xor(~xor@dsl-50-5-233-169.fuse.net) (Read error: Connection reset by peer)
2022-01-26 20:09:35 +0100_xor(~xor@dsl-50-5-233-169.fuse.net)
2022-01-26 20:09:54 +0100 <monochrom> Ironically v2 solves "depending on the ABI of a plugin is usually not enough". v2 says you depend on complete build context.
2022-01-26 20:09:57 +0100ralu(~ralu@static.211.245.203.116.clients.your-server.de) (Ping timeout: 240 seconds)
2022-01-26 20:10:52 +0100abrar_(~abrar@static-108-2-152-54.phlapa.fios.verizon.net) (Quit: WeeChat 3.1)
2022-01-26 20:10:55 +0100 <EvanR> so... remove plugins from the project build-depends
2022-01-26 20:10:57 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2022-01-26 20:11:04 +0100 <monochrom> Then again v2 redefines "ABI" to mean complete build context :)
2022-01-26 20:11:08 +0100 <EvanR> install --lib plugins globally
2022-01-26 20:11:12 +0100abrar(~abrar@static-108-2-152-54.phlapa.fios.verizon.net)
2022-01-26 20:12:02 +0100 <EvanR> now the program depends on a combination of sandboxed packages and global packages
2022-01-26 20:12:04 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net)
2022-01-26 20:12:31 +0100deadmarshal_(~deadmarsh@95.38.116.86) (Ping timeout: 256 seconds)
2022-01-26 20:12:32 +0100 <geekosaur> yes. I don't think there's a good fix or workaround for that
2022-01-26 20:12:34 +0100 <EvanR> also, leaving the dir and doing cabal install --lib plugins doesn't seem to do anything
2022-01-26 20:12:49 +0100 <EvanR> I guess it's already installed
2022-01-26 20:13:41 +0100 <EvanR> did I already say this, if plugins is unmaintained, how does it even still work with newer ghc
2022-01-26 20:14:08 +0100 <EvanR> confirm... it worked
2022-01-26 20:14:15 +0100nunggu(~q@user/nunggu) (Remote host closed the connection)
2022-01-26 20:14:17 +0100coot(~coot@89-64-85-93.dynamic.chello.pl) (Quit: coot)
2022-01-26 20:14:34 +0100 <geekosaur> someone submitted a pull request for it
2022-01-26 20:14:37 +0100 <monochrom> In this case, since there is no need to rebuild, "cabal install --lib" does not have to waste time, it just has to update your environment file. (You can see it is changed.)
2022-01-26 20:15:19 +0100 <monochrom> I guess the GHC API has not changed that much.
2022-01-26 20:16:16 +0100 <geekosaur> I would not be surprised to find it doesn't work with 9.0.2 or 9.2.1, but 8.10.7 is proibably fine. (ghc-api has been changing a lot especially in 9.2.1, actually)
2022-01-26 20:16:25 +0100 <monochrom> Or rather, plugins just needs to ask GHC API to load things. That part doesn't change a lot.
2022-01-26 20:16:26 +0100 <EvanR> well that eval succeeds is serendipitous
2022-01-26 20:17:01 +0100ircbrowse_tom(~ircbrowse@2a01:4f8:1c1c:9319::1)
2022-01-26 20:17:02 +0100Server+Cnt
2022-01-26 20:18:17 +0100tomsmeding(~tomsmedin@tomsmeding.com) (Quit: ZNC 1.8.2 - https://znc.in)
2022-01-26 20:19:15 +0100waleee(~waleee@2001:9b0:21d:fc00:398f:b003:b90d:acf4)
2022-01-26 20:19:42 +0100 <EvanR> the eval action takes about 2 seconds of latency
2022-01-26 20:19:58 +0100 <EvanR> to turn "True" into Just True xD
2022-01-26 20:20:12 +0100 <EvanR> > True
2022-01-26 20:20:14 +0100 <lambdabot> True
2022-01-26 20:20:18 +0100 <EvanR> lambdabot is faster
2022-01-26 20:20:55 +0100Akiva(~Akiva@user/Akiva)
2022-01-26 20:21:16 +0100ralu(~ralu@static.211.245.203.116.clients.your-server.de)
2022-01-26 20:21:18 +0100 <monochrom> Does it still take 2 seconds the 2nd time?
2022-01-26 20:21:45 +0100 <monochrom> I think that there is a lot of dynamic lazy loading that was forced the 1st time.
2022-01-26 20:23:41 +0100 <EvanR> 2 seconds for the first eval, then 0.2 seconds for each subsequent eval
2022-01-26 20:23:42 +0100gehmehgeh(~user@user/gehmehgeh) (Remote host closed the connection)
2022-01-26 20:23:52 +0100 <EvanR> pretty good
2022-01-26 20:24:13 +0100gehmehgeh(~user@user/gehmehgeh)
2022-01-26 20:24:42 +0100 <EvanR> 0.2 might be too slow turn around for linux torvalds though
2022-01-26 20:24:49 +0100 <EvanR> linus*
2022-01-26 20:25:25 +0100 <EvanR> eval takes a list of module names, but it says on stderr it can't find any
2022-01-26 20:25:43 +0100 <geekosaur> you're probably still building a new runtime environment for each expression. if you rearrange things to keep one around instead of naïvelyy calling eval each time, does it get any faster?
2022-01-26 20:25:46 +0100 <EvanR> I guess I need to use the more elaborate call that allows flags to be specified
2022-01-26 20:26:17 +0100 <EvanR> good point
2022-01-26 20:26:20 +0100Major_Biscuit(~MajorBisc@2a02:a461:129d:1:193d:75d8:745d:e91e)
2022-01-26 20:26:22 +0100_xor(~xor@dsl-50-5-233-169.fuse.net) (Read error: Connection reset by peer)
2022-01-26 20:26:28 +0100 <geekosaur> might have to dig into the source of eval to see how to do that though
2022-01-26 20:26:33 +0100lbseale(~ep1ctetus@user/ep1ctetus) (Read error: Connection reset by peer)
2022-01-26 20:26:48 +0100_xor(~xor@dsl-50-5-233-169.fuse.net)
2022-01-26 20:26:58 +0100_xor(~xor@dsl-50-5-233-169.fuse.net) (Read error: Connection reset by peer)
2022-01-26 20:27:17 +0100_xor(~xor@dsl-50-5-233-169.fuse.net)
2022-01-26 20:27:38 +0100 <geekosaur> or better yet the source to ghci, which is almost standalone by design
2022-01-26 20:27:43 +0100 <EvanR> it calls out to ghc
2022-01-26 20:27:59 +0100 <EvanR> using a command line
2022-01-26 20:28:06 +0100 <geekosaur> ghc -e? that'd do it
2022-01-26 20:28:19 +0100 <geekosaur> go poke at ghci sources to see how to do it properly
2022-01-26 20:28:44 +0100 <EvanR> to be clear, we're talking about not using plugins right xD
2022-01-26 20:29:10 +0100 <geekosaur> yes
2022-01-26 20:29:26 +0100 <geekosaur> with the price that this uses a separate runtime environment from your main program
2022-01-26 20:29:35 +0100 <geekosaur> so you can't readily share data
2022-01-26 20:30:36 +0100Major_Biscuit(~MajorBisc@2a02:a461:129d:1:193d:75d8:745d:e91e) (Ping timeout: 250 seconds)
2022-01-26 20:31:04 +0100tomsmeding(~tomsmedin@tomsmeding.com)
2022-01-26 20:31:11 +0100 <EvanR> I want to change the definition of a value or a function, then yield the updated value or function to the main program
2022-01-26 20:31:17 +0100 <EvanR> which somehow eval is doing
2022-01-26 20:31:28 +0100 <EvanR> using Typeable to check if it's remotely valid
2022-01-26 20:31:38 +0100 <monochrom> I think data is sharable.
2022-01-26 20:32:23 +0100 <monochrom> The real price is that the separate runtime environment comes from the very same compiler you used to compile your main program.
2022-01-26 20:32:39 +0100Major_Biscuit(~MajorBisc@2a02:a461:129d:1:193d:75d8:745d:e91e)
2022-01-26 20:32:41 +0100 <monochrom> "same" is down to which directory you installed GHC in.
2022-01-26 20:33:31 +0100 <EvanR> meaning don't expect to ship this exe easily? xD
2022-01-26 20:33:36 +0100 <monochrom> If you ship your exe to another computer, you have to also ship your GHC installation verbatim, yes.
2022-01-26 20:33:40 +0100jgeerds(~jgeerds@55d4a547.access.ecotel.net) (Quit: Leaving)
2022-01-26 20:33:48 +0100 <monochrom> Either that, or reproduce the same installation effect.
2022-01-26 20:34:00 +0100 <geekosaur> yes
2022-01-26 20:34:01 +0100 <EvanR> I guess that's why people write new programming languages
2022-01-26 20:34:05 +0100 <EvanR> within haskell
2022-01-26 20:34:08 +0100lbseale(~ep1ctetus@user/ep1ctetus)
2022-01-26 20:34:41 +0100 <EvanR> looking at this now https://github.com/ghc/ghc/tree/master/ghc/GHCi
2022-01-26 20:34:42 +0100 <monochrom> This is why back in the days of whatever was before HLS, it was so fragile.
2022-01-26 20:34:47 +0100 <geekosaur> in particular it needs the settings file and the package database from your ghc installation, plus anything pointed to by the settings file
2022-01-26 20:35:10 +0100 <monochrom> Also it was cabal-v1, to add more hell.
2022-01-26 20:35:25 +0100 <EvanR> is hugs or something like that an option?
2022-01-26 20:35:31 +0100 <EvanR> as a library
2022-01-26 20:36:43 +0100 <polyphem> isn't android the worlds most common operating system ?
2022-01-26 20:37:07 +0100 <monochrom> Hugs is much smaller. You wouldn't feel guilty shipping it. But I don't know that Hugs has a library API.
2022-01-26 20:37:23 +0100Major_Biscuit(~MajorBisc@2a02:a461:129d:1:193d:75d8:745d:e91e) (Ping timeout: 252 seconds)
2022-01-26 20:37:54 +0100 <EvanR> and hugs may not have some advance stuff
2022-01-26 20:38:05 +0100 <monochrom> Linux kernel version 2.4 is the world's most common OS because home routers. :)
2022-01-26 20:38:31 +0100 <EvanR> whatever OS runs on all the microcontrollers in your car
2022-01-26 20:38:36 +0100 <geekosaur> EvanR, but has its own (Trex is iirc better than anything ghc has come up with in terms of a record system)
2022-01-26 20:38:42 +0100 <monochrom> Hugs has TREX. More advanced than GHC. Today.
2022-01-26 20:38:55 +0100 <polyphem> hmm, i guess a household has a router and maybe some cell phones ...
2022-01-26 20:39:00 +0100 <EvanR> orly
2022-01-26 20:39:02 +0100 <monochrom> TREX also solve all your record problems :)
2022-01-26 20:39:26 +0100 <monochrom> OK I was kidding, phones are more abundant than home routers.
2022-01-26 20:39:48 +0100 <monochrom> Or rather, I don't have data either way.
2022-01-26 20:40:15 +0100 <polyphem> yes , but android is technically linux based
2022-01-26 20:40:20 +0100 <geekosaur> I, uh, spent some time in a homeless shelter. No home routers, but *everyone* had a smartphone
2022-01-26 20:40:44 +0100 <geekosaur> not to mention that it seems like every kid these days has their own smartphone
2022-01-26 20:41:02 +0100 <geekosaur> I would absolutely not be surprised if phone OSes vastly outnumber desktops and laptops
2022-01-26 20:41:39 +0100 <monochrom> But I already blamed everything on Windows long before I heard of Haskell.
2022-01-26 20:41:52 +0100 <monochrom> As a C and C++ user I blamed Windows too.
2022-01-26 20:42:17 +0100 <monochrom> And did not suddenly make C or C++ unappealing to newcomers.
2022-01-26 20:42:23 +0100 <EvanR> now that I'm using Haskell i can blame C and C++
2022-01-26 20:42:38 +0100 <EvanR> one day I'll be on language blub 9000, and blame Haskell
2022-01-26 20:43:06 +0100vysn(~vysn@user/vysn) (Ping timeout: 268 seconds)
2022-01-26 20:43:11 +0100 <monochrom> I bet every programming language community thinks of Windows lowly.
2022-01-26 20:43:25 +0100 <EvanR> dot net?
2022-01-26 20:43:42 +0100 <monochrom> If anything, it's OCaml, not Haskell, that really gives the finger to Windows.
2022-01-26 20:44:03 +0100 <polyphem> when i was 14 , on win95 i heard about this strange os that had 9 virtual terminals, i went to the local bookstore and bought a book on linex, and was flashed, when i realized thet it had a cdrom with redhat linux for free ... :)
2022-01-26 20:44:41 +0100 <EvanR> you saw a book on linux, and was flashed. By men in black from microsoft
2022-01-26 20:44:45 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:7175:fef6:491:2dba)
2022-01-26 20:45:14 +0100 <EvanR> open source is a cancer!
2022-01-26 20:45:24 +0100 <EvanR> get the facts
2022-01-26 20:46:00 +0100fendor_(~fendor@77.119.174.56.wireless.dyn.drei.com) (Remote host closed the connection)
2022-01-26 20:46:00 +0100 <monochrom> The world is like a CDROM. It's flat.
2022-01-26 20:46:34 +0100 <polyphem> ... i imideatly formated my 1024 MB drive win95 install and installed redhat
2022-01-26 20:47:00 +0100 <geekosaur> oh, I also have to wonder how linux installs compare to windows installs due to WSL(2). obviously can't be greater, but approaching parity would be interesting
2022-01-26 20:47:28 +0100 <EvanR> you can't have multiple linux installs?
2022-01-26 20:47:39 +0100 <geekosaur> also I am a bit surprised ot hear that there is some latency in WSL2, it should be very close to bare metal because of how they designed it
2022-01-26 20:47:58 +0100 <geekosaur> sure you can, and swithc between them and windows via grub
2022-01-26 20:48:18 +0100 <EvanR> I mean within the WSL framework
2022-01-26 20:48:31 +0100 <geekosaur> afaik no
2022-01-26 20:48:50 +0100 <EvanR> so it's a linux shaped hole that is empty or filled
2022-01-26 20:48:52 +0100 <geekosaur> might not take much work to enable it but it'd have to be done by Microsoft
2022-01-26 20:48:55 +0100 <EvanR> MVar Linux
2022-01-26 20:49:01 +0100lbseale(~ep1ctetus@user/ep1ctetus) (Read error: Connection reset by peer)
2022-01-26 20:49:10 +0100 <geekosaur> that's not exactly right either
2022-01-26 20:49:31 +0100 <polyphem> windows used to overwrite your linux install if you wanted to do multiboot in those days , you had to first install windows and then linux
2022-01-26 20:49:42 +0100 <geekosaur> remember windows is a microkernel architecture since winnt. WSL2 is just linux as a microkernel client
2022-01-26 20:50:16 +0100 <geekosaur> wsl1 was more of an emulation, I think
2022-01-26 20:50:18 +0100max22-(~maxime@2a01cb0883359800ca42cd4ecfb21dbb.ipv6.abo.wanadoo.fr)
2022-01-26 20:50:44 +0100dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be) (Quit: WeeChat 3.4)
2022-01-26 20:50:58 +0100_xor(~xor@dsl-50-5-233-169.fuse.net) (Read error: Connection reset by peer)
2022-01-26 20:51:18 +0100 <EvanR> embrace extend extinguish, microsoft is at it again!
2022-01-26 20:51:21 +0100_xor(~xor@dsl-50-5-233-169.fuse.net)
2022-01-26 20:51:45 +0100 <geekosaur> well, actually, no, it seems like they actually mean it
2022-01-26 20:52:00 +0100gehmehgeh(~user@user/gehmehgeh) (Remote host closed the connection)
2022-01-26 20:52:09 +0100 <geekosaur> they were getting their asses eaten in the cloud because windows is such a lousy cloud OS
2022-01-26 20:52:15 +0100gehmehgeh(~user@user/gehmehgeh)
2022-01-26 20:52:34 +0100 <geekosaur> it *really* wants a physical console
2022-01-26 20:52:58 +0100 <geekosaur> and things like remote desktop and even powershell just weren't enough
2022-01-26 20:53:06 +0100 <polyphem> ms had xenix, right
2022-01-26 20:53:10 +0100 <geekosaur> yes
2022-01-26 20:53:15 +0100 <geekosaur> then they sold it off to SCO
2022-01-26 20:53:24 +0100lbseale(~ep1ctetus@user/ep1ctetus)
2022-01-26 20:53:32 +0100 <geekosaur> then SCO sold itself out and became a shell for lawyers
2022-01-26 20:54:13 +0100 <EvanR> I worked at a place with SCO unix
2022-01-26 20:54:18 +0100 <geekosaur> but it was amusing, I once had the developer manual or ms-dos 2.11 and it talked about a future migration path that had dos and xenix merging sometime around dos 6.0
2022-01-26 20:54:25 +0100 <EvanR> not as ergonomic as linux
2022-01-26 20:54:27 +0100 <kuribas> My uncle was CEO of SCO benelux.
2022-01-26 20:54:33 +0100 <geekosaur> *for ms-dos
2022-01-26 20:54:34 +0100 <maerwald> well, windows at least has proper hardware support for laptops. Linux is a nightmare (suspend to ram, cpu throttling... all trash)
2022-01-26 20:54:44 +0100 <kuribas> before they went rogue.
2022-01-26 20:54:45 +0100 <maerwald> but I still can't force myself to switch
2022-01-26 20:55:06 +0100 <EvanR> macbook air my dude
2022-01-26 20:55:14 +0100dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Quit: WeeChat 3.3)
2022-01-26 20:55:15 +0100 <monochrom> Oh, so that's why DOS went from the file-control-block model to the file-handle (so file descriptor) model...
2022-01-26 20:56:26 +0100 <geekosaur> the file controlo block model was left over from dos 1.0 being a poor ripoff of cp/m
2022-01-26 20:56:36 +0100 <monochrom> Yeah
2022-01-26 20:56:37 +0100intersect(~ivoolivei@a109-50-190-38.cpe.netcabo.pt)
2022-01-26 20:57:26 +0100 <polyphem> dos 1.0 was int21h + command.com + gwbasic
2022-01-26 20:57:35 +0100 <polyphem> + autoexec.bat
2022-01-26 20:57:58 +0100 <geekosaur> actuslly I don't recall if dos .0 had int21h
2022-01-26 20:58:01 +0100 <geekosaur> 1.0
2022-01-26 20:58:10 +0100 <EvanR> back when your computer came with nothing but a programming environment
2022-01-26 20:58:28 +0100 <geekosaur> it still had jumping to address 0005 to make syscalls, which is part of the cp/m "emulation"
2022-01-26 20:58:39 +0100n3rdy1(~n3rdy1@2600:1700:4570:3480::41)
2022-01-26 20:59:14 +0100trillp(~trillp@2600:1700:28e2:14d0::3a)
2022-01-26 20:59:26 +0100 <intersect> Hello guys, how can i find how to use lambdabot?
2022-01-26 21:00:08 +0100 <monochrom> I lurked here and watched other people use it.
2022-01-26 21:00:32 +0100 <polyphem> wasn't the story of ms success being they tookover a deal to use cp/m as os for ibm-compatible pcs ,and instead bought the int21h handler from some students added their gwbasig and a shell command.com and made the deal with ibm
2022-01-26 21:00:37 +0100 <dminuoso> Yeah, it's best to just use the channel history, and dig through 10 years of chatlogs. We dont have any other documentation for it.
2022-01-26 21:00:41 +0100 <monochrom> But the most frequently used thing is this:
2022-01-26 21:00:44 +0100 <monochrom> > 1+1
2022-01-26 21:00:46 +0100 <lambdabot> 2
2022-01-26 21:01:07 +0100 <EvanR> @botsnack
2022-01-26 21:01:08 +0100 <lambdabot> :)
2022-01-26 21:01:17 +0100 <monochrom> It has some kind of @help command, but you will find it not very helpful.
2022-01-26 21:01:47 +0100 <intersect> hum, i was trying to figure out how to use it to make a pointwise function in to pointfree
2022-01-26 21:01:48 +0100 <dminuoso> I personally just use yahb at the end, for it is just an IRC bot bolted onto GHCi.
2022-01-26 21:01:59 +0100 <dminuoso> Which makes it simple to use
2022-01-26 21:02:06 +0100 <EvanR> @pl \x -> x + 1
2022-01-26 21:02:06 +0100 <lambdabot> (1 +)
2022-01-26 21:02:14 +0100 <EvanR> wait
2022-01-26 21:02:15 +0100 <monochrom> Yeah yahb is a real ghci, much more complete than lambdabot's >
2022-01-26 21:02:26 +0100 <EvanR> @pl \x -> x - 1
2022-01-26 21:02:26 +0100 <lambdabot> subtract 1
2022-01-26 21:02:27 +0100tomsmeding(~tomsmedin@tomsmeding.com) (Quit: ZNC 1.8.2 - https://znc.in)
2022-01-26 21:02:31 +0100 <EvanR> @pl \x -> x / 1
2022-01-26 21:02:31 +0100 <lambdabot> (/ 1)
2022-01-26 21:02:43 +0100 <EvanR> /1, 1+
2022-01-26 21:02:52 +0100 <monochrom> Oh interesting.
2022-01-26 21:02:53 +0100 <EvanR> it is assuming commutativitiy or
2022-01-26 21:03:22 +0100 <EvanR> I guess have laws for Num now
2022-01-26 21:03:31 +0100 <dminuoso> See, this is one of those things.
2022-01-26 21:03:39 +0100 <intersect> f(g(h(i))(x,y)
2022-01-26 21:03:59 +0100 <monochrom> Some human wrote @pl and perhaps their opinion went into it too.
2022-01-26 21:04:09 +0100 <monochrom> Right? I thought it was obvious.
2022-01-26 21:04:25 +0100 <monochrom> Every program exists because, only because, it's some programmer's opinion.
2022-01-26 21:04:39 +0100 <EvanR> that's a very constructive take
2022-01-26 21:04:49 +0100 <EvanR> brouwer would be proud
2022-01-26 21:05:45 +0100 <EvanR> let's see if their opinion extended to matrix multiplication
2022-01-26 21:05:52 +0100 <EvanR> @pl \x -> x * 1
2022-01-26 21:05:52 +0100 <lambdabot> id
2022-01-26 21:05:55 +0100juhp(~juhp@128.106.188.82) (Ping timeout: 268 seconds)
2022-01-26 21:06:03 +0100 <EvanR> the world may never know
2022-01-26 21:06:07 +0100 <monochrom> Matrix multiplication is a social construct.
2022-01-26 21:06:22 +0100 <monochrom> I mean, >:)
2022-01-26 21:07:23 +0100juhp(~juhp@128.106.188.82)
2022-01-26 21:07:39 +0100 <EvanR> @pl \i x y -> f (g (h i)) (x,y)
2022-01-26 21:07:39 +0100 <lambdabot> (. (,)) . (.) . f . g . h
2022-01-26 21:07:54 +0100 <EvanR> @pl \i x y -> f (g (h i)) x y
2022-01-26 21:07:54 +0100 <lambdabot> f . g . h
2022-01-26 21:08:14 +0100 <monochrom> Ho hum that turns out surprisingly neat.
2022-01-26 21:09:24 +0100mtjm(~mutantmel@2604:a880:2:d0::208b:d001) (Remote host closed the connection)
2022-01-26 21:09:24 +0100ub(~Thunderbi@141.98.252.232)
2022-01-26 21:10:28 +0100mtjm(~mutantmel@2604:a880:2:d0::208b:d001)
2022-01-26 21:10:53 +0100ubert(~Thunderbi@p548c8cd6.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2022-01-26 21:10:53 +0100ububert
2022-01-26 21:10:55 +0100 <geekosaur> I still need to flesh out my commands list so it's usable :(
2022-01-26 21:11:59 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-26 21:11:59 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-26 21:11:59 +0100wroathe(~wroathe@user/wroathe)
2022-01-26 21:12:34 +0100cynomys(~cynomys@user/cynomys)
2022-01-26 21:14:01 +0100Pickchea(~private@user/pickchea)
2022-01-26 21:15:29 +0100kuribas(~user@ptr-25vy0i9nxqs797laykw.18120a2.ip6.access.telenet.be) (Remote host closed the connection)
2022-01-26 21:15:32 +0100jle`(~jle`@cpe-23-240-75-236.socal.res.rr.com) (Ping timeout: 240 seconds)
2022-01-26 21:15:41 +0100haskellb1(~nut@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2022-01-26 21:17:26 +0100jle`(~jle`@cpe-23-240-75-236.socal.res.rr.com)
2022-01-26 21:18:02 +0100intersect(~ivoolivei@a109-50-190-38.cpe.netcabo.pt) (Ping timeout: 240 seconds)
2022-01-26 21:19:05 +0100trillp(~trillp@2600:1700:28e2:14d0::3a) (Quit: trillp)
2022-01-26 21:19:33 +0100intersect(~ivoolivei@a109-50-190-38.cpe.netcabo.pt)
2022-01-26 21:22:37 +0100ec(~ec@gateway/tor-sasl/ec)
2022-01-26 21:22:51 +0100segfaultfizzbuzz(~rustisafu@2602:306:cd3c:9350:59e3:db49:aa0a:46e5)
2022-01-26 21:23:55 +0100intersect(~ivoolivei@a109-50-190-38.cpe.netcabo.pt) (Ping timeout: 256 seconds)
2022-01-26 21:24:11 +0100Erutuon(~Erutuon@user/erutuon)
2022-01-26 21:25:02 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2022-01-26 21:27:29 +0100ultsllt(~ultsllt@50.231.5.242)
2022-01-26 21:31:21 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2022-01-26 21:31:40 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-26 21:31:40 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-26 21:31:40 +0100wroathe(~wroathe@user/wroathe)
2022-01-26 21:31:57 +0100xsperry(~xs@user/xsperry) (Ping timeout: 240 seconds)
2022-01-26 21:33:33 +0100jeetelongname(~jeet@88-111-159-26.dynamic.dsl.as9105.com)
2022-01-26 21:37:57 +0100yauhsien_(~yauhsien@61-231-17-3.dynamic-ip.hinet.net)
2022-01-26 21:39:52 +0100Feuermagier(~Feuermagi@user/feuermagier)
2022-01-26 21:41:15 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2022-01-26 21:42:32 +0100yauhsien_(~yauhsien@61-231-17-3.dynamic-ip.hinet.net) (Ping timeout: 240 seconds)
2022-01-26 21:45:00 +0100intersect(~ivoolivei@a109-50-190-38.cpe.netcabo.pt)
2022-01-26 21:47:44 +0100zincy(~zincy@host86-151-99-97.range86-151.btcentralplus.com)
2022-01-26 21:51:12 +0100denbrahe[m](~denbrahem@2001:470:69fc:105::19c0) (Quit: Client limit exceeded: 20000)
2022-01-26 21:52:09 +0100little_mac(~little_ma@2601:410:4300:3ce0:4001:9094:16f1:84ab) (Remote host closed the connection)
2022-01-26 21:52:15 +0100machinedgod(~machinedg@24.105.81.50)
2022-01-26 21:53:36 +0100ec(~ec@gateway/tor-sasl/ec)
2022-01-26 21:53:54 +0100 <intersect> 1+1
2022-01-26 21:54:06 +0100denbrahe[m](~denbrahem@2001:470:69fc:105::19c0)
2022-01-26 21:54:12 +0100 <intersect> >1+1
2022-01-26 21:54:16 +0100 <intersect> > 1+1
2022-01-26 21:54:18 +0100 <lambdabot> 2
2022-01-26 21:54:58 +0100 <intersect> > f(x) = x
2022-01-26 21:55:00 +0100 <lambdabot> <hint>:1:6: error: parse error on input ‘=’
2022-01-26 21:55:22 +0100 <intersect> > f(x) .=. x
2022-01-26 21:55:24 +0100 <lambdabot> error:
2022-01-26 21:55:24 +0100 <lambdabot> • Variable not in scope: (.=.) :: t0 -> Expr -> t
2022-01-26 21:55:24 +0100 <lambdabot> • Perhaps you meant one of these:
2022-01-26 21:56:06 +0100pavonia(~user@user/siracusa)
2022-01-26 21:56:23 +0100 <monochrom> No definition. But you can use "let ... in ..."
2022-01-26 21:56:24 +0100 <geekosaur> no assignments at the lambdabot prompt
2022-01-26 22:00:32 +0100neceve(~quassel@2.26.93.228) (Ping timeout: 240 seconds)
2022-01-26 22:01:28 +0100 <monochrom> Generally maybe you should pick up a bit of basic Haskell before using lambdabot.
2022-01-26 22:02:57 +0100n3rdy1(~n3rdy1@2600:1700:4570:3480::41) (Ping timeout: 240 seconds)
2022-01-26 22:03:53 +0100lechner(~lechner@debian/lechner) (Ping timeout: 268 seconds)
2022-01-26 22:04:22 +0100 <dsal> (at least, in a public channel)
2022-01-26 22:05:00 +0100 <EvanR> 1+1 is notation from basic math, f x y z is notation from lisp... I'mean... pick a side
2022-01-26 22:05:21 +0100_ht(~quassel@2a02:a468:b619:1:8a98:8031:2935:e3fc) (Remote host closed the connection)
2022-01-26 22:07:58 +0100little_mac(~little_ma@2601:410:4300:3ce0:dc4e:59ab:7b42:4b50)
2022-01-26 22:08:22 +0100 <dsal> BASIC math.
2022-01-26 22:08:36 +0100briandaed(~root@185.234.208.208.r.toneticgroup.pl)
2022-01-26 22:10:21 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2022-01-26 22:10:34 +0100lispy(~lispy4@84.69.59.93) (Quit: Leaving)
2022-01-26 22:11:01 +0100jushur(~human@user/jushur) (Quit: ¯\_(ツ)_/¯)
2022-01-26 22:14:51 +0100jushur(~human@user/jushur)
2022-01-26 22:16:08 +0100n3rdy1(~n3rdy1@2600:1700:4570:3480:1b88:50f:dae0:9293)
2022-01-26 22:19:06 +0100coot(~coot@89-64-85-93.dynamic.chello.pl)
2022-01-26 22:21:37 +0100 <Henson> I'm trying to interact with some C++ functions from Haskell that just do some referentially-transparent calculations and memory allocation. Is it okay to put those kinds of things into an unsafePerformIO?
2022-01-26 22:21:44 +0100briandaed(~root@185.234.208.208.r.toneticgroup.pl) (Quit: Lost terminal)
2022-01-26 22:22:15 +0100 <geekosaur> memory allocation is explicitly not safe for that
2022-01-26 22:23:22 +0100 <EvanR> is the memory temporary, released before the computation is done, or
2022-01-26 22:23:41 +0100 <EvanR> (or released in case of error before computation is done, or)
2022-01-26 22:25:30 +0100CHUD(~CHUD@host-80-41-89-108.as13285.net) (Ping timeout: 256 seconds)
2022-01-26 22:28:56 +0100 <Henson> the thing I'm trying to do is interact with some OpenCV functions in C++, which will take in a cv::Mat wrapped in a ForeignPtr, do some image processing on it, then allocate a new cv::Mat and return a pointer to that, which will then be wrapped in a ForeignPtr. Ideally I'd like to try to make these image processing operations not have to be in IO, and some of the OpenCV libraries I've seen for...
2022-01-26 22:29:13 +0100 <Henson> Haskell make it so these IO operations are behind an unsafePerformIO so they can be done in pure code.
2022-01-26 22:30:03 +0100 <geekosaur> I'm pretty sure if they are allocating memory under an unsafePerformIO they're playing with fire
2022-01-26 22:30:13 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 256 seconds)
2022-01-26 22:30:55 +0100 <geekosaur> the basic rule of unsafePerformIO is "if it breaks you get to keep the pieces", so if you insist on doing it it's your problem
2022-01-26 22:31:35 +0100 <Henson> haha, ok
2022-01-26 22:31:36 +0100 <EvanR> unsafePerformIO only makes sense when the IO action is pure, which it doesn't sound like your thing is
2022-01-26 22:31:48 +0100 <EvanR> I went through this yesterday with opengl
2022-01-26 22:32:01 +0100 <geekosaur> well, it could be pure right up until it allocates a new one, which isn't
2022-01-26 22:32:27 +0100 <geekosaur> if the image processing is deterministic and repeatable, at least
2022-01-26 22:33:18 +0100 <EvanR> allocating a new object to hold the answer rather than modifying the original is how normal haskell works though
2022-01-26 22:33:58 +0100 <EvanR> the question is if anything I care about can observe that allocation in a bad way
2022-01-26 22:34:21 +0100 <EvanR> or interfere with it
2022-01-26 22:34:43 +0100 <ephemient> the unsafePerformIO allocation might get inlined and duplicated or cse'd and unduplicated, both of which could be problematic
2022-01-26 22:34:43 +0100 <Henson> it looks like they use unsafeCoerce to convert it from an IO action to whatever they're returning
2022-01-26 22:35:16 +0100 <EvanR> doubling the allocation or undoubling could lead to a change in performance but not necessarily semantics
2022-01-26 22:36:13 +0100 <EvanR> of course... there's... THREAD SAFETY
2022-01-26 22:36:38 +0100 <EvanR> two threads try to compute on the same thing at the same time
2022-01-26 22:36:45 +0100 <Henson> EvanR: it looks like they allocate a new image to hold the answer, then get OpenCV to put the answer in the thing they've allocated. But the allocation is still being done at the C++ layer
2022-01-26 22:37:19 +0100 <EvanR> yes ForeignPtr is for that, holding a ref to a foreign object, potentially calling a finalizer when haskell loses track of it
2022-01-26 22:37:29 +0100 <geekosaur> EvanR, I think that can't happen. unsafePerformIO has a mutex, unsafeDupablePerformIo doens't, iirc
2022-01-26 22:38:04 +0100 <EvanR> speaking of just the IO action yeah
2022-01-26 22:38:11 +0100jeetelongname(~jeet@88-111-159-26.dynamic.dsl.as9105.com) (Ping timeout: 250 seconds)
2022-01-26 22:38:17 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-26 22:38:18 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-26 22:38:18 +0100wroathe(~wroathe@user/wroathe)
2022-01-26 22:38:20 +0100 <davean> I mean theres the blackhole
2022-01-26 22:38:39 +0100 <davean> is it locked on compute or update?
2022-01-26 22:38:47 +0100 <Henson> EvanR: but is there any difference from performing the allocation in C++ and creating a ForeignPtr from it, then calling C++ with the Ptr (getting OpenCV to put the answer in the image you've previously allocated) compared to C++ taking in your image and allocating an image for the answer, and then you creating a ForeignPtr for the answer post-facto?
2022-01-26 22:39:01 +0100 <EvanR> I am reading into what Henson is doing, that they will have some foreign data that two haskel threads accesses after the fact, but maybe I'm off the deep end now
2022-01-26 22:39:29 +0100 <EvanR> Henson, wait, you're now allocating space in one action, and later doing a call to fill in the answer?
2022-01-26 22:39:38 +0100 <EvanR> or rewriting an already made object? or
2022-01-26 22:39:43 +0100 <ephemient> if it was a single unsafePerformIO wrapping the whole "allocate and fill in" then it seems potentially okay-ish to me? but if it's a unsafePerformIO allocate, some pure Haskell code, then unsafePerformIO fill, that is questionable
2022-01-26 22:39:57 +0100 <EvanR> yes that's ... not going to turn out good
2022-01-26 22:40:29 +0100 <EvanR> Henson, yeah, big diff
2022-01-26 22:40:58 +0100 <EvanR> esp if you're trying to do it all without admitting it's IO
2022-01-26 22:41:08 +0100 <Henson> EvanR: I would never have OpenCV perform in-place operations on the image I've passed it. I would always have it put the results in a new image
2022-01-26 22:41:25 +0100 <EvanR> but what's this idea of passing it a pointer to empty space
2022-01-26 22:41:26 +0100 <dolio> Are you just asking if it matters who does the allocation?
2022-01-26 22:41:51 +0100 <Henson> EvanR: but whether that destination image has been pre-allocated in a previous C++ function call and has already been turned into a ForeignPtr, or it's allocated within the image processing call and then gets turned into a ForeignPtr afterwards is the question.
2022-01-26 22:42:00 +0100 <Henson> dolio: yes
2022-01-26 22:42:11 +0100 <EvanR> it sounds like C++ does the allocation regardless
2022-01-26 22:42:14 +0100 <Henson> in both bases C++ does the allocation
2022-01-26 22:42:28 +0100 <dolio> I think if you have C++ do the allocation, you might have to write your own finalizer that calls back into C++.
2022-01-26 22:42:36 +0100 <Henson> in the pre-allocation case there's a ForeignPtr for the answer before the image processing function is called.
2022-01-26 22:42:36 +0100 <dolio> Which sounds more complicated.
2022-01-26 22:42:41 +0100 <EvanR> you can make 2 calls, but you better not make two unsafePerformIOs
2022-01-26 22:42:41 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 256 seconds)
2022-01-26 22:42:50 +0100 <davean> Henson: what about the deallocate linked to the F Ptr?
2022-01-26 22:42:53 +0100 <Henson> dolio: yes. It's not that complicated, it's just a simple cast and a free. I've got that written already.
2022-01-26 22:42:55 +0100 <davean> Henson: you want that called, right?
2022-01-26 22:42:56 +0100 <EvanR> assuming you determine unsafePerformIO is even safe
2022-01-26 22:43:06 +0100 <davean> so you don't want to create 2 new images
2022-01-26 22:43:13 +0100 <davean> and have one of them not exist to the GC
2022-01-26 22:43:37 +0100myShoggoth(~myShoggot@97-120-67-120.ptld.qwest.net) (Ping timeout: 240 seconds)
2022-01-26 22:43:57 +0100myShoggoth(~myShoggot@97-120-67-120.ptld.qwest.net)
2022-01-26 22:44:23 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475) (Ping timeout: 256 seconds)
2022-01-26 22:44:33 +0100 <Henson> davean: correct, I don't want to do that. I simply want to do a referentially-transparent image operation that will not modify the things I'm sending in, but will return something that will involve memory allocation at the C++ level. I'm wondering how safe/unsafe doing that is with unsafePerformIO so I can use it in pure code instead of in IO.
2022-01-26 22:44:49 +0100OscarH(~OscarH@2a02:c7f:a0da:ae00:ba27:ebff:fe84:d2f4) (Quit: ZNC 1.7.2+deb3 - https://znc.in)
2022-01-26 22:45:00 +0100 <dolio> That's basically what unsafePerformIO is for.
2022-01-26 22:45:04 +0100OscarH(~OscarH@2a02:c7f:a0da:ae00:ba27:ebff:fe84:d2f4)
2022-01-26 22:45:10 +0100 <ephemient> if some things get lost and never end up finalized/freed by the GC, it can still be considered "safe"
2022-01-26 22:45:41 +0100 <EvanR> do that in 1 unsafePerformIO, make sure to use a finalizer, and accept that the whole thing may happen more than once if inlining happens...
2022-01-26 22:45:43 +0100 <davean> Henson: unsafePerformIO can be done correctly, but its certainly not dupable
2022-01-26 22:45:44 +0100 <ephemient> but you probably do want to have a ForeignPtr+finalizer in there for practical purposes
2022-01-26 22:46:16 +0100 <Henson> davean: what do you mean by "dupable"?
2022-01-26 22:46:20 +0100wyrd(~wyrd@gateway/tor-sasl/wyrd)
2022-01-26 22:46:27 +0100mon_aaraj(~MonAaraj@user/mon-aaraj/x-4416475)
2022-01-26 22:46:31 +0100 <EvanR> two threads execute your computation at the same time
2022-01-26 22:46:42 +0100 <Henson> ephemient: yes, anything allocated in C++ that gets returned as a Ptr will be converted to a ForeignPtr with an appropriate finalizer.
2022-01-26 22:47:06 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 250 seconds)
2022-01-26 22:47:20 +0100 <EvanR> which might happen with unsafeDupablePerformIO
2022-01-26 22:47:57 +0100 <Henson> EvanR: can you explain a bit more about the call happening more than once with inlining?
2022-01-26 22:48:03 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2022-01-26 22:48:04 +0100 <EvanR> well you claim it's pure so
2022-01-26 22:48:18 +0100 <EvanR> let x = unsafePerformIO stuff = (x, x)
2022-01-26 22:48:26 +0100 <EvanR> let x = unsafePerformIO stuff in (x, x)
2022-01-26 22:48:31 +0100 <EvanR> that's the same as
2022-01-26 22:48:40 +0100 <EvanR> (unsafePerformIO stuff, unsafePerformIO stuff)
2022-01-26 22:48:58 +0100 <EvanR> it got inlined
2022-01-26 22:49:10 +0100Feuermagier(~Feuermagi@user/feuermagier) (Remote host closed the connection)
2022-01-26 22:49:46 +0100 <Henson> EvanR: in that case would Haskell not evaluate one of them because the function and arguments are the same for both of them?
2022-01-26 22:50:03 +0100 <EvanR> you mean common subexpression elimination? undoing the inlinine it just did? xD
2022-01-26 22:50:20 +0100 <EvanR> usually no
2022-01-26 22:50:20 +0100 <geekosaur> there's more thn that. if it's pure then ghc can decide to lift the operation out of e.g. a loop
2022-01-26 22:50:28 +0100travisb_(~travisb@172-13-49-137.lightspeed.milwwi.sbcglobal.net)
2022-01-26 22:50:43 +0100Pickchea(~private@user/pickchea) (Quit: Leaving)
2022-01-26 22:50:46 +0100 <EvanR> yeah it could happen multiple times, or fewer times than you thought
2022-01-26 22:50:48 +0100 <geekosaur> this caused major problems for bytestring when they thought it wss okay to cheat like that
2022-01-26 22:50:49 +0100 <ephemient> pure expressions have no side effects so Haskell is free to evaluate them any number of times, including fewer or more than you wrote
2022-01-26 22:51:35 +0100 <davean> EvanR: you can mark it expensive
2022-01-26 22:51:51 +0100 <EvanR> mark it expensive?
2022-01-26 22:51:52 +0100 <Henson> EvanR: but in let x = unsafePerformIO stuff in (x, x) Haskell will make two identical thunks in the tuple, right? Whenever either one of them gets evaluated the other will no longer need to be evaluated, right?
2022-01-26 22:51:57 +0100tabemann(~travisb@172-13-49-137.lightspeed.milwwi.sbcglobal.net) (Ping timeout: 240 seconds)
2022-01-26 22:52:47 +0100lechner(~lechner@debian/lechner)
2022-01-26 22:52:49 +0100 <EvanR> in literally let x = 1000 in (x,x) there's only 1 1000
2022-01-26 22:52:57 +0100 <EvanR> in literally (1000,1000) there's 2 1000
2022-01-26 22:53:17 +0100 <EvanR> they can be transformed into each other at compile time
2022-01-26 22:53:24 +0100justsomeguy(~justsomeg@user/justsomeguy)
2022-01-26 22:53:34 +0100 <EvanR> it's fine since 1000 is just a value
2022-01-26 22:53:50 +0100 <EvanR> not a command to fire missiles
2022-01-26 22:54:00 +0100 <Henson> if Haskell were to evaluate (x,x) twice, then the two x values wouldn't be identical anymore, as they'd be two different ForeignPtrs
2022-01-26 22:54:13 +0100 <EvanR> yeah, is that ok
2022-01-26 22:54:15 +0100 <Henson> where x is the result of the image processing
2022-01-26 22:54:59 +0100 <Henson> EvanR: that's fine with me. It would result it unneccessary image processing work, but the final results would be the same, just essentially copies of each other in memory.
2022-01-26 22:54:59 +0100 <EvanR> if not you can attempt to cheat by putting hints to stop inlining
2022-01-26 22:55:29 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2022-01-26 22:58:35 +0100 <Henson> now here's a question of taking the "naughtiness" to another level. Say I have a list of ForeignPtrs to images, and I want to call a C++ function that operates on a list of images and returns a list of images. I need to call withForeignPtr recursively to get at the Ptrs within each of the images in a list, then run the image processing operation, then wrap up the returned Ptrs as ForeignPtrs...
2022-01-26 22:58:37 +0100jeetelongname(~jeet@88-111-159-26.dynamic.dsl.as9105.com)
2022-01-26 22:59:14 +0100 <Henson> in the documentations, it says withForeignPtr is need to prevent the ForeignPtrs from being deallocated during the call that is inside of them. If I was that all in an unsafePerformIO, do those guarantees go out of the window?
2022-01-26 23:00:02 +0100 <Henson> also, is there a difference between unsafePerformIO and unsafeCoerce in terms of safety?
2022-01-26 23:00:07 +0100FroskyArr(~froskyarr@203.175.13.219) (Remote host closed the connection)
2022-01-26 23:00:15 +0100 <Henson> I mean runtime safety, and not type safety
2022-01-26 23:00:24 +0100 <geekosaur> unsafeCoerce is unsafe in part because you can make unsafePerformIO from it
2022-01-26 23:00:25 +0100FroskyArr(~froskyarr@203.175.13.219)
2022-01-26 23:01:14 +0100haskellb1(~nut@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Ping timeout: 268 seconds)
2022-01-26 23:01:22 +0100 <EvanR> unsafeCoerce is very unsafe
2022-01-26 23:01:23 +0100 <Henson> would it be better to do my IO a -> a with unsafePerformIO, or with unsafeCoerce to do my image processing in pure code instead of IO?
2022-01-26 23:01:51 +0100 <EvanR> omg don't use unsafeCoerce to do IO xD
2022-01-26 23:01:56 +0100 <Henson> haha
2022-01-26 23:02:33 +0100 <Henson> ok, so just stick with unsafePerformIO and be as careful as I can
2022-01-26 23:02:47 +0100mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net) (Quit: ZNC 1.8.2 - https://znc.in)
2022-01-26 23:03:18 +0100haskellberryfinn(~nut@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Remote host closed the connection)
2022-01-26 23:03:29 +0100 <Henson> EvanR: what should I look for to prevent Haskell from inlining the function? I know there's the {-# INLINE foo #-} statement, is there a similar one to prevent inlining?
2022-01-26 23:03:35 +0100 <EvanR> earlier you mentioned they use it to convert a pointer? There's a not-as-unsafe-as-unsafeCoerce other operation for that called castPtr
2022-01-26 23:03:37 +0100 <geekosaur> NOINLINE
2022-01-26 23:04:04 +0100cdsmith(~cdsmithma@2001:470:69fc:105::284) (Quit: Client limit exceeded: 20000)
2022-01-26 23:04:20 +0100travisb_(~travisb@172-13-49-137.lightspeed.milwwi.sbcglobal.net) (Remote host closed the connection)
2022-01-26 23:04:22 +0100mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net)
2022-01-26 23:04:34 +0100 <EvanR> change the type of a Ptr when "you know better than the type system"
2022-01-26 23:04:49 +0100cdsmith(~cdsmithma@2001:470:69fc:105::284)
2022-01-26 23:05:07 +0100travisb_(~travisb@172-13-49-137.lightspeed.milwwi.sbcglobal.net)
2022-01-26 23:05:34 +0100 <Henson> EvanR: here's the OpenCV source code for the library I was looking at as a comparison: https://hackage.haskell.org/package/opencv-0.0.2.1/docs/src/OpenCV-Core-ArrayOps.html#matScalarAdd this is not the OpenCV functions I'm using, but where I got the idea for unsafeCoerce
2022-01-26 23:07:11 +0100 <EvanR> the function unsafeCoerceMat might be a limited version of unsafeCoerce
2022-01-26 23:07:33 +0100 <EvanR> to do with the matrix dimensions or something
2022-01-26 23:09:03 +0100 <EvanR> unsafeCoerceMat :: Mat shapeIn channelsIn depthIn -> Mat shapeOut channelsOut depthOut
2022-01-26 23:09:15 +0100zincy(~zincy@host86-151-99-97.range86-151.btcentralplus.com) (Remote host closed the connection)
2022-01-26 23:09:22 +0100 <EvanR> a "trust me" for matrices only
2022-01-26 23:10:02 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net) (Quit: WeeChat 2.2-dev)
2022-01-26 23:10:29 +0100 <EvanR> there are other safer operations to change shape, I saw at a glance in the docs elsewhere
2022-01-26 23:10:32 +0100jeetelongname(~jeet@88-111-159-26.dynamic.dsl.as9105.com) (Ping timeout: 240 seconds)
2022-01-26 23:12:22 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2022-01-26 23:12:23 +0100 <Henson> EvanR: https://hackage.haskell.org/package/opencv-0.0.2.1/docs/src/OpenCV-Internal-Core-Types-Mat.html#un… is just unsafeCoerce. But there are functions in that module that talk about safer versions of unsafeCoerceMat.
2022-01-26 23:12:46 +0100 <Henson> EvanR: and unsafeCoerce is from the Unsafe.Coerce module.
2022-01-26 23:12:58 +0100 <EvanR> unsafeCoerceMat with a type signature way more limited than unsafeCoerce simply implemented as unsafeCoerce is way better
2022-01-26 23:14:50 +0100 <Henson> EvanR: but the question I have is: they use unsafeCoerceMat = unsafeCoerce to do IO operations in pure code. Should I emulate what they're doing and use unsafeCoerce (or some more type-safe variant), or should I use unsafePerformIO?
2022-01-26 23:15:02 +0100 <EvanR> note they are probably only using it when the object they are coercing actually has the type they coerce to, in spirit
2022-01-26 23:15:42 +0100EvanRdoes a double take
2022-01-26 23:16:16 +0100 <monochrom> No, unsafeCoerceMat = unsafeCoerce does not do IO operations in pure code.
2022-01-26 23:16:19 +0100haskellb1(~nut@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2022-01-26 23:16:21 +0100 <ski> (how're they using `unsafeCoerce' to do `unsafePerformIO' ?)
2022-01-26 23:16:24 +0100michalz(~michalz@185.246.204.37) (Remote host closed the connection)
2022-01-26 23:16:48 +0100 <monochrom> There is an explicit "unsafePerformIO" somewhere else in matScalarAdd.
2022-01-26 23:17:07 +0100 <haskellb1> is Comonad widely used in Haskell programming? I find it extremely abstract
2022-01-26 23:17:18 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net)
2022-01-26 23:17:32 +0100 <EvanR> I used it on the sea cucumber advent of code last month
2022-01-26 23:17:44 +0100 <haskellb1> spending time on defining it's class methods seems not at all related to the problem logic itself
2022-01-26 23:18:05 +0100gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2022-01-26 23:18:08 +0100 <EvanR> that's why it's support code, just like monad >>=
2022-01-26 23:18:36 +0100 <EvanR> or map, filter, fold for list, it's supporting code, not for any particular problem
2022-01-26 23:18:37 +0100myShoggoth(~myShoggot@97-120-67-120.ptld.qwest.net) (Ping timeout: 240 seconds)
2022-01-26 23:19:35 +0100 <Rembane> The Comonad is an abstraction that makes some problems easy to solve.
2022-01-26 23:20:06 +0100 <monochrom> I haven't used comonad, but everything you said could be said of monad too.
2022-01-26 23:20:25 +0100 <haskellb1> Can commoners come up with abstractions like this?
2022-01-26 23:20:36 +0100 <monochrom> I could make the case that for parsing, >>= "does not relate to the parsing logic".
2022-01-26 23:20:38 +0100 <geekosaur> not even most haskellers can
2022-01-26 23:20:54 +0100 <haskellb1> I guess it takes years of practice to see things like that
2022-01-26 23:20:58 +0100 <geekosaur> but once it's been come up with, almost anyone can learn to use it
2022-01-26 23:21:07 +0100 <monochrom> Ah but "parsing logic" itself is inexpressible until you can take >>= for granted.
2022-01-26 23:21:22 +0100 <EvanR> I found monad >>= and comonad <<= to be equally hard to write
2022-01-26 23:21:33 +0100 <EvanR> luckily you don't have to do it too often
2022-01-26 23:21:53 +0100 <Henson> monochrom: you're right, they're using unsafePerformIO instead of unsafeCoerce
2022-01-26 23:21:55 +0100 <monochrom> So, yes and no. The parser monad's >>= does not express parsing logic, but parsing logic needs >>= to be writable in the first place.
2022-01-26 23:22:18 +0100 <Henson> ski: thanks for doing that out, I was wrong about how they were using unsafeCoerce
2022-01-26 23:22:46 +0100 <monochrom> Well, or at least <*>
2022-01-26 23:23:29 +0100 <Henson> ski: doing that out -> pointing that out
2022-01-26 23:23:30 +0100 <haskellb1> Can I understand that Monad represents something that can be collapsed while comonad is the other way around?
2022-01-26 23:23:45 +0100 <ski> `(>>=)' and `(<*>)' are "plumbing", yea
2022-01-26 23:23:58 +0100 <EvanR> comonads can replicate (duplicate)
2022-01-26 23:24:16 +0100 <ski> haskellb1 : in a vague (or perhaps abstract) sense, yea
2022-01-26 23:24:27 +0100 <monochrom> Yeah, "whatever that means".
2022-01-26 23:24:34 +0100 <ski> (the devil's in the details of what you mean by those words)
2022-01-26 23:24:49 +0100 <haskellb1> I'm trying to figure out "when" people are going to use these concepts to model their problems
2022-01-26 23:24:54 +0100 <monochrom> The beauty of those oh-so-intuitive wording is they make you comfortable without any predictive power.
2022-01-26 23:24:56 +0100 <EvanR> If a monad is a burrito, then a comonad is like a night club
2022-01-26 23:25:27 +0100 <geekosaur> oboy…
2022-01-26 23:25:37 +0100xff0x(~xff0x@2001:1a81:53ec:e00:6733:4fa5:6e13:2687) (Ping timeout: 240 seconds)
2022-01-26 23:25:46 +0100 <EvanR> sorry
2022-01-26 23:25:54 +0100 <haskellb1> Conventional data structures such as Heap and stack or trees are easier to see
2022-01-26 23:26:00 +0100 <monochrom> Space Telescope (ST) that wraps and unwraps like a burrito >:)
2022-01-26 23:26:28 +0100 <EvanR> I still don't really understand a Heap
2022-01-26 23:26:31 +0100 <ski> stuff like monads are usually better to think of as "control structures"
2022-01-26 23:26:35 +0100 <geekosaur> http://blog.sigfpe.com/2006/08/you-could-have-invented-monads-and.html
2022-01-26 23:26:37 +0100 <haskellb1> of course not always obvious(such as particle collisions can be modeled by priority heaps)
2022-01-26 23:26:43 +0100myShoggoth(~myShoggot@97-120-67-120.ptld.qwest.net)
2022-01-26 23:26:48 +0100xff0x(~xff0x@2001:1a81:53ec:e00:f919:e263:9a7f:5670)
2022-01-26 23:26:55 +0100 <EvanR> ah a heap is like a priority queue?
2022-01-26 23:27:09 +0100 <ski> it's one implementation of PQs, yea
2022-01-26 23:27:36 +0100 <geekosaur> http://blog.sigfpe.com/2006/06/monads-kleisli-arrows-comonads-and.html
2022-01-26 23:27:40 +0100 <haskellb1> anyway i feel like Haskell is abstract in a different way
2022-01-26 23:28:02 +0100 <monochrom> Yeah control structures.
2022-01-26 23:28:03 +0100coot(~coot@89-64-85-93.dynamic.chello.pl) (Quit: coot)
2022-01-26 23:28:20 +0100 <EvanR> stacks, trees, etc are concrete data structures
2022-01-26 23:28:32 +0100 <justsomeguy> Refresh my memory: Do regular function definitions have a precedence of 7 or 9 by default?
2022-01-26 23:28:38 +0100 <monochrom> Bet few programmers have thought of "a zoo of control structures" and so don't get monads just because of that.
2022-01-26 23:28:38 +0100 <EvanR> where as Functors and Monads are abstract interfaces waiting to be implemented
2022-01-26 23:28:46 +0100 <ski> justsomeguy : 10, if you mean function application
2022-01-26 23:29:17 +0100 <haskellb1> stack and trees are still abstract because they can be applied to many different situations. But they are so common it takes less effort on the mind
2022-01-26 23:29:20 +0100 <monochrom> And it doesn't help that Haskell is like even "data Foo a = ..." is often used to express control...
2022-01-26 23:29:43 +0100 <EvanR> that's a different sense of abstract but ok
2022-01-26 23:29:55 +0100 <monochrom> Plus, "what is control?" is equivalent to "what is effect?" :)
2022-01-26 23:29:59 +0100 <EvanR> they certainly can be used for multiple things
2022-01-26 23:30:11 +0100 <justsomeguy> ski: I thought that precedence only goes from 0..9? Or maybe that's only the range for fixity declarations, rather than fixity in general.
2022-01-26 23:30:31 +0100craige[m](~craigemcw@2001:470:69fc:105::35f1) (Quit: Client limit exceeded: 20000)
2022-01-26 23:30:34 +0100 <geekosaur> the default fixity of a function is infixl 9
2022-01-26 23:30:48 +0100 <EvanR> in each case we're still talking about the same concrete structure. Unlike "how to solve something with a random unknown monad", that's a whole nother story, and not even necessarily what is always done
2022-01-26 23:30:54 +0100craige[m](~craigemcw@2001:470:69fc:105::35f1)
2022-01-26 23:30:56 +0100 <geekosaur> function application behaves as if it has fixity 10, record updates behave as if they had fixity 11
2022-01-26 23:31:23 +0100ski. o O ( "Escaping Hell with Monads" by Philip Nilsson in 2017-05-08 at <https://philipnilsson.github.io/Badness10k/escaping-hell-with-monads/> ; "Flattening Callback Chains with Monad Do-Notation" by Remko Tronçon in 2015-07-02 at <https://el-tramo.be/blog/async-monad/> )
2022-01-26 23:31:24 +0100 <justsomeguy> Thank you, that clears things up. I wish the language report made that a little more obvious.
2022-01-26 23:32:03 +0100 <ski> justsomeguy : fixity of function application (juxtaposition syntactic operator) is `10'
2022-01-26 23:32:19 +0100 <monochrom> Function application and record syntax cannot be formally given predence levels because there is no binary operator to attach the predence levels to.
2022-01-26 23:32:26 +0100 <ski> er, s/fixity/precedence/
2022-01-26 23:32:35 +0100kjak(~kjak@pool-108-45-56-21.washdc.fios.verizon.net)
2022-01-26 23:32:44 +0100 <ski> ordinary (definable) operators have precedences from zero to nine, sure
2022-01-26 23:32:57 +0100 <monochrom> And the Haskell Report is supposed to give formal definitions not intuitive conceptual moral fast-and-loose bedtime stories.
2022-01-26 23:33:27 +0100 <Henson> check out https://www.haskell.org/onlinereport/decls.html section 4.4.2 for fixity declarations
2022-01-26 23:33:28 +0100 <monochrom> So yeah it has to hide the intuitive interpretation in a formal grammar.
2022-01-26 23:33:57 +0100 <Henson> "The integer in a fixity declaration must be in the range 0 to 9"
2022-01-26 23:34:25 +0100 <EvanR> nothing wrong with turning it up to 11 every once in a while though
2022-01-26 23:34:33 +0100 <monochrom> You can maybe go Dijkstra's way and demand function application to be an explicit binary operator. He uses ".", for example "sin.0"
2022-01-26 23:34:39 +0100 <monochrom> haha
2022-01-26 23:35:05 +0100 <monochrom> He was also happy with curry, "f.x.y".
2022-01-26 23:35:14 +0100 <monochrom> err, currying!
2022-01-26 23:35:21 +0100 <ski> % data Prec = P; instance Show Prec where showsPrec p P = showChar '<' . shows p . showChar '>'
2022-01-26 23:35:22 +0100 <yahb> ski:
2022-01-26 23:35:25 +0100 <ski> % P :+ P
2022-01-26 23:35:26 +0100 <yahb> ski: <7> :+ <7>
2022-01-26 23:35:28 +0100 <ski> % (P,P)
2022-01-26 23:35:29 +0100 <yahb> ski: (<0>,<0>)
2022-01-26 23:35:31 +0100 <ski> % Just P
2022-01-26 23:35:32 +0100 <yahb> ski: Just <11>
2022-01-26 23:35:42 +0100 <EvanR> what did you just do
2022-01-26 23:36:16 +0100 <ski> (eleven, because function application is `infixl', so you add one to the precedence, when going to the right operand (the function argument expression))
2022-01-26 23:36:17 +0100 <EvanR> print out the number passed around with showsPrec
2022-01-26 23:36:35 +0100 <monochrom> Sneaky.
2022-01-26 23:36:49 +0100 <Henson> "Any operator lacking a fixity declaration is assumed to be infixl 9". This means that since function application isn't defined in the list it has the strongest fixity of 9, right?
2022-01-26 23:37:13 +0100 <Henson> I mean, I guess your function name IS the operator, and it's infixl with a fixity of 9
2022-01-26 23:37:18 +0100 <monochrom> No. Function application is not an operator.
2022-01-26 23:37:23 +0100 <monochrom> As said.
2022-01-26 23:37:44 +0100 <ski> Henson : that only applies to ordinary operators
2022-01-26 23:37:45 +0100 <EvanR> % Just P
2022-01-26 23:37:45 +0100 <yahb> EvanR: Just <11>
2022-01-26 23:37:59 +0100 <EvanR> oops
2022-01-26 23:38:02 +0100geranim0(~geranim0@d-132-204-221-88.res.umontreal.ca) (Remote host closed the connection)
2022-01-26 23:38:12 +0100 <ski> it does not apply to `@' in patterns, e.g. (another "syntatic operator" (my term))
2022-01-26 23:38:54 +0100 <Henson> ski: can you elaborate?
2022-01-26 23:38:59 +0100 <monochrom> An "operator" is at least a lexeme as per Chapter 2. In "f e", there is no lexeme between "f" and "e".
2022-01-26 23:39:47 +0100 <EvanR> until we get overloaded whitespace
2022-01-26 23:40:22 +0100 <ski> (`~',`!' in patterns are examples of prefix (syntactic) operators. and then there's record construction (and update), which has higher precedence (binds tighter) than function application. `foo Node {rootLabel = r,subForest = ts}' is parsed as `foo (Node {rootLabel = r,subForest = ts})')
2022-01-26 23:41:00 +0100 <monochrom> > length"xxxx" -- my favourite example
2022-01-26 23:41:02 +0100 <lambdabot> 4
2022-01-26 23:41:17 +0100 <monochrom> > const"abc"123 -- have one more
2022-01-26 23:41:19 +0100 <lambdabot> "abc"
2022-01-26 23:41:32 +0100 <monochrom> No operator.
2022-01-26 23:41:32 +0100 <EvanR> I retract my joke
2022-01-26 23:41:51 +0100 <EvanR> not enough space between the lexemes for this joke
2022-01-26 23:42:09 +0100 <ski> Henson : "operator" as in the report is as you say. however, i was talking about some syntactic constructions which turn up as binary nodes in the AST, and which behave as "syntactic operators". other examples are `::' and `<-'
2022-01-26 23:42:12 +0100 <monochrom> "space is function application" is one of those white lies like Santa Claus we tell to kids.
2022-01-26 23:42:30 +0100 <ski> yes, better to say "juxtaposition"
2022-01-26 23:42:48 +0100 <monochrom> When you grow up, there is no longer any tooth fairy.
2022-01-26 23:42:56 +0100 <EvanR> f x y
2022-01-26 23:42:58 +0100 <EvanR> f x y
2022-01-26 23:42:59 +0100 <EvanR> fxy
2022-01-26 23:43:09 +0100 <geekosaur> consecutive tokens
2022-01-26 23:43:23 +0100segfaultfizzbuzz(~rustisafu@2602:306:cd3c:9350:59e3:db49:aa0a:46e5) (Remote host closed the connection)
2022-01-26 23:43:39 +0100 <ski> (obviously, Santa Claus and the Tooth Fairy exists. just like cities, countries, bands, organizations exist ..)
2022-01-26 23:43:45 +0100segfaultfizzbuzz(~rustisafu@2602:306:cd3c:9350:59e3:db49:aa0a:46e5)
2022-01-26 23:44:13 +0100 <monochrom> Oh haha I like that.
2022-01-26 23:44:24 +0100 <monochrom> Haskell is a social construct. :)
2022-01-26 23:44:39 +0100 <EvanR> "they didn't tell you? Santa clause died. 4 years ago" -- home improvement
2022-01-26 23:45:41 +0100 <monochrom> Horn Claus takes polynomial time, Santa Claus is NP-hard >:)
2022-01-26 23:45:59 +0100 <EvanR> minus e
2022-01-26 23:46:22 +0100 <monochrom> Your typo was inspiring. Please don't fix it! :)
2022-01-26 23:46:45 +0100romesrf(~romes@44.190.189.46.rev.vodafone.pt)
2022-01-26 23:47:51 +0100 <dolio> Just say it was an acknowledgement that Tim Allen was in The Santa Clause.
2022-01-26 23:48:02 +0100 <EvanR> lol
2022-01-26 23:48:13 +0100 <monochrom> Hee hee good catch.
2022-01-26 23:48:28 +0100 <EvanR> where he actually died... that must be where that movie came from
2022-01-26 23:48:33 +0100 <EvanR> unfortunately
2022-01-26 23:49:11 +0100 <monochrom> > 1
2022-01-26 23:49:13 +0100 <lambdabot> 1
2022-01-26 23:50:24 +0100 <EvanR> > "monochrom" > "1"
2022-01-26 23:50:25 +0100 <lambdabot> True
2022-01-26 23:50:43 +0100Feuermagier(~Feuermagi@user/feuermagier)
2022-01-26 23:51:21 +0100 <EvanR> > monochrom > 1
2022-01-26 23:51:22 +0100 <lambdabot> False
2022-01-26 23:53:35 +0100Feuermagier(~Feuermagi@user/feuermagier) (Remote host closed the connection)
2022-01-26 23:55:03 +0100tomsmeding(~tomsmedin@tomsmeding.com)
2022-01-26 23:56:06 +0100soxen(~bob@pool-173-54-217-168.nwrknj.fios.verizon.net)
2022-01-26 23:56:51 +0100azimut_(~azimut@gateway/tor-sasl/azimut)
2022-01-26 23:57:24 +0100romesrf(~romes@44.190.189.46.rev.vodafone.pt) (Quit: WeeChat 3.4)
2022-01-26 23:57:46 +0100_xor(~xor@dsl-50-5-233-169.fuse.net) (Read error: Connection reset by peer)
2022-01-26 23:59:04 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-26 23:59:04 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-26 23:59:04 +0100wroathe(~wroathe@user/wroathe)
2022-01-26 23:59:20 +0100Feuermagier(~Feuermagi@user/feuermagier)