IRCBrowse

2020/10/06

2020-10-06 00:00:15 +0200 <dolio> I'm not sure it's even strictly affine in the paper.
2020-10-06 00:00:25 +0200 <ski> (it may have been you who've mentioned some links to that here. i forgot whom)
2020-10-06 00:00:46 +0200 <ski> (hm, last time, it may have been carter, i think ?)
2020-10-06 00:00:57 +0200 <carter> eh?
2020-10-06 00:01:14 +0200mirrorbird(~psutcliff@2a00:801:2d5:9d73:ff00:6553:d451:a276) (Quit: Leaving)
2020-10-06 00:01:23 +0200 <ski> carter : you mentioned some paper by Mike Shulman, not too long ago, in here, yes ?
2020-10-06 00:01:26 +0200 <dolio> Like, it suggests certain additional axioms that are based on the specific translation into intuitionistic logic.
2020-10-06 00:01:27 +0200 <carter> yes
2020-10-06 00:01:31 +0200polyrain(~polyrain@2001:8003:e501:6901:a41a:145a:3fce:c107)
2020-10-06 00:01:43 +0200 <carter> but the linearity / affinity isn't the important part :)
2020-10-06 00:01:47 +0200 <dolio> Like A×A -> !A.
2020-10-06 00:02:04 +0200 <dolio> Once you have two, you have as many as you want.
2020-10-06 00:02:31 +0200 <int-e> Oh I should really take advantage of the new-ish atomic readMVar in ivar-simple; that way an IVar would only have one MVar instead of two.
2020-10-06 00:02:37 +0200 <carter> yeah, evaluation order + dualitiies is nice
2020-10-06 00:02:44 +0200 <ski> monochrom : one way to understand this constructivistic kerfuffle about "subfinite" and so on, is to think of it as being about "stages of knowledge"
2020-10-06 00:03:25 +0200 <dolio> That's definitely the Brouwerian angle, I think.
2020-10-06 00:03:52 +0200 <ski> (but in an epistemic modal logic, one has an explicit connective for "known" (often "by some particular agent"). but in a constructive setting, it's so to speak "built in")
2020-10-06 00:03:54 +0200 <carter> dolio: which semantics for par are you drawing from?
2020-10-06 00:04:03 +0200 <carter> i think choice/& is also cbn
2020-10-06 00:04:10 +0200 <dolio> carter: I was thinking of Compiling with Classical Connectives.
2020-10-06 00:04:26 +0200 <dolio> Yeah, & is also call-by-name.
2020-10-06 00:04:31 +0200 <dolio> And × is by-value.
2020-10-06 00:04:33 +0200 <ski> monochrom : but yes, the Kripke semantics for intuitionistic logic is, iiuc, related to the one for epistemic modal logic
2020-10-06 00:04:40 +0200pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net) (Ping timeout: 246 seconds)
2020-10-06 00:05:04 +0200 <carter> do whats their semantics for par? (i'd actually wanted to read that paper when i found it a few months ago, but it fell off my queue)
2020-10-06 00:05:06 +0200 <int-e> ("new-ish"... refers to ghc 7.10 here, I think.)
2020-10-06 00:05:10 +0200 <ski> (there's a "modal translation" from the former logic to the latter. at least in the propositional case, dunno about how it works with the quantifiers)
2020-10-06 00:06:05 +0200 <dolio> ski: You should definitely look at that paper, by the way. It's got arbitrary (co)data types with constructors whose types are sequents, and can have arbitrarily many value and continuation fields.
2020-10-06 00:06:13 +0200 <ski> dolio : oh .. that's a bit strange (the "i can't distinguish between two and infinity" one)
2020-10-06 00:06:17 +0200 <dolio> I think I've pointed you to it, but I don't know if you've seen it.
2020-10-06 00:06:26 +0200oisdk(~oisdk@2001:bb6:3329:d100:189f:9172:61d6:2b9e) (Quit: oisdk)
2020-10-06 00:07:01 +0200 <ski> carter : hm, did you look into the paper by Wadler about relating session types to linear logic ?
2020-10-06 00:07:12 +0200 <carter> session types are trash :)
2020-10-06 00:07:30 +0200oisdk(~oisdk@2001:bb6:3329:d100:e56d:4357:c75:2f61)
2020-10-06 00:07:35 +0200 <dolio> carter: A par continuation is two continuations, and a par value is a lambda term that binds two continuations, I think.
2020-10-06 00:07:49 +0200 <carter> ok, that sounds correct
2020-10-06 00:07:54 +0200 <carter> its forkIO by another name !
2020-10-06 00:08:08 +0200 <ski> i think the "cbn" vs. "cbv" distinction you mentioned above is more or less the same as the "negative" vs. "positive" one, that's cropping up in some cases (focusing, uniform proof)
2020-10-06 00:08:08 +0200pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net)
2020-10-06 00:08:31 +0200 <carter> or "cbpv"
2020-10-06 00:08:33 +0200 <dolio> Yes, but another cool thing this paper does is incorporate call-by-need and call-by-coneed.
2020-10-06 00:08:40 +0200 <carter> ... whats that even mean
2020-10-06 00:08:48 +0200 <carter> *coneed
2020-10-06 00:08:57 +0200 <ski> dolio : hm, i haven't seen this one before. ty for the suggestion
2020-10-06 00:09:26 +0200machinedgod(~machinedg@142.169.78.240)
2020-10-06 00:09:53 +0200 <dolio> -by-need saves work when you do a let that gets used multiple times. -by-coneed saves work when you do a shift where the continuation gets used multiple times, or something.
2020-10-06 00:10:19 +0200ski. o O ( "Compiling with Classical Connectives" by Paul Downen,Zena M. Ariola in 2020-08-28 at <https://arxiv.org/abs/1907.13227> )
2020-10-06 00:10:37 +0200 <fraktor> Hey, I've been trying to find definitive sources on this (admittedly controversial) topic: what's the plan for the new record syntax?
2020-10-06 00:11:41 +0200 <ski> carter : well, that session types paper does evoke such analogies as `forkIO'
2020-10-06 00:12:18 +0200 <ski> dolio, hm, interesting
2020-10-06 00:12:19 +0200albethere(sid457088@gateway/web/irccloud.com/x-fnvfojoflynertwf) (Ping timeout: 272 seconds)
2020-10-06 00:12:25 +0200 <carter> ski: explicitly?
2020-10-06 00:12:25 +0200 <carter> i gave a talk where i dervied it
2020-10-06 00:12:57 +0200alanz(sid110616@gateway/web/irccloud.com/x-rotyfkerxdfrgsjt) (Ping timeout: 272 seconds)
2020-10-06 00:13:45 +0200 <ski> carter : i don't recall if it's mentioned explicitly. but i did a presentation of the paper (first part was a refreshed of linear logic), which ended by a translation table having terms like "spawn" and "join" for the `par' case
2020-10-06 00:13:53 +0200 <dolio> ski: It's probably not all novel, but it was the first time I've seen almost everything in the paper (because I slacked on learning CBPV), so it just seemed like one cool idea after another when I read it. :)
2020-10-06 00:14:03 +0200 <ski> (s/refreshed/refresher/)
2020-10-06 00:14:31 +0200alanz(sid110616@gateway/web/irccloud.com/x-hhuchzrtvkxyanvu)
2020-10-06 00:14:51 +0200dmj`(sid72307@gateway/web/irccloud.com/x-adxoyhgdabwnfahc) (Ping timeout: 272 seconds)
2020-10-06 00:15:19 +0200 <koz_> :t maybe empty pure
2020-10-06 00:15:21 +0200 <lambdabot> Alternative f => Maybe a -> f a
2020-10-06 00:15:29 +0200liszt_(sid336875@gateway/web/irccloud.com/x-yllqqkokdlggifua) (Ping timeout: 272 seconds)
2020-10-06 00:15:47 +0200albethere(sid457088@gateway/web/irccloud.com/x-uubpnvrpjsbjfkmg)
2020-10-06 00:15:50 +0200 <ski> koz_ : i sometimes wish that was in a "standard library"
2020-10-06 00:15:52 +0200liszt_(sid336875@gateway/web/irccloud.com/x-uuxepiucxpvvjuow)
2020-10-06 00:15:59 +0200 <koz_> ski: Yeah, you and me both.
2020-10-06 00:16:04 +0200 <koz_> It's probbo in extra or something.
2020-10-06 00:16:07 +0200conjunctive(sid433686@gateway/web/irccloud.com/x-ddwejxzgxrdkpmwd) (Ping timeout: 272 seconds)
2020-10-06 00:16:07 +0200elvishjerricco(sid237756@NixOS/user/ElvishJerricco) (Ping timeout: 272 seconds)
2020-10-06 00:16:07 +0200tchar(sid301738@gateway/web/irccloud.com/x-squtmljpvmzfdfsk) (Ping timeout: 272 seconds)
2020-10-06 00:16:07 +0200adius(sid321344@gateway/web/irccloud.com/x-hdzjqmobobrptkzk) (Ping timeout: 272 seconds)
2020-10-06 00:16:28 +0200hackagetini 0.1.0.1 - Tiny INI file and configuration library with a minimal dependency footprint. https://hackage.haskell.org/package/tini-0.1.0.1 (AntonEkblad)
2020-10-06 00:16:29 +0200tchar(sid301738@gateway/web/irccloud.com/x-rgpmjtqqbhrmcohe)
2020-10-06 00:16:45 +0200SrPx(sid108780@gateway/web/irccloud.com/x-czvvabmhqaigtsgp) (Ping timeout: 272 seconds)
2020-10-06 00:16:57 +0200 <carter> ski: oh, it def does that, the issue i have with session types is that a lotta expositions kinda treat par as not being symmetric in the two args
2020-10-06 00:16:59 +0200dmj`(sid72307@gateway/web/irccloud.com/x-khxpyzsgwpyndoap)
2020-10-06 00:17:19 +0200SrPx(sid108780@gateway/web/irccloud.com/x-lqrnqgbzvbfaqfbf)
2020-10-06 00:17:35 +0200albethere(sid457088@gateway/web/irccloud.com/x-uubpnvrpjsbjfkmg) (Max SendQ exceeded)
2020-10-06 00:17:52 +0200albethere(sid457088@gateway/web/irccloud.com/x-lwglmvolkygoqkcg)
2020-10-06 00:18:10 +0200adius(sid321344@gateway/web/irccloud.com/x-fevubjfnjnczxgiy)
2020-10-06 00:18:18 +0200conjunctive(sid433686@gateway/web/irccloud.com/x-svszloomofjzwqrv)
2020-10-06 00:18:23 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0)
2020-10-06 00:18:33 +0200 <dolio> carter: I guess in more detail, the idea with by-need is that there can be non-trivial work to reduce a term to an actionable value when you 'let' something, and you want to delay doing that work until you need it, but only do it once. Similarly, when you capture a continuation, there might be non-trivial work to reduce it to an actionable co-value, and you similarly only want to do it once, but only if you actually jump to it.
2020-10-06 00:19:17 +0200buggymcbugfix(sid432603@gateway/web/irccloud.com/x-fjvfxmicxyzmpfmg) (Ping timeout: 272 seconds)
2020-10-06 00:19:27 +0200elvishjerricco(sid237756@NixOS/user/ElvishJerricco)
2020-10-06 00:19:55 +0200m-renaud(sid333785@gateway/web/irccloud.com/x-wdhdpnuntagzspud) (Ping timeout: 272 seconds)
2020-10-06 00:19:55 +0200^[_(sid43445@gateway/web/irccloud.com/x-eiyktghegavpjkto) (Ping timeout: 272 seconds)
2020-10-06 00:20:01 +0200__monty__(~toonn@unaffiliated/toonn) (Quit: leaving)
2020-10-06 00:20:06 +0200ski. o O ( `(getAlt .) . foldMap . (Alt .) :: (Foldable t,Alternative f) => (a -> f b) -> (t a -> f b)' )
2020-10-06 00:20:11 +0200Tops21(~Tobias@dyndsl-095-033-017-021.ewe-ip-backbone.de) (Read error: Connection reset by peer)
2020-10-06 00:20:26 +0200buggymcbugfix(sid432603@gateway/web/irccloud.com/x-hmfcqscsbxxfrwjh)
2020-10-06 00:20:56 +0200 <ski> carter : yea, it's a bit annoying, perhaps, but it seems it's what you get, for the intended application domain of session types ? (at least to a first approximation ?)
2020-10-06 00:21:49 +0200 <ski> (note that i haven't really looked much at session types, apart from that paper relating them to linear logic .. so i might be missing some relevant stuff)
2020-10-06 00:22:03 +0200^[_(sid43445@gateway/web/irccloud.com/x-jnodviuydqdnbssz)
2020-10-06 00:22:20 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:507:9614:9e50:551c) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 00:22:30 +0200m-renaud(sid333785@gateway/web/irccloud.com/x-hxgmjbgqyiqvuvvr)
2020-10-06 00:23:14 +0200moet(~moet@mobile-166-170-41-37.mycingular.net)
2020-10-06 00:23:43 +0200noan(~noan@2604:a880:400:d0::12fc:5001) (Ping timeout: 272 seconds)
2020-10-06 00:24:06 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net) (Ping timeout: 258 seconds)
2020-10-06 00:24:07 +0200 <moet> is it better to have a "search & extract" function like `(a -> Bool) -> [a] -> Maybe ([a], a)` or like `(a -> Bool) -> [a] -> ([a], Maybe a)` ?
2020-10-06 00:24:20 +0200Sgeo_(~Sgeo@ool-18b982ad.dyn.optonline.net)
2020-10-06 00:24:43 +0200 <koz_> moet: I guess this finds (possibly) the first satisfying item, and the rest?
2020-10-06 00:24:43 +0200 <moet> i tend to prefer the former `Maybe ([a], a)` because it communicates that there's no need to update the list in it's containing data structure because no result was found
2020-10-06 00:24:49 +0200noan(~noan@2604:a880:400:d0::12fc:5001)
2020-10-06 00:24:50 +0200 <koz_> What happens if there's more than one?
2020-10-06 00:24:59 +0200no-n(sid257727@gateway/web/irccloud.com/x-rjqspinjxdvineod) (Ping timeout: 272 seconds)
2020-10-06 00:24:59 +0200AndreasK(sid320732@gateway/web/irccloud.com/x-degmzwhevcbnxqim) (Ping timeout: 272 seconds)
2020-10-06 00:25:24 +0200 <ski> moet : assuming i understand the context correctly, i'd go for the former, probably
2020-10-06 00:25:34 +0200snakemasterflex(~snakemast@213.100.206.23)
2020-10-06 00:25:37 +0200carter(sid14827@gateway/web/irccloud.com/x-qxwtkltudlralpiz) (Ping timeout: 272 seconds)
2020-10-06 00:25:58 +0200 <ski> it seems less common to want to remove an element, if present, and separately get a notification whether an element was removed
2020-10-06 00:25:58 +0200 <moet> koz_: yes, it finds the first and returns the list with that item removed .. eg `searchExtract (=='l') "hello" == Just ("helo", 'l')`
2020-10-06 00:26:05 +0200 <koz_> Ah.
2020-10-06 00:26:06 +0200 <moet> koz_: if there's more than one, they're left in the list
2020-10-06 00:26:07 +0200 <dolio> carter: I'm not sure what a great example is. The one that comes to mind is: when you capture a continuation that does some lets to build (by-need) closures after it's called, those closures should not be built for each invocation of the continuation.
2020-10-06 00:26:28 +0200carter(sid14827@gateway/web/irccloud.com/x-sizpssbboxwjlzfn)
2020-10-06 00:26:30 +0200xff0x(~fox@2001:1a81:5300:fe00:1175:d8f5:8ada:f855) (Quit: xff0x)
2020-10-06 00:26:30 +0200 <ski> usually, i think, one'd want to explicitly tell how to continue with the list, if the item was not present
2020-10-06 00:26:30 +0200 <dolio> Only once, if possible, and shared.
2020-10-06 00:26:59 +0200no-n(sid257727@gateway/web/irccloud.com/x-njvyzrpfdtdezqbh)
2020-10-06 00:27:01 +0200AndreasK(sid320732@gateway/web/irccloud.com/x-hkkwdrhutkwmrhne)
2020-10-06 00:27:11 +0200 <ski> dolio : maybe some `shift'&`reset' example ?
2020-10-06 00:27:33 +0200Sgeo(~Sgeo@ool-18b982ad.dyn.optonline.net) (Ping timeout: 258 seconds)
2020-10-06 00:27:55 +0200 <moet> ski: so if i'm understanding you correctly, you agree with what i said above about preferring `Maybe ([a], a)` because it's less ambiguous in meaning than `([a], Maybe a)`?
2020-10-06 00:27:56 +0200machinedgod(~machinedg@142.169.78.240) (Ping timeout: 258 seconds)
2020-10-06 00:28:17 +0200 <dolio> Maybe. I have trouble of thinking of good 'doing computation to determine the continuation' examples because that's basically something you can't do in most type theory.
2020-10-06 00:28:22 +0200 <ski> (there's some paper on normalization-by-evaluation, which has a `reflect' operation that uses `shift' on sum types, to evaluate both branches, iirc .. hmm)
2020-10-06 00:29:25 +0200ghuntley(sid16877@gateway/web/irccloud.com/x-jwzkcgtobgufetir) (Ping timeout: 272 seconds)
2020-10-06 00:29:25 +0200pent(sid313808@gateway/web/irccloud.com/x-mbwahawoqthelmme) (Ping timeout: 272 seconds)
2020-10-06 00:29:33 +0200 <carter> ski: i specfically think that the session types approach to linar logica was the biggest barrier to people understanding linear logic and relating it to functional programming
2020-10-06 00:29:35 +0200ghuntley(sid16877@gateway/web/irccloud.com/x-hazckpioupzucowz)
2020-10-06 00:29:40 +0200 <ski> moet : yes, the latter would allow/encourage continuing using the list (whether an element was removed or not), and perhaps later checking the removal status of the other part. if that was a common pattern one'd want to support, i'd probably go with the latter alternative (or maybe support both)
2020-10-06 00:29:52 +0200snakemasterflex(~snakemast@213.100.206.23) (Ping timeout: 246 seconds)
2020-10-06 00:30:03 +0200JSharp(sid4580@wikia/JSharp) (Ping timeout: 272 seconds)
2020-10-06 00:30:24 +0200 <ski> moet : but if it's not a likely situation (to reasonably be in), i'd go with the former, to reduce risk of bugs due to not being forced to upfront check the status
2020-10-06 00:30:25 +0200cosimone(~user@2001:b07:ae5:db26:f68c:50ff:fe0b:b774) (Ping timeout: 240 seconds)
2020-10-06 00:30:31 +0200pent(sid313808@gateway/web/irccloud.com/x-lsufgbovmcuefoiy)
2020-10-06 00:30:53 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-06 00:31:57 +0200cemerick(sid54985@gateway/web/irccloud.com/x-ongnogrqassjmkgm) (Ping timeout: 272 seconds)
2020-10-06 00:32:22 +0200JSharp(sid4580@wikia/JSharp)
2020-10-06 00:32:29 +0200cemerick(sid54985@gateway/web/irccloud.com/x-ticsgvtoxvknnlzm)
2020-10-06 00:32:30 +0200 <ski> carter : oh, that might be so. i haven't heard of many people trying to understand linear logic (or even functional programming), coming from a session types perspective. i learned linear logic long before i heard of session types
2020-10-06 00:32:57 +0200 <carter> How’d you manage that?
2020-10-06 00:33:13 +0200 <ski> dolio : hm, elaborate on "doing computation to determine the continuation" ?
2020-10-06 00:33:22 +0200polyrain(~polyrain@2001:8003:e501:6901:a41a:145a:3fce:c107) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 00:33:54 +0200 <carter> dolio: this is the co-need bit? the paper kinda talks about it
2020-10-06 00:34:08 +0200 <carter> "control effectful cbv but more efficient for weird programs"
2020-10-06 00:34:12 +0200polyrain(~polyrain@2001:8003:e501:6901:a41a:145a:3fce:c107)
2020-10-06 00:34:12 +0200 <ski> carter : i dunno. i'm not sure how long session types have been a thing (i heard of them, less than ten years ago, i think). but i was reading lots of papers on various logics and type systems, and encountered linear logic that way
2020-10-06 00:34:21 +0200 <carter> cool
2020-10-06 00:34:48 +0200 <carter> by volume, most linear lgoic stuff in the last 20 years seems to either be in small boring fragments, or session types
2020-10-06 00:34:51 +0200 <carter> until the past 2-5 years
2020-10-06 00:34:59 +0200 <ski> carter : let's enable more weird programs, heh ;)
2020-10-06 00:36:15 +0200moet(~moet@mobile-166-170-41-37.mycingular.net) (Quit: leaving)
2020-10-06 00:37:13 +0200 <dolio> carter: Yeah.
2020-10-06 00:37:31 +0200 <carter> dolio: wrt co-need or wrt linear logic?
2020-10-06 00:37:41 +0200 <carter> https://ix.cs.uoregon.edu/~pdownen/presentations/beyond-polarity.pdf maybe this presentation by the author has stuff
2020-10-06 00:37:43 +0200 <carter> skimming atm
2020-10-06 00:38:02 +0200 <ski> a tail-recursive function (definition) is one that passes the same continuation (for output) to the recursive calls. how would a "head-recursive function (definition)", being one that passes the same value (for input) to the recursive calls, work ?
2020-10-06 00:38:18 +0200 <carter> ski: ???
2020-10-06 00:38:22 +0200chaosmasttter(~chaosmast@p200300c4a73b2e0100f3c5a701cd6e56.dip0.t-ipconnect.de) (Quit: WeeChat 2.9)
2020-10-06 00:38:22 +0200 <dolio> ski, carter: I think another example is: if the continuation starts by doing case analysis on a sum type that is closed over by the continuation, you should just reduce that out of the continuation the first time you go through it, and memoize the result.
2020-10-06 00:38:25 +0200 <carter> co deta?
2020-10-06 00:38:35 +0200 <ski> ah, i suppose this is related to "message-dispatching syntax" (aka "copattern syntax") (i was thinking that before, but didn't mention)
2020-10-06 00:38:46 +0200 <dolio> carter: co-need.
2020-10-06 00:39:10 +0200atknil
2020-10-06 00:39:18 +0200 <ski> dolio : what's the dual situation to that ?
2020-10-06 00:39:21 +0200 <carter> i dont like the up/down shift notations in this
2020-10-06 00:39:23 +0200nil(~Arch-TK@ircpuzzles/staff/Arch-TK) (Disconnected by services)
2020-10-06 00:39:26 +0200 <carter> in these papers
2020-10-06 00:39:27 +0200 <carter> hard to read
2020-10-06 00:40:03 +0200 <dolio> ski: The first time you evaluate a lazy let function call, you should remember the value it produces.
2020-10-06 00:40:06 +0200atk(~Arch-TK@ircpuzzles/staff/Arch-TK)
2020-10-06 00:40:38 +0200argent0(~argent0@168.227.97.5)
2020-10-06 00:40:44 +0200jwynn6(~jwynn6@050-088-122-078.res.spectrum.com) (Ping timeout: 256 seconds)
2020-10-06 00:41:12 +0200 <ski> carter : if you consider `shunt [] ys = ys; shunt (x:xs) ys = shunt xs (x:ys)' (for `reverse xs = shunt xs []'), then it inspects information in its input value (putting stuff into the accumulator), and continues looping with the same continuation (only actually used in the base casr)
2020-10-06 00:41:28 +0200 <carter> whats this about?
2020-10-06 00:42:00 +0200 <ski> carter : for a "head-recursive" definition, you'd pass the same input parameter `v' to the recursive call as you got in the current call. but instead, you'd extract information, by inspecting your continuation (which would change across recursive calls)
2020-10-06 00:42:11 +0200 <argent0> Hi, what does `do ...; let foo bar = cat <$> dog <*> aniamal` means?
2020-10-06 00:42:11 +0200 <carter> are you just talking about coinductive
2020-10-06 00:42:27 +0200 <argent0> I ask about the `foo bar` part?
2020-10-06 00:42:50 +0200 <ski> i was wondering if one could relate this to what dolio mentioned about "doing computation to determine the continuation"
2020-10-06 00:43:00 +0200 <monochrom> <$> is fmap, from the Functor class. <*> is from the Applicative class.
2020-10-06 00:43:04 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:71a4:5e3f:3433:7ae1)
2020-10-06 00:43:18 +0200 <ski> dolio : "a lazy let function call" ?
2020-10-06 00:43:33 +0200 <monochrom> This is obviously very abstract and unnecessarily general. But this is how much information is possible from the question.
2020-10-06 00:43:45 +0200 <argent0> monochrom: yes but how does the `foo bar` part matches
2020-10-06 00:43:55 +0200mav1(~mav@p5dee344b.dip0.t-ipconnect.de) (Quit: WeeChat 2.9)
2020-10-06 00:44:02 +0200 <monochrom> foo is a function name, bar is an argument name.
2020-10-06 00:44:23 +0200 <monochrom> This is defining the function "foo".
2020-10-06 00:44:24 +0200dminuoso(~dminuoso@unaffiliated/dminuoso) (Quit: ZNC 1.6.6+deb1ubuntu0.1 - http://znc.in)
2020-10-06 00:44:33 +0200 <argent0> monochrom: ok, thanks
2020-10-06 00:44:48 +0200 <ski> argent0 : if `cat :: I (Dog -> Animal -> Farm)', and `dog :: I Dog',`animal :: I Animal', then `cat <$> dog <*> animal :: I Farm', where `I' is some idiom (an instance of `Applicative')
2020-10-06 00:44:49 +0200argent0:-P
2020-10-06 00:45:04 +0200LKoen(~LKoen@81.255.219.130) (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”)
2020-10-06 00:45:21 +0200 <argent0> ski: thanks I get it now
2020-10-06 00:45:58 +0200 <ski> (er, sorry. that should be just `cat :: Dog -> Animal -> Farm'. if you had used `cat <*> dog <*> aniamal', then it would have been as i said above)
2020-10-06 00:45:59 +0200Andre4(~Andrea@p5de77723.dip0.t-ipconnect.de)
2020-10-06 00:47:19 +0200 <ski> carter : "are you just talking about coinductive" -- more or less. thinking about how to relate it to the other topic here. have you seen "message-dispatching syntax" (perhaps read the "copatterns" paper) ?
2020-10-06 00:47:35 +0200 <carter> copatterns are fun
2020-10-06 00:47:51 +0200 <ski> indeed
2020-10-06 00:47:54 +0200 <carter> ski: did you see my thing about how to fake copatterns in haskell on reddit a few years ago
2020-10-06 00:48:04 +0200 <ski> hm, i don't recall so ?
2020-10-06 00:48:15 +0200 <ski> @where ErikPoll
2020-10-06 00:48:15 +0200 <lambdabot> "Subtyping and Inheritance for Inductive Types" in 1997 at <http://www.cs.ru.nl/E.Poll/papers/durham97.pdf>,"Subtyping and Inheritance for Categorical Datatypes" in 1997 at <http://www.cs.ru.nl/E.
2020-10-06 00:48:15 +0200 <lambdabot> Poll/papers/kyoto97.pdf>,"A Coalgebraic Semantics of Subtyping" in 2000 at <http://www.cs.ru.nl/E.Poll/papers/cmcs00.pdf>,later version of that in 2001 at <http://www.cs.ru.nl/E.Poll/papers/ita01.
2020-10-06 00:48:15 +0200 <lambdabot> pdf>
2020-10-06 00:48:55 +0200 <dolio> ski: `let y = f x` is naming (y) a computation that matches up closed-over variables in a par redex that might do non-trivial amounts of work before reducing to a value. So call-by-need says that when you want its value, you should do the work and remember the value.
2020-10-06 00:49:00 +0200 <carter> https://www.reddit.com/r/haskell/comments/4aju8f/simple_example_of_emulating_copattern_matching_in/ ski
2020-10-06 00:49:27 +0200 <ski> the first two of these papers, are where i first saw the idea (which i called "message-dispatching syntax", since it seemed to obviously correspond to definitions of how objects respond to messages (by giving method implementations), in OO)
2020-10-06 00:49:49 +0200 <dolio> Instead of re-doing the redex every time (call-by-name).
2020-10-06 00:50:15 +0200 <carter> dolio: aka its saying "continuations are cbn normally in cbv languages"
2020-10-06 00:51:54 +0200 <dolio> Something like that.
2020-10-06 00:52:00 +0200 <Andre4> is the St Monad ( Data.STRef, DataArrayST) impure, is this monoad magic, like IO ?
2020-10-06 00:52:06 +0200 <ski> carter : ah, cool :) .. you're emulating a record as a function taking a tag (in this case a `GADT' tag)
2020-10-06 00:52:44 +0200 <dolio> carter: Like, they just grab the stack, and run back through it verbatim every time. They don't optimize it on the first time through.
2020-10-06 00:52:51 +0200danvet_(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa) (Ping timeout: 272 seconds)
2020-10-06 00:53:12 +0200 <carter> dolio: ohhh, it makes more sense when explained that way
2020-10-06 00:53:18 +0200 <carter> call CC is terrible for exposition
2020-10-06 00:53:21 +0200 <carter> CPS makes more sense to me
2020-10-06 00:53:22 +0200 <carter> :)
2020-10-06 00:53:37 +0200 <carter> dolio: would this allow a faster logicT mmonad? :)
2020-10-06 00:53:55 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:71a4:5e3f:3433:7ae1) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 00:54:27 +0200hackageivar-simple 0.3.3 - Write once concurrency primitives. https://hackage.haskell.org/package/ivar-simple-0.3.3 (BertramFelgenhauer)
2020-10-06 00:55:02 +0200 <dolio> Hah. I don't know. I barely understand this paper.
2020-10-06 00:55:20 +0200 <ski> carter : reminds me of a trick to represent `data Expr where Let :: [Decl] -> Expr -> Expr; data Decl where Def :: Ident -> [Ident] -> Expr -> Decl' as `data Tag = E | D; data AST :: Tag -> * where Let :: [AST D] -> ADT E -> AST E; Def :: Ident -> [Ident] -> AST E -> AST D'
2020-10-06 00:55:23 +0200 <int-e> ski: ^^new release
2020-10-06 00:55:23 +0200 <carter> Yeah. It found it a bit hard to read
2020-10-06 00:55:59 +0200 <int-e> (it's even simpler now; writeIVar is just a putMVar, the way it was originally intended)
2020-10-06 00:56:02 +0200dminuoso(~dminuoso@unaffiliated/dminuoso)
2020-10-06 00:56:02 +0200 <carter> int-e: I cooked up a fun idea for an Mvar variant when helping viktor debug some fun perf issues
2020-10-06 00:56:10 +0200 <ski> carter : the point is that if one wants to do explicit fixpoints, we can encode a type-level tuple/record as a type function from `Tag'
2020-10-06 00:56:35 +0200 <carter> https://gitlab.haskell.org/ghc/ghc/-/issues/18798
2020-10-06 00:57:01 +0200 <carter> ski: I’m middle of eating. So not 100% atm
2020-10-06 00:57:02 +0200mav1(~mav@p5dee344b.dip0.t-ipconnect.de)
2020-10-06 00:58:11 +0200 <ski> dolio : hm, not seeing how it relates to `par'
2020-10-06 00:58:28 +0200 <dolio> function calls are par.
2020-10-06 00:59:15 +0200 <ski> Andre4 : neither `ST' nor `IO' are impure. but both are "magic", in the sense that they have direct support by the implementation. (they aren't defined totally in Haskell source code)
2020-10-06 00:59:27 +0200 <dolio> I'd have to think a while how to actually write that 'let' thing. :)
2020-10-06 00:59:35 +0200 <ski> (similarly to how `Integer',`Int',`Double',`(->)' are also "magic", or "primitive", in the same sense)
2020-10-06 00:59:51 +0200tv-(~tv@unaffiliated/tv-)
2020-10-06 01:01:02 +0200alx741(~alx741@186.178.110.22) (Quit: alx741)
2020-10-06 01:02:07 +0200albert_91(~Albert@p200300e5ff0b5b4248a33bded2872db1.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-06 01:02:11 +0200 <carter> dolio: more you can encode functions in par
2020-10-06 01:02:11 +0200 <Andre4> aki: in the source code from Stref some foreign statements are included
2020-10-06 01:02:57 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0) (Remote host closed the connection)
2020-10-06 01:03:23 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0)
2020-10-06 01:04:30 +0200 <Andre4> ski: does stref, or arrayst work together with laty evaluation ?
2020-10-06 01:04:42 +0200Amras(~Amras@unaffiliated/amras0000) (Ping timeout: 260 seconds)
2020-10-06 01:04:45 +0200 <Andre4> lazy evaluation
2020-10-06 01:05:12 +0200Axman6(~Axman6@pdpc/supporter/student/Axman6)
2020-10-06 01:05:20 +0200mav1(~mav@p5dee344b.dip0.t-ipconnect.de) (Quit: WeeChat 2.9)
2020-10-06 01:06:11 +0200 <dolio> ski: Something like this, maybe: <shift k. <f|¬x:k> | let y. ...>
2020-10-06 01:06:26 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-10-06 01:06:27 +0200 <ski> int-e : nice :D
2020-10-06 01:07:30 +0200oisdk(~oisdk@2001:bb6:3329:d100:e56d:4357:c75:2f61) (Quit: oisdk)
2020-10-06 01:08:04 +0200 <dolio> How to reduce that is ambiguous, though, and I left out all the polarity shifting that makes it deterministic. :)
2020-10-06 01:08:13 +0200m0rphism(~m0rphism@HSI-KBW-046-005-177-122.hsi8.kabel-badenwuerttemberg.de) (Ping timeout: 260 seconds)
2020-10-06 01:08:16 +0200entkme^(entkme@ip98-184-89-2.mc.at.cox.net) ()
2020-10-06 01:08:16 +0200 <ski> dolio : hm, yes. but for some reason, i thought you were thinking about constructing a `par', behind the scenes, in some way there
2020-10-06 01:08:52 +0200alx741(~alx741@186.178.110.22)
2020-10-06 01:09:31 +0200tsrt^(tsrt@ip98-184-89-2.mc.at.cox.net)
2020-10-06 01:09:37 +0200Andre4(~Andrea@p5de77723.dip0.t-ipconnect.de) (Quit: Leaving)
2020-10-06 01:09:38 +0200 <dolio> I guess you should imagine that f is actually a lambda term.
2020-10-06 01:09:44 +0200 <dolio> To be analogous to a case statement.
2020-10-06 01:10:16 +0200 <ski> Andre4 : yes, they don't force the values stored inside the mutable cells. however, `Control.Monad.ST' is strict in the state (the collection of `STRef's and `STArray's) that it carries around. if you want laziness there, try `Control.Monad.ST.Lazy' (i'd link you to some fun examples by monochrom here, but alas, the paste service they were on is no more ..)
2020-10-06 01:10:30 +0200 <dolio> Then it's a β redex.
2020-10-06 01:10:54 +0200polyrain(~polyrain@2001:8003:e501:6901:a41a:145a:3fce:c107) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 01:11:16 +0200 <ski> dolio : how should i parse `<.. | ..>' ? creating a `par' ?
2020-10-06 01:11:25 +0200thc202(~thc202@unaffiliated/thc202) (Ping timeout: 240 seconds)
2020-10-06 01:11:54 +0200 <dolio> No, <...|...> is cut.
2020-10-06 01:12:15 +0200 <dolio> cut a term with a coterm.
2020-10-06 01:12:23 +0200 <ski> ah, i was just thinking it could be that
2020-10-06 01:12:54 +0200 <dolio> Anyhow, `shift` can capture a β redex for a sum in a continuation, dually to this.
2020-10-06 01:13:11 +0200dminuoso(~dminuoso@unaffiliated/dminuoso) (Quit: ZNC 1.7.5 - https://znc.in)
2020-10-06 01:13:19 +0200 <ski> (still pondering how to parse it, though)
2020-10-06 01:13:36 +0200massma(~user@dyn-160-39-62-152.dyn.columbia.edu)
2020-10-06 01:14:14 +0200 <dolio> Haha. <(shift k. <f|¬x:k>) | (let y. ...)>
2020-10-06 01:14:28 +0200 <ski> what's the type of either side of the jump `<shift k. <f|¬x:k> | let y. ...>' ?
2020-10-06 01:14:41 +0200 <ski> (yes, i took that bracketting for granted)
2020-10-06 01:14:48 +0200 <dolio> 'let' is supposed to capture the term it's cut with in the variable (y). 'shift' captures the continuation it's cut with in `k`.
2020-10-06 01:14:57 +0200 <ski> how does it correspond to `let y = f x in ...' ?
2020-10-06 01:15:06 +0200 <ski> (is it the same `...' in both ?)
2020-10-06 01:16:35 +0200 <ski> hm, ok, so `let y. ...' is a continuation, then
2020-10-06 01:16:42 +0200 <dolio> Yeah.
2020-10-06 01:16:48 +0200dminuoso(~dminuoso@unaffiliated/dminuoso)
2020-10-06 01:17:01 +0200 <ski> (and that `...' is another jump)
2020-10-06 01:17:09 +0200 <dolio> It's a continuation that captures the term it's cut with and runs a computation in an extended environment.
2020-10-06 01:17:18 +0200 <ski> yes
2020-10-06 01:17:25 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net) (Ping timeout: 240 seconds)
2020-10-06 01:17:47 +0200 <dolio> To make a value version of the let might require another shift or something.
2020-10-06 01:18:12 +0200GyroW_(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-06 01:18:22 +0200GyroW(~GyroW@d54c03e98.access.telenet.be)
2020-10-06 01:18:23 +0200GyroW(~GyroW@d54c03e98.access.telenet.be) (Changing host)
2020-10-06 01:18:23 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-06 01:18:28 +0200polyrain(~polyrain@2001:8003:e501:6901:a41a:145a:3fce:c107)
2020-10-06 01:21:32 +0200 <int-e> carter: looks risky... I'd think that marking the MVar as dirty is as much about the list of waiters (which, if you block on an MVar, contains an item in the youngest generation) as it is about the value.
2020-10-06 01:21:52 +0200 <ski> Γ , y : B ⊢{ ⋯y⋯ } Δ
2020-10-06 01:21:55 +0200 <ski> ──────────────────────
2020-10-06 01:21:58 +0200 <ski> Γ | let y. ⋯y⋯ : B ⊢ Δ
2020-10-06 01:22:03 +0200 <ski> something like that
2020-10-06 01:22:16 +0200tv-(~tv@unaffiliated/tv-) (Quit: WeeChat 2.8)
2020-10-06 01:22:17 +0200 <dolio> Yeah, I think so.
2020-10-06 01:22:37 +0200tv-(~tv@unaffiliated/tv-)
2020-10-06 01:22:59 +0200 <carter> ohh
2020-10-06 01:23:03 +0200 <carter> int-e: comment on that plz :)
2020-10-06 01:23:13 +0200 <ski> and ⌜¬x:k⌝ is a "calling context" of a called function, yes ?
2020-10-06 01:23:27 +0200notzmv(~user@unaffiliated/zmv) (Read error: Connection reset by peer)
2020-10-06 01:23:50 +0200 <dolio> Yeah. A function continuation is an argument pushed on the return continuation.
2020-10-06 01:23:57 +0200 <ski> right
2020-10-06 01:24:20 +0200 <ski> (oh, that's why you used ⌜:⌝, since you're thinking of the continuation as a stack you're pushing things on)
2020-10-06 01:24:53 +0200pacak(~pacak@bb116-14-220-91.singnet.com.sg) (Remote host closed the connection)
2020-10-06 01:24:56 +0200 <int-e> carter: you sure know how to put the "labor" into elaborate :P
2020-10-06 01:25:09 +0200 <ski> (at first i was wondering why ⌜¬x⌝ had type ⌜k⌝ ..)
2020-10-06 01:25:09 +0200notzmv(~user@177.45.26.174)
2020-10-06 01:25:13 +0200pacak(~pacak@bb116-14-220-91.singnet.com.sg)
2020-10-06 01:25:23 +0200 <dolio> Oh, sorry.
2020-10-06 01:25:25 +0200notzmvGuest43030
2020-10-06 01:26:05 +0200dminuoso(~dminuoso@unaffiliated/dminuoso) (Quit: ZNC 1.7.5 - https://znc.in)
2020-10-06 01:26:13 +0200 <dolio> I should say, that's what a function continuation value is. Or a co-value.
2020-10-06 01:26:21 +0200dminuoso(~dminuoso@unaffiliated/dminuoso)
2020-10-06 01:26:47 +0200Guest43030zmv
2020-10-06 01:26:51 +0200zmv(~user@177.45.26.174) (Changing host)
2020-10-06 01:26:51 +0200zmv(~user@unaffiliated/zmv)
2020-10-06 01:26:58 +0200 <dolio> You could also put a 'let' in there to do more stuff.
2020-10-06 01:26:58 +0200zmvnotzmv
2020-10-06 01:30:30 +0200 <argent0> :q
2020-10-06 01:30:46 +0200 <ski> Γ ⊢ x : A | Δ
2020-10-06 01:30:51 +0200 <ski> ────────────────
2020-10-06 01:30:55 +0200 <ski> Γ , ¬x : ¬ A ⊢ Δ Γ | k : B ⊢ Δ
2020-10-06 01:30:59 +0200 <ski> ────────────────────────────────
2020-10-06 01:31:02 +0200 <ski> Γ | ¬x::k : A → B ⊢ Δ
2020-10-06 01:31:25 +0200Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi) (Ping timeout: 240 seconds)
2020-10-06 01:31:54 +0200pacak(~pacak@bb116-14-220-91.singnet.com.sg) (Remote host closed the connection)
2020-10-06 01:32:04 +0200 <dolio> Yeah.
2020-10-06 01:32:17 +0200pacak(~pacak@bb116-14-220-91.singnet.com.sg)
2020-10-06 01:32:36 +0200 <ski> Γ ⊢ f : A → B ⊢ Δ Γ | ¬x::k : A → B ⊢ Δ
2020-10-06 01:32:41 +0200 <ski> ─────────────────────────────────────────
2020-10-06 01:32:44 +0200 <ski> Γ ⊢{ ⟨f|¬x:k⟩ } Δ
2020-10-06 01:34:15 +0200 <dolio> Yeah, with one of the ⊢ replaced with a |.
2020-10-06 01:34:36 +0200 <ski> er, yes
2020-10-06 01:34:48 +0200conal(~conal@64.71.133.70)
2020-10-06 01:34:55 +0200 <ski> should have been ⌜Γ ⊢ f : A → B | Δ⌝
2020-10-06 01:35:01 +0200 <dolio> Right.
2020-10-06 01:35:45 +0200 <dolio> And for a genuine β redex we'ere imagining f = λ[¬x::k] <...>
2020-10-06 01:37:13 +0200 <dolio> So it's a value cut with a covalue.
2020-10-06 01:37:18 +0200 <ski> Γ ⊢{ ⟨f|¬x:k⟩ } Δ
2020-10-06 01:37:22 +0200 <ski> ───────────────────────────────────
2020-10-06 01:37:26 +0200 <ski> Γ ⊢ ξ k. ⟨f|¬x:k⟩ : B | Δ ∸ (k : B)
2020-10-06 01:37:31 +0200 <ski> and then cut with the other one
2020-10-06 01:38:07 +0200 <ski> (i should have included ⌜k : B⌝ in ⌜Δ⌝, for the ⌜¬x::k⌝ derivation, above)
2020-10-06 01:38:15 +0200 <dolio> Oh, you never put k in the context.
2020-10-06 01:38:18 +0200 <dolio> Yeah.
2020-10-06 01:38:25 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-06 01:39:28 +0200 <ski> hm, so we have a "critical pair"
2020-10-06 01:39:44 +0200 <ski> each one side wanting to override the other one
2020-10-06 01:40:23 +0200 <dolio> Yeah, so you need an evaluation strategy to decide what happens.
2020-10-06 01:40:35 +0200 <ski> mm
2020-10-06 01:40:47 +0200 <ski> i'm not seeing where by-need ties into this, atm, though
2020-10-06 01:44:18 +0200 <ski> <dolio> ski, carter: I think another example is: if the continuation starts by doing case analysis on a sum type that is closed over by the continuation, you should just reduce that out of the continuation the first time you go through it, and memoize the result.
2020-10-06 01:44:22 +0200 <ski> <dolio> ski: The first time you evaluate a lazy let function call, you should remember the value it produces.
2020-10-06 01:44:31 +0200 <ski> <dolio> ski: `let y = f x` is naming (y) a computation that matches up closed-over variables in a par redex that might do non-trivial amounts of work before reducing to a value. So call-by-need says that when you want its value, you should do the work and remember the value.
2020-10-06 01:44:42 +0200 <ski> (backtracking back to these now)
2020-10-06 01:45:14 +0200 <dolio> Suppose `let` wins, B is by-name, and y occurs multiple times. Then the beta reduction happens twice, because we duplicate the whole term (I think).
2020-10-06 01:45:37 +0200 <ski> "a sum type that is closed over by the continuation", would that be ⌜y⌝, above ?
2020-10-06 01:46:45 +0200 <dolio> No, that would be the dual case.
2020-10-06 01:47:09 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-06 01:47:25 +0200inkbottle(~inkbottle@aaubervilliers-654-1-101-245.w86-212.abo.wanadoo.fr) (Quit: Konversation terminated!)
2020-10-06 01:47:25 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0) (Ping timeout: 240 seconds)
2020-10-06 01:47:32 +0200 <ski> Γ ⊢ ξ k. ⟨f|¬x::k⟩ : B | Δ ∸ (k : B) Γ | let y. ⋯y⋯ : B ⊢ Δ
2020-10-06 01:47:35 +0200 <ski> ─────────────────────────────────────────────────────────────
2020-10-06 01:47:39 +0200 <ski> Γ ⊢{ ⟨ξ k. ⟨f|¬x::k⟩|let y. ⋯y⋯⟩ } Δ
2020-10-06 01:47:44 +0200 <ski> (spelling the final cut out, for easy reference)
2020-10-06 01:47:45 +0200inkbottle(~inkbottle@aaubervilliers-654-1-101-245.w86-212.abo.wanadoo.fr)
2020-10-06 01:48:38 +0200vicfred(~vicfred@unaffiliated/vicfred) (Quit: Leaving)
2020-10-06 01:48:44 +0200 <dolio> <λ[¬x::k] ... | ¬x::k> is a par redex, <inl x | case{inl x -> ... | inr y -> ...}> is a + redex.
2020-10-06 01:48:48 +0200albert_91(~Albert@p200300e5ff0b5b4248a33bded2872db1.dip0.t-ipconnect.de)
2020-10-06 01:48:51 +0200conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-10-06 01:49:23 +0200 <int-e> carter: Fine there you go
2020-10-06 01:50:20 +0200 <ski> hm, yes. in the latter, the continuation is a pair of two continuations
2020-10-06 01:50:38 +0200 <ski> (thinking about the former)
2020-10-06 01:50:59 +0200justache(~justache@unaffiliated/justache) (Ping timeout: 260 seconds)
2020-10-06 01:50:59 +0200 <dolio> Yeah, but it's a pair of continuataions that does arbitrary computation in each case.
2020-10-06 01:51:12 +0200 <ski> as opposed to ?
2020-10-06 01:51:21 +0200 <dolio> Whereas par has continuations that are well-founded trees.
2020-10-06 01:51:44 +0200 <dolio> At least, those are teh values.
2020-10-06 01:51:48 +0200 <ski> how do you mean ?
2020-10-06 01:51:55 +0200 <dolio> That 'case' is a continuation value for +.
2020-10-06 01:52:01 +0200 <ski> yes
2020-10-06 01:53:39 +0200albert_91(~Albert@p200300e5ff0b5b4248a33bded2872db1.dip0.t-ipconnect.de) (Ping timeout: 272 seconds)
2020-10-06 01:53:46 +0200 <dolio> Well, it's not quite true once you get into all the polarity shifting. But if you work in the system without any shifts, then par is only applicable to hereditarily by-name codata types, and those have continuation values that are well-founded trees, just like data types have term values that are well-founded trees.
2020-10-06 01:53:59 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de)
2020-10-06 01:54:21 +0200 <ski> hm, ok
2020-10-06 01:54:56 +0200 <dolio> Codata covalues are the tree of all the projections, data values are the tree of all the constructors.
2020-10-06 01:55:27 +0200machinedgod(~machinedg@24.105.81.50)
2020-10-06 01:55:58 +0200 <dolio> And you're only allowed to substitute (co)values for variables.
2020-10-06 01:56:07 +0200conal(~conal@64.71.133.70)
2020-10-06 01:58:25 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-06 01:59:36 +0200 <ski> (loking at the typing rules in the paper now .. i think i was thinking of another right rule for `par')
2020-10-06 02:00:01 +0200jesusabdullah(~jesusabdu@178.162.204.214) ()
2020-10-06 02:00:13 +0200justache(~justache@unaffiliated/justache)
2020-10-06 02:00:26 +0200 <ski> in the reductions in the first figure in the paper, are they only substituting (co)values for variables ?
2020-10-06 02:00:48 +0200 <ski> or maybe that's the initial system they start with, and want to improve on
2020-10-06 02:00:59 +0200 <dolio> I think the first figure is showing you the problem with classical logic.
2020-10-06 02:01:05 +0200 <dolio> First section, even.
2020-10-06 02:01:25 +0200hiroaki(~hiroaki@ip4d176049.dynamic.kabel-deutschland.de) (Ping timeout: 240 seconds)
2020-10-06 02:01:43 +0200 <dolio> So they can over-fix it, and then relax into something that can actually be used (kind of).
2020-10-06 02:02:13 +0200 <ski> mhm (over-fix ?)
2020-10-06 02:03:32 +0200 <dolio> Well, when everything is hereditarily by-name or by-value, you can't write some things, I think.
2020-10-06 02:04:30 +0200 <dolio> You can't put a function value in an either.
2020-10-06 02:05:28 +0200 <ski> hm, so some escaping from / explicit switching of polarity, i suppose
2020-10-06 02:05:44 +0200 <dolio> Yeah.
2020-10-06 02:08:09 +0200xerox_(~xerox@unaffiliated/xerox) (Ping timeout: 256 seconds)
2020-10-06 02:08:34 +0200GyroW_(~GyroW@d54C03E98.access.telenet.be)
2020-10-06 02:08:34 +0200GyroW_(~GyroW@d54C03E98.access.telenet.be) (Changing host)
2020-10-06 02:08:34 +0200GyroW_(~GyroW@unaffiliated/gyrow)
2020-10-06 02:08:45 +0200 <dolio> Actually, the identity function isn't even well-typed, I think.
2020-10-06 02:09:08 +0200GyroW(~GyroW@unaffiliated/gyrow) (Ping timeout: 256 seconds)
2020-10-06 02:09:09 +0200 <dolio> Because `A \par ¬A` doesn't make sense. A would have to be both positive and negative.
2020-10-06 02:12:01 +0200martin02(silas@hund.fs.lmu.de) (Ping timeout: 272 seconds)
2020-10-06 02:13:49 +0200snakemasterflex(~snakemast@213.100.206.23)
2020-10-06 02:14:58 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:71a4:5e3f:3433:7ae1)
2020-10-06 02:18:25 +0200snakemasterflex(~snakemast@213.100.206.23) (Ping timeout: 240 seconds)
2020-10-06 02:22:19 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-10-06 02:22:45 +0200amiri(~amiri@cpe-76-91-154-9.socal.res.rr.com) (Read error: No route to host)
2020-10-06 02:23:39 +0200acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 260 seconds)
2020-10-06 02:23:56 +0200amiri(~amiri@cpe-76-91-154-9.socal.res.rr.com)
2020-10-06 02:26:02 +0200tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Read error: Connection reset by peer)
2020-10-06 02:26:39 +0200tromp(~tromp@dhcp-077-249-230-040.chello.nl)
2020-10-06 02:31:44 +0200acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2020-10-06 02:32:25 +0200 <ski> hm. reminds me of dinatural transformations
2020-10-06 02:32:43 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-06 02:34:49 +0200alp(~alp@2a01:e0a:58b:4920:e03a:3413:fb91:53fc) (Ping timeout: 272 seconds)
2020-10-06 02:35:24 +0200nineonine(~nineonine@216.81.48.202) (Remote host closed the connection)
2020-10-06 02:37:45 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:71a4:5e3f:3433:7ae1) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 02:42:49 +0200polyrain(~polyrain@2001:8003:e501:6901:a41a:145a:3fce:c107) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 02:44:18 +0200conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-10-06 02:47:07 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:71a4:5e3f:3433:7ae1)
2020-10-06 02:47:45 +0200acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 240 seconds)
2020-10-06 02:48:17 +0200nineonine(~nineonine@216-19-190-182.dyn.novuscom.net)
2020-10-06 02:49:39 +0200zoom84(44beb1c9@068-190-177-201.res.spectrum.com) (Ping timeout: 245 seconds)
2020-10-06 02:49:55 +0200da39a3ee5e6b4b0d(~textual@n11211935170.netvigator.com)
2020-10-06 02:51:41 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0)
2020-10-06 02:51:52 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-10-06 02:51:55 +0200 <Squarism> Anyone got some idea on this. I want users of a library be able to create a type TheType that can consist of any composition of records/lists/maybe/either/tuple2. All "leafs" of this structure should be of type "forall a. Leafy a => Leaf a". I want to create a serializable/textual addressing by type "Path" so that I can do that I can implement : get :: forall a b. (Leafy a,THDerivedMagic b) => b -> Path -> Maybe (Leaf a). Or, as a will be lost, ge
2020-10-06 02:51:55 +0200 <Squarism> (THDerivedMagic b) => b -> Path -> Maybe LeafProjection.
2020-10-06 02:52:22 +0200LarryTheCow(~user@cpe-104-34-71-94.socal.res.rr.com)
2020-10-06 02:53:04 +0200 <Squarism> a textual/serializable getter lens that rely on the fact all leafs carry the same parameterized type.
2020-10-06 02:53:57 +0200 <ski> cut off after ".. Or, as a will be lost, ge"
2020-10-06 02:54:40 +0200rob01(~rob0@178.162.204.214)
2020-10-06 02:54:51 +0200 <Squarism> where THDerivedMagic is an instance that TheType gets after compilation
2020-10-06 02:55:24 +0200notzmv`(~user@179.246.218.173)
2020-10-06 02:55:31 +0200 <ski> "all leafs carry the same parameterized type" -- hm, "All \"leafs\" of this structure should be of type \"forall a. Leafy a => Leaf a\"" sounded like you had something like `data TheType = ... | forall a. Leafy a => Leaf a', in which case not all leaves would have the same type
2020-10-06 02:55:32 +0200 <Squarism> ski, it continued on next row there
2020-10-06 02:55:52 +0200polyrain(~polyrain@2001:8003:e501:6901:a41a:145a:3fce:c107)
2020-10-06 02:56:02 +0200 <ski> hm, so you're saying you wrote ".. Or, as a will be lost, ge(THDerivedMagic b) => b -> Path -> Maybe LeafProjection.", then ? nothing missing in the middle ?
2020-10-06 02:56:34 +0200 <Squarism> oh ok. Man, I have a hard time explaining / figuring this out.
2020-10-06 02:56:57 +0200notzmv`zmv
2020-10-06 02:57:01 +0200zmv(~user@179.246.218.173) (Changing host)
2020-10-06 02:57:01 +0200zmv(~user@unaffiliated/zmv)
2020-10-06 02:57:15 +0200 <Squarism> ski, get :: (THDerivedMagic b) => b -> Path -> Maybe LeafProjection
2020-10-06 02:57:18 +0200notzmv(~user@unaffiliated/zmv) (Ping timeout: 256 seconds)
2020-10-06 02:57:26 +0200zmvnotzmv
2020-10-06 02:57:36 +0200plutoniix(~q@175.176.222.7)
2020-10-06 02:58:33 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-06 02:58:48 +0200 <ski> first, i was thinking you might want something like `data TheType = FromList [TheType] | FromMaybe (Maybe TheType) | FromEither (Either TheType TheType) | FromPair (TheType,TheType) | forall a. Leafy a => Leaf a' (not sure what to do with records) .. but then the `THDerivedMagic b => ..b..' part seemed to suggest you wanted to reflect the actual structure of the nested types, in the Haskell type `b' (rather
2020-10-06 02:58:54 +0200 <ski> than using a single "universe" type `TheType')
2020-10-06 02:58:56 +0200 <ski> Squarism : ty
2020-10-06 02:59:19 +0200 <ski> i dunno what `LeafProjection' is for
2020-10-06 02:59:52 +0200 <Squarism> I guess I'm trying to provide half of the solution wo knowing if its a good idea or not.
2020-10-06 03:01:06 +0200 <Squarism> Important parts are really. Let users define a type using above mentioned constructs. Be able to address leafs of that structure using textual paths/addresses.
2020-10-06 03:01:07 +0200 <ski> i'm not sure what `Leafy' includes .. nor what `THDerivedMagic' would provide
2020-10-06 03:01:25 +0200 <Squarism> neither do I really.
2020-10-06 03:02:04 +0200 <Squarism> But previous message formalizes the basic requirement.
2020-10-06 03:02:10 +0200 <ski> why do you want users to express themselves using exactly those particular type constructions, when interfacing with your library ?
2020-10-06 03:02:32 +0200 <ski> do you intend to serialize values of types constructed in such a way ?
2020-10-06 03:03:21 +0200 <ski> what if the user would like to use some other type, e.g. maybe `NonEmpty' or `Map' or `Queue' ?
2020-10-06 03:03:32 +0200 <Squarism> I want them to freely define a process as basic data structure.
2020-10-06 03:03:39 +0200 <Squarism> that is TheType
2020-10-06 03:03:49 +0200 <ski> i don't understand what you mean by that
2020-10-06 03:04:15 +0200aarvar(~foewfoiew@50.35.43.33) (Ping timeout: 260 seconds)
2020-10-06 03:04:55 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0) (Ping timeout: 240 seconds)
2020-10-06 03:06:13 +0200xsperry(~as@unaffiliated/xsperry) (Ping timeout: 264 seconds)
2020-10-06 03:06:18 +0200 <ski> for the `TheType' i mentioned, i guess you could have `data Path = Here | ToIndex Int Path | InJust Path | InLeft Path | InRight Path | InFst Path | InSnd Path'
2020-10-06 03:06:58 +0200 <ski> (not sure to which extent that type would make sense, for what you're trying to do)
2020-10-06 03:07:54 +0200dansho(~dansho@ip68-108-167-185.lv.lv.cox.net)
2020-10-06 03:08:15 +0200 <ski> oh .. and i suspect that instead of `get :: forall a b. (Leafy a,THDerivedMagic b) => b -> Path -> Maybe (Leaf a)', you may have intended something like `get :: forall b. THDerivedMagic b => b -> Path -> Maybe (exists a. Leafy *> a)' ..
2020-10-06 03:08:32 +0200 <ski> .. perhaps `exists a. Leafy *> a' is what you meant by `LeafProjection' ?
2020-10-06 03:08:40 +0200 <Squarism> Lets call the Leaf a type Step a. So users could define data TheType = TheType { s1 :: Step S1, s2 :: Maybe (Step S2, Maybe (Step S3)) } . Which would be a very simple process. Easy to serializa and pattern match
2020-10-06 03:09:25 +0200ericsagnes(~ericsagne@2405:6580:0:5100:a920:8792:1be2:949f) (Ping timeout: 240 seconds)
2020-10-06 03:09:30 +0200 <Squarism> so basically i just want to great serializable addressing of Step's in this structure.
2020-10-06 03:09:44 +0200 <ski> another thing one could imagine (with `Path' a GADT) would be `get :: forall a b. THDerivedMagic b => b -> Path b a -> Maybe b' (dunno if you'd want a `Leafy b' somewhere in there)
2020-10-06 03:10:06 +0200xerox_(~xerox@unaffiliated/xerox)
2020-10-06 03:10:09 +0200 <ski> er, sorry, that should be : `get :: forall a b. THDerivedMagic b => b -> Path b a -> Maybe a' (dunno if you'd want a `Leafy a' somewhere in there)
2020-10-06 03:10:53 +0200 <ski> Squarism : wait a moment. is `TheType' something the library defines, or something a user of the library would define ?
2020-10-06 03:11:15 +0200 <Squarism> Something the that the user defines
2020-10-06 03:11:44 +0200 <L29Ah> https://github.com/kowainik/learn4haskell lol
2020-10-06 03:11:45 +0200 <Squarism> Basically I want to a simple textual lens library.
2020-10-06 03:11:58 +0200abhixec(~abhixec@c-67-169-141-95.hsd1.ca.comcast.net)
2020-10-06 03:12:10 +0200 <ski> (also, i thought `Leaf' was to be a data constructor, not a type constructor. if it was meant as a type constructor, then i doubt that you really meant `forall a. Leafy a => Leaf a' before. perhaps rather `exists a. Leafy a *> Leaf a')
2020-10-06 03:12:11 +0200ystael(~ystael@209.6.50.55) (Ping timeout: 240 seconds)
2020-10-06 03:12:44 +0200 <Squarism> ski, okok
2020-10-06 03:13:33 +0200 <ski> i don't understand what `Step' is for
2020-10-06 03:13:47 +0200 <ski> what is `S1',`S2',`S3' ?
2020-10-06 03:13:49 +0200 <Squarism> its the same as "Leaf a"
2020-10-06 03:14:11 +0200 <ski> yes, but i don't understand what `Leaf' is for, either, if it's a type constructor
2020-10-06 03:14:14 +0200 <Squarism> S1-3 are parameters to "Step a"
2020-10-06 03:14:24 +0200 <Squarism> its a type and and constructor
2020-10-06 03:14:27 +0200 <ski> yes, but what purpose does `Step' have ?
2020-10-06 03:14:37 +0200 <ski> which is a type and a constructor ?
2020-10-06 03:15:28 +0200 <Squarism> A requirement on "TheType" (verified by TH presumebly) is that all leafs of the datastructure are of that type.
2020-10-06 03:16:00 +0200 <ski> also, you didn't answer whether the library or the user would define `TheType'
2020-10-06 03:16:16 +0200 <Squarism> I use Leaf/Step interchangeably (sorry for that). Same thing
2020-10-06 03:16:18 +0200 <ski> oh. actually, i'm sorry. you did
2020-10-06 03:16:24 +0200 <Squarism> so data Step
2020-10-06 03:16:33 +0200 <ski> (i think i got confused by the other link, at the time)
2020-10-06 03:16:36 +0200 <Squarism> data Step a = Step a
2020-10-06 03:16:53 +0200 <ski> that looks fairly useless, to me
2020-10-06 03:17:06 +0200 <Squarism> which part?
2020-10-06 03:17:15 +0200 <ski> the whole `data' type declaration
2020-10-06 03:17:23 +0200 <ski> it's basically just `Identity'
2020-10-06 03:17:29 +0200xsperry(~as@unaffiliated/xsperry)
2020-10-06 03:17:32 +0200 <ski> why use `Step S1' instead of just `S1' directly ?
2020-10-06 03:17:49 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-06 03:17:49 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-06 03:17:49 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-06 03:18:00 +0200GyroW_(~GyroW@unaffiliated/gyrow) (Ping timeout: 272 seconds)
2020-10-06 03:18:06 +0200 <Squarism> yeah, But I leave out other information as its not important for the task at hand "Step a" will contain other info too
2020-10-06 03:18:16 +0200 <ski> ok
2020-10-06 03:19:06 +0200 <ski> so, the user defines some `TheType' data type, and makes it (maybe using TH), an instance of some type class (perhaps `THDerivedMagic')
2020-10-06 03:19:31 +0200 <ski> is that correct ?
2020-10-06 03:19:36 +0200 <Squarism> correct.
2020-10-06 03:19:40 +0200 <Squarism> BUT
2020-10-06 03:20:02 +0200ystael(~ystael@209.6.50.55)
2020-10-06 03:20:35 +0200 <Squarism> What THDerivedMagic contains I really have to clear idea of yet. I see it will be needed at some point to collect the "analysis" of TheType.
2020-10-06 03:20:41 +0200 <ski> if `TheType' derives `Generic', i think you could use that to inspect how `TheType' was constructed, so that you can do different things, in e.g. an instance of `THDerivedMagic', depending on whether you see a record, a list, a `Maybe', a pair, an `Either'
2020-10-06 03:21:14 +0200Saukk(~Saukk@2001:998:f1:3963:1c59:9bb5:b94c:2)
2020-10-06 03:21:44 +0200 <ski> i think looking into docs for `Generic' (or `Data' ?) could possibly be useful, for what(ever) you're actually trying to do
2020-10-06 03:22:21 +0200 <Squarism> So the gist of this is. Give basic lens functionality to some type (TheType - defined by user). First milestone, create a getter on TheType (automatically) that answers "Maybe (StepProjection)"
2020-10-06 03:22:22 +0200ericsagnes(~ericsagne@2405:6580:0:5100:11f9:52f9:c5f:a031)
2020-10-06 03:22:51 +0200 <Squarism> and by "lens" I mean textual/serializable addresses as opposed to real lenses.
2020-10-06 03:23:15 +0200 <Squarism> ski, ok, ill read up on Generic
2020-10-06 03:23:55 +0200fraktor(~walt@129.93.191.18) (Ping timeout: 240 seconds)
2020-10-06 03:26:00 +0200 <ski> <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#generic-programm…>,<https://downloads.haskell.org/~ghc/latest/docs/html/libraries/base-4.14.0.0/GHC-Generics.html>
2020-10-06 03:26:08 +0200 <ski> Squarism ^
2020-10-06 03:26:10 +0200fraktor(~walt@129.93.191.18)
2020-10-06 03:26:42 +0200totallynotnate(~nate@125.160.143.17)
2020-10-06 03:26:52 +0200 <Squarism> ski, thanks. I stumbled upon that class before and see you can have a point there. I need to refresh my memory
2020-10-06 03:27:23 +0200 <ski> i'm not totally sure whether you can do what you want to do with this. but it sounds like it could possibly be relevant
2020-10-06 03:27:37 +0200totallynotnate(~nate@125.160.143.17) (Client Quit)
2020-10-06 03:27:56 +0200 <Squarism> ski, thanks for helping me process this. Really appreciated.
2020-10-06 03:28:03 +0200cr3(~cr3@192-222-143-195.qc.cable.ebox.net) (Ping timeout: 260 seconds)
2020-10-06 03:28:18 +0200 <ski> Squarism : anyway, what's `StepProjection' for ?
2020-10-06 03:29:29 +0200mirrorbird(~psutcliff@2a00:801:2d5:9d73:ff00:6553:d451:a276)
2020-10-06 03:30:23 +0200 <Squarism> ski, results of the getter need to be sent over the wire. Then "a" of Step a will be out of scope. So need to make a type independent type (?) =D
2020-10-06 03:30:41 +0200 <Squarism> "a" of "Step a"
2020-10-06 03:31:58 +0200 <ski> "will be out of scope" -- out of which scope ?
2020-10-06 03:32:46 +0200 <ski> could `StepProjection' be something like `exists a. (Leafy a,Typeable a) *> a' ?
2020-10-06 03:34:00 +0200taurux(~taurux@net-93-146-149-217.cust.vodafonedsl.it) (Ping timeout: 244 seconds)
2020-10-06 03:34:39 +0200taurux(~taurux@net-188-152-143-169.cust.dsl.teletu.it)
2020-10-06 03:37:54 +0200cr3(~cr3@192-222-143-195.qc.cable.ebox.net)
2020-10-06 03:40:59 +0200Lowl3v3l(~Lowl3v3l@dslb-090-186-188-115.090.186.pools.vodafone-ip.de) (Ping timeout: 240 seconds)
2020-10-06 03:41:41 +0200 <Squarism> ski, imagine some "REST Controller" delegating the "get" application on TheType".
2020-10-06 03:42:05 +0200 <Squarism> ...that will work for all implementations of TheType
2020-10-06 03:42:18 +0200 <Squarism> or should i say definitions
2020-10-06 03:43:18 +0200ddellacosta(~dd@86.106.121.168) (Ping timeout: 244 seconds)
2020-10-06 03:44:24 +0200 <Squarism> ski, " could `StepProjection' be something like `exists a. (Leafy a,Typeable a) *> a' ?" ... I really dont know. Wouldnt "a" need to be in function scope for such applications?
2020-10-06 03:44:29 +0200machinedgod(~machinedg@24.105.81.50) (Ping timeout: 256 seconds)
2020-10-06 03:44:41 +0200jedws(~jedws@121.209.186.103)
2020-10-06 03:47:15 +0200 <ski> by `StepProjection' encoding `exists a. (Leafy a,Typeable a) *> a' i mean something like `data StepProjection = forall a. (Leafy a,Typeable a) => MkStepProjection a', or the equivalent (using `GADTSyntax') `data StepProjection where MkStepProjection :: (Leafy a,Typeable a) => a -> StepProjection'
2020-10-06 03:48:03 +0200 <ski> (i dunno what you mean by "Wouldnt \"a\" need to be in function scope for such applications?" -- what is "function scope" ? are you thinking of any particular function (`get' ?) ?)
2020-10-06 03:48:28 +0200ryansmccoy(~ryansmcco@156.96.151.132) (Ping timeout: 244 seconds)
2020-10-06 03:48:48 +0200shatriff(~vitaliish@217.27.153.240) (Remote host closed the connection)
2020-10-06 03:49:05 +0200ryansmccoy(~ryansmcco@193.37.254.27)
2020-10-06 03:49:06 +0200shatriff(~vitaliish@217.27.153.240)
2020-10-06 03:49:21 +0200albert_91(~Albert@p200300e5ff0b5b4248a33bded2872db1.dip0.t-ipconnect.de)
2020-10-06 03:49:36 +0200shatriff(~vitaliish@217.27.153.240) (Remote host closed the connection)
2020-10-06 03:49:55 +0200shatriff(~vitaliish@217.27.153.240)
2020-10-06 03:50:25 +0200shatriff(~vitaliish@217.27.153.240) (Remote host closed the connection)
2020-10-06 03:50:43 +0200shatriff(~vitaliish@217.27.153.240)
2020-10-06 03:51:10 +0200 <ski> (an alternative encoding of `exists a. (Leafy a,Typeable a) *> a' is `forall o. (forall a. (Leafy a,Typeable a) => a -> o) -> o'. this is CPS (Continuation-Passing Style), where you pass your main result to a callback (a continuation). like `withCString :: String -> (CString -> IO a) -> IO a' or `withStep :: StepProjection -> (forall a. (Leafy a,Typeable a) => a -> o) -> o')
2020-10-06 03:51:11 +0200shatriff(~vitaliish@217.27.153.240) (Remote host closed the connection)
2020-10-06 03:51:31 +0200shatriff(~vitaliish@217.27.153.240)
2020-10-06 03:51:57 +0200shatriff(~vitaliish@217.27.153.240) (Remote host closed the connection)
2020-10-06 03:52:01 +0200argent0(~argent0@168.227.97.5) (Quit: leaving)
2020-10-06 03:52:02 +0200 <ski> (or, i suppose, `get :: forall b. THDerivedMagic b => b -> Path -> (forall a. (Leafy a,Typeable a) => a -> o) -> o', directly)
2020-10-06 03:53:08 +0200 <Squarism> ski, yeah "get". If I had say `myRestEndpoint :: Path -> SomeSerializableStep ; myRestEndpoint p = let r = get theTypeInstance in convertToSomeSerializableStep r` wouldnt it complain about not knowing what "a" is. "Not bound"
2020-10-06 03:53:54 +0200 <Squarism> (oh forgot to pass p to get ^)
2020-10-06 03:54:26 +0200 <ski> (better to say `theTypeValue', since "instance" means something else, in Haskell)
2020-10-06 03:54:37 +0200albert_91(~Albert@p200300e5ff0b5b4248a33bded2872db1.dip0.t-ipconnect.de) (Ping timeout: 272 seconds)
2020-10-06 03:54:49 +0200 <ski> Squarism : what's the intended type of `convertToSomeSerializableStep', here ?
2020-10-06 03:55:22 +0200 <ski> convertToSomeSerializableStep :: Leafy a => a -> SomeSerializableStep -- ?
2020-10-06 03:55:28 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de)
2020-10-06 03:55:49 +0200Lowl3v3l(~Lowl3v3l@dslb-002-203-195-108.002.203.pools.vodafone-ip.de)
2020-10-06 03:55:57 +0200 <Squarism> not that important. Something that could contain the important informaiton `forall a. Step a`
2020-10-06 03:56:14 +0200 <ski> myRestEndpoint p = get theTypeValue p convertToSomeSerializableStep -- in that case. using the CPS version of `get'
2020-10-06 03:57:15 +0200Gurkenglas(~Gurkengla@unaffiliated/gurkenglas) (Ping timeout: 244 seconds)
2020-10-06 03:57:30 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:71a4:5e3f:3433:7ae1) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 03:59:25 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-06 03:59:57 +0200zacts(~zacts@dragora/developer/zacts)
2020-10-06 04:00:03 +0200abhixec(~abhixec@c-67-169-141-95.hsd1.ca.comcast.net) (Read error: Connection reset by peer)
2020-10-06 04:01:58 +0200snakemasterflex(~snakemast@213.100.206.23)
2020-10-06 04:06:47 +0200snakemasterflex(~snakemast@213.100.206.23) (Ping timeout: 260 seconds)
2020-10-06 04:07:41 +0200GyroW(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-06 04:08:00 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-06 04:08:00 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-06 04:08:00 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-06 04:10:10 +0200slack1256(~slack1256@181.203.50.26)
2020-10-06 04:11:49 +0200mathlover2(~mathlover@2604:6000:1013:129e:755e:eccf:8735:da37)
2020-10-06 04:12:11 +0200zebrag(~inkbottle@aaubervilliers-654-1-95-218.w86-212.abo.wanadoo.fr)
2020-10-06 04:12:49 +0200inkbottle(~inkbottle@aaubervilliers-654-1-101-245.w86-212.abo.wanadoo.fr) (Ping timeout: 264 seconds)
2020-10-06 04:16:49 +0200urodna(~urodna@unaffiliated/urodna) (Quit: urodna)
2020-10-06 04:18:58 +0200Wuzzy(~Wuzzy@p5790e6f5.dip0.t-ipconnect.de) (Remote host closed the connection)
2020-10-06 04:18:59 +0200 <hololeap> how important is it to know where to add INLINE pragmas these days? will compiling with -O2 on the latest GHC be sufficient without worrying about using INLINE?
2020-10-06 04:19:26 +0200solonarv(~solonarv@astrasbourg-653-1-252-112.w92-161.abo.wanadoo.fr) (Ping timeout: 272 seconds)
2020-10-06 04:19:31 +0200hololeapis actually using GHC 8.8.4, not the latest one
2020-10-06 04:20:22 +0200 <dolio> Depends on the program.
2020-10-06 04:20:42 +0200berberman_(~berberman@2408:8207:2560:ee60::a44)
2020-10-06 04:20:46 +0200solonarv(~solonarv@adijon-655-1-70-207.w90-13.abo.wanadoo.fr)
2020-10-06 04:23:19 +0200 <hololeap> can you elaborate, dolio?
2020-10-06 04:23:42 +0200 <dolio> Well, if I remove all the inline pragmas from vector-algorithms, it will be a lot slower.
2020-10-06 04:23:57 +0200 <dolio> (Unless I compensate in other ways.)
2020-10-06 04:24:07 +0200berberman(~berberman@2408:8207:2560:ee60:584e:a9ff:fe9b:d3fe) (Ping timeout: 244 seconds)
2020-10-06 04:24:28 +0200cosimone(~cosimone@2001:b07:ae5:db26:f68c:50ff:fe0b:b774)
2020-10-06 04:24:34 +0200cosimone(~cosimone@2001:b07:ae5:db26:f68c:50ff:fe0b:b774) (Client Quit)
2020-10-06 04:24:36 +0200 <dsal> If you need something inlined, or need it not inlined, you should say so.
2020-10-06 04:25:26 +0200cosimone(~cosimone@2001:b07:ae5:db26:f68c:50ff:fe0b:b774)
2020-10-06 04:25:30 +0200 <dolio> That isn't the only significant factor, necessarily. But sometimes it enables important optimizations, and GHC will not automatically inline everything.
2020-10-06 04:25:55 +0200 <dolio> Inlining everything isn't even really desirable.
2020-10-06 04:25:58 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com)
2020-10-06 04:25:59 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com) (Changing host)
2020-10-06 04:25:59 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 04:26:10 +0200cosimone(~cosimone@2001:b07:ae5:db26:f68c:50ff:fe0b:b774) (Client Quit)
2020-10-06 04:26:32 +0200 <hololeap> i don't understand what makes a function needing to be inlined, where GHC wouldn't already do it automatically. is there a good primer on all this?
2020-10-06 04:26:33 +0200 <dsal> Does GHC ever automatically inline anything? I've had pretty big optimizations from telling it to inline things I thought would be obvious.
2020-10-06 04:26:56 +0200 <dolio> Well, here's an example from vector-algorithms again.
2020-10-06 04:27:11 +0200 <dolio> The algorithms need to be inlined so that the code can be specialized to the comparison function.
2020-10-06 04:27:18 +0200 <dsal> If you have a tiny function you use in a lot of places, copying the instructions will be faster than making a function call.
2020-10-06 04:27:33 +0200 <dolio> Because if that doesn't happen, the overhead of comparing integers will be massive.
2020-10-06 04:28:01 +0200brandly(~brandly@c-73-68-15-46.hsd1.ma.comcast.net)
2020-10-06 04:28:06 +0200 <hololeap> dsal: what determines the size of a function?
2020-10-06 04:28:09 +0200 <dolio> Like, a couple instructions on unboxed values vs. function calls on boxed values.
2020-10-06 04:29:19 +0200 <dsal> hololeap: I mean like, you write the abstraction that makes sense, but if you have something that's called enough that the overhead of calling it makes a difference in your runtime, inlining might help.
2020-10-06 04:29:57 +0200 <dolio> The actual size of the expression is the size.
2020-10-06 04:30:05 +0200 <dolio> I'm not sure what exactly the threshold is.
2020-10-06 04:30:39 +0200 <dsal> If it's a lot of code, and you use it in a lot of places, inlining while make your code a lot bigger and your cache less effective.
2020-10-06 04:31:20 +0200 <dolio> I'm pretty sure `f x = x + x` is small enough for GHC to decide to inline it automatically. But if you're in doubt, and it matters, it's better to annotate it.
2020-10-06 04:31:31 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 256 seconds)
2020-10-06 04:31:36 +0200user2(~user@068-190-177-201.res.spectrum.com)
2020-10-06 04:31:49 +0200 <hololeap> ok, it's becoming clearer
2020-10-06 04:32:33 +0200user2(~user@068-190-177-201.res.spectrum.com) (Client Quit)
2020-10-06 04:33:40 +0200 <dolio> I've been experimenting with doing vector-algorithms with backpack, and that doesn't require inlining tons of code.
2020-10-06 04:33:52 +0200 <hololeap> the problem is, i've been spending all my time learning haskell focusing on semantics and getting stuff to compile. i haven't looked into performance or tweaking GHC at all beyond using -O2 every time
2020-10-06 04:33:55 +0200 <dolio> Because you can specialize the implementation to the comparson/types.
2020-10-06 04:34:42 +0200 <dolio> Well, it might not matter a whole lot depending on what you're doing.
2020-10-06 04:35:37 +0200 <dolio> If you're trying to beat C's qsort, though, it matters.
2020-10-06 04:36:44 +0200 <hololeap> i'm using a lot of newtype wrappers around monad transformer stacks; packing and unpacking while using inherited typeclasses. and a lot of production code i've seen uses INLINE a lot for this type of thing. but i wonder how much of it is necessary.
2020-10-06 04:37:18 +0200zoom55AA(~zoom55aa@068-190-177-201.res.spectrum.com)
2020-10-06 04:37:24 +0200 <dsal> Profiling is usually a good step before taking action.
2020-10-06 04:37:45 +0200 <dsal> benchmarking helps both as well, but benchmarking as an effort can be pretty misleading.
2020-10-06 04:38:27 +0200 <hololeap> i don't even understand the difference between profiling and benchmarking :/
2020-10-06 04:39:18 +0200 <dsal> benchmarking is writing a tool that gives you a repeatable measurement.
2020-10-06 04:39:25 +0200 <dsal> profiling is using a tool that tells you where time is spent.
2020-10-06 04:39:41 +0200rusua_(uid124537@gateway/web/irccloud.com/x-mpizelreyaaubxup) (Quit: Connection closed for inactivity)
2020-10-06 04:40:03 +0200 <dsal> So profiling might tell you that a particular function is where you spend a lot of your time. So you write a benchmark for that function, and then do stuff to the implementation until the benchmark gives you consistently better results.
2020-10-06 04:40:18 +0200 <dsal> It's a little tricky in haskell, but the tools are helpful.
2020-10-06 04:40:30 +0200 <hololeap> what tools should i be looking into?
2020-10-06 04:40:53 +0200 <dsal> criterion (or whatever that lighter version is people use, but I still use criterion, I think)
2020-10-06 04:41:11 +0200 <dsal> And like, wherever "how to profile haskell" takes you.
2020-10-06 04:42:02 +0200 <hololeap> cool, i will crawl the web for it, but i also appreciate specific advice from people who have done it.
2020-10-06 04:42:24 +0200 <dsal> stack test --profile
2020-10-06 04:42:37 +0200 <dsal> It's a report you read.
2020-10-06 04:43:21 +0200 <dsal> Your test or application or whatever runs and then you look at it, stroke your bear, say "hmm... I see" and then your code is faster.
2020-10-06 04:44:01 +0200 <dsal> In any case, you don't try to optimize anything you're not measuring.
2020-10-06 04:44:13 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:71a4:5e3f:3433:7ae1)
2020-10-06 04:44:19 +0200 <dsal> I've seen every optimization you can think of slow code down.
2020-10-06 04:44:41 +0200abhixec(~abhixec@c-67-169-141-95.hsd1.ca.comcast.net)
2020-10-06 04:44:41 +0200 <hololeap> is the species of bear a crucial variable in this equation?
2020-10-06 04:45:02 +0200cr3(~cr3@192-222-143-195.qc.cable.ebox.net) (Quit: leaving)
2020-10-06 04:45:16 +0200 <dsal> Maybe. It's best to go in without assumptions.
2020-10-06 04:45:17 +0200ski. o O ( "Let's hug a bear." )
2020-10-06 04:45:57 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0)
2020-10-06 04:46:17 +0200Stanley00(~stanley00@unaffiliated/stanley00)
2020-10-06 04:47:55 +0200ralejs_(~ralejs@2620:10d:c093:400::5:2842) (Read error: Connection reset by peer)
2020-10-06 04:48:23 +0200ralejs(~ralejs@2620:10d:c093:400::5:2842)
2020-10-06 04:49:31 +0200vicfred(~vicfred@unaffiliated/vicfred)
2020-10-06 04:50:51 +0200zoom55AA(~zoom55aa@068-190-177-201.res.spectrum.com) ("WeeChat 2.9")
2020-10-06 04:51:40 +0200zoom84(~zoom55aa@068-190-177-201.res.spectrum.com)
2020-10-06 04:51:47 +0200lagothrix(~lagothrix@unaffiliated/lagothrix) (Killed (hitchcock.freenode.net (Nickname regained by services)))
2020-10-06 04:51:55 +0200lagothrix(~lagothrix@unaffiliated/lagothrix)
2020-10-06 04:54:06 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0) (Remote host closed the connection)
2020-10-06 04:56:58 +0200hackagereanimate-svg 0.12.0.0 - SVG file loader and serializer https://hackage.haskell.org/package/reanimate-svg-0.12.0.0 (DavidHimmelstrup)
2020-10-06 04:58:35 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 04:58:54 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0)
2020-10-06 05:00:01 +0200rob01(~rob0@178.162.204.214) ()
2020-10-06 05:01:34 +0200drbean(~drbean@TC210-63-209-99.static.apol.com.tw)
2020-10-06 05:02:55 +0200berberman_(~berberman@2408:8207:2560:ee60::a44) (Ping timeout: 240 seconds)
2020-10-06 05:03:40 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 256 seconds)
2020-10-06 05:04:09 +0200berberman(~berberman@2408:8207:2563:5ae0:584e:a9ff:fe9b:d3fe)
2020-10-06 05:06:25 +0200drbean(~drbean@TC210-63-209-99.static.apol.com.tw) (Client Quit)
2020-10-06 05:16:08 +0200notzmv`(~user@177.45.26.174)
2020-10-06 05:17:23 +0200notzmv(~user@unaffiliated/zmv) (Ping timeout: 240 seconds)
2020-10-06 05:17:27 +0200elliott_(~elliott@pool-108-51-141-12.washdc.fios.verizon.net)
2020-10-06 05:17:38 +0200bloodstalker(~bloodstal@46.166.187.178) (Read error: Connection reset by peer)
2020-10-06 05:18:04 +0200 <zoom84> when I load a module with a type error in a function, GHCI shows me the expected and actual types, and also shows me all the bindings. is there a way to display the bindings on command for a given function, outside of compile errors
2020-10-06 05:18:51 +0200 <dsal> The bindings? Are you debugging?
2020-10-06 05:18:58 +0200 <dsal> Or do you just want type annotations?
2020-10-06 05:18:59 +0200 <dsal> :T fix
2020-10-06 05:19:00 +0200 <dsal> :t fix
2020-10-06 05:19:02 +0200 <lambdabot> (a -> a) -> a
2020-10-06 05:19:21 +0200 <zoom84> more exploring than debugging
2020-10-06 05:19:37 +0200 <zoom84> :t shows me the sig. i'm looking to the the sig and the bindings that resulted from it
2020-10-06 05:19:39 +0200 <lambdabot> error:
2020-10-06 05:19:39 +0200 <lambdabot> • Variable not in scope: me
2020-10-06 05:19:39 +0200 <lambdabot> • Perhaps you meant one of these:
2020-10-06 05:19:41 +0200 <dsal> There's :browse and :i and :t
2020-10-06 05:19:51 +0200 <dsal> I'm not quite sure what you mean by bindings.
2020-10-06 05:20:07 +0200 <zoom84> for example, here are the bindings displayed for a compile error:
2020-10-06 05:20:07 +0200 <dsal> Local variables inside of functions? That's not normally a thing that you care about from the outside.
2020-10-06 05:20:29 +0200 <zoom84> • Occurs check: cannot construct the infinite type: a ~ (a, a)
2020-10-06 05:20:31 +0200 <zoom84> • In the first argument of ‘f’, namely ‘(x, y)’
2020-10-06 05:20:32 +0200 <solonarv> you can add a typed hole somewhere in the function; that will produce a compile error telling you: the type of what should fill the hole; bindings in scope; and expressions that might be able to fill the hole
2020-10-06 05:20:33 +0200 <zoom84> In the expression: f (x, y)
2020-10-06 05:20:35 +0200 <zoom84> In an equation for ‘fmap’: fmap f (MyT (x, y)) = f (x, y)
2020-10-06 05:20:37 +0200 <zoom84> • Relevant bindings include
2020-10-06 05:20:39 +0200 <zoom84> y :: a (bound at learn.hs:806:20)
2020-10-06 05:20:41 +0200 <zoom84> x :: a (bound at learn.hs:806:18)
2020-10-06 05:20:43 +0200 <zoom84> f :: a -> b (bound at learn.hs:806:10)
2020-10-06 05:20:45 +0200 <zoom84> fmap :: (a -> b) -> MyTT a -> MyTT b (bound at learn.hs:806:5)
2020-10-06 05:20:47 +0200 <zoom84> i'm looking to display the "relevent bindings include" section on command
2020-10-06 05:21:02 +0200 <dsal> Yeah, typed holes and pastebins
2020-10-06 05:21:02 +0200 <solonarv> a typed hole looks like this: _ , or _someNameHere (has to start with an underscore)
2020-10-06 05:21:46 +0200toorevitimirp(~tooreviti@117.182.180.245)
2020-10-06 05:22:16 +0200 <dsal> Once you get your function done, it's basically a sealed box. None of the insides matter to you. When you're writing something, typed holes induce that type of thing and help you understand what goes somewhere when you're confused.
2020-10-06 05:22:49 +0200GyroW(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-06 05:23:00 +0200GyroW(~GyroW@d54C03E98.access.telenet.be)
2020-10-06 05:23:00 +0200GyroW(~GyroW@d54C03E98.access.telenet.be) (Changing host)
2020-10-06 05:23:00 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-06 05:23:15 +0200conal(~conal@64.71.133.70)
2020-10-06 05:23:43 +0200 <zoom84> not clear where I put the typehole. do I create a new pattern match line and just do a _ on it
2020-10-06 05:24:01 +0200 <dsal> You put it anywhere you'd put a value, but you don't know what the value is that you need.
2020-10-06 05:24:09 +0200 <dsal> % 1 + _
2020-10-06 05:24:14 +0200 <yahb> dsal: [Timed out]
2020-10-06 05:24:19 +0200 <dsal> heh. Thanks, yahb
2020-10-06 05:24:50 +0200 <dsal> % maximum _
2020-10-06 05:24:56 +0200 <yahb> dsal: ; <interactive>:1:9: error:; * Found hole: _ :: [a]; Where: `a' is a rigid type variable bound by; the inferred type of it :: Ord a => a; at <interactive>:1:1-9; * In the first argument of `maximum', namely `_'; In the expression: maximum _; In an equation for `it': it = maximum _; * Relevant bindings include it :: a (bound at <interactive>:1:1);
2020-10-06 05:25:18 +0200slack1256(~slack1256@181.203.50.26) (Ping timeout: 272 seconds)
2020-10-06 05:25:23 +0200 <dsal> So, I need a list of things that have an Ord instance.
2020-10-06 05:26:28 +0200 <zoom84> i put the type hole on both the left and right site of the pattern, right?
2020-10-06 05:26:48 +0200 <dsal> % let x = 1 :: Int in 1 + _
2020-10-06 05:26:52 +0200 <yahb> dsal: ; <interactive>:2:26: error:; * Found hole: _ :: a; Where: `a' is a rigid type variable bound by; the inferred type of it :: Num a => a; at <interactive>:2:1-26; * In the second argument of `(+)', namely `_'; In the expression: 1 + _; In the expression: let x = 1 :: Int in 1 + _; * Relevant bindings include; x :: Int (bound at <interactive>
2020-10-06 05:27:03 +0200 <dsal> You can put them where you'd like. It will make suggestions for you. e.g., it suggests x here.
2020-10-06 05:28:17 +0200 <zoom84> if I put it only on the destructuring side doesn't that just mean I'm not interested in the pattern-matched value and thus it's not an error
2020-10-06 05:28:54 +0200drbean(~drbean@TC210-63-209-213.static.apol.com.tw)
2020-10-06 05:29:26 +0200 <dsal> % let x = 1 :: Int; y = 2 :: Int in _ x y + x -- contriving kind of hard, but run this in your ghci
2020-10-06 05:29:28 +0200 <yahb> dsal: ; <interactive>:4:38: error:; * Found hole: _ :: Int -> Int -> Int; * In the expression: _; In the first argument of `(+)', namely `_ x y'; In the expression: _ x y + x; * Relevant bindings include; x :: Int (bound at <interactive>:4:7); y :: Int (bound at <interactive>:4:21); it :: Int (bound at <interactive>:4:1); Valid hole fits include; (-) ::
2020-10-06 05:30:05 +0200 <dsal> Oh, yeah, if it's a parameter binding, it just means "don't care"
2020-10-06 05:30:28 +0200 <zoom84> ok, it only works if I put it inside the function body
2020-10-06 05:30:41 +0200 <zoom84> got it, thanks
2020-10-06 05:31:20 +0200slack1256(~slack1256@181.203.50.26)
2020-10-06 05:31:36 +0200 <dsal> Well, it works if you put it somewhere you want to try to find a possible match. This can't be a parameter, for example, because that's input. If you want to know possible parameter values, you _ the caller
2020-10-06 05:32:57 +0200 <zoom84> the hole trick works great, thanks
2020-10-06 05:37:05 +0200jedws(~jedws@121.209.186.103) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 05:38:36 +0200slack1256(~slack1256@181.203.50.26) (Remote host closed the connection)
2020-10-06 05:38:41 +0200vk3wtf(~doc@14-202-30-62.static.tpgi.com.au) (Quit: WeeChat 2.7.1)
2020-10-06 05:39:04 +0200vk3wtf(~doc@14-202-30-62.static.tpgi.com.au)
2020-10-06 05:41:25 +0200jwynn6(~jwynn6@050-088-122-078.res.spectrum.com)
2020-10-06 05:43:39 +0200CMCDragonkai1(~Thunderbi@120.17.228.7)
2020-10-06 05:47:33 +0200polyrain(~polyrain@2001:8003:e501:6901:a41a:145a:3fce:c107) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 05:50:19 +0200albert_91(~Albert@p200300e5ff0b5b4248a33bded2872db1.dip0.t-ipconnect.de)
2020-10-06 05:51:45 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2020-10-06 05:51:59 +0200Unhammer(~Unhammer@gateway/tor-sasl/unhammer) (Remote host closed the connection)
2020-10-06 05:52:09 +0200petersen(~petersen@redhat/juhp) (Quit: petersen)
2020-10-06 05:52:25 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0) (Ping timeout: 272 seconds)
2020-10-06 05:52:36 +0200Unhammer(~Unhammer@gateway/tor-sasl/unhammer)
2020-10-06 05:54:26 +0200CMCDragonkai1(~Thunderbi@120.17.228.7) (Ping timeout: 272 seconds)
2020-10-06 05:55:35 +0200albert_91(~Albert@p200300e5ff0b5b4248a33bded2872db1.dip0.t-ipconnect.de) (Ping timeout: 272 seconds)
2020-10-06 05:55:52 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-06 05:59:09 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:71a4:5e3f:3433:7ae1) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 05:59:59 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311)
2020-10-06 06:01:03 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2020-10-06 06:01:15 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0)
2020-10-06 06:01:59 +0200Saukk(~Saukk@2001:998:f1:3963:1c59:9bb5:b94c:2) (Remote host closed the connection)
2020-10-06 06:03:23 +0200elliott_(~elliott@pool-108-51-141-12.washdc.fios.verizon.net) (Ping timeout: 260 seconds)
2020-10-06 06:03:57 +0200hackageyesod-filter 0.1.0.0 - Automatic filter generator for Yesod https://hackage.haskell.org/package/yesod-filter-0.1.0.0 (KenzoYotsuya)
2020-10-06 06:04:06 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:71a4:5e3f:3433:7ae1)
2020-10-06 06:07:20 +0200bbear(~dkremer@2a01:e34:ec2b:d430:cc93:67b2:c4ea:7463) (Remote host closed the connection)
2020-10-06 06:10:24 +0200angerman_angerman
2020-10-06 06:13:17 +0200jedws(~jedws@121.209.186.103)
2020-10-06 06:13:49 +0200 <gnumonik> Hello. I'm having some trouble with the lens library. I have a complicated data structure that consists of a product type that contains a record which is a list of a sum type. I would like to use the library to write a function that allows me to set/"over" a specific (indexed) element of the list (if it exists). I can't figure out if I can do that. Everything I try runs into "can't deduce As(sum type) (Product type)" (I'm using
2020-10-06 06:13:49 +0200 <gnumonik> classy prisms). AFAIK I can't write a prism for a product type so I can't actually declare the instance and I'm wondering if there's another way to do this. Could someone point me in the right direction?
2020-10-06 06:16:29 +0200shafox(~shafox@106.51.234.111)
2020-10-06 06:16:40 +0200 <c_wraith> You can certainly do it. You just need to ensure you actually have the necessary lenses available.
2020-10-06 06:16:43 +0200 <hololeap> zoom84, _ has type `a` (e.g. anything, similar to `undefined`) and you can use it multiple times and get multiple error messages
2020-10-06 06:17:31 +0200 <c_wraith> if you don't have a sum type, don't try to create a prism for it?
2020-10-06 06:18:17 +0200Sheilong(uid293653@gateway/web/irccloud.com/x-wunoznsilndrshkm) ()
2020-10-06 06:18:37 +0200 <hololeap> gnumonik: you might want to look at a data structure instead of lists, which supports something better than O(n) lookups with an index
2020-10-06 06:19:23 +0200 <hololeap> like Seq (O(log(n))) or Vector (O(n))
2020-10-06 06:19:34 +0200 <hololeap> oops... Vector (O(1))
2020-10-06 06:19:37 +0200 <c_wraith> that seems like an entirely useless criticism
2020-10-06 06:19:49 +0200 <c_wraith> also, if you're using over, Vector is also O(n)
2020-10-06 06:19:57 +0200 <c_wraith> because it has to allocate an entire new one
2020-10-06 06:21:01 +0200 <dsal> A nice thing about using lens is you can replace a list with a vector without changing code.
2020-10-06 06:21:05 +0200 <hololeap> well, it would be more efficient when getter
2020-10-06 06:21:18 +0200 <hololeap> *using a getter
2020-10-06 06:22:13 +0200 <gnumonik> The lists are so short I doubt that'll make much of a difference. So actually I'm writing template haskell to generate setting/over functions, and the only case in which it doesn't work is where I have a product with one component that's a list of a sum type. And the only clue I have as to why it's not working is that can't deduce error :-(
2020-10-06 06:23:35 +0200 <c_wraith> well, the nice thing about lens is composability. Break things down and figure out exactly which part is sketchy.
2020-10-06 06:25:57 +0200massma(~user@dyn-160-39-62-152.dyn.columbia.edu) (Quit: rcirc on GNU Emacs 26.1)
2020-10-06 06:29:12 +0200MasterGruntR75(~MasterGru@185.244.214.216)
2020-10-06 06:35:00 +0200kori(~kori@2804:14c:85a3:9105::1000)
2020-10-06 06:35:00 +0200kori(~kori@2804:14c:85a3:9105::1000) (Changing host)
2020-10-06 06:35:00 +0200kori(~kori@arrowheads/kori)
2020-10-06 06:35:36 +0200haritz(~hrtz@unaffiliated/haritz) (Ping timeout: 272 seconds)
2020-10-06 06:36:31 +0200 <hololeap> :t \x y -> _ (x + y)
2020-10-06 06:36:36 +0200 <lambdabot> error:
2020-10-06 06:36:36 +0200 <lambdabot> • Found hole: _ :: t -> t1
2020-10-06 06:36:36 +0200 <lambdabot> Where: ‘t’, ‘t1’ are rigid type variables bound by
2020-10-06 06:37:13 +0200haritz(~hrtz@62.3.70.206)
2020-10-06 06:37:14 +0200haritz(~hrtz@62.3.70.206) (Changing host)
2020-10-06 06:37:14 +0200haritz(~hrtz@unaffiliated/haritz)
2020-10-06 06:38:39 +0200day_(~Unknown@unaffiliated/day)
2020-10-06 06:39:29 +0200 <gnumonik> I'm not even sure how to break this down. I've been at this for more than a week... This seems like it should work: myFunc adt val adtLens fieldPrism i = set' (adtLens . ix i . fieldPrism) val adt. But it doesn't for the list-of-sums-inside-a-product. The sketchy part, as far as I can tell, is that the product type doesn't have an instance of a class that it can't possibly have. Oh well.
2020-10-06 06:39:53 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2020-10-06 06:40:29 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-06 06:41:02 +0200zoom84(~zoom55aa@068-190-177-201.res.spectrum.com) (Quit: WeeChat 2.9)
2020-10-06 06:41:18 +0200zoom84(~user@068-190-177-201.res.spectrum.com)
2020-10-06 06:41:56 +0200day(~Unknown@unaffiliated/day) (Ping timeout: 272 seconds)
2020-10-06 06:41:56 +0200day_day
2020-10-06 06:42:21 +0200 <Axman6> gnumonik: can you share a more concrete example?
2020-10-06 06:44:39 +0200 <Axman6> gnumonik: given that code it's difficult to tell what the types are, I can sort of infer them, but some type signatures and definitions of the sums and products would be good
2020-10-06 06:45:44 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 272 seconds)
2020-10-06 06:46:09 +0200 <Axman6> :t set'
2020-10-06 06:46:11 +0200 <lambdabot> ASetter' s a -> a -> s -> s
2020-10-06 06:46:16 +0200 <Axman6> :t set
2020-10-06 06:46:18 +0200 <lambdabot> ASetter s t a b -> b -> s -> t
2020-10-06 06:47:32 +0200 <hololeap> doesn't lens composition get reversed from the usual order, e.g. (fieldPrism . ix i . adtLens), assuming that the sum type is the "topmost" structure
2020-10-06 06:47:56 +0200solonarv(~solonarv@adijon-655-1-70-207.w90-13.abo.wanadoo.fr) (Ping timeout: 256 seconds)
2020-10-06 06:47:58 +0200zacts(~zacts@dragora/developer/zacts) (Quit: leaving)
2020-10-06 06:48:11 +0200brandly(~brandly@c-73-68-15-46.hsd1.ma.comcast.net) (Ping timeout: 240 seconds)
2020-10-06 06:48:32 +0200 <Axman6> yeah if it's a product containing a list containing a sum then it would be fieldLens . ix i . sumPrism
2020-10-06 06:48:43 +0200 <hololeap> "topmost" isn't very descriptive. i mean the first structure you navigate
2020-10-06 06:48:54 +0200 <hololeap> right
2020-10-06 06:49:07 +0200 <Axman6> it looks to me like it is doing the right thing, assuming it is what I said it is
2020-10-06 06:50:43 +0200 <hololeap> oh, so it would be the normal order of composition then (same as functions)? i remembered composing lens' to be the opposite of what you usually do
2020-10-06 06:51:54 +0200 <gnumonik> It's actually a sum containing a product containing a list of sums. The actual context of this is pretty substantial. I'm writing a protocol analyzer that wraps different message types in one big sum type. The 'adtLens' thing is actually a composition of lenses and prisms but I dunno that that matters
2020-10-06 06:52:28 +0200 <hololeap> sorry, i misread
2020-10-06 06:52:35 +0200hololeapedges away from the conversation
2020-10-06 06:54:08 +0200 <dsal> > Right (1, [Right 2, Left 3, Right 4]) ^.. _Right . _2 . folded . _Right
2020-10-06 06:54:11 +0200 <lambdabot> [2,4]
2020-10-06 06:56:23 +0200 <dsal> > Right (1, [Right 2, Left 3, Right 4]) & _Right . _2 . traversed . _Right %~ (^2)
2020-10-06 06:56:25 +0200 <lambdabot> Right (1,[Right 4,Left 3,Right 16])
2020-10-06 06:56:32 +0200 <Axman6> :t (folded, each)
2020-10-06 06:56:34 +0200 <lambdabot> (Indexable Int p, Contravariant f1, Each s t a1 b, Foldable f2, Applicative f1, Applicative f3) => (p a2 (f1 a2) -> f2 a2 -> f1 (f2 a2), (a1 -> f3 b) -> s -> f3 t)
2020-10-06 06:56:44 +0200zoom84(~user@068-190-177-201.res.spectrum.com) (Quit: WeeChat 2.9)
2020-10-06 06:57:03 +0200 <dsal> Oh, I never think of each like that. That's pretty neat.
2020-10-06 06:57:15 +0200 <dsal> Lens doesn't fit in my tiny headcache
2020-10-06 06:58:55 +0200ixian(~mgold@2002:4a74:ba78:1701:0:ff:fe78:6269) (Ping timeout: 240 seconds)
2020-10-06 07:00:37 +0200ixian(~mgold@terra.bitplane.org)
2020-10-06 07:01:26 +0200 <gnumonik> Ugh I can't even make this more concrete. If there's nothing wrong with that function then I think I just can't do what I want with lens. That's literally the function I use.
2020-10-06 07:03:28 +0200dansho(~dansho@ip68-108-167-185.lv.lv.cox.net) (Remote host closed the connection)
2020-10-06 07:04:12 +0200 <dsal> The above examples match your description. It's hard to guess what you're doing differently.
2020-10-06 07:06:28 +0200hackagereanimate-svg 0.12.1.0 - SVG file loader and serializer https://hackage.haskell.org/package/reanimate-svg-0.12.1.0 (DavidHimmelstrup)
2020-10-06 07:09:44 +0200mathlover2(~mathlover@2604:6000:1013:129e:755e:eccf:8735:da37) (Quit: Leaving)
2020-10-06 07:09:55 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0) (Ping timeout: 240 seconds)
2020-10-06 07:10:35 +0200xff0x(~fox@2001:1a81:5339:8000:bdc7:ef33:4985:5e4f)
2020-10-06 07:10:44 +0200GyroW_(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-06 07:10:45 +0200GyroW_(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-06 07:10:45 +0200GyroW_(~GyroW@unaffiliated/gyrow)
2020-10-06 07:11:07 +0200GyroW(~GyroW@unaffiliated/gyrow) (Ping timeout: 260 seconds)
2020-10-06 07:11:53 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-06 07:13:29 +0200 <gnumonik> Well, if I'm going to start over I have a question: My goal here is to find a way to expose lens functionality to the user without writing a bunch of boilerplate for every record field/constructor. I was trying to use TH to generate parsers for every valid combination of nested records/type constructors (i.e. the string "foo.bar" parses to the composition of lenses foo and bar). Is there an... obvious easier way to do that?
2020-10-06 07:13:54 +0200coot(~coot@37.30.49.218.nat.umts.dynamic.t-mobile.pl)
2020-10-06 07:14:42 +0200 <dsal> the lens library does that for you.
2020-10-06 07:16:42 +0200 <gnumonik> huh? how?
2020-10-06 07:16:43 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2020-10-06 07:18:27 +0200snakemasterflex(~snakemast@213.100.206.23)
2020-10-06 07:18:33 +0200Tritlo(sid58727@gateway/web/irccloud.com/x-vuffzyrxnybrguux) (Ping timeout: 272 seconds)
2020-10-06 07:18:50 +0200howdoi(uid224@gateway/web/irccloud.com/x-bfkecngtkcukjezu) (Quit: Connection closed for inactivity)
2020-10-06 07:19:55 +0200ishutin_(~Ishutin@193-110-63-54.cable-modem.hdsnet.hu)
2020-10-06 07:20:10 +0200Tritlo(sid58727@gateway/web/irccloud.com/x-gcmzpwtjgmfrhnky)
2020-10-06 07:20:13 +0200 <gnumonik> Er maybe that wasn't clear. What I really need is a function :: String -> Lens, since I was hoping to use the functionality in a small DSL. When I say I'm trying to generate parsers, I mean functions that take strings and spit out lenses/prisms/traversals. (I'm sorry if this is stupid, Haskell's my first programming language and I've been teaching myself without much guidance)
2020-10-06 07:22:45 +0200snakemasterflex(~snakemast@213.100.206.23) (Ping timeout: 240 seconds)
2020-10-06 07:23:18 +0200ishutin(~Ishutin@92-249-150-146.static.digikabel.hu) (Ping timeout: 260 seconds)
2020-10-06 07:24:41 +0200petersen(~petersen@redhat/juhp)
2020-10-06 07:26:45 +0200snakemasterflex(~snakemast@213.100.206.23)
2020-10-06 07:27:01 +0200kori(~kori@arrowheads/kori) (Ping timeout: 244 seconds)
2020-10-06 07:27:27 +0200spew(uid195861@gateway/web/irccloud.com/x-zoqmilcrntqznxpj) (Quit: Connection closed for inactivity)
2020-10-06 07:36:10 +0200idhugo(~idhugo@563472ae.rev.stofanet.dk)
2020-10-06 07:37:18 +0200snakemasterflex(~snakemast@213.100.206.23) (Ping timeout: 260 seconds)
2020-10-06 07:37:43 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0)
2020-10-06 07:37:47 +0200shailangsa(~shailangs@host165-120-169-97.range165-120.btcentralplus.com) (Ping timeout: 240 seconds)
2020-10-06 07:37:48 +0200snakemasterflex(~snakemast@213.100.206.23)
2020-10-06 07:41:42 +0200 <jackdk> I think dsal's saying that the point of lens is that lenses themselves compose with `.`, so you shouldn't feel like you have to generate all the compositions yourself
2020-10-06 07:43:50 +0200kori(~kori@arrowheads/kori)
2020-10-06 07:45:31 +0200 <dsal> Well, I mean you don't have to generate the boilerplate for every field. That's what makeLenses does. But doing this at runtime is a bit weird.
2020-10-06 07:46:47 +0200 <[exa]> kindof guess that gnumonik only wants an autogenerated dictionary that does f "foo" = foo
2020-10-06 07:47:10 +0200 <[exa]> the rest (like parsing out the dot and joining the results) can be easily done with the parser
2020-10-06 07:47:57 +0200hackagehoauth2 1.16.0 - Haskell OAuth2 authentication client https://hackage.haskell.org/package/hoauth2-1.16.0 (HaishengWu)
2020-10-06 07:48:28 +0200 <gnumonik> yeah, ideally i'd not have to pre-generate the entire string, but that seemed to work (up to a point anyway) whereas storing a variety of differently-typed lenses in any kind of data structure did not
2020-10-06 07:48:58 +0200idhugo(~idhugo@563472ae.rev.stofanet.dk) (Ping timeout: 260 seconds)
2020-10-06 07:49:06 +0200 <dsal> How would a user use this mechanism?
2020-10-06 07:49:43 +0200 <dsal> Is it just about making runtime errors out of lens expressions?
2020-10-06 07:51:09 +0200albert_91(~Albert@p200300e5ff0b5b4248a33bded2872db1.dip0.t-ipconnect.de)
2020-10-06 07:52:51 +0200 <gnumonik> Not really. I wanted to somehow leverage lens to allow a user to select fields in data types that represent network packets and filter or replace those fields. But given that there are... i dunno, a few thousand network protocols out there, I wanted some way of automating the construction of functions for doing those things.
2020-10-06 07:53:01 +0200bahamas(~lucian@unaffiliated/bahamas)
2020-10-06 07:54:26 +0200 <dsal> I think that makes sense. The string is throwing me off, though. I think it's a confusing detail. If you didn't have the string, and someone were using your library, what would they have to do now in one example?
2020-10-06 07:55:25 +0200albert_91(~Albert@p200300e5ff0b5b4248a33bded2872db1.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-06 07:55:47 +0200shatriff(~vitaliish@217.27.153.240)
2020-10-06 07:56:55 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de)
2020-10-06 07:57:23 +0200 <dsal> because, as jackdk says, you don't need to generate all the combinations, but you might be able to write some useful helpers that skip a few common steps.
2020-10-06 08:00:01 +0200MasterGruntR75(~MasterGru@185.244.214.216) ()
2020-10-06 08:03:07 +0200aplainze1akind(~johndoe@captainludd.powered.by.lunarbnc.net)
2020-10-06 08:03:15 +0200jcarpenter2(~rofl@96.78.87.197)
2020-10-06 08:04:21 +0200 <gnumonik> Well I wasn't exactly writing a library; the rest of the program (it's a packet stream generator/processor, for lack of a better term), is a small dsl for live packet modification/analysis that uses libpcap and the machines library
2020-10-06 08:04:47 +0200carldd10(~carldd@90-224-49-113-no56.tbcn.telia.com)
2020-10-06 08:05:00 +0200brown121407_(~brown1214@2001:19f0:6c01:2b9c:3c66:4201:22f3:3ebc)
2020-10-06 08:05:01 +0200jtojnar(jtojnarmat@gateway/shell/matrix.org/x-gjvcckkmfrtqleyn) (*.net *.split)
2020-10-06 08:05:01 +0200rawles(~r@unaffiliated/rawles) (*.net *.split)
2020-10-06 08:05:01 +0200aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (*.net *.split)
2020-10-06 08:05:01 +0200sphalerite(~sphalerit@NixOS/user/lheckemann) (*.net *.split)
2020-10-06 08:05:01 +0200ocharles(sid30093@musicbrainz/user/ocharles) (*.net *.split)
2020-10-06 08:05:01 +0200metadave(sid28102@gateway/web/irccloud.com/x-saqsamxyttpjnhcp) (*.net *.split)
2020-10-06 08:05:01 +0200ajmcmiddlin(sid284402@gateway/web/irccloud.com/x-ioikmsgxhbssuurt) (*.net *.split)
2020-10-06 08:05:01 +0200cvlad-(sid203065@gateway/web/irccloud.com/x-ohozyplbhkhukaip) (*.net *.split)
2020-10-06 08:05:01 +0200Cir0X(sid221743@gateway/web/irccloud.com/x-cpmvkyxaeuqbghtu) (*.net *.split)
2020-10-06 08:05:01 +0200koankeeper(sid216950@gateway/web/irccloud.com/x-ccxungdzitxujqnk) (*.net *.split)
2020-10-06 08:05:01 +0200rodlogic__(sid214676@gateway/web/irccloud.com/x-baxtgbtrpgxheice) (*.net *.split)
2020-10-06 08:05:01 +0200alehander92(sid331460@gateway/web/irccloud.com/x-kyfpobayuduivyro) (*.net *.split)
2020-10-06 08:05:01 +0200pasukon(sid49097@gateway/web/irccloud.com/x-uwiqcjpvkreobzhx) (*.net *.split)
2020-10-06 08:05:01 +0200Firedancer(sid336191@gateway/web/irccloud.com/x-qvrclkltirfahdkn) (*.net *.split)
2020-10-06 08:05:01 +0200aizen_s(sid462968@gateway/web/irccloud.com/x-tvunfsqxbrkdapxk) (*.net *.split)
2020-10-06 08:05:01 +0200graingert(sid128301@gateway/web/irccloud.com/x-yubepytnnhokizvs) (*.net *.split)
2020-10-06 08:05:01 +0200darthThorik(sid39589@gateway/web/irccloud.com/x-rxkyoafrogbhiwsr) (*.net *.split)
2020-10-06 08:05:01 +0200lexi-lambda(sid92601@gateway/web/irccloud.com/x-domkjkegafyntpmw) (*.net *.split)
2020-10-06 08:05:01 +0200FMJz____(sid279245@gateway/web/irccloud.com/x-elbokqjeheccquxp) (*.net *.split)
2020-10-06 08:05:01 +0200johs(sid246410@gateway/web/irccloud.com/x-muqxisckhdengjbz) (*.net *.split)
2020-10-06 08:05:01 +0200brown121407(~brown1214@fsf/member/brown121407) (*.net *.split)
2020-10-06 08:05:01 +0200pepeiborra(sid443799@gateway/web/irccloud.com/x-srqetfybaannrdjz) (*.net *.split)
2020-10-06 08:05:01 +0200themsay[m](themsaymat@gateway/shell/matrix.org/x-rdynrutjzsdvufmx) (*.net *.split)
2020-10-06 08:05:01 +0200chreekat[m]1(chreekatma@gateway/shell/matrix.org/x-jpfnucpqjtwzgcaa) (*.net *.split)
2020-10-06 08:05:01 +0200thi(sid97277@gateway/web/irccloud.com/x-dqtrzegkhhzyfxqr) (*.net *.split)
2020-10-06 08:05:01 +0200ullbeking(sid5364@gateway/web/irccloud.com/x-usiikxzxacqmemve) (*.net *.split)
2020-10-06 08:05:01 +0200zopsi(zopsi@2600:3c00::f03c:91ff:fe14:551f) (*.net *.split)
2020-10-06 08:05:01 +0200ezzieyguywuf(~Unknown@unaffiliated/ezzieyguywuf) (*.net *.split)
2020-10-06 08:05:01 +0200connrs-(~connrs@runciter.connrs.uk) (*.net *.split)
2020-10-06 08:05:01 +0200thaumavorio(~thaumavor@thaumavor.io) (*.net *.split)
2020-10-06 08:05:01 +0200SolarAquarion(SolarAquar@gateway/shell/panicbnc/x-oeudzyiyixftjdbl) (*.net *.split)
2020-10-06 08:05:01 +0200alvinsj[m](alvinsjmat@gateway/shell/matrix.org/x-zctlkjvmpqfdbdtm) (*.net *.split)
2020-10-06 08:05:01 +0200hololeap(~hololeap@unaffiliated/hololeap) (*.net *.split)
2020-10-06 08:05:01 +0200Xnuk(~xnuk@vultr.xnu.kr) (*.net *.split)
2020-10-06 08:05:01 +0200eyenx(~eyenxeyen@unaffiliated/eye/x-1653358) (*.net *.split)
2020-10-06 08:05:01 +0200Cerise(~jerry@unaffiliated/cerise) (*.net *.split)
2020-10-06 08:05:01 +0200jrqc(~rofl@96.78.87.197) (*.net *.split)
2020-10-06 08:05:01 +0200operand(~operand@is.altijd.moe) (*.net *.split)
2020-10-06 08:05:01 +0200carldd1(~carldd@90-224-49-113-no56.tbcn.telia.com) (*.net *.split)
2020-10-06 08:05:01 +0200CitizenSnips(~CitizenSn@irc.refl.club) (*.net *.split)
2020-10-06 08:05:01 +0200rslima_____(sid26145@gateway/web/irccloud.com/x-vbogpauczgzfxuev) (*.net *.split)
2020-10-06 08:05:01 +0200mudri(sid317655@gateway/web/irccloud.com/x-wgciiciclurklmio) (*.net *.split)
2020-10-06 08:05:01 +0200dopplergange(~dop@titan.pathogen.is) (*.net *.split)
2020-10-06 08:05:01 +0200andi-(~andi-@NixOS/user/andi-) (*.net *.split)
2020-10-06 08:05:01 +0200hyiltiz-M(hyiltizkde@gateway/shell/kde/matrix/x-gsazjbgdfcbtdfre) (*.net *.split)
2020-10-06 08:05:01 +0200joshmeredith(sid387798@gateway/web/irccloud.com/x-lhhtwrcyukiolswv) (*.net *.split)
2020-10-06 08:05:01 +0200pong(chiya@2406:3003:2077:2341::babe) (*.net *.split)
2020-10-06 08:05:01 +0200coeus(~coeus@p200300d02724ef00d20f0ecf5ac74df4.dip0.t-ipconnect.de) (*.net *.split)
2020-10-06 08:05:01 +0200nopf(~frosch@static.179.17.76.144.clients.your-server.de) (*.net *.split)
2020-10-06 08:05:01 +0200M2tias(m2@seri.fi) (*.net *.split)
2020-10-06 08:05:06 +0200polyrain(~polyrain@130.102.13.177)
2020-10-06 08:05:10 +0200CitizenS-(~CitizenSn@irc.refl.club)
2020-10-06 08:05:10 +0200aplainze1akindaplainzetakind
2020-10-06 08:05:12 +0200 <gnumonik> If it were possible (maybe it is? couldn't figure out) to just package ghci in a binary I suppose I could just do that and skip the parsing.
2020-10-06 08:05:13 +0200dopplerg-(~dop@titan.pathogen.is)
2020-10-06 08:05:15 +0200ocharles(sid30093@musicbrainz/user/ocharles)
2020-10-06 08:05:16 +0200lexi-lambda(sid92601@gateway/web/irccloud.com/x-tjxetnhmsaedwtsv)
2020-10-06 08:05:16 +0200mudri(sid317655@gateway/web/irccloud.com/x-ewrkkkqbsfrqlwpo)
2020-10-06 08:05:17 +0200pasukon(sid49097@gateway/web/irccloud.com/x-zvjflytzjcvxxkxp)
2020-10-06 08:05:18 +0200rodlogic__(sid214676@gateway/web/irccloud.com/x-mpkvpqnfqcxewmmv)
2020-10-06 08:05:18 +0200koankeeper(sid216950@gateway/web/irccloud.com/x-bkecwwfkbfgjodrp)
2020-10-06 08:05:19 +0200Cir0X(sid221743@gateway/web/irccloud.com/x-qlritdmlnfgwpmoo)
2020-10-06 08:05:19 +0200cvlad-(sid203065@gateway/web/irccloud.com/x-efqqsgkcshqvhkds)
2020-10-06 08:05:20 +0200thi(sid97277@gateway/web/irccloud.com/x-vjszalnbbkcfzara)
2020-10-06 08:05:20 +0200Firedancer(sid336191@gateway/web/irccloud.com/x-lxrtxgmxxnrqvfvu)
2020-10-06 08:05:21 +0200ajmcmiddlin(sid284402@gateway/web/irccloud.com/x-uarbdiezmlsauejy)
2020-10-06 08:05:22 +0200rawles(~r@unaffiliated/rawles)
2020-10-06 08:05:22 +0200operand(~operand@is.altijd.moe)
2020-10-06 08:05:25 +0200Xnuk(~xnuk@vultr.xnu.kr)
2020-10-06 08:05:26 +0200zopsi(~zopsi@irc.dir.ac)
2020-10-06 08:05:26 +0200thaumavorio(~thaumavor@thaumavor.io)
2020-10-06 08:05:30 +0200connrs(~connrs@runciter.connrs.uk)
2020-10-06 08:05:30 +0200alehander92(sid331460@gateway/web/irccloud.com/x-ialhrufekwqdevrg)
2020-10-06 08:05:30 +0200hololeap(~hololeap@unaffiliated/hololeap)
2020-10-06 08:05:31 +0200hyiltiz-M(hyiltizkde@gateway/shell/kde/matrix/x-szzrzvhizldgudqq)
2020-10-06 08:05:32 +0200eyenx(~eyenxeyen@unaffiliated/eye/x-1653358)
2020-10-06 08:05:32 +0200pepeiborra(sid443799@gateway/web/irccloud.com/x-oyxipiqtflckullf)
2020-10-06 08:05:33 +0200FMJz____(sid279245@gateway/web/irccloud.com/x-vztbmrxtdakgkjkm)
2020-10-06 08:05:33 +0200rslima_____(sid26145@gateway/web/irccloud.com/x-umtfqvjespivtrcw)
2020-10-06 08:05:35 +0200metadave(sid28102@gateway/web/irccloud.com/x-homnjybqfevkpyxd)
2020-10-06 08:05:36 +0200johs(sid246410@gateway/web/irccloud.com/x-jrsdwkwqkuyhnhvg)
2020-10-06 08:05:37 +0200sphalerite(~sphalerit@NixOS/user/lheckemann)
2020-10-06 08:05:41 +0200aizen_s(sid462968@gateway/web/irccloud.com/x-gdqrmywyttbvydrx)
2020-10-06 08:05:41 +0200darthThorik(sid39589@gateway/web/irccloud.com/x-sosblkkrlevwimaq)
2020-10-06 08:06:00 +0200Cerise(~jerry@natsumi.devzero.info)
2020-10-06 08:06:00 +0200Cerise(~jerry@natsumi.devzero.info) (Changing host)
2020-10-06 08:06:00 +0200Cerise(~jerry@unaffiliated/cerise)
2020-10-06 08:06:01 +0200nyd(~nyd@unaffiliated/elysian)
2020-10-06 08:06:05 +0200ullbeking(sid5364@gateway/web/irccloud.com/x-lkffkwwaixuaercd)
2020-10-06 08:06:08 +0200chreekat[m]1(chreekatma@gateway/shell/matrix.org/x-ibewbadsrcqnctfw)
2020-10-06 08:06:11 +0200jtojnar(jtojnarmat@gateway/shell/matrix.org/x-dytikvjqsilohedp)
2020-10-06 08:06:32 +0200graingert(sid128301@gateway/web/irccloud.com/x-yfujwzpliujjotpd)
2020-10-06 08:06:44 +0200mozzarella(~sam@unaffiliated/sam113101) (Remote host closed the connection)
2020-10-06 08:06:53 +0200 <dsal> Oh. Well, I think it'd be far easier to get something parsing haskell to operate on lenses than to build a language that has some of lenses to do a subset of the same thing. After all, we have two bots here that do that. :)
2020-10-06 08:07:41 +0200andi-(~andi-@NixOS/user/andi-)
2020-10-06 08:08:06 +0200GyroW_(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-06 08:08:23 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-06 08:08:24 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-06 08:08:24 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-06 08:09:37 +0200 <gnumonik> The sort of people who might actually use the thing probably aren't going to do so if they have to deal with stack/cabal/etc though. My intended audience wasn't exactly coextensive with haskell users. Bleh.
2020-10-06 08:10:11 +0200themsay[m](themsaymat@gateway/shell/matrix.org/session)
2020-10-06 08:10:11 +0200alvinsj[m](alvinsjmat@gateway/shell/matrix.org/session)
2020-10-06 08:10:11 +0200ezzieyguywuf(~Unknown@unaffiliated/ezzieyguywuf)
2020-10-06 08:10:11 +0200joshmeredith(sid387798@gateway/web/irccloud.com/x-lhhtwrcyukiolswv)
2020-10-06 08:10:11 +0200pong(chiya@2406:3003:2077:2341::babe)
2020-10-06 08:10:11 +0200coeus(~coeus@p200300d02724ef00d20f0ecf5ac74df4.dip0.t-ipconnect.de)
2020-10-06 08:10:11 +0200nopf(~frosch@static.179.17.76.144.clients.your-server.de)
2020-10-06 08:10:11 +0200M2tias(m2@seri.fi)
2020-10-06 08:10:11 +0200alvinsj[m](alvinsjmat@gateway/shell/matrix.org/session) (Changing host)
2020-10-06 08:10:11 +0200alvinsj[m](alvinsjmat@gateway/shell/matrix.org/x-iedunhycfauwrdat)
2020-10-06 08:10:11 +0200themsay[m](themsaymat@gateway/shell/matrix.org/session) (Changing host)
2020-10-06 08:10:11 +0200themsay[m](themsaymat@gateway/shell/matrix.org/x-gldycjibrackcnzk)
2020-10-06 08:10:18 +0200 <dsal> Sure, sure. But I don't install stack to interact with lambdabot :)
2020-10-06 08:10:23 +0200themsay[m](themsaymat@gateway/shell/matrix.org/x-gldycjibrackcnzk) (Max SendQ exceeded)
2020-10-06 08:10:39 +0200danvet_(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa)
2020-10-06 08:11:05 +0200themsay[m](themsaymat@gateway/shell/matrix.org/x-nqzuuncfdzjshmrp)
2020-10-06 08:11:21 +0200 <dsal> > let halt = halt in halt
2020-10-06 08:11:24 +0200 <lambdabot> *Exception: <<loop>>
2020-10-06 08:11:41 +0200 <dsal> Look at that thing solving the halting problem.
2020-10-06 08:12:05 +0200 <dsal> I wonder if I named it something else if it'd still figure out what I was doing. It's pretty clever...
2020-10-06 08:14:55 +0200pierrot(~pi@unaffiliated/pierrot) (Ping timeout: 272 seconds)
2020-10-06 08:19:38 +0200ym555(~ym@156.199.113.15)
2020-10-06 08:19:38 +0200seanvert(~user@177.84.244.242)
2020-10-06 08:22:53 +0200cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net) (Ping timeout: 258 seconds)
2020-10-06 08:24:17 +0200polyrain(~polyrain@130.102.13.177) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 08:24:35 +0200 <gnumonik> Wait is lambdabot actually parsing and evaluating this stuff? Like it's not just echoing to and from a ghci terminal somewhere?
2020-10-06 08:25:59 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:71a4:5e3f:3433:7ae1) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 08:26:55 +0200snakemasterflex(~snakemast@213.100.206.23) (Ping timeout: 240 seconds)
2020-10-06 08:27:07 +0200 <gnumonik> > foldr (+) [1..]
2020-10-06 08:27:10 +0200 <lambdabot> error:
2020-10-06 08:27:10 +0200 <lambdabot> • No instance for (Num [Integer]) arising from a use of ‘e_11’
2020-10-06 08:27:10 +0200 <lambdabot> • In the expression: e_11
2020-10-06 08:27:28 +0200 <gnumonik> Hm it does not work how I thought it did.
2020-10-06 08:28:51 +0200yoeljacobsen(~yoel.jaco@5.28.167.89)
2020-10-06 08:29:02 +0200 <dsal> yahb is more of just a ghci
2020-10-06 08:30:57 +0200 <gnumonik> Well I think lambdabot actually solved my problem. Some combination of mueval and hint should allow me to not have to parse an infinite number of lenses. Yay.
2020-10-06 08:32:04 +0200 <dsal> Yeah, that sounds pretty great.
2020-10-06 08:33:45 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311) ()
2020-10-06 08:35:20 +0200vicfred(~vicfred@unaffiliated/vicfred) (Remote host closed the connection)
2020-10-06 08:35:42 +0200vicfred(~vicfred@unaffiliated/vicfred)
2020-10-06 08:36:40 +0200polyrain(~polyrain@130.102.13.177)
2020-10-06 08:36:47 +0200dhouthoo(~dhouthoo@ptr-eiv6509pb4ifhdr9lsd.18120a2.ip6.access.telenet.be)
2020-10-06 08:39:35 +0200snakemasterflex(~snakemast@213.100.206.23)
2020-10-06 08:45:23 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0) (Remote host closed the connection)
2020-10-06 08:46:43 +0200pierrot(~pi@unaffiliated/pierrot)
2020-10-06 08:52:35 +0200idhugo(~idhugo@eduroam06.au.dk)
2020-10-06 08:52:48 +0200Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net) (Remote host closed the connection)
2020-10-06 08:53:10 +0200Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net)
2020-10-06 08:54:36 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0)
2020-10-06 08:55:42 +0200jden(~jden@185.244.214.216)
2020-10-06 08:57:17 +0200idhugo(~idhugo@eduroam06.au.dk) (Ping timeout: 256 seconds)
2020-10-06 08:59:24 +0200snakemasterflex(~snakemast@213.100.206.23) (Ping timeout: 260 seconds)
2020-10-06 08:59:24 +0200albert_91(~Albert@p200300e5ff0b5b4248a33bded2872db1.dip0.t-ipconnect.de)
2020-10-06 08:59:35 +0200idhugo(~idhugo@users-1190.st.net.au.dk)
2020-10-06 09:00:29 +0200alp(~alp@2a01:e0a:58b:4920:cc00:82e3:fd5:ee39)
2020-10-06 09:00:37 +0200tbreslein(~tbreslein@2a02:8108:140:44f8::3cc4)
2020-10-06 09:01:25 +0200bahamas(~lucian@unaffiliated/bahamas) (Ping timeout: 264 seconds)
2020-10-06 09:01:30 +0200entropygain(levitate@unaffiliated/entropygain)
2020-10-06 09:02:12 +0200mananamenos(~mananamen@84.122.202.215.dyn.user.ono.com)
2020-10-06 09:02:32 +0200chele(~chele@ip5b416ea2.dynamic.kabel-deutschland.de)
2020-10-06 09:02:50 +0200John20(~John@82.46.59.122)
2020-10-06 09:03:00 +0200snakemasterflex(~snakemast@213.100.206.23)
2020-10-06 09:04:09 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de) (Ping timeout: 244 seconds)
2020-10-06 09:04:29 +0200danvet(~danvet@2a02:168:57f4:0:5f80:650d:c6e6:3453)
2020-10-06 09:04:33 +0200danvet(~danvet@2a02:168:57f4:0:5f80:650d:c6e6:3453) (Client Quit)
2020-10-06 09:06:32 +0200tzh(~tzh@2601:448:c500:5300::143b) (Quit: zzz)
2020-10-06 09:06:49 +0200shafox(~shafox@106.51.234.111) (Remote host closed the connection)
2020-10-06 09:07:34 +0200mananamenos_(~mananamen@84.122.202.215.dyn.user.ono.com)
2020-10-06 09:07:41 +0200mananamenos_(~mananamen@84.122.202.215.dyn.user.ono.com) (Read error: Connection reset by peer)
2020-10-06 09:08:01 +0200shafox(~shafox@106.51.234.111)
2020-10-06 09:08:04 +0200shatriff(~vitaliish@217.27.153.240) (Remote host closed the connection)
2020-10-06 09:10:21 +0200Rudd0(~Rudd0@185.189.115.103) (Read error: Connection reset by peer)
2020-10-06 09:10:45 +0200mananamenos(~mananamen@84.122.202.215.dyn.user.ono.com) (Ping timeout: 240 seconds)
2020-10-06 09:14:54 +0200oxide(~lambda@unaffiliated/mclaren)
2020-10-06 09:15:49 +0200kritzefitz(~kritzefit@fw-front.credativ.com)
2020-10-06 09:16:07 +0200SolarAquarion(SolarAquar@gateway/shell/panicbnc/x-wdutgpsghohoucfq)
2020-10-06 09:16:52 +0200JohnTalent(~john@unaffiliated/johntalent) (Quit: leaving)
2020-10-06 09:18:12 +0200albert_91(~Albert@p200300e5ff0b5b4248a33bded2872db1.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2020-10-06 09:18:13 +0200bahamas(~lucian@unaffiliated/bahamas)
2020-10-06 09:18:18 +0200zacts(~zacts@dragora/developer/zacts)
2020-10-06 09:19:47 +0200albert_91(~Albert@p200300e5ff0b5b421cd7bb50d39404b6.dip0.t-ipconnect.de)
2020-10-06 09:22:11 +0200ralejs_(~ralejs@2620:10d:c093:400::5:2842)
2020-10-06 09:22:11 +0200ralejs(~ralejs@2620:10d:c093:400::5:2842) (Read error: Connection reset by peer)
2020-10-06 09:28:27 +0200hackageserverless-haskell 0.12.4 - Deploying Haskell code onto AWS Lambda using Serverless https://hackage.haskell.org/package/serverless-haskell-0.12.4 (AlexeyKotlyarov)
2020-10-06 09:29:42 +0200GyroW(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-06 09:30:00 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-06 09:30:00 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-06 09:30:00 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-06 09:31:35 +0200Sanchayan(~Sanchayan@136.185.184.11)
2020-10-06 09:33:12 +0200oisdk(~oisdk@2001:bb6:3329:d100:4f8:7c72:bd88:6c6a)
2020-10-06 09:33:34 +0200zacts(~zacts@dragora/developer/zacts) (Quit: leaving)
2020-10-06 09:35:19 +0200murphy_(~murphy_@2604:2000:1281:8a9e:c24e:de35:eb75:8dab) (Remote host closed the connection)
2020-10-06 09:35:37 +0200murphy_(~murphy_@2604:2000:1281:8a9e:5be4:8f01:b36d:6549)
2020-10-06 09:36:05 +0200__monty__(~toonn@unaffiliated/toonn)
2020-10-06 09:38:03 +0200abhixec(~abhixec@c-67-169-141-95.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2020-10-06 09:38:37 +0200m0rphism(~m0rphism@HSI-KBW-046-005-177-122.hsi8.kabel-badenwuerttemberg.de)
2020-10-06 09:43:54 +0200Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi)
2020-10-06 09:45:07 +0200polyrain(~polyrain@130.102.13.177) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 09:46:29 +0200mpereira(~mpereira@2a02:810d:f40:d96:1c35:7f2e:59ff:953)
2020-10-06 09:51:55 +0200amiri(~amiri@cpe-76-91-154-9.socal.res.rr.com) (Ping timeout: 240 seconds)
2020-10-06 09:51:59 +0200idhugo_(~idhugo@users-1190.st.net.au.dk)
2020-10-06 09:52:03 +0200amiri(~amiri@cpe-76-91-154-9.socal.res.rr.com)
2020-10-06 09:53:41 +0200polyrain(~polyrain@130.102.13.170)
2020-10-06 09:55:23 +0200idhugo(~idhugo@users-1190.st.net.au.dk) (Ping timeout: 240 seconds)
2020-10-06 09:55:54 +0200Sgeo_(~Sgeo@ool-18b982ad.dyn.optonline.net) (Read error: Connection reset by peer)
2020-10-06 09:57:51 +0200Buntspecht_(~user@unaffiliated/siracusa)
2020-10-06 09:57:52 +0200Buntspecht(~user@unaffiliated/siracusa) (Read error: Connection reset by peer)
2020-10-06 09:58:17 +0200Buntspecht_Buntspecht
2020-10-06 09:59:53 +0200borne(~fritjof@2001:638:708:30da:1afd:4599:bd4b:9f4b)
2020-10-06 10:03:25 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0) (Ping timeout: 240 seconds)
2020-10-06 10:08:07 +0200idhugo_(~idhugo@users-1190.st.net.au.dk) (Ping timeout: 240 seconds)
2020-10-06 10:08:27 +0200hackageservant-auth-client 0.4.1.0 - servant-client/servant-auth compatibility https://hackage.haskell.org/package/servant-auth-client-0.4.1.0 (domenkozar)
2020-10-06 10:11:37 +0200toorevitimirp(~tooreviti@117.182.180.245) (Ping timeout: 264 seconds)
2020-10-06 10:12:41 +0200toorevitimirp(~tooreviti@117.182.180.245)
2020-10-06 10:12:58 +0200hackagepolysemy-zoo 0.7.0.1 - Experimental, user-contributed effects and interpreters for polysemy https://hackage.haskell.org/package/polysemy-zoo-0.7.0.1 (KingoftheHomeless)
2020-10-06 10:17:57 +0200hackageservant-auth-server 0.4.6.0 - servant-server/servant-auth compatibility https://hackage.haskell.org/package/servant-auth-server-0.4.6.0 (domenkozar)
2020-10-06 10:19:58 +0200fendor(~fendor@e237-037.eduroam.tuwien.ac.at)
2020-10-06 10:22:11 +0200jedws(~jedws@121.209.186.103) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 10:22:31 +0200ramon_(~ramon@2001:1c01:3c01:2300:f093:b478:1b8f:4797)
2020-10-06 10:22:51 +0200mirrorbird(~psutcliff@2a00:801:2d5:9d73:ff00:6553:d451:a276) (Ping timeout: 272 seconds)
2020-10-06 10:24:00 +0200cpressey(~cpressey@88.144.95.3)
2020-10-06 10:24:29 +0200chaosmasttter(~chaosmast@p200300c4a73b2e01d0131264df465fff.dip0.t-ipconnect.de)
2020-10-06 10:24:58 +0200hackageservant-auth-swagger 0.2.10.1 - servant-swagger/servant-auth compatibility https://hackage.haskell.org/package/servant-auth-swagger-0.2.10.1 (domenkozar)
2020-10-06 10:25:14 +0200cfricke(~cfricke@unaffiliated/cfricke)
2020-10-06 10:27:12 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0)
2020-10-06 10:27:14 +0200bahamas(~lucian@unaffiliated/bahamas) (Ping timeout: 256 seconds)
2020-10-06 10:27:20 +0200hnOsmium0001(uid453710@gateway/web/irccloud.com/x-lsiqjycknfirtsck) (Quit: Connection closed for inactivity)
2020-10-06 10:27:56 +0200Amras(~Amras@unaffiliated/amras0000)
2020-10-06 10:28:22 +0200taurux(~taurux@net-188-152-143-169.cust.dsl.teletu.it) (Ping timeout: 244 seconds)
2020-10-06 10:28:47 +0200taurux(~taurux@net-93-144-148-40.cust.dsl.teletu.it)
2020-10-06 10:30:31 +0200jedws(~jedws@121.209.186.103)
2020-10-06 10:31:13 +0200jedws(~jedws@121.209.186.103) (Client Quit)
2020-10-06 10:31:19 +0200da39a3ee5e6b4b0d(~textual@n11211935170.netvigator.com) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 10:35:18 +0200Ariakenom(~Ariakenom@193.254.193.1)
2020-10-06 10:35:25 +0200falafel(~falafel@2605:e000:1527:d491:99fe:5613:f0a7:56f0) (Ping timeout: 240 seconds)
2020-10-06 10:37:31 +0200shatriff(~vitaliish@88.155.115.165)
2020-10-06 10:38:17 +0200thc202(~thc202@unaffiliated/thc202)
2020-10-06 10:38:20 +0200taurux(~taurux@net-93-144-148-40.cust.dsl.teletu.it) (Ping timeout: 260 seconds)
2020-10-06 10:38:49 +0200Amras(~Amras@unaffiliated/amras0000) (Remote host closed the connection)
2020-10-06 10:38:55 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com)
2020-10-06 10:38:55 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com) (Changing host)
2020-10-06 10:38:55 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 10:39:25 +0200ramon_(~ramon@2001:1c01:3c01:2300:f093:b478:1b8f:4797) ()
2020-10-06 10:40:02 +0200taurux(~taurux@net-93-146-7-28.cust.vodafonedsl.it)
2020-10-06 10:40:07 +0200ramon_(~ramon@2001:1c01:3c01:2300:f093:b478:1b8f:4797)
2020-10-06 10:42:33 +0200ramon_(~ramon@2001:1c01:3c01:2300:f093:b478:1b8f:4797) (Client Quit)
2020-10-06 10:43:31 +0200albert_99(~Albert@p200300e5ff0b5b39340e476afbaec452.dip0.t-ipconnect.de)
2020-10-06 10:45:55 +0200albert_91(~Albert@p200300e5ff0b5b421cd7bb50d39404b6.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-06 10:48:35 +0200shaman_king(b94186b1@185.65.134.177)
2020-10-06 10:48:37 +0200 <shaman_king> hi all
2020-10-06 10:48:49 +0200 <shaman_king> i want to learn more about haskell and beyond
2020-10-06 10:49:26 +0200livvy(~livvy@gateway/tor-sasl/livvy)
2020-10-06 10:51:21 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net)
2020-10-06 10:54:09 +0200Amras(~Amras@unaffiliated/amras0000)
2020-10-06 10:55:53 +0200 <shaman_king> hi
2020-10-06 11:00:01 +0200jden(~jden@185.244.214.216) ()
2020-10-06 11:00:18 +0200notzmv`(~user@177.45.26.174) (Ping timeout: 260 seconds)
2020-10-06 11:04:11 +0200shatriff(~vitaliish@88.155.115.165) (Remote host closed the connection)
2020-10-06 11:04:58 +0200hackageaterm 0.1.0.2 - serialisation for Haskell values with sharing support https://hackage.haskell.org/package/aterm-0.1.0.2 (ChristianMaeder)
2020-10-06 11:06:11 +0200todda7(~torstein@athedsl-4367507.home.otenet.gr) (Ping timeout: 258 seconds)
2020-10-06 11:07:30 +0200shatriff(~vitaliish@88.155.115.165)
2020-10-06 11:07:35 +0200fendor_(~fendor@212095005149.public.telering.at)
2020-10-06 11:10:32 +0200drbean(~drbean@TC210-63-209-213.static.apol.com.tw) (Ping timeout: 260 seconds)
2020-10-06 11:10:38 +0200Buntspecht(~user@unaffiliated/siracusa) (Quit: Bye!)
2020-10-06 11:10:48 +0200fendor(~fendor@e237-037.eduroam.tuwien.ac.at) (Ping timeout: 256 seconds)
2020-10-06 11:12:40 +0200raichoo(~raichoo@dslb-088-077-027-113.088.077.pools.vodafone-ip.de)
2020-10-06 11:13:50 +0200polyrain(~polyrain@130.102.13.170) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 11:14:55 +0200phaul(~phaul@ruby/staff/phaul) (Ping timeout: 246 seconds)
2020-10-06 11:18:32 +0200 <tomsmeding> If I have a type class 'C s a' with an associated type 'type T a', how can I promise that for every instance 'C s a', the type 'T a' will be an instance of class 'D' (i.e. we will have 'D (T a)')?
2020-10-06 11:19:14 +0200 <tomsmeding> alternatively, can I promise that for a particular instance
2020-10-06 11:19:22 +0200 <shaman_king> i think thats wrong.
2020-10-06 11:19:28 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-10-06 11:20:24 +0200 <tomsmeding> how so?
2020-10-06 11:22:18 +0200Sanchayan(~Sanchayan@136.185.184.11) (Quit: leaving)
2020-10-06 11:22:35 +0200bahamas(~lucian@unaffiliated/bahamas)
2020-10-06 11:25:04 +0200yoeljacobsen(~yoel.jaco@5.28.167.89) (Ping timeout: 246 seconds)
2020-10-06 11:26:28 +0200hackageattoparsec-data 1.0.5 - Parsers for the standard Haskell data types https://hackage.haskell.org/package/attoparsec-data-1.0.5 (NikitaVolkov)
2020-10-06 11:27:17 +0200 <cpressey> tomsmeding: I would be surprised if you could say that directly, but maybe you could constraints on 'a' in both C and D? Or perhaps a smart constructor for D's?
2020-10-06 11:27:31 +0200 <shaman_king> its wrong
2020-10-06 11:27:34 +0200 <dminuoso> tomsmeding: MPTC+fundeps instead of associated types, then you could make it a superclass constraints
2020-10-06 11:27:59 +0200 <tomsmeding> problem is that I don't control D, though I do control C
2020-10-06 11:27:59 +0200 <dminuoso> Or.. is the superclass constraint possible perhaps?
2020-10-06 11:28:24 +0200 <tomsmeding> basically, this is a "shim" for D
2020-10-06 11:29:07 +0200 <tomsmeding> ah yes putting T as a type argument to C and using fundeps might work...
2020-10-06 11:29:09 +0200shaman_king(b94186b1@185.65.134.177) ()
2020-10-06 11:29:15 +0200 <tomsmeding> interesting visit
2020-10-06 11:29:39 +0200 <dminuoso> % class D (T a) => C s a where type T a
2020-10-06 11:29:40 +0200 <yahb> dminuoso:
2020-10-06 11:29:43 +0200 <dminuoso> tomsmeding: ^- this seems to work fine
2020-10-06 11:29:52 +0200 <tomsmeding> oooooooh
2020-10-06 11:30:07 +0200tomsmedingis off to the editor
2020-10-06 11:30:48 +0200Saukk(~Saukk@2001:998:f1:3963:1c59:9bb5:b94c:2)
2020-10-06 11:30:58 +0200ubert(~Thunderbi@2a02:8109:9880:303c:ca5b:76ff:fe29:f233)
2020-10-06 11:33:29 +0200jonathanx(~jonathan@dyn-8-sc.cdg.chalmers.se) (Remote host closed the connection)
2020-10-06 11:34:29 +0200jonathanx(~jonathan@dyn-8-sc.cdg.chalmers.se)
2020-10-06 11:35:47 +0200shatriff(~vitaliish@88.155.115.165) (Remote host closed the connection)
2020-10-06 11:36:00 +0200da39a3ee5e6b4b0d(~textual@n11211935170.netvigator.com)
2020-10-06 11:36:23 +0200seanvert(~user@177.84.244.242) (Read error: Connection reset by peer)
2020-10-06 11:40:14 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de)
2020-10-06 11:41:25 +0200nyd(~nyd@unaffiliated/elysian) (Ping timeout: 240 seconds)
2020-10-06 11:44:10 +0200nyd(~nyd@unaffiliated/elysian)
2020-10-06 11:44:25 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-06 11:45:00 +0200 <tomsmeding> putting 'T a' as an extra type argument to C works very well :)
2020-10-06 11:47:43 +0200kuribas(~user@ptr-25vy0i9yx55ffflw5e3.18120a2.ip6.access.telenet.be)
2020-10-06 11:51:11 +0200 <tomsmeding> and the fundep is indeed necessary
2020-10-06 11:51:55 +0200Lord_of_Life(~Lord@unaffiliated/lord-of-life/x-0885362) (Ping timeout: 240 seconds)
2020-10-06 11:51:59 +0200yoeljacobsen(~yoel.jaco@5.28.167.89)
2020-10-06 11:52:02 +0200Lord_of_Life_(~Lord@unaffiliated/lord-of-life/x-0885362)
2020-10-06 11:53:16 +0200Lord_of_Life_Lord_of_Life
2020-10-06 11:55:05 +0200Implant1(~Implant@178.162.212.214)
2020-10-06 11:56:37 +0200aurieeeh(~aurieh@static.91.102.243.136.clients.your-server.de) (Ping timeout: 260 seconds)
2020-10-06 11:57:01 +0200ArsenArsen(~Arsen@kshare/developer/ArsenArsen) (Ping timeout: 265 seconds)
2020-10-06 11:58:29 +0200auri_(~auri_@fsf/memeber/auri-) (Ping timeout: 272 seconds)
2020-10-06 11:59:13 +0200GyroW(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-06 11:59:15 +0200gekh(~gkh@thor.kevinhill.nl)
2020-10-06 11:59:23 +0200GyroW(~GyroW@d54c03e98.access.telenet.be)
2020-10-06 11:59:23 +0200GyroW(~GyroW@d54c03e98.access.telenet.be) (Changing host)
2020-10-06 11:59:23 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-06 12:00:31 +0200Rudd0(~Rudd0@185.189.115.108)
2020-10-06 12:01:39 +0200petersen(~petersen@redhat/juhp) (Quit: petersen)
2020-10-06 12:01:49 +0200 <kuribas> is there a typeclass to say, type "a" is a record with field "f"?
2020-10-06 12:02:02 +0200ArsenArsen(~Arsen@kshare/developer/ArsenArsen)
2020-10-06 12:02:30 +0200auri_(~auri_@fsf/memeber/auri-)
2020-10-06 12:02:54 +0200aurieeeh(~aurieh@static.91.102.243.136.clients.your-server.de)
2020-10-06 12:03:40 +0200todda7(~torstein@2a02:587:d32:8d00:e12b:ad32:29e:9021)
2020-10-06 12:07:22 +0200 <jiribenes> kuribas: There's a 'HasField' typeclass in GHC https://downloads.haskell.org/ghc/latest/docs/html/libraries/base-4.14.0.0/GHC-Records.html
2020-10-06 12:07:23 +0200fendor_(~fendor@212095005149.public.telering.at) (Read error: Connection reset by peer)
2020-10-06 12:07:23 +0200xerox_(~xerox@unaffiliated/xerox) (Ping timeout: 260 seconds)
2020-10-06 12:07:47 +0200 <kuribas> jiribenes: right, thanks!
2020-10-06 12:09:04 +0200fendor_(~fendor@e237-037.eduroam.tuwien.ac.at)
2020-10-06 12:09:37 +0200coot(~coot@37.30.49.218.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2020-10-06 12:09:57 +0200polyrain(~polyrain@130.102.13.170)
2020-10-06 12:10:05 +0200polyrain(~polyrain@130.102.13.170) (Client Quit)
2020-10-06 12:13:25 +0200olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber) (Ping timeout: 240 seconds)
2020-10-06 12:14:40 +0200zariuq(~zar@fw4.ciirc.cvut.cz)
2020-10-06 12:15:25 +0200GyroW(~GyroW@unaffiliated/gyrow) (Ping timeout: 240 seconds)
2020-10-06 12:15:27 +0200GyroW_(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-06 12:15:27 +0200GyroW_(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-06 12:15:27 +0200GyroW_(~GyroW@unaffiliated/gyrow)
2020-10-06 12:15:56 +0200plutoniix(~q@175.176.222.7) (Quit: Leaving)
2020-10-06 12:17:36 +0200zargoertzel(~zar@fw5.ciirc.cvut.cz) (Ping timeout: 272 seconds)
2020-10-06 12:18:04 +0200akegalj(~akegalj@93-138-123-17.adsl.net.t-com.hr)
2020-10-06 12:19:58 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-06 12:21:37 +0200ralejs(~ralejs@2620:10d:c093:400::5:2842)
2020-10-06 12:21:37 +0200ralejs_(~ralejs@2620:10d:c093:400::5:2842) (Read error: Connection reset by peer)
2020-10-06 12:24:49 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 264 seconds)
2020-10-06 12:25:46 +0200todda7(~torstein@2a02:587:d32:8d00:e12b:ad32:29e:9021) (Quit: Konversation terminated!)
2020-10-06 12:25:58 +0200todda7(~torstein@athedsl-217541.home.otenet.gr)
2020-10-06 12:26:26 +0200olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber)
2020-10-06 12:27:13 +0200notzmv(~user@unaffiliated/zmv)
2020-10-06 12:27:33 +0200phaul(~phaul@ruby/staff/phaul)
2020-10-06 12:30:10 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 246 seconds)
2020-10-06 12:32:17 +0200aarvar(~foewfoiew@50.35.43.33)
2020-10-06 12:33:13 +0200hyiltiz-M(hyiltizkde@gateway/shell/kde/matrix/x-szzrzvhizldgudqq) (*.net *.split)
2020-10-06 12:33:13 +0200ralejs(~ralejs@2620:10d:c093:400::5:2842) (*.net *.split)
2020-10-06 12:33:13 +0200GyroW_(~GyroW@unaffiliated/gyrow) (*.net *.split)
2020-10-06 12:33:13 +0200sphalerite(~sphalerit@NixOS/user/lheckemann) (*.net *.split)
2020-10-06 12:33:13 +0200pasukon(sid49097@gateway/web/irccloud.com/x-zvjflytzjcvxxkxp) (*.net *.split)
2020-10-06 12:33:13 +0200lexi-lambda(sid92601@gateway/web/irccloud.com/x-tjxetnhmsaedwtsv) (*.net *.split)
2020-10-06 12:33:13 +0200mudri(sid317655@gateway/web/irccloud.com/x-ewrkkkqbsfrqlwpo) (*.net *.split)
2020-10-06 12:33:13 +0200rodlogic__(sid214676@gateway/web/irccloud.com/x-mpkvpqnfqcxewmmv) (*.net *.split)
2020-10-06 12:33:14 +0200rawles(~r@unaffiliated/rawles) (*.net *.split)
2020-10-06 12:33:14 +0200kori(~kori@arrowheads/kori) (*.net *.split)
2020-10-06 12:33:14 +0200xff0x(~fox@2001:1a81:5339:8000:bdc7:ef33:4985:5e4f) (*.net *.split)
2020-10-06 12:33:14 +0200berberman(~berberman@2408:8207:2563:5ae0:584e:a9ff:fe9b:d3fe) (*.net *.split)
2020-10-06 12:33:14 +0200ghuntley(sid16877@gateway/web/irccloud.com/x-hazckpioupzucowz) (*.net *.split)
2020-10-06 12:33:14 +0200carter(sid14827@gateway/web/irccloud.com/x-sizpssbboxwjlzfn) (*.net *.split)
2020-10-06 12:33:14 +0200elvishjerricco(sid237756@NixOS/user/ElvishJerricco) (*.net *.split)
2020-10-06 12:33:14 +0200conjunctive(sid433686@gateway/web/irccloud.com/x-svszloomofjzwqrv) (*.net *.split)
2020-10-06 12:33:14 +0200adius(sid321344@gateway/web/irccloud.com/x-fevubjfnjnczxgiy) (*.net *.split)
2020-10-06 12:33:14 +0200tchar(sid301738@gateway/web/irccloud.com/x-rgpmjtqqbhrmcohe) (*.net *.split)
2020-10-06 12:33:14 +0200liszt_(sid336875@gateway/web/irccloud.com/x-uuxepiucxpvvjuow) (*.net *.split)
2020-10-06 12:33:14 +0200Ericson2314(ericson231@gateway/shell/matrix.org/x-tddshmiwufwouryw) (*.net *.split)
2020-10-06 12:33:14 +0200iinuwa1(iinuwamatr@gateway/shell/matrix.org/x-vozqawbtzhuizygn) (*.net *.split)
2020-10-06 12:33:14 +0200_flow_(~none@salem.informatik.uni-erlangen.de) (*.net *.split)
2020-10-06 12:33:14 +0200jokester_(~mono@2001:19f0:5:1e1d:5400:1ff:fe45:5877) (*.net *.split)
2020-10-06 12:33:14 +0200recon_-(~quassel@2602:febc:0:b6::6ca2) (*.net *.split)
2020-10-06 12:33:14 +0200noCheese(~nocheese@unaffiliated/nocheese) (*.net *.split)
2020-10-06 12:33:14 +0200angerman(sid209936@gateway/web/irccloud.com/x-oahfetnahbdvwgfo) (*.net *.split)
2020-10-06 12:33:14 +0200verlet64_(sid261276@gateway/web/irccloud.com/x-xjfovybibszlojpl) (*.net *.split)
2020-10-06 12:33:14 +0200nick_h(sid319833@gateway/web/irccloud.com/x-omwgtsberokhnnup) (*.net *.split)
2020-10-06 12:33:14 +0200joeyh_(joeyh@kitenet.net) (*.net *.split)
2020-10-06 12:33:14 +0200bitmapper(uid464869@gateway/web/irccloud.com/x-tfzdjxpokcsicuwj) (*.net *.split)
2020-10-06 12:33:14 +0200balbirs(~balbirs__@bilbo.ozlabs.org) (*.net *.split)
2020-10-06 12:33:14 +0200topos(uid467876@gateway/web/irccloud.com/x-twpqbqvekrcsozee) (*.net *.split)
2020-10-06 12:33:14 +0200polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889) (*.net *.split)
2020-10-06 12:33:14 +0200parisienne(sid383587@gateway/web/irccloud.com/x-wkbgoesgrpfdelps) (*.net *.split)
2020-10-06 12:33:14 +0200strugglingming(sid10571@gateway/web/irccloud.com/x-pwoyzccowxbiqivf) (*.net *.split)
2020-10-06 12:33:14 +0200stree(~stree@50-108-75-26.adr01.mskg.mi.frontiernet.net) (*.net *.split)
2020-10-06 12:33:14 +0200seanparsons(~sean@cpc145088-gill21-2-0-cust281.20-1.cable.virginm.net) (*.net *.split)
2020-10-06 12:33:14 +0200dcoutts(~duncan@unaffiliated/dcoutts) (*.net *.split)
2020-10-06 12:33:14 +0200thonkpod(~thonkpod@2001:19f0:ac01:b46:5400:1ff:fec7:d73d) (*.net *.split)
2020-10-06 12:33:14 +0200liff(liff@kapsi.fi) (*.net *.split)
2020-10-06 12:33:14 +0200PotatoHatsue(berbermanp@gateway/shell/matrix.org/x-lcuapfbpkatzswxh) (*.net *.split)
2020-10-06 12:33:14 +0200dequbed(~dequbed@yanduxian.paranoidlabs.org) (*.net *.split)
2020-10-06 12:33:14 +0200miklcct(quasselcor@2001:19f0:7001:5ad:5400:2ff:feb6:50d7) (*.net *.split)
2020-10-06 12:33:14 +0200ThaEwat(thaewraptm@gateway/shell/matrix.org/x-mopjnwlxyxbzydyc) (*.net *.split)
2020-10-06 12:33:14 +0200srid(sridmatrix@gateway/shell/matrix.org/x-zqttickmrfyduksr) (*.net *.split)
2020-10-06 12:33:14 +0200michaelpj1(michaelpjm@gateway/shell/matrix.org/x-bmrqrkqdmdnabvkc) (*.net *.split)
2020-10-06 12:33:14 +0200johnnyboy[m](gifumatrix@gateway/shell/matrix.org/x-xczqbcixpmjhwvre) (*.net *.split)
2020-10-06 12:33:14 +0200lambdaclan(lambdaclan@gateway/shell/matrix.org/x-rosqvrjyauthsfym) (*.net *.split)
2020-10-06 12:33:14 +0200io_r_us[m](commandlin@gateway/shell/matrix.org/x-kjrwesnzoyenqgzx) (*.net *.split)
2020-10-06 12:33:14 +0200fl0_id(~fl0_id@2a01:4f8:171:4de::40:2) (*.net *.split)
2020-10-06 12:33:14 +0200barrucadu(~barrucadu@fsf/member/barrucadu) (*.net *.split)
2020-10-06 12:33:14 +0200bcoppens(~bartcopp@kde/coppens) (*.net *.split)
2020-10-06 12:33:14 +0200noteness(~noteness@unaffiliated/nessessary129) (*.net *.split)
2020-10-06 12:33:14 +0200opqdonut(opqdonut@pseudo.fixme.fi) (*.net *.split)
2020-10-06 12:33:14 +0200Velpoman(~Velpoman@159.65.76.124) (*.net *.split)
2020-10-06 12:33:14 +0200dixie(~dixie@real.wilbury.sk) (*.net *.split)
2020-10-06 12:33:14 +0200uwap(~uwap@genja.uwap.name) (*.net *.split)
2020-10-06 12:33:25 +0200carlomagno(~cararell@inet-hqmc01-o.oracle.com) (Write error: Broken pipe)
2020-10-06 12:33:29 +0200stree(~stree@50-108-75-26.adr01.mskg.mi.frontiernet.net)
2020-10-06 12:33:37 +0200carlomagno(~cararell@inet-hqmc01-o.oracle.com)
2020-10-06 12:34:41 +0200ralejs(~ralejs@2620:10d:c093:400::5:2842)
2020-10-06 12:34:41 +0200GyroW_(~GyroW@unaffiliated/gyrow)
2020-10-06 12:34:41 +0200sphalerite(~sphalerit@NixOS/user/lheckemann)
2020-10-06 12:34:41 +0200rawles(~r@unaffiliated/rawles)
2020-10-06 12:34:41 +0200rodlogic__(sid214676@gateway/web/irccloud.com/x-mpkvpqnfqcxewmmv)
2020-10-06 12:34:41 +0200pasukon(sid49097@gateway/web/irccloud.com/x-zvjflytzjcvxxkxp)
2020-10-06 12:34:41 +0200mudri(sid317655@gateway/web/irccloud.com/x-ewrkkkqbsfrqlwpo)
2020-10-06 12:34:41 +0200lexi-lambda(sid92601@gateway/web/irccloud.com/x-tjxetnhmsaedwtsv)
2020-10-06 12:34:41 +0200kori(~kori@arrowheads/kori)
2020-10-06 12:34:41 +0200xff0x(~fox@2001:1a81:5339:8000:bdc7:ef33:4985:5e4f)
2020-10-06 12:34:41 +0200berberman(~berberman@2408:8207:2563:5ae0:584e:a9ff:fe9b:d3fe)
2020-10-06 12:34:41 +0200ghuntley(sid16877@gateway/web/irccloud.com/x-hazckpioupzucowz)
2020-10-06 12:34:41 +0200carter(sid14827@gateway/web/irccloud.com/x-sizpssbboxwjlzfn)
2020-10-06 12:34:41 +0200elvishjerricco(sid237756@NixOS/user/ElvishJerricco)
2020-10-06 12:34:41 +0200conjunctive(sid433686@gateway/web/irccloud.com/x-svszloomofjzwqrv)
2020-10-06 12:34:41 +0200adius(sid321344@gateway/web/irccloud.com/x-fevubjfnjnczxgiy)
2020-10-06 12:34:41 +0200tchar(sid301738@gateway/web/irccloud.com/x-rgpmjtqqbhrmcohe)
2020-10-06 12:34:41 +0200liszt_(sid336875@gateway/web/irccloud.com/x-uuxepiucxpvvjuow)
2020-10-06 12:34:41 +0200Ericson2314(ericson231@gateway/shell/matrix.org/x-tddshmiwufwouryw)
2020-10-06 12:34:41 +0200iinuwa1(iinuwamatr@gateway/shell/matrix.org/x-vozqawbtzhuizygn)
2020-10-06 12:34:41 +0200_flow_(~none@salem.informatik.uni-erlangen.de)
2020-10-06 12:34:41 +0200jokester_(~mono@2001:19f0:5:1e1d:5400:1ff:fe45:5877)
2020-10-06 12:34:41 +0200recon_-(~quassel@2602:febc:0:b6::6ca2)
2020-10-06 12:34:41 +0200noCheese(~nocheese@unaffiliated/nocheese)
2020-10-06 12:34:41 +0200angerman(sid209936@gateway/web/irccloud.com/x-oahfetnahbdvwgfo)
2020-10-06 12:34:41 +0200verlet64_(sid261276@gateway/web/irccloud.com/x-xjfovybibszlojpl)
2020-10-06 12:34:41 +0200nick_h(sid319833@gateway/web/irccloud.com/x-omwgtsberokhnnup)
2020-10-06 12:34:41 +0200joeyh_(joeyh@kitenet.net)
2020-10-06 12:34:41 +0200bitmapper(uid464869@gateway/web/irccloud.com/x-tfzdjxpokcsicuwj)
2020-10-06 12:34:41 +0200balbirs(~balbirs__@bilbo.ozlabs.org)
2020-10-06 12:34:41 +0200topos(uid467876@gateway/web/irccloud.com/x-twpqbqvekrcsozee)
2020-10-06 12:34:41 +0200polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889)
2020-10-06 12:34:41 +0200parisienne(sid383587@gateway/web/irccloud.com/x-wkbgoesgrpfdelps)
2020-10-06 12:34:41 +0200strugglingming(sid10571@gateway/web/irccloud.com/x-pwoyzccowxbiqivf)
2020-10-06 12:34:41 +0200seanparsons(~sean@cpc145088-gill21-2-0-cust281.20-1.cable.virginm.net)
2020-10-06 12:34:41 +0200dcoutts(~duncan@unaffiliated/dcoutts)
2020-10-06 12:34:41 +0200fl0_id(~fl0_id@2a01:4f8:171:4de::40:2)
2020-10-06 12:34:41 +0200ThaEwat(thaewraptm@gateway/shell/matrix.org/x-mopjnwlxyxbzydyc)
2020-10-06 12:34:41 +0200thonkpod(~thonkpod@2001:19f0:ac01:b46:5400:1ff:fec7:d73d)
2020-10-06 12:34:41 +0200liff(liff@kapsi.fi)
2020-10-06 12:34:41 +0200PotatoHatsue(berbermanp@gateway/shell/matrix.org/x-lcuapfbpkatzswxh)
2020-10-06 12:34:41 +0200dequbed(~dequbed@yanduxian.paranoidlabs.org)
2020-10-06 12:34:41 +0200miklcct(quasselcor@2001:19f0:7001:5ad:5400:2ff:feb6:50d7)
2020-10-06 12:34:41 +0200srid(sridmatrix@gateway/shell/matrix.org/x-zqttickmrfyduksr)
2020-10-06 12:34:41 +0200michaelpj1(michaelpjm@gateway/shell/matrix.org/x-bmrqrkqdmdnabvkc)
2020-10-06 12:34:41 +0200johnnyboy[m](gifumatrix@gateway/shell/matrix.org/x-xczqbcixpmjhwvre)
2020-10-06 12:34:41 +0200lambdaclan(lambdaclan@gateway/shell/matrix.org/x-rosqvrjyauthsfym)
2020-10-06 12:34:41 +0200io_r_us[m](commandlin@gateway/shell/matrix.org/x-kjrwesnzoyenqgzx)
2020-10-06 12:34:41 +0200barrucadu(~barrucadu@fsf/member/barrucadu)
2020-10-06 12:34:41 +0200bcoppens(~bartcopp@kde/coppens)
2020-10-06 12:34:41 +0200noteness(~noteness@unaffiliated/nessessary129)
2020-10-06 12:34:41 +0200opqdonut(opqdonut@pseudo.fixme.fi)
2020-10-06 12:34:41 +0200Velpoman(~Velpoman@159.65.76.124)
2020-10-06 12:34:41 +0200dixie(~dixie@real.wilbury.sk)
2020-10-06 12:34:41 +0200uwap(~uwap@genja.uwap.name)
2020-10-06 12:34:44 +0200bahamas(~lucian@unaffiliated/bahamas) (Ping timeout: 256 seconds)
2020-10-06 12:34:48 +0200d34df00d(~d34df00d@104-14-27-213.lightspeed.austtx.sbcglobal.net) (Excess Flood)
2020-10-06 12:35:45 +0200xerox_(~xerox@unaffiliated/xerox)
2020-10-06 12:35:46 +0200PatrickRobotham_(sid18270@gateway/web/irccloud.com/x-szkuaevozzmraacs) (Ping timeout: 246 seconds)
2020-10-06 12:36:48 +0200Saukk(~Saukk@2001:998:f1:3963:1c59:9bb5:b94c:2) (Remote host closed the connection)
2020-10-06 12:37:10 +0200ynota(~Thunderbi@d49-191-192-139.mrk2.qld.optusnet.com.au)
2020-10-06 12:37:30 +0200PatrickRobotham_(sid18270@gateway/web/irccloud.com/x-rwsbokiyuenqgdjm)
2020-10-06 12:39:40 +0200ynota(~Thunderbi@d49-191-192-139.mrk2.qld.optusnet.com.au) ()
2020-10-06 12:39:52 +0200hyiltiz-M(hyiltizkde@gateway/shell/kde/matrix/x-zvgetfbstubrdqzf)
2020-10-06 12:39:55 +0200alp(~alp@2a01:e0a:58b:4920:cc00:82e3:fd5:ee39) (Ping timeout: 240 seconds)
2020-10-06 12:42:56 +0200LarryTheCow(~user@cpe-104-34-71-94.socal.res.rr.com) (Ping timeout: 272 seconds)
2020-10-06 12:42:58 +0200da39a3ee5e6b4b0d(~textual@n11211935170.netvigator.com) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 12:48:23 +0200mathlover2(~mathlover@2604:6000:1013:129e:755e:eccf:8735:da37)
2020-10-06 12:49:04 +0200mathlover2(~mathlover@2604:6000:1013:129e:755e:eccf:8735:da37) (Remote host closed the connection)
2020-10-06 12:49:48 +0200Amras(~Amras@unaffiliated/amras0000) (Remote host closed the connection)
2020-10-06 12:51:33 +0200alp(~alp@2a01:e0a:58b:4920:41af:3872:fb2a:8dae)
2020-10-06 12:53:11 +0200coot(~coot@37.30.49.218.nat.umts.dynamic.t-mobile.pl)
2020-10-06 12:55:07 +0200GyroW_(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-06 12:55:17 +0200GyroW(~GyroW@d54C03E98.access.telenet.be)
2020-10-06 12:55:18 +0200GyroW(~GyroW@d54C03E98.access.telenet.be) (Changing host)
2020-10-06 12:55:18 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-06 12:55:48 +0200yoeljacobsen(~yoel.jaco@5.28.167.89) (Ping timeout: 260 seconds)
2020-10-06 12:56:00 +0200olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber) (Ping timeout: 260 seconds)
2020-10-06 12:59:19 +0200jchia__(~jchia@45.32.62.73)
2020-10-06 12:59:32 +0200jchia__(~jchia@45.32.62.73) (Client Quit)
2020-10-06 13:00:15 +0200GyroW_(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-06 13:00:15 +0200GyroW_(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-06 13:00:15 +0200GyroW_(~GyroW@unaffiliated/gyrow)
2020-10-06 13:00:50 +0200Amras(~Amras@unaffiliated/amras0000)
2020-10-06 13:01:03 +0200GyroW(~GyroW@unaffiliated/gyrow) (Ping timeout: 260 seconds)
2020-10-06 13:02:08 +0200tito_04(~taurux@net-93-146-7-28.cust.vodafonedsl.it)
2020-10-06 13:02:13 +0200taurux(~taurux@net-93-146-7-28.cust.vodafonedsl.it) (Ping timeout: 260 seconds)
2020-10-06 13:02:31 +0200LKoen(~LKoen@81.255.219.130)
2020-10-06 13:05:43 +0200todda7(~torstein@athedsl-217541.home.otenet.gr) (Ping timeout: 260 seconds)
2020-10-06 13:06:16 +0200olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber)
2020-10-06 13:06:27 +0200GyroW_(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-06 13:06:44 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-06 13:06:44 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-06 13:06:44 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-06 13:07:40 +0200zargoertzel(~zar@fw1.ciirc.cvut.cz)
2020-10-06 13:08:27 +0200mpereira(~mpereira@2a02:810d:f40:d96:1c35:7f2e:59ff:953) (Ping timeout: 240 seconds)
2020-10-06 13:10:28 +0200zariuq(~zar@fw4.ciirc.cvut.cz) (Ping timeout: 260 seconds)
2020-10-06 13:11:13 +0200seanvert(~user@177.84.244.242)
2020-10-06 13:11:38 +0200Gurkenglas(~Gurkengla@unaffiliated/gurkenglas)
2020-10-06 13:17:52 +0200cpressey(~cpressey@88.144.95.3) (Quit: WeeChat 1.9.1)
2020-10-06 13:18:58 +0200hackagereanimate-svg 0.12.2.0 - SVG file loader and serializer https://hackage.haskell.org/package/reanimate-svg-0.12.2.0 (DavidHimmelstrup)
2020-10-06 13:19:40 +0200todda7(~torstein@athedsl-217541.home.otenet.gr)
2020-10-06 13:21:01 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-06 13:21:21 +0200shailangsa(~shailangs@host165-120-169-97.range165-120.btcentralplus.com)
2020-10-06 13:21:28 +0200hackageuniqueness-periods-vector-examples 0.9.0.0 - Usage examples for the uniqueness-periods-vector series of packages https://hackage.haskell.org/package/uniqueness-periods-vector-examples-0.9.0.0 (OleksandrZhabenko)
2020-10-06 13:21:35 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Read error: Connection reset by peer)
2020-10-06 13:24:12 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2020-10-06 13:24:53 +0200mpereira(~mpereira@2a02:810d:f40:d96:1c35:7f2e:59ff:953)
2020-10-06 13:25:28 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 246 seconds)
2020-10-06 13:28:56 +0200frdg(60e94035@pool-96-233-64-53.bstnma.fios.verizon.net) (Remote host closed the connection)
2020-10-06 13:30:25 +0200snakemasterflex(~snakemast@213.100.206.23) (Ping timeout: 256 seconds)
2020-10-06 13:32:09 +0200oisdk(~oisdk@2001:bb6:3329:d100:4f8:7c72:bd88:6c6a) (Quit: oisdk)
2020-10-06 13:32:39 +0200yoeljacobsen(~yoel.jaco@5.28.167.89)
2020-10-06 13:34:51 +0200Guest_91(bcfa50ec@188.250.80.236)
2020-10-06 13:36:07 +0200Guest_91(bcfa50ec@188.250.80.236) ()
2020-10-06 13:37:13 +0200hekkaidekapus{(~tchouri@gateway/tor-sasl/hekkaidekapus)
2020-10-06 13:38:43 +0200hekkaidekapus_(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 240 seconds)
2020-10-06 13:39:18 +0200bahamas(~lucian@unaffiliated/bahamas)
2020-10-06 13:40:24 +0200Habib(~Habib@194.35.233.138)
2020-10-06 13:42:07 +0200todda7(~torstein@athedsl-217541.home.otenet.gr) (Ping timeout: 240 seconds)
2020-10-06 13:42:25 +0200gekh(~gkh@thor.kevinhill.nl) (Quit: Goodbye!)
2020-10-06 13:43:20 +0200gekh(~gkh@thor.kevinhill.nl)
2020-10-06 13:43:47 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-10-06 13:44:37 +0200fendor_(~fendor@e237-037.eduroam.tuwien.ac.at) (Ping timeout: 264 seconds)
2020-10-06 13:46:10 +0200pacak(~pacak@bb116-14-220-91.singnet.com.sg) (Read error: Connection reset by peer)
2020-10-06 13:46:55 +0200fendor(~fendor@e237-037.eduroam.tuwien.ac.at)
2020-10-06 13:47:59 +0200da39a3ee5e6b4b0d(~textual@n11211935170.netvigator.com)
2020-10-06 13:49:25 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Ping timeout: 240 seconds)
2020-10-06 13:49:40 +0200alx741(~alx741@186.178.110.22) (Ping timeout: 260 seconds)
2020-10-06 13:52:35 +0200todda7(~torstein@athedsl-217541.home.otenet.gr)
2020-10-06 13:55:22 +0200pacak(~pacak@bb116-14-220-91.singnet.com.sg)
2020-10-06 13:55:38 +0200zariuq(~zar@fw1.ciirc.cvut.cz)
2020-10-06 13:57:20 +0200 <quazimod1> so I was playing around with ocaml and found some things quite disappointing
2020-10-06 13:57:26 +0200frdg(60e94035@pool-96-233-64-53.bstnma.fios.verizon.net)
2020-10-06 13:57:53 +0200 <quazimod1> it took forever to spin up a working code base... and i still have no idea how to split nested submodules into their own files... doesn't appear to be possible
2020-10-06 13:58:05 +0200zargoertzel(~zar@fw1.ciirc.cvut.cz) (Ping timeout: 240 seconds)
2020-10-06 13:58:39 +0200 <quazimod1> anyway I'm writing quantitative finance code and am evaluating languages, when reading about ocaml's strictness vs haskell's laziness I found that GHC has a 'strict' option
2020-10-06 13:59:04 +0200 <quazimod1> i had no idea that this existed, is it commonly used, or compatible with existing libraries
2020-10-06 14:00:01 +0200Implant1(~Implant@178.162.212.214) ()
2020-10-06 14:00:04 +0200Wuzzy(~Wuzzy@p5790e6f5.dip0.t-ipconnect.de)
2020-10-06 14:00:05 +0200bahamas(~lucian@unaffiliated/bahamas) (Ping timeout: 240 seconds)
2020-10-06 14:00:18 +0200 <dminuoso> quazimod1: Not very commonly used.
2020-10-06 14:00:31 +0200 <quazimod1> i cant wrap my head around it being a drop in option that 'just works'
2020-10-06 14:01:00 +0200 <dminuoso> Well, ultimately I dont think lazyness is a real issue. Overall lazy by default seems far more preferrable to strict by default.
2020-10-06 14:01:16 +0200 <quazimod1> dminuoso: far more preferrable?
2020-10-06 14:01:19 +0200 <dminuoso> Yes.
2020-10-06 14:01:28 +0200hackagefuthark 0.17.3 - An optimising compiler for a functional, array-oriented language. https://hackage.haskell.org/package/futhark-0.17.3 (TroelsHenriksen)
2020-10-06 14:01:28 +0200 <dminuoso> Code becomes far more modular
2020-10-06 14:01:43 +0200 <dminuoso> And the downsides are just matters of having to debug a space leak in the odd case.
2020-10-06 14:02:06 +0200 <dminuoso> But equivalently, if you're too strict, you can have performance issues as well.
2020-10-06 14:02:07 +0200 <quazimod1> i'm not experience enough with haskell to really understand 'code becomes far more modular'
2020-10-06 14:02:22 +0200 <quazimod1> i'll take your word for it though
2020-10-06 14:02:24 +0200snakemasterflex(~snakemast@213.100.206.23)
2020-10-06 14:03:05 +0200 <dminuoso> Don't take my word for it.
2020-10-06 14:03:47 +0200Stanley00(~stanley00@unaffiliated/stanley00) (Remote host closed the connection)
2020-10-06 14:03:55 +0200alx741(~alx741@186.178.110.191)
2020-10-06 14:04:53 +0200 <frdg> I am having trouble understanding this error. Can I accumulate values with only Foldable and Monoid instances? https://dpaste.org/ekMY
2020-10-06 14:05:19 +0200 <dminuoso> quazimod1: The topic has been discussed at ends on reddit or stackoverflow, so Ill just redirect you there.
2020-10-06 14:05:21 +0200 <dminuoso> https://www.reddit.com/r/haskell/comments/5xge0v/today_i_used_laziness_for/deia53t/?utm_source=red…
2020-10-06 14:06:17 +0200 <quazimod1> ah nice
2020-10-06 14:09:38 +0200machinedgod(~machinedg@24.105.81.50)
2020-10-06 14:10:35 +0200 <dminuoso> frdg: True -> x <> acc
2020-10-06 14:10:54 +0200 <dminuoso> frdg: This is where the accident happens. Consider what the type of `x` is
2020-10-06 14:12:05 +0200 <dminuoso> % :t foldr
2020-10-06 14:12:05 +0200 <yahb> dminuoso: Foldable t => (a -> b -> b) -> b -> t a -> b
2020-10-06 14:12:12 +0200 <frdg> x :: a. So I need a function that is `a -> t a -> t a`
2020-10-06 14:12:25 +0200 <dminuoso> Sure, but that's not possible with t being just Foldable
2020-10-06 14:12:56 +0200 <frdg> that is what I feared
2020-10-06 14:13:35 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-10-06 14:13:36 +0200 <dminuoso> Im pondering about this currently, I feel there might be something close
2020-10-06 14:14:06 +0200mpereira(~mpereira@2a02:810d:f40:d96:1c35:7f2e:59ff:953) (Read error: Connection reset by peer)
2020-10-06 14:14:17 +0200yoeljacobsen(~yoel.jaco@5.28.167.89) (Ping timeout: 265 seconds)
2020-10-06 14:14:31 +0200 <dminuoso> From the looks of it, Set is the best you have.
2020-10-06 14:14:35 +0200mpereira(~mpereira@2a02:810d:f40:d96:693e:4333:5b77:9e8f)
2020-10-06 14:15:14 +0200 <dminuoso> Ah I found it
2020-10-06 14:15:17 +0200 <dminuoso> So what you're asking for is
2020-10-06 14:15:57 +0200 <L29Ah> % minimum(1,2)
2020-10-06 14:15:58 +0200 <dminuoso> intersect :: (Unfoldable t, Foldable t, Eq a) => t a -> t a -> t a
2020-10-06 14:15:58 +0200 <yahb> L29Ah: 2
2020-10-06 14:16:06 +0200 <dminuoso> Where Unfoldable is from the package `unfoldable`
2020-10-06 14:16:28 +0200 <dminuoso> Then, the most efficient way would be to roundtrip through a set, do the intersection, and then unfold it back
2020-10-06 14:16:45 +0200 <frdg> ok thanks Ill try this.
2020-10-06 14:16:47 +0200 <ski> @where whyfp
2020-10-06 14:16:47 +0200 <lambdabot> "Why Functional Programming Matters" by John Hughes in 1984 at <http://www.cse.chalmers.se/~rjmh/Papers/whyfp.html>
2020-10-06 14:17:23 +0200 <ski> quazimod1 : iirc that ^ has an example of the modularity (with separating generating a search-tree for games, from traversing (and pruning) it)
2020-10-06 14:19:11 +0200 <ski> quazimod1 : "it being a drop in option that 'just works'" -- i don't think that's the case. i think that for many modules/libraries, turning on `Strict' (or even just `StrictData', depending), will make them not work
2020-10-06 14:19:31 +0200 <quazimod1> yeah that makes more sense
2020-10-06 14:19:32 +0200__skn(~sunil@sec.nimmagadda.net)
2020-10-06 14:20:10 +0200 <dminuoso> quazimod1: Note that there's limits to lazyness being useful though. Just being able to use lazyness doesn't make all occurences of it useful.
2020-10-06 14:20:12 +0200 <ski> (if you turn it on, when you're compiling them, that is)
2020-10-06 14:20:20 +0200 <maerwald> ski: I enabled Strict and StrictData for large projects and nothing happened :)
2020-10-06 14:20:20 +0200 <dminuoso> For instance, lazy bytestrings are very debatable. They are very non-composable.
2020-10-06 14:20:44 +0200 <maerwald> Strict is only problematic when you write monadic combinators
2020-10-06 14:20:58 +0200st8less(~st8less@2603:a060:11fd:0:101c:4882:6a23:1c57)
2020-10-06 14:21:28 +0200 <quazimod1> yeah i'm too dumb to understand
2020-10-06 14:21:29 +0200 <ski> i think `Strict' (and `StrictData') are more useful for when you know you'll be working "in a strict way", where you won't really be helped much by non-strictness anyway. and possibly also for converting some preexisting code/library that mostly satisfy those constraints
2020-10-06 14:21:55 +0200st8less(~st8less@2603:a060:11fd:0:101c:4882:6a23:1c57) (Client Quit)
2020-10-06 14:21:58 +0200 <dminuoso> If I look back, ever since I started writing Haskell, I haven't been bitten by a space leak yet, but have had numerous occasions where lazyness let me write code far more modular, and more expressive.
2020-10-06 14:22:06 +0200 <dminuoso> It's even small things like being able to write `zip [1..]`
2020-10-06 14:22:08 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-06 14:22:16 +0200 <ski> maerwald : yea, i'm not saying you'll get bottom directly :) but some things may be way less efficient than one's expecting. it obviously depends on the style of the code, what kind of things it's doing
2020-10-06 14:22:28 +0200 <maerwald> ski: kazu yamamoto seems to disagree with you https://github.com/yesodweb/wai/pull/752#issuecomment-501531386
2020-10-06 14:23:52 +0200 <quazimod1> even though i'm dumb it feells to me like selective laziness is better than always lazy
2020-10-06 14:24:00 +0200 <maerwald> I agree
2020-10-06 14:25:25 +0200 <ski> maerwald : interesting :) perhaps the kind of things they's doing (or the way they tend to do them) more easily lends itself to strict semantics then. and perhaps that being the case is a bit more common than one'd thing
2020-10-06 14:26:32 +0200jespada(~jespada@90.254.246.48) (Ping timeout: 260 seconds)
2020-10-06 14:26:43 +0200 <ski> yea, i think having a reasonable way to get both worlds, would be good. but it's hard to know how to mix them, being able to succinctly and clearly choose which you want, when, not clear how to design such a language
2020-10-06 14:26:52 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 256 seconds)
2020-10-06 14:27:02 +0200 <quazimod1> doesn't the strict mode do that
2020-10-06 14:27:09 +0200 <dminuoso> quazimod1: It's debatable at the end. The thing with lazyness, is that its value doesn't kick in until you actually have lazyness by default.
2020-10-06 14:27:10 +0200 <quazimod1> give you the ability to whitelist lazy
2020-10-06 14:28:02 +0200jespada(~jespada@90.254.246.48)
2020-10-06 14:28:50 +0200 <quazimod1> this may again be more dumb thinking but i get the strong impression that commercial decision makers will avoid laziness
2020-10-06 14:29:27 +0200 <dminuoso> quazimod1: The best summary is that adding a selective strictness annotation always works, but selective lazyness annotations dont.
2020-10-06 14:29:40 +0200 <ski> quazimod1 : "doesn't the strict mode do that" -- no, because it turns it on for the whole module
2020-10-06 14:29:42 +0200 <dminuoso> Lazyness needs to be pervasive to work
2020-10-06 14:29:50 +0200 <ski> yea, that too
2020-10-06 14:30:10 +0200 <maerwald> There are some arguments pro composition and compiler optimisations due to non-strict semantics, but in the end: lazyness is a poor streaming method, which is why we go away from lazy bytestring and lazy IO and towards actual streaming libraries, that guarantee proper streaming. Otherwise there's too much cleverness in your code you don't understand yourself
2020-10-06 14:30:28 +0200 <dminuoso> Lazyness is not just for streaming.
2020-10-06 14:30:34 +0200 <Habib> can someone help me out w/ understanding prettyprinter?
2020-10-06 14:30:34 +0200 <maerwald> I didn't say that
2020-10-06 14:30:46 +0200 <dminuoso> Habib: Just ask!
2020-10-06 14:30:52 +0200 <ski> what i had in mind was to have a fine-grained selection of strictness and non-strictness. possibly, in some way, reflected in the types (but how to do that, in a not too obtrusive and code-duplicating way, isn't clear)
2020-10-06 14:31:01 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Read error: Connection reset by peer)
2020-10-06 14:31:21 +0200 <ski> i'd like to experiment with a language with call-by-coneed :)
2020-10-06 14:31:34 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-10-06 14:31:35 +0200 <maerwald> ski: http://docs.idris-lang.org/en/latest/tutorial/typesfuns.html#laziness
2020-10-06 14:32:23 +0200Habib_(~Habib@185.134.23.120)
2020-10-06 14:32:25 +0200 <quazimod1> I've done a lot of stream programming in javascript
2020-10-06 14:32:35 +0200 <Habib_> is prettyprinter really a prettyprinter, or is it just a prettyprinting engine?
2020-10-06 14:32:44 +0200 <dminuoso> quazimod1: So the realization that selective/surgical annotations only work with strictness annotations makes it obvious, that StrictData needs *far* more work if you want to use lazyness at all, as opposed to default with some strictness.
2020-10-06 14:32:46 +0200 <quazimod1> i dont know how comfy i'd be with implicit streaming vs actual streaming constructs
2020-10-06 14:32:50 +0200 <dminuoso> Habib_: Yes.
2020-10-06 14:32:56 +0200 <dminuoso> Habib_: What's the difference?
2020-10-06 14:33:28 +0200 <maerwald> dminuoso: there aren't many instances where you don't want StrictData
2020-10-06 14:33:37 +0200 <quazimod1> dminuoso: so the Strict and StrictData options appear to allow optional laziness using ~, so you'd have 'lazy modules' littered with ~ in a strict by default apporach, is what you're saying?
2020-10-06 14:33:43 +0200 <dminuoso> maerwald: I dont think that's true. I've had very few places where I needed a bang.
2020-10-06 14:33:51 +0200 <dminuoso> *far* less instances where I *wanted* lazyness
2020-10-06 14:34:06 +0200 <Habib_> pretty-simple just prints data types in a nicely formatted way so i can see largely nested values, but prettyprinter seems to be more of a bunch of primitives to let me control everything in a very precise way, but no way to just… print something.
2020-10-06 14:34:07 +0200 <quazimod1> to be fair i think the vast majority of the time you don't really care which way
2020-10-06 14:34:11 +0200 <maerwald> You need it very quickly if you store a lot of data in memory
2020-10-06 14:34:28 +0200 <quazimod1> still, it appears to me that having optional & deliberate laziness makes more sense
2020-10-06 14:34:35 +0200akegalj(~akegalj@93-138-123-17.adsl.net.t-com.hr) (Ping timeout: 240 seconds)
2020-10-06 14:34:36 +0200 <quazimod1> dumb dumb opinions
2020-10-06 14:34:44 +0200 <ski> maerwald : yea, having explicit suspensions (that `Lazy'), is good to have in a strict language, but are a bit awkward to use (also really needs to be combined with something like <https://srfi.schemers.org/srfi-45/srfi-45.html>. also see <http://homepages.inf.ed.ac.uk/wadler/topics/language-design.html#lazyinstrict>). there's the pervasiveness argument that dminuoso mentioned
2020-10-06 14:35:00 +0200 <Habib_> dminuoso: i don't get how anyone is supposed to be able to use prettyprinter in the console for just looking at values without getting lost
2020-10-06 14:35:05 +0200Habib(~Habib@194.35.233.138) (Ping timeout: 240 seconds)
2020-10-06 14:35:05 +0200Habib_Habib
2020-10-06 14:35:15 +0200 <maerwald> quazimod1: also: laziness is harder to reason about. And ppl get it wrong all the time. It's just less intuitive and some of the rules aren't that obvious
2020-10-06 14:35:17 +0200shatriff(~vitaliish@217.27.153.240)
2020-10-06 14:35:23 +0200 <dminuoso> Habib: prettyprinter is not for "just looking at values"
2020-10-06 14:35:27 +0200 <dminuoso> It's for generating pretty output.
2020-10-06 14:35:33 +0200 <quazimod1> i guess the other question that I have is, what happens when you have zero laziness... don't you just solve the same problems slightly differently
2020-10-06 14:35:37 +0200 <Habib> yeah, this is what i mean by pretty printer vs. pretty printing engine
2020-10-06 14:35:39 +0200 <dminuoso> Think of generating error/warning messages for your prorgram.
2020-10-06 14:35:43 +0200 <ski> maerwald : "Otherwise there's too much cleverness in your code you don't understand yourself" -- i agree that this is not that good, yea. (but it's not just streams)
2020-10-06 14:35:48 +0200 <Habib> a pretty printer prints… prettily
2020-10-06 14:36:00 +0200 <quazimod1> ocaml, despite it's hateful tooling, seems to be a reasonable FP without laziness
2020-10-06 14:36:11 +0200 <maerwald> but it isn't pure either
2020-10-06 14:36:19 +0200 <dminuoso> Habib: I see. prettyprinter is a pretty printing engine.
2020-10-06 14:36:21 +0200 <Habib> dminuoso: error/warning messages, go on…
2020-10-06 14:36:28 +0200 <quazimod1> that's true, do you need laziness to have purity?
2020-10-06 14:36:38 +0200 <dminuoso> Habib: https://github.com/quchen/prettyprinter read the README down below :)
2020-10-06 14:36:48 +0200 <dminuoso> It covers the motivation and uses for this library
2020-10-06 14:37:06 +0200 <maerwald> quazimod1: you need to be able to make your language non-strict without it overthrowing the entire semantics (modulo bottom)
2020-10-06 14:37:13 +0200 <dminuoso> (One important aspect is that prettyprinter makes a strict separation between the document that you prettyprint and the layouting
2020-10-06 14:37:13 +0200 <maerwald> otherwise it's not pure
2020-10-06 14:37:18 +0200 <Habib> i don't understand why it's recommended in the aelve guide alongside options like pretty-simple and then made out to be the best option (subjectively); they do completely different things
2020-10-06 14:37:28 +0200 <maerwald> whether the language is actually strict or not doesn't matter for it to be pure
2020-10-06 14:37:54 +0200jassy(~jassy@60-242-83-81.tpgi.com.au)
2020-10-06 14:38:12 +0200 <Habib> dminuoso: can you say more about the separation between the document and the layouting? it seems all its primitives are about layouting.
2020-10-06 14:38:16 +0200 <quazimod1> maerwald: is there an example that could illustrate that concept?
2020-10-06 14:38:25 +0200 <dminuoso> Habib: Well, think of pretty-simple as giving an adhoc "prettificiation". Sort of a generic.
2020-10-06 14:38:28 +0200 <quazimod1> i cant wrap my head around it
2020-10-06 14:38:35 +0200 <dminuoso> Habib: No they are not! That's the beauty :)
2020-10-06 14:38:49 +0200 <maerwald> quazimod1: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.27.7800&rep=rep1&type=pdf
2020-10-06 14:38:59 +0200 <dminuoso> Habib: https://hackage.haskell.org/package/prettyprinter-1.7.0/docs/Prettyprinter.html
2020-10-06 14:39:04 +0200 <dminuoso> Scroll down to "General workflow"
2020-10-06 14:39:10 +0200 <ski> quazimod1 : "what happens when you have zero laziness... don't you just solve the same problems slightly differently" -- yes. or you don't solve them at all (give up, or work around them, in a more clumsy, less modular/composable way) (or you simulate laziness, with suspensions like the one maerwald linked to)
2020-10-06 14:39:22 +0200 <dminuoso> So you write up a document, you layout it, and then you render it
2020-10-06 14:39:30 +0200motherfs1(~motherfsc@unaffiliated/motherfsck)
2020-10-06 14:39:33 +0200 <dminuoso> And there's different layout algorithms (you can also write your own)
2020-10-06 14:39:53 +0200 <Habib> so i could write a layout algorithm that lays out the document in the same way that pretty-simple does?
2020-10-06 14:40:03 +0200 <ski> quazimod1 : OCaml is quite nice. and SML too. F# is not bad, either, although it lacks the good module system, alas
2020-10-06 14:40:04 +0200 <maerwald> quazimod1: informally you could say: if your language is pure, the evaulation strategy shouldn't define its semantics
2020-10-06 14:40:16 +0200 <dminuoso> Habib: pretty-simple is rather a sort of "generic" implementation for anything that has a show instance
2020-10-06 14:40:34 +0200 <sm[m]> oh wow that's some great docs
2020-10-06 14:40:37 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Quit: Quit.)
2020-10-06 14:40:40 +0200 <dminuoso> think of it as a "parser" that reads the Haskell Report compliant deriving based Show instances, and then emits some prettyprinter code, layouts it, and renders it to string.
2020-10-06 14:40:50 +0200 <quazimod1> ski: ocaml's killing me
2020-10-06 14:40:51 +0200 <Habib> dminuoso: afaiu, pretty-simple just takes what show produces and goes through the string and aligns things based on braces and such
2020-10-06 14:40:59 +0200 <dminuoso> Habib: right, its very rigid
2020-10-06 14:41:02 +0200 <dminuoso> but your assessment is right
2020-10-06 14:41:06 +0200 <dminuoso> they are somewhat orthogonal
2020-10-06 14:41:08 +0200 <dminuoso> but not entirely unrelated
2020-10-06 14:41:15 +0200 <quazimod1> > informally you could say: if your language is pure, the evaulation strategy shouldn't define its semantics
2020-10-06 14:41:17 +0200 <lambdabot> <hint>:1:51: error: <hint>:1:51: error: parse error on input ‘,’
2020-10-06 14:41:19 +0200 <quazimod1> gonna have to do more reading
2020-10-06 14:41:22 +0200 <quazimod1> because i don't fully get that
2020-10-06 14:42:00 +0200todda7(~torstein@athedsl-217541.home.otenet.gr) (Ping timeout: 272 seconds)
2020-10-06 14:42:11 +0200motherfsck(~motherfsc@unaffiliated/motherfsck) (Ping timeout: 240 seconds)
2020-10-06 14:42:28 +0200 <quazimod1> "Finally, we observe that call-by-name reasoning principles are unsound in compilers for monadic Haskell"
2020-10-06 14:42:29 +0200 <dminuoso> Habib: If you just want some ad-hoc "make show instances more readable" with no effort, use pretty-simple. If you want to generate user-facing output (regardless of whether thats html, markdown, text, whatever), prettyprinter is a great option. :)
2020-10-06 14:42:35 +0200 <ski> a pretty-printer is a case where laziness can be useful. in a strict language, you can make multiple passes through the data, passing back the top-level outputs from last pass as inputs. (this is basically what attribute-grammars do). with non-strictness, you can just "do a single pass" (syntactically, so less clutter), but you have to be a bit careful to make sure you don't access a late input prematurely
2020-10-06 14:42:39 +0200 <quazimod1> doesn't that mean that they found that strict is kinda unworkable for monadic haskell
2020-10-06 14:43:28 +0200 <Habib> dminuoso: okay, i understand that now, i think i was just expecting something more like pretty-simple as that was the comparison being made on the aelve guide
2020-10-06 14:44:05 +0200 <Habib> i still don't quite understand prettyprinter, but i don't want to dwell on that when it's not what i need anyway
2020-10-06 14:44:12 +0200 <maerwald> quazimod1: it bottoms out :p
2020-10-06 14:44:19 +0200jonatanb(~jonatanb@79.184.190.239.ipv4.supernova.orange.pl)
2020-10-06 14:44:20 +0200 <quazimod1> i don't know what that means!!
2020-10-06 14:44:23 +0200 <dminuoso> Habib: prettyprinter is one of the finer libraries out there :)
2020-10-06 14:44:25 +0200 <quazimod1> lol
2020-10-06 14:44:31 +0200 <quazimod1> FP world is >so weird<
2020-10-06 14:44:38 +0200 <dminuoso> It has really good ergonomics, and makes writing output fun.
2020-10-06 14:44:49 +0200 <Habib> i get that impression, but for now, it's just gonna stay over my head i guess
2020-10-06 14:45:00 +0200 <dminuoso> Fair enough. Just dont be scared, it's very easy to use.
2020-10-06 14:45:03 +0200LKoen(~LKoen@81.255.219.130) (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”)
2020-10-06 14:45:15 +0200 <ski> quazimod1 : where was that quote from ?
2020-10-06 14:45:18 +0200 <maerwald> quazimod1: the paper explicitly says that semantics for different eval strategies are only equivalent if you ignore error/non-termination etc
2020-10-06 14:45:33 +0200 <maerwald> bc these will never be equivalent
2020-10-06 14:45:38 +0200 <quazimod1> ski: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.27.7800&rep=rep1&type=pdf
2020-10-06 14:45:41 +0200 <quazimod1> in the blurb
2020-10-06 14:46:01 +0200 <quazimod1> maerwald: that makes intuitive sense to me
2020-10-06 14:46:16 +0200 <quazimod1> wow haskell really is a research language isn't it
2020-10-06 14:46:26 +0200 <quazimod1> it's purpose is not commercial in the slightest
2020-10-06 14:46:57 +0200 <sm[m]> prettyprinter docs always are a bit opaque, even these; they sssume certain knowledge and jargon
2020-10-06 14:47:29 +0200 <lortabac> quazimod1: it's a research language that is also used commercially
2020-10-06 14:47:29 +0200 <maerwald> quazimod1: that's how it began... like your first date is exciting, but the truth settles soon enough
2020-10-06 14:47:38 +0200 <dminuoso> sm[m]: Doesn't any library?
2020-10-06 14:47:44 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:f500:dc4c:283a:a1a5)
2020-10-06 14:47:47 +0200 <dminuoso> I mean it's much worse with most of eds libraries.
2020-10-06 14:48:10 +0200 <maerwald> it's already too widely used to make drastic backwards-incompatible changes
2020-10-06 14:48:14 +0200 <dminuoso> Can't even use the damn thing without getting confused by half a dozen ncatlab articles.
2020-10-06 14:48:18 +0200 <maerwald> we can't even get rid of String :)
2020-10-06 14:48:35 +0200 <sm[m]> many docs are better at defining their terms for a non CS student eg
2020-10-06 14:48:50 +0200 <Habib> dminuoso: let me try one last time for today :). the question in my mind about the way prettyprinter works is, i don't quite understand the separation between functions like vsep, pretty, <+>, nest, align - which all seem to suggest stuff to do layouting - and the layoutSimple, layoutPretty, etc. functions
2020-10-06 14:48:51 +0200 <dminuoso> lortabac: That surely can't be a bad thing. PHP was a *toy* language that is also used commercially now.
2020-10-06 14:49:01 +0200 <quazimod1> maerwald: seen unison language?
2020-10-06 14:49:02 +0200 <lortabac> dminuoso: :D
2020-10-06 14:49:05 +0200 <quazimod1> that thing gives me hope
2020-10-06 14:49:14 +0200 <sm[m]> it wouldn't be hard to give a better intro to pretty printing in plain English. It's probably out there somewhere
2020-10-06 14:49:30 +0200 <maerwald> quazimod1: never seen it
2020-10-06 14:49:43 +0200 <dminuoso> Habib: https://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf is a very nice read that might be easier than to dive into the implementation.
2020-10-06 14:49:47 +0200 <quazimod1> it's pretty schmick
2020-10-06 14:50:08 +0200 <quazimod1> some things in it are non strict
2020-10-06 14:50:23 +0200 <quazimod1> such as boolean expressions
2020-10-06 14:50:27 +0200 <Habib> dminuoso: cheers, i'll take a look at this tonight :_
2020-10-06 14:50:29 +0200 <Habib> :)
2020-10-06 14:50:31 +0200 <quazimod1> but then again i'm sure that's the case for many languages
2020-10-06 14:50:35 +0200 <quazimod1> ... all languages?
2020-10-06 14:50:46 +0200 <dminuoso> Habib: for me, it was just two bindings that instantly explained the entirety of prettyprinter to me
2020-10-06 14:51:26 +0200 <sm[m]> (Maybe that General workflow section is it ? I'll have to read on a big screen)
2020-10-06 14:51:27 +0200 <ski> quazimod1 : ah (looked at page 20, which talks about that). that quote is about intermediate representation, in conjunction with generating code to do update-in-place, inside a compiler. it doesn't apply at the user-level of the language
2020-10-06 14:51:39 +0200 <dminuoso> Habib: Staring at hardline and softline for just a minute made me understand what Doc was about. :)
2020-10-06 14:51:45 +0200 <kuribas> dminuoso: same for me, I have heared a lot of scary stories about lazyness causing, spaceleaks, but I never experienced it...
2020-10-06 14:52:12 +0200 <ski> maerwald : "only equivalent if you ignore error/non-termination etc" -- yes, because partiality and non-termination are effects :)
2020-10-06 14:52:16 +0200 <chreekat[m]1> I also bounced pretty hard off the division of paradigms in that pretty printer lineage
2020-10-06 14:52:18 +0200 <ski> (side-effects, in Haskell)
2020-10-06 14:52:18 +0200 <quazimod1> so what i'm getting is that I should use python for my quantitative finance program
2020-10-06 14:52:36 +0200 <dminuoso> quazimod1: If you feel more comfortable with that, go for it.
2020-10-06 14:52:44 +0200 <quazimod1> dminuoso: i want to burn python
2020-10-06 14:52:53 +0200 <quazimod1> the quintessential 'im not a programmer' language
2020-10-06 14:53:08 +0200 <quazimod1> fuck me the amount of garbage python code i've had to wade through
2020-10-06 14:53:09 +0200 <dminuoso> quazimod1: All Im saying is, dont let the lazyness distract you from picking the language. It shouldn't matter at all.
2020-10-06 14:53:15 +0200 <ski> dminuoso : "without getting confused by half a dozen ncatlab articles" -- haha :)
2020-10-06 14:53:47 +0200 <maerwald> quazimod1: is this about an actual business or some toy program
2020-10-06 14:54:39 +0200 <dminuoso> quazimod1: If you're not comfortable with Haskell, your main concerns should be "how long until you become comfortable enough to become productive" or "do you have good library support for what you intend to do", or "do you have the ability to hire/train people in the desired language if needed"
2020-10-06 14:54:54 +0200 <quazimod1> maerwald: it's a project that i'm starting but professionally i work as a consulting tech lead for startups & corporate innovation ventures, i've taken a lot of things into production and this will be no different
2020-10-06 14:55:11 +0200 <quazimod1> the only difference is that nothing i've done before was purely my choice, my team, or time sensitive
2020-10-06 14:55:27 +0200 <quazimod1> so we settled with the RoR/Djangos, the typescripts, etc
2020-10-06 14:55:33 +0200cpressey(~cpressey@88.144.95.3)
2020-10-06 14:55:37 +0200noirin(~noirin@185.103.96.135)
2020-10-06 14:55:47 +0200 <maerwald> quazimod1: doing a startup haskell project is very dangerous with little knowledge about the language imo and I'd advise against it
2020-10-06 14:55:58 +0200 <sm[m]> Haskell may not be the quickest or cheapest to production but it will be the cheapest over the long haul
2020-10-06 14:55:58 +0200 <quazimod1> and any time any data science/computation was needed someone would appear who wanted to do it in python, which everyone else was familiar with
2020-10-06 14:56:07 +0200 <dminuoso> I second what maerwald just said. :)
2020-10-06 14:56:28 +0200 <maerwald> Haskell is something you pick if you know what you're doing.
2020-10-06 14:56:34 +0200oxide(~lambda@unaffiliated/mclaren) (Ping timeout: 258 seconds)
2020-10-06 14:56:55 +0200 <kuribas> clojure when you don't...
2020-10-06 14:56:59 +0200 <maerwald> lel
2020-10-06 14:57:04 +0200 <quazimod1> i'm not worried about picking up and learning something, im' worried about having to fix another man's mistakes
2020-10-06 14:57:18 +0200 <sm[m]> bah that has never been my approach :)
2020-10-06 14:57:19 +0200 <kuribas> at least if you're confused about types
2020-10-06 14:57:21 +0200 <quazimod1> django & it's 'rest framework' are full of mistakes that you have to fix
2020-10-06 14:57:37 +0200oxide(~lambda@unaffiliated/mclaren)
2020-10-06 14:57:47 +0200 <dminuoso> quazimod1: It might take 6 months before you can write solid code though, if you're completely new to Haskell.
2020-10-06 14:57:55 +0200 <sm[m]> Haskell is the language you can be sure you can refactor yourself way out of wrong decisions
2020-10-06 14:58:05 +0200 <dminuoso> The curve is difference, you can't just "simply switch". Overall Id say its worth learning
2020-10-06 14:58:10 +0200 <quazimod1> rails was good to me, to be honest. in fact ruby is the easiest language i've ever used and they're adding static typing to it so it'll be waaay more scalable soon. Shame it's so slow
2020-10-06 14:58:12 +0200 <sm[m]> s/way//
2020-10-06 14:58:24 +0200 <maerwald> sm[m]: also depends
2020-10-06 14:58:29 +0200 <kuribas> yeah, I never understood the argument why clojure would be more "organic", as if it automatically grows with your problems...
2020-10-06 14:58:40 +0200 <dminuoso> quazimod1: The type system is absolute rubbish. :)
2020-10-06 14:58:47 +0200 <quazimod1> dminuoso: it's a type system at least
2020-10-06 14:58:50 +0200 <dminuoso> It's not really
2020-10-06 14:58:59 +0200 <quazimod1> i don't need it to be brilliant, i need it to stop devs making type mistakes
2020-10-06 14:59:03 +0200 <maerwald> sm[m]: vertical refactoring isn't much easier (as in: change the way you express effects, exceptions etc)
2020-10-06 14:59:14 +0200 <dminuoso> The main problem is, Ruby by design and ecosystem promotes reflection techniques and monkey patching so hard
2020-10-06 14:59:16 +0200 <maerwald> horizontal yes
2020-10-06 14:59:18 +0200 <quazimod1> dminuoso: have you inspected the rails 3 type system?
2020-10-06 14:59:18 +0200 <dminuoso> The type system cant keep track of it
2020-10-06 14:59:27 +0200albert_99(~Albert@p200300e5ff0b5b39340e476afbaec452.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2020-10-06 14:59:32 +0200 <dminuoso> quazimod1: Ive stopped with Ruby 2 years ago in favor of Haskell
2020-10-06 14:59:34 +0200 <quazimod1> yeah the monkey patching isn't great
2020-10-06 14:59:42 +0200 <sm[m]> quazimod1: yesod is a good industrial strength "rails" worth looking at - not as easy to use but faster
2020-10-06 14:59:44 +0200 <kuribas> quazimod1: ruby (and python/perl/clojure/php...) are easy tot get started with, but hard to maintain.
2020-10-06 15:00:02 +0200 <quazimod1> sm[m]: in 10 years i've never had speed issues with rails tbh
2020-10-06 15:00:04 +0200 <sm[m]> you might also like to chat out the new IHP
2020-10-06 15:00:04 +0200 <dminuoso> There's very few popular languages that I consider to have respectable type systems. Rust is one of them.
2020-10-06 15:00:16 +0200 <kuribas> thanks to monkey patching, you never know what your standard library functions are doing.
2020-10-06 15:00:18 +0200mirrorbird(~psutcliff@2a00:801:2d5:9d73:ff00:6553:d451:a276)
2020-10-06 15:00:21 +0200 <sm[m]> quazimod1: ok, I thought you just said it was slow
2020-10-06 15:00:24 +0200ryansmccoy(~ryansmcco@193.37.254.27) (Ping timeout: 258 seconds)
2020-10-06 15:00:33 +0200 <quazimod1> sm[m]: for computation & the like, web server is fine
2020-10-06 15:00:46 +0200ryansmccoy(~ryansmcco@193.37.254.27)
2020-10-06 15:01:12 +0200 <quazimod1> dminuoso: i'm 90% settled on writing this thing in rust actually
2020-10-06 15:01:19 +0200 <quazimod1> that language does not appear to fuck around
2020-10-06 15:01:27 +0200 <quazimod1> the tooling is easy to use too, as far as i've used it
2020-10-06 15:01:45 +0200 <maerwald> kuribas: what does ("/foo" </> "/bar") (from System.FilePath) return?
2020-10-06 15:02:02 +0200 <quazimod1> but it was in reading about stuff that i stumbled on the lazy v strict thing... such a shame ocaml is surrounded by very ... non commercial thinking contributors
2020-10-06 15:02:05 +0200 <kuribas> maerwald: "/foo/bar"?
2020-10-06 15:02:07 +0200 <maerwald> no
2020-10-06 15:02:23 +0200urodna(~urodna@unaffiliated/urodna)
2020-10-06 15:02:31 +0200 <kuribas> "/foo//bar" then? :-)
2020-10-06 15:02:39 +0200 <quazimod1> sm[m]: i don't think i would do any financial computation stuff in ruby, even ruby 3 with the JIT
2020-10-06 15:02:44 +0200 <maerwald> kuribas: "/bar"
2020-10-06 15:02:47 +0200rihards(~rihards@balticom-142-78-50.balticom.lv)
2020-10-06 15:02:51 +0200 <kuribas> ??
2020-10-06 15:02:54 +0200 <maerwald> :)
2020-10-06 15:02:59 +0200albert_99(~Albert@p200300e5ff0b5b39340e476afbaec452.dip0.t-ipconnect.de)
2020-10-06 15:03:25 +0200 <kuribas> FilePath is a historical smell
2020-10-06 15:03:26 +0200Tops2(~Tobias@dyndsl-095-033-093-242.ewe-ip-backbone.de)
2020-10-06 15:03:26 +0200 <dminuoso> quazimod1: The one thing that Haskell is just pretty good at, reasoning about code like equational reasoning.
2020-10-06 15:03:27 +0200 <sm[m]> quazimod1: I build a financial app in Haskell, its great
2020-10-06 15:03:36 +0200 <maerwald> kuribas: https://github.com/haskell/filepath/issues/49
2020-10-06 15:03:42 +0200 <quazimod1> sm[m]: tell me more
2020-10-06 15:03:44 +0200 <dminuoso> For financial code, Haskell would be at the top of my list probably :)
2020-10-06 15:03:51 +0200 <quazimod1> dminuoso: it appears to me that that's the case too
2020-10-06 15:03:53 +0200 <maerwald> kuribas: just saying... are you *sure* we are doing better wrt sdlib :p
2020-10-06 15:04:14 +0200 <dminuoso> The better you can reason about code, the more likely your code is correct, the easier you can maintain your code, and it makes refactoring that much easier.
2020-10-06 15:04:24 +0200 <quazimod1> dminuoso: yeah i guess i got spooked by the lazy thing. It doesn't help that the jane street nerds specifically didn't use haskell because it would make their high speed trading less predictable... which spooked me again
2020-10-06 15:04:28 +0200 <quazimod1> even though i'm nothing near high speed
2020-10-06 15:04:30 +0200 <sm[m]> smooth evolution from "I have no idea what I'm doing" to "pretty decent architecture that gets the job done"
2020-10-06 15:04:34 +0200 <kuribas> maerwald: at least it's consistently wrong :)
2020-10-06 15:04:39 +0200 <sm[m]> over 13 years..
2020-10-06 15:04:45 +0200 <Uniaika> sm[m]: :D
2020-10-06 15:04:48 +0200 <dminuoso> quazimod1: One of Haskell's primary use is actually in financial institutions.
2020-10-06 15:05:10 +0200 <dminuoso> It's not as if Haskell was "made for it" or that its "particularly well suited", but it *is* used there.
2020-10-06 15:05:19 +0200 <sm[m]> quazimod1: (hledger.org)
2020-10-06 15:05:32 +0200 <quazimod1> i can understand why, if i was going to analyse existing data it'd be different
2020-10-06 15:05:44 +0200 <quazimod1> i'm sure lazy or not the throughput would be fantastic & the code very very reliable
2020-10-06 15:05:50 +0200 <dminuoso> It felt like every third person I met in London as Haskell eXchange was working for some financial institution
2020-10-06 15:05:51 +0200 <sm[m]> but yes look at cards I for a much more significant financial app
2020-10-06 15:06:13 +0200 <quazimod1> also whoever mentioned clojure before: i do not need a language that encourages deveolpers to dump their brain thoughts into files thank you
2020-10-06 15:06:18 +0200 <sm[m]> Cardano. Dangit, phone..
2020-10-06 15:06:31 +0200drbean(~drbean@TC210-63-209-203.static.apol.com.tw)
2020-10-06 15:06:33 +0200 <quazimod1> i will never implement another thing in lisp again
2020-10-06 15:06:36 +0200 <quazimod1> except emacs
2020-10-06 15:06:53 +0200 <quazimod1> sm[m]: hey that's cool
2020-10-06 15:07:08 +0200notzmv(~user@unaffiliated/zmv) (Ping timeout: 260 seconds)
2020-10-06 15:07:29 +0200 <dminuoso> quazimod1: But yeah, dont be spooked by lazyness. Overally I think it makes writing code easier, and the rare space leaks it brings with it can be debugged - for some reason some people trip into space leaks more often than others.
2020-10-06 15:07:33 +0200 <frdg> now that I think about it, Haskell isn't good for talking about sets because sets should be able to hold different types of elements.
2020-10-06 15:07:38 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-10-06 15:07:47 +0200 <dminuoso> frdg: Why should it?
2020-10-06 15:08:03 +0200 <quazimod1> dminuoso: so what do i do, use rust, python, ocaml or haskell for the quant app
2020-10-06 15:08:28 +0200berberman_(~berberman@123.118.97.97)
2020-10-06 15:08:32 +0200 <dminuoso> quazimod1: Why are you asking #haskell what you should do?
2020-10-06 15:08:38 +0200 <dminuoso> That seems like the wrong question
2020-10-06 15:08:42 +0200 <quazimod1> you're all pretty smart
2020-10-06 15:08:50 +0200 <frdg> dminuoso: [1,2,foo] is valid mathematically but in haskell this is a type error.
2020-10-06 15:08:51 +0200 <sm[m]> prototype in all until you see a winner!
2020-10-06 15:08:52 +0200 <ski> Scheme is cool. CL seems a bit less principled, more focused on getting things done, now. haven't looked at Clojure
2020-10-06 15:08:53 +0200 <dminuoso> Im not very smart
2020-10-06 15:08:55 +0200berberman(~berberman@2408:8207:2563:5ae0:584e:a9ff:fe9b:d3fe) (Ping timeout: 244 seconds)
2020-10-06 15:08:58 +0200 <dminuoso> Which is why Im using Haskell
2020-10-06 15:08:59 +0200 <quazimod1> never had any jackassery here that i can remember
2020-10-06 15:09:14 +0200 <dminuoso> It allows me to write good code *despite* being only average.
2020-10-06 15:09:28 +0200 <sm[m]> heh same :)
2020-10-06 15:09:32 +0200 <quazimod1> ski: CL is an abomination
2020-10-06 15:09:35 +0200 <dminuoso> Of course people here will tell you how good Haskell is
2020-10-06 15:09:41 +0200 <dminuoso> So Im not quite sure what you hope to hear.
2020-10-06 15:09:43 +0200 <ski> frdg : "[1,2,foo] is valid mathematically" -- in actual mathematical practice, that doesn't happen (or only very rarely)
2020-10-06 15:09:43 +0200 <quazimod1> lol
2020-10-06 15:09:52 +0200 <quazimod1> i'm honestly thinking rust
2020-10-06 15:09:55 +0200 <kuribas> ski: clojure is trying to be the cool kid, but adopting part of the new developments (purity), and completly trashing the rest (static types).
2020-10-06 15:10:32 +0200 <dminuoso> frdg: In fact, completely unlimited sets lead to Russels Paradox!
2020-10-06 15:10:39 +0200 <kuribas> ski: it's also a rather inefficient and clumsy approach to leverage the JVM.
2020-10-06 15:11:30 +0200 <ski> frdg : the problem is that (due to the influence of Zermelo-Fraenkel set theory), math literature tends to not talk about the distinction between subsets (aka material sets), and sets/types (aka structural sets) .. even though, imho, it's a distinction that's implicitly present, very often
2020-10-06 15:11:48 +0200 <quazimod1> ski: CL is like a perfect vision of beauty has had that 'the fly' thing done to it
2020-10-06 15:12:11 +0200 <ski> quazimod1 : .. yea, i tend to lean more to the Scheme side
2020-10-06 15:12:20 +0200 <quazimod1> ever seen CLOS
2020-10-06 15:12:25 +0200 <quazimod1> you _never_ need CLOS
2020-10-06 15:12:29 +0200 <frdg> ski: ok this is nice to know
2020-10-06 15:12:33 +0200 <dminuoso> My opinion is, if I wanted to drive a startup, I wouldn't pick a language that I had to learn first, especially if that language was so exotic, that I couldn't reasonably start to become productive in 2 weeks.
2020-10-06 15:12:40 +0200 <quazimod1> it's okay, great to read about it just to see how else you could do OOP
2020-10-06 15:12:59 +0200 <quazimod1> instrumented multiple inheritance. Yes please, sign me up. I'll take some flagellation too
2020-10-06 15:13:22 +0200 <quazimod1> dminuoso: i'm not worried about that, i'm a consulting tech lead, that's all i do
2020-10-06 15:13:28 +0200ski. o O ( "Interface-passing style" by Fare (François-René Rideau) in 2010-02-17 at <https://fare.livejournal.com/155094.html> )
2020-10-06 15:13:28 +0200 <kuribas> CL was made to bring order in the chaos of all the different lisps, but without rewriting the language. Scheme was made to rewrite the language, and make it small, elegant and consistent.
2020-10-06 15:13:34 +0200 <dminuoso> Consulting on a language youd ont even know.
2020-10-06 15:13:38 +0200 <dminuoso> Not sure whether that its better.
2020-10-06 15:13:40 +0200 <dminuoso> :)
2020-10-06 15:13:45 +0200 <quazimod1> dminuoso: getting paid a goddamn lot to do it too :P
2020-10-06 15:13:53 +0200 <quazimod1> hey man all my customers are happy i make shit happen
2020-10-06 15:13:57 +0200 <dminuoso> Maybe I should switch jobs
2020-10-06 15:14:09 +0200 <dminuoso> I could do COBOL consulting perhaps.
2020-10-06 15:14:17 +0200 <quazimod1> could probably make good money there too
2020-10-06 15:14:22 +0200 <quazimod1> i know that the banks are having a hard time
2020-10-06 15:14:23 +0200 <kuribas> quazimod1: cool, then you can start consulting on haskell?
2020-10-06 15:14:35 +0200 <quazimod1> kuribas: if I took it seriously, yeah
2020-10-06 15:14:40 +0200 <dminuoso> Didn't Facebook just kick off some artificial intelligence project aimed to rewrite cobol in traditional languages?
2020-10-06 15:14:42 +0200 <ski> that "Interface-passing style" is more or less using type classes (sans the uniqueness of instance), or rather, the explicit dictionary-passing implementation of it. (in a Lisp context)
2020-10-06 15:14:43 +0200 <quazimod1> i wouldn't shy away from it
2020-10-06 15:14:53 +0200 <dminuoso> frdg: Also, consider that `Set a` has an additional limitation in that it needs to satisfy a `Ord a` constraint (well not the type, but almost all its functions)
2020-10-06 15:15:14 +0200 <quazimod1> i know i'd be studying my ass off to learn & understand it, and I don't lie to my clients about my understanding of something
2020-10-06 15:16:21 +0200 <ski> kuribas : how does Clojure fare with STM ? i think i've heard they mentioned at the same time. and do you have any mutability (not counting if they're separated from the rest of the code like with `IORef' in Haskell. yes, that can be done, without static types) ?
2020-10-06 15:16:36 +0200 <dminuoso> frdg: So that alone mandates the set be uniform, so comparisons even work.
2020-10-06 15:16:41 +0200 <quazimod1> man 99% of my income is because, outside of IRC tomfoolery, I communicate pretty well and expect my staff to communicate pretty well too, you'd be surprised how well a venture can go with pretty meh commodity devs who are communicating with each other & the stake holders
2020-10-06 15:16:44 +0200 <dminuoso> Without this, we couldn't have a performant (and thus useful) implementation
2020-10-06 15:17:04 +0200 <kuribas> ski: I haven't done anything with concurrency in clojure...
2020-10-06 15:17:43 +0200 <frdg> dminuoso: So what we have in haskell is `uniform sets`?
2020-10-06 15:18:24 +0200 <dminuoso> or "homogenous" rather. yeah
2020-10-06 15:18:30 +0200 <kuribas> ski: and yes, clojure has mutability, as it can access java objects. But most clojure datatypes are immutable.
2020-10-06 15:18:35 +0200 <ski> frdg : it doesn't happen, for the same reason as in programming. you need to know how to use the data as well. for a list in Haskell, if you have no idea whether an element is an integer, or a string, or another list, you can't do much useful, except passing them on to someone who knows. and even if you can query (like with dynamic typing), this tends to be clumsy, not lead to well-structured developments
2020-10-06 15:19:07 +0200 <frdg> ok I understand
2020-10-06 15:19:09 +0200cr3(~cr3@192-222-143-195.qc.cable.ebox.net)
2020-10-06 15:20:08 +0200toorevitimirp(~tooreviti@117.182.180.245) (Ping timeout: 256 seconds)
2020-10-06 15:20:51 +0200 <sm[m]> quazimod1: do you hire only good communicators, or do you channel client communications through a few senior people ?
2020-10-06 15:21:03 +0200 <ski> kuribas : ok. i take that the mutability isn't "warded off / contained", or explicitly marked, with some kind of effect stuff ("tainting" ?), then
2020-10-06 15:21:11 +0200 <kuribas> ski: nope
2020-10-06 15:21:25 +0200 <quazimod1> sm[m]: my rule of thumb is to hire good natured & helpful seniors
2020-10-06 15:22:01 +0200 <maerwald> quazimod1: many ppl hire for "IQ" in tech and then get confused why their team is an unmanagable mess :)
2020-10-06 15:22:04 +0200 <quazimod1> client comms are tricky sometimes, ofc, especially when you've got arrogant fuckheads on the other side, frequntly happens
2020-10-06 15:22:29 +0200 <quazimod1> maerwald: dont get me started on 'smart' people
2020-10-06 15:22:33 +0200 <quazimod1> fucking worthless
2020-10-06 15:22:36 +0200 <ski> frdg : of course, you can have more exotic things, like a list where the first element is a number, the next is a pair of numbers, the next is a pair of pair of numbers, &c. .. to express many such, you need dependent types (although sometimes one can encode them without)
2020-10-06 15:22:52 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-06 15:23:13 +0200 <sm[m]> yes please don't maerwald :)
2020-10-06 15:23:18 +0200 <maerwald> :p
2020-10-06 15:23:22 +0200 <dminuoso> ski: Well, we can still have such things with intermediate data types in Haskell.
2020-10-06 15:23:36 +0200 <quazimod1> too late i'm starting
2020-10-06 15:23:40 +0200 <ski> frdg : but generally, you do have some kind of "order" that allows you to know what kind of value you're dealing with, without having to query (at least if you do express some amount of "querying" in terms of "tags", that is sum types)
2020-10-06 15:23:52 +0200 <sm[m]> quazimod1: interesting but probably
2020-10-06 15:23:52 +0200 <quazimod1> i have a guy doing ML for us... when he gets "bored" he "starts new projects"
2020-10-06 15:24:00 +0200 <sm[m]> OT here
2020-10-06 15:24:15 +0200 <maerwald> yeah, we have OT channels for that
2020-10-06 15:24:26 +0200 <quazimod1> he's a vestigial remnant of a company that we work with. Soon to be snipped off
2020-10-06 15:24:34 +0200 <quazimod1> what's OT
2020-10-06 15:24:35 +0200 <ski> dminuoso : hm, elaborate on what you mean ?
2020-10-06 15:24:52 +0200 <maerwald> and make sure you don't disclose names :p
2020-10-06 15:24:57 +0200 <quazimod1> oh right, yeah n/p i'll let it go. Back to haskell. This white paper is hard to read :/
2020-10-06 15:25:00 +0200 <sm[m]> off topic , at least at this busy time.
2020-10-06 15:25:21 +0200 <sm[m]> especially if it's a rant :)
2020-10-06 15:25:29 +0200 <ski> quazimod1 : ML as in SML,OCaml or F# ? or Machine Language ? or Machine Learning ?
2020-10-06 15:25:37 +0200 <quazimod1> ski: machine learning
2020-10-06 15:25:40 +0200 <maerwald> sm[m]: we barely rant here, do we? :angelface:
2020-10-06 15:25:51 +0200toorevitimirp(~tooreviti@117.182.180.245)
2020-10-06 15:26:01 +0200 <dminuoso> ski: Well the particular example you named could just be encoded by `data P = S Int | P P P deriving (Eq, Ord)`, and then you can have `Set P` just fine.
2020-10-06 15:26:14 +0200 <dminuoso> Oh wait
2020-10-06 15:26:17 +0200 <dminuoso> I see what you mean
2020-10-06 15:26:32 +0200GyroW(~GyroW@unaffiliated/gyrow) (Remote host closed the connection)
2020-10-06 15:26:44 +0200 <sm[m]> maerwald not too much really :)
2020-10-06 15:26:51 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-06 15:26:51 +0200GyroW(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-06 15:26:51 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-06 15:27:09 +0200conal(~conal@64.71.133.70) (Ping timeout: 256 seconds)
2020-10-06 15:27:15 +0200 <ski> dminuoso : no, the example i had was more like `data DoublingList a = Nil | Cons a (DoublingList (a,a))' (a "non-regular data type", since it's not passing the same type parameters in the recursive call)
2020-10-06 15:27:20 +0200AlterEgo-(~ladew@124-198-158-163.dynamic.caiway.nl)
2020-10-06 15:27:22 +0200 <dminuoso> Right
2020-10-06 15:27:37 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 258 seconds)
2020-10-06 15:28:38 +0200 <quazimod1> , where 7!
2020-10-06 15:28:47 +0200 <quazimod1> ignore
2020-10-06 15:29:19 +0200 <ski> then, you can throw a `Maybe', like `data BinNumeral a = Nil | Cons (Maybe a) (BinNumeral (a,a))' and now you have a collection of arbitrary (finite) number of elements of `a', represented as a "binary numeral" "sequence of `1's and `0's". each `1' being a perfectly-balanced binary tree of size `2^n', where `n' is the index of the bit
2020-10-06 15:29:22 +0200 <quazimod1> oh man so out of my depth, ->* is the reflexive transitive closure of ->
2020-10-06 15:29:25 +0200 <quazimod1> what the hell does that mean
2020-10-06 15:29:31 +0200conal(~conal@66.115.157.135)
2020-10-06 15:29:41 +0200 <ski> quazimod1 : it means that `->*' is zero or more `->' steps
2020-10-06 15:29:50 +0200jonatanb(~jonatanb@79.184.190.239.ipv4.supernova.orange.pl) (Read error: Connection reset by peer)
2020-10-06 15:30:15 +0200 <quazimod1> lol
2020-10-06 15:30:17 +0200 <quazimod1> nice
2020-10-06 15:30:23 +0200jonatanb(~jonatanb@79.184.190.239.ipv4.supernova.orange.pl)
2020-10-06 15:30:33 +0200 <ski> quazimod1 : so, for all `x', you have `x ->* x' (zero steps). and if you have `x -> y' and `y ->* z', then you have `x ->* z' (you can "add in" one more step)
2020-10-06 15:30:41 +0200 <sm[m]> quazimod1: tip: easy to get lost in CS when learning haskell, common mistake is thinking it's the only way to get productive - it's not
2020-10-06 15:31:03 +0200 <quazimod1> sm[m]: its the best way to not be productive, in fact you need none of this to ever be productive :P
2020-10-06 15:31:24 +0200 <quazimod1> i don't know how i'm gonna build a stripe wrapper when my mind's caught up in this mess
2020-10-06 15:31:26 +0200 <kuribas> the best way is to start of with really crude haskell
2020-10-06 15:31:26 +0200 <sm[m]> over the long term I think that's not true :)
2020-10-06 15:31:35 +0200 <kuribas> then as you learn more to refine it.
2020-10-06 15:31:37 +0200 <ski> (you could also express the latter rule by saying that if you have `x -> y', then you have `x ->* y' (one step). and if you have `x ->* y' and `y ->* z', then you have `x ->* z' (combine multiple steps with multiple steps. this is transitivity.) (the "zero steps" is reflexivity)'
2020-10-06 15:32:13 +0200skinods to sm[m]
2020-10-06 15:32:14 +0200 <sm[m]> kuribas: that's my approach also
2020-10-06 15:32:20 +0200berberman_(~berberman@123.118.97.97) (Ping timeout: 260 seconds)
2020-10-06 15:32:26 +0200 <quazimod1> by zero steps are we talking about intermediate transformations, or computations?
2020-10-06 15:32:31 +0200 <quazimod1> what is a step, here?
2020-10-06 15:32:54 +0200 <kuribas> in fact, I find that often when I am stuck in to much refinement, it helps to start of with something dumb and basic, then gradualy rewriting it.
2020-10-06 15:33:04 +0200 <ski> a "step" is the relation `->' you started with. could be any binary relation on a set. in your case, i presume it's some kind of reduction or transition step
2020-10-06 15:33:09 +0200berberman(~berberman@123.118.96.247)
2020-10-06 15:33:35 +0200 <quazimod1> ski: it's actually page 4 of http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.27.7800&rep=rep1&type=pdf
2020-10-06 15:34:20 +0200 <ski> from any binary relation `R' on a set, we can construct a binary relation `R*' that includes `R', and is both reflexive and transitive (so is a "partial order"). in fact, `R*' is the "smallest" such relation (doesn't include extra irrelevant cruft). that's why it's called the "reflexive-transitive closure"
2020-10-06 15:35:28 +0200 <ski> quazimod1 : it's standard to talk about reflexive-transitive closure, when speaking more formally about the (small-step) operational/procedural semantics of programming languages
2020-10-06 15:36:39 +0200 <ski> yea, in this situation, `x -> y' means that the expression `x' can reduce to the expression `y' "in one step". then `x ->* y' means that it can reduce, in zero or more steps
2020-10-06 15:36:45 +0200 <quazimod1> i dont have a background in this maths
2020-10-06 15:36:55 +0200 <quazimod1> does this fall into set or category theory?
2020-10-06 15:36:55 +0200 <ski> yea, that's why i'm explaining
2020-10-06 15:37:15 +0200 <ski> it's semantics of programming languages
2020-10-06 15:37:15 +0200 <quazimod1> so the 'zero' in the zero or more steps is important
2020-10-06 15:37:31 +0200 <quazimod1> why do we think abouth the zero, rather than 1 or more?
2020-10-06 15:37:36 +0200plutoniix(~q@ppp-223-24-166-134.revip6.asianet.co.th)
2020-10-06 15:37:43 +0200 <ski> yea, sometimes you see `->+' for "one or more steps". that's "transitive closure" (without the reflexive part)
2020-10-06 15:37:54 +0200 <ski> but i think it's more common to want to include the possibility of zero steps
2020-10-06 15:37:56 +0200zoom84(~user@068-190-177-201.res.spectrum.com)
2020-10-06 15:38:02 +0200zoom84(~user@068-190-177-201.res.spectrum.com) ()
2020-10-06 15:38:11 +0200 <ski> well, one common use of this is to talk about confluence
2020-10-06 15:38:22 +0200ym555(~ym@156.199.113.15) (Quit: leaving...)
2020-10-06 15:38:32 +0200 <ski> say you have an expression `(2 + 3) * (1 + 4)'. you can imagine doing the additions in either order
2020-10-06 15:38:35 +0200 <ski> so, you can go
2020-10-06 15:38:51 +0200 <ski> (2 + 3) * (1 + 4) |-> 5 * (1 + 4)
2020-10-06 15:38:55 +0200 <ski> or else you can go
2020-10-06 15:39:01 +0200 <ski> (2 + 3) * (1 + 4) |-> (2 + 3) * 5
2020-10-06 15:39:04 +0200 <quazimod1> sure
2020-10-06 15:39:23 +0200 <ski> but regardless of which path we take, we will eventually "converge" again, get back to the same spot
2020-10-06 15:39:30 +0200 <ski> (2 + 3) * (1 + 4) |-> 5 * (1 + 4) |-> 5 * 5
2020-10-06 15:39:31 +0200 <ski> vs.
2020-10-06 15:39:32 +0200 <quazimod1> skrj
2020-10-06 15:39:36 +0200 <ski> (2 + 3) * (1 + 4) |-> (2 + 3) * 5 |-> 5 * 5
2020-10-06 15:39:39 +0200 <quazimod1> sorry, dvorak, sure
2020-10-06 15:39:47 +0200Ariakenom(~Ariakenom@193.254.193.1) (Ping timeout: 240 seconds)
2020-10-06 15:40:17 +0200 <ski> so, one way to express this is that if you have `x |-> y0' and also have `x |-> y1', then there should exist some `z' such that `y0 |->* z' and `y1 |->* z'
2020-10-06 15:40:47 +0200 <ski> so, regardless of whether we go left or right, we'll eventually come to a common spot on the path, again
2020-10-06 15:41:18 +0200 <ski> however, it could be that from `y0' you can get (in some steps) to `y1' itself
2020-10-06 15:41:25 +0200 <quazimod1> ah sure, and the zero being the case that the y0 was the same as whe z anyway
2020-10-06 15:42:36 +0200 <ski> so, then we want `z' to be `y1'. so the last part then becomes `y0 |->* y1' and `y1 |->* y1'. the last thing here wouldn't work, if we didn't include "zero steps" as a possibility. we'd have to try to add one step to both (and that's not always possible, depending on how one sets things up. and setting it up so it's always possible is an extra hassle)
2020-10-06 15:42:41 +0200 <ski> yes
2020-10-06 15:42:56 +0200 <ski> anyway, this is not category theory
2020-10-06 15:43:34 +0200 <ski> (not really set theory, either, although it could use some set theory terminology)
2020-10-06 15:44:10 +0200 <carter> Algebraic combinatorics! ;)
2020-10-06 15:44:39 +0200fendor_(~fendor@t204-126.demo.tuwien.ac.at)
2020-10-06 15:45:18 +0200 <quazimod1> yeah it didn't feel like category theory but its been a few years since i looked at that, and I never got particularly far into it so idno
2020-10-06 15:45:48 +0200 <ski> quazimod1 : anyway, if you're interested, you can look at papers like this. and some of the insights or conclusions can be good to know about, from a more practical programming standpoint. but i wouldn't worry too much about not understanding things in such papers, if you're mainly interested in practical programming (e.g. in Haskell, or some other language)
2020-10-06 15:46:01 +0200fm_(~fm@p2e5335ae.dip0.t-ipconnect.de)
2020-10-06 15:46:39 +0200fm_(~fm@p2e5335ae.dip0.t-ipconnect.de) (Client Quit)
2020-10-06 15:47:09 +0200 <quazimod1> yeah certainly agree with you, i just get interested
2020-10-06 15:47:14 +0200fendor(~fendor@e237-037.eduroam.tuwien.ac.at) (Ping timeout: 272 seconds)
2020-10-06 15:47:22 +0200 <ski> (btw, that property with `x',`y0',`y1',`z' above, confluence, is sometimes called "diamond property", since if you draw it in a diagram, it looks like a rhombus)
2020-10-06 15:48:48 +0200Lord_of_Life(~Lord@unaffiliated/lord-of-life/x-0885362) (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine)
2020-10-06 15:48:57 +0200 <ski> one way to think about `R*' is that its like a "list of `R's". so `a R* z' means `a R b /\ b R c /\ c R d /\ ... /\ w R x /\ x R y /\ y R z', for some (possibly zero) number of `R' steps (some "list" of `R's)
2020-10-06 15:49:35 +0200 <ski> (`A*' is also a common notation for a (possibly empty) list of elements of `A'. in Haskell, this is `[A]'. and `A+' for non-empty lists)
2020-10-06 15:49:51 +0200fmeyer(~fmeyer@p2e5335ae.dip0.t-ipconnect.de)
2020-10-06 15:51:02 +0200drbean(~drbean@TC210-63-209-203.static.apol.com.tw) (Ping timeout: 272 seconds)
2020-10-06 15:51:04 +0200 <quazimod1> the binary relation in our case can be anything right?
2020-10-06 15:51:21 +0200 <ski> yes
2020-10-06 15:51:24 +0200fmeyer(~fmeyer@p2e5335ae.dip0.t-ipconnect.de) (Client Quit)
2020-10-06 15:51:36 +0200 <ski> as long as it's relating two elements from the same set
2020-10-06 15:51:55 +0200Sgeo(~Sgeo@ool-18b982ad.dyn.optonline.net)
2020-10-06 15:52:02 +0200fmeyer(uid257539@gateway/web/irccloud.com/x-yvvsemtlqrvsuvhi)
2020-10-06 15:52:04 +0200 <quazimod1> sure but we're free to choose a suitably diverse set right?
2020-10-06 15:52:11 +0200 <ski> yes
2020-10-06 15:52:19 +0200 <quazimod1> may i ask why it has to be the same set
2020-10-06 15:52:40 +0200 <quazimod1> if they're different sets, do we need to draw a ring around the 2 different sets & make a new set
2020-10-06 15:53:08 +0200Lord_of_Life(~Lord@unaffiliated/lord-of-life/x-0885362)
2020-10-06 15:53:33 +0200 <ski> the "reflexive-transitive closure" and the "transitive closure" are ways to "make" such binary relations transitive, or both reflexive and transitive, by "adding in more related pairs" (as few as possible), until we get a relation that satisfies the desired property
2020-10-06 15:53:49 +0200 <frdg> \join #prolog
2020-10-06 15:54:25 +0200son0p(~son0p@181.136.122.143)
2020-10-06 15:54:38 +0200Super_Feeling(~Super_Fee@103.108.4.50)
2020-10-06 15:54:43 +0200 <ski> quazimod1 : you can do that, if you want to. you'd take the "disjoint/discriminated union" (same things as variant/sum type, and part of "algebraic data type") of the two sets/types, to get one that "includes the elements of both"
2020-10-06 15:54:44 +0200Super_Feeling1(~Super_Fee@103.108.4.50)
2020-10-06 15:54:44 +0200Super_Feeling1(~Super_Fee@103.108.4.50) (Client Quit)
2020-10-06 15:55:01 +0200 <ski> this is what a "bipartite graph" does, for the nodes/vertices, e.g.
2020-10-06 15:55:09 +0200 <ski> frdg : haha :)
2020-10-06 15:55:18 +0200 <ski> (it's actually ##prolog)
2020-10-06 15:55:50 +0200 <frdg> heh thanks
2020-10-06 15:56:30 +0200 <Super_Feeling> hey guys, is haskell is the right way to start learning about fp? the syntax is so hard, that i get confused all the time and concepts don't make sense
2020-10-06 15:56:47 +0200 <ski> quazimod1 : usually, people would say that you take a "union" of the two sets. but more commonly, that's not what you want. in case there's no common element to the two sets, it makes no difference, but if there might be common elements, then usually you'd want the "sum type" version. in math, people often (clumsily) express this as saying you union a set with "a copy" of another set
2020-10-06 15:57:15 +0200tbreslein(~tbreslein@2a02:8108:140:44f8::3cc4) (Remote host closed the connection)
2020-10-06 15:57:33 +0200 <maerwald> Super_Feeling: yes
2020-10-06 15:57:49 +0200 <ski> (this is another example of people in mathematics usually conflating subsets (/ material sets) with sets/types/sorts (/ structural sets))
2020-10-06 15:58:19 +0200justan0theruserjustanotheruser
2020-10-06 15:58:23 +0200 <ski> Super_Feeling : is Haskell your first programming language ?
2020-10-06 15:59:22 +0200cfricke(~cfricke@unaffiliated/cfricke) (Quit: WeeChat 2.9)
2020-10-06 15:59:32 +0200 <quazimod1> Super_Feeling: are you me?
2020-10-06 15:59:35 +0200 <quazimod1> from back in time
2020-10-06 15:59:57 +0200hackagehills 0.1.2.7 - Generate STL models from SRTM elevation data. https://hackage.haskell.org/package/hills-0.1.2.7 (djf)
2020-10-06 16:00:31 +0200 <quazimod1> ski: my brain farted when you said that a bartite graph does this
2020-10-06 16:00:39 +0200 <ski> heh, why ? :)
2020-10-06 16:01:51 +0200 <quazimod1> if you have u0 -> u1 and u1 -> v1 then i'd get it
2020-10-06 16:01:58 +0200 <quazimod1> but bipartite graphs don't do this
2020-10-06 16:02:39 +0200 <ski> (note that the edges in an (undirected, non-multi) graph is just a binary relation on the set/type of vertices/nodes)
2020-10-06 16:02:39 +0200 <quazimod1> so then i dont understand the modelling of the 'includes the elements of both' in a bipartite graph
2020-10-06 16:03:18 +0200 <ski> for a graph, `->*' would describe paths in the graph
2020-10-06 16:03:42 +0200 <quazimod1> mmm i can maybe understand
2020-10-06 16:03:47 +0200 <quazimod1> if we have nodes in groups U & V
2020-10-06 16:03:58 +0200 <quazimod1> then you could get from v1 to v2 by going into U
2020-10-06 16:04:04 +0200seanvert`(~user@177.84.244.242)
2020-10-06 16:04:11 +0200 <quazimod1> i dont see any bipartite graphs with an edge from a node in V to another node in V
2020-10-06 16:04:14 +0200 <quazimod1> is that what you mean?
2020-10-06 16:04:28 +0200 <ski> (well, i suppose i should just say directed. for undirected, you add the requirement that the relation is symmetric. another way to express it is that instead of having edges be ordered pairs, you have them be unordered pairs)
2020-10-06 16:05:11 +0200 <quazimod1> symmetric meaning goes in both directions?
2020-10-06 16:05:15 +0200 <ski> yes
2020-10-06 16:05:27 +0200 <ski> if `x -> y', then also `y -> x'
2020-10-06 16:05:32 +0200 <quazimod1> yeah ok
2020-10-06 16:05:36 +0200seanvert(~user@177.84.244.242) (Ping timeout: 272 seconds)
2020-10-06 16:05:47 +0200 <Super_Feeling> ski, no i've done a lot of python, js, go and c++.
2020-10-06 16:05:50 +0200 <quazimod1> but referring to my earlier qusetion
2020-10-06 16:05:59 +0200 <Super_Feeling> But i've no clue about fp, since i'm self taught
2020-10-06 16:06:13 +0200blasius(~blasius@4e69b241.skybroadband.com) (Ping timeout: 264 seconds)
2020-10-06 16:06:15 +0200 <ski> yea, for a bipartite graph, we'd have the additional requirement that there's no edges "inside" the two parts of the partition of the vertices
2020-10-06 16:07:11 +0200 <ski> so it's not that you get exactly a bipartite graph, if you divide your nodes into two kinds/sorts/types/sets. but it's a nice way to think about it, although you still need that extra condition about no "internal edges"
2020-10-06 16:07:33 +0200 <quazimod1> yeah see that completely threw me off
2020-10-06 16:07:56 +0200 <quazimod1> otherwise, discounting that that additional rule in bipartite graphs I can understand what you mean now
2020-10-06 16:08:12 +0200 <ski> Super_Feeling : well, learning another programming paradigm (like functional programming, or logic programming) will be a bit like learning to program all over from scratch again. it's not quite like that, but it's a good mindset to assume, when learning. you will need to unlearn things you're taking for granted
2020-10-06 16:08:12 +0200 <quazimod1> also graphs are hard & weird
2020-10-06 16:08:41 +0200 <ski> Super_Feeling : there are of course things that carry over. but it's better to set that aside, for the time being, until you got the basics under your belt
2020-10-06 16:08:42 +0200 <quazimod1> Super_Feeling: i had a huge chip on my shoulder when it came to my inadequacies re. trying to understand monads
2020-10-06 16:09:01 +0200 <quazimod1> step 1: pick up haskell & try to build something simple with it
2020-10-06 16:09:13 +0200 <quazimod1> step 2: read & watch a lot of youtube videos about FP & haskell
2020-10-06 16:09:16 +0200 <ski> Super_Feeling : do you remember how confused you were, when you learned programming initially, how the concepts didn't make sense ?
2020-10-06 16:09:23 +0200 <Super_Feeling> exactly, it's like everything we do in oop has no place here in haskell
2020-10-06 16:09:25 +0200 <quazimod1> the maths theory is an indulgence, you don't need to do it
2020-10-06 16:09:27 +0200 <Super_Feeling> yes, makes sense
2020-10-06 16:09:43 +0200 <quazimod1> Super_Feeling: everything you do in oop has no place here
2020-10-06 16:09:55 +0200 <quazimod1> lol, i guess thats true?
2020-10-06 16:10:26 +0200 <ski> yea .. for monads, i think most "monad tutorials" out there doesn't help that much (there are a few exceptions), possibly even making it harder to understand
2020-10-06 16:10:57 +0200 <quazimod1> ski: you know functor is a craaaaazy intimidating name for something that's pretty freaking simple
2020-10-06 16:11:30 +0200 <ski> the best practice, i think, is to first learn properly how the basic type system works, with type signatures, `data' types, polymorphism, parameterized `data' types, type classes .. before trying to tackle monads. also, start by learning particular monads, not by trying to grasp the general concept
2020-10-06 16:11:38 +0200 <Super_Feeling> i guess i will continue with "real world haskell"
2020-10-06 16:11:51 +0200mpereira(~mpereira@2a02:810d:f40:d96:693e:4333:5b77:9e8f) (Remote host closed the connection)
2020-10-06 16:11:59 +0200 <quazimod1> Super_Feeling: i'm not really a haskell developer, ski's forgotten more about haskell than I ever knew. But I'd say everything we do in oop kinda sucks anyway
2020-10-06 16:12:06 +0200 <maerwald> quazimod1: I have the unpopular opinion that monads give way to OOP style programming in haskell
2020-10-06 16:12:07 +0200 <quazimod1> it's post modernism for programming
2020-10-06 16:12:52 +0200 <maerwald> The main (informal) property about OOP is, imo, that it clouds control flow
2020-10-06 16:12:53 +0200 <quazimod1> Super_Feeling: just build basic stuff & work yoru way up
2020-10-06 16:13:00 +0200 <maerwald> Monads can do the same (especially transformers)
2020-10-06 16:13:01 +0200 <ski> quazimod1 : well, there are some good modularity things in OOP. but they're not exclusive to OOP. also, "objects are a poor man's closures" (there's also the reverse saying, in OOP circles, "closures are a poor man's objects" ;)
2020-10-06 16:13:36 +0200fendor_(~fendor@t204-126.demo.tuwien.ac.at) (Remote host closed the connection)
2020-10-06 16:13:43 +0200tzh(~tzh@2601:448:c500:5300::143b)
2020-10-06 16:13:56 +0200 <quazimod1> i dno man
2020-10-06 16:14:24 +0200 <ski> quazimod1 : yea. perhaps one could have called it `Container' (or something like that) instead of `Functor'. however, that term already have lots of (subtly) different connotations. sometimes it's just better to use a "new" word, that's not encumbered with lots of associations which may be inappropriate
2020-10-06 16:14:28 +0200 <Super_Feeling> okay so basically start building calculators in haskell, and work your way up lol (that's how i learned cpp)
2020-10-06 16:14:39 +0200 <quazimod1> oop feels like a group of dudes got together, started echoing each other's anthropomorphisations (or should i say objectomorphisations) and then now por Super_Feeling needs to know 'oop patters' and it still sucks to write complex or big programs
2020-10-06 16:14:45 +0200John20(~John@82.46.59.122) (Ping timeout: 256 seconds)
2020-10-06 16:15:08 +0200 <ski> quazimod1 : furthermore, by using the established (in math) term "functor", we can (more easily) make use of existing theory and insights regarding functors
2020-10-06 16:15:22 +0200 <quazimod1> ski: not saying it's something to change, not even hinting at that
2020-10-06 16:15:23 +0200 <quazimod1> just saying
2020-10-06 16:15:27 +0200John20(~John@82.46.59.122)
2020-10-06 16:15:31 +0200 <quazimod1> how hilariously scary that word is vs what is actually happening
2020-10-06 16:16:27 +0200 <ski> but yes, i understand it can feel intimidating, to see some apparently alien jargon, that one hasn't a clue (based on commonly used terminology) what it might mean. especially if one's not used to doing that
2020-10-06 16:17:00 +0200 <quazimod1> mostly since it's not even a type of function
2020-10-06 16:17:06 +0200 <quazimod1> i hear functor i'm like
2020-10-06 16:17:09 +0200 <quazimod1> scary function
2020-10-06 16:17:12 +0200 <quazimod1> scary happenings, run
2020-10-06 16:17:30 +0200 <quazimod1> then you say 'oh yeah that data type is a functor'
2020-10-06 16:17:32 +0200 <quazimod1> lol wtf?
2020-10-06 16:17:37 +0200Habib(~Habib@185.134.23.120) ()
2020-10-06 16:18:40 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:f500:dc4c:283a:a1a5) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 16:18:46 +0200danso(~dan@107-190-41-58.cpe.teksavvy.com)
2020-10-06 16:18:47 +0200alp(~alp@2a01:e0a:58b:4920:41af:3872:fb2a:8dae) (Ping timeout: 272 seconds)
2020-10-06 16:18:56 +0200Super_Feeling(~Super_Fee@103.108.4.50) (Quit: Leaving)
2020-10-06 16:18:57 +0200 <ski> maerwald : i'm not sure about the "OOP" part, but i'd agree that sometimes we seem to reach to easily for a monad (which is basically doing imperative programming, although sometimes a very powerful form of imperative programming, and neatly separated from the rest of the language, in Haskell), rather than seek a more "declarative" (or "denotative" as conal prefers to call it) style
2020-10-06 16:19:01 +0200 <quazimod1> hey here's aweird one, suppose that you have a type that's like a ternary maybe, like Just x, Kinda x, None
2020-10-06 16:19:09 +0200 <quazimod1> that can't really be a functor can it
2020-10-06 16:19:17 +0200 <sm[m]> Super_Feeling: you may find https://code.world or
2020-10-06 16:19:17 +0200 <sm[m]> @where haskell-via-sokoban good
2020-10-06 16:19:18 +0200 <lambdabot> https://haskell-via-sokoban.nomeata.de
2020-10-06 16:19:25 +0200shatriff(~vitaliish@217.27.153.240) (Remote host closed the connection)
2020-10-06 16:20:51 +0200 <quazimod1> dumb question i guess, isuppose it could be a functor depending on semantics
2020-10-06 16:21:05 +0200 <maerwald> ski: monads are the most expressive tool and must be avoided most, as such
2020-10-06 16:21:12 +0200 <ski> quazimod1 : well, thing is, it is "a type of function" .. only, a function on the type level
2020-10-06 16:21:16 +0200 <maerwald> and for pretty practical reasons: they're slow
2020-10-06 16:21:18 +0200 <sm[m]> ack, missed them
2020-10-06 16:21:30 +0200 <quazimod1> ski: you talking about fmap?
2020-10-06 16:21:33 +0200 <ski> no
2020-10-06 16:21:36 +0200 <quazimod1> or `functor`
2020-10-06 16:21:42 +0200 <quazimod1> oh, ok new brain fart
2020-10-06 16:21:54 +0200 <ski> take `Tree'. this is a function that, given a type, produces another type
2020-10-06 16:22:02 +0200 <quazimod1> the data type maybe is a function at the type level, let me think
2020-10-06 16:22:11 +0200 <quazimod1> Yeah that's fair
2020-10-06 16:22:15 +0200 <ski> so, if we pass `Int' to `Tree', we get `Tree Int', the type of trees of `Int' (trees with elements of type `Int')
2020-10-06 16:22:17 +0200 <quazimod1> hey look at that you made me smarter
2020-10-06 16:22:27 +0200Tops21(~Tobias@dyndsl-095-033-093-242.ewe-ip-backbone.de)
2020-10-06 16:22:45 +0200 <ski> `Tree' could also be said to be a parameterized type, a "type template", an "incomplete/unsaturated type"
2020-10-06 16:22:48 +0200 <quazimod1> i hadn't really thought about it like that but yeah that's fair
2020-10-06 16:22:50 +0200mirrorbird(~psutcliff@2a00:801:2d5:9d73:ff00:6553:d451:a276) (Quit: Leaving)
2020-10-06 16:22:58 +0200Tops22(~Tobias@dyndsl-095-033-093-242.ewe-ip-backbone.de)
2020-10-06 16:23:08 +0200spew(uid195861@gateway/web/irccloud.com/x-srtpfsrzrguwlscu)
2020-10-06 16:23:26 +0200 <John20> Hi All, is it correct to say that Haskell language extensions increase the space of valid 'haskell' programs? e.g. if a program is valid in core haskell, it will also be valid with extension A switched on?
2020-10-06 16:23:26 +0200 <quazimod1> im trying to imagine a type that's a functor but not a type function
2020-10-06 16:23:36 +0200jonatanb(~jonatanb@79.184.190.239.ipv4.supernova.orange.pl) (Quit: Leaving...)
2020-10-06 16:23:39 +0200 <ski> quazimod1 : if you define `data TernaryMaybe a = None | Kinda a | Just a', then `TernaryMaybe' is a functor
2020-10-06 16:23:40 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-06 16:23:53 +0200 <ski> but perhaps you wanted `Kinda' and `Just' to hold items of different types ?
2020-10-06 16:24:13 +0200 <quazimod1> TernaryMaybe is weird
2020-10-06 16:24:26 +0200 <sm[m]> broadly but not 100% true I think, John20
2020-10-06 16:24:32 +0200 <ski> maerwald : yea, there's something to be said for that. <https://en.wikipedia.org/wiki/Rule_of_least_power>
2020-10-06 16:24:40 +0200 <quazimod1> i wonder if you could throw in an fmap that takes more than 1 function
2020-10-06 16:25:04 +0200 <maerwald> ski: that rule isn't popular in here :p
2020-10-06 16:25:25 +0200Tops2(~Tobias@dyndsl-095-033-093-242.ewe-ip-backbone.de) (Ping timeout: 240 seconds)
2020-10-06 16:25:27 +0200frdg(60e94035@pool-96-233-64-53.bstnma.fios.verizon.net) (Remote host closed the connection)
2020-10-06 16:25:29 +0200 <ski> John20 : mostly. some extensions introduce new keywords, though, which can't be used as identifiers then
2020-10-06 16:25:47 +0200Gurkenglas(~Gurkengla@unaffiliated/gurkenglas) (Ping timeout: 240 seconds)
2020-10-06 16:26:14 +0200frdg(60e94035@pool-96-233-64-53.bstnma.fios.verizon.net)
2020-10-06 16:26:24 +0200 <quazimod1> ok it's 1am in sleepy sydney
2020-10-06 16:26:26 +0200acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2020-10-06 16:26:36 +0200 <quazimod1> time for me to hit the hay, have to wrestle a kangaroo tomorrow
2020-10-06 16:26:37 +0200 <ski> maerwald : it's about the tradeoff between expressiveness / expressive power (/ "cavalier power") and "reasonability" / reasoning (including refactoring) power (/ "predictive power")
2020-10-06 16:27:04 +0200Tops21(~Tobias@dyndsl-095-033-093-242.ewe-ip-backbone.de) (Ping timeout: 256 seconds)
2020-10-06 16:27:26 +0200 <ski> quazimod1 : "i wonder if you could throw in an fmap that takes more than 1 function" -- see `Bifunctor',`Difunctor' (hrm, `Profunctor' ..)
2020-10-06 16:27:30 +0200 <ski> @type bimap
2020-10-06 16:27:32 +0200 <lambdabot> Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
2020-10-06 16:27:40 +0200 <ski> @type dimap
2020-10-06 16:27:41 +0200 <lambdabot> Profunctor p => (a -> b) -> (c -> d) -> p b c -> p a d
2020-10-06 16:27:45 +0200 <John20> Thanks sm[m] and ski. That answers my question
2020-10-06 16:27:57 +0200 <ski> > bimap (* 2) show (3,4)
2020-10-06 16:27:57 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:1da1:2732:bb9f:da76)
2020-10-06 16:28:00 +0200 <lambdabot> (6,"4")
2020-10-06 16:28:12 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 256 seconds)
2020-10-06 16:29:08 +0200voyons_osti(~dan@107-190-41-58.cpe.teksavvy.com)
2020-10-06 16:29:20 +0200xerox_(~xerox@unaffiliated/xerox) (Ping timeout: 258 seconds)
2020-10-06 16:29:22 +0200 <ski> > dimap (+ 2) (+ 2) (^ 2) 3
2020-10-06 16:29:25 +0200 <lambdabot> 27
2020-10-06 16:30:20 +0200 <quazimod1> that's cool
2020-10-06 16:30:38 +0200 <ski> quazimod1 : "im trying to imagine a type that's a functor but not a type function" -- all functors are type functions. but not necessarily vice versa. e.g. `Endo',`IORef',`Comparision' (with `type Comparision a = a -> a -> Ordering')
2020-10-06 16:30:40 +0200bahamas(~lucian@unaffiliated/bahamas)
2020-10-06 16:31:13 +0200 <ski> quazimod1 : anyway, good night, and have fun with programming, whether in Haskell or otherwhere :)
2020-10-06 16:31:32 +0200 <quazimod1> btw profunctor is cool
2020-10-06 16:31:39 +0200 <quazimod1> i hadn't considered that
2020-10-06 16:31:55 +0200 <ski> note how it goes in "opposite direction" in one type parameter
2020-10-06 16:32:03 +0200 <quazimod1> i cant imagine a specific use but i'm sure ive come across that
2020-10-06 16:32:05 +0200 <quazimod1> yeah
2020-10-06 16:32:16 +0200 <quazimod1> that's neat
2020-10-06 16:32:18 +0200 <ski> that's known as being "contravariant". there's `Contrafunctor' for contravariant functors (ordinary ones are covariant)
2020-10-06 16:32:30 +0200 <quazimod1> and like i said, i'm sure there are places where this abstraction could have been a neat solution
2020-10-06 16:32:37 +0200 <ski> contravariant functors are "consumers". covariant ones are producers
2020-10-06 16:32:44 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-06 16:32:49 +0200ralejs(~ralejs@2620:10d:c093:400::5:2842) (Read error: Connection reset by peer)
2020-10-06 16:33:01 +0200 <quazimod1> i dont understand the consumer/producer thing
2020-10-06 16:33:01 +0200 <ski> a bifunctor is covariant in both parameters. a difunctor (cough, "profunctor") is contravariant in one parameter, and covariant in the other
2020-10-06 16:33:15 +0200ralejs(~ralejs@2620:10d:c093:400::5:2842)
2020-10-06 16:33:23 +0200 <ski> (covariance and contravariance also crops up, with subtyping in OOP)
2020-10-06 16:33:46 +0200 <ski> consider `Tree a', this "produces `a's" in the sense that you can get `a' elements from it
2020-10-06 16:33:58 +0200hackagelibfuse3 0.1.1.1 - A Haskell binding for libfuse-3.x https://hackage.haskell.org/package/libfuse3-0.1.1.1 (yohashi)
2020-10-06 16:34:00 +0200 <quazimod1> sure
2020-10-06 16:34:06 +0200snakemasterflex(~snakemast@213.100.206.23) (Ping timeout: 272 seconds)
2020-10-06 16:34:12 +0200 <ski> `Maybe a' is similar, and so is `IO a' (although you can't "escape" from `IO'). you can still `fmap' over `IO', though
2020-10-06 16:34:27 +0200toorevitimirp(~tooreviti@117.182.180.245) (Ping timeout: 240 seconds)
2020-10-06 16:34:31 +0200 <quazimod1> sure
2020-10-06 16:34:41 +0200 <ski> but if you have `type Predicate a = a -> Bool', then a `Predicate a' is a consumer of `a's, not a producer (same for `Comparision' above)
2020-10-06 16:34:46 +0200 <quazimod1> also, for another time, i do not understand why you cant 'escape' from IO
2020-10-06 16:35:02 +0200toorevitimirp(~tooreviti@117.182.180.245)
2020-10-06 16:35:11 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com)
2020-10-06 16:35:12 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com) (Changing host)
2020-10-06 16:35:12 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 16:35:22 +0200 <ski> another example is something like `newtype Sink a = MkSink (a -> IO ())', that's used to throw `a' values to somewhere else, perhaps in another concurrently executing thread. that's also contravariant
2020-10-06 16:35:41 +0200 <quazimod1> oh i see what you mean
2020-10-06 16:35:43 +0200ddellacosta(~dd@86.106.121.168)
2020-10-06 16:36:06 +0200 <ski> if you have a `Chan a', that's a concurrent channel that you can both write to, and read from, from different threads
2020-10-06 16:36:31 +0200 <ski> sometimes it may be good to "separate" the read and the write ends, so that you have `ReadChan a' to read `a's from, and `WriteChan a' to write `a's to
2020-10-06 16:36:59 +0200 <ski> `ReadChan' can be made into a (covariant) functor (so `Functor'), while `WriteChan' can be made into a contravariant functor (`Contrafunctor')
2020-10-06 16:37:32 +0200 <ski> you can do the same thing with references to mutable cells, like `IORef',`IOArray',`MVar', have separate read and write interfaces to them
2020-10-06 16:37:55 +0200 <ski> the point of doing this, is if you want to ensure that one part of the program can only read from it, and another part of the program can only write to it
2020-10-06 16:38:17 +0200 <quazimod1> I think that I understand
2020-10-06 16:38:36 +0200phaul(~phaul@ruby/staff/phaul) (Ping timeout: 260 seconds)
2020-10-06 16:39:09 +0200 <ski> (i think people doesn't do this, that commonly, but it could be done. being able to `fmap' or `contramap' (for contravariant functors) over them could be handy, in some cases. `Chan',`IORef',`IOArray i' are not functors at all, neither covariant nor contravariant, you can't "map" over them)
2020-10-06 16:42:19 +0200 <quazimod1> this all makes sense
2020-10-06 16:42:21 +0200 <quazimod1> also i really should seep!
2020-10-06 16:42:31 +0200lorozic(~lorozic@wks-41-812.mpi-sws.org) (Quit: Leaving)
2020-10-06 16:42:32 +0200 <quazimod1> peace, tomorrow!
2020-10-06 16:42:33 +0200 <ski> have fun !
2020-10-06 16:42:37 +0200datajerk(~datajerk@sense.net) (Quit: ZNC 1.7.3 - https://znc.in)
2020-10-06 16:42:40 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 265 seconds)
2020-10-06 16:42:52 +0200phaul(~phaul@ruby/staff/phaul)
2020-10-06 16:42:56 +0200datajerk(~datajerk@sense.net)
2020-10-06 16:43:03 +0200pta2002(~quassel@104.248.23.110) (Remote host closed the connection)
2020-10-06 16:44:11 +0200pta2002(~quassel@104.248.23.110)
2020-10-06 16:45:21 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-06 16:46:38 +0200Gurkenglas(~Gurkengla@unaffiliated/gurkenglas)
2020-10-06 16:50:28 +0200 <hololeap> @unmtl StateT s (ErrorT e (ReaderT r m)) a
2020-10-06 16:50:28 +0200 <lambdabot> s -> r -> m (Either e (a, s))
2020-10-06 16:50:44 +0200 <hololeap> @unmtl ReaderT r (StateT s (ErrorT e m)) a
2020-10-06 16:50:44 +0200 <lambdabot> r -> s -> m (Either e (a, s))
2020-10-06 16:51:19 +0200mmynsted[m](mmynstedtc@gateway/shell/matrix.org/x-zaildyuiusfkwsag)
2020-10-06 16:52:44 +0200 <hololeap> so, where you place a ReaderT doesn't change anything except the order of input arguments?
2020-10-06 16:53:21 +0200oisdk(~oisdk@2001:bb6:3329:d100:c982:e387:7052:58be)
2020-10-06 16:53:59 +0200Guest18(567e8866@gateway/web/cgi-irc/kiwiirc.com/ip.86.126.136.102)
2020-10-06 16:54:56 +0200 <ski> @unmtl ReaderT r (ContT o m) a
2020-10-06 16:54:56 +0200 <lambdabot> r -> (a -> m o) -> m o
2020-10-06 16:54:57 +0200 <ski> @unmtl ContT o (ReaderT r m) a
2020-10-06 16:54:57 +0200 <lambdabot> (a -> r -> m o) -> r -> m o
2020-10-06 16:55:06 +0200 <ski> @unmtl StateT s (ContT o m) a
2020-10-06 16:55:06 +0200 <lambdabot> s -> (a -> s -> m o) -> m o
2020-10-06 16:55:27 +0200 <ski> @unmtl ContT o (StateT s m) a
2020-10-06 16:55:28 +0200 <lambdabot> (a -> s -> m (o, s)) -> s -> m (o, s)
2020-10-06 16:55:35 +0200 <ski> hololeap : "depends"
2020-10-06 16:55:37 +0200alp(~alp@2a01:e0a:58b:4920:3117:a7c5:eaf1:360f)
2020-10-06 16:56:57 +0200 <ski> also, `ReaderT r (LogicT m) a' is not the same as `LogicT (ReaderT r m) a'
2020-10-06 16:57:08 +0200akegalj(~akegalj@93-138-123-17.adsl.net.t-com.hr)
2020-10-06 16:57:13 +0200 <ski> (where `LogicT' is more or less "`ListT' done right")
2020-10-06 16:57:13 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 264 seconds)
2020-10-06 16:57:17 +0200 <ski> @wiki ListT done right
2020-10-06 16:57:17 +0200 <lambdabot> https://wiki.haskell.org/ListT_done_right
2020-10-06 16:57:23 +0200jneira[m](~jneira@227.red-176-87-45.dynamicip.rima-tde.net)
2020-10-06 16:58:23 +0200 <ski> @hackage logict
2020-10-06 16:58:23 +0200 <lambdabot> https://hackage.haskell.org/package/logict
2020-10-06 16:58:42 +0200martin02(silas@hund.fs.lmu.de)
2020-10-06 17:00:01 +0200noirin(~noirin@185.103.96.135) ()
2020-10-06 17:04:35 +0200plutoniix(~q@ppp-223-24-166-134.revip6.asianet.co.th) (Quit: Leaving)
2020-10-06 17:05:46 +0200toorevitimirp(~tooreviti@117.182.180.245) (Remote host closed the connection)
2020-10-06 17:08:51 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 17:12:42 +0200nand_(~nand@haasn.xyz)
2020-10-06 17:12:47 +0200nand_(~nand@haasn.xyz) (Remote host closed the connection)
2020-10-06 17:14:10 +0200cpressey(~cpressey@88.144.95.3) (Quit: WeeChat 1.9.1)
2020-10-06 17:17:48 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 272 seconds)
2020-10-06 17:18:06 +0200cpressey(~cpressey@88.144.95.3)
2020-10-06 17:19:47 +0200 <AWizzArd> Using the `req` http client – is there a way to get the request as a String? The headers and body? The data that it will send over the wire?
2020-10-06 17:20:19 +0200fendor(~fendor@178.115.129.46.wireless.dyn.drei.com)
2020-10-06 17:20:29 +0200Salt1(~Salt@s91904426.blix.com)
2020-10-06 17:22:11 +0200seanvert`(~user@177.84.244.242) (Remote host closed the connection)
2020-10-06 17:23:00 +0200bloodstalker(~bloodstal@46.166.187.154)
2020-10-06 17:24:20 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-06 17:24:27 +0200Gurkenglas(~Gurkengla@unaffiliated/gurkenglas) (Ping timeout: 240 seconds)
2020-10-06 17:25:37 +0200rihards(~rihards@balticom-142-78-50.balticom.lv) (Quit: rihards)
2020-10-06 17:29:00 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 260 seconds)
2020-10-06 17:29:58 +0200acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 256 seconds)
2020-10-06 17:30:42 +0200shatriff(~vitaliish@88.155.146.251)
2020-10-06 17:30:52 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 17:31:08 +0200PragCypher_(~cypher@li1507-98.members.linode.com) (Quit: ZNC 1.7.5 - https://znc.in)
2020-10-06 17:31:19 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-06 17:31:20 +0200bahamas(~lucian@unaffiliated/bahamas) (Ping timeout: 260 seconds)
2020-10-06 17:31:53 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-06 17:32:30 +0200shatriff(~vitaliish@88.155.146.251) (Remote host closed the connection)
2020-10-06 17:34:23 +0200Lord_of_Life(~Lord@unaffiliated/lord-of-life/x-0885362) (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine)
2020-10-06 17:34:52 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311)
2020-10-06 17:36:07 +0200ryansmccoy(~ryansmcco@193.37.254.27) (Ping timeout: 240 seconds)
2020-10-06 17:36:30 +0200voyons_osti(~dan@107-190-41-58.cpe.teksavvy.com) (Read error: Connection reset by peer)
2020-10-06 17:36:31 +0200danso(~dan@107-190-41-58.cpe.teksavvy.com) (Read error: Connection reset by peer)
2020-10-06 17:36:31 +0200ryansmccoy(~ryansmcco@156.96.151.132)
2020-10-06 17:36:45 +0200kav(~kari@dsl-hkibng42-56733f-225.dhcp.inet.fi) (Ping timeout: 240 seconds)
2020-10-06 17:36:46 +0200shatriff(~vitaliish@88.155.146.251)
2020-10-06 17:36:46 +0200avdb(~avdb@ip-213-49-61-90.dsl.scarlet.be)
2020-10-06 17:37:02 +0200danso(~dan@107-190-41-58.cpe.teksavvy.com)
2020-10-06 17:37:18 +0200voyons_osti(~dan@107-190-41-58.cpe.teksavvy.com)
2020-10-06 17:37:26 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 272 seconds)
2020-10-06 17:37:32 +0200 <dminuoso> AWizzArd: To what end?
2020-10-06 17:38:04 +0200dyeplexer(~lol@unaffiliated/terpin)
2020-10-06 17:38:30 +0200dhouthoo(~dhouthoo@ptr-eiv6509pb4ifhdr9lsd.18120a2.ip6.access.telenet.be) (Quit: WeeChat 2.8)
2020-10-06 17:39:05 +0200PragCypher(~cypher@li1507-98.members.linode.com)
2020-10-06 17:39:24 +0200PragCypher(~cypher@li1507-98.members.linode.com) (Client Quit)
2020-10-06 17:40:02 +0200xerox_(~xerox@unaffiliated/xerox)
2020-10-06 17:40:05 +0200knupfer(~Thunderbi@dynamic-046-114-150-131.46.114.pool.telefonica.de)
2020-10-06 17:41:29 +0200 <dminuoso> At any rate, judging from the API, you could use req' to do that.
2020-10-06 17:41:41 +0200PragCypher(~cypher@li1507-98.members.linode.com)
2020-10-06 17:44:35 +0200kav(~kari@dsl-hkibng42-56733f-225.dhcp.inet.fi)
2020-10-06 17:44:41 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:1da1:2732:bb9f:da76) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 17:45:15 +0200kritzefitz(~kritzefit@fw-front.credativ.com) (Remote host closed the connection)
2020-10-06 17:45:36 +0200 <dminuoso> You dont get any access to the primitives that generate the raw string though.
2020-10-06 17:45:41 +0200 <dminuoso> That's hidden deep inside https://hackage.haskell.org/package/http-client-0.7.2.1/docs/src/Network.HTTP.Client.Request.html#…
2020-10-06 17:46:12 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-06 17:46:40 +0200hnOsmium0001(uid453710@gateway/web/irccloud.com/x-wkoagvlxhlhmtgti)
2020-10-06 17:47:58 +0200 <AWizzArd> dminuoso: okay I see, thx. I saw that there *are* tools to analyze the response (but not the request).
2020-10-06 17:48:07 +0200borne(~fritjof@2001:638:708:30da:1afd:4599:bd4b:9f4b) (Ping timeout: 240 seconds)
2020-10-06 17:48:20 +0200 <dminuoso> There's also several steps in between that do modifications to the request.
2020-10-06 17:48:33 +0200conal(~conal@66.115.157.135) (Quit: Computer has gone to sleep.)
2020-10-06 17:48:43 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:1da1:2732:bb9f:da76)
2020-10-06 17:48:46 +0200 <dminuoso> So req' only gives you access to an early less-modified version of it
2020-10-06 17:50:05 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 240 seconds)
2020-10-06 17:50:39 +0200bahamas(~lucian@unaffiliated/bahamas)
2020-10-06 17:52:00 +0200 <AWizzArd> I found a QQ that lets me write multiline strings: http://hackage.haskell.org/package/raw-strings-qq-1.1/docs/Text-RawString-QQ.html
2020-10-06 17:52:14 +0200 <AWizzArd> Is there something that outputs Text or ByteString?
2020-10-06 17:53:06 +0200 <dminuoso> AWizzArd: there's string-qq
2020-10-06 17:53:34 +0200 <dminuoso> You could trivially make your own QQ around the one from raw-strings-qq as well)
2020-10-06 17:53:44 +0200xff0x(~fox@2001:1a81:5339:8000:bdc7:ef33:4985:5e4f) (Ping timeout: 244 seconds)
2020-10-06 17:53:50 +0200 <dminuoso> It's just a matter of `fmap fromString`
2020-10-06 17:54:09 +0200 <AWizzArd> dminuoso: perfect, I wasn’t brave enough to ask even for this.
2020-10-06 17:54:28 +0200kritzefitz(~kritzefit@fw-front.credativ.com)
2020-10-06 17:54:50 +0200xff0x(~fox@2001:1a81:5339:8000:d49f:ac74:3895:c1cd)
2020-10-06 17:54:50 +0200conal(~conal@66.115.157.135)
2020-10-06 17:54:53 +0200kritzefitz(~kritzefit@fw-front.credativ.com) (Remote host closed the connection)
2020-10-06 17:54:58 +0200ubert(~Thunderbi@2a02:8109:9880:303c:ca5b:76ff:fe29:f233) (Remote host closed the connection)
2020-10-06 17:55:18 +0200avdb(~avdb@ip-213-49-61-90.dsl.scarlet.be) (Quit: WeeChat 2.9)
2020-10-06 17:56:27 +0200albert_99(~Albert@p200300e5ff0b5b39340e476afbaec452.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-06 17:57:06 +0200PragCypher(~cypher@li1507-98.members.linode.com) (Quit: ZNC 1.7.5 - https://znc.in)
2020-10-06 17:57:13 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de)
2020-10-06 17:57:20 +0200conal(~conal@66.115.157.135) (Client Quit)
2020-10-06 17:58:22 +0200cfricke(~cfricke@unaffiliated/cfricke)
2020-10-06 17:58:57 +0200PragCypher(~cypher@li1507-98.members.linode.com)
2020-10-06 17:59:06 +0200tttom[m](tttommatri@gateway/shell/matrix.org/x-adhyifuyanfymgvo)
2020-10-06 17:59:34 +0200cfricke(~cfricke@unaffiliated/cfricke) (Client Quit)
2020-10-06 17:59:43 +0200lordcirth_(~lordcirth@2607:f2c0:95a8:ef00:b128:6022:758c:dbc) ("Leaving")
2020-10-06 17:59:44 +0200kritzefitz(~kritzefit@fw-front.credativ.com)
2020-10-06 17:59:59 +0200nbloomf(~nbloomf@2600:1700:83e0:1f40:1da1:2732:bb9f:da76) (Quit: Textual IRC Client: www.textualapp.com)
2020-10-06 18:00:15 +0200cpressey(~cpressey@88.144.95.3) (Quit: WeeChat 1.9.1)
2020-10-06 18:01:11 +0200kuribas(~user@ptr-25vy0i9yx55ffflw5e3.18120a2.ip6.access.telenet.be) (Quit: ERC (IRC client for Emacs 26.3))
2020-10-06 18:01:47 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2020-10-06 18:02:02 +0200kritzefitz(~kritzefit@fw-front.credativ.com) (Client Quit)
2020-10-06 18:02:25 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-06 18:05:55 +0200jchia_(~jchia@58.32.35.239) (Ping timeout: 240 seconds)
2020-10-06 18:07:53 +0200bahamas(~lucian@unaffiliated/bahamas) (Ping timeout: 260 seconds)
2020-10-06 18:09:30 +0200aenesidemus(~aenesidem@c-73-53-247-25.hsd1.fl.comcast.net)
2020-10-06 18:09:36 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 260 seconds)
2020-10-06 18:11:06 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net)
2020-10-06 18:11:07 +0200 <tomsmeding> AWizzArd: if all you're after is multiline strings, not necessarily the lack of escape sequences, then plain haskell has that :p
2020-10-06 18:11:30 +0200 <tomsmeding> thing = "this is a\n\
2020-10-06 18:11:34 +0200 <tomsmeding> \multiline string"
2020-10-06 18:11:51 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com)
2020-10-06 18:11:51 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com) (Changing host)
2020-10-06 18:11:51 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 18:11:51 +0200 <tomsmeding> (... with two more spaces)
2020-10-06 18:12:11 +0200akegalj(~akegalj@93-138-123-17.adsl.net.t-com.hr) (Remote host closed the connection)
2020-10-06 18:13:00 +0200da39a3ee5e6b4b0d(~textual@n11211935170.netvigator.com) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-10-06 18:13:02 +0200PragCypher(~cypher@li1507-98.members.linode.com) (Quit: ZNC 1.7.5 - https://znc.in)
2020-10-06 18:14:31 +0200PragCypher(~cypher@li1507-98.members.linode.com)
2020-10-06 18:16:02 +0200cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net)
2020-10-06 18:17:37 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-06 18:19:06 +0200conal(~conal@66.115.157.135)
2020-10-06 18:19:47 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 240 seconds)
2020-10-06 18:19:50 +0200conal(~conal@66.115.157.135) (Client Quit)
2020-10-06 18:20:07 +0200minne(~minne@4e69b241.skybroadband.com)
2020-10-06 18:20:29 +0200 <AWizzArd> tomsmeding: I considered that, but it’s just not readable.
2020-10-06 18:20:46 +0200 <AWizzArd> tomsmeding: the [s| ... |] macro works fine.
2020-10-06 18:23:12 +0200GyroW(~GyroW@unaffiliated/gyrow) (Quit: Someone ate my pie)
2020-10-06 18:23:23 +0200GyroW(~GyroW@d54C03E98.access.telenet.be)
2020-10-06 18:23:23 +0200GyroW(~GyroW@d54C03E98.access.telenet.be) (Changing host)
2020-10-06 18:23:23 +0200GyroW(~GyroW@unaffiliated/gyrow)
2020-10-06 18:25:28 +0200albert_99(~Albert@p200300e5ff0b5b39340e476afbaec452.dip0.t-ipconnect.de)
2020-10-06 18:26:45 +0200conal(~conal@64.71.133.70)
2020-10-06 18:27:17 +0200shatriff(~vitaliish@88.155.146.251) (Remote host closed the connection)
2020-10-06 18:27:19 +0200avdb(~avdb@ip-213-49-61-90.dsl.scarlet.be)
2020-10-06 18:29:47 +0200albert_99(~Albert@p200300e5ff0b5b39340e476afbaec452.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-06 18:30:06 +0200codygman_work(~user@47-184-107-46.dlls.tx.frontiernet.net)
2020-10-06 18:30:07 +0200 <maerwald> pretty much all quasiquoters are broken on unicode, aren't they?
2020-10-06 18:31:12 +0200Takumo(takumo@unaffiliated/takumokatekari) (Quit: WeeChat 2.8)
2020-10-06 18:31:12 +0200xff0x(~fox@2001:1a81:5339:8000:d49f:ac74:3895:c1cd) (Ping timeout: 260 seconds)
2020-10-06 18:31:15 +0200solonarv(~solonarv@adijon-655-1-70-207.w90-13.abo.wanadoo.fr)
2020-10-06 18:31:32 +0200 <maerwald> https://github.com/audreyt/string-qq/issues/2
2020-10-06 18:31:47 +0200Takumo(takumo@unaffiliated/takumokatekari)
2020-10-06 18:31:56 +0200 <maerwald> ah, it was the old bytestring issue
2020-10-06 18:31:56 +0200sedeki(~textual@unaffiliated/sedeki)
2020-10-06 18:32:00 +0200xff0x(~fox@port-92-193-207-209.dynamic.as20676.net)
2020-10-06 18:32:46 +0200 <maralorn> I have made good experiences with https://hackage.haskell.org/package/interpolate-0.2.1/docs/Data-String-Interpolate.html#v:i
2020-10-06 18:33:10 +0200mirrorbird(~psutcliff@2a00:801:2d5:9d73:ff00:6553:d451:a276)
2020-10-06 18:33:20 +0200 <maralorn> No, wait. That's not the one I meant.
2020-10-06 18:33:36 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com)
2020-10-06 18:33:37 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com) (Changing host)
2020-10-06 18:33:37 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 18:33:38 +0200 <maralorn> This one. https://hackage.haskell.org/package/string-interpolate-0.3.0.2/docs/Data-String-Interpolate.html#v:i
2020-10-06 18:33:43 +0200 <maerwald> maralorn: https://github.com/sol/interpolate/issues/14
2020-10-06 18:33:45 +0200 <maerwald> haha
2020-10-06 18:33:48 +0200 <maerwald> I'm right
2020-10-06 18:33:56 +0200geekosaur(42d52102@66.213.33.2)
2020-10-06 18:34:27 +0200 <maerwald> https://gitlab.com/williamyaoh/string-interpolate/-/tree/master#unicode-handling
2020-10-06 18:34:32 +0200 <maralorn> Gonna test that. now.
2020-10-06 18:34:57 +0200 <AWizzArd> maralorn: besides what maerwald said this looks even nicer.
2020-10-06 18:36:09 +0200 <maerwald> nice table https://gitlab.com/williamyaoh/string-interpolate/-/tree/master#features
2020-10-06 18:37:27 +0200ArsenArsen(~Arsen@kshare/developer/ArsenArsen) (Ping timeout: 240 seconds)
2020-10-06 18:37:33 +0200aurieeeh(~aurieh@static.91.102.243.136.clients.your-server.de) (Ping timeout: 256 seconds)
2020-10-06 18:37:38 +0200bahamas(~lucian@unaffiliated/bahamas)
2020-10-06 18:38:14 +0200auri_(~auri_@fsf/memeber/auri-) (Ping timeout: 272 seconds)
2020-10-06 18:39:16 +0200 <maralorn> I remember using string-interpolate in a library of mine and promptly got a PR patching all uses out …
2020-10-06 18:39:22 +0200mirrorbird(~psutcliff@2a00:801:2d5:9d73:ff00:6553:d451:a276) (Ping timeout: 260 seconds)
2020-10-06 18:39:28 +0200 <maralorn> Okay, admittedly it was only one use. So it was kinda useless.
2020-10-06 18:39:46 +0200 <maerwald> also note that quasiquoters break/confuse hasktags
2020-10-06 18:39:58 +0200 <maralorn> What's that?
2020-10-06 18:39:58 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 260 seconds)
2020-10-06 18:40:07 +0200LKoen(~LKoen@81.255.219.130)
2020-10-06 18:40:15 +0200 <maerwald> @hackage hasktags
2020-10-06 18:40:16 +0200 <lambdabot> https://hackage.haskell.org/package/hasktags
2020-10-06 18:40:29 +0200aurieeeh(~aurieh@static.91.102.243.136.clients.your-server.de)
2020-10-06 18:40:32 +0200shatriff(~vitaliish@88.155.146.251)
2020-10-06 18:40:36 +0200ArsenArsen(~Arsen@kshare/developer/ArsenArsen)
2020-10-06 18:41:01 +0200auri_(~auri_@fsf/memeber/auri-)
2020-10-06 18:42:18 +0200emmanuel_erc(~user@2604:2000:1382:ce03:88f9:ad61:775c:c25) (Remote host closed the connection)
2020-10-06 18:42:28 +0200emmanuel_erc(~user@2604:2000:1382:ce03:25fa:9e0d:1140:beff)
2020-10-06 18:43:07 +0200bahamas(~lucian@unaffiliated/bahamas) (Ping timeout: 240 seconds)
2020-10-06 18:43:09 +0200raichoo(~raichoo@dslb-088-077-027-113.088.077.pools.vodafone-ip.de) (Quit: Lost terminal)
2020-10-06 18:43:26 +0200 <maralorn> Ah, don‘t use that.
2020-10-06 18:43:34 +0200 <maralorn> I don‘t use that.^^
2020-10-06 18:43:43 +0200 <maralorn> This was not a recommendation.
2020-10-06 18:44:31 +0200howdoi(uid224@gateway/web/irccloud.com/x-bptppyjybdukwtgy)
2020-10-06 18:45:05 +0200 <maerwald> it's the only thing that lets you jump to library definitions
2020-10-06 18:45:14 +0200 <maerwald> (via codex)
2020-10-06 18:46:30 +0200sedeki(~textual@unaffiliated/sedeki) (Quit: Textual IRC Client: www.textualapp.com)
2020-10-06 18:46:43 +0200 <geekosaur> but any kind of quoter or macro processor will generally make tags utilities unhappy unless they do full parses. which ghci does, but then has a lame tags generator
2020-10-06 18:47:47 +0200juuandyy(~juuandyy@90.166.144.65)
2020-10-06 18:48:12 +0200 <maerwald> GHC parses isn't exposed I hear
2020-10-06 18:50:08 +0200 <geekosaur> no, but haskell-src-exts is. and there are plugins. but tags utilities have to combine normal parsing with regex since it generates regexes for a tags-consuming program to use, so it all gets fairly tricky
2020-10-06 18:50:18 +0200st8less(~st8less@2603:a060:11fd:0:443c:d730:5d8c:f920)
2020-10-06 18:52:44 +0200 <geekosaur> of course, if you follow this all too far, you land in the mess of semantic editors
2020-10-06 18:54:55 +0200oisdk(~oisdk@2001:bb6:3329:d100:c982:e387:7052:58be) (Ping timeout: 240 seconds)
2020-10-06 18:56:00 +0200nineonine(~nineonine@216-19-190-182.dyn.novuscom.net) (Remote host closed the connection)
2020-10-06 18:56:22 +0200oisdk(~oisdk@2001:bb6:3329:d100:c982:e387:7052:58be)
2020-10-06 18:57:21 +0200Guest_67(904061ed@bl23-97-237.dsl.telepac.pt)
2020-10-06 18:57:39 +0200 <maralorn> hls will soon have jum to library definitions.
2020-10-06 18:57:47 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2020-10-06 18:58:16 +0200Guest_67(904061ed@bl23-97-237.dsl.telepac.pt) (Remote host closed the connection)
2020-10-06 18:58:23 +0200nckx(~nckx@tobias.gr) (Quit: Updating my Guix System — https://guix.gnu.org)
2020-10-06 18:59:12 +0200 <sm[m]> that's going to be great!
2020-10-06 19:00:09 +0200Guest_62(904061ed@bl23-97-237.dsl.telepac.pt)
2020-10-06 19:00:33 +0200conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-10-06 19:00:35 +0200wroathe(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net)
2020-10-06 19:01:13 +0200 <Guest_62> I'm having problems installing haskell
2020-10-06 19:01:50 +0200 <Guest_62> i have a mac
2020-10-06 19:01:55 +0200 <davean> Guest_62: did you install it via ghcup? Or did you do pieces on your own?
2020-10-06 19:02:11 +0200albert_99(~Albert@p200300e5ff0b5b39340e476afbaec452.dip0.t-ipconnect.de)
2020-10-06 19:02:14 +0200 <Guest_62> via ghcup
2020-10-06 19:02:19 +0200 <davean> What went wrong?
2020-10-06 19:02:26 +0200 <maerwald> PATH
2020-10-06 19:02:26 +0200knupfer(~Thunderbi@dynamic-046-114-150-131.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2020-10-06 19:02:29 +0200 <maerwald> :)
2020-10-06 19:02:54 +0200 <sm[m]> docs! :)
2020-10-06 19:03:10 +0200 <maerwald> sm[m]: there's enough info, but ppl don't read it
2020-10-06 19:03:41 +0200 <davean> I do not understand why people don't read directions
2020-10-06 19:03:41 +0200nineonine(~nineonine@216.81.48.202)
2020-10-06 19:03:48 +0200nineonine(~nineonine@216.81.48.202) (Remote host closed the connection)
2020-10-06 19:03:53 +0200 <sm[m]> it's still a docs fail somehow.. if they're necessary, how do you ensure they are read...
2020-10-06 19:03:57 +0200 <maerwald> could add a quizz at the end of the installation that tries to figure out if the user has read the instructions
2020-10-06 19:04:02 +0200nineonine(~nineonine@216.81.48.202)
2020-10-06 19:04:06 +0200 <sm[m]> indeed
2020-10-06 19:04:17 +0200 <sm[m]> or have the script print the required docs to the console ?
2020-10-06 19:04:20 +0200Guest_62(904061ed@bl23-97-237.dsl.telepac.pt) (Remote host closed the connection)
2020-10-06 19:04:27 +0200 <maerwald> oh, they left
2020-10-06 19:04:37 +0200 <sm[m]> very wise :)
2020-10-06 19:04:56 +0200 <sm[m]> maerwald: could the script do whatever docs are telling users to do ?
2020-10-06 19:05:05 +0200 <davean> thats not reasonable
2020-10-06 19:05:16 +0200 <maerwald> and it's platform dependent
2020-10-06 19:05:17 +0200 <davean> Nor desirable
2020-10-06 19:05:18 +0200 <sm[m]> sometimes, but it's valid question to ask
2020-10-06 19:05:21 +0200alp(~alp@2a01:e0a:58b:4920:3117:a7c5:eaf1:360f) (Ping timeout: 272 seconds)
2020-10-06 19:05:30 +0200 <sm[m]> I don't say it's easy or always desirable
2020-10-06 19:05:33 +0200 <maerwald> many mac users here ask how to *open a file*
2020-10-06 19:06:05 +0200 <sm[m]> PATH in particular trips up almost every new user and is something that really should be more automatable
2020-10-06 19:06:14 +0200 <ghoulguy> maerwald: When I start ghcup tui, all the outdated GHC versions tend to dominate the screen. This will only get worse over time. Do you think we could come up witha better order that features the more useful list entries with the outdated stuff below?
2020-10-06 19:06:19 +0200motherfs1motherfsck
2020-10-06 19:06:42 +0200 <sm[m]> (I'm not pointing the finger at ghcup here, I have the same problem in my docs)
2020-10-06 19:06:52 +0200 <maerwald> ghoulguy: https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/69
2020-10-06 19:07:32 +0200 <sm[m]> stack's install script and stack itself print a clear(ish) warning about PATH on the console, that's something at least
2020-10-06 19:08:14 +0200conal(~conal@64.71.133.70)
2020-10-06 19:08:32 +0200 <maralorn> simonmic: I despise scripts as replacement for documentation. They keep me stupid.
2020-10-06 19:09:07 +0200 <maerwald> and unix is so messy, there's no real API to add something to PATH
2020-10-06 19:09:19 +0200 <davean> Yah, and it varies by shell and other factors
2020-10-06 19:09:19 +0200 <ghoulguy> maerwald: Thanks. I left some notes.
2020-10-06 19:09:24 +0200 <davean> PATH is a really complicated variable.
2020-10-06 19:09:32 +0200 <sm[m]> maralorn: if you stick to that view, we'd never get anywhere
2020-10-06 19:09:45 +0200 <sm[m]> some abstraction is needed
2020-10-06 19:10:03 +0200 <maralorn> simonmic: Well I think it depends on the situation. ;-)
2020-10-06 19:10:05 +0200 <sm[m]> I for one am heartily sick of explaining PATH issues
2020-10-06 19:10:07 +0200 <maerwald> davean: it's reassuring that the entirety of nix is based on that variable :p
2020-10-06 19:10:24 +0200 <koala_man> my favorite PATH fun fact is that you can put a literal tilde in it, and only bash will treat it as your home dir
2020-10-06 19:10:29 +0200 <davean> maerwald: thats hardly true
2020-10-06 19:10:44 +0200 <maralorn> maerwald: sudo cp .bin/* /usr/bin?
2020-10-06 19:10:57 +0200 <maerwald> sudo: command not found
2020-10-06 19:11:03 +0200 <maralorn> Very clean api
2020-10-06 19:11:06 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311) ()
2020-10-06 19:11:25 +0200 <maerwald> I despise scripts that assume I have sudo... and I despise scripts that just run it
2020-10-06 19:12:58 +0200bahamas(~lucian@unaffiliated/bahamas)
2020-10-06 19:12:58 +0200nckx(~nckx@tobias.gr)
2020-10-06 19:13:58 +0200knupfer(~Thunderbi@dynamic-046-114-150-131.46.114.pool.telefonica.de)
2020-10-06 19:15:48 +0200 <dsal> Running it from inside a command is quite wrong.
2020-10-06 19:16:04 +0200raehik(~raehik@cpc96984-rdng25-2-0-cust109.15-3.cable.virginm.net) (Quit: WeeChat 2.8)
2020-10-06 19:16:27 +0200 <yushyin> to make things more interesting, I use zsh's option to treat PATH as a Set. `typeset -U path; path+=(~/.local/bin)' :)
2020-10-06 19:17:27 +0200bahamas(~lucian@unaffiliated/bahamas) (Ping timeout: 240 seconds)
2020-10-06 19:18:14 +0200dolio(~dolio@haskell/developer/dolio) (Read error: Connection reset by peer)
2020-10-06 19:18:34 +0200 <sm[m]> this is not helping! :)
2020-10-06 19:19:08 +0200oisdk(~oisdk@2001:bb6:3329:d100:c982:e387:7052:58be) (Quit: oisdk)
2020-10-06 19:19:43 +0200Guest18(567e8866@gateway/web/cgi-irc/kiwiirc.com/ip.86.126.136.102) (Quit: Connection closed)
2020-10-06 19:20:28 +0200mirrorbird(~psutcliff@2a00:801:2d5:9d73:ff00:6553:d451:a276)
2020-10-06 19:20:39 +0200dolio(~dolio@haskell/developer/dolio)
2020-10-06 19:20:41 +0200johnw(~johnw@haskell/developer/johnw)
2020-10-06 19:21:09 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 19:21:19 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-10-06 19:23:16 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-06 19:23:16 +0200jneira[m](~jneira@227.red-176-87-45.dynamicip.rima-tde.net) (Read error: Connection reset by peer)
2020-10-06 19:23:34 +0200jneira[m](~jneira@80.30.101.206)
2020-10-06 19:24:05 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de)
2020-10-06 19:25:53 +0200nyd(~nyd@unaffiliated/elysian) (Quit: nyd)
2020-10-06 19:27:38 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 272 seconds)
2020-10-06 19:28:00 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 260 seconds)
2020-10-06 19:29:24 +0200oisdk(~oisdk@2001:bb6:3329:d100:c982:e387:7052:58be)
2020-10-06 19:29:57 +0200Sgeo_(~Sgeo@ool-18b982ad.dyn.optonline.net)
2020-10-06 19:32:12 +0200Sgeo(~Sgeo@ool-18b982ad.dyn.optonline.net) (Ping timeout: 260 seconds)
2020-10-06 19:33:25 +0200albert_99(~Albert@p200300e5ff0b5b39340e476afbaec452.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-06 19:34:05 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com)
2020-10-06 19:34:05 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com) (Changing host)
2020-10-06 19:34:05 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 19:36:17 +0200conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-10-06 19:36:22 +0200Gurkenglas(~Gurkengla@unaffiliated/gurkenglas)
2020-10-06 19:37:08 +0200phaul(~phaul@ruby/staff/phaul) (Ping timeout: 260 seconds)
2020-10-06 19:38:17 +0200chaosmasttter(~chaosmast@p200300c4a73b2e01d0131264df465fff.dip0.t-ipconnect.de) (Ping timeout: 272 seconds)
2020-10-06 19:38:19 +0200avdb(~avdb@ip-213-49-61-90.dsl.scarlet.be) (Quit: WeeChat 2.9)
2020-10-06 19:39:01 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-06 19:39:13 +0200codygman_work(~user@47-184-107-46.dlls.tx.frontiernet.net) (Ping timeout: 264 seconds)
2020-10-06 19:39:26 +0200codygman`(~user@209.251.131.98)
2020-10-06 19:40:14 +0200phaul(~phaul@ruby/staff/phaul)
2020-10-06 19:40:38 +0200conal(~conal@64.71.133.70)
2020-10-06 19:41:23 +0200 <maerwald> I think the solution is to refine the automatic shell detection logic and do the right thing when ppl just hit the ANY key in anger
2020-10-06 19:42:15 +0200 <geekosaur> then there's getting the running shell to acknowledge it somehow
2020-10-06 19:42:34 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 256 seconds)
2020-10-06 19:42:49 +0200 <geekosaur> and no, kill -9 $PPID won't cut it :)
2020-10-06 19:43:35 +0200shatriff(~vitaliish@88.155.146.251) (Remote host closed the connection)
2020-10-06 19:44:10 +0200 <maerwald> geekosaur: that reminds me of my coc.nvim bug report for being able to shut down the LSP server. I was told to use kill :)
2020-10-06 19:44:14 +0200Lycurgus(~niemand@98.4.96.130)
2020-10-06 19:45:07 +0200phaul(~phaul@ruby/staff/phaul) (Ping timeout: 240 seconds)
2020-10-06 19:45:26 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311)
2020-10-06 19:46:57 +0200 <dsal> GHC used to have that feature where it deleted bad code...
2020-10-06 19:47:49 +0200phaul(~phaul@ruby/staff/phaul)
2020-10-06 19:48:26 +0200polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889) (Ping timeout: 244 seconds)
2020-10-06 19:49:37 +0200polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889)
2020-10-06 19:53:01 +0200dyeplexer(~lol@unaffiliated/terpin) (Remote host closed the connection)
2020-10-06 19:53:52 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com)
2020-10-06 19:53:52 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com) (Changing host)
2020-10-06 19:53:52 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 19:55:12 +0200knupfer(~Thunderbi@dynamic-046-114-150-131.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2020-10-06 19:55:54 +0200geekosaur(42d52102@66.213.33.2) (Ping timeout: 245 seconds)
2020-10-06 19:57:00 +0200 <maerwald> and then it deledted itself? :)
2020-10-06 19:57:14 +0200 <monochrom> Haha leave no evidence :)
2020-10-06 19:57:30 +0200 <dolio> No, GHC passed its own type checker at that point, probably.
2020-10-06 19:59:51 +0200avdb(~avdb@ip-213-49-61-90.dsl.scarlet.be)
2020-10-06 20:00:02 +0200Salt1(~Salt@s91904426.blix.com) ()
2020-10-06 20:00:58 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 246 seconds)
2020-10-06 20:01:09 +0200Sgeo_(~Sgeo@ool-18b982ad.dyn.optonline.net) (Read error: Connection reset by peer)
2020-10-06 20:06:53 +0200Sgeo(~Sgeo@ool-18b982ad.dyn.optonline.net)
2020-10-06 20:08:14 +0200Aquazi(uid312403@gateway/web/irccloud.com/x-bssvxoobsmajjsoa)
2020-10-06 20:08:32 +0200albert_99(~Albert@p200300e5ff0b5b39340e476afbaec452.dip0.t-ipconnect.de)
2020-10-06 20:09:21 +0200avdb(~avdb@ip-213-49-61-90.dsl.scarlet.be) (Quit: WeeChat 2.9)
2020-10-06 20:11:12 +0200bahamas(~lucian@188.24.181.166)
2020-10-06 20:11:12 +0200bahamas(~lucian@188.24.181.166) (Changing host)
2020-10-06 20:11:12 +0200bahamas(~lucian@unaffiliated/bahamas)
2020-10-06 20:12:16 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Quit: Quit.)
2020-10-06 20:14:40 +0200chaosmasttter(~chaosmast@p200300c4a73b2e01d0131264df465fff.dip0.t-ipconnect.de)
2020-10-06 20:15:38 +0200pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net) (Quit: gone to sleep. ZZZzzz…)
2020-10-06 20:16:13 +0200bahamas(~lucian@unaffiliated/bahamas) (Ping timeout: 260 seconds)
2020-10-06 20:17:42 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311) ()
2020-10-06 20:18:55 +0200albert_99(~Albert@p200300e5ff0b5b39340e476afbaec452.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-06 20:20:33 +0200albert_99(~Albert@p200300e5ff0b5b39340e476afbaec452.dip0.t-ipconnect.de)
2020-10-06 20:20:44 +0200wroathe(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2020-10-06 20:21:36 +0200conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-10-06 20:22:44 +0200bitmagie(~Thunderbi@200116b80618560030363e2b73a65650.dip.versatel-1u1.de)
2020-10-06 20:24:58 +0200hackageordinal 0.2.0.0 - Convert numbers to words in different languages. https://hackage.haskell.org/package/ordinal-0.2.0.0 (wvanonsem90)
2020-10-06 20:25:05 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de) (Remote host closed the connection)
2020-10-06 20:25:34 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de)
2020-10-06 20:27:05 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-06 20:28:56 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com)
2020-10-06 20:28:56 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com) (Changing host)
2020-10-06 20:28:56 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 20:29:31 +0200brandly(~brandly@c-73-68-15-46.hsd1.ma.comcast.net)
2020-10-06 20:29:49 +0200oisdk(~oisdk@2001:bb6:3329:d100:c982:e387:7052:58be) (Quit: oisdk)
2020-10-06 20:30:07 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-06 20:30:20 +0200conal(~conal@64.71.133.70)
2020-10-06 20:31:39 +0200geekosaur(42d52102@66.213.33.2)
2020-10-06 20:33:08 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 258 seconds)
2020-10-06 20:34:59 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 240 seconds)
2020-10-06 20:35:22 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com)
2020-10-06 20:35:22 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com) (Changing host)
2020-10-06 20:35:22 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 20:36:52 +0200mirrorbird(~psutcliff@2a00:801:2d5:9d73:ff00:6553:d451:a276) (Quit: Leaving)
2020-10-06 20:37:13 +0200mirrorbird(~psutcliff@2a00:801:2d5:9d73:ff00:6553:d451:a276)
2020-10-06 20:37:33 +0200conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-10-06 20:40:42 +0200twanvl(~twanvl@77.165.89.227)
2020-10-06 20:41:28 +0200hackagecommander-cli 0.10.0.0 - A command line argument/option parser library https://hackage.haskell.org/package/commander-cli-0.10.0.0 (sgschlesinger)
2020-10-06 20:41:44 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 260 seconds)
2020-10-06 20:42:12 +0200bitmagie(~Thunderbi@200116b80618560030363e2b73a65650.dip.versatel-1u1.de) (Quit: bitmagie)
2020-10-06 20:43:09 +0200shatriff(~vitaliish@217.27.153.240)
2020-10-06 20:43:10 +0200shatriff(~vitaliish@217.27.153.240) (Remote host closed the connection)
2020-10-06 20:44:22 +0200aenesidemus(~aenesidem@c-73-53-247-25.hsd1.fl.comcast.net) (Read error: Connection reset by peer)
2020-10-06 20:45:48 +0200conal(~conal@64.71.133.70)
2020-10-06 20:46:05 +0200ryansmccoy(~ryansmcco@156.96.151.132) (Ping timeout: 240 seconds)
2020-10-06 20:46:29 +0200hiroaki(~hiroaki@ip4d176049.dynamic.kabel-deutschland.de)
2020-10-06 20:46:32 +0200ryansmccoy(~ryansmcco@193.37.254.27)
2020-10-06 20:50:02 +0200bahamas(~lucian@unaffiliated/bahamas)
2020-10-06 20:51:25 +0200lechner(~lechner@letbox-vps.us-core.com) (Remote host closed the connection)
2020-10-06 20:53:11 +0200Zetagon(~leo@c151-177-52-233.bredband.comhem.se)
2020-10-06 20:54:27 +0200bahamas(~lucian@unaffiliated/bahamas) (Ping timeout: 240 seconds)
2020-10-06 20:55:59 +0200bgamari(~bgamari@2001:470:e438::1) (Quit: ZNC 1.7.5 - https://znc.in)
2020-10-06 20:56:46 +0200codygman`(~user@209.251.131.98) (Read error: Connection reset by peer)
2020-10-06 20:58:20 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de)
2020-10-06 20:59:49 +0200conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-10-06 21:00:04 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com)
2020-10-06 21:00:04 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com) (Changing host)
2020-10-06 21:00:04 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 21:00:34 +0200bgamari(~bgamari@2001:470:e438::1)
2020-10-06 21:02:25 +0200LarryTheCow(~user@cpe-104-34-71-94.socal.res.rr.com)
2020-10-06 21:02:58 +0200hackagecommander-cli 0.10.0.1 - A command line argument/option parser library https://hackage.haskell.org/package/commander-cli-0.10.0.1 (sgschlesinger)
2020-10-06 21:04:39 +0200nineonin_(~nineonine@216.81.48.202)
2020-10-06 21:04:39 +0200nineonine(~nineonine@216.81.48.202) (Read error: Connection reset by peer)
2020-10-06 21:05:25 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-06 21:06:22 +0200juuandyy(~juuandyy@90.166.144.65) (Ping timeout: 256 seconds)
2020-10-06 21:06:29 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 258 seconds)
2020-10-06 21:08:43 +0200roconnor(~roconnor@host-45-78-194-116.dyn.295.ca) (Ping timeout: 260 seconds)
2020-10-06 21:10:35 +0200bahamas(~lucian@unaffiliated/bahamas)
2020-10-06 21:11:26 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-06 21:15:12 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-10-06 21:15:23 +0200alp(~alp@2a01:e0a:58b:4920:d98b:8dcd:26ff:1d63)
2020-10-06 21:15:45 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 240 seconds)
2020-10-06 21:16:13 +0200conal(~conal@64.71.133.70)
2020-10-06 21:17:46 +0200jneira(501e65ce@gateway/web/cgi-irc/kiwiirc.com/ip.80.30.101.206) (Ping timeout: 256 seconds)
2020-10-06 21:18:27 +0200conal_(~conal@64.71.133.70)
2020-10-06 21:19:52 +0200knupfer(~Thunderbi@i59F7FFCF.versanet.de)
2020-10-06 21:20:58 +0200conal(~conal@64.71.133.70) (Ping timeout: 260 seconds)
2020-10-06 21:21:06 +0200Lycurgus(~niemand@98.4.96.130) (Ping timeout: 256 seconds)
2020-10-06 21:21:39 +0200Zetagon(~leo@c151-177-52-233.bredband.comhem.se) (Remote host closed the connection)
2020-10-06 21:22:19 +0200jneira(501e65ce@gateway/web/cgi-irc/kiwiirc.com/ip.80.30.101.206)
2020-10-06 21:22:55 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Ping timeout: 240 seconds)
2020-10-06 21:23:13 +0200cyphase(~cyphase@unaffiliated/cyphase) (Ping timeout: 246 seconds)
2020-10-06 21:24:03 +0200shafox(~shafox@106.51.234.111) (Remote host closed the connection)
2020-10-06 21:24:17 +0200GyroW_(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be)
2020-10-06 21:24:17 +0200GyroW_(~GyroW@ptr-48ujrfd1ztq5fjywfw3.18120a2.ip6.access.telenet.be) (Changing host)
2020-10-06 21:24:17 +0200GyroW_(~GyroW@unaffiliated/gyrow)
2020-10-06 21:24:44 +0200 <tomsmeding> "deleted bad code" as in, if code doesn't typecheck, let's just not run it?
2020-10-06 21:24:49 +0200pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net)
2020-10-06 21:24:53 +0200knupfer(~Thunderbi@i59F7FFCF.versanet.de) (Quit: knupfer)
2020-10-06 21:24:58 +0200knupfer1(~Thunderbi@200116b8242f3f0081952173b951cca6.dip.versatel-1u1.de)
2020-10-06 21:25:03 +0200 <tomsmeding> that's eerily reminiscent of the behaviour of C compilers in the presence of undefined behaviour
2020-10-06 21:25:27 +0200 <ski> tomsmeding : no, deleted the source file
2020-10-06 21:25:40 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-10-06 21:25:52 +0200 <tomsmeding> oh, that's far better
2020-10-06 21:25:58 +0200 <monochrom> :)
2020-10-06 21:25:59 +0200Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net) (Read error: No route to host)
2020-10-06 21:25:59 +0200 <tomsmeding> good bug
2020-10-06 21:25:59 +0200Kaeipi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net)
2020-10-06 21:26:04 +0200GyroW(~GyroW@unaffiliated/gyrow) (Ping timeout: 272 seconds)
2020-10-06 21:26:06 +0200knupfer1(~Thunderbi@200116b8242f3f0081952173b951cca6.dip.versatel-1u1.de) (Read error: Connection reset by peer)
2020-10-06 21:26:16 +0200knupfer(~Thunderbi@200116b8242f3f00494fb3442f584eae.dip.versatel-1u1.de)
2020-10-06 21:26:19 +0200knupfer(~Thunderbi@200116b8242f3f00494fb3442f584eae.dip.versatel-1u1.de) (Client Quit)
2020-10-06 21:26:27 +0200knupfer(~Thunderbi@200116b8242f3f0085a7569c4e781f9d.dip.versatel-1u1.de)
2020-10-06 21:26:32 +0200conal(~conal@209.58.130.230)
2020-10-06 21:27:04 +0200nigel_c(~nigel_c@195.140.213.38)
2020-10-06 21:27:23 +0200conal_(~conal@64.71.133.70) (Ping timeout: 260 seconds)
2020-10-06 21:28:05 +0200jneira(501e65ce@gateway/web/cgi-irc/kiwiirc.com/ip.80.30.101.206) (Ping timeout: 240 seconds)
2020-10-06 21:28:49 +0200shaman_king(b94186aa@185.65.134.170)
2020-10-06 21:28:50 +0200 <shaman_king> hi
2020-10-06 21:28:54 +0200 <shaman_king> i think haskell is shit.
2020-10-06 21:28:58 +0200ChanServ+o monochrom
2020-10-06 21:29:05 +0200monochrom+b *!*@185.65.134.170
2020-10-06 21:29:05 +0200shaman_kingmonochromshaman_king
2020-10-06 21:29:36 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Read error: Connection reset by peer)
2020-10-06 21:31:25 +0200p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515)
2020-10-06 21:31:30 +0200monochrom-bbbb *!*@gateway/web/cgi-irc/kiwiirc.com/ip.82.1.242.183 *!*@50-36-180-21.alma.mi.frontiernet.net *!*@gateway/web/cgi-irc/kiwiirc.com/ip.91.217.246.19 *!*@192.95.191.129
2020-10-06 21:32:40 +0200monochrom-bo *!*@gateway/web/cgi-irc/kiwiirc.com/ip.147.135.116.81 monochrom
2020-10-06 21:33:07 +0200murphy_(~murphy_@2604:2000:1281:8a9e:5be4:8f01:b36d:6549) (Ping timeout: 240 seconds)
2020-10-06 21:33:29 +0200murphy_(~murphy_@2604:2000:1281:8a9e:46d4:9a6b:fb19:e552)
2020-10-06 21:34:23 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com)
2020-10-06 21:34:24 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com) (Changing host)
2020-10-06 21:34:24 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 21:35:39 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-06 21:35:39 +0200shatriff(~vitaliish@217.27.153.240)
2020-10-06 21:37:13 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de)
2020-10-06 21:39:05 +0200jneira(501e65ce@gateway/web/cgi-irc/kiwiirc.com/ip.80.30.101.206)
2020-10-06 21:40:06 +0200hololeap(~hololeap@unaffiliated/hololeap) (Quit: KVIrc 5.0.1 Aria http://www.kvirc.net/)
2020-10-06 21:40:20 +0200cyphase(~cyphase@unaffiliated/cyphase)
2020-10-06 21:40:25 +0200hololeap(~hololeap@unaffiliated/hololeap)
2020-10-06 21:40:26 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 256 seconds)
2020-10-06 21:41:55 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-10-06 21:43:07 +0200alp(~alp@2a01:e0a:58b:4920:d98b:8dcd:26ff:1d63) (Ping timeout: 260 seconds)
2020-10-06 21:43:43 +0200Kaeipi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net) (Ping timeout: 260 seconds)
2020-10-06 21:44:27 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-10-06 21:46:03 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 260 seconds)
2020-10-06 21:47:05 +0200oisdk(~oisdk@2001:bb6:3329:d100:c982:e387:7052:58be)
2020-10-06 21:49:02 +0200Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net)
2020-10-06 21:52:17 +0200zebrag(~inkbottle@aaubervilliers-654-1-95-218.w86-212.abo.wanadoo.fr) (Quit: Konversation terminated!)
2020-10-06 21:52:35 +0200 <koz_> 0 to kick in less than 10 seconds, nice.
2020-10-06 21:52:54 +0200heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-10-06 21:53:14 +0200 <monochrom> I was still too slow. :)
2020-10-06 21:53:56 +0200 <dolio> Yeah, should hav IP banned when they were here yesterday. :)
2020-10-06 21:54:20 +0200 <geekosaur> they were on different IP
2020-10-06 21:54:21 +0200 <Uniaika> I say, k-line the whole /16
2020-10-06 21:54:27 +0200 <dolio> Oh were they?
2020-10-06 21:54:29 +0200 <geekosaur> and using webchat
2020-10-06 21:54:30 +0200 <geekosaur> yes
2020-10-06 21:55:13 +0200 <geekosaur> Uniaika, pity that wouldn't work, 3 different /16s too
2020-10-06 21:57:08 +0200zebrag(~inkbottle@aaubervilliers-654-1-95-218.w86-212.abo.wanadoo.fr)
2020-10-06 21:57:26 +0200kritzefitz(~kritzefit@212.86.56.80)
2020-10-06 21:58:21 +0200theorbtwo(~theorb@cpc81860-swin19-2-0-cust166.3-1.cable.virginm.net)
2020-10-06 21:58:39 +0200brandly(~brandly@c-73-68-15-46.hsd1.ma.comcast.net) (Remote host closed the connection)
2020-10-06 21:58:39 +0200 <Uniaika> ah damn
2020-10-06 21:58:44 +0200 <monochrom> In the past 10 days I can only find 185.65.134.*. But I only grepped for "shaman". Is there some other things I can look for?
2020-10-06 21:59:12 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net) (Ping timeout: 260 seconds)
2020-10-06 21:59:43 +0200 <monochrom> Well, I can do the known right away.
2020-10-06 21:59:45 +0200ChanServ+o monochrom
2020-10-06 21:59:54 +0200fmeyer(uid257539@gateway/web/irccloud.com/x-yvvsemtlqrvsuvhi) (Quit: Connection closed for inactivity)
2020-10-06 22:00:06 +0200 <geekosaur> I looked at the scrollback where monochrom took off the past two days. and I specifically recall him quieting (not banning) his address via webchat
2020-10-06 22:00:07 +0200monochrom-b+b *!*@185.65.134.170 *!*@185.65.134.*
2020-10-06 22:00:59 +0200 <geekosaur> and saw removal of (what I think are) those today before monochrom deopped
2020-10-06 22:01:20 +0200bahamas(~lucian@unaffiliated/bahamas) (Ping timeout: 256 seconds)
2020-10-06 22:03:10 +0200 <maerwald> and I wanted to know what he had to say...
2020-10-06 22:03:33 +0200 <geekosaur> all three by "shaman_king" and all basically the same drivel
2020-10-06 22:04:43 +0200 <monochrom> I haven't used quieting for a long time. And today I didn't touch the quiet list, I removed old bans, some several months old, some one week old.
2020-10-06 22:05:32 +0200 <monochrom> (The unbans were about 35 minutes ago.)
2020-10-06 22:06:40 +0200jneira(501e65ce@gateway/web/cgi-irc/kiwiirc.com/ip.80.30.101.206) (Ping timeout: 258 seconds)
2020-10-06 22:07:07 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com)
2020-10-06 22:07:07 +0200jle`(~mstksg@cpe-23-240-75-236.socal.res.rr.com) (Changing host)
2020-10-06 22:07:07 +0200jle`(~mstksg@unaffiliated/mstksg)
2020-10-06 22:08:02 +0200 <monochrom> The ban that I placed on Sep 30 and removed today was for "I'm so h0rny now. Wanna trade. ...", doesn't look like shaman_king.
2020-10-06 22:08:22 +0200 <geekosaur> ok, yesterday was a kick apparently (I'm looking at ircbrowse which is not good about how/where one joined/parted)
2020-10-06 22:09:09 +0200 <monochrom> Yesterday they quitted before I was fast enough to kickban. I didn't place a ban for that.
2020-10-06 22:09:24 +0200 <monochrom> My ban yesterday was for fog.
2020-10-06 22:09:40 +0200 <geekosaur> hm
2020-10-06 22:09:51 +0200 <sm[m]> seems excessive
2020-10-06 22:09:54 +0200 <geekosaur> I can't tell that from ircbrowse apparently
2020-10-06 22:10:19 +0200 <geekosaur> also I am just about out of time for today :/
2020-10-06 22:10:35 +0200geekosaur(42d52102@66.213.33.2) (Remote host closed the connection)
2020-10-06 22:13:44 +0200p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515) (Quit: p-core)
2020-10-06 22:13:44 +0200chele(~chele@ip5b416ea2.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2020-10-06 22:13:52 +0200 <dminuoso> How do quasiquoters break/confuse hasktags?
2020-10-06 22:14:07 +0200jle`(~mstksg@unaffiliated/mstksg) (Ping timeout: 240 seconds)
2020-10-06 22:14:14 +0200monochrom-o monochrom
2020-10-06 22:14:22 +0200jneira(501e65ce@gateway/web/cgi-irc/kiwiirc.com/ip.80.30.101.206)
2020-10-06 22:15:21 +0200DavidEichmann(~david@43.240.198.146.dyn.plus.net)
2020-10-06 22:16:13 +0200snakemas1(~snakemast@213.100.206.23)
2020-10-06 22:16:58 +0200 <maerwald> dminuoso: https://github.com/MarcWeber/hasktags/issues/78
2020-10-06 22:18:10 +0200 <dminuoso> Mmm curious that hasktags doesnt use haskell-src-exts
2020-10-06 22:18:18 +0200 <dminuoso> But I guess that's the answer.
2020-10-06 22:20:40 +0200kav(~kari@dsl-hkibng42-56733f-225.dhcp.inet.fi) (Ping timeout: 260 seconds)
2020-10-06 22:20:40 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-10-06 22:20:49 +0200snakemas1(~snakemast@213.100.206.23) (Ping timeout: 256 seconds)
2020-10-06 22:23:15 +0200conal(~conal@209.58.130.230) (Quit: Computer has gone to sleep.)
2020-10-06 22:24:20 +0200oxide(~lambda@unaffiliated/mclaren) (Ping timeout: 272 seconds)
2020-10-06 22:27:32 +0200caubert(~caubert@82.131.52.222.cable.starman.ee)
2020-10-06 22:29:27 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de)
2020-10-06 22:32:27 +0200hackagephonetic-languages-ukrainian 0.2.3.0 - Prepares Ukrainian text to be used as a phonetic language text https://hackage.haskell.org/package/phonetic-languages-ukrainian-0.2.3.0 (OleksandrZhabenko)
2020-10-06 22:32:30 +0200 <maerwald> sm[m]: cabal.project in hledger doesn't parse :>
2020-10-06 22:33:20 +0200mrbentarikau(~mrbentari@207.246.80.112)
2020-10-06 22:33:27 +0200hackageuniqueness-periods-vector-common 0.4.1.0 - Generalization of the dobutokO-poetry-general package functionality https://hackage.haskell.org/package/uniqueness-periods-vector-common-0.4.1.0 (OleksandrZhabenko)
2020-10-06 22:33:38 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-06 22:33:46 +0200thir(~thir@p200300f27f0fc60038c1b16891cbfa03.dip0.t-ipconnect.de) (Ping timeout: 244 seconds)
2020-10-06 22:33:46 +0200murphy_(~murphy_@2604:2000:1281:8a9e:46d4:9a6b:fb19:e552) (Ping timeout: 244 seconds)
2020-10-06 22:34:35 +0200murphy_(~murphy_@2604:2000:1281:8a9e:5b6c:ced:3586:ca8c)
2020-10-06 22:34:42 +0200 <sm[m]> maerwald: thanks.. how do I reproduce that ?
2020-10-06 22:35:16 +0200conal(~conal@209.58.130.230)
2020-10-06 22:35:17 +0200voyons_calice(~dan@162.246.216.28)
2020-10-06 22:35:32 +0200 <maerwald> cabal build?
2020-10-06 22:36:39 +0200 <sm[m]> ah cabal build all
2020-10-06 22:37:10 +0200 <sm[m]> I get cabal: The program 'ghc' version >=7.0.1 is required but it could not be found. But that's not what you mean I guess ?
2020-10-06 22:37:32 +0200 <sm[m]> cabal-install 3.2 here
2020-10-06 22:37:54 +0200 <maerwald> https://paste.tomsmeding.com/kJrW4XQR
2020-10-06 22:37:59 +0200 <maerwald> 3.4 prerelease
2020-10-06 22:38:14 +0200voyons_osti(~dan@107-190-41-58.cpe.teksavvy.com) (Ping timeout: 256 seconds)
2020-10-06 22:38:49 +0200borne(~fritjof@200116b864d97f00d30d76f456a7111b.dip.versatel-1u1.de)
2020-10-06 22:39:48 +0200 <sm[m]> it's complaining about the line 8 here I think ? https://paste.tomsmeding.com/Wgovb0sq
2020-10-06 22:41:54 +0200mrbentarikau(~mrbentari@207.246.80.112) (Quit: WeeChat 2.8)
2020-10-06 22:42:36 +0200mrbentarikau(~mrbentari@207.246.80.112)
2020-10-06 22:44:51 +0200caubert(~caubert@82.131.52.222.cable.starman.ee) (Remote host closed the connection)
2020-10-06 22:46:37 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Quit: Quit.)
2020-10-06 22:46:52 +0200alp(~alp@2a01:e0a:58b:4920:11c4:1b60:3a4e:bcb2)
2020-10-06 22:47:16 +0200kav(~kari@dsl-hkibng42-56733f-225.dhcp.inet.fi)
2020-10-06 22:47:37 +0200cosimone_(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-10-06 22:49:41 +0200cosimone_(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6) (Quit: cosimone_)
2020-10-06 22:50:43 +0200cosimone(~cosimone@2001:b07:ae5:db26:b248:7aff:feea:34b6)
2020-10-06 22:51:16 +0200ryansmccoy(~ryansmcco@193.37.254.27) (Ping timeout: 256 seconds)
2020-10-06 22:51:31 +0200ryansmccoy(~ryansmcco@193.37.254.27)
2020-10-06 22:55:03 +0200Tops22(~Tobias@dyndsl-095-033-093-242.ewe-ip-backbone.de) (Read error: Connection reset by peer)
2020-10-06 22:56:31 +0200oxide(~lambda@unaffiliated/mclaren)
2020-10-06 23:00:01 +0200justsomeguy(~justsomeg@unaffiliated/--/x-3805311)
2020-10-06 23:00:01 +0200nigel_c(~nigel_c@195.140.213.38) ()
2020-10-06 23:03:09 +0200leungbk(~user@2605:e000:1315:706:8785:470d:bc5b:c5f9)
2020-10-06 23:03:25 +0200shatriff(~vitaliish@217.27.153.240) (Remote host closed the connection)
2020-10-06 23:03:47 +0200 <leungbk> When is it correct to use 'in' with a 'let' expression?
2020-10-06 23:04:15 +0200obihann(~jhann@156.34.160.69) (Remote host closed the connection)
2020-10-06 23:04:45 +0200danvet_(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa) (Ping timeout: 272 seconds)
2020-10-06 23:04:57 +0200hackageuniqueness-periods-vector-general 0.4.5.0 - Some kind of the optimization approach to data inner structure. https://hackage.haskell.org/package/uniqueness-periods-vector-general-0.4.5.0 (OleksandrZhabenko)
2020-10-06 23:06:20 +0200 <koz_> leungbk: Everywhere except do-notation.
2020-10-06 23:06:37 +0200 <leungbk> Thanks.
2020-10-06 23:06:50 +0200 <koz_> Do you have a specific example that's throwing you?
2020-10-06 23:08:46 +0200 <leungbk> I was writing a simple graph algorithm just now, but after your remark I noticed I was one 'in' short.
2020-10-06 23:09:12 +0200 <koz_> Are you nesting lets or something?
2020-10-06 23:09:25 +0200knupfer(~Thunderbi@200116b8242f3f0085a7569c4e781f9d.dip.versatel-1u1.de) (Ping timeout: 244 seconds)
2020-10-06 23:10:03 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2020-10-06 23:11:41 +0200Lycurgus(~niemand@98.4.96.130)
2020-10-06 23:12:54 +0200 <leungbk> Yeah, I used 'let' to define an inner function and then used 'let' within that inner function. Maybe it would have been better to use 'where' somewhere.
2020-10-06 23:13:27 +0200 <koz_> Or just define a non-exported top-level function.
2020-10-06 23:13:42 +0200 <koz_> There's no need to jam everything into one big blob. We have modules with export lists for a reason.
2020-10-06 23:14:27 +0200hackageuniqueness-periods-vector-examples 0.9.1.0 - Usage examples for the uniqueness-periods-vector series of packages https://hackage.haskell.org/package/uniqueness-periods-vector-examples-0.9.1.0 (OleksandrZhabenko)
2020-10-06 23:15:00 +0200 <monochrom> I simply developed a habit of entering "let <newline> in ???" and then fill it in. (I don't want to go out of my way to configure my editor to automate this.)
2020-10-06 23:15:43 +0200cr3(~cr3@192-222-143-195.qc.cable.ebox.net) (Quit: leaving)
2020-10-06 23:16:14 +0200 <leungbk> I shied away from a separate top-level functio since I needed to read some local variables, and since the function I had defined was recursive.
2020-10-06 23:16:33 +0200 <leungbk> I prob need to rethink it though.
2020-10-06 23:16:36 +0200 <monochrom> Don't worry, you're doing fine. :)
2020-10-06 23:16:58 +0200fendor(~fendor@178.115.129.46.wireless.dyn.drei.com) (Remote host closed the connection)
2020-10-06 23:17:25 +0200shatriff(~vitaliish@217.27.153.240)
2020-10-06 23:17:30 +0200 <monochrom> I understand that when there is a choice, some people's way of thinking prefers let-in, some other's prefers where. Or generally define-before vs define-after.
2020-10-06 23:17:47 +0200 <monochrom> Very generally bottom-up vs top-down.
2020-10-06 23:18:07 +0200tito_04(~taurux@net-93-146-7-28.cust.vodafonedsl.it) (Ping timeout: 240 seconds)
2020-10-06 23:18:16 +0200 <monochrom> Me, I'm a quantum superposition of both.
2020-10-06 23:18:56 +0200kritzefitz(~kritzefit@212.86.56.80) (Remote host closed the connection)
2020-10-06 23:19:30 +0200taurux(~taurux@net-188-152-143-247.cust.dsl.teletu.it)
2020-10-06 23:20:28 +0200hackagetyped-encoding 0.5.1.0 - Type safe string transformations https://hackage.haskell.org/package/typed-encoding-0.5.1.0 (rpeszek)
2020-10-06 23:20:42 +0200 <pjb> You have to know all those processes, and mix and match them depending on your knowledge.
2020-10-06 23:20:49 +0200 <pjb> They are discovery processes.
2020-10-06 23:20:59 +0200 <pjb> If you know the algorithm you can just code it from a to z.
2020-10-06 23:21:26 +0200 <pjb> If you don't you need to design or explore, so writing code in all direction is possible.
2020-10-06 23:21:54 +0200yar1(~yar@185.163.110.116)
2020-10-06 23:22:38 +0200 <monochrom> For that reason, people used to advocate prototyping and then throwing away the prototype and restarting from scratch.
2020-10-06 23:23:24 +0200 <monochrom> I am really fond of that.
2020-10-06 23:24:00 +0200 <monochrom> But at some point of time, the next generation decided that they couldn't stand throwing away "hard-earned" code.
2020-10-06 23:24:57 +0200coot(~coot@37.30.49.218.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2020-10-06 23:25:04 +0200 <orzo> i'm having a frustration with cabal. The v2-configure command wants to download a version of a library that i already have installed that works perfectly well to build the project
2020-10-06 23:25:17 +0200 <orzo> I mean, it wants to download a newer version
2020-10-06 23:25:24 +0200 <orzo> but i want it to work with what's here
2020-10-06 23:25:31 +0200 <orzo> it seems like it should be working with what's here
2020-10-06 23:25:44 +0200 <orzo> because that's the path of least effort for it
2020-10-06 23:25:57 +0200 <monochrom> Ironically it was the new generation that could easily afford throwing away code wholesale, because they had much more decent VCS (compared to the older generation that believed in throwing away prototypes) such that "throwing away" means you never lost it, you could always refer to it again.
2020-10-06 23:26:30 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-10-06 23:27:15 +0200Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net) (Remote host closed the connection)
2020-10-06 23:27:22 +0200Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net)
2020-10-06 23:27:30 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2020-10-06 23:27:35 +0200 <monochrom> You have to use "cabal freeze" to prevent bringing in a newer version.
2020-10-06 23:27:41 +0200 <orzo> aha
2020-10-06 23:28:11 +0200 <orzo> i use v2-* commands
2020-10-06 23:28:17 +0200 <orzo> does that mean i should have a v2-freeze?
2020-10-06 23:28:33 +0200 <monochrom> And if you use it later, e.g. now, the generated "cabal.project.freeze" likely selects the newer version, so you have to edit it to select the older version.
2020-10-06 23:28:33 +0200 <orzo> cabal 3.2
2020-10-06 23:28:40 +0200Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net) (Remote host closed the connection)
2020-10-06 23:28:45 +0200 <monochrom> 3.2 means the default is v2.
2020-10-06 23:29:38 +0200Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net)
2020-10-06 23:30:07 +0200 <orzo> freeze doesn't work like i hoped
2020-10-06 23:30:15 +0200 <monochrom> There is probably also a way you first tell cabal "roll back your hackage index to this date in the past", and then your "cabal freeze" will be more meaningful in freezing the older version numbers you desire.
2020-10-06 23:30:23 +0200 <orzo> is there a way to just specify library versions directly?
2020-10-06 23:31:00 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 258 seconds)
2020-10-06 23:31:15 +0200 <orzo> i edited the cabal file to verify the installed library works
2020-10-06 23:31:18 +0200 <orzo> but i don't want to do that
2020-10-06 23:31:31 +0200 <monochrom> edit cabal.project.freeze ?
2020-10-06 23:31:52 +0200 <orzo> so i conigure, freeze, and then edit that to change the lib version?
2020-10-06 23:31:57 +0200 <sclv> new style encourages using the latest and rebuilding and freezing is the way to avoid that
2020-10-06 23:31:58 +0200abhixec(~abhixec@c-67-169-141-95.hsd1.ca.comcast.net)
2020-10-06 23:31:59 +0200 <monochrom> yeah
2020-10-06 23:32:30 +0200 <sclv> but going with the nonfrozen latest stuff is a nicer workflow for me tbqh
2020-10-06 23:32:51 +0200 <orzo> this is all working around a bug in cabal though, right? I mean shouldn't the default behavior be to do what I want?
2020-10-06 23:33:15 +0200 <dminuoso> Mmm, I wish we had per-module dependencies. That way I could depend on some of the more nasty packages without pulling in a huge hunk of transitive dependencies if I only need one module.
2020-10-06 23:33:21 +0200 <monochrom> https://xkcd.com/303/ applies
2020-10-06 23:33:34 +0200 <monochrom> No, this is considered a feature.
2020-10-06 23:34:34 +0200 <orzo> My rationale is "do as little as neccessary to get it to build." What is the rationale for the default behavior?
2020-10-06 23:34:42 +0200 <monochrom> I liked the v1 way, too. But I have accepted v2 and accepted that I would need to freeze, and I would need to do that early enough.
2020-10-06 23:35:14 +0200 <monochrom> "get as many latest bugfixes as possible"? I don't know.
2020-10-06 23:35:17 +0200leungbk(~user@2605:e000:1315:706:8785:470d:bc5b:c5f9) (Quit: ERC (IRC client for Emacs 28.0.50))
2020-10-06 23:35:49 +0200 <monochrom> Also, in v2, "configure" is highly redundant.
2020-10-06 23:36:36 +0200 <dminuoso> orzo: Btw, v2- without freezing style promotes using PVP bounds. So if your dependencies make large jumps, you're missing a bound.
2020-10-06 23:36:54 +0200 <dminuoso> If you have tight bounds, think of this as a feature, where you're getting bugfixes automatically
2020-10-06 23:36:56 +0200 <monochrom> Also, under v2 semantics, I would first let "build" have a go, so I see that it succeeds, before I use "freeze".
2020-10-06 23:36:56 +0200Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net) (Remote host closed the connection)
2020-10-06 23:37:03 +0200Kaeipi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net)
2020-10-06 23:37:50 +0200 <orzo> what's a pvp bound
2020-10-06 23:38:11 +0200 <monochrom> https://pvp.haskell.org/
2020-10-06 23:39:43 +0200 <dminuoso> orzo: If you pin versions using ^>=, then cabal will consider the specified version as the earliest compatible version, and allow any newer compatible version.
2020-10-06 23:39:53 +0200 <dminuoso> There's some tools to automatically generate these bounds
2020-10-06 23:40:03 +0200 <monochrom> "cabal genbounds" :)
2020-10-06 23:40:17 +0200 <monochrom> err gen-bounds
2020-10-06 23:40:38 +0200frdg(60e94035@pool-96-233-64-53.bstnma.fios.verizon.net) (Remote host closed the connection)
2020-10-06 23:42:33 +0200 <dminuoso> cabal has some lesser know features as well that complement the above notation, like the set notation for bounds
2020-10-06 23:42:52 +0200 <dminuoso> so you can specify `foo ^>= {1.1.1, 1.2, 1.4}
2020-10-06 23:42:59 +0200Rudd0(~Rudd0@185.189.115.108) (Ping timeout: 256 seconds)
2020-10-06 23:43:17 +0200 <dminuoso> I think cabal gen-bounds generates >/<= bounds?
2020-10-06 23:44:04 +0200 <monochrom> IIRC yes, but equiv to ^>=.
2020-10-06 23:44:32 +0200 <dminuoso> Sure, ^>= is just more explicit about it. :)
2020-10-06 23:44:50 +0200 <dminuoso> And with the set notation, it makes it more clear what versions you have tested it with
2020-10-06 23:45:09 +0200 <monochrom> Actually I have only tried using gen-bounds for a *.cabal file that explicitly says "cabal-version: >= 1.10" or something, so it tries to be friendly to old syntax?
2020-10-06 23:45:22 +0200jneira_(~jneira@170.red-176-87-39.dynamicip.rima-tde.net)
2020-10-06 23:45:57 +0200 <monochrom> I mean, if you have "cabal-version: 4.2" it may very well take advantage of the new concise syntax.
2020-10-06 23:46:11 +0200 <monochrom> Ha, let me try.
2020-10-06 23:47:32 +0200 <dminuoso> I have a baby sleeping in a carrier, Im not gonna hack around on my dev machine since it has a clicky keyboard. ;)
2020-10-06 23:47:42 +0200DataComputist(~lumeng@static-50-43-26-251.bvtn.or.frontiernet.net)
2020-10-06 23:47:53 +0200 <monochrom> Nah, it always outputs >= && < regardless of "cabal-version: 2.2"
2020-10-06 23:47:56 +0200jneira[m](~jneira@80.30.101.206) (Ping timeout: 260 seconds)
2020-10-06 23:48:11 +0200 <monochrom> You need a mind-reading interface!
2020-10-06 23:48:48 +0200 <dminuoso> Emacs has that.
2020-10-06 23:48:52 +0200 <dminuoso> M-x mind-mode
2020-10-06 23:49:31 +0200 <dminuoso> https://xkcd.com/378/
2020-10-06 23:49:31 +0200 <monochrom> Such as the one in the movie "Firefox" in which the USSR invented a fly-by-thinking jet fighter, and the US asked Clint Eastwood to steal it. "But you have to think in RUSSIAN!"
2020-10-06 23:50:11 +0200 <dminuoso> Haha, I once saw a trailer of that movie.
2020-10-06 23:50:11 +0200jneira_(~jneira@170.red-176-87-39.dynamicip.rima-tde.net) (Read error: Connection reset by peer)
2020-10-06 23:50:47 +0200 <dminuoso> It looked so awful
2020-10-06 23:50:52 +0200jneira_(~jneira@80.30.101.206)
2020-10-06 23:51:52 +0200 <monochrom> Firefox used to read your mind. Now it just really respects your privacy. >:)
2020-10-06 23:51:55 +0200st8less(~st8less@2603:a060:11fd:0:443c:d730:5d8c:f920) (Ping timeout: 240 seconds)
2020-10-06 23:52:18 +0200 <davean> but not your agency
2020-10-06 23:52:19 +0200 <dminuoso> http://calpaterson.com/mozilla.html
2020-10-06 23:52:35 +0200 <dminuoso> Firefox respects your privacy because it's not even on your machine.
2020-10-06 23:52:42 +0200 <monochrom> haha
2020-10-06 23:56:30 +0200 <orzo> what's the hot new browser steeling their share?
2020-10-06 23:56:37 +0200 <dminuoso> Chrome? :)
2020-10-06 23:56:58 +0200 <orzo> hm
2020-10-06 23:57:00 +0200 <dminuoso> Followed by Edge now.
2020-10-06 23:57:34 +0200 <dminuoso> Microsoft's new strategy of just *forcing* edge onto everybodies Windows machine repeatedly, and making it impossible to get rid of, seems to be paying off
2020-10-06 23:58:24 +0200 <monochrom> No, I think it is not that. Because Firefox users would not switch to Edge, whether Edge is based on Chrome or Microsoft's original rendering engine.
2020-10-06 23:59:35 +0200 <monochrom> Instead, it is not that the absolute number of Firefox users decreased, but that their percentage decreased, i.e., new users use Edge, Safari, or whatever it is on their new smartphones (definitely not Firefox).