2020/10/09

2020-10-09 00:01:21 +0200 <dolio> Of course, that only depends on `m a` being a free algebra. If you situate it in the category of all algebras, it's `(a -> r) -> m a -> r`, presuming `r` is an algebra.
2020-10-09 00:03:28 +0200falafel(~falafel@2605:e000:1527:d491:1ccf:5c8d:7928:e9cc)
2020-10-09 00:04:01 +0200ryansmccoy(~ryansmcco@156.96.151.132) (Ping timeout: 246 seconds)
2020-10-09 00:04:36 +0200ryansmccoy(~ryansmcco@193.37.254.27)
2020-10-09 00:04:36 +0200 <dminuoso> proofofme: Now to the next step. An applicative is simply a monoid in the category of endofunctors as well!
2020-10-09 00:05:15 +0200fendor(~fendor@77.119.131.69.wireless.dyn.drei.com) (Remote host closed the connection)
2020-10-09 00:05:17 +0200 <dminuoso> But that category is equipped with a different tensor. In case of Monad it's endofunctor composition, and in case of Applicative it's Day convolution. :)
2020-10-09 00:05:41 +0200monochromcries
2020-10-09 00:05:46 +0200 <dolio> In that case it doesn't need to be an endofunctor, though.
2020-10-09 00:06:35 +0200worc3131(~quassel@2a02:c7f:c026:9500:7d0b:65d0:38a4:4786) (Ping timeout: 272 seconds)
2020-10-09 00:07:34 +0200 <proofofme> interesting! I am referencing all this stuff right now
2020-10-09 00:08:22 +0200 <monochrom> I now agree with St. Augustine that you math nerds are pure evil. :)
2020-10-09 00:08:41 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-09 00:09:10 +0200 <hpc> we should make like pythagoras and throw them overboard
2020-10-09 00:09:18 +0200 <monochrom> Programmers work very hard to code up things, then a math nerd comes along to point out that "it's just a special case of this conceptually simple thing"
2020-10-09 00:09:19 +0200 <dminuoso> proofofme: As a fun excercise, try to think of other tensors and see whether you discover more such monoids.
2020-10-09 00:09:46 +0200 <dminuoso> There's at least three more tensors that yield interesting results.
2020-10-09 00:10:22 +0200 <monochrom> One time I was TAing in a computer graphics course. In terms of coding up ray tracing for example, intersection test for a ray with a sphere is very different from intersection test for a ray with a cube.
2020-10-09 00:10:32 +0200conal(~conal@64.71.133.70)
2020-10-09 00:10:56 +0200 <dminuoso> tomsmeding: I managed a testcase btw: https://gitlab.haskell.org/ghc/ghc/-/issues/18822
2020-10-09 00:11:16 +0200 <monochrom> Then a math prof friend visited the graphics prof, we brought up that, and the math prof friend pointed out "but a cube is just a sphere under a different norm".
2020-10-09 00:11:54 +0200 <dolio> Maybe programmers should have looked at what math people were doing decades before, so they wouldn't have to reinvent it.
2020-10-09 00:12:14 +0200 <dminuoso> dolio: Heh. Or even at what programmers were doing decades before!
2020-10-09 00:12:25 +0200 <dminuoso> Im looking at you, mongodb developers.
2020-10-09 00:12:35 +0200 <dolio> Yeah, that too.
2020-10-09 00:13:23 +0200 <monochrom> I am sympathetic to them, though in disagreement, because as a consequence of the victors writing history, the nosql people never knew that historically databases started out as nosql.
2020-10-09 00:13:23 +0200jespada(~jespada@90.254.245.15) (Ping timeout: 246 seconds)
2020-10-09 00:13:27 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2020-10-09 00:13:58 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311) (Remote host closed the connection)
2020-10-09 00:14:12 +0200 <dminuoso> There's an influx of new programmers, completely oblivious about POSIX, relational algebra, interesting languages...
2020-10-09 00:14:14 +0200conal(~conal@64.71.133.70) (Client Quit)
2020-10-09 00:14:35 +0200 <monochrom> If you tell them the old name "network database" they will totally misunderstand you because they don't know that "network" simply meant pointers back then.
2020-10-09 00:14:58 +0200 <monochrom> (They will think you mean, like, cloud.)
2020-10-09 00:14:59 +0200 <dminuoso> monochrom: If I stare at some of the early steps of MongoDB they are not just repeating it, but repeating it poorly. MongoDB will crash if you use more than 2GiB in your database on a 32 bit architecture.
2020-10-09 00:15:00 +0200 <dolio> If you squint at the 'algebra' thing above, you see that Lawvere invented CPS for algebra 12 years before Steele and Sussman. :)
2020-10-09 00:15:04 +0200conal(~conal@64.71.133.70)
2020-10-09 00:15:11 +0200 <dminuoso> I mean, for a database that's saying quite a lot.
2020-10-09 00:15:20 +0200 <dminuoso> Or the complete lack of any properties of ACID early on
2020-10-09 00:15:46 +0200 <dminuoso> It seemed to have been a "Lets see how hard a database can be, if we dont do any reading and just start writing"
2020-10-09 00:16:58 +0200jespada(~jespada@90.254.245.15)
2020-10-09 00:18:48 +0200 <maralorn> dolio: I say this as a mathematician. Normally people (like physicists, programmers) invent something and then after a few decads mathematicians are like "well what you did is btw. this really simple concept, that we invented motivated by what you did"
2020-10-09 00:19:49 +0200 <monochrom> And while we're at it... I wish I could write "C because (because A, so B)" up there for that sentence that I ended up wording "C because as a consequence of A, B".
2020-10-09 00:20:34 +0200 <monochrom> So the logical structure of what I was saying is: (A therefore B) therefore C. Marvel at the CPS structure! >:)
2020-10-09 00:20:55 +0200mirrorbird(~psutcliff@2a00:801:3f8:10df:3fb2:3ec3:6676:3873)
2020-10-09 00:21:38 +0200 <dolio> maralorn: If I were talking to mathematicians I'd be playing the opposite side. :)
2020-10-09 00:21:58 +0200 <maralorn> ^^
2020-10-09 00:22:27 +0200 <dolio> They just stole our Martin-löf type theory.
2020-10-09 00:22:39 +0200 <maralorn> It's not always like that. But in general I think both sides deserve a lot of credit. And in a world where people tend to idolize abstractness, rigor and brute intelligence. I try to nudge the world view into the direction of valuing intuition, motivation and experience.
2020-10-09 00:22:40 +0200 <monochrom> heh
2020-10-09 00:24:22 +0200 <monochrom> That is a minority world from what I saw.
2020-10-09 00:24:51 +0200 <monochrom> The majority world idolize intuition, experience, and after-the-fact rationalization instead.
2020-10-09 00:25:00 +0200 <monochrom> Just look at politics.
2020-10-09 00:25:43 +0200spew(uid195861@gateway/web/irccloud.com/x-ypeilgetepuhkpyp) (Quit: Connection closed for inactivity)
2020-10-09 00:26:12 +0200 <dolio> I mean, it wasn't long ago that I was talking in here about how mathematicians are all wrong when they tell physicists they 'aren't allowed to do' various stuff with derivatives because it doesn't work in classical analysis or whatever.
2020-10-09 00:26:46 +0200 <dolio> Because they went off and studied something different than what physicists are actually doing, but decided the math was the real thing.
2020-10-09 00:27:30 +0200conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-10-09 00:29:03 +0200conal(~conal@64.71.133.70)
2020-10-09 00:29:13 +0200conal(~conal@64.71.133.70) (Client Quit)
2020-10-09 00:30:28 +0200 <proofofme> So let's say that I have a field of type `Maybe [String]` and want to compare it to elements from input of type [String], and return the index of the first match, if it exists. Would I use mapM_ to accomplish this?
2020-10-09 00:32:21 +0200 <monochrom> No. More like fmap.
2020-10-09 00:32:57 +0200 <monochrom> What does "compare" mean to compare Nothing against ["hello", "hi"] ?
2020-10-09 00:34:33 +0200 <proofofme> Just ["hello", "hi"], yeah?
2020-10-09 00:34:38 +0200 <proofofme> is that what you mean?
2020-10-09 00:34:49 +0200 <dminuoso> So, just out of curiosity proofofme
2020-10-09 00:34:54 +0200 <monochrom> No. You wrote "compare Maybe [String] to [String]".
2020-10-09 00:35:05 +0200 <dminuoso> You dabble in non-trivial category theory but seem to be stuck in the beginning steps of Haskell.
2020-10-09 00:35:11 +0200 <dminuoso> What's your motivation behind learning CT?
2020-10-09 00:35:17 +0200 <monochrom> So I compare Nothing :: Maybe [String] to ["hello", "hi"] :: [String]
2020-10-09 00:35:31 +0200 <maralorn> I read up on the Monads are Monoids in the category of Endofunctors thing. A few years ago I was like "A now I get it.". Now I feel that's like saying "a bycicle is just two wheels with pedals." It's not really wrong but it's a really bad definition and I can think of contraptions that fit the name, that don‘t match at all.
2020-10-09 00:36:29 +0200 <proofofme> My main motivation is personal fulfillment in learning this stuff, but also applying it professionally to write better code, whether it's Haskell or whatever else I'm using.
2020-10-09 00:37:10 +0200 <proofofme> I'm really new at non-trivial Haskell
2020-10-09 00:37:19 +0200 <proofofme> or less-trivial Haskell, I should say
2020-10-09 00:37:31 +0200 <dminuoso> proofofme: My personal recommendation, stay clear of Category Theory then.
2020-10-09 00:37:36 +0200conal(~conal@64.71.133.70)
2020-10-09 00:37:45 +0200 <proofofme> why's that?
2020-10-09 00:37:50 +0200chaosmasttter(~chaosmast@p200300c4a70b40010854fe5f0255a133.dip0.t-ipconnect.de) (Quit: WeeChat 2.9)
2020-10-09 00:37:50 +0200 <koz_> maralorn: This. I especially feel that a lot of people (especially learners) fixate too much on what a monad _is_, and less on 'why we care in the first place'.
2020-10-09 00:37:55 +0200_ashbreeze_(~mark@184-157-33-36.dyn.centurytel.net)
2020-10-09 00:38:07 +0200 <dminuoso> Unless you do this out of personal enjoyment for CT itself, CT has very little bang for bucks in terms of programming.
2020-10-09 00:38:28 +0200 <proofofme> I want to learn CT, abstract algebra, and number theory for my own sake
2020-10-09 00:38:28 +0200 <maralorn> koz_: That also.
2020-10-09 00:38:41 +0200 <dminuoso> While some of the really advanced folks can use it in some particular situations, I dont think one can appreciate even half the stuff unless you happen to be well versed in multiple fields of maths already
2020-10-09 00:39:02 +0200 <dminuoso> proofofme: In that case, dont mind me!
2020-10-09 00:39:11 +0200 <dminuoso> Just wanted to make sure you didn't fall into the trap I (and many others) did. :)
2020-10-09 00:39:28 +0200 <maralorn> koz_: But unless someone can enlighten me in the error of my ways. It now feels like that is not even something a mathematician would say.
2020-10-09 00:39:42 +0200 <dminuoso> Because I learned category theory for the sake of having an easier entry into Haskell. Turned out, I understood the joke `a monad is just..`, went to Haskell, and didn't even understand how to use IO at all.
2020-10-09 00:39:45 +0200 <dminuoso> (True story)
2020-10-09 00:39:58 +0200 <dolio> What isn't?
2020-10-09 00:40:09 +0200 <proofofme> haha I feel that
2020-10-09 00:40:39 +0200 <maralorn> dolio: "Monads are Monoids in the category of Endofunctors"
2020-10-09 00:41:26 +0200 <dolio> maralorn: It's a one-off sentence in Categories for the Working Mathematician, I think.
2020-10-09 00:41:35 +0200Jesin(~Jesin@pool-72-66-101-18.washdc.fios.verizon.net) (Quit: Leaving)
2020-10-09 00:41:46 +0200 <maralorn> Hm
2020-10-09 00:41:53 +0200 <dolio> And for some reason gets quoted all over.
2020-10-09 00:42:17 +0200 <maralorn> But what does "A Monoid in the category C" even mean?
2020-10-09 00:42:37 +0200 <dolio> I think it's quoted somewhere by Wadler, maybe, and that's why it's popular amongst programmers.
2020-10-09 00:42:57 +0200 <dminuoso> maralorn: A monoid (or monoid object) (M, μ, η) in a monoidal category (C, ⊗, I) is an object M together with two morphisms
2020-10-09 00:43:09 +0200 <dminuoso> (I ruthlessly copy pasted it, but I would have said the same thing myself
2020-10-09 00:43:28 +0200 <dminuoso> (well followed by blahblablah(
2020-10-09 00:43:31 +0200 <maralorn> Ah, okay. Fair enough.
2020-10-09 00:43:40 +0200 <dolio> In MacLaine I think it comes at the end of explaining how it works.
2020-10-09 00:44:23 +0200 <dolio> And for Wadler it's a joke that doesn't actually explain anything.
2020-10-09 00:44:51 +0200 <monochrom> The real numbers are just the complete Archimedian ordered field. >:)
2020-10-09 00:44:52 +0200 <maralorn> Then the Wikipedia article is just exceptionally bad at making that point. It even has a [Citation needed] next to the claim …
2020-10-09 00:45:53 +0200 <maralorn> monochrom: Well that is how we defined them in my first semester, so I am okay with that.
2020-10-09 00:45:55 +0200 <dminuoso> maralorn, dolio: According to stackoverflow, the particular joking phrasing is actually from: http://james-iry.blogspot.com/2009/05/brief-incomplete-and-mostly-wrong.html
2020-10-09 00:46:07 +0200 <dminuoso> (With a fictional attribution to Wadler)
2020-10-09 00:46:45 +0200 <dolio> Oh, okay.
2020-10-09 00:46:45 +0200 <dminuoso> And I think that joke is what got it popular, but the joke is sometimes lost
2020-10-09 00:46:56 +0200 <monochrom> Any sufficiently insider joke is indistinguishable from sufficiently advanced knowledge.
2020-10-09 00:47:04 +0200 <dminuoso> monochrom: Haha true.
2020-10-09 00:48:23 +0200 <maralorn> That page doesn‘t load for me. :-(
2020-10-09 00:49:22 +0200 <monochrom> Learning monads is not easy. After successfully learning something challenging, people make jokes for relief. I'm sure this happens in every profession. I'm sure similar nerdy jokes are among accountants, lawyers, medical doctors, everything.
2020-10-09 00:50:17 +0200 <dolio> It seems like the irony of this discussion is that it's not really mathematicians saying it. It's programmers.
2020-10-09 00:50:24 +0200 <monochrom> But when such insider jokes leak out, they sound like words of deep wisdom to beginners, and beginners misbelieve that they must understand them rather than just go "haha" and take it easy.
2020-10-09 00:50:29 +0200 <maralorn> Yeah, there is an evolution of jokes about different math jokes which funnieness depends on your own skilllevel.
2020-10-09 00:50:43 +0200 <maralorn> First you don‘t even get it's a math joke and it's not funny.
2020-10-09 00:51:04 +0200 <dminuoso> I mean to be fair, the core essence of "a monad is just..." is very valuable and ever present in my head.
2020-10-09 00:51:14 +0200 <dminuoso> But it's not the category theory definition that I think about
2020-10-09 00:51:21 +0200 <maralorn> Later you know enough math, to understand it's a joke, but you don‘t know why, so you laugh with the others.
2020-10-09 00:51:36 +0200 <dminuoso> I rather have a visual/mental model of: https://gist.github.com/dminuoso/d5ab4ba5d8a5142dde9f4d4c736e3ecb
2020-10-09 00:51:55 +0200 <maralorn> Then you know barely enough math to understand the joke and you find it hilarious.
2020-10-09 00:52:14 +0200 <dminuoso> Just to address your comment about "this is not even something a mathematician would say"
2020-10-09 00:52:26 +0200heebo(~user@cpc97956-croy24-2-0-cust20.19-2.cable.virginm.net)
2020-10-09 00:53:18 +0200 <maralorn> And some years later the knowledge required seems so basic, that you maybe laugh a little.
2020-10-09 00:54:10 +0200 <monochrom> So, like that one on smbc?
2020-10-09 00:54:13 +0200xsperry(~as@unaffiliated/xsperry) ()
2020-10-09 00:54:19 +0200 <maralorn> dminuoso: Well I was wrong about that. Apparently that sentence has a very precise meaning if you know monoidal categories and a generelized definition of monoid.
2020-10-09 00:54:39 +0200 <monochrom> "Did you know that every sum of two primes is greater than 2"
2020-10-09 00:54:43 +0200 <dolio> It's hard to believe I hadn't heard that quip before 2009, though.
2020-10-09 00:54:55 +0200 <dminuoso> maralorn: I like Saunders Mac Lanes definition more, but I'd rephrase it into:
2020-10-09 00:55:17 +0200 <dminuoso> A monad is a monoid in a monoidal category equipped with endofunctor composition as its tensor.
2020-10-09 00:55:26 +0200 <dminuoso> Err
2020-10-09 00:55:38 +0200 <dminuoso> A monad is a monoid in the monoidal category of endofunctors equipped with endofunctor composition as its tensor.
2020-10-09 00:55:54 +0200 <dolio> I'm going to guess it was only written down somewhere permanent in 2009.
2020-10-09 00:55:55 +0200ryansmccoy(~ryansmcco@193.37.254.27) (Ping timeout: 260 seconds)
2020-10-09 00:56:02 +0200cosimone(~cosimone@93-47-228-249.ip115.fastwebnet.it) (Quit: cosimone)
2020-10-09 00:56:04 +0200 <dminuoso> But really, this is neither the conclusion of some large chunk of text, nor is it a particularly funny joke
2020-10-09 00:56:12 +0200 <dminuoso> So it's pretty valueless
2020-10-09 00:56:27 +0200ryansmccoy(~ryansmcco@193.37.254.27)
2020-10-09 00:56:54 +0200 <heebo> if im using ghcup , hie , haskell language server: whats the best build tool to use , stack or cabal?
2020-10-09 00:56:59 +0200Jesin(~Jesin@pool-72-66-101-18.washdc.fios.verizon.net)
2020-10-09 00:57:00 +0200 <dminuoso> As programmers, I think the kleisli category route to think of programmers is a bit more natural to think of.
2020-10-09 00:57:05 +0200 <hpc> the slightly funnier version goes something like "a monad is a monad in the 2-category of categories"
2020-10-09 00:57:07 +0200 <monochrom> cabal
2020-10-09 00:57:35 +0200 <maralorn> dminuoso: Yeah, that gist makes it very clear. I also think for definition I prefer join over bind.
2020-10-09 00:58:08 +0200zacts(~zacts@dragora/developer/zacts) (Quit: leaving)
2020-10-09 00:58:12 +0200kreetx(~markus@228-90-235-80.dyn.estpak.ee) (Quit: leaving)
2020-10-09 00:58:28 +0200 <dminuoso> I think bind is better to think of.
2020-10-09 00:58:45 +0200 <dminuoso> Then you can think of (<=<) as the principle operation of monads
2020-10-09 00:58:52 +0200 <dminuoso> You get some pretty elegant laws with that
2020-10-09 00:59:09 +0200 <monochrom> I like them both. Both have helped me greatly.
2020-10-09 00:59:14 +0200 <dminuoso> Assoc: f <=< (g <=< h) = (f <=< g) <=< h
2020-10-09 00:59:25 +0200 <dminuoso> Identity: f <=< return = return <=< f = f
2020-10-09 00:59:34 +0200 <maralorn> heebo: Note a) hie is deprecated in favor of haskell-language-server and b) the choice of your build tool is largely orthogonal to the rest of the setup. But c) yeah, I'd also say, cabal.
2020-10-09 00:59:57 +0200 <dminuoso> (All these definitions are of course equivalent)
2020-10-09 01:00:16 +0200 <heebo> thanks, just getting back into things. ill remove my hie setup in favour of hie
2020-10-09 01:00:16 +0200 <monochrom> Oh, my consideration is simply "if you use stack, you would not be with ghcup in the first place"
2020-10-09 01:00:29 +0200 <heebo> er haskell -language server i mean
2020-10-09 01:00:41 +0200 <maralorn> Well that is the monoid Wikipedia claims makes a monad a monoid …
2020-10-09 01:01:05 +0200conal_(~conal@66.115.157.46)
2020-10-09 01:01:09 +0200 <heebo> monochrom: i only used ghcup because its the easiest way to install hls
2020-10-09 01:01:09 +0200 <dminuoso> maralorn: At the very core, monads and monoids are deeply related :)
2020-10-09 01:01:18 +0200 <dminuoso> nclatlab has a slightly different take again
2020-10-09 01:01:19 +0200 <monochrom> Ah
2020-10-09 01:01:44 +0200 <dminuoso> As a handwaving idea: A monad is a structure that is a lot like a monoid, but that lives in a bicategory rather than a monoidal category. In other words, the concept of a monad is a vertical categorification of that of a monoid.
2020-10-09 01:02:15 +0200 <dminuoso> Which connects to hpc's joke earlier
2020-10-09 01:02:18 +0200 <heebo> but i'll get back into cabal i always felt a little uncomfortable with the fact that stack sits on top of cabal and you end up having to maintain cabal files even with a stack setup
2020-10-09 01:02:39 +0200heebo(~user@cpc97956-croy24-2-0-cust20.19-2.cable.virginm.net) ("ERC (IRC client for Emacs 26.2)")
2020-10-09 01:02:41 +0200 <phadej> cabal-install /= Cabal
2020-10-09 01:02:47 +0200conal(~conal@64.71.133.70) (Ping timeout: 240 seconds)
2020-10-09 01:02:48 +0200 <phadej> there is no "cabal" (lowercase ;)
2020-10-09 01:03:07 +0200 <monochrom> We mean cabal-install.
2020-10-09 01:03:24 +0200 <phadej> stack doesn't sit on top of cabal-install
2020-10-09 01:03:28 +0200 <dminuoso> maralorn: My largest revelation was to see how Applicative and Monad were related. How Monad has a very deep sense of "sequencing" in all its definitions (in a very handwaving sense), while Applicative has a sort of "diamond" branching notion to it.
2020-10-09 01:03:33 +0200 <maralorn> phadej: So are they Cabal-files or cabal-install-files?^^
2020-10-09 01:03:40 +0200 <phadej> maralorn: Cabal-files
2020-10-09 01:03:55 +0200 <dminuoso> It made me realize how the Applicative superclass constraint of Monad feels somewhat wrong, because it suggests a relationship that feels more accidental
2020-10-09 01:03:58 +0200 <monochrom> The confusion comes from the executable name "cabal".
2020-10-09 01:04:19 +0200 <phadej> it would be very painful if we had two (or more!) non-interoptible package specification formats
2020-10-09 01:05:06 +0200 <dolio> dminuoso: But do you know that arrows are also related?
2020-10-09 01:05:17 +0200 <dminuoso> dolio: What do you mean?
2020-10-09 01:05:46 +0200 <maralorn> dminuoso: I have seen one or two talks about how you can not introspect a Monad, because in a bind anything can happen.
2020-10-09 01:05:48 +0200 <phadej> dminuoso: it is "accidental", but also always true in the *specific category* of Haskell
2020-10-09 01:05:51 +0200 <phadej> types
2020-10-09 01:05:52 +0200dhouthoo(~dhouthoo@ptr-eiv6509pb4ifhdr9lsd.18120a2.ip6.access.telenet.be) (Quit: WeeChat 2.9)
2020-10-09 01:06:27 +0200 <dolio> dminuoso: Arrows are monoids with respect to profunctor composition (plus an extra thing).
2020-10-09 01:06:46 +0200 <dminuoso> dolio: Arrow is the one abstraction I've never really understood. :)
2020-10-09 01:06:47 +0200leungbk(~user@2605:e000:1315:706:1e77:a69f:2d77:7de4) (Ping timeout: 240 seconds)
2020-10-09 01:06:57 +0200 <dolio> https://homepages.inf.ed.ac.uk/cheunen/publications/2006/arrows/arrows.pdf
2020-10-09 01:06:58 +0200 <maralorn> So for me Functor and Aplicative feel kinda close, whereas Monads are really heavy weight.
2020-10-09 01:07:07 +0200 <phadej> Arrows are very ad-hoc abstraction
2020-10-09 01:07:33 +0200 <phadej> the `arr` doesn't fit.
2020-10-09 01:07:37 +0200 <dminuoso> maralorn: The relationship Im getting at, is that each Monad induces a trivial Applicative instance, rather than "Applicative being a sort of precursor to Monad"
2020-10-09 01:08:44 +0200 <dminuoso> dolio: Cheers! A very brief skim suggests this should be readable with my expertise. Ill crunch that on the weekend
2020-10-09 01:09:33 +0200 <maralorn> dminuoso: I am not sure I understand. Each Monoid induces a trivial Semigroup instance sounds to me nearly equivalent to "Semigroup being a sort of precursor to Monoid"
2020-10-09 01:09:46 +0200siloxid(~user@unaffiliated/siloxid)
2020-10-09 01:09:58 +0200 <phadej> maralorn: not true.
2020-10-09 01:10:02 +0200 <dolio> It won't make arrows any more relevant, but it's an amusing fact.
2020-10-09 01:10:08 +0200 <phadej> Monoid is "Semigroup + unit"
2020-10-09 01:10:19 +0200 <phadej> but (<*>) and (>>=) are very different
2020-10-09 01:10:43 +0200Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi) (Ping timeout: 260 seconds)
2020-10-09 01:10:46 +0200 <phadej> or liftA2 (,) and join -- if you look for more "categorical" members
2020-10-09 01:10:49 +0200 <maralorn> Ah, okay.
2020-10-09 01:11:07 +0200 <monochrom> What is "precursor"? Does it carry a historical view, or is it simply logical subsumption?
2020-10-09 01:11:34 +0200 <monochrom> or something a bit different from both?
2020-10-09 01:11:54 +0200 <maralorn> You are saying we could give a different applicative instance for a Monad, but having another semigroup for a monoid would just violate the definition.
2020-10-09 01:12:04 +0200 <dminuoso> monochrom: Just a handwaving term
2020-10-09 01:12:11 +0200 <phadej> maralorn: in Haskell no
2020-10-09 01:12:43 +0200revprez_1nzio(~revprez_a@pool-108-49-213-40.bstnma.fios.verizon.net) (Ping timeout: 260 seconds)
2020-10-09 01:12:57 +0200redmynk(~redmynk@2804:1b2:180:5c13:a8b7:4418:5b7e:8baa)
2020-10-09 01:13:23 +0200 <maralorn> phadej: Because of the choosen hierarchy and the laws to combine them?
2020-10-09 01:13:24 +0200 <dolio> But there are other semigroup structures on various monoids. They're just not the one used in the monoid.
2020-10-09 01:13:27 +0200 <phadej> but I think that in some category there could be Applicative-like things and Monad-like things for some functor, which aren't compatible
2020-10-09 01:13:31 +0200revprez_anzio(~revprez_a@pool-108-49-213-40.bstnma.fios.verizon.net)
2020-10-09 01:14:00 +0200 <phadej> dolio: monoid is (carrier set, <>, mempty)
2020-10-09 01:14:14 +0200 <dminuoso> maralorn: What Im about to say requires some long thinking and building up intuition to make real sense, so take this with a grain of salt and not too literally.
2020-10-09 01:14:14 +0200 <dolio> I know what a monoid is.
2020-10-09 01:15:24 +0200 <phadej> there are different applicative strucures for `f` in Haskell too, ZipList and ordinary [] instance
2020-10-09 01:15:44 +0200 <dminuoso> maralorn: Monad is somehow about `sequencing` (and I mean this more abstract than just effects). Applicative otoh is rather a diamond that branches in parallel and joins again.
2020-10-09 01:15:45 +0200 <phadej> but having them different won't be very good idea
2020-10-09 01:16:15 +0200 <phadej> i.e. if Applicative weren't superclass of Monad, and Applicative [] were ZipList like
2020-10-09 01:16:26 +0200 <maralorn> I have to say in the last few weeks I kinda got the impression, that having a monoid class was a mistake. I have observed multiple occasions where people assumed the wrong of multiple possible monoid instances for some type and got subtle bugs because of that.
2020-10-09 01:16:44 +0200 <dminuoso> maralorn: The fact that Applicative usually carries "sequencing semantics" arises from the fact that the superclass constraint demands the Applicative instance and Monad instance be coherent. So as long as we have a Monad instance, the Applicative diamond is a sort of "go left side, and *then* to right side, and *then* join together"
2020-10-09 01:17:09 +0200 <dminuoso> These coherence rules exist for good reasons, but they do lead to Applicative looking too much like Monad most of the time.
2020-10-09 01:17:18 +0200 <dolio> No, Applicative is about sequencing, because it's not commutative.
2020-10-09 01:19:40 +0200 <dminuoso> dolio: Can you elaborate?
2020-10-09 01:19:50 +0200 <phadej> it can be commutative though :)
2020-10-09 01:20:19 +0200 <maralorn> e.g. (<>) :: (a -> a) -> (a -> a)
2020-10-09 01:20:39 +0200 <phadej> f <*> x can be (&) <$> x <*> f
2020-10-09 01:21:33 +0200 <dolio> Monads can be commutative.
2020-10-09 01:21:59 +0200 <phadej> you cannot really do `k` "first" in `m >>= k`
2020-10-09 01:22:05 +0200 <phadej> there is dependency
2020-10-09 01:22:14 +0200 <phadej> and I think that's what is dminuoso is after
2020-10-09 01:22:27 +0200 <phadej> being too pedantic doens't help
2020-10-09 01:22:59 +0200 <dminuoso> As a particular example, Haxl is a real-world example of how Applicatives let you explore parallel code.
2020-10-09 01:24:12 +0200 <dolio> It is an over-generalization to say that Applicative is "about" the use case of haxl.
2020-10-09 01:24:31 +0200 <phadej> I don't think it's too far fetched
2020-10-09 01:24:42 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 01:24:55 +0200 <phadej> most intersting Applicative usages are exploiting the interspectability of Applicative computations
2020-10-09 01:24:58 +0200nineonine(~nineonine@216.81.48.202) (Remote host closed the connection)
2020-10-09 01:25:11 +0200 <phadej> haxl is very aggressive, so in a sense a good example
2020-10-09 01:25:27 +0200 <phadej> optparse-applicative is another one, less controversial maybe
2020-10-09 01:26:07 +0200 <dminuoso> Overall, Applicative seems very underused. Mostly, we just use the convenient interface of `ap` but with Monad semantics.
2020-10-09 01:26:34 +0200 <dminuoso> At least for non-library writers.
2020-10-09 01:27:22 +0200 <phadej> there aren't many non-Monad Applicatives
2020-10-09 01:27:28 +0200 <dminuoso> It's pretty much that coherence law I referenced earlier that mostly puts Applicative into the shadows
2020-10-09 01:27:30 +0200leungbk(~user@cpe-104-33-52-83.socal.res.rr.com)
2020-10-09 01:27:36 +0200 <maralorn> There should be a significant difference between applicative parsers and monodal parsers, right?
2020-10-09 01:27:57 +0200 <maralorn> An applicative parser might be much better optimizable?
2020-10-09 01:27:58 +0200leungbk(~user@cpe-104-33-52-83.socal.res.rr.com) (Remote host closed the connection)
2020-10-09 01:28:06 +0200 <phadej> maralorn: Applicative parsers is regex-applicative
2020-10-09 01:28:10 +0200 <dolio> Anyhow, the commutative point is that Applicative allows for things where `f <*> x` is not the same as `x <**> f` (assuming I got that right). This means that there is a well-defined sequence that the operations have been combined in, even if the semantics decide that is irrelevant.
2020-10-09 01:28:13 +0200 <dminuoso> maralorn: Better yet, parsers based on selective functors!
2020-10-09 01:28:27 +0200 <dminuoso> (selective functors are a breed between monadic and applicative)
2020-10-09 01:28:43 +0200 <dminuoso> With selective parsers, you get static analyzability but dynamic choices of subsequent effects. :)
2020-10-09 01:29:02 +0200 <phadej> with observable equality (to recognise recursion) you get CFG (check Earley)
2020-10-09 01:29:05 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 240 seconds)
2020-10-09 01:30:25 +0200frdg(47b88ff9@pool-71-184-143-249.bstnma.fios.verizon.net) (Remote host closed the connection)
2020-10-09 01:30:42 +0200 <dminuoso> If I can convince my employer to spend a few weeks, I'd love to make a optparse-selective.
2020-10-09 01:32:31 +0200 <dminuoso> dolio: I see, well, I'd rather consider that a case of "associativity" than "sequencing" in some abtract sense.
2020-10-09 01:32:44 +0200 <dolio> I'm not even sure the characterization makes sense with Haxl, because the 'join' part is monad, right?
2020-10-09 01:33:01 +0200 <phadej> dminuoso: what would you need selective power for there?
2020-10-09 01:33:12 +0200 <dolio> Sequences are the primordial associative structure.
2020-10-09 01:33:39 +0200GyroW_(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-09 01:33:55 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-09 01:33:55 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-09 01:33:55 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-09 01:34:27 +0200 <dolio> Anyhow, I could maybe agree that Applicative is about sequences of things, and Monad is about nested things, and what Haxl does is take advantage that you can parallelize sequences of things.
2020-10-09 01:34:43 +0200 <dminuoso> phadej: Oh just parsing differently depending on previous flags. Nothing too fancy really
2020-10-09 01:34:54 +0200vicfred(~vicfred@unaffiliated/vicfred)
2020-10-09 01:34:58 +0200frdg(47b88ff9@pool-71-184-143-249.bstnma.fios.verizon.net)
2020-10-09 01:35:14 +0200 <dminuoso> It was mostly just "would be nice to have this" cases.
2020-10-09 01:36:00 +0200acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 272 seconds)
2020-10-09 01:36:44 +0200jedws(~jedws@121.209.161.98)
2020-10-09 01:37:07 +0200 <dminuoso> dolio: At the end this has become a discussion about what particular intutions/mind models we have adapted. My mind model is based on thinking of `Day` and (:.:), or (<*>) and (>>=). One comes with a sequencing of effects, data dependencies, the other does not.
2020-10-09 01:37:21 +0200 <maralorn> Is there an applicative or selective parsing library?
2020-10-09 01:37:36 +0200 <dminuoso> maralorn: optparse-applicative is an applicative option parsing library
2020-10-09 01:37:44 +0200 <dminuoso> https://github.com/J-mie6/ParsleyHaskell
2020-10-09 01:38:14 +0200 <dminuoso> Is an example of a selective parser combinator library that analyzes and optimizes your parser in TH.
2020-10-09 01:38:18 +0200ClaudiusMaximus(~claude@unaffiliated/claudiusmaximus) (Quit: ->)
2020-10-09 01:38:53 +0200acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2020-10-09 01:39:08 +0200 <maralorn> I think you can‘t have a lift instance for monadic parsers, is that right?
2020-10-09 01:40:32 +0200 <maralorn> Wait that repo has no README and is not on hackage? :-(
2020-10-09 01:40:39 +0200 <dminuoso> dolio: So what you mentioned about non-commutative applicatives, I realized my mistake. So I'd say you still have conceptual parallel branching, but the combination of results has some sequencing yes.
2020-10-09 01:40:40 +0200conal_(~conal@66.115.157.46) (Quit: Computer has gone to sleep.)
2020-10-09 01:40:55 +0200 <dminuoso> But based on that, I would not go as far as saying that "sequencing is the defining characteristic of applicative"
2020-10-09 01:41:30 +0200 <dminuoso> Consider:
2020-10-09 01:41:54 +0200 <dolio> The whole difference between `f <*> x` and `x <**> f` in a non-commutative Applicative is that it won't in general be combining the same 'results'.
2020-10-09 01:41:55 +0200 <dminuoso> We could think of Applicative as being desribed by `f a -> f b -> f (a, b)` as its signature method
2020-10-09 01:42:12 +0200 <dminuoso> So yeah, there's a clear ordering in the tuple, but the core essence lies in what happens with the `f`
2020-10-09 01:42:18 +0200 <ghoulguy> If we wanted to speculate on the defining characteristic we could start by staring at the free structure: http://hackage.haskell.org/package/free-5.1.4/docs/Control-Applicative-Free.html#t:Ap
2020-10-09 01:42:56 +0200 <dminuoso> So `f a -> f b -> f (a, b)` suggests potential branching as opposed to linear data dependencies. static effects as opposed to dynamic effects.
2020-10-09 01:43:02 +0200 <ghoulguy> it's a sequence of primitives
2020-10-09 01:43:10 +0200 <ghoulguy> the branching doesn't matter because of the associative-like law
2020-10-09 01:43:37 +0200 <ghoulguy> I'm late to to the party so you might already be past that
2020-10-09 01:44:32 +0200 <ghoulguy> it's an ordered sequence of some primitives combined with a pure function to make all the type-indexes match up
2020-10-09 01:44:45 +0200xff0x(~fox@2001:1a81:53a8:5900:4dd1:b846:131b:3964) (Ping timeout: 272 seconds)
2020-10-09 01:45:15 +0200xff0x(~fox@2001:1a81:53a8:5900:18dc:5fd3:ab0c:ba1c)
2020-10-09 01:45:24 +0200 <dminuoso> sure, that's just paraphrasing what dolio just said though with more elaborate terms. :)
2020-10-09 01:45:25 +0200proofofme(~proofofme@184-96-74-65.hlrn.qwest.net) (Remote host closed the connection)
2020-10-09 01:45:33 +0200 <ghoulguy> oh, maybe that means dolio is right!
2020-10-09 01:45:56 +0200MVQq(~anja@198.254.202.72) (Quit: q)
2020-10-09 01:46:09 +0200 <dminuoso> Well, you are still free to interpret these in parallel
2020-10-09 01:46:24 +0200 <dminuoso> Or you could interpret the right first, then the left..
2020-10-09 01:46:30 +0200MarcelineVQ(~anja@198.254.202.72)
2020-10-09 01:46:39 +0200 <dminuoso> There's nothing about it that forces you into an effect order
2020-10-09 01:46:56 +0200 <dminuoso> Yes, at the end you have a particular ordering in which you combine the results again
2020-10-09 01:47:12 +0200 <dminuoso> Ap could have also been defined as
2020-10-09 01:47:16 +0200 <dolio> If Applicatives are 'about' parallelism, why are there so many examples where you can't do them in parallel, because the order matters?
2020-10-09 01:47:25 +0200 <dminuoso> Ap :: f a -> Ap f b -> Ap f (a, b)
2020-10-09 01:47:35 +0200 <ghoulguy> Some applicatives allow you to work in parallel, but that's not inherent to applicatives
2020-10-09 01:47:47 +0200 <dminuoso> dolio: Because most of the time you have a Monad instance, and then the coherence laws matter.
2020-10-09 01:47:50 +0200 <dolio> Shouldn't those be illegal?
2020-10-09 01:48:01 +0200 <dminuoso> And it's the coherence laws that force the Applicative to have the Monad semantics.
2020-10-09 01:48:14 +0200 <dminuoso> And the monad itself is inherently sequenced because of that data dependency in (>>=)
2020-10-09 01:48:42 +0200 <dminuoso> dolio: That's a bit more extreme than what I suggested, but yeah, that's the crux of it!
2020-10-09 01:48:57 +0200 <dminuoso> They are just trivial instances induced by the monad
2020-10-09 01:48:59 +0200 <dolio> What's the proof that there area no non-monad Applicatives where ordering matters?
2020-10-09 01:49:38 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-09 01:49:45 +0200 <dminuoso> Look, I think you're taking this a bit too exact.
2020-10-09 01:50:02 +0200 <dminuoso> % :t (<*>)
2020-10-09 01:50:03 +0200 <yahb> dminuoso: Applicative f => f (a -> b) -> f a -> f b
2020-10-09 01:50:31 +0200 <dminuoso> This f has no sequencing built into its type
2020-10-09 01:50:46 +0200 <dminuoso> And if we stare at Day we see this deeper again
2020-10-09 01:50:49 +0200 <c_wraith> There are monads where the order doesn't matter outside of the data dependency. Maybe, for instance.
2020-10-09 01:50:51 +0200 <dolio> I think I used one recently, actually. It was basically state composed with writer.
2020-10-09 01:50:51 +0200 <dminuoso> % data Day f g a where Day :: f x -> g y -> (x -> y -> a) -> Day f g a
2020-10-09 01:50:52 +0200 <yahb> dminuoso:
2020-10-09 01:50:58 +0200 <ghoulguy> Monad doesn't even enforce an "effect order" which is how we get the reverse state examples
2020-10-09 01:51:05 +0200 <dminuoso> ghoulguy: Of course they do!
2020-10-09 01:51:07 +0200 <dminuoso> % :t (>>=)
2020-10-09 01:51:07 +0200 <yahb> dminuoso: Monad m => m a -> (a -> m b) -> m b
2020-10-09 01:51:13 +0200 <dminuoso> It's buried right into the type here.
2020-10-09 01:51:28 +0200 <dolio> Also the one people use that collects multiple error messages.
2020-10-09 01:51:29 +0200 <dminuoso> You cant run `m b` without having an `a` to begin with
2020-10-09 01:51:29 +0200 <c_wraith> Reader and Identity for the trivial examples
2020-10-09 01:51:45 +0200 <c_wraith> dminuoso: Proxy?
2020-10-09 01:51:54 +0200 <ghoulguy> dminuoso: who said I had to "run" m a to get an a?
2020-10-09 01:52:07 +0200 <ghoulguy> It's my m
2020-10-09 01:52:33 +0200 <dolio> There were people a while back talking about a sub-monad of IO that could have its operations re-ordered, too.
2020-10-09 01:52:49 +0200 <dolio> ACIO or something.
2020-10-09 01:53:05 +0200 <c_wraith> > undefined >>= undefined :: Proxy ()
2020-10-09 01:53:08 +0200 <lambdabot> Proxy
2020-10-09 01:53:09 +0200g-belmonte(~g-belmont@2804:14c:8786:9312:3638:eaf5:dc36:146d)
2020-10-09 01:53:35 +0200 <ghoulguy> dminuoso: I think you're making too much out of the data dependency suggested by the type of (>>=) and the lack of that same obvious data dependency in (<*>)
2020-10-09 01:53:37 +0200 <c_wraith> no values of a, b, Proxy a, or Proxy b
2020-10-09 01:53:47 +0200 <c_wraith> (as inputs, anyway)
2020-10-09 01:53:57 +0200 <dminuoso> ghoulguy: Let's take another approach then.
2020-10-09 01:54:10 +0200 <dminuoso> Can we agree that the signature method of Monad is `m :.: m ~> m` ?
2020-10-09 01:54:27 +0200ericsagnes(~ericsagne@2405:6580:0:5100:1c60:69e9:f30b:d7e8) (Ping timeout: 260 seconds)
2020-10-09 01:54:31 +0200 <dminuoso> And equivalently the signature method of Applicative is: m `Day` m ~> m ?
2020-10-09 01:54:50 +0200 <dminuoso> (Perhaps I shouldnt have used backticks in the first example, that seems mildly confusing)
2020-10-09 01:55:21 +0200 <maralorn> :t Day
2020-10-09 01:55:23 +0200 <lambdabot> error: Data constructor not in scope: Day
2020-10-09 01:55:28 +0200 <dminuoso> % data Day f g a where Day :: f x -> g y -> (x -> y -> a) -> Day f g a
2020-10-09 01:55:28 +0200 <yahb> dminuoso:
2020-10-09 01:55:33 +0200 <maralorn> % :t Day
2020-10-09 01:55:34 +0200 <yahb> maralorn: f x -> g y -> (x -> y -> a) -> Day f g a
2020-10-09 01:56:07 +0200 <maralorn> Why is it called Day?
2020-10-09 01:56:28 +0200 <dminuoso> maralorn: It's named after Brian Day who introduced the day convolution.
2020-10-09 01:56:45 +0200 <maralorn> huh
2020-10-09 01:56:47 +0200falafel(~falafel@2605:e000:1527:d491:1ccf:5c8d:7928:e9cc) (Ping timeout: 260 seconds)
2020-10-09 01:57:58 +0200 <dminuoso> ghoulguy: The abstract, handwaving, sequencing (of effects) semantics are buried into (:.:). If we think of functors as effects in Haskell, the (associative) composition of two functors is almost literally the sequencing of two effects.
2020-10-09 01:58:01 +0200conal(~conal@66.115.157.46)
2020-10-09 01:59:39 +0200 <dolio> You know, GHC does not guarantee that IORef reads/writes appear to happen in a certain order, or even a possible interleaving of orders.
2020-10-09 01:59:44 +0200 <dolio> I made a model of it in Agda.
2020-10-09 02:00:01 +0200frank001(~frank001@178.162.212.214) ()
2020-10-09 02:00:11 +0200 <nshepperd1> you mean concurrent read/writes?
2020-10-09 02:00:17 +0200 <dolio> Yeah.
2020-10-09 02:00:23 +0200 <dminuoso> dolio: Heh, Im waiting for conal to appear and make some note about "IO monad is not even wrong because it has no denotation". :p
2020-10-09 02:00:31 +0200polyrain(~polyrain@2001:8003:e501:6901:d439:cec4:3811:73e4)
2020-10-09 02:00:42 +0200 <dolio> Well, he'd be wrong about that.
2020-10-09 02:01:13 +0200 <nshepperd1> huh, I'd expect sequential consistency in the absence of documentation saying there isn't sequential consistency
2020-10-09 02:01:24 +0200 <dolio> It says there may not be.
2020-10-09 02:01:29 +0200 <dminuoso> Your point about IORef is interesting, does GHC actually reorder them?
2020-10-09 02:01:30 +0200 <dolio> That's how I know about it.
2020-10-09 02:01:36 +0200 <dolio> No, the CPU does.
2020-10-09 02:01:39 +0200 <dminuoso> Oh
2020-10-09 02:02:05 +0200conal(~conal@66.115.157.46) (Client Quit)
2020-10-09 02:02:08 +0200 <dminuoso> You mean `writeIORef f 1 >> writeIORef f 2` could leave me with `1`?
2020-10-09 02:02:21 +0200 <dolio> No, it's more complicated than that.
2020-10-09 02:02:35 +0200frdg(47b88ff9@pool-71-184-143-249.bstnma.fios.verizon.net) (Remote host closed the connection)
2020-10-09 02:02:50 +0200 <maralorn> It's worse on ARM, right?
2020-10-09 02:02:52 +0200 <dolio> That one would be pretty bad.
2020-10-09 02:02:55 +0200 <monochrom> No. But funny things happen when one thread goes "write to x; read from y; write to y" and another thread is also playing with x and y.
2020-10-09 02:03:06 +0200 <nshepperd1> https://hackage.haskell.org/package/base-4.14.0.0/docs/Data-IORef.html#g:2 ah
2020-10-09 02:03:10 +0200 <dminuoso> Oh if its just that..
2020-10-09 02:03:21 +0200 <dminuoso> I see
2020-10-09 02:03:36 +0200 <dminuoso> That seems expected
2020-10-09 02:03:53 +0200 <monochrom> CPU can look at 1st thread and say "looks like x and y are independent, I can change it to "read from y; write to y; write to x""
2020-10-09 02:03:58 +0200emmanuel_erc(~user@2604:2000:1382:ce03:6c74:afa7:7b91:b469) (Remote host closed the connection)
2020-10-09 02:04:02 +0200 <dolio> Anyhow, IO is an algebra, and the machine is the model, and does what it wants.
2020-10-09 02:04:04 +0200 <nshepperd1> well i guess that's fine since you'll probably use tvar for concurrent stuff anyway
2020-10-09 02:04:08 +0200 <dminuoso> monochrom: Yeah, but that's just memory
2020-10-09 02:04:09 +0200emmanuel_erc(~user@2604:2000:1382:ce03:ddc4:166d:60ea:ae29)
2020-10-09 02:04:11 +0200 <dminuoso> Nothing fancy here
2020-10-09 02:04:13 +0200 <monochrom> If the 2nd thread has assumptions about 1st thread's order, it's toasted.
2020-10-09 02:04:15 +0200conal(~conal@66.115.157.46)
2020-10-09 02:04:32 +0200 <monochrom> I think the IORef doc has a better example than mine.
2020-10-09 02:04:34 +0200 <nshepperd1> or use atomicModifyIORef if you're a masochist
2020-10-09 02:04:44 +0200 <monochrom> And then starts rambling about memory barriers
2020-10-09 02:05:09 +0200 <monochrom> Oh, two IORefs have to be involved, so atomicModifyIORef is beside the point.
2020-10-09 02:06:28 +0200 <nshepperd1> except for the memory barrier rambling
2020-10-09 02:06:31 +0200 <dminuoso> Haha, reminds me of C and how endless programmers use volatile thinking it helps with memory orderings.
2020-10-09 02:06:35 +0200ericsagnes(~ericsagne@2405:6580:0:5100:841d:b2f8:a54e:9827)
2020-10-09 02:06:57 +0200 <dolio> Someone was saying that in here the other day.
2020-10-09 02:06:57 +0200 <monochrom> https://downloads.haskell.org/~ghc/8.10.2/docs/html/libraries/base-4.14.1.0/Data-IORef.html#g:2
2020-10-09 02:07:25 +0200 <dolio> I decided to go read the C specification, and it didn't say anything about how much a pointer dereference or assignment costs.
2020-10-09 02:07:49 +0200 <nshepperd1> The c specification barely says anything
2020-10-09 02:07:57 +0200 <monochrom> Well, "rambling" is my view, I have this very purist opinion that if you need memory barriers you're abusing mutable shared variables.
2020-10-09 02:08:06 +0200 <dolio> It's pretty long for not saying anything.
2020-10-09 02:08:29 +0200 <dminuoso> nshepperd1: It says quite a lot, just not the things you hope it says.
2020-10-09 02:08:32 +0200 <c_wraith> It says lots of things that turn out to not be useful
2020-10-09 02:08:49 +0200 <nshepperd1> perhaps the c specification should run for political office
2020-10-09 02:08:52 +0200 <monochrom> I think setting out a grammar is useful.
2020-10-09 02:09:14 +0200remexre(~nathan@207-153-38-50.fttp.usinternet.com) (Quit: WeeChat 2.9)
2020-10-09 02:10:19 +0200 <dolio> Even the grammar parts are pretty amazing. Like, there could be a 'type too big' error.
2020-10-09 02:10:20 +0200 <monochrom> The Haskell Report isn't all that better either.
2020-10-09 02:10:21 +0200siloxid(~user@unaffiliated/siloxid) (Remote host closed the connection)
2020-10-09 02:10:48 +0200 <dolio> No, I wanted to make sure the C one wasn't significantly better than the Haskell one, like was claimed.
2020-10-09 02:11:23 +0200 <dolio> Like Haskell, most of what it talks about is 'what' and not 'how'.
2020-10-09 02:12:47 +0200emmanuel_erc(~user@2604:2000:1382:ce03:ddc4:166d:60ea:ae29) (Ping timeout: 240 seconds)
2020-10-09 02:13:15 +0200 <koz_> dolio: In many cases for the C Standard, that 'what' is followed by 'the fuck'.
2020-10-09 02:13:19 +0200 <dolio> I had to read the '17 one, though, because the '18 one was like $100. Maybe it's much improved.
2020-10-09 02:13:26 +0200emmanuel_erc(~user@2604:2000:1382:ce03:ddc4:166d:60ea:ae29)
2020-10-09 02:13:43 +0200 <koz_> (apologies if I broke any channel norms)
2020-10-09 02:14:02 +0200 <monochrom> hehe
2020-10-09 02:14:36 +0200 <dolio> I was surprised at how little was specified about the floating point numbers.
2020-10-09 02:15:42 +0200 <koz_> dolio: Yeah, contrary to popular belief, the C standard requires IEEE 754 precisely nowhere.
2020-10-09 02:15:49 +0200 <koz_> (C++ I believe does, or at least nowadays)
2020-10-09 02:16:00 +0200 <dolio> Maybe ISO doesn't want to pay royalties.
2020-10-09 02:16:04 +0200 <koz_> But then again, C doesn't even require integer representations to be 2s comp.
2020-10-09 02:16:10 +0200 <koz_> (again, C++ does, as of recently)
2020-10-09 02:16:48 +0200 <dolio> Yeah. I could see how to really play games with an implementation. You can use sign-and-magnitude with as many padding bits as you want, etc.
2020-10-09 02:16:57 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311)
2020-10-09 02:17:33 +0200 <justsomeguy> If I want to define a default class method, do I put the term-level implementation of that method directly in the type class?
2020-10-09 02:17:40 +0200 <koz_> Also, again contrary to popular belief, char doesn't have to be 8 bits.
2020-10-09 02:17:50 +0200 <monochrom> That's too easy. Unless you use, like, a dynamically determined middle bit position for the sign bit.
2020-10-09 02:17:54 +0200 <koz_> (it has to be at least 7, and nothing else can be smaller than it, but otherwise, go nuts)
2020-10-09 02:18:11 +0200 <koz_> (there are legit computers for sale _today_ which have 9-bit chars)
2020-10-09 02:18:11 +0200 <dolio> Yeah.
2020-10-09 02:18:40 +0200 <koz_> justsomeguy: Yeah, it goes under the type signature in the class definition, as if you were just writing a normal function.
2020-10-09 02:19:37 +0200 <koz_> Ultimate implementation trolling - x86_64, every type is 64 bits wide.
2020-10-09 02:19:44 +0200 <justsomeguy> koz_: Hmm, ok. I'll try that out.
2020-10-09 02:19:46 +0200 <koz_> (well, not _that_ ultimate)
2020-10-09 02:19:50 +0200 <koz_> (but it'd be funny)
2020-10-09 02:19:55 +0200 <dolio> 64bits is too fast.
2020-10-09 02:20:19 +0200 <monochrom> GHC comes close to that. Every type is a multiple of 64 bits wide.
2020-10-09 02:20:25 +0200 <koz_> Something something Atari Jaguar.
2020-10-09 02:20:37 +0200 <monochrom> Err I guess not really "every".
2020-10-09 02:20:42 +0200Wolfy87(~Wolfy87@s91904426.blix.com)
2020-10-09 02:21:22 +0200 <monochrom> But for example Word8 is 64 bits for the data constructor, 64 bits for the number.
2020-10-09 02:22:17 +0200 <koz_> WordNotReally8.
2020-10-09 02:22:30 +0200 <maralorn> I love how this conversation has drifted from CT to processor behavior.
2020-10-09 02:22:33 +0200 <{abby}> Word8, the "12" is silent
2020-10-09 02:23:03 +0200 <koz_> Maybe it's actually short for 'WordMultipleOf8'?
2020-10-09 02:23:23 +0200 <koz_> maralorn: This is how we roll.
2020-10-09 02:23:46 +0200 <monochrom> Nah, the real explanation is really boring. Alignment-friendly.
2020-10-09 02:24:01 +0200emmanuel_erc(~user@2604:2000:1382:ce03:ddc4:166d:60ea:ae29) (Ping timeout: 272 seconds)
2020-10-09 02:24:08 +0200 <koz_> monochrom: Yeah, but I can dream!
2020-10-09 02:24:51 +0200 <monochrom> Right? In popular C implementations, if you malloc(1) you expect alignment to ruin it and you're wasiting at least 7 bytes, too.
2020-10-09 02:25:31 +0200 <koz_> Not if you have 64-bit char!
2020-10-09 02:26:04 +0200 <monochrom> That's going to be interesting.
2020-10-09 02:26:10 +0200 <koz_> UTF-64 lolol.
2020-10-09 02:26:27 +0200 <monochrom> For, one thing the C standard does require very clearly, is "sizeof(char) = 1".
2020-10-09 02:26:42 +0200 <koz_> Yes, but 1 can be whatever bit count you want.
2020-10-09 02:26:49 +0200 <koz_> As long as it's at least 7.
2020-10-09 02:27:35 +0200 <koz_> You are within your rights as an implementer to decide that sizeof(char) == sizeof(short int) == sizeof(int) == sizeof(long int) == sizeof(long long int)
2020-10-09 02:27:47 +0200 <monochrom> Yeah, so it's interesting in blowing up the proportion of most people's expectations.
2020-10-09 02:28:55 +0200 <koz_> I also believe, though I am unsure, that sizeof(float) == sizeof(double) is legal.
2020-10-09 02:29:25 +0200 <spinnylights> i might be the voice against the choir here a bit but i think the relative vagueness of the c standard is reasonable :P c code needs to compile for a huge variety of different hardware with widely varying characteristics, and if the standard was too specific it would cut certain platforms out
2020-10-09 02:29:41 +0200 <dolio> Yeah, the person a few days ago was lamenting the Haskell report saying "you should expect a reasonable graph reduction algorithm" or something. But the C spec is full of those kind of 'reasonable expectation' things that don't technically hold force.
2020-10-09 02:29:47 +0200 <koz_> spinnylights: Yeah, but the POSIX standard is _much_ more restrictive and somehow nobody's died yet.
2020-10-09 02:30:10 +0200 <koz_> Back the 80s it was an architectural wild west.
2020-10-09 02:30:11 +0200 <spinnylights> yes but POSIX-compliant operating systems don't run on as wide a variety of hardware as any given c code
2020-10-09 02:30:13 +0200 <koz_> Implementational too.
2020-10-09 02:30:21 +0200 <koz_> Nowadays it's _way_ more convergent.
2020-10-09 02:30:29 +0200nineonine(~nineonine@216-19-190-182.dyn.novuscom.net)
2020-10-09 02:30:52 +0200 <koz_> dolio: The only reasonable expectation one can have vis a vis C is that you're invoking UB.
2020-10-09 02:31:08 +0200 <koz_> Since there's like, over 100 sources of UB, some of which are highly surprising and almost impossible to guard against.
2020-10-09 02:31:28 +0200 <koz_> (I've been bitten by a few, and I do not see how you can possibly ensure you don't violate them in general)
2020-10-09 02:31:34 +0200 <spinnylights> people write c to control factory equipment, small appliances, etc. etc.—if you look at the implementation for the specific hardware you're targeting it's generally much more precise about its behavior than the standard is
2020-10-09 02:31:37 +0200psygate(~psygate@unaffiliated/psygate) (Ping timeout: 272 seconds)
2020-10-09 02:32:04 +0200 <spinnylights> i think that's basically by design
2020-10-09 02:32:40 +0200 <koz_> spinnylights: And I believe said design is absolutely bonkers. The way the standard defines 'portability' translates to 'compiler writers should have the easiest job defining conformant implementations'.
2020-10-09 02:32:51 +0200 <koz_> Which I argue is literally not how _anyone_ else views 'portability'.
2020-10-09 02:33:22 +0200 <dolio> I have no real beef with the C standard. But the context was a claim that the standard was/needed to be precise, not the implementation.
2020-10-09 02:34:10 +0200 <dolio> I mean, the implementation needs to be precise, of course, but that that isn't good enough.
2020-10-09 02:34:18 +0200 <spinnylights> i don't think portability is as high a priority for c as it is for c++, in the sense that you mean; a lot of the places where c is used, the alternative would be some assembly language, and it's being used for ease of programming, not portability
2020-10-09 02:34:55 +0200 <spinnylights> c code like that might be portable over some specific class of hardware but it's not usually meant to even run on PCs
2020-10-09 02:34:58 +0200 <koz_> spinnylights: Then what's the point of the standard?
2020-10-09 02:35:18 +0200 <spinnylights> if you _do_ need to write portable c code, it's there for you
2020-10-09 02:35:18 +0200nineonine(~nineonine@216-19-190-182.dyn.novuscom.net) (Ping timeout: 260 seconds)
2020-10-09 02:35:31 +0200 <spinnylights> it's good to be able to know what's portable and what's implementation-specific
2020-10-09 02:35:43 +0200 <spinnylights> plus, without it compiler writers wouldn't know what to do :P
2020-10-09 02:35:51 +0200 <koz_> Which translates essentially to 'essentially nothing' and 'essentially everything'.
2020-10-09 02:36:07 +0200 <koz_> And I _really_ question the last assertion, considering that most languages lack anything like a standard and their authors seem to be just fine.
2020-10-09 02:36:13 +0200shatriff(~vitaliish@78.111.190.16)
2020-10-09 02:36:21 +0200 <koz_> Or certainly no worse than the authors of compilers for 'standardized' languages.
2020-10-09 02:36:35 +0200 <spinnylights> well not literally nothing or everything :P i kind of wish that was the case, it might be easier to make a good FFI
2020-10-09 02:36:58 +0200 <koz_> spinnylights: 'Almost nothing', much like 'almost everything' is almost useless as a claim of anything.
2020-10-09 02:37:00 +0200 <dolio> I was surprised by the scheme 'proper tail recursion' spec, too.
2020-10-09 02:37:12 +0200 <koz_> dolio: Yeah, unlike Common Lisp.
2020-10-09 02:37:16 +0200 <dolio> It's more vague than I'd heard.
2020-10-09 02:37:22 +0200 <spinnylights> those are not the same kinds of languages :P i doubt those languages are widely used in the embedded world
2020-10-09 02:37:45 +0200 <monochrom> Ah, atomicModifyIORef includes memory barrier, I didn't notice that.
2020-10-09 02:37:47 +0200xerox_(~xerox@unaffiliated/xerox) (Ping timeout: 240 seconds)
2020-10-09 02:37:52 +0200 <spinnylights> maybe you have a good counterexample but it would be surprising to me
2020-10-09 02:37:53 +0200 <koz_> spinnylights: Perhaps, but being the _only_ option does not imply being the _best_ option. It's a grubby world nobody wants to grub around in.
2020-10-09 02:38:15 +0200 <koz_> So there's no other options because nobody wants to write languages for that space, not because C is somehow good there.
2020-10-09 02:38:18 +0200 <spinnylights> well sure :P i don't think c is too many people's favorite language in the world or anything, but the constraints on its design are really severe
2020-10-09 02:39:08 +0200 <spinnylights> a language like c++ or rust could theoretically take its place but they require much bulkier, harder-to-implement compilers
2020-10-09 02:39:38 +0200 <koz_> C++ does so because it's the clown car of proglangs and must include literally everything. Except garbage collection because it's badwrongfun somehow.
2020-10-09 02:39:52 +0200emmanuel_erc(~user@2604:2000:1382:ce03:ddc4:166d:60ea:ae29)
2020-10-09 02:39:54 +0200 <spinnylights> writing a c compiler is relatively easy by comparison, which is nice if your language is meant to support a wide variety of esoteric hardware
2020-10-09 02:39:59 +0200ski. o O ( isn't the only element of an ordered singleton set the greatest (and the least) element ? )
2020-10-09 02:40:20 +0200 <koz_> ski: Isn't every singleton set ordered? Like, vacuously?
2020-10-09 02:40:44 +0200 <ski> there's only one order on it that you can impose, sure
2020-10-09 02:40:55 +0200 <ski> (but `Set' is not the same category as `PO')
2020-10-09 02:41:05 +0200 <spinnylights> and that's partially thanks to the permissive standard :P there's a reason for everything, even if it's not exactly utopian
2020-10-09 02:41:31 +0200 <koz_> spinnylights: I question the merits of such a standard, if the outcome is 'it's easy to throw together something that may or may not do anything you may or may not expect'.
2020-10-09 02:41:48 +0200 <koz_> I don't wanna have to play language lawyer when aiming for portability, and C _forces_ you to do this _even when you're not trying_.
2020-10-09 02:42:07 +0200 <koz_> (again, I got bitten by UB, and portability wasn't even my tenth damned concern)
2020-10-09 02:42:37 +0200 <koz_> There's no reason for the situation _other_ than an adoption drive (back in the 80s) and legacy (today).
2020-10-09 02:43:45 +0200 <spinnylights> to be fair, i think claiming that the standard doesn't specify any behavior in particular is overstating your case a bit ;^^ i've written quite a bit of c and any time i've produced ub i've had only myself to blame :P i have yet to find a real compiler bug or anything
2020-10-09 02:44:03 +0200 <spinnylights> perhaps, i think it's kind of hard to say one way or the other with something like that since the history is so complicated
2020-10-09 02:44:20 +0200 <koz_> spinnylights: Glad that one of us is lucky like that. I'm not, because I find every bug in everything by breathing.
2020-10-09 02:44:39 +0200 <koz_> (I'm not joking - I just found a bug in my Real Money Job's nix config by _running nix-build_)
2020-10-09 02:44:48 +0200 <koz_> (this went unnoticed by everyone for _months_)
2020-10-09 02:44:53 +0200 <koz_> (well, everyone _else_)
2020-10-09 02:45:09 +0200 <koz_> And that's basically my life forever with everything.
2020-10-09 02:45:11 +0200 <spinnylights> i'm not talking about software in general, to be fair :P i've never found a bug compiling c code with gcc
2020-10-09 02:45:22 +0200 <koz_> spinnylights: Again, compared to me, you lead a charmed life.
2020-10-09 02:45:36 +0200 <koz_> May you forever continue to be this fortunate.
2020-10-09 02:45:48 +0200 <spinnylights> if you regularly find bugs in gcc then you're a great boon to the rest of us ^^
2020-10-09 02:45:59 +0200 <koz_> spinnylights: Trust me, nobody thanks you for doing this kind of work.
2020-10-09 02:46:17 +0200 <koz_> (believe me, the responses I've had from certain communities for daring to suggest that somehow I am not responsible personally for every bug I find...)
2020-10-09 02:47:14 +0200 <koz_> But anyway, I'm _way_ off-topic, so to bring it back to Haskell: I recently realized that wai's Application is effectively ReaderT Request (ContT ResponseReceived IO) Response.
2020-10-09 02:47:15 +0200 <spinnylights> well, if you're really confident, keep fighting the good fight ^^ if you can find the time to submit a patch they may be more receptive in some cases, also
2020-10-09 02:47:58 +0200 <spinnylights> but yeah, that's true, this is far away from haskelland :P
2020-10-09 02:48:06 +0200 <koz_> spinnylights: I do when I can, but a lot of the time, I can't really. I've found bugs in LibreOffice and Firefox - good luck trying to figure out how to fix _those_ unless you've been wrangling those codebases intimately for years.
2020-10-09 02:48:13 +0200 <monochrom> @unmtl ReaderT Request (ContT ResponseReceived IO) Response
2020-10-09 02:48:14 +0200 <lambdabot> Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived
2020-10-09 02:48:39 +0200 <spinnylights> i just patched a bug in firefox's audio backend last week ^^ it's possible
2020-10-09 02:48:50 +0200 <monochrom> Hrm, what is that ContT doing there?
2020-10-09 02:48:50 +0200 <spinnylights> sometimes the code's not as gnarly as you would think
2020-10-09 02:49:05 +0200 <spinnylights> sorry, you're right about all this being off topic though
2020-10-09 02:49:17 +0200 <koz_> spinnylights: 'Possible' is one thing. It is also 'possible' for me to write a GPGPU-based AV1 encoder, but the number of hours, days, or _months_ it would take me preclude this possibility from being realized.
2020-10-09 02:49:26 +0200 <koz_> monochrom: Resource handling according to the docs.
2020-10-09 02:49:31 +0200 <koz_> (no really)
2020-10-09 02:50:04 +0200falafel(~falafel@2605:e000:1527:d491:1ccf:5c8d:7928:e9cc)
2020-10-09 02:50:25 +0200 <monochrom> I think I know that idiom, yeah.
2020-10-09 02:50:56 +0200 <koz_> How would you ensure resource release a la bracket by way of ContT?
2020-10-09 02:51:04 +0200 <monochrom> (after "resource handling")
2020-10-09 02:51:07 +0200 <koz_> Like, if this is an idiom, it's one I've never seen.
2020-10-09 02:51:35 +0200 <monochrom> It doesn't ensure more than bracket does, but it looks nicely syntactically.
2020-10-09 02:52:07 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de)
2020-10-09 02:52:52 +0200 <monochrom> Whereas you normally write "withFoo (\h1 -> withBar (\h2 -> ...))" and after 5 levels it is indenting too much to the right...
2020-10-09 02:53:17 +0200nineonine(~nineonine@216-19-190-182.dyn.novuscom.net)
2020-10-09 02:54:12 +0200 <monochrom> do { h1 <- ContT (\k -> withFoo k); h2 <- ContT (\k -> withBar k); ... } looks more vertical, sequential, straightline.
2020-10-09 02:54:59 +0200 <koz_> So what's the ContT-based translation of withFile, say?
2020-10-09 02:55:21 +0200 <monochrom> withFoo k = withFile "filename" ReadMode k
2020-10-09 02:55:44 +0200 <monochrom> withBar k = bracket acquire release k
2020-10-09 02:56:10 +0200elliott_(~elliott@pool-108-51-141-12.washdc.fios.verizon.net)
2020-10-09 02:56:27 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-09 02:56:28 +0200 <monochrom> You just slap a ContT (the data constructor) wrapper around each one. And a runContT at some outer level.
2020-10-09 02:57:36 +0200 <ski> @hackage managed -- koz_ ?
2020-10-09 02:57:37 +0200 <lambdabot> https://hackage.haskell.org/package/managed -- koz_ ?
2020-10-09 02:57:46 +0200 <monochrom> Also, this: http://blog.sigfpe.com/2011/10/quick-and-dirty-reinversion-of-control.html
2020-10-09 02:58:07 +0200 <dolio> So this is an example of a monad where each action causes something in the listed order, and also something in the opposite of the listed order.
2020-10-09 02:58:37 +0200 <ski> they should add `evalContT = flip runContT return' ..
2020-10-09 02:58:45 +0200 <monochrom> I would count "in the opposite of the listed order" as "also sequential".
2020-10-09 02:58:58 +0200 <monochrom> Not that I really want to get into that debate. :)
2020-10-09 03:00:09 +0200 <monochrom> But an inspiration I drew from is this:
2020-10-09 03:00:57 +0200 <monochrom> In eager evaluation, "(f . g . h) x" is evaluated in order of: x, h of that, g of that, f of that.
2020-10-09 03:01:07 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2020-10-09 03:01:13 +0200 <monochrom> In lazy evaluation, in order of: f, g, h, x.
2020-10-09 03:01:20 +0200 <monochrom> Which one is "the listed order"?
2020-10-09 03:01:51 +0200 <monochrom> Instead, what I'm sure is that of the two linear orders, one of them happens. So it's sequential.
2020-10-09 03:02:21 +0200ski. o O ( speculative evaluation )
2020-10-09 03:02:58 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net) (Ping timeout: 265 seconds)
2020-10-09 03:04:00 +0200 <monochrom> Taking a step further, suppose in a very strong sense both orders happen together, for example Tardis.
2020-10-09 03:04:10 +0200 <monochrom> I still say it's sequential.
2020-10-09 03:04:34 +0200 <koz_> monochrom: Thanks - I will read those, but this is rather cool.
2020-10-09 03:04:50 +0200 <monochrom> If you don't have a commutative law, then it is sequential, or perhaps you object to that commitment, OK not-not-sequential.
2020-10-09 03:05:11 +0200 <ski> list monad is still sequential
2020-10-09 03:05:24 +0200 <monochrom> And by the time you have an anti-commutative law, it's in every sense definitely sequential.
2020-10-09 03:05:37 +0200 <ski> the interface is sequential
2020-10-09 03:05:42 +0200 <dolio> I'm on record saying that only commutative things should be considered not sequential.
2020-10-09 03:07:05 +0200Benzi-Junior(~BenziJuni@88-149-67-198.du.xdsl.is) (Ping timeout: 272 seconds)
2020-10-09 03:07:26 +0200conal(~conal@66.115.157.46) (Quit: Computer has gone to sleep.)
2020-10-09 03:09:29 +0200elliott_(~elliott@pool-108-51-141-12.washdc.fios.verizon.net) (Ping timeout: 258 seconds)
2020-10-09 03:09:38 +0200Benzi-Junior(~BenziJuni@dsl-149-67-198.hive.is)
2020-10-09 03:10:13 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-09 03:10:27 +0200aarvar(~foewfoiew@50.35.43.33) (Ping timeout: 240 seconds)
2020-10-09 03:10:35 +0200Rudd0(~Rudd0@185.189.115.98) (Ping timeout: 240 seconds)
2020-10-09 03:11:23 +0200machinedgod(~machinedg@24.105.81.50) (Ping timeout: 240 seconds)
2020-10-09 03:11:35 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-10-09 03:12:48 +0200conal(~conal@66.115.157.46)
2020-10-09 03:13:04 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 03:13:49 +0200conal(~conal@66.115.157.46) (Client Quit)
2020-10-09 03:13:58 +0200hackageprairie 0.0.1.0 - A first class record field library https://hackage.haskell.org/package/prairie-0.0.1.0 (parsonsmatt)
2020-10-09 03:17:47 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 260 seconds)
2020-10-09 03:18:53 +0200Wuzzy(~Wuzzy@p5790e6f5.dip0.t-ipconnect.de) (Remote host closed the connection)
2020-10-09 03:22:44 +0200plutoniix(~q@175.176.222.7)
2020-10-09 03:23:07 +0200redmynk(~redmynk@2804:1b2:180:5c13:a8b7:4418:5b7e:8baa) (Quit: Leaving)
2020-10-09 03:30:02 +0200conal(~conal@66.115.157.46)
2020-10-09 03:32:26 +0200nineonin_(~nineonine@50.216.62.2)
2020-10-09 03:32:27 +0200xerox_(~xerox@unaffiliated/xerox)
2020-10-09 03:33:52 +0200quinn(~quinn@c-73-223-224-163.hsd1.ca.comcast.net) (Quit: ZNC 1.8.1 - https://znc.in)
2020-10-09 03:35:09 +0200quinn(~quinn@c-73-223-224-163.hsd1.ca.comcast.net)
2020-10-09 03:35:42 +0200nineonine(~nineonine@216-19-190-182.dyn.novuscom.net) (Ping timeout: 272 seconds)
2020-10-09 03:36:09 +0200 <monochrom> TIL: f (x :: forall a. a->a) = ... is also allowed under RankNTypes and ScopedTypeVariables
2020-10-09 03:36:19 +0200m0rphism(~m0rphism@HSI-KBW-046-005-177-122.hsi8.kabel-badenwuerttemberg.de) (Ping timeout: 265 seconds)
2020-10-09 03:36:23 +0200 <monochrom> f will get the rightful rank-2 type.
2020-10-09 03:36:40 +0200xsperry(~as@unaffiliated/xsperry)
2020-10-09 03:37:30 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 03:41:47 +0200xff0x(~fox@2001:1a81:53a8:5900:18dc:5fd3:ab0c:ba1c) (Ping timeout: 260 seconds)
2020-10-09 03:43:15 +0200 <dolio> That's what we did in ermine, except it wasn't optional.
2020-10-09 03:43:26 +0200xff0x(~fox@2001:1a81:53da:5200:18dc:5fd3:ab0c:ba1c)
2020-10-09 03:43:28 +0200 <dolio> The signature for f did no good. :þ
2020-10-09 03:57:45 +0200Dungdv(abf4bce2@gateway/web/cgi-irc/kiwiirc.com/ip.171.244.188.226)
2020-10-09 03:58:08 +0200 <spinnylights> i realize as long as i'm hanging out in this channel i mgiht as well ask :P i'm looking into using haskell for game development, and as far as i can tell aside from the sdl2 bindings (which seem quite nice) there's not much available in terms of libraries?
2020-10-09 03:58:58 +0200 <spinnylights> at least in terms of like, actively-maintained stuff
2020-10-09 03:59:09 +0200 <spinnylights> but maybe i'm missing something?
2020-10-09 04:00:49 +0200acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 264 seconds)
2020-10-09 04:02:15 +0200 <spinnylights> in theory this https://hackage.haskell.org/package/inline-c seems really handy—i wouldn't mind working on bindings in general but in this particular case it would be for a series of short, sketchy, fast-as-possible games, so spending a lot of time up front writing bindings would kind of undercut that
2020-10-09 04:02:25 +0200conal(~conal@66.115.157.46) (Quit: Computer has gone to sleep.)
2020-10-09 04:04:21 +0200 <spinnylights> in the abstract haskell seems like a nice language to use for that sort of project because programs can come together in it so fast :P but i'm kind of worried that the lack of library support will limit what i can realistically do without writing a lot of enginey code beforehand
2020-10-09 04:04:58 +0200 <sm[m]> spinnylights: still here ?
2020-10-09 04:05:12 +0200 <spinnylights> yaya, i just wrote that stuff :P
2020-10-09 04:05:47 +0200 <sm[m]> cool. You're right, there's not a lot that's actively maintained. But there is quite a lot of libs and interested folks out there
2020-10-09 04:06:10 +0200 <spinnylights> yeah, that's the impression i get—lots of blog posts, some old libraries here and there, etc.
2020-10-09 04:06:23 +0200 <sm[m]> a.lot of good pieces exist but have not been tied together so you have to do that work
2020-10-09 04:06:49 +0200 <sm[m]> I'm building a game with sdl right now, I think it's working out
2020-10-09 04:07:27 +0200 <justsomeguy> How can I determine which type classes can be derived, and which cannot? Do I just have to know, or can I query them somehow?
2020-10-09 04:07:35 +0200 <spinnylights> i tried to see if i could still use the chipmunk bindings but i think they would need some work before they'll compile under the latest ghc
2020-10-09 04:07:53 +0200 <spinnylights> what sort of game is it? how much have you had to do yourself?
2020-10-09 04:07:56 +0200 <dolio> justsomeguy: They're listed in the Haskell report, and GHC has some extras turned on by extensions.
2020-10-09 04:08:01 +0200 <sm[m]> If you haven't seen, there are: a lot of games on hackage, a games page on the wiki, /r/haskell-game and #haskell-game
2020-10-09 04:08:25 +0200 <spinnylights> oh there are games on hackage, that's cool, i didn't realize that
2020-10-09 04:08:52 +0200 <sm[m]> spinnylights: yes, a lot and some even build with modern ghc
2020-10-09 04:08:54 +0200 <dolio> There are also some extensions that let you derive almost anything in particular ways.
2020-10-09 04:09:07 +0200 <spinnylights> yeah i should probably check out that channel—i've come across the wiki page and the reddit a bit
2020-10-09 04:09:08 +0200Jeanne-Kamikaze(~Jeanne-Ka@68.235.43.158)
2020-10-09 04:09:17 +0200 <sm[m]> spinnylights: I'm making breakout, deliberately not using any framework
2020-10-09 04:09:21 +0200 <spinnylights> anything you would particularly recommend? it would be awesome to have some examples
2020-10-09 04:09:25 +0200 <spinnylights> nice i love breakout ^^
2020-10-09 04:10:28 +0200 <spinnylights> yeah in theory you can do a lot with just plain sdl, it's mainly a matter of time :P the goal for this particular project would be to make a series of games spending 1 or maybe 2 days on each one
2020-10-09 04:10:31 +0200 <dsal> justsomeguy: I often just assume I can't derive classes and write them, but I've found GHC's been able to do some pretty fantastic deriving at times. There's lots of magic when you're ready for it.
2020-10-09 04:10:38 +0200 <dsal> Is there a particular class you want derived?
2020-10-09 04:10:58 +0200 <sm[m]> monadius is great. Dino-rush. lambda-heights. Allure of the stars (also has its own chat room). For game engines, I maintain the oldest, and I would say possible still the most productive: FunGEn
2020-10-09 04:11:17 +0200 <spinnylights> so i think for that to be realistic i would need to do some sort of simple engine writing beforehand—if i don't worry about the lack of an easy-available physics library it probably wouldn't be too bad
2020-10-09 04:11:28 +0200 <spinnylights> awesome thanks, i'll definitely take a look
2020-10-09 04:11:37 +0200theDon(~td@muedsl-82-207-238-010.citykom.de) (Ping timeout: 264 seconds)
2020-10-09 04:11:52 +0200 <sm[m]> spinnylights: I was trying to make the simplest possible game a bunch of different ways. It turns out to be a big project for me but it's still fun
2020-10-09 04:12:02 +0200 <justsomeguy> dsal: I can't think of a particular example right now; I was just reading about type classes in the textbook I'm learning from, and it piqued my interest.
2020-10-09 04:12:18 +0200 <sm[m]> once you've done it once or twice I think it's waaaay faster
2020-10-09 04:12:45 +0200 <dsal> justsomeguy: Very often, there's only one way to do it, so it makes sense that it can be derived.
2020-10-09 04:12:57 +0200 <spinnylights> yeah i was planning to write a game or two beforehand just since i would end up putting together a lot of the components of a simple engine that way as i went
2020-10-09 04:13:13 +0200theDon(~td@94.134.91.7)
2020-10-09 04:13:17 +0200 <sm[m]> I think using fungen would have been much faster
2020-10-09 04:13:22 +0200 <spinnylights> i just don't want to spend too much time up front :P the goal of the project is partially to teach myself restraint ;^^
2020-10-09 04:14:03 +0200 <spinnylights> i notice the fungen repo is a few years old now—you still keep it up and such?
2020-10-09 04:14:23 +0200 <spinnylights> i like that it's glut-based, that's nice
2020-10-09 04:14:46 +0200 <sm[m]> It's basically emergency fixes only and nobody ever used it but afaik still works great
2020-10-09 04:14:59 +0200 <sm[m]> Very simple deps
2020-10-09 04:15:16 +0200oisdk(~oisdk@2001:bb6:3329:d100:7807:4c86:5073:949e) (Quit: oisdk)
2020-10-09 04:15:26 +0200 <spinnylights> if it still works that's all i really care about :P
2020-10-09 04:15:26 +0200 <sm[m]> sm-breakout on github is my current WIP
2020-10-09 04:15:43 +0200 <sm[m]> try the sample games
2020-10-09 04:16:08 +0200 <spinnylights> yeah i'm checking out the hackage page rn
2020-10-09 04:16:26 +0200 <spinnylights> "executable game spec" is definitely the dream :P
2020-10-09 04:17:18 +0200urodna(~urodna@unaffiliated/urodna) (Quit: urodna)
2020-10-09 04:17:24 +0200remexre(~remexre@x-160-94-179-160.acm.umn.edu)
2020-10-09 04:17:25 +0200remexre(~remexre@x-160-94-179-160.acm.umn.edu) (Client Quit)
2020-10-09 04:17:40 +0200lagothrixGuest34111
2020-10-09 04:17:40 +0200Guest34111(~lagothrix@unaffiliated/lagothrix) (Killed (wilhelm.freenode.net (Nickname regained by services)))
2020-10-09 04:17:46 +0200 <sm[m]> it trips me out how long ago this framework was made and how it's still the go to
2020-10-09 04:17:49 +0200lagothrix(~lagothrix@unaffiliated/lagothrix)
2020-10-09 04:18:30 +0200remexre(~remexre@x-160-94-179-160.acm.umn.edu)
2020-10-09 04:19:33 +0200 <spinnylights> kinda makes sense in a way, if it has a lot of useful features
2020-10-09 04:20:37 +0200 <spinnylights> building the examples rn
2020-10-09 04:23:53 +0200 <spinnylights> v cool ^^ definitely a good proof-of-concept, i'm looking at the pong code and it's v short and readable
2020-10-09 04:25:10 +0200 <spinnylights> it's too bad about audio though :/ i wonder how easily this https://hackage.haskell.org/package/csound-expression could be integrated...maybe i'll experiment a bit
2020-10-09 04:25:10 +0200 <sm[m]> yep I appreciate it more after working with just sdl
2020-10-09 04:25:22 +0200 <spinnylights> yeah it definitely has more game-specific stuff
2020-10-09 04:26:04 +0200 <spinnylights> it's nice that you get collision detection, and it seems easier to work with graphics
2020-10-09 04:26:14 +0200 <sm[m]> and the binaries will work on any machine I think - no need to install sdl separately
2020-10-09 04:26:41 +0200 <spinnylights> yeah that's great as well, i've been thinking about that in the back of my head
2020-10-09 04:26:55 +0200 <sm[m]> oh yeah. Isn't there a openAL lib ?
2020-10-09 04:27:29 +0200 <sm[m]> elerea looks like an interesting new sound lib
2020-10-09 04:27:55 +0200 <spinnylights> seems kind of uncommon to statically link sdl in c or c++ which can def make distribution a bit of a pain
2020-10-09 04:28:10 +0200sword865(uid208942@gateway/web/irccloud.com/x-oofcgutvwgwgnuoj)
2020-10-09 04:28:20 +0200 <spinnylights> oh i see, does seem interesting
2020-10-09 04:29:16 +0200 <spinnylights> i know csound quite deeply so i automatically gravitate in that direction :P it does have the advantage that it can talk to a wide variety of backends (i like to have JACK support in linux which a lot of generic audio libs overlook)
2020-10-09 04:29:24 +0200evanjs(~evanjs@075-129-188-019.res.spectrum.com) (Quit: ZNC 1.8.1 - https://znc.in)
2020-10-09 04:30:10 +0200 <spinnylights> and if it could be made to talk to fungen it would provide a very easy means to add procedural sound to your game which is always cool
2020-10-09 04:30:37 +0200evanjs(~evanjs@075-129-188-019.res.spectrum.com)
2020-10-09 04:31:05 +0200 <spinnylights> i know the csound community is rather fond of haskell but i haven't actually played around with the haskell-related stuff people have made so maybe this is a good time
2020-10-09 04:31:09 +0200 <sm[m]> I don't there's any integration required, just use both ?
2020-10-09 04:31:37 +0200 <sm[m]> but I haven't tried
2020-10-09 04:31:38 +0200 <spinnylights> yeah hopefully it's that straightforward
2020-10-09 04:31:49 +0200 <spinnylights> i _think_ that should be the case but yeah, i haven't tried yet
2020-10-09 04:32:55 +0200 <spinnylights> the csound-expression lib seems to have a strong focus on live coding which is def promising for use in a game context
2020-10-09 04:33:00 +0200Saukk(~Saukk@2001:998:f1:3963:1c59:9bb5:b94c:2)
2020-10-09 04:33:56 +0200 <spinnylights> whoa this library is really fancy 0_0 it even has a cabbage monad
2020-10-09 04:34:02 +0200 <spinnylights> i should have looked at it sooner :P
2020-10-09 04:35:32 +0200tmciver(~tmciver@cpe-172-101-40-226.maine.res.rr.com) (Ping timeout: 256 seconds)
2020-10-09 04:36:14 +0200 <spinnylights> i'm going to see if i can modify the pong example to produce sound using csound-expression, i'll report back :P
2020-10-09 04:36:47 +0200 <spinnylights> i guess maybe i should share my results in #haskell-game
2020-10-09 04:37:34 +0200tmciver(~tmciver@cpe-172-101-40-226.maine.res.rr.com)
2020-10-09 04:39:14 +0200nullheroes(~danielvu@168.235.66.22) (Quit: WeeChat 2.9)
2020-10-09 04:39:55 +0200hololeap(~hololeap@unaffiliated/hololeap)
2020-10-09 04:41:58 +0200 <sm[m]> spinnylights: live coding is a bit more of a project but I think some good things to look at are ghcid, Tidal package, and the new reloading system used by IHP
2020-10-09 04:42:57 +0200 <spinnylights> oh yeah, i just mean that if it supports live coding it will probably be up to use in a game context
2020-10-09 04:43:11 +0200 <spinnylights> in terms of lag etc.
2020-10-09 04:43:34 +0200 <spinnylights> csound is pretty fast on its own so as long as the library doesn't introduce extra performance issues it should be fine
2020-10-09 04:43:53 +0200polyrain(~polyrain@2001:8003:e501:6901:d439:cec4:3811:73e4) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 04:46:22 +0200gnar^2(~user@c-73-118-153-248.hsd1.wa.comcast.net)
2020-10-09 04:46:27 +0200falafel(~falafel@2605:e000:1527:d491:1ccf:5c8d:7928:e9cc) (Ping timeout: 240 seconds)
2020-10-09 04:46:33 +0200jedws(~jedws@121.209.161.98) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 04:49:47 +0200Gurkenglas(~Gurkengla@unaffiliated/gurkenglas) (Ping timeout: 240 seconds)
2020-10-09 04:50:46 +0200 <koz_> A cabbage monad?
2020-10-09 04:52:17 +0200ericsagnes(~ericsagne@2405:6580:0:5100:841d:b2f8:a54e:9827) (Quit: WeeChat 2.7.1)
2020-10-09 04:52:48 +0200ericsagnes(~ericsagne@2405:6580:0:5100:9d42:ed56:2b0:8ee0)
2020-10-09 04:53:31 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de)
2020-10-09 04:53:35 +0200 <sm[m]> don't you use vegetable monads ?
2020-10-09 04:54:02 +0200 <koz_> sm[m]: I prefer fruit.
2020-10-09 04:54:22 +0200 <Axman6> You can't call them that any more, we prefer differently-abled monads
2020-10-09 04:54:24 +0200koz_. o O (instance Monad Tomato where)
2020-10-09 04:54:32 +0200 <spinnylights> makes it easy to put the stems, leaves, etc. together
2020-10-09 04:54:43 +0200sand_dull(~theuser@104.140.53.43)
2020-10-09 04:54:50 +0200 <spinnylights> v convenient
2020-10-09 04:55:36 +0200 <spinnylights> unfortunately i seem to be stuck in some kind of extra-deps hell with stack :/ i'm still kind of new to it so maybe i'm not going about this the right way
2020-10-09 04:56:00 +0200 <koz_> What's the specific extra-deps hell?
2020-10-09 04:56:48 +0200 <spinnylights> csound-expression doesn't seem to be part of the package set for the resolver fungen uses, so i'm trying to specify the versions of the needed dependencies by hand, but it's a lot of trouble to figure out how to line everything up so there's no version conflicts :/
2020-10-09 04:57:25 +0200 <spinnylights> i might be able to figure it out if i keep at it but it definitely seems like something an automated tool would be better at
2020-10-09 04:57:51 +0200gnar^2(~user@c-73-118-153-248.hsd1.wa.comcast.net) (Ping timeout: 256 seconds)
2020-10-09 04:58:01 +0200danso(~dan@107-190-41-58.cpe.teksavvy.com)
2020-10-09 04:58:12 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2020-10-09 04:58:18 +0200 <koz_> Which resolver does fungen use?
2020-10-09 04:58:19 +0200nineonine(~nineonine@216-19-190-182.dyn.novuscom.net)
2020-10-09 04:58:31 +0200 <koz_> Are neither of fungen and csound on Stackage?
2020-10-09 04:59:09 +0200 <spinnylights> lts-6.12
2020-10-09 04:59:13 +0200falafel(~falafel@2605:e000:1527:d491:1ccf:5c8d:7928:e9cc)
2020-10-09 04:59:26 +0200 <Axman6> that's... very old
2020-10-09 04:59:58 +0200nineonin_(~nineonine@50.216.62.2) (Ping timeout: 260 seconds)
2020-10-09 05:00:01 +0200Wolfy87(~Wolfy87@s91904426.blix.com) ()
2020-10-09 05:00:07 +0200 <Axman6> has basically no chance of ever compiling on macOS, since older GHCs have issues with linker changes Apple made
2020-10-09 05:00:11 +0200 <koz_> That's _hilariously_ ancient.
2020-10-09 05:00:43 +0200 <koz_> It's like, GHC 7.10.3 I think?
2020-10-09 05:01:16 +0200 <spinnylights> fungen itself builds and runs fine in my environment (arch linux) but yeah, i don't think the code has been updated in a long time
2020-10-09 05:01:17 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 05:01:49 +0200 <spinnylights> i'm trying to use a version of csound-expression that's roughly contemporary with the fungen source but so far no luck :/
2020-10-09 05:02:15 +0200 <koz_> fungen was last updated in 2016.
2020-10-09 05:02:19 +0200 <koz_> I wouldn't hope for much.
2020-10-09 05:02:23 +0200 <spinnylights> @sm[m] does fungen require lts-6.12 or can it build with something more recent?
2020-10-09 05:02:23 +0200 <lambdabot> Unknown command, try @list
2020-10-09 05:02:40 +0200 <spinnylights> er :P
2020-10-09 05:03:28 +0200darjeeling_(~darjeelin@115.215.43.235) (Ping timeout: 260 seconds)
2020-10-09 05:04:15 +0200alp(~alp@2a01:e0a:58b:4920:ac57:f0c6:c76e:e7d6) (Ping timeout: 272 seconds)
2020-10-09 05:05:37 +0200 <koz_> spinnylights: I'm trying with 8.10.2 right now.
2020-10-09 05:05:40 +0200 <koz_> Seeing how I go.
2020-10-09 05:05:41 +0200ulidtko(~ulidtko@193.111.48.79) (Read error: Connection reset by peer)
2020-10-09 05:05:45 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 240 seconds)
2020-10-09 05:05:48 +0200ulidtko|k(~ulidtko@193.111.48.79)
2020-10-09 05:06:55 +0200 <spinnylights> yeah i'm trying with 8.8.3...we'll see
2020-10-09 05:07:56 +0200 <spinnylights> one of the dependencies for that old version of csound-expression would not build, but let's try with a more recent version
2020-10-09 05:09:37 +0200 <koz_> Nah, 8.10.2 breaks due to MonadFail.
2020-10-09 05:09:49 +0200 <Axman6> #MonadFailFail
2020-10-09 05:10:11 +0200 <spinnylights> darn, csound-expression-5.3.3 and fungen have conflicting dependencies :/
2020-10-09 05:10:29 +0200 <koz_> spinnylights: What conflicts?
2020-10-09 05:10:33 +0200 <spinnylights> sm[m]: how hard do you think it would be to bring fungen up-to-date? :P is that overly ambitious?
2020-10-09 05:10:35 +0200 <Axman6> --allow-newer-yolo
2020-10-09 05:10:55 +0200 <koz_> spinnylights: There's a mission MonadFail instance required for 8.10.
2020-10-09 05:11:00 +0200 <koz_> For 8.8, I'm about to find out.
2020-10-09 05:12:18 +0200 <sm[m]> spinnylights: sorry was afk. I though my I updated it for maybe 8.6 in the git repo. It shouldn't be hard to update
2020-10-09 05:13:12 +0200 <Axman6> https://matrix.hackage.haskell.org/#/package/FunGEn makes me sad
2020-10-09 05:13:24 +0200 <spinnylights> ah well i got the build process to start again at least
2020-10-09 05:14:04 +0200 <koz_> 8.8.4 works.
2020-10-09 05:14:14 +0200 <koz_> (you need --allow-newer I think, but it works)
2020-10-09 05:14:20 +0200 <koz_> Oh wait never mind.
2020-10-09 05:14:23 +0200 <koz_> Same MonadFail issue.
2020-10-09 05:14:30 +0200 <spinnylights> no worries, if it's easy that would be awesome—i'm happy to help/submit a patch too
2020-10-09 05:15:06 +0200 <Axman6> MonadFail issues aren't hard to solve though
2020-10-09 05:15:12 +0200 <koz_> spinnylights: Basically, you gotta add an instance of MonadFail for IOGame GameAttribute ObjectAttribute GameState TileAttribute
2020-10-09 05:15:19 +0200 <koz_> That's the most obvious issue.
2020-10-09 05:15:20 +0200 <sm[m]> I don't have time, even to review right now - travelling. Help welcome
2020-10-09 05:15:59 +0200 <koz_> Also, the cabal file doesn't indicate Paths_FunGEn, but that's also easy to fix.
2020-10-09 05:16:14 +0200 <spinnylights> okay i'll take a look
2020-10-09 05:16:19 +0200 <spinnylights> yeah i just got there myself
2020-10-09 05:16:28 +0200darjeeling_(~darjeelin@122.245.210.138)
2020-10-09 05:16:38 +0200polyrain(~polyrain@2001:8003:e501:6901:d439:cec4:3811:73e4)
2020-10-09 05:16:46 +0200 <sm[m]> but at least it should be usable with lts-whateveritis
2020-10-09 05:16:56 +0200 <spinnylights> csound builds okay—lots of warnings but it came together
2020-10-09 05:17:23 +0200 <koz_> Is there even an LTS for 8.10.*?
2020-10-09 05:17:25 +0200 <spinnylights> luckily at least so far the issue is in the worms example so at least that's pretty simple
2020-10-09 05:17:39 +0200 <spinnylights> not yet i don't think
2020-10-09 05:18:02 +0200 <sm[m]> it'll be obsolete soon :(
2020-10-09 05:18:25 +0200 <sm[m]> but I guess it's not exactly stable yet
2020-10-09 05:18:45 +0200 <sm[m]> (ghc 8.10)
2020-10-09 05:19:06 +0200 <sm[m]> one of these statements must be wrong eh
2020-10-09 05:19:12 +0200 <spinnylights> heh :P
2020-10-09 05:20:49 +0200 <koz_> But yeah, sm[m] is right, this is an easyish fix.
2020-10-09 05:21:10 +0200 <koz_> It's not like the kind of gore I had to involve myself with when I lifted my Real Job For Real Money codebase to 8.8.
2020-10-09 05:21:15 +0200 <koz_> That was... *shudders*
2020-10-09 05:21:52 +0200jpcw1(~jpcw@195.206.169.184)
2020-10-09 05:23:13 +0200 <sm[m]> hehe wishful thinking on my part.. I last updated it to ghc 8.0
2020-10-09 05:27:38 +0200drbean(~drbean@TC210-63-209-62.static.apol.com.tw)
2020-10-09 05:34:26 +0200proofofme(~proofofme@184-96-74-65.hlrn.qwest.net)
2020-10-09 05:38:09 +0200 <ski> @remember monochrom Any sufficiently insider joke is indistinguishable from sufficiently advanced knowledge.
2020-10-09 05:38:10 +0200 <lambdabot> Done.
2020-10-09 05:44:44 +0200 <spinnylights> ooh i think i got it ^^
2020-10-09 05:45:15 +0200 <spinnylights> it was pretty simple in the end, yeah :P
2020-10-09 05:46:22 +0200 <spinnylights> sm[m]: would you accept a pull request if i submitted one? it's like two lines of code :P
2020-10-09 05:46:37 +0200falafel(~falafel@2605:e000:1527:d491:1ccf:5c8d:7928:e9cc) (Ping timeout: 260 seconds)
2020-10-09 05:46:41 +0200 <spinnylights> trivial monadfail instance for iogame
2020-10-09 05:51:45 +0200mirrorbird(~psutcliff@2a00:801:3f8:10df:3fb2:3ec3:6676:3873) (Ping timeout: 272 seconds)
2020-10-09 05:52:11 +0200 <spinnylights> i'll just go ahead and put one together, it won't take long anyway
2020-10-09 05:52:41 +0200conal(~conal@64.71.133.70)
2020-10-09 05:55:07 +0200Tario(~Tario@201.192.165.173) (Read error: Connection reset by peer)
2020-10-09 05:55:14 +0200shafox(~shafox@106.51.234.111)
2020-10-09 05:55:43 +0200Tario(~Tario@201.192.165.173)
2020-10-09 05:57:23 +0200Tario(~Tario@201.192.165.173) (Client Quit)
2020-10-09 05:57:38 +0200Tario(~Tario@201.192.165.173)
2020-10-09 05:57:42 +0200Saukk(~Saukk@2001:998:f1:3963:1c59:9bb5:b94c:2) (Remote host closed the connection)
2020-10-09 06:00:13 +0200zebrag(~inkbottle@aaubervilliers-654-1-112-132.w86-198.abo.wanadoo.fr) (Ping timeout: 264 seconds)
2020-10-09 06:00:16 +0200inkbottle(~inkbottle@aaubervilliers-654-1-114-176.w86-198.abo.wanadoo.fr)
2020-10-09 06:01:20 +0200Rudd0(~Rudd0@185.189.115.108)
2020-10-09 06:01:44 +0200fresheyeball(~isaac@c-71-237-105-37.hsd1.co.comcast.net)
2020-10-09 06:03:16 +0200conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-10-09 06:04:06 +0200conal(~conal@64.71.133.70)
2020-10-09 06:04:23 +0200conal(~conal@64.71.133.70) (Client Quit)
2020-10-09 06:09:07 +0200Buntspecht(~user@unaffiliated/siracusa) (Quit: Bye!)
2020-10-09 06:09:36 +0200Jeanne-Kamikaze(~Jeanne-Ka@68.235.43.158) (Ping timeout: 272 seconds)
2020-10-09 06:09:59 +0200ddellacosta(~dd@86.106.121.168) (Ping timeout: 260 seconds)
2020-10-09 06:11:23 +0200g-belmonte(~g-belmont@2804:14c:8786:9312:3638:eaf5:dc36:146d) (Quit: Leaving)
2020-10-09 06:13:27 +0200polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889) (Ping timeout: 260 seconds)
2020-10-09 06:13:28 +0200 <sm[m]> spinnylights: sure! Think I can handle that :)
2020-10-09 06:14:15 +0200dsf(~dsf@cpe-75-82-64-167.socal.res.rr.com) (Quit: Konversation terminated!)
2020-10-09 06:14:37 +0200ericsagnes(~ericsagne@2405:6580:0:5100:9d42:ed56:2b0:8ee0) (Ping timeout: 260 seconds)
2020-10-09 06:15:39 +0200Dungdv(abf4bce2@gateway/web/cgi-irc/kiwiirc.com/ip.171.244.188.226) (Quit: Connection closed)
2020-10-09 06:23:21 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 06:24:39 +0200Dungdv(abf4bce2@gateway/web/cgi-irc/kiwiirc.com/ip.171.244.188.226)
2020-10-09 06:26:30 +0200ericsagnes(~ericsagne@2405:6580:0:5100:841d:b2f8:a54e:9827)
2020-10-09 06:30:47 +0200Tario(~Tario@201.192.165.173) (Ping timeout: 240 seconds)
2020-10-09 06:34:04 +0200GyroW(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-09 06:34:15 +0200GyroW(~GyroW@d54C03E98.access.telenet.be)
2020-10-09 06:34:15 +0200GyroW(~GyroW@d54C03E98.access.telenet.be) (Changing host)
2020-10-09 06:34:15 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-09 06:35:46 +0200day_(~Unknown@unaffiliated/day)
2020-10-09 06:36:45 +0200falafel(~falafel@2605:e000:1527:d491:1ccf:5c8d:7928:e9cc)
2020-10-09 06:36:47 +0200borne(~fritjof@200116b864a02a00739dc2dd650b1f65.dip.versatel-1u1.de) (Ping timeout: 240 seconds)
2020-10-09 06:38:37 +0200Amras(~Amras@unaffiliated/amras0000) (Ping timeout: 272 seconds)
2020-10-09 06:39:00 +0200borne(~fritjof@200116b864025d00484afbeee9030254.dip.versatel-1u1.de)
2020-10-09 06:39:08 +0200day(~Unknown@unaffiliated/day) (Ping timeout: 260 seconds)
2020-10-09 06:39:08 +0200day_day
2020-10-09 06:41:16 +0200_vaibhavingale_(~Adium@203.188.228.27)
2020-10-09 06:42:39 +0200jneira(501e65ce@gateway/web/cgi-irc/kiwiirc.com/ip.80.30.101.206) (Ping timeout: 260 seconds)
2020-10-09 06:43:07 +0200jneira_(~jneira@80.30.101.206) (Ping timeout: 240 seconds)
2020-10-09 06:43:29 +0200jneira_(~jneira@79.red-37-10-144.dynamicip.rima-tde.net)
2020-10-09 06:44:07 +0200borne(~fritjof@200116b864025d00484afbeee9030254.dip.versatel-1u1.de) (Ping timeout: 240 seconds)
2020-10-09 06:48:08 +0200Tario(~Tario@201.192.165.173)
2020-10-09 06:56:07 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2020-10-09 06:58:20 +0200jneira_(~jneira@79.red-37-10-144.dynamicip.rima-tde.net) (Ping timeout: 258 seconds)
2020-10-09 06:59:27 +0200GyroW_(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-09 06:59:28 +0200GyroW_(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-09 06:59:28 +0200GyroW_(~GyroW@unaffiliated/gyrow)
2020-10-09 07:00:25 +0200GyroW(~GyroW@unaffiliated/gyrow) (Ping timeout: 240 seconds)
2020-10-09 07:01:16 +0200 <hololeap> so, a Traversal cannot be used as a lens, but the types make it seem like Traversals are a subset of Lenses
2020-10-09 07:02:01 +0200 <hololeap> type Traversal s t a b = forall f. Applicative f => (a -> f b) -> s -> f t
2020-10-09 07:02:02 +0200nados(~dan@107-190-41-58.cpe.teksavvy.com) (Quit: Leaving)
2020-10-09 07:02:12 +0200 <hololeap> type Lens s t a b = forall f. Functor f => (a -> f b) -> s -> f t
2020-10-09 07:03:11 +0200 <hololeap> since all Applicatives are also Functors, why does it say in the lens docs that a Traversal cannot be used as a Lens
2020-10-09 07:04:14 +0200 <dolio> Functor f => Applicative f, so (Applicative f => T) < (Functor f => T)
2020-10-09 07:05:07 +0200Dungdv(abf4bce2@gateway/web/cgi-irc/kiwiirc.com/ip.171.244.188.226) (Ping timeout: 240 seconds)
2020-10-09 07:06:24 +0200 <dolio> Wait, I wrote some of that backwards, didn't I?
2020-10-09 07:06:37 +0200 <hololeap> right, the set of Applicatives is a subset of the set of Functors
2020-10-09 07:06:40 +0200 <dolio> Anyhow, the subtyping relationship flips on the left of an arrow.
2020-10-09 07:07:00 +0200 <hololeap> so shouldn't the same be true for Traversals vs Lenses?
2020-10-09 07:07:47 +0200 <hololeap> therefore, any Traversal is also a Lens?
2020-10-09 07:07:53 +0200 <dibblego> it's the other way around
2020-10-09 07:08:08 +0200 <dolio> Applicative is the subtype.
2020-10-09 07:08:29 +0200natechan(~natechan@108-233-125-227.lightspeed.sntcca.sbcglobal.net)
2020-10-09 07:09:13 +0200 <hololeap> any Applicative is also a Functor, therefore any Traversal should also be a Lens. what am i missing here?
2020-10-09 07:09:27 +0200 <dibblego> any Applicative is also a Functor, therefore any Lens should also be a Traversal
2020-10-09 07:09:57 +0200 <hololeap> but why?
2020-10-09 07:10:03 +0200 <dolio> Lenses work for every Functor, so they also work for every Applicative.
2020-10-09 07:10:11 +0200 <dibblego> because the types say so
2020-10-09 07:10:31 +0200 <dibblego> the constraint is in contravariant position
2020-10-09 07:10:33 +0200 <hololeap> oh, i get it now
2020-10-09 07:11:15 +0200 <hololeap> that was a little tricky :)
2020-10-09 07:12:05 +0200 <dibblego> Applicative f => f a -> b -- this function not only accepts any Applicative, but also any Functor
2020-10-09 07:13:38 +0200 <hololeap> that's freaky. i never thought about the fact that constraints could be contravariant
2020-10-09 07:13:48 +0200 <hololeap> although it makes total sense intuitively
2020-10-09 07:15:47 +0200fresheyeball(~isaac@c-71-237-105-37.hsd1.co.comcast.net) (Ping timeout: 240 seconds)
2020-10-09 07:16:45 +0200 <hololeap> dolio: what is a subtyping relationship?
2020-10-09 07:17:29 +0200 <dolio> A is a subtype of B if every A can be used when a B is required.
2020-10-09 07:18:37 +0200 <hololeap> i reread the sentence, and you're saying that if it's used in the negative position, the relationship is reversed, aka contravariant
2020-10-09 07:19:14 +0200 <dolio> Yes.
2020-10-09 07:20:56 +0200jedws(~jedws@121.209.161.98)
2020-10-09 07:21:05 +0200 <hololeap> although, in these cases, the constraint is placed on a variable that appears in the negative and positive positions
2020-10-09 07:21:17 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-09 07:22:18 +0200sand_dull(~theuser@104.140.53.43) (Ping timeout: 260 seconds)
2020-10-09 07:23:56 +0200 <dolio> That part doesn't matter, because what's being subtyped is the type class, basically.
2020-10-09 07:24:15 +0200 <dolio> You could think of it as the dictionaries being subtypes, if you want.
2020-10-09 07:25:09 +0200 <hololeap> wait, what are these dictionaries you mentioned?
2020-10-09 07:26:10 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 256 seconds)
2020-10-09 07:26:38 +0200coot(~coot@37.30.49.218.nat.umts.dynamic.t-mobile.pl)
2020-10-09 07:27:26 +0200 <dolio> A record that contains the methods and superclasses of the type class.
2020-10-09 07:28:21 +0200 <dolio> For Functor, {fmap}, and for Applicative, {fmap, pure, (<*>)}, or something.
2020-10-09 07:29:24 +0200aqd(~aqd@87-92-145-87.rev.dnainternet.fi)
2020-10-09 07:29:40 +0200 <spinnylights> sm[m]: submitted ^^ there were a few small config changes needed as well but it should only a take a moment to look over
2020-10-09 07:30:08 +0200 <hololeap> you know, the more i think about it, the more i see the obviousness of the answer here. i'm not sure what made me think it would be otherwise >_>
2020-10-09 07:30:45 +0200alp(~alp@2a01:e0a:58b:4920:c189:de1b:78e1:7d82)
2020-10-09 07:31:15 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2020-10-09 07:31:16 +0200 <dolio> Well, the fact that it's written `Functor f => Applicative f` probably doesn't help.
2020-10-09 07:32:43 +0200 <hololeap> it's saying that Functor f is equal to or larger then Applicative :)
2020-10-09 07:32:50 +0200 <dolio> It even made me give you the wrong answer at first.
2020-10-09 07:36:15 +0200alp(~alp@2a01:e0a:58b:4920:c189:de1b:78e1:7d82) (Ping timeout: 272 seconds)
2020-10-09 07:37:14 +0200 <proofofme> One more question: How do I process a type of `IO (Maybe [String])` line by line? For now, just to `print` it line by line. `print =<< allStrings` works, but it doesn't provide the line-by-line control
2020-10-09 07:38:02 +0200 <Taneb> :t mapM_
2020-10-09 07:38:16 +0200 <lambdabot> (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
2020-10-09 07:38:47 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-10-09 07:38:58 +0200 <Taneb> proofofme: if you make a function of type "Maybe [String] -> IO a" then you can use it with (=<<) like you're doing with print
2020-10-09 07:39:22 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 07:40:20 +0200dyeplexer(~lol@unaffiliated/terpin)
2020-10-09 07:42:42 +0200falafel(~falafel@2605:e000:1527:d491:1ccf:5c8d:7928:e9cc) (Ping timeout: 260 seconds)
2020-10-09 07:43:39 +0200Guest40023lep-delete
2020-10-09 07:43:40 +0200lep-deleteGuest40023
2020-10-09 07:43:42 +0200Guest40023lep-delete
2020-10-09 07:44:53 +0200proofofme(~proofofme@184-96-74-65.hlrn.qwest.net) (Remote host closed the connection)
2020-10-09 07:46:07 +0200xff0x(~fox@2001:1a81:53da:5200:18dc:5fd3:ab0c:ba1c) (Ping timeout: 240 seconds)
2020-10-09 07:47:36 +0200xff0x(~fox@2001:1a81:53da:5200:18dc:5fd3:ab0c:ba1c)
2020-10-09 07:48:15 +0200maroloccio(~marolocci@212.129.85.119)
2020-10-09 07:49:17 +0200GyroW_(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-09 07:49:35 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-09 07:49:36 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-09 07:49:36 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-09 07:58:39 +0200Dungdv(abf4bce2@gateway/web/cgi-irc/kiwiirc.com/ip.171.244.188.226)
2020-10-09 08:00:01 +0200jpcw1(~jpcw@195.206.169.184) ()
2020-10-09 08:00:07 +0200solonarv(~solonarv@adijon-655-1-70-207.w90-13.abo.wanadoo.fr) (Ping timeout: 240 seconds)
2020-10-09 08:00:24 +0200 <Axman6> :t mapM (mapM putStrLn)
2020-10-09 08:00:27 +0200 <lambdabot> (Traversable t1, Traversable t2) => t1 (t2 String) -> IO (t1 (t2 ()))
2020-10-09 08:00:44 +0200 <Axman6> :t mapM (mapM putStrLn) `asAppliedTo` (undefined :: Maybe [String])
2020-10-09 08:00:46 +0200 <lambdabot> Maybe [String] -> IO (Maybe [()])
2020-10-09 08:01:10 +0200 <Axman6> :t mapM_ (mapM_ putStrLn) `asAppliedTo` (undefined :: Maybe [String])
2020-10-09 08:01:12 +0200 <lambdabot> Maybe [String] -> IO ()
2020-10-09 08:02:37 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-09 08:03:06 +0200danvet_(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa)
2020-10-09 08:03:24 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 08:04:17 +0200kori(~kori@arrowheads/kori) (Ping timeout: 260 seconds)
2020-10-09 08:06:45 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2020-10-09 08:07:47 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 240 seconds)
2020-10-09 08:12:15 +0200toorevitimirp(~tooreviti@117.182.180.245)
2020-10-09 08:19:27 +0200hackageZ-Data 0.1.5.0 - Array, vector and text https://hackage.haskell.org/package/Z-Data-0.1.5.0 (winterland)
2020-10-09 08:20:56 +0200 <hololeap> type Iso s t a b = forall p f. (Profunctor p, Functor f) => p a (f b) -> p s (f t)
2020-10-09 08:21:21 +0200 <hololeap> could this not be simplified since Star f is already a profunctor?
2020-10-09 08:21:44 +0200 <hololeap> type Iso s t a b = forall p. Profunctor p => p a b -> p s t
2020-10-09 08:25:58 +0200 <hololeap> maybe this would conflict with Lens, etc being a subtype of Iso
2020-10-09 08:26:08 +0200 <hololeap> that must be the reason
2020-10-09 08:27:19 +0200 <Taneb> hololeap: yeah, that's the reason
2020-10-09 08:27:29 +0200 <Taneb> We want to be able to compose a lens with an iso
2020-10-09 08:27:33 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 08:27:38 +0200chele(~chele@ip5b416ea2.dynamic.kabel-deutschland.de)
2020-10-09 08:27:47 +0200 <Taneb> There's another style of lenses called "pure profunctor" lenses
2020-10-09 08:28:12 +0200sfvm(~sfvm@37.228.215.148) (Quit: off to the basement, mixing up the medicine)
2020-10-09 08:28:24 +0200 <Taneb> Which I think has type Lens s t a b = Strong p => p a b -> p s t
2020-10-09 08:29:34 +0200 <hololeap> oh ok
2020-10-09 08:29:45 +0200xQc(b644f401@182.68.244.1)
2020-10-09 08:29:53 +0200 <Taneb> lens doesn't use that because it means you can't define lenses while only depending on base
2020-10-09 08:32:06 +0200Ariakenom(~Ariakenom@193.254.193.1)
2020-10-09 08:32:15 +0200 <hololeap> it's interesting to me that not all Profunctors are Categories, which means some Profunctors don't compose, i would assume
2020-10-09 08:33:10 +0200 <Taneb> Yeah. The composition here uses the (->) in the middle
2020-10-09 08:36:00 +0200 <hololeap> could Lenses be generalized to: Lens s t a b = forall cat p. (Category cat, Strong p) => p a b `cat` p s t
2020-10-09 08:36:45 +0200 <Taneb> Hmm, sort of? But you get something different to a lens
2020-10-09 08:37:00 +0200 <Taneb> Basically, you'll only be able to define ones that are "id"
2020-10-09 08:38:32 +0200 <hololeap> (Monad m, Strong p) => Kleisli m (p a b) (p s t) -- could this be useful?
2020-10-09 08:39:07 +0200 <Taneb> That doesn't give you anything that (->) doesn't, I think
2020-10-09 08:39:43 +0200 <Taneb> Because the only way you can define one of those is essentially with arr somelens
2020-10-09 08:40:17 +0200HaskellYogi(~vivekrama@49.207.212.129) (Remote host closed the connection)
2020-10-09 08:41:07 +0200 <xQc> I was trying to define a list recursively. Can someone explain why these two approaches return different result? I think they are defined exactly the same https://pastebin.com/w7BTL1wn
2020-10-09 08:41:13 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 08:41:21 +0200 <hololeap> the rabbit hole is deep here :p
2020-10-09 08:43:05 +0200Dungdv(abf4bce2@gateway/web/cgi-irc/kiwiirc.com/ip.171.244.188.226) (Ping timeout: 240 seconds)
2020-10-09 08:44:09 +0200falafel(~falafel@2605:e000:1527:d491:1ccf:5c8d:7928:e9cc)
2020-10-09 08:45:47 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 240 seconds)
2020-10-09 08:47:25 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 08:50:34 +0200Dungdv(abf4bce2@gateway/web/cgi-irc/kiwiirc.com/ip.171.244.188.226)
2020-10-09 08:51:48 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 258 seconds)
2020-10-09 08:52:00 +0200 <hololeap> myfibs = 1:1:1:2:(1+(0-1)+(2*2)):(1+(0-1)+(2*(1+(0-1)+(2*2)))):(1+(0-1)+(2*((1+(0-1)+(2*(1+(0-1)+(2*2))))))
2020-10-09 08:52:07 +0200 <hololeap> ...
2020-10-09 08:53:03 +0200 <olligobber> hololeap, parse error (possibly incorrect indentation or mismatched brackets)
2020-10-09 08:53:10 +0200tzh(~tzh@2601:448:c500:5300::143b) (Quit: zzz)
2020-10-09 08:53:42 +0200 <hololeap> the applicative instance of [] is a cartesian product
2020-10-09 08:54:14 +0200 <olligobber> added an extra bracket and :[] and got [1,1,1,2,4,8,16]
2020-10-09 08:54:18 +0200 <olligobber> "fibs"
2020-10-09 08:54:25 +0200fr33domlover(~fr33domlo@fsf/member/fr33domlover) (Quit: fr33domlover)
2020-10-09 08:54:50 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de)
2020-10-09 08:54:55 +0200fr33domlover(~fr33domlo@fsf/member/fr33domlover)
2020-10-09 08:55:04 +0200 <hololeap> Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
2020-10-09 08:55:24 +0200Sgeo(~Sgeo@ool-18b982ad.dyn.optonline.net) (Read error: Connection reset by peer)
2020-10-09 08:55:56 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de) (Remote host closed the connection)
2020-10-09 08:56:09 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de)
2020-10-09 08:56:13 +0200 <hololeap> for the list instance of Applicative, it will start with the first values of `f a` and `f b`, along with _every value_ of `f c`
2020-10-09 08:56:25 +0200 <hololeap> if `f c` is infinite, you can imagine what happens
2020-10-09 08:56:58 +0200 <xQc> oh. I think i get the error
2020-10-09 08:57:08 +0200 <xQc> I guess I have to use the ZipList class?
2020-10-09 08:57:44 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 265 seconds)
2020-10-09 08:58:01 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 08:59:07 +0200 <hololeap> yeah, that might work
2020-10-09 08:59:09 +0200hololeapshrugs
2020-10-09 08:59:17 +0200poljar(~poljar@93-139-70-179.adsl.net.t-com.hr) (Remote host closed the connection)
2020-10-09 08:59:38 +0200 <hololeap> it seems like it would, with my brain's limited computing power
2020-10-09 08:59:47 +0200poljar(~poljar@93-139-70-179.adsl.net.t-com.hr)
2020-10-09 09:02:45 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 240 seconds)
2020-10-09 09:04:00 +0200Super_Feeling(~Super_Fee@103.108.4.50)
2020-10-09 09:04:23 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 09:04:41 +0200Super_Feeling(~Super_Fee@103.108.4.50) (Client Quit)
2020-10-09 09:05:16 +0200berberman(~berberman@123.118.111.156)
2020-10-09 09:08:27 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 240 seconds)
2020-10-09 09:08:50 +0200alp(~alp@2a01:e0a:58b:4920:a1ed:32ca:ea5a:70c4)
2020-10-09 09:09:02 +0200dhouthoo(~dhouthoo@ptr-eiv6509pb4ifhdr9lsd.18120a2.ip6.access.telenet.be)
2020-10-09 09:09:45 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 09:10:08 +0200berberman(~berberman@123.118.111.156) (Client Quit)
2020-10-09 09:11:10 +0200berberman(~berberman@2408:8207:2563:44a0::a44)
2020-10-09 09:14:20 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 256 seconds)
2020-10-09 09:14:53 +0200jedws(~jedws@121.209.161.98) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 09:15:41 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 09:17:38 +0200 <dminuoso> 09:02:56 hololeap | [06:32:15] it's interesting to me that not all Profunctors are Categories, which means some Profunctors don't compose, i would assume
2020-10-09 09:17:57 +0200 <dminuoso> Hi, out of curiosities, are not all profunctors composable via coends in bicategories?
2020-10-09 09:18:10 +0200jedws(~jedws@121.209.161.98)
2020-10-09 09:18:56 +0200vilpan(~0@mail.elitnet.lt)
2020-10-09 09:19:42 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 09:20:00 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 256 seconds)
2020-10-09 09:23:06 +0200random(~random@185.219.70.106)
2020-10-09 09:23:25 +0200 <random> hey guys, does anyone know if you can generate a "create table" command with persistent
2020-10-09 09:23:29 +0200berberman(~berberman@2408:8207:2563:44a0::a44) (Quit: ZNC 1.7.5 - https://znc.in)
2020-10-09 09:23:34 +0200 <random> I know it's doable because the automatic migrations do it but I can't seem to find a way
2020-10-09 09:24:08 +0200berberman(~berberman@2408:8207:2563:44a0::a44)
2020-10-09 09:27:30 +0200danso(~dan@107-190-41-58.cpe.teksavvy.com) (Read error: Connection reset by peer)
2020-10-09 09:27:40 +0200kaimi1(~kaimi@185.244.214.216)
2020-10-09 09:28:10 +0200danso(~dan@107-190-41-58.cpe.teksavvy.com)
2020-10-09 09:31:16 +0200psygate(~psygate@unaffiliated/psygate)
2020-10-09 09:31:17 +0200fendor(~fendor@77.119.131.69.wireless.dyn.drei.com)
2020-10-09 09:31:43 +0200psygate(~psygate@unaffiliated/psygate) (Client Quit)
2020-10-09 09:32:16 +0200Franciman(~francesco@host-95-247-31-62.retail.telecomitalia.it)
2020-10-09 09:34:53 +0200borne(~fritjof@200116b864025d00739dc2dd650b1f65.dip.versatel-1u1.de)
2020-10-09 09:36:38 +0200jjhoo(jahakala@dsl-trebng21-58c19c-166.dhcp.inet.fi) (Ping timeout: 246 seconds)
2020-10-09 09:38:31 +0200John20(~John@82.46.59.122)
2020-10-09 09:40:27 +0200p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515)
2020-10-09 09:41:07 +0200GyroW(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-09 09:41:21 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-09 09:41:21 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-09 09:41:21 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-09 09:41:25 +0200chaosmasttter(~chaosmast@p200300c4a70b4001c004325a2a510724.dip0.t-ipconnect.de)
2020-10-09 09:42:04 +0200danso(~dan@107-190-41-58.cpe.teksavvy.com) (Quit: WeeChat 2.9)
2020-10-09 09:43:01 +0200sagax(~sagax_nb@213.138.71.146) (Read error: Connection reset by peer)
2020-10-09 09:43:48 +0200toorevitimirp(~tooreviti@117.182.180.245) (Ping timeout: 256 seconds)
2020-10-09 09:44:05 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 240 seconds)
2020-10-09 09:44:11 +0200ryansmccoy(~ryansmcco@193.37.254.27) (Ping timeout: 260 seconds)
2020-10-09 09:44:23 +0200ryansmccoy(~ryansmcco@156.96.151.132)
2020-10-09 09:44:32 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 09:47:53 +0200remexre(~remexre@x-160-94-179-160.acm.umn.edu) (Quit: WeeChat 2.8)
2020-10-09 09:48:02 +0200remexre_(~nathan@207-153-38-50.fttp.usinternet.com)
2020-10-09 09:48:07 +0200falafel(~falafel@2605:e000:1527:d491:1ccf:5c8d:7928:e9cc) (Ping timeout: 260 seconds)
2020-10-09 09:50:06 +0200todda7(~torstein@2a02:587:d2d:4f00:1158:6d78:eb7d:9777)
2020-10-09 09:50:49 +0200chele_(~chele@ip5b416ea2.dynamic.kabel-deutschland.de)
2020-10-09 09:51:24 +0200xQc(b644f401@182.68.244.1) (Remote host closed the connection)
2020-10-09 09:53:31 +0200chele(~chele@ip5b416ea2.dynamic.kabel-deutschland.de) (Ping timeout: 258 seconds)
2020-10-09 09:56:53 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de) (Remote host closed the connection)
2020-10-09 09:57:21 +0200proofofme(~proofofme@184-96-74-65.hlrn.qwest.net)
2020-10-09 09:57:22 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de)
2020-10-09 09:57:42 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 10:00:18 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c)
2020-10-09 10:00:25 +0200cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net) (Ping timeout: 258 seconds)
2020-10-09 10:01:26 +0200vicfred(~vicfred@unaffiliated/vicfred) (Quit: Leaving)
2020-10-09 10:01:27 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-09 10:02:23 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 260 seconds)
2020-10-09 10:03:06 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 10:03:57 +0200GyroW(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-09 10:04:07 +0200GyroW(~GyroW@d54C03E98.access.telenet.be)
2020-10-09 10:04:08 +0200GyroW(~GyroW@d54C03E98.access.telenet.be) (Changing host)
2020-10-09 10:04:08 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-09 10:04:17 +0200kritzefitz(~kritzefit@2003:5b:203b:100:c23e:baff:feb8:8cdb)
2020-10-09 10:06:49 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c) (Quit: My MacBook Air has gone to sleep. ZZZzzz…)
2020-10-09 10:07:42 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c)
2020-10-09 10:08:20 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c) (Client Quit)
2020-10-09 10:08:32 +0200p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515) (Ping timeout: 260 seconds)
2020-10-09 10:09:06 +0200dansho(~dansho@ip68-108-167-185.lv.lv.cox.net)
2020-10-09 10:10:45 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 240 seconds)
2020-10-09 10:11:05 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 240 seconds)
2020-10-09 10:11:40 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-09 10:12:31 +0200raichoo(~raichoo@213.240.178.58)
2020-10-09 10:12:40 +0200dqd(id@wikipedia/dqd) (Ping timeout: 246 seconds)
2020-10-09 10:12:51 +0200vicfred(~vicfred@unaffiliated/vicfred)
2020-10-09 10:13:15 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 10:14:39 +0200proofofme(~proofofme@184-96-74-65.hlrn.qwest.net) (Remote host closed the connection)
2020-10-09 10:15:51 +0200proofofme(~proofofme@184-96-74-65.hlrn.qwest.net)
2020-10-09 10:16:08 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 258 seconds)
2020-10-09 10:17:36 +0200acowley(~acowley@c-68-83-22-43.hsd1.nj.comcast.net) (Read error: Connection reset by peer)
2020-10-09 10:17:48 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 256 seconds)
2020-10-09 10:17:54 +0200cpressey(~cpressey@79-72-202-104.dynamic.dsl.as9105.com)
2020-10-09 10:18:08 +0200berberman(~berberman@2408:8207:2563:44a0::a44) (Quit: ZNC 1.7.5 - https://znc.in)
2020-10-09 10:19:00 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 10:20:00 +0200jedws(~jedws@121.209.161.98) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 10:20:05 +0200proofofme(~proofofme@184-96-74-65.hlrn.qwest.net) (Ping timeout: 240 seconds)
2020-10-09 10:20:05 +0200dqd(id@wikipedia/dqd)
2020-10-09 10:20:32 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311) ()
2020-10-09 10:21:34 +0200proofofme(~proofofme@184-96-74-65.hlrn.qwest.net)
2020-10-09 10:21:36 +0200acowley(~acowley@c-68-83-22-43.hsd1.nj.comcast.net)
2020-10-09 10:23:37 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 264 seconds)
2020-10-09 10:24:28 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 10:26:03 +0200drbean(~drbean@TC210-63-209-62.static.apol.com.tw) (Ping timeout: 260 seconds)
2020-10-09 10:28:05 +0200turion(~turion@ip1f10fe5a.dynamic.kabel-deutschland.de)
2020-10-09 10:28:17 +0200turion(~turion@ip1f10fe5a.dynamic.kabel-deutschland.de) (Client Quit)
2020-10-09 10:29:03 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de)
2020-10-09 10:29:05 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 265 seconds)
2020-10-09 10:29:28 +0200maroloccio(~marolocci@212.129.85.119) (Ping timeout: 246 seconds)
2020-10-09 10:30:24 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 10:32:05 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 10:32:49 +0200worc3131(~quassel@2a02:c7f:c026:9500:7d0b:65d0:38a4:4786)
2020-10-09 10:32:58 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt)
2020-10-09 10:33:08 +0200LKoen(~LKoen@81.255.219.130)
2020-10-09 10:33:14 +0200cosimone(~cosimone@2001:b07:ae5:db26:a16f:75:586:b3b0)
2020-10-09 10:34:55 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 258 seconds)
2020-10-09 10:36:45 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de) (Ping timeout: 272 seconds)
2020-10-09 10:37:39 +0200nyd(~lpy@unaffiliated/elysian)
2020-10-09 10:37:59 +0200berberman(~berberman@2408:8207:2569:5270:584e:a9ff:fe9b:d3fe)
2020-10-09 10:38:14 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 10:38:59 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt) (Ping timeout: 256 seconds)
2020-10-09 10:39:04 +0200vicfred(~vicfred@unaffiliated/vicfred) (Quit: Leaving)
2020-10-09 10:40:09 +0200vicfred(~vicfred@unaffiliated/vicfred)
2020-10-09 10:40:27 +0200cosimone(~cosimone@2001:b07:ae5:db26:a16f:75:586:b3b0) (Remote host closed the connection)
2020-10-09 10:40:51 +0200cosimone(~cosimone@2001:b07:ae5:db26:a16f:75:586:b3b0)
2020-10-09 10:40:57 +0200hackageuniqueness-periods-vector-common 0.5.0.0 - Generalization of the dobutokO-poetry-general package functionality https://hackage.haskell.org/package/uniqueness-periods-vector-common-0.5.0.0 (OleksandrZhabenko)
2020-10-09 10:41:05 +0200o1lo01ol_(~o1lo01ol1@bl8-213-81.dsl.telepac.pt)
2020-10-09 10:41:51 +0200berberman(~berberman@2408:8207:2569:5270:584e:a9ff:fe9b:d3fe) (Remote host closed the connection)
2020-10-09 10:42:08 +0200cosimone(~cosimone@2001:b07:ae5:db26:a16f:75:586:b3b0) (Client Quit)
2020-10-09 10:42:27 +0200xff0x(~fox@2001:1a81:53da:5200:18dc:5fd3:ab0c:ba1c) (Ping timeout: 240 seconds)
2020-10-09 10:43:06 +0200worc3131(~quassel@2a02:c7f:c026:9500:7d0b:65d0:38a4:4786) (Remote host closed the connection)
2020-10-09 10:43:18 +0200howdoi(uid224@gateway/web/irccloud.com/x-matykgsofoxxiiee) (Quit: Connection closed for inactivity)
2020-10-09 10:43:29 +0200xff0x(~fox@2001:1a81:53da:5200:e942:2dc6:3612:ec91)
2020-10-09 10:43:34 +0200berberman(~berberman@2408:8207:2569:5270:584e:a9ff:fe9b:d3fe)
2020-10-09 10:43:39 +0200bliminse(~bliminse@host217-42-95-37.range217-42.btcentralplus.com)
2020-10-09 10:43:47 +0200proofofme(~proofofme@184-96-74-65.hlrn.qwest.net) (Remote host closed the connection)
2020-10-09 10:43:55 +0200verement(~anonymous@cpe-76-167-229-223.san.res.rr.com) (Quit: verement)
2020-10-09 10:44:08 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 260 seconds)
2020-10-09 10:44:51 +0200berberman(~berberman@2408:8207:2569:5270:584e:a9ff:fe9b:d3fe) (Client Quit)
2020-10-09 10:47:33 +0200thc202(~thc202@unaffiliated/thc202)
2020-10-09 10:49:13 +0200berberman(~berberman@2408:8207:2569:5270:584e:a9ff:fe9b:d3fe)
2020-10-09 10:50:22 +0200berberman(~berberman@2408:8207:2569:5270:584e:a9ff:fe9b:d3fe) (Client Quit)
2020-10-09 10:50:30 +0200o1lo01ol_(~o1lo01ol1@bl8-213-81.dsl.telepac.pt) (Read error: Connection reset by peer)
2020-10-09 10:50:37 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt)
2020-10-09 10:50:44 +0200berberman(~berberman@2408:8207:2569:5270:584e:a9ff:fe9b:d3fe)
2020-10-09 10:50:57 +0200hackageuniqueness-periods-vector-general 0.5.0.0 - Some kind of the optimization approach to data inner structure. https://hackage.haskell.org/package/uniqueness-periods-vector-general-0.5.0.0 (OleksandrZhabenko)
2020-10-09 10:52:39 +0200sagax(~sagax_nb@213.138.71.146)
2020-10-09 10:57:13 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 10:57:14 +0200hnOsmium0001(uid453710@gateway/web/irccloud.com/x-fnhpronrbczootvp) (Quit: Connection closed for inactivity)
2020-10-09 10:57:58 +0200hackageuniqueness-periods-vector-properties 0.5.0.0 - Metrices for the maximum element for the uniqueness-periods-vector packages family. https://hackage.haskell.org/package/uniqueness-periods-vector-properties-0.5.0.0 (OleksandrZhabenko)
2020-10-09 11:00:02 +0200kaimi1(~kaimi@185.244.214.216) ()
2020-10-09 11:01:22 +0200polyrain(~polyrain@2001:8003:e501:6901:d439:cec4:3811:73e4) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 11:01:27 +0200jedws(~jedws@121.209.161.98)
2020-10-09 11:02:19 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-10-09 11:04:03 +0200DavSanchez[m](davsanchez@gateway/shell/matrix.org/x-khetygqiqqqbmftv) ("Kicked by @appservice-irc:matrix.org : Idle for 30+ days")
2020-10-09 11:04:06 +0200sajith[m](sajithmatr@gateway/shell/matrix.org/x-nztmgmuycmbqrvoe) ("Kicked by @appservice-irc:matrix.org : Idle for 30+ days")
2020-10-09 11:04:14 +0200itai33[m](itai33matr@gateway/shell/matrix.org/x-cwbivzdyksbwtkzq) ("Kicked by @appservice-irc:matrix.org : Idle for 30+ days")
2020-10-09 11:10:25 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de)
2020-10-09 11:11:13 +0200 <xwvvvvwx> Hi, so I want to generate strings in quickcheck that never repeat themselves. I'm fuzzing a parser, and I need unique random names for identifiers.
2020-10-09 11:11:18 +0200 <xwvvvvwx> Does anyone have any tips?
2020-10-09 11:12:45 +0200 <Taneb> xwvvvvwx: can you use the arbitrary instance for Set? I think that would work if you only need a small number of names
2020-10-09 11:13:25 +0200polyrain(~polyrain@2001:8003:e501:6901:c889:b4c6:945c:a1ea)
2020-10-09 11:13:47 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 240 seconds)
2020-10-09 11:13:47 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt) (Ping timeout: 260 seconds)
2020-10-09 11:13:55 +0200bliminse(~bliminse@host217-42-95-37.range217-42.btcentralplus.com) (Quit: leaving)
2020-10-09 11:14:16 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt)
2020-10-09 11:14:27 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-09 11:14:54 +0200bliminse(~bliminse@host217-42-95-37.range217-42.btcentralplus.com)
2020-10-09 11:15:01 +0200 <xwvvvvwx> ohhhhhh clever
2020-10-09 11:15:09 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 11:15:27 +0200 <xwvvvvwx> and then pull a random element from the set?
2020-10-09 11:16:39 +0200todda7(~torstein@2a02:587:d2d:4f00:1158:6d78:eb7d:9777) (Ping timeout: 272 seconds)
2020-10-09 11:18:17 +0200 <xwvvvvwx> or no if I pull a random elemnent I might repeat myself
2020-10-09 11:18:25 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt) (Ping timeout: 240 seconds)
2020-10-09 11:18:27 +0200hackageopenapi3 3.0.0.1 - OpenAPI 3.0 data model https://hackage.haskell.org/package/openapi3-3.0.0.1 (maksbotan)
2020-10-09 11:18:37 +0200 <xwvvvvwx> I need to have some counter to make sure I never pull the same element
2020-10-09 11:18:42 +0200 <phadej> you cannot have "unique randoms" without carrying some state with you
2020-10-09 11:19:01 +0200berberman(~berberman@2408:8207:2569:5270:584e:a9ff:fe9b:d3fe) (Quit: ZNC 1.7.5 - https://znc.in)
2020-10-09 11:19:32 +0200 <dminuoso> xwvvvvwx: Just a hunch.. but you are not looking for `unbound`, are you? :>
2020-10-09 11:20:16 +0200 <xwvvvvwx> https://hackage.haskell.org/package/unbound ?
2020-10-09 11:20:19 +0200 <dminuoso> Yes.
2020-10-09 11:20:33 +0200 <dminuoso> Oh wait, I missed the QuickCheck part. Nevermind me.
2020-10-09 11:20:43 +0200berberman(~berberman@2408:8207:2569:5270:584e:a9ff:fe9b:d3fe)
2020-10-09 11:20:57 +0200hackageservant-openapi3 2.0.0.1 - Generate a Swagger/OpenAPI/OAS 3.0 specification for your servant API. https://hackage.haskell.org/package/servant-openapi3-2.0.0.1 (maksbotan)
2020-10-09 11:20:59 +0200tw1sted1(~tw1sted@184.75.221.3)
2020-10-09 11:21:53 +0200berberman(~berberman@2408:8207:2569:5270:584e:a9ff:fe9b:d3fe) (Client Quit)
2020-10-09 11:22:01 +0200ubert(~Thunderbi@2a02:8109:9880:303c:ca5b:76ff:fe29:f233)
2020-10-09 11:22:17 +0200 <xwvvvvwx> Can I do something with the state monad?
2020-10-09 11:22:41 +0200berberman(~berberman@2408:8207:2569:5270:584e:a9ff:fe9b:d3fe)
2020-10-09 11:24:20 +0200jedws(~jedws@121.209.161.98) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 11:24:25 +0200__monty__(~toonn@unaffiliated/toonn)
2020-10-09 11:24:57 +0200ahmr88(~ahmr88@cpc85006-haye22-2-0-cust131.17-4.cable.virginm.net)
2020-10-09 11:26:13 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt)
2020-10-09 11:26:45 +0200berberman(~berberman@2408:8207:2569:5270:584e:a9ff:fe9b:d3fe) (Client Quit)
2020-10-09 11:27:00 +0200berberman(~berberman@123.118.111.247)
2020-10-09 11:27:51 +0200 <phadej> you can work with StateT something Gen yes
2020-10-09 11:30:11 +0200 <phadej> But i'd rather rethink whether you really need unique random names
2020-10-09 11:30:14 +0200 <phadej> to begin with
2020-10-09 11:30:30 +0200 <carbolymer> I need to block thread indefinitely - `newEmptyMVar >>= takeMVar` - is it a good idea?
2020-10-09 11:30:44 +0200 <phadej> that's something (uniqueness) which is hard to maintain in shrinking
2020-10-09 11:31:22 +0200 <phadej> carbolymer: that might not work, as you might get a "BlockedIndefinitelyOnMVar" exception
2020-10-09 11:31:43 +0200 <phadej> why you want to block indefinitely, that doesn't sound right
2020-10-09 11:31:57 +0200 <phadej> surely there' something you can wait on
2020-10-09 11:32:24 +0200 <carbolymer> phadej, we have weird app shutdown process implemented - all services are getting `cancel`-ed (from async)
2020-10-09 11:32:36 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt) (Ping timeout: 272 seconds)
2020-10-09 11:32:43 +0200 <carbolymer> phadej, so my idea is to catch AsyncCancelled and perform resources cleanup
2020-10-09 11:33:24 +0200 <phadej> they [async'd threads] will do cleanup if you use `bracket`?
2020-10-09 11:33:31 +0200 <phadej> ... to acquire them
2020-10-09 11:33:34 +0200 <phadej> no need to catch anything
2020-10-09 11:33:45 +0200 <carbolymer> phadej, I can't use bracket, because the cleanup has to be done a completely different place
2020-10-09 11:34:03 +0200kl1xto(~klixto@49.188.65.219)
2020-10-09 11:34:14 +0200 <carbolymer> our app design is flawed :/
2020-10-09 11:34:38 +0200kl1xto(~klixto@49.188.65.219) (Client Quit)
2020-10-09 11:34:45 +0200 <carbolymer> phadej, so my idea is to `(newEmptyMVar >>= takeMVar) `catch` (\(_ :: AsyncCancelled) -> doCleanup)`
2020-10-09 11:34:46 +0200 <phadej> anyway, you can have "this thread is completed" TVar for each thread, and wait until they become `True`
2020-10-09 11:35:08 +0200 <dminuoso> carbolymer: How about, instead of throwing an async exception, you use an MVar?
2020-10-09 11:35:21 +0200 <dminuoso> That way you can just take from an initially empty MVar, and if the other side wants to terminate, they just put to it?
2020-10-09 11:35:26 +0200 <[exa]> async exception?!
2020-10-09 11:35:39 +0200 <phadej> yes, what dminuoso proposes is better.
2020-10-09 11:35:42 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net)
2020-10-09 11:35:45 +0200 <phadej> make something to wait upon, and wait on it.
2020-10-09 11:36:17 +0200 <phadej> flawed current state is not a good reason to make it even worse :)
2020-10-09 11:36:28 +0200 <carbolymer> dminuoso, that would work I guess, it would be a precedent though
2020-10-09 11:36:49 +0200 <phadej> feels like there is no clear resource ownership
2020-10-09 11:37:00 +0200 <carbolymer> yeah...
2020-10-09 11:37:53 +0200 <[exa]> carbolymer: do the services somehow process "requests" or "data packages" or anything?
2020-10-09 11:38:47 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt)
2020-10-09 11:39:09 +0200 <carbolymer> [exa], yes
2020-10-09 11:40:07 +0200 <[exa]> the usual way is to either have a special request that says "all done, pls exit", or even better a shared exit flag (simple wrapped IORef will do) that the tiny services check regularly
2020-10-09 11:43:21 +0200 <carbolymer> [exa], I agree, it's aka poison pill, If I were implmeenting the app from scratch, I would implement it that way, it's just it was done previously by canceling services
2020-10-09 11:43:47 +0200 <carbolymer> and I wanted to fit in, without week-long refactoring ;)
2020-10-09 11:43:57 +0200hackagehasql-dynamic-statements 0.2.0.3 - Toolkit for constructing Hasql statements dynamically https://hackage.haskell.org/package/hasql-dynamic-statements-0.2.0.3 (NikitaVolkov)
2020-10-09 11:44:43 +0200 <phadej> Haskell is the language to do refactorings
2020-10-09 11:45:21 +0200 <phadej> very enjoyable if you are sure what's the end state should be, IMO.
2020-10-09 11:45:25 +0200 <phadej> would rather do sooner than later.
2020-10-09 11:45:32 +0200 <carbolymer> but when you can deliver business values, when all you do is refactoring? :)
2020-10-09 11:45:44 +0200 <phadej> on mondays.
2020-10-09 11:45:50 +0200 <carbolymer> on meetings ;-]
2020-10-09 11:45:53 +0200ahmr88(~ahmr88@cpc85006-haye22-2-0-cust131.17-4.cable.virginm.net) (Remote host closed the connection)
2020-10-09 11:46:39 +0200polyrain(~polyrain@2001:8003:e501:6901:c889:b4c6:945c:a1ea) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 11:47:10 +0200berberman(~berberman@123.118.111.247) (Quit: ZNC 1.7.5 - https://znc.in)
2020-10-09 11:47:31 +0200berberman(~berberman@123.118.111.247)
2020-10-09 11:47:38 +0200berberman(~berberman@123.118.111.247) (Remote host closed the connection)
2020-10-09 11:47:42 +0200m0rphism(~m0rphism@HSI-KBW-046-005-177-122.hsi8.kabel-badenwuerttemberg.de)
2020-10-09 11:48:26 +0200berberman(~berberman@2408:8207:2569:5270:584e:a9ff:fe9b:d3fe)
2020-10-09 11:50:46 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt) (Remote host closed the connection)
2020-10-09 11:50:56 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt)
2020-10-09 11:52:14 +0200tw1sted1(~tw1sted@184.75.221.3) (Ping timeout: 272 seconds)
2020-10-09 11:53:19 +0200jedws(~jedws@121.209.161.98)
2020-10-09 11:57:12 +0200 <AWizzArd> Guys, what is your general strategy in Snap to „extract” request parameters? We may have route [ ("populate/:collection/:precision", populateHandler) ] and expect two variables, say an Int and String. I can call `getParam "collection"` to get a Maybe value. Same for precision. Only when both are available I want to handle the request, otherwise throw a client error.
2020-10-09 11:57:20 +0200 <AWizzArd> Then I will also have to parse the incoming data and see if it is plausible. This may result in more Maybes or Eithers. This whole machinery needs to be repeated in every single handler.
2020-10-09 11:57:26 +0200 <AWizzArd> Does Snap offer anything that allows me to do the core extraction, getting rid of Maybes/Eithers and such?
2020-10-09 12:00:55 +0200galagora(c5ed143c@197.237.20.60)
2020-10-09 12:00:58 +0200hackagemmsyn7s 0.9.1.0 - Shows a sorted list of the Ukrainian sounds representations that can be used by mmsyn7 series of programs https://hackage.haskell.org/package/mmsyn7s-0.9.1.0 (OleksandrZhabenko)
2020-10-09 12:02:51 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 12:04:07 +0200snyp(~rksht@49.207.204.102) (Ping timeout: 240 seconds)
2020-10-09 12:04:46 +0200cr0ssw1nd(~crosswind@adsl-174.176.58.193.tellas.gr)
2020-10-09 12:05:01 +0200 <cr0ssw1nd> hi folks
2020-10-09 12:05:12 +0200jedws(~jedws@121.209.161.98) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 12:05:55 +0200 <AWizzArd> Hey cr0ssw1nd
2020-10-09 12:07:26 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 272 seconds)
2020-10-09 12:07:57 +0200alp(~alp@2a01:e0a:58b:4920:a1ed:32ca:ea5a:70c4) (Ping timeout: 272 seconds)
2020-10-09 12:08:28 +0200hackageprettyprinter-graphviz 1.1.0.0 - A prettyprinter backend for graphviz https://hackage.haskell.org/package/prettyprinter-graphviz-1.1.0.0 (GeorgeThomas)
2020-10-09 12:08:33 +0200Tops2(~Tobias@dyndsl-095-033-021-014.ewe-ip-backbone.de)
2020-10-09 12:15:49 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 264 seconds)
2020-10-09 12:16:41 +0200gienah(~mwright@gentoo/developer/gienah) (Remote host closed the connection)
2020-10-09 12:18:58 +0200hackageuniqueness-periods-vector-properties 0.5.1.0 - Metrices for the maximum element for the uniqueness-periods-vector packages family. https://hackage.haskell.org/package/uniqueness-periods-vector-properties-0.5.1.0 (OleksandrZhabenko)
2020-10-09 12:19:27 +0200rprije(~rprije@203.214.95.251) (Ping timeout: 240 seconds)
2020-10-09 12:19:58 +0200hackagenamed-servant-server 0.1.0, named-servant-client 0.1.0 (KristofBastiaensen): https://qbin.io/arabia-sole-w4ye
2020-10-09 12:26:57 +0200hackagenamed-servant 0.1.1 - https://hackage.haskell.org/package/named-servant-0.1.1 (KristofBastiaensen)
2020-10-09 12:27:19 +0200ericholscher(~ericholsc@178.162.212.214)
2020-10-09 12:27:58 +0200hackagenamed-servant-server 0.1.1, named-servant-client 0.1.1 (KristofBastiaensen): https://qbin.io/cat-rpm-5a0f
2020-10-09 12:29:30 +0200alp(~alp@2a01:e0a:58b:4920:303d:a1e1:2db5:170e)
2020-10-09 12:31:05 +0200jespada(~jespada@90.254.245.15) (Ping timeout: 240 seconds)
2020-10-09 12:32:33 +0200jespada(~jespada@90.254.245.15)
2020-10-09 12:32:39 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 12:32:50 +0200ralejs(~ralejs@2620:10d:c093:400::5:a494) (Read error: Connection reset by peer)
2020-10-09 12:33:14 +0200ralejs(~ralejs@2620:10d:c093:400::5:a494)
2020-10-09 12:34:28 +0200hackagebytestring-tree-builder 0.2.7.5 - A very efficient ByteString builder implementation based on the binary tree https://hackage.haskell.org/package/bytestring-tree-builder-0.2.7.5 (NikitaVolkov)
2020-10-09 12:36:06 +0200kuribas(~user@ptr-25vy0iaj6vgftnb4emr.18120a2.ip6.access.telenet.be)
2020-10-09 12:36:51 +0200maroloccio(~marolocci@212.129.85.119)
2020-10-09 12:37:57 +0200hackageuniqueness-periods-vector-examples 0.11.0.0 - Usage examples for the uniqueness-periods-vector series of packages https://hackage.haskell.org/package/uniqueness-periods-vector-examples-0.11.0.0 (OleksandrZhabenko)
2020-10-09 12:38:16 +0200shatriff(~vitaliish@78.111.190.16) (Ping timeout: 246 seconds)
2020-10-09 12:41:32 +0200 <kuribas> why does hlint recommends (Just True = x) for fromMaybe False x
2020-10-09 12:41:32 +0200 <kuribas> ?
2020-10-09 12:41:58 +0200 <dminuoso> kuribas: Because its an opinionated tool
2020-10-09 12:42:14 +0200 <kuribas> s/=/==
2020-10-09 12:42:40 +0200polyrain(~polyrain@2001:8003:e501:6901:c889:b4c6:945c:a1ea)
2020-10-09 12:42:43 +0200__ngua(~rory@2402:800:6379:81de:c01f:8864:9ffb:a477)
2020-10-09 12:42:45 +0200 <dminuoso> If the author believes `A` is better than `B`, you have to ask the author why they think that.
2020-10-09 12:42:50 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt) (Remote host closed the connection)
2020-10-09 12:43:08 +0200 <kuribas> well, sometimes I can see the point, even if I disagree.
2020-10-09 12:43:08 +0200 <maerwald> which is why I don't understand why ppl use it in CI
2020-10-09 12:43:12 +0200 <kuribas> here I don't even see the point
2020-10-09 12:43:18 +0200 <dminuoso> It's weird when I see people using tools like `hlint` and then zealously following its recommendations, hoping it "improves your code"
2020-10-09 12:43:31 +0200 <kuribas> maerwald: it doesn't make sense in CI at all.
2020-10-09 12:43:41 +0200 <maerwald> Yet, ppl do that.
2020-10-09 12:43:45 +0200 <dminuoso> You should modify and tweak hlint to tell you about things *you* want to know about
2020-10-09 12:43:52 +0200 <maerwald> hintman makes sense, but not in CI
2020-10-09 12:44:02 +0200 <kuribas> maerwald: unless it just shows the warnings, not stopping the build.
2020-10-09 12:44:02 +0200knupfer(~Thunderbi@i59F7FF25.versanet.de)
2020-10-09 12:44:10 +0200 <dminuoso> Like, Im a big fan of stylish-haskell and similar tools, but only if you tweak them to apply the formatting you wanted *anyway*.
2020-10-09 12:44:12 +0200 <kuribas> maerwald: even some ghc warnings I disagree with.
2020-10-09 12:44:15 +0200 <maerwald> https://github.com/apps/hint-man
2020-10-09 12:44:18 +0200gienah(~mwright@gentoo/developer/gienah)
2020-10-09 12:44:28 +0200 <dminuoso> kuribas: that's why GHC allows you to turn them on or off.
2020-10-09 12:44:36 +0200 <dminuoso> If you dont agree with them, disable them.
2020-10-09 12:44:37 +0200 <maerwald> kuribas: it does stop the build, so I have to argue every time and disable non-sensical warnings :)
2020-10-09 12:44:48 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt)
2020-10-09 12:44:57 +0200 <dminuoso> Mostly, GHC has good defaults if you enable -Wall. Emphasis on mostly.
2020-10-09 12:45:08 +0200 <maerwald> if those are comments in the PR, like hint-man does, it's fine
2020-10-09 12:45:34 +0200Rudd0^(~Rudd0@185.189.115.98)
2020-10-09 12:45:46 +0200 <dminuoso> Though in case of GHC, I wish we had a granular tool to disable particular warnings in code regions.
2020-10-09 12:45:53 +0200 <dminuoso> That would solve the above issues.
2020-10-09 12:46:47 +0200 <dminuoso> Especially orphan instances. :>
2020-10-09 12:46:55 +0200dminuosowishes for {-# ADOPT #-}
2020-10-09 12:47:58 +0200Rudd0(~Rudd0@185.189.115.108) (Ping timeout: 272 seconds)
2020-10-09 12:48:34 +0200knupfer1(~Thunderbi@200116b82c4c7d00a9c8a35dca5dba93.dip.versatel-1u1.de)
2020-10-09 12:48:52 +0200knupfer1(~Thunderbi@200116b82c4c7d00a9c8a35dca5dba93.dip.versatel-1u1.de) (Client Quit)
2020-10-09 12:50:44 +0200jchia__(~jchia@45.32.62.73)
2020-10-09 12:50:49 +0200cpressey(~cpressey@79-72-202-104.dynamic.dsl.as9105.com) (Quit: WeeChat 1.9.1)
2020-10-09 12:50:58 +0200jchia__(~jchia@45.32.62.73) (Client Quit)
2020-10-09 12:51:18 +0200knupfer(~Thunderbi@i59F7FF25.versanet.de) (Ping timeout: 260 seconds)
2020-10-09 12:51:48 +0200jchia__(~jchia@45.32.62.73)
2020-10-09 12:51:57 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt) (Remote host closed the connection)
2020-10-09 12:52:03 +0200jchia__(~jchia@45.32.62.73) (Client Quit)
2020-10-09 12:52:03 +0200 <kuribas> maerwald: making some warnings errors I can understand, like totality checking.
2020-10-09 12:52:25 +0200 <kuribas> maerwald: I would also disallow `head`, `(!)`, etc...
2020-10-09 12:52:27 +0200jchia__(~jchia@45.32.62.73)
2020-10-09 12:52:37 +0200jchia__(~jchia@45.32.62.73) (Client Quit)
2020-10-09 12:53:01 +0200jchia__(~jchia@58.32.35.239)
2020-10-09 12:53:11 +0200jchia__(~jchia@58.32.35.239) (Client Quit)
2020-10-09 12:53:14 +0200 <kuribas> maerwald: I was bitten by partial functions in a small script I wrote. I was thinking it didn't matter for the small script, but the person using it was getting unhelpful errors.
2020-10-09 12:53:25 +0200knupfer(~Thunderbi@i59F7FF25.versanet.de)
2020-10-09 12:53:31 +0200jchia__(~jchia@45.32.62.73)
2020-10-09 12:53:45 +0200jchia__(~jchia@45.32.62.73) (Client Quit)
2020-10-09 12:53:55 +0200Zetagon(~leo@c151-177-52-233.bredband.comhem.se)
2020-10-09 12:53:58 +0200 <kuribas> the good thing is that finally my colleage could make his hands dirty on haskell :)
2020-10-09 12:54:09 +0200jchia__(~jchia@58.32.35.239)
2020-10-09 12:54:19 +0200jchia__(~jchia@58.32.35.239) (Client Quit)
2020-10-09 12:54:39 +0200jchia__(~jchia@58.32.35.239)
2020-10-09 12:54:53 +0200jchia__(~jchia@58.32.35.239) (Client Quit)
2020-10-09 12:55:18 +0200jchia__(~jchia@45.32.62.73)
2020-10-09 12:55:27 +0200jchia__(~jchia@45.32.62.73) (Client Quit)
2020-10-09 12:55:47 +0200jchia__(~jchia@58.32.35.239)
2020-10-09 12:56:01 +0200jchia__(~jchia@58.32.35.239) (Client Quit)
2020-10-09 12:56:26 +0200jchia__(~jchia@58.32.35.239)
2020-10-09 12:56:35 +0200jchia__(~jchia@58.32.35.239) (Client Quit)
2020-10-09 12:57:27 +0200xff0x(~fox@2001:1a81:53da:5200:e942:2dc6:3612:ec91) (Ping timeout: 240 seconds)
2020-10-09 12:58:40 +0200xff0x(~fox@2001:1a81:53da:5200:a463:747d:cc85:3e35)
2020-10-09 12:59:47 +0200olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber) (Ping timeout: 240 seconds)
2020-10-09 13:00:15 +0200turion(~turion@ip1f10fe5a.dynamic.kabel-deutschland.de)
2020-10-09 13:00:27 +0200knupfer1(~Thunderbi@200116b82c4c7d0028ffdd8de8181ed3.dip.versatel-1u1.de)
2020-10-09 13:00:29 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt)
2020-10-09 13:00:29 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt) (Remote host closed the connection)
2020-10-09 13:00:32 +0200o1lo01ol_(~o1lo01ol1@bl8-213-81.dsl.telepac.pt)
2020-10-09 13:01:27 +0200hackagenamed-servant 0.2.0 - https://hackage.haskell.org/package/named-servant-0.2.0 (KristofBastiaensen)
2020-10-09 13:02:25 +0200nihilazo(nihilazoma@gateway/shell/matrix.org/x-ynhyzeaxhyhpxjcx) (Quit: killed)
2020-10-09 13:02:25 +0200johnnyboy[m](gifumatrix@gateway/shell/matrix.org/x-sdbsmmdtbhtyarzx) (Quit: killed)
2020-10-09 13:02:25 +0200SlackIntegration(slackbotma@gateway/shell/matrix.org/x-esxicxmpfxumgwpu) (Quit: killed)
2020-10-09 13:02:25 +0200psydruid(psydruidma@gateway/shell/matrix.org/x-jnnvasqbzlbcdazz) (Quit: killed)
2020-10-09 13:02:25 +0200maralorn(maralornma@gateway/shell/matrix.org/x-xcbwgmzbnjbofzkc) (Quit: killed)
2020-10-09 13:02:25 +0200fgaz(fgazmatrix@gateway/shell/matrix.org/x-xkyvxxetlscnwafl) (Quit: killed)
2020-10-09 13:02:25 +0200PotatoHatsue(berbermanp@gateway/shell/matrix.org/x-ltxkvqlzigmwjcmb) (Quit: killed)
2020-10-09 13:02:25 +0200jtojnar(jtojnarmat@gateway/shell/matrix.org/x-sxfbmpglnidreblu) (Quit: killed)
2020-10-09 13:02:25 +0200themsay[m](themsaymat@gateway/shell/matrix.org/x-doisvmaprkvtlian) (Quit: killed)
2020-10-09 13:02:25 +0200domenkozar[m](domenkozar@NixOS/user/domenkozar) (Quit: killed)
2020-10-09 13:02:26 +0200unclechu(unclechuma@gateway/shell/matrix.org/x-siyegrvxmbqkrarq) (Quit: killed)
2020-10-09 13:02:26 +0200vaibhavsagar(vaibhavsag@gateway/shell/matrix.org/x-lbhwkudhrzavozue) (Quit: killed)
2020-10-09 13:02:26 +0200theduke(thedukem1@gateway/shell/matrix.org/x-ywjhvhoswxgzllwc) (Quit: killed)
2020-10-09 13:02:26 +0200siraben(sirabenmat@gateway/shell/matrix.org/x-ykymenvgfoixvnor) (Quit: killed)
2020-10-09 13:02:26 +0200sm[m](simonmicma@gateway/shell/matrix.org/x-smgmdfguunjmvhtb) (Quit: killed)
2020-10-09 13:02:27 +0200drozdziak1(drozdziak1@gateway/shell/matrix.org/x-aitoffbhswubbvqs) (Quit: killed)
2020-10-09 13:02:27 +0200kadoban(kadobanmat@gateway/shell/matrix.org/x-hygrfqqyfjnsdlux) (Quit: killed)
2020-10-09 13:02:27 +0200srid(sridmatrix@gateway/shell/matrix.org/x-xvfelxeqgrijfein) (Quit: killed)
2020-10-09 13:02:27 +0200Noughtmare[m](naughtmare@gateway/shell/matrix.org/x-pxgtffywirgpojke) (Quit: killed)
2020-10-09 13:02:27 +0200bonvoyage[m](bonvoyageu@gateway/shell/matrix.org/x-flypodpwywfnwhbp) (Quit: killed)
2020-10-09 13:02:29 +0200CaptainFox[m](onianimatr@gateway/shell/matrix.org/x-qldffscxaigohrqf) (Quit: killed)
2020-10-09 13:02:29 +0200jkaye[m](jkayematri@gateway/shell/matrix.org/x-sacwexxudjndlbhb) (Quit: killed)
2020-10-09 13:02:30 +0200mikr[m](mikrdavral@gateway/shell/matrix.org/x-ertglelnvdyfmpmz) (Quit: killed)
2020-10-09 13:02:31 +0200JoelMcCracken[m](joelmccrac@gateway/shell/matrix.org/x-iuizycevqaqwplpt) (Quit: killed)
2020-10-09 13:02:31 +0200michaelpj(michaelpjm@gateway/shell/matrix.org/x-lalgvgrwwexhlata) (Quit: killed)
2020-10-09 13:02:32 +0200materialfuture[m(materialfu@gateway/shell/matrix.org/x-natatakpvirpbwzh) (Quit: killed)
2020-10-09 13:02:32 +0200alexfmpe(alexfmpema@gateway/shell/matrix.org/x-puoreeslprltamlk) (Quit: killed)
2020-10-09 13:02:36 +0200dyniec[m](dyniecmatr@gateway/shell/matrix.org/x-eqsqupnlptqjhopn) (Quit: killed)
2020-10-09 13:02:36 +0200albestro[m](albestroma@gateway/shell/matrix.org/x-jhifwvtorjzyapnj) (Quit: killed)
2020-10-09 13:02:38 +0200jlv(jlvjustinl@gateway/shell/matrix.org/x-edyheupziglvmygt) (Quit: killed)
2020-10-09 13:02:39 +0200hnOsmium0001[m](hnosmium00@gateway/shell/matrix.org/x-asylavqwpoyheblp) (Quit: killed)
2020-10-09 13:02:39 +0200pqwy[m](pqwymatrix@gateway/shell/matrix.org/x-nxhnwnrcnkxvbjgw) (Quit: killed)
2020-10-09 13:02:40 +0200mmynsted[m](mmynstedtc@gateway/shell/matrix.org/x-weneqjetvglndztb) (Quit: killed)
2020-10-09 13:02:40 +0200Ericson2314(ericson231@gateway/shell/matrix.org/x-msawmwnrrupoyzdw) (Quit: killed)
2020-10-09 13:02:42 +0200steve[m](stevetrout@gateway/shell/matrix.org/x-giosogvjuwgmzgeq) (Quit: killed)
2020-10-09 13:02:42 +0200hackagelightstep-haskell 0.10.4 - LightStep OpenTracing client library https://hackage.haskell.org/package/lightstep-haskell-0.10.4 (DmitryIvanov)
2020-10-09 13:02:42 +0200hackagenamed-servant-server 0.2.0, named-servant-client 0.2.0 (KristofBastiaensen): https://qbin.io/sur-robots-p3us
2020-10-09 13:02:42 +0200knupfer(~Thunderbi@i59F7FF25.versanet.de) (Ping timeout: 264 seconds)
2020-10-09 13:02:43 +0200GuillaumeChrel[m(guillaumec@gateway/shell/matrix.org/x-kgpqbbuzoemsaame) (Quit: killed)
2020-10-09 13:02:43 +0200ethercrow[m](ethercrowm@gateway/shell/matrix.org/x-cngkbkqzfiyaehzq) (Quit: killed)
2020-10-09 13:02:43 +0200gmind[m](gmindmatri@gateway/shell/matrix.org/x-xxubemmtfzohlasf) (Quit: killed)
2020-10-09 13:02:43 +0200sepp2k(sepp2kmatr@gateway/shell/matrix.org/x-lbhxftmcyljkcwmt) (Quit: killed)
2020-10-09 13:02:45 +0200hsiktas[m](hsiktasmat@gateway/shell/matrix.org/x-kynxvphdyxwicwmr) (Quit: killed)
2020-10-09 13:02:45 +0200chreekat[m](chreekatma@gateway/shell/matrix.org/x-lhpszfbfikwwpjcq) (Quit: killed)
2020-10-09 13:02:45 +0200sureyeaah(shauryab98@gateway/shell/matrix.org/x-bexfvkzxvxsukjbn) (Quit: killed)
2020-10-09 13:02:45 +0200rednaZ[m](r3dnazmatr@gateway/shell/matrix.org/x-frefqrwfmvpulcxq) (Quit: killed)
2020-10-09 13:02:46 +0200io_r_us[m](commandlin@gateway/shell/matrix.org/x-hfbhrzjwkhpdkxmx) (Quit: killed)
2020-10-09 13:02:46 +0200iinuwa(iinuwamatr@gateway/shell/matrix.org/x-ojhvzvdjehejmjyl) (Quit: killed)
2020-10-09 13:02:46 +0200ciderpunx[m](ciderpunxm@gateway/shell/matrix.org/x-eiqlaujdcrrjihof) (Quit: killed)
2020-10-09 13:02:46 +0200betrion[m](betrionmat@gateway/shell/matrix.org/x-jtuvgpaxjhagltpq) (Quit: killed)
2020-10-09 13:02:49 +0200lambdaclan(lambdaclan@gateway/shell/matrix.org/x-nfskoikomeigrjig) (Quit: killed)
2020-10-09 13:02:49 +0200alvinsj[m](alvinsjmat@gateway/shell/matrix.org/x-mkainprhrhntgffj) (Quit: killed)
2020-10-09 13:02:50 +0200jeffcasavant[m](jeffcasava@gateway/shell/matrix.org/x-ksjiuklwciszscec) (Quit: killed)
2020-10-09 13:02:50 +0200jiribenes1(jbjiribene@gateway/shell/matrix.org/x-oeyhikodljyfssef) (Quit: killed)
2020-10-09 13:02:50 +0200Fernando-Basso[m(fernando-b@gateway/shell/matrix.org/x-ukhpvkodxcjgraor) (Quit: killed)
2020-10-09 13:02:50 +0200knupfer1knupfer
2020-10-09 13:02:52 +0200tttom[m](tttommatri@gateway/shell/matrix.org/x-tfjycddkqvetadxg) (Quit: killed)
2020-10-09 13:02:52 +0200texasmynsted[m](mmynstedko@gateway/shell/matrix.org/x-kjavtksplelfadkn) (Quit: killed)
2020-10-09 13:02:52 +0200tsrt^(tsrt@ip98-184-89-2.mc.at.cox.net) (Max SendQ exceeded)
2020-10-09 13:03:48 +0200tsrt^(tsrt@ip98-184-89-2.mc.at.cox.net)
2020-10-09 13:04:27 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 13:05:34 +0200lightandlight(sid135476@gateway/web/irccloud.com/x-hovjzoliueuictrg) (Ping timeout: 246 seconds)
2020-10-09 13:05:59 +0200plutoniix(~q@175.176.222.7) (Quit: Leaving)
2020-10-09 13:06:02 +0200maroloccio(~marolocci@212.129.85.119) (Quit: WeeChat 2.3)
2020-10-09 13:06:16 +0200lightandlight(sid135476@gateway/web/irccloud.com/x-esxphvmhpsuzltwt)
2020-10-09 13:06:43 +0200tomboy64(~tomboy64@gateway/tor-sasl/tomboy64) (Ping timeout: 240 seconds)
2020-10-09 13:07:34 +0200tomboy64(~tomboy64@gateway/tor-sasl/tomboy64)
2020-10-09 13:08:48 +0200Sanchayan(~Sanchayan@2401:4900:3306:43b4:5db8:9096:94f4:9d42)
2020-10-09 13:09:09 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 256 seconds)
2020-10-09 13:09:10 +0200mmynsted[m](mmynstedko@gateway/shell/matrix.org/x-vezacdswknregcsw)
2020-10-09 13:10:56 +0200Sanchayan(~Sanchayan@2401:4900:3306:43b4:5db8:9096:94f4:9d42) (Client Quit)
2020-10-09 13:12:28 +0200hackageuniqueness-periods-vector-properties 0.5.2.0 - Metrices for the maximum element for the uniqueness-periods-vector packages family. https://hackage.haskell.org/package/uniqueness-periods-vector-properties-0.5.2.0 (OleksandrZhabenko)
2020-10-09 13:13:22 +0200HaskellYogi(~vivekrama@49.207.212.129) (Remote host closed the connection)
2020-10-09 13:13:57 +0200jedws(~jedws@121.209.161.98)
2020-10-09 13:14:18 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 13:15:47 +0200berberman(~berberman@2408:8207:2569:5270:584e:a9ff:fe9b:d3fe) (Ping timeout: 240 seconds)
2020-10-09 13:16:41 +0200berberman(~berberman@2408:8207:256a:1720:584e:a9ff:fe9b:d3fe)
2020-10-09 13:17:37 +0200alp(~alp@2a01:e0a:58b:4920:303d:a1e1:2db5:170e) (Ping timeout: 272 seconds)
2020-10-09 13:18:22 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 272 seconds)
2020-10-09 13:19:13 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 246 seconds)
2020-10-09 13:19:21 +0200berberman(~berberman@2408:8207:256a:1720:584e:a9ff:fe9b:d3fe) (Client Quit)
2020-10-09 13:19:46 +0200berberman(~berberman@2408:8207:256a:1720:584e:a9ff:fe9b:d3fe)
2020-10-09 13:20:09 +0200Dungdv(abf4bce2@gateway/web/cgi-irc/kiwiirc.com/ip.171.244.188.226) (Quit: Connection closed)
2020-10-09 13:23:40 +0200jtojnar(jtojnarmat@gateway/shell/matrix.org/x-usgrtgvgawipzskz)
2020-10-09 13:23:40 +0200hsiktas[m](hsiktasmat@gateway/shell/matrix.org/x-mdsaohojuseguvva)
2020-10-09 13:23:40 +0200hnOsmium0001[m](hnosmium00@gateway/shell/matrix.org/x-szmgbxfcnviaeywn)
2020-10-09 13:23:40 +0200SlackIntegration(slackbotma@gateway/shell/matrix.org/x-rxhzofxlqowyvoex)
2020-10-09 13:23:40 +0200vaibhavsagar(vaibhavsag@gateway/shell/matrix.org/x-dzrnwheyyrqqkaxx)
2020-10-09 13:23:40 +0200kadoban(kadobanmat@gateway/shell/matrix.org/x-hqzwblsefampavod)
2020-10-09 13:23:40 +0200nihilazo(nihilazoma@gateway/shell/matrix.org/x-afxdcasmpruwczpn)
2020-10-09 13:23:40 +0200bonvoyage[m](bonvoyageu@gateway/shell/matrix.org/x-gwfeippcnxqufbie)
2020-10-09 13:23:40 +0200ThaEwat(thaewraptm@gateway/shell/matrix.org/x-hrgahnccdejedpjj)
2020-10-09 13:23:40 +0200avocado(renningmat@gateway/shell/matrix.org/x-lbeurhasvwcxrpwp)
2020-10-09 13:23:40 +0200jeffcasavant[m](jeffcasava@gateway/shell/matrix.org/x-hjhltkjttsndhhkz)
2020-10-09 13:23:41 +0200lambdaclan(lambdaclan@gateway/shell/matrix.org/x-ohajfkfwbdgxlpmo)
2020-10-09 13:23:41 +0200sm[m](simonmicma@gateway/shell/matrix.org/x-tneitzltqviyrfjn)
2020-10-09 13:23:41 +0200alvinsj[m](alvinsjmat@gateway/shell/matrix.org/x-nwfftzrznvagqvns)
2020-10-09 13:23:41 +0200boistordu1(boistordum@gateway/shell/matrix.org/x-uaffjwqaamebhlmi)
2020-10-09 13:23:41 +0200chreekat[m](chreekatma@gateway/shell/matrix.org/x-kpqcqdtuspbqaepg)
2020-10-09 13:23:41 +0200shatriff(~vitaliish@178-133-212-10.mobile.vf-ua.net)
2020-10-09 13:23:41 +0200drozdziak1(drozdziak1@gateway/shell/matrix.org/x-qbmoanboxydujdwb)
2020-10-09 13:23:41 +0200Ericson2314(ericson231@gateway/shell/matrix.org/x-jqfqhltqwawefczw)
2020-10-09 13:23:41 +0200iinuwa(iinuwamatr@gateway/shell/matrix.org/x-jxlnqrgayqijmilv)
2020-10-09 13:23:41 +0200io_r_us[m](commandlin@gateway/shell/matrix.org/x-xajpenbgtlsrahzn)
2020-10-09 13:23:42 +0200sureyeaah(shauryab98@gateway/shell/matrix.org/x-huvitbkiaeizvifg)
2020-10-09 13:23:42 +0200johnnyboy[m](gifumatrix@gateway/shell/matrix.org/x-vahebxhkdkvauchy)
2020-10-09 13:23:42 +0200unclechu(unclechuma@gateway/shell/matrix.org/x-smvlsqqmverjjhyj)
2020-10-09 13:23:42 +0200Fernando-Basso[m(fernando-b@gateway/shell/matrix.org/x-ytyxcamjxrgxyfkl)
2020-10-09 13:23:42 +0200ethercrow[m](ethercrowm@gateway/shell/matrix.org/x-zwklnxjxcmhjkoow)
2020-10-09 13:23:42 +0200rednaZ[m](r3dnazmatr@gateway/shell/matrix.org/x-nzlaqkxqhijamdxj)
2020-10-09 13:23:42 +0200themsay[m](themsaymat@gateway/shell/matrix.org/x-twnfzasmxscnzufy)
2020-10-09 13:23:42 +0200PotatoHatsue(berbermanp@gateway/shell/matrix.org/x-qjylcwexkmjwddia)
2020-10-09 13:23:42 +0200JoelMcCracken[m](joelmccrac@gateway/shell/matrix.org/x-fgrnajlvcmfxorzc)
2020-10-09 13:23:42 +0200maralorn(maralornma@gateway/shell/matrix.org/x-awbsrvgnrvynarjf)
2020-10-09 13:23:42 +0200siraben(sirabenmat@gateway/shell/matrix.org/x-pjuezldzdrfckkhi)
2020-10-09 13:23:42 +0200pqwy[m](pqwymatrix@gateway/shell/matrix.org/x-gsboooajgyollaro)
2020-10-09 13:23:42 +0200michaelpj(michaelpjm@gateway/shell/matrix.org/x-lwzxhlbrpraenxqc)
2020-10-09 13:23:43 +0200fgaz(fgazmatrix@gateway/shell/matrix.org/x-rlbcopwnlnlrszcb)
2020-10-09 13:23:43 +0200theduke(thedukem1@gateway/shell/matrix.org/x-uxfoavbkhrpjinhc)
2020-10-09 13:23:43 +0200lnxw37d4(lnxw37d4ma@gateway/shell/matrix.org/x-yolujewggzqqhajb)
2020-10-09 13:23:43 +0200srid(sridmatrix@gateway/shell/matrix.org/x-bwagjvhebtsmrixk)
2020-10-09 13:23:43 +0200domenkozar[m](domenkozar@NixOS/user/domenkozar)
2020-10-09 13:23:43 +0200psydruid(psydruidma@gateway/shell/matrix.org/x-jnwhbopqsvzftvuy)
2020-10-09 13:23:46 +0200materialfuture[m(materialfu@gateway/shell/matrix.org/x-ahudgacklhknadwx)
2020-10-09 13:23:47 +0200ciderpunx[m](ciderpunxm@gateway/shell/matrix.org/x-emamieladdrukutt)
2020-10-09 13:23:47 +0200alexfmpe(alexfmpema@gateway/shell/matrix.org/x-ibothraqnolnyjqn)
2020-10-09 13:23:47 +0200jlv(jlvjustinl@gateway/shell/matrix.org/x-bxnvhwbzqxqophdz)
2020-10-09 13:23:47 +0200jiribenes1(jbjiribene@gateway/shell/matrix.org/x-irvqkvgzltpjcfzd)
2020-10-09 13:23:47 +0200GuillaumeChrel[m(guillaumec@gateway/shell/matrix.org/x-irgukfuwtdkplfnf)
2020-10-09 13:23:47 +0200steve[m](stevetrout@gateway/shell/matrix.org/x-nolzmrzxmohotgty)
2020-10-09 13:23:47 +0200sepp2k(sepp2kmatr@gateway/shell/matrix.org/x-uvkezxfeawylssgh)
2020-10-09 13:23:47 +0200CaptainFox[m](onianimatr@gateway/shell/matrix.org/x-psgxuihgrttrwsoo)
2020-10-09 13:23:48 +0200albestro[m](albestroma@gateway/shell/matrix.org/x-ceoaxwandmwefloq)
2020-10-09 13:23:48 +0200Noughtmare[m](naughtmare@gateway/shell/matrix.org/x-hukludizhwnrxifz)
2020-10-09 13:23:48 +0200gmind[m](gmindmatri@gateway/shell/matrix.org/x-azjcyqgyoflizrpj)
2020-10-09 13:23:48 +0200mmynsted[m]1(mmynstedtc@gateway/shell/matrix.org/x-otbnrbbvnxztknls)
2020-10-09 13:23:48 +0200mikr[m](mikrdavral@gateway/shell/matrix.org/x-kwgubaqxdcmojbtm)
2020-10-09 13:23:49 +0200tttom[m](tttommatri@gateway/shell/matrix.org/x-envhcytnrwvreghj)
2020-10-09 13:23:49 +0200jkaye[m](jkayematri@gateway/shell/matrix.org/x-dkdulepbdrwoghiq)
2020-10-09 13:23:49 +0200betrion[m](betrionmat@gateway/shell/matrix.org/x-jxfdancklrdizijq)
2020-10-09 13:23:50 +0200dyniec[m](dyniecmatr@gateway/shell/matrix.org/x-djxhqzczqzhwogcr)
2020-10-09 13:24:29 +0200jedws(~jedws@121.209.161.98) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 13:26:08 +0200dansho(~dansho@ip68-108-167-185.lv.lv.cox.net) (Remote host closed the connection)
2020-10-09 13:26:32 +0200dansho(~dansho@ip68-108-167-185.lv.lv.cox.net)
2020-10-09 13:27:09 +0200shatriff(~vitaliish@178-133-212-10.mobile.vf-ua.net) (Remote host closed the connection)
2020-10-09 13:27:53 +0200polyrain(~polyrain@2001:8003:e501:6901:c889:b4c6:945c:a1ea) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 13:29:17 +0200LKoen(~LKoen@81.255.219.130) (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”)
2020-10-09 13:30:09 +0200machinedgod(~machinedg@24.105.81.50)
2020-10-09 13:30:27 +0200o1lo01ol_(~o1lo01ol1@bl8-213-81.dsl.telepac.pt) (Ping timeout: 240 seconds)
2020-10-09 13:30:47 +0200vilpan(~0@mail.elitnet.lt) ()
2020-10-09 13:32:12 +0200 <kuribas> since JSON decodes utf8, isn't it wrong for aeson to take ByteString, instead of Text?
2020-10-09 13:32:42 +0200 <lyxia> aeson does the utf-8 decoding.
2020-10-09 13:32:49 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt)
2020-10-09 13:32:52 +0200 <kuribas> lyxia: that's not my question
2020-10-09 13:32:58 +0200hackagelsp-test 0.11.0.7 - Functional test framework for LSP servers. https://hackage.haskell.org/package/lsp-test-0.11.0.7 (luke_)
2020-10-09 13:33:06 +0200 <lyxia> what's wrong about it then
2020-10-09 13:33:12 +0200 <kuribas> lyxia: not because it *does*, that it *should*.
2020-10-09 13:33:39 +0200 <kuribas> lyxia: it's wrong because it does to much.
2020-10-09 13:33:50 +0200chele__(~chele@ip5b416ea2.dynamic.kabel-deutschland.de)
2020-10-09 13:33:57 +0200acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2020-10-09 13:33:59 +0200 <dminuoso> kuribas: If you want something more customizable, consider waargonaut.
2020-10-09 13:34:07 +0200 <dminuoso> That lets you use a custom parser.
2020-10-09 13:34:08 +0200crossw1nd(~crosswind@adsl-174.176.58.193.tellas.gr)
2020-10-09 13:34:25 +0200jkaye[m](jkayematri@gateway/shell/matrix.org/x-dkdulepbdrwoghiq) (*.net *.split)
2020-10-09 13:34:25 +0200jiribenes1(jbjiribene@gateway/shell/matrix.org/x-irvqkvgzltpjcfzd) (*.net *.split)
2020-10-09 13:34:25 +0200kadoban(kadobanmat@gateway/shell/matrix.org/x-hqzwblsefampavod) (*.net *.split)
2020-10-09 13:34:25 +0200hsiktas[m](hsiktasmat@gateway/shell/matrix.org/x-mdsaohojuseguvva) (*.net *.split)
2020-10-09 13:34:25 +0200nihilazo(nihilazoma@gateway/shell/matrix.org/x-afxdcasmpruwczpn) (*.net *.split)
2020-10-09 13:34:25 +0200michaelpj(michaelpjm@gateway/shell/matrix.org/x-lwzxhlbrpraenxqc) (*.net *.split)
2020-10-09 13:34:25 +0200__ngua(~rory@2402:800:6379:81de:c01f:8864:9ffb:a477) (*.net *.split)
2020-10-09 13:34:25 +0200cr0ssw1nd(~crosswind@adsl-174.176.58.193.tellas.gr) (*.net *.split)
2020-10-09 13:34:25 +0200ericholscher(~ericholsc@178.162.212.214) (*.net *.split)
2020-10-09 13:34:25 +0200m0rphism(~m0rphism@HSI-KBW-046-005-177-122.hsi8.kabel-badenwuerttemberg.de) (*.net *.split)
2020-10-09 13:34:25 +0200chele_(~chele@ip5b416ea2.dynamic.kabel-deutschland.de) (*.net *.split)
2020-10-09 13:34:25 +0200remexre_(~nathan@207-153-38-50.fttp.usinternet.com) (*.net *.split)
2020-10-09 13:34:25 +0200nyd(~lpy@unaffiliated/elysian) (*.net *.split)
2020-10-09 13:34:25 +0200aqd(~aqd@87-92-145-87.rev.dnainternet.fi) (*.net *.split)
2020-10-09 13:34:25 +0200day(~Unknown@unaffiliated/day) (*.net *.split)
2020-10-09 13:34:25 +0200darjeeling_(~darjeelin@122.245.210.138) (*.net *.split)
2020-10-09 13:34:25 +0200lagothrix(~lagothrix@unaffiliated/lagothrix) (*.net *.split)
2020-10-09 13:34:25 +0200theDon(~td@94.134.91.7) (*.net *.split)
2020-10-09 13:34:25 +0200Jesin(~Jesin@pool-72-66-101-18.washdc.fios.verizon.net) (*.net *.split)
2020-10-09 13:34:25 +0200ixian(~mgold@terra.bitplane.org) (*.net *.split)
2020-10-09 13:34:26 +0200martin02(silas@hund.fs.lmu.de) (*.net *.split)
2020-10-09 13:34:26 +0200giaco(~jack@2-238-151-49.ip244.fastwebnet.it) (*.net *.split)
2020-10-09 13:34:26 +0200taktoa[c](sid282096@gateway/web/irccloud.com/x-glimjsfxdcqvfuja) (*.net *.split)
2020-10-09 13:34:26 +0200CindyLinz(~cindy_utf@112.121.78.20) (*.net *.split)
2020-10-09 13:34:26 +0200dsal(sid13060@gateway/web/irccloud.com/x-kjyjumpbtqbmmaod) (*.net *.split)
2020-10-09 13:34:26 +0200spinnylights(~zoe@pool-100-6-142-89.pitbpa.fios.verizon.net) (*.net *.split)
2020-10-09 13:34:26 +0200arahael(~arahael@203.194.43.207) (*.net *.split)
2020-10-09 13:34:26 +0200pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net) (*.net *.split)
2020-10-09 13:34:26 +0200ezzieyguywuf(~Unknown@unaffiliated/ezzieyguywuf) (*.net *.split)
2020-10-09 13:34:26 +0200joshmeredith(sid387798@gateway/web/irccloud.com/x-lhhtwrcyukiolswv) (*.net *.split)
2020-10-09 13:34:26 +0200pong(chiya@2406:3003:2077:2341::babe) (*.net *.split)
2020-10-09 13:34:26 +0200coeus(~coeus@p200300d02724ef00d20f0ecf5ac74df4.dip0.t-ipconnect.de) (*.net *.split)
2020-10-09 13:34:26 +0200nopf(~frosch@static.179.17.76.144.clients.your-server.de) (*.net *.split)
2020-10-09 13:34:26 +0200M2tias(m2@seri.fi) (*.net *.split)
2020-10-09 13:34:36 +0200day(~Unknown@unaffiliated/day)
2020-10-09 13:34:36 +0200ixian(~mgold@2002:4a74:ba78:1701:0:ff:fe78:6269)
2020-10-09 13:34:37 +0200taktoa[c](sid282096@gateway/web/irccloud.com/x-nuycfigarigggsbg)
2020-10-09 13:34:40 +0200 <kuribas> dminuoso: that's a different issue :)
2020-10-09 13:34:42 +0200dsal(sid13060@gateway/web/irccloud.com/x-kthuquovdrjebyop)
2020-10-09 13:34:48 +0200Jesin(~Jesin@pool-72-66-101-18.washdc.fios.verizon.net)
2020-10-09 13:34:49 +0200Buntspecht(~user@unaffiliated/siracusa)
2020-10-09 13:34:50 +0200darjeeling_(~darjeelin@122.245.210.138)
2020-10-09 13:34:52 +0200nyd(~lpy@unaffiliated/elysian)
2020-10-09 13:34:53 +0200lagothrix(~lagothrix@unaffiliated/lagothrix)
2020-10-09 13:34:53 +0200spinnylights(~zoe@pool-100-6-142-89.pitbpa.fios.verizon.net)
2020-10-09 13:34:54 +0200m0rphism(~m0rphism@HSI-KBW-046-005-177-122.hsi8.kabel-badenwuerttemberg.de)
2020-10-09 13:34:56 +0200remexre_(~nathan@207-153-38-50.fttp.usinternet.com)
2020-10-09 13:34:57 +0200martin02(silas@hund.fs.lmu.de)
2020-10-09 13:35:05 +0200jiribenes1(jbjiribene@gateway/shell/matrix.org/x-hlzxlgqhzheuoshi)
2020-10-09 13:35:20 +0200giaco(~jack@2-238-151-49.ip244.fastwebnet.it)
2020-10-09 13:35:32 +0200 <kuribas> lyxia: Aeson is meant to do text encoding/decoding, so it should have to mess with bytestring encodings.
2020-10-09 13:35:54 +0200 <dminuoso> kuribas: You probably get better performance if you dont roundtrip through text.
2020-10-09 13:36:00 +0200kadoban(kadobanmat@gateway/shell/matrix.org/x-vbpdmawecokvypon)
2020-10-09 13:36:07 +0200 <lyxia> that seems to be a pretty arbitrary requirement
2020-10-09 13:36:12 +0200nihilazo(nihilazoma@gateway/shell/matrix.org/x-gmshkgiyniprfgmk)
2020-10-09 13:36:12 +0200michaelpj(michaelpjm@gateway/shell/matrix.org/x-qaoqeszlpidmiidi)
2020-10-09 13:36:32 +0200hsiktas[m](hsiktasmat@gateway/shell/matrix.org/x-pxllgyrlikkrbict)
2020-10-09 13:36:37 +0200chaosmasttter(~chaosmast@p200300c4a70b4001c004325a2a510724.dip0.t-ipconnect.de) (Ping timeout: 272 seconds)
2020-10-09 13:36:39 +0200 <dminuoso> Also, if you require Text, then you're *still* forced into a particular decoder, namely those provided by text.
2020-10-09 13:37:04 +0200Tario(~Tario@201.192.165.173) (Ping timeout: 246 seconds)
2020-10-09 13:37:23 +0200 <kuribas> dminuoso: there are different encoders for Text.
2020-10-09 13:37:31 +0200 <dminuoso> And ontop, that puts additional burden on the programmer, since you yourself have to explicitly use decodeUtf8, since Utf16/32 is invalid for JSON.
2020-10-09 13:37:38 +0200 <dminuoso> (Outside closed systems)
2020-10-09 13:37:57 +0200 <kuribas> lyxia: for example, I may want to generate a json string into Text.
2020-10-09 13:38:07 +0200Zetagon(~leo@c151-177-52-233.bredband.comhem.se) (Ping timeout: 246 seconds)
2020-10-09 13:38:19 +0200 <kuribas> ByteString and Text shouldn't be interchangeable
2020-10-09 13:38:25 +0200 <phadej> It's not about having either, yes, aeson should have an option to generate Text directly too
2020-10-09 13:38:48 +0200 <phadej> but due mentioned performance reasons, one have to pick one, and ByteString is "better" choice
2020-10-09 13:39:20 +0200 <phadej> bold claim: make stack support backpack (or go away), then there could be backpacked Aeson for either bytestrings or text
2020-10-09 13:39:52 +0200 <dminuoso> phadej: An even bolder claim, before we use backpack, can we have a functional documentation for it first? :p
2020-10-09 13:39:52 +0200 <phadej> i.e. lets rather not choose either, but make library support everything (but without performance penalties)
2020-10-09 13:40:11 +0200 <kuribas> phadej: that would be a better option of course... Is aeson really that optimized on speed?
2020-10-09 13:40:11 +0200jkaye[m](jkayematri@gateway/shell/matrix.org/session)
2020-10-09 13:40:11 +0200aqd(~aqd@87-92-145-87.rev.dnainternet.fi)
2020-10-09 13:40:11 +0200theDon(~td@94.134.91.7)
2020-10-09 13:40:11 +0200CindyLinz(~cindy_utf@112.121.78.20)
2020-10-09 13:40:11 +0200arahael(~arahael@203.194.43.207)
2020-10-09 13:40:11 +0200pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net)
2020-10-09 13:40:11 +0200ezzieyguywuf(~Unknown@unaffiliated/ezzieyguywuf)
2020-10-09 13:40:11 +0200joshmeredith(sid387798@gateway/web/irccloud.com/x-lhhtwrcyukiolswv)
2020-10-09 13:40:11 +0200pong(chiya@2406:3003:2077:2341::babe)
2020-10-09 13:40:11 +0200coeus(~coeus@p200300d02724ef00d20f0ecf5ac74df4.dip0.t-ipconnect.de)
2020-10-09 13:40:11 +0200nopf(~frosch@static.179.17.76.144.clients.your-server.de)
2020-10-09 13:40:11 +0200M2tias(m2@seri.fi)
2020-10-09 13:40:12 +0200jkaye[m](jkayematri@gateway/shell/matrix.org/session) (Changing host)
2020-10-09 13:40:12 +0200jkaye[m](jkayematri@gateway/shell/matrix.org/x-qpddmqzxjujexbdo)
2020-10-09 13:40:16 +0200 <phadej> kuribas: it is
2020-10-09 13:40:59 +0200 <phadej> the addition of toEncoding was purely motivated by performance considerations
2020-10-09 13:41:05 +0200hekkaidekapus](~tchouri@gateway/tor-sasl/hekkaidekapus)
2020-10-09 13:41:25 +0200 <phadej> otherwise you (can quite easily in fact) use toJSON + Value -> Text function
2020-10-09 13:41:39 +0200carlomagno1(~cararell@inet-hqmc01-o.oracle.com)
2020-10-09 13:42:07 +0200 <phadej> writing Text -> Value parser is in fact also ok and possible, I guess someone just need to do the legwork there
2020-10-09 13:42:23 +0200 <phadej> (as parsing side of aeson always goes through `Value`)
2020-10-09 13:42:32 +0200 <kuribas> I thought Text was still quite performant
2020-10-09 13:42:39 +0200Gurkenglas(~Gurkengla@unaffiliated/gurkenglas)
2020-10-09 13:42:54 +0200 <kuribas> was aeson made pre-Text?
2020-10-09 13:43:03 +0200hekkaidekapus[(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 240 seconds)
2020-10-09 13:43:05 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 13:43:13 +0200carlomagno(~cararell@inet-hqmc02-o.oracle.com) (Ping timeout: 260 seconds)
2020-10-09 13:43:45 +0200chele__(~chele@ip5b416ea2.dynamic.kabel-deutschland.de) (Ping timeout: 240 seconds)
2020-10-09 13:44:27 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 13:45:20 +0200 <phadej> text is performant when you already have it
2020-10-09 13:45:35 +0200spinnylights(~zoe@pool-100-6-142-89.pitbpa.fios.verizon.net) (Quit: WeeChat 2.9)
2020-10-09 13:45:36 +0200 <phadej> for parsing, in fact it isn't as you have to decode backing UTF16 on the fly
2020-10-09 13:46:10 +0200marek(~mmahut@209.250.249.245) (Ping timeout: 246 seconds)
2020-10-09 13:46:11 +0200 <phadej> Vector Word32 would be more performant (i.e. UTF32 encoding), if you can afford having 4bytes per character
2020-10-09 13:48:11 +0200cpressey(~cpressey@79-72-202-104.dynamic.dsl.as9105.com)
2020-10-09 13:48:21 +0200marek(~mmahut@209.250.249.245)
2020-10-09 13:48:52 +0200 <phadej> in fact, `text` is weird compromise nowadays, utf16 isn't really space efficient, nor is fixed-width (i.e. as performant as it can get)
2020-10-09 13:49:28 +0200 <phadej> but then there are reasons why its internal encoding isn't changed
2020-10-09 13:50:37 +0200 <kuribas> if the internals aren't leaky, we could change to utf8
2020-10-09 13:51:25 +0200galagora(c5ed143c@197.237.20.60) (Remote host closed the connection)
2020-10-09 13:52:43 +0200 <phadej> https://github.com/text-utf8/META/issues/1
2020-10-09 13:53:01 +0200 <phadej> "we" doesn't work
2020-10-09 13:53:31 +0200 <phadej> people burnout climbing this kind of hills
2020-10-09 13:54:01 +0200 <dminuoso> Presumably the main issue is that those people have day jobs, hobby projects, maintainer positions for dozens of other projects..
2020-10-09 13:54:19 +0200 <dminuoso> So if you have a personal life and still want to get text-utf8 done, it's gonna be hard.
2020-10-09 13:54:42 +0200 <phadej> yes, these kind of issues should be someones dayjob
2020-10-09 13:56:30 +0200 <phadej> Though, honestly, I don't think that driving these kind of big-scale changes through is a nice job
2020-10-09 13:58:03 +0200 <phadej> and IMHO that team should be at least of size three
2020-10-09 13:58:16 +0200 <phadej> so it's not any single person's job either
2020-10-09 13:58:55 +0200 <__skn> CX
2020-10-09 13:59:17 +0200acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 260 seconds)
2020-10-09 13:59:27 +0200 <phadej> because these kind of libraries should be associated with a single person
2020-10-09 13:59:55 +0200mmohammadi981266(~mmohammad@5.238.185.98)
2020-10-09 14:04:08 +0200jedws(~jedws@121.209.161.98)
2020-10-09 14:05:08 +0200 <dminuoso> *shouldn't
2020-10-09 14:06:37 +0200R8128(~R8128@77-170-72-55.fixed.kpn.net)
2020-10-09 14:08:34 +0200jedws(~jedws@121.209.161.98) (Ping timeout: 246 seconds)
2020-10-09 14:10:14 +0200mmohammadi981266(~mmohammad@5.238.185.98) (Quit: I quit (╯°□°)╯︵ ┻━┻)
2020-10-09 14:11:07 +0200 <Cheery> I wrote a tool that fetches a og:title/og:description from the website and dumps it along the link.
2020-10-09 14:11:37 +0200 <Cheery> Now I'd need a tool that can get in bunch of text, and produce a short summary from it.
2020-10-09 14:11:50 +0200dansho(~dansho@ip68-108-167-185.lv.lv.cox.net) (Quit: Leaving)
2020-10-09 14:12:45 +0200acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2020-10-09 14:13:09 +0200alp(~alp@2a01:e0a:58b:4920:d4ea:6c81:73c8:e91a)
2020-10-09 14:13:33 +0200mmohammadi981266(~mmohammad@5.238.185.98)
2020-10-09 14:14:57 +0200 <Cheery> Yay.. there's a linux tool for that. :)
2020-10-09 14:15:31 +0200ClaudiusMaximus(~claude@198.123.199.146.dyn.plus.net)
2020-10-09 14:15:31 +0200ClaudiusMaximus(~claude@198.123.199.146.dyn.plus.net) (Changing host)
2020-10-09 14:15:31 +0200ClaudiusMaximus(~claude@unaffiliated/claudiusmaximus)
2020-10-09 14:16:27 +0200catchme(uid355354@gateway/web/irccloud.com/x-lkuruwxjciobmoti)
2020-10-09 14:16:49 +0200mmohammadi981266(~mmohammad@5.238.185.98) (Client Quit)
2020-10-09 14:18:46 +0200 <phadej> dminuoso: yes, thanks for correction :)
2020-10-09 14:19:13 +0200mmohammadi981266(~mmohammad@5.238.185.98)
2020-10-09 14:19:23 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 260 seconds)
2020-10-09 14:20:32 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 14:24:48 +0200Nahra(~Nahra@unaffiliated/nahra)
2020-10-09 14:25:03 +0200gxt(~gxt@gateway/tor-sasl/gxt) (Ping timeout: 240 seconds)
2020-10-09 14:25:10 +0200geekosaur(82659a05@host154-005.vpn.uakron.edu)
2020-10-09 14:25:41 +0200John20(~John@82.46.59.122) (Ping timeout: 258 seconds)
2020-10-09 14:26:01 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 264 seconds)
2020-10-09 14:26:34 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 14:26:46 +0200turion(~turion@ip1f10fe5a.dynamic.kabel-deutschland.de) (Ping timeout: 246 seconds)
2020-10-09 14:28:32 +0200gxt(~gxt@gateway/tor-sasl/gxt)
2020-10-09 14:28:43 +0200iyyel(~iyyel@52d3ced1.dynamic-ip.k-net.dk)
2020-10-09 14:29:18 +0200lemmih(~lemmih@218.186.157.57) (Ping timeout: 272 seconds)
2020-10-09 14:32:28 +0200Tario(~Tario@201.192.165.173)
2020-10-09 14:33:26 +0200chaosmasttter(~chaosmast@p200300c4a70b4001c004325a2a510724.dip0.t-ipconnect.de)
2020-10-09 14:34:32 +0200knupfer(~Thunderbi@200116b82c4c7d0028ffdd8de8181ed3.dip.versatel-1u1.de) (Ping timeout: 260 seconds)
2020-10-09 14:34:36 +0200iyyel(~iyyel@52d3ced1.dynamic-ip.k-net.dk) (Quit: WeeChat 2.9)
2020-10-09 14:34:53 +0200Codaraxis_(~Codaraxis@ip68-5-90-227.oc.oc.cox.net)
2020-10-09 14:34:59 +0200 <Cheery> Ok.. the summarizers seem to not work too well.
2020-10-09 14:34:59 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net)
2020-10-09 14:35:09 +0200 <Cheery> So the stuff I get is probably the best I can get.
2020-10-09 14:35:46 +0200 <Cheery> there's this crazy python-written kit, but it's even harder to use than all the rest.
2020-10-09 14:36:00 +0200lemmih(~lemmih@2406:3003:2072:44:a0ec:19b9:a607:ec5)
2020-10-09 14:37:02 +0200Codaraxis(~Codaraxis@ip68-5-90-227.oc.oc.cox.net) (Ping timeout: 265 seconds)
2020-10-09 14:38:15 +0200knupfer1(~Thunderbi@i59F7FF25.versanet.de)
2020-10-09 14:39:33 +0200polyrain(~polyrain@2001:8003:e501:6901:c889:b4c6:945c:a1ea)
2020-10-09 14:40:05 +0200darjeeling_(~darjeelin@122.245.210.138) (Ping timeout: 240 seconds)
2020-10-09 14:40:38 +0200knupfer1knupfer
2020-10-09 14:42:39 +0200darjeeling_(~darjeelin@122.245.210.138)
2020-10-09 14:42:43 +0200Nahra(~Nahra@unaffiliated/nahra) (Ping timeout: 260 seconds)
2020-10-09 14:43:16 +0200polyrain(~polyrain@2001:8003:e501:6901:c889:b4c6:945c:a1ea) (Client Quit)
2020-10-09 14:43:25 +0200random(~random@185.219.70.106) (Remote host closed the connection)
2020-10-09 14:44:30 +0200wz1000(~wz1000@static.11.113.47.78.clients.your-server.de) (Ping timeout: 272 seconds)
2020-10-09 14:48:55 +0200Nahra(~Nahra@unaffiliated/nahra)
2020-10-09 14:49:19 +0200Nahra(~Nahra@unaffiliated/nahra) (Client Quit)
2020-10-09 14:49:46 +0200wz1000(~wz1000@static.11.113.47.78.clients.your-server.de)
2020-10-09 14:50:37 +0200titusg(~user@192.173.128.35)
2020-10-09 14:51:20 +0200 <titusg> hi, how do I tell ghc about cabal 3.2 packages?
2020-10-09 14:51:56 +0200 <geekosaur> ideally you use a cabal project instead of ghc directly
2020-10-09 14:51:58 +0200turion(~turion@ip1f10fe5a.dynamic.kabel-deutschland.de)
2020-10-09 14:52:15 +0200 <dcoutts> titusg: e.g. cabal repl will start ghci in your project
2020-10-09 14:52:17 +0200 <titusg> this is in order to use xmonad
2020-10-09 14:52:25 +0200quazimod1(~quazimodo@27-33-123-50.tpgi.com.au) (Ping timeout: 264 seconds)
2020-10-09 14:52:30 +0200turion(~turion@ip1f10fe5a.dynamic.kabel-deutschland.de) (Client Quit)
2020-10-09 14:52:57 +0200 <geekosaur> use "cabal v2-install --lib" outside of a project, then
2020-10-09 14:53:21 +0200 <geekosaur> that said, there are build scripts that can use cabal to rebuild xmonad
2020-10-09 14:53:28 +0200 <dminuoso> titusg: For xmonad you need to use a custom build script
2020-10-09 14:53:54 +0200quazimodo(~quazimodo@45.67.96.217)
2020-10-09 14:55:38 +0200Nahra(~Nahra@unaffiliated/nahra)
2020-10-09 14:55:55 +0200Velociraptor1(~Velocirap@s91904426.blix.com)
2020-10-09 14:56:42 +0200Nahra(~Nahra@unaffiliated/nahra) (Client Quit)
2020-10-09 14:56:43 +0200cpressey(~cpressey@79-72-202-104.dynamic.dsl.as9105.com) (Ping timeout: 260 seconds)
2020-10-09 15:01:28 +0200John20(~John@82.46.59.122)
2020-10-09 15:02:25 +0200Nahra(~Nahra@unaffiliated/nahra)
2020-10-09 15:05:50 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 15:06:52 +0200gnar^2(~user@c-73-118-153-248.hsd1.wa.comcast.net)
2020-10-09 15:07:04 +0200urodna(~urodna@unaffiliated/urodna)
2020-10-09 15:07:32 +0200cpressey(~cpressey@88.144.68.224)
2020-10-09 15:10:28 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 272 seconds)
2020-10-09 15:10:46 +0200mcmoor(727ce828@114.124.232.40)
2020-10-09 15:11:56 +0200alp(~alp@2a01:e0a:58b:4920:d4ea:6c81:73c8:e91a) (Remote host closed the connection)
2020-10-09 15:12:11 +0200tomboy64(~tomboy64@gateway/tor-sasl/tomboy64) (Remote host closed the connection)
2020-10-09 15:12:22 +0200gnar^2(~user@c-73-118-153-248.hsd1.wa.comcast.net) (Ping timeout: 272 seconds)
2020-10-09 15:12:30 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de)
2020-10-09 15:12:38 +0200berberman(~berberman@2408:8207:256a:1720:584e:a9ff:fe9b:d3fe) (Changing host)
2020-10-09 15:12:38 +0200berberman(~berberman@unaffiliated/berberman)
2020-10-09 15:12:55 +0200tomboy64(~tomboy64@gateway/tor-sasl/tomboy64)
2020-10-09 15:13:06 +0200oisdk(~oisdk@2001:bb6:3329:d100:7807:4c86:5073:949e)
2020-10-09 15:14:03 +0200titusg(~user@192.173.128.35) (Quit: ERC (IRC client for Emacs 26.3))
2020-10-09 15:14:19 +0200 <crossw1nd> what should I install on linux server over SSH in order to random random haskell binary?
2020-10-09 15:14:22 +0200 <crossw1nd> just ghc?
2020-10-09 15:14:35 +0200 <crossw1nd> *to run random haskell binary
2020-10-09 15:15:30 +0200 <[exa]> what kind of linux is that?
2020-10-09 15:15:49 +0200 <[exa]> generally ghc compiles the haskell source to a normal binary that you should be able to run just as any other language's binary
2020-10-09 15:16:42 +0200vicfred(~vicfred@unaffiliated/vicfred) (Quit: Leaving)
2020-10-09 15:16:51 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de) (Ping timeout: 244 seconds)
2020-10-09 15:17:06 +0200 <crossw1nd> debian I guess
2020-10-09 15:17:11 +0200 <crossw1nd> apt is present
2020-10-09 15:17:26 +0200jedws(~jedws@121.209.161.98)
2020-10-09 15:17:33 +0200 <crossw1nd> [exa] but I mean usually it isn't statically compiled?
2020-10-09 15:17:38 +0200quazimodo(~quazimodo@45.67.96.217) (Ping timeout: 256 seconds)
2020-10-09 15:17:43 +0200 <crossw1nd> I need to have haskell runtime at least
2020-10-09 15:17:50 +0200 <maerwald> crossw1nd: you need libgmp
2020-10-09 15:17:59 +0200 <crossw1nd> or is GC bundled into a binary already?
2020-10-09 15:17:59 +0200berberman(~berberman@unaffiliated/berberman) (Quit: ZNC 1.7.5 - https://znc.in)
2020-10-09 15:18:21 +0200berberman(~berberman@unaffiliated/berberman)
2020-10-09 15:19:00 +0200 <geekosaur> the runtime should be statically linked into the executable usually
2020-10-09 15:19:01 +0200jedws(~jedws@121.209.161.98) (Client Quit)
2020-10-09 15:19:20 +0200quazimodo(~quazimodo@45.67.96.217)
2020-10-09 15:19:47 +0200 <maerwald> you need at least libgmp and possibly other libraries
2020-10-09 15:20:14 +0200 <maerwald> just check the binary with lddtree
2020-10-09 15:20:17 +0200 <kuribas> is there a way to force servant-client to always emit a =true for boolean flags?
2020-10-09 15:20:30 +0200 <kuribas> it seems it sometimes emits flag=true, and sometimes just flag
2020-10-09 15:22:09 +0200boistordu1(boistordum@gateway/shell/matrix.org/x-uaffjwqaamebhlmi) (Quit: Idle for 30+ days)
2020-10-09 15:24:03 +0200 <crossw1nd> geekosaur, ooh, I guess it was different 5 years ago
2020-10-09 15:24:25 +0200 <crossw1nd> maerwald, thanks, trying to figure out how to do it in ubuntu :)
2020-10-09 15:24:33 +0200 <crossw1nd> there are several libgmp
2020-10-09 15:24:45 +0200 <crossw1nd> lddtree is awesome idea
2020-10-09 15:25:31 +0200 <geekosaur> it depends on the platform, but dynamic by default has mostly gone away iirc
2020-10-09 15:25:56 +0200 <crossw1nd> that's nice
2020-10-09 15:26:01 +0200 <geekosaur> OS libs are linked dynamic but ghc's own or generated libs should normally be static
2020-10-09 15:26:09 +0200xerox_(~xerox@unaffiliated/xerox) (Quit: leaving)
2020-10-09 15:26:14 +0200nineonine(~nineonine@216-19-190-182.dyn.novuscom.net) (Remote host closed the connection)
2020-10-09 15:26:38 +0200 <geekosaur> (arch links dynamic by default, and breaks a bunch of stuff thereby, but that's another story)
2020-10-09 15:27:36 +0200avocado(renningmat@gateway/shell/matrix.org/x-lbeurhasvwcxrpwp) ("Kicked by @appservice-irc:matrix.org : Idle for 30+ days")
2020-10-09 15:27:48 +0200 <mcmoor> Hello, I have this snippet of red-black-tree implementation https://repl.it/repls/DisastrousClientsideDataset#main.hs
2020-10-09 15:28:07 +0200 <mcmoor> My main question is, why does redden success to be compiled?
2020-10-09 15:28:40 +0200 <mcmoor> I thought that Valid class only allows Red Black Black or Black Red/Black Red/Black
2020-10-09 15:29:26 +0200kritzefitz(~kritzefit@2003:5b:203b:100:c23e:baff:feb8:8cdb) (Remote host closed the connection)
2020-10-09 15:31:04 +0200todda7(~torstein@athedsl-4367507.home.otenet.gr)
2020-10-09 15:32:14 +0200 <crossw1nd> libicuuc.so.65 => not found
2020-10-09 15:32:14 +0200 <crossw1nd> libicui18n.so.65 => not found
2020-10-09 15:32:14 +0200 <crossw1nd> libicudata.so.65 => not found
2020-10-09 15:32:20 +0200 <crossw1nd> omg can't find it on ubuntu
2020-10-09 15:32:49 +0200 <crossw1nd> is it some common lib for haskell?
2020-10-09 15:32:56 +0200 <crossw1nd> or very specific
2020-10-09 15:33:15 +0200 <geekosaur> it's part of the ICU package
2020-10-09 15:33:25 +0200 <geekosaur> which is a common package, not Haskell specific
2020-10-09 15:34:24 +0200 <crossw1nd> but this particular so can be found only in CentOS and Fedora
2020-10-09 15:34:27 +0200 <crossw1nd> according to pkgs.org
2020-10-09 15:34:51 +0200 <crossw1nd> (+ alt, openmandriva and slackware)
2020-10-09 15:35:07 +0200 <crossw1nd> ah I get it
2020-10-09 15:35:09 +0200 <crossw1nd> of course
2020-10-09 15:35:09 +0200 <geekosaur> on ubuntu it's libicu60 package
2020-10-09 15:35:13 +0200 <crossw1nd> becaues I compiled in on fedora
2020-10-09 15:35:30 +0200 <crossw1nd> but I need to recompile it on debian then?
2020-10-09 15:35:41 +0200 <crossw1nd> then can be not easy in current circumstances..
2020-10-09 15:36:23 +0200 <crossw1nd> yeah, libicu60 is installed
2020-10-09 15:37:03 +0200 <crossw1nd> docker to the rescue
2020-10-09 15:37:20 +0200 <geekosaur> oh, fedora had 6.5 I guess
2020-10-09 15:38:50 +0200alp(~alp@2a01:e0a:58b:4920:f183:394b:8c77:4cf5)
2020-10-09 15:39:34 +0200nineonine(~nineonine@216.81.48.202)
2020-10-09 15:40:27 +0200Sanchayan(~Sanchayan@136.185.164.171)
2020-10-09 15:42:02 +0200 <maerwald> crossw1nd: are you planning to redistribute the binary to multiple users?
2020-10-09 15:42:08 +0200todda7(~torstein@athedsl-4367507.home.otenet.gr) (Ping timeout: 272 seconds)
2020-10-09 15:42:47 +0200 <crossw1nd> maerwald, no, it's one-time job
2020-10-09 15:43:02 +0200 <crossw1nd> it's just quicker than to fix all warning or find how those guys enabled -Werror :D
2020-10-09 15:43:20 +0200 <crossw1nd> the setup is pretty complicated with multiple docker kubernetes etc
2020-10-09 15:43:34 +0200rihards_(~rihards@vpnlv.tilde.com)
2020-10-09 15:43:54 +0200 <crossw1nd> so this is my savious, I guess
2020-10-09 15:43:55 +0200 <crossw1nd> docker run --net=host --rm -it -v /root:/host -it fedora:32 /bin/bash
2020-10-09 15:44:28 +0200 <crossw1nd> or I can recompile there, but I don't want to install haskell there
2020-10-09 15:45:36 +0200todda7(~torstein@athedsl-4367507.home.otenet.gr)
2020-10-09 15:46:58 +0200aarvar(~foewfoiew@50.35.43.33)
2020-10-09 15:47:24 +0200oldsk00l_(~znc@ec2-18-130-254-135.eu-west-2.compute.amazonaws.com)
2020-10-09 15:48:29 +0200oldsk00l(~znc@ec2-18-130-254-135.eu-west-2.compute.amazonaws.com) (Ping timeout: 258 seconds)
2020-10-09 15:52:45 +0200ulidtko|k(~ulidtko@193.111.48.79) (Ping timeout: 240 seconds)
2020-10-09 15:52:57 +0200kori(~kori@arrowheads/kori)
2020-10-09 15:53:24 +0200AlterEgo-(~ladew@124-198-158-163.dynamic.caiway.nl)
2020-10-09 15:53:27 +0200Velociraptor1(~Velocirap@s91904426.blix.com) (Remote host closed the connection)
2020-10-09 15:55:30 +0200Nahra(~Nahra@unaffiliated/nahra) (Quit: leaving)
2020-10-09 15:55:49 +0200Nahra(~Nahra@unaffiliated/nahra)
2020-10-09 15:56:14 +0200shatriff(~vitaliish@78.111.190.16)
2020-10-09 15:56:26 +0200jessu(~jessu@unaffiliated/jessu)
2020-10-09 15:56:56 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:8027:67:300d:f48)
2020-10-09 15:59:00 +0200miconda1(~miconda@s91904426.blix.com)
2020-10-09 16:02:08 +0200 <crossw1nd> yeah it worked
2020-10-09 16:04:14 +0200geekosaur(82659a05@host154-005.vpn.uakron.edu) (Ping timeout: 245 seconds)
2020-10-09 16:05:32 +0200ralejs(~ralejs@2620:10d:c093:400::5:a494) (Read error: Connection reset by peer)
2020-10-09 16:05:44 +0200ralejs(~ralejs@2620:10d:c093:400::5:a494)
2020-10-09 16:06:23 +0200cosimone_(~cosimone@93-47-228-249.ip115.fastwebnet.it)
2020-10-09 16:06:37 +0200ddellacosta(~dd@86.106.121.168)
2020-10-09 16:07:29 +0200polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889)
2020-10-09 16:10:16 +0200Nahra(~Nahra@unaffiliated/nahra) (Quit: leaving)
2020-10-09 16:11:29 +0200cosimone(~cosimone@93-47-228-249.ip115.fastwebnet.it)
2020-10-09 16:11:59 +0200cosimone_(~cosimone@93-47-228-249.ip115.fastwebnet.it) (Ping timeout: 260 seconds)
2020-10-09 16:11:59 +0200fendor_(~fendor@91.141.0.104.wireless.dyn.drei.com)
2020-10-09 16:12:33 +0200John20(~John@82.46.59.122) (Ping timeout: 260 seconds)
2020-10-09 16:13:26 +0200Lycurgus(~niemand@98.4.96.130)
2020-10-09 16:13:27 +0200mcc(~pbodev1@5-15-16-231.residential.rdsnet.ro)
2020-10-09 16:13:58 +0200hackageZ-Data 0.1.6.0 - Array, vector and text https://hackage.haskell.org/package/Z-Data-0.1.6.0 (winterland)
2020-10-09 16:14:33 +0200fendor(~fendor@77.119.131.69.wireless.dyn.drei.com) (Ping timeout: 258 seconds)
2020-10-09 16:15:36 +0200oldsk00l(~znc@ec2-18-130-254-135.eu-west-2.compute.amazonaws.com)
2020-10-09 16:15:36 +0200aqd(~aqd@87-92-145-87.rev.dnainternet.fi) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 16:16:31 +0200 <kuribas> ah I found it: makeClientRequest can rewrite the requests
2020-10-09 16:16:31 +0200ralejs(~ralejs@2620:10d:c093:400::5:a494) (Read error: Connection reset by peer)
2020-10-09 16:16:56 +0200ulidtko|k(~ulidtko@193.111.48.79)
2020-10-09 16:17:00 +0200ralejs(~ralejs@2620:10d:c093:400::5:a494)
2020-10-09 16:17:57 +0200ralejs(~ralejs@2620:10d:c093:400::5:a494) (Read error: Connection reset by peer)
2020-10-09 16:18:11 +0200oldsk00l_(~znc@ec2-18-130-254-135.eu-west-2.compute.amazonaws.com) (Ping timeout: 240 seconds)
2020-10-09 16:18:19 +0200ralejs(~ralejs@2620:10d:c093:400::5:a494)
2020-10-09 16:18:21 +0200geekosaur(82659a05@host154-005.vpn.uakron.edu)
2020-10-09 16:19:32 +0200Sanchayan(~Sanchayan@136.185.164.171) (Quit: leaving)
2020-10-09 16:20:02 +0200st8less(~st8less@2603:a060:11fd:0:9c66:9b18:c21:60c)
2020-10-09 16:22:54 +0200bitmapper(uid464869@gateway/web/irccloud.com/x-jxsyyeiuxmytinai) (Quit: Connection closed for inactivity)
2020-10-09 16:23:31 +0200shatriff(~vitaliish@78.111.190.16) (Read error: Connection reset by peer)
2020-10-09 16:25:51 +0200shatriff(~vitaliish@78.111.190.16)
2020-10-09 16:28:38 +0200alp(~alp@2a01:e0a:58b:4920:f183:394b:8c77:4cf5) (Read error: Connection reset by peer)
2020-10-09 16:28:44 +0200conal(~conal@64.71.133.70)
2020-10-09 16:28:58 +0200alp(~alp@2a01:e0a:58b:4920:f183:394b:8c77:4cf5)
2020-10-09 16:29:23 +0200nados(~dan@107-190-41-58.cpe.teksavvy.com)
2020-10-09 16:30:00 +0200ubert(~Thunderbi@2a02:8109:9880:303c:ca5b:76ff:fe29:f233) (Remote host closed the connection)
2020-10-09 16:30:56 +0200cr3(~cr3@192-222-143-195.qc.cable.ebox.net)
2020-10-09 16:31:33 +0200alp_(~alp@2a01:e0a:58b:4920:f183:394b:8c77:4cf5)
2020-10-09 16:33:48 +0200spew(uid195861@gateway/web/irccloud.com/x-bxhjiqhornabfyxm)
2020-10-09 16:35:13 +0200alp(~alp@2a01:e0a:58b:4920:f183:394b:8c77:4cf5) (Ping timeout: 272 seconds)
2020-10-09 16:37:56 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-09 16:38:41 +0200Tops21(~Tobias@dyndsl-095-033-021-014.ewe-ip-backbone.de)
2020-10-09 16:39:14 +0200jessu(~jessu@unaffiliated/jessu) (Quit: Leaving)
2020-10-09 16:42:04 +0200Tops2(~Tobias@dyndsl-095-033-021-014.ewe-ip-backbone.de) (Ping timeout: 256 seconds)
2020-10-09 16:42:05 +0200Amras(~Amras@unaffiliated/amras0000)
2020-10-09 16:43:41 +0200o1lo01ol1o(~o1lo01ol1@bl8-213-81.dsl.telepac.pt) (Remote host closed the connection)
2020-10-09 16:45:11 +0200Lycurgus(~niemand@98.4.96.130) (Quit: Exeunt)
2020-10-09 16:45:33 +0200alp_(~alp@2a01:e0a:58b:4920:f183:394b:8c77:4cf5) (Remote host closed the connection)
2020-10-09 16:45:58 +0200alp_(~alp@2a01:e0a:58b:4920:f183:394b:8c77:4cf5)
2020-10-09 16:46:00 +0200gnar^2(~user@c-73-118-153-248.hsd1.wa.comcast.net)
2020-10-09 16:49:45 +0200taurux(~taurux@net-188-152-69-171.cust.dsl.teletu.it) (Ping timeout: 240 seconds)
2020-10-09 16:50:16 +0200gnar^2(~user@c-73-118-153-248.hsd1.wa.comcast.net) (Ping timeout: 246 seconds)
2020-10-09 16:50:33 +0200shatriff(~vitaliish@78.111.190.16) (Read error: Connection reset by peer)
2020-10-09 16:51:21 +0200shatriff(~vitaliish@78.111.190.16)
2020-10-09 16:51:50 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c)
2020-10-09 16:52:42 +0200Franciman(~francesco@host-95-247-31-62.retail.telecomitalia.it) (Quit: Leaving)
2020-10-09 16:53:00 +0200Franciman(~francesco@host-95-247-31-62.retail.telecomitalia.it)
2020-10-09 16:53:02 +0200machinedgod(~machinedg@24.105.81.50) (Quit: leaving)
2020-10-09 16:53:09 +0200Franciman(~francesco@host-95-247-31-62.retail.telecomitalia.it) (Remote host closed the connection)
2020-10-09 16:53:31 +0200mcmoor(727ce828@114.124.232.40) (Remote host closed the connection)
2020-10-09 16:53:58 +0200taurux(~taurux@net-188-152-69-171.cust.vodafonedsl.it)
2020-10-09 16:54:14 +0200machinedgod(~machinedg@24.105.81.50)
2020-10-09 16:56:48 +0200 <maralorn> I‘d like some opinions about hackage. I have written a tool, which might benefit a large number of users and a few have already voiced interest. It is a workaround that should actually be fixed upstream in nix (which is written in C++), which will take years, if it ever happens. But still my tool is kinda temporary. Should I release it to hackage anyways? https://github.com/maralorn/nix-output-monitor/issues/2
2020-10-09 16:57:22 +0200vicfred(~vicfred@unaffiliated/vicfred)
2020-10-09 16:57:48 +0200 <geekosaur> you can deprecate it later if it ever does get fixed upstream
2020-10-09 16:57:59 +0200Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi)
2020-10-09 16:58:44 +0200justache(~justache@unaffiliated/justache) (Remote host closed the connection)
2020-10-09 17:00:02 +0200miconda1(~miconda@s91904426.blix.com) ()
2020-10-09 17:00:04 +0200justache(~justache@unaffiliated/justache)
2020-10-09 17:02:05 +0200mirrorbird(~psutcliff@2a00:801:429:5ea0:80af:2bca:f885:1bb9)
2020-10-09 17:02:05 +0200gxt(~gxt@gateway/tor-sasl/gxt) (Remote host closed the connection)
2020-10-09 17:02:51 +0200gxt(~gxt@gateway/tor-sasl/gxt)
2020-10-09 17:03:11 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:8027:67:300d:f48) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 17:03:36 +0200quazimodo(~quazimodo@45.67.96.217) (Ping timeout: 256 seconds)
2020-10-09 17:03:46 +0200machinedgod(~machinedg@24.105.81.50) (Quit: leaving)
2020-10-09 17:04:28 +0200todda7(~torstein@athedsl-4367507.home.otenet.gr) (Ping timeout: 260 seconds)
2020-10-09 17:04:59 +0200machinedgod(~machinedg@24.105.81.50)
2020-10-09 17:05:10 +0200quazimodo(~quazimodo@45.67.96.217)
2020-10-09 17:05:10 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c) (Quit: My MacBook Air has gone to sleep. ZZZzzz…)
2020-10-09 17:05:14 +0200 <maralorn> So that wouldn‘t count as spaming hackage?
2020-10-09 17:05:57 +0200 <geekosaur> maybe if they were planning to fix it in a week or so, it might count as spamming. but I suspect not even then
2020-10-09 17:06:34 +0200 <kuribas> it's not like there is a quality garantee on hackage
2020-10-09 17:07:13 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 17:07:53 +0200sword865(uid208942@gateway/web/irccloud.com/x-oofcgutvwgwgnuoj) (Quit: Connection closed for inactivity)
2020-10-09 17:09:35 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:8027:67:300d:f48)
2020-10-09 17:09:41 +0200jollygood2(~bc8165ab@217.29.117.252)
2020-10-09 17:10:02 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c)
2020-10-09 17:10:29 +0200geekosaur(82659a05@host154-005.vpn.uakron.edu) (Ping timeout: 245 seconds)
2020-10-09 17:11:25 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 240 seconds)
2020-10-09 17:11:35 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c) (Client Quit)
2020-10-09 17:14:13 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c)
2020-10-09 17:15:08 +0200Sgeo(~Sgeo@ool-18b982ad.dyn.optonline.net)
2020-10-09 17:15:45 +0200xerox_(~xerox@unaffiliated/xerox)
2020-10-09 17:17:29 +0200kuribas(~user@ptr-25vy0iaj6vgftnb4emr.18120a2.ip6.access.telenet.be) (Remote host closed the connection)
2020-10-09 17:17:57 +0200gnar^2(~user@c-73-118-153-248.hsd1.wa.comcast.net)
2020-10-09 17:18:04 +0200cosimone(~cosimone@93-47-228-249.ip115.fastwebnet.it) (Quit: cosimone)
2020-10-09 17:19:11 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c) (Quit: My MacBook Air has gone to sleep. ZZZzzz…)
2020-10-09 17:19:39 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net) (Ping timeout: 260 seconds)
2020-10-09 17:19:52 +0200cosimone(~cosimone@93-47-228-249.ip115.fastwebnet.it)
2020-10-09 17:20:05 +0200hyiltiz(~quassel@unaffiliated/hyiltiz) (Ping timeout: 240 seconds)
2020-10-09 17:20:23 +0200jjhoo(~jahakala@dsl-trebng21-58c19c-43.dhcp.inet.fi)
2020-10-09 17:20:41 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c)
2020-10-09 17:21:18 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net)
2020-10-09 17:23:47 +0200son0p(~son0p@181.136.122.143)
2020-10-09 17:29:03 +0200chaosmasttter(~chaosmast@p200300c4a70b4001c004325a2a510724.dip0.t-ipconnect.de) (Ping timeout: 272 seconds)
2020-10-09 17:29:49 +0200CitizenSnips(~CitizenSn@irc.refl.club) (Quit: ZNC 1.8.1 - https://znc.in)
2020-10-09 17:30:27 +0200hnOsmium0001(uid453710@gateway/web/irccloud.com/x-pqpthentcvdfsjfm)
2020-10-09 17:31:10 +0200CitizenSnips(~CitizenSn@irc.refl.club)
2020-10-09 17:31:26 +0200Ariakenom_(~Ariakenom@h-155-4-221-50.NA.cust.bahnhof.se)
2020-10-09 17:31:42 +0200ryansmccoy(~ryansmcco@156.96.151.132) (Ping timeout: 272 seconds)
2020-10-09 17:32:26 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c) (Quit: My MacBook Air has gone to sleep. ZZZzzz…)
2020-10-09 17:32:40 +0200ryansmccoy(~ryansmcco@156.96.151.132)
2020-10-09 17:33:29 +0200xff0x(~fox@2001:1a81:53da:5200:a463:747d:cc85:3e35) (Ping timeout: 272 seconds)
2020-10-09 17:33:46 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 17:34:08 +0200John20(~John@82.46.59.122)
2020-10-09 17:35:20 +0200jjhoo(~jahakala@dsl-trebng21-58c19c-43.dhcp.inet.fi) (Ping timeout: 246 seconds)
2020-10-09 17:35:50 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c)
2020-10-09 17:36:06 +0200xff0x(~fox@2001:1a81:53da:5200:a463:747d:cc85:3e35)
2020-10-09 17:36:16 +0200sedeki(~textual@unaffiliated/sedeki)
2020-10-09 17:36:23 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:8027:67:300d:f48) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 17:37:05 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2020-10-09 17:38:47 +0200 <maerwald> hackage isn't collaboration point, it's a publishing platform
2020-10-09 17:40:34 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de)
2020-10-09 17:40:34 +0200 <phadej> https://hackage.haskell.org/upload
2020-10-09 17:40:36 +0200 <phadej> Because each package added to the main package index has a cost of operation and maintenance associated to it, your package should strive to provide value for the community by being intended to be useful to others.
2020-10-09 17:40:48 +0200 <phadej> is your tool useful to others in current state?
2020-10-09 17:40:55 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:ad71:da11:4be:c8fb)
2020-10-09 17:41:01 +0200geekosaur(82659a05@host154-005.vpn.uakron.edu)
2020-10-09 17:41:58 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:ad71:da11:4be:c8fb) (Client Quit)
2020-10-09 17:42:03 +0200 <phadej> if it is, and you aim to maintain it (which entails giving your package a meaningful synopsis/description as well as ensuring your package is installable by helping with providing accurate meta-data.) then putting it on Hackage is fine
2020-10-09 17:42:09 +0200sedeki(~textual@unaffiliated/sedeki) ("Textual IRC Client: www.textualapp.com")
2020-10-09 17:44:11 +0200 <phadej> otoh, if it's usable only to nix people, maybe less binding way is just to make github releases and make people install it from there
2020-10-09 17:44:59 +0200 <phadej> it's nix tool, and nix makes it easy to install from github, so why to go through Hackage at all
2020-10-09 17:45:20 +0200 <maerwald> especially when all your deps need to be on hackage too
2020-10-09 17:45:50 +0200 <maerwald> fork, fire and forget is easier with github release
2020-10-09 17:46:28 +0200 <phadej> well, https://matrix.hackage.haskell.org/#/package/nix-derivation
2020-10-09 17:46:34 +0200 <phadej> IMO that is not really maintained
2020-10-09 17:46:48 +0200 <phadej> and I think this is even more common with nix-oriented libraries than stack ones
2020-10-09 17:46:58 +0200 <AWizzArd> Is there possibly a `check` function like this in Haskell? check val f err = if f val then Right val else Left err
2020-10-09 17:47:08 +0200jjhoo(jahakala@dsl-trebng21-b048b5-171.dhcp.inet.fi)
2020-10-09 17:47:22 +0200 <phadej> their maintainers don't care about non-nix(pkgs) installation methods
2020-10-09 17:47:49 +0200jjhoo(jahakala@dsl-trebng21-b048b5-171.dhcp.inet.fi) (Client Quit)
2020-10-09 17:47:59 +0200jjhoo(jahakala@dsl-trebng21-b048b5-171.dhcp.inet.fi)
2020-10-09 17:48:48 +0200 <phadej> AWizzArd: you have just written one :)
2020-10-09 17:48:49 +0200 <ski> @hoogle (a -> Bool) -> e -> a -> Either e a
2020-10-09 17:48:51 +0200 <lambdabot> No results found
2020-10-09 17:48:56 +0200 <phadej> but, no, I don't think there is such.
2020-10-09 17:49:05 +0200 <phadej> better to write your `f` to return Either to begin with
2020-10-09 17:49:12 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:4547:b7c6:8761:29ce)
2020-10-09 17:49:24 +0200 <ski> (also wrong parameter order, most likely)
2020-10-09 17:49:47 +0200ahmr88(~ahmr88@cpc85006-haye22-2-0-cust131.17-4.cable.virginm.net)
2020-10-09 17:49:55 +0200 <phadej> compare
2020-10-09 17:49:57 +0200 <phadej> :t Data.List.NonEmpty.nonEmpty
2020-10-09 17:49:58 +0200 <lambdabot> [a] -> Maybe (GHC.Base.NonEmpty a)
2020-10-09 17:49:59 +0200 <phadej> and
2020-10-09 17:50:04 +0200 <phadej> :t null :: [a] -> Bool
2020-10-09 17:50:06 +0200 <lambdabot> [a] -> Bool
2020-10-09 17:50:36 +0200 <phadej> https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/
2020-10-09 17:51:24 +0200 <ski> @where boolean-blindness
2020-10-09 17:51:24 +0200 <lambdabot> http://existentialtype.wordpress.com/2011/03/15/boolean-blindness/
2020-10-09 17:53:55 +0200solonarv(~solonarv@adijon-655-1-70-207.w90-13.abo.wanadoo.fr)
2020-10-09 17:55:38 +0200kers(~kers@178.162.212.214)
2020-10-09 17:55:51 +0200 <Ariakenom_> slightly reminiscent of
2020-10-09 17:55:54 +0200 <Ariakenom_> :t guard
2020-10-09 17:55:56 +0200 <lambdabot> Alternative f => Bool -> f ()
2020-10-09 17:56:00 +0200jonathanx(~jonathan@dyn-8-sc.cdg.chalmers.se) (Remote host closed the connection)
2020-10-09 17:56:31 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:4547:b7c6:8761:29ce) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 17:56:43 +0200borne(~fritjof@200116b864025d00739dc2dd650b1f65.dip.versatel-1u1.de) (Quit: WeeChat 2.9)
2020-10-09 17:56:59 +0200 <phadej> guard is nice in Maybe
2020-10-09 17:57:25 +0200 <phadej> but with Either MyError it's too rough :)
2020-10-09 17:57:38 +0200 <Ariakenom_> ye :(
2020-10-09 17:57:42 +0200 <ski> @type \p e a -> a <$ unless (p a) (throwError e)
2020-10-09 17:57:44 +0200 <lambdabot> MonadError e f => (t -> Bool) -> e -> t -> f t
2020-10-09 17:57:55 +0200gnar^2(~user@c-73-118-153-248.hsd1.wa.comcast.net) (Ping timeout: 260 seconds)
2020-10-09 18:00:38 +0200HaskellYogi(~vivekrama@49.207.212.129) (Remote host closed the connection)
2020-10-09 18:00:56 +0200 <phadej> that looks almost like perl (which has postfix conditionals :)
2020-10-09 18:01:22 +0200crossw1nd(~crosswind@adsl-174.176.58.193.tellas.gr) (Ping timeout: 260 seconds)
2020-10-09 18:01:51 +0200Zetagon(~leo@c151-177-52-233.bredband.comhem.se)
2020-10-09 18:02:02 +0200cpressey(~cpressey@88.144.68.224) (Quit: WeeChat 1.9.1)
2020-10-09 18:02:53 +0200ahmr88(~ahmr88@cpc85006-haye22-2-0-cust131.17-4.cable.virginm.net) (Remote host closed the connection)
2020-10-09 18:03:45 +0200verement(~anonymous@cpe-76-167-229-223.san.res.rr.com)
2020-10-09 18:04:26 +0200raichoo(~raichoo@213.240.178.58) (Quit: Lost terminal)
2020-10-09 18:04:55 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net) (Ping timeout: 260 seconds)
2020-10-09 18:05:20 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net)
2020-10-09 18:06:00 +0200HaskellYogi(~vivekrama@49.207.212.129)
2020-10-09 18:06:09 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:a50e:6765:3d1c:f1d6)
2020-10-09 18:10:25 +0200HaskellYogi(~vivekrama@49.207.212.129) (Ping timeout: 246 seconds)
2020-10-09 18:15:09 +0200jespada(~jespada@90.254.245.15) (Quit: Leaving)
2020-10-09 18:16:05 +0200catchme(uid355354@gateway/web/irccloud.com/x-lkuruwxjciobmoti) (Quit: Connection closed for inactivity)
2020-10-09 18:18:28 +0200dhouthoo(~dhouthoo@ptr-eiv6509pb4ifhdr9lsd.18120a2.ip6.access.telenet.be) (Quit: WeeChat 2.9)
2020-10-09 18:21:05 +0200 <maerwald> phadej: everything should be installed through nix anyway :p
2020-10-09 18:22:00 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c) (Quit: My MacBook Air has gone to sleep. ZZZzzz…)
2020-10-09 18:26:55 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c)
2020-10-09 18:30:26 +0200gnar^2(~user@c-73-118-153-248.hsd1.wa.comcast.net)
2020-10-09 18:31:28 +0200roconnor(~roconnor@host-45-78-205-7.dyn.295.ca)
2020-10-09 18:31:42 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c) (Client Quit)
2020-10-09 18:34:17 +0200oisdk(~oisdk@2001:bb6:3329:d100:7807:4c86:5073:949e) (Quit: oisdk)
2020-10-09 18:34:45 +0200gnar^2(~user@c-73-118-153-248.hsd1.wa.comcast.net) (Ping timeout: 240 seconds)
2020-10-09 18:34:51 +0200nados(~dan@107-190-41-58.cpe.teksavvy.com) (Read error: Connection reset by peer)
2020-10-09 18:34:56 +0200avdb(~avdb@ip-62-235-188-165.dsl.scarlet.be)
2020-10-09 18:35:33 +0200nados(~dan@107-190-41-58.cpe.teksavvy.com)
2020-10-09 18:36:19 +0200geekosaur(82659a05@host154-005.vpn.uakron.edu) (Ping timeout: 245 seconds)
2020-10-09 18:36:47 +0200ebsen(~ebsene@64-33-113-59-dynamic.midco.net)
2020-10-09 18:37:40 +0200ebsen(~ebsene@64-33-113-59-dynamic.midco.net) (Client Quit)
2020-10-09 18:38:43 +0200mirrorbird(~psutcliff@2a00:801:429:5ea0:80af:2bca:f885:1bb9) (Ping timeout: 272 seconds)
2020-10-09 18:38:53 +0200DataComputist(~lumeng@static-50-43-26-251.bvtn.or.frontiernet.net)
2020-10-09 18:44:25 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de) (Remote host closed the connection)
2020-10-09 18:44:58 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de)
2020-10-09 18:46:46 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:a50e:6765:3d1c:f1d6) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 18:48:32 +0200LKoen(~LKoen@81.255.219.130)
2020-10-09 18:50:02 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2020-10-09 18:50:28 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:c588:f17e:f3e:2fb3)
2020-10-09 18:52:23 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 260 seconds)
2020-10-09 18:53:23 +0200taurux(~taurux@net-188-152-69-171.cust.vodafonedsl.it) (Ping timeout: 240 seconds)
2020-10-09 18:53:23 +0200kritzefitz(~kritzefit@200116b80fda0d0086f540e7cd0422d3.dip.versatel-1u1.de)
2020-10-09 18:53:28 +0200kritzefitz(~kritzefit@200116b80fda0d0086f540e7cd0422d3.dip.versatel-1u1.de) (Client Quit)
2020-10-09 18:54:24 +0200taurux(~taurux@net-188-152-69-171.cust.dsl.teletu.it)
2020-10-09 18:54:53 +0200gnar^2(~user@c-73-118-153-248.hsd1.wa.comcast.net)
2020-10-09 18:54:56 +0200abrar(~abrar@static-108-30-103-121.nycmny.fios.verizon.net) (Quit: WeeChat 2.7.1)
2020-10-09 18:55:49 +0200alp_(~alp@2a01:e0a:58b:4920:f183:394b:8c77:4cf5) (Ping timeout: 272 seconds)
2020-10-09 18:58:30 +0200GyroW_(~GyroW@d54c03e98.access.telenet.be)
2020-10-09 18:58:30 +0200GyroW_(~GyroW@d54c03e98.access.telenet.be) (Changing host)
2020-10-09 18:58:30 +0200GyroW_(~GyroW@unaffiliated/gyrow)
2020-10-09 18:59:23 +0200GyroW(~GyroW@unaffiliated/gyrow) (Ping timeout: 260 seconds)
2020-10-09 18:59:48 +0200Jeanne-Kamikaze(~Jeanne-Ka@68.235.43.142)
2020-10-09 19:01:00 +0200John20(~John@82.46.59.122) (Ping timeout: 272 seconds)
2020-10-09 19:02:31 +0200mirrorbird(~psutcliff@m83-185-82-223.cust.tele2.se)
2020-10-09 19:06:15 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-09 19:06:24 +0200cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net)
2020-10-09 19:10:27 +0200murphy_(~murphy_@2604:2000:1281:8a9e:5b6c:ced:3586:ca8c) (Quit: WeeChat 2.9)
2020-10-09 19:11:25 +0200fendor_fendor
2020-10-09 19:12:36 +0200R8128(~R8128@77-170-72-55.fixed.kpn.net) (Quit: R8128)
2020-10-09 19:13:49 +0200alp_(~alp@2a01:e0a:58b:4920:a813:2213:43c8:3e1b)
2020-10-09 19:18:03 +0200evade(~evade@2001:b07:a15:ec0c:91a9:d55f:dffd:96e)
2020-10-09 19:20:00 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de)
2020-10-09 19:22:03 +0200ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex) (Ping timeout: 240 seconds)
2020-10-09 19:22:53 +0200evade(~evade@2001:b07:a15:ec0c:91a9:d55f:dffd:96e) (Client Quit)
2020-10-09 19:23:48 +0200mdunnio(~mdunnio@208.59.170.5)
2020-10-09 19:24:29 +0200ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex)
2020-10-09 19:24:38 +0200mirrorbird(~psutcliff@m83-185-82-223.cust.tele2.se) (Ping timeout: 256 seconds)
2020-10-09 19:25:51 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 19:25:56 +0200geekosaur(82659a05@host154-005.vpn.uakron.edu)
2020-10-09 19:26:15 +0200oisdk(~oisdk@2001:bb6:3329:d100:d4b4:3667:7218:633)
2020-10-09 19:28:51 +0200mdunnio(~mdunnio@208.59.170.5) (Read error: Connection reset by peer)
2020-10-09 19:28:52 +0200avdb(~avdb@ip-62-235-188-165.dsl.scarlet.be) (Quit: WeeChat 2.9)
2020-10-09 19:29:26 +0200mdunnio(~mdunnio@208.59.170.5)
2020-10-09 19:33:27 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-09 19:34:08 +0200galagora-(~ao@197.237.20.60)
2020-10-09 19:41:03 +0200LKoen(~LKoen@81.255.219.130) (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”)
2020-10-09 19:43:18 +0200 <dwts> hi all, when a comparison returns GT, LT, or EQ, is it safe to assume that in reality the "real" values of them are numbers?
2020-10-09 19:43:33 +0200 <tomsmeding> dwts: the real values of what exactly
2020-10-09 19:43:37 +0200 <tomsmeding> GT/LT/EQ ?
2020-10-09 19:43:39 +0200 <dwts> yes
2020-10-09 19:44:01 +0200 <dwts> I have trouble understanding what is the benefit of returning these instead of numbers
2020-10-09 19:44:16 +0200 <tomsmeding> https://hackage.haskell.org/package/base-4.14.0.0/docs/Data-Ord.html#t:Ordering
2020-10-09 19:44:25 +0200 <tomsmeding> it's just 'data Ordering = LT | EQ | GT'
2020-10-09 19:44:48 +0200 <dsal> dwts: Why would you want a number there?
2020-10-09 19:44:49 +0200 <tomsmeding> though you can use fromEnum on them to get 0,1,2 if you should wish :p
2020-10-09 19:45:53 +0200 <tomsmeding> re:benefit: more type safety
2020-10-09 19:46:33 +0200 <tomsmeding> a number you can potentially confuse with something else that produces a number
2020-10-09 19:46:34 +0200todda7(~torstein@athedsl-4367507.home.otenet.gr)
2020-10-09 19:46:34 +0200 <dwts> dsal: I don't *want* a number, I'm trying to visualize in my mind what haskell is doing underneath and why the ordering is implemented that way
2020-10-09 19:46:39 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de)
2020-10-09 19:46:51 +0200 <dwts> ah, I see
2020-10-09 19:46:57 +0200 <tomsmeding> well deep down in the implementation details, Ordering really boils down to just a byte
2020-10-09 19:47:00 +0200 <tomsmeding> that's 0, 1 or 2
2020-10-09 19:47:10 +0200 <tomsmeding> because that's how haskell compiles down sum types like these
2020-10-09 19:47:20 +0200 <tomsmeding> but the programmer need not think about that :)
2020-10-09 19:47:46 +0200 <dsal> Similar to how Bool is False and True. You *can* convert those to numbers and some languages do that and it's massively error prone.
2020-10-09 19:48:22 +0200st8less(~st8less@2603:a060:11fd:0:9c66:9b18:c21:60c) (Ping timeout: 260 seconds)
2020-10-09 19:48:27 +0200 <dwts> do these LT/EQ/GT have a special name like True/False have Boolean?
2020-10-09 19:48:40 +0200 <Uniaika> hmm, not that I know of
2020-10-09 19:48:43 +0200 <tomsmeding> data Bool = False | True
2020-10-09 19:48:46 +0200 <Uniaika> they're just values of an ADT
2020-10-09 19:48:49 +0200 <tomsmeding> data Ordering = LT | EQ | GT
2020-10-09 19:48:51 +0200 <dsal> Ordering?
2020-10-09 19:48:56 +0200 <dwts> ok
2020-10-09 19:49:33 +0200 <dwts> I think I'm good for now, thank you all
2020-10-09 19:49:37 +0200 <dsal> Similarly, Boolean is often a really bad abstraction.
2020-10-09 19:50:05 +0200 <dwts> dsal: not sure why, but I have no reason not to believe you :)
2020-10-09 19:50:07 +0200 <dsal> I had an awful time understanding some of my own code that I modeled a bit from a protocol specification as a Boolean before I changed it to my own sum type and suddenly could read my own code.
2020-10-09 19:50:14 +0200 <dsal> boolean blindness is a terrible thing
2020-10-09 19:50:20 +0200 <tomsmeding> now we're (indirectly) talking about performance anyway: is there a faster way to read lots of Double's from a file than the following: sum . map (read @Double) . words <$> readFile "doubles.txt"
2020-10-09 19:50:30 +0200 <tomsmeding> because that's horribly slow
2020-10-09 19:50:59 +0200 <ski> @where boolean-blindness
2020-10-09 19:51:00 +0200 <lambdabot> http://existentialtype.wordpress.com/2011/03/15/boolean-blindness/
2020-10-09 19:51:02 +0200avdb(~avdb@ip-62-235-188-165.dsl.scarlet.be)
2020-10-09 19:51:03 +0200 <dsal> Is read that slow?
2020-10-09 19:51:08 +0200 <tomsmeding> apparently?
2020-10-09 19:51:45 +0200 <dsal> You could probably make a faster parser if you don't need all of the things that a Double parser could parse.
2020-10-09 19:52:36 +0200 <ski> > sortBy (comparing length <> compare) (words "The quick brown fox jumps over the lazy dog") -- dwts, with a separate `Ordering' data type, we can do this "primarily sort by length, secondarily by ordinary lexicographic word ordering")
2020-10-09 19:52:39 +0200 <lambdabot> ["The","dog","fox","the","lazy","over","brown","jumps","quick"]
2020-10-09 19:52:43 +0200 <tomsmeding> from some rudimentary timing the 'read' part indeed takes the longest time
2020-10-09 19:53:28 +0200hackagerebase 1.10.0.1 - A more progressive alternative to the "base" package https://hackage.haskell.org/package/rebase-1.10.0.1 (NikitaVolkov)
2020-10-09 19:53:29 +0200 <tomsmeding> dwts: ski's example is a thing because we can define <> to do something special on Ordering that it does not do on plain numbers
2020-10-09 19:53:38 +0200 <dwts> ski: I was actually reading a book with a sortBy example and came to the definition of LT/EQ/GT
2020-10-09 19:54:03 +0200 <dwts> this looks really powerful and confusing at the same time
2020-10-09 19:54:14 +0200shafox(~shafox@106.51.234.111) (Remote host closed the connection)
2020-10-09 19:54:20 +0200 <tomsmeding> dsal: I could try that, but 'length . words' already takes longer than C++ takes to parse the entire thing into an std::vector<double>
2020-10-09 19:54:28 +0200hackagererebase 1.10.0.1 - Reexports from "base" with a bunch of other standard libraries https://hackage.haskell.org/package/rerebase-1.10.0.1 (NikitaVolkov)
2020-10-09 19:54:34 +0200 <tomsmeding> dwts: welcome to haskell :p
2020-10-09 19:54:42 +0200 <ski> @where monoids
2020-10-09 19:54:43 +0200 <lambdabot> comment on "Monoids? In my programming language?" by Cale in 2008 (or 2009 ?) at <http://www.reddit.com/r/programming/comments/7cf4r/monoids_in_my_programming_language/c06adnx> about a use of `
2020-10-09 19:54:43 +0200 <lambdabot> instance Monoid a => Monoid (rho -> a)'
2020-10-09 19:54:46 +0200 <ski> dwts ^
2020-10-09 19:55:24 +0200 <dsal> dwts: At a higher level, discussing meaning makes it a lot easier to reason about things than discussing implementation.
2020-10-09 19:55:59 +0200 <dwts> tomsmeding: thanks :P Coming from a scheme background some things are similar but others seem so different
2020-10-09 19:56:19 +0200 <dwts> dsal: I see your point
2020-10-09 19:56:20 +0200 <dsal> You never have to read the manual to remember what a compare function returns and how the integer value maps to maybe -1, 0, 1, or maybe just some negative or positive value, or 0, 1, 2, or how you might be able to combine comparisons by renormalizing them, etc...
2020-10-09 19:56:54 +0200 <dsal> The Ordering semigroup is really a secondary benefit. Primarily, you get to talk about what you mean instead of going back and forth to machine speak constantly.
2020-10-09 19:58:10 +0200 <dwts> hmmm
2020-10-09 19:58:15 +0200 <dwts> there's a lot to digest here
2020-10-09 19:58:16 +0200 <dwts> lol
2020-10-09 19:58:39 +0200 <tomsmeding> dwts: sidenote: "semigroup" means that definition of <>
2020-10-09 19:58:49 +0200 <tomsmeding> nothing more :p
2020-10-09 19:58:50 +0200 <dwts> ah
2020-10-09 19:59:51 +0200 <dsal> Well, what happens is when you start talking about what you mean, you get to make a lot of things common that you wouldn't have been able to see the commonality in before.
2020-10-09 20:00:01 +0200kers(~kers@178.162.212.214) ()
2020-10-09 20:00:08 +0200emmanuel`(~user@2604:2000:1382:ce03:4ce1:f2da:89aa:1919)
2020-10-09 20:01:47 +0200darjeeling_(~darjeelin@122.245.210.138) (Ping timeout: 240 seconds)
2020-10-09 20:02:12 +0200 <galagora-> Has anyone ever used Silica, the lens library?
2020-10-09 20:02:36 +0200dyeplexer(~lol@unaffiliated/terpin) (Remote host closed the connection)
2020-10-09 20:03:32 +0200emmanuel_erc(~user@2604:2000:1382:ce03:ddc4:166d:60ea:ae29) (Ping timeout: 260 seconds)
2020-10-09 20:04:37 +0200AlterEgo-(~ladew@124-198-158-163.dynamic.caiway.nl) (Read error: Connection reset by peer)
2020-10-09 20:05:30 +0200darjeeling_(~darjeelin@122.245.210.138)
2020-10-09 20:06:42 +0200gnar^2(~user@c-73-118-153-248.hsd1.wa.comcast.net) (Remote host closed the connection)
2020-10-09 20:06:43 +0200jrqc(~rofl@96.78.87.197) (Ping timeout: 260 seconds)
2020-10-09 20:07:20 +0200AlterEgo-(~ladew@124-198-158-163.dynamic.caiway.nl)
2020-10-09 20:07:35 +0200jrqc(~rofl@96.78.87.197)
2020-10-09 20:07:49 +0200 <dsal> galagora-: I just heard about it a around 5 minutes ago. Is it working out for you?
2020-10-09 20:08:05 +0200todda7(~torstein@athedsl-4367507.home.otenet.gr) (Ping timeout: 240 seconds)
2020-10-09 20:08:16 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 256 seconds)
2020-10-09 20:08:17 +0200DataComputist(~lumeng@static-50-43-26-251.bvtn.or.frontiernet.net) (Quit: Leaving...)
2020-10-09 20:08:46 +0200wroathe(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net)
2020-10-09 20:09:47 +0200 <tomsmeding> dsal: the same pipeline but then with Int instead of Double is only slightly faster (on a file that only contains integers, of course)
2020-10-09 20:09:56 +0200 <tomsmeding> so a custom Double parser is unlikely to make things better
2020-10-09 20:10:34 +0200howdoi(uid224@gateway/web/irccloud.com/x-nyfmrtbjovrebhnn)
2020-10-09 20:10:45 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-09 20:10:45 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-09 20:10:45 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-09 20:10:49 +0200 <dsal> I tend to reach for megaparsec early, but I also don't parse for performance much.
2020-10-09 20:11:00 +0200 <geekosaur> depends. Read itself has a decent amount of overhead
2020-10-09 20:11:21 +0200 <tomsmeding> @hoogle ByteString -> (Double, ByteString)
2020-10-09 20:11:22 +0200 <lambdabot> Algebra.RealRing splitFraction :: (C a, C b) => a -> (b, a)
2020-10-09 20:11:22 +0200 <lambdabot> NumericPrelude splitFraction :: (C a, C b) => a -> (b, a)
2020-10-09 20:11:22 +0200 <lambdabot> NumericPrelude.Numeric splitFraction :: (C a, C b) => a -> (b, a)
2020-10-09 20:11:25 +0200GyroW_(~GyroW@unaffiliated/gyrow) (Ping timeout: 240 seconds)
2020-10-09 20:11:29 +0200 <tomsmeding> now if that would've existed :p
2020-10-09 20:11:56 +0200 <tomsmeding> @hoogle ByteString -> Maybe (Double, ByteString)
2020-10-09 20:11:57 +0200 <lambdabot> Data.ByteString.Lex.Integral readDecimal :: Integral a => ByteString -> Maybe (a, ByteString)
2020-10-09 20:11:57 +0200 <lambdabot> Data.ByteString.Lex.Integral readHexadecimal :: Integral a => ByteString -> Maybe (a, ByteString)
2020-10-09 20:11:57 +0200 <lambdabot> Data.ByteString.Lex.Integral readOctal :: Integral a => ByteString -> Maybe (a, ByteString)
2020-10-09 20:12:05 +0200 <tomsmeding> there we go, let's try that
2020-10-09 20:14:30 +0200ClaudiusMaximus(~claude@unaffiliated/claudiusmaximus) (Quit: ->)
2020-10-09 20:14:58 +0200 <ski> @type ((listToMaybe .) . evalStateT . (>>= \ns -> do "" <- StateT lex; return ns) . many . StateT) (reads :: ReadS Double)
2020-10-09 20:15:00 +0200 <lambdabot> String -> Maybe [Double]
2020-10-09 20:17:58 +0200Ariakenom(~Ariakenom@193.254.193.1) (Ping timeout: 258 seconds)
2020-10-09 20:19:12 +0200 <tomsmeding> ski: that's ~60% slower than my simple read pipeline
2020-10-09 20:19:37 +0200 <tomsmeding> and my read pipeline additionally has the advantage of not using the list monad in an obscure manner :p
2020-10-09 20:20:11 +0200 <tomsmeding> (on my machine)
2020-10-09 20:21:16 +0200cosimone(~cosimone@93-47-228-249.ip115.fastwebnet.it) (Quit: cosimone)
2020-10-09 20:21:51 +0200cosimone(~cosimone@2001:b07:ae5:db26:fe52:4567:a4e4:fc3a)
2020-10-09 20:21:56 +0200ButterflyOfFire(~Butterfly@185.163.110.116)
2020-10-09 20:22:13 +0200nyd(~lpy@unaffiliated/elysian) (Ping timeout: 260 seconds)
2020-10-09 20:22:37 +0200GyroW(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-09 20:22:47 +0200GyroW(~GyroW@d54c03e98.access.telenet.be)
2020-10-09 20:22:48 +0200GyroW(~GyroW@d54c03e98.access.telenet.be) (Changing host)
2020-10-09 20:22:48 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-09 20:23:53 +0200 <tomsmeding> ski: though I'm curious how you came up with that monstrosity :p
2020-10-09 20:24:44 +0200Guest18(4f7755cb@gateway/web/cgi-irc/kiwiirc.com/ip.79.119.85.203)
2020-10-09 20:24:54 +0200 <tomsmeding> ah the bytestring way seems _significantly_ faster
2020-10-09 20:25:09 +0200 <tomsmeding> (as expected, in hindsight)
2020-10-09 20:25:23 +0200 <Guest18> Hello, I have a question regarding unbalanced binary search trees in haskell
2020-10-09 20:25:31 +0200ashbreeze(~mark@72-161-255-112.dyn.centurytel.net)
2020-10-09 20:25:42 +0200 <ski> dwts : you could compare with <https://srfi.schemers.org/srfi-67/srfi-67.html#node_sec_4.5>
2020-10-09 20:25:48 +0200 <Athas> Roughly, when you have a monad transformer stack, is it more efficient to have an Error/Except monad innermost, or an error monad transformer outermost?
2020-10-09 20:25:54 +0200 <Athas> Or does it depend on the specifics?
2020-10-09 20:26:08 +0200 <ski> tomsmeding : hm, i thought it was fairly straightforward
2020-10-09 20:27:00 +0200bifunc2(bifunc2@gateway/vpn/protonvpn/bifunc2)
2020-10-09 20:27:01 +0200 <ski> "my read pipeline additionally has the advantage of not using the list monad in an obscure manner" -- is that an advantage ? ;p
2020-10-09 20:27:20 +0200 <tomsmeding> questionably :
2020-10-09 20:27:20 +0200 <ski> (but i don't really think it's that obscure ..)
2020-10-09 20:27:21 +0200 <tomsmeding> * :p
2020-10-09 20:27:31 +0200 <tomsmeding> but apart from how obscure your pipeline is or not
2020-10-09 20:27:37 +0200_ashbreeze_(~mark@184-157-33-36.dyn.centurytel.net) (Ping timeout: 246 seconds)
2020-10-09 20:27:39 +0200 <tomsmeding> why did you think it would be faster than my simple read pipeline?
2020-10-09 20:28:09 +0200 <bifunc2> If unsigned integers are serialized in big endian, order is preserved. (smaller number gets a smaller bytestring)
2020-10-09 20:28:09 +0200 <bifunc2> Is there any such way to serialize signed integers, Doubles, and Floats?
2020-10-09 20:28:30 +0200raym(~ray@115.187.50.175)
2020-10-09 20:29:05 +0200tomsmedinghas no idea regarding Athas' question, pass to another willing answerer
2020-10-09 20:29:40 +0200 <Guest18> I made a small type that is a binary search tree and some functions for it, like insert, delete, etc. All is well so far, except for the function that returns the node depth for a given value. for example, if a node has a value of '3' and is 2 levels down from the root, it should return 'Just 2'. If the value searched for isn't in the tree, it
2020-10-09 20:29:40 +0200 <Guest18> returns nothing. I have a working example, but it isn't that good. Can anybody provide me with a better implementation or at least some advice?
2020-10-09 20:29:47 +0200 <dolio> Innermost vs. outermost might not have the same semantics.
2020-10-09 20:30:25 +0200mirrorbird(~psutcliff@m83-185-82-223.cust.tele2.se)
2020-10-09 20:30:54 +0200geekosaur(82659a05@host154-005.vpn.uakron.edu) (Ping timeout: 245 seconds)
2020-10-09 20:31:16 +0200 <tomsmeding> bifunc2: in the standard IEEE floating point format, positive doubles and floats already sort correctly
2020-10-09 20:31:27 +0200 <tomsmeding> negative ones sort above positive ones
2020-10-09 20:31:30 +0200 <ski> @quote Dr._Seuss
2020-10-09 20:31:30 +0200 <lambdabot> Dr._Seuss says: `type Parser a = String -> [(a,String)]' -- "A Parser for Things / is a function from Strings / to Lists of Pairs / of Things and Strings!" -- <https://willamette.edu/~fruehr/haskell/
2020-10-09 20:31:30 +0200 <lambdabot> seuss.html>
2020-10-09 20:31:43 +0200 <tomsmeding> the same holds for signed integers in 2's complement, when you write them in big endian order
2020-10-09 20:31:54 +0200 <bifunc2> tomsmeding, wow, that's mind-blowing, thanks!
2020-10-09 20:32:01 +0200 <Guest18> The code here: https://pastebin.pl/view/9ea923e2
2020-10-09 20:32:04 +0200 <Cale> Guest18: Seems like something that perhaps the Monad instance for Maybe could help to make clean
2020-10-09 20:32:05 +0200Jesin(~Jesin@pool-72-66-101-18.washdc.fios.verizon.net) (Ping timeout: 246 seconds)
2020-10-09 20:32:07 +0200 <tomsmeding> bifunc2: about the signed integers, or about the floats?
2020-10-09 20:32:36 +0200 <Guest18> Cale: I don't know how to use monads yet
2020-10-09 20:32:38 +0200 <Cale> Guest18: one sec... that's just taking a moment to load here
2020-10-09 20:32:54 +0200 <bifunc2> tomsmeding, I'm more interested in the floats. For positive Doubles and Floats, will the "store" package preserve the order on a little endian machine?
2020-10-09 20:32:57 +0200 <tomsmeding> for the floats, you can see that by noting that if 0 < A < B, then either A has a smaller exponent than B, or it has the same exponent and a smaller mantissa
2020-10-09 20:33:11 +0200 <tomsmeding> ignoring the sign bit of course
2020-10-09 20:33:13 +0200 <Cale> Guest18: does it load for you?
2020-10-09 20:33:24 +0200 <Cale> Not sure if I'm just having an issue locally...
2020-10-09 20:33:26 +0200 <Guest18> Cale: Slowly, but yeah
2020-10-09 20:33:31 +0200 <Guest18> It took a while
2020-10-09 20:33:53 +0200 <tomsmeding> bifunc2: I have no idea what the 'store' package does, but that claim about the IEEE format only holds for big-endian order
2020-10-09 20:34:02 +0200 <Cale> Maybe try dpaste.com?
2020-10-09 20:34:31 +0200 <tomsmeding> ski: it's unfortunate that that quote splits over lines halfway through a URL
2020-10-09 20:34:46 +0200 <Guest18> Cale: https://dpaste.com/GX8QSKDLD
2020-10-09 20:34:52 +0200 <Cale> thanks
2020-10-09 20:35:56 +0200chaosmasttter(~chaosmast@p200300c4a70b4001c004325a2a510724.dip0.t-ipconnect.de)
2020-10-09 20:36:00 +0200 <bifunc2> tomsmeding okay. https://hackage.haskell.org/package/store always uses machine endianness. so i'm out of luck there with the order on most machines nowadays.
2020-10-09 20:36:01 +0200 <bifunc2> However I can use cereal https://hackage.haskell.org/package/cereal-0.5.8.1/docs/Data-Serialize-IEEE754.html which can encode floats in big-endian
2020-10-09 20:36:03 +0200 <Cale> That code looks fairly reasonable to me actually
2020-10-09 20:36:11 +0200 <bifunc2> are there any alternatives to cereal that are faster nowadays?
2020-10-09 20:36:12 +0200 <Cale> You might want to use compare x root
2020-10-09 20:36:13 +0200 <Guest18> Oh, yeah, I should mention that i used to do a lookup first, to ensure that if the element isn't there, i return nothign
2020-10-09 20:36:46 +0200 <Cale> Oh, right, depthGo isn't returning Nothing, somehow
2020-10-09 20:36:57 +0200 <Guest18> but it seemed to me that it would be too slow and maybe there is a better way, but i couldn't find it
2020-10-09 20:37:02 +0200 <Guest18> that's why i came here
2020-10-09 20:37:13 +0200 <tomsmeding> bifunc2: not well-versed enough in the library ecosystem to answer that question, unfortunately
2020-10-09 20:37:39 +0200 <Guest18> for small trees, it's fine, but doing a lookup on big trees before searching for the depth once again, does add unnecesarry computation
2020-10-09 20:37:39 +0200 <Cale> Guest18: I would guess that you want depthGo _ EmptyTree acc = Nothing
2020-10-09 20:38:15 +0200 <monochrom> and the x==root case, = Just acc
2020-10-09 20:38:19 +0200 <Cale> yeah
2020-10-09 20:38:20 +0200 <bifunc2> tomsmeding, np, thanks for the other info!
2020-10-09 20:38:32 +0200 <monochrom> So generally the whole depthGo does Maybe, too.
2020-10-09 20:38:37 +0200 <Cale> and then take the Maybe stuff out of depth
2020-10-09 20:38:39 +0200 <Guest18> so modify the depthGo to return Maybe b as well
2020-10-09 20:38:49 +0200 <Cale> (it'll produce Maybe only because depthGo does)
2020-10-09 20:38:50 +0200 <Cale> yeah
2020-10-09 20:38:52 +0200 <Guest18> Yeah, actually that makes sense
2020-10-09 20:38:57 +0200 <ski> tomsmeding : hm, i didn't really had in mind that it would be. i just wondered how to express it, with `reads'
2020-10-09 20:39:04 +0200 <Guest18> i don't know why i didnt see that
2020-10-09 20:39:14 +0200 <ski> tomsmeding : hm, i don't recall it used to break line, quite that early
2020-10-09 20:39:25 +0200 <monochrom> depth should be "depth x tree = depthGo x tree 0" very simply, no more no less.
2020-10-09 20:39:33 +0200 <tomsmeding> ski: ah I see
2020-10-09 20:39:43 +0200 <Guest18> I am programming in haskell for one week so my code can be sketchy sometimes
2020-10-09 20:39:44 +0200 <monochrom> For example there is no point "depth" cares about empty trees.
2020-10-09 20:40:02 +0200 <Cale> also, you can do: depthGo x (Node root left right) acc = case compare x root of EQ -> ...; LT -> ...; GT -> ...
2020-10-09 20:40:05 +0200 <Guest18> i see, yeah
2020-10-09 20:40:15 +0200 <monochrom> Well in this case I'm just using the DRY principle.
2020-10-09 20:40:18 +0200 <Cale> Which will only compute the comparison once, and match on the result
2020-10-09 20:40:30 +0200_deepfire(~user@80.92.100.69) (Remote host closed the connection)
2020-10-09 20:40:53 +0200alp_(~alp@2a01:e0a:58b:4920:a813:2213:43c8:3e1b) (Remote host closed the connection)
2020-10-09 20:41:18 +0200alp_(~alp@2a01:e0a:58b:4920:b989:9831:f361:9cf)
2020-10-09 20:41:25 +0200ryansmccoy(~ryansmcco@156.96.151.132) (Ping timeout: 240 seconds)
2020-10-09 20:42:09 +0200ryansmccoy(~ryansmcco@193.37.254.27)
2020-10-09 20:42:43 +0200 <ski> Guest18 : instead of using an accumulator, it would be possible to do the addition "after the recursive call"
2020-10-09 20:43:12 +0200thc202(~thc202@unaffiliated/thc202) (Ping timeout: 260 seconds)
2020-10-09 20:43:14 +0200 <Guest18> ski: isn't the accumulator letting the compiler use tail call optimization?
2020-10-09 20:43:25 +0200 <monochrom> That turns out to be much uglier in this case. And don't even get me started on efficiency.
2020-10-09 20:43:53 +0200 <ski> Guest18 : yes, that might be preferrable (at least if you'd be using say `Int' or `Integer' ..) .. but then you should make sure to force the accumulator, as you go
2020-10-09 20:44:13 +0200 <monochrom> Because you then have to say "if the recursion gives you Nothing, nothing to add" and "if the recursion gives you Just n, now it's Just (n+1)"
2020-10-09 20:44:23 +0200 <ski> Guest18 : but ignoring such performance considerations, a non-accumulating version can often be more readable
2020-10-09 20:44:31 +0200 <ski> yea, there's that
2020-10-09 20:45:17 +0200 <ski> Guest18 : depending, it's commonly preferable to not be tail-recursive
2020-10-09 20:45:23 +0200 <monochrom> For computing tree height or tree size, yes I would do "1 + height left + height right".
2020-10-09 20:45:52 +0200 <monochrom> In fact for height and size, tail recursion is the much uglier one.
2020-10-09 20:45:58 +0200 <ski> (but in this case, you're just computing a single number, so there's not much point to that, here)
2020-10-09 20:46:05 +0200 <monochrom> Also throughout, my "ugly" includes both ugly and hard to follow.
2020-10-09 20:46:10 +0200 <dolio> monochrom: Not only that, it's easier to not be better than an accumulator with that. :)
2020-10-09 20:46:18 +0200 <monochrom> because they are caused by complications
2020-10-09 20:46:18 +0200 <dolio> An unforced accumulator, that is.
2020-10-09 20:47:00 +0200 <ski> (i suppose an alternative here would be CPS ..)
2020-10-09 20:47:23 +0200 <monochrom> Oh CPS is the most unreadable of them all haha
2020-10-09 20:47:52 +0200 <ski> hm, i think it could be more readable than doing `case's
2020-10-09 20:48:14 +0200 <Guest18> https://dpaste.com/DRF3G9AA6 -- any other suggestions?
2020-10-09 20:48:17 +0200 <ski> (as long as one's familiar with CPS, of course)
2020-10-09 20:48:46 +0200 <ski> Guest18 : your `Show' instance is incorrect
2020-10-09 20:49:22 +0200 <monochrom> <CPS> Mirror mirror, who's the most unreadable of them all? <Mirror> You, in all Haskell Land. <CPS> But I mean universally, not just Haskell Land. <Mirror> Then it's your step daughter, CPS+trampolining, she's is Javascript Forest now.
2020-10-09 20:49:23 +0200geekosaur(82659a05@host154-005.vpn.uakron.edu)
2020-10-09 20:49:44 +0200 <Guest18> ski: how so? it works fine for me
2020-10-09 20:50:02 +0200 <ski> Guest18 : it doesn't output valid Haskell source
2020-10-09 20:50:17 +0200 <dolio> monochrom: That's why you need delimited continuations, to make it perfectly clear.
2020-10-09 20:50:47 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2020-10-09 20:50:59 +0200 <monochrom> <CPS> I'm going to give reactive node.js thingy to Javascript Forest to poison them all!
2020-10-09 20:51:06 +0200Ariakenom__(~Ariakenom@h-155-4-221-50.NA.cust.bahnhof.se)
2020-10-09 20:51:11 +0200nyd(~lpy@unaffiliated/elysian)
2020-10-09 20:51:21 +0200 <Guest18> ski: why should it? I just wanted a more readable version, so i can debug easily
2020-10-09 20:51:23 +0200 <ski> Guest18 : if you want to do custom pretty-printing, then please don't use `Show' for that. (`Show' instances are meant to work together. your instance, when combined with other `Show' instances, will produce a mixture of Haskell and non-Haskell code). please define a separate function, say `displayTree'
2020-10-09 20:51:39 +0200 <Guest18> ski: oh, okay
2020-10-09 20:51:52 +0200 <Guest18> That actually makes sense
2020-10-09 20:52:19 +0200 <geekosaur> also Show and Read are designed to work together such that the output of a valid Show instance can be passed to `read'
2020-10-09 20:52:51 +0200 <ski> Haskell will automatically combine instances like this, e.g. if you were to display a list of type `[BST (BST a)]'
2020-10-09 20:52:58 +0200 <ski> yes, that too
2020-10-09 20:53:00 +0200 <tomsmeding> monochrom: :D
2020-10-09 20:53:08 +0200 <Guest18> I also have a flatten, insert, search and fromList functions and want to add some more. I'm really digging how easy it is to make these kind of stuff in Haskell
2020-10-09 20:54:25 +0200Ariakenom_(~Ariakenom@h-155-4-221-50.NA.cust.bahnhof.se) (Ping timeout: 240 seconds)
2020-10-09 20:55:20 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c)
2020-10-09 20:55:23 +0200vicfred(~vicfred@unaffiliated/vicfred) (Quit: Leaving)
2020-10-09 20:56:03 +0200Pasalmachow(~textual@2601:643:8000:a570:9513:b921:a468:618c) (Client Quit)
2020-10-09 20:56:18 +0200 <ski> Guest18 : there are cases when one may want to make a hand-written `Show' (and `Read') instance. e.g. when the implementation can't manage to derive one for you. or when you're making an abstract data type, and don't want to expose your implementation, but rather display a value in terms of the exported operations
2020-10-09 20:57:24 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-10-09 20:59:43 +0200 <Guest18> yeah, this was more for the educational value than naything else
2020-10-09 21:00:06 +0200Sososasa(~textual@2601:643:8000:a570:9513:b921:a468:618c)
2020-10-09 21:00:35 +0200 <Guest18> follow up question
2020-10-09 21:01:21 +0200 <dwts> Which haskell book would you guys suggest for someone new to haskell but not new to programming? I've started "Get programming with Haskell" but I'm not very happy with it
2020-10-09 21:02:17 +0200 <Guest18> say i have the following line of code: `[depth x tree | x <- flatten tree]`. How do i sum up these depths? Since they are wrapped in a Just, I can't just use `sum` on the list
2020-10-09 21:02:20 +0200gxt(~gxt@gateway/tor-sasl/gxt) (Remote host closed the connection)
2020-10-09 21:02:51 +0200 <Cale> dwts: Graham Hutton's Programming in Haskell seems pretty good
2020-10-09 21:03:01 +0200 <dwts> To help you understand what I don't like: 1) it doesn't explain how to indent code 2) it doesn't explain how to read function definitions
2020-10-09 21:03:09 +0200 <dwts> Cale: thank you sir
2020-10-09 21:03:12 +0200GyroW_(~GyroW@d54c03e98.access.telenet.be)
2020-10-09 21:03:12 +0200GyroW_(~GyroW@d54c03e98.access.telenet.be) (Changing host)
2020-10-09 21:03:12 +0200GyroW_(~GyroW@unaffiliated/gyrow)
2020-10-09 21:03:15 +0200gxt(~gxt@gateway/tor-sasl/gxt)
2020-10-09 21:03:17 +0200 <Cale> Guest18: What do you want to do if there's a Nothing?
2020-10-09 21:03:36 +0200berberman_(~berberman@unaffiliated/berberman)
2020-10-09 21:03:40 +0200 <Cale> Guest18: Oh, of course there won't be
2020-10-09 21:03:47 +0200berberman(~berberman@unaffiliated/berberman) (Ping timeout: 240 seconds)
2020-10-09 21:04:26 +0200GyroW(~GyroW@unaffiliated/gyrow) (Ping timeout: 256 seconds)
2020-10-09 21:04:55 +0200 <Cale> Guest18: One cute way is to write [d | x <- flatten tree, Just d <- [depth x tree]]
2020-10-09 21:05:30 +0200 <Cale> But it seems a bit expensive to be doing it like this
2020-10-09 21:05:35 +0200 <Guest18> Cale: yeah, there will never be nothing
2020-10-09 21:06:17 +0200vicfred(~vicfred@unaffiliated/vicfred)
2020-10-09 21:06:29 +0200 <monochrom> <pun>Just cause to use fromJust? >:) </pun>
2020-10-09 21:06:34 +0200 <Cale> You're going to end up paying the price to look up every element of the tree, when ideally you'd do none of that work
2020-10-09 21:07:47 +0200 <monochrom> More realistically, how about directly write a function that computes the list of all depths of all internal nodes?
2020-10-09 21:08:13 +0200 <monochrom> Or even, a tree of the same shape but keys are replaced by depths; then use flatten.
2020-10-09 21:08:22 +0200 <Cale> yeah
2020-10-09 21:08:24 +0200cr0ssw1nd(~crosswind@adsl-174.176.58.193.tellas.gr)
2020-10-09 21:08:51 +0200 <Cale> avoid all the order comparisons
2020-10-09 21:08:58 +0200 <Guest18> monochrom: i like the first idea, seems pretty efficient
2020-10-09 21:08:58 +0200 <ski> monochrom : Just because
2020-10-09 21:09:54 +0200 <Guest18> so using fromJust is expensive?
2020-10-09 21:10:18 +0200 <koz_> Guest18: It's not expensive, it's just error-prone, and you wanna avoid it if possible.
2020-10-09 21:10:19 +0200 <ski> no, repeatedly traverersing down the tree, for every element in it, is
2020-10-09 21:10:20 +0200 <geekosaur> no, Just a bad idea
2020-10-09 21:10:22 +0200 <monochrom> No. It's just unsatisfactory.
2020-10-09 21:10:23 +0200 <koz_> And in this case, it's 100% possible.
2020-10-09 21:10:41 +0200crossw1nd(~crosswind@188.73.195.239)
2020-10-09 21:11:30 +0200whiteline(~whiteline@unaffiliated/whiteline) (Remote host closed the connection)
2020-10-09 21:11:47 +0200whiteline(~whiteline@unaffiliated/whiteline)
2020-10-09 21:11:55 +0200 <Guest18> Well, it's not error prone, because i am guaranteed that depth will never return Nothing in my list comprehension
2020-10-09 21:12:07 +0200 <Guest18> but i see why it isn't efficient
2020-10-09 21:12:20 +0200 <dsal> dwts: I really like haskellbook.com -- it's easier if you pretend that you're new to programming
2020-10-09 21:12:59 +0200 <Guest18> I am going to get back to you with a better solution
2020-10-09 21:13:19 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:c588:f17e:f3e:2fb3) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 21:13:26 +0200 <Cale> Guest18: It's often error prone in that while your code might satisfy the precondition to not have fromJust crash when you write the fromJust, future changes to the code often result in fromJust being applied to Nothing, and they're a total pain to deal with
2020-10-09 21:13:26 +0200cr0ssw1nd(~crosswind@adsl-174.176.58.193.tellas.gr) (Ping timeout: 256 seconds)
2020-10-09 21:13:38 +0200 <Cale> > fromJust Nothing
2020-10-09 21:13:41 +0200 <lambdabot> *Exception: Maybe.fromJust: Nothing
2020-10-09 21:13:44 +0200 <Cale> ^^ this is all you get at runtime
2020-10-09 21:13:54 +0200 <Cale> Note the lack of a source location to help you
2020-10-09 21:14:06 +0200 <Cale> I would actually usually prefer to write (\(Just x) -> x)
2020-10-09 21:14:10 +0200 <Cale> just because...
2020-10-09 21:14:18 +0200 <Cale> > (\(Just x) -> x) Nothing
2020-10-09 21:14:20 +0200 <lambdabot> *Exception: <interactive>:3:2-15: Non-exhaustive patterns in lambda
2020-10-09 21:14:37 +0200 <Cale> ^^ that will include the file and line number of the lambda which failed to match
2020-10-09 21:14:50 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:744e:3fd6:7740:f62b)
2020-10-09 21:14:56 +0200 <Guest18> Although, I must say, I was getting errors non-stop when i started with haskell, but now, i kinda get some things and i start to understand where the ghc has a problem and know how to fix it. It is really satisfying to write haskell :))
2020-10-09 21:15:23 +0200 <Guest18> Cale: I see, good to know! Thanks!
2020-10-09 21:15:32 +0200 <Cale> Yeah, generally the type system makes refactors a lot more manageable -- you learn to rely on the errors that the compiler is going to give you
2020-10-09 21:15:52 +0200 <Cale> You can just change something and let the compiler figure out most of the consequences
2020-10-09 21:15:58 +0200 <ski> dsal : i suspect they didn't want to pretend that. (especially since they come from Scheme)
2020-10-09 21:16:42 +0200 <dsal> Yeah, scheme might be a more gentle approach vector.
2020-10-09 21:16:58 +0200 <Guest18> Cale: yees, i so love it. I dread working with normal, idiomatic C# now, I much favor using functional constructs in it now
2020-10-09 21:17:40 +0200 <Guest18> One of these days, I am gonna suggest to my boss to maybe let me work in F#
2020-10-09 21:18:15 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de)
2020-10-09 21:19:04 +0200ashbreeze(~mark@72-161-255-112.dyn.centurytel.net) (Ping timeout: 272 seconds)
2020-10-09 21:19:05 +0200 <Guest18> I heard F# is pretty good actually, what do you think?
2020-10-09 21:19:43 +0200_ashbreeze_(~mark@72-161-255-112.dyn.centurytel.net)
2020-10-09 21:20:41 +0200 <koz_> As far as I am aware, F# is basically .NET's Scala.
2020-10-09 21:20:59 +0200 <dsal> Isn't F# ocaml?
2020-10-09 21:21:20 +0200 <dsal> I don't know much about microsoft.
2020-10-09 21:21:25 +0200 <dolio> It's more like ocaml than scala, I think.
2020-10-09 21:21:26 +0200 <Guest18> dsal: that's what i heard, and seeing it, yeah, it is very similar to ocaml
2020-10-09 21:21:39 +0200 <koz_> dolio: Yeah, that's a fair call.
2020-10-09 21:22:27 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-09 21:22:36 +0200 <dolio> It's missing a lot of ML stuff, though.
2020-10-09 21:22:58 +0200 <dolio> Or maybe not a lot, but what it's missing is significant.
2020-10-09 21:23:04 +0200 <Guest18> like what?
2020-10-09 21:23:11 +0200 <dolio> The module system.
2020-10-09 21:23:49 +0200 <Guest18> it does have modules though
2020-10-09 21:24:32 +0200 <dolio> It doesn't have ML style modules.
2020-10-09 21:25:26 +0200 <aldum> anyone know about F*?
2020-10-09 21:26:01 +0200 <aldum> allegedly it's an even more advanced functional lang from MS, but there's not much out there about it
2020-10-09 21:26:14 +0200 <Guest18> never heard of it
2020-10-09 21:26:17 +0200 <monochrom> Oh, if you already have a Scheme background, then "a gentle introduction to haskell" ought to do.
2020-10-09 21:26:22 +0200GyroW(~GyroW@d54C03E98.access.telenet.be)
2020-10-09 21:26:22 +0200GyroW(~GyroW@d54C03E98.access.telenet.be) (Changing host)
2020-10-09 21:26:22 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-09 21:27:49 +0200GyroW_(~GyroW@unaffiliated/gyrow) (Ping timeout: 264 seconds)
2020-10-09 21:29:27 +0200 <dminuoso> It's very gentle.
2020-10-09 21:29:31 +0200 <dminuoso> The name isn't totally misleading.
2020-10-09 21:29:39 +0200 <monochrom> \∩/ "In the rest of the paper we will often say “more polymorphic than” instead of the more precise but clumsier “at least as polymorphic as”." I have always wanted to do that.
2020-10-09 21:29:42 +0200dminuosostops with the tongue-in-cheek
2020-10-09 21:30:05 +0200ashbreeze(~mark@72-161-253-2.dyn.centurytel.net)
2020-10-09 21:30:18 +0200 <monochrom> It is gentle if you're OK with Scheme or ML or ...
2020-10-09 21:30:21 +0200wroathe_(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-09 21:30:30 +0200 <dminuoso> It's still not, really.
2020-10-09 21:31:27 +0200 <dminuoso> I'd say the type system, lack-of-IO-purity and lazyness make for a pretty wild experience, even from Scheme.
2020-10-09 21:31:27 +0200chenshen(~chenshen@2620:10d:c090:400::5:7709) (Quit: My MacBook Pro has gone to sleep. ZZZzzz…)
2020-10-09 21:32:01 +0200wroathe(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net) (Ping timeout: 264 seconds)
2020-10-09 21:32:07 +0200bifunc2(bifunc2@gateway/vpn/protonvpn/bifunc2) (Quit: -)
2020-10-09 21:32:35 +0200 <dminuoso> The gentle introduction is just a very brief rush over Haskell that works well enough for someone who comes from say Idris.
2020-10-09 21:32:52 +0200 <dminuoso> It doesn't teach the language at all
2020-10-09 21:32:56 +0200 <dolio> I read it after learning Scheme.
2020-10-09 21:33:03 +0200_ashbreeze_(~mark@72-161-255-112.dyn.centurytel.net) (Ping timeout: 260 seconds)
2020-10-09 21:33:06 +0200 <monochrom> It worked very well for me, and Idris didn't exist when it worked for me.
2020-10-09 21:33:42 +0200 <dsal> I played with haskell for years and even had some useful not-completely-trivial programs, but it wasn't until I suspended prior knowledge that understanding got a lot easier.
2020-10-09 21:34:49 +0200 <dminuoso> monochrom: Says the professor in comp sci.
2020-10-09 21:34:51 +0200 <dminuoso> ;)
2020-10-09 21:34:54 +0200 <monochrom> nor Agda. Coq existed but I wasn't patient with it, I gave up after a few simple propositions.
2020-10-09 21:35:10 +0200cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net) (Quit: Goodbye)
2020-10-09 21:35:36 +0200 <monochrom> For the type system you could point towards me having done ML before I ran into Haskell.
2020-10-09 21:36:01 +0200 <monochrom> But how the hell did I grok ML's type system in the first place, after only Scheme and Pascal?
2020-10-09 21:36:14 +0200 <monochrom> Well I guess I also met Ada.
2020-10-09 21:36:32 +0200 <dolio> I didn't do ML first.
2020-10-09 21:36:35 +0200 <monochrom> and C++ templates
2020-10-09 21:37:48 +0200 <ski> monochrom : with Ada generics ?
2020-10-09 21:38:02 +0200 <monochrom> My feeling is that, eg, Hutton's and Bird's are only more wordy, and more examples, than the gentle introduction. But not gentler.
2020-10-09 21:38:06 +0200 <monochrom> Yeah
2020-10-09 21:38:25 +0200darjeeling_(~darjeelin@122.245.210.138) (Ping timeout: 240 seconds)
2020-10-09 21:39:15 +0200 <monochrom> Those books feel gentler because the wordy fillers forces you to spend 500 pages of time over what could be said in 10 pages such is in the gentle introduction.
2020-10-09 21:39:45 +0200jollygood2(~bc8165ab@217.29.117.252) (Ping timeout: 240 seconds)
2020-10-09 21:40:02 +0200 <monochrom> This means if you consume the gentle introduction at the slow rate of, like, one afternoon per paragraph, then it's gentle.
2020-10-09 21:40:09 +0200 <monochrom> And I think I did exactly that.
2020-10-09 21:40:41 +0200darjeeling_(~darjeelin@122.245.210.138)
2020-10-09 21:40:47 +0200 <dminuoso> I think its highly situational
2020-10-09 21:40:54 +0200 <dwts> dsal: let me check that - thanks
2020-10-09 21:41:33 +0200 <dolio> If you already know how to write scheme programs, it seems like enough to start messing around.
2020-10-09 21:41:44 +0200 <dolio> It won't teach you everthing about every situation, obviously.
2020-10-09 21:41:47 +0200geekosaur(82659a05@host154-005.vpn.uakron.edu) (Remote host closed the connection)
2020-10-09 21:43:19 +0200 <dsal> dwts: When I started learning Haskell for real, I had production code in c, c++, objective c, ocaml, java, scheme, perl, tcl, erlang, ruby, r, and probably something else I forgot. Tossing another language on seemed like no big deal.
2020-10-09 21:43:49 +0200 <dsal> Haskell isn't hard fundamentally. People build a lot of seemingly complex things in Haskell, but that's because it's easy. :)
2020-10-09 21:44:48 +0200leungbk(~user@2605:e000:1315:706:ec37:30e1:3998:1459)
2020-10-09 21:44:52 +0200 <dsal> I realized I never had any production Eiffel. I built a postgres replication system in it, but clearly I never made anything I thought was useful enough.
2020-10-09 21:46:11 +0200 <dwts> dsal: I can't yet have an opinion if it's hard or not, but I need to get a better understanding on the function definitions (and how to read them e.g. when reading the haskell docs). Functional programming is not new to me as I've played with scheme before, but I tend to find the parentheses much more readable (so far)
2020-10-09 21:46:56 +0200taurux(~taurux@net-188-152-69-171.cust.dsl.teletu.it) (Ping timeout: 272 seconds)
2020-10-09 21:47:31 +0200 <dsal> Heh. Yeah. I used to write a lot of (small) scheme. It was fine. ocaml was a bigger step for me. But I went from "Haskell is really hard and only for elite snobs" to finding it the easiest language to work in for almost anything I want to do.
2020-10-09 21:47:41 +0200taurux(~taurux@net-93-144-148-150.cust.dsl.teletu.it)
2020-10-09 21:48:04 +0200 <dolio> Maybe the problem is that I was content messing around with homework exercises in Haskell, but it seems like a lot of people only want to 'mess around' if it involves a ton of web junk or something.
2020-10-09 21:48:16 +0200 <dwts> I wish I'll reach that stage, so far it manages to make me feel like a complete idiot :)
2020-10-09 21:48:35 +0200 <dsal> Yeah, that's why I like the approach of suspending knowledge and watching it all unfold.
2020-10-09 21:48:53 +0200 <dolio> And all the web junk in Haskell is fancy.
2020-10-09 21:48:55 +0200 <dwts> the irc community doesn't seem snob at all btw, lots of interesting conversations in here
2020-10-09 21:48:55 +0200elliott_(~elliott@pool-108-51-141-12.washdc.fios.verizon.net)
2020-10-09 21:48:57 +0200 <dsal> Much of the really cool magic goes away when you become a magician, but then you can still get more done more eaisly.
2020-10-09 21:49:21 +0200 <dsal> Haskell folks really like Haskell and want everyone to feel the same joy.
2020-10-09 21:49:44 +0200 <ski> dwts : yea, often it seems newbies goes way overboard with `$' .. i much prefer seeing the brackets, much of the time. using `.' is fine, though
2020-10-09 21:50:14 +0200 <dsal> If I have a lot of $ in code, it's because I'm shell scripting incrementally in Haskell.
2020-10-09 21:50:36 +0200 <dwts> ski: I guess the haskell people tried a lot to avoid the parens. You can clearly see that in the funciton definitions
2020-10-09 21:51:05 +0200 <dminuoso> Question, why exactly do we have no parens for function application?
2020-10-09 21:51:08 +0200 <monochrom> What dolio said is true of me too. Also generally not just web junk, but overall any "real" "application".
2020-10-09 21:51:18 +0200 <dsal> dminuoso: You can if you want, but why do you want?
2020-10-09 21:51:26 +0200 <ski> dminuoso : curried style ?
2020-10-09 21:51:33 +0200 <ghoulguy> dminuoso: with functions all taking a single argument it probably gets pretty noisy to do it with them
2020-10-09 21:51:34 +0200 <dwts> I thought hat you can use parens?
2020-10-09 21:51:37 +0200 <ski> possibly goes back to ISWIM, at least ?
2020-10-09 21:51:57 +0200 <dwts> s/hat/that
2020-10-09 21:52:04 +0200 <nshepperd1> too many parentheses spoil the curry
2020-10-09 21:52:10 +0200 <monochrom> Me, I believe in "stronger foundation before higher ambition". More need to mess around with "toys" to more deeply understand what's really going on, before it's meaningful to try a useful project.
2020-10-09 21:52:29 +0200 <dolio> Logicians were already avoiding parentheses when Church was around.
2020-10-09 21:52:45 +0200 <dsal> > subtract (7) (5)
2020-10-09 21:52:46 +0200 <ski> yea, combinatory logic
2020-10-09 21:52:47 +0200 <lambdabot> -2
2020-10-09 21:52:48 +0200 <dminuoso> Im just wondering whether someone knows what the reason was
2020-10-09 21:52:58 +0200 <dminuoso> Id say the immediate reason was that Miranda was that way I guess
2020-10-09 21:53:06 +0200 <ski> Church did curried stylw
2020-10-09 21:53:27 +0200 <ski> yea
2020-10-09 21:53:30 +0200 <dminuoso> But, perhaps the origins of parens-less function application are just lambda calculus?
2020-10-09 21:53:35 +0200 <dwts> I assume the lambda bot is written in haskell too?
2020-10-09 21:53:39 +0200 <ski> yes
2020-10-09 21:53:41 +0200 <dwts> nice
2020-10-09 21:53:47 +0200 <monochrom> If you point at Miranda then you still have the question "so why did they do it this way?"
2020-10-09 21:53:51 +0200 <dminuoso> Right. :)
2020-10-09 21:53:52 +0200Sososasa(~textual@2601:643:8000:a570:9513:b921:a468:618c) (Quit: Textual IRC Client: www.textualapp.com)
2020-10-09 21:53:56 +0200 <ski> @version
2020-10-09 21:53:56 +0200 <lambdabot> lambdabot 5.3.0.1
2020-10-09 21:53:57 +0200 <lambdabot> git clone https://github.com/lambdabot/lambdabot
2020-10-09 21:54:02 +0200 <dminuoso> My instinct says it was from lambda calculus.
2020-10-09 21:54:16 +0200 <monochrom> But really you look at eg Landin's papers "f(x)(y)(z)(t)" after a while you would invent "f x y z" too.
2020-10-09 21:54:26 +0200 <ski> monochrom : the "why ?"s never end :)
2020-10-09 21:54:33 +0200 <dsal> It also kind of overloads the meaning of ()
2020-10-09 21:54:42 +0200 <ski> math, yes
2020-10-09 21:54:47 +0200wz1000(~wz1000@static.11.113.47.78.clients.your-server.de) (Ping timeout: 240 seconds)
2020-10-09 21:54:49 +0200 <ski> (heavily)
2020-10-09 21:54:54 +0200 <monochrom> Disgust is the mother of syntax invention. :)
2020-10-09 21:55:01 +0200 <dminuoso> Well, I was hoping for someone to just have a citation ready "XYZ explained the decision in publication ABC"
2020-10-09 21:55:03 +0200 <dminuoso> :p
2020-10-09 21:55:12 +0200 <dminuoso> monochrom: Disgust is sometimes also the child of it.
2020-10-09 21:55:24 +0200 <dwts> 22:54 < monochrom> Disgust is the mother of syntax invention. :)
2020-10-09 21:55:25 +0200elliott_(~elliott@pool-108-51-141-12.washdc.fios.verizon.net) (Ping timeout: 265 seconds)
2020-10-09 21:55:28 +0200 <dwts> that quote is gold ^
2020-10-09 21:55:42 +0200 <ski> there's `@remember', if you think it's memorable enough
2020-10-09 21:55:53 +0200 <dolio> Back in the 30s and such they were doing `∃ x . P` to avoid the parentheses in `(∃x)(P)` and such. :)
2020-10-09 21:56:09 +0200isovector1(~isovector@172.103.216.166)
2020-10-09 21:56:13 +0200 <dminuoso> dolio: hold on, what did the spaces add exactly there?
2020-10-09 21:56:24 +0200 <dminuoso> `∃x.P` seems clear as well
2020-10-09 21:56:24 +0200 <dolio> The spaces aren't important. The dot is.
2020-10-09 21:56:27 +0200 <dminuoso> Ah
2020-10-09 21:56:29 +0200 <ski> before ⌜(∀x)Px⌝ it was ⌜(x)Px⌝
2020-10-09 21:56:38 +0200 <dolio> Dot is kind of like $. Low-precedence.
2020-10-09 21:56:42 +0200 <monochrom> dolio, then I'm really disappointed that many 1960s logic textbooks still go "(∃x)(P)"
2020-10-09 21:56:44 +0200 <ski> @help remember
2020-10-09 21:56:45 +0200 <lambdabot> remember <nick> <quote>: Remember that <nick> said <quote>.
2020-10-09 21:57:03 +0200 <dminuoso> See, the one thing mathematical publications is missing, is fixity declarations of these notations.
2020-10-09 21:57:05 +0200 <dwts> ah, I see
2020-10-09 21:57:29 +0200 <ski> the brackets in ⌜(x)Px⌝ comes from the "rounded dent" in Frege's two-dimensional notation for graphical formulae
2020-10-09 21:57:32 +0200 <dwts> thanks ski
2020-10-09 21:57:39 +0200 <dolio> Also you write `P ⊃. Q ⊃ R` to avoid `P ⊃ (Q ⊃ R)`
2020-10-09 21:58:02 +0200 <ski> yes, there should be a language that picks up the dot notation, instead of brackets
2020-10-09 21:58:03 +0200 <monochrom> Yikes.
2020-10-09 21:58:04 +0200 <dolio> Because making it associate one way wasn't a thing yet.
2020-10-09 21:58:08 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 21:58:27 +0200 <monochrom> Well there is now a language that picks up the $ notation. It's called Haskell. :)
2020-10-09 21:58:47 +0200isovector1(~isovector@172.103.216.166) (Client Quit)
2020-10-09 21:59:01 +0200 <ski> it annoyes me when people write `foo $ bar $ ...' or `blah (f $ ...)'
2020-10-09 21:59:18 +0200 <ski> usually the code is clearer, reinserting the brackets
2020-10-09 21:59:45 +0200 <dminuoso> my rule of thumb is, ($) is for non-BlockArguments code and liftIO/lift :p
2020-10-09 22:00:11 +0200 <ski> yea, `lift $ ...',`liftIO $ ...',`return $ ...',`pure $ ...' can be okay
2020-10-09 22:01:09 +0200 <ski> (but if `...' is just a simple expression (on a single line), with no brackets, i'd usually replace the `$' by brackets, anyway)
2020-10-09 22:01:43 +0200 <dsal> $ is for the last thing in a chain of .
2020-10-09 22:01:56 +0200 <Cale> I'm perfectly happy writing stuff like liftIO . forM blah $ \x -> ...
2020-10-09 22:02:16 +0200 <dolio> Yeah, putting a $ at the end of a composition is what I usually do.
2020-10-09 22:02:25 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 240 seconds)
2020-10-09 22:04:28 +0200nshepperd1can't stop thinking about that idea of abusing BlockArguments to substitute indentation for parentheses
2020-10-09 22:04:36 +0200 <Cale> P ⊃: Q ⊃. R ⊃ S for P ⊃ (Q ⊃ (R ⊃ S))
2020-10-09 22:04:42 +0200 <dolio> nshepperd1: Yeah, can't say I'm a fan of that.
2020-10-09 22:04:42 +0200 <Cale> moar dots
2020-10-09 22:05:00 +0200 <Cale> That'll be a 50 dkp minus for parens
2020-10-09 22:05:04 +0200conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-10-09 22:05:07 +0200 <dolio> Cale: You're not thinking creatively enough.
2020-10-09 22:05:10 +0200 <dminuoso> nshepperd1: can you elaborate?
2020-10-09 22:05:40 +0200 <ski> nshepperd1 : yea, i'll need to think about that
2020-10-09 22:05:40 +0200 <dolio> P ⊃ Q .⊃. P ⊃ R
2020-10-09 22:06:17 +0200 <ski> that's ⌜(P ⊃ Q) ⊃ (P ⊃ R)⌝
2020-10-09 22:06:28 +0200 <dolio> Yeah, obviously. :)
2020-10-09 22:06:49 +0200 <dwts> dsal: I'll probably get the book you suggested
2020-10-09 22:07:05 +0200coot(~coot@37.30.49.218.nat.umts.dynamic.t-mobile.pl) (Ping timeout: 240 seconds)
2020-10-09 22:07:11 +0200 <Cale> The periods are literal pauses in speech
2020-10-09 22:07:13 +0200 <dwts> looks promising
2020-10-09 22:07:16 +0200 <Cale> haha
2020-10-09 22:07:28 +0200 <ski> but then the periods were also used for conjunction, at the same time
2020-10-09 22:07:44 +0200 <Cale> If you were speaking "P implies Q ... implies ... P implies R", people would know where you wanted the parens
2020-10-09 22:07:50 +0200 <dsal> dwts: I've found the slow path the fastest way to get there.
2020-10-09 22:07:55 +0200 <dolio> You can put them on any connective.
2020-10-09 22:08:27 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 22:08:34 +0200 <dwts> dsal: what do you define as slow path here?
2020-10-09 22:09:00 +0200rprije(~rprije@203.214.95.251)
2020-10-09 22:09:19 +0200 <dolio> I was looking at Church's simple type theory recently, and one of his core things is 'A' which stands for ∨.
2020-10-09 22:09:22 +0200conal(~conal@64.71.133.70)
2020-10-09 22:09:50 +0200 <dsal> dwts: That book starts with really basic fundamentals that kind of seem obvious, but walks you through layers in a fairly slow, but deliberate way, building on things until, instead of running around asking people to explain what a Monad is, you find yourself wanting a solution to a problem and realize that the name of that solution is Monad (or whatever part you're on).
2020-10-09 22:10:01 +0200 <ski> Cale : some math teacher got a bit confused, at one point, when i used indentation rather than brackets, for indicating precedence
2020-10-09 22:10:30 +0200 <ski> hm, for "Alternative" or something like that, dolio ?
2020-10-09 22:10:37 +0200 <dsal> dwts: e.g., instead of just throwing cool magic things at you, it shows you how function application works. And then you build on that. By the time you get to magic, there's no magic left.
2020-10-09 22:10:46 +0200 <dolio> I have no idea. I guess that makes more sense.
2020-10-09 22:10:48 +0200chenshen(~chenshen@2620:10d:c090:400::5:1bbd)
2020-10-09 22:10:57 +0200 <dwts> dsal: that sounds encouraging. No that I don't enjoy to other people more knowledgable than me, but the best way to learn is by reading/experimenting on your own
2020-10-09 22:11:02 +0200 <dsal> dwts: vs. trying to take a concept you know and "translate" it to Haskell and then maybe stuff in an advanced concept.
2020-10-09 22:11:15 +0200 <Cale> dolio: 'A' for "or"?
2020-10-09 22:11:22 +0200 <dsal> To be fair, I did a lot of this in parallel with solving problems I had.
2020-10-09 22:11:27 +0200 <dwts> yeah, that is very common (trying to translate from other langs)
2020-10-09 22:11:35 +0200 <dolio> Cale: Yeah. Then p∧q = ¬(¬p∨¬q).
2020-10-09 22:11:57 +0200 <dwts> dsal: it's hard to stay 100% on a book's exercises/examples
2020-10-09 22:12:05 +0200 <ski> hm, Frege had conjunction, negation, universal, as primitives
2020-10-09 22:12:05 +0200 <dwts> as you try new things, new ideas pop up usualy
2020-10-09 22:12:07 +0200 <dwts> usually*
2020-10-09 22:12:14 +0200 <ski> hmm
2020-10-09 22:12:20 +0200 <dsal> Yeah, exercises are often too narrow to really understand what they're doing.
2020-10-09 22:12:23 +0200 <ski> or was it implication, rather than conjunction ?
2020-10-09 22:12:24 +0200 <dwts> so you want to try them while you learn that new language
2020-10-09 22:12:49 +0200 <dwts> in any case, I need to go offline, long day tomorrow
2020-10-09 22:12:55 +0200 <dsal> I really enjoy doing Advent of Code in Haskell. Lots of applied knowledge.
2020-10-09 22:12:56 +0200 <ski> ah, it was implication
2020-10-09 22:13:00 +0200 <dwts> thank you all for your help
2020-10-09 22:13:02 +0200 <dwts> cheers
2020-10-09 22:13:03 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 260 seconds)
2020-10-09 22:13:11 +0200 <dwts> dsal: note taken
2020-10-09 22:13:11 +0200 <no-n> dsal, what book?
2020-10-09 22:13:11 +0200 <ski> have fun, dwts !
2020-10-09 22:13:30 +0200 <ski> @where HPFFP
2020-10-09 22:13:31 +0200 <lambdabot> "Haskell Programming: from first principles - Pure functional programming without fear or frustration" by Chistopher Allen (bitemyapp),Julie Moronuki at <http://haskellbook.com/>,#haskell-beginners
2020-10-09 22:14:22 +0200conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-10-09 22:14:57 +0200 <no-n> oh, ok. that one is still on my reading list :p
2020-10-09 22:15:36 +0200knupfer(~Thunderbi@i59F7FF25.versanet.de) (Quit: knupfer)
2020-10-09 22:15:37 +0200knupfer1(~Thunderbi@200116b82c4c7d00e0839dc4feebae4b.dip.versatel-1u1.de)
2020-10-09 22:16:04 +0200 <nshepperd> dminuoso: i forget exactly how the person i saw using it had things laid out, but like this https://zlkj.in:8778/uploads/33f4737ce81a95c4/lisp.hs
2020-10-09 22:16:07 +0200knupfer1(~Thunderbi@200116b82c4c7d00e0839dc4feebae4b.dip.versatel-1u1.de) (Client Quit)
2020-10-09 22:16:15 +0200knupfer(~Thunderbi@200116b82c4c7d006558355e534b95a9.dip.versatel-1u1.de)
2020-10-09 22:16:17 +0200knupfer(~Thunderbi@200116b82c4c7d006558355e534b95a9.dip.versatel-1u1.de) (Client Quit)
2020-10-09 22:16:26 +0200knupfer(~Thunderbi@200116b82c4c7d00cc4c311526e4b875.dip.versatel-1u1.de)
2020-10-09 22:16:49 +0200 <dminuoso> Cunning.
2020-10-09 22:17:17 +0200 <ski> nshepperd1 : reminds me of <https://srfi.schemers.org/srfi-49/srfi-49.html>
2020-10-09 22:17:23 +0200avdb(~avdb@ip-62-235-188-165.dsl.scarlet.be) (Ping timeout: 260 seconds)
2020-10-09 22:17:25 +0200 <dminuoso> % :t (do 'c')
2020-10-09 22:17:25 +0200 <yahb> dminuoso: Char
2020-10-09 22:17:27 +0200 <dminuoso> Wow fancy.
2020-10-09 22:17:32 +0200 <nshepperd> or like this https://zlkj.in:8778/uploads/9e74cf0ad48d0794/lisp.hs
2020-10-09 22:17:33 +0200 <dminuoso> What does do even do. :<
2020-10-09 22:17:37 +0200 <ski> GHC generalization
2020-10-09 22:17:40 +0200 <ski> @undo do x
2020-10-09 22:17:41 +0200 <lambdabot> x
2020-10-09 22:17:44 +0200 <nshepperd> endless possibilities xD
2020-10-09 22:17:51 +0200 <shapr> that's wild
2020-10-09 22:18:11 +0200 <dminuoso> I think Ill just sneak some (do work) bits into my code
2020-10-09 22:18:20 +0200 <dminuoso> Just to confuse future generations
2020-10-09 22:18:40 +0200 <dminuoso> (do work) `and` fix error
2020-10-09 22:18:45 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 22:18:56 +0200nyd(~lpy@unaffiliated/elysian) (Quit: nyd)
2020-10-09 22:19:18 +0200cr0ssw1nd(~crosswind@adsl-174.176.58.193.tellas.gr)
2020-10-09 22:21:07 +0200crossw1nd(~crosswind@188.73.195.239) (Ping timeout: 260 seconds)
2020-10-09 22:22:54 +0200 <ski> > do let in [do () | let,do let {}; not otherwise,case () of]
2020-10-09 22:22:56 +0200 <lambdabot> []
2020-10-09 22:23:40 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 272 seconds)
2020-10-09 22:23:56 +0200 <nshepperd> % do it
2020-10-09 22:23:56 +0200 <yahb> nshepperd: 1
2020-10-09 22:24:46 +0200 <Cheery> I came from python2 to code haskell stuff, now to get a autosummarizer I'm still installing python3, tensorflow, torch, transformers, then have pipeline download gig-large models to summarize articles for me.
2020-10-09 22:25:13 +0200elliott_(~elliott@pool-108-51-141-12.washdc.fios.verizon.net)
2020-10-09 22:26:04 +0200 <nshepperd> i wish you luck in your impossible quest
2020-10-09 22:26:53 +0200stevenxl(uid133530@gateway/web/irccloud.com/x-lycvhaiijjxatwhk)
2020-10-09 22:27:37 +0200 <dminuoso> ski: that's not bad
2020-10-09 22:28:42 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 22:28:52 +0200 <Cheery> I was going to make a python deprecation alliance, now I got to write a footnote "summarized with tensorflow&pals"
2020-10-09 22:30:12 +0200Jesin(~Jesin@pool-72-66-101-18.washdc.fios.verizon.net)
2020-10-09 22:30:22 +0200motherfsck(~motherfsc@unaffiliated/motherfsck) (Read error: Connection reset by peer)
2020-10-09 22:30:28 +0200 <bsima> if I do random.getrandbits(128) in python, what is the equivalent in Haskell?
2020-10-09 22:30:58 +0200hackageuniqueness-periods-vector-properties 0.5.3.0 - Metrices for the maximum element for the uniqueness-periods-vector packages family. https://hackage.haskell.org/package/uniqueness-periods-vector-properties-0.5.3.0 (OleksandrZhabenko)
2020-10-09 22:31:05 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 240 seconds)
2020-10-09 22:31:18 +0200_ashbreeze_(~mark@72-161-51-13.dyn.centurytel.net)
2020-10-09 22:32:26 +0200mmohammadi981266(~mmohammad@5.238.185.98) (Quit: I quit (╯°□°)╯︵ ┻━┻)
2020-10-09 22:32:31 +0200ashbreeze(~mark@72-161-253-2.dyn.centurytel.net) (Ping timeout: 258 seconds)
2020-10-09 22:32:37 +0200 <dminuoso> bsima: You could use the hackage package `random`
2020-10-09 22:32:54 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:744e:3fd6:7740:f62b) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 22:33:00 +0200 <dminuoso> `genShortByteString 16 g` for a suitable RandomGen g
2020-10-09 22:33:07 +0200 <dminuoso> Or maybe some other variants, depends a bit on your usecase
2020-10-09 22:33:13 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 264 seconds)
2020-10-09 22:33:35 +0200 <Cheery> are there well-defined ways to seed it?
2020-10-09 22:34:00 +0200 <Cheery> because you could use genWord64 twice.
2020-10-09 22:34:10 +0200 <dminuoso> Sure
2020-10-09 22:34:20 +0200 <dminuoso> I mean it depends really on what you want the random data for.
2020-10-09 22:35:11 +0200brisbin(~patrick@pool-173-49-158-4.phlapa.fios.verizon.net)
2020-10-09 22:35:30 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:744e:3fd6:7740:f62b)
2020-10-09 22:36:03 +0200 <nshepperd> % do id or do Just do not do otherwise
2020-10-09 22:36:03 +0200 <yahb> nshepperd: False
2020-10-09 22:36:06 +0200 <Cheery> Hm.. yeah, you seem to be able to do plenty of tricks with that stuff.
2020-10-09 22:36:19 +0200 <dsal> I agree with yahb on tha tone.
2020-10-09 22:38:32 +0200leungbk(~user@2605:e000:1315:706:ec37:30e1:3998:1459) (Remote host closed the connection)
2020-10-09 22:38:52 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 22:39:52 +0200zaquest(~notzaques@5.128.210.178) (Quit: Leaving)
2020-10-09 22:40:30 +0200 <dminuoso> % Just do fix error
2020-10-09 22:40:31 +0200 <yahb> dminuoso: ; <interactive>:1:6: error:; Unexpected do block in function application:; do fix error; You could write it with parentheses; Or perhaps you meant to enable BlockArguments?
2020-10-09 22:40:38 +0200 <dminuoso> Gah! Im fighting with someone here.
2020-10-09 22:40:43 +0200 <dminuoso> % :set -XBlockArguments
2020-10-09 22:40:43 +0200 <yahb> dminuoso:
2020-10-09 22:40:45 +0200 <dminuoso> % Just do fix error
2020-10-09 22:40:51 +0200 <yahb> dminuoso: Just "*** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: ***
2020-10-09 22:40:53 +0200 <dminuoso> Someone keeps turning the above extension off.
2020-10-09 22:41:18 +0200rekahsoft(~rekahsoft@fitz10681.telemetry.esentire.com)
2020-10-09 22:42:49 +0200raym(~ray@115.187.50.175) (Remote host closed the connection)
2020-10-09 22:43:01 +0200pera(~pera@unaffiliated/pera)
2020-10-09 22:43:25 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 264 seconds)
2020-10-09 22:43:26 +0200 <bsima> dminuoso: i see, my version of random is 1.1, all the good stuff is in 1.2
2020-10-09 22:44:36 +0200 <dminuoso> bsima: What do you need the random data for?
2020-10-09 22:45:12 +0200 <bsima> i just need a uid
2020-10-09 22:45:40 +0200 <bsima> maybe i'll use the uuid package instead, i don't think i have a constraint for 128=-bits specifically
2020-10-09 22:46:00 +0200bitmapper(uid464869@gateway/web/irccloud.com/x-cqfrvvppmmqjnkgv)
2020-10-09 22:46:14 +0200 <dsal> I like the uuid package on occasion.
2020-10-09 22:46:21 +0200 <dminuoso> Fun fact
2020-10-09 22:46:32 +0200 <dminuoso> There's an entry in procfs that generates uuids: `/proc/sys/kernel/random/uuid`
2020-10-09 22:47:15 +0200 <bsima> cool, unfortunately i'm on mac at the moment
2020-10-09 22:48:07 +0200 <dminuoso> bsima: Random Word64
2020-10-09 22:48:17 +0200 <phadej> % Just do fix error
2020-10-09 22:48:18 +0200 <yahb> phadej: ; <interactive>:1:6: error:; Unexpected do block in function application:; do fix error; You could write it with parentheses; Or perhaps you meant to enable BlockArguments?
2020-10-09 22:48:21 +0200 <phadej> :(
2020-10-09 22:48:28 +0200 <dminuoso> % :set -XBlockArguments
2020-10-09 22:48:28 +0200 <yahb> dminuoso:
2020-10-09 22:48:32 +0200 <phadej> % Just do fix error
2020-10-09 22:48:37 +0200 <yahb> phadej: Just "*** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: ***
2020-10-09 22:48:39 +0200 <phadej> % Just do it
2020-10-09 22:48:40 +0200 <yahb> phadej: ; <interactive>:1:6: error:; Unexpected do block in function application:; do it; You could write it with parentheses; Or perhaps you meant to enable BlockArguments?
2020-10-09 22:48:45 +0200 <phadej> what
2020-10-09 22:48:48 +0200 <phadej> % :set -xBlockArguments
2020-10-09 22:48:48 +0200 <yahb> phadej: Some flags have not been recognized: -xBlockArguments
2020-10-09 22:48:48 +0200 <dminuoso> Someone keeps flipping it off
2020-10-09 22:48:52 +0200ashbreeze(~mark@72-161-51-13.dyn.centurytel.net)
2020-10-09 22:48:52 +0200 <phadej> % :set -XBlockArguments
2020-10-09 22:48:53 +0200 <yahb> phadej:
2020-10-09 22:48:55 +0200 <phadej> % Just do it
2020-10-09 22:48:56 +0200 <yahb> phadej: Just ()
2020-10-09 22:48:58 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 22:49:00 +0200 <phadej> % Just do fix error
2020-10-09 22:49:05 +0200 <yahb> phadej: Just "*** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: ***
2020-10-09 22:49:11 +0200 <phadej> % :set -XBlockArguments
2020-10-09 22:49:12 +0200 <yahb> phadej:
2020-10-09 22:49:14 +0200 <phadej> % Just do it
2020-10-09 22:49:14 +0200 <yahb> phadej: Just ()
2020-10-09 22:49:16 +0200 <int-e> Uhm
2020-10-09 22:49:22 +0200 <phadej> I guess it flips on exception
2020-10-09 22:49:26 +0200 <int-e> doesn't yahb answer privmsgs?
2020-10-09 22:49:36 +0200 <dminuoso> int-e: No it does not. It only answers in #haskell
2020-10-09 22:49:38 +0200 <dminuoso> Clearly.
2020-10-09 22:49:42 +0200 <dminuoso> Otherwise we'd be using queries.
2020-10-09 22:50:03 +0200 <int-e> Well that's weird, because it works for me :-P
2020-10-09 22:50:32 +0200 <monochrom> Some kind of selection bias. (OK I know I know, you were joking. :) )
2020-10-09 22:50:35 +0200 <dsal> Yeah, I usually have private dialogues with yahb and lambdabot.
2020-10-09 22:50:58 +0200 <dminuoso> oleg does not simply have a private chat with yahb.
2020-10-09 22:51:05 +0200_ashbreeze_(~mark@72-161-51-13.dyn.centurytel.net) (Ping timeout: 240 seconds)
2020-10-09 22:51:06 +0200 <phadej> let's try again
2020-10-09 22:51:13 +0200 <phadej> % :set -XBlockArguments
2020-10-09 22:51:13 +0200 <yahb> phadej:
2020-10-09 22:51:20 +0200 <phadej> % error "foo"
2020-10-09 22:51:20 +0200 <yahb> phadej: *** Exception: foo; CallStack (from HasCallStack):; error, called at <interactive>:5:1 in interactive:Ghci6
2020-10-09 22:51:25 +0200 <phadej> % Just do it
2020-10-09 22:51:26 +0200 <yahb> phadej: Just 1
2020-10-09 22:51:34 +0200 <dminuoso> phadej: Oh I have an idea.
2020-10-09 22:51:36 +0200 <phadej> someone is playing with it concurrently!
2020-10-09 22:51:40 +0200 <phadej> % Just do it
2020-10-09 22:51:40 +0200 <yahb> phadej: Just (Just 1)
2020-10-09 22:51:41 +0200 <dminuoso> Maybe, `fix error` hangs yahb
2020-10-09 22:51:51 +0200 <dminuoso> so it gets killed off, and that resets the flags
2020-10-09 22:51:53 +0200 <phadej> because that `1` could come from just somewhere
2020-10-09 22:51:56 +0200 <phadej> % Just do it
2020-10-09 22:51:56 +0200 <yahb> phadej: Just (Just (Just 1))
2020-10-09 22:52:11 +0200 <dminuoso> % fix error
2020-10-09 22:52:17 +0200 <yahb> dminuoso: "*** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Exception: *** Excep
2020-10-09 22:52:18 +0200 <dminuoso> % Just do it
2020-10-09 22:52:19 +0200 <yahb> dminuoso: ; <interactive>:1:6: error:; Unexpected do block in function application:; do it; You could write it with parentheses; Or perhaps you meant to enable BlockArguments?
2020-10-09 22:52:27 +0200 <monochrom> Ah, yeah.
2020-10-09 22:52:29 +0200 <dminuoso> Yeah, I think it's that `fix error` hangs yahb.
2020-10-09 22:53:08 +0200 <monochrom> It's an infinite loop printing that infinite string. Gets timed out and killed. The watchdog starts a new one.
2020-10-09 22:53:25 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 240 seconds)
2020-10-09 22:54:01 +0200 <monochrom> As a corollary, if you want a reset, just use :quit to tell it to quit, the watchdog will start a new one too.
2020-10-09 22:55:38 +0200elliott_(~elliott@pool-108-51-141-12.washdc.fios.verizon.net) (Ping timeout: 260 seconds)
2020-10-09 22:58:53 +0200remexre_remexre
2020-10-09 22:59:07 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 22:59:16 +0200elliott_(~elliott@pool-108-51-141-12.washdc.fios.verizon.net)
2020-10-09 22:59:23 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:744e:3fd6:7740:f62b) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 23:00:02 +0200ButterflyOfFire(~Butterfly@185.163.110.116) ()
2020-10-09 23:00:24 +0200knupfer(~Thunderbi@200116b82c4c7d00cc4c311526e4b875.dip.versatel-1u1.de) (Quit: knupfer)
2020-10-09 23:00:32 +0200knupfer(~Thunderbi@200116b82c4c7d00ac20288f9f283cdb.dip.versatel-1u1.de)
2020-10-09 23:01:06 +0200_vaibhavingale_(~Adium@203.188.228.27) (Quit: Leaving.)
2020-10-09 23:01:19 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 23:01:55 +0200elliott_(~elliott@pool-108-51-141-12.washdc.fios.verizon.net) (Client Quit)
2020-10-09 23:02:53 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:ac:b25b:cce8:9c5a)
2020-10-09 23:02:54 +0200conal(~conal@64.71.133.70)
2020-10-09 23:02:54 +0200 <ghoulguy> Good dog
2020-10-09 23:03:56 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 256 seconds)
2020-10-09 23:06:07 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:ac:b25b:cce8:9c5a) (Client Quit)
2020-10-09 23:06:57 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 265 seconds)
2020-10-09 23:07:03 +0200elliott_(~elliott@pool-108-51-141-12.washdc.fios.verizon.net)
2020-10-09 23:08:31 +0200Zetagon(~leo@c151-177-52-233.bredband.comhem.se) (Remote host closed the connection)
2020-10-09 23:09:14 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 23:09:18 +0200timotayj(~timotayj@188.214.15.156)
2020-10-09 23:10:28 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 23:10:34 +0200chaosmasttter(~chaosmast@p200300c4a70b4001c004325a2a510724.dip0.t-ipconnect.de) (Quit: WeeChat 2.9)
2020-10-09 23:10:42 +0200vicfred(~vicfred@unaffiliated/vicfred) (Quit: Leaving)
2020-10-09 23:11:22 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:ac:b25b:cce8:9c5a)
2020-10-09 23:11:33 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-10-09 23:11:49 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-09 23:11:58 +0200vicfred(~vicfred@unaffiliated/vicfred)
2020-10-09 23:12:51 +0200 <Cheery> wee.. these guys haven't solved what to do if the text is longer than what the program is meant to process.
2020-10-09 23:15:10 +0200timotayjTJChem
2020-10-09 23:15:45 +0200GyroW_(~GyroW@d54c03e98.access.telenet.be)
2020-10-09 23:15:45 +0200GyroW_(~GyroW@d54c03e98.access.telenet.be) (Changing host)
2020-10-09 23:15:45 +0200GyroW_(~GyroW@unaffiliated/gyrow)
2020-10-09 23:15:48 +0200 <Cheery> it's interesting though.. should the summarizer run twice on the content? Or should there be sentiment analysis that identifies non-important parts of the text first?
2020-10-09 23:16:25 +0200GyroW(~GyroW@unaffiliated/gyrow) (Ping timeout: 240 seconds)
2020-10-09 23:16:25 +0200vicfred(~vicfred@unaffiliated/vicfred) (Client Quit)
2020-10-09 23:17:13 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 260 seconds)
2020-10-09 23:17:22 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Ping timeout: 258 seconds)
2020-10-09 23:18:08 +0200ryansmccoy(~ryansmcco@193.37.254.27) (Ping timeout: 258 seconds)
2020-10-09 23:18:31 +0200ryansmccoy(~ryansmcco@193.37.254.27)
2020-10-09 23:19:51 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de)
2020-10-09 23:21:25 +0200mirrorbird(~psutcliff@m83-185-82-223.cust.tele2.se) (Quit: Leaving)
2020-10-09 23:23:43 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-09 23:24:04 +0200vicfred(~vicfred@unaffiliated/vicfred)
2020-10-09 23:24:24 +0200fantasticsid(~user@2601:641:8000:4f00:58ae:cf75:1df1:eeff)
2020-10-09 23:25:23 +0200ryansmccoy(~ryansmcco@193.37.254.27) (Ping timeout: 260 seconds)
2020-10-09 23:26:21 +0200ryansmccoy(~ryansmcco@193.37.254.27)
2020-10-09 23:27:45 +0200wroathe_(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2020-10-09 23:28:17 +0200thir(~thir@p200300f27f02580060eb7dde324e54c8.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2020-10-09 23:28:58 +0200Jesin(~Jesin@pool-72-66-101-18.washdc.fios.verizon.net) (Quit: Leaving)
2020-10-09 23:29:33 +0200 <nshepperd> first summarize the first half, then summarize the second half, then summarize the two summaries
2020-10-09 23:30:31 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:ac:b25b:cce8:9c5a) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-09 23:30:59 +0200machinedgod(~machinedg@24.105.81.50) (Remote host closed the connection)
2020-10-09 23:31:09 +0200 <monochrom> That doesn't bode well when each half establishes context for the other half.
2020-10-09 23:31:59 +0200machinedgod(~machinedg@24.105.81.50)
2020-10-09 23:32:11 +0200 <monochrom> Or rather, e.g., the last sentence of the first half is useful when summarizing the second half.
2020-10-09 23:32:58 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 260 seconds)
2020-10-09 23:33:22 +0200 <monochrom> And so I propose a sliding window scheme. For every i, summarize from byte i to byte i+N, where N is the input length limit of the summerizer algorithm.
2020-10-09 23:33:31 +0200 <sshine> I'm writing a Megaparsec parser for an AST made recursive with Data.Fix. before Data.Fix I would write e.g.: InfixL (Mul <$ symbol "*") -- with Mul :: Expr -> Expr -> Expr. but with Data.Fix, I need to replace 'Mul' with '\a b -> Fix (Mul a b)'. is there a convenient way to overcome that?
2020-10-09 23:33:56 +0200 <monochrom> Then perhaps summarize the concatenation of those outputs. And perhaps one more level above that, as necessary.
2020-10-09 23:34:43 +0200 <ghoulguy> sshine: When you're using Fix it's not uncommon to then name the constructors wrapped in fix
2020-10-09 23:34:53 +0200 <ghoulguy> mul x y = Fix (Mul x y)
2020-10-09 23:35:02 +0200brandly(~brandly@c-73-68-15-46.hsd1.ma.comcast.net)
2020-10-09 23:35:24 +0200 <sshine> ghoulguy, as part of the module where the AST lives in?
2020-10-09 23:35:40 +0200 <sshine> that certainly makes my tests look nicer.
2020-10-09 23:35:59 +0200 <ghoulguy> or even with pattern synonyms to do that
2020-10-09 23:36:08 +0200 <ghoulguy> yeah, close to the AST definition makes sense
2020-10-09 23:36:09 +0200 <monochrom> It certain makes good sense for a module to provide convenience for its user and use cases.
2020-10-09 23:36:23 +0200Sososasa(~textual@2601:643:8000:a570:9513:b921:a468:618c)
2020-10-09 23:36:29 +0200 <sshine> I sense TH opportunity, and I sense that maybe recursion-schemes did something here.
2020-10-09 23:36:34 +0200 <ski> sshine : you could define pattern synonyms
2020-10-09 23:36:45 +0200 <monochrom> Now, if you also find that when writing pattern matching, "f (Fix (Mul a b)) = ..." is very tiresome...
2020-10-09 23:36:57 +0200 <ski> what monochrom was about to say
2020-10-09 23:37:09 +0200 <monochrom> then what ski said. Pattern synonyms solves both problems. Two birds in one stone.
2020-10-09 23:37:10 +0200 <ghoulguy> You're going to find using Fix is tiresome in general
2020-10-09 23:37:13 +0200 <sshine> I don't actually pattern match much on the Fix thingy because of all the convenience combinators.
2020-10-09 23:37:29 +0200 <sshine> ghoulguy, oh, thanks for the heads up.
2020-10-09 23:37:51 +0200 <monochrom> And as well, it's desired to define the pattern synonyms in the AST module and export them, so users benefit.
2020-10-09 23:37:52 +0200 <sshine> I was wanting to save lines doing passes. :)
2020-10-09 23:38:11 +0200 <monochrom> s/desired/desirable/
2020-10-09 23:38:48 +0200 <monochrom> pattern synonym = smart constructors and deconstructors
2020-10-09 23:39:00 +0200 <monochrom> well, bidirection pattern synonym
2020-10-09 23:39:02 +0200 <sshine> right.
2020-10-09 23:39:18 +0200 <sshine> I've tried pattern synonyms. seems neat.
2020-10-09 23:40:47 +0200elliott_(~elliott@pool-108-51-141-12.washdc.fios.verizon.net) (Ping timeout: 265 seconds)
2020-10-09 23:42:53 +0200ryansmccoy(~ryansmcco@193.37.254.27) (Ping timeout: 260 seconds)
2020-10-09 23:42:53 +0200ystael(~ystael@209.6.50.55) (Ping timeout: 260 seconds)
2020-10-09 23:43:10 +0200ryansmccoy(~ryansmcco@193.37.254.27)
2020-10-09 23:43:57 +0200hackagewolf 0.3.48 - Amazon Simple Workflow Service Wrapper. https://hackage.haskell.org/package/wolf-0.3.48 (markfine)
2020-10-09 23:44:44 +0200cpape`(~user@static.180.18.203.116.clients.your-server.de) (Quit: ERC (IRC client for Emacs 26.3))
2020-10-09 23:44:52 +0200 <sshine> ghoulguy, so you wouldn't pick data-fix/recursion-schemes for an AST at some point in the near future?
2020-10-09 23:45:07 +0200fantasticsid(~user@2601:641:8000:4f00:58ae:cf75:1df1:eeff) (Ping timeout: 240 seconds)
2020-10-09 23:46:09 +0200cpape(~user@static.180.18.203.116.clients.your-server.de)
2020-10-09 23:46:57 +0200knupfer(~Thunderbi@200116b82c4c7d00ac20288f9f283cdb.dip.versatel-1u1.de) (Ping timeout: 260 seconds)
2020-10-09 23:47:39 +0200tambow44(~tambow44@163.47.239.202)
2020-10-09 23:47:44 +0200 <monochrom> I am not ghoulguy, but I found recursion schemes ineffective in cost-benefit. For all its extra Fix annoyance, it saves you, what, from writing an easy-to-write catamorphism?
2020-10-09 23:48:03 +0200tambow44(~tambow44@163.47.239.202) ()
2020-10-09 23:48:06 +0200 <dsal> I kind of wish I knew what recursion schemes was.
2020-10-09 23:48:44 +0200nshepperd(~nshepperd@pool-96-239-61-124.nycmny.fios.verizon.net) (Quit: bye)
2020-10-09 23:48:54 +0200 <monochrom> Instead, I find "data types a la carte" much more worthwhile, if you plan an extensible AST and interpreter etc.
2020-10-09 23:49:26 +0200 <ski> i still would like to be able to turn `splitPrefix' into a pattern synonym ..
2020-10-09 23:49:54 +0200 <dminuoso> dsal: The motivation is actually quite simple.
2020-10-09 23:50:07 +0200 <dminuoso> % foldr (+) 0 [1..10] -- dsal
2020-10-09 23:50:07 +0200 <yahb> dminuoso: 55
2020-10-09 23:50:09 +0200 <monochrom> There are even many free monads that I would rather hand-write than use the free monad library. Unless I want that library's feature of making things efficient.
2020-10-09 23:50:27 +0200 <dminuoso> dsal: Do you see, how foldr lets us hide the recursion, instead we can just sort of talk about (+) and 0 here.
2020-10-09 23:50:40 +0200 <dminuoso> Recursion schemes is about exploring such ideas. :)
2020-10-09 23:50:46 +0200 <dminuoso> (Very handwavingly)
2020-10-09 23:50:54 +0200 <ski> (perhaps with a focus on "exploring")
2020-10-09 23:51:12 +0200 <dsal> I get it at that level, but the last time I looked at it, it required a lot of commitment to get started.
2020-10-09 23:51:13 +0200ziman(~ziman@c25-5.condornet.sk) (Ping timeout: 264 seconds)
2020-10-09 23:51:36 +0200Wuzzy(~Wuzzy@p5790e6f5.dip0.t-ipconnect.de)
2020-10-09 23:52:37 +0200ziman(~ziman@c25-5.condornet.sk)
2020-10-09 23:52:48 +0200 <dsal> A single word of documentation would be pretty great. Some are documented, but there's stuff like `gzygo :: (Recursive t, Comonad w) => (Base t b -> b) -> (forall c. Base t (w c) -> w (Base t c)) -> (Base t (EnvT b w a) -> a) -> t -> a`
2020-10-09 23:53:57 +0200larsan1(~larsan@178.239.168.171)
2020-10-09 23:54:00 +0200 <dsal> This is the most haskell section header I've ever seen on a web page, though: Zygohistomorphic prepromorphisms
2020-10-09 23:54:17 +0200zhenchaoli(~user@2601:641:8000:4f00:58ae:cf75:1df1:eeff)
2020-10-09 23:54:59 +0200TMA(tma@twin.jikos.cz) (Ping timeout: 240 seconds)
2020-10-09 23:55:00 +0200 <topos> what's so hard about a zygohistomorphic prepromorphism? it's just a zygomorphic histo that's also prepromorphic
2020-10-09 23:55:36 +0200 <dminuoso> @remember topos what's so hard about a zygohistomorphic prepromorphism? it's just a zygomorphic histo that's also prepromorphic
2020-10-09 23:55:37 +0200 <lambdabot> I will remember.
2020-10-09 23:55:44 +0200 <topos> LOL
2020-10-09 23:56:45 +0200 <ski> monochrom : at first i read "hand-wave"
2020-10-09 23:57:42 +0200 <monochrom> @quote olsner zygohistomorphic
2020-10-09 23:57:43 +0200 <lambdabot> olsner says: nah, SkyNet is just a zygohistomorphic prepromorphism, nothing fancy
2020-10-09 23:58:38 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-09 23:59:27 +0200hackagecut-the-crap 2.0.0 - Cuts out uninteresting parts of videos by detecting silences. https://hackage.haskell.org/package/cut-the-crap-2.0.0 (Jappie)
2020-10-09 23:59:53 +0200Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi) (Quit: Leaving.)