IRCBrowse

2021/09/17

2021-09-17 00:00:00 +0200 <ldlework> kuribas: it's in his pastebin
2021-09-17 00:00:11 +0200 <ldlework> I think SomeData is a catch all for reporting errors
2021-09-17 00:00:16 +0200 <ldlework> the successes are single integers
2021-09-17 00:00:28 +0200 <newbie> SomeData is a catch for all reporting errors
2021-09-17 00:00:29 +0200 <ldlework> the result should either be a Left SomeData a, or a Right [Integer]
2021-09-17 00:00:46 +0200 <newbie> Test does a computation given the "string input"
2021-09-17 00:00:50 +0200 <ldlework> so it feels like all you need is monoid
2021-09-17 00:01:25 +0200 <newbie> And side effects is passed into the [Integer] : 0 = no side effect, 1 = side effect
2021-09-17 00:01:34 +0200jokleinn(~jokleinn@user/jokleinn) (Quit: WeeChat 3.2)
2021-09-17 00:02:24 +0200ec_(~ec@gateway/tor-sasl/ec)
2021-09-17 00:03:01 +0200 <kuribas> That sounds more like sequence...
2021-09-17 00:03:14 +0200shailangsa(~shailangs@host86-186-132-44.range86-186.btcentralplus.com)
2021-09-17 00:04:03 +0200 <kuribas> :t sequence
2021-09-17 00:04:04 +0200 <lambdabot> (Traversable t, Monad m) => t (m a) -> m (t a)
2021-09-17 00:04:54 +0200favonia(~favonia@user/favonia)
2021-09-17 00:04:58 +0200 <kuribas> you run all the tests, and collect the errors.
2021-09-17 00:05:27 +0200 <kuribas> newbie's description isn't very clear...
2021-09-17 00:05:35 +0200 <kuribas> Why does he need monad here?
2021-09-17 00:05:35 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-09-17 00:05:48 +0200 <kuribas> Does the result of one test depends on the other test?
2021-09-17 00:05:55 +0200 <monochrom> This is a school assignment right? Could we see the verbatim school assignment, not your interpretation?
2021-09-17 00:06:15 +0200 <monochrom> Because my data shows that students always misinterpret everything on the assignment handout.
2021-09-17 00:06:30 +0200 <monochrom> Or at least those students who actually need help.
2021-09-17 00:07:11 +0200 <newbie> It is my bad, I tried to obfuscate the types and assignment since one of my teachers is admin in here
2021-09-17 00:07:40 +0200 <newbie> I'll try to come up with a better explanation, 1 sec
2021-09-17 00:08:05 +0200 <geekosaur> heh
2021-09-17 00:08:17 +0200 <monochrom> Oh, I don't think they will mind you asking, as long as the answerers, in turn, are careful about what help to provide.
2021-09-17 00:08:23 +0200 <monochrom> err
2021-09-17 00:08:31 +0200 <monochrom> nah, no typo.
2021-09-17 00:11:35 +0200 <ProofTechnique> I barely did my own homework, I'm not about to start giving away answers for other people's 😄
2021-09-17 00:11:42 +0200 <monochrom> haha
2021-09-17 00:11:47 +0200OscarH(~OscarH@054449d6.skybroadband.com) (Ping timeout: 245 seconds)
2021-09-17 00:11:59 +0200 <hpc> irc is the original proof of work protocol
2021-09-17 00:13:18 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-09-17 00:13:53 +0200slowButPresent(~slowButPr@user/slowbutpresent)
2021-09-17 00:14:38 +0200Erutuon(~Erutuon@user/erutuon) (Quit: WeeChat 2.8)
2021-09-17 00:16:16 +0200 <newbie> I created a formulation more 1:1 with my assignment
2021-09-17 00:16:17 +0200 <newbie> https://pastebin.com/KPZQDeyN
2021-09-17 00:17:03 +0200 <newbie> Oh lord, bad formatting. This one is better https://pastebin.com/JHKrCSHJ
2021-09-17 00:17:09 +0200wroathe(~wroathe@c-75-72-98-163.hsd1.mn.comcast.net)
2021-09-17 00:17:09 +0200wroathe(~wroathe@c-75-72-98-163.hsd1.mn.comcast.net) (Changing host)
2021-09-17 00:17:09 +0200wroathe(~wroathe@user/wroathe)
2021-09-17 00:18:02 +0200 <newbie> I have included my working solution using pattern matching - however I wish to avoid that somehow since it seems kinda un-Haskell'y
2021-09-17 00:18:27 +0200 <kuribas> err, what is unhaskelly about it?
2021-09-17 00:18:44 +0200 <awpr> :t first
2021-09-17 00:18:45 +0200 <Cajun> i find guards to be more non-idiomatic than pattern matching
2021-09-17 00:18:45 +0200 <lambdabot> Arrow a => a b c -> a (b, d) (c, d)
2021-09-17 00:18:48 +0200 <awpr> :t fst
2021-09-17 00:18:49 +0200 <lambdabot> (a, b) -> a
2021-09-17 00:18:50 +0200 <monochrom> I bet it means "writing code by hand".
2021-09-17 00:18:59 +0200gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2021-09-17 00:18:59 +0200seventhCrow(crow@gateway/vpn/protonvpn/seventhcrow) (Remote host closed the connection)
2021-09-17 00:19:25 +0200seventhCrow(crow@gateway/vpn/protonvpn/seventhcrow)
2021-09-17 00:19:33 +0200 <newbie> My teacher seems to want us to utilize Monads in every possible case
2021-09-17 00:20:01 +0200 <monochrom> Well that's one of the possible misinterpretations I was talking about.
2021-09-17 00:20:44 +0200 <monochrom> I completely never worried about how you changed type names away from the original assignment. I'm sure you didn't goof that part.
2021-09-17 00:21:10 +0200favonia(~favonia@user/favonia) (Ping timeout: 252 seconds)
2021-09-17 00:21:10 +0200 <monochrom> But what your actual job is, every student who seek help always misinterpret that.
2021-09-17 00:22:40 +0200 <monochrom> In particular since the tuple order is (Either SomeError a, [String]) rather than ([String], Either SomeError a), you will not be able to "utilize Monads" to the fullest extent.
2021-09-17 00:22:55 +0200 <monochrom> s/you will not/no one will/
2021-09-17 00:23:39 +0200 <awpr> it almost looks like it's designed to force you to implement it directly instead of with easy DerivingVia trickery
2021-09-17 00:24:17 +0200 <awpr> ...although maybe if a student knows to use DerivingVia and what via type would get the right result, they should be able to do that :)
2021-09-17 00:24:55 +0200 <monochrom> Concretely, there are two points on why the not-working version is not working.
2021-09-17 00:25:33 +0200 <monochrom> "f (first t)" is a type error after you find out correctly the type of t. It doesn't fit there.
2021-09-17 00:25:52 +0200 <newbie> I see, thank you guys. It is still somewhat hard to comprehend Haskell within the first week of learning it, which is why I wanted to find out if I could do something smarter than what I did
2021-09-17 00:26:17 +0200 <kuribas> newbie: I don't think you're supposed to do something smart.
2021-09-17 00:26:23 +0200 <ProofTechnique> (I'm mostly just mystified by the lack of Functor and Applicative instances)
2021-09-17 00:26:27 +0200 <monochrom> And if you look at the working version, you find that you don't unconditionally do "runTest (f whatever)". You do it only under one condition.
2021-09-17 00:26:48 +0200 <monochrom> In the not-working version, you're doing it unconditionally.
2021-09-17 00:27:08 +0200 <awpr> never hurts to learn by practicing though, even if the assignment is perfectly content with being implemented by direct pattern matching
2021-09-17 00:27:45 +0200 <newbie> The conditional thing actually makes sense
2021-09-17 00:27:50 +0200 <kuribas> awpr: it hurts if they try to do advanced stuff, when they don't grasp the simple stuff.
2021-09-17 00:28:04 +0200 <kuribas> Doing pattern matching is fine.
2021-09-17 00:28:17 +0200jokleinn(~jokleinn@user/jokleinn)
2021-09-17 00:28:28 +0200 <awpr> depends on what "hurts" means. "my brain hurts" maybe, but if they figure it out after a few hours of trying by choice / for fun, then that's learning
2021-09-17 00:28:30 +0200 <newbie> awpr: Exactly: I already have a working solution for the assignment, so trying to explore other options and learn from that is very nice
2021-09-17 00:29:43 +0200 <ProofTechnique> The only stylistic thing you _could_ do (and you definitely don't _need_ to) is to reorder the cases and replace your `(Left a, x) -> (Left a, x)` with something like `err -> err`, since you don't need to inspect or do anything with any of the components
2021-09-17 00:30:01 +0200 <newbie> At least that is how I learn. Next time I experience a similar problem I will not spend hours wondering about it
2021-09-17 00:30:30 +0200 <newbie> ProofTechnique: Oh ya ofc, thanks : )
2021-09-17 00:31:43 +0200 <kuribas> newbie: well, the short way would be to use the monad stack.
2021-09-17 00:32:36 +0200 <ProofTechnique> Simply replace all this completely readable pattern matching with an inscrutable transformer stack!
2021-09-17 00:33:00 +0200 <ProofTechnique> That'll show the TA what's what :D
2021-09-17 00:33:59 +0200 <kuribas> ProofTechnique: he wanted to know what's after the manual implementation :-)
2021-09-17 00:34:28 +0200 <newbie> I do not know what that is lol
2021-09-17 00:35:05 +0200 <kuribas> newbie: composition of monads.
2021-09-17 00:35:19 +0200 <monochrom> They just mean there is a way to refactor Env -> (Either SomeError a, [String]) into 3 pieces, and then it won't suck.
2021-09-17 00:35:54 +0200 <kuribas> well, then I can be lazy, and let the compiler infer the instances.
2021-09-17 00:36:03 +0200 <newbie> So a monad stack is utilizing MonadTransformers?
2021-09-17 00:36:09 +0200 <kuribas> yes
2021-09-17 00:36:49 +0200 <kuribas> you "stack" the monad transformers on top of each other, hence "monad stack".
2021-09-17 00:36:59 +0200 <monochrom> My POV is that if you do that, there are 2 annoying newtype wrappers that get into the way, it will still be ugly.
2021-09-17 00:37:10 +0200 <kuribas> monochrom: coerce?
2021-09-17 00:37:26 +0200 <newbie> Ah nice, makes sense
2021-09-17 00:37:34 +0200 <monochrom> Ugh do you teach coerce in a course? Any course?
2021-09-17 00:37:36 +0200 <ProofTechnique> If you want the compiler to write code for you, just ask the nearest Simon to do it instead
2021-09-17 00:37:44 +0200 <newbie> I think I have to work a little more with monads before utilizing Monad Transformers tho
2021-09-17 00:37:52 +0200 <kuribas> monochrom: of course not
2021-09-17 00:38:51 +0200 <ProofTechnique> Oh, that reminds me: Seeing as it's school season again, we should get a list of active courses and their problem sets so we can get ahead of the questions :)
2021-09-17 00:39:42 +0200pfurla_pfurla
2021-09-17 00:40:19 +0200 <ProofTechnique> Professors of IRC, post your syllabus so we can prepare maximally cryptic pointfree solutions to homework questions
2021-09-17 00:40:31 +0200 <newbie> :D
2021-09-17 00:40:34 +0200 <monochrom> haha
2021-09-17 00:41:01 +0200 <monochrom> I don't think pointfree is all that hot any more.
2021-09-17 00:41:02 +0200 <awpr> we can insert 0-width spaces to fingerprint our solutions
2021-09-17 00:41:12 +0200 <geekosaur> ContT
2021-09-17 00:41:15 +0200 <monochrom> The rage is with either linear types or type-level tricks.
2021-09-17 00:41:19 +0200 <hpc> zygohistomorphic prepromorphisms?
2021-09-17 00:41:50 +0200 <ldlework> i usually let hlint eta reduce my stuff
2021-09-17 00:42:01 +0200 <ldlework> dunno if it's a good habit yet
2021-09-17 00:42:32 +0200 <dsal> hlint has some good suggestions and some really weird ones.
2021-09-17 00:42:36 +0200 <monochrom> There was once I inserted or delete spaces or puntuations to fingerprint my solutions.
2021-09-17 00:42:41 +0200 <dsal> The trick is to find two people who can agree on either of those categories.
2021-09-17 00:43:16 +0200 <monochrom> I had 6 TAs, 1 of them was leaking my solution to help students cheat, I wanted to find out who.
2021-09-17 00:43:16 +0200 <awpr> "use operator sections" on alphanumeric names is a particularly weird one
2021-09-17 00:43:20 +0200 <ProofTechnique> "It's very simple. Just start with `data family Homework a` ..."
2021-09-17 00:44:14 +0200 <monochrom> So when I sent solutions to TAs for preparation, each TA received a different addition or deletion of spaces or puntuations.
2021-09-17 00:44:16 +0200 <ldlework> awpr: do you ever do that yourself?
2021-09-17 00:44:25 +0200 <ldlework> sometimes I have done (`foo` val)
2021-09-17 00:44:25 +0200 <dsal> I do that some sometimes.
2021-09-17 00:44:47 +0200 <awpr> if HLint bugs me about it I'll generally just do it, but stream of consciousness I tend to end up writing `flip foo val`
2021-09-17 00:44:52 +0200 <monochrom> So when the cheating student submitted my solution obtained through a TA, I was able to identify the TA.
2021-09-17 00:44:53 +0200 <dsal> hlint author hates flip
2021-09-17 00:45:09 +0200 <monochrom> The students and the TA were successfully convicted.
2021-09-17 00:45:10 +0200 <ProofTechnique> Those are some bush league cheaters, sheesh. Imagine copying and pasting like a rube :/
2021-09-17 00:45:45 +0200 <awpr> sounds like some old spy story where an agency intentionally leaked subtly different information to their agents to find out who was leaking
2021-09-17 00:45:52 +0200 <ldlework> i think sectioning is cool, because flipping is like a "natural need" based on the nature of what we're doing
2021-09-17 00:45:58 +0200 <monochrom> awpr, I think "map (`mod` 7) [a,b,c]" is fairly OK.
2021-09-17 00:46:02 +0200 <ldlework> so it's nice to have a tiny sugar for it
2021-09-17 00:46:17 +0200 <ldlework> yeah that
2021-09-17 00:46:25 +0200kuribas(~user@ptr-25vy0i9fqiblx2l1e59.18120a2.ip6.access.telenet.be) (Quit: ERC (IRC client for Emacs 26.3))
2021-09-17 00:46:27 +0200 <awpr> monochrom: yeah, it's perfectly fine IMO, just not sure I see the need to have a linter forbid the alternative for all prefix functions
2021-09-17 00:46:49 +0200 <monochrom> all (`elem` ['a'..'z']) mystring
2021-09-17 00:46:56 +0200 <ldlework> is hlint configurable in that sense?
2021-09-17 00:46:57 +0200 <monochrom> at which point it read like English
2021-09-17 00:46:59 +0200 <ldlework> like eslint
2021-09-17 00:47:04 +0200 <monochrom> at which point it read like COBOL, too
2021-09-17 00:47:09 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 00:47:19 +0200newbie(~newbie@80-196-109-198-dynamic.dk.customer.tdc.net) (Remote host closed the connection)
2021-09-17 00:47:20 +0200 <ProofTechnique> flip is a subtle poison. I use it, too, but it gets out of hand so fast if you let it :D
2021-09-17 00:47:23 +0200 <awpr> yeah, those uses and plenty of others do look better than with flip, IMO
2021-09-17 00:47:44 +0200 <monochrom> Oh yeah, hlint is opinion, not linter. False advertising.
2021-09-17 00:48:19 +0200 <monochrom> "map (\x -> mod x 7)" is fine. Everyone does not have to code like a smart*ss.
2021-09-17 00:48:40 +0200 <ldlework> i have an irrational aversion to haskell's lambdas
2021-09-17 00:49:11 +0200 <ProofTechnique> 80% of my interaction with hlint is idly writing `fmap foo`, seeing it's not the shape I want, sticking `sequence .` on the front and being chided for forgetting that every single problem reduces to `traverse`
2021-09-17 00:49:15 +0200 <ldlework> for some reason I wish you could either `x -> f x` or `(x, y) -> f x y`
2021-09-17 00:49:41 +0200bontaq(~user@ool-45779fe5.dyn.optonline.net)
2021-09-17 00:49:49 +0200 <awpr> backslash is a lambda letter with a missing leg
2021-09-17 00:50:00 +0200 <monochrom> You will want |->, which is what mathematicians do.
2021-09-17 00:50:06 +0200 <ldlework> yeah but the parser isn't strong enough to not require parens everywhere
2021-09-17 00:50:14 +0200 <ldlework> or grammar or whatever
2021-09-17 00:50:20 +0200 <ProofTechnique> Turn on UnicodeSyntax and ensure that no one will ever work with you. Problem solved
2021-09-17 00:50:25 +0200 <ldlework> haha
2021-09-17 00:50:30 +0200 <monochrom> Why do you have an irrational aversion to parentheses?
2021-09-17 00:50:42 +0200 <awpr> time for Lisp exposure therapy
2021-09-17 00:50:42 +0200 <ldlework> monochrom: just those ones, with the \ it just gets noisy
2021-09-17 00:50:49 +0200 <ldlework> i come from a lisp background!
2021-09-17 00:50:49 +0200tommd(~tommd@75-164-130-101.ptld.qwest.net)
2021-09-17 00:51:02 +0200 <ldlework> well, i mean, i have lots of lisp experience!
2021-09-17 00:51:07 +0200 <monochrom> "map ((x,y) |-> f x y)" is fine.
2021-09-17 00:51:19 +0200 <ldlework> afterall, it is an irrational aversion
2021-09-17 00:51:21 +0200 <monochrom> "map (x,y) |-> f x y" is the confusing one. You need parentheses.
2021-09-17 00:51:42 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2021-09-17 00:51:54 +0200 <ProofTechnique> Be a monster and turn on BlockArguments just for `map do \(x, y) -> f x y`
2021-09-17 00:52:34 +0200 <awpr> from a parsing perspective, it might be helpful to have the lambda up front to avoid parsing as an expression and then backtracking. I don't remember if patterns have a separate grammar from expressions, though -- seems like they should with ViewPatterns, AsPatterns, etc.
2021-09-17 00:52:40 +0200 <dsal> Agda manages to let you just use λ
2021-09-17 00:53:02 +0200 <ProofTechnique> Sure, but it's spelled \Gl, which is a lot
2021-09-17 00:53:08 +0200 <ldlework> be like python and just type `lambda` everywhere
2021-09-17 00:53:18 +0200 <monochrom> patterns have to have a separate grammar from expressions.
2021-09-17 00:53:24 +0200 <dsal> I use λ as a parameter in a thing that uses AWS lambda.
2021-09-17 00:53:30 +0200 <monochrom> "f * g" is an expression, but not a pattern.
2021-09-17 00:53:33 +0200 <ldlework> nerd
2021-09-17 00:54:09 +0200 <awpr> I mean, it could parse as a pattern and get rejected by some sanity check, if you really wanted to unify them. but yeah, I agree they should be separate
2021-09-17 00:55:24 +0200 <monochrom> But yeah language designers try to stay within LALR(k) or something for parser efficiency.
2021-09-17 00:55:30 +0200ec_(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-09-17 00:55:46 +0200 <ProofTechnique> The sanity check that rejects it is having a separate grammar :)
2021-09-17 00:56:24 +0200 <monochrom> which is arguably silly for a language that goes on to do exponential-time type inference.
2021-09-17 00:56:48 +0200 <monochrom> Cubic-time parsing is nothing compared to type inference.
2021-09-17 00:57:33 +0200 <awpr> even worse is GHC.Generics generating pathological cases for type inference to deal with :)
2021-09-17 00:57:42 +0200 <awpr> or rather DeriveGeneric
2021-09-17 00:58:02 +0200 <ProofTechnique> I would hope the n is quite a bit smaller in the type inference case than in the parsing case, but then I remember deriving chicanery
2021-09-17 01:02:37 +0200ec_(~ec@gateway/tor-sasl/ec)
2021-09-17 01:04:46 +0200 <ldlework> anyone know how to use time in hylogen/hylide?
2021-09-17 01:05:34 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 260 seconds)
2021-09-17 01:05:54 +0200 <ldlework> nm just got it working
2021-09-17 01:07:21 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-17 01:07:21 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-17 01:07:21 +0200wroathe(~wroathe@user/wroathe)
2021-09-17 01:07:30 +0200 <ProofTechnique> I have never seen that library before, but it looks very cool
2021-09-17 01:10:32 +0200aegon(~mike@174.127.249.180)
2021-09-17 01:11:13 +0200 <aegon> is do notation left or right associative in desugaring? bind and >> are left but do is right or am i wrong about right and right is left o_o
2021-09-17 01:12:06 +0200amahl(~amahl@dsl-jklbng12-54fbca-64.dhcp.inet.fi) (Ping timeout: 260 seconds)
2021-09-17 01:12:08 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2021-09-17 01:12:40 +0200 <awpr> seems effectively right-associative, in that the stuff after a do-statement is all contained inside the lambda that's given to the first >>=
2021-09-17 01:13:32 +0200 <ldlework> Where `c` is a `Vec4 a a a a` I wonder how to translate `fract(c.xxxw + K.xyzw)` into hylogen
2021-09-17 01:13:48 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-09-17 01:13:50 +0200 <awpr> the left associativity of >>= is a different matter -- it controls what happens when you write `x >>= f >>= g`, namely that it's the only associativity that typechecks that expression
2021-09-17 01:13:56 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-17 01:13:56 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-17 01:13:56 +0200wroathe(~wroathe@user/wroathe)
2021-09-17 01:14:15 +0200 <ldlework> aka swizzling
2021-09-17 01:14:24 +0200mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net)
2021-09-17 01:14:37 +0200 <awpr> meanwhile if you have unparenthesized lambdas, associativity doesn't come into play, it's just the parsing of the lambda eating the rest of the expression
2021-09-17 01:15:06 +0200 <aegon> awpr: thats the source of a bunch of accidently quadradic perf problems if i'm understanding hte reading correct though
2021-09-17 01:15:55 +0200 <awpr> having left-associated binds? yeah, it can be slower for some monads, but just moving the parens around doesn't type-check anymore
2021-09-17 01:17:03 +0200 <aegon> ldlework: i'm just seeing hylogen but it looks like there are a bunch of swizzle funcs already defined here https://hackage.haskell.org/package/hylogen-0.1.5.1/docs/Hylogen-Types-Vec.html
2021-09-17 01:17:10 +0200 <ldlework> i just found those!
2021-09-17 01:17:13 +0200 <ldlework> thank you aegon
2021-09-17 01:17:22 +0200 <aegon> np!
2021-09-17 01:18:27 +0200 <aegon> awpr: thanks for the insight, gonna play around with paren places in ghci to see more what you mean
2021-09-17 01:19:10 +0200 <awpr> `x >>= f >>= g` <-> `x >>= (f >=> g)`
2021-09-17 01:19:43 +0200 <aegon> :t (>=>)
2021-09-17 01:19:44 +0200 <lambdabot> Monad m => (a -> m b) -> (b -> m c) -> a -> m c
2021-09-17 01:19:53 +0200 <awpr> <-> `x >>= \y -> f y >>= g`
2021-09-17 01:20:49 +0200 <awpr> tbh I never actually thought about successive >>=s being a potential performance issue until now. will have to keep that in mind and remember to use the fish operator version
2021-09-17 01:23:27 +0200ec_(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-09-17 01:23:44 +0200xsperry(~as@user/xsperry) (Remote host closed the connection)
2021-09-17 01:24:08 +0200 <aegon> i haven't run into anyone suggesting (>=>) in the posts as a way to guard against it, thats kinda neat
2021-09-17 01:27:47 +0200Lycurgus(~juan@98.4.112.204) (Quit: Exeunt)
2021-09-17 01:30:41 +0200retroid_(~retro@176.255.22.194)
2021-09-17 01:31:08 +0200 <ProofTechnique> How does that get rid of binds?
2021-09-17 01:31:30 +0200 <awpr> it right-associates them so you don't repeatedly re-traverse the same structure you just built
2021-09-17 01:31:37 +0200retro_(~retro@176.255.22.194) (Ping timeout: 252 seconds)
2021-09-17 01:32:16 +0200 <awpr> I think the docs of `Codensity` in `kan-extensions` describe the issue pretty well
2021-09-17 01:32:42 +0200 <ProofTechnique> I've only ever seen this bind performance thing come up in the context of free monads, but I'll go read kan-extensions for the details :)
2021-09-17 01:33:53 +0200ec_(~ec@gateway/tor-sasl/ec)
2021-09-17 01:34:20 +0200 <ProofTechnique> Oh, lol, the linked paper is exactly "Asymptotic Improvement of Computations over Free Monads" :D
2021-09-17 01:36:36 +0200ec_(~ec@gateway/tor-sasl/ec) (Client Quit)
2021-09-17 01:38:21 +0200 <ProofTechnique> Oh, gosh, GHC 6.6. I think 6.8.3 was the first GHC I used. The years do fly by
2021-09-17 01:38:23 +0200 <monochrom> Yeah it's mainly for free monads that are coded up as an ADT.
2021-09-17 01:38:47 +0200 <ldlework> Looks like Hylogen is abandoned and it only has minimal support. Dang!
2021-09-17 01:38:50 +0200chris(~chris@81.96.113.213)
2021-09-17 01:38:54 +0200chrisGuest640
2021-09-17 01:39:00 +0200 <monochrom> But even then I am skeptical about how often it hurts. It is not like you have left recursion all that often.
2021-09-17 01:39:42 +0200 <ldlework> my dreams of fast game-of-life in haskell are dying ^_^
2021-09-17 01:40:01 +0200 <ProofTechnique> Revive it!
2021-09-17 01:40:28 +0200 <ProofTechnique> I'm very much looking forward to delimited continuations to happen so I can try out eff without Herculean effort
2021-09-17 01:41:05 +0200tdidrfyls^(~tdidrfyls@68.101.54.227)
2021-09-17 01:41:10 +0200 <ProofTechnique> Polysemy is still very nice, but eff has that sports car sheen
2021-09-17 01:42:34 +0200MQ-17J(~MQ-17J@8.21.10.6) (Ping timeout: 252 seconds)
2021-09-17 01:45:22 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Read error: Connection reset by peer)
2021-09-17 01:45:44 +0200geekosaur(~geekosaur@xmonad/geekosaur)
2021-09-17 01:46:39 +0200 <ldlework> https://github.com/jaredloomis/andromeda
2021-09-17 01:46:43 +0200 <ldlework> this library isn't on hackage
2021-09-17 01:46:46 +0200 <ldlework> how do i install it?
2021-09-17 01:48:10 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 265 seconds)
2021-09-17 01:49:55 +0200System123(~System123@net-37-179-171-3.cust.vodafonedsl.it)
2021-09-17 01:50:04 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Killed (NickServ (GHOST command used by allbery_b)))
2021-09-17 01:50:04 +0200allbery_b(~geekosaur@xmonad/geekosaur)
2021-09-17 01:50:07 +0200allbery_bgeekosaur
2021-09-17 01:50:29 +0200 <aegon> ldlework: with stack you specify the git repo as an external source in your stack.yaml then add the dependency to your package.yaml, with cabal you...
2021-09-17 01:51:05 +0200 <geekosaur> you can also download it and use "cabal install" without naming a package, usually
2021-09-17 01:51:13 +0200 <ProofTechnique> https://cabal.readthedocs.io/en/3.4/cabal-project.html#specifying-packages-from-remote-version-con…
2021-09-17 01:51:16 +0200 <ldlework> i'm using NixOS and the only good info I can find is using cabal
2021-09-17 01:51:24 +0200 <geekosaur> from the directory with the cabal file (or cabal.project file)
2021-09-17 01:52:03 +0200 <ProofTechnique> Idlework: Are you looking to install it in your global package set, or in a project shell? Are you using haskell.nix?
2021-09-17 01:52:33 +0200 <aegon> ldlework: https://cabal.readthedocs.io/en/latest/cabal-project.html#specifying-packages-from-remote-version-…
2021-09-17 01:52:37 +0200 <ProofTechnique> Essentially you just want to write an overlay (or maybe the fancy thing is flakes now) to override `haskellPackages` and add it to the set
2021-09-17 01:53:01 +0200 <ProofTechnique> How to do that nicely depends a little bit on your setup
2021-09-17 01:55:25 +0200mikoto-chan(~mikoto-ch@83.137.2.242) (Ping timeout: 265 seconds)
2021-09-17 01:56:52 +0200System123(~System123@net-37-179-171-3.cust.vodafonedsl.it) (Ping timeout: 265 seconds)
2021-09-17 01:57:10 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-09-17 01:59:04 +0200justsomeguy(~justsomeg@user/justsomeguy)
2021-09-17 01:59:40 +0200 <ldlework> ProofTechnique: here is the repo I'm working with https://github.com/dustinlacewell/andromeda-hs
2021-09-17 02:00:03 +0200 <ldlework> It's got the andromeda example code in Main.hs, .cabal depending on andromeda, shell.nix, etc
2021-09-17 02:00:49 +0200 <ldlework> after doing `nix-shell` you do `runhaskell Setup.hs configure`
2021-09-17 02:01:03 +0200 <ldlework> which would install cabal deps, then `runhaskell Setup.hs build` to build
2021-09-17 02:01:28 +0200 <ProofTechnique> I expect you'll run into some issues with your package and this other package having the same name
2021-09-17 02:02:00 +0200aegon(~mike@174.127.249.180) (Quit: leaving)
2021-09-17 02:03:29 +0200 <ProofTechnique> I think changing your `pkgs` in you shell.nix to something like https://pastebin.com/RkJ55SDe (filling in the rev and sha according to whatever `nix-prefetch-git` says) should work
2021-09-17 02:04:30 +0200 <ProofTechnique> Oh, and you may need to be more specific than `haskellPackages` if you're targeting 8.10.7, specifically
2021-09-17 02:04:30 +0200 <ldlework> ProofTechnique: OK I changed the name to androcells and pushed
2021-09-17 02:04:44 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Killed (NickServ (GHOST command used by allbery_b)))
2021-09-17 02:04:44 +0200allbery_b(~geekosaur@xmonad/geekosaur)
2021-09-17 02:04:47 +0200allbery_bgeekosaur
2021-09-17 02:05:03 +0200 <ProofTechnique> And then you'll just be able to refer to `pkgs.haskell.packages.ghc8107.andromeda` and all should be hunky-dory
2021-09-17 02:06:16 +0200 <ldlework> ProofTechnique: should I be extending `pkgs.haskell.packages.ghc8107` ?
2021-09-17 02:06:22 +0200 <ProofTechnique> https://pastebin.com/cFNLE6Rh
2021-09-17 02:06:36 +0200tdidrfyls^(~tdidrfyls@68.101.54.227) (Remote host closed the connection)
2021-09-17 02:06:46 +0200 <ldlework> i see
2021-09-17 02:06:55 +0200 <ProofTechnique> Yeah, if you do it like this, you can then use `pkgs.haskellPackages` and be guaranteed that all of your packages come from the extended set
2021-09-17 02:08:25 +0200 <ProofTechnique> Looks like `rev` should be `502dfa6703eca9717c7cde0c93959fa0a83e77ed` and `sha256` should be `0ymbfpxlh938zryvw2nab0jls9nmf8jjcnyxbbdl47vaq543chir`
2021-09-17 02:10:04 +0200 <ldlework> ProofTechnique: where am I going wrong here
2021-09-17 02:10:06 +0200 <ldlework> https://gist.github.com/dustinlacewell/8fb9f4c7dca9426fc635d6920152a54e
2021-09-17 02:10:15 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-17 02:10:35 +0200thyriaen(~thyriaen@dynamic-078-055-122-076.78.55.pool.telefonica.de) (Quit: Leaving)
2021-09-17 02:10:43 +0200 <ProofTechnique> https://pastebin.com/U2aP1z1B Edited config with all the stuff
2021-09-17 02:10:47 +0200 <ProofTechnique> Uh, not sure
2021-09-17 02:11:11 +0200 <ldlework> yours worked
2021-09-17 02:11:52 +0200 <ProofTechnique> Really? I'm honestly a little stunned :D
2021-09-17 02:13:29 +0200 <ldlework> ProofTechnique: http://logos.ldlework.com/caps/2021-09-17-00-13-26.png
2021-09-17 02:13:30 +0200sneedsfeed(~sneedsfee@rrcs-173-95-122-169.midsouth.biz.rr.com) (Quit: Client closed)
2021-09-17 02:13:34 +0200 <ldlework> \o/
2021-09-17 02:14:48 +0200 <ProofTechnique> Nice!
2021-09-17 02:17:07 +0200 <ldlework> I also just found http://lambdacube3d.com/
2021-09-17 02:25:41 +0200arkho(~ccc@dynamic-acs-24-112-153-241.zoominternet.net) (Remote host closed the connection)
2021-09-17 02:27:26 +0200favonia(~favonia@user/favonia)
2021-09-17 02:32:55 +0200proofofkeags_(~proofofke@205.209.28.54) (Ping timeout: 268 seconds)
2021-09-17 02:34:14 +0200favonia(~favonia@user/favonia) (Ping timeout: 260 seconds)
2021-09-17 02:39:16 +0200xff0x(~xff0x@2001:1a81:526d:1c00:6ed0:c2d3:55f8:e793) (Ping timeout: 252 seconds)
2021-09-17 02:39:42 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 02:40:03 +0200xff0x(~xff0x@2001:1a81:526d:1c00:e52d:fb7a:8e70:ce09)
2021-09-17 02:44:51 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 268 seconds)
2021-09-17 02:47:20 +0200favonia(~favonia@user/favonia)
2021-09-17 02:56:23 +0200 <Cajun> Idlework: are you using that shader library to implement game of life?
2021-09-17 02:56:23 +0200justsomeguy(~justsomeg@user/justsomeguy) (Quit: WeeChat 3.2)
2021-09-17 03:00:05 +0200alx741(~alx741@181.196.68.9) (Quit: alx741)
2021-09-17 03:03:45 +0200 <Cajun> because its not entirely necessary for GoL if thats the case. heres some example code i found that runs pretty well on my system given its insane size. i cant tell what the framerate is, but its not 60. probably more around 30. https://prnt.sc/1shzok2
2021-09-17 03:09:02 +0200dragestil(~quassel@user/dragestil) (Ping timeout: 252 seconds)
2021-09-17 03:09:02 +0200dragestil_dragestil
2021-09-17 03:10:01 +0200dragestil_(~quassel@user/dragestil)
2021-09-17 03:10:08 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 268 seconds)
2021-09-17 03:10:24 +0200 <ldlework> Cajun: my problem is that with Gloss it is slow
2021-09-17 03:10:31 +0200 <Cajun> try GLUT
2021-09-17 03:11:45 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.2.1)
2021-09-17 03:12:58 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Ping timeout: 260 seconds)
2021-09-17 03:13:06 +0200 <hololeap> I have newtype N = N { getN :: TVar T } and I have the function `fmap N . traverse (fmap f . readTVar) . getN`
2021-09-17 03:13:34 +0200 <hololeap> I would like to use optics to reduce the clutter and hopefully remove the `fmap N` and `getN` from that function. how can I do this?
2021-09-17 03:13:50 +0200xff0x(~xff0x@2001:1a81:526d:1c00:e52d:fb7a:8e70:ce09) (Ping timeout: 268 seconds)
2021-09-17 03:14:43 +0200MQ-17J(~MQ-17J@8.21.10.6)
2021-09-17 03:15:14 +0200xff0x(~xff0x@2001:1a81:52ad:c900:2fb9:e85d:6382:ddb8)
2021-09-17 03:17:21 +0200lavaman(~lavaman@98.38.249.169)
2021-09-17 03:18:18 +0200 <c_wraith> that... type-checks?
2021-09-17 03:18:43 +0200 <c_wraith> I guess it type-checks if f returns TVar T
2021-09-17 03:19:07 +0200 <hololeap> oh, yeah I suppose it doesn't... bad attempt at a simplification
2021-09-17 03:20:09 +0200 <hololeap> newtype Children f a = Children { getChildren :: HashMap ChildName (f a) }
2021-09-17 03:20:31 +0200 <hololeap> fromTVarChildren :: Children TVar a -> STM (Children Identity a)
2021-09-17 03:20:39 +0200 <hololeap> fromTVarChildren = fmap Children . traverse (fmap Identity . readTVar) . getChildren
2021-09-17 03:20:45 +0200 <c_wraith> if you want to mutate TVars in place at locations described by optics, traverseOf_ would apply
2021-09-17 03:21:34 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 252 seconds)
2021-09-17 03:22:14 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 03:22:57 +0200 <awpr> looks like `traverse10 readTVar` to me: https://hackage.haskell.org/package/ten-0.1.0.1/docs/Data-Ten-Traversable.html#v:traverse10
2021-09-17 03:23:29 +0200 <awpr> or `traverse10 (fmap Identity . readTVar)` I guess
2021-09-17 03:24:23 +0200 <awpr> the Generics stuff should be able to derive the instances for that type
2021-09-17 03:25:54 +0200 <hololeap> hm, ok
2021-09-17 03:25:59 +0200dsrt^(~dsrt@68.101.54.227)
2021-09-17 03:27:55 +0200juhp_(~juhp@bb220-255-204-220.singnet.com.sg)
2021-09-17 03:28:16 +0200 <awpr> granted the right application of 'coerce' would probably do the trick too in this case since it's just a newtype constructor
2021-09-17 03:28:28 +0200neurocyte0(~neurocyte@user/neurocyte)
2021-09-17 03:29:40 +0200juhp__(~juhp@bb220-255-204-220.singnet.com.sg)
2021-09-17 03:29:41 +0200juhp(~juhp@bb220-255-204-220.singnet.com.sg) (Read error: Connection reset by peer)
2021-09-17 03:30:08 +0200 <awpr> oh, it doesn't have the right kind for `ten`, my bad. `newtype Children a f` would, but I don't know if that's reasonable for your situation
2021-09-17 03:30:16 +0200 <hololeap> I just wanted to somehow shove the `traverse (fmap Identity . readTVar)` underneath the Children wrapper without the explicit unwrap and "fmapped wrap"
2021-09-17 03:30:22 +0200juhp__juhp
2021-09-17 03:30:32 +0200loonycyborg(~loonycybo@wesnoth/developer/loonycyborg) (Ping timeout: 250 seconds)
2021-09-17 03:31:01 +0200 <awpr> `coerce` can probably do that
2021-09-17 03:31:06 +0200neurocyte(~neurocyte@user/neurocyte) (Ping timeout: 268 seconds)
2021-09-17 03:31:06 +0200neurocyte0neurocyte
2021-09-17 03:31:38 +0200 <Axman6> coerce readTVar should work
2021-09-17 03:31:45 +0200 <Axman6> maybe with some type annotations
2021-09-17 03:31:56 +0200wrengrwrengr_away
2021-09-17 03:31:58 +0200Guest640(~chris@81.96.113.213) (Remote host closed the connection)
2021-09-17 03:32:02 +0200 <awpr> that's for the old oversimplified version of the type
2021-09-17 03:32:54 +0200 <hololeap> no way to do this with optics? my intention was to reduce verbosity, and adding a bunch of type annotations seems like it might increase it
2021-09-17 03:33:06 +0200 <hololeap> mapped :: Functor f => Setter (f a) (f b) a b
2021-09-17 03:33:25 +0200loonycyborg(~loonycybo@wesnoth/developer/loonycyborg)
2021-09-17 03:33:25 +0200 <awpr> `_Wrapped` maybe
2021-09-17 03:33:46 +0200 <awpr> might have to TH some instances into existence to make that work, though
2021-09-17 03:33:48 +0200 <Axman6> does coerce (traverse (fmap Identity . readTVar)) work?
2021-09-17 03:33:58 +0200 <hololeap> let me try
2021-09-17 03:33:58 +0200juhp_(~juhp@bb220-255-204-220.singnet.com.sg) (Ping timeout: 268 seconds)
2021-09-17 03:34:28 +0200sneedsfeed(~sneedsfee@rrcs-173-95-122-169.midsouth.biz.rr.com)
2021-09-17 03:34:32 +0200 <Axman6> might need some .... annotations for the type params. hmm, can't remember what those were called
2021-09-17 03:34:49 +0200 <awpr> TypeApplications, or just a signature
2021-09-17 03:34:56 +0200 <Axman6> type roles
2021-09-17 03:35:31 +0200funsafe(~funsafe@2601:1c1:4200:e53:2875:5507:42e4:4e14) (Read error: Connection reset by peer)
2021-09-17 03:35:37 +0200 <awpr> those should be inferred correctly in this case, and they have no power over coercions in the same module that defines the newtype
2021-09-17 03:35:38 +0200 <Axman6> https://downloads.haskell.org/ghc/9.2.1-alpha1/docs/html/users_guide/exts/roles.html
2021-09-17 03:35:52 +0200 <Axman6> hmm, ok
2021-09-17 03:36:36 +0200 <Axman6> % :t coerce (traverse (fmap Identity . readTVar))
2021-09-17 03:36:36 +0200 <yahb> Axman6: (Traversable t, Coercible b (t (TVar a) -> STM (t (Identity a)))) => b
2021-09-17 03:36:40 +0200 <hololeap> Axman6: http://sprunge.us/Ny5tua
2021-09-17 03:36:55 +0200juhp(~juhp@bb220-255-204-220.singnet.com.sg) (Ping timeout: 265 seconds)
2021-09-17 03:37:02 +0200funsafe(~funsafe@2601:1c1:4200:e53:2875:5507:42e4:4e14)
2021-09-17 03:37:13 +0200 <Axman6> % :t \x -> coerce (traverse (fmap Identity . readTVar)) x
2021-09-17 03:37:13 +0200 <yahb> Axman6: (Traversable t1, Coercible t2 (t1 (TVar a)), Coercible t3 (STM (t1 (Identity a)))) => t2 -> t3
2021-09-17 03:37:28 +0200 <awpr> yeah, coerce tends to result in a lot of confusion about what types you want on either side
2021-09-17 03:38:20 +0200 <awpr> you can probably also `makeLenses ''Children` and get an Iso to use like `_getChildren (traverse ...)`
2021-09-17 03:38:51 +0200 <Axman6> yeah, and that implementation should just be coerce anyway
2021-09-17 03:39:00 +0200 <Axman6> that's probably the way to go
2021-09-17 03:39:07 +0200MQ-17J(~MQ-17J@8.21.10.6) (Ping timeout: 268 seconds)
2021-09-17 03:39:31 +0200 <hololeap> I'm using Optics.Label and OverloadedLabels
2021-09-17 03:39:51 +0200 <Axman6> you'd have something like _Children . traversed . mapped (coerce readTVar)
2021-09-17 03:40:02 +0200Cajun(~Cajun@user/cajun) (Quit: Client closed)
2021-09-17 03:40:55 +0200 <Axman6> % :t _Wrapped . traversed . mapped (coerce readTVar :: TVar a -> STM (Identity a))
2021-09-17 03:40:55 +0200 <yahb> Axman6: ; <interactive>:1:24: error:; * Couldn't match type `STM' with `p0 a0'; Expected: f (TVar a) -> p0 a0 (f (Identity a)); Actual: f (TVar a) -> STM (f (Identity a)); * In the second argument of `(.)', namely `mapped (coerce readTVar :: TVar a -> STM (Identity a))'; In the second argument of `(.)', namely `traversed . mapped (coerce readTVar :: TVar a -> STM (Identity a))';
2021-09-17 03:40:56 +0200Cajun(~Cajun@user/cajun)
2021-09-17 03:41:30 +0200 <Axman6> % :t _Wrapped . traversed . mapped (fmap Identity readTVar)
2021-09-17 03:41:30 +0200 <yahb> Axman6: ; <interactive>:1:32: error:; * Couldn't match type `Identity' with `p0 a0'; Expected: TVar a -> p0 a0 (STM a); Actual: TVar a -> Identity (STM a); * In the first argument of `mapped', namely `(fmap Identity readTVar)'; In the second argument of `(.)', namely `mapped (fmap Identity readTVar)'; In the second argument of `(.)', namely `traversed . mapped (fmap Identity rea
2021-09-17 03:42:09 +0200 <Axman6> ok, I don't know hwat I'm doing
2021-09-17 03:42:55 +0200 <hololeap> you and me both :p
2021-09-17 03:43:06 +0200 <hololeap> anything past simple getters and setters is over my head
2021-09-17 03:43:23 +0200lavaman(~lavaman@98.38.249.169)
2021-09-17 03:44:34 +0200lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-09-17 03:46:10 +0200vysn(~vysn@user/vysn) (Ping timeout: 240 seconds)
2021-09-17 03:47:45 +0200dragestil_(~quassel@user/dragestil) (Ping timeout: 268 seconds)
2021-09-17 03:47:48 +0200chris(~chris@81.96.113.213)
2021-09-17 03:47:51 +0200chrisGuest1782
2021-09-17 03:50:42 +0200OscarH(~OscarH@90.201.86.195)
2021-09-17 03:52:41 +0200Guest1782(~chris@81.96.113.213) (Ping timeout: 268 seconds)
2021-09-17 03:52:50 +0200juhp(~juhp@111.65.68.133)
2021-09-17 03:52:52 +0200pbrisbin(~patrick@pool-173-49-147-250.phlapa.fios.verizon.net) (Ping timeout: 265 seconds)
2021-09-17 03:55:27 +0200 <Boarders> Does anyone know an open source repo that makes heavy use of intmap and has extensive benchmarks?
2021-09-17 03:56:28 +0200System123(~System123@net-37-179-171-3.cust.vodafonedsl.it)
2021-09-17 03:58:22 +0200lavaman(~lavaman@98.38.249.169)
2021-09-17 03:59:53 +0200dragestil_(~quassel@user/dragestil)
2021-09-17 04:01:19 +0200System123(~System123@net-37-179-171-3.cust.vodafonedsl.it) (Ping timeout: 268 seconds)
2021-09-17 04:02:41 +0200hololeap(~hololeap@user/hololeap) (Remote host closed the connection)
2021-09-17 04:03:42 +0200hololeap(~hololeap@user/hololeap)
2021-09-17 04:05:14 +0200 <hololeap> Boarders: https://github.com/haskell/containers/blob/master/containers-tests/benchmarks/IntMap.hs
2021-09-17 04:05:15 +0200 <hololeap> ?
2021-09-17 04:06:55 +0200 <Axman6> GHC? :)
2021-09-17 04:07:12 +0200 <Axman6> there was a great talk at this year's HIW about GHC's IntMap usage actually!
2021-09-17 04:08:06 +0200jokleinn(~jokleinn@user/jokleinn) (Ping timeout: 268 seconds)
2021-09-17 04:08:25 +0200 <hololeap> this has all the containers benchmarks: https://github.com/haskell/containers/blob/master/containers-tests/containers-tests.cabal
2021-09-17 04:09:06 +0200lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-09-17 04:18:13 +0200shapr(~user@pool-100-36-247-68.washdc.fios.verizon.net) (Ping timeout: 252 seconds)
2021-09-17 04:20:38 +0200td_(~td@muedsl-82-207-238-006.citykom.de) (Ping timeout: 260 seconds)
2021-09-17 04:22:25 +0200td_(~td@94.134.91.4)
2021-09-17 04:26:51 +0200 <awpr> I don't know whether to be appreciative of QuickCheck or annoyed at it, for informing me I fail to round-trip "\SO\&H" to "\SOH"
2021-09-17 04:27:07 +0200 <awpr> text escaping is... fun
2021-09-17 04:31:22 +0200 <awpr> ooh, juicy tidbit, `instance Show String` uses `ShowS` as something more than just a `DList`, it actually peeks at what comes after it
2021-09-17 04:31:48 +0200 <awpr> > showsPrec "\SO" "H"
2021-09-17 04:31:49 +0200 <lambdabot> error:
2021-09-17 04:31:49 +0200 <lambdabot> • Couldn't match expected type ‘Int’ with actual type ‘[Char]’
2021-09-17 04:31:49 +0200 <lambdabot> • In the first argument of ‘showsPrec’, namely ‘"\SO"’
2021-09-17 04:31:53 +0200 <awpr> > show "\SO" "H"
2021-09-17 04:31:54 +0200seventhCrow(crow@gateway/vpn/protonvpn/seventhcrow) (Remote host closed the connection)
2021-09-17 04:31:54 +0200 <lambdabot> error:
2021-09-17 04:31:54 +0200 <lambdabot> • Couldn't match expected type ‘[Char] -> t’
2021-09-17 04:31:54 +0200 <lambdabot> with actual type ‘[Char]’
2021-09-17 04:32:45 +0200seventhCrow(crow@gateway/vpn/protonvpn/seventhcrow)
2021-09-17 04:33:22 +0200 <awpr> > (GHC.Show.showLitString "\SO" "H", GHC.Show.showLitString "\SO" "S")
2021-09-17 04:33:24 +0200 <lambdabot> error:
2021-09-17 04:33:24 +0200 <lambdabot> Not in scope: ‘GHC.Show.showLitString’
2021-09-17 04:33:24 +0200 <lambdabot> No module named ‘GHC.Show’ is imported.error:
2021-09-17 04:33:46 +0200 <awpr> huh. oh well
2021-09-17 04:38:48 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Quit: Leaving)
2021-09-17 04:39:37 +0200lavaman(~lavaman@98.38.249.169)
2021-09-17 04:39:45 +0200pooryorick(~pooryoric@87-119-174-173.tll.elisa.ee) (Ping timeout: 265 seconds)
2021-09-17 04:40:52 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-17 04:41:11 +0200pooryorick(~pooryoric@87-119-174-173.tll.elisa.ee)
2021-09-17 04:41:24 +0200favonia(~favonia@user/favonia) (Ping timeout: 268 seconds)
2021-09-17 04:42:10 +0200dragestil_(~quassel@user/dragestil) (Ping timeout: 265 seconds)
2021-09-17 04:43:15 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 268 seconds)
2021-09-17 04:43:30 +0200dragestil_(~quassel@user/dragestil)
2021-09-17 04:44:04 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 252 seconds)
2021-09-17 04:44:40 +0200xff0x(~xff0x@2001:1a81:52ad:c900:2fb9:e85d:6382:ddb8) (Ping timeout: 252 seconds)
2021-09-17 04:45:24 +0200xff0x(~xff0x@2001:1a81:52ad:c900:aed8:d538:dc44:ee0)
2021-09-17 04:47:12 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 04:47:44 +0200hololeap(~hololeap@user/hololeap) (Quit: Bye)
2021-09-17 04:57:30 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 260 seconds)
2021-09-17 04:59:23 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2021-09-17 05:04:25 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 252 seconds)
2021-09-17 05:04:46 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 05:11:58 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 260 seconds)
2021-09-17 05:15:02 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-09-17 05:19:20 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 05:22:00 +0200hendursaga(~weechat@user/hendursaga) (Ping timeout: 276 seconds)
2021-09-17 05:22:05 +0200hendursa1(~weechat@user/hendursaga)
2021-09-17 05:23:49 +0200xsperry(~as@user/xsperry)
2021-09-17 05:26:25 +0200waleee(~waleee@h-98-128-228-119.na.cust.bahnhof.se) (Ping timeout: 252 seconds)
2021-09-17 05:39:33 +0200zebrag(~chris@user/zebrag) (Remote host closed the connection)
2021-09-17 05:46:34 +0200lavaman(~lavaman@98.38.249.169)
2021-09-17 05:51:10 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 260 seconds)
2021-09-17 06:01:55 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 265 seconds)
2021-09-17 06:07:07 +0200juhp(~juhp@111.65.68.133) (Read error: Connection reset by peer)
2021-09-17 06:07:38 +0200brettgilio(~brettgili@x-node.gq) (Quit: Ping timeout (120 seconds))
2021-09-17 06:08:10 +0200brettgilio(~brettgili@x-node.gq)
2021-09-17 06:11:33 +0200falafel(~falafel@2603-8000-d800-688c-753f-04f5-7eeb-6eb7.res6.spectrum.com)
2021-09-17 06:17:21 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 06:21:18 +0200falafel(~falafel@2603-8000-d800-688c-753f-04f5-7eeb-6eb7.res6.spectrum.com) (Ping timeout: 268 seconds)
2021-09-17 06:27:21 +0200falafel(~falafel@2603-8000-d800-688c-753f-04f5-7eeb-6eb7.res6.spectrum.com)
2021-09-17 06:34:44 +0200seventhCrow(crow@gateway/vpn/protonvpn/seventhcrow) (Quit: WeeChat 3.2.1)
2021-09-17 06:36:48 +0200ArctVaulMarsHMPJ(~pjetcetal@2.95.253.167)
2021-09-17 06:37:04 +0200ArctVaulMarsHMPJ(~pjetcetal@2.95.253.167) (Read error: Connection reset by peer)
2021-09-17 06:38:28 +0200vonfry(~user@116.236.75.238)
2021-09-17 06:41:05 +0200 <Axman6> @pl (\s -> (,s) <$> ux)
2021-09-17 06:41:05 +0200 <lambdabot> (line 1, column 10):
2021-09-17 06:41:05 +0200 <lambdabot> unexpected ','
2021-09-17 06:41:05 +0200 <lambdabot> expecting expression
2021-09-17 06:41:16 +0200 <Axman6> @pl (\s -> (\x -> (x,s)) <$> ux)
2021-09-17 06:41:16 +0200 <lambdabot> (<$> ux) . flip (,)
2021-09-17 06:41:22 +0200 <Axman6> gross
2021-09-17 06:41:38 +0200 <Axman6> @pl (\s -> fmap (\x -> (x,s)) ux)
2021-09-17 06:41:38 +0200 <lambdabot> flip fmap ux . flip (,)
2021-09-17 06:41:43 +0200 <Axman6> Also gross
2021-09-17 06:45:40 +0200falafel(~falafel@2603-8000-d800-688c-753f-04f5-7eeb-6eb7.res6.spectrum.com) (Ping timeout: 240 seconds)
2021-09-17 06:51:54 +0200neo1(~neo3@cpe-292712.ip.primehome.com)
2021-09-17 06:52:18 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 260 seconds)
2021-09-17 06:57:26 +0200mikoto-chan(~mikoto-ch@83.137.2.251)
2021-09-17 07:08:43 +0200mikoto-chan(~mikoto-ch@83.137.2.251) (Ping timeout: 252 seconds)
2021-09-17 07:11:39 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-17 07:15:59 +0200Cajun(~Cajun@user/cajun) (Ping timeout: 256 seconds)
2021-09-17 07:17:15 +0200falafel(~falafel@2603-8000-d800-688c-753f-04f5-7eeb-6eb7.res6.spectrum.com)
2021-09-17 07:19:30 +0200martin02(~silas@141.84.69.76) (Ping timeout: 260 seconds)
2021-09-17 07:21:10 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Ping timeout: 240 seconds)
2021-09-17 07:21:31 +0200doyougnu(~user@c-73-25-202-122.hsd1.or.comcast.net) (Ping timeout: 268 seconds)
2021-09-17 07:22:08 +0200falafel(~falafel@2603-8000-d800-688c-753f-04f5-7eeb-6eb7.res6.spectrum.com) (Ping timeout: 268 seconds)
2021-09-17 07:25:34 +0200_ht(~quassel@82-169-194-8.biz.kpn.net)
2021-09-17 07:27:57 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-09-17 07:28:26 +0200vysn(~vysn@user/vysn)
2021-09-17 07:37:06 +0200vysn(~vysn@user/vysn) (Ping timeout: 260 seconds)
2021-09-17 07:38:15 +0200 <vaibhavsagar[m]> Does anyone know why `fail "<errormsg>" o` is valid in GHC pre-8.8? https://nbviewer.jupyter.org/github/vaibhavsagar/notebooks/blob/a7d0a787c9757778505d8458b4e2318fc6…
2021-09-17 07:38:41 +0200vysn(~vysn@user/vysn)
2021-09-17 07:38:49 +0200 <vaibhavsagar[m]> my colleague thinks it's because `fail` was part of `Monad` then, which means there was a `fail` instance for `((->) r)`
2021-09-17 07:38:50 +0200 <awpr> probably `(->) a` Monad instance?
2021-09-17 07:39:00 +0200 <awpr> yeah, that
2021-09-17 07:39:05 +0200 <vaibhavsagar[m]> it's fixed in 8.8 onwards: https://nbviewer.jupyter.org/github/vaibhavsagar/notebooks/blob/ee7e1756137e6c7f0a5744b0144203b348…
2021-09-17 07:39:27 +0200 <vaibhavsagar[m]> okay, I lost a day or two to it at work since we're on an old GHC
2021-09-17 07:39:55 +0200 <vaibhavsagar[m]> but I've been nudging us to upgrade so more evidence that we should is good I guess
2021-09-17 07:41:31 +0200 <vaibhavsagar[m]> also I'm really proud of that notebook, I used a different version of Aeson than the one that was used to build IHaskell and it still worked because I made some changes to how IHaskell is packaged with Nix just a week ago
2021-09-17 07:42:52 +0200michalz(~michalz@185.246.204.37)
2021-09-17 07:43:38 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2021-09-17 07:45:50 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-09-17 07:46:54 +0200zmt00(~zmt00@user/zmt00) (Ping timeout: 260 seconds)
2021-09-17 07:50:01 +0200theang(~theang@fef109.internetdsl.tpnet.pl) (Ping timeout: 252 seconds)
2021-09-17 07:50:16 +0200theang(~theang@2a00:f41:5866:e08:671b:b01e:3ccd:22d3)
2021-09-17 07:52:50 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 07:55:40 +0200tommd(~tommd@75-164-130-101.ptld.qwest.net) (Ping timeout: 240 seconds)
2021-09-17 08:01:21 +0200chele(~chele@user/chele)
2021-09-17 08:02:33 +0200Akronymus(~Akronymus@85.118.189.59)
2021-09-17 08:02:39 +0200Akronymus(~Akronymus@85.118.189.59) ()
2021-09-17 08:05:39 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Ping timeout: 265 seconds)
2021-09-17 08:06:06 +0200tomjaguarpaw(~tom@li367-225.members.linode.com) (Quit: Lost terminal)
2021-09-17 08:09:01 +0200Gurkenglas(~Gurkengla@dslb-002-207-014-195.002.207.pools.vodafone-ip.de)
2021-09-17 08:12:54 +0200son0p(~ff@181.136.122.143) (Ping timeout: 265 seconds)
2021-09-17 08:13:22 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-09-17 08:15:19 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 265 seconds)
2021-09-17 08:19:16 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-09-17 08:19:29 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2021-09-17 08:20:13 +0200_ht(~quassel@82-169-194-8.biz.kpn.net) (Remote host closed the connection)
2021-09-17 08:22:37 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-09-17 08:23:39 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-09-17 08:28:22 +0200bontaq(~user@ool-45779fe5.dyn.optonline.net) (Ping timeout: 265 seconds)
2021-09-17 08:28:33 +0200martin02(~silas@141.84.69.76)
2021-09-17 08:29:41 +0200Kaiepi(~Kaiepi@156.34.44.192) (Ping timeout: 252 seconds)
2021-09-17 08:30:54 +0200ubert(~Thunderbi@178.115.60.138.wireless.dyn.drei.com)
2021-09-17 08:31:28 +0200ubert1(~Thunderbi@178.115.60.138.wireless.dyn.drei.com)
2021-09-17 08:33:36 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-09-17 08:33:40 +0200renzhi(~xp@2607:fa49:6500:b100::5845) (Ping timeout: 240 seconds)
2021-09-17 08:34:27 +0200vonfry(~user@116.236.75.238) (Quit: ERC (IRC client for Emacs 27.2))
2021-09-17 08:38:27 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 08:40:25 +0200shriekingnoise(~shrieking@186.137.144.80) (Quit: Quit)
2021-09-17 08:43:53 +0200dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be)
2021-09-17 08:45:40 +0200renzhi(~xp@2607:fa49:6500:b100::1d9d)
2021-09-17 08:47:24 +0200ephemient(uid407513@id-407513.lymington.irccloud.com)
2021-09-17 08:48:52 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-09-17 09:01:31 +0200mc47(~mc47@xmonad/TheMC47)
2021-09-17 09:02:34 +0200lavaman(~lavaman@98.38.249.169)
2021-09-17 09:05:00 +0200haykam2(~haykam@static.100.2.21.65.clients.your-server.de)
2021-09-17 09:05:04 +0200haykam1(~haykam@static.100.2.21.65.clients.your-server.de) (Read error: Connection reset by peer)
2021-09-17 09:05:11 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2021-09-17 09:05:20 +0200lbseale_(~lbseale@user/ep1ctetus)
2021-09-17 09:05:25 +0200Sgeo(~Sgeo@user/sgeo)
2021-09-17 09:06:58 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 252 seconds)
2021-09-17 09:08:29 +0200lbseale(~lbseale@user/ep1ctetus) (Ping timeout: 265 seconds)
2021-09-17 09:11:59 +0200jstolarek(~jstolarek@ers4.neoplus.adsl.tpnet.pl)
2021-09-17 09:13:16 +0200vaucouleur(~vaucouleu@176.124.42.130)
2021-09-17 09:14:05 +0200slowButPresent(~slowButPr@user/slowbutpresent) (Read error: Connection reset by peer)
2021-09-17 09:14:27 +0200kenran(~kenran@b2b-37-24-119-190.unitymedia.biz)
2021-09-17 09:16:59 +0200 <kenran> How do you usually decide between different forms of encoding errors, like Either MyError a vs MonadError MyError a vs MonadFail vs ...? My problem: I'm writing a function in a library that I will then be using in another project. The project uses polysemy, but I still don't want to just use Polysemy.Error in the library.
2021-09-17 09:17:20 +0200 <kenran> I often stumble over how to best glue together all these different mechanisms for failure in the final project
2021-09-17 09:17:52 +0200 <kenran> There's so much work happening in that regard that it's hard to trust blog posts and such from, like, 2016
2021-09-17 09:19:34 +0200 <kenran> One concrete question: Is there a tradeoff to using MonadError e over Either e? MonadError looks strictly more powerful + flexible to mee
2021-09-17 09:20:06 +0200Kaiepi(~Kaiepi@156.34.44.192)
2021-09-17 09:20:07 +0200xstill(~xstill@fimu/xstill) ()
2021-09-17 09:21:17 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-09-17 09:22:28 +0200 <dminuoso> MonadError generalizes IO exceptions.
2021-09-17 09:22:46 +0200 <dminuoso> It's not more flexible or powerful, it's orthogonal
2021-09-17 09:23:03 +0200 <dminuoso> Generally the state of "how to do errors" in Haskell is very mixed, there's no general canonical way
2021-09-17 09:23:46 +0200 <dminuoso> MonadFail otoh is the interface that gets invoked on pattern match failures in do-notation
2021-09-17 09:23:48 +0200 <dminuoso> Like:
2021-09-17 09:24:21 +0200 <dminuoso> `do F a <- expr; ...` calls fail if the bind fails to match the pattern `F a`
2021-09-17 09:24:55 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 265 seconds)
2021-09-17 09:25:18 +0200 <dminuoso> Sadly MonadFail gets reused for raising errors in monads, an interface that it's inappropriate, especially because the passed String might not even be representable.
2021-09-17 09:25:25 +0200 <dminuoso> For example in Maybe the passed String is simply.... ignored.
2021-09-17 09:25:41 +0200 <dminuoso> And in IO it picks some exception you probably would not want.
2021-09-17 09:27:09 +0200 <kenran> dminuoso: thanks, that explains the MonadFail usage I've seen but not understood. I knew about the pattern matching failures, but I've seen it used as an easy way to get compatible interfaces to lots of stuff
2021-09-17 09:27:18 +0200 <dminuoso> Or actually MonadError is not really a generalization of Exception, sorry that was wrong. Its an odd breed.
2021-09-17 09:27:21 +0200 <dminuoso> MonadThrow generalizes throwIO
2021-09-17 09:27:57 +0200 <dminuoso> kenran: My personal favourite for when there's IO in the mix, is hierarchial IO exceptions.
2021-09-17 09:28:13 +0200 <dminuoso> It's composable and gives fine control over callers in what kind of exceptions they want to capture.
2021-09-17 09:28:18 +0200 <kenran> Like, having a library function return `m Int`, with m having the MonadFail constraint, and then being able to call this in some fromJSON
2021-09-17 09:28:35 +0200 <kenran> dminuoso: that's where I want to to land, just not with IOExceptions but Polysemy.Error, if that makes sense
2021-09-17 09:28:50 +0200 <dminuoso> I dont know Polysemy realyl
2021-09-17 09:29:18 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2021-09-17 09:29:34 +0200xff0x(~xff0x@2001:1a81:52ad:c900:aed8:d538:dc44:ee0) (Ping timeout: 252 seconds)
2021-09-17 09:29:42 +0200 <kenran> Polysemy.Error is basically the equivalent of the MonadError in mtl, iiuc. You get throw and catch in the effect monad's context
2021-09-17 09:30:32 +0200xff0x(~xff0x@2001:1a81:52ad:c900:b704:3c1b:6bea:6e62)
2021-09-17 09:30:46 +0200 <kenran> dminuoso: so just that I get you right: you have some fine-tuned data types for exceptions that you throw in "their" context, and the callers can decide whether to just keep that constraint or "widen" it, or transform it?
2021-09-17 09:31:01 +0200 <kenran> Like, the e in MonadError e changes on the way "up"
2021-09-17 09:31:11 +0200 <dminuoso> kenran: do you know how Java or C++ style exceptions work wrt to class hierarchies?
2021-09-17 09:31:18 +0200 <dminuoso> And being able to "catch some class of exceptions"?
2021-09-17 09:31:26 +0200 <kenran> yeah
2021-09-17 09:31:31 +0200 <dminuoso> We can do exactly the same in Haskell
2021-09-17 09:31:34 +0200 <kenran> ahhh, I see what I missed
2021-09-17 09:31:38 +0200funsafe(~funsafe@2601:1c1:4200:e53:2875:5507:42e4:4e14) (Ping timeout: 268 seconds)
2021-09-17 09:32:11 +0200 <kenran> I was thinking of just one tree of exception types, but that misses the point with "I can catch this one error, but let this other one bubble up"
2021-09-17 09:32:14 +0200 <dminuoso> The reason I like it, is because it's such a simple and yet generic interface, doesn't require me to interface with libraries like mtl to even interact with your library, gives me good control over what I care about..
2021-09-17 09:32:23 +0200 <dminuoso> But it only does work when there's IO :)
2021-09-17 09:32:39 +0200 <dminuoso> Well, you can still do that with exceptions too
2021-09-17 09:32:41 +0200 <dminuoso> % :t cathces
2021-09-17 09:32:41 +0200 <yahb> dminuoso: ; <interactive>:1:1: error:; * Variable not in scope: cathces; * Perhaps you meant one of these: `catches' (imported from Control.Monad.Error.Lens), `catches' (imported from Control.Exception)
2021-09-17 09:32:43 +0200 <dminuoso> % :t catches
2021-09-17 09:32:43 +0200 <yahb> dminuoso: ; <interactive>:1:1: error:; Ambiguous occurrence `catches'; It could refer to; either `Control.Monad.Error.Lens.catches', imported from `Control.Monad.Error.Lens'; or `Control.Exception.catches', imported from `Control.Exception'
2021-09-17 09:32:50 +0200 <dminuoso> % :t Control.Exception.catches
2021-09-17 09:32:50 +0200 <yahb> dminuoso: IO a -> [Control.Exception.Handler a] -> IO a
2021-09-17 09:33:01 +0200 <dminuoso> Here you can specify a list of exceptions you care about, everything else bubbles through,.
2021-09-17 09:33:11 +0200 <kenran> dminuoso: yeah, that's the problem :D I wonder if it's possible with Polysemy to have multiple Error constraints that I can handle separately. Have to try that
2021-09-17 09:33:17 +0200 <dminuoso> And best of all, you can mix this with what I mentioned above. "Catch this class of exceptions, and that other tree of exceptions, let everything else go through"
2021-09-17 09:33:29 +0200 <dminuoso> The only problem is, unlike polysemy, there's no communication of either in the type system.
2021-09-17 09:33:43 +0200 <dminuoso> But there's no silver bullet in Haskell.
2021-09-17 09:33:54 +0200 <kenran> Right
2021-09-17 09:34:11 +0200 <kenran> The only reasonable goal for me seems to be to get consistent with how we do error handling
2021-09-17 09:34:19 +0200 <kenran> Right now it's a mess of different stuff
2021-09-17 09:34:38 +0200 <dminuoso> I've largely settled on IO exceptions, but then again much of our stuff is IO centric..
2021-09-17 09:34:58 +0200 <dminuoso> Also, since Im a big fan of MonadUnliftIO, I dont have many other choices...
2021-09-17 09:35:00 +0200 <dminuoso> :p
2021-09-17 09:35:01 +0200ubert(~Thunderbi@178.115.60.138.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-17 09:35:01 +0200ubert1ubert
2021-09-17 09:35:20 +0200 <kenran> I really like Polysemy so far, it's like mtl-style (which somehow resonates with me, probably from my OO background), but I'm not sure yet whether I really want it to be present in the "pure library code"
2021-09-17 09:35:37 +0200 <kenran> I know some package authors have separate packages for the different paradigms
2021-09-17 09:36:06 +0200 <kenran> For instance co-log, which has co-log-core, co-log (mtl-style), and co-log-polysemy
2021-09-17 09:36:52 +0200 <kenran> Thanks for all the input, really interesting stuff dminuoso
2021-09-17 09:37:26 +0200 <dminuoso> After a long while of Haskell, I've settled on simpler haskell without too many type level tricks - at least on the external interface.
2021-09-17 09:38:21 +0200 <dminuoso> kenran: So if I understand polysemy correctly, one thing that would immediately annoy me is that '[A, B] and '[B, A] would be incompatible
2021-09-17 09:38:49 +0200 <dminuoso> So code doesn't freely compose, as you might have to shuffle the composition order around to make polysemy happy
2021-09-17 09:39:53 +0200jtomas(~jtomas@95.red-88-11-64.dynamicip.rima-tde.net)
2021-09-17 09:42:00 +0200betelgeuse(~betelgeus@94-225-47-8.access.telenet.be) (Read error: Connection reset by peer)
2021-09-17 09:42:18 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-17 09:43:03 +0200betelgeuse(~betelgeus@94-225-47-8.access.telenet.be)
2021-09-17 09:44:55 +0200kuribas(~user@ptr-25vy0i7x8rtrl519tor.18120a2.ip6.access.telenet.be)
2021-09-17 09:47:32 +0200max22-(~maxime@2a01cb0883359800999b760ae95fc90b.ipv6.abo.wanadoo.fr)
2021-09-17 09:50:28 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr)
2021-09-17 09:51:35 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:854d:ae90:d2a1:51ab) (Remote host closed the connection)
2021-09-17 09:52:29 +0200 <kenran> dminuoso: that's correct in principle, but the way you actually use it in your domain function it doesn't pose a problem.
2021-09-17 09:53:03 +0200 <kenran> dminuoso: You write your functions like this: Members '[Eff1, PersistFoo, ...] r => Int -> Sem r String
2021-09-17 09:53:48 +0200funsafe(~funsafe@2601:1c1:4200:e53:2875:5507:42e4:4e14)
2021-09-17 09:53:50 +0200 <kenran> And in the Members constraint the order is not important. Once you get to actually interpreting the effects, of course, that's where you have to pay attention to the actual order, so yes, that's the one point where it can be a bit more tricky
2021-09-17 09:53:58 +0200econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2021-09-17 09:54:47 +0200gehmehgeh(~user@user/gehmehgeh)
2021-09-17 09:54:51 +0200 <kenran> As with everything, one has to pay attention to not have like 7+ effects "active" all the time, which is where I sometimes struggle
2021-09-17 09:55:23 +0200notzmv(~zmv@user/notzmv) (Read error: Connection reset by peer)
2021-09-17 09:56:12 +0200 <kenran> In general I have that problem with mtl-style too, but I feel like where Polysemy exceeds over encoding your effects as type classes directly is at this point: actually removing/reinterpreting an effect at a certain point in your code without having to choose a concrete type, if that makes sense
2021-09-17 09:57:00 +0200 <kenran> I'm still not experienced enough with it and it's only a vague feeling until now, though. More or less a "let's use it and see where it leads us"
2021-09-17 09:57:23 +0200 <kenran> I love that we're actually encouraged to do soo at this job
2021-09-17 09:59:24 +0200vpan(~vilius@212.117.1.172)
2021-09-17 10:01:56 +0200ub(~Thunderbi@178.115.60.138.wireless.dyn.drei.com)
2021-09-17 10:03:29 +0200eggplantade(~Eggplanta@108-201-191-115.lightspeed.sntcca.sbcglobal.net)
2021-09-17 10:04:08 +0200cfricke(~cfricke@user/cfricke)
2021-09-17 10:04:27 +0200eggplantade(~Eggplanta@108-201-191-115.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2021-09-17 10:05:02 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81a:6736:1170:5e1c)
2021-09-17 10:05:55 +0200hendursaga(~weechat@user/hendursaga)
2021-09-17 10:08:43 +0200theang(~theang@2a00:f41:5866:e08:671b:b01e:3ccd:22d3) (Ping timeout: 252 seconds)
2021-09-17 10:09:09 +0200theang(~theang@fef109.internetdsl.tpnet.pl)
2021-09-17 10:09:16 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:f81a:6736:1170:5e1c) (Ping timeout: 252 seconds)
2021-09-17 10:09:18 +0200hendursa1(~weechat@user/hendursaga) (Ping timeout: 276 seconds)
2021-09-17 10:11:12 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:a20c:3ab6:8175:e3ff)
2021-09-17 10:11:57 +0200 <kuribas> I guess that's why ReaderT r IO is so popular. No need to juggle effects around.
2021-09-17 10:12:01 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 10:13:35 +0200 <dminuoso> Yes, and you can have MonadUnliftIO too.
2021-09-17 10:14:00 +0200 <kuribas> It's funny how we create all these fancy effect systems, and we end up having mutable state and exceptions again :)
2021-09-17 10:14:14 +0200 <dminuoso> Well I certainly understand why people want effect systems.
2021-09-17 10:14:22 +0200 <dminuoso> But in Haskell they feel bolted on more often than not.
2021-09-17 10:14:25 +0200 <kuribas> But being able to "see" the state is already a big advantage IMO.
2021-09-17 10:14:43 +0200 <dminuoso> No effect system in Haskell has really convinced me so far.
2021-09-17 10:14:44 +0200 <kuribas> dminuoso: the way I use the effect systems is encapsulated in functionality.
2021-09-17 10:15:01 +0200 <kuribas> as in, they are an implementation detail of whatever I want to do.
2021-09-17 10:15:12 +0200 <kuribas> Not a big architectural design feature.
2021-09-17 10:15:35 +0200oxide(~lambda@user/oxide)
2021-09-17 10:17:09 +0200 <kenran> I think I've let the easy testability of polysemy-based code convince me a bit too easily ("changing your interpreter for a test is just using another function", but I've yet to actually use it as much as I'd like :D
2021-09-17 10:17:44 +0200allbery_b(~geekosaur@xmonad/geekosaur)
2021-09-17 10:17:44 +0200geekosaur(~geekosaur@xmonad/geekosaur) (Killed (NickServ (GHOST command used by allbery_b)))
2021-09-17 10:17:47 +0200allbery_bgeekosaur
2021-09-17 10:18:02 +0200benin036932301(~benin@183.82.205.89)
2021-09-17 10:18:48 +0200 <kuribas> Not having global state is the biggest advantage.
2021-09-17 10:19:03 +0200 <kuribas> or better, "invisible" global state.
2021-09-17 10:19:17 +0200 <dminuoso> It's all a trade off. Sometimes I think people spend way too much time and effort in restructuring with effect systems on the misbelief, that being able to "plug in different interpreters" will yield valuable net results.
2021-09-17 10:19:35 +0200 <kenran> dminuoso: yep, that's definitely true
2021-09-17 10:19:38 +0200 <dminuoso> It feels it comes at the price of readability and maintainability. When you need to become a polysemy expert just to interact and deal with the code, Im not sure much was won.
2021-09-17 10:21:05 +0200 <kenran> Honestly, the same goes for me trying to write mtl/tagless-final style code, too. My experience with polysemy in particular was that it improves upon that style, but if the code I transform is already wrongly based on the (dis)belief you mention, there's definitely nothing won, and time lost
2021-09-17 10:21:17 +0200 <dminuoso> It reminds me how some projects spent endless amount of time on pleasing some coverage tester, convincing themselves that having 100% coverage means there's less bugs.
2021-09-17 10:21:31 +0200juhp(~juhp@111.65.68.133)
2021-09-17 10:21:33 +0200 <dminuoso> I wonder whether this is just the Haskell-variant of that.
2021-09-17 10:21:42 +0200 <kenran> It might just be
2021-09-17 10:22:15 +0200 <kenran> Lots of the bugs that are not prevented by coverage alone are of the kind that is harder to produce in Haskell when leveraging the type system well
2021-09-17 10:22:55 +0200benin036932301(~benin@183.82.205.89) (Ping timeout: 265 seconds)
2021-09-17 10:23:53 +0200dtman34(~dtman34@c-73-62-246-247.hsd1.mn.comcast.net) (Ping timeout: 265 seconds)
2021-09-17 10:34:54 +0200chele(~chele@user/chele) (Remote host closed the connection)
2021-09-17 10:35:54 +0200chele(~chele@user/chele)
2021-09-17 10:36:07 +0200hnOsmium0001(uid453710@id-453710.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-09-17 10:40:58 +0200vaucouleur(~vaucouleu@176.124.42.130) (Read error: Connection reset by peer)
2021-09-17 10:41:16 +0200vaucouleur(~vaucouleu@176.124.42.130)
2021-09-17 10:43:47 +0200jstolarek(~jstolarek@ers4.neoplus.adsl.tpnet.pl) (Quit: leaving)
2021-09-17 10:43:59 +0200jstolarek(~jstolarek@ers4.neoplus.adsl.tpnet.pl)
2021-09-17 10:44:34 +0200jstolarek(~jstolarek@ers4.neoplus.adsl.tpnet.pl) (Client Quit)
2021-09-17 10:44:46 +0200jstolarek(~jstolarek@ers4.neoplus.adsl.tpnet.pl)
2021-09-17 10:46:06 +0200jstolarek(~jstolarek@ers4.neoplus.adsl.tpnet.pl) (Client Quit)
2021-09-17 10:46:18 +0200jstolarek(~jstolarek@ers4.neoplus.adsl.tpnet.pl)
2021-09-17 10:49:53 +0200dtman34(~dtman34@c-73-62-246-247.hsd1.mn.comcast.net)
2021-09-17 10:52:06 +0200favonia(~favonia@user/favonia)
2021-09-17 10:52:53 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 265 seconds)
2021-09-17 10:55:13 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 10:56:05 +0200jonathanx(~jonathan@dyn-8-sc.cdg.chalmers.se) (Remote host closed the connection)
2021-09-17 10:56:23 +0200jonathanx(~jonathan@dyn-8-sc.cdg.chalmers.se)
2021-09-17 10:58:27 +0200jespada(~jespada@2803:9800:9842:7a62:95e0:d2b5:ae88:676) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-09-17 11:00:06 +0200fabfianda[m](~fabfianda@2001:470:69fc:105::6db) (Quit: You have been kicked for being idle)
2021-09-17 11:00:54 +0200 <maerwald> dminuoso: polysemy is also very slow
2021-09-17 11:01:09 +0200 <maerwald> and has questionable semantics
2021-09-17 11:01:39 +0200 <maerwald> because: effects systems are hard
2021-09-17 11:01:51 +0200 <dminuoso> The real solution is to have software without errors. Then you dont need error effects.
2021-09-17 11:01:58 +0200 <maerwald> and yeah, I think this is hype driven development in haskell
2021-09-17 11:02:00 +0200 <dminuoso> It's why bottom was invented.
2021-09-17 11:02:05 +0200 <dminuoso> Always error free. :-)
2021-09-17 11:02:18 +0200 <dminuoso> "hype driven development"
2021-09-17 11:02:22 +0200 <dminuoso> Interesting expression, had not heard about that
2021-09-17 11:02:25 +0200dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Quit: WeeChat 3.2.1)
2021-09-17 11:02:34 +0200 <maerwald> there are several blog posts about it (I think bashing NoSQL)
2021-09-17 11:03:31 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-09-17 11:04:00 +0200 <dminuoso> NoSQL is an interesting proposition. I stand by my opinion that it's an emergent technology of folks thinking "Who cares about well-principled databases founded on research and academia, you only live once!" for most people. Who cares about transactional safety.
2021-09-17 11:04:25 +0200 <dminuoso> The fact that MongoDB, not until too long ago crashed and corrupted if the dataset exceeded 4GiB on 32bit systems is just telling..
2021-09-17 11:04:40 +0200 <maerwald> Afaiu NoSQL was an attempt to solve a very specific performance problem with relational databases. It wasn't intended as general purpose technology
2021-09-17 11:04:57 +0200 <maerwald> but then it got hyped and here we are
2021-09-17 11:05:11 +0200 <dminuoso> Sure, though "NoSQL" as a term that comes from that hype.
2021-09-17 11:05:20 +0200 <dminuoso> I mean memcached is also.. "nosql"
2021-09-17 11:05:38 +0200 <dminuoso> Though its not new and hipster enough
2021-09-17 11:06:03 +0200 <maerwald> there's also microservices in town, which is basically "you could have written a library, but that's too easy"
2021-09-17 11:06:39 +0200 <maerwald> "your library needs a database, a protocol and be part of a kubernetes cluster"
2021-09-17 11:06:40 +0200tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2021-09-17 11:06:41 +0200 <dminuoso> One of our hottest postgresql servers serves roughly 5kTX/s.. during the hottest phase of the day. And that's without even trying hard!
2021-09-17 11:06:50 +0200 <dminuoso> Writing.
2021-09-17 11:06:54 +0200 <dminuoso> Not reading. :-)
2021-09-17 11:07:22 +0200 <maerwald> That's the problem with CTOs looking at "what does facebook/google do"
2021-09-17 11:07:29 +0200 <maerwald> they're solving problems you don't have
2021-09-17 11:08:11 +0200 <dminuoso> Of course. I think there's some hope that if you employ the same technologies as google does, you get as large and rich as google.
2021-09-17 11:08:17 +0200 <maerwald> :D
2021-09-17 11:08:50 +0200sim590(~simon@modemcable090.207-203-24.mc.videotron.ca)
2021-09-17 11:11:04 +0200 <dminuoso> It's nothing but an example of cum hoc ergo propter hoc.
2021-09-17 11:11:32 +0200 <dminuoso> (Or maybe its a different fallacy?)
2021-09-17 11:12:30 +0200 <maerwald> I think it's just plain stupidity
2021-09-17 11:12:52 +0200 <maerwald> as plain as white rice (although the latter is more delicious)
2021-09-17 11:14:11 +0200 <dminuoso> White rice is indeed delicious.
2021-09-17 11:14:22 +0200 <dminuoso> Especially if cooked with tahdig.
2021-09-17 11:14:28 +0200 <dminuoso> The only true way to cook rice.
2021-09-17 11:15:26 +0200[exa]discovers tahdig
2021-09-17 11:15:57 +0200 <dminuoso> [exa]: Good luck on your endaveours, it took me over two years to make perfect tahdig.
2021-09-17 11:16:13 +0200 <dminuoso> And it's not even half as perfect as when my Farsi friends do it.
2021-09-17 11:16:16 +0200 <[exa]> time to rice
2021-09-17 11:16:31 +0200 <dminuoso> :)
2021-09-17 11:23:18 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd)
2021-09-17 11:26:21 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:b0fa:b428:27dc:59de)
2021-09-17 11:27:15 +0200vaucouleur_(~vaucouleu@176.124.42.130)
2021-09-17 11:27:46 +0200vaucouleur__(~vaucouleu@176.124.42.130)
2021-09-17 11:30:25 +0200fef(~thedawn@user/thedawn)
2021-09-17 11:30:35 +0200vaucouleur(~vaucouleu@176.124.42.130) (Ping timeout: 265 seconds)
2021-09-17 11:30:54 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:b0fa:b428:27dc:59de) (Ping timeout: 260 seconds)
2021-09-17 11:31:46 +0200vaucouleur(~vaucouleu@176.124.42.130)
2021-09-17 11:32:06 +0200vaucouleur_(~vaucouleu@176.124.42.130) (Ping timeout: 268 seconds)
2021-09-17 11:33:00 +0200vaucouleur__(~vaucouleu@176.124.42.130) (Ping timeout: 265 seconds)
2021-09-17 11:34:41 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168)
2021-09-17 11:38:32 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-17 11:39:18 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168) (Ping timeout: 260 seconds)
2021-09-17 11:40:09 +0200pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2021-09-17 11:42:39 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2021-09-17 11:42:57 +0200wonko(~wjc@62.115.229.50)
2021-09-17 11:52:02 +0200betelgeuse(~betelgeus@94-225-47-8.access.telenet.be) (Quit: Ping timeout (120 seconds))
2021-09-17 11:53:33 +0200neurocyte(~neurocyte@user/neurocyte) (Quit: The Lounge - https://thelounge.chat)
2021-09-17 11:54:04 +0200betelgeuse(~betelgeus@94-225-47-8.access.telenet.be)
2021-09-17 11:58:53 +0200neurocyte0(~neurocyte@185.238.253.211)
2021-09-17 11:58:53 +0200neurocyte0(~neurocyte@185.238.253.211) (Changing host)
2021-09-17 11:58:53 +0200neurocyte0(~neurocyte@user/neurocyte)
2021-09-17 11:59:27 +0200betelgeuse(~betelgeus@94-225-47-8.access.telenet.be) (Read error: Connection reset by peer)
2021-09-17 12:00:48 +0200betelgeuse(~betelgeus@94-225-47-8.access.telenet.be)
2021-09-17 12:02:48 +0200arkanoid(~arkanoid@2-238-151-49.ip244.fastwebnet.it) (Quit: WeeChat 2.8)
2021-09-17 12:08:46 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr) (Ping timeout: 265 seconds)
2021-09-17 12:11:36 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net)
2021-09-17 12:13:12 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 268 seconds)
2021-09-17 12:16:53 +0200jespada(~jespada@host244.190-3-30.dynamic.telmex.net.ar)
2021-09-17 12:19:33 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net) (Remote host closed the connection)
2021-09-17 12:20:10 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net)
2021-09-17 12:25:07 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net) (Ping timeout: 252 seconds)
2021-09-17 12:25:30 +0200thornAvery(~thornAver@2401:c080:1800:4346:5400:3ff:fe2c:c8f8)
2021-09-17 12:26:03 +0200 <thornAvery> anyone got experience with `XMPP`, its failing to build (i think because haskell98 fails too) and im wondering whether its worth figuring out or if i should use something else
2021-09-17 12:27:57 +0200 <maerwald> xmpp?
2021-09-17 12:29:00 +0200__monty__(~toonn@user/toonn)
2021-09-17 12:29:56 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr)
2021-09-17 12:30:01 +0200zaquest(~notzaques@5.128.210.178) (Quit: Leaving)
2021-09-17 12:30:39 +0200hannessteffenhag(~hannesste@ip4d14ffd8.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2021-09-17 12:31:12 +0200zaquest(~notzaques@5.128.210.178)
2021-09-17 12:32:12 +0200 <thornAvery> maerwald: https://hackage.haskell.org/package/XMPP
2021-09-17 12:34:21 +0200burnsidesLlama(~burnsides@client-8-81.eduroam.oxuni.org.uk)
2021-09-17 12:35:24 +0200jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2021-09-17 12:37:06 +0200burnside_(~burnsides@dhcp168-024.wadham.ox.ac.uk)
2021-09-17 12:38:40 +0200enicar(~enikar@user/enikar)
2021-09-17 12:39:07 +0200enicar(~enikar@user/enikar) (Client Quit)
2021-09-17 12:41:09 +0200burnsidesLlama(~burnsides@client-8-81.eduroam.oxuni.org.uk) (Ping timeout: 265 seconds)
2021-09-17 12:41:09 +0200ksu(~ksu@user/prtr) (Ping timeout: 265 seconds)
2021-09-17 12:50:00 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net)
2021-09-17 12:55:21 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net) (Ping timeout: 268 seconds)
2021-09-17 12:57:57 +0200juhp(~juhp@111.65.68.133) (Read error: Connection reset by peer)
2021-09-17 13:00:48 +0200betelgeuse(~betelgeus@94-225-47-8.access.telenet.be) (Quit: Ping timeout (120 seconds))
2021-09-17 13:00:57 +0200alx741(~alx741@181.196.68.9)
2021-09-17 13:02:11 +0200betelgeuse(~betelgeus@94-225-47-8.access.telenet.be)
2021-09-17 13:04:12 +0200lavaman(~lavaman@98.38.249.169)
2021-09-17 13:04:21 +0200rawles(~o@user/rawles)
2021-09-17 13:04:40 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr) (Ping timeout: 240 seconds)
2021-09-17 13:08:17 +0200leah2(~leah@vuxu.org) (Ping timeout: 250 seconds)
2021-09-17 13:08:55 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 260 seconds)
2021-09-17 13:10:31 +0200AlexNoo_(~AlexNoo@178.34.163.108)
2021-09-17 13:12:34 +0200Alex_test(~al_test@178.34.162.211) (Ping timeout: 265 seconds)
2021-09-17 13:13:01 +0200AlexZenon(~alzenon@178.34.162.211) (Ping timeout: 268 seconds)
2021-09-17 13:14:02 +0200AlexNoo(~AlexNoo@178.34.162.211) (Ping timeout: 260 seconds)
2021-09-17 13:18:04 +0200Alex_test(~al_test@178.34.163.108)
2021-09-17 13:18:30 +0200AlexZenon(~alzenon@178.34.163.108)
2021-09-17 13:22:07 +0200AlexNoo_AlexNoo
2021-09-17 13:27:57 +0200leah2(~leah@vuxu.org)
2021-09-17 13:27:59 +0200jakalx(~jakalx@base.jakalx.net)
2021-09-17 13:33:10 +0200sim590(~simon@modemcable090.207-203-24.mc.videotron.ca) (Ping timeout: 240 seconds)
2021-09-17 13:33:26 +0200Cajun(~Cajun@user/cajun)
2021-09-17 13:36:04 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168)
2021-09-17 13:37:07 +0200Tuplanolla(~Tuplanoll@91-159-69-50.elisa-laajakaista.fi)
2021-09-17 13:37:20 +0200sim590(~simon@modemcable090.207-203-24.mc.videotron.ca)
2021-09-17 13:40:59 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168) (Ping timeout: 268 seconds)
2021-09-17 13:43:36 +0200tcard(~tcard@p2307053-ipngn17101hodogaya.kanagawa.ocn.ne.jp) (Quit: Leaving)
2021-09-17 13:44:47 +0200benin036932301(~benin@183.82.205.89)
2021-09-17 13:44:50 +0200sim590(~simon@modemcable090.207-203-24.mc.videotron.ca) (Ping timeout: 260 seconds)
2021-09-17 13:48:24 +0200tcard(~tcard@p2307053-ipngn17101hodogaya.kanagawa.ocn.ne.jp)
2021-09-17 13:49:01 +0200jinsun(~quassel@user/jinsun) (Read error: Connection reset by peer)
2021-09-17 13:49:49 +0200benin036932301(~benin@183.82.205.89) (Ping timeout: 252 seconds)
2021-09-17 13:50:31 +0200jinsun(~quassel@user/jinsun)
2021-09-17 13:53:13 +0200Phantastes(~Phantaste@c-67-173-229-120.hsd1.co.comcast.net)
2021-09-17 13:54:36 +0200vpan(~vilius@212.117.1.172) (Quit: Leaving.)
2021-09-17 13:59:52 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-09-17 14:00:35 +0200jonathanx(~jonathan@dyn-8-sc.cdg.chalmers.se) (Remote host closed the connection)
2021-09-17 14:00:42 +0200__monty__(~toonn@user/toonn) (Ping timeout: 260 seconds)
2021-09-17 14:00:53 +0200jonathanx(~jonathan@dyn-8-sc.cdg.chalmers.se)
2021-09-17 14:02:58 +0200max22-(~maxime@2a01cb0883359800999b760ae95fc90b.ipv6.abo.wanadoo.fr) (Ping timeout: 268 seconds)
2021-09-17 14:09:16 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2021-09-17 14:09:55 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-17 14:12:51 +0200shapr(~user@pool-100-36-247-68.washdc.fios.verizon.net)
2021-09-17 14:16:10 +0200vysn(~vysn@user/vysn) (Ping timeout: 240 seconds)
2021-09-17 14:19:22 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-09-17 14:21:41 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Ping timeout: 268 seconds)
2021-09-17 14:22:48 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd)
2021-09-17 14:27:51 +0200dsrt^(~dsrt@68.101.54.227) (Ping timeout: 268 seconds)
2021-09-17 14:29:05 +0200yaroot(~yaroot@6.3.30.125.dy.iij4u.or.jp) (Quit: The Lounge - https://thelounge.chat)
2021-09-17 14:29:58 +0200yaroot(~yaroot@6.3.30.125.dy.iij4u.or.jp)
2021-09-17 14:31:01 +0200dsrt^(~dsrt@68.101.54.227)
2021-09-17 14:31:15 +0200dsrt^(~dsrt@68.101.54.227) (Remote host closed the connection)
2021-09-17 14:37:25 +0200__monty__(~toonn@user/toonn)
2021-09-17 14:38:21 +0200 <ProofTechnique> maerwald: (on microservices) I'm working on exactly such a platform right now, and I've set it as a team principle that all our services are just libraries with a thin executable wrapper that depends on the library. I don't want our business logic to ever understand anything about the system, it just needs to transform data
2021-09-17 14:38:58 +0200 <maerwald> ProofTechnique: why do you have microservices in the first place?
2021-09-17 14:39:39 +0200 <ProofTechnique> Because an architect said so, and because we need to replace the tangled Groovy monolith we're currently using :D
2021-09-17 14:39:52 +0200 <maerwald> sounds like a poor choice then
2021-09-17 14:41:13 +0200 <ProofTechnique> The main nice thing is that it's a lot easier to onboard _other people's_ services. As long as they can read the auth headers we decorate requests with, they can ignore authn/authz logic in their own code
2021-09-17 14:42:01 +0200kimjetwav(~user@2607:fea8:235f:9730:162d:fa69:3f15:a6a5) (Remote host closed the connection)
2021-09-17 14:42:37 +0200 <ProofTechnique> As compared to "make someone unfamiliar with the monolith hack their new functionality into it and make the trashball worse"
2021-09-17 14:42:52 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net)
2021-09-17 14:43:26 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-09-17 14:44:17 +0200 <ProofTechnique> And it has been significantly easier to get an active-active configuration working consistently across our environments without a bunch of bookkeeping
2021-09-17 14:47:07 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net) (Ping timeout: 245 seconds)
2021-09-17 14:47:20 +0200 <ProofTechnique> In good news, if we ever need to collapse down some of the services into beefier ones, it's just shuffling library imports :)
2021-09-17 14:48:01 +0200 <dminuoso> Microservices is that other thing that people adopt for no good reason, and later dont even realize that they're regretting it..
2021-09-17 14:48:28 +0200 <dminuoso> While most of the hype has passed, it's still a very popular practice.
2021-09-17 14:49:19 +0200 <kuribas> people knowing what to regret would be an advancement for many teams :)
2021-09-17 14:49:33 +0200 <ProofTechnique> I'm being a little facetious, we do have good reasons (that are very boring), I just like to blame the architect because their initial recommendation was "just do it as a bunch of lambdas" :D
2021-09-17 14:49:58 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr)
2021-09-17 14:50:33 +0200 <kuribas> ProofTechnique: if the services are just libraries, then why not pack it into a single executable?
2021-09-17 14:51:11 +0200 <ldlework> dminuoso: I have found that microservice regret is a function of a team's infrastructure/orchestration prowess.
2021-09-17 14:51:55 +0200 <dminuoso> ldlework: And what kind of function is that?
2021-09-17 14:52:57 +0200 <ldlework> It's just to say, that the more handedness (in knowledge or automation) in orchestration, the less associated pain with microservices there is.
2021-09-17 14:53:27 +0200 <ldlework> Developers seem fine making services and making them use each other's APIs. It's the operational complexity that usually degrades returns (in my experience).
2021-09-17 14:53:42 +0200max22-(~maxime@2a01cb0883359800445667b961f4f8f5.ipv6.abo.wanadoo.fr)
2021-09-17 14:53:45 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 268 seconds)
2021-09-17 14:53:56 +0200 <dminuoso> ldlework: that's a myth. some of the biggest issues of microservices dont relate to orchestration.
2021-09-17 14:54:29 +0200 <ldlework> OK, maybe you have some research paper, I only have a couple decades of experience to go off.
2021-09-17 14:54:34 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 14:54:37 +0200 <ProofTechnique> Multiple languages across teams, multiple on-prem and cloud resources that need consistent access patterns, and we don't have any dedicated ops people since I shifted into product development :D
2021-09-17 14:54:58 +0200 <dminuoso> Not sure what that snarky comment was supposed to convey, but okay.
2021-09-17 14:55:18 +0200 <ldlework> dminuoso: not sure what an offhanded rejection of someone else's premise as "myth" was supposed to convey, but okay.
2021-09-17 14:55:28 +0200 <ProofTechnique> And there's just decades of legacy that needs to be enclosed so that we don't have to think so damn hard about it just to barf JSON at each other all over the place
2021-09-17 14:56:18 +0200 <ProofTechnique> At the end of the day, it's not my money, so I just write good software and automation and don't worry too much about how it actually gets run
2021-09-17 14:58:03 +0200 <kuribas> I think service architecture is good, but you want to maximise service size, not minimize it.
2021-09-17 14:58:38 +0200 <kuribas> Unless you have needs that *require* it.
2021-09-17 14:58:47 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 245 seconds)
2021-09-17 14:59:07 +0200 <maerwald> ProofTechnique: there are very few reasons for microservices, technically
2021-09-17 14:59:21 +0200 <maerwald> all of them have nothing to do with architecture
2021-09-17 14:59:59 +0200 <maerwald> I know of only 2 good ones: 1. you need to scale microservices differently (e.g. one needs more CPU, the other ram, the other better latency, ...)
2021-09-17 15:00:34 +0200pbrisbin(~patrick@pool-173-49-147-250.phlapa.fios.verizon.net)
2021-09-17 15:00:42 +0200 <maerwald> 2. someone wants to verify your microservice formally/semi-formally (happens in online casino business for the RNG... it has to be a microservice)
2021-09-17 15:01:28 +0200 <ProofTechnique> We do need to scale them differently, so box ticked :)
2021-09-17 15:02:12 +0200 <dminuoso> Microservices are usually not a technical solution to a problem, but an emergent cultural phenomenon in companies.
2021-09-17 15:02:29 +0200 <dminuoso> They tend to be modelled after the organization
2021-09-17 15:02:55 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 15:03:59 +0200 <ldlework> There's different ways of looking at things depending on what you are aiming to optimize for. In the reductio of optimizing for scaling, you'd segregate your overall system specficially by utilization. But concerns abound you end up balancing what you're optimizing for. Microservices sounds like a paradigm in which you blindly optimize for concerns that demand microserivces, but really it is the
2021-09-17 15:04:01 +0200 <ldlework> study of small unit services so there is something known to say in cases in which small services are the answer to the optimizations you're looking for.
2021-09-17 15:04:09 +0200 <kuribas> we rejected some candidates because in the interview they asked us why we didn't grow with the time, and used cubernetes :)
2021-09-17 15:04:27 +0200 <maerwald> dminuoso: true, someone once said the architecture is merely a reflection of the communication
2021-09-17 15:04:36 +0200 <kuribas> We use decade old unix technology, and it still works fine :)
2021-09-17 15:04:56 +0200 <gehmehgeh> kuribas: I'm looking for job, can I apply? :D
2021-09-17 15:05:08 +0200 <dminuoso> maerwald: And there's a lot of merit in it with microservices. Each team can monitor its own services, responsible for their deployment, alerting, defined interfaces, etc.
2021-09-17 15:05:22 +0200 <dminuoso> But then again, this can as easily happen inside a given program
2021-09-17 15:05:26 +0200 <ProofTechnique> For my part, if we didn't do it this way then I wouldn't be able to write services in Haskell :D
2021-09-17 15:05:29 +0200 <maerwald> dminuoso: yeah... and deployment is SO MUCH FUN
2021-09-17 15:05:30 +0200 <dminuoso> Where you have some defined module structure how some other part will interface.
2021-09-17 15:05:38 +0200 <ldlework> ProofTechnique: heh
2021-09-17 15:05:40 +0200 <maerwald> because suddenly the entire armada of microservices need to be in sync
2021-09-17 15:05:41 +0200 <kuribas> gehmehgeh: well, currently we don't need backend developers, only a senior devops guy.
2021-09-17 15:05:43 +0200 <maerwald> BOOM
2021-09-17 15:05:54 +0200 <ldlework> > function of orchestration prowess
2021-09-17 15:05:56 +0200 <lambdabot> <hint>:1:10: error: parse error on input ‘of’
2021-09-17 15:05:57 +0200ldleworkshrugs
2021-09-17 15:05:59 +0200acidjnk(~acidjnk@p200300d0c703cb83089449f0c9186ff3.dip0.t-ipconnect.de)
2021-09-17 15:06:01 +0200cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.2.1)
2021-09-17 15:06:05 +0200 <maerwald> then you end up doing multi-stage deployments and all sorts of things
2021-09-17 15:06:10 +0200 <dminuoso> ldlework: At what benefit, though?
2021-09-17 15:06:17 +0200 <kuribas> gehmehgeh: and a junior one.
2021-09-17 15:06:22 +0200 <dminuoso> You drive up complexity, introduce additional angles in which the entirety of your service can fail..
2021-09-17 15:06:26 +0200 <ldlework> I feel like I just gave a generalized principle for understanding that
2021-09-17 15:06:49 +0200 <dminuoso> Optimizing for scaling is a problem most software applications dont have.
2021-09-17 15:06:55 +0200 <ldlework> Yes, if you have priorities, you will have to pay for them with costs elsewhere.
2021-09-17 15:07:34 +0200 <kuribas> well, scaling on a single system is good enough for most applications.
2021-09-17 15:08:07 +0200mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net) (Quit: ZNC 1.8.2 - https://znc.in)
2021-09-17 15:08:22 +0200 <ldlework> Again, treating microservices as a dogmatic paradigm where all you are allowed to do is make microservices, rather than a series of worked out ideas for working with unit services when you happen to need them is a mistake.
2021-09-17 15:09:22 +0200 <maerwald> and there go 80% of your Go programming opportunities :D
2021-09-17 15:09:31 +0200 <ProofTechnique> lol
2021-09-17 15:09:32 +0200mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net)
2021-09-17 15:09:33 +0200 <kuribas> I read about this haskell company that migrated the code from distributed scala running on a several nodes, to a single haskell node, and they saw an *improvement* in performance.
2021-09-17 15:09:54 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-09-17 15:09:55 +0200 <ldlework> maerwald: heh yeah, that's not to say some people arnt out there treating it like a paradigm
2021-09-17 15:10:08 +0200 <maerwald> like scrum
2021-09-17 15:10:13 +0200 <maerwald> imagine you do both
2021-09-17 15:10:18 +0200 <maerwald> microservices and scrum
2021-09-17 15:10:58 +0200 <ProofTechnique> .oO(I don't have to imagine)
2021-09-17 15:10:59 +0200 <dminuoso> We have one microservice oriented stack here, but that's done because this particular stack interfaces with at least three separate network regions, and we want high fault taulerance against network failures. So we split it up to have locally running service that could provide local services while the network was down.
2021-09-17 15:11:11 +0200 <dminuoso> Not done out of any religion or scaling, but just out of a strict technical requirement.
2021-09-17 15:11:31 +0200 <ldlework> kuribas: sure, horizontal scaling isn't some universal optimization
2021-09-17 15:13:24 +0200fresheyeball(~fresheyeb@c-71-237-105-37.hsd1.co.comcast.net)
2021-09-17 15:14:59 +0200 <ldlework> JS is adding a pipeline operator to the language
2021-09-17 15:15:15 +0200 <sshine> besides ->? :-P
2021-09-17 15:15:24 +0200 <ldlework> |>
2021-09-17 15:15:32 +0200 <sshine> JS#
2021-09-17 15:15:37 +0200 <ldlework> actually
2021-09-17 15:15:42 +0200 <ldlework> instead of F# semantics
2021-09-17 15:15:48 +0200 <ldlework> where it just applies a value
2021-09-17 15:15:56 +0200 <ldlework> they are going with a whacky expression based one
2021-09-17 15:16:00 +0200 <ldlework> where the lhs is bound to ^
2021-09-17 15:16:03 +0200 <ProofTechnique> We have a couple of tiny glue services that didn't really "fit" anywhere else and basically just amount to slightly fancy proxies around garbage legacy systems that we want to quarantine, but the majority are mid-to-large size units that don't logically share any functionality beyond "reads our auth headers". I expect things will evolve over time and we'll coalesce things as we observe more of how everything actually interacts
2021-09-17 15:16:07 +0200 <ldlework> so you can do things with it
2021-09-17 15:16:38 +0200jtomas(~jtomas@95.red-88-11-64.dynamicip.rima-tde.net) (Remote host closed the connection)
2021-09-17 15:17:01 +0200jtomas(~jtomas@95.red-88-11-64.dynamicip.rima-tde.net)
2021-09-17 15:17:11 +0200 <ldlework> ProofTechnique: this conversation reminds me of some funny video about microservices where a developer is trying to explain to a product manager how some change is no small ask
2021-09-17 15:17:30 +0200 <ldlework> https://www.youtube.com/watch?v=y8OnoxKotPQ
2021-09-17 15:18:04 +0200 <ProofTechnique> I love that video :D
2021-09-17 15:18:19 +0200 <ldlework> cracks me up everytime
2021-09-17 15:20:06 +0200 <ldlework> "you think you know what it takes to tell the user their birthday... you know nothing!!"
2021-09-17 15:20:19 +0200 <ProofTechnique> When someone started drawing a diagram to explain a new service they wanted to onboard, I stopped them right there and said "okay, but why does this need to be five moving pieces instead of one?" and now they've rewritten it to just run in a container. A logical unit of work should not require a chain of 3 lambdas and an API gateway just to puke JSON
2021-09-17 15:20:39 +0200 <ProofTechnique> (And now they get multi-region deploys for free, just because I'm nice)
2021-09-17 15:22:37 +0200xsperry(~as@user/xsperry) (Ping timeout: 252 seconds)
2021-09-17 15:23:46 +0200 <ldlework> ProofTechnique: it's possible to get to the point where a collection of containers, at the level of analysis relevant to ops, is a single logical unit.
2021-09-17 15:24:41 +0200 <ldlework> (or a collection of AWS CF artifacts, or whatever else)
2021-09-17 15:26:22 +0200 <ProofTechnique> If you knew this team, you would not give the benefit of the doubt :D
2021-09-17 15:27:28 +0200 <ProofTechnique> (Also AWS API Gateways have _no_ good story for multi-region other than "just deploy a second one, lol", so that was a big operational no)
2021-09-17 15:28:09 +0200xsperry(~as@user/xsperry)
2021-09-17 15:29:26 +0200pavonia(~user@user/siracusa) (Quit: Bye!)
2021-09-17 15:31:20 +0200fresheyeball(~fresheyeb@c-71-237-105-37.hsd1.co.comcast.net) (Quit: WeeChat 2.9)
2021-09-17 15:32:25 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net)
2021-09-17 15:33:13 +0200favonia(~favonia@user/favonia) (Ping timeout: 265 seconds)
2021-09-17 15:35:16 +0200ubert(~Thunderbi@178.115.60.138.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2021-09-17 15:35:16 +0200ububert
2021-09-17 15:36:00 +0200ubert1(~Thunderbi@178.115.60.138.wireless.dyn.drei.com)
2021-09-17 15:37:30 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168)
2021-09-17 15:41:54 +0200byorgey(~byorgey@155.138.238.211) (Quit: leaving)
2021-09-17 15:41:58 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168) (Ping timeout: 260 seconds)
2021-09-17 15:43:36 +0200machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-09-17 15:44:31 +0200Sgeo(~Sgeo@user/sgeo)
2021-09-17 15:48:28 +0200xsperry(~as@user/xsperry) (Ping timeout: 252 seconds)
2021-09-17 15:51:38 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-09-17 15:56:16 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net) (Remote host closed the connection)
2021-09-17 15:57:20 +0200kimjetwav(~user@2607:fea8:235f:9730:162d:fa69:3f15:a6a5)
2021-09-17 15:58:22 +0200lbseale_(~lbseale@user/ep1ctetus) (Ping timeout: 252 seconds)
2021-09-17 15:58:52 +0200burnside_(~burnsides@dhcp168-024.wadham.ox.ac.uk) (Remote host closed the connection)
2021-09-17 15:59:21 +0200burnsidesLlama(~burnsides@dhcp168-024.wadham.ox.ac.uk)
2021-09-17 16:02:10 +0200ub(~Thunderbi@178.115.57.167.wireless.dyn.drei.com)
2021-09-17 16:02:49 +0200xsperry(~as@user/xsperry)
2021-09-17 16:03:26 +0200ubert(~Thunderbi@178.115.60.138.wireless.dyn.drei.com) (Ping timeout: 260 seconds)
2021-09-17 16:03:26 +0200ububert
2021-09-17 16:03:52 +0200burnsidesLlama(~burnsides@dhcp168-024.wadham.ox.ac.uk) (Ping timeout: 252 seconds)
2021-09-17 16:03:54 +0200ubert1(~Thunderbi@178.115.60.138.wireless.dyn.drei.com) (Ping timeout: 260 seconds)
2021-09-17 16:03:56 +0200hiruji(~hiruji@user/hiruji)
2021-09-17 16:04:09 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-17 16:04:09 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-17 16:04:09 +0200wroathe(~wroathe@user/wroathe)
2021-09-17 16:04:32 +0200hiruji(~hiruji@user/hiruji) (Client Quit)
2021-09-17 16:04:43 +0200lbseale_(~lbseale@user/ep1ctetus)
2021-09-17 16:05:28 +0200shriekingnoise(~shrieking@186.137.144.80)
2021-09-17 16:05:40 +0200alx741(~alx741@181.196.68.9) (Ping timeout: 260 seconds)
2021-09-17 16:06:17 +0200slowButPresent(~slowButPr@user/slowbutpresent)
2021-09-17 16:10:25 +0200favonia(~favonia@user/favonia)
2021-09-17 16:11:39 +0200gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2021-09-17 16:13:05 +0200fef(~thedawn@user/thedawn) (Quit: Leaving)
2021-09-17 16:13:07 +0200Phantastes(~Phantaste@c-67-173-229-120.hsd1.co.comcast.net) (Quit: Client closed)
2021-09-17 16:14:08 +0200Phantastes(~Phantaste@c-67-173-229-120.hsd1.co.comcast.net)
2021-09-17 16:18:04 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr) (Remote host closed the connection)
2021-09-17 16:18:24 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr)
2021-09-17 16:18:24 +0200alx741(~alx741@186.178.108.187)
2021-09-17 16:24:40 +0200zebrag(~chris@user/zebrag)
2021-09-17 16:25:57 +0200cawfee(~root@2406:3003:2077:2758::babe) (Quit: WeeChat 3.2.1)
2021-09-17 16:27:34 +0200hiruji(~hiruji@user/hiruji)
2021-09-17 16:27:43 +0200 <ldlework> :O http://lambdacube3d.com/editor.html
2021-09-17 16:31:07 +0200kenran(~kenran@b2b-37-24-119-190.unitymedia.biz) (Quit: WeeChat info:version)
2021-09-17 16:31:29 +0200burnsidesLlama(~burnsides@dhcp168-024.wadham.ox.ac.uk)
2021-09-17 16:35:55 +0200burnsidesLlama(~burnsides@dhcp168-024.wadham.ox.ac.uk) (Ping timeout: 252 seconds)
2021-09-17 16:36:02 +0200bontaq(~user@ool-45779fe5.dyn.optonline.net)
2021-09-17 16:36:48 +0200doyougnu(~user@c-73-25-202-122.hsd1.or.comcast.net)
2021-09-17 16:37:08 +0200hiruji(~hiruji@user/hiruji) (Quit: ZNC 1.8.2 - https://znc.in)
2021-09-17 16:37:44 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net)
2021-09-17 16:38:34 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr) (Remote host closed the connection)
2021-09-17 16:38:41 +0200 <ldlework> ProofTechnique: https://hydra.nixos.org/job/nixpkgs/trunk/haskellPackages.lambdacube-engine.x86_64-linux/all
2021-09-17 16:38:53 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr)
2021-09-17 16:39:49 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-17 16:42:22 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net) (Ping timeout: 252 seconds)
2021-09-17 16:45:01 +0200jess(~jess@libera/staff/jess)
2021-09-17 16:46:41 +0200tdammers(~tdammers@77.109.72.177.res.static.edpnet.net) (Ping timeout: 265 seconds)
2021-09-17 16:50:00 +0200hnOsmium0001(uid453710@id-453710.hampstead.irccloud.com)
2021-09-17 16:51:22 +0200hiruji(~hiruji@user/hiruji)
2021-09-17 16:55:31 +0200mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2021-09-17 16:57:16 +0200jstolarek(~jstolarek@ers4.neoplus.adsl.tpnet.pl) (Ping timeout: 252 seconds)
2021-09-17 17:01:59 +0200celeste(~celeste@wsip-70-182-89-66.ok.ok.cox.net)
2021-09-17 17:02:08 +0200celeste__celeste
2021-09-17 17:03:33 +0200dyeplexer(~dyeplexer@user/dyeplexer)
2021-09-17 17:04:40 +0200tommd(~tommd@75-164-130-101.ptld.qwest.net)
2021-09-17 17:05:04 +0200p_____(~dyeplexer@user/dyeplexer)
2021-09-17 17:05:12 +0200p_____(~dyeplexer@user/dyeplexer) (Remote host closed the connection)
2021-09-17 17:05:58 +0200lavaman(~lavaman@98.38.249.169)
2021-09-17 17:07:34 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:a20c:3ab6:8175:e3ff) (Quit: WeeChat 2.8)
2021-09-17 17:07:54 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2021-09-17 17:10:10 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 240 seconds)
2021-09-17 17:12:06 +0200benin036932301(~benin@183.82.205.89)
2021-09-17 17:12:29 +0200zmt00(~zmt00@user/zmt00)
2021-09-17 17:13:11 +0200vaucouleur(~vaucouleu@176.124.42.130) (Read error: Connection reset by peer)
2021-09-17 17:17:07 +0200benin036932301(~benin@183.82.205.89) (Ping timeout: 245 seconds)
2021-09-17 17:19:42 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net)
2021-09-17 17:23:38 +0200cawfee(~root@2406:3003:2077:2758::babe)
2021-09-17 17:28:37 +0200yauhsien_(~yauhsien@118-167-49-246.dynamic-ip.hinet.net)
2021-09-17 17:28:37 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net) (Read error: Connection reset by peer)
2021-09-17 17:30:25 +0200tdammers(~tdammers@77.109.72.177.res.static.edpnet.net)
2021-09-17 17:34:37 +0200yauhsien_(~yauhsien@118-167-49-246.dynamic-ip.hinet.net) (Ping timeout: 252 seconds)
2021-09-17 17:34:55 +0200xff0x(~xff0x@2001:1a81:52ad:c900:b704:3c1b:6bea:6e62) (Ping timeout: 260 seconds)
2021-09-17 17:35:34 +0200mortemeur(~mortemeur@pool-173-76-107-201.bstnma.fios.verizon.net)
2021-09-17 17:36:25 +0200 <monochrom> On haskell-cafe, I think I lost my respect for Michael Turner when he reported that he didn't understand "(TTree -> TTree -> Tree) -> TTree -> TTree -> [TTree]", he only understood it after using a type alias for the "(TTree -> TTree -> Tree)".
2021-09-17 17:37:51 +0200 <Hecate> I am resisting from posting on this thread
2021-09-17 17:37:54 +0200 <Hecate> this is a hell thread
2021-09-17 17:37:59 +0200slack1256(~slack1256@static-132-147-34-179.fl.cpe.atlanticbb.net)
2021-09-17 17:38:10 +0200 <monochrom> I can respect using a few type aliases or defining a few component types in a very much more complex scenerio, but this is not one of the complex scenerios at all.
2021-09-17 17:38:19 +0200 <geekosaur> AntC isn't exactly helping
2021-09-17 17:38:25 +0200vysn(~vysn@user/vysn)
2021-09-17 17:38:56 +0200__celeste(~celeste@wsip-70-182-89-66.ok.ok.cox.net) (Remote host closed the connection)
2021-09-17 17:39:04 +0200 <slack1256> On emacs + LSP, what is the M-x command name for searching a project for calls to a specific function? Currently I am using grep/ag but maybe LSP does that too?
2021-09-17 17:39:04 +0200 <monochrom> On top of that, can you guess the name Turner chose for (TTree -> TTree -> Tree)? It's "Order". I have no idea why "order" makes sense for that.
2021-09-17 17:39:13 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168)
2021-09-17 17:39:19 +0200__celeste(~celeste@wsip-70-182-89-66.ok.ok.cox.net)
2021-09-17 17:39:43 +0200 <Clint> fascinating
2021-09-17 17:40:13 +0200 <Hecate> again, this is a hell thread
2021-09-17 17:40:14 +0200 <Hecate> do not post
2021-09-17 17:40:18 +0200 <Hecate> do not read
2021-09-17 17:40:22 +0200__celeste(~celeste@wsip-70-182-89-66.ok.ok.cox.net) (Remote host closed the connection)
2021-09-17 17:40:45 +0200__celeste(~celeste@wsip-70-182-89-66.ok.ok.cox.net)
2021-09-17 17:40:49 +0200dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be) (Quit: WeeChat 3.2)
2021-09-17 17:41:20 +0200 <monochrom> Turner asks "am I translating Haskell to C/C++"? My heart say yes, you're translating to the C/C++ culture, in which people feel that every function parameter type "needs" a typedef.
2021-09-17 17:41:44 +0200xff0x(~xff0x@2001:1a81:52ad:c900:b704:3c1b:6bea:6e62)
2021-09-17 17:43:26 +0200 <monochrom> I would have lost less respect if he chose a more apt name, e.g., along the line of "TTreeCombiner". At least that's closer to the nature of TTree -> TTree -> Tree.
2021-09-17 17:43:46 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168) (Ping timeout: 260 seconds)
2021-09-17 17:45:03 +0200 <janus> what is a hell thread? urban dictionary gives a definition that doesn't make sense
2021-09-17 17:45:21 +0200 <monochrom> "Order" is a very unhelpful name for that one, in fact very misleading, we say that "less than", "greater than or equal to" are "orders", not this.
2021-09-17 17:45:47 +0200 <monochrom> So much for someone who keep asking for more "plain English" and then goes on to show how broken it is.
2021-09-17 17:46:34 +0200 <monochrom> Oh, I think you have to take apart "hell" and "thread", understand each individually, and then just combine :)
2021-09-17 17:46:39 +0200chele(~chele@user/chele) (Remote host closed the connection)
2021-09-17 17:46:42 +0200 <monochrom> Maybe "thread from hell" helps.
2021-09-17 17:46:55 +0200 <monochrom> or fix the grammar, "hellish thread".
2021-09-17 17:47:02 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net)
2021-09-17 17:47:14 +0200 <janus> ah all right, i was overthinking it
2021-09-17 17:47:35 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 265 seconds)
2021-09-17 17:47:55 +0200 <Hecate> janus: yeah, it's a bad place
2021-09-17 17:48:23 +0200 <monochrom> But yeah I'm not posting.
2021-09-17 17:48:44 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 17:51:02 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168)
2021-09-17 17:51:47 +0200 <monochrom> My other angle is that Kmett started in a similar but worse initial condition too. Decades of C++ before trying Haskell. And he started way earlier, meaning even worse tutorials and books.
2021-09-17 17:52:39 +0200 <monochrom> And yet he went on to understand everything and surpass it. Look at how much category-theoretic libraries he churns out that it is our turn to not understand!
2021-09-17 17:52:59 +0200 <geekosaur> I think comparing most newcomers to Haskell can't very ewll be compared to Kmett, though
2021-09-17 17:53:36 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 268 seconds)
2021-09-17 17:54:07 +0200 <monochrom> You know, I'm very tempted to just plot a line between those two data points and conclude: You need worse tutorials to learn Haskell better.
2021-09-17 17:54:40 +0200 <monochrom> Either that, or conclude that the old, "worse" tutorials such as the Gentle Introduction is actually better.
2021-09-17 17:55:11 +0200 <monochrom> It may be that it is today's hand-holding tutorials that are worse.
2021-09-17 17:55:16 +0200 <ldlework> I really think HFFP is a great way to go for people who have coded for a long time in non-functional languages.
2021-09-17 17:55:21 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 17:55:29 +0200 <ldlework> It felt very much like brick-laying, which is what I appreciate from pedagogy in other domains.
2021-09-17 17:55:46 +0200 <ldlework> It didn't assume I was a category theorist, just someone capable of understanding a new formal system.
2021-09-17 17:56:22 +0200 <monochrom> I think Turner was following and complaining about HFFP when he said "talking down to me". (But I think he will neither confirm nor deny.)
2021-09-17 17:57:05 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net) (Remote host closed the connection)
2021-09-17 17:57:14 +0200 <ldlework> huh, i wonder what passages made him feel that way
2021-09-17 17:57:17 +0200mortemeur(~mortemeur@pool-173-76-107-201.bstnma.fios.verizon.net) (Read error: Connection reset by peer)
2021-09-17 17:57:27 +0200 <monochrom> This is wher AntC may be right, as much as you say that he's unhelpful.
2021-09-17 17:57:39 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net)
2021-09-17 17:57:59 +0200 <ldlework> Even if HFFP is not the best possible articulation of the approach, I think it's pedagogical structure is sound
2021-09-17 17:58:00 +0200 <geekosaur> AntC's main problem is not his understanding but his presentation
2021-09-17 17:58:09 +0200 <monochrom> No, I suspect not about any passage, but the whole plan of "start from square 1".
2021-09-17 17:58:29 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer)
2021-09-17 17:58:58 +0200 <ldlework> it seems contradictory to want an accessible pedagogy but interpret an assumption of nothing as condescension
2021-09-17 17:59:01 +0200nctcf^(~nctcf@68.101.54.227)
2021-09-17 17:59:24 +0200 <monochrom> Right? There are humble, modest people who recognize that they should start from square 1, so they are thankful when you do that to them.
2021-09-17 17:59:28 +0200 <ldlework> I feel for Turner, but am really glad it jived with me.
2021-09-17 17:59:32 +0200 <ldlework> yes!
2021-09-17 17:59:53 +0200 <monochrom> And then there are proud people who deny that they should start from square 1, so they will hate you for doing that to them.
2021-09-17 18:01:10 +0200 <monochrom> Turner did, for multiple times, remind us that he has so many decades of programming experience.
2021-09-17 18:01:18 +0200mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be)
2021-09-17 18:01:23 +0200 <monochrom> I think someone who speaks like that is the proud kind.
2021-09-17 18:01:57 +0200 <janus> someone who has a 12 line signature...
2021-09-17 18:02:03 +0200 <monochrom> And of course, I should remind you that he never actually said it was HFFP, he never said which works he tried.
2021-09-17 18:02:13 +0200 <ldlework> There is this nice video on youtube "Learn Haskell in One Video" and all it does is teach the core ML side of Haskell.
2021-09-17 18:02:49 +0200 <c_wraith> I had about 20 years of experience programming when I first picked up haskell. And it was *hard*, but I loved it. Because I love learning new things.
2021-09-17 18:02:54 +0200 <lbseale_> ldlework: that is a great video
2021-09-17 18:03:05 +0200 <lbseale_> it was my starting point
2021-09-17 18:03:22 +0200benin036932301(~benin@183.82.205.89)
2021-09-17 18:03:26 +0200 <c_wraith> But if you don't come at it as "time to learn something new", it can be really frustrating to be expected to learn something actually new
2021-09-17 18:03:39 +0200lbseale_lbseale
2021-09-17 18:04:18 +0200 <janus> why even try to cater to people with that much experience, they are a tiny part of the market and they are not disadvantaged
2021-09-17 18:04:45 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-09-17 18:04:54 +0200 <ldlework> i actually did try to give haskell a real go in the past a few times, but the jargon made me sleepy. HFFP's introduction with LC made me really get into the mood that I'm just learning a new formal system (pattern matching essentially) and that things like Functors and Monoids are just gonna be some algebraic laws (generic patterns).
2021-09-17 18:05:11 +0200 <monochrom> And here is the thing. Two of his complaints are: "materials that assume I already know much", and "materials that talk down to me". See the paradox there? Even hypocrisy?
2021-09-17 18:05:22 +0200 <ldlework> Then I got over the fact that they have opaque names, and just listened to what the author was telling me they are.
2021-09-17 18:05:37 +0200proofofkeags_(~proofofke@205.209.28.54)
2021-09-17 18:05:56 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net) (Ping timeout: 268 seconds)
2021-09-17 18:06:50 +0200 <monochrom> IMO when someone harps "plain English" so much, this is why. They are expecting the unsolvable, and they just assume that jargon is the problem, "plain English" can solve it.
2021-09-17 18:07:04 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-17 18:07:30 +0200 <ldlework> I think that also, once HFFP got to Semigroups and was like "semigroups are like the generalization of addition" (or something to that effect) I was re-energized again with confidence that the opaque sounding typeclasses were just gonna be some general patterns, where the idea behind it is not all that complicated.
2021-09-17 18:08:10 +0200benin036932301(~benin@183.82.205.89) (Ping timeout: 252 seconds)
2021-09-17 18:08:42 +0200 <ldlework> I was actually excited to know what they were at that point.
2021-09-17 18:09:38 +0200 <janus> think i will write a mail telling Turner that he must read Software Foundations first, since it is the foundation ;)
2021-09-17 18:10:47 +0200 <monochrom> Ugh hahaha but please don't troll him!
2021-09-17 18:11:04 +0200vysn(~vysn@user/vysn) (Ping timeout: 252 seconds)
2021-09-17 18:12:22 +0200rond_(~rond_@2a02:a31a:a23c:f480:2fd7:e087:5546:a438)
2021-09-17 18:13:50 +0200 <janus> wow, Software Foundations has 6 volumes now! amazing
2021-09-17 18:14:05 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-17 18:14:05 +0200 <monochrom> Wait what? Oh noes.
2021-09-17 18:14:16 +0200 <monochrom> Is it competing with HFFP for length?!
2021-09-17 18:15:04 +0200 <monochrom> Maybe I should adopt volume 2 as my textbook and curriculum.
2021-09-17 18:15:47 +0200TPBP(~TPBP@2001:67c:2628:647:12::83)
2021-09-17 18:15:58 +0200 <monochrom> The course is named "principles of programming languages". My long-standing concern is "the class average is too high". I need something to make it harder. >:)
2021-09-17 18:16:12 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168) (Remote host closed the connection)
2021-09-17 18:16:20 +0200 <monochrom> OK, the other long-standing concern is I teach too much Haskell.
2021-09-17 18:16:44 +0200 <monochrom> Well, this solution fixes both!
2021-09-17 18:17:28 +0200 <monochrom> And yeah I haven't harped Hoare triples as an approach to semantics for a long time. Maybe it's time to do it.
2021-09-17 18:17:52 +0200econo(uid147250@user/econo)
2021-09-17 18:18:34 +0200 <monochrom> (Hoare triples are widely harped as one way to prove your program correct, not one way to define what the language means. It can do both, and Hoare certainly proposed both.)
2021-09-17 18:19:38 +0200 <raehik> how do I package some data files (used in hspec tests) with a Stack+Cabal package?
2021-09-17 18:19:43 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-17 18:20:06 +0200 <janus> i certainly would have been happy if i had had a Coq-based course available in uni instead of working with custom tools
2021-09-17 18:20:07 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168)
2021-09-17 18:20:26 +0200 <raehik> I find recommendations for 'extra-source-files: folder/*' but, Stack appears to only allow files. No folders
2021-09-17 18:21:19 +0200chris(~chris@81.96.113.213)
2021-09-17 18:21:23 +0200chrisGuest6232
2021-09-17 18:21:39 +0200 <janus> raehik: ** (double star) wild cards were added in cabal 2.4, are you using a stack based on that?
2021-09-17 18:21:47 +0200 <sm> got a link ?
2021-09-17 18:21:56 +0200 <c_wraith> Hoare triples kind of make it clear how tough it is to program based on mutability.
2021-09-17 18:22:26 +0200 <janus> sm: https://cabal.readthedocs.io/en/3.4/cabal-package.html#pkg-field-data-files
2021-09-17 18:22:29 +0200 <raehik> janus: I'm on Stack 2.7 / Cabal 3.6. I tried double star too on Stack, but it complains still. Cabal might be OK with one or both
2021-09-17 18:22:44 +0200 <sm> that doc is for cabal files, janus
2021-09-17 18:23:06 +0200 <sm> stack files have their own doc
2021-09-17 18:23:15 +0200tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2021-09-17 18:23:37 +0200 <janus> sm: right, but doesn't stack use cabal for lots? i would assume that fields named similarily would have similar underpinnings
2021-09-17 18:24:03 +0200 <sm> ok, if it's actually in your .cabal file you're on the right track. In that case I'd guess your stack needs upgrading
2021-09-17 18:24:18 +0200 <raehik> I was especially confused because I'm using stack to generate my cabal file. And when I tried 'data/*', 'data/**', the generated Cabal file didn't include them
2021-09-17 18:24:43 +0200 <raehik> the Stack side says "nothing found for this entry" and scrubs it from the similarly named Cabal filed
2021-09-17 18:24:48 +0200 <raehik> s/filed/field
2021-09-17 18:26:11 +0200 <raehik> (oops, I've been talking about Stack -- I mean hpack, that uses package.yaml)
2021-09-17 18:26:19 +0200 <sm> hehe
2021-09-17 18:26:36 +0200 <sm> and I've been mixing up raehik and janus
2021-09-17 18:26:46 +0200 <sm> but we'll get there
2021-09-17 18:27:25 +0200 <raehik> sm: hahaha no worries I was following
2021-09-17 18:27:33 +0200 <sm> study the appropriate doc and all will make sense 🤞
2021-09-17 18:28:00 +0200 <c_wraith> yeah, hpack is a totally different thing. It generates cabal files, but that doesn't mean it supports all of cabal's ways of doing things
2021-09-17 18:30:45 +0200chisui(~chisui@200116b8686a18002a976267586344a5.dip.versatel-1u1.de)
2021-09-17 18:32:21 +0200 <raehik> mmmmm sm you were right. it feels silly but I have to do 'extra-source-files: data/**/*' ...
2021-09-17 18:33:06 +0200 <janus> raehik: it is the same in zsh, what did you expect? that ** would also match files?
2021-09-17 18:33:06 +0200 <raehik> but I admit, it's more powerful and only feels silly because my mind has been rotted by poorly defined globbing and regexes
2021-09-17 18:33:20 +0200 <raehik> janus: pretty much yes x)
2021-09-17 18:33:49 +0200 <janus> raehik: they are useful, i'd recommend enabling them in the shell
2021-09-17 18:34:22 +0200 <janus> saves you from using `find -type f -iname '*blabla*'` all over the place
2021-09-17 18:37:44 +0200 <janus> though cabal doesn't support that feature, so maybe it is dangerous of me to compare them...
2021-09-17 18:38:04 +0200 <janus> "** wildcards can only appear as the final path component before the file name (e.g., data/**/images/*.jpg is not allowed). If a ** wildcard is used, then the file name must include a * wildcard (e.g., data/**/README.rst is not allowed)."
2021-09-17 18:39:02 +0200_ht(~quassel@82-169-194-8.biz.kpn.net)
2021-09-17 18:39:10 +0200MQ-17J(~MQ-17J@8.21.10.6)
2021-09-17 18:39:21 +0200 <raehik> meh, the hpack readme defines it well enough
2021-09-17 18:39:38 +0200 <raehik> it was surprising primarily because the same field name is treated differently in hpack & cabal
2021-09-17 18:43:22 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr) (Ping timeout: 252 seconds)
2021-09-17 18:49:19 +0200acidjnk(~acidjnk@p200300d0c703cb83089449f0c9186ff3.dip0.t-ipconnect.de) (Ping timeout: 268 seconds)
2021-09-17 18:49:56 +0200acidjnk(~acidjnk@p200300d0c703cb83089449f0c9186ff3.dip0.t-ipconnect.de)
2021-09-17 18:51:31 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-09-17 18:52:09 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr)
2021-09-17 18:53:48 +0200cheater(~Username@user/cheater) (Ping timeout: 265 seconds)
2021-09-17 18:56:06 +0200Skyfire(~pyon@user/pyon) (Ping timeout: 260 seconds)
2021-09-17 18:57:18 +0200cheater(~Username@user/cheater)
2021-09-17 19:02:08 +0200parafactual(~celeste@wsip-70-182-89-66.ok.ok.cox.net)
2021-09-17 19:02:30 +0200__celeste(~celeste@wsip-70-182-89-66.ok.ok.cox.net) (Ping timeout: 265 seconds)
2021-09-17 19:02:44 +0200rond_(~rond_@2a02:a31a:a23c:f480:2fd7:e087:5546:a438) (Quit: Client closed)
2021-09-17 19:03:31 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr) (Remote host closed the connection)
2021-09-17 19:03:55 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr)
2021-09-17 19:07:26 +0200TPBP(~TPBP@2001:67c:2628:647:12::83) (Quit: Client closed)
2021-09-17 19:09:09 +0200Guest70(~Guest70@p200300f7770495091b8e7aac2bb6dd42.dip0.t-ipconnect.de)
2021-09-17 19:09:46 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-17 19:10:00 +0200Guest70(~Guest70@p200300f7770495091b8e7aac2bb6dd42.dip0.t-ipconnect.de) ()
2021-09-17 19:13:07 +0200chisui(~chisui@200116b8686a18002a976267586344a5.dip.versatel-1u1.de) (Quit: Client closed)
2021-09-17 19:15:15 +0200 <ldlework> Anyone know how to make blank-canvas accept remote traffic?
2021-09-17 19:15:16 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-17 19:16:16 +0200tfeb(~tfb@109.249.185.23)
2021-09-17 19:17:00 +0200Guest6232(~chris@81.96.113.213) (Remote host closed the connection)
2021-09-17 19:18:45 +0200tfebtfb
2021-09-17 19:18:46 +0200 <ldlework> figured it out
2021-09-17 19:22:06 +0200mousey(~sky@gateway/tor-sasl/mousey)
2021-09-17 19:22:40 +0200 <awpr> I would be highly amused if the cellular automata thing turned out to be way faster by sending everything over a socket and rendering with canvas, compared to a natural implementation with Gloss
2021-09-17 19:23:37 +0200 <ldlework> hehe
2021-09-17 19:24:38 +0200tfb(~tfb@109.249.185.23) (Quit: died)
2021-09-17 19:25:49 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-09-17 19:26:55 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr) (Ping timeout: 260 seconds)
2021-09-17 19:27:03 +0200 <ldlework> i feel like i've been teased with haskell GLSL eDSLs lol
2021-09-17 19:28:59 +0200 <ldlework> lambdacube looks like the best one, but it uses a very old haskell and very old dependencies that don't work on Nix anymore
2021-09-17 19:32:34 +0200chris(~chris@81.96.113.213)
2021-09-17 19:32:35 +0200chrisGuest3188
2021-09-17 19:32:48 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168) (Remote host closed the connection)
2021-09-17 19:37:19 +0200Guest3188(~chris@81.96.113.213) (Ping timeout: 252 seconds)
2021-09-17 19:37:21 +0200vicfred(~vicfred@user/vicfred)
2021-09-17 19:38:20 +0200 <cdsmith> How would you feel if a library you wanted to use required a GHC plugin? Asking because I'm thinking of making HMock depend on https://hackage.haskell.org/package/if-instance. It would let me offer both good error messages (if there's a Show instance) and a more general API (by not requiring Show).
2021-09-17 19:39:08 +0200 <dminuoso> Requiring a GHC plugin is an *very* high threshold.
2021-09-17 19:39:35 +0200 <dminuoso> Unless this was crucial to the core functionality of it, I'd stay clear of it.
2021-09-17 19:40:20 +0200 <cdsmith> Yeah. Maybe I can get away with a general API that requires Show and then an alternate package using the plugin
2021-09-17 19:40:52 +0200parafactual(~celeste@wsip-70-182-89-66.ok.ok.cox.net) (Ping timeout: 245 seconds)
2021-09-17 19:41:42 +0200 <cdsmith> This is for the explainable predicates. They are essentially (a -> Bool), except with the ability to explain why or why not. Right now, a lot of them require Show instances on a. I don't like that.
2021-09-17 19:44:19 +0200System123(~System123@net-37-179-171-3.cust.vodafonedsl.it)
2021-09-17 19:51:25 +0200max22-(~maxime@2a01cb0883359800445667b961f4f8f5.ipv6.abo.wanadoo.fr) (Ping timeout: 260 seconds)
2021-09-17 19:54:39 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168)
2021-09-17 20:01:54 +0200justsomeguy(~justsomeg@user/justsomeguy)
2021-09-17 20:02:36 +0200tlaxkit(~hexchat@170.253.35.150)
2021-09-17 20:03:12 +0200_xft0(~jaroslawj@185.234.208.208.r.toneticgroup.pl)
2021-09-17 20:04:55 +0200slack1256(~slack1256@static-132-147-34-179.fl.cpe.atlanticbb.net) (Ping timeout: 252 seconds)
2021-09-17 20:06:14 +0200chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2021-09-17 20:06:22 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168) (Remote host closed the connection)
2021-09-17 20:06:29 +0200chexum(~quassel@gateway/tor-sasl/chexum)
2021-09-17 20:09:26 +0200sneedsfeed(~sneedsfee@rrcs-173-95-122-169.midsouth.biz.rr.com) (Quit: Client closed)
2021-09-17 20:10:50 +0200Phantastes(~Phantaste@c-67-173-229-120.hsd1.co.comcast.net) (Quit: Phantastes)
2021-09-17 20:15:56 +0200parafactual(~celeste@wsip-70-182-89-66.ok.ok.cox.net)
2021-09-17 20:18:58 +0200lavaman(~lavaman@98.38.249.169)
2021-09-17 20:20:56 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168)
2021-09-17 20:23:37 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 252 seconds)
2021-09-17 20:24:04 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2021-09-17 20:26:36 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-17 20:30:16 +0200OutreEE(~OutreEE@modemcable105.60-176-173.mc.videotron.ca)
2021-09-17 20:31:28 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Ping timeout: 268 seconds)
2021-09-17 20:31:28 +0200aji(~alex@prickle.ajitek.net) (Ping timeout: 268 seconds)
2021-09-17 20:31:46 +0200aji(~alex@prickle.ajitek.net)
2021-09-17 20:31:47 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-09-17 20:31:56 +0200Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-09-17 20:32:07 +0200wrengr_away(~wrengr@56.72.82.34.bc.googleusercontent.com) (Remote host closed the connection)
2021-09-17 20:32:50 +0200TranquilEcho(~grom@user/tranquilecho)
2021-09-17 20:34:42 +0200ralu(~ralu@static.211.245.203.116.clients.your-server.de) (Ping timeout: 245 seconds)
2021-09-17 20:34:56 +0200ralu(~ralu@static.211.245.203.116.clients.your-server.de)
2021-09-17 20:37:38 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 268 seconds)
2021-09-17 20:37:38 +0200dyeplexer(~dyeplexer@user/dyeplexer) (Remote host closed the connection)
2021-09-17 20:38:29 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2021-09-17 20:39:07 +0200burnsidesLlama(~burnsides@dhcp168-024.wadham.ox.ac.uk)
2021-09-17 20:40:37 +0200theang(~theang@fef109.internetdsl.tpnet.pl) (Ping timeout: 265 seconds)
2021-09-17 20:40:48 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-17 20:40:48 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-17 20:40:48 +0200wroathe(~wroathe@user/wroathe)
2021-09-17 20:41:06 +0200theang(~theang@2a00:f41:5858:653e:e8e3:df9b:74cb:6565)
2021-09-17 20:41:14 +0200justsomeguy(~justsomeg@user/justsomeguy) (Quit: WeeChat 3.2)
2021-09-17 20:43:20 +0200tlaxkit(~hexchat@170.253.35.150) (Quit: Leaving)
2021-09-17 20:43:52 +0200burnsidesLlama(~burnsides@dhcp168-024.wadham.ox.ac.uk) (Ping timeout: 252 seconds)
2021-09-17 20:45:31 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2021-09-17 20:47:30 +0200Cajun(~Cajun@user/cajun) (Quit: Client closed)
2021-09-17 20:48:15 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net)
2021-09-17 20:50:00 +0200wrengr(~wrengr@136.247.83.34.bc.googleusercontent.com)
2021-09-17 20:52:05 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 260 seconds)
2021-09-17 20:52:56 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-09-17 20:55:20 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-09-17 20:55:24 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 21:00:42 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-09-17 21:02:34 +0200yauhsien(~yauhsien@118-167-49-246.dynamic-ip.hinet.net) (Ping timeout: 252 seconds)
2021-09-17 21:06:50 +0200MQ-17J(~MQ-17J@8.21.10.6) (Ping timeout: 268 seconds)
2021-09-17 21:09:21 +0200MQ-17J(~MQ-17J@8.21.10.6)
2021-09-17 21:12:02 +0200kenran(~kenran@200116b82ba3ca004cc511249199c36d.dip.versatel-1u1.de)
2021-09-17 21:12:43 +0200aegon(~mike@174.127.249.180)
2021-09-17 21:15:07 +0200tlaxkit(~hexchat@170.253.35.150)
2021-09-17 21:20:24 +0200theang(~theang@2a00:f41:5858:653e:e8e3:df9b:74cb:6565) (Ping timeout: 268 seconds)
2021-09-17 21:21:06 +0200theang(~theang@fef109.internetdsl.tpnet.pl)
2021-09-17 21:22:14 +0200tinhatcat(~manjaro-g@2620:103:a000:2201:8e4c:af6a:e11c:11a1)
2021-09-17 21:23:11 +0200oxide(~lambda@user/oxide) (Quit: oxide)
2021-09-17 21:25:07 +0200hyiltiz(~quassel@31.220.5.250) (Ping timeout: 268 seconds)
2021-09-17 21:25:27 +0200hyiltiz(~quassel@31.220.5.250)
2021-09-17 21:27:45 +0200parafactual(~celeste@wsip-70-182-89-66.ok.ok.cox.net) (Remote host closed the connection)
2021-09-17 21:28:30 +0200tinhatcat(~manjaro-g@2620:103:a000:2201:8e4c:af6a:e11c:11a1) (Quit: Leaving)
2021-09-17 21:28:42 +0200 <ProofTechnique> cdsmith: Would IfCxt work for your purposes, or have you been down that road and found it not a good fit (it may also be bit-rotted)?
2021-09-17 21:28:54 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-09-17 21:31:42 +0200wonko(~wjc@62.115.229.50) (Ping timeout: 245 seconds)
2021-09-17 21:34:01 +0200tinhatcat(~manjaro-g@2620:103:a000:2201:8e4c:af6a:e11c:11a1)
2021-09-17 21:36:36 +0200chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2021-09-17 21:37:31 +0200chexum(~quassel@gateway/tor-sasl/chexum)
2021-09-17 21:40:45 +0200 <drewolson> anyone have a good reference project that uses github actions to build a test a stack project, with a cache, and produce artifacts?
2021-09-17 21:49:26 +0200 <sm> there is a better reference project somewhere, but hledger is a battle-tested one
2021-09-17 21:52:16 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168) (Remote host closed the connection)
2021-09-17 21:59:08 +0200 <dsal> drewolson: Do you mean you want downloadable binaries from your project? I do that for docs and stuff, but the binaries don't seem to stick around.
2021-09-17 21:59:17 +0200 <dsal> My github actions push binaries into cachix and I use them from there.
2021-09-17 21:59:28 +0200 <drewolson> yes, i want the most recent build to have a downloadable binary
2021-09-17 21:59:36 +0200 <drewolson> i was able to do this on gitlab with a very simple config
2021-09-17 21:59:43 +0200burnsidesLlama(~burnsides@dhcp168-024.wadham.ox.ac.uk)
2021-09-17 21:59:54 +0200 <maerwald> I use cabal
2021-09-17 22:00:01 +0200 <maerwald> but is pretty much the same
2021-09-17 22:00:04 +0200 <drewolson> https://gist.github.com/drewolson/d052e54c306b6147c5a7f0e0f58cff15
2021-09-17 22:00:42 +0200 <maerwald> https://github.com/hasufell/stack2cabal/blob/master/.github/workflows/release.yaml
2021-09-17 22:00:57 +0200 <dsal> drewolson: This does it: https://github.com/dustin/waitforsocket/blob/master/.github/workflows/haskell.yml
2021-09-17 22:01:03 +0200 <maerwald> this gives you fully static binaries on linux
2021-09-17 22:01:31 +0200 <maerwald> slightly outdated though
2021-09-17 22:01:48 +0200 <maerwald> ghcup is now pre-installed in all environments I think
2021-09-17 22:02:05 +0200 <drewolson> thanks
2021-09-17 22:02:41 +0200 <dsal> I don't actually use these bins, so maerwald's probably produces something more usable. Mine does much less. I primarily just want stuff in cachix and to know if my tests have broken.
2021-09-17 22:07:38 +0200_ht(~quassel@82-169-194-8.biz.kpn.net) (Remote host closed the connection)
2021-09-17 22:07:42 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2021-09-17 22:07:45 +0200_xft0(~jaroslawj@185.234.208.208.r.toneticgroup.pl) (Quit: Lost terminal)
2021-09-17 22:09:07 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Ping timeout: 268 seconds)
2021-09-17 22:10:02 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-17 22:11:00 +0200waleee(~waleee@h-98-128-228-119.NA.cust.bahnhof.se)
2021-09-17 22:20:22 +0200chisui(~chisui@200116b8686a1800fa65b73f3e7c071d.dip.versatel-1u1.de)
2021-09-17 22:22:13 +0200hololeap(~hololeap@user/hololeap)
2021-09-17 22:24:04 +0200bradyt(~bradyt@user/bradyt)
2021-09-17 22:24:20 +0200eggplantade(~Eggplanta@108-201-191-115.lightspeed.sntcca.sbcglobal.net)
2021-09-17 22:26:55 +0200michalz(~michalz@185.246.204.37) (Remote host closed the connection)
2021-09-17 22:27:09 +0200 <bradyt> i hate bash
2021-09-17 22:27:13 +0200 <bradyt> and zsh
2021-09-17 22:28:01 +0200 <bradyt> i want to append to a cli call like 0-4, 5-9, 10-14, 14-19, ...
2021-09-17 22:28:11 +0200 <bradyt> so call the command multiple times
2021-09-17 22:28:25 +0200 <bradyt> maybe passing in other arguments
2021-09-17 22:28:42 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-17 22:28:42 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-17 22:28:42 +0200wroathe(~wroathe@user/wroathe)
2021-09-17 22:29:01 +0200tinhatcat(~manjaro-g@2620:103:a000:2201:8e4c:af6a:e11c:11a1) (Quit: Leaving)
2021-09-17 22:29:06 +0200 <bradyt> seems easier to do with haskell. time to learn some haskell shell thing?
2021-09-17 22:29:22 +0200_xft0(~jaroslawj@185.234.208.208.r.toneticgroup.pl)
2021-09-17 22:29:49 +0200 <geekosaur> maybe. there's several
2021-09-17 22:30:46 +0200 <geekosaur> you have a few options: https://hackage.haskell.org/package/shh - https://hackage.haskell.org/package/shelly - https://hackage.haskell.org/package/turtle - https://hackage.haskell.org/package/shell-conduit
2021-09-17 22:31:04 +0200tlaxkit(~hexchat@170.253.35.150) (Ping timeout: 252 seconds)
2021-09-17 22:31:16 +0200 <bradyt> hmm, how to compare
2021-09-17 22:31:44 +0200 <geekosaur> were it me I'd just do it in shell, but then I've been doing shell since 1981
2021-09-17 22:32:42 +0200 <bradyt> maybe i'll just create a project and hard-code it as a Main.hs
2021-09-17 22:32:56 +0200 <bradyt> probably start with "just do it in haskell"
2021-09-17 22:32:57 +0200mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be) (Ping timeout: 268 seconds)
2021-09-17 22:33:20 +0200 <bradyt> i keep wanting this 0-4, 5-9 thing pretty often
2021-09-17 22:33:37 +0200 <bradyt> and haskell seems like the most pleasant way to do
2021-09-17 22:34:07 +0200 <carbolymer> be prepared for some boilerplate tho
2021-09-17 22:34:17 +0200pavonia(~user@user/siracusa)
2021-09-17 22:34:39 +0200mikoto-chan(~mikoto-ch@83.137.2.246)
2021-09-17 22:37:24 +0200 <bradyt> `main = callCommand "echo hello"` seemed to work
2021-09-17 22:37:46 +0200 <bradyt> M-x compile RET ghc Main.hs && ./Main RET
2021-09-17 22:38:07 +0200 <bradyt> lol, now i have to remember how to write haskell
2021-09-17 22:38:29 +0200epolanski(uid312403@id-312403.helmsley.irccloud.com)
2021-09-17 22:38:33 +0200raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 265 seconds)
2021-09-17 22:38:41 +0200tlaxkit(~hexchat@170.253.35.150)
2021-09-17 22:38:46 +0200 <bradyt> main = do, ... do haust, ...
2021-09-17 22:38:55 +0200Ram-Z(~Ram-Z@li1814-254.members.linode.com) (Quit: ZNC - http://znc.in)
2021-09-17 22:39:35 +0200pbrisbin(~patrick@pool-173-49-147-250.phlapa.fios.verizon.net) (Quit: WeeChat 3.2)
2021-09-17 22:39:46 +0200 <geekosaur> "hast". unless it's "haßt"
2021-09-17 22:39:59 +0200 <geekosaur> they were deliberately ambiguous
2021-09-17 22:41:10 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 260 seconds)
2021-09-17 22:42:11 +0200Ram-Z(Ram-Z@2a01:7e01::f03c:91ff:fe57:d2df)
2021-09-17 22:44:16 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 268 seconds)
2021-09-17 22:44:58 +0200System12_(~System123@ec2-52-61-197-79.us-gov-west-1.compute.amazonaws.com)
2021-09-17 22:45:48 +0200justsomeguy(~justsomeg@user/justsomeguy)
2021-09-17 22:47:19 +0200tlaxkit(~hexchat@170.253.35.150) (Quit: Leaving)
2021-09-17 22:48:40 +0200System123(~System123@net-37-179-171-3.cust.vodafonedsl.it) (Ping timeout: 252 seconds)
2021-09-17 22:49:21 +0200eggplantade(~Eggplanta@108-201-191-115.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2021-09-17 22:51:51 +0200Cajun(~Cajun@user/cajun)
2021-09-17 22:53:00 +0200 <dibblego> funny, I typically start with shell, then regret it, and go to .hs — and I am there right now
2021-09-17 22:53:56 +0200kuribas(~user@ptr-25vy0i7x8rtrl519tor.18120a2.ip6.access.telenet.be) (Remote host closed the connection)
2021-09-17 22:55:42 +0200fendor_(~fendor@78-2-181-45.adsl.net.t-com.hr)
2021-09-17 22:56:21 +0200kenran(~kenran@200116b82ba3ca004cc511249199c36d.dip.versatel-1u1.de) (Quit: WeeChat info:version)
2021-09-17 22:57:34 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-09-17 22:57:35 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-09-17 22:57:35 +0200wroathe(~wroathe@user/wroathe)
2021-09-17 23:00:35 +0200lavaman(~lavaman@98.38.249.169)
2021-09-17 23:01:38 +0200 <sm> sadly I often start with hs, then regret it and go to bash
2021-09-17 23:02:14 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 265 seconds)
2021-09-17 23:02:18 +0200 <sm> of the haskell shell things, don't miss the one in Shake (cmd), it's excellent and you also have shake's dependency engine there if needed
2021-09-17 23:02:48 +0200 <sm> also, is oil shell usable yet ?
2021-09-17 23:02:55 +0200 <monochrom> OK so I finally broke my oath and posted to the hell thread.
2021-09-17 23:03:02 +0200vysn(~vysn@user/vysn)
2021-09-17 23:03:07 +0200 <geekosaur> I generally have a pretty good idea of which language fits best beforehand these days. of course it's taken me decades to develop that to the point where I don't find myself switching languages mid-project
2021-09-17 23:03:19 +0200 <monochrom> But it is only because to put the "some people are visual learners" myth to death. Cf https://www.youtube.com/watch?v=rhgwIhB58PA
2021-09-17 23:03:28 +0200awprfetches popcorn to read the hell thread
2021-09-17 23:03:36 +0200 <sm> also bradyt, python ? I found it best recently for something where neither bash nor hs was a fit
2021-09-17 23:04:00 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 268 seconds)
2021-09-17 23:04:19 +0200 <monochrom> That's all. I am not a conservative who says "the status quo is just fine". :)
2021-09-17 23:04:32 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2021-09-17 23:04:48 +0200notzmv(~zmv@user/notzmv)
2021-09-17 23:05:05 +0200 <geekosaur> I'm also prone to use perl still but that's the price of being an Olde Phart :þ
2021-09-17 23:05:32 +0200 <geekosaur> (and I still don't like python much)
2021-09-17 23:06:59 +0200 <sm> I like the sound of the starlark variant. No good for system scripting though
2021-09-17 23:13:16 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-17 23:14:36 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168)
2021-09-17 23:14:49 +0200 <awpr> I released a library last night with automatic deriving of pretty Haskell-value-syntax printing of any Generics-compatible type, incl. configurable syntax highlighting, optional unicode escaping, and smart line wrapping of long strings -- see https://hackage.haskell.org/package/portray-prettyprinter and https://hackage.haskell.org/package/portray
2021-09-17 23:15:43 +0200geekosaurwonders suddenly where hackagebot ended up after we left freenode
2021-09-17 23:17:58 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-09-17 23:18:40 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168) (Ping timeout: 240 seconds)
2021-09-17 23:20:24 +0200zfnmxt(~zfnmxtzfn@2001:470:69fc:105::2b32) (Changing host)
2021-09-17 23:20:24 +0200zfnmxt(~zfnmxtzfn@user/zfnmxt)
2021-09-17 23:23:14 +0200jtomas(~jtomas@95.red-88-11-64.dynamicip.rima-tde.net) (Remote host closed the connection)
2021-09-17 23:23:28 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Excess Flood)
2021-09-17 23:23:31 +0200jtomas(~jtomas@95.red-88-11-64.dynamicip.rima-tde.net)
2021-09-17 23:23:38 +0200 <awpr> oh right, and automatically-derived structural diffs for better comparisons in tests, in `portray-diff`
2021-09-17 23:23:46 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2021-09-17 23:24:17 +0200 <carbolymer> monochrom: which thread?
2021-09-17 23:24:36 +0200 <Boarders> could someone tell me how to rely on a particular version of a library from github with cabal? Thanks!
2021-09-17 23:24:51 +0200 <sclv> trying to understand the doctest ecosystem and i'm curious -- why do doctest runners prefer to use ghci instead of just emitting a proper executable to be run?
2021-09-17 23:24:54 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:3440:f429:80f2:b168)
2021-09-17 23:24:56 +0200 <sclv> is there any special reason?
2021-09-17 23:25:05 +0200 <carbolymer> dibblego: yeah, that what I usually do, then I look at the monster that came out from rewriting shell into haskell and I'm not sure that was the best way
2021-09-17 23:25:28 +0200 <monochrom> The one that started as "Haskell's "historical futurism" needs better writing, not better tools" but now the subject line has mutated to several different variants.
2021-09-17 23:25:32 +0200fiddlerwoaroof(~fiddlerwo@user/fiddlerwoaroof) (Ping timeout: 245 seconds)
2021-09-17 23:25:45 +0200 <sclv> context: i'm working on cabal's doctest support and it seems like a huge amount of the weird irritating complexity of doctest systems all stems from this choice to run doctests interactively
2021-09-17 23:25:53 +0200 <monochrom> Or more simply, look for Michael Turner (original poster) :)
2021-09-17 23:26:11 +0200 <sclv> michael turner is a ridiculous troll
2021-09-17 23:27:01 +0200 <sclv> also yeah i was watching that talk and thinking "ok, this interactive experience with the compiler you're describing... that's the repl. you're describing the repl"
2021-09-17 23:27:02 +0200fiddlerwoaroof(~fiddlerwo@user/fiddlerwoaroof)
2021-09-17 23:27:14 +0200 <carbolymer> monochrom: is this on discourse or where?
2021-09-17 23:27:19 +0200 <sclv> haskell cafe
2021-09-17 23:27:35 +0200 <carbolymer> right
2021-09-17 23:27:37 +0200fr33domlover(~fr33domlo@angeley.es) (Ping timeout: 245 seconds)
2021-09-17 23:27:44 +0200 <monochrom> That reminds me, I haven't checked discourse today! :)
2021-09-17 23:27:46 +0200 <Boarders> one thing I am amazed about is rust still doesn't have a repl
2021-09-17 23:27:54 +0200fr33domlover(~fr33domlo@angeley.es)
2021-09-17 23:28:17 +0200chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2021-09-17 23:28:27 +0200chexum(~quassel@gateway/tor-sasl/chexum)
2021-09-17 23:30:13 +0200 <sclv> again -- could really appreciate any reports from people familiar with haskell's doctest tools about why the ghci-based approach seems preferred?
2021-09-17 23:38:25 +0200 <Boarders> what's the best way to compare two benchmark runs with criterion?
2021-09-17 23:38:32 +0200System12_(~System123@ec2-52-61-197-79.us-gov-west-1.compute.amazonaws.com) (Ping timeout: 268 seconds)
2021-09-17 23:38:43 +0200 <bradyt> there
2021-09-17 23:38:45 +0200 <bradyt> http://ix.io/3zcq/hs
2021-09-17 23:38:53 +0200 <bradyt> so then i do `Main | less -R`
2021-09-17 23:39:26 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2021-09-17 23:40:09 +0200 <bradyt> oh that `print x` is not needed
2021-09-17 23:40:14 +0200System123(~System123@ec2-52-61-197-79.us-gov-west-1.compute.amazonaws.com)
2021-09-17 23:42:19 +0200System12_(~System123@net-37-179-171-3.cust.vodafonedsl.it)
2021-09-17 23:43:15 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-09-17 23:45:54 +0200System123(~System123@ec2-52-61-197-79.us-gov-west-1.compute.amazonaws.com) (Ping timeout: 260 seconds)
2021-09-17 23:46:03 +0200Boarders(sid425905@id-425905.lymington.irccloud.com) ()
2021-09-17 23:46:22 +0200Boarders(sid425905@id-425905.lymington.irccloud.com)
2021-09-17 23:46:24 +0200 <Melvar> With cabal, is there any tutorial on putting a non-fixed set of autogenerated modules into `exposed-modules` using a custom setup? Because it looks like `build-type: Configure` does not support this.
2021-09-17 23:46:54 +0200 <sclv> you'll need to use Custom
2021-09-17 23:46:58 +0200 <sclv> but _please_ don't do that! please!
2021-09-17 23:47:01 +0200 <Melvar> Or at least an intro to Cabal-the-library, or what the hooks system actually means.
2021-09-17 23:47:10 +0200 <sclv> its completely recommended against
2021-09-17 23:48:11 +0200lavaman(~lavaman@98.38.249.169) (Ping timeout: 268 seconds)
2021-09-17 23:48:22 +0200wroathe(~wroathe@96-88-30-181-static.hfc.comcastbusiness.net)
2021-09-17 23:48:23 +0200wroathe(~wroathe@96-88-30-181-static.hfc.comcastbusiness.net) (Changing host)
2021-09-17 23:48:23 +0200wroathe(~wroathe@user/wroathe)
2021-09-17 23:49:06 +0200gehmehgeh(~user@user/gehmehgeh)
2021-09-17 23:50:31 +0200 <sclv> if you want to see how to do it, here's a simple example https://github.com/kowainik/autopack -- but again, i'm going to urge you super strongly to never release a package that does this (i.e. only use this for proprietary packages at most). the exposed-modules is used directly for hackage, so doing this will make the hackage docs very useless, and generally make your package a Bad Citizen.
2021-09-17 23:50:32 +0200 <sclv> and depending on why you want this, there is almost certainly a better way.
2021-09-17 23:50:32 +0200 <Melvar> Okay then. The only alternative I see is to write a package.yaml and invoke hpack after generating the modules, because I do not want to write code to insert modules into the cabal file.
2021-09-17 23:50:47 +0200 <sclv> ok, then write the package.yaml and invoke hpack
2021-09-17 23:51:05 +0200 <sclv> or just write some code once and for all to generate the module names, then paste them into the cabal file
2021-09-17 23:51:05 +0200 <sm> Boarders, quick and dirty but I like quickbench !
2021-09-17 23:51:53 +0200 <sclv> cabal files are designed to be a full interface manifest, which is why they don't expose wildcarding or the like
2021-09-17 23:51:57 +0200 <sclv> for modules in particular
2021-09-17 23:52:27 +0200 <sm> sclv: doctests are ghci commands, how might compiling them work ?
2021-09-17 23:52:30 +0200 <Melvar> The actual problem: I have written a toy wayland library, and have now written a scanner for it which is obliged to generate one module per interface because there are otherwise name clashes.
2021-09-17 23:52:55 +0200 <sclv> sm: i mean they're just a snippet of code, that generates a result that is shown, and then they compare the result vs the expected result
2021-09-17 23:53:03 +0200 <sclv> so like... they'd turn into standard spec tests or the like?
2021-09-17 23:53:04 +0200vysn(~vysn@user/vysn) (Ping timeout: 252 seconds)
2021-09-17 23:53:47 +0200merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-09-17 23:54:23 +0200tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-09-17 23:54:26 +0200 <sclv> Melvar: if you control the generation, I'd suggest just using better name munging :-)
2021-09-17 23:54:27 +0200 <ProofTechnique> Boarders: I think Rust had a repl in the very early days
2021-09-17 23:54:44 +0200 <sclv> sm: unless its common to have doctests using `:t` or `:i` or the like?? is it?
2021-09-17 23:55:28 +0200 <ProofTechnique> It was called `rusti` or something like that
2021-09-17 23:55:39 +0200 <Melvar> sclv: I don’t *want* to have hungarian notation on every request and event constructor, that’s what namespacing and qualification are for.
2021-09-17 23:55:43 +0200 <sm> it sounds interesting. Some compilation delay but maybe a speedup overall ? that would be very welcome
2021-09-17 23:56:11 +0200 <sclv> my main motivation is it eliminates the hardest part of the doctest runners, which is trying to match options to ghci etc perfectly
2021-09-17 23:56:11 +0200 <bradyt> oops, more like x <- readProcess "task" ["status:pending", "count"] ""
2021-09-17 23:56:22 +0200 <sclv> but also i'd imagine that its overall equally efficient
2021-09-17 23:56:27 +0200 <sclv> if not moreso
2021-09-17 23:56:29 +0200 <sm> i'd guess few projects use ghci commands in their doctests
2021-09-17 23:56:41 +0200 <ProofTechnique> I guess there's also https://github.com/google/evcxr, now
2021-09-17 23:56:54 +0200 <sclv> i wonder if its just a holdover from the python mentality doctests evolved from
2021-09-17 23:57:54 +0200 <sm> currently doctests start too slowly too use, for me
2021-09-17 23:58:02 +0200 <Boarders> I am trying to depend on this fork of containers: https://github.com/Boarders/containers - but the cabal file is in the subdirectory containers, does anyone know where the url of cabal.project should point to pick it up?
2021-09-17 23:58:10 +0200gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2021-09-17 23:59:20 +0200 <ProofTechnique> https://cabal.readthedocs.io/en/3.4/cabal-project.html#specifying-packages-from-remote-version-con… Boarders
2021-09-17 23:59:21 +0200 <Boarders> sm: I haven't tried quickbench, I'll have to see
2021-09-17 23:59:37 +0200 <ProofTechnique> Same url, just specify subdir
2021-09-17 23:59:56 +0200 <Boarders> thank you ProofTechnique (I have such a hard time finding stuff in the cabal docs, idk why)