IRCBrowse

2020/11/19

2020-11-19 00:00:02 +0100 <hekkaidekapus> Ah, ok.
2020-11-19 00:00:23 +0100 <ski> (for some reason, i've noticed that i, unnervingly often, write "i" when i mean "it")
2020-11-19 00:01:15 +0100 <hekkaidekapus> heh Those pesky keyboards :d
2020-11-19 00:02:12 +0100 <ski> (.. and some other annoying typos, like the "the the" class of typos (you pause after writing a word, to think, and then when you continue, you repeat the last word). also, sometimes, when thinking ahead about how to formulate myself, i write out a later planned word, in place of the current one that i intended)
2020-11-19 00:02:30 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-19 00:04:00 +0100 <ski> (and no, i don't think i'm simply failing to press the "t" key in the "it". it may be related to another class of typos, where i write another word, that, when pronounced, sounds more or less similar to the intended word)
2020-11-19 00:05:33 +0100 <ski> (.. some kind of mess-up, in the internal sentence-structure to keypress serialization)
2020-11-19 00:05:34 +0100 <hekkaidekapus> Maybe it’s the cerebral chemistry being quicker than the bio-mechanical anatomy. By the time a typo is spotted, some other body part has already initiated an irreversible action.
2020-11-19 00:05:39 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-19 00:06:39 +0100 <hpc> i wonder if they make joke keyboards that don't have a backspace or delete key
2020-11-19 00:07:11 +0100 <ski> it's interesting to read a transcript of what someone has spoken, including "er"s, half-formed sentences, changing midway through, &c.
2020-11-19 00:08:22 +0100 <ski> hm. perhaps they could brand those keyboards "Dijkstra"
2020-11-19 00:09:14 +0100 <justsomeguy> ski: I do a lot of that, too. My worst sin is writing in inconsistent tense (past, present, future), because I've rephrased my comment in the chat box five or six times before sending.
2020-11-19 00:09:22 +0100 <ski> (another example of an annoying typo is writing "now" in place of "not" (or vice versa))
2020-11-19 00:09:34 +0100random(~random@46.254.129.126) (Ping timeout: 246 seconds)
2020-11-19 00:10:10 +0100 <ski> yea, rephrasing (incompletely/inconsistently) is dangerous
2020-11-19 00:10:38 +0100abhixec(~abhixec@c-67-169-141-95.hsd1.ca.comcast.net) (Remote host closed the connection)
2020-11-19 00:11:02 +0100justsomeguyalso sometimes habitually replaces English words with similar sounding command names since he's more used to typing them, which is hilarious.
2020-11-19 00:11:21 +0100 <ski> hm, yea. i've noticed that too
2020-11-19 00:11:33 +0100 <ski> e.g. writing "type" in place of "typo"
2020-11-19 00:11:58 +0100 <ski> partly a muscle-memory thing, i'd guess
2020-11-19 00:11:58 +0100Tourist(~tourist@unaffiliated/tourist) (Ping timeout: 256 seconds)
2020-11-19 00:12:00 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-11-19 00:12:04 +0100Flonk(~Flonk@ec2-52-40-29-25.us-west-2.compute.amazonaws.com) (Ping timeout: 240 seconds)
2020-11-19 00:12:06 +0100digia(~digia@unaffiliated/digia) (Remote host closed the connection)
2020-11-19 00:12:08 +0100bsima(~bsima@simatime.com) (Quit: ZNC 1.7.5 - https://znc.in)
2020-11-19 00:12:09 +0100vicfred(~vicfred@unaffiliated/vicfred) (Quit: Leaving)
2020-11-19 00:12:19 +0100digia(~digia@unaffiliated/digia)
2020-11-19 00:12:31 +0100bsima(~bsima@simatime.com)
2020-11-19 00:12:36 +0100 <boxscape> any idea why `Fam alt MkR = alt` here doesn't produce an error? (using ghc 8.10) https://gist.github.com/JakobBruenker/a1b8c66abcb1c05e9bf4ff55e73fa6c8
2020-11-19 00:12:43 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 240 seconds)
2020-11-19 00:12:44 +0100bobbytables(~bobbytabl@ec2-44-224-191-138.us-west-2.compute.amazonaws.com) (Ping timeout: 240 seconds)
2020-11-19 00:12:53 +0100orcus-(~orcus@unaffiliated/orcus)
2020-11-19 00:13:03 +0100jb55(~jb55@gateway/tor-sasl/jb55) (Ping timeout: 240 seconds)
2020-11-19 00:13:07 +0100conal(~conal@64.71.133.70)
2020-11-19 00:13:08 +0100conal(~conal@64.71.133.70) (Client Quit)
2020-11-19 00:13:09 +0100 <ski> (or, writing an english (usually short) word in place of a similar-looking swedish one)
2020-11-19 00:13:16 +0100vicfred(~vicfred@unaffiliated/vicfred)
2020-11-19 00:13:18 +0100mastarija(~mastarija@93-136-63-196.adsl.net.t-com.hr)
2020-11-19 00:13:23 +0100Inoperable(~PLAYER_1@fancydata.science) (Ping timeout: 260 seconds)
2020-11-19 00:13:25 +0100cheers(user@unaffiliated/cheers) (Ping timeout: 240 seconds)
2020-11-19 00:13:25 +0100Madars(~null@unaffiliated/madars) (Ping timeout: 240 seconds)
2020-11-19 00:13:48 +0100rotty(rotty@ghost.xx.vu) (Ping timeout: 272 seconds)
2020-11-19 00:13:59 +0100conal(~conal@64.71.133.70)
2020-11-19 00:14:20 +0100vicfred(~vicfred@unaffiliated/vicfred) (Max SendQ exceeded)
2020-11-19 00:14:24 +0100siraben(sirabenmat@gateway/shell/matrix.org/x-ayxhmamsaxhvcaxs) (Ping timeout: 240 seconds)
2020-11-19 00:14:39 +0100 <ski> boxscape : hm, i'd guess it's interpreted as `Fam @a @b @b alt MkR = alt' ?
2020-11-19 00:14:50 +0100vicfred(~vicfred@unaffiliated/vicfred)
2020-11-19 00:14:56 +0100bobbytables(~bobbytabl@ec2-44-224-191-138.us-west-2.compute.amazonaws.com)
2020-11-19 00:14:57 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2020-11-19 00:15:04 +0100maralorn(maralornma@gateway/shell/matrix.org/x-dbfnqoxrhdjljtko) (Ping timeout: 240 seconds)
2020-11-19 00:15:13 +0100 <boxscape> oh, hm, I suppose that makes sense
2020-11-19 00:15:25 +0100 <ski> so, in that case, that `MkR' has kind `Relation b b'
2020-11-19 00:15:27 +0100cheers(user@unaffiliated/cheers)
2020-11-19 00:15:44 +0100iinuwa(iinuwamatr@gateway/shell/matrix.org/x-jxshhrkktrqfnuqi) (Ping timeout: 240 seconds)
2020-11-19 00:15:44 +0100orcus(~orcus@unaffiliated/orcus) (Ping timeout: 240 seconds)
2020-11-19 00:15:54 +0100 <boxscape> I think I only considered that the pattern matching could influence what the invisible args are, and forgot that the result could as well
2020-11-19 00:15:57 +0100rotty(rotty@ghost.xx.vu)
2020-11-19 00:16:00 +0100 <boxscape> thanks
2020-11-19 00:17:04 +0100maralorn(maralornma@gateway/shell/matrix.org/x-qdyphvplrxcjzfoq)
2020-11-19 00:17:39 +0100abhixec(~abhixec@c-67-169-141-95.hsd1.ca.comcast.net)
2020-11-19 00:18:22 +0100In0perable(~PLAYER_1@fancydata.science)
2020-11-19 00:18:54 +0100 <ski> well, well, `alt :: Relation a c' is consistent with `alt :: Relation a b',`MkR :: Relation b c', if `b = c'
2020-11-19 00:19:09 +0100Flonk(~Flonk@ec2-52-40-29-25.us-west-2.compute.amazonaws.com)
2020-11-19 00:19:25 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-11-19 00:19:26 +0100 <boxscape> right, that makes sense
2020-11-19 00:20:02 +0100conal(~conal@64.71.133.70)
2020-11-19 00:20:12 +0100conal(~conal@64.71.133.70) (Client Quit)
2020-11-19 00:20:16 +0100siraben(sirabenmat@gateway/shell/matrix.org/x-moaedtsqvaqtshxu)
2020-11-19 00:20:29 +0100 <ski> (that "well, well, " being an (inadvertent) example of the "the the" class of typos mentioned above)
2020-11-19 00:20:30 +0100hackageth-lift-instances 0.1.18 - Lift instances for template-haskell for common data types. https://hackage.haskell.org/package/th-lift-instances-0.1.18 (BennoFuenfstueck)
2020-11-19 00:20:52 +0100aoei(~aoei@240.223.246.35.bc.googleusercontent.com) (Remote host closed the connection)
2020-11-19 00:22:03 +0100crdrost(~crdrost@c-98-207-102-156.hsd1.ca.comcast.net)
2020-11-19 00:22:04 +0100aoei(~aoei@240.223.246.35.bc.googleusercontent.com)
2020-11-19 00:22:15 +0100 <boxscape> What apparently also confused me is that I encountered this in a situation where MkR was slightly different and made b ~ c impossible, but not in a way that was obvious to the type checker
2020-11-19 00:23:33 +0100 <boxscape> (specifically, MkR took a proof that b < c)
2020-11-19 00:23:49 +0100danvet(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa) (Ping timeout: 272 seconds)
2020-11-19 00:23:55 +0100abhixec(~abhixec@c-67-169-141-95.hsd1.ca.comcast.net) (Ping timeout: 246 seconds)
2020-11-19 00:25:22 +0100rotty(rotty@ghost.xx.vu) (Ping timeout: 260 seconds)
2020-11-19 00:26:00 +0100jb55(~jb55@gateway/tor-sasl/jb55)
2020-11-19 00:27:03 +0100rotty(rotty@ghost.xx.vu)
2020-11-19 00:27:42 +0100shutdown_-h_now(~arjan@2001:1c06:2d0b:2312:190f:5fcb:2d71:58b) (Ping timeout: 260 seconds)
2020-11-19 00:27:56 +0100 <ski> hmm, it's curious that a polymorphic type family isn't blind in the `forall'
2020-11-19 00:28:07 +0100Madars(~null@unaffiliated/madars)
2020-11-19 00:28:22 +0100 <boxscape> what do you mean by "blind" here?
2020-11-19 00:29:07 +0100ystael(~ystael@209.6.50.55) (Ping timeout: 260 seconds)
2020-11-19 00:29:19 +0100 <ski> not being able to match on the kind bound by the `forall'
2020-11-19 00:29:56 +0100 <boxscape> I think that's what Richard Eisenberg et al call "relevant" vs "irrelevant"?
2020-11-19 00:30:06 +0100 <ski> you can't write `notId :: forall a. a -> a; notId @Int n = n + 1; notId x = x'
2020-11-19 00:30:13 +0100 <boxscape> he's complained before that the "forall" on the kind level really should be called "foreach" to match up with the value level plans
2020-11-19 00:30:41 +0100 <ski> in relation to type (and `data') families, specifically ?
2020-11-19 00:31:25 +0100 <boxscape> Well, I'm fairly certain that relevancy is a concept applicable to type families, I'm less certain if I saw Richard complain about it in that context
2020-11-19 00:32:17 +0100 <ski> (since i'd think parametricity would also sensibly apply to polymorphic types)
2020-11-19 00:32:23 +0100conal(~conal@64.71.133.70)
2020-11-19 00:32:30 +0100 <ski> mhm
2020-11-19 00:32:51 +0100 <boxscape> Yeah, hm, I suppose relevancy can break parametricity
2020-11-19 00:32:57 +0100 <ski> iow, i guess i'd expect your `Fam' to use `foreach' instead, but to also be able to use `forall' on the type-level
2020-11-19 00:32:59 +0100iinuwa(iinuwamatr@gateway/shell/matrix.org/x-cburarlywoxtjfrp)
2020-11-19 00:33:12 +0100 <boxscape> yeah that makes sense
2020-11-19 00:34:06 +0100 <ski> that could have helped catch your confusion in the pasted code, preventing `Fam alt MkR = alt' to work, unless you used `foreach'
2020-11-19 00:34:17 +0100shutdown_-h_now(~arjan@2001:1c06:2d0b:2312:794d:ef9:43c6:21d5)
2020-11-19 00:34:23 +0100 <boxscape> that's true
2020-11-19 00:34:53 +0100 <ski> (btw, i think the "blind" terminology might come from Japaridze's computability logic)
2020-11-19 00:34:58 +0100 <boxscape> although even then I think in a value level function with foreach the result (as supposed to matching on other arguments) couldn't influence the invisible arguments like that? I'm not sure
2020-11-19 00:35:25 +0100 <boxscape> s/supposed/opposed
2020-11-19 00:37:00 +0100 <ski> i'm still not totally sure what you mean by "the result [..] couldn't influence the invisible arguments like that" -- i suspect you mean the "back-propagation" of unification of tyvars, to specialize the (implicit type-)parameters, based on the type inference/checking on the body
2020-11-19 00:37:33 +0100 <boxscape> that.. sounds it like should be what I mean
2020-11-19 00:38:18 +0100 <dolio> The whole system is kind of inconsistent.
2020-11-19 00:38:29 +0100nek0(~nek0@mail.nek0.eu) (Quit: Ping timeout (120 seconds))
2020-11-19 00:38:33 +0100 <dolio> Like, type families already let you match on things that you aren't normally allowed to match on.
2020-11-19 00:38:36 +0100 <glguy> unclechu: You around?
2020-11-19 00:38:42 +0100 <ski> hmm .. consider something like `sameNat :: foreach (m :: Nat) (n :: Nat). Maybe (Equal m n); sameNat = Just Refl; sameNat = Nothing'
2020-11-19 00:38:43 +0100ulidtko(~ulidtko@193.111.48.79) (Remote host closed the connection)
2020-11-19 00:38:50 +0100 <glguy> I was playing with a module based on your wanting a reusable, type-level Map https://gist.github.com/glguy/98331ca1c3876a188e5380b9d0da5751
2020-11-19 00:39:02 +0100nek0(~nek0@mail.nek0.eu)
2020-11-19 00:39:02 +0100ulidtko(~ulidtko@193.111.48.79)
2020-11-19 00:39:06 +0100 <glguy> It's not "light-weight", but I thought it was cool that it worked
2020-11-19 00:39:31 +0100 <ski> where the definition would be expanded into `sameNat @n @n = Just (Refl @Nat @n); sameNat @_ @_ = Nothing'
2020-11-19 00:39:34 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl)
2020-11-19 00:40:11 +0100 <ski> dolio : yea. we sortof pretend `*'/`Type' is a(n open) sum type, in families
2020-11-19 00:40:20 +0100 <dolio> So it's kind of hard to draw analogies between the two levels, because they don't work the same in many ways.
2020-11-19 00:41:14 +0100 <boxscape> right, but the eventual goal of folks like Richard is to unify them, so.. I guess I was analogizing with that hypothetical future value level
2020-11-19 00:41:15 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 00:41:29 +0100 <boxscape> though of course that's not fully specified at this point
2020-11-19 00:41:39 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de) (Ping timeout: 256 seconds)
2020-11-19 00:41:52 +0100 <dolio> And even in more uniform systems, parametricity gets kind of fuzzy and unsatisfying when you talk about applying it to types.
2020-11-19 00:42:05 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 00:42:08 +0100 <boxscape> ski intuitively I would expect sameNat not to compile in a Haskell with foreach, but maybe it should, I'm not sure. Hm, would it compile in agda?
2020-11-19 00:42:28 +0100 <ski> (and this is one argument against the terminology "type constructor" (vs. "data constructor"), i suppose .. also, with `DataKinds', with say `data Tag = E | D', `Tag' being a kind, what do we call `Tag',`E',`D' ? calling the latter two "type constructors" would seem to be confusing, possibly ? .. oh, well)
2020-11-19 00:43:06 +0100 <ski> boxscape : in Agda, with implicit parameters, yes
2020-11-19 00:43:14 +0100 <boxscape> okay, fair enough
2020-11-19 00:43:32 +0100 <ski> or, well
2020-11-19 00:43:50 +0100 <ski> you'd have to actually do recursion on the `Nat's, not being able to use non-linear patterns
2020-11-19 00:44:09 +0100 <ski> (so not with that exact implementation. but you could implement it)
2020-11-19 00:44:13 +0100 <boxscape> ok
2020-11-19 00:44:30 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de)
2020-11-19 00:46:37 +0100boxscape(54a35f37@gateway/web/cgi-irc/kiwiirc.com/ip.84.163.95.55) (Quit: Connection closed)
2020-11-19 00:46:50 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl) (Remote host closed the connection)
2020-11-19 00:47:03 +0100boxscape(54a35f37@gateway/web/cgi-irc/kiwiirc.com/ip.84.163.95.55)
2020-11-19 00:47:19 +0100hexfive(~hexfive@50-47-142-195.evrt.wa.frontiernet.net) (Quit: i must go. my people need me.)
2020-11-19 00:48:01 +0100 <energizer> usually arrays are indexed by natural numbers. is there something like an array but indexed by some other type
2020-11-19 00:48:30 +0100 <energizer> like strings or whatever
2020-11-19 00:48:33 +0100 <ski> > listArray (LT,GT) [-1,0,1]
2020-11-19 00:48:35 +0100 <lambdabot> array (LT,GT) [(LT,-1),(EQ,0),(GT,1)]
2020-11-19 00:48:38 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-19 00:49:01 +0100 <ski> perhaps you want some form of trie ?
2020-11-19 00:49:24 +0100 <ski> @type listArray (LT,GT) [-1,0,1 :: Integer]
2020-11-19 00:49:26 +0100 <lambdabot> Array Ordering Integer
2020-11-19 00:49:31 +0100 <ClaudiusMaximus> Ix is a class for mapping values of a type to natural numbers for use as array indices
2020-11-19 00:49:44 +0100 <ski> (an array indexed by values of type `Ordering')
2020-11-19 00:49:59 +0100 <ski> @type listArray
2020-11-19 00:50:01 +0100 <lambdabot> Ix i => (i, i) -> [e] -> Array i e
2020-11-19 00:50:23 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb)
2020-11-19 00:50:54 +0100 <energizer> there should be the property that a<b<c means b is a valid index whenever a and c are
2020-11-19 00:51:15 +0100 <ski> @type range
2020-11-19 00:51:16 +0100 <lambdabot> Ix a => (a, a) -> [a]
2020-11-19 00:51:27 +0100 <ski> gives values in a kind of "interval"
2020-11-19 00:51:46 +0100 <ski> (for two-dimensional arrays, it gives indices in a "rectangle")
2020-11-19 00:52:00 +0100 <ClaudiusMaximus> @type inRange -- tests, and i can never remember the argument order
2020-11-19 00:52:01 +0100 <lambdabot> Ix a => (a, a) -> a -> Bool
2020-11-19 00:52:05 +0100 <ski> > range ((-1,-1),(2,3))
2020-11-19 00:52:06 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 00:52:07 +0100 <lambdabot> [(-1,-1),(-1,0),(-1,1),(-1,2),(-1,3),(0,-1),(0,0),(0,1),(0,2),(0,3),(1,-1),(...
2020-11-19 00:52:23 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 00:52:54 +0100 <ClaudiusMaximus> (it has a name that sounds infix, but it is flipped w.r.t. infix usage)
2020-11-19 00:54:24 +0100 <ski> in other words, `range (lo,hi)' should give a list of all indices `i', where ⌜lo ≼ i ∧ i ≼ hi⌝, where the ordering here is not lexicographic ordering in case of tuples, but rather the product order (a partial order, not a total/linear one)
2020-11-19 00:57:06 +0100 <ski> (ClaudiusMaximus : i wonder how that happened ..)
2020-11-19 00:58:34 +0100 <boxscape> %! ghc --version
2020-11-19 00:58:34 +0100 <yahb> boxscape: [Segmentation fault]
2020-11-19 00:58:35 +0100 <boxscape> cool
2020-11-19 01:00:38 +0100boxscape(54a35f37@gateway/web/cgi-irc/kiwiirc.com/ip.84.163.95.55) (Quit: Connection closed)
2020-11-19 01:00:49 +0100boxscape(54a35f37@gateway/web/cgi-irc/kiwiirc.com/ip.84.163.95.55)
2020-11-19 01:02:44 +0100 <boxscape> % :kind! Fam MkR (MkR :: Relation Int Int) -- so this is fine
2020-11-19 01:02:45 +0100 <yahb> boxscape: forall {k} {a :: k}. Relation a Int; = 'MkR
2020-11-19 01:02:46 +0100 <boxscape> % :kind! Fam MkR (MkR :: Int Int) -- But I do find it a bit confusing that this has no output
2020-11-19 01:02:46 +0100 <yahb> boxscape:
2020-11-19 01:03:24 +0100 <boxscape> I guess I'll try installing HEAD and see if it's fixed there
2020-11-19 01:03:31 +0100erisco(~erisco@d24-57-249-233.home.cgocable.net)
2020-11-19 01:05:27 +0100sfvm(~sfvm@37.228.215.148) (Remote host closed the connection)
2020-11-19 01:05:37 +0100alp(~alp@2a01:e0a:58b:4920:7462:8d66:154:f167) (Ping timeout: 272 seconds)
2020-11-19 01:06:19 +0100ski. o O ( <https://lambdacats.github.io/fixed-in-head/> )
2020-11-19 01:07:01 +0100sfvm(~sfvm@37.228.215.148)
2020-11-19 01:07:34 +0100 <boxscape> :)
2020-11-19 01:08:23 +0100 <hpc> whenever someone says "it's fixed in head", i read it as "it's fixed in my imagination"
2020-11-19 01:08:26 +0100borne(~fritjof@200116b864880600f1dc39039d201adf.dip.versatel-1u1.de) (Ping timeout: 264 seconds)
2020-11-19 01:09:30 +0100hackagewitch 0.0.0.3 - Convert values from one type into another. https://hackage.haskell.org/package/witch-0.0.0.3 (fozworth)
2020-11-19 01:10:52 +0100jedws(~jedws@101.184.175.183) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-19 01:15:57 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-19 01:16:36 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2020-11-19 01:19:03 +0100mastarija(~mastarija@93-136-63-196.adsl.net.t-com.hr) (Remote host closed the connection)
2020-11-19 01:19:07 +0100Entertainment(~entertain@104.246.132.210) ()
2020-11-19 01:19:25 +0100mastarija(~mastarija@93-136-63-196.adsl.net.t-com.hr)
2020-11-19 01:20:19 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:d091:432d:3cee:b0b2) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-19 01:24:41 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb) (Remote host closed the connection)
2020-11-19 01:27:44 +0100vicfred(~vicfred@unaffiliated/vicfred) (Quit: Leaving)
2020-11-19 01:27:44 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 01:28:01 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 01:28:19 +0100conal(~conal@64.71.133.70) (Ping timeout: 246 seconds)
2020-11-19 01:29:48 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:6c29:bc9c:b97a:2b45)
2020-11-19 01:29:49 +0100 <monochrom> That's half true because clearly there is no release plan other than imagination.
2020-11-19 01:30:00 +0100conal(~conal@66.115.157.132)
2020-11-19 01:32:10 +0100solonarv(~solonarv@astrasbourg-653-1-156-4.w90-6.abo.wanadoo.fr) (Ping timeout: 265 seconds)
2020-11-19 01:32:13 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 01:32:42 +0100haasn(~nand@mpv/developer/haasn) (Quit: ZNC 1.7.5+deb4 - https://znc.in)
2020-11-19 01:33:04 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 01:33:39 +0100DTZUZUtoxix
2020-11-19 01:35:55 +0100hekkaidekapus_(~tchouri@gateway/tor-sasl/hekkaidekapus)
2020-11-19 01:37:29 +0100fendor_(~fendor@178.165.128.131.wireless.dyn.drei.com)
2020-11-19 01:37:38 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:6c29:bc9c:b97a:2b45) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-19 01:37:43 +0100hekkaidekapus(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 240 seconds)
2020-11-19 01:37:45 +0100jespada(~jespada@90.254.245.49) (Ping timeout: 256 seconds)
2020-11-19 01:37:50 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 01:38:04 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 01:38:25 +0100 <boxscape> ski: FWIW this fails in agda, but I'm not sure if the same caveat applies here that you mentioned about Nats https://pastebin.com/jKsJpPVd
2020-11-19 01:39:05 +0100jespada(~jespada@90.254.245.49)
2020-11-19 01:39:22 +0100 <boxscape> guess I should look up non-linear pattern
2020-11-19 01:39:32 +0100 <dolio> You need to prove it by cases.
2020-11-19 01:40:03 +0100fendor(~fendor@77.119.128.218.wireless.dyn.drei.com) (Ping timeout: 260 seconds)
2020-11-19 01:40:31 +0100mastarija(~mastarija@93-136-63-196.adsl.net.t-com.hr) (Quit: Leaving)
2020-11-19 01:40:34 +0100 <boxscape> dolio right, that would have been my intuition but from my conversation with ski it initially sounded like this would work (and it would in Haskell type families, I think)
2020-11-19 01:41:28 +0100fr33domlover(~fr33domlo@fsf/member/fr33domlover) (Ping timeout: 260 seconds)
2020-11-19 01:42:00 +0100haasn(~nand@mpv/developer/haasn)
2020-11-19 01:44:55 +0100fr33domlover(~fr33domlo@fsf/member/fr33domlover)
2020-11-19 01:46:23 +0100 <dolio> Yeah, an analogous type family would work. That it does work is a massive difference in expectation of what they mean, more or less.
2020-11-19 01:46:25 +0100Gurkenglas(~Gurkengla@unaffiliated/gurkenglas) (Ping timeout: 240 seconds)
2020-11-19 01:46:39 +0100 <dolio> Like, type families are assuming that all the things they operate over have decidable equality.
2020-11-19 01:47:05 +0100 <boxscape> Oh, that's interesting
2020-11-19 01:47:39 +0100 <dolio> I guess in some ways it's not even that, though.
2020-11-19 01:47:52 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:6c29:bc9c:b97a:2b45)
2020-11-19 01:48:27 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:6c29:bc9c:b97a:2b45) (Client Quit)
2020-11-19 01:48:48 +0100 <dolio> Because the actual behavior is like, 'if you ever figure out that m = n, then `foo m n` reduces to one thing, and if you figure out that m /= n, it reduces to another.'
2020-11-19 01:49:16 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-19 01:49:55 +0100 <boxscape> oh, yeah.. I thought it would work in agda if you wrote {a} {.a}, but with your it doesn't sound like it, and indeed, it says "Failed to infer the value of dotted pattern".
2020-11-19 01:50:09 +0100 <boxscape> s/with your/with your explanation
2020-11-19 01:50:17 +0100bergey(~user@pool-74-108-99-127.nycmny.fios.verizon.net) (Remote host closed the connection)
2020-11-19 01:50:19 +0100 <dolio> No, .a is for when you match on a proof that two things are equal.
2020-11-19 01:50:51 +0100 <boxscape> RIght, okay
2020-11-19 01:51:03 +0100 <boxscape> So it's very different from saying @a @a in a type family
2020-11-19 01:51:26 +0100 <dolio> Yeah.
2020-11-19 01:51:49 +0100DataComp_(~lumeng@static-50-43-26-251.bvtn.or.frontiernet.net) (Remote host closed the connection)
2020-11-19 01:54:30 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 272 seconds)
2020-11-19 01:54:46 +0100rogue_cheddar(~manjaro-u@2806:1000:8003:2a54:da9a:e457:f660:288a)
2020-11-19 01:55:37 +0100 <dolio> Anyhow, if you don't want things to get stuck, which is important in Agda, then decidable equality is kind of important for justifying that sort of matching.
2020-11-19 01:56:07 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:6c29:bc9c:b97a:2b45)
2020-11-19 01:56:19 +0100 <dolio> Whereas type families are kind of based on the idea of adding things that get stuck, and specifying certain scenarios where they become unstuck, with no guarantee that all scenarios are covered.
2020-11-19 01:56:37 +0100wpcarro(sid397589@gateway/web/irccloud.com/x-jyvrhcovkjnuufaq) (Ping timeout: 260 seconds)
2020-11-19 01:57:36 +0100 <boxscape> hmm I wonder how this pretend-dec-eq-ness will work when you try to match on unsaturated type families once those are merged
2020-11-19 01:57:44 +0100 <boxscape> I guess maybe it'll just get stuck
2020-11-19 01:58:21 +0100Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi) (Quit: Leaving.)
2020-11-19 01:59:24 +0100wpcarro(sid397589@gateway/web/irccloud.com/x-mptadpaqtazralft)
2020-11-19 01:59:33 +0100xsperry(~as@unaffiliated/xsperry) (Ping timeout: 260 seconds)
2020-11-19 02:01:14 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-19 02:02:13 +0100Tesseraction(~Tesseract@unaffiliated/tesseraction)
2020-11-19 02:02:54 +0100thc202(~thc202@unaffiliated/thc202) (Quit: thc202)
2020-11-19 02:03:00 +0100 <ski> boxscape : yes, you'd need `sameNat {false} {false} = just refl; sameNat {true} {true} = just refl; sameNat = nothing', pretty sure
2020-11-19 02:03:47 +0100 <boxscape> yeah, that does work
2020-11-19 02:05:37 +0100jneira(02896ac0@gateway/web/cgi-irc/kiwiirc.com/ip.2.137.106.192) (Ping timeout: 264 seconds)
2020-11-19 02:05:38 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 02:06:01 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 02:06:30 +0100 <p0a> /quit bye
2020-11-19 02:06:32 +0100p0a(~user@unaffiliated/p0a) (Quit: bye)
2020-11-19 02:06:39 +0100SupaYoshi(~supayoshi@213-10-140-13.fixed.kpn.net) (Ping timeout: 260 seconds)
2020-11-19 02:08:14 +0100cosimone(~cosimone@5.171.24.92)
2020-11-19 02:08:19 +0100iqubic(~user@2601:602:9500:4870:18b7:5f73:2db2:1881) ("ERC (IRC client for Emacs 28.0.50)")
2020-11-19 02:09:18 +0100vicfred(~vicfred@unaffiliated/vicfred)
2020-11-19 02:13:25 +0100m0rphism(~m0rphism@HSI-KBW-095-208-098-207.hsi5.kabel-badenwuerttemberg.de) (Ping timeout: 264 seconds)
2020-11-19 02:13:49 +0100SupaYoshi(~supayoshi@213-10-140-13.fixed.kpn.net)
2020-11-19 02:17:10 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de) (Quit: Leaving)
2020-11-19 02:17:45 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 240 seconds)
2020-11-19 02:19:14 +0100DataComputist(~lumeng@static-50-43-26-251.bvtn.or.frontiernet.net)
2020-11-19 02:20:37 +0100Tourist(~tourist@da.tourist.sh)
2020-11-19 02:20:37 +0100Tourist(~tourist@da.tourist.sh) (Changing host)
2020-11-19 02:20:37 +0100Tourist(~tourist@unaffiliated/tourist)
2020-11-19 02:20:41 +0100christo(~chris@81.96.113.213)
2020-11-19 02:21:14 +0100nuncanada(~dude@179.235.160.168)
2020-11-19 02:21:27 +0100guest1119(~user@49.5.6.87)
2020-11-19 02:25:32 +0100nek0(~nek0@mail.nek0.eu) (Ping timeout: 260 seconds)
2020-11-19 02:25:45 +0100cgfuh(~cgfuh@181.167.191.58) (Ping timeout: 240 seconds)
2020-11-19 02:27:03 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-19 02:30:34 +0100i8ucl(~manjaro-u@201.130.137.230.dsl.dyn.telnor.net)
2020-11-19 02:31:07 +0100rogue_cheddar(~manjaro-u@2806:1000:8003:2a54:da9a:e457:f660:288a) (Ping timeout: 272 seconds)
2020-11-19 02:32:06 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 265 seconds)
2020-11-19 02:32:45 +0100Rudd0(~Rudd0@185.189.115.103) (Ping timeout: 240 seconds)
2020-11-19 02:33:16 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net) (Quit: leaving)
2020-11-19 02:33:24 +0100magnuscake(~magnuscak@103.44.33.121)
2020-11-19 02:33:36 +0100Lord_of_Life_(~Lord@46.217.218.252)
2020-11-19 02:33:36 +0100Lord_of_Life(~Lord@46.217.217.18) (Ping timeout: 240 seconds)
2020-11-19 02:34:31 +0100hackageciteproc 0.2 - Generates citations and bibliography from CSL styles. https://hackage.haskell.org/package/citeproc-0.2 (JohnMacFarlane)
2020-11-19 02:35:47 +0100magnuscake(~magnuscak@103.44.33.121) (Client Quit)
2020-11-19 02:37:03 +0100wh0(~wh0000@cpc152777-shef18-2-0-cust223.17-1.cable.virginm.net)
2020-11-19 02:37:05 +0100elliott__(~elliott@pool-108-51-141-12.washdc.fios.verizon.net)
2020-11-19 02:42:42 +0100nek0(~nek0@mail.nek0.eu)
2020-11-19 02:44:51 +0100Deide(~Deide@217.155.19.23) (Quit: Seeee yaaaa)
2020-11-19 02:47:29 +0100nek0(~nek0@mail.nek0.eu) (Client Quit)
2020-11-19 02:49:07 +0100nek0(~nek0@mail.nek0.eu)
2020-11-19 02:52:07 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-19 02:52:51 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2020-11-19 03:06:19 +0100 <guest1119> case parse (spaces >> symbol) "lisp" input of ...
2020-11-19 03:06:27 +0100 <guest1119> what "lisp" and input here mean?
2020-11-19 03:06:40 +0100 <guest1119> parse :: Stream s Identity t => Parsec s () a -> SourceName -> s -> Either ParseError a
2020-11-19 03:06:52 +0100 <guest1119> from https://hackage.haskell.org/package/parsec-3.1.14.0/docs/Text-Parsec.html
2020-11-19 03:07:25 +0100wh0(~wh0000@cpc152777-shef18-2-0-cust223.17-1.cable.virginm.net) (Ping timeout: 264 seconds)
2020-11-19 03:07:46 +0100 <guest1119> also, what do Stream s Identity t constraint? constraint for s? not t?
2020-11-19 03:08:37 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-19 03:10:47 +0100 <glguy> "lisp" is the name of the input
2020-11-19 03:11:01 +0100 <glguy> Often that's a filename or some other description
2020-11-19 03:13:19 +0100christo(~chris@81.96.113.213)
2020-11-19 03:15:44 +0100 <Axman6> s appears to be the type of impot that's being parsed, to probably usually a String or Text
2020-11-19 03:15:51 +0100 <Axman6> input*
2020-11-19 03:17:49 +0100xsperry(~as@unaffiliated/xsperry)
2020-11-19 03:18:44 +0100toorevitimirp(~tooreviti@117.182.180.118)
2020-11-19 03:23:00 +0100jakob_(~textual@p200300f49f162200756a589588d5c172.dip0.t-ipconnect.de) (Quit: My Laptop has gone to sleep. ZZZzzz…)
2020-11-19 03:23:44 +0100conal(~conal@66.115.157.132) (Quit: Computer has gone to sleep.)
2020-11-19 03:24:46 +0100 <Axman6> guest1119: does that help at all?
2020-11-19 03:30:34 +0100 <guest1119> Axman6: yes
2020-11-19 03:30:50 +0100 <guest1119> but why we would give input a name?
2020-11-19 03:31:03 +0100 <guest1119> case (parse numbers "" "11, 2, 43") of
2020-11-19 03:31:15 +0100 <guest1119> numbers = commaSep integer
2020-11-19 03:31:43 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 260 seconds)
2020-11-19 03:31:44 +0100 <guest1119> this give "11, 2, 43" a "" name?
2020-11-19 03:33:25 +0100st8less(~st8less@2603:a060:11fd:0:9539:fd10:c1ca:1d78) (Quit: WeeChat 2.9)
2020-11-19 03:37:40 +0100guest1119(~user@49.5.6.87) (Remote host closed the connection)
2020-11-19 03:38:10 +0100nuncanada(~dude@179.235.160.168) (Quit: Leaving)
2020-11-19 03:39:51 +0100isacl___(uid13263@gateway/web/irccloud.com/x-zatkgdiubqivrbyl)
2020-11-19 03:40:09 +0100xff0x(~fox@2001:1a81:5310:3c00:eddd:290e:8cac:b048) (Ping timeout: 272 seconds)
2020-11-19 03:41:33 +0100xff0x(~fox@2001:1a81:534b:a000:20f1:4040:a0e2:f16)
2020-11-19 03:48:08 +0100jakob_(~textual@p200300f49f16220080fac7d5cef5a2db.dip0.t-ipconnect.de)
2020-11-19 03:48:17 +0100jakob_(~textual@p200300f49f16220080fac7d5cef5a2db.dip0.t-ipconnect.de) (Client Quit)
2020-11-19 03:48:54 +0100drbean(~drbean@TC210-63-209-68.static.apol.com.tw)
2020-11-19 03:50:45 +0100vicfred(~vicfred@unaffiliated/vicfred) (Quit: Leaving)
2020-11-19 03:54:34 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 03:55:37 +0100hidedagger(~nate@unaffiliated/hidedagger) (Client Quit)
2020-11-19 03:56:35 +0100SupaYoshii(~supayoshi@213-10-140-13.fixed.kpn.net)
2020-11-19 03:57:23 +0100SupaYoshi(~supayoshi@213-10-140-13.fixed.kpn.net) (Ping timeout: 260 seconds)
2020-11-19 03:58:59 +0100guest1119(~user@49.5.6.87)
2020-11-19 04:02:50 +0100guest1119(~user@49.5.6.87) (Client Quit)
2020-11-19 04:04:00 +0100guest1119(~user@49.5.6.87)
2020-11-19 04:04:02 +0100boxscape(54a35f37@gateway/web/cgi-irc/kiwiirc.com/ip.84.163.95.55) (Quit: Connection closed)
2020-11-19 04:04:31 +0100boxscape(54a35f37@gateway/web/cgi-irc/kiwiirc.com/ip.84.163.95.55)
2020-11-19 04:05:45 +0100wei2912(~wei2912@unaffiliated/wei2912)
2020-11-19 04:07:37 +0100rab24ack[m](rab24ackma@gateway/shell/matrix.org/x-psmufgypmrylcnyv)
2020-11-19 04:12:27 +0100inkbottle(~inkbottle@aaubervilliers-654-1-104-55.w86-212.abo.wanadoo.fr) (Quit: Konversation terminated!)
2020-11-19 04:12:27 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 04:13:05 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 04:13:07 +0100howdoi(uid224@gateway/web/irccloud.com/x-xcriusnvhpaknzlz) (Quit: Connection closed for inactivity)
2020-11-19 04:13:16 +0100erisco(~erisco@d24-57-249-233.home.cgocable.net) (Ping timeout: 240 seconds)
2020-11-19 04:14:18 +0100falafel(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4)
2020-11-19 04:15:08 +0100Benzi-Junior(~BenziJuni@dsl-149-67-198.hive.is) (Ping timeout: 244 seconds)
2020-11-19 04:15:32 +0100zebrag(~inkbottle@aaubervilliers-654-1-104-55.w86-212.abo.wanadoo.fr)
2020-11-19 04:18:27 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 04:18:27 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 04:19:01 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 04:19:41 +0100hidedagger(~nate@unaffiliated/hidedagger) (Client Quit)
2020-11-19 04:19:41 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 04:20:26 +0100urodna(~urodna@unaffiliated/urodna) (Quit: urodna)
2020-11-19 04:21:43 +0100i8ucl(~manjaro-u@201.130.137.230.dsl.dyn.telnor.net) (Quit: Konversation terminated!)
2020-11-19 04:24:00 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 04:25:08 +0100Saukk(~Saukk@2001:998:f9:2914:1c59:9bb5:b94c:4)
2020-11-19 04:25:18 +0100toorevitimirp(~tooreviti@117.182.180.118) (Remote host closed the connection)
2020-11-19 04:26:38 +0100toorevitimirp(~tooreviti@117.182.180.118)
2020-11-19 04:28:21 +0100vicfred(~vicfred@unaffiliated/vicfred)
2020-11-19 04:29:26 +0100vicfred(~vicfred@unaffiliated/vicfred) (Max SendQ exceeded)
2020-11-19 04:29:30 +0100hackageaeson-gadt-th 0.2.5.0 - Derivation of Aeson instances for GADTs https://hackage.haskell.org/package/aeson-gadt-th-0.2.5.0 (abrar)
2020-11-19 04:29:53 +0100vicfred(~vicfred@unaffiliated/vicfred)
2020-11-19 04:33:39 +0100ph88(~ph88@ip5f5af6cd.dynamic.kabel-deutschland.de) (Ping timeout: 260 seconds)
2020-11-19 04:37:47 +0100Amras(~Amras@unaffiliated/amras0000) (Ping timeout: 272 seconds)
2020-11-19 04:39:06 +0100crdrost(~crdrost@c-98-207-102-156.hsd1.ca.comcast.net) (Quit: This computer has gone to sleep)
2020-11-19 04:42:39 +0100Benzi-Junior(~BenziJuni@88-149-67-198.du.xdsl.is)
2020-11-19 04:43:39 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 04:43:58 +0100machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Ping timeout: 246 seconds)
2020-11-19 04:45:19 +0100lagothrix(~lagothrix@unaffiliated/lagothrix) (Killed (moon.freenode.net (Nickname regained by services)))
2020-11-19 04:45:27 +0100lagothrix(~lagothrix@unaffiliated/lagothrix)
2020-11-19 04:45:48 +0100Tario(~Tario@201.192.165.173) (Ping timeout: 260 seconds)
2020-11-19 04:46:59 +0100andi-(~andi-@NixOS/user/andi-) (Remote host closed the connection)
2020-11-19 04:50:17 +0100 <hololeap> i have a function: tryE :: MonadUnliftIO m => m a -> ExceptT IOException m a
2020-11-19 04:51:06 +0100toorevitimirp(~tooreviti@117.182.180.118) (Remote host closed the connection)
2020-11-19 04:51:07 +0100jedws(~jedws@101.184.150.93)
2020-11-19 04:51:23 +0100 <hololeap> how reasonable is it to use this wherever possible (and deal with the ExceptT monad) vs. keeping IOExceptions from the IO monad implicit and dealing with them closer to the `main` function
2020-11-19 04:51:45 +0100theDon(~td@94.134.91.119) (Ping timeout: 240 seconds)
2020-11-19 04:52:14 +0100 <hololeap> converting to `ExceptT ...` makes the possibility of an exception more explicit
2020-11-19 04:52:38 +0100toorevitimirp(~tooreviti@117.182.180.118)
2020-11-19 04:53:57 +0100theDon(~td@muedsl-82-207-238-104.citykom.de)
2020-11-19 04:54:04 +0100andi-(~andi-@NixOS/user/andi-)
2020-11-19 04:54:08 +0100 <hololeap> but then again, i could just try to remember that any IO operation has the possibility of throwing an IOException
2020-11-19 04:58:41 +0100 <glguy> Doing this will mean you have two places to catch IOExceptions, still in IO and also in ExceptT, and your code will be slower
2020-11-19 05:00:01 +0100alexelcu(~alexelcu@142.93.180.198) (Quit: ZNC 1.8.2 - https://znc.in)
2020-11-19 05:00:15 +0100 <hololeap> yeah, it's also more typing
2020-11-19 05:00:23 +0100Rudd0(~Rudd0@185.189.115.108)
2020-11-19 05:00:55 +0100 <hololeap> i did it in one place and then realized it's kind of an all-or-nothing approach. you can't really mix it with the default.
2020-11-19 05:01:00 +0100alexelcu(~alexelcu@142.93.180.198)
2020-11-19 05:01:22 +0100 <hololeap> well, you can...
2020-11-19 05:02:19 +0100ddellacosta(dd@gateway/vpn/mullvad/ddellacosta) (Ping timeout: 256 seconds)
2020-11-19 05:04:27 +0100acidjnk_new(~acidjnk@p200300d0c719ff57608036dc958592ad.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2020-11-19 05:05:12 +0100macrover(~macrover@ip70-189-231-35.lv.lv.cox.net)
2020-11-19 05:05:26 +0100renzhi(~renzhi@2607:fa49:655f:e600::28da) (Ping timeout: 264 seconds)
2020-11-19 05:12:13 +0100thunderrd(~thunderrd@183.182.111.169) (Ping timeout: 264 seconds)
2020-11-19 05:14:11 +0100FreeBirdLjj(~freebirdl@101.228.42.108)
2020-11-19 05:16:31 +0100boxscape(54a35f37@gateway/web/cgi-irc/kiwiirc.com/ip.84.163.95.55) (Ping timeout: 246 seconds)
2020-11-19 05:17:35 +0100moth(~moth@s91904426.blix.com) (Remote host closed the connection)
2020-11-19 05:19:29 +0100FreeBirdLjj(~freebirdl@101.228.42.108) (Remote host closed the connection)
2020-11-19 05:20:12 +0100FreeBirdLjj(~freebirdl@101.228.42.108)
2020-11-19 05:20:35 +0100mwehner(~martin@li910-8.members.linode.com) ()
2020-11-19 05:22:31 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-19 05:24:21 +0100thunderrd(~thunderrd@183.182.114.130)
2020-11-19 05:24:56 +0100FreeBirdLjj(~freebirdl@101.228.42.108) (Ping timeout: 240 seconds)
2020-11-19 05:26:19 +0100FreeBirdLjj(~freebirdl@101.228.42.108)
2020-11-19 05:29:35 +0100ph88(~ph88@2a02:8109:9e00:7e5c:a963:461:83fa:2c4)
2020-11-19 05:30:58 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:6c29:bc9c:b97a:2b45) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-19 05:37:36 +0100drbean(~drbean@TC210-63-209-68.static.apol.com.tw) (Ping timeout: 240 seconds)
2020-11-19 05:46:28 +0100tumdedum(~tumdedum@unaffiliated/espiral) (Ping timeout: 260 seconds)
2020-11-19 05:46:31 +0100hackageyesod-core 1.6.18.7 - Creation of type-safe, RESTful web applications. https://hackage.haskell.org/package/yesod-core-1.6.18.7 (MichaelSnoyman)
2020-11-19 05:53:12 +0100falafel(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4) (Ping timeout: 260 seconds)
2020-11-19 05:53:14 +0100spatchkaa(~spatchkaa@S010600fc8da47b63.gv.shawcable.net)
2020-11-19 05:53:35 +0100tumdedum(~tumdedum@unaffiliated/espiral)
2020-11-19 05:54:30 +0100thunderrd(~thunderrd@183.182.114.130) (Ping timeout: 246 seconds)
2020-11-19 05:55:23 +0100jb55(~jb55@gateway/tor-sasl/jb55) (Ping timeout: 240 seconds)
2020-11-19 05:56:55 +0100Stanley00(~stanley00@unaffiliated/stanley00)
2020-11-19 06:00:17 +0100texasmynsted(~texasmyns@212.102.45.121) (Remote host closed the connection)
2020-11-19 06:00:57 +0100conal(~conal@64.71.133.70)
2020-11-19 06:00:57 +0100Saukk(~Saukk@2001:998:f9:2914:1c59:9bb5:b94c:4) (Remote host closed the connection)
2020-11-19 06:02:29 +0100texasmynsted(~texasmyns@212.102.45.121)
2020-11-19 06:04:13 +0100jb55(~jb55@gateway/tor-sasl/jb55)
2020-11-19 06:05:15 +0100tumdedum(~tumdedum@unaffiliated/espiral) (Ping timeout: 265 seconds)
2020-11-19 06:07:12 +0100texasmynsted(~texasmyns@212.102.45.121) (Ping timeout: 260 seconds)
2020-11-19 06:07:42 +0100thunderrd(~thunderrd@183.182.110.8)
2020-11-19 06:08:54 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-11-19 06:09:49 +0100spatchkaa(~spatchkaa@S010600fc8da47b63.gv.shawcable.net) (Ping timeout: 264 seconds)
2020-11-19 06:10:56 +0100mbomba(~mbomba@bras-base-toroon2719w-grc-49-142-114-9-241.dsl.bell.ca) (Quit: WeeChat 3.0)
2020-11-19 06:12:53 +0100christo(~chris@81.96.113.213)
2020-11-19 06:13:03 +0100tumdedum(~tumdedum@unaffiliated/espiral)
2020-11-19 06:13:16 +0100cosimone(~cosimone@5.171.24.92) (Ping timeout: 240 seconds)
2020-11-19 06:14:21 +0100aioe(aoei@2a01:7e01::f03c:92ff:fe4f:e85a)
2020-11-19 06:14:23 +0100monochrom(trebla@216.138.220.146) (Quit: NO CARRIER)
2020-11-19 06:15:20 +0100FreeBirdLjj(~freebirdl@101.228.42.108) (Remote host closed the connection)
2020-11-19 06:15:25 +0100xerox_(~xerox@unaffiliated/xerox) (Ping timeout: 240 seconds)
2020-11-19 06:17:16 +0100cosimone(~cosimone@5.170.241.44)
2020-11-19 06:17:23 +0100christo(~chris@81.96.113.213) (Ping timeout: 260 seconds)
2020-11-19 06:17:29 +0100aoei(~aoei@240.223.246.35.bc.googleusercontent.com) (Remote host closed the connection)
2020-11-19 06:18:44 +0100aioeaoei
2020-11-19 06:19:07 +0100ericsagn1(~ericsagne@2405:6580:0:5100:8c9:42ac:c0f6:8508) (Ping timeout: 272 seconds)
2020-11-19 06:21:32 +0100jb55(~jb55@gateway/tor-sasl/jb55) (Remote host closed the connection)
2020-11-19 06:21:38 +0100ft(~ft@shell.chaostreff-dortmund.de) (Ping timeout: 264 seconds)
2020-11-19 06:21:52 +0100jb55(~jb55@gateway/tor-sasl/jb55)
2020-11-19 06:22:23 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Quit: leaving)
2020-11-19 06:22:38 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-19 06:24:43 +0100day_(~Unknown@unaffiliated/day)
2020-11-19 06:27:05 +0100SanchayanMaity(~Sanchayan@106.201.35.233)
2020-11-19 06:27:45 +0100day(~Unknown@unaffiliated/day) (Ping timeout: 240 seconds)
2020-11-19 06:27:45 +0100day_day
2020-11-19 06:27:58 +0100monochrom(trebla@216.138.220.146)
2020-11-19 06:28:31 +0100xerox_(~xerox@unaffiliated/xerox)
2020-11-19 06:31:06 +0100ericsagn1(~ericsagne@2405:6580:0:5100:b274:8c51:102c:8ca9)
2020-11-19 06:32:10 +0100n00b(d055ed89@208.85.237.137)
2020-11-19 06:32:55 +0100n00bn0042
2020-11-19 06:33:34 +0100 <n0042> Hello folks. May I ask what is probably a pretty common newbie question? I have done a lot of research on it and am starting to feel a little stumped at having not found the proper answer
2020-11-19 06:33:48 +0100xerox_(~xerox@unaffiliated/xerox) (Ping timeout: 272 seconds)
2020-11-19 06:34:52 +0100zyklotomic(~ethan@unaffiliated/chocopuff)
2020-11-19 06:35:29 +0100 <n0042> I have a situation where I need to take an unknown # of lines from stdin (no more, no less, finite but unknown until runtime). I have tried a hundred different ways of trying to use getLine programmatically so that it collects exactly n-amount of lines, after n is known. Is there a good article I can read on this?
2020-11-19 06:36:11 +0100 <zyklotomic> what have you tried so far
2020-11-19 06:37:33 +0100 <n0042> So far my most promising approach has been to get the initial number of lines with getLine (because that input is known) parse it and extract the number, and then try to run getLine that amount of times.
2020-11-19 06:37:59 +0100 <glguy> that sounds right
2020-11-19 06:37:59 +0100 <zyklotomic> i'm just a beginner, but maybe replicateM might help
2020-11-19 06:38:04 +0100 <dsal> It'd be easier to show code and describe the confusion than to describe the problem.
2020-11-19 06:38:06 +0100hidedagger(~nate@unaffiliated/hidedagger) (Quit: WeeChat 2.9)
2020-11-19 06:38:18 +0100 <glguy> ?paste
2020-11-19 06:38:18 +0100 <lambdabot> A pastebin: https://paste.debian.net/
2020-11-19 06:38:20 +0100 <zyklotomic> replicateM n getLine
2020-11-19 06:38:39 +0100 <n0042> I have not tried replicateM. I'll try that.
2020-11-19 06:38:41 +0100 <glguy> zyklotomic, maybe, but n0042 ought to be able to do this without any library functions first
2020-11-19 06:39:13 +0100 <glguy> n0042, Do you have any attempts yet? What have you tried?
2020-11-19 06:39:32 +0100 <n0042> I did try: "take n (repeat getLine)" and wound up with a list of getLine functions that I then wasn't sure how to turn into values
2020-11-19 06:39:54 +0100 <n0042> I also tried recursive-do as described in the ghc docs, but that didn't want to compile the way I was trying to do it.
2020-11-19 06:40:29 +0100 <glguy> recursive-do is something you don't need
2020-11-19 06:40:29 +0100 <dsal> Showing code (and errors/confusion) is more informative than describing code.
2020-11-19 06:40:42 +0100cosimone(~cosimone@5.170.241.44) (Quit: cosimone)
2020-11-19 06:40:45 +0100 <glguy> You can paste your code on a pastebin so that people can see what you've got
2020-11-19 06:40:56 +0100 <n0042> I'll use pastebin real quick to show you what I've got so far. uno momento
2020-11-19 06:41:04 +0100 <glguy> showing code will help us see what you do know how to do
2020-11-19 06:41:52 +0100agrajag`(~agrajag`@84.39.117.57)
2020-11-19 06:43:24 +0100 <dsal> Some confusion seems to be between functions and actions. replicating `getLine` will make a bunch of `getLine` actions, but it won't get lines. There's a path from there, but it's probably not what you want.
2020-11-19 06:43:57 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:6c29:bc9c:b97a:2b45)
2020-11-19 06:44:49 +0100 <zyklotomic> on a seperate thread, i have a question about folds vs monads
2020-11-19 06:44:59 +0100 <zyklotomic> hope you guys don't mind juggling the convo a bit
2020-11-19 06:45:11 +0100 <glguy> go for it
2020-11-19 06:45:29 +0100 <zyklotomic> is there any deeper relationship b/w them? I was reading https://mail.haskell.org/pipermail/beginners/2014-August/013993.html
2020-11-19 06:45:43 +0100 <zyklotomic> as a result of a google search, after noticing that foldl was kinda like State
2020-11-19 06:46:20 +0100 <zyklotomic> then I was writing another function that folded with a monoid (list appending)
2020-11-19 06:46:30 +0100 <glguy> There's not much relating folds to monads
2020-11-19 06:46:31 +0100 <zyklotomic> and it basically was Writer (i think)
2020-11-19 06:46:38 +0100 <zyklotomic> are these just coincidences?
2020-11-19 06:46:56 +0100 <zyklotomic> I should generally prefer using folds right
2020-11-19 06:47:11 +0100 <zyklotomic> I can show an example
2020-11-19 06:47:29 +0100aoei(aoei@2a01:7e01::f03c:92ff:fe4f:e85a) (Quit: ZNC 1.7.5 - https://znc.in)
2020-11-19 06:47:37 +0100 <n0042> https://pastebin.com/zwuqHsSY
2020-11-19 06:47:37 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 06:48:00 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 06:48:02 +0100 <glguy> zyklotomic, foldl is similar to traverse used with State
2020-11-19 06:48:04 +0100 <n0042> Here's sort of what I got so far. It's for an assignment but there's no need to get into the assignment itself. I already have that part figured out. It's just the I/O that's confusing me
2020-11-19 06:48:08 +0100 <glguy> but that's not much about being a monad
2020-11-19 06:48:17 +0100 <zyklotomic> https://paste.debian.net/1173146/
2020-11-19 06:48:32 +0100 <zyklotomic> wait yeah, you're right, I probably shouldn't have jumped to monad
2020-11-19 06:48:35 +0100 <glguy> that's more about foldl being related to State specifically in the context of foldable types
2020-11-19 06:49:44 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 06:49:56 +0100 <glguy> :t \f t -> runState(traverse (state . f) t)
2020-11-19 06:49:57 +0100 <lambdabot> Traversable t => (a -> s -> (b, s)) -> t a -> s -> (t b, s)
2020-11-19 06:50:08 +0100aoei(~aoei@li2174-104.members.linode.com)
2020-11-19 06:50:12 +0100 <glguy> :t foldl
2020-11-19 06:50:13 +0100 <lambdabot> Foldable t => (b -> a -> b) -> b -> t a -> b
2020-11-19 06:50:36 +0100 <glguy> :t scanl
2020-11-19 06:50:38 +0100 <lambdabot> (b -> a -> b) -> b -> [a] -> [b]
2020-11-19 06:50:46 +0100 <glguy> :t mapAccumL
2020-11-19 06:50:47 +0100 <lambdabot> Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
2020-11-19 06:51:01 +0100 <zyklotomic> or actually, I mean, what about Writer and State
2020-11-19 06:51:17 +0100 <zyklotomic> would you like classify them as some kind, or am I looking into this too much
2020-11-19 06:51:27 +0100 <zyklotomic> and it is just a nice coincidenec
2020-11-19 06:51:51 +0100 <zyklotomic> where the behavior is "traversing"
2020-11-19 06:51:52 +0100 <glguy> there's no deep connection that I can think of
2020-11-19 06:52:21 +0100 <zyklotomic> ah fair enough, thanks for entertaining my q
2020-11-19 06:52:43 +0100 <dsal> n0042: what do you want `results` to be?
2020-11-19 06:53:14 +0100 <dsal> From the application, it looks like you want it to be a single string.
2020-11-19 06:54:18 +0100 <n0042> So, results is going to print a line for each "packet" showing the time it was processed or if it was processed. That's all going to be handled by the program logic which i've got covered, and it'll just print off a list of strings. But to get there I need to collect the strings which contain the arrival time and time-to-process for each packet,
2020-11-19 06:54:18 +0100 <n0042> which is the programmatic input part.
2020-11-19 06:54:54 +0100 <dsal> Do you understand what `repeat getLine` means?
2020-11-19 06:55:01 +0100 <dsal> :t repeat getLine
2020-11-19 06:55:04 +0100 <lambdabot> [IO String]
2020-11-19 06:55:35 +0100 <n0042> Yeah it's a list of getLine functions. I was trying to find some way to call getLine a certain amount of times in a row.
2020-11-19 06:55:43 +0100 <n0042> But I'm not sure I'm on the right track
2020-11-19 06:55:50 +0100 <dsal> It's a list of actions that produce strings.
2020-11-19 06:56:31 +0100 <dsal> What type would make more sense here?
2020-11-19 06:57:02 +0100 <dsal> (it's often easier to think about what you want than to struggle with the parts you have)
2020-11-19 06:57:11 +0100 <n0042> Strings themselves, I suppose.
2020-11-19 06:57:33 +0100hidedagger(~nate@unaffiliated/hidedagger) (Quit: WeeChat 2.9)
2020-11-19 06:57:44 +0100 <dsal> What does "Strings themselves" mean?
2020-11-19 06:57:56 +0100 <n0042> The assignment's program flow is: Input buffer size and number of packets -> input line for each packet -> calculate the processing time for each packet or if it was dropped -> output a line for each packet.
2020-11-19 06:58:00 +0100 <dsal> (Haskell is an ideal language to speak here to avoid misunderstanding)
2020-11-19 06:58:08 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 06:58:22 +0100 <n0042> The input/output is pre-determined and I can't change how it works because it's an automated system that collectes from stdin during runtime.
2020-11-19 06:58:38 +0100 <dsal> None of these details are relevant to what you're trying to do.
2020-11-19 06:58:42 +0100 <n0042> We got to choose our language though and I figured it's be a good way to dive in head first with haskell
2020-11-19 06:59:23 +0100 <zyklotomic> i'm saying in case no one pointed out the distinction, `repeat getLine` is returing a list of the actions, but nothing is executing those actions
2020-11-19 06:59:48 +0100 <dsal> But taking a step back and identifying what you actually want might make this easy.
2020-11-19 06:59:52 +0100 <n0042> I know. I'm not sure how to execute those actions once I have them.
2020-11-19 07:00:00 +0100 <zyklotomic> yup that is the crux (i think)
2020-11-19 07:00:10 +0100 <dsal> Stating clearly what you want would speed things up a lot.
2020-11-19 07:00:38 +0100 <n0042> What I want is to get n-lines from stdin, separated by newline characters.
2020-11-19 07:00:58 +0100 <n0042> As [Char] types
2020-11-19 07:01:17 +0100 <n0042> Which I will then parse into [Int] types
2020-11-19 07:01:37 +0100 <dsal> OK, closer... Less English, more Haskell. How would you describe the above in Haskell?
2020-11-19 07:01:44 +0100 <dsal> :t getLine -- e.g.
2020-11-19 07:01:46 +0100 <lambdabot> IO String
2020-11-19 07:01:54 +0100 <n0042> Well, a single line is easy: line <- getLine
2020-11-19 07:01:58 +0100 <dsal> So, `getLine` is `IO String`
2020-11-19 07:02:04 +0100 <dsal> What type are you looking for
2020-11-19 07:02:05 +0100 <dsal> ?
2020-11-19 07:02:06 +0100hidedagger(~nate@unaffiliated/hidedagger) (Client Quit)
2020-11-19 07:02:35 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 07:02:58 +0100 <n0042> String
2020-11-19 07:03:07 +0100 <zyklotomic> bigger
2020-11-19 07:03:20 +0100 <n0042> [String]?
2020-11-19 07:03:21 +0100 <zyklotomic> think a bit higher
2020-11-19 07:03:23 +0100 <zyklotomic> yup
2020-11-19 07:03:37 +0100 <dsal> Closer, but it isn't pure.
2020-11-19 07:03:40 +0100 <dsal> You're doing IO to get there.
2020-11-19 07:03:56 +0100 <n0042> I am intrigued. Tell me more.
2020-11-19 07:04:03 +0100 <dsal> :t getLine
2020-11-19 07:04:04 +0100 <lambdabot> IO String
2020-11-19 07:04:31 +0100 <dsal> That's not a String.
2020-11-19 07:04:37 +0100 <n0042> line <- getLine results in String.
2020-11-19 07:04:49 +0100 <n0042> according to my REPL, the type of line is String after that
2020-11-19 07:05:03 +0100 <dsal> Eh. That's slightly confusing.
2020-11-19 07:05:20 +0100 <n0042> Which is why I thought I might be able to turn [getLine] into [String] somehow
2020-11-19 07:05:34 +0100 <zyklotomic> the <- does some magic lol
2020-11-19 07:05:56 +0100 <dsal> It's also not a complete useful expression. The repl lets you do things that don't fully make sense.
2020-11-19 07:06:08 +0100 <dsal> @undo do { line <- getLine }
2020-11-19 07:06:08 +0100 <lambdabot> <unknown>.hs:1:23:Parse error: Last statement in a do-block must be an expression
2020-11-19 07:06:16 +0100 <dsal> @undo do { line <- getLine; putStrLn line }
2020-11-19 07:06:16 +0100 <lambdabot> getLine >>= \ line -> putStrLn line
2020-11-19 07:07:34 +0100 <dsal> How about this. Let's say you want to create a new thing called `getLines`. What does is its type?
2020-11-19 07:07:40 +0100hidedagger(~nate@unaffiliated/hidedagger) (Quit: WeeChat 2.9)
2020-11-19 07:07:49 +0100 <n0042> :t getLine
2020-11-19 07:07:50 +0100 <lambdabot> IO String
2020-11-19 07:07:57 +0100 <n0042> so... [IO String] ?
2020-11-19 07:08:22 +0100 <LKoen> IO [String] ?
2020-11-19 07:08:26 +0100 <dsal> That's not super useful, though, as you found out, because now instead of having one action, you have a list of actions. What would one action look like?
2020-11-19 07:08:57 +0100xerox_(~xerox@unaffiliated/xerox)
2020-11-19 07:09:48 +0100 <dsal> So, there's a super easy way to go from `[m a]` to `m [a]` but I don't think it's necessarily a good path. It might be more useful for you to consider writing a function that takes the `n` and returns the actual thing you need.
2020-11-19 07:10:24 +0100 <dsal> (which is technical `replicateM`, but you'd get pretty far along if you write this yourself)
2020-11-19 07:10:29 +0100 <n0042> I must admit I'm having a hard time with Haskell's I/O. That is exactly what I'd like to do.
2020-11-19 07:10:54 +0100 <dsal> You're having a hard time because you're trying to use it without understanding it or your goal. :)
2020-11-19 07:10:59 +0100 <n0042> I have really enjoyed using this language for my assignments so far. It's a real pleasure to write and work with.
2020-11-19 07:11:34 +0100borne(~fritjof@200116b864eda200f1dc39039d201adf.dip.versatel-1u1.de)
2020-11-19 07:11:34 +0100 <dsal> It continues to get better as you learn more of it. But some things that you can kind of hand wave will eventually require a bit more understanding. In particular, expressing the type of the thing you want.
2020-11-19 07:12:12 +0100SanchayanM(~Sanchayan@223.226.123.235)
2020-11-19 07:12:57 +0100 <n0042> Well my goal is to take input, calculate some results, and print outputs. The "calculating some results" part is the actual assignment, and I've already worked it out, and was the fun part. The I/O part is throwing me for a loop because it should have been trivial. It's like two different languages when it comes to program logic and I/O
2020-11-19 07:12:59 +0100 <dsal> Also, though it's still partial, I'd write what you have so far something like: `[bufferSize, numPackets] <- map read . words <$> getLine` -- but that's next week's episode.
2020-11-19 07:13:16 +0100SanchayanMaity(~Sanchayan@106.201.35.233) (Ping timeout: 260 seconds)
2020-11-19 07:13:39 +0100 <n0042> I am the sort of person who likes to understand this stuff from first principles where possible. Do you have any good resources for understanding how replicateM works on a more intuitive level? I'd like to learn this.
2020-11-19 07:14:06 +0100 <dsal> Haskell Programming From First Principles will get you there quickly.
2020-11-19 07:14:34 +0100 <dsal> @src replicateM
2020-11-19 07:14:34 +0100 <lambdabot> replicateM n x = sequence (replicate n x)
2020-11-19 07:14:49 +0100 <zyklotomic> the weird part about haskell is, the hard stuff becomes easy and the "easy" stuff becomes hard
2020-11-19 07:14:55 +0100 <zyklotomic> *when you're first learning it
2020-11-19 07:15:13 +0100 <zyklotomic> like IO basically
2020-11-19 07:15:22 +0100 <dsal> I'd by that with the addendum. After a while, most things are easy.
2020-11-19 07:15:51 +0100lukelau_(~lukelau@46.101.13.214) (Quit: Bye)
2020-11-19 07:16:05 +0100 <n0042> I recently joined a study group for that book, but we haven't started yet.
2020-11-19 07:16:05 +0100 <zyklotomic> but i'm sure the fun never gets old
2020-11-19 07:16:07 +0100lukelau(~lukelau@46.101.13.214)
2020-11-19 07:16:25 +0100 <n0042> It really is a fun language. The list comprehensions are my favorite in any language I've used so far.
2020-11-19 07:16:49 +0100 <dsal> I generally recommend that book. It's a slow path, which I think will get you somewhere useful the fastest.
2020-11-19 07:17:19 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl)
2020-11-19 07:17:46 +0100darjeeling_(~darjeelin@122.245.211.11)
2020-11-19 07:17:46 +0100 <zyklotomic> list comprehensions are cool indeed
2020-11-19 07:18:07 +0100 <dsal> I somehow don't use list comprehensions that much in haskell.
2020-11-19 07:18:28 +0100 <zyklotomic> I use them in ghci most often tbh
2020-11-19 07:18:31 +0100 <dsal> I often forget they exist. heh.
2020-11-19 07:18:35 +0100 <n0042> So far everything I've written has been a mixture of list comprehensions and the recursive-go pattern.
2020-11-19 07:18:42 +0100 <n0042> But I'm still doing pretty basic stuff
2020-11-19 07:18:52 +0100 <zyklotomic> when I switched to Linux from a Mac, ghci replaced the Spotlight calculator if you know what spotlight is
2020-11-19 07:18:59 +0100 <n0042> recursive-go makes my inner LISP programmer happy
2020-11-19 07:19:07 +0100 <zyklotomic> basically just quickfire calculator that you can type some math into
2020-11-19 07:19:07 +0100 <dsal> what's recursive-go?
2020-11-19 07:19:52 +0100 <n0042> Where you wrap a function in a "go" function scoped in a "where" statement that requires parameters that don't make sense to call outside the function. Usually to do something in a list-processing kind of way
2020-11-19 07:20:08 +0100 <dsal> Oh. Just recursion. :)
2020-11-19 07:20:36 +0100 <zyklotomic> I've been struggling to know what to call that practice lol
2020-11-19 07:20:36 +0100 <dsal> Usually there's a higher level abstraction that does the thing already
2020-11-19 07:20:42 +0100 <n0042> Yes, but in Scheme or something you'd have to wrap it in a macro to make it look decent.
2020-11-19 07:20:57 +0100 <zyklotomic> some things are just kinda un-pronuncable in Haskell lol
2020-11-19 07:21:10 +0100 <zyklotomic> like all the weird operators and when someone decides to roll their own custom operator too
2020-11-19 07:21:42 +0100 <dsal> > maximumOf (folded . _Right) [Left 1, Right 2, Left 3, Right 4, Left 5, Right 3]
2020-11-19 07:21:44 +0100 <lambdabot> Just 4
2020-11-19 07:22:35 +0100 <dsal> Operators are just functions. The really common ones have fairly common names. Or we just don't say them much.
2020-11-19 07:23:58 +0100 <n0042> I am still trying to wrap my head around some of them. You used two I'm unfamiliar with in that snippet you posted: (.) and <$>
2020-11-19 07:24:07 +0100 <dsal> > sum (digitToInt <$> "123")
2020-11-19 07:24:09 +0100 <lambdabot> 6
2020-11-19 07:24:16 +0100alp(~alp@2a01:e0a:58b:4920:d4c7:761f:e715:72ea)
2020-11-19 07:24:17 +0100 <dsal> . and $ are *super* common
2020-11-19 07:24:22 +0100 <dsal> :t (.)
2020-11-19 07:24:24 +0100 <lambdabot> (b -> c) -> (a -> b) -> a -> c
2020-11-19 07:24:25 +0100 <zyklotomic> with time
2020-11-19 07:24:25 +0100 <dsal> :t ($)
2020-11-19 07:24:27 +0100 <lambdabot> (a -> b) -> a -> b
2020-11-19 07:24:41 +0100codeAlways(uid272474@gateway/web/irccloud.com/x-rnqcrwigssxuyxdw)
2020-11-19 07:24:42 +0100 <dsal> . is just how you compose functions.
2020-11-19 07:24:50 +0100 <dsal> @src (.)
2020-11-19 07:24:50 +0100 <lambdabot> (f . g) x = f (g x)
2020-11-19 07:24:56 +0100 <zyklotomic> <$> is fmap
2020-11-19 07:24:58 +0100 <dsal> That's it.
2020-11-19 07:25:05 +0100 <n0042> Oh
2020-11-19 07:25:06 +0100 <zyklotomic> it is like a generlaized map
2020-11-19 07:25:22 +0100 <dsal> IMO, map shouldn't exist, but at least a few people think it's not bad.
2020-11-19 07:25:35 +0100 <dsal> > fmap (+1) [1..5]
2020-11-19 07:25:37 +0100 <lambdabot> [2,3,4,5,6]
2020-11-19 07:25:42 +0100 <dsal> > (+1) <$> [1..5]
2020-11-19 07:25:44 +0100 <lambdabot> [2,3,4,5,6]
2020-11-19 07:25:48 +0100 <n0042> ($) I have used plenty to get rid of parentheses, but <$> was a new one. That's pretty sweet
2020-11-19 07:26:07 +0100 <dsal> $ should be used sparingly. :)
2020-11-19 07:26:13 +0100 <dsal> :t ($)
2020-11-19 07:26:14 +0100 <lambdabot> (a -> b) -> a -> b
2020-11-19 07:26:16 +0100 <dsal> :t (<$>)
2020-11-19 07:26:18 +0100 <lambdabot> Functor f => (a -> b) -> f a -> f b
2020-11-19 07:26:20 +0100 <zyklotomic> dsal: I find myself using fmap on lists unconsciously, cause you type that before the list and you don't register that you're getting a list mentally yet
2020-11-19 07:26:38 +0100 <n0042> <$> is just infix fmap... got it.. that's pretty neat
2020-11-19 07:26:43 +0100 <zyklotomic> yup
2020-11-19 07:26:48 +0100 <dsal> @src (<$>)
2020-11-19 07:26:48 +0100 <lambdabot> f <$> a = fmap f a
2020-11-19 07:27:16 +0100 <zyklotomic> but I'm guessing it's existence is legacy cruft
2020-11-19 07:27:17 +0100 <n0042> And you said ($) should be used sparingly? I have been using it willy-nilly on the assumption that people don't like parentheses as much as I do. What's the general guideline there?
2020-11-19 07:27:32 +0100 <dsal> If you're composing functions, use .
2020-11-19 07:27:53 +0100 <zyklotomic> when would you say it's acceptable to use $
2020-11-19 07:28:05 +0100 <dsal> At the end of a bunch of .s :)
2020-11-19 07:28:27 +0100 <n0042> take 5 $ repeat 10
2020-11-19 07:28:31 +0100 <n0042> or something like that
2020-11-19 07:28:38 +0100 <n0042> to avoid take 5 (repeat 10) ?
2020-11-19 07:28:43 +0100 <dsal> > replicate 5 10
2020-11-19 07:28:45 +0100 <lambdabot> [10,10,10,10,10]
2020-11-19 07:29:02 +0100 <dsal> : take 5 . repeat
2020-11-19 07:29:07 +0100 <dsal> :t take 5 . repeat
2020-11-19 07:29:08 +0100 <zyklotomic> (take 5 . repeat) 10 hon oh you beat me to it
2020-11-19 07:29:09 +0100 <lambdabot> a -> [a]
2020-11-19 07:29:27 +0100 <zyklotomic> but it's not that much cleaner i'm gonna oh, wait ig you can put a $ instead of the paren
2020-11-19 07:29:40 +0100 <dsal> > take 5 . repeat $ 10
2020-11-19 07:29:42 +0100 <zyklotomic> i'm clearly not a very good user of $ lol
2020-11-19 07:29:42 +0100 <lambdabot> [10,10,10,10,10]
2020-11-19 07:29:55 +0100 <n0042> Oh nice
2020-11-19 07:29:55 +0100 <dsal> Save yo #
2020-11-19 07:29:57 +0100 <dsal> Save yo $
2020-11-19 07:29:58 +0100 <dsal> damnit
2020-11-19 07:30:12 +0100 <n0042> Okay I see how (.) works now
2020-11-19 07:30:21 +0100 <zyklotomic> i'm going to go out on a limb though and say that sometimes
2020-11-19 07:30:30 +0100 <zyklotomic> take 5 $ repeat 10 is just easier to read
2020-11-19 07:30:50 +0100 <zyklotomic> or my brain hasn't been molded enough
2020-11-19 07:31:21 +0100 <dsal> > let f = show . sum . take 5 . repeat in f 10
2020-11-19 07:31:23 +0100 <lambdabot> "50"
2020-11-19 07:32:36 +0100 <n0042> For something a little different, do any of you know if it's true that last is an O(n) function? Like, if you wanted to use a list as a Queue, would it really be O(n) to call last to dequeue?
2020-11-19 07:32:46 +0100 <dsal> > let f = nub . sort show . sum . take 11 . repeat in f 13
2020-11-19 07:32:48 +0100 <lambdabot> error:
2020-11-19 07:32:48 +0100 <lambdabot> • Couldn't match expected type ‘b -> [a2]’ with actual type ‘[a0]’
2020-11-19 07:32:48 +0100 <lambdabot> • Possible cause: ‘sort’ is applied to too many arguments
2020-11-19 07:32:51 +0100 <dsal> stupid keyboard
2020-11-19 07:32:54 +0100 <dsal> > let f = nub . sort . show . sum . take 11 . repeat in f 13
2020-11-19 07:32:57 +0100 <lambdabot> "134"
2020-11-19 07:32:58 +0100 <n0042> I sort of assumed that the built-in list object would have a tail pointer, but hoogle says that's O(n)
2020-11-19 07:33:17 +0100 <dsal> @src (:)
2020-11-19 07:33:17 +0100 <lambdabot> Source not found. Listen, broccoli brains, I don't have time to listen to this trash.
2020-11-19 07:33:20 +0100 <dsal> boooo
2020-11-19 07:33:26 +0100 <dsal> a list is just a head and a tail.
2020-11-19 07:33:29 +0100 <n0042> Whoah that bot has atittude
2020-11-19 07:34:02 +0100 <dsal> It's a cons list. You said you're familiar with lisp.
2020-11-19 07:34:14 +0100 <n0042> Right, a singly-linked list with a head pointer
2020-11-19 07:34:46 +0100 <n0042> So to get the last element you would have to traverse all the way down the list, hence O(n).
2020-11-19 07:34:48 +0100Stanley00(~stanley00@unaffiliated/stanley00) (Remote host closed the connection)
2020-11-19 07:35:21 +0100 <n0042> But there's no reason you couldn't have the low-level logic include a tail pointer so that last is O(1).
2020-11-19 07:35:26 +0100 <dsal> Lists are great, but if you need other performance characteristics, there are better data structures.
2020-11-19 07:35:37 +0100 <dsal> There are many, many reasons you can't do that.
2020-11-19 07:35:42 +0100 <dsal> But if you disagree, write one.
2020-11-19 07:35:56 +0100 <dsal> Haskell has very little magic. You can write most of what you see.
2020-11-19 07:36:12 +0100 <dsal> Even many of the super fancy compiler optimizations are library-definable.
2020-11-19 07:37:04 +0100 <n0042> My plan was to use Data.Array but that seems kind of un-functional. What would you suggest?
2020-11-19 07:37:10 +0100mceier(~mceier@89-68-132-187.dynamic.chello.pl) (Ping timeout: 268 seconds)
2020-11-19 07:37:12 +0100 <dsal> Vector?
2020-11-19 07:37:16 +0100 <dsal> Seq?
2020-11-19 07:37:17 +0100Stanley00(~stanley00@unaffiliated/stanley00)
2020-11-19 07:37:18 +0100 <MarcelineVQ> for what?
2020-11-19 07:37:28 +0100 <n0042> To simulate a Queue, or circular buffer
2020-11-19 07:38:03 +0100 <dsal> Lists are fine for many of these things, but there are specific structures.
2020-11-19 07:40:45 +0100 <zyklotomic> is it a bad practice to append to the front of a list instead tehn
2020-11-19 07:40:50 +0100 <zyklotomic> to get around the time complexity of ++
2020-11-19 07:40:56 +0100 <dsal> It's the best.
2020-11-19 07:41:01 +0100 <n0042> Seems like the opposite. Bad practice to append to the rear
2020-11-19 07:41:04 +0100 <dsal> No better place to put something.
2020-11-19 07:41:13 +0100 <dsal> ++ is another one of those language warts.
2020-11-19 07:41:21 +0100 <MarcelineVQ> lists make pretty good queues in haskell https://rafal.io/posts/haskell-queues.html
2020-11-19 07:41:55 +0100 <zyklotomic> dsal: so lists make a pretty bad monoid?
2020-11-19 07:41:58 +0100 <MarcelineVQ> This doesn't explain super in depth, but the idea is to use two lists with one in reverse to create your queue
2020-11-19 07:42:15 +0100 <dsal> zyklotomic: ++ vs. <>
2020-11-19 07:42:19 +0100 <n0042> Thank you very much
2020-11-19 07:42:22 +0100 <dsal> lists are fine for what they do
2020-11-19 07:42:23 +0100mceier(~mceier@89-68-132-187.dynamic.chello.pl)
2020-11-19 07:42:47 +0100shangxiao(~davids@101.181.159.140)
2020-11-19 07:43:21 +0100 <MarcelineVQ> There's a lot of queue-like things around though so you'd probably just want to use whatever and optommize later, Seq that dsal mentioned is a fair all-around option for accessing either end of.
2020-11-19 07:44:02 +0100 <n0042> Oh wow, Haskell has built-ins for everything
2020-11-19 07:44:12 +0100 <dsal> built-in?
2020-11-19 07:44:52 +0100 <n0042> Stuff you don't have to roll on your own.
2020-11-19 07:45:02 +0100 <MarcelineVQ> dsal: people who don't already know don't know what you mean when you say you don't like map and ++. They won't realize you mean you don't like that there's both fmap and map and just want one, or relatedly that ++ and <> are the same for lists so just <> is fine
2020-11-19 07:45:12 +0100 <dsal> Oh. Not built-in, just already implemented..
2020-11-19 07:45:22 +0100 <n0042> Yes, thank you
2020-11-19 07:45:35 +0100Stanley|00(~stanley00@unaffiliated/stanley00)
2020-11-19 07:45:46 +0100 <dsal> MarcelineVQ: that's true. People should understand me better. heh
2020-11-19 07:46:02 +0100 <n0042> You've both been very helpful, thank you.
2020-11-19 07:46:24 +0100jlamothe(~jlamothe@198.251.55.207) (Ping timeout: 260 seconds)
2020-11-19 07:46:48 +0100 <dsal> The functional data structure stuff is amazing. That queue thing was amazing to see.
2020-11-19 07:47:34 +0100 <zyklotomic> MarcelineVQ: wait, I don't think ++ and <> are the same
2020-11-19 07:47:41 +0100 <dsal> :t (++)
2020-11-19 07:47:42 +0100 <lambdabot> [a] -> [a] -> [a]
2020-11-19 07:47:44 +0100 <dsal> :t (<>)
2020-11-19 07:47:45 +0100 <lambdabot> Semigroup a => a -> a -> a
2020-11-19 07:47:49 +0100 <MarcelineVQ> The okasaki paper is a bit of a hard read if you're new to it all but it's pretty great, interesting how little progress there's been since it at as well
2020-11-19 07:47:51 +0100 <zyklotomic> which was what dsal meant
2020-11-19 07:48:10 +0100 <dsal> ++ doesn't need to exist in Haskell. Or, perhaps, <> should be ++
2020-11-19 07:48:17 +0100 <dsal> Same as map vs. fmap
2020-11-19 07:48:56 +0100Stanley00(~stanley00@unaffiliated/stanley00) (Ping timeout: 240 seconds)
2020-11-19 07:49:04 +0100 <MarcelineVQ> Where your Semigroup is [a] then <> = ++
2020-11-19 07:49:33 +0100 <zyklotomic> <> should be ++ i think
2020-11-19 07:49:43 +0100 <zyklotomic> ++ looks more natural
2020-11-19 07:50:02 +0100 <zyklotomic> idk about fmap vs map though if you had to pick one of the two
2020-11-19 07:50:15 +0100Stanley|00(~stanley00@unaffiliated/stanley00) (Remote host closed the connection)
2020-11-19 07:50:30 +0100 <dsal> Sure. It's just one of those things that is too much legacy code.
2020-11-19 07:50:31 +0100 <zyklotomic> MarcelineVQ: I meant the implementation, I'm not sure if they behave the same
2020-11-19 07:50:40 +0100 <zyklotomic> I get that they're isomorphic
2020-11-19 07:50:50 +0100Stanley00(~stanley00@unaffiliated/stanley00)
2020-11-19 07:50:53 +0100 <dsal> How could they behave differently?
2020-11-19 07:50:53 +0100 <zyklotomic> mconcat xss = [x | xs <- xss, x <- xs]
2020-11-19 07:51:05 +0100 <zyklotomic> (++) [] ys = ys
2020-11-19 07:51:07 +0100 <zyklotomic> (++) (x:xs) ys = x : xs ++ ys
2020-11-19 07:51:19 +0100 <dsal> @quick \l1 l2 -> (l1 ++ l2) === (l1 <> l2)
2020-11-19 07:51:19 +0100 <lambdabot> Not enough privileges
2020-11-19 07:51:31 +0100 <dsal> @check \l1 l2 -> (l1 ++ l2) === (l1 <> l2)
2020-11-19 07:51:33 +0100 <lambdabot> +++ OK, passed 100 tests.
2020-11-19 07:51:33 +0100 <MarcelineVQ> That is the implementation :> http://hackage.haskell.org/package/base-4.14.0.0/docs/src/GHC.Base.html#line-306
2020-11-19 07:52:00 +0100 <zyklotomic> my bad im barking up the wrong tree
2020-11-19 07:52:12 +0100 <zyklotomic> I looked into Data.Monoid
2020-11-19 07:53:48 +0100 <zyklotomic> wait so that wasnt disagreeing with lists being a somewhat inefficient monoid then
2020-11-19 07:54:05 +0100 <n0042> So when I asked about lists with tail-pointers dsal said "There are many, many reasons you can't do that." I have implemented a few linked lists in C and I've done some LISPing, but I'm far from an expert. I would be interested in hearing some of those reasons. Is it a performance thing, from the days of yore? Thanks again for answering my
2020-11-19 07:54:05 +0100 <n0042> questions. You folks are all very helpful.
2020-11-19 07:54:57 +0100 <n0042> I've learned more just hanging out in here for an hour than in the last two days combined. You guys are great.
2020-11-19 07:55:37 +0100 <glguy> n0042, the issue is that things aren't mutable, so you can't use a reference to the last element to add to the end of a list
2020-11-19 07:56:04 +0100 <glguy> Unless you build a mutable structure explicitly with mutable references that's accessed using IO actions
2020-11-19 07:56:27 +0100mananamenos(~mananamen@84.122.202.215.dyn.user.ono.com)
2020-11-19 07:56:56 +0100bliminse(~bliminse@host109-156-197-211.range109-156.btcentralplus.com) (Ping timeout: 240 seconds)
2020-11-19 07:57:25 +0100 <zyklotomic> I was also thinking, what about [1..]
2020-11-19 07:58:00 +0100zebrag(~inkbottle@aaubervilliers-654-1-104-55.w86-212.abo.wanadoo.fr) (Quit: Konversation terminated!)
2020-11-19 07:58:02 +0100borne(~fritjof@200116b864eda200f1dc39039d201adf.dip.versatel-1u1.de) (Ping timeout: 260 seconds)
2020-11-19 07:58:04 +0100 <dsal> let a = 1:a in take 5 a
2020-11-19 07:58:09 +0100bliminse(~bliminse@host109-156-197-211.range109-156.btcentralplus.com)
2020-11-19 07:58:10 +0100 <dsal> > let a = 1:a in take 5 a
2020-11-19 07:58:12 +0100 <lambdabot> [1,1,1,1,1]
2020-11-19 07:59:17 +0100 <dsal> > let a = 'x':a in length a
2020-11-19 07:59:24 +0100 <lambdabot> mueval: ExitFailure 1
2020-11-19 07:59:29 +0100 <dsal> boo. Too many exes.
2020-11-19 07:59:44 +0100Stanley00(~stanley00@unaffiliated/stanley00) (Remote host closed the connection)
2020-11-19 08:00:10 +0100 <MarcelineVQ> how many, would you say?
2020-11-19 08:00:11 +0100 <dsal> n0042: A lot of these questions get a lot easier when you try to do the thing you think is probably easy. :)
2020-11-19 08:00:27 +0100alp(~alp@2a01:e0a:58b:4920:d4c7:761f:e715:72ea) (Ping timeout: 272 seconds)
2020-11-19 08:01:13 +0100 <n0042> That's good advice in general, for sure
2020-11-19 08:01:24 +0100 <dsal> > let a = 'x':a in take 5 (a <> "and then y")
2020-11-19 08:01:26 +0100 <lambdabot> "xxxxx"
2020-11-19 08:02:10 +0100Stanley00(~stanley00@unaffiliated/stanley00)
2020-11-19 08:02:18 +0100 <dsal> I just made a list of infinite length and appended a list to the end of it. Please adjust pointers accordingly. :)
2020-11-19 08:06:59 +0100idhugo(~idhugo@80-62-116-101-mobile.dk.customer.tdc.net)
2020-11-19 08:07:11 +0100Gurkenglas(~Gurkengla@unaffiliated/gurkenglas)
2020-11-19 08:08:02 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:6c29:bc9c:b97a:2b45) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-19 08:08:17 +0100 <n0042> Is the `<> "and then y"` part ever evaluated?
2020-11-19 08:09:02 +0100actuallybatman(~sam@S010664777dafd303.cg.shawcable.net)
2020-11-19 08:09:06 +0100 <n0042> lazy evaluation is pretty wild. I'm still trying to wrap my head around that part.
2020-11-19 08:09:34 +0100solonarv(~solonarv@astrasbourg-653-1-156-4.w90-6.abo.wanadoo.fr)
2020-11-19 08:09:54 +0100LKoen(~LKoen@169.244.88.92.rev.sfr.net) (Remote host closed the connection)
2020-11-19 08:10:59 +0100 <ClaudiusMaximus> n0042: it's evaluated, just enough to push it down 5 cells: (x : xs) <> ys = x : (xs <> ys) happens 5 times during the evaluation of the result, after which take drops it
2020-11-19 08:13:27 +0100zyklotomic(~ethan@unaffiliated/chocopuff) (Quit: WeeChat 2.9)
2020-11-19 08:14:52 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2020-11-19 08:15:04 +0100idhugo(~idhugo@80-62-116-101-mobile.dk.customer.tdc.net) (Quit: Leaving)
2020-11-19 08:15:40 +0100 <n0042> Yeah, I have no idea how you'd do the pointers for that. That's a mind-bender.
2020-11-19 08:16:10 +0100 <dsal> It's really easy to follow if you don't try to think about how you'd write it as a singly linked list in C.
2020-11-19 08:16:32 +0100 <n0042> Conditioning is hard to break '=D
2020-11-19 08:16:44 +0100 <n0042> But thank you for bearing with me. I really appreciate it
2020-11-19 08:17:10 +0100 <dsal> What is `a`? It's a list where the head is 'x' and the tail is some other stuff. If you only need the head, you're done. If you need the tail, you look at that. Oh, it's `a, that's a list where...
2020-11-19 08:18:39 +0100alx741(~alx741@181.196.68.148) (Ping timeout: 265 seconds)
2020-11-19 08:19:03 +0100Amras(~Amras@unaffiliated/amras0000)
2020-11-19 08:21:16 +0100chaosmasttter(~chaosmast@p200300c4a70b2a01441f1455f36b3658.dip0.t-ipconnect.de)
2020-11-19 08:21:33 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2020-11-19 08:23:51 +0100sfvm(~sfvm@37.228.215.148) (Remote host closed the connection)
2020-11-19 08:25:08 +0100p8m_(p8m@gateway/vpn/protonvpn/p8m)
2020-11-19 08:26:32 +0100p8m(p8m@gateway/vpn/protonvpn/p8m) (Ping timeout: 272 seconds)
2020-11-19 08:27:41 +0100 <n0042> If I replace `take 5` with `tail` that sequence generates `x`s forever. That is wild.
2020-11-19 08:30:50 +0100acidjnk_new(~acidjnk@p200300d0c719ff57608036dc958592ad.dip0.t-ipconnect.de)
2020-11-19 08:31:16 +0100alx741(~alx741@181.196.68.156)
2020-11-19 08:32:21 +0100dan64-(~dan64@dannyadam.com)
2020-11-19 08:32:52 +0100 <dsal> @src tail
2020-11-19 08:32:52 +0100 <lambdabot> tail (_:xs) = xs
2020-11-19 08:32:52 +0100 <lambdabot> tail [] = error "Prelude.tail: empty list"
2020-11-19 08:34:49 +0100dan64(~dan64@dannyadam.com) (Ping timeout: 256 seconds)
2020-11-19 08:34:59 +0100 <dsal> :t tail . tail . tail
2020-11-19 08:35:01 +0100 <lambdabot> [a] -> [a]
2020-11-19 08:35:16 +0100dhouthoo(~dhouthoo@ptr-eiv6509pb4ifhdr9lsd.18120a2.ip6.access.telenet.be)
2020-11-19 08:35:47 +0100 <dsal> Or you could `drop ∞` and get to that appended bit.
2020-11-19 08:36:01 +0100 <dsal> @src drop
2020-11-19 08:36:01 +0100 <lambdabot> drop n xs | n <= 0 = xs
2020-11-19 08:36:01 +0100 <lambdabot> drop _ [] = []
2020-11-19 08:36:01 +0100 <lambdabot> drop n (_:xs) = drop (n-1) xs
2020-11-19 08:36:13 +0100 <dsal> drop isn't partial.
2020-11-19 08:36:26 +0100 <dsal> I wonder why `tail` isn't `drop 1`
2020-11-19 08:36:41 +0100 <dsal> @check \l -> tail l === drop 1 l
2020-11-19 08:36:43 +0100 <lambdabot> *Exception: Prelude.tail: empty list
2020-11-19 08:36:55 +0100 <dsal> 👍
2020-11-19 08:37:11 +0100 <n0042> That's what I was trying to do. I was trying to see what I could put in there to get to the appended part
2020-11-19 08:37:12 +0100 <dsal> Partial functions aren't awesome.
2020-11-19 08:37:33 +0100 <dsal> It's an infinitely long list, do you'd have to drop infinite items first.
2020-11-19 08:39:47 +0100 <n0042> I was trying to get a better grip on the "let" and "in" syntax earlier today, and that was a pretty useful practical example. Thank you.
2020-11-19 08:42:11 +0100SourOatMilk(SourOatMil@gateway/vpn/protonvpn/souroatmilk)
2020-11-19 08:42:12 +0100 <dsal> This is one of the things I like about the book mentioned earlier. If you think about eager evaluation in C or something, you'll find haskell confusing. If you stop pretending you know things, it'll make a lot more sense.
2020-11-19 08:42:25 +0100Sgeo(~Sgeo@ool-18b982ad.dyn.optonline.net) (Read error: Connection reset by peer)
2020-11-19 08:42:59 +0100 <dsal> (also worth noting that list isn't mentioned for like, several chapters, and you make it yourself)
2020-11-19 08:43:03 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh)
2020-11-19 08:44:23 +0100 <n0042> That sounds pretty intense
2020-11-19 08:44:29 +0100 <n0042> I'll check it out for sure
2020-11-19 08:44:33 +0100 <dsal> No, there's nothing very special about it.
2020-11-19 08:44:54 +0100 <dsal> There are three or four books you can read and end up finding haskell is actually pretty boring and doesn't have a lot of magic.
2020-11-19 08:45:14 +0100 <dsal> It's just that most other languages are worse and don't give the user much power or ability to generalize things.
2020-11-19 08:46:14 +0100 <dsal> @let data MyList a = Item a | EOL deriving Show
2020-11-19 08:46:16 +0100 <lambdabot> .L.hs:162:1: error:
2020-11-19 08:46:16 +0100 <lambdabot> Multiple declarations of ‘MyList’
2020-11-19 08:46:16 +0100 <lambdabot> Declared at: .L.hs:158:1
2020-11-19 08:46:31 +0100Flonk(~Flonk@ec2-52-40-29-25.us-west-2.compute.amazonaws.com) (Ping timeout: 246 seconds)
2020-11-19 08:46:34 +0100 <n0042> The things that I really like about it so far are the amazing REPL, the list comprehensions, and recursion-friendly syntax. It's just really easy to write most things I want to write. Except I/O, but I'll get there.
2020-11-19 08:46:39 +0100 <dsal> Er. Ignore the error. That's basically List, plus a few other things (and a slightly fancier Show)
2020-11-19 08:46:48 +0100 <dibblego> Maybe
2020-11-19 08:47:13 +0100 <dsal> er, I messed that up anyway
2020-11-19 08:47:38 +0100bob_twinkles(~quassel@ec2-52-37-66-13.us-west-2.compute.amazonaws.com) (Quit: No Ping reply in 180 seconds.)
2020-11-19 08:47:53 +0100bob_twinkles(~quassel@ec2-52-37-66-13.us-west-2.compute.amazonaws.com)
2020-11-19 08:48:03 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh) (Ping timeout: 240 seconds)
2020-11-19 08:48:28 +0100 <dsal> @let data MyList a = Item a (MyList a) | EOL deriving Show
2020-11-19 08:48:29 +0100 <lambdabot> Defined.
2020-11-19 08:48:30 +0100Flonk(~Flonk@ec2-52-40-29-25.us-west-2.compute.amazonaws.com)
2020-11-19 08:48:50 +0100clog(~nef@bespin.org) (Ping timeout: 256 seconds)
2020-11-19 08:49:05 +0100 <dsal> > let a = Item 'x' a in a
2020-11-19 08:49:07 +0100 <lambdabot> Item 'x' (Item 'x' (Item 'x' (Item 'x' (Item 'x' (Item 'x' (Item 'x' (Item '...
2020-11-19 08:49:44 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh)
2020-11-19 08:51:13 +0100 <dsal> > let mytake _ EOL = EOL; mytake 0 _ = EOL; mytake n (Item x l) = Item x (mytake (n-1) l); a = Item 'x' a in mytake 3 a
2020-11-19 08:51:15 +0100 <lambdabot> Item 'x' (Item 'x' (Item 'x' EOL))
2020-11-19 08:51:18 +0100jedws(~jedws@101.184.150.93) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-19 08:51:57 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2020-11-19 08:55:29 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl)
2020-11-19 08:58:33 +0100coco(~coco@212-51-146-87.fiber7.init7.net)
2020-11-19 08:58:40 +0100 <dsal> @let instance Foldable MyList where foldMap _ EOL = mempty; foldMap f (Item a l) = f a <> foldMap f l
2020-11-19 08:58:41 +0100 <lambdabot> Defined.
2020-11-19 08:58:55 +0100 <dsal> > toList (Item 1 (Item 2 (Item 3 EOL)))
2020-11-19 08:58:57 +0100 <lambdabot> error:
2020-11-19 08:58:57 +0100 <lambdabot> Ambiguous occurrence ‘toList’
2020-11-19 08:58:57 +0100 <lambdabot> It could refer to
2020-11-19 08:59:05 +0100 <dsal> > sum (Item 1 (Item 2 (Item 3 EOL)))
2020-11-19 08:59:08 +0100 <lambdabot> 6
2020-11-19 08:59:11 +0100 <dsal> woo
2020-11-19 08:59:20 +0100kritzefitz(~kritzefit@fw-front.credativ.com)
2020-11-19 08:59:22 +0100 <n0042> nice
2020-11-19 08:59:42 +0100SourOatMilk(SourOatMil@gateway/vpn/protonvpn/souroatmilk) (Quit: leaving)
2020-11-19 09:00:02 +0100 <dsal> :t fmap
2020-11-19 09:00:06 +0100 <lambdabot> Functor f => (a -> b) -> f a -> f b
2020-11-19 09:01:15 +0100 <dsal> @let instance Functor MyList where fmap _ EOL = EOL; fmap f (Item x l) = Item (f x) (fmap f l)
2020-11-19 09:01:17 +0100 <lambdabot> Defined.
2020-11-19 09:01:42 +0100 <dsal> > (2 ^) <$> Item 1 (Item 2 (Item 3 EOL))
2020-11-19 09:01:44 +0100 <lambdabot> Item 2 (Item 4 (Item 8 EOL))
2020-11-19 09:03:40 +0100 <dsal> Throw in monoid, monad, applicative, and probably a few other things and that's basically list.
2020-11-19 09:06:20 +0100chele(~chele@ip5b416ea2.dynamic.kabel-deutschland.de)
2020-11-19 09:07:10 +0100cfricke(~cfricke@unaffiliated/cfricke)
2020-11-19 09:09:08 +0100 <n0042> From the POV of someone who's still pretty new to the language, that's impressive stuff.
2020-11-19 09:15:07 +0100jedws(~jedws@101.184.150.93)
2020-11-19 09:16:26 +0100 <dsal> n0042: It gets cooler. e.g.
2020-11-19 09:16:44 +0100 <dsal> % [1, 2, 3] :: MyList Int
2020-11-19 09:16:44 +0100 <yahb> dsal: Item 1 (Item 2 (Item 3 EOL))
2020-11-19 09:16:47 +0100LKoen(~LKoen@169.244.88.92.rev.sfr.net)
2020-11-19 09:16:59 +0100 <dsal> I taught yahb how to understand my list from normal list syntax.
2020-11-19 09:17:26 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-19 09:17:35 +0100 <dsal> % sum ([1..100] :: MyList Int)
2020-11-19 09:17:36 +0100 <yahb> dsal: ; <interactive>:1:18: error:; Not in scope: type constructor or class `MyList'; Perhaps you meant one of these: `IsList' (imported from GHC.Exts), `TyLit' (imported from Language.Haskell.TH)
2020-11-19 09:17:46 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Client Quit)
2020-11-19 09:17:47 +0100keep_learning(~keep_lear@43.231.26.152) (Quit: Leaving)
2020-11-19 09:18:13 +0100 <dsal> Someone else taught it how to not know that, apparently. heh
2020-11-19 09:19:53 +0100 <dsal> n0042: Anyway, I should've gone to bed a while ago. The main point is that haskell doesn't reserve a lot of magic for the ivory tower. If you see something that looks magical, you can often implement it yourself from scratch.
2020-11-19 09:20:04 +0100alp(~alp@2a01:e0a:58b:4920:6cd6:5f96:4d6d:5a5)
2020-11-19 09:20:33 +0100 <n0042> That's good to know! Thanks for all the help. I am planning on going through that book with a study group, so I'm looking forward to it.
2020-11-19 09:20:44 +0100 <n0042> Have a good night and thanks again
2020-11-19 09:20:58 +0100 <dsal> (e.g., I could've made a Show instance that displayed my list exactly as regular list does, making it look and and act just like the list you already know)
2020-11-19 09:21:48 +0100 <dsal> It's like learning Santa Claus isn't real. All this wonderful magic is suddenly boring, but then you get to be Santa Claus, so that's nice.
2020-11-19 09:21:50 +0100 <dsal> 'night. :)
2020-11-19 09:24:28 +0100Franciman(~francesco@host-82-56-223-169.retail.telecomitalia.it)
2020-11-19 09:29:06 +0100n0042(d055ed89@208.85.237.137) ()
2020-11-19 09:31:09 +0100thc202(~thc202@unaffiliated/thc202)
2020-11-19 09:34:35 +0100frogger(d055ed89@208.85.237.137)
2020-11-19 09:35:16 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de)
2020-11-19 09:36:24 +0100ph88^(~ph88@2a02:8109:9e00:7e5c:f073:c081:c2ef:433b)
2020-11-19 09:40:31 +0100ph88(~ph88@2a02:8109:9e00:7e5c:a963:461:83fa:2c4) (Ping timeout: 272 seconds)
2020-11-19 09:45:18 +0100jedws(~jedws@101.184.150.93) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-19 09:45:38 +0100borne(~fritjof@200116b864eda200f1dc39039d201adf.dip.versatel-1u1.de)
2020-11-19 09:46:09 +0100frogger(d055ed89@208.85.237.137) (Remote host closed the connection)
2020-11-19 09:46:54 +0100danvet(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa)
2020-11-19 09:48:06 +0100n0042(d055ed89@208.85.237.137)
2020-11-19 09:48:30 +0100hackagemu-rpc 0.4.0.1 - Protocol-independent declaration of services and servers. https://hackage.haskell.org/package/mu-rpc-0.4.0.1 (AlejandroSerrano)
2020-11-19 09:49:25 +0100cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2020-11-19 09:50:47 +0100danvet_(~danvet@2a02:168:57f4:0:5f80:650d:c6e6:3453)
2020-11-19 09:51:25 +0100Boomerang(~Boomerang@xd520f68c.cust.hiper.dk)
2020-11-19 09:51:52 +0100 <unclechu> glguy: no i am around, why?
2020-11-19 09:53:07 +0100Yumasi(~guillaume@2a01cb09b06b29ea0877e1bda345185b.ipv6.abo.wanadoo.fr)
2020-11-19 09:53:17 +0100Ariakenom(~Ariakenom@h-98-128-229-104.NA.cust.bahnhof.se)
2020-11-19 09:54:00 +0100hackagecompendium-client 0.2.1.1 - Client for the Compendium schema server https://hackage.haskell.org/package/compendium-client-0.2.1.1 (AlejandroSerrano)
2020-11-19 09:54:04 +0100hnOsmium0001(uid453710@gateway/web/irccloud.com/x-rpvaqdolaahudqno) (Quit: Connection closed for inactivity)
2020-11-19 09:55:24 +0100vicfred(~vicfred@unaffiliated/vicfred) (Quit: Leaving)
2020-11-19 09:57:00 +0100hackagemu-avro 0.4.0.2 - Avro serialization support for Mu microservices https://hackage.haskell.org/package/mu-avro-0.4.0.2 (AlejandroSerrano)
2020-11-19 09:58:11 +0100britva(~britva@31-10-157-156.cgn.dynamic.upc.ch)
2020-11-19 09:58:29 +0100britva(~britva@31-10-157-156.cgn.dynamic.upc.ch) (Client Quit)
2020-11-19 09:59:00 +0100hackagemu-protobuf 0.4.0.2 - Protocol Buffers serialization and gRPC schema import for Mu microservices https://hackage.haskell.org/package/mu-protobuf-0.4.0.2 (AlejandroSerrano)
2020-11-19 09:59:17 +0100britva(~britva@2a02:aa13:7240:2980:7da5:a1a0:c038:90b4)
2020-11-19 10:00:31 +0100hackagemu-optics 0.3.0.1 - Optics for @mu-schema@ terms https://hackage.haskell.org/package/mu-optics-0.3.0.1 (AlejandroSerrano)
2020-11-19 10:01:31 +0100hackagemu-persistent 0.3.1.0 - Utilities for interoperation between Mu and Persistent https://hackage.haskell.org/package/mu-persistent-0.3.1.0 (AlejandroSerrano)
2020-11-19 10:02:31 +0100hackagemu-grpc-client 0.4.0.1 - gRPC clients from Mu definitions https://hackage.haskell.org/package/mu-grpc-client-0.4.0.1 (AlejandroSerrano)
2020-11-19 10:04:31 +0100hackagemu-graphql 0.4.1.0 - GraphQL support for Mu https://hackage.haskell.org/package/mu-graphql-0.4.1.0 (AlejandroSerrano)
2020-11-19 10:06:56 +0100watt801(~watt801@124.123.105.47)
2020-11-19 10:07:23 +0100n0042(d055ed89@208.85.237.137) (Remote host closed the connection)
2020-11-19 10:08:26 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2020-11-19 10:10:09 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2020-11-19 10:10:23 +0100laxasksudden
2020-11-19 10:10:24 +0100 <idnar> :t \a -> a <> a
2020-11-19 10:10:26 +0100 <lambdabot> Semigroup a => a -> a
2020-11-19 10:10:35 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de) (Quit: mputz)
2020-11-19 10:11:30 +0100watt801(~watt801@124.123.105.47) (Ping timeout: 256 seconds)
2020-11-19 10:13:28 +0100invaser(~Thunderbi@31.148.23.125)
2020-11-19 10:13:52 +0100 <idnar> I guess that's `stimes 2`
2020-11-19 10:14:04 +0100Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi)
2020-11-19 10:17:18 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-19 10:17:32 +0100 <avn> Folks, anyone could hint me some examples of usage for aside/outside/without from Control.Lens.Prisms?
2020-11-19 10:20:22 +0100rotty(rotty@ghost.xx.vu) (Ping timeout: 260 seconds)
2020-11-19 10:23:33 +0100jakob_(~textual@p200300f49f162200c400a7daff5c73c4.dip0.t-ipconnect.de)
2020-11-19 10:26:20 +0100kuribas(~user@ptr-25vy0i8y4kl4v762twz.18120a2.ip6.access.telenet.be)
2020-11-19 10:27:19 +0100 <jophish> bgamari: is your ring-buffer library worth using?
2020-11-19 10:27:31 +0100 <jophish> It doesn't build at the moment, but I think that's just version bounds
2020-11-19 10:30:21 +0100boxscape(54a35f37@gateway/web/cgi-irc/kiwiirc.com/ip.84.163.95.55)
2020-11-19 10:31:10 +0100britva(~britva@2a02:aa13:7240:2980:7da5:a1a0:c038:90b4) (Quit: This computer has gone to sleep)
2020-11-19 10:31:27 +0100sagax(~sagax_nb@213.138.71.146) (Ping timeout: 260 seconds)
2020-11-19 10:34:55 +0100Varis(~Tadas@unaffiliated/varis) (Remote host closed the connection)
2020-11-19 10:35:36 +0100ADG1089(~adg1089@223.235.75.84)
2020-11-19 10:36:29 +0100 <ADG1089> @hoogle (FilePath -> IO ()) -> IO [FilePath] -> IO ()
2020-11-19 10:36:30 +0100 <lambdabot> Data.Drinkery.Combinators traverseFrom_ :: (Foldable t, Monad m) => m (t a) -> (a -> m b) -> m ()
2020-11-19 10:36:36 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh) (Remote host closed the connection)
2020-11-19 10:36:59 +0100 <ADG1089> @ty mapM
2020-11-19 10:37:01 +0100 <lambdabot> (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
2020-11-19 10:37:28 +0100Lycurgus(~niemand@cpe-45-46-142-188.buffalo.res.rr.com)
2020-11-19 10:37:55 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh)
2020-11-19 10:38:08 +0100phaul(~phaul@ruby/staff/phaul) (Ping timeout: 256 seconds)
2020-11-19 10:38:53 +0100nckx(~nckx@tobias.gr) (Quit: Updating my Guix System — https://guix.gnu.org)
2020-11-19 10:39:31 +0100britva(~britva@2a02:aa13:7240:2980:7da5:a1a0:c038:90b4)
2020-11-19 10:40:00 +0100phaul(~phaul@ruby/staff/phaul)
2020-11-19 10:41:33 +0100nckx(~nckx@tobias.gr)
2020-11-19 10:43:02 +0100Varis(~Tadas@unaffiliated/varis)
2020-11-19 10:43:16 +0100 <boxscape> % type family Fam :: a :~: b where
2020-11-19 10:43:16 +0100 <yahb> boxscape:
2020-11-19 10:43:19 +0100 <boxscape> % :kind Fam
2020-11-19 10:43:20 +0100 <yahb> boxscape: forall k (a :: k) (b :: k). a :~: b
2020-11-19 10:44:16 +0100 <boxscape> % type family Fam :: a :~: b where Fam = 'Refl
2020-11-19 10:44:16 +0100 <yahb> boxscape: ; <interactive>:24:26: error:; * Couldn't match `a' with `b'; * In the type family declaration for `Fam'
2020-11-19 10:44:25 +0100 <boxscape> % type Fam :: forall k (a :: k) (b :: k) . a :~: b; type family Fam :: a :~: b where Fam = 'Refl
2020-11-19 10:44:26 +0100 <yahb> boxscape:
2020-11-19 10:44:31 +0100clog(~nef@bespin.org)
2020-11-19 10:44:34 +0100 <boxscape> the inferred kind seems to be the same one I gave it
2020-11-19 10:44:41 +0100 <boxscape> why does it result in an error without type sig?
2020-11-19 10:44:44 +0100 <boxscape> (kind sig)
2020-11-19 10:45:22 +0100 <boxscape> ohh wait
2020-11-19 10:45:31 +0100 <boxscape> is the Refl call changing the inferred kind
2020-11-19 10:46:04 +0100Varis(~Tadas@unaffiliated/varis) (Remote host closed the connection)
2020-11-19 10:46:40 +0100 <idnar> jophish: last time I tried to use it, I got segfaults
2020-11-19 10:48:25 +0100Varis(~Tadas@unaffiliated/varis)
2020-11-19 10:48:53 +0100 <idnar> @type \f x -> traverse_ f =<< x
2020-11-19 10:48:54 +0100 <lambdabot> (Monad m, Foldable t) => (a -> m b) -> m (t a) -> m ()
2020-11-19 10:49:10 +0100 <idnar> ADG1089: ^
2020-11-19 10:49:34 +0100 <ADG1089> Thansk!!
2020-11-19 10:50:52 +0100danvet_(~danvet@2a02:168:57f4:0:5f80:650d:c6e6:3453) (Quit: Leaving)
2020-11-19 10:54:25 +0100LKoen(~LKoen@169.244.88.92.rev.sfr.net) (Remote host closed the connection)
2020-11-19 11:01:12 +0100thc202(~thc202@unaffiliated/thc202) (Ping timeout: 260 seconds)
2020-11-19 11:02:10 +0100Zetagon(~leo@c151-177-52-233.bredband.comhem.se)
2020-11-19 11:04:16 +0100chalkmonster(~chalkmons@unaffiliated/chalkmonster)
2020-11-19 11:06:38 +0100Lord_of_Life_Lord_of_Life
2020-11-19 11:07:30 +0100hackagejsonifier 0.1.0.5 - Fast and simple JSON encoding toolkit https://hackage.haskell.org/package/jsonifier-0.1.0.5 (NikitaVolkov)
2020-11-19 11:07:33 +0100thc202(~thc202@unaffiliated/thc202)
2020-11-19 11:08:10 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb)
2020-11-19 11:15:25 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb) (Ping timeout: 240 seconds)
2020-11-19 11:16:18 +0100zyextant(~zyextant@120.155.30.153)
2020-11-19 11:16:21 +0100oish(~charlie@228.25.169.217.in-addr.arpa)
2020-11-19 11:18:07 +0100ben_m(~ben_m@unaffiliated/ben-m/x-8385872) (Quit: ZNC 1.7.5 - https://znc.in)
2020-11-19 11:18:12 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-19 11:19:33 +0100guest1119(~user@49.5.6.87) (Quit: ERC (IRC client for Emacs 27.1))
2020-11-19 11:20:52 +0100ben_m(~ben_m@56.ip-51-38-127.eu)
2020-11-19 11:22:16 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 240 seconds)
2020-11-19 11:24:41 +0100cosimone(~cosimone@2001:b07:ae5:db26:d849:743b:370b:b3cd)
2020-11-19 11:26:38 +0100nerded(~user@lfbn-idf3-1-374-154.w83-199.abo.wanadoo.fr)
2020-11-19 11:26:53 +0100 <nerded> hi guys
2020-11-19 11:27:29 +0100 <Zetagon> Hello
2020-11-19 11:28:10 +0100ubert(~Thunderbi@2a02:8109:9880:303c:ca5b:76ff:fe29:f233)
2020-11-19 11:28:31 +0100ubert(~Thunderbi@2a02:8109:9880:303c:ca5b:76ff:fe29:f233) (Remote host closed the connection)
2020-11-19 11:29:18 +0100patier[m](patiermatr@gateway/shell/matrix.org/x-defohognfbqcqriu)
2020-11-19 11:29:43 +0100nerded(~user@lfbn-idf3-1-374-154.w83-199.abo.wanadoo.fr) (Client Quit)
2020-11-19 11:32:01 +0100ubert(~Thunderbi@2a02:8109:9880:303c:ca5b:76ff:fe29:f233)
2020-11-19 11:32:14 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de)
2020-11-19 11:32:16 +0100rprije(~rprije@124.148.131.132) (Ping timeout: 240 seconds)
2020-11-19 11:34:16 +0100fendor(~fendor@178.165.131.185.wireless.dyn.drei.com)
2020-11-19 11:36:05 +0100fendor_(~fendor@178.165.128.131.wireless.dyn.drei.com) (Ping timeout: 240 seconds)
2020-11-19 11:36:37 +0100 <jophish> idnar: cool, thanks
2020-11-19 11:36:47 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de) (Ping timeout: 260 seconds)
2020-11-19 11:41:05 +0100ben_m(~ben_m@56.ip-51-38-127.eu) (Quit: ZNC 1.7.5 - https://znc.in)
2020-11-19 11:41:25 +0100zyklotomic(~ethan@unaffiliated/chocopuff)
2020-11-19 11:43:25 +0100stree(~stree@50-108-97-52.adr01.mskg.mi.frontiernet.net) (Quit: Caught exception)
2020-11-19 11:43:25 +0100star_cloud(~star_clou@ec2-34-220-44-120.us-west-2.compute.amazonaws.com) (Remote host closed the connection)
2020-11-19 11:43:42 +0100stree(~stree@50-108-97-52.adr01.mskg.mi.frontiernet.net)
2020-11-19 11:44:48 +0100star_cloud(~star_clou@ec2-34-220-44-120.us-west-2.compute.amazonaws.com)
2020-11-19 11:46:01 +0100 <bgamari> jophish, frankly I would need to check
2020-11-19 11:46:10 +0100 <bgamari> jophish, it was a long time ago that I wrote that
2020-11-19 11:46:16 +0100 <bgamari> and I had very particular needs
2020-11-19 11:47:10 +0100ADG1089(~adg1089@223.235.75.84) ()
2020-11-19 11:48:38 +0100 <dminuoso> What's the motivation behind: data :~: where Refl :: a :~: a
2020-11-19 11:48:50 +0100 <dminuoso> Err
2020-11-19 11:49:00 +0100 <dminuoso> data a :~: b where Refl :: a :~: a
2020-11-19 11:49:14 +0100 <Franciman> Hi, does happy have some functionality for writing pratt parsers?
2020-11-19 11:49:24 +0100 <dminuoso> I keep staring at this, not quite understanding how this works or what this is for.
2020-11-19 11:50:25 +0100 <Franciman> dminuoso, the motivation is that you can say that two things are the same, when they are the same
2020-11-19 11:50:26 +0100 <Franciman> :P
2020-11-19 11:50:47 +0100 <Franciman> so that you surely want to conclude a = a
2020-11-19 11:51:53 +0100 <kuribas> I am wondering, would namedFieldPuns be prefered over RecordWildCards?
2020-11-19 11:51:57 +0100 <dminuoso> Does GHC bury a (a ~ b) into the GADT?
2020-11-19 11:52:20 +0100 <kuribas> RecordWildCards add hidden fields to the namespace, but namedFieldPuns make them visible.
2020-11-19 11:52:21 +0100 <dminuoso> % import Data.Type.Equality
2020-11-19 11:52:22 +0100 <yahb> dminuoso:
2020-11-19 11:52:27 +0100 <dminuoso> % :t Refl
2020-11-19 11:52:27 +0100 <yahb> dminuoso: forall k (a :: k). a :~: a
2020-11-19 11:52:36 +0100 <boxscape> dminuoso as far as I know it does
2020-11-19 11:52:38 +0100 <boxscape> or wait
2020-11-19 11:52:43 +0100 <boxscape> I thought you wrote a ~ a
2020-11-19 11:53:03 +0100 <boxscape> Oh nevermind
2020-11-19 11:53:11 +0100 <boxscape> a ~ a wouldn't make sense
2020-11-19 11:53:20 +0100 <dminuoso> Well, a ~ a necessarily holds true, no?
2020-11-19 11:53:25 +0100 <boxscape> so yes, as far as I know it does put a ~ b into the GADT
2020-11-19 11:53:32 +0100 <boxscape> dminuoso right, that's what I meant
2020-11-19 11:53:55 +0100 <dminuoso> The above type signature seems strange, Id have expected it to we
2020-11-19 11:53:59 +0100cosimone(~cosimone@2001:b07:ae5:db26:d849:743b:370b:b3cd) (Remote host closed the connection)
2020-11-19 11:54:15 +0100 <dminuoso> Refl :: forall a b. (a ~ b) => a :~: b
2020-11-19 11:54:20 +0100cosimone(~cosimone@2001:b07:ae5:db26:d849:743b:370b:b3cd)
2020-11-19 11:54:22 +0100 <dminuoso> (ignoring the PolyKinds noise)
2020-11-19 11:54:45 +0100 <boxscape> % :t undefined :: forall a b . (a ~ b) => a :~: b
2020-11-19 11:54:45 +0100 <yahb> boxscape: forall k (b :: k). b :~: b
2020-11-19 11:54:53 +0100 <boxscape> dminuoso same thing
2020-11-19 11:54:54 +0100jwynn6(~jwynn6@050-088-122-078.res.spectrum.com) (Ping timeout: 272 seconds)
2020-11-19 11:55:36 +0100jwynn6(~jwynn6@050-088-122-078.res.spectrum.com)
2020-11-19 11:55:49 +0100zyxtant(~zyextant@120.155.30.153)
2020-11-19 11:57:07 +0100 <dminuoso> So Refl is just a reified ~ constraint?
2020-11-19 11:57:18 +0100 <boxscape> yes
2020-11-19 11:58:00 +0100 <dminuoso> im genuinely curious what this could be used for then
2020-11-19 11:59:14 +0100 <boxscape> dminuoso to show that things are equal, for example, if you had data Nat = Z | S Nat, and defined plus for it, you could have plus_comm :: forall (n :: Nat) (m :: Nat) . Plus n m :~: Plus m n
2020-11-19 11:59:20 +0100zyextant(~zyextant@120.155.30.153) (Ping timeout: 272 seconds)
2020-11-19 11:59:31 +0100 <boxscape> and the proof would contain 2 or 3 Refls
2020-11-19 12:00:12 +0100 <dminuoso> 2 or 3 Refls?
2020-11-19 12:00:51 +0100kuribas(~user@ptr-25vy0i8y4kl4v762twz.18120a2.ip6.access.telenet.be) (Read error: Connection reset by peer)
2020-11-19 12:01:31 +0100zyklotomic(~ethan@unaffiliated/chocopuff) (Quit: WeeChat 2.9)
2020-11-19 12:01:35 +0100 <boxscape> as in, the Refl constructor would appear in the proof two or three times - as the base case for the induction (though actually you need to add singleton arguments here I think to match on)
2020-11-19 12:02:07 +0100kuribas(~user@ptr-25vy0i8y4kl4v762twz.18120a2.ip6.access.telenet.be)
2020-11-19 12:03:18 +0100 <boxscape> so if you also had data SNat :: Nat -> Type where SZ :: SNat Z | SS :: SNat n -> SNat (S n), i.e. the singleton type for Nat, you could have plus_comm :: SNat n -> SNat m -> Plus n m :~: Plus m n, and then the first equation, the inductive base case, could be plus_comm SZ n = Refl
2020-11-19 12:03:59 +0100 <boxscape> assuming Plus is defined as type family Plus n m where Plus Z m = m; Plus (S n) m = S (Plus n m)
2020-11-19 12:06:39 +0100ft(~ft@shell.chaostreff-dortmund.de)
2020-11-19 12:07:25 +0100chalkmonster(~chalkmons@unaffiliated/chalkmonster) (Quit: WeeChat 2.9)
2020-11-19 12:07:58 +0100zyklotomic(~ethan@unaffiliated/chocopuff)
2020-11-19 12:08:30 +0100hackagehadolint 1.19.0 - Dockerfile Linter JavaScript API https://hackage.haskell.org/package/hadolint-1.19.0 (lorenzo)
2020-11-19 12:08:46 +0100 <zyklotomic> soft question here, is there a reason behind the ". . . $" style? I think it's part of "point-free" style? but I might be wrong
2020-11-19 12:09:17 +0100 <boxscape> (technically that base case isn't quite correct but let me write up the example real quick)
2020-11-19 12:09:39 +0100 <zyklotomic> like just now, I wrote something like `drop 1 . foldl' f [a, start] $ xs`, but I honenstly find this style more difficult to read than `drop 1 $ foldl' f [a, start] $ xs`
2020-11-19 12:10:31 +0100 <zyklotomic> * in the second one, the second $ was a typo / extraneous
2020-11-19 12:10:50 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-19 12:13:02 +0100 <dminuoso> zyklotomic: It's personal taste, some people like: . . . $, others prefer (. . .) (. . .), and there's other styles too
2020-11-19 12:13:20 +0100ft(~ft@shell.chaostreff-dortmund.de) (Ping timeout: 260 seconds)
2020-11-19 12:13:48 +0100 <dminuoso> I tend to avoid ($) generally except for do blocks/lambdas (cant get myself to enable BlockArguments)
2020-11-19 12:15:26 +0100 <dminuoso> In my opinion it's good to use function composition and parens. It gives you a better view on code structure
2020-11-19 12:15:28 +0100 <kuribas> dminuoso: so do you write (f . g . h) x then?
2020-11-19 12:16:03 +0100 <dminuoso> kuribas: Generally I favor `... f x where f = g . h . i`
2020-11-19 12:16:21 +0100datajerk(~datajerk@sense.net) (Remote host closed the connection)
2020-11-19 12:16:26 +0100kuribaswonders if he writes everything infix his lisp colleages will like haskell more...
2020-11-19 12:16:28 +0100 <dminuoso> but `f (g (h x))` is not bad either
2020-11-19 12:16:35 +0100kuribasmeans prefix
2020-11-19 12:16:44 +0100 <dminuoso> It's somewhat situational
2020-11-19 12:16:46 +0100datajerk(~datajerk@sense.net)
2020-11-19 12:16:49 +0100 <kuribas> dminuoso: lispers agree :)
2020-11-19 12:16:55 +0100 <kuribas> dminuoso: but clojurers not
2020-11-19 12:17:12 +0100 <zyklotomic> ah i see
2020-11-19 12:17:15 +0100 <zyklotomic> thanks for sharing
2020-11-19 12:17:28 +0100 <zyklotomic> i've been generally writing (f . g . h) x too
2020-11-19 12:17:37 +0100 <zyklotomic> and $ felt a bit unnatural at first
2020-11-19 12:17:54 +0100 <kuribas> clojurers write (-> x h g f). IMO it's strictly worse than ($) or (.), as it is a syntactic, rather than semantic construct.
2020-11-19 12:18:30 +0100 <dminuoso> zyklotomic: Using function composition brings functions as first class objects more into view
2020-11-19 12:18:43 +0100 <dminuoso> Say `fmap (f . g) ...`
2020-11-19 12:18:51 +0100 <kuribas> zyklotomic: I think the reasoning behidn . . . $ is that if you remove the last argument it still works.
2020-11-19 12:19:14 +0100 <dminuoso> (You could call this "point-free", but often its useful to think of functions as pipelines you can just compose to do more complex things)
2020-11-19 12:19:15 +0100 <boxscape> dminuoso Refl example: https://gist.github.com/JakobBruenker/38251269a93cdd1f4979b771e613f4e6
2020-11-19 12:19:18 +0100 <kuribas> zyklotomic: f x = g . h $ x => f = g . h
2020-11-19 12:19:20 +0100 <zyklotomic> yeah, i do `fmap (f . g)` too
2020-11-19 12:19:44 +0100 <zyklotomic> like the other pattern i've seen that parallels this, is f <*> g <$> h
2020-11-19 12:19:47 +0100 <kuribas> zyklotomic: but with f x = g $ h $ x you have to replace all the ($)'s
2020-11-19 12:19:50 +0100 <zyklotomic> which well it does make sense
2020-11-19 12:20:17 +0100 <boxscape> dminuoso in the pattern guards the equality constraint is extracted
2020-11-19 12:20:25 +0100 <dminuoso> zyklotomic: If you explore this much, there's some pretty cool tricks
2020-11-19 12:20:31 +0100 <kuribas> zyklotomic: in the end it's your own preference
2020-11-19 12:20:33 +0100 <dminuoso> Personally Im a big fan of foldMap for example
2020-11-19 12:20:45 +0100alp(~alp@2a01:e0a:58b:4920:6cd6:5f96:4d6d:5a5) (Ping timeout: 272 seconds)
2020-11-19 12:20:45 +0100 <zyklotomic> dminuoso: wait, I finally see exactly what you mean about the last argument now
2020-11-19 12:20:53 +0100 <zyklotomic> I never came upon that realization
2020-11-19 12:21:13 +0100 <dminuoso> % getSum . foldMap Sum $ [1,2,3,4] :: Integer
2020-11-19 12:21:14 +0100 <yahb> dminuoso: 10
2020-11-19 12:21:14 +0100 <zyklotomic> it was always trying to work out the order of operations/priority of the operetors idk what it's called
2020-11-19 12:21:19 +0100 <zyklotomic> precedence?
2020-11-19 12:21:43 +0100 <zyklotomic> like the PEMDAS of operators, i'm not sure what to calli t
2020-11-19 12:22:06 +0100 <dminuoso> boxscape: Okay, so Im staring at this, my head is not quite ready to be contorted.
2020-11-19 12:22:16 +0100 <dminuoso> Superficially, I can read it and understand what this is doing
2020-11-19 12:22:23 +0100 <dminuoso> But not quite why this works inductively
2020-11-19 12:22:40 +0100pfurla_(~pfurla@ool-182ed2e2.dyn.optonline.net) (Ping timeout: 260 seconds)
2020-11-19 12:22:40 +0100 <dminuoso> Is this essentially a theorem prover like coq in action?
2020-11-19 12:23:00 +0100 <boxscape> dminuoso yes, the main difference being that we can't be sure they're actually proofs because the totality checker is missing
2020-11-19 12:23:01 +0100alp(~alp@2a01:e0a:58b:4920:7900:a63:b56e:5a9)
2020-11-19 12:23:15 +0100 <boxscape> (though if a proof terminates successfully for an input, you've proven it for that input)
2020-11-19 12:23:20 +0100 <dminuoso> boxscape: Oh you mean because I can just sneak `undefined` in at any point to prove whatever?
2020-11-19 12:23:24 +0100 <boxscape> right
2020-11-19 12:23:55 +0100 <kuribas> dminuoso: how is that better than foldr (+) 0 [1, 2, 3, 4] ?
2020-11-19 12:24:23 +0100 <dminuoso> kuribas: Sum carries monoid laws implictly
2020-11-19 12:24:23 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 240 seconds)
2020-11-19 12:24:32 +0100 <boxscape> dminuoso tbh these kinds of proofs are a lot easier to understand while writing than while reading, because you can look at the hole types along the way
2020-11-19 12:24:33 +0100 <dminuoso> with foldr you cant reason about laws
2020-11-19 12:24:43 +0100pfurla(~pfurla@190.15.195.173.client.static.strong-in52.as13926.net)
2020-11-19 12:25:01 +0100 <dminuoso> say, will `foldr (+) 0 [1,2,3,4]` and `foldl (+) 0 [1,2,3,4]` do the same thing?
2020-11-19 12:25:12 +0100 <dminuoso> Dunno really
2020-11-19 12:25:44 +0100 <dminuoso> I mean for this case I can of course tell, but the associativity and identity is not clearly communicated, and it's extra verbose
2020-11-19 12:25:48 +0100 <kuribas> dminuoso: depends on the Num instance
2020-11-19 12:25:59 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2020-11-19 12:26:00 +0100 <dminuoso> kuribas: Im just very fond of traverse and foldMap
2020-11-19 12:26:08 +0100 <boxscape> for example `plus_Z (SS n) = _` has hole type `'S (Plus n1 'Z) :~: 'S n1`, so we can call plus_Z n recursively and match on that to get out the `Plus n1 Z ~ n1` constraint, and then we just have to make something of type `S n1 :~: S n1`, which is Refl
2020-11-19 12:26:09 +0100 <kuribas> also foldMap Sum is very ineffecient
2020-11-19 12:26:20 +0100 <kuribas> it's too lazy
2020-11-19 12:26:46 +0100 <dminuoso> Often efficiency is not a problem I need, expressivity is more important to me :)
2020-11-19 12:27:01 +0100 <dminuoso> Consider this trick to implement traverse:
2020-11-19 12:27:04 +0100 <kuribas> I prefer both
2020-11-19 12:27:11 +0100sdx23(~sdx23@unaffiliated/sdx23) (Remote host closed the connection)
2020-11-19 12:27:16 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber) (Ping timeout: 240 seconds)
2020-11-19 12:27:20 +0100 <kuribas> I mean efficiency and expressivity are not necessary mutually exclusive
2020-11-19 12:27:26 +0100sdx23(~sdx23@unaffiliated/sdx23)
2020-11-19 12:27:30 +0100 <dminuoso> % ala ZipList traverse [[1,2,3],[10,20,30],[100,200,300]]
2020-11-19 12:27:30 +0100 <yahb> dminuoso: ; <interactive>:32:1: warning: [-Wtype-defaults]; * Defaulting the following constraints to type `Integer'; (Show b0) arising from a use of `print' at <interactive>:32:1-55; (Num b0) arising from a use of `it' at <interactive>:32:1-55; * In a stmt of an interactive GHCi command: print it; [[1,10,100],[2,20,200],[3,30,300]]
2020-11-19 12:27:39 +0100 <dminuoso> % ala ZipList traverse [[1,2,3],[10,20,30],[100,200,300]] :: [[Integer]]
2020-11-19 12:27:40 +0100 <yahb> dminuoso: [[1,10,100],[2,20,200],[3,30,300]]
2020-11-19 12:28:02 +0100 <dminuoso> Can't deny there's a certain beauty of both foldMap and traverse :)
2020-11-19 12:28:38 +0100 <dminuoso> kuribas: Also, we have foldMap' now :p
2020-11-19 12:29:07 +0100 <dminuoso> % ala Product foldMap [1,2,3,4]
2020-11-19 12:29:07 +0100 <yahb> dminuoso: ; <interactive>:34:1: warning: [-Wtype-defaults]; * Defaulting the following constraints to type `Integer'; (Show a0) arising from a use of `print' at <interactive>:34:1-29; (Num a0) arising from a use of `it' at <interactive>:34:1-29; * In a stmt of an interactive GHCi command: print it; 24
2020-11-19 12:29:27 +0100 <dminuoso> % ala Product foldMap [1,2,3,4]
2020-11-19 12:29:28 +0100 <yahb> dminuoso: 24
2020-11-19 12:29:30 +0100 <kuribas> foldMap' evaluated from left?
2020-11-19 12:29:44 +0100 <dminuoso> foldMap' f = foldl' (\ acc a -> acc <> f a) mempty
2020-11-19 12:29:52 +0100 <dminuoso> foldMap f = foldr (mappend . f) mempty
2020-11-19 12:29:56 +0100 <kuribas> ah cool
2020-11-19 12:30:20 +0100 <nshepperd> i presume foldMap' is strictly evaluated in whatever direction makes most sense for the type?
2020-11-19 12:30:52 +0100 <kuribas> nshepperd: is that even possible?
2020-11-19 12:31:06 +0100 <kuribas> nshepperd: ah by type you mean the foldable?
2020-11-19 12:31:21 +0100 <nshepperd> ie. foldl' for lists, foldr' for snoc lists
2020-11-19 12:31:24 +0100 <nshepperd> yeah
2020-11-19 12:33:40 +0100berberman_(~berberman@unaffiliated/berberman)
2020-11-19 12:34:41 +0100berberman(~berberman@unaffiliated/berberman) (Ping timeout: 272 seconds)
2020-11-19 12:35:47 +0100chalkmonster(~chalkmons@unaffiliated/chalkmonster)
2020-11-19 12:36:31 +0100 <dminuoso> what is a snoc list?
2020-11-19 12:37:04 +0100 <pjb> A list from the end?
2020-11-19 12:37:24 +0100 <dminuoso> And that is different from a list... how?
2020-11-19 12:37:54 +0100 <boxscape> I guess it's different in that foldl has been renamed to foldr and vice versa?
2020-11-19 12:38:36 +0100 <dminuoso> boxscape: How's that?
2020-11-19 12:38:46 +0100 <dminuoso> The difference between foldl and foldr is not the order of the lits
2020-11-19 12:39:19 +0100 <dminuoso> It's how the function we replace the cons with associates
2020-11-19 12:39:39 +0100 <boxscape> dminuoso I know, but for that you need to have some mental image of what left and right means in a list, right?
2020-11-19 12:39:58 +0100 <boxscape> which isn't fundamentally part of the type
2020-11-19 12:40:16 +0100 <kuribas> (a <> (b <> (c <> d))) should be the same as (((a <> b) <> c) <> d)
2020-11-19 12:40:25 +0100 <kuribas> but one may be more efficient to calculate
2020-11-19 12:40:34 +0100 <boxscape> so if you swap directions of that mental image, you rename foldr to foldl and foldl to foldr, and perhaps write the constructor as [a] : a, and I imagine that's what a snoc list would be
2020-11-19 12:40:38 +0100 <boxscape> functionally the same as a list
2020-11-19 12:40:55 +0100 <dminuoso> Ill await nshepperd's response. :)
2020-11-19 12:40:59 +0100 <dminuoso> To clarify
2020-11-19 12:40:59 +0100 <boxscape> that's fair
2020-11-19 12:41:00 +0100 <kuribas> > foldMap' (<>) [a, b, c, d]
2020-11-19 12:41:02 +0100 <lambdabot> <Expr -> Expr>
2020-11-19 12:41:24 +0100 <kuribas> > foldMap' Sum [a, b, c, d]
2020-11-19 12:41:26 +0100 <lambdabot> Sum {getSum = 0 + a + b + c + d}
2020-11-19 12:41:30 +0100 <kuribas> > foldMap Sum [a, b, c, d]
2020-11-19 12:41:32 +0100 <lambdabot> Sum {getSum = a + (b + (c + (d + 0)))}
2020-11-19 12:41:51 +0100 <dminuoso> kuribas: The difference matters in two respects: Is the input data structure infinite, and do we need to be lazy on the output (do we build a chain of data constructors)
2020-11-19 12:42:18 +0100 <kuribas> those aren't the same value
2020-11-19 12:42:24 +0100 <kuribas> are they?
2020-11-19 12:42:24 +0100chaosmasttter(~chaosmast@p200300c4a70b2a01441f1455f36b3658.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-11-19 12:42:59 +0100 <kuribas> ah they are since 0 is the empty element
2020-11-19 12:43:16 +0100invaser(~Thunderbi@31.148.23.125) (Ping timeout: 240 seconds)
2020-11-19 12:43:20 +0100 <dminuoso> kuribas: by monoid laws they are the same
2020-11-19 12:43:41 +0100 <dminuoso> because precisely, a monoid is associative (so it doesnt matter how they associate) and mempty is the identity element (it doesnt matter where you slap it onto)
2020-11-19 12:44:15 +0100ft(~ft@shell.chaostreff-dortmund.de)
2020-11-19 12:44:47 +0100 <dminuoso> Guess that's the sort of things that makes foldMap so cool. You can just replace it with foldMap' without worrying whether it changes its meaning
2020-11-19 12:44:55 +0100 <dminuoso> with foldr/foldl
2020-11-19 12:45:07 +0100 <dminuoso> you have to manually check for associativity and identity
2020-11-19 12:46:55 +0100zyklotomic(~ethan@unaffiliated/chocopuff) (Quit: WeeChat 2.9)
2020-11-19 12:46:58 +0100Alleria_(~AllahuAkb@2604:2000:1484:26:ef:21ba:eb1b:b066)
2020-11-19 12:47:05 +0100 <boxscape> hmm I wonder if a monoid with separate left and right identity elements could be useful
2020-11-19 12:47:31 +0100 <tomjaguarpaw> If you had left and right identities el and er what would el <> er be?
2020-11-19 12:48:26 +0100Stanley00(~stanley00@unaffiliated/stanley00) ()
2020-11-19 12:48:53 +0100 <boxscape> that's a very good question
2020-11-19 12:49:17 +0100 <boxscape> I guess it wouldn't be useful then
2020-11-19 12:49:36 +0100cfricke(~cfricke@unaffiliated/cfricke) (Quit: WeeChat 2.9)
2020-11-19 12:49:53 +0100Amras(~Amras@unaffiliated/amras0000) (Ping timeout: 272 seconds)
2020-11-19 12:50:32 +0100 <kuribas> dminuoso: it does change meaning wrt bottom
2020-11-19 12:50:35 +0100jeet1(~jeet@183.83.41.219)
2020-11-19 12:50:48 +0100 <boxscape> Although, I guess you could have a (not-quite-)monoid that *only* has left identity (or only right-identity)
2020-11-19 12:51:22 +0100 <kuribas> > foldMap First [1, 2, undefined]
2020-11-19 12:51:24 +0100 <lambdabot> error:
2020-11-19 12:51:24 +0100 <lambdabot> • No instance for (Num (Maybe ())) arising from a use of ‘e_112’
2020-11-19 12:51:24 +0100 <lambdabot> • In the expression: e_112
2020-11-19 12:51:50 +0100 <nshepperd> yeah a snoc list is just a cons list that has had left and right renamed
2020-11-19 12:52:41 +0100cosimone(~cosimone@2001:b07:ae5:db26:d849:743b:370b:b3cd) (Remote host closed the connection)
2020-11-19 12:53:02 +0100cosimone(~cosimone@2001:b07:ae5:db26:d849:743b:370b:b3cd)
2020-11-19 12:53:04 +0100 <kuribas> > foldMap First [Just 1, Just 2, undefined]
2020-11-19 12:53:06 +0100 <lambdabot> First {getFirst = Just 1}
2020-11-19 12:53:12 +0100 <kuribas> > foldMap' First [Just 1, Just 2, undefined]
2020-11-19 12:53:14 +0100 <lambdabot> First {getFirst = Just 1}
2020-11-19 12:53:47 +0100noctux(~noctux@unaffiliated/noctux) (Read error: Connection reset by peer)
2020-11-19 12:53:48 +0100 <nshepperd> you won't often find them in the wild
2020-11-19 12:54:25 +0100noctux(~noctux@unaffiliated/noctux)
2020-11-19 12:54:36 +0100 <kuribas> > foldMap All [True, False, undefined]
2020-11-19 12:54:37 +0100 <lambdabot> All {getAll = False}
2020-11-19 12:54:41 +0100 <kuribas> > foldMap' All [True, False, undefined]
2020-11-19 12:54:42 +0100 <lambdabot> All {getAll = False}
2020-11-19 12:54:49 +0100 <kuribas> hmmm
2020-11-19 12:55:10 +0100m0rphism(~m0rphism@HSI-KBW-095-208-098-207.hsi5.kabel-badenwuerttemberg.de)
2020-11-19 12:55:36 +0100 <dminuoso> nshepperd: That sounds.. like a list.
2020-11-19 12:56:04 +0100 <nshepperd> well yeah
2020-11-19 12:56:38 +0100 <nshepperd> you can just do things with lists, and remember to reverse things in your head when reading code
2020-11-19 12:57:27 +0100agrajag`(~agrajag`@84.39.117.57) (Remote host closed the connection)
2020-11-19 12:57:31 +0100 <nshepperd> but sometimes it's easier to have a different type so that the syntax corresponds to the intended ordering
2020-11-19 12:57:56 +0100 <dminuoso> So roughly a `data Tsil a = Snoc a (Tsil a) | Lin` differs from [] by conceptually reversing before folding/traversing?
2020-11-19 12:58:15 +0100 <dminuoso> (or in case of traverse, revere, traverse, and then reverse again)
2020-11-19 12:58:15 +0100 <kuribas> they are the same even with bottom then?
2020-11-19 12:59:14 +0100 <boxscape> the list matches the intended left right order better with Snoc (Tsil a) a: Lin `SNoc` 3 `Snoc` 2 `Snoc` 1
2020-11-19 12:59:17 +0100 <nshepperd> generally you write SnocList a = Nil | Snoc (SnocList a) a
2020-11-19 12:59:29 +0100chaosmasttter(~chaosmast@p200300c4a70b2a01441f1455f36b3658.dip0.t-ipconnect.de)
2020-11-19 12:59:48 +0100 <dminuoso> Why not just use Dual?
2020-11-19 13:00:02 +0100jeet1(~jeet@183.83.41.219) (Quit: WeeChat 2.9)
2020-11-19 13:00:11 +0100 <nshepperd> performance
2020-11-19 13:00:23 +0100 <dminuoso> Mmm, fair
2020-11-19 13:00:34 +0100 <nshepperd> also, pattern matching
2020-11-19 13:00:44 +0100Lycurgus(~niemand@cpe-45-46-142-188.buffalo.res.rr.com) (Quit: Exeunt)
2020-11-19 13:00:45 +0100cfricke(~cfricke@unaffiliated/cfricke)
2020-11-19 13:00:46 +0100pfurla(~pfurla@190.15.195.173.client.static.strong-in52.as13926.net) (Ping timeout: 272 seconds)
2020-11-19 13:00:56 +0100 <dminuoso> boxscape: Ill take a look at your gist later tonight, think I need to sit down and employ the good ol' fashioned Feynman algorithm
2020-11-19 13:00:57 +0100__monty__(~toonn@unaffiliated/toonn)
2020-11-19 13:01:18 +0100 <dminuoso> nshepperd: well, the pattern matching is a mood argument, since it's no different from (:)
2020-11-19 13:01:37 +0100pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net)
2020-11-19 13:01:44 +0100 <nshepperd> nooo
2020-11-19 13:01:58 +0100 <dminuoso> Whether you write `1:2:3:[]` or `[]:%3:%2:%1` seems no different at all
2020-11-19 13:02:07 +0100 <nshepperd> i mean, you can't use Dual when you're doing type level lists
2020-11-19 13:02:07 +0100AWizzArd(~code@unaffiliated/awizzard) (Read error: Connection reset by peer)
2020-11-19 13:02:10 +0100 <dminuoso> ah
2020-11-19 13:02:41 +0100AWizzArd(~code@gehrels.uberspace.de)
2020-11-19 13:03:42 +0100 <boxscape> dminuoso In a way I think these proofs are even harder to understand in Haskell than in some other languages, because the way constraint resolution makes it so it's not obvious how things are actually plugged together (though at least these are small proofs). But replacing the rhss with typed holes should help.
2020-11-19 13:03:44 +0100xff0x(~fox@2001:1a81:534b:a000:20f1:4040:a0e2:f16) (Ping timeout: 240 seconds)
2020-11-19 13:03:58 +0100 <boxscape> s/the way//
2020-11-19 13:04:32 +0100 <kuribas> I find myself going back from typed holes to tuples
2020-11-19 13:04:45 +0100xff0x(~fox@2001:1a81:534b:a000:65df:cebc:ef3d:70f7)
2020-11-19 13:04:48 +0100 <kuribas> the error message is much better
2020-11-19 13:05:06 +0100 <__monty__> Do you mean unit?
2020-11-19 13:05:13 +0100 <kuribas> __monty__: yes
2020-11-19 13:05:36 +0100 <kuribas> my-fun = () $ partial-implementation
2020-11-19 13:06:11 +0100 <__monty__> That does change how associativity is parsed, no?
2020-11-19 13:06:42 +0100 <boxscape> oh huh
2020-11-19 13:06:45 +0100 <dminuoso> boxscape: Btw, I think there's a mistake in your proof
2020-11-19 13:06:48 +0100 <boxscape> the error message is better, you're right
2020-11-19 13:06:50 +0100 <boxscape> dminuoso oh?
2020-11-19 13:06:53 +0100 <dminuoso> boxscape: plus_Z :: SNat n -> Plus n Z :~: n
2020-11-19 13:06:58 +0100 <dminuoso> boxscape: Think you mixed up the order to Plus there
2020-11-19 13:07:14 +0100 <dminuoso> The identity is only on one side in the tyfam
2020-11-19 13:07:26 +0100 <dminuoso> Or am I confusing things?
2020-11-19 13:07:46 +0100 <boxscape> dminuoso the identity of Plus Z n = n is trivial, but I have to write this proof to convince ghc that the other direction works, too
2020-11-19 13:08:33 +0100 <dminuoso> boxscape: Ohh, so `plus_Z SZ = Refl` gives us `Plus Z Z ~ Z` for the base case
2020-11-19 13:08:40 +0100 <boxscape> right
2020-11-19 13:08:51 +0100 <dminuoso> (Which evalutaes to Z ~ Z, dischargable because every type is automatically equal to itself)
2020-11-19 13:08:58 +0100 <dminuoso> So we dont need to provide proof ofZ ~ Z
2020-11-19 13:09:29 +0100cosimone(~cosimone@2001:b07:ae5:db26:d849:743b:370b:b3cd) (Quit: cosimone)
2020-11-19 13:09:35 +0100 <boxscape> I would hope that if there were a mistake ghc would have caught it, otherwise there'd be a bug in ghc (or in my copy-paste abilites)
2020-11-19 13:10:15 +0100 <boxscape> uh, assuming it's not the sort of mistake that makes a proof non-total
2020-11-19 13:10:34 +0100 <dminuoso> plus_Z (SS n) | Refl <- plus_Z n = Refl
2020-11-19 13:10:44 +0100 <dminuoso> How does this inductive step work exaclty from the constraint solvers point of view?
2020-11-19 13:13:17 +0100 <boxscape> so, if you write plus_Z (SS n), what you have to solve is 'S (Plus n 'Z) :~: 'S n. plus_Z n has type (Plus n Z) :~: n, so by matching on that, we can unify Plus n Z with n, and we have to solve S n :~: S n
2020-11-19 13:13:31 +0100 <boxscape> and Refl is a value with that type, so we can just write Refl
2020-11-19 13:13:39 +0100 <boxscape> dminuoso
2020-11-19 13:14:14 +0100 <dminuoso> "what you have to solve is 'S (Plus n 'Z) :~: 'S n"
2020-11-19 13:14:21 +0100oerjan(~oerjan@195.206.169.184)
2020-11-19 13:14:26 +0100 <dminuoso> do you mean `S (Plus n 'Z) ~ 'S`?
2020-11-19 13:15:06 +0100 <boxscape> hmm I don't think I do. S by itself isn't a natural number, but S (Plus n Z) is a natural number, so that appears to be a kind error.
2020-11-19 13:15:15 +0100 <dminuoso> err
2020-11-19 13:15:37 +0100Tario(~Tario@201.192.165.173)
2020-11-19 13:16:17 +0100 <boxscape> ah but
2020-11-19 13:16:23 +0100 <boxscape> I should have used a different letter
2020-11-19 13:16:32 +0100 <dminuoso> boxscape: Sorry I think I cut off a quote there. We want to produce a value of type: 'S (Plus n 'Z) :~: 'S n
2020-11-19 13:16:32 +0100 <boxscape> like S (Plus m 'Z) :~: 'S m
2020-11-19 13:16:42 +0100 <dminuoso> So we use the data constructor Refl. That requires us to solve for a constraint
2020-11-19 13:16:50 +0100 <dminuoso> 'S (Plus n 'Z) ~ 'S n
2020-11-19 13:17:26 +0100 <boxscape> Ah, fair. What I meant by "solve" was "we have to write a value of that type on the rhs", but the terminology was a bit off, I admit
2020-11-19 13:17:59 +0100 <dminuoso> The pattern matching `Refl <- plus_Z n` uncovers the dictionary for the proof of the inductive hypothesis
2020-11-19 13:18:07 +0100 <boxscape> right
2020-11-19 13:18:30 +0100 <dminuoso> And from that we can show that (Plus n 'Z) ~ n
2020-11-19 13:18:36 +0100 <dminuoso> (or GHC can)
2020-11-19 13:18:42 +0100 <dminuoso> Thus leading us to conclude that
2020-11-19 13:18:50 +0100 <dminuoso> 'S n ~ 'S n
2020-11-19 13:18:52 +0100alp(~alp@2a01:e0a:58b:4920:7900:a63:b56e:5a9) (Ping timeout: 260 seconds)
2020-11-19 13:19:08 +0100 <boxscape> yeah, that sounds right
2020-11-19 13:19:08 +0100 <dminuoso> which is what Refl demands
2020-11-19 13:19:18 +0100 <dminuoso> mmm okay
2020-11-19 13:19:43 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-19 13:20:02 +0100 <dminuoso> So the value here of :~: is that we can have it in *positive* position, such that things can *produce* proofs of this
2020-11-19 13:20:12 +0100 <dminuoso> Whereas with => its, in effect, in negative position
2020-11-19 13:20:15 +0100alp(~alp@2a01:e0a:58b:4920:7562:27bf:89c5:b0d)
2020-11-19 13:20:18 +0100enoq(~textual@194-208-146-143.lampert.tv)
2020-11-19 13:20:24 +0100 <boxscape> right
2020-11-19 13:22:27 +0100Entertainment(~entertain@104.246.132.210)
2020-11-19 13:22:51 +0100 <dminuoso> actually I missed one step!
2020-11-19 13:22:57 +0100 <dminuoso> 13:18:42 dminuoso | Thus leading us to conclude that
2020-11-19 13:23:15 +0100 <dminuoso> This requires injectivity of 'S
2020-11-19 13:23:36 +0100 <dminuoso> Or.. mmm
2020-11-19 13:23:48 +0100 <boxscape> I think any function would do
2020-11-19 13:24:03 +0100 <boxscape> going the other way around would though
2020-11-19 13:24:18 +0100noctux(~noctux@unaffiliated/noctux) (Remote host closed the connection)
2020-11-19 13:24:18 +0100 <dminuoso> I should really reimplement the type system myself to get an idea
2020-11-19 13:24:23 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 256 seconds)
2020-11-19 13:24:37 +0100xacktm(xacktm@gateway/shell/panicbnc/x-wtuwnbsvfqpgvaqk) (Quit: PanicBNC - http://PanicBNC.net)
2020-11-19 13:24:47 +0100 <dminuoso> It's a bit mysterous what we can do with this though
2020-11-19 13:25:17 +0100 <dminuoso> Surely the value is not to prove commutativity of peano naturals to ourselves, using GHC.
2020-11-19 13:25:29 +0100noctux(~noctux@unaffiliated/noctux)
2020-11-19 13:25:43 +0100 <boxscape> dminuoso the value is in using this proof for value level functions, let me see if I can think of a good example
2020-11-19 13:26:01 +0100Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net) (Ping timeout: 264 seconds)
2020-11-19 13:26:01 +0100Kaeipi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net)
2020-11-19 13:26:13 +0100invaser(~Thunderbi@31.148.23.125)
2020-11-19 13:28:16 +0100 <boxscape> dminuoso hmm for example you could use it to prove things about other value level functions, like if you wanted to prove that (<>) :: Vec n a -> Vec m a -> Vec (Plus n m) a is associative, you would need associativity of Plus first
2020-11-19 13:28:52 +0100ArsenArsen(~Arsen@fsf/member/ArsenArsen) (Quit: bye)
2020-11-19 13:29:13 +0100ArsenArsen(~Arsen@fsf/member/ArsenArsen)
2020-11-19 13:29:13 +0100 <boxscape> dminuoso but it can also be useful for writing some regular type-level functions with complex types without explicitly trying to prove something about them, can't quite think of an example of that right now though
2020-11-19 13:30:03 +0100 <dminuoso> boxscape: Well but whats the value of *proving* this to GHC?
2020-11-19 13:30:16 +0100 <dminuoso> I mean providing a proof seems only useful if there's something demanding that proof
2020-11-19 13:30:47 +0100 <__monty__> Certified libraries?
2020-11-19 13:30:54 +0100 <boxscape> Right, that's what I meant with the example I can't think of right now :) Though I would say a proof is also useful to convice yourself that the function you wrote is correct
2020-11-19 13:30:59 +0100Entertainment(~entertain@104.246.132.210) ()
2020-11-19 13:32:25 +0100Entertainment(~entertain@104.246.132.210)
2020-11-19 13:32:40 +0100 <boxscape> dminuoso also when I wrote "regular type-level functions" I mean "regular value-level functions"
2020-11-19 13:37:07 +0100p0a(~user@unaffiliated/p0a)
2020-11-19 13:37:26 +0100 <p0a> Hello why is this happening to `stack ghci' in every new stack project of mine? https://pastebin.com/SHVA1zET
2020-11-19 13:39:07 +0100 <__monty__> p0a: Looks like the same filename in a lib and an executable? Not sure why it's a problem though.
2020-11-19 13:39:26 +0100 <__monty__> Is the fully qualified name identical?
2020-11-19 13:39:47 +0100 <p0a> I don't know how to check whta you're asking me __monty__
2020-11-19 13:39:58 +0100 <merijn> Who was asking about languages for low level/embedded stuff yesterday? I realised I forgot to mention a totally obvious candidate..
2020-11-19 13:40:21 +0100 <p0a> __monty__: what lib has the same filename as an executable?
2020-11-19 13:40:40 +0100 <p0a> merijn: texasny-something I believe
2020-11-19 13:40:54 +0100 <__monty__> p0a: Paths_read_binfiles
2020-11-19 13:41:28 +0100 <__monty__> I think the problem is the module identifiers are identical and GHC doesn't know which one to pick.
2020-11-19 13:41:28 +0100 <p0a> __monty__: I don't know if it's a problem but `stack ghci' has some weird modules loaded
2020-11-19 13:41:36 +0100 <p0a> who decided on these names __monty__ ?
2020-11-19 13:41:47 +0100 <__monty__> Don't know.
2020-11-19 13:42:08 +0100 <__monty__> @hackage read-binfiles
2020-11-19 13:42:08 +0100 <lambdabot> https://hackage.haskell.org/package/read-binfiles
2020-11-19 13:42:10 +0100 <merijn> Paths_ modules are autogenerated by Cabal to access datafiles
2020-11-19 13:42:18 +0100 <p0a> It happens to all my new projects __monty__
2020-11-19 13:43:13 +0100 <merijn> Make an issue on the stack github? Presumably they'll know how to debug what's going on
2020-11-19 13:43:29 +0100 <p0a> ok wanted to make sure it's not something obvious
2020-11-19 13:44:09 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de)
2020-11-19 13:45:49 +0100 <merijn> It might be, but I don't use stack, so who knows :p
2020-11-19 13:47:59 +0100 <boxscape> dminuoso I ran into an example yesterday where I did need a proof, though not an equality proof, and it was on the type level, but I think should work equally well on the value level: Let's say you have an ordered list, where the cons constructor carries a proof that a cons'd element is less than the next element in the list (thus making sure it
2020-11-19 13:47:59 +0100 <boxscape> actually is ordered). If you want to delete an element in that list, you'll need a proof that less-than is transitive, as e.g. if you have [a,b,c] and want to delete b, you'll need to somehow construct a proof that a<c to get a new ordered list
2020-11-19 13:48:56 +0100 <dminuoso> Makes sense
2020-11-19 13:49:18 +0100 <dminuoso> So providing this proof is just to be able to re-construct this provably ordered list after the operation
2020-11-19 13:49:23 +0100gxt(~gxt@gateway/tor-sasl/gxt) (Ping timeout: 240 seconds)
2020-11-19 13:49:24 +0100 <boxscape> right
2020-11-19 13:49:39 +0100 <dminuoso> And the value is, you have some provable assurance the ordering is preserved by all operations
2020-11-19 13:49:46 +0100 <boxscape> yes
2020-11-19 13:50:24 +0100 <dminuoso> (in the absence of shortcircuiting the proof with bottom, of course)
2020-11-19 13:50:34 +0100p0a(~user@unaffiliated/p0a) (Quit: bye)
2020-11-19 13:50:45 +0100 <boxscape> right, though at least you can be sure that if your program *does* produce a result, it's a correct result
2020-11-19 13:51:07 +0100 <dminuoso> well that depends though, if the proof of transitivity is just bottom.. ?
2020-11-19 13:51:13 +0100 <dminuoso> It has to be runnable code
2020-11-19 13:51:21 +0100 <Boomerang> We use Refl very often at work when writing circuits in Clash. Clash uses type level Nat everywhere, it's often useful to choose which sub-circuit to use depending on the type
2020-11-19 13:51:59 +0100 <boxscape> right, it's still run to construct the actual proof object. Richard Eisenberg actually suggested in his thesis to replace equality proofs with unsafeCoerce Refl via a rewrite rule if you're sure they're total, for performance's sake
2020-11-19 13:52:10 +0100gxt(~gxt@gateway/tor-sasl/gxt)
2020-11-19 13:53:24 +0100 <dminuoso> Ah right, because Refl still has a runtime representation
2020-11-19 13:53:31 +0100 <boxscape> yeah
2020-11-19 13:59:23 +0100 <boxscape> (Though you can't do this unsafeCoerce stuff with all proofs, because for less-than for example, proofs will typically have different run-time reprenentations depending on how large the difference between the two values is, at least for comparing data Nat = S Nat | Z)
2020-11-19 14:00:15 +0100shangxiao(~davids@101.181.159.140) (Quit: WeeChat 2.9)
2020-11-19 14:01:59 +0100 <boxscape> (that is, data (<) :: Nat -> Nat -> Type where ZltS :: Z < (S n); SltS :: n < m -> (S n) < (S m), so for example SltS (SltS (ZltS) :: 2 < 5)
2020-11-19 14:02:19 +0100 <boxscape> (I guess what matters there is actually the size of the first value, not the difference between them)
2020-11-19 14:02:30 +0100troydm(~troydm@unaffiliated/troydm) (Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset)
2020-11-19 14:02:36 +0100elliott__(~elliott@pool-108-51-141-12.washdc.fios.verizon.net) (Ping timeout: 240 seconds)
2020-11-19 14:03:08 +0100elliott__(~elliott@pool-108-51-141-12.washdc.fios.verizon.net)
2020-11-19 14:03:11 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:6c29:bc9c:b97a:2b45)
2020-11-19 14:05:15 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2020-11-19 14:07:41 +0100xacktm(xacktm@gateway/shell/panicbnc/x-fxbrslxxjjorsbbu)
2020-11-19 14:07:47 +0100kritzefitz(~kritzefit@fw-front.credativ.com) (Read error: Connection timed out)
2020-11-19 14:08:15 +0100n0042(d055ed89@208.85.237.137)
2020-11-19 14:10:14 +0100urodna(~urodna@unaffiliated/urodna)
2020-11-19 14:12:47 +0100texasmynsted(~texasmyns@212.102.45.112)
2020-11-19 14:13:16 +0100valdyn(~valdyn@host-88-217-143-53.customer.m-online.net) (Ping timeout: 260 seconds)
2020-11-19 14:14:29 +0100geekosaur(82659a09@host154-009.vpn.uakron.edu)
2020-11-19 14:15:55 +0100christo(~chris@81.96.113.213)
2020-11-19 14:16:00 +0100jwynn6(~jwynn6@050-088-122-078.res.spectrum.com) (Read error: Connection reset by peer)
2020-11-19 14:16:19 +0100jwynn6(~jwynn6@050-088-122-078.res.spectrum.com)
2020-11-19 14:18:14 +0100tromp_(~tromp@dhcp-077-249-230-040.chello.nl)
2020-11-19 14:18:15 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Read error: Connection reset by peer)
2020-11-19 14:21:47 +0100bitmapper(uid464869@gateway/web/irccloud.com/x-xpsufctbszodgohs) (Quit: Connection closed for inactivity)
2020-11-19 14:22:26 +0100troydm(~troydm@unaffiliated/troydm)
2020-11-19 14:22:36 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 265 seconds)
2020-11-19 14:24:45 +0100chalkmonster(~chalkmons@unaffiliated/chalkmonster) (Ping timeout: 240 seconds)
2020-11-19 14:24:57 +0100kritzefitz(~kritzefit@fw-front.credativ.com)
2020-11-19 14:31:30 +0100aarvar(~foewfoiew@50.35.43.33)
2020-11-19 14:31:36 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-19 14:32:47 +0100christo(~chris@81.96.113.213)
2020-11-19 14:32:57 +0100cosimone(~cosimone@2001:b07:ae5:db26:d849:743b:370b:b3cd)
2020-11-19 14:33:46 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:6c29:bc9c:b97a:2b45) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-19 14:35:42 +0100n0042(d055ed89@208.85.237.137) (Remote host closed the connection)
2020-11-19 14:38:46 +0100gnumonic_(~gnumonic@c-73-170-91-210.hsd1.ca.comcast.net) (Read error: Connection reset by peer)
2020-11-19 14:39:37 +0100n0042(d055ed89@208.85.237.137)
2020-11-19 14:39:49 +0100LKoen(~LKoen@169.244.88.92.rev.sfr.net)
2020-11-19 14:40:00 +0100hackagesubG 0.4.1.0 - Some extension to the Foldable and Monoid classes. https://hackage.haskell.org/package/subG-0.4.1.0 (OleksandrZhabenko)
2020-11-19 14:40:22 +0100 <n0042> Are there any rules or guidelines for messing with the Lambdabot? That looks like fun but I don't want to break it or anything
2020-11-19 14:40:59 +0100 <Uniaika> don't try to form an emotional connection with it, you'll be disappointed
2020-11-19 14:41:21 +0100 <n0042> :O
2020-11-19 14:41:31 +0100 <boxscape> n0042 you may know this but if you want to mess with it without spamming #haskell, you can do so in DMs. If you do find a way to break it, seems like a great opportunity for a bug report
2020-11-19 14:41:34 +0100 <boxscape> @botsnack
2020-11-19 14:41:34 +0100 <lambdabot> :)
2020-11-19 14:41:36 +0100 <geekosaur> .oO { if you can break it, we did it wrong }
2020-11-19 14:41:36 +0100 <tdammers> I thought lambdabot was a "she"?
2020-11-19 14:42:08 +0100 <Uniaika> I don't have a habit of anthropomorphising bots
2020-11-19 14:42:10 +0100 <n0042> Thank you boxscape. That is a good tip
2020-11-19 14:42:25 +0100 <tdammers> ships are "she" too
2020-11-19 14:43:13 +0100 <Uniaika> tdammers: that's a maritime culture convention :P
2020-11-19 14:43:33 +0100 <boxscape> countries do, too
2020-11-19 14:43:42 +0100 <boxscape> s/do/are
2020-11-19 14:43:53 +0100 <Uniaika> is that so?
2020-11-19 14:44:18 +0100 <boxscape> yes, I mostly hear it in geopolitical commentary
2020-11-19 14:44:26 +0100 <boxscape> or cgpgrey's videos
2020-11-19 14:44:39 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:2da3:37d0:5114:5834)
2020-11-19 14:46:07 +0100 <boxscape> ..or, actually, I think in geopolitical commentary I usually see the capital being used
2020-11-19 14:46:24 +0100cads(~cads@ip-64-72-99-232.lasvegas.net) (Ping timeout: 260 seconds)
2020-11-19 14:46:40 +0100 <n0042> That's definitely a thing.
2020-11-19 14:46:41 +0100 <tdammers> Uniaika: if sailors can have weird traditions, why can't we
2020-11-19 14:47:24 +0100 <boxscape> because if you anthropomorphize lambdabot, you'll form emotional connections with it, and as we learned that means you'll be disappointed
2020-11-19 14:47:32 +0100wei2912(~wei2912@unaffiliated/wei2912) (Remote host closed the connection)
2020-11-19 14:47:57 +0100 <ski> lambdabot was anthropomorphized as a she, rather long ago, yes
2020-11-19 14:48:06 +0100 <dminuoso> authoritatively?
2020-11-19 14:48:19 +0100dminuosodidn't get the memo
2020-11-19 14:48:27 +0100 <n0042> What is the command to make Lambdabot evaluate an expression or list comprehension?
2020-11-19 14:48:47 +0100 <boxscape> > [ x | x <- [1..5] ]
2020-11-19 14:48:49 +0100 <lambdabot> [1,2,3,4,5]
2020-11-19 14:48:56 +0100 <ski> the South Park style avatar for lambdabot, chosen by voting in #haskell-blah, was definitely female
2020-11-19 14:48:59 +0100 <dminuoso> > fix error
2020-11-19 14:49:02 +0100 <lambdabot> "*Exception: *Exception: *Exception: *Exception: *Exception: *Exception: *Ex...
2020-11-19 14:49:03 +0100machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2020-11-19 14:49:09 +0100 <boxscape> (a list comprehension is an expression fwiw)
2020-11-19 14:49:12 +0100 <Uniaika> ski: is that channel still alive?
2020-11-19 14:49:17 +0100 <boxscape> ish
2020-11-19 14:49:23 +0100__monty_1(~toonn@unaffiliated/toonn)
2020-11-19 14:49:24 +0100 <boxscape> #haskell-offtopic is more popular
2020-11-19 14:49:34 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:2da3:37d0:5114:5834) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-19 14:49:36 +0100 <dminuoso> ski: Maybe we could have the Haskell Foundation make an announcement then, as their first official act.
2020-11-19 14:49:43 +0100 <dminuoso> It seems relevant.
2020-11-19 14:49:58 +0100 <Uniaika> hahaha
2020-11-19 14:50:05 +0100__monty__(~toonn@unaffiliated/toonn) (Ping timeout: 240 seconds)
2020-11-19 14:50:05 +0100 <n0042> Excellent, thank you. I tried to do it without a space after the prompt, which is why it wasn't working.
2020-11-19 14:50:11 +0100 <ski> i'm not sure if the page where there were some South Park style avatars for some people on #haskell / #haskell-blah, is still available somewhere. the original link doesn't work anymore, at least
2020-11-19 14:51:08 +0100skiidly recalls the `@vixen' command
2020-11-19 14:52:21 +0100 <hpc> i liked it better when @vixen was removed and it autocorrected to @nixon :D
2020-11-19 14:52:33 +0100FreeBirdLjj(~freebirdl@101.228.42.108)
2020-11-19 14:52:40 +0100 <ski> that still happens
2020-11-19 14:53:08 +0100 <boxscape> https://wiki.haskell.org/Lambdabot still has the lambdabot avatar, at least
2020-11-19 14:53:22 +0100 <ski> yes, that was the one
2020-11-19 14:54:53 +0100 <ski> (i think the idea was to portray someone being a bit overworked, eyes glazing over, by lots of queries, many of them not that interesting)
2020-11-19 14:56:12 +0100 <ski> but there were also some similar style avatars selected, by some other channel regulars, including shapr, me, Philippa, &c.
2020-11-19 14:57:28 +0100FreeBirdLjj(~freebirdl@101.228.42.108) (Remote host closed the connection)
2020-11-19 14:58:07 +0100 <siraben> What's the shortest way to write r x y z = y z x, in pointfree?
2020-11-19 14:58:22 +0100 <siraben> @pl \x y z -> y z x
2020-11-19 14:58:22 +0100 <lambdabot> flip flip
2020-11-19 14:58:37 +0100 <ski> @keal
2020-11-19 14:58:37 +0100 <lambdabot> i try make program called Glyph to do it but my script lang called T too slow. i invent T
2020-11-19 14:58:47 +0100 <ski> @palomer
2020-11-19 14:58:47 +0100 <lambdabot> Brump!
2020-11-19 15:01:04 +0100 <n0042> That's a pretty great bot lol. Its creators should be proud
2020-11-19 15:01:20 +0100FreeBirdLjj(~freebirdl@101.228.42.108)
2020-11-19 15:02:31 +0100lep-deletetest
2020-11-19 15:03:00 +0100testGuest56787
2020-11-19 15:03:07 +0100Guest56787lep-delete
2020-11-19 15:03:23 +0100 <boxscape> tbh I tend to use yahb more often these days, it's nice to have a proper ghci with alls bells and whistles. Then again, you can't do this with yahb:
2020-11-19 15:03:24 +0100 <boxscape> @pl \a b d c d e f -> f b d c a e
2020-11-19 15:03:24 +0100 <lambdabot> ((const . ((flip .) .)) .) . flip (flip . ((flip . (flip .)) .) . flip . (flip .) . flip . flip id)
2020-11-19 15:04:01 +0100 <siraben> boxscape: yahb?
2020-11-19 15:04:15 +0100 <boxscape> % print "yahb"
2020-11-19 15:04:15 +0100 <yahb> boxscape: "yahb"
2020-11-19 15:04:31 +0100hackageprolude 0.0.0.9 - ITProTV's custom prelude https://hackage.haskell.org/package/prolude-0.0.0.9 (saramuse)
2020-11-19 15:04:43 +0100skiremembers preflex
2020-11-19 15:08:56 +0100invaser1(~Thunderbi@31.148.23.125)
2020-11-19 15:10:03 +0100 <kuribas> I was just thinking how similar destructuring syntax for records in haskell is to clojure hashmaps.
2020-11-19 15:10:15 +0100 <kuribas> with NamedFieldPuns it's almost the same.
2020-11-19 15:10:36 +0100invaser(~Thunderbi@31.148.23.125) (Ping timeout: 240 seconds)
2020-11-19 15:10:36 +0100invaser1invaser
2020-11-19 15:11:16 +0100howdoi(uid224@gateway/web/irccloud.com/x-zkpwgkjicmhndtdh)
2020-11-19 15:11:24 +0100 <kuribas> And while haskell records are not extensible, you can still simulate it with overloadedFields and RecordWildCards.
2020-11-19 15:12:00 +0100hackagesubG 0.4.2.0 - Some extension to the Foldable and Monoid classes. https://hackage.haskell.org/package/subG-0.4.2.0 (OleksandrZhabenko)
2020-11-19 15:12:05 +0100 <kuribas> For example merging: merge PartialUser1{..} PartialUser2{..} = User{..}
2020-11-19 15:12:58 +0100 <kuribas> the "drawback" is having to define partial types, although I think that's a feature, not a drawback.
2020-11-19 15:13:16 +0100ft(~ft@shell.chaostreff-dortmund.de) (Ping timeout: 246 seconds)
2020-11-19 15:13:50 +0100 <kuribas> haskell has a reputation for being terrible with records, my experience is quite positive.
2020-11-19 15:14:35 +0100 <ski> it's too bad that Haskell records binds selector functions to the field names
2020-11-19 15:14:46 +0100 <kuribas> yeah true
2020-11-19 15:14:56 +0100hexfive(~hexfive@50-47-142-195.evrt.wa.frontiernet.net)
2020-11-19 15:14:59 +0100 <ski> the ML way is, imho, much better
2020-11-19 15:15:14 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-19 15:16:36 +0100aveltras(uid364989@gateway/web/irccloud.com/x-jtdricnolbjelrxi)
2020-11-19 15:16:47 +0100christo(~chris@81.96.113.213)
2020-11-19 15:17:14 +0100 <merijn> ski: That's fixed soon!
2020-11-19 15:17:26 +0100 <kuribas> and with overloadedLabels selector functions are even more useless
2020-11-19 15:17:26 +0100 <merijn> ski: There was a GHC proposal for -XNoFieldSelectors
2020-11-19 15:17:28 +0100 <ski> writing `#x pt' or `pt #x' or something along those lines would be much better than to write `x pt'. that way, you don't shadow the field extraction, with `NamedFieldPuns'
2020-11-19 15:17:44 +0100 <merijn> ski: It's already implemented and slated to merge into 9.2, iirc?
2020-11-19 15:18:06 +0100hseg(~gesh@185.120.126.113)
2020-11-19 15:18:06 +0100 <ski> yea, i've heard that mentioned. is there are proposal for a replacement field selector syntax, that you know ?
2020-11-19 15:18:07 +0100Lycurgus(~niemand@cpe-45-46-142-188.buffalo.res.rr.com)
2020-11-19 15:18:31 +0100oish(~charlie@228.25.169.217.in-addr.arpa) (Ping timeout: 246 seconds)
2020-11-19 15:18:39 +0100 <merijn> Not directly, but if you use it the namespace is free to generate, for example, lenses with the field names
2020-11-19 15:18:56 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-19 15:19:07 +0100skinods
2020-11-19 15:20:19 +0100 <xsperry> ski, how does ML do it?
2020-11-19 15:20:39 +0100christo(~chris@81.96.113.213)
2020-11-19 15:20:43 +0100 <ski> (also, users (especially newbies) wouldn't be confused by the cognitive dissonance by the field signature `x :: Int' vs. the field extraction function signature `x :: Point -> Int')
2020-11-19 15:21:18 +0100 <ski> xsperry : if `x' is a field in a record, then `#x' is a field extraction function, taking the record and extracting the field. that's in SML
2020-11-19 15:21:28 +0100 <ski> O'Caml does `pt .x', iirc
2020-11-19 15:21:54 +0100 <xsperry> so fields are in separate namespace?
2020-11-19 15:22:01 +0100 <ski> (but the main point is to not simply bind the field name to a field extraction function)
2020-11-19 15:22:22 +0100 <ski> yes
2020-11-19 15:22:26 +0100cads(~cads@ip-64-72-99-232.lasvegas.net)
2020-11-19 15:22:41 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2020-11-19 15:22:44 +0100renzhi(~renzhi@2607:fa49:655f:e600::28da)
2020-11-19 15:23:17 +0100AlterEgo-(~ladew@124-198-158-163.dynamic.caiway.nl)
2020-11-19 15:23:28 +0100 <xsperry> and what if multiple objects have field named x?
2020-11-19 15:23:33 +0100 <xsperry> multiple types*
2020-11-19 15:23:58 +0100 <merijn> xsperry: With NoFieldSelectors, yes
2020-11-19 15:24:16 +0100 <merijn> xsperry: i.e. you can only use them in pattern matches/record creation
2020-11-19 15:24:18 +0100 <ski> in SML, you must pin down the record type
2020-11-19 15:24:21 +0100 <xsperry> I mean in ML/Ocaml. just wondering if it basically works like structs/classes in mainstream languages
2020-11-19 15:24:26 +0100ft(~ft@shell.chaostreff-dortmund.de)
2020-11-19 15:24:53 +0100 <ski> in OCaml, iirc, field extraction is polymorphic, using row types
2020-11-19 15:25:02 +0100noteness(noteness@unaffiliated/nessessary129)
2020-11-19 15:25:26 +0100 <merijn> ski: uh
2020-11-19 15:25:33 +0100 <merijn> ski: OCaml doesn't have rowtypes, does it?
2020-11-19 15:25:47 +0100 <ski> (ML is a family of languages, including SML,O'Caml,F#,Alice ML,..)
2020-11-19 15:25:50 +0100 <ski> it does
2020-11-19 15:25:52 +0100 <merijn> Unless they added those super recently
2020-11-19 15:26:32 +0100forell(~forell@unaffiliated/forell) (Ping timeout: 260 seconds)
2020-11-19 15:28:00 +0100sagax(~sagax_nb@213.138.71.146)
2020-11-19 15:28:12 +0100forell(~forell@unaffiliated/forell)
2020-11-19 15:28:37 +0100Amras(~Amras@unaffiliated/amras0000)
2020-11-19 15:29:38 +0100GilReiter(4d7e19c5@77.126.25.197)
2020-11-19 15:29:56 +0100n0042(d055ed89@208.85.237.137) (Remote host closed the connection)
2020-11-19 15:29:57 +0100 <ski> object types and polymorphic variants have long been in O'Caml
2020-11-19 15:30:00 +0100forell(~forell@unaffiliated/forell) (Client Quit)
2020-11-19 15:30:37 +0100 <ski> "If 'ident denotes an explicit polymorphic variable, and typexpr denotes either an object or polymorphic variant type, the row variable of typexpr is captured by 'ident, and quantified upon."
2020-11-19 15:31:19 +0100elliott__(~elliott@pool-108-51-141-12.washdc.fios.verizon.net) (Ping timeout: 256 seconds)
2020-11-19 15:31:21 +0100forell(~forell@unaffiliated/forell)
2020-11-19 15:34:10 +0100oish(~charlie@217.169.25.228)
2020-11-19 15:34:14 +0100 <ski> "The type <{method-type ;} ..> is the type of an object whose method names and types are described by method-type₁ …, method-typeₙ, possibly some other methods represented by the ellipsis. This ellipsis actually is a special kind of type variable (called row variable in the literature) that stands for any number of extra method types."
2020-11-19 15:34:44 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2020-11-19 15:35:12 +0100 <ski> (that's from <https://caml.inria.fr/pub/docs/manual-ocaml/types.html>)
2020-11-19 15:40:10 +0100ystael(~ystael@209.6.50.55)
2020-11-19 15:40:44 +0100 <ski> xsperry : ah, ok. so it's just method selection for object types that's polymororphic, not field selection for record types. see <
2020-11-19 15:40:50 +0100ystael(~ystael@209.6.50.55) (Read error: Connection reset by peer)
2020-11-19 15:41:55 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh) (Remote host closed the connection)
2020-11-19 15:42:25 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-19 15:43:05 +0100christo(~chris@81.96.113.213)
2020-11-19 15:43:16 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh)
2020-11-19 15:44:55 +0100 <ski> see <https://caml.inria.fr/pub/docs/manual-ocaml/coreexamples.html#ss:record-and-variant-disambiguation> and <https://caml.inria.fr/pub/docs/manual-ocaml/objectexamples.html>
2020-11-19 15:45:01 +0100byorgey(~byorgey@155.138.238.211) (Quit: leaving)
2020-11-19 15:45:13 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-19 15:45:28 +0100geekosaur(82659a09@host154-009.vpn.uakron.edu) (Remote host closed the connection)
2020-11-19 15:45:30 +0100toorevitimirp(~tooreviti@117.182.180.118) (Remote host closed the connection)
2020-11-19 15:46:01 +0100toorevitimirp(~tooreviti@117.182.180.118)
2020-11-19 15:46:23 +0100christo(~chris@81.96.113.213)
2020-11-19 15:46:47 +0100Lycurgus(~niemand@cpe-45-46-142-188.buffalo.res.rr.com) (Quit: Exeunt)
2020-11-19 15:47:26 +0100ystael(~ystael@209.6.50.55)
2020-11-19 15:50:31 +0100hseg(~gesh@185.120.126.113) (Quit: WeeChat 2.9)
2020-11-19 15:50:56 +0100cads(~cads@ip-64-72-99-232.lasvegas.net) (Ping timeout: 240 seconds)
2020-11-19 15:52:19 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de) (Quit: mputz)
2020-11-19 15:53:12 +0100knupfer(~Thunderbi@dynamic-046-114-144-166.46.114.pool.telefonica.de)
2020-11-19 15:55:30 +0100knupfer(~Thunderbi@dynamic-046-114-144-166.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2020-11-19 15:56:36 +0100oish(~charlie@217.169.25.228) (Ping timeout: 240 seconds)
2020-11-19 15:57:52 +0100Sgeo(~Sgeo@ool-18b982ad.dyn.optonline.net)
2020-11-19 16:00:13 +0100LKoen(~LKoen@169.244.88.92.rev.sfr.net) (Read error: Connection reset by peer)
2020-11-19 16:00:13 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 16:00:31 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 16:00:48 +0100DataComputist(~lumeng@static-50-43-26-251.bvtn.or.frontiernet.net) (Quit: Leaving...)
2020-11-19 16:01:34 +0100LKoen(~LKoen@169.244.88.92.rev.sfr.net)
2020-11-19 16:02:39 +0100GilReiter(4d7e19c5@77.126.25.197) (Remote host closed the connection)
2020-11-19 16:07:38 +0100nbloomf(~nbloomf@76.217.43.73)
2020-11-19 16:08:35 +0100conal(~conal@64.71.133.70)
2020-11-19 16:08:50 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net)
2020-11-19 16:09:46 +0100coco(~coco@212-51-146-87.fiber7.init7.net) (Quit: WeeChat 2.9)
2020-11-19 16:12:02 +0100xff0x(~fox@2001:1a81:534b:a000:65df:cebc:ef3d:70f7) (Ping timeout: 264 seconds)
2020-11-19 16:12:19 +0100nbloomf(~nbloomf@76.217.43.73) (Ping timeout: 265 seconds)
2020-11-19 16:13:55 +0100xff0x(~fox@141.98.255.145)
2020-11-19 16:14:34 +0100invaser(~Thunderbi@31.148.23.125) (Ping timeout: 272 seconds)
2020-11-19 16:15:20 +0100invaser(~Thunderbi@31.148.23.125)
2020-11-19 16:15:43 +0100alp(~alp@2a01:e0a:58b:4920:7562:27bf:89c5:b0d) (Ping timeout: 272 seconds)
2020-11-19 16:22:18 +0100cfricke(~cfricke@unaffiliated/cfricke) (Quit: WeeChat 2.9)
2020-11-19 16:24:13 +0100xff0x(~fox@141.98.255.145) (Ping timeout: 264 seconds)
2020-11-19 16:24:55 +0100st8less(~st8less@2603:a060:11fd:0:744d:b66f:d608:4e8e)
2020-11-19 16:25:02 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:f4f3:bbb1:9462:91ce)
2020-11-19 16:26:07 +0100xerox_(~xerox@unaffiliated/xerox) (Ping timeout: 260 seconds)
2020-11-19 16:26:09 +0100xff0x(~fox@2001:1a81:534b:a000:65df:cebc:ef3d:70f7)
2020-11-19 16:26:53 +0100xerox_(~xerox@unaffiliated/xerox)
2020-11-19 16:29:55 +0100toorevitimirp(~tooreviti@117.182.180.118) (Read error: Connection reset by peer)
2020-11-19 16:32:36 +0100FreeBirdLjj(~freebirdl@101.228.42.108) (Remote host closed the connection)
2020-11-19 16:35:11 +0100Shiranai(beed0255@gateway/web/cgi-irc/kiwiirc.com/ip.190.237.2.85)
2020-11-19 16:39:03 +0100Sarma(~Amras@unaffiliated/amras0000)
2020-11-19 16:39:15 +0100__monty_1(~toonn@unaffiliated/toonn) (Quit: leaving)
2020-11-19 16:41:03 +0100Amras(~Amras@unaffiliated/amras0000) (Ping timeout: 272 seconds)
2020-11-19 16:46:07 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Ping timeout: 256 seconds)
2020-11-19 16:46:15 +0100ddellacosta(dd@gateway/vpn/mullvad/ddellacosta)
2020-11-19 16:47:04 +0100bitmapper(uid464869@gateway/web/irccloud.com/x-uhdfbowqpmvzztxz)
2020-11-19 16:47:58 +0100Mrkz71(c1ef2595@193-239-37-149.ksi-system.net)
2020-11-19 16:48:41 +0100carlomagno(~cararell@148.87.23.12) (Remote host closed the connection)
2020-11-19 16:49:01 +0100carlomagno(~cararell@148.87.23.5)
2020-11-19 16:51:57 +0100 <dminuoso> Mmm, I have a file with lines of varying indention, and I intend to interpret that as a tree like this https://gist.github.com/dminuoso/7911cb8e16c4de0d48de20e7270ebc68
2020-11-19 16:52:24 +0100 <dminuoso> I can cook up some sort of stateful unfold, but I was wondering whether there was some tree related library that would give me this for free
2020-11-19 16:52:43 +0100northman_(~textual@204.111.252.124)
2020-11-19 16:53:02 +0100 <dminuoso> (Doesnt have to be that exact tree data type)
2020-11-19 16:53:03 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de)
2020-11-19 16:53:55 +0100zebrag(~inkbottle@aaubervilliers-654-1-104-55.w86-212.abo.wanadoo.fr)
2020-11-19 16:56:37 +0100invaser(~Thunderbi@31.148.23.125) (Ping timeout: 264 seconds)
2020-11-19 16:57:28 +0100 <[exa]> dminuoso: you can preprocess the leading whitespace to 'indent' and 'unindent' marks easily, then it's pretty easy to do
2020-11-19 16:57:40 +0100hnOsmium0001(uid453710@gateway/web/irccloud.com/x-lviokxjrzjjmnlqh)
2020-11-19 17:01:39 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2020-11-19 17:01:45 +0100Codaraxis(~Codaraxis@ip68-5-90-227.oc.oc.cox.net)
2020-11-19 17:01:55 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl)
2020-11-19 17:01:59 +0100 <dminuoso> [exa]: Mmm, what kind of un/indent mark are you referring to? Should these become conceptual push/pop instructions of a stack of things?
2020-11-19 17:03:20 +0100Codaraxis_(~Codaraxis@ip68-5-90-227.oc.oc.cox.net) (Ping timeout: 244 seconds)
2020-11-19 17:04:19 +0100Codaraxis_(~Codaraxis@ip68-5-90-227.oc.oc.cox.net)
2020-11-19 17:04:26 +0100vicfred(~vicfred@unaffiliated/vicfred)
2020-11-19 17:05:24 +0100vicfred(~vicfred@unaffiliated/vicfred) (Max SendQ exceeded)
2020-11-19 17:05:48 +0100concept2(~concept2@unaffiliated/tubo) (Ping timeout: 256 seconds)
2020-11-19 17:05:51 +0100vicfred(~vicfred@unaffiliated/vicfred)
2020-11-19 17:06:32 +0100Aquazi(uid312403@gateway/web/irccloud.com/x-sgcggzhikhhgebxn)
2020-11-19 17:06:42 +0100Shiranai(beed0255@gateway/web/cgi-irc/kiwiirc.com/ip.190.237.2.85) (Quit: Connection closed)
2020-11-19 17:06:47 +0100concept2(~concept2@unaffiliated/tubo)
2020-11-19 17:06:59 +0100vicfred(~vicfred@unaffiliated/vicfred) (Max SendQ exceeded)
2020-11-19 17:07:26 +0100vicfred(~vicfred@unaffiliated/vicfred)
2020-11-19 17:07:54 +0100Codaraxis(~Codaraxis@ip68-5-90-227.oc.oc.cox.net) (Ping timeout: 265 seconds)
2020-11-19 17:08:34 +0100vicfred(~vicfred@unaffiliated/vicfred) (Max SendQ exceeded)
2020-11-19 17:09:05 +0100vicfred(~vicfred@unaffiliated/vicfred)
2020-11-19 17:11:15 +0100 <[exa]> dminuoso: yeah, it's not supersmart but safest way around I found
2020-11-19 17:11:17 +0100hyperisco(~hyperisco@d192-186-117-226.static.comm.cgocable.net)
2020-11-19 17:12:01 +0100 <dmj`> why can't we :unset -Werror in ghci
2020-11-19 17:14:19 +0100 <dolio> Seems like it doesn't no how to :unset any -W flag.
2020-11-19 17:14:25 +0100 <dolio> Know, even.
2020-11-19 17:15:00 +0100hackagesubG-instances 0.1.0.0 - Additional instances for the InsertLeft class from subG package. https://hackage.haskell.org/package/subG-instances-0.1.0.0 (OleksandrZhabenko)
2020-11-19 17:15:45 +0100 <dminuoso> [exa]: heh yeah that's what Im already doing. I just keep the previous indention as state around, so if it increases it becomes a push on a buffer where I push things onto, and on a pop I just flush the butter
2020-11-19 17:15:49 +0100 <boxscape> does :set -Wno-error work?
2020-11-19 17:15:52 +0100 <dminuoso> this is incredibly imperative, sadly
2020-11-19 17:16:06 +0100 <[exa]> https://gist.github.com/exaexa/9920eb85d2bd20f4c575f2f1d307ae96
2020-11-19 17:16:08 +0100 <dolio> You can `:set -Wwarn`
2020-11-19 17:16:13 +0100 <boxscape> ah
2020-11-19 17:16:14 +0100 <dolio> Which is supposed to reverse it.
2020-11-19 17:16:26 +0100 <dminuoso> % :set -Wno-warn
2020-11-19 17:16:26 +0100 <yahb> dminuoso: ; <no location info>: warning: unrecognised warning flag: -Wno-warn
2020-11-19 17:16:33 +0100 <dminuoso> % :set -Wno-error
2020-11-19 17:16:33 +0100 <yahb> dminuoso: ; <no location info>: warning: unrecognised warning flag: -Wno-error
2020-11-19 17:16:35 +0100 <dminuoso> Mmm
2020-11-19 17:16:45 +0100 <dolio> There's no `no-` for those for some reason.
2020-11-19 17:16:52 +0100northman_(~textual@204.111.252.124) (Quit: Textual IRC Client: www.textualapp.com)
2020-11-19 17:17:02 +0100 <[exa]> dminuoso: I guess there's no better way, the indented stream itself is a series of commands encoded in the spaces...so what. :]
2020-11-19 17:17:03 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Read error: Connection reset by peer)
2020-11-19 17:17:19 +0100 <dminuoso> [exa]: Well I can always throw `indents` at it!
2020-11-19 17:17:41 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2020-11-19 17:18:21 +0100 <boxscape> hm I suppose if -Wno-warn existed the intuitive interpretation would be that it turns off warnings alltogether, and then it would be unclear if -Wno-error should put warnings into -Wwarn mode or into -Wno-warn mode
2020-11-19 17:18:44 +0100northman_(~textual@204.111.252.124)
2020-11-19 17:19:36 +0100invaser(~Thunderbi@31.148.23.125)
2020-11-19 17:19:51 +0100northman_(~textual@204.111.252.124) (Client Quit)
2020-11-19 17:20:12 +0100larou(5eae2591@gateway/web/cgi-irc/kiwiirc.com/ip.94.174.37.145)
2020-11-19 17:20:17 +0100 <larou> hello!
2020-11-19 17:20:42 +0100 <boxscape> hi
2020-11-19 17:20:46 +0100huskyhaskell(~user@2001:9b1:29fe:fc00:55d8:279e:df7e:2d64)
2020-11-19 17:20:52 +0100 <larou> I have code!!
2020-11-19 17:21:10 +0100 <[exa]> dminuoso: careful not to end up with python. :D
2020-11-19 17:21:16 +0100 <larou> no i dont, i only have rumours of code
2020-11-19 17:21:28 +0100northman_(~northman@204.111.252.124)
2020-11-19 17:21:45 +0100huskyhaskell(~user@2001:9b1:29fe:fc00:55d8:279e:df7e:2d64) ()
2020-11-19 17:22:08 +0100 <larou> i have a new type of tree
2020-11-19 17:22:17 +0100howdoi(uid224@gateway/web/irccloud.com/x-zkpwgkjicmhndtdh) (Quit: Connection closed for inactivity)
2020-11-19 17:22:25 +0100 <larou> its better than normal trees
2020-11-19 17:22:41 +0100 <larou> it has upwards branches
2020-11-19 17:22:48 +0100 <larou> iv been trying to do it for ages
2020-11-19 17:22:55 +0100[exa]briefly recalls "normal" trees
2020-11-19 17:23:08 +0100 <larou> yeah, those have only downwards branches
2020-11-19 17:23:32 +0100 <larou> these are way better
2020-11-19 17:23:34 +0100 <[exa]> I mean the nature ones
2020-11-19 17:24:03 +0100 <larou> never mind your vacant wonderings
2020-11-19 17:24:42 +0100 <larou> they typecheck and everything
2020-11-19 17:24:45 +0100 <boxscape> does it have upwards as well as downward branches or only upwards branches?
2020-11-19 17:24:45 +0100knupfer(~Thunderbi@200116b82cfb87004c47b2fffe20891d.dip.versatel-1u1.de)
2020-11-19 17:24:45 +0100knupfer(~Thunderbi@200116b82cfb87004c47b2fffe20891d.dip.versatel-1u1.de) (Client Quit)
2020-11-19 17:25:01 +0100hackagegit-lfs 1.1.1 - git-lfs protocol https://hackage.haskell.org/package/git-lfs-1.1.1 (JoeyHess)
2020-11-19 17:25:05 +0100 <larou> sure, its not just an upside down tree...
2020-11-19 17:25:08 +0100knupfer(~Thunderbi@200116b82cfb8700fd61a7f6e9856548.dip.versatel-1u1.de)
2020-11-19 17:25:14 +0100 <boxscape> ah, good
2020-11-19 17:25:24 +0100 <larou> i put functions on them
2020-11-19 17:25:30 +0100 <larou> at the branches
2020-11-19 17:25:41 +0100 <larou> MIMO functions (multiple inputs multiple outputs)
2020-11-19 17:25:58 +0100 <larou> just one input and one output argument, that are HLists
2020-11-19 17:25:59 +0100boxscapethinks the upwards branches should be called "roots"
2020-11-19 17:26:13 +0100 <larou> original!
2020-11-19 17:26:20 +0100p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515)
2020-11-19 17:26:38 +0100 <larou> i call them output edges
2020-11-19 17:26:43 +0100jneira(02896ac0@gateway/web/cgi-irc/kiwiirc.com/ip.2.137.106.192)
2020-11-19 17:26:47 +0100 <larou> inputs go at the leafs
2020-11-19 17:27:09 +0100 <larou> and they do the cyclic thing perfectly!!!
2020-11-19 17:27:20 +0100 <merijn> So...graphs?
2020-11-19 17:27:21 +0100 <larou> they are a list, instead of a free thing
2020-11-19 17:27:34 +0100cocreature(~cocreatur@eirene.uberspace.de) (Read error: Connection reset by peer)
2020-11-19 17:27:34 +0100 <larou> meijn: no they are trees
2020-11-19 17:27:41 +0100 <larou> they just have lookup tables
2020-11-19 17:27:49 +0100 <larou> but its just the same
2020-11-19 17:27:50 +0100 <merijn> trees are graphs
2020-11-19 17:28:02 +0100 <larou> but graphs can be cyclic, while trees cant
2020-11-19 17:28:04 +0100 <merijn> They're just a more boring subset of graphs (i.e. on without cycles)
2020-11-19 17:28:08 +0100 <larou> thats what makes them trees not graphs
2020-11-19 17:28:11 +0100 <larou> and this is a tree
2020-11-19 17:28:12 +0100cocreature(~cocreatur@eirene.uberspace.de)
2020-11-19 17:28:31 +0100Mrkz71(c1ef2595@193-239-37-149.ksi-system.net) (Remote host closed the connection)
2020-11-19 17:28:33 +0100 <larou> so... not graphs...
2020-11-19 17:28:40 +0100 <larou> i have also "sparks"
2020-11-19 17:28:47 +0100 <larou> these are the bits that make them not graphs
2020-11-19 17:28:58 +0100 <larou> when you see a cycle, you must make a spark
2020-11-19 17:29:01 +0100 <larou> it is a state
2020-11-19 17:29:06 +0100 <[exa]> larou: data structure folks demand a precise written definition
2020-11-19 17:29:11 +0100justan0theruser(~justanoth@unaffiliated/justanotheruser) (Ping timeout: 272 seconds)
2020-11-19 17:29:21 +0100 <merijn> [exa]: non-data structure folk too :p
2020-11-19 17:29:41 +0100 <larou> it goes to an output instead of to the input variable, this is externally stored, as a state, and fed back in at the input at the next itteration
2020-11-19 17:30:07 +0100 <larou> it would have been imposible to reference its current value to calculate itself at this iteration, so it has to be from the last
2020-11-19 17:30:13 +0100 <larou> thats why we get "spark states"
2020-11-19 17:30:51 +0100cosimone(~cosimone@2001:b07:ae5:db26:d849:743b:370b:b3cd) (Quit: cosimone)
2020-11-19 17:31:01 +0100 <[exa]> like seriously, this sounds like the random rnn-generated paper about quantum physics. Get a piece of LaTeX and write it down, with examples and pics.
2020-11-19 17:31:13 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-19 17:31:18 +0100 <larou> [exa]: its definition is an extension of the GADT for list, in that it has extra params on the thing being consed to. also, there is another record to the datatype which just wraps itself, but has a constraint that checks to see the sparks are correct in preventing cycles
2020-11-19 17:31:49 +0100 <larou> oh you want the code, hang on
2020-11-19 17:32:27 +0100enoq(~textual@194-208-146-143.lampert.tv) (Quit: Textual IRC Client: www.textualapp.com)
2020-11-19 17:33:06 +0100 <larou> here
2020-11-19 17:33:07 +0100 <larou> https://pastebin.com/raw/Kq05pARC
2020-11-19 17:34:50 +0100 <larou> and here; https://pastebin.com/raw/gHZaze9F
2020-11-19 17:34:51 +0100 <[exa]> on which line are the trees and sparks?
2020-11-19 17:35:04 +0100 <larou> in the 2nd paste, its "Net"
2020-11-19 17:35:07 +0100Ariakenom(~Ariakenom@h-98-128-229-104.NA.cust.bahnhof.se) (Quit: Leaving)
2020-11-19 17:35:26 +0100Ariakenom(~Ariakenom@h-98-128-229-104.NA.cust.bahnhof.se)
2020-11-19 17:35:50 +0100kritzefitz(~kritzefit@fw-front.credativ.com) (Remote host closed the connection)
2020-11-19 17:36:13 +0100 <[exa]> ok cool, does it work?
2020-11-19 17:36:14 +0100 <larou> now here i can specify the same graph, and using the definition of the input output pairs broken by designating "Sparks"
2020-11-19 17:36:28 +0100 <larou> then, it will return a graph which passes the matrix test
2020-11-19 17:36:33 +0100 <larou> ie, is not cyclic
2020-11-19 17:36:42 +0100 <larou> this is the constraint on the CloseNet constructor
2020-11-19 17:36:58 +0100 <larou> so you can, if you specify the correct sparks, as this check ensures you must
2020-11-19 17:37:04 +0100jakob_(~textual@p200300f49f162200c400a7daff5c73c4.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-11-19 17:38:01 +0100 <larou> you add functions to your net any which old way, and ensure that you have a way in mind to break the cycles (where you put the sparks, which inputs matched with outputs you do not pass as internal edges
2020-11-19 17:38:03 +0100 <larou> )
2020-11-19 17:38:15 +0100 <larou> [exa]: i didnt make a graph yet
2020-11-19 17:38:36 +0100 <larou> i need to shuffle them so the inputs to outputs are well ordered in the list of functions
2020-11-19 17:38:40 +0100bob_twinkles(~quassel@ec2-52-37-66-13.us-west-2.compute.amazonaws.com) (Read error: Connection reset by peer)
2020-11-19 17:38:44 +0100 <larou> so you can supply inputs to each of them in a fold
2020-11-19 17:39:00 +0100 <larou> and the values it calculates serve as inputs to the rest
2020-11-19 17:39:02 +0100knupfer(~Thunderbi@200116b82cfb8700fd61a7f6e9856548.dip.versatel-1u1.de) (Ping timeout: 260 seconds)
2020-11-19 17:39:17 +0100 <larou> you specify type level symbols as annotations to the edges of the Net
2020-11-19 17:39:26 +0100 <larou> thats how these new type of trees work
2020-11-19 17:39:56 +0100 <larou> they dont sit underneath each other in a GADT, appearing as a self reference within a list, like a regular tree
2020-11-19 17:40:20 +0100 <larou> so you give each of the edges a label, and have the nodes that are on either end of it both reference that
2020-11-19 17:40:35 +0100bob_twinkles(~quassel@ec2-52-37-66-13.us-west-2.compute.amazonaws.com)
2020-11-19 17:40:38 +0100 <larou> the matrix is a numerical representation of the resulting adjacency matrix
2020-11-19 17:40:45 +0100 <larou> well, its directed from inputs to outputs
2020-11-19 17:41:11 +0100 <larou> and then you exponentiate that to get, "if it is above itself" which would throw an error as a cycle
2020-11-19 17:41:34 +0100 <larou> the constraint on the CloseNet constructor would not hold
2020-11-19 17:41:44 +0100 <larou> you would have to specify better sparks as a type annotation
2020-11-19 17:42:13 +0100invaser1(~Thunderbi@31.148.23.125)
2020-11-19 17:42:18 +0100 <larou> so what do you recon!? solved the ancient, upwards branching trees thing, finally
2020-11-19 17:42:25 +0100 <merijn> I propose implementing a prototype and showing that to people, rather than roughly explaining in english
2020-11-19 17:42:27 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-19 17:42:40 +0100 <larou> it works as in the links provided
2020-11-19 17:42:50 +0100 <[exa]> cabal install <what>
2020-11-19 17:42:52 +0100 <larou> i dont have it doing what i want yet though
2020-11-19 17:43:06 +0100 <merijn> So...it doesn't work yet
2020-11-19 17:43:16 +0100 <larou> i need to shuffle them so the nodes at the leafs pass inputs along for functions to be evaluated
2020-11-19 17:43:30 +0100 <larou> merijn: exactly what i described is demonstrated in those pastes
2020-11-19 17:43:38 +0100kritzefitz(~kritzefit@212.86.56.80)
2020-11-19 17:43:41 +0100 <larou> what it doesnt do yet, it does not yet do
2020-11-19 17:43:54 +0100 <larou> so its not with "the final demo"
2020-11-19 17:44:04 +0100 <larou> which would probably be what you would want
2020-11-19 17:44:27 +0100 <larou> so, basically its a state function
2020-11-19 17:44:32 +0100 <larou> so i can put it on a graph!
2020-11-19 17:44:36 +0100 <larou> and that makes it a monad
2020-11-19 17:44:39 +0100 <larou> which is pretty mad
2020-11-19 17:44:47 +0100 <larou> the "net" thing, with actual functions on
2020-11-19 17:44:52 +0100invaser(~Thunderbi@31.148.23.125) (Ping timeout: 260 seconds)
2020-11-19 17:44:52 +0100invaser1invaser
2020-11-19 17:44:59 +0100 <larou> its the monad from; "programs are monads"
2020-11-19 17:45:14 +0100 <merijn> "and that makes it a monad" <- I doubt that without a proof
2020-11-19 17:45:14 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 17:45:22 +0100 <larou> i have explicitly named bound variables expressed at type level
2020-11-19 17:45:26 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 17:45:31 +0100 <larou> meijn: it is a monad though...
2020-11-19 17:45:53 +0100justan0theruser(~justanoth@unaffiliated/justanotheruser)
2020-11-19 17:45:56 +0100 <larou> you can break programs down and compose them, programs aka functions
2020-11-19 17:46:10 +0100 <larou> anyway, the point is its a *state*
2020-11-19 17:46:12 +0100 <larou> so it changes
2020-11-19 17:46:17 +0100 <larou> the whole program
2020-11-19 17:46:26 +0100 <larou> and thats where these sparks sit, internally as states
2020-11-19 17:46:51 +0100 <larou> they go along internal edges that you have brokn to make them external inputs and outputs directed to a state variable that acts as a memory store
2020-11-19 17:46:59 +0100 <[exa]> larou: it makes no sense, seriously
2020-11-19 17:47:20 +0100 <larou> you have the graph of functions, and with it, all of the spark states, that are returned when you run the function on its inputs and previous spark states
2020-11-19 17:47:48 +0100 <larou> and you package all of that up as a state function
2020-11-19 17:48:08 +0100pavonia(~user@unaffiliated/siracusa) (Quit: Bye!)
2020-11-19 17:48:15 +0100 <larou> and put it on a graph of functions, with its cycles broken as another layer of sparks, stored as states in another state function wrapper and so on
2020-11-19 17:48:19 +0100oish(~charlie@228.25.169.217.in-addr.arpa)
2020-11-19 17:48:23 +0100 <larou> its the "and so on" thats the monadic recursion
2020-11-19 17:49:01 +0100 <larou> nodes, that internally, are graphs of functions
2020-11-19 17:49:11 +0100 <larou> the "nets as neurons" monad
2020-11-19 17:49:14 +0100Feuermagier(~Feuermagi@213.178.26.41) (Remote host closed the connection)
2020-11-19 17:49:36 +0100 <larou> you partition the program any which way into functions, depending on how you define them and with synonyms
2020-11-19 17:49:43 +0100 <larou> or unpartition it
2020-11-19 17:49:47 +0100 <larou> thats cobind and bind
2020-11-19 17:50:08 +0100 <merijn> Just because you call them that, doesn't mean they obey the monad laws
2020-11-19 17:50:15 +0100 <larou> yeah but they do though
2020-11-19 17:50:37 +0100 <larou> in the same way a tree is
2020-11-19 17:50:47 +0100 <larou> i guess i need them to be nonempty etc
2020-11-19 17:50:58 +0100 <larou> but yeah, theres a monad there, no doubt
2020-11-19 17:51:18 +0100 <larou> anyway, thats not the fun part
2020-11-19 17:51:21 +0100alp(~alp@2a01:e0a:58b:4920:e0d5:8136:ac9f:8cb7)
2020-11-19 17:51:35 +0100 <larou> the spark states get "hidden" when you package them into a state function wrapper placed on the net
2020-11-19 17:51:52 +0100 <larou> because the net can handle state functions, so the sparks just get absorbed by that machinery
2020-11-19 17:52:00 +0100 <larou> you get new nodes to the graph
2020-11-19 17:52:29 +0100 <merijn> I suggest writing a blogpost, rather than writing a novel in a channel meant for discussion
2020-11-19 17:52:42 +0100 <larou> the spark cycles, end up at an input and output terminus, that stores the spark state, and can be written to and read from
2020-11-19 17:52:59 +0100cocreature(~cocreatur@eirene.uberspace.de) (Remote host closed the connection)
2020-11-19 17:53:05 +0100 <larou> merijn: thanks for keeping me on track.
2020-11-19 17:53:21 +0100cocreature(~cocreatur@eirene.uberspace.de)
2020-11-19 17:53:22 +0100 <larou> i have presented these new trees
2020-11-19 17:55:22 +0100mananamenos(~mananamen@84.122.202.215.dyn.user.ono.com) (Ping timeout: 260 seconds)
2020-11-19 17:55:33 +0100 <larou> anyway, all this stuff to do with new nodes for the sparks when the nets handle state functions on the nodes - is just the next part of the todo - and is just to say what i have shown does not yet do
2020-11-19 17:55:46 +0100 <larou> so far it just checks to see that the sparks provided are correct
2020-11-19 17:55:56 +0100 <larou> so you cant make it wrong!
2020-11-19 17:56:04 +0100 <larou> almost as good as making it right...
2020-11-19 17:56:41 +0100 <larou> you basically just have to be sure the edges you define dont cause a cycle
2020-11-19 17:56:50 +0100 <larou> but it will tell you if there is
2020-11-19 17:57:27 +0100 <larou> the only thing worth discussing really is the fact we have a new notion of tree
2020-11-19 17:57:36 +0100 <larou> not, how far i am at making it better
2020-11-19 17:57:50 +0100 <larou> what i show completely defines it
2020-11-19 17:58:07 +0100 <larou> but many other implementations of the same idea exist
2020-11-19 17:58:13 +0100ChanServ+q *!*@*/ip.94.174.37.145
2020-11-19 17:58:52 +0100oish(~charlie@228.25.169.217.in-addr.arpa) (Ping timeout: 260 seconds)
2020-11-19 18:00:02 +0100he9388(2fe3e53b@047-227-229-059.res.spectrum.com)
2020-11-19 18:00:28 +0100 <he9388> Hi everyone, I'm trying to install the Haskell extension for VSCode, and I'm getting the error "Couldn't figure out what GHC version the project is using"
2020-11-19 18:00:43 +0100oish(~charlie@228.25.169.217.in-addr.arpa)
2020-11-19 18:00:48 +0100 <he9388> I couldn't figure out what's the issue. Can anyone give a pointer? Thanks a lot.
2020-11-19 18:01:04 +0100 <merijn> are you using stack or cabal?
2020-11-19 18:01:17 +0100 <he9388> Cabal
2020-11-19 18:01:32 +0100 <he9388> Or I believe so at least...
2020-11-19 18:01:35 +0100 <merijn> he9388: Is GHC in your path?
2020-11-19 18:01:51 +0100 <he9388> Which path?
2020-11-19 18:01:57 +0100 <he9388> Sorry, I am beginner :)
2020-11-19 18:03:05 +0100invaser(~Thunderbi@31.148.23.125) (Ping timeout: 240 seconds)
2020-11-19 18:03:10 +0100 <he9388> I get some message like this:Couldn't figure out what GHC version the project is using: /home/he/.config/Code/User/globalStorage/haskell.haskell/haskell-language-server-wrapper-0.6.0-linux --project-ghc-version exited with exit code 1: Module "/home/he/Documents/learn4haskell/a" is loaded by Cradle: Cradle {cradleRootDir =
2020-11-19 18:03:11 +0100 <he9388> "/home/he/Documents/learn4haskell", cradleOptsProg = CradleAction: Cabal} Failed to get project GHC version:CradleError {cradleErrorDependencies = [], cradleErrorExitCode = ExitFailure 1, cradleErrorStderr = ["Error when calling cabal v2-exec ghc -v0 -- --numeric-version","","cabal: unrecognised command: v2-exec (try --help)\n"]}
2020-11-19 18:03:17 +0100 <merijn> he9388: Let's rewind further: What OS? :p
2020-11-19 18:03:20 +0100jlamothe(~jlamothe@198.251.55.207)
2020-11-19 18:03:26 +0100 <he9388> I am on Ubuntu
2020-11-19 18:03:41 +0100 <merijn> he9388: If you run "which ghc" in your shell, what do you get?
2020-11-19 18:03:55 +0100byorgey(~byorgey@155.138.238.211)
2020-11-19 18:04:20 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-19 18:04:25 +0100 <he9388> Ok, weird, I ran in two different directory and got two different location :)
2020-11-19 18:04:44 +0100 <he9388> One I get: /usr/bin/ghc. The other: /home/he/.ghcup/bin/ghc
2020-11-19 18:05:15 +0100 <merijn> The first is probably from your package manager, the second from ghcup. So step one is figuring out which you want :p
2020-11-19 18:05:26 +0100invaser(~Thunderbi@31.148.23.125)
2020-11-19 18:05:55 +0100 <he9388> What's the difference :)
2020-11-19 18:06:05 +0100 <monochrom> Ubuntu's is much older.
2020-11-19 18:06:18 +0100 <he9388> Then probably I'll stick to the new one
2020-11-19 18:06:37 +0100ubert(~Thunderbi@2a02:8109:9880:303c:ca5b:76ff:fe29:f233) (Remote host closed the connection)
2020-11-19 18:06:38 +0100 <monochrom> How old? How bad? Answer: So old that only a few profs who never take a look at the current outside world still think it's in use.
2020-11-19 18:06:52 +0100valdyn(~valdyn@host-88-217-143-53.customer.m-online.net)
2020-11-19 18:07:20 +0100 <monochrom> So old that it's like some Windows users hold on to Windows 98 because they still hold on to WinFax. (OK this is an exaggeration.)
2020-11-19 18:07:39 +0100 <he9388> Point taken, ready to get rid of it :)
2020-11-19 18:07:58 +0100mananamenos(~mananamen@84.122.202.215.dyn.user.ono.com)
2020-11-19 18:08:14 +0100 <merijn> he9388: Also, ghcup lets you install multiple different versions at the same time so you can test across compiler versions
2020-11-19 18:08:22 +0100 <he9388> What's the proper way to get rid of it
2020-11-19 18:08:33 +0100 <monochrom> sudo apt remove
2020-11-19 18:08:50 +0100 <he9388> oh right
2020-11-19 18:08:54 +0100 <he9388> was almost going to rm -rf it...
2020-11-19 18:09:04 +0100geekosaur(82659a09@host154-009.vpn.uakron.edu)
2020-11-19 18:09:24 +0100 <he9388> now it says ghc not found
2020-11-19 18:09:28 +0100 <he9388> when I run which ghc
2020-11-19 18:09:31 +0100hackagerosebud 0.2.0.0 - Common rose tree/forest functions https://hackage.haskell.org/package/rosebud-0.2.0.0 (jship)
2020-11-19 18:10:05 +0100 <monochrom> You will need /home/he/.ghcup/bin to be an element of your PATH
2020-11-19 18:10:24 +0100 <he9388> OK, got it! Now this part works
2020-11-19 18:11:06 +0100motte(~weechat@unaffiliated/motte) (Quit: WeeChat 1.9.1)
2020-11-19 18:12:14 +0100 <he9388> Now I am getting this error message: The Haskell (learn4haskell) server crashed 5 times in the last 3 minutes. The server will not be restarted.
2020-11-19 18:12:39 +0100cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net)
2020-11-19 18:12:43 +0100 <merijn> hmm, what's learn4haskell?
2020-11-19 18:13:19 +0100 <he9388> https://github.com/kowainik/learn4haskell
2020-11-19 18:13:26 +0100 <he9388> It's tutorial I'm going through :)
2020-11-19 18:13:44 +0100acidjnk_new(~acidjnk@p200300d0c719ff57608036dc958592ad.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-11-19 18:13:44 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 18:14:01 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 18:14:31 +0100 <merijn> hmmm
2020-11-19 18:14:44 +0100 <he9388> Why should the extension be dependent on the server?
2020-11-19 18:15:15 +0100 <monochrom> Never heard of it.
2020-11-19 18:15:18 +0100jneira(02896ac0@gateway/web/cgi-irc/kiwiirc.com/ip.2.137.106.192) (Quit: Ping timeout (120 seconds))
2020-11-19 18:16:11 +0100 <merijn> he9388: No clue. tbh, the editor plugin landscape has evolved rather dramatically over the past year, but it isn't quite at the "works reliably in all setups" state yet
2020-11-19 18:17:01 +0100 <merijn> That said, for the vast majority of my haskell career I've worked without editor plugins just fine. It's not ideal, but I can't really recommend investing a lot of time into getting it working now
2020-11-19 18:17:22 +0100 <he9388> Having type checking would be nice :)
2020-11-19 18:17:40 +0100 <he9388> I'm just starting to develop
2020-11-19 18:18:12 +0100 <merijn> he9388: Yeah, but the current editor plugin landscape that you can either invest hours fixing things or wait a month and the plugins has improved much more :p
2020-11-19 18:18:22 +0100 <monochrom> -fdefer-type-errors achieves 90% of the same goal at 0.1% of the cost
2020-11-19 18:18:43 +0100 <merijn> monochrom: -fdefer-typed-holes >> -fdefer-type-errors :)
2020-11-19 18:19:18 +0100 <merijn> he9388: You can always try something like ghcid running in a separate terminal
2020-11-19 18:19:28 +0100 <monochrom> It means it demotes die-hard-erroring-out to just warning. This means functions that are unaffected by the type error are still usable, so you can continue to explore and figure out what to do.
2020-11-19 18:19:53 +0100 <merijn> he9388: That gets you 80% of the way there
2020-11-19 18:20:16 +0100 <monochrom> my "cost" refers to installation cost
2020-11-19 18:20:59 +0100 <monochrom> cost of one-time installing extra software and long-time babysitting said fragile perpetually-in-beta-quality software
2020-11-19 18:21:05 +0100 <he9388> Did not know about ghcide either haha
2020-11-19 18:21:06 +0100 <monochrom> s/long-time/long-term/
2020-11-19 18:21:21 +0100 <merijn> he9388: Confusingly ghcid and ghcide are different things :)
2020-11-19 18:21:22 +0100 <monochrom> Oh, and ghcid != ghcide
2020-11-19 18:21:43 +0100 <he9388> oh
2020-11-19 18:21:45 +0100 <monochrom> This is ghcid: http://hackage.haskell.org/package/ghcid
2020-11-19 18:22:05 +0100 <merijn> he9388: ghcide is what your current plugin probably uses, but it's not as robust as ghcid yet. ghcid is basically a program that just repeatedly runs compile for you and reports errors
2020-11-19 18:22:30 +0100larou(5eae2591@gateway/web/cgi-irc/kiwiirc.com/ip.94.174.37.145) (Quit: Connection closed)
2020-11-19 18:22:51 +0100 <monochrom> It is just an inotify loop over "oh you have updated Foo.hs again, so let me run ghc again so you see the error messages"
2020-11-19 18:23:17 +0100crdrost(~crdrost@c-98-207-102-156.hsd1.ca.comcast.net)
2020-11-19 18:23:32 +0100 <monochrom> I think it is very misleading to call it anything related to IDE.
2020-11-19 18:23:44 +0100 <monochrom> I would describe it as continuous smoke-testing
2020-11-19 18:24:04 +0100 <sm[m]> I will say that VS Code + Haskell extension is quite likely to just work and give he9388 a really nice experience these days
2020-11-19 18:24:15 +0100 <monochrom> You save a file, it reruns type checking, build checking, and test cases.
2020-11-19 18:24:19 +0100 <he9388> I am using VS Code + Haskell extension actually...
2020-11-19 18:24:41 +0100 <sm[m]> he9388: isn't it giving you realtime type errors, types on hover, etc ?
2020-11-19 18:24:50 +0100 <merijn> monochrom: Well to be fair it was "ghci daemon", presumably
2020-11-19 18:25:01 +0100 <merijn> sm[m]: Well, no, it kept crashing, hence the start of this discussion :p
2020-11-19 18:25:08 +0100 <he9388> Oh, the extension is not loading: when I make new folder, I got "The Haskell (test) server crashed 5 times in the last 3 minutes. The server will not be restarted"
2020-11-19 18:25:19 +0100 <sm[m]> oops, missed that. #haskell-ide-engine would help
2020-11-19 18:25:28 +0100 <sm[m]> would also help.
2020-11-19 18:25:35 +0100 <he9388> Ok, thank you for the reference
2020-11-19 18:26:15 +0100aveltras(uid364989@gateway/web/irccloud.com/x-jtdricnolbjelrxi) (Quit: Connection closed for inactivity)
2020-11-19 18:26:45 +0100christo(~chris@81.96.113.213) (Read error: Connection reset by peer)
2020-11-19 18:27:09 +0100christo(~chris@81.96.113.213)
2020-11-19 18:30:37 +0100alp(~alp@2a01:e0a:58b:4920:e0d5:8136:ac9f:8cb7) (Ping timeout: 272 seconds)
2020-11-19 18:31:06 +0100howdoi(uid224@gateway/web/irccloud.com/x-dgisunxwmcstbixs)
2020-11-19 18:33:16 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 240 seconds)
2020-11-19 18:35:49 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2020-11-19 18:36:27 +0100glguy(x@freenode/staff/haskell.developer.glguy) (Ping timeout: 615 seconds)
2020-11-19 18:36:51 +0100glguy(x@freenode/staff/haskell.developer.glguy)
2020-11-19 18:37:25 +0100kav(~kari@dsl-hkibng42-56733f-225.dhcp.inet.fi) (Ping timeout: 240 seconds)
2020-11-19 18:37:40 +0100valdyn(~valdyn@host-88-217-143-53.customer.m-online.net) (Read error: No route to host)
2020-11-19 18:37:48 +0100justsomeguy(~justsomeg@unaffiliated/--/x-3805311) ()
2020-11-19 18:38:20 +0100avn(~avn@78-56-108-78.static.zebra.lt) (Ping timeout: 260 seconds)
2020-11-19 18:38:51 +0100ph88^(~ph88@2a02:8109:9e00:7e5c:f073:c081:c2ef:433b) (Ping timeout: 272 seconds)
2020-11-19 18:38:52 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 18:40:40 +0100Boomerang(~Boomerang@xd520f68c.cust.hiper.dk) (Ping timeout: 260 seconds)
2020-11-19 18:41:16 +0100alp(~alp@2a01:e0a:58b:4920:6867:806e:6b2d:b0d)
2020-11-19 18:42:08 +0100 <koz_> monochrom: I don't recall if it was you, but someone complained that we say 'Big-O', not 'Big-omikron'. Bird and Gibbons' algorithms book is here to right this wrong!
2020-11-19 18:42:31 +0100hackageeasy-args 0.1.0.1 - Parses command line arguments https://hackage.haskell.org/package/easy-args-0.1.0.1 (jlamothe)
2020-11-19 18:42:33 +0100 <boxscape> "Big-omikron" isn't that just regular o
2020-11-19 18:42:44 +0100 <merijn> I say death to Big O analysis :p
2020-11-19 18:43:11 +0100 <merijn> It's just a mathematical way of lying about performance :p
2020-11-19 18:43:31 +0100hackagecryptol 2.10.0 - Cryptol: The Language of Cryptography https://hackage.haskell.org/package/cryptol-2.10.0 (AaronTomb)
2020-11-19 18:43:41 +0100 <c_wraith> People are very bad at it, and believe lies like "hash table insert and lookup are O(1)" with shocking credulity
2020-11-19 18:44:09 +0100 <merijn> c_wraith: A reasonable number people know about *that*
2020-11-19 18:44:24 +0100codeAlways(uid272474@gateway/web/irccloud.com/x-rnqcrwigssxuyxdw) (Quit: Connection closed for inactivity)
2020-11-19 18:44:30 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Quit: WeeChat 2.8)
2020-11-19 18:44:53 +0100avn(~avn@78-56-108-78.static.zebra.lt)
2020-11-19 18:44:53 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2020-11-19 18:45:15 +0100 <merijn> The people that realise "the fundamental base of assumption of Big O is just 100% lies" is dramatically less :p
2020-11-19 18:46:39 +0100 <boxscape> which assumption is that?
2020-11-19 18:46:51 +0100 <maerwald> it's one of those things that make you look smart in interviews
2020-11-19 18:46:54 +0100 <dminuoso> boxscape: Stuff like constant random memory access.
2020-11-19 18:46:59 +0100 <merijn> It only seems to work because people in general mostly only care about the happy path
2020-11-19 18:47:04 +0100kav(~kari@dsl-hkibng42-56733f-225.dhcp.inet.fi)
2020-11-19 18:47:14 +0100 <koz_> maerwald: Alternatively, if you inhabit certain academic spaces.
2020-11-19 18:47:17 +0100 <koz_> (which was my fate)
2020-11-19 18:47:22 +0100 <dminuoso> If that's your model of computation, fine, but the truth of the matter is memory access is not constant on a computer implemented within the laws of physics.
2020-11-19 18:47:27 +0100 <merijn> boxscape: random memory access is constant time
2020-11-19 18:47:40 +0100 <c_wraith> that's only an assumption if you make it one...
2020-11-19 18:47:40 +0100 <merijn> maerwald: It has real world implications
2020-11-19 18:47:44 +0100 <boxscape> is the problem there caching or something else?
2020-11-19 18:47:48 +0100 <merijn> boxscape: Yeah
2020-11-19 18:47:51 +0100 <boxscape> I see
2020-11-19 18:47:57 +0100 <koz_> Yeah, the memory hierarchy is a thing.
2020-11-19 18:47:58 +0100 <dminuoso> boxscape: blackhole thermodynamics and relativity, roughly
2020-11-19 18:48:01 +0100 <koz_> For good reason.
2020-11-19 18:48:12 +0100 <merijn> You can construct algorithms that are "worse" per big O complexity while being *much* faster in reality
2020-11-19 18:48:36 +0100 <koz_> merijn: And that's before we get to abuses of the form 'simplex is exponential'.
2020-11-19 18:48:55 +0100 <merijn> c_wraith: eh, that assumption is baked into classical big O analysis as taught in CS and parroted when talking data structure complexity
2020-11-19 18:49:10 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-19 18:49:24 +0100 <c_wraith> merijn: hmm. not in my courses/textbooks. They explicitly called out that they were working in the RAM model
2020-11-19 18:49:24 +0100 <dminuoso> c_wraith: Well, the question is what conclusions you can draw from complexity analysis if the model doesn't fit reality well
2020-11-19 18:50:22 +0100kav(~kari@dsl-hkibng42-56733f-225.dhcp.inet.fi) (Read error: Connection timed out)
2020-11-19 18:50:25 +0100 <merijn> c_wraith: Well, *CLRS* assumes that throughout the book and even calls it out as a wildly unrealistic assumption in the first 1 or 2 chapters
2020-11-19 18:50:35 +0100 <merijn> Anyway, dinner time
2020-11-19 18:50:54 +0100 <koz_> merijn: Yeah, you get this a lot. 'This isn't realistic, but we're just goin' with it.' came up a bunch when I was learning a lot of algorithms-related things.
2020-11-19 18:51:00 +0100 <merijn> c_wraith: What does "RAM model" mean? Did they include caches or not?
2020-11-19 18:51:16 +0100 <merijn> (Actually, don't bother answering, 'cause dinner time :p)
2020-11-19 18:51:25 +0100 <koz_> merijn: I assume Random Access Model. AKA 'all memory is flat, if you have an address, you have that memory in Theta(1)'.
2020-11-19 18:51:26 +0100 <c_wraith> merijn: it's the standard name for the model in which all memory accesses have the same cost
2020-11-19 18:52:05 +0100codeAlways(uid272474@gateway/web/irccloud.com/x-zbflumxjrtygmhzc)
2020-11-19 18:52:08 +0100kav(~kari@dsl-hkibng42-56733f-225.dhcp.inet.fi)
2020-11-19 18:52:20 +0100toxix(~DTZUZU@207.81.171.116) (Ping timeout: 256 seconds)
2020-11-19 18:52:23 +0100 <koz_> I think monochrom (maybe?) mentioned that many presentations of Dijkstra's algorithm straight-up lie about their actual performance because they assume magical thinking in priority changes.
2020-11-19 18:54:44 +0100 <monochrom> Rather, an important implementation question of decrease-priority is grossed over.
2020-11-19 18:55:02 +0100 <koz_> I _love_ the expression 'to gross over'.
2020-11-19 18:55:25 +0100wroathe_(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net)
2020-11-19 18:56:02 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2020-11-19 18:56:04 +0100boxscape(54a35f37@gateway/web/cgi-irc/kiwiirc.com/ip.84.163.95.55) (Ping timeout: 272 seconds)
2020-11-19 18:56:36 +0100 <monochrom> In practice, I think people just gave up.
2020-11-19 18:56:48 +0100 <koz_> In general, the folks that taught me algorithm-related stuff in CS had an attitude to implementation that was roughly 'ehh, it can be done somehow, who cares, now do more analysis'.
2020-11-19 18:57:05 +0100acowley(~acowley@c-68-83-22-43.hsd1.nj.comcast.net)
2020-11-19 18:57:10 +0100 <koz_> (one was outright dismissive, the other just mentioned that these issues were resolvable but gave zero explanation how)
2020-11-19 18:57:53 +0100 <monochrom> I have seen programming-contest-quality code libraries that don't use a log-time priority queue at all. Every extract-min and decrease-priority is linear brute-force search over an array.
2020-11-19 18:57:58 +0100oerjan(~oerjan@195.206.169.184) (Remote host closed the connection)
2020-11-19 18:58:03 +0100wroathe_wroathe
2020-11-19 18:58:20 +0100 <monochrom> Dijkstra himself also said he did that for his first demo, it was fast enough for him.
2020-11-19 18:58:53 +0100 <koz_> monochrom: So wait, their priority queue essentially amounts to Vector (Int, a) or so?
2020-11-19 19:00:02 +0100 <monochrom> I gross over details too. But I make a judgment: If I think an average student can think up how to code it up, I can gross over it; if it would be new and clever to them, I have to spell it out.
2020-11-19 19:00:10 +0100 <monochrom> Yeah!
2020-11-19 19:01:00 +0100 <koz_> Somewhat ironically, this makes me feel better about a recent Real Haskell Job call I had to make.
2020-11-19 19:01:03 +0100 <geekosaur> considering the kinds of things your average student comes up with, you must have to spell things out a lot
2020-11-19 19:01:22 +0100 <monochrom> And this is U of bloody Waterloo world class for-ACM-ICPC has-been-world-champion code library they bring on paper to the contests.
2020-11-19 19:01:48 +0100 <monochrom> Fortunately, it's in C, so it is still fast. >:)
2020-11-19 19:02:58 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-19 19:02:59 +0100 <monochrom> Oh, to be sure, "average student" still depends on which school we're talking about.
2020-11-19 19:03:36 +0100enoq(~textual@194-208-146-143.lampert.tv)
2020-11-19 19:04:12 +0100 <monochrom> Suppose you pose the 1st-year-CS problem of "find the max of an array" for example. Actually, more honestly, a word problem that doesn't say outright "find max of array" but if you understand the wordy problem you see it's that.
2020-11-19 19:04:42 +0100 <monochrom> In my school, the average students wouldn't have any difficulty.
2020-11-19 19:04:56 +0100 <monochrom> In U of Waterloo, haha are you kidding, that's too easy.
2020-11-19 19:06:18 +0100jneira(02896ac0@gateway/web/cgi-irc/kiwiirc.com/ip.2.137.106.192)
2020-11-19 19:06:44 +0100 <monochrom> So, that kind of word problems is the usual kind of problems you see during the warm-up practice stage of an ACM-ICPC-style programming contest. The warm-up practice stage being the whole point being familiarizing yourself with the computing environment, so let's solve a trivial problem so you can focus on learning how to use vi and gcc, say.
2020-11-19 19:06:48 +0100cosimone(~cosimone@2001:b07:ae5:db26:9217:95c7:973d:d0ad)
2020-11-19 19:07:46 +0100 <monochrom> I overheard the conversation of a team from another school. <Coach> So, what do you think? <Contestant> No clue.
2020-11-19 19:08:11 +0100 <monochrom> That's their contestant. So now imagine the average of that school. But compare to the average of Waterloo.
2020-11-19 19:10:08 +0100 <maerwald> Man. Why not just get under the sun at the beach, instead of all this programming.
2020-11-19 19:11:18 +0100foursaph(~foursaph@dynamic-077-000-101-034.77.0.pool.telefonica.de)
2020-11-19 19:11:25 +0100ski. o O ( "The Myth of RAM, part I" by Emil Ernerfeldt in 2014-04-21 at <https://www.ilikebigbits.com/2014_04_21_myth_of_ram_1.html> )
2020-11-19 19:11:28 +0100 <monochrom> IKR? I saw a lot of people working hard for their 100-metre dash, or marathon, or something.
2020-11-19 19:11:43 +0100 <monochrom> Why not just get a ride?
2020-11-19 19:11:54 +0100 <monochrom> Why not just call uber?
2020-11-19 19:11:58 +0100 <koz_> ski: Thanks! I was hoping someone did a teardown.
2020-11-19 19:12:43 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 240 seconds)
2020-11-19 19:13:22 +0100AWizzArd(~code@gehrels.uberspace.de) (Changing host)
2020-11-19 19:13:22 +0100AWizzArd(~code@unaffiliated/awizzard)
2020-11-19 19:13:34 +0100toxix(~DTZUZU@207.81.171.116)
2020-11-19 19:14:12 +0100ph88^(~ph88@2a02:8109:9e00:7e5c:f073:c081:c2ef:433b)
2020-11-19 19:15:07 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2020-11-19 19:16:38 +0100jrm(~jrm@freebsd/developer/jrm) (Ping timeout: 256 seconds)
2020-11-19 19:16:50 +0100Yumasi(~guillaume@2a01cb09b06b29ea0877e1bda345185b.ipv6.abo.wanadoo.fr) (Ping timeout: 264 seconds)
2020-11-19 19:17:07 +0100 <koz_> @unmtl StateT s Maybe a
2020-11-19 19:17:07 +0100 <lambdabot> s -> Maybe (a, s)
2020-11-19 19:18:28 +0100Tracerneo1(~Tracerneo@193.56.252.12)
2020-11-19 19:18:51 +0100neiluj(~jco@91-167-203-101.subs.proxad.net)
2020-11-19 19:18:51 +0100neiluj(~jco@91-167-203-101.subs.proxad.net) (Changing host)
2020-11-19 19:18:51 +0100neiluj(~jco@unaffiliated/neiluj)
2020-11-19 19:19:35 +0100chele(~chele@ip5b416ea2.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2020-11-19 19:20:16 +0100 <koz_> :t guard
2020-11-19 19:20:17 +0100 <lambdabot> Alternative f => Bool -> f ()
2020-11-19 19:21:11 +0100 <koz_> And of course 'guard' is from Control.Monad. That odd sock drawer of a module.
2020-11-19 19:21:11 +0100 <dolio> I think people should really leave out the 'black hole' stuff from write-ups like this.
2020-11-19 19:23:02 +0100 <koz_> Rod Downey famously claims that 'it's an open problem' is an 80% accurate heuristic for correct answers to complexity theory questions. At this point, I think 'Control.Monad' is an 80% accurate heuristic for correct answers to 'where on earth in base is this function?'-type questions.
2020-11-19 19:23:58 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-11-19 19:24:13 +0100hidedagger(~nate@unaffiliated/hidedagger) (Quit: WeeChat 2.9)
2020-11-19 19:24:22 +0100 <monochrom> You have to narrow the scope to "combinators that are good for all Applicatives, Alternatives, Monads, or MonadPluses". But yeah.
2020-11-19 19:24:27 +0100ph88^(~ph88@2a02:8109:9e00:7e5c:f073:c081:c2ef:433b) (Ping timeout: 272 seconds)
2020-11-19 19:24:43 +0100 <koz_> monochrom: I dunno if I'm just special, but those are the kinds of things I need a lot, and can never find.
2020-11-19 19:24:45 +0100conal(~conal@64.71.133.70)
2020-11-19 19:25:05 +0100conal(~conal@64.71.133.70) (Client Quit)
2020-11-19 19:25:21 +0100 <monochrom> It is historical. 2 decades ago, there was only Functor and Monad, and module-wise there was only Control.Monad, not even Data.Functor, so all the cool tools got into there.
2020-11-19 19:25:58 +0100 <monochrom> I guess 2 decades ago the module name was just Monad, too.
2020-11-19 19:26:01 +0100 <ski> (and before hierarchical, wasn't there just `Monad' ?)
2020-11-19 19:26:06 +0100 <monochrom> Yeah that
2020-11-19 19:26:37 +0100 <koz_> Oh, I get why it is that way.
2020-11-19 19:26:44 +0100 <koz_> It's just amusing to me.
2020-11-19 19:27:27 +0100conal(~conal@64.71.133.70)
2020-11-19 19:27:28 +0100conal(~conal@64.71.133.70) (Client Quit)
2020-11-19 19:27:31 +0100hackageivory-avr-atmega328p-registers 0.1.0.0 - Ivory register bindings for the Atmega328p https://hackage.haskell.org/package/ivory-avr-atmega328p-registers-0.1.0.0 (erdeszt)
2020-11-19 19:28:49 +0100ulidtko(~ulidtko@193.111.48.79) (Read error: Connection reset by peer)
2020-11-19 19:29:36 +0100ishutin(~Ishutin@92-249-179-45.pool.digikabel.hu) (Ping timeout: 240 seconds)
2020-11-19 19:30:33 +0100ishutin(~Ishutin@77-234-92-253.pool.digikabel.hu)
2020-11-19 19:31:32 +0100conal(~conal@64.71.133.70)
2020-11-19 19:32:04 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de)
2020-11-19 19:32:59 +0100 <monochrom> I enjoy using history to explain why things suck today. Those who have learned from history are doomed to helplessly watching other people repeat it.
2020-11-19 19:33:24 +0100alephu5[m](alephu5mat@gateway/shell/matrix.org/x-ldzorvnirgjegsey)
2020-11-19 19:33:37 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 19:35:20 +0100hidedagger(~nate@unaffiliated/hidedagger) (Client Quit)
2020-11-19 19:35:20 +0100avn(~avn@78-56-108-78.static.zebra.lt) (Read error: Connection reset by peer)
2020-11-19 19:35:29 +0100avn(~avn@78-56-108-78.static.zebra.lt)
2020-11-19 19:36:28 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de) (Ping timeout: 256 seconds)
2020-11-19 19:37:34 +0100wroathe(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net) (Quit: leaving)
2020-11-19 19:38:57 +0100 <koz_> monochrom: After all, everything is either history or applied history? :P
2020-11-19 19:39:01 +0100alp(~alp@2a01:e0a:58b:4920:6867:806e:6b2d:b0d) (Ping timeout: 272 seconds)
2020-11-19 19:39:57 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 19:40:47 +0100hidedagger(~nate@unaffiliated/hidedagger) (Client Quit)
2020-11-19 19:40:47 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 19:41:02 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 19:42:05 +0100kritzefitz(~kritzefit@212.86.56.80) (Ping timeout: 240 seconds)
2020-11-19 19:43:07 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 19:45:35 +0100Ariakenom(~Ariakenom@h-98-128-229-104.NA.cust.bahnhof.se) (Read error: Connection reset by peer)
2020-11-19 19:45:58 +0100Ariakenom(~Ariakenom@h-98-128-229-104.NA.cust.bahnhof.se)
2020-11-19 19:46:46 +0100hidedagger(~nate@unaffiliated/hidedagger) (Client Quit)
2020-11-19 19:47:13 +0100boxscape(54a35f37@gateway/web/cgi-irc/kiwiirc.com/ip.84.163.95.55)
2020-11-19 19:47:31 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 19:48:24 +0100thc202(~thc202@unaffiliated/thc202) (Quit: thc202)
2020-11-19 19:50:59 +0100 <zincy__> koz_: Are you by any chance from New Zealand?
2020-11-19 19:51:10 +0100 <koz_> zincy__: I am, by chance, from there.
2020-11-19 19:51:19 +0100 <koz_> Was the Rod Downey mention the giveaway?
2020-11-19 19:52:14 +0100jespada(~jespada@90.254.245.49) (Ping timeout: 265 seconds)
2020-11-19 19:52:55 +0100 <zincy__> Juspay?
2020-11-19 19:53:03 +0100 <koz_> zincy__: Contractor, but yes.
2020-11-19 19:53:22 +0100 <zincy__> Yes we talked a bit about logic and discrete mathematics there
2020-11-19 19:53:32 +0100 <koz_> Oh hi!
2020-11-19 19:53:35 +0100 <zincy__> hehe
2020-11-19 19:53:45 +0100 <zincy__> Hi
2020-11-19 19:54:03 +0100 <koz_> Guess it figures Haskellers hang out here.
2020-11-19 19:54:33 +0100 <zincy__> Yeah I saw the name and thought hmm that is a familiar name.
2020-11-19 19:54:43 +0100 <koz_> I'm some variant of 'Koz' everywhere.
2020-11-19 19:55:16 +0100jespada(~jespada@90.254.245.49)
2020-11-19 19:55:28 +0100zx__(~oracle@unaffiliated/oracle)
2020-11-19 19:55:42 +0100SanchayanM(~Sanchayan@223.226.123.235) (Quit: SanchayanM)
2020-11-19 19:58:05 +0100kish`(~oracle@unaffiliated/oracle) (Ping timeout: 240 seconds)
2020-11-19 20:00:07 +0100hidedagger(~nate@unaffiliated/hidedagger) (Quit: WeeChat 2.9)
2020-11-19 20:01:28 +0100DavidEichmann(~david@62.110.198.146.dyn.plus.net) (Remote host closed the connection)
2020-11-19 20:01:50 +0100DavidEichmann(~david@62.110.198.146.dyn.plus.net)
2020-11-19 20:02:21 +0100knupfer(~Thunderbi@200116b82cfb870024438394791f27e9.dip.versatel-1u1.de)
2020-11-19 20:02:25 +0100Lord_of_Life(~Lord@46.217.218.252) (Ping timeout: 240 seconds)
2020-11-19 20:02:54 +0100Lord_of_Life(~Lord@46.217.218.252)
2020-11-19 20:02:54 +0100Lord_of_Life(~Lord@46.217.218.252) (Changing host)
2020-11-19 20:02:54 +0100Lord_of_Life(~Lord@unaffiliated/lord-of-life/x-0885362)
2020-11-19 20:03:32 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-19 20:03:37 +0100berberman(~berberman@unaffiliated/berberman)
2020-11-19 20:04:14 +0100geekosaur(82659a09@host154-009.vpn.uakron.edu) (Ping timeout: 245 seconds)
2020-11-19 20:04:24 +0100berberman_(~berberman@unaffiliated/berberman) (Ping timeout: 240 seconds)
2020-11-19 20:04:28 +0100boxscape(54a35f37@gateway/web/cgi-irc/kiwiirc.com/ip.84.163.95.55) (Ping timeout: 272 seconds)
2020-11-19 20:05:11 +0100buckworst(~nate@125.161.129.195)
2020-11-19 20:05:29 +0100kuribas(~user@ptr-25vy0i8y4kl4v762twz.18120a2.ip6.access.telenet.be) (Quit: ERC (IRC client for Emacs 26.3))
2020-11-19 20:06:27 +0100buckworst(~nate@125.161.129.195) (Client Quit)
2020-11-19 20:08:24 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 260 seconds)
2020-11-19 20:09:31 +0100he9388(2fe3e53b@047-227-229-059.res.spectrum.com) (Remote host closed the connection)
2020-11-19 20:11:26 +0100Rudd0(~Rudd0@185.189.115.108) (Ping timeout: 272 seconds)
2020-11-19 20:13:16 +0100buckworst(~nate@125.161.129.195)
2020-11-19 20:13:42 +0100DavidEichmann(~david@62.110.198.146.dyn.plus.net) (Remote host closed the connection)
2020-11-19 20:14:00 +0100hackagenonempty-vector 0.2.1.0 - Non-empty vectors https://hackage.haskell.org/package/nonempty-vector-0.2.1.0 (topos)
2020-11-19 20:15:01 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 20:15:02 +0100kritzefitz(~kritzefit@212.86.56.80)
2020-11-19 20:17:16 +0100Tario(~Tario@201.192.165.173) (Ping timeout: 256 seconds)
2020-11-19 20:17:23 +0100bsima(~bsima@simatime.com) (Quit: ZNC 1.7.5 - https://znc.in)
2020-11-19 20:18:00 +0100bsima(~bsima@simatime.com)
2020-11-19 20:18:36 +0100Tario(~Tario@201.192.165.173)
2020-11-19 20:19:13 +0100boxscape(54a35f37@gateway/web/cgi-irc/kiwiirc.com/ip.84.163.95.55)
2020-11-19 20:23:57 +0100geekosaur(82659a09@host154-009.vpn.uakron.edu)
2020-11-19 20:30:09 +0100comerijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-19 20:30:26 +0100nbloomf_(~nbloomf@2600:1700:ad14:3020:c5d0:5105:4451:33e9)
2020-11-19 20:31:04 +0100invaser(~Thunderbi@31.148.23.125) (Ping timeout: 246 seconds)
2020-11-19 20:31:44 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2020-11-19 20:31:48 +0100st8less(~st8less@2603:a060:11fd:0:744d:b66f:d608:4e8e) (Quit: WeeChat 2.9)
2020-11-19 20:32:52 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:f4f3:bbb1:9462:91ce) (Ping timeout: 260 seconds)
2020-11-19 20:34:04 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2020-11-19 20:35:23 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl)
2020-11-19 20:39:49 +0100Sarma(~Amras@unaffiliated/amras0000) (Ping timeout: 272 seconds)
2020-11-19 20:40:22 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-19 20:40:34 +0100dcoutts_(~duncan@33.14.75.194.dyn.plus.net) (Ping timeout: 272 seconds)
2020-11-19 20:40:35 +0100dustypacer(~pi@2600:6c50:80:2f4a:e9d0:6569:1cea:d1d4) (Remote host closed the connection)
2020-11-19 20:41:01 +0100dustypacer(~pi@2600:6c50:80:2f4a:e9d0:6569:1cea:d1d4)
2020-11-19 20:41:42 +0100nbloomf_(~nbloomf@2600:1700:ad14:3020:c5d0:5105:4451:33e9) (Quit: Textual IRC Client: www.textualapp.com)
2020-11-19 20:41:58 +0100acidjnk_new(~acidjnk@p200300d0c719ff356dc4eeabe79b61ea.dip0.t-ipconnect.de)
2020-11-19 20:44:18 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:7958:7d8e:4908:c843)
2020-11-19 20:45:05 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-19 20:47:52 +0100comerijnmerijn
2020-11-19 20:47:59 +0100oatshafer
2020-11-19 20:48:06 +0100EyalSK(~EyalSK@bzq-84-109-128-227.red.bezeqint.net)
2020-11-19 20:48:06 +0100EyalSK(~EyalSK@bzq-84-109-128-227.red.bezeqint.net) (Client Quit)
2020-11-19 20:49:57 +0100christo(~chris@81.96.113.213)
2020-11-19 20:51:57 +0100christo_(~chris@81.96.113.213)
2020-11-19 20:51:57 +0100christo(~chris@81.96.113.213) (Read error: Connection reset by peer)
2020-11-19 20:52:06 +0100hidedagger(~nate@unaffiliated/hidedagger) (Quit: WeeChat 2.9)
2020-11-19 20:52:12 +0100waskell_(~quassel@d66-183-127-166.bchsia.telus.net)
2020-11-19 20:52:41 +0100christo_(~chris@81.96.113.213) (Read error: Connection reset by peer)
2020-11-19 20:52:57 +0100christo(~chris@81.96.113.213)
2020-11-19 20:54:36 +0100waskell(~quassel@d66-183-127-166.bchsia.telus.net) (Ping timeout: 260 seconds)
2020-11-19 20:54:43 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 20:55:31 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-19 20:57:17 +0100boxscape(54a35f37@gateway/web/cgi-irc/kiwiirc.com/ip.84.163.95.55) (Quit: Connection closed)
2020-11-19 20:57:39 +0100hidedagger(~nate@unaffiliated/hidedagger) (Client Quit)
2020-11-19 21:04:23 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-19 21:06:29 +0100remby(~rg@2607:fea8:2c40:307::1ef6)
2020-11-19 21:06:51 +0100Zetagon(~leo@c151-177-52-233.bredband.comhem.se) (Remote host closed the connection)
2020-11-19 21:09:06 +0100neiluj(~jco@unaffiliated/neiluj) (Quit: leaving)
2020-11-19 21:10:05 +0100infinity0(~infinity0@freenet/developer/infinity0) (Remote host closed the connection)
2020-11-19 21:10:12 +0100knupfer(~Thunderbi@200116b82cfb870024438394791f27e9.dip.versatel-1u1.de) (Ping timeout: 260 seconds)
2020-11-19 21:10:58 +0100oish(~charlie@228.25.169.217.in-addr.arpa) (Ping timeout: 246 seconds)
2020-11-19 21:11:47 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-19 21:12:09 +0100coot_(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl)
2020-11-19 21:13:31 +0100hackagepcg-random 0.1.3.7 - Haskell bindings to the PCG random number generator. https://hackage.haskell.org/package/pcg-random-0.1.3.7 (cchalmers)
2020-11-19 21:13:56 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl) (Ping timeout: 256 seconds)
2020-11-19 21:13:57 +0100coot_coot
2020-11-19 21:19:12 +0100AlterEgo-(~ladew@124-198-158-163.dynamic.caiway.nl) (Quit: Leaving)
2020-11-19 21:19:19 +0100buckwors1(~nate@180.251.220.35)
2020-11-19 21:19:38 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl) (Remote host closed the connection)
2020-11-19 21:19:42 +0100waskell(~quassel@d66-183-127-166.bchsia.telus.net)
2020-11-19 21:19:43 +0100waskell_(~quassel@d66-183-127-166.bchsia.telus.net) (Ping timeout: 265 seconds)
2020-11-19 21:20:17 +0100ClaudiusMaximus(~claude@unaffiliated/claudiusmaximus) (Quit: ->)
2020-11-19 21:20:25 +0100geekosaur(82659a09@host154-009.vpn.uakron.edu) (Remote host closed the connection)
2020-11-19 21:21:22 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 21:21:25 +0100buckworst(~nate@125.161.129.195) (Ping timeout: 240 seconds)
2020-11-19 21:24:48 +0100Deide(~Deide@217.155.19.23)
2020-11-19 21:29:07 +0100 <dminuoso> dolio: The black hole stuff is what justifies O(sqrt(n)) for random access. Without it, you'd arrive at the notion that the maximum of information storable in a region of space is defined by its volume, not its surface.
2020-11-19 21:29:19 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl)
2020-11-19 21:29:39 +0100hidedagger(~nate@unaffiliated/hidedagger) (Quit: WeeChat 2.9)
2020-11-19 21:31:27 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-19 21:31:32 +0100Franciman(~francesco@host-82-56-223-169.retail.telecomitalia.it) (Quit: Leaving)
2020-11-19 21:31:45 +0100andi-(~andi-@NixOS/user/andi-) (Ping timeout: 272 seconds)
2020-11-19 21:32:07 +0100 <dolio> It doesn't justify it for anything close to an approximation of practical situations, though. And I've heard doubt that the theoretical stuff actually means what people say it means. So it's both unnecessary and potentially discredits you.
2020-11-19 21:33:01 +0100 <dminuoso> Well, it just so happens that the O(sqrt(n)) asymptotics nicely match what we observe in cache hierarchies, local storage, remote storage, etc..
2020-11-19 21:33:18 +0100 <dolio> Right, so you don't need to appeal to black hole stuff.
2020-11-19 21:33:31 +0100hackagephonetic-languages-permutations 0.1.0.0 - Commonly used versions of the phonetic-languages-common package https://hackage.haskell.org/package/phonetic-languages-permutations-0.1.0.0 (OleksandrZhabenko)
2020-11-19 21:33:39 +0100 <dolio> So don't.
2020-11-19 21:33:45 +0100 <dminuoso> What's the alternative. "Random access is O(sqrt(n)) but I wont tell you why?"
2020-11-19 21:34:00 +0100 <dolio> They already explained why before talking about the black hole stuff.
2020-11-19 21:34:26 +0100 <monochrom> In the interest of pruning dependencies you don't actually use, if your analysis just needs cache hierarchies, prune everything else.
2020-11-19 21:35:53 +0100 <dminuoso> I guess it depends on the audience, really.
2020-11-19 21:35:55 +0100 <dolio> The reason is that nobody actually knows how to effectively cool 3D stuff on the small scale, so memory is effectively planar.
2020-11-19 21:36:07 +0100 <dminuoso> From the theoretical approach of studying real asymptotics, it seems suitable
2020-11-19 21:36:26 +0100 <dolio> And even when you scale up to data centers, you build on the surface of the earth, so you don't actually scale arbitrarily in 3 dimensions.
2020-11-19 21:36:28 +0100 <dminuoso> Fair, I guess that's a good reason
2020-11-19 21:37:37 +0100acidjnk_new(~acidjnk@p200300d0c719ff356dc4eeabe79b61ea.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2020-11-19 21:38:23 +0100 <dminuoso> I was just under the impression that complexity analysis didn't just care for "How does this function behave in some arbitrarily fixed region", but about the limiting factor in theory
2020-11-19 21:39:30 +0100 <dminuoso> But your arguments about 2-dimensionality are still valid, as it's reasonable to assume that if we increase memory, we still will approximately only fill the surface of the earth
2020-11-19 21:40:15 +0100 <dminuoso> But then we should take into account that there's large regions on the earth where we wont build data centers
2020-11-19 21:40:30 +0100 <dminuoso> And that we have limited resources to even build memory
2020-11-19 21:41:00 +0100hackagephonetic-languages-permutations 0.1.1.0 - Commonly used versions of the phonetic-languages-common package https://hackage.haskell.org/package/phonetic-languages-permutations-0.1.1.0 (OleksandrZhabenko)
2020-11-19 21:41:07 +0100Boomerang(~Boomerang@xd520f68c.cust.hiper.dk)
2020-11-19 21:41:29 +0100Aquazi(uid312403@gateway/web/irccloud.com/x-sgcggzhikhhgebxn) (Quit: Connection closed for inactivity)
2020-11-19 21:42:25 +0100invaser(~Thunderbi@31.148.23.125)
2020-11-19 21:42:48 +0100 <dolio> How is that going to inform a better asymptotic cost of memory access than √n?
2020-11-19 21:43:08 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 21:43:34 +0100 <dolio> You don't need to address every possible nitpick. There just needs to be a reason to use one model over another.
2020-11-19 21:45:03 +0100 <dolio> √n is actually better for a lot of things empirically, regardless of any theoretical justification. The latter only helps you understand why.
2020-11-19 21:45:41 +0100andi-(~andi-@NixOS/user/andi-)
2020-11-19 21:47:11 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de)
2020-11-19 21:48:20 +0100nckxjorts
2020-11-19 21:49:48 +0100hidedagger(~nate@unaffiliated/hidedagger) (Quit: WeeChat 2.9)
2020-11-19 21:50:24 +0100borne(~fritjof@200116b864eda200f1dc39039d201adf.dip.versatel-1u1.de) (Ping timeout: 240 seconds)
2020-11-19 21:50:35 +0100 <monochrom> More meta-ly, a lot of programmers are unable to accept that we have and use models, not absolute truths; and even that some of those models are purely empirical, i.e., no one bothered to dig deeper for why the model fits observation.
2020-11-19 21:51:08 +0100 <monochrom> Engineers have made peace with that for a long time, and it's why engineers are so successful.
2020-11-19 21:51:42 +0100buckwors1(~nate@180.251.220.35) (Quit: WeeChat 2.9)
2020-11-19 21:51:42 +0100 <monochrom> This is one of many aspects programmers still have a long way to go before we can legitimately call them "software engineers".
2020-11-19 21:52:21 +0100 <dolio> And since no one is using black holes for memory (and won't for the forseeable future), that isn't a good explanation for why the model works anyway.
2020-11-19 21:53:20 +0100 <monochrom> From the engineering point of view, a model is judged for merely this: For the scope of your application (possibly very niche and narrow), how much computation you need to get how much prediction accuracy.
2020-11-19 21:53:36 +0100foursaph(~foursaph@dynamic-077-000-101-034.77.0.pool.telefonica.de) (Ping timeout: 240 seconds)
2020-11-19 21:54:01 +0100 <monochrom> (A scientist then dig deeper for why the model works so nicely, what is the deeper model behind it.)
2020-11-19 21:54:11 +0100 <merijn> monochrom: Not if you're me
2020-11-19 21:54:23 +0100jortsnckx
2020-11-19 21:54:41 +0100 <merijn> Then you just go "you guys all suck so hard at engineering I had to spend most of my phd doing the engineering to even investigate these models and now I can't tell you why it works and I blame you" :p
2020-11-19 21:55:00 +0100hackagephonetic-languages-simplified-common 0.1.0.0 - A simplified version of the phonetic-languages-functionality https://hackage.haskell.org/package/phonetic-languages-simplified-common-0.1.0.0 (OleksandrZhabenko)
2020-11-19 21:55:36 +0100 <monochrom> The fact that programmers are so unhealthy OCD with absolute truths is one of many reasons why I say that programmers are in the same genre as priests.
2020-11-19 21:55:37 +0100conal(~conal@64.71.133.70) (Read error: Connection reset by peer)
2020-11-19 21:55:48 +0100 <alephu5[m]> monochrom: Do you really think that programmers are more bound to theory than traditional engineers? That's not my experience of the industry at all
2020-11-19 21:56:12 +0100 <merijn> alephu5[m]: His point is that they are, but the industry refuses to acknowledge it
2020-11-19 21:56:19 +0100 <merijn> Which is why they keep building broken trash :p
2020-11-19 21:56:33 +0100 <aoei> monochrom: lmao
2020-11-19 21:56:34 +0100 <monochrom> I am saying that programmers are bound to theory in the wrong way.
2020-11-19 21:56:38 +0100conal(~conal@64.71.133.70)
2020-11-19 21:56:55 +0100Sgeo_(~Sgeo@ool-18b982ad.dyn.optonline.net)
2020-11-19 21:57:02 +0100 <aoei> monochrom: I was in academic science for a few years.. many of those people are also like that :P
2020-11-19 21:58:01 +0100seanparsons(~sean@cpc145088-gill21-2-0-cust281.20-1.cable.virginm.net) (Quit: ZNC 1.8.1 - https://znc.in)
2020-11-19 21:58:06 +0100 <merijn> Most of the HPC/"empirical" side of CS is a joke, tbh >.>
2020-11-19 21:58:32 +0100 <monochrom> You give a piece of theory to engineers, they take it as a model. It works? Cool. It doesn't work? They just look for another model.
2020-11-19 21:59:06 +0100 <aoei> monochrom: smart folk
2020-11-19 21:59:10 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-19 21:59:21 +0100 <monochrom> You give a piece of theory to programmers, they take it as a religion. It can only be absolutely true or absolutely heretic.
2020-11-19 21:59:45 +0100Sgeo(~Sgeo@ool-18b982ad.dyn.optonline.net) (Ping timeout: 240 seconds)
2020-11-19 21:59:45 +0100conal(~conal@64.71.133.70) (Client Quit)
2020-11-19 22:00:00 +0100 <aoei> i wonder if programmers is too broad and you mean a specific subset
2020-11-19 22:00:16 +0100 <dolio> Well, it isn't just programmers, either.
2020-11-19 22:00:17 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 22:00:22 +0100 <merijn> monochrom: Pfft, I belief in paraconsistent logics, I'm perfectly happy believing piece of theory to be simultaneously absolutely true *and* heretical :)
2020-11-19 22:00:27 +0100seanparsons(~sean@cpc145088-gill21-2-0-cust281.20-1.cable.virginm.net)
2020-11-19 22:00:29 +0100 <monochrom> Modulo the programer in question actually has the intellectual capacity to properly read the piece of theory in the first place, of course.
2020-11-19 22:00:30 +0100 <alephu5[m]> But if assumptions A, B and C imply a particular model that fails drastically, it's often useful to the pragmatist to know that the assumptions are wrong
2020-11-19 22:00:42 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-19 22:00:42 +0100zx__(~oracle@unaffiliated/oracle) (Read error: Connection reset by peer)
2020-11-19 22:00:44 +0100 <davean> Yah, and I mean thats also true for one side of it. On the mathematical side its either true of false, on the HW side it can be more varied. Both sides often want approximations.
2020-11-19 22:01:39 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber)
2020-11-19 22:01:46 +0100kish`(~oracle@unaffiliated/oracle)
2020-11-19 22:02:26 +0100bitmagie(~Thunderbi@200116b806fd8d007960b9f54c7c6d5e.dip.versatel-1u1.de)
2020-11-19 22:03:03 +0100 <dolio> The usual "theory vs. practice" truism is really a nonsense way of thinking. Theories are useful when they can be applied to practice, and they should be informed and developed by practice. And practice can be assisted by a good/suitable theory.
2020-11-19 22:03:46 +0100 <dolio> Learning a "theory" that never applies to practice is just kind of useless unless you enjoy the activity in itself.
2020-11-19 22:04:09 +0100britva(~britva@2a02:aa13:7240:2980:7da5:a1a0:c038:90b4) (Quit: This computer has gone to sleep)
2020-11-19 22:04:12 +0100 <monochrom> Yeah. Knuth said: The best theory is inspired by practice. The best practice is inspired by theory. (I forgot whether that's his order haha.)
2020-11-19 22:04:19 +0100bitmagie(~Thunderbi@200116b806fd8d007960b9f54c7c6d5e.dip.versatel-1u1.de) (Client Quit)
2020-11-19 22:05:25 +0100borne(~fritjof@200116b864eda200f1dc39039d201adf.dip.versatel-1u1.de)
2020-11-19 22:06:00 +0100britva(~britva@2a02:aa13:7240:2980:9169:d6ce:8b28:2e63)
2020-11-19 22:06:46 +0100Lycurgus(~niemand@cpe-45-46-142-188.buffalo.res.rr.com)
2020-11-19 22:07:05 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber) (Ping timeout: 240 seconds)
2020-11-19 22:07:07 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2020-11-19 22:08:17 +0100 <maerwald> monochrom: you got that wrong... some priests are good people :)
2020-11-19 22:08:58 +0100arahael(~arahael@125-209-166-120.tpgi.com.au) (Ping timeout: 256 seconds)
2020-11-19 22:10:04 +0100 <alephu5[m]> <dolio "Learning a "theory" that never a"> Isn't that philosophy?
2020-11-19 22:11:06 +0100Ariakenom(~Ariakenom@h-98-128-229-104.NA.cust.bahnhof.se) (Quit: Leaving)
2020-11-19 22:11:08 +0100arahael(~arahael@14-203-208-142.tpgi.com.au)
2020-11-19 22:11:16 +0100 <davean> maerwald: unlike any programmers
2020-11-19 22:11:28 +0100 <maerwald> I didn't say thate :p
2020-11-19 22:11:34 +0100 <maerwald> (but I thought it)
2020-11-19 22:12:04 +0100 <dolio> alephu5[m]: Maybe. I don't put a lot of stock in philosophy. :)
2020-11-19 22:12:19 +0100sand_dull(~theuser@c-73-149-95-105.hsd1.ct.comcast.net)
2020-11-19 22:13:40 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl) (Remote host closed the connection)
2020-11-19 22:15:06 +0100sand_dull(~theuser@c-73-149-95-105.hsd1.ct.comcast.net) (Client Quit)
2020-11-19 22:15:10 +0100Lycurgus.oO( what part of perpetuating stupid lies about the nature of reality and man's relation to it is good?)
2020-11-19 22:15:33 +0100sand_dull(~theuser@c-73-149-95-105.hsd1.ct.comcast.net)
2020-11-19 22:15:54 +0100Lycurgus(~niemand@cpe-45-46-142-188.buffalo.res.rr.com) (Quit: Exeunt)
2020-11-19 22:15:55 +0100glguywonders how far back he'd need to read to find Haskell in this
2020-11-19 22:16:44 +0100son0p(~son0p@181.136.122.143)
2020-11-19 22:18:28 +0100 <zincy__> monochrom: Right, but don't most programmers implicitly accept they are using models?
2020-11-19 22:18:56 +0100 <zincy__> A voltage is never exactly "high" or "low" ...
2020-11-19 22:19:59 +0100 <zincy__> We dont even need electricity to build computers
2020-11-19 22:20:05 +0100sand_dull(~theuser@c-73-149-95-105.hsd1.ct.comcast.net) (Client Quit)
2020-11-19 22:20:19 +0100 <zincy__> Surely an acceptance of these facts is an implicit agreement that we use models
2020-11-19 22:20:21 +0100 <dolio> Good thing the model doesn't talk about voltages, then.
2020-11-19 22:20:34 +0100neiluj(~jco@91-167-203-101.subs.proxad.net)
2020-11-19 22:20:34 +0100neiluj(~jco@91-167-203-101.subs.proxad.net) (Changing host)
2020-11-19 22:20:34 +0100neiluj(~jco@unaffiliated/neiluj)
2020-11-19 22:20:35 +0100sand_dull(~theuser@c-73-149-95-105.hsd1.ct.comcast.net)
2020-11-19 22:20:44 +0100 <zincy__> dolio: What do you mean
2020-11-19 22:21:18 +0100 <dolio> If you're not using electricity to implement computation, it wouldn't make much sense for your model of computation to talk about voltages.
2020-11-19 22:22:12 +0100 <zincy__> Yeah
2020-11-19 22:22:47 +0100chaosmasttter(~chaosmast@p200300c4a70b2a01441f1455f36b3658.dip0.t-ipconnect.de) (Quit: WeeChat 2.9)
2020-11-19 22:24:10 +0100 <zincy__> What is it Marvin Minsky said, a computer is a a physical model of an abstract process.
2020-11-19 22:25:10 +0100son0p(~son0p@181.136.122.143) (Quit: Lost terminal)
2020-11-19 22:25:34 +0100son0p(~son0p@181.136.122.143)
2020-11-19 22:25:35 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-19 22:25:55 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-19 22:26:29 +0100pavonia(~user@unaffiliated/siracusa)
2020-11-19 22:26:54 +0100zyxtant(~zyextant@120.155.30.153) (Ping timeout: 265 seconds)
2020-11-19 22:28:07 +0100gienah(~mwright@gentoo/developer/gienah) (Quit: leaving)
2020-11-19 22:28:44 +0100danvet(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa) (Ping timeout: 240 seconds)
2020-11-19 22:28:57 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2020-11-19 22:29:10 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-19 22:30:06 +0100knupfer(~Thunderbi@200116b82cfb8700905b10fffed96eb6.dip.versatel-1u1.de)
2020-11-19 22:30:07 +0100knupfer(~Thunderbi@200116b82cfb8700905b10fffed96eb6.dip.versatel-1u1.de) (Client Quit)
2020-11-19 22:30:20 +0100knupfer(~Thunderbi@87.123.206.167)
2020-11-19 22:34:14 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-19 22:34:16 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-19 22:35:24 +0100alp(~alp@2a01:e0a:58b:4920:8196:f1ff:e993:87c3)
2020-11-19 22:36:06 +0100oish(~charlie@228.25.169.217.in-addr.arpa)
2020-11-19 22:39:20 +0100Bad_K4rMa(~Bad_K4rMa@unaffiliated/rjphares)
2020-11-19 22:40:41 +0100 <Bad_K4rMa> couple haskell books for sale cheap less than 24 hours left: https://www.ebay.com/usr/roph-rjp-nb5hus5uzh
2020-11-19 22:41:36 +0100justan0theruser(~justanoth@unaffiliated/justanotheruser) (Ping timeout: 240 seconds)
2020-11-19 22:42:24 +0100sand_dull(~theuser@c-73-149-95-105.hsd1.ct.comcast.net) (Ping timeout: 256 seconds)
2020-11-19 22:45:13 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Read error: Connection reset by peer)
2020-11-19 22:45:38 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2020-11-19 22:47:15 +0100rprije(~rprije@124.148.131.132)
2020-11-19 22:47:20 +0100aidecoe(~aidecoe@unaffiliated/aidecoe)
2020-11-19 22:49:01 +0100benb(52456307@82-69-99-7.dsl.in-addr.zen.co.uk)
2020-11-19 22:49:56 +0100knupfer1(~Thunderbi@200116b82cfb8700286c2aae4538dae1.dip.versatel-1u1.de)
2020-11-19 22:49:56 +0100knupfer(~Thunderbi@87.123.206.167) (Read error: Connection reset by peer)
2020-11-19 22:49:56 +0100knupfer1knupfer
2020-11-19 22:53:42 +0100neiluj(~jco@unaffiliated/neiluj) (Quit: leaving)
2020-11-19 22:55:15 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-19 22:55:19 +0100dhouthoo(~dhouthoo@ptr-eiv6509pb4ifhdr9lsd.18120a2.ip6.access.telenet.be) (Quit: WeeChat 2.9)
2020-11-19 22:56:03 +0100christo(~chris@81.96.113.213)
2020-11-19 22:56:53 +0100zerstroyer[m](zerstroyer@gateway/shell/matrix.org/x-thvxsfmerzqegbym)
2020-11-19 22:59:54 +0100bliminse(~bliminse@host109-156-197-211.range109-156.btcentralplus.com) (Ping timeout: 256 seconds)
2020-11-19 23:00:28 +0100christo(~chris@81.96.113.213) (Ping timeout: 256 seconds)
2020-11-19 23:02:28 +0100invaser(~Thunderbi@31.148.23.125) (Ping timeout: 260 seconds)
2020-11-19 23:04:40 +0100cosimone(~cosimone@2001:b07:ae5:db26:9217:95c7:973d:d0ad) (Quit: cosimone)
2020-11-19 23:06:27 +0100falafel(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4)
2020-11-19 23:06:44 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net) (Quit: leaving)
2020-11-19 23:10:45 +0100hyperisco(~hyperisco@d192-186-117-226.static.comm.cgocable.net) (Ping timeout: 240 seconds)
2020-11-19 23:14:25 +0100conal(~conal@64.71.133.70)
2020-11-19 23:16:16 +0100mananamenos(~mananamen@84.122.202.215.dyn.user.ono.com) (Ping timeout: 246 seconds)
2020-11-19 23:18:46 +0100britva(~britva@2a02:aa13:7240:2980:9169:d6ce:8b28:2e63) (Quit: This computer has gone to sleep)
2020-11-19 23:18:54 +0100cyphase(~cyphase@unaffiliated/cyphase) (Ping timeout: 272 seconds)
2020-11-19 23:19:25 +0100machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Ping timeout: 264 seconds)
2020-11-19 23:21:27 +0100Bad_K4rMa(~Bad_K4rMa@unaffiliated/rjphares) (Ping timeout: 260 seconds)
2020-11-19 23:21:39 +0100justanotheruser(~justanoth@unaffiliated/justanotheruser)
2020-11-19 23:21:56 +0100Rudd0(~Rudd0@185.189.115.108)
2020-11-19 23:22:22 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-19 23:22:55 +0100dcoutts_(~duncan@33.14.75.194.dyn.plus.net)
2020-11-19 23:24:30 +0100magma(~magma@host-87-20-128-180.retail.telecomitalia.it)
2020-11-19 23:24:40 +0100magma(~magma@host-87-20-128-180.retail.telecomitalia.it) (Read error: Connection reset by peer)
2020-11-19 23:26:42 +0100knupfer(~Thunderbi@200116b82cfb8700286c2aae4538dae1.dip.versatel-1u1.de) (Ping timeout: 260 seconds)
2020-11-19 23:26:48 +0100cyphase(~cyphase@unaffiliated/cyphase)
2020-11-19 23:28:03 +0100britva(~britva@2a02:aa13:7240:2980:9169:d6ce:8b28:2e63)
2020-11-19 23:28:43 +0100Boomerang(~Boomerang@xd520f68c.cust.hiper.dk) (Ping timeout: 260 seconds)
2020-11-19 23:29:12 +0100haferdidymos
2020-11-19 23:31:26 +0100cads(~cads@ip-64-72-99-232.lasvegas.net)
2020-11-19 23:32:12 +0100justanotheruser(~justanoth@unaffiliated/justanotheruser) (Ping timeout: 272 seconds)
2020-11-19 23:32:50 +0100britva(~britva@2a02:aa13:7240:2980:9169:d6ce:8b28:2e63) (Client Quit)
2020-11-19 23:33:08 +0100crdrost(~crdrost@c-98-207-102-156.hsd1.ca.comcast.net) (Quit: This computer has gone to sleep)
2020-11-19 23:37:36 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de) (Ping timeout: 240 seconds)
2020-11-19 23:44:00 +0100conal(~conal@64.71.133.70) (Ping timeout: 260 seconds)
2020-11-19 23:46:35 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:7958:7d8e:4908:c843) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-19 23:47:12 +0100DirefulSalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt)
2020-11-19 23:47:19 +0100conal(~conal@ip-66-115-176-195.creativelink.net)
2020-11-19 23:47:43 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 256 seconds)
2020-11-19 23:47:51 +0100DirefulSalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt) (Remote host closed the connection)
2020-11-19 23:48:17 +0100DirefulSalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt)
2020-11-19 23:48:24 +0100justanotheruser(~justanoth@unaffiliated/justanotheruser)
2020-11-19 23:54:38 +0100p8m_(p8m@gateway/vpn/protonvpn/p8m) (Quit: birdd)
2020-11-19 23:54:58 +0100p8m(p8m@gateway/vpn/protonvpn/p8m)
2020-11-19 23:56:00 +0100hackagepandoc 2.11.2 - Conversion between markup formats https://hackage.haskell.org/package/pandoc-2.11.2 (JohnMacFarlane)
2020-11-19 23:56:08 +0100xerox_(~xerox@unaffiliated/xerox) (Ping timeout: 260 seconds)
2020-11-19 23:56:17 +0100 <monochrom> zincy__: Consider how many programmers simply insist that recursive calls must consume call stack space except for tail recursion under TCO. Especially being very unambiguously specific about "stack", "call stack", and "tail".
2020-11-19 23:57:29 +0100 <monochrom> Here in #haskell we enjoy a pretty good proxy statistics based on the frequency of someone coming in to ask "so, does Haskell do TCO?"
2020-11-19 23:57:46 +0100jwynn6(~jwynn6@050-088-122-078.res.spectrum.com) (Ping timeout: 265 seconds)
2020-11-19 23:58:34 +0100 <monochrom> A clear sign that the askers took their models too religiously.
2020-11-19 23:58:53 +0100Feuermagier(~Feuermagi@213.178.26.41)
2020-11-19 23:58:58 +0100crdrost(~crdrost@2601:646:8280:85f0:90f7:1b03:f01f:afae)
2020-11-19 23:59:19 +0100jwynn6(~jwynn6@050-088-122-078.res.spectrum.com)